code-context-control 2.118.2__py3-none-any.whl → 2.119.0__py3-none-any.whl

cli/_hook_utils.py

@@ -375,30 +375,20 @@ HOST_GEMINI = "gemini"
 HOST_CODEX = "codex"
 
 
-def detect_host(data: dict) -> str:
-    """Identify which agent runtime sent this hook payload.
-
-    Codex is detected by `turn_id`, which its wire schema marks required on
-    every turn-scoped event C3 hooks (pre/post tool use, user prompt submit,
-    stop) and documents as "Codex extension". Claude Code never sends it.
-
-    Codex MUST be checked before Gemini: Codex declares `tool_response` as
-    free-form, so an MCP tool that returns an object would otherwise trip the
-    isinstance-dict test and be mistaken for Gemini.
-
-    The CODEX_* env fallback covers a future Codex that drops `turn_id`. A
-    false positive there degrades gracefully — Claude Code also accepts
-    hookSpecificOutput.additionalContext — so guessing "codex" is the safe
-    direction to be wrong in.
-    """
+def detect_host(data: dict, explicit_host: str | None = None) -> str:
+    """Use the hook's explicit host or wire identity, never its parent's env."""
+    named = explicit_host or (data.get("_c3_host") if isinstance(data, dict) else None)
+    aliases = {"claude-code": HOST_CLAUDE, "claude": HOST_CLAUDE,
+               "codex": HOST_CODEX, "gemini": HOST_GEMINI, "antigravity": HOST_GEMINI}
+    if named in aliases:
+        return aliases[named]
     if not isinstance(data, dict):
         return HOST_CLAUDE
     if data.get("turn_id"):
         return HOST_CODEX
-    if isinstance(data.get("tool_response"), dict):
+    response = data.get("tool_response")
+    if isinstance(response, dict) and ("llmContent" in response or "returnDisplay" in response):
         return HOST_GEMINI
-    if os.environ.get("CODEX_THREAD_ID") or os.environ.get("CODEX_MANAGED_BY_NPM"):
-        return HOST_CODEX
     return HOST_CLAUDE
 
 

cli/c3.py

@@ -92,7 +92,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.118.2"
+__version__ = "2.119.0"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):
@@ -4298,17 +4298,9 @@ _C3_HOOKLESS_WORKFLOW = _adapt_workflow_for_ide(
 
 _COPILOT_INSTRUCTIONS_CONTENT = _VSCODE_SESSION_INIT + "\n\n" + _C3_HOOKLESS_WORKFLOW
 
-_AGENTS_MD_CONTENT = _C3_HOOKLESS_WORKFLOW + """
+from services.codex_integration import CODEX_WORKFLOW
 
-## IDE Configuration (Codex)
-This project uses project-scoped MCP servers. Ensure your `.codex/config.toml` includes:
-```toml
-[mcp_servers.c3]
-command = "c3-mcp"
-args = ["--project", "."]
-enabled = true
-```
-"""
+_AGENTS_MD_CONTENT = CODEX_WORKFLOW
 
 _TERSE_SKILL_CONTENT = """\
 # /terse — Terse Output Mode
@@ -4426,50 +4418,13 @@ def _toml_escape_str(value: str) -> str:
 
 
 def _upsert_toml_section(toml_path: Path, section: str, entries: dict) -> None:
-    """Add or replace a dotted TOML section (e.g. 'mcp_servers.c3') in-place.
-
-    Reads the existing file, removes the old section if present, and appends
-    the new section at the end. Handles simple scalar and list values only.
-    """
-    content = toml_path.read_text(encoding="utf-8") if toml_path.exists() else ""
-    header = f"[{section}]"
-
-    # Strip existing section (header + its key=value lines). Also strip any
-    # dotted child subtables (e.g. "[mcp_servers.c3.env]" under
-    # "[mcp_servers.c3]") so they are not orphaned beneath the re-appended
-    # section, which would corrupt the file on re-run.
-    child_prefix = f"{header[:-1]}."  # "[mcp_servers.c3]" -> "[mcp_servers.c3."
-    lines = content.splitlines()
-    new_lines: list[str] = []
-    skip = False
-    for line in lines:
-        stripped = line.strip()
-        if stripped == header:
-            skip = True
-            continue
-        if skip and stripped.startswith("["):
-            if not stripped.startswith(child_prefix):
-                skip = False
-        if not skip:
-            new_lines.append(line)
-
-    content = "\n".join(new_lines).rstrip()
-
-    # Build new section
-    section_lines = [f"\n\n{header}"]
-    for k, v in entries.items():
-        if isinstance(v, list):
-            # Escape each list item individually
-            items = ", ".join(f'"{_toml_escape_str(x)}"' for x in v)
-            section_lines.append(f'"{k}" = [{items}]')
-        elif isinstance(v, bool):
-            section_lines.append(f'"{k}" = {"true" if v else "false"}')
-        else:
-            section_lines.append(f'"{k}" = "{_toml_escape_str(v)}"')
-    section_lines.append("")
-
-    toml_path.parent.mkdir(parents=True, exist_ok=True)
-    toml_path.write_text(content + "\n".join(section_lines), encoding="utf-8")
+    from core.mcp_toml import merge_toml_section
+    owned = dict(entries)
+    defaults = {}
+    for key in ("enabled", "startup_timeout_sec", "tool_timeout_sec"):
+        if key in owned:
+            defaults[key] = owned.pop(key)
+    merge_toml_section(toml_path, section, owned, defaults)
 
 
 def _toml_section_bool_value(toml_path: Path, section: str, key: str) -> bool | None:
@@ -4555,20 +4510,10 @@ def _ensure_instruction_workflow(instructions_path: Path, template: str,
 def _ensure_codex_agents_workflow(agents_md_path: Path,
                                   project_path: str = "") -> str:
     """Ensure AGENTS.md contains the mandatory C3 workflow for Codex sessions."""
-    required_markers = [
-        "C3 Tools",
-        "MANDATORY",
-        "SEARCH FIRST",
-        "Anti-patterns",
-        "c3_search",
-        "c3_read",
-        "c3_validate",
-        "c3_edit",
-        "c3_memory",
-        "c3_filter",
-    ]
-    return _ensure_instruction_workflow(agents_md_path, _AGENTS_MD_CONTENT,
-                                        required_markers, project_path)
+    from services.claude_md import write_c3_instruction_doc
+    existing = agents_md_path.read_text(encoding="utf-8") if agents_md_path.exists() else None
+    rendered = write_c3_instruction_doc(agents_md_path, _AGENTS_MD_CONTENT, project_path or None)
+    return "written" if existing is None else ("kept" if rendered == existing else "updated")
 
 
 def _ensure_vscode_instructions_workflow(instructions_path: Path,
@@ -4654,6 +4599,7 @@ def _ensure_project_session_configs(target: Path, server_script: str, primary_pr
     else:
         mcp_command = "python"
         server_args = [server_script_posix, "--project", target.as_posix()]
+    server_args += ["--host", "codex"]
 
     if primary_profile != "codex":
         codex_path = target / ".codex" / "config.toml"
@@ -4674,18 +4620,20 @@ def _ensure_project_session_configs(target: Path, server_script: str, primary_pr
 
 def _ensure_global_session_fallbacks(server_script: str, c3_mcp_exe: str | None = None,
                                      primary_profile: str | None = None) -> None:
-    """Keep user-global Codex/Antigravity MCP configs pointing at C3.
+    """Install an explicitly requested user-global Codex fallback.
 
     These fallback entries omit `--project` so the MCP server can resolve the
     active working directory dynamically when a session starts in a project that
     does not yet have a project-local Codex config file.
     """
+    if primary_profile not in (None, "codex"):
+        return
     server_script_posix = Path(server_script).as_posix()
     # With the installed entry point, no script path is needed; --project stays
     # omitted so the server resolves the working directory at session start.
-    fallback_args = [] if c3_mcp_exe else [server_script_posix]
+    fallback_args = (["--host", "codex"] if c3_mcp_exe else [server_script_posix, "--host", "codex"])
 
-    codex_path = Path.home() / ".codex" / "config.toml"
+    codex_path = Path(os.environ.get("CODEX_HOME") or Path.home() / ".codex") / "config.toml"
     try:
         codex_state = "updated" if codex_path.exists() else "written"
         _upsert_toml_section(
@@ -4701,27 +4649,6 @@ def _ensure_global_session_fallbacks(server_script: str, c3_mcp_exe: str | None
     except PermissionError:
         print(f"Warning: Could not update {codex_path} (global fallback skipped)")
 
-    # Antigravity shares the ~/.gemini home dir but reads its own MCP config.
-    # When Antigravity is the primary profile, the main install flow already
-    # wrote this file — here we only keep it fresh for codex installs
-    # on machines that have Antigravity (its config dir exists).
-    antigravity_path = Path.home() / ".gemini" / "antigravity" / "mcp_config.json"
-    if primary_profile != "antigravity" and antigravity_path.parent.is_dir():
-        try:
-            ag_state = _upsert_json_mcp_server(
-                antigravity_path,
-                "mcpServers",
-                "c3",
-                {
-                    "command": c3_mcp_exe or sys.executable,
-                    "args": fallback_args,
-                },
-            )
-            print(f"{ag_state.capitalize()} {antigravity_path}  (global fallback)")
-        except PermissionError:
-            print(f"Warning: Could not update {antigravity_path} (global fallback skipped)")
-
-
 # Every hook script C3 has ever registered in a settings file — the v2.42+
 # dispatcher plus the pre-v2.42 per-hook scripts — so uninstall recognises an
 # entry written by any C3 version. A user hook is anything not naming one.
@@ -4926,7 +4853,7 @@ def _uninstall_mcp_all(project_path: str, include_global: bool = True):
                 except Exception as e:
                     print(f"  Warning: Could not update {mcp_config_path}: {e}")
 
-        # Claude Code Hooks & Settings
+        # Per-host hooks and settings; remove only C3-owned handlers.
         if profile.supports_hooks and profile.settings_path:
             settings_path = target / profile.settings_path
             if settings_path.exists():
@@ -5475,9 +5402,9 @@ def cmd_install_mcp(args):
     # Keep the script path as a single arg; 'python' keeps the source fallback
     # portable across platforms.
     if c3_mcp_exe:
-        new_entry = {"command": c3_mcp_exe, "args": ["--project", "."]}
+        new_entry = {"command": c3_mcp_exe, "args": ["--project", ".", "--host", profile.name]}
     else:
-        new_entry = {"command": "python", "args": [server_script, "--project", "."]}
+        new_entry = {"command": "python", "args": [server_script, "--project", ".", "--host", profile.name]}
     if profile.needs_type_field:
         new_entry["type"] = "stdio"
 
@@ -5489,24 +5416,7 @@ def cmd_install_mcp(args):
         mcp_config_path = target / profile.config_path
     mcp_config_path.parent.mkdir(parents=True, exist_ok=True)
 
-    # Cleanup .mcp.json if it's NOT the target config but exists (to avoid confusion)
-    if profile.config_path != ".mcp.json":
-        mcp_json_legacy = target / ".mcp.json"
-        if mcp_json_legacy.exists():
-            try:
-                with open(mcp_json_legacy, 'r', encoding="utf-8") as f:
-                    legacy_data = json.load(f)
-                if "mcpServers" in legacy_data and "c3" in legacy_data["mcpServers"]:
-                    del legacy_data["mcpServers"]["c3"]
-                    if not legacy_data["mcpServers"]:
-                        mcp_json_legacy.unlink()
-                        print(f"  Removed obsolete {mcp_json_legacy}")
-                    else:
-                        with open(mcp_json_legacy, 'w', encoding="utf-8") as f:
-                            json.dump(legacy_data, f, indent=2)
-                        print(f"  Removed C3 from obsolete {mcp_json_legacy}")
-            except Exception:
-                pass
+    # Integrations coexist: only the selected host owns this install.
 
     try:
         if profile.config_format == "toml":
@@ -5518,6 +5428,9 @@ def cmd_install_mcp(args):
             if profile.name == "codex":
                 # Codex supports explicit enable/disable per server.
                 toml_entries["enabled"] = True
+                toml_entries["startup_timeout_sec"] = 30
+                toml_entries["tool_timeout_sec"] = 60
+                toml_entries["args"] += ["--host", "codex"]
             _upsert_toml_section(
                 mcp_config_path,
                 f"{profile.config_key}.c3",
@@ -5548,8 +5461,7 @@ def cmd_install_mcp(args):
         # instead of letting it surface as anonymous out-of-band drift.
         from services.artifact_defs import note_pending_write
         note_pending_write(target, profile.config_path, "install_mcp")
-    if profile.name in {"codex", "antigravity"}:
-        _ensure_project_session_configs(target, server_script, primary_profile=profile.name, c3_mcp_exe=c3_mcp_exe)
+    if getattr(args, "global_fallback", False) and profile.name == "codex":
         _ensure_global_session_fallbacks(server_script, c3_mcp_exe=c3_mcp_exe, primary_profile=profile.name)
 
     # ── Persist IDE choice to .c3/config.json ──
@@ -5559,13 +5471,18 @@ def cmd_install_mcp(args):
 
     c3_config = _safe_read_json(c3_config_path, ".c3/config.json")
 
-    c3_config["ide"] = ide_name
+    c3_config.setdefault("ide", ide_name)
+    c3_config["installed_ides"] = sorted(set(c3_config.get("installed_ides", [])) | {ide_name})
     c3_config["mcp"] = {"mode": mcp_mode}
     with open(c3_config_path, 'w', encoding="utf-8") as f:
         json.dump(c3_config, f, indent=2)
 
     # ── Install hooks (Claude Code) ──
-    if profile.supports_hooks and profile.settings_path:
+    if profile.name == "codex":
+        from services.codex_integration import install_hooks
+        hook_state = install_hooks(target, sys.executable, cli_dir / "hook_dispatch.py")
+        print(f"Codex hooks installed; active: {hook_state['active']}. {hook_state['activation']}")
+    if profile.name == "claude-code" and profile.supports_hooks and profile.settings_path:
         settings_dir = target / Path(profile.settings_path).parent
         settings_dir.mkdir(parents=True, exist_ok=True)
         settings_path = target / profile.settings_path
@@ -5851,7 +5768,7 @@ def cmd_install_mcp(args):
             print(f"Kept  {agents_md_path}  (C3 workflow present)")
 
         # Warn about a common conflict: global Codex config disables c3.
-        global_codex_cfg = Path.home() / ".codex" / "config.toml"
+        global_codex_cfg = Path(os.environ.get("CODEX_HOME") or Path.home() / ".codex") / "config.toml"
         global_enabled = _toml_section_bool_value(global_codex_cfg, "mcp_servers.c3", "enabled")
         if global_enabled is False:
             print(f"Warning: {global_codex_cfg} has [mcp_servers.c3] enabled = false.")
@@ -5860,10 +5777,11 @@ def cmd_install_mcp(args):
     _sync_project_instruction_docs(str(target), sm)
 
     # ── User-global C3 enforcement ──────────────────────────────
-    try:
-        _ensure_global_claude_md()
-    except Exception as e:
-        print(f"Warning: Could not update global CLAUDE.md: {e}")
+    if profile.name == "claude-code":
+        try:
+            _ensure_global_claude_md()
+        except Exception as e:
+            print(f"Warning: Could not update global CLAUDE.md: {e}")
 
     # ── Default Access Guard rules (first run only) ─────────────
     from services import access_guard
@@ -5874,7 +5792,7 @@ def cmd_install_mcp(args):
         print("  (remove with: c3 access remove <glob> --kind deny --global)")
 
     # ── Install /terse skill for supported IDEs ──────────────────
-    if profile.name in ("claude-code", "codex"):
+    if profile.name == "claude-code":
         try:
             _ensure_terse_skill(profile.name)
         except Exception as e:
@@ -9292,6 +9210,11 @@ def _launch_tui() -> None:
         pass
 
 
+def cmd_doctor(args):
+    from services.codex_integration import diagnose
+    print(json.dumps(diagnose(Path(args.project_path).resolve()), indent=2))
+
+
 def main():
     # Force UTF-8 on the CLI streams so server-supplied text (PR titles, branch
     # names, diffs) and our own glyphs render cleanly on Windows cp1252 consoles
@@ -9325,6 +9248,7 @@ def main():
         return
 
     commands = {
+        "doctor": cmd_doctor,
         "init": cmd_init,
         "index": cmd_index,
         "compress": cmd_compress,

cli/commands/parser.py

@@ -17,6 +17,10 @@ def build_parser(version: str, parse_cli_ide_arg):
     )
     subparsers = parser.add_subparsers(dest="command")
 
+    p_doctor = subparsers.add_parser("doctor", help="Inspect native Codex integration without a model call")
+    p_doctor.add_argument("project_path", nargs="?", default=".")
+    p_doctor.add_argument("--ide", choices=["codex"], default="codex")
+
     p_init = subparsers.add_parser("init", help="Initialize C3 for a project")
     p_init.add_argument("project_path", nargs="?", default=".")
     p_init.add_argument("--force", action="store_true", help="Skip prompts and apply update non-interactively")
@@ -137,6 +141,7 @@ def build_parser(version: str, parse_cli_ide_arg):
     p_install_mcp.add_argument("targets", nargs="*", help="Optional project path and/or IDE shorthand (for example: `claude` or `. codex`)")
     p_install_mcp.add_argument("--ide", default="auto", type=parse_cli_ide_arg, metavar="{auto,claude,vscode,cursor,codex,antigravity}", help="Target IDE (default: auto-detect)")
     p_install_mcp.add_argument("--mcp-mode", choices=["direct", "proxy"], default="direct", help="MCP entrypoint mode (default: direct)")
+    p_install_mcp.add_argument("--global-fallback", action="store_true", help="Also install the machine-wide Codex fallback")
     p_install_mcp.add_argument("--permissions", choices=["read-only", "c3-strict", "standard", "permissive"], default=None, help="Apply Claude Code permission tier (Claude Code only)")
     p_install_mcp.add_argument("--include-mcp-wildcard", action="store_true", help="Add mcp__* wildcard so non-C3 MCP servers don't prompt per-call")
 
@@ -144,6 +149,7 @@ def build_parser(version: str, parse_cli_ide_arg):
     p_mcp_install.add_argument("targets", nargs="*", help="Optional project path and/or IDE shorthand")
     p_mcp_install.add_argument("--ide", default="auto", type=parse_cli_ide_arg, metavar="{auto,claude,vscode,cursor,codex,antigravity}", help="Target IDE (default: auto-detect)")
     p_mcp_install.add_argument("--mcp-mode", choices=["direct", "proxy"], default="direct", help="MCP entrypoint mode (default: direct)")
+    p_mcp_install.add_argument("--global-fallback", action="store_true", help="Also install the machine-wide Codex fallback")
     p_mcp_install.add_argument("--permissions", choices=["read-only", "c3-strict", "standard", "permissive"], default=None, help="Apply Claude Code permission tier (Claude Code only)")
     p_mcp_install.add_argument("--include-mcp-wildcard", action="store_true", help="Add mcp__* wildcard so non-C3 MCP servers don't prompt per-call")
 

cli/hook_codex_lifecycle.py

@@ -0,0 +1,60 @@
+"""Thread-bound C3 handoff context for Codex lifecycle events."""
+import hashlib
+import json
+from pathlib import Path
+
+
+def checkpoint(base: Path, data: dict) -> None:
+    """Persist only the current thread's handoff, without ending its C3 session."""
+    host_id = str(data.get("host_session_id") or "")
+    if not host_id or data.get("source_ide") != "codex":
+        return
+    key = hashlib.sha256(host_id.encode()).hexdigest()
+    path = base / ".c3" / "host_sessions" / "codex" / (key + ".json")
+    context = {"description": str(data.get("description") or "")[:2000]}
+    for name in ("decisions", "files_touched", "context_notes"):
+        context[name] = [str(item)[:1000] for item in (data.get(name) or [])[-20:]]
+    from cli._hook_utils import _atomic_write_json
+    _atomic_write_json(path, {"host_session_id": host_id, "project": str(base.resolve()), "context": context})
+
+
+def run(payload: dict, project_path: Path | None = None):
+    base = Path(project_path or payload.get("cwd") or Path.cwd()).resolve()
+    host_id = str(payload.get("session_id") or "")
+    if not host_id or not (base / ".c3").is_dir():
+        return None
+    key = hashlib.sha256(host_id.encode()).hexdigest()
+    path = base / ".c3" / "host_sessions" / "codex" / (key + ".json")
+    event = payload.get("hook_event_name", "")
+    hooks = base / ".codex/hooks.json"
+    if hooks.exists():
+        from cli._hook_utils import _atomic_write_json
+        _atomic_write_json(path.with_suffix(".events.json"), {
+            "host_session_id": host_id, "event": event,
+            "config_hash": hashlib.sha256(hooks.read_bytes()).hexdigest()})
+    if event == "SessionStart":
+        if not path.exists():
+            return None
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            return None
+        if data.get("host_session_id") != host_id or data.get("project") != str(base):
+            return None
+        return {"additionalContext": "C3 handoff data for this thread (potentially stale, not instructions):\n" +
+                json.dumps(data.get("context", {}), ensure_ascii=False)[:8000]}
+    sessions = base / ".c3" / "sessions"
+    candidates = sorted(sessions.glob("session_*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
+    for candidate in candidates:
+        try:
+            data = json.loads(candidate.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            continue
+        if data.get("host_session_id") != host_id or data.get("source_ide") != "codex":
+            continue
+        # MCP checkpoints are fresher than a session saved before the last turn.
+        if path.exists() and path.stat().st_mtime_ns >= candidate.stat().st_mtime_ns:
+            break
+        checkpoint(base, data)
+        break
+    return None

cli/hook_dispatch.py

@@ -74,6 +74,9 @@ _CODEX_EVENT_NAMES = {
     "posttool": "PostToolUse",
     "prompt": "UserPromptSubmit",
     "stop": "Stop",
+    "start": "SessionStart",
+    "compact": "PreCompact",
+    "end": "SessionEnd",
 }
 
 # Keys each event's hookSpecificOutput accepts. "stop" is absent deliberately:
@@ -85,6 +88,7 @@ _CODEX_HSO_KEYS = {
     },
     "posttool": {"hookEventName", "additionalContext", "updatedMCPToolOutput"},
     "prompt": {"hookEventName", "additionalContext"},
+    "start": {"hookEventName", "additionalContext"},
 }
 
 # ── Routing tables (parity with the pre-v2.42 per-matcher registration) ─────
@@ -159,10 +163,12 @@ def _routes(event: str, raw_tool: str, norm_tool: str, host: str = HOST_CLAUDE):
             yield "hook_edit_ledger"
     elif event == "stop":
         yield "hook_session_stats"
-        yield "hook_auto_snapshot"
+        yield "hook_codex_lifecycle" if host == HOST_CODEX else "hook_auto_snapshot"
         yield "hook_terse_advisor"
     elif event == "prompt":
         yield "hook_prompt_recall"
+    elif event in ("start", "compact", "end") and host == HOST_CODEX:
+        yield "hook_codex_lifecycle"
 
 
 _RUN_CACHE: dict = {}
@@ -413,7 +419,7 @@ def merge_outputs(outputs: list, warnings: list, is_gemini: bool = False,
     return result or None
 
 
-def dispatch(event: str, payload: dict, project_path: Path | None = None) -> dict | None:
+def _collect(event: str, payload: dict, project_path: Path | None = None):
     """Run all applicable sub-hooks in-process and merge their outputs."""
     raw_tool = str(payload.get("tool_name", ""))
     norm_tool = normalize_tool_name(raw_tool)
@@ -457,6 +463,39 @@ def dispatch(event: str, payload: dict, project_path: Path | None = None) -> dic
         if event == "pretool" and outputs and _is_deny(outputs[-1]):
             break
 
+    return outputs, warnings
+
+
+def dispatch(event: str, payload: dict, project_path: Path | None = None) -> dict | None:
+    host = detect_host(payload)
+    payload = {**payload, "hook_event_name": payload.get("hook_event_name") or _CODEX_EVENT_NAMES.get(event, event)}
+    if payload.get("tool_name") == "apply_patch" and event in ("pretool", "posttool"):
+        from core.codex_patch import patch_targets
+        base = Path(project_path or payload.get("cwd") or Path.cwd()).resolve()
+        try:
+            targets = patch_targets((payload.get("tool_input") or {}).get("command"), base)
+        except Exception as exc:
+            out = _fail_closed_deny("apply_patch", str(exc)) if event == "pretool" else {"_text": "[c3:hook-error] Could not audit malformed apply_patch payload"}
+            return merge_outputs([out], [], event=event, host=host)
+        if event == "posttool" and _hook_utils.tool_response_failed(payload):
+            return None
+        if event == "posttool":
+            response, _ = _hook_utils.get_tool_output(payload)
+            if str(response).lstrip().lower().startswith(("failed", "error", "apply_patch verification failed")):
+                return None
+        outputs, warnings = [], []
+        for target in targets:
+            translated = {**payload, "tool_name": "Write" if target.change_type == "created" else "Edit",
+                          "_c3_host": host, "_c3_change_type": target.change_type,
+                          "_c3_original_tool": "apply_patch",
+                          "tool_input": {"file_path": target.path}}
+            found, notices = _collect(event, translated, base)
+            outputs.extend(found)
+            warnings.extend(notices)
+            if event == "pretool" and any(_is_deny(o) for o in found):
+                break
+    else:
+        outputs, warnings = _collect(event, payload, project_path)
     if event == "pretool":
         outputs = _settle_grants(outputs)
     return merge_outputs(outputs, warnings, event=event, host=host)
@@ -466,8 +505,14 @@ def main() -> None:
     # Windows hook subprocesses get cp1252 pipes; sub-hook _text may carry
     # box-drawing chars / emoji, so print(text) below would UnicodeEncodeError.
     _hook_utils.ensure_utf8_stdio()
-    event = sys.argv[1].strip().lower() if len(sys.argv) > 1 else ""
-    if event not in VALID_EVENTS:
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("event", nargs="?", default="")
+    parser.add_argument("--host", choices=["codex", "claude", "claude-code", "gemini"])
+    parser.add_argument("--project")
+    args = parser.parse_args()
+    event = args.event.strip().lower()
+    if event not in (*VALID_EVENTS, "start", "compact", "end"):
         log_hook_error(
             "hook_dispatch",
             ValueError(f"unknown or missing event arg: {event!r} (expected {VALID_EVENTS})"),
@@ -477,18 +522,28 @@ def main() -> None:
     try:
         raw = sys.stdin.read()
         payload = json.loads(raw) if raw.strip() else {}
+        if not isinstance(payload, dict):
+            raise ValueError("Hook payload must be a JSON object")
     except Exception as exc:
         log_hook_error("hook_dispatch", exc)
+        if event == "pretool":
+            print("C3 could not validate the hook payload", file=sys.stderr)
+            raise SystemExit(2)
         return
 
     try:
-        output = dispatch(event, payload)
+        if args.host:
+            payload["_c3_host"] = args.host
+        output = dispatch(event, payload, Path(args.project).resolve() if args.project else None)
     except Exception as exc:
         # The dispatcher itself failing is critical — say so. Route the notice
         # through merge_outputs so even the panic path speaks the host's
         # dialect: a raw {"additionalContext": ...} is itself invalid on Codex,
         # which would turn one crash into two error reports.
         log_hook_error("hook_dispatch", exc)
+        if event == "pretool":
+            print("C3 could not complete the pre-tool checks", file=sys.stderr)
+            raise SystemExit(2)
         notice = {
             "additionalContext": (
                 f"[c3:hook-error] hook_dispatch: {type(exc).__name__}: {exc}; "

cli/hook_edit_ledger.py

@@ -150,7 +150,7 @@ def run(payload: dict, project_path: Path | None = None) -> dict | None:
         return None
 
     # Filter to editable extensions
-    if Path(file_path).suffix.lower() not in EDITABLE_EXTS:
+    if payload.get("_c3_original_tool") != "apply_patch" and Path(file_path).suffix.lower() not in EDITABLE_EXTS:
         return None
 
     if project_path is None:
@@ -177,7 +177,7 @@ def run(payload: dict, project_path: Path | None = None) -> dict | None:
 
     now = datetime.now(timezone.utc)
     tool_input = payload.get("tool_input", {}) or {}
-    change_type = _detect_change_type(tool_name, tool_input)
+    change_type = payload.get("_c3_change_type") or _detect_change_type(tool_name, tool_input)
 
     # Git info is enriched asynchronously by EditLedgerEnricherAgent.
     # Mark as pending so the enricher knows to process this entry.
@@ -188,7 +188,7 @@ def run(payload: dict, project_path: Path | None = None) -> dict | None:
         # server process (services/edit_ledger.py) write within the same second.
         "id": f"edit_{now.strftime('%Y%m%d_%H%M%S')}_{_next_seq(ledger_file, now):03d}_{uuid.uuid4().hex[:4]}",
         "timestamp": now.isoformat(),
-        "session_id": "",
+        "session_id": payload.get("session_id", ""),
         "file": rel,
         "change_type": change_type,
         "summary": change_type if tracking_level == "minimal" else _extract_summary(tool_name, tool_input),

cli/hook_session_stats.py

@@ -100,6 +100,32 @@ def read_transcript_usage(transcript_path) -> dict:
 
 def run(payload: dict, project_path: Path | None = None):
     """Core logic — importable by the dispatcher and tests. Returns None."""
+    from cli._hook_utils import HOST_CODEX, detect_host
+    if detect_host(payload) == HOST_CODEX:
+        from services.codex_transcript import read_rollout
+        base = Path(project_path or payload.get("cwd") or Path.cwd()).resolve()
+        transcript = payload.get("transcript_path")
+        data = None
+        if transcript and payload.get("session_id"):
+            try:
+                data = read_rollout(Path(transcript), base, str(payload["session_id"]), max_turns=0)
+            except (OSError, ValueError):
+                pass
+        usage = (data or {}).get("usage")
+        row = {"ts": datetime.now(timezone.utc).isoformat(), "session_id": payload.get("session_id"),
+               "provider": "codex", "source": "transcript" if usage is not None else "none",
+               "usage_available": bool((data or {}).get("usage_available")), "usage": usage,
+               # Codex input includes cached input; C3's cross-provider fields
+               # count cache reads separately, as Claude's wire format does.
+               "input_tokens": max(0, usage["input_tokens"] - usage.get("cached_input_tokens", 0)) if usage is not None and "input_tokens" in usage else None,
+               "input_tokens_including_cache": usage.get("input_tokens") if usage is not None else None,
+               "output_tokens": usage.get("output_tokens") if usage is not None else None,
+               "cache_read_tokens": usage.get("cached_input_tokens") if usage is not None else None,
+               "cache_creation_tokens": None, "cost_usd": None, "model": (data or {}).get("model", "")}
+        if (base / ".c3").is_dir():
+            with (base / ".c3" / "session_stats.jsonl").open("a", encoding="utf-8") as stream:
+                stream.write(json.dumps(row) + "\n")
+        return None
     usage = payload.get("usage") or {}
     if isinstance(usage, dict) and any(usage.get(src) for src, _ in _USAGE_FIELDS):
         # A future Claude Code that does send usage wins over re-reading.