fix the reintroduced dead code

Author: Trecek

src/autoskillit/server/__init__.py

@@ -1,12 +1,11 @@
 #!/usr/bin/env python3
 """MCP server for orchestrating automated skill-driven workflows.
 
-Kitchen tools (19 gated) are hidden at startup via FastMCP v3
+Kitchen tools (24 gated) are hidden at startup via FastMCP v3
 mcp.disable(tags={'kitchen'}) applied once after all tool modules are
 imported. Each new session sees only the 12 ungated tools (including
 open_kitchen and close_kitchen). Calling the open_kitchen tool reveals
 all 36 tools for that session via ctx.enable_components(tags={'kitchen'}).
-The GateState + .kitchen_gate file mechanism is retained as defense-in-depth.
 
 Transport: stdio (default for FastMCP).
 """

src/autoskillit/server/_state.py

@@ -16,7 +16,6 @@
 from __future__ import annotations
 
 from datetime import UTC
-from pathlib import Path
 
 from autoskillit.config import AutomationConfig
 from autoskillit.core import get_logger
@@ -32,14 +31,6 @@ def _initialize(ctx: ToolContext) -> None:
     global _ctx
     _ctx = ctx
 
-    # Gate file cleanup: remove stale gate files left by crashed sessions.
-    try:
-        from autoskillit.server.helpers import cleanup_stale_gate_file
-
-        cleanup_stale_gate_file(Path.cwd())
-    except Exception:
-        logger.debug("stale_gate_cleanup_at_startup_failed", exc_info=True)
-
     # Recovery sweep: finalize any orphaned tmpfs trace files from crashed sessions.
     try:
         from autoskillit.execution import recover_crashed_sessions

src/autoskillit/server/helpers.py

@@ -1,15 +1,12 @@
-"""Gate helpers, dry-walkthrough check, and subprocess wrapper for MCP tools."""
+"""Subprocess wrapper, dry-walkthrough check, and shared helpers for MCP tools."""
 
 from __future__ import annotations
 
-import json
-import os
 import time
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from autoskillit.core import RESERVED_LOG_RECORD_KEYS, TerminationReason, get_logger
-from autoskillit.execution import read_boot_id, read_starttime_ticks
 from autoskillit.pipeline import gate_error_result
 from autoskillit.recipe import (
     StaleItem,
@@ -29,7 +26,6 @@
 logger = get_logger(__name__)
 
 _HOOK_CONFIG_FILENAME: str = ".autoskillit_hook_config.json"
-_GATE_FILENAME: str = ".kitchen_gate"
 _HOOK_DIR_COMPONENTS: tuple[str, ...] = (".autoskillit", "temp")
 
 
@@ -38,67 +34,6 @@ def _hook_config_path(project_root: Path) -> Path:
     return project_root.joinpath(*_HOOK_DIR_COMPONENTS, _HOOK_CONFIG_FILENAME)
 
 
-def _gate_file_path(project_root: Path) -> Path:
-    """Return the canonical path to the kitchen gate file."""
-    return project_root.joinpath(*_HOOK_DIR_COMPONENTS, _GATE_FILENAME)
-
-
-def _is_pid_alive(
-    pid: int,
-    starttime_ticks: int | None = None,
-    boot_id: str | None = None,
-) -> bool:
-    """Return True if the process with pid is the same process that wrote the gate file."""
-    try:
-        os.kill(pid, 0)
-    except ProcessLookupError:
-        return False
-    except PermissionError:
-        pass  # process exists but we cannot signal it
-
-    if starttime_ticks is not None:
-        current_ticks = read_starttime_ticks(pid)
-        if current_ticks is not None and current_ticks != starttime_ticks:
-            return False  # PID reused
-
-    if boot_id is not None:
-        current_boot = read_boot_id()
-        if current_boot is not None and current_boot != boot_id:
-            return False  # different boot session
-
-    return True
-
-
-def cleanup_stale_gate_file(project_root: Path) -> None:
-    """Remove the gate file and companion hook config if the owning process is gone."""
-    gate_file = _gate_file_path(project_root)
-    hook_config = _hook_config_path(project_root)
-
-    if not gate_file.exists():
-        return
-
-    try:
-        data = json.loads(gate_file.read_text())
-        pid = data.get("pid")
-        starttime_ticks = data.get("starttime_ticks")
-        boot_id = data.get("boot_id")
-    except (json.JSONDecodeError, OSError):
-        # Malformed gate file — remove it and companion
-        try:
-            gate_file.unlink(missing_ok=True)
-            hook_config.unlink(missing_ok=True)
-        except OSError:
-            pass
-        return
-
-    if pid is None or not _is_pid_alive(pid, starttime_ticks, boot_id):
-        try:
-            gate_file.unlink(missing_ok=True)
-            hook_config.unlink(missing_ok=True)
-        except OSError:
-            pass
-
-
 async def _notify(
     ctx: Context,
     level: str,

src/autoskillit/server/tools_kitchen.py

@@ -2,49 +2,15 @@
 
 from __future__ import annotations
 
-import atexit
 import json
-import os
-from datetime import UTC, datetime
 from pathlib import Path
 
 from fastmcp import Context
 from fastmcp.dependencies import CurrentContext
 
 from autoskillit.core import PIPELINE_FORBIDDEN_TOOLS, atomic_write, pkg_root
 from autoskillit.server import mcp
-from autoskillit.server.helpers import (
-    _find_recipe,
-    _gate_file_path,
-    _hook_config_path,
-    _prime_quota_cache,
-    read_boot_id,
-    read_starttime_ticks,
-)
-
-
-def _register_gate_cleanup() -> None:
-    """Write the gate file and register an atexit handler to remove it on exit."""
-    gate_file = _gate_file_path(pkg_root())
-    try:
-        gate_file.parent.mkdir(parents=True, exist_ok=True)
-        payload = {
-            "pid": os.getpid(),
-            "starttime_ticks": read_starttime_ticks(os.getpid()),
-            "boot_id": read_boot_id(),
-            "opened_at": datetime.now(UTC).isoformat(),
-        }
-        atomic_write(gate_file, json.dumps(payload))
-    except OSError:
-        return
-
-    def _cleanup() -> None:
-        try:
-            gate_file.unlink(missing_ok=True)
-        except OSError:
-            pass
-
-    atexit.register(_cleanup)
+from autoskillit.server.helpers import _find_recipe, _hook_config_path, _prime_quota_cache
 
 
 def _write_hook_config() -> None:
@@ -80,7 +46,6 @@ async def _open_kitchen_handler() -> None:
     _get_ctx().gate.enable()
     logger.info("open_kitchen", gate_state="open")
     _write_hook_config()
-    _register_gate_cleanup()
     await _prime_quota_cache()
 
 

tests/server/test_server_init.py

@@ -301,8 +301,7 @@ async def test_disable_reverses_enable(self, tool_ctx):
 
         with patch.object(tools_kitchen_mod, "_prime_quota_cache", new=AsyncMock()):
             with patch.object(tools_kitchen_mod, "_write_hook_config"):
-                with patch.object(tools_kitchen_mod, "_register_gate_cleanup"):
-                    await _open_kitchen_handler()
+                await _open_kitchen_handler()
         _close_kitchen_handler()
         result = json.loads(await run_cmd(cmd="echo hi", cwd="/tmp"))
         assert result["success"] is False
@@ -612,110 +611,6 @@ def test_get_config_raises_before_initialize(self, monkeypatch):
             _state._get_config()
 
 
-class TestGateFileRecovery:
-    """T-RECOVER: _initialize removes stale/malformed gate files at startup."""
-
-    @pytest.mark.anyio
-    async def test_initialize_removes_stale_gate_file(self, monkeypatch, tmp_path):
-        """_initialize must remove gate files whose owning PID is dead."""
-        monkeypatch.chdir(tmp_path)
-        gate_dir = tmp_path / ".autoskillit" / "temp"
-        gate_dir.mkdir(parents=True)
-        gate_file = gate_dir / ".kitchen_gate"
-        gate_file.write_text(json.dumps({"pid": 999999999, "opened_at": "2026-01-01T00:00:00Z"}))
-
-        from autoskillit.server._factory import make_context
-        from tests.conftest import MockSubprocessRunner
-
-        ctx = make_context(
-            AutomationConfig(), runner=MockSubprocessRunner(), plugin_dir=str(tmp_path)
-        )
-        from autoskillit.server._state import _initialize
-
-        _initialize(ctx)
-        assert not gate_file.exists()
-
-    @pytest.mark.anyio
-    async def test_initialize_preserves_live_gate_file(self, monkeypatch, tmp_path):
-        """_initialize must NOT remove gate files whose owning PID is alive."""
-        import os
-
-        monkeypatch.chdir(tmp_path)
-        gate_dir = tmp_path / ".autoskillit" / "temp"
-        gate_dir.mkdir(parents=True)
-        gate_file = gate_dir / ".kitchen_gate"
-        from datetime import UTC, datetime
-
-        from autoskillit.execution import read_boot_id, read_starttime_ticks
-
-        gate_file.write_text(
-            json.dumps(
-                {
-                    "pid": os.getpid(),
-                    "starttime_ticks": read_starttime_ticks(os.getpid()),
-                    "boot_id": read_boot_id(),
-                    "opened_at": datetime.now(UTC).isoformat(),
-                }
-            )
-        )
-
-        from autoskillit.server._factory import make_context
-        from tests.conftest import MockSubprocessRunner
-
-        ctx = make_context(
-            AutomationConfig(), runner=MockSubprocessRunner(), plugin_dir=str(tmp_path)
-        )
-        from autoskillit.server._state import _initialize
-
-        _initialize(ctx)
-        assert gate_file.exists()  # still there — owning process is alive
-
-    @pytest.mark.anyio
-    async def test_initialize_removes_malformed_gate_file(self, monkeypatch, tmp_path):
-        """Malformed gate files must be removed at startup."""
-        monkeypatch.chdir(tmp_path)
-        gate_dir = tmp_path / ".autoskillit" / "temp"
-        gate_dir.mkdir(parents=True)
-        gate_file = gate_dir / ".kitchen_gate"
-        gate_file.write_text("not valid json")
-
-        from autoskillit.server._factory import make_context
-        from tests.conftest import MockSubprocessRunner
-
-        ctx = make_context(
-            AutomationConfig(), runner=MockSubprocessRunner(), plugin_dir=str(tmp_path)
-        )
-        from autoskillit.server._state import _initialize
-
-        _initialize(ctx)
-        assert not gate_file.exists()
-
-    @pytest.mark.anyio
-    async def test_initialize_removes_companion_hook_config_with_stale_gate(
-        self, monkeypatch, tmp_path
-    ):
-        """_initialize must remove both gate file and companion hook config when stale."""
-        monkeypatch.chdir(tmp_path)
-        gate_dir = tmp_path / ".autoskillit" / "temp"
-        gate_dir.mkdir(parents=True)
-        gate_file = gate_dir / ".kitchen_gate"
-        gate_file.write_text(json.dumps({"pid": 999999999, "opened_at": "2026-01-01T00:00:00Z"}))
-        companion = gate_dir / ".autoskillit_hook_config.json"
-        companion.write_text("{}")
-
-        from autoskillit.server._factory import make_context
-        from tests.conftest import MockSubprocessRunner
-
-        ctx = make_context(
-            AutomationConfig(), runner=MockSubprocessRunner(), plugin_dir=str(tmp_path)
-        )
-        from autoskillit.server._state import _initialize
-
-        _initialize(ctx)
-        assert not gate_file.exists()
-        assert not companion.exists()
-
-
 class TestConfigDrivenBehavior:
     """S1-S10: Verify tools use config instead of hardcoded values."""
 

tests/server/test_tools_kitchen.py

@@ -189,8 +189,8 @@ async def test_close_kitchen_tool_calls_reset_visibility(tmp_path, monkeypatch):
 
 
 @pytest.mark.anyio
-async def test_open_kitchen_does_not_write_gate_file_directly(tmp_path, monkeypatch):
-    """_open_kitchen_handler must not directly write to the gate path (delegates to _register_gate_cleanup)."""
+async def test_open_kitchen_does_not_write_gate_file(tmp_path, monkeypatch):
+    """_open_kitchen_handler must never write a gate file."""
     monkeypatch.chdir(tmp_path)
     mock_ctx = _make_mock_ctx()
     mock_ctx.config.quota_guard.threshold = None
@@ -199,10 +199,9 @@ async def test_open_kitchen_does_not_write_gate_file_directly(tmp_path, monkeypa
     with patch("autoskillit.server._get_ctx", return_value=mock_ctx):
         with patch("autoskillit.server.logger"):
             with patch("autoskillit.server.tools_kitchen._prime_quota_cache", new=AsyncMock()):
-                with patch("autoskillit.server.tools_kitchen._register_gate_cleanup"):
-                    from autoskillit.server.tools_kitchen import _open_kitchen_handler
+                from autoskillit.server.tools_kitchen import _open_kitchen_handler
 
-                    await _open_kitchen_handler()
+                await _open_kitchen_handler()
     gate_file = tmp_path / ".autoskillit" / "temp" / ".kitchen_gate"
     assert not gate_file.exists()