getcodexy 1.13.4__tar.gz → 2.0.0__tar.gz

{getcodexy-1.13.4 → getcodexy-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: getcodexy
-Version: 1.13.4
+Version: 2.0.0
 Summary: A Codex harness for coordinating agents through planning, implementation, verification, and review.
 Author: Eunsoo Lee
 License-Expression: MIT

{getcodexy-1.13.4 → getcodexy-2.0.0}/pyproject.toml

@@ -5,7 +5,7 @@ backend-path = ["."]
 
 [project]
 name = "getcodexy"
-version = "1.13.4"
+version = "2.0.0"
 description = "A Codex harness for coordinating agents through planning, implementation, verification, and review."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{getcodexy-1.13.4 → getcodexy-2.0.0}/src/codexy_runtime_tools/_version_data/uv.lock

@@ -4,5 +4,5 @@ requires-python = ">=3.10"
 
 [[package]]
 name = "getcodexy"
-version = "1.13.4"
+version = "2.0.0"
 source = { editable = "." }

{getcodexy-1.13.4 → getcodexy-2.0.0}/src/codexy_runtime_tools/component-manifest.json

@@ -29,7 +29,7 @@
     {
       "id": "core",
       "plugin": "codexy",
-      "version": "1.13.4",
+      "version": "2.0.0",
       "dependencies": [],
       "asset": {
         "pluginId": "codexy@codexy",
@@ -39,10 +39,6 @@
           "assets/codexy-icon.png",
           "skills/self-improvement/SKILL.md",
           "skills/self-improvement/agents/openai.yaml",
-          ".mcp.json",
-          "mcp/codexy_mcp_bootstrap.py",
-          "mcp/codexy-mcp-watcher.sh",
-          "mcp/codexy-mcp-watcher.cmd",
           "skills/dreaming/scripts/resumable-context-capsule.sh",
           "skills/dreaming/scripts/resumable-context-capsule.cmd",
           "skills/dreaming/scripts/resumable_context_capsule.py",
@@ -63,7 +59,7 @@
     {
       "id": "github",
       "plugin": "codexy-github",
-      "version": "1.13.4",
+      "version": "2.0.0",
       "dependencies": [
         "core"
       ],
@@ -79,7 +75,7 @@
     {
       "id": "devtools",
       "plugin": "codexy-devtools",
-      "version": "1.13.4",
+      "version": "2.0.0",
       "dependencies": [
         "core"
       ],
@@ -97,27 +93,27 @@
   "compatibleCombinations": [
     {
       "components": [],
-      "version": "1.13.4"
+      "version": "2.0.0"
     },
     {
       "components": [
         "core"
       ],
-      "version": "1.13.4"
+      "version": "2.0.0"
     },
     {
       "components": [
         "core",
         "github"
       ],
-      "version": "1.13.4"
+      "version": "2.0.0"
     },
     {
       "components": [
         "core",
         "devtools"
       ],
-      "version": "1.13.4"
+      "version": "2.0.0"
     },
     {
       "components": [
@@ -125,7 +121,7 @@
         "github",
         "devtools"
       ],
-      "version": "1.13.4"
+      "version": "2.0.0"
     }
   ]
 }

{getcodexy-1.13.4 → getcodexy-2.0.0}/src/codexy_runtime_tools/component_capability_observation.py

@@ -11,17 +11,19 @@ _DIRECT_SCOPE = "plugin-subprocess"
 _REGISTRATION_SOURCE = "getcodexy-registration-check"
 _REGISTRATION_SCOPE = "current-doctor-invocation"
 
+# Registration records configuration only; native specialist invocation remains unverified.
 CAPABILITIES = {
     "core": (
         "hook:codexy-thread-delivery",
         "specialist:codexy-architect",
+        "specialist:codexy-advisor",
         "specialist:codexy-auditor",
         "specialist:codexy-cartographer",
         "specialist:codexy-inspector",
         "specialist:codexy-sentinel",
         "specialist:codexy-shipwright",
         "specialist:codexy-warden",
-        "specialist:codexy-watcher",
+        # Legacy registration remains visible without implying a current Watcher process.
         "mcp:watcher",
     ),
     "github": ("hook:codexy-github-workflow-context", "specialist:codexy-weaver"),
@@ -45,7 +47,18 @@ def component_observations(
     direct = probe.get("_capability_probes")
     if not isinstance(direct, dict):
         direct = {}
+    contract = probe.get("_capability_contract")
+    if (
+        component == "core"
+        and isinstance(contract, dict)
+        and contract.get("mcp:watcher") is False
+    ):
+        # A validated no-MCP core has no configured Watcher capability to report.
+        observations.pop("mcp:watcher", None)
     for name in observations:
+        if name == "mcp:watcher":
+            # Current getcodexy never launches legacy Watcher MCP, so execution stays unknown.
+            continue
         details = direct.get(name)
         if isinstance(details, dict):
             observations[name] = _entry(

{getcodexy-1.13.4 → getcodexy-2.0.0}/src/codexy_runtime_tools/component_capability_probe.py

@@ -13,7 +13,7 @@ from .component_capability_probe_process import (
     _probe_diagnostics,
     _run,
 )
-from .component_watcher_probe import probe_watcher as _probe_watcher
+from .component_mcp_materialization import selected_mcp_spec, valid_component_mcp
 from .version_lock import default_package_version
 
 
@@ -57,7 +57,7 @@ def _request(method, identifier=None, params=None):
 
 
 def probe_component(component, plugin, record):
-    """Probe one installed component, keeping core hook and watcher checks linked."""
+    """Probe one installed component without starting legacy core MCP servers."""
     base = _base(record)
     if plugin is None:
         return base
@@ -68,17 +68,25 @@ def probe_component(component, plugin, record):
 
 
 def _probe_core(plugin, base):
-    # The watcher probe depends on a callable core hook; merge only observed results.
-    hook = _probe_hook("core", plugin, base)
-    if not hook.get("started") or not hook.get("callable"):
-        return hook
-    watcher = _probe_watcher(plugin, base)
-    probes = dict(hook.get("_capability_probes", {}))
-    probes.update(watcher.get("_capability_probes", {}))
-    watcher["_capability_probes"] = probes
-    if not watcher.get("started") or not watcher.get("callable"):
-        return watcher
-    return _outcome(base, _capability_probes=probes)
+    # Preserve legacy registration visibility while the current doctor stays read-only.
+    watcher_declared = _core_declares_watcher(plugin)
+    if watcher_declared is not None:
+        base["_capability_contract"] = {"mcp:watcher": watcher_declared}
+    return _probe_hook("core", plugin, base)
+
+
+def _core_declares_watcher(plugin):
+    """Read legacy Watcher registration without launching its configured runner."""
+    try:
+        manifest = json.loads(
+            (plugin / ".codex-plugin/plugin.json").read_text(encoding="utf-8")
+        )
+    except (OSError, ValueError, json.JSONDecodeError):
+        return None
+    version = manifest.get("version") if isinstance(manifest, dict) else None
+    if not isinstance(version, str) or not valid_component_mcp(plugin, "core", version):
+        return None
+    return "watcher" in selected_mcp_spec(plugin, "core").servers
 
 
 def _probe_hook(component, plugin, base):

{getcodexy-1.13.4 → getcodexy-2.0.0}/src/codexy_runtime_tools/component_capability_probe_process.py

@@ -97,6 +97,7 @@ def _run_windows(argv, cwd, input_text, env, deadline):
     )
     cleanup_deadline = deadline
     abort_pipes = False
+    threads_stopped = True
     try:
         remaining = max(0.0, deadline - perf_counter())
         if not remaining:
@@ -107,16 +108,17 @@ def _run_windows(argv, cwd, input_text, env, deadline):
         abort_pipes = True
         cleanup_deadline = perf_counter() + _WINDOWS_CLEANUP_TIMEOUT
         _terminate_process_tree(process, cleanup_deadline)
-        _cancel_windows_pipe_threads(process, cleanup_deadline)
+        threads_stopped = _cancel_windows_pipe_threads(process, cleanup_deadline)
         remaining = max(0.0, cleanup_deadline - perf_counter())
         if remaining:
             try:
-                process.communicate(timeout=remaining)
+                _ = process.communicate(timeout=remaining)
+                threads_stopped = True
             except (OSError, ValueError, subprocess.TimeoutExpired):
                 pass
         raise
     finally:
-        _close_process_pipes(process, abort=abort_pipes, deadline=cleanup_deadline)
+        _close_process_pipes(process, abort_pipes, threads_stopped)
         _wait_for_exit(process, cleanup_deadline)
 
 
@@ -145,10 +147,8 @@ def _terminate_process_tree(process, deadline):
             pass
 
 
-def _close_process_pipes(process, abort=False, deadline=None):
-    threads_stopped = True
-    if abort:
-        threads_stopped = _cancel_windows_pipe_threads(process, deadline)
+def _close_process_pipes(process, abort=False, threads_stopped: bool = False):
+    # Timeout handling owns cancellation; repeating it here can outlive the deadline.
     for attribute in ("stdin", "stdout", "stderr"):
         stream = getattr(process, attribute, None)
         if stream is None:
@@ -177,7 +177,7 @@ def _abort_process_pipe(process, attribute, stream):
         setattr(process, attribute, None)
 
 
-def _cancel_windows_pipe_threads(process, deadline):
+def _cancel_windows_pipe_threads(process, deadline) -> bool:
     threads = [
         getattr(process, attribute, None)
         for attribute in ("stdin_thread", "stdout_thread", "stderr_thread")
@@ -186,7 +186,7 @@ def _cancel_windows_pipe_threads(process, deadline):
     if not threads:
         return False
     for thread in threads:
-        if thread.is_alive():
+        if thread.is_alive() and deadline > perf_counter():
             _cancel_synchronous_io(thread)
     for thread in threads:
         if not thread.is_alive():

{getcodexy-1.13.4 → getcodexy-2.0.0}/src/codexy_runtime_tools/component_cli.py

@@ -90,7 +90,20 @@ def main(argv: list[str] | None = None) -> int:
     unhealthy = arguments.command in {"status", "doctor"} and bool(
         receipt.get("errors")
     )
-    return 0 if receipt["outcome"] == "completed" and not unhealthy else 2
+    # Doctor health findings stay outside the closed lifecycle-domain error codes.
+    orphaned_registration = arguments.command == "doctor" and any(
+        isinstance(entry, dict)
+        and entry.get("reason_code")
+        in {"orphaned-managed-registration", "registration-inspection-unavailable"}
+        for entry in receipt.get("component_health", [])
+    )
+    return (
+        0
+        if receipt["outcome"] == "completed"
+        and not unhealthy
+        and not orphaned_registration
+        else 2
+    )
 
 
 def _record_capability_failures(receipt: dict[str, object]) -> None:

{getcodexy-1.13.4 → getcodexy-2.0.0}/src/codexy_runtime_tools/component_core_hooks.py

@@ -7,15 +7,10 @@ COMMAND_HOOKS = (
     (_TOOL_PREFIX + "create_thread$", "codexy-child-thread-creation"),
     (r"^(?:(?:agents|multi_agent_v1)__)?spawn_agent$", "codexy-subagent-ownership"),
 )
-WATCHER_WAIT_HOOK = (r"^(?:mcp__[^ ]+__)?watcher_wait$", "codexy-watcher-interrupt")
-LIFECYCLE_HOOKS = (WATCHER_WAIT_HOOK,)
-# Observe only completed sender calls; failed sends cannot release recipient waits.
-POST_TOOL_HOOKS = (
-    (r"^mcp__codex_app__send_message_to_thread$", "codexy-watcher-interrupt"),
-)
+# The installed core package carries only its retained routing and ownership launchers.
 LAUNCHERS = tuple(
     f"hooks/{stem}.{extension}"
-    for _, stem in (*COMMAND_HOOKS, *LIFECYCLE_HOOKS)
+    for _, stem in COMMAND_HOOKS
     for extension in ("sh", "cmd")
 )
 # Windows invokes the event script with `py.exe -3 -I -B`, bypassing the POSIX
@@ -33,8 +28,4 @@ DEPENDENCIES = (
     "hooks/codexy_policy/envelope.py",
     "hooks/codexy_policy/timing.py",
     "hooks/codexy_policy/windows_timing.py",
-    "hooks/codexy-watcher-interrupt.sh",
-    "hooks/codexy-watcher-interrupt.cmd",
-    "hooks/codexy_watcher_interrupt.py",
-    "hooks/codexy_watcher_interrupt_events.py",
 )

{getcodexy-1.13.4 → getcodexy-2.0.0}/src/codexy_runtime_tools/component_health.py

@@ -2,27 +2,27 @@
 
 from __future__ import annotations
 
-import os
-from pathlib import Path
-
 from . import component_capability_probe as _probe
 from .component_capability_observation import component_observations
 from .component_hook_activation import ACTIVATION_STATES
-from .component_mcp_materialization import MCP_COMPONENTS, valid_component_mcp_cache
+from .component_mcp_materialization import (
+    MCP_COMPONENTS,
+    mcp_spec_for_plugin,
+    valid_component_mcp_cache,
+)
 from .component_health_support import (
     _authority_valid,
     _health_plugin,
     _legacy_state,
     _observed,
+    _plugin_root,
+    _selected_registration_valid,
     manifest_is_valid,
     record_version,
     version_relation,
 )
 from .component_manifest import ComponentManifest
-from .component_registration_health import (
-    registration_role as _registration_role,
-    valid_registration,
-)
+from .component_registration_orphans import include_orphaned_registrations
 from .updater import compare_managed_files
 
 FAILURES = _probe.FAILURES
@@ -51,11 +51,12 @@ def health(
         activation,
         codex_home,
     )
-    return [
+    entries = [
         _component_health(context, component)
         for component in manifest.component_ids
         if component in expected
     ]
+    return include_orphaned_registrations(entries, manifest, actual, codex_home)
 
 
 def _component_health(context, component):
@@ -64,6 +65,17 @@ def _component_health(context, component):
     )
     record = records.get(component)
     installed = component in actual
+    expected_mcp_spec = None
+    if component in MCP_COMPONENTS:
+        source_plugin = _plugin_root(record)
+        if source_plugin is not None:
+            try:
+                # Check package shape separately; authority remains a later health check.
+                expected_mcp_spec = mcp_spec_for_plugin(
+                    source_plugin, component, record_version(record)
+                )
+            except (OSError, RuntimeError, ValueError):
+                expected_mcp_spec = None
     plugin = _health_plugin(manifest, component, record, codex_home)
     registration = (
         compare_managed_files(plugin, codex_home, component)
@@ -76,7 +88,9 @@ def _component_health(context, component):
         and manifest_is_valid(
             plugin, manifest.component(component).plugin, record_version(record)
         )
-        and valid_registration(plugin, component)
+        and _selected_registration_valid(
+            plugin, component, record_version(record), expected_mcp_spec
+        )
         and (
             not registration
             or not registration["observed"]
@@ -84,11 +98,26 @@ def _component_health(context, component):
         )
         and (
             component not in MCP_COMPONENTS
-            or valid_component_mcp_cache(codex_home, component, manifest.version)
+            or (
+                expected_mcp_spec is not None
+                and valid_component_mcp_cache(
+                    codex_home,
+                    component,
+                    manifest.version,
+                    expected_spec=expected_mcp_spec,
+                )
+            )
         )
     )
     state = _legacy_state(
-        manifest, component, actual, records, admission_error, host_error, codex_home
+        manifest,
+        component,
+        actual,
+        records,
+        admission_error,
+        host_error,
+        codex_home,
+        expected_mcp_spec,
     )
     registration_state = registration["state"] if registration else "exact"
     if state in {"healthy", "stale"} and registration_state != "exact":
@@ -109,7 +138,18 @@ def _component_health(context, component):
         restart_required=False,
         observed={
             **_observed(record),
-            "capabilities": component_observations(component, configured),
+            # Keep a no-MCP core accurate when activation prevents its live probe.
+            "capabilities": component_observations(
+                component,
+                configured,
+                {
+                    "_capability_contract": {
+                        "mcp:watcher": "watcher" in expected_mcp_spec.servers
+                    }
+                }
+                if component == "core" and expected_mcp_spec is not None
+                else None,
+            ),
             "registration": registration,
         },
     )
@@ -170,81 +210,3 @@ def _mark(result: dict[str, object], stage: str, reason: str) -> dict[str, objec
     ):
         result["state"] = "incompatible"
     return result
-
-
-def _registration_roles(home, root, marker, expected, read_regular, max_bytes):
-    roles, managed, unmanaged = [], [], []  # Track expected and marker-owned roles.
-    for name, value in expected.items():
-        roles.append(
-            _registered_role(home, root, name, value, marker, read_regular, max_bytes)
-        )
-    for entry in os.scandir(root):
-        if entry.name in expected or not entry.name.endswith(".toml"):
-            continue
-        try:
-            current = (
-                read_regular(home, Path(entry.path).relative_to(home), max_bytes)
-                .decode()
-                .replace("\r\n", "\n")
-                .replace("\r", "\n")
-            )
-        except (OSError, UnicodeDecodeError, ValueError):
-            unmanaged.append(entry.name)
-            continue
-        (managed if current.startswith(marker) else unmanaged).append(entry.name)
-    roles.extend(
-        _registration_role(
-            name, "stale", "managed role is not declared by the current catalog"
-        )
-        for name in managed
-    )
-    states = {item["state"] for item in roles}
-    state = next(
-        (
-            candidate
-            for candidate in ("unmanaged-conflict", "stale", "missing")
-            if candidate in states or candidate == "unmanaged-conflict" and unmanaged
-        ),
-        "exact",
-    )
-    return roles, tuple(sorted(managed)), tuple(sorted(unmanaged)), state
-
-
-def _registered_role(
-    home: Path,
-    root: Path,
-    name: str,
-    expected: bytes,
-    marker: str,
-    read_regular,
-    max_bytes: int,
-) -> dict[str, object]:
-    try:  # Inspect the marker-owned role file as a bounded regular input.
-        current = (
-            read_regular(home, root.relative_to(home) / name, max_bytes)
-            .decode()
-            .replace("\r\n", "\n")
-            .replace("\r", "\n")
-        )
-    except FileNotFoundError:
-        return _registration_role(name, "missing", "managed role file is missing")
-    except (OSError, UnicodeDecodeError, ValueError):
-        return _registration_role(
-            name,
-            "unmanaged-conflict",
-            "managed role file is unreadable or not a regular file",
-            True,
-        )
-    if not current.startswith(marker):
-        return _registration_role(
-            name,
-            "unmanaged-conflict",
-            "existing role file is not marker-owned by Codexy",
-            True,
-        )
-    exact = current.encode() == expected
-    return _registration_role(
-        name,
-        "exact" if exact else "stale",
-        None if exact else "registered role differs from the package",
-    )

{getcodexy-1.13.4 → getcodexy-2.0.0}/src/codexy_runtime_tools/component_health_support.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from .component_mcp_materialization import (
     MCP_COMPONENTS,
     component_cache_plugin,
-    mcp_spec,
+    McpSpec,
 )
 from .component_manifest import ComponentManifest
 from .component_registration_health import valid_registration
@@ -19,14 +19,25 @@ SURFACE_PATHS = {
         "agents/catalog.toml",
         "hooks/hooks.json",
         "skills/wiki/SKILL.md",
-        *(path.as_posix() for path in mcp_spec("core").surface_paths),
     ),
     "github": ("agents/catalog.toml", "hooks/hooks.json"),
-    "devtools": tuple(path.as_posix() for path in mcp_spec("devtools").surface_paths),
+    "devtools": (),
 }
 AUTHORITY_KEYS = ("authority", "artifact_authority", "artifactAuthority")
 
 
+def _selected_registration_valid(plugin, component, version, expected_mcp_spec):
+    """Require a verified source MCP contract before accepting cached registration."""
+    if component in MCP_COMPONENTS and expected_mcp_spec is None:
+        return False
+    return valid_registration(
+        plugin,
+        component,
+        version,
+        expected_mcp_spec=expected_mcp_spec,
+    )
+
+
 def _legacy_state(
     manifest,
     component,
@@ -35,6 +46,7 @@ def _legacy_state(
     admission_error,
     host_error,
     codex_home=None,
+    expected_mcp_spec: McpSpec | None = None,
 ):
     """Preserve the coarse state contract while checking installed package integrity."""
     record = records.get(component)
@@ -46,11 +58,15 @@ def _legacy_state(
     if relation != 0:
         return "stale" if relation < 0 else "incompatible"
     plugin = _health_plugin(manifest, component, record, codex_home)
-    if plugin is None or not _required_files(manifest, component, plugin, codex_home):
+    if plugin is None or not _required_files(
+        manifest, component, plugin, codex_home, expected_mcp_spec
+    ):
         return "stale"
     if not manifest_is_valid(
         plugin, manifest.component(component).plugin, record_version(record)
-    ) or not valid_registration(plugin, component):
+    ) or not _selected_registration_valid(
+        plugin, component, record_version(record), expected_mcp_spec
+    ):
         return "incompatible"
     if component == "core" and any(
         os.path.lexists(plugin / path)
@@ -62,9 +78,21 @@ def _legacy_state(
     return "healthy"
 
 
-def _required_files(manifest, component, plugin, codex_home=None):
+def _required_files(
+    manifest, component, plugin, codex_home=None, expected_mcp_spec=None
+):
+    # The selected source contract controls whether doctor expects registration files.
+    if component in MCP_COMPONENTS and expected_mcp_spec is None:
+        return False
+    mcp_paths = (
+        tuple(path.as_posix() for path in expected_mcp_spec.surface_paths)
+        if component in MCP_COMPONENTS
+        else ()
+    )
     paths = (
-        manifest.component(component).asset.required_paths + SURFACE_PATHS[component]
+        manifest.component(component).asset.required_paths
+        + SURFACE_PATHS[component]
+        + mcp_paths
     )
     return all(
         (plugin / path).is_file() and not (plugin / path).is_symlink() for path in paths

{getcodexy-1.13.4 → getcodexy-2.0.0}/src/codexy_runtime_tools/component_hook_registration.py

@@ -2,8 +2,6 @@
 
 from .component_core_hooks import (
     COMMAND_HOOKS as _CORE_COMMAND_HOOKS,
-    LIFECYCLE_HOOKS as _CORE_LIFECYCLE_HOOKS,
-    POST_TOOL_HOOKS as _CORE_POST_TOOL_HOOKS,
     LAUNCHERS as CORE_HOOK_LAUNCHERS,
 )
 
@@ -27,11 +25,6 @@ def _command_hook(
     }
 
 
-def _lifecycle_hook(launcher_stem: str, event: str) -> dict[str, object]:
-    command = f'"${{PLUGIN_ROOT}}/hooks/{launcher_stem}'
-    return {"hooks": [_hook(f'{command}.sh" {event}', f'{command}.cmd" {event}', 3)]}
-
-
 def _bash_hooks(event: str) -> list[dict[str, object]]:
     return [_command_hook("^Bash$", "codexy-destructive-command", event)]
 
@@ -72,29 +65,14 @@ _TITLE_MATCHERS = (
 
 
 def _core_hooks() -> dict[str, object]:
-    """Build core event groups with a separate completed-send cancellation hook."""
+    """Build the retained core routing and ownership hook event groups."""
     command = lambda event: [
         _command_hook(matcher, stem, event) for matcher, stem in _CORE_COMMAND_HOOKS
     ]
-    lifecycle = lambda event: [
-        _command_hook(matcher, stem, event) for matcher, stem in _CORE_LIFECYCLE_HOOKS
-    ]
-    post_tool = [
-        _command_hook(matcher, stem, "PostToolUse", 3)
-        for matcher, stem in _CORE_POST_TOOL_HOOKS
-    ]
     return {
         "hooks": {
             "PermissionRequest": command("PermissionRequest"),
-            "PreToolUse": command("PreToolUse") + lifecycle("PreToolUse"),
-            "PostToolUse": post_tool,
-            "Interrupt": [
-                _lifecycle_hook(stem, "Interrupt") for _, stem in _CORE_LIFECYCLE_HOOKS
-            ],
-            "UserPromptSubmit": [
-                _lifecycle_hook(stem, "UserPromptSubmit")
-                for _, stem in _CORE_LIFECYCLE_HOOKS
-            ],
+            "PreToolUse": command("PreToolUse"),
         }
     }