code-context-control 2.37.0__tar.gz → 2.39.0__tar.gz

{code_context_control-2.37.0/code_context_control.egg-info → code_context_control-2.39.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.37.0
+Version: 2.39.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0
@@ -334,6 +334,10 @@ Only **read** and **safe-action** tools are exposed (no code editing); requests
 default. Generate, rotate, and copy the token from the dashboard's **Settings →
 Discovery API** tab. See the [Oracle Discovery API guide](oracle-guide/discovery-api.md).
 
+As of v2.38.0 the Oracle also reports a **cross-project activity digest** — sessions,
+tool calls, edits, git mutations, and token/cost for a day — via the `activity_report`
+discovery tool, the `GET /api/activity/digest` endpoint, and the dashboard's **Activity** tab.
+
 ---
 
 ## Tiered local AI (optional)

{code_context_control-2.37.0 → code_context_control-2.39.0}/README.md

@@ -272,6 +272,10 @@ Only **read** and **safe-action** tools are exposed (no code editing); requests
 default. Generate, rotate, and copy the token from the dashboard's **Settings →
 Discovery API** tab. See the [Oracle Discovery API guide](oracle-guide/discovery-api.md).
 
+As of v2.38.0 the Oracle also reports a **cross-project activity digest** — sessions,
+tool calls, edits, git mutations, and token/cost for a day — via the `activity_report`
+discovery tool, the `GET /api/activity/digest` endpoint, and the dashboard's **Activity** tab.
+
 ---
 
 ## Tiered local AI (optional)

{code_context_control-2.37.0 → code_context_control-2.39.0}/cli/_hook_utils.py

@@ -74,9 +74,46 @@ def get_tool_output(data: dict) -> tuple:
 
 
 def get_tool_input_path(data: dict) -> str:
-    """Extract file path from tool_input, handling both Claude (file_path) and Gemini (path)."""
+    """Extract file path from tool_input, handling Claude (file_path),
+    Gemini (path), and NotebookEdit (notebook_path)."""
     tool_input = data.get("tool_input", {})
-    return tool_input.get("file_path", "") or tool_input.get("path", "")
+    return (
+        tool_input.get("file_path", "")
+        or tool_input.get("path", "")
+        or tool_input.get("notebook_path", "")
+    )
+
+
+def record_json_unlocks(editable: list, project_path: Path | None = None) -> None:
+    """Record file paths as read+edit unlocked in .c3/unlocked_files.json.
+
+    This is the map that hook_pretool_enforce.py actually reads (the plain
+    .txt unlock list is not consumed by any hook). Mirrors the behaviour of
+    cli/hook_c3read._record_json_unlocks so c3_compress/c3_agent sticky
+    unlocks reach the enforcer. Fails silently on I/O errors.
+    """
+    base = project_path if project_path is not None else Path.cwd()
+    json_path = base / ".c3" / "unlocked_files.json"
+    try:
+        existing: dict = {}
+        if json_path.exists():
+            try:
+                existing = json.loads(json_path.read_text(encoding="utf-8"))
+                if not isinstance(existing, dict):
+                    existing = {}
+            except Exception:
+                existing = {}
+        for fp in editable:
+            if not fp:
+                continue
+            normalized = str(Path(fp).resolve())
+            cats = set(existing.get(normalized, []))
+            cats.update({"read", "edit"})
+            existing[normalized] = sorted(cats)
+        json_path.parent.mkdir(parents=True, exist_ok=True)
+        json_path.write_text(json.dumps(existing), encoding="utf-8")
+    except Exception:
+        pass
 
 
 def emit_additional_context(text: str, is_gemini: bool) -> None:

{code_context_control-2.37.0 → code_context_control-2.39.0}/cli/c3.py

@@ -85,7 +85,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.37.0"
+__version__ = "2.39.0"
 
 
 def _command_deps() -> CommandDeps:
@@ -4084,7 +4084,11 @@ def _upsert_toml_section(toml_path: Path, section: str, entries: dict) -> None:
     content = toml_path.read_text(encoding="utf-8") if toml_path.exists() else ""
     header = f"[{section}]"
 
-    # Strip existing section (header + its key=value lines)
+    # 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
@@ -4094,7 +4098,8 @@ def _upsert_toml_section(toml_path: Path, section: str, entries: dict) -> None:
             skip = True
             continue
         if skip and stripped.startswith("["):
-            skip = False
+            if not stripped.startswith(child_prefix):
+                skip = False
         if not skip:
             new_lines.append(line)
 
@@ -4577,41 +4582,48 @@ def _ensure_global_claude_md() -> None:
 
     existing = global_md.read_text(encoding="utf-8")
 
-    if _GLOBAL_CLAUDE_MD_MARKER not in existing:
-        # User has their own CLAUDE.md — append C3 section
-        merged = existing.rstrip() + "\n\n" + _GLOBAL_CLAUDE_MD_CONTENT
-        global_md.write_text(merged, encoding="utf-8")
-        print(f"Updated {global_md}  (appended C3 enforcement)")
-        return
+    # The C3-managed region is delimited by explicit BEGIN/END sentinels (the
+    # same ones used for project instruction docs). This is unambiguous, so
+    # user-written content outside the markers — including H1 headings that
+    # happen to mention "C3" or "Tool Discipline" — is never swallowed.
+    from services.claude_md import C3_BLOCK_BEGIN, C3_BLOCK_END, merge_c3_block
 
-    # C3 section exists — replace it with the latest version
-    # Find the C3 section boundaries: starts at the marker, ends at next # heading or EOF
-    start = existing.index(_GLOBAL_CLAUDE_MD_MARKER)
-    # Find the next top-level heading after the C3 section
-    rest = existing[start + len(_GLOBAL_CLAUDE_MD_MARKER):]
-    lines_after = rest.split("\n")
-    end_offset = len(rest)  # default: to EOF
-    running = 0
-    for line in lines_after:
-        running += len(line) + 1
-        # A top-level heading that's NOT part of C3's sub-headings
-        if line.startswith("# ") and "C3" not in line and "Tool Discipline" not in line:
-            end_offset = running - len(line) - 1
-            break
-
-    end = start + len(_GLOBAL_CLAUDE_MD_MARKER) + end_offset
-    before = existing[:start].rstrip()
-    after = existing[end:].lstrip()
+    wrapped = f"{C3_BLOCK_BEGIN}\n{_GLOBAL_CLAUDE_MD_CONTENT.strip()}\n{C3_BLOCK_END}"
 
-    parts = []
-    if before:
-        parts.append(before)
-    parts.append(_GLOBAL_CLAUDE_MD_CONTENT.strip())
-    if after:
-        parts.append(after)
+    # Markers already present → surgical, marker-bounded replacement.
+    if C3_BLOCK_BEGIN in existing:
+        global_md.write_text(merge_c3_block(existing, wrapped), encoding="utf-8")
+        print(f"Updated {global_md}  (refreshed C3 enforcement)")
+        return
 
-    global_md.write_text("\n\n".join(parts) + "\n", encoding="utf-8")
-    print(f"Updated {global_md}  (refreshed C3 enforcement)")
+    # Legacy marker-less C3 region → one-time migration into the marked block.
+    # Bound the region from the legacy heading to the NEXT top-level (``# ``)
+    # heading. C3's own content has exactly one H1 (the legacy heading itself),
+    # so the next H1 reliably marks where user content resumes; we deliberately
+    # do NOT skip H1s containing "C3"/"Tool Discipline" (the old heuristic did,
+    # which is what swallowed user headings).
+    if _GLOBAL_CLAUDE_MD_MARKER in existing:
+        start = existing.index(_GLOBAL_CLAUDE_MD_MARKER)
+        rest = existing[start + len(_GLOBAL_CLAUDE_MD_MARKER):]
+        end_offset = len(rest)  # default: to EOF
+        running = 0
+        for line in rest.split("\n"):
+            running += len(line) + 1
+            if line.startswith("# "):
+                end_offset = running - len(line) - 1
+                break
+        end = start + len(_GLOBAL_CLAUDE_MD_MARKER) + end_offset
+        before = existing[:start].rstrip()
+        after = existing[end:].lstrip()
+        parts = [p for p in (before, wrapped, after) if p]
+        global_md.write_text("\n\n".join(parts) + "\n", encoding="utf-8")
+        print(f"Updated {global_md}  (migrated C3 enforcement to markers)")
+        return
+
+    # User has their own CLAUDE.md with no C3 content — append the marked block.
+    merged = existing.rstrip() + "\n\n" + wrapped + "\n"
+    global_md.write_text(merged, encoding="utf-8")
+    print(f"Updated {global_md}  (appended C3 enforcement)")
 
 
 def _instruction_documents_for_project() -> list[tuple[str, str]]:
@@ -5019,6 +5031,8 @@ def cmd_install_mcp(args):
             glob_matcher   = "find_files"
             edit_matcher   = "edit_file"
             write_matcher  = "write_file"
+            # Gemini has no MultiEdit / NotebookEdit equivalents.
+            extra_edit_matchers = []
         else:
             shell_matcher  = "Bash"
             read_matcher   = "Read"
@@ -5026,6 +5040,9 @@ def cmd_install_mcp(args):
             glob_matcher   = "Glob"
             edit_matcher   = "Edit"
             write_matcher  = "Write"
+            # Claude Code also exposes MultiEdit (batch edits) and NotebookEdit;
+            # both bypass enforcement/logging unless their matchers are registered.
+            extra_edit_matchers = ["MultiEdit", "NotebookEdit"]
 
         # ── PostToolUse hooks ──
         desired_post_hooks = [
@@ -5120,6 +5137,10 @@ def cmd_install_mcp(args):
                 "matcher": write_matcher,
                 "hooks": [{"type": "command", "command": hook_edit_ledger_cmd}]
             },
+            *[
+                {"matcher": m, "hooks": [{"type": "command", "command": hook_edit_ledger_cmd}]}
+                for m in extra_edit_matchers
+            ],
         ]
 
         # ── PreToolUse hooks (enforcement — blocks native tools without prior c3_*) ──
@@ -5144,6 +5165,10 @@ def cmd_install_mcp(args):
                 "matcher": write_matcher,
                 "hooks": [{"type": "command", "command": hook_enforce_cmd}]
             },
+            *[
+                {"matcher": m, "hooks": [{"type": "command", "command": hook_enforce_cmd}]}
+                for m in extra_edit_matchers
+            ],
         ]
 
         # Merge: replace existing C3 hooks (so re-running install-mcp updates commands),

{code_context_control-2.37.0 → code_context_control-2.39.0}/cli/guide/oracle.html

@@ -269,6 +269,7 @@ curl -X POST \
           <tr><td class="grp-read"><code>c3_status</code></td>       <td>Project health / budget / sessions overview</td></tr>
           <tr><td class="grp-read"><code>c3_memory_query</code></td> <td>Read-only memory query (recall/list/score/graph/trends)</td></tr>
           <tr><td class="grp-read"><code>c3_edits</code> / <code>c3_edits_cross</code></td><td>Query the edit ledger (one / all projects)</td></tr>
+          <tr><td class="grp-read"><code>activity_report</code></td><td>Cross-project daily digest: sessions, tool calls, edits, git mutations, token/cost (optional LLM narration)</td></tr>
         </tbody>
       </table>
 

{code_context_control-2.37.0 → code_context_control-2.39.0}/cli/hook_edit_ledger.py

@@ -10,6 +10,7 @@ EditLedgerEnricherAgent running in the MCP server background.
 
 import json
 import sys
+import uuid
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -25,7 +26,7 @@ EDITABLE_EXTS = {
     ".py", ".js", ".ts", ".tsx", ".jsx", ".go", ".rs", ".java",
     ".rb", ".c", ".cpp", ".h", ".cs", ".html", ".css",
     ".json", ".yaml", ".yml", ".toml", ".sql", ".md", ".txt",
-    ".sh", ".bat", ".ps1", ".r",
+    ".sh", ".bat", ".ps1", ".r", ".ipynb",
 }
 
 # How many tail lines to scan for version/seq (avoids full-file parse)
@@ -95,8 +96,11 @@ def _next_seq(ledger_file: Path, now: datetime) -> int:
             continue
         eid = entry.get("id", "")
         if eid.startswith(prefix):
+            # ids may carry a random suffix ("..._001_a1b2"); take the leading
+            # numeric run after the prefix so same-second seq counting survives.
+            seq_part = eid[len(prefix):].split("_", 1)[0]
             try:
-                max_seq = max(max_seq, int(eid[len(prefix):]))
+                max_seq = max(max_seq, int(seq_part))
             except ValueError:
                 pass
     return max_seq + 1
@@ -172,7 +176,9 @@ def main():
         git_pending = tracking_level != "minimal"
 
         entry = {
-            "id": f"edit_{now.strftime('%Y%m%d_%H%M%S')}_{_next_seq(ledger_file, now):03d}",
+            # Random suffix prevents id collisions when the hook process and the
+            # 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": "",
             "file": rel,

{code_context_control-2.37.0 → code_context_control-2.39.0}/cli/hook_edit_unlock.py

@@ -14,7 +14,11 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
-from cli._hook_utils import emit_additional_context, log_hook_error  # noqa: E402
+from cli._hook_utils import (  # noqa: E402
+    emit_additional_context,
+    log_hook_error,
+    record_json_unlocks,
+)
 
 EDITABLE_EXTS = {
     ".py", ".js", ".ts", ".tsx", ".jsx", ".go", ".rs", ".java",
@@ -144,6 +148,10 @@ def main():
         except Exception:
             pass
 
+        # Fix 2: also write the .json unlock map — the .txt list above is read
+        # by NO hook; hook_pretool_enforce.py only consults unlocked_files.json.
+        record_json_unlocks(editable)
+
         # Emit batched nudge with all pending files
         # Prefer c3_edit (no unlock needed). Native Edit is also unlocked via sticky file set.
         if len(pending) == 1:

{code_context_control-2.37.0 → code_context_control-2.39.0}/cli/hook_pretool_enforce.py

@@ -180,24 +180,30 @@ def _is_file_unlocked(project_path: Path, file_path: str, category: str) -> bool
     return category in cats or "both" in cats
 
 
-def _check_signal_file(project_path: Path) -> tuple[bool, bool]:
+def _check_signal_file(project_path: Path) -> tuple[bool, bool, str]:
     """Read last_c3_call.json written by hook_c3_signal.py.
 
-    Returns (recent, read_unlocked):
+    Returns (recent, read_unlocked, c3_tool):
       recent:        True if a c3_* tool completed within _SIGNAL_MAX_AGE_SECS
       read_unlocked: True if that tool was c3_search/c3_compress/c3_filter
+      c3_tool:       short name of the c3 tool that wrote the signal (e.g.
+                     "c3_edit"), or "" if recent is False / unparseable.
+
+    Fails closed: on any parse error, returns (False, False, "").
     """
     signal_path = project_path / _SIGNAL_FILE
     if not signal_path.exists():
-        return False, False
+        return False, False, ""
     try:
         data = json.loads(signal_path.read_text(encoding="utf-8"))
         ts = datetime.fromisoformat(data["timestamp"])
         age = (datetime.now(timezone.utc) - ts).total_seconds()
         recent = age <= _SIGNAL_MAX_AGE_SECS
-        return recent, bool(data.get("read_unlocked", False)) and recent
+        if not recent:
+            return False, False, ""
+        return True, bool(data.get("read_unlocked", False)), str(data.get("tool", ""))
     except Exception:
-        return False, False
+        return False, False, ""
 
 
 def _check_c3_used(project_path: Path, tool_name: str, tool_input: dict) -> tuple[bool, str]:
@@ -223,10 +229,20 @@ def _check_c3_used(project_path: Path, tool_name: str, tool_input: dict) -> tupl
     required_cat = _TOOL_CATEGORY.get(tool_name, "read")
 
     # ── Fix 4: signal file — primary, fast, reliable ─────────────────────────
-    signal_recent, signal_read_unlocked = _check_signal_file(project_path)
+    signal_recent, signal_read_unlocked, signal_tool = _check_signal_file(project_path)
     if signal_recent:
+        # Bypass fix: for write-class tools (Edit/Write/MultiEdit), the signal
+        # may only unlock them when the c3 tool that wrote it actually satisfies
+        # this tool's prereqs (e.g. c3_edit/c3_edits/c3_agent). A read-class
+        # signal (c3_status, c3_search, …) must NOT unlock a native write.
+        if tool_name in _BLOCKED_TOOLS:
+            if signal_tool in allowed:
+                if native_target:
+                    _record_unlock(project_path, native_target, required_cat)
+                return True, "signal"
+            # Fresh signal exists but it's not a write-prereq tool — fall through
         # Fix 5: Grep/Glob without file path needs a read-unlocking tool
-        if not native_target and tool_name in ("Grep", "Glob", "FindFiles", "SearchText"):
+        elif not native_target and tool_name in ("Grep", "Glob", "FindFiles", "SearchText"):
             if signal_read_unlocked:
                 return True, "signal"
             # Signal exists but not read-unlocking (e.g. c3_memory) — fall through

{code_context_control-2.37.0 → code_context_control-2.39.0}/cli/mcp_server.py

@@ -120,12 +120,19 @@ async def lifespan(server):
                 services.indexer.build_index()
             except Exception:
                 pass
-            # After code index is built, build embedding index
-            if services.embedding_index and services.embedding_index.ready:
+            # After code index is built, build embedding index. build() lazily
+            # inits its chromadb/ollama backends, kept off the handshake path.
+            if services.embedding_index:
                 try:
                     services.embedding_index.build(services.indexer)
                 except Exception:
                     pass
+            # Warm SLTM vector store so the first memory call isn't slow.
+            if services.vector_store:
+                try:
+                    services.vector_store.warm()
+                except Exception:
+                    pass
             # Build doc index for Local RAG Pipeline
             if services.doc_index:
                 try:
@@ -136,15 +143,23 @@ async def lifespan(server):
         threading.Thread(target=_bg_build, daemon=True, name="c3-initial-index").start()
     else:
         services.indexer._load_index()
-        # Build/update embedding index in background
-        if services.embedding_index and services.embedding_index.ready:
+        # Build/update embedding index + warm SLTM in background. Deferred off
+        # the handshake path: build()/warm() lazily init the heavy backends, so
+        # this must NOT gate on .ready synchronously here.
+        if services.embedding_index or services.vector_store:
             import threading
 
             def _bg_embed():
-                try:
-                    services.embedding_index.build(services.indexer)
-                except Exception:
-                    pass
+                if services.embedding_index:
+                    try:
+                        services.embedding_index.build(services.indexer)
+                    except Exception:
+                        pass
+                if services.vector_store:
+                    try:
+                        services.vector_store.warm()
+                    except Exception:
+                        pass
 
             threading.Thread(target=_bg_embed, daemon=True, name="c3-embed-index").start()
 

{code_context_control-2.37.0 → code_context_control-2.39.0}/cli/tools/delegate.py

@@ -40,6 +40,7 @@ def _kill_proc_tree(proc):
             subprocess.run(
                 ["taskkill", "/F", "/T", "/PID", str(proc.pid)],
                 capture_output=True, stdin=subprocess.DEVNULL,
+                creationflags=subprocess.CREATE_NO_WINDOW,
             )
         else:
             proc.kill()
@@ -51,8 +52,10 @@ def _kill_proc_tree(proc):
 def _communicate_with_heartbeat(proc, timeout=45, idle_timeout=15):
     """communicate() replacement with idle-activity watchdog.
 
-    Monitors stderr for activity. If no stderr output for idle_timeout seconds,
-    kills the process early (catches MCP startup hangs). Also enforces total timeout.
+    Monitors both stdout and stderr for activity. If neither stream produces
+    output for idle_timeout seconds, kills the process early (catches MCP startup
+    hangs) without killing a backend that streams its answer only on stdout.
+    Also enforces total timeout.
 
     Returns (stdout, stderr, status) where status is 'ok', 'timeout', or 'idle_timeout'.
     """
@@ -71,7 +74,7 @@ def _communicate_with_heartbeat(proc, timeout=45, idle_timeout=15):
         except (ValueError, OSError):
             pass
 
-    t_out = threading.Thread(target=_read_stream, args=(proc.stdout, stdout_parts), daemon=True)
+    t_out = threading.Thread(target=_read_stream, args=(proc.stdout, stdout_parts, True), daemon=True)
     t_err = threading.Thread(target=_read_stream, args=(proc.stderr, stderr_parts, True), daemon=True)
     t_out.start()
     t_err.start()
@@ -218,10 +221,17 @@ def _run_claude(task: str, context: str, cwd: str | None = None,
             cmd,
             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             stdin=subprocess.DEVNULL,
-            text=True, cwd=cwd,
+            text=True, encoding="utf-8", errors="replace", cwd=cwd,
             **_popen_kwargs(),
         )
-        output, err = _communicate_with_heartbeat(proc, timeout=timeout, idle_timeout=idle_timeout)
+        output, err, status = _communicate_with_heartbeat(
+            proc, timeout=timeout, idle_timeout=idle_timeout,
+        )
+        if status == "idle_timeout":
+            return (f"[claude:idle_timeout] No stderr activity for {idle_timeout}s "
+                    f"(likely MCP startup hang)"), False
+        if status == "timeout":
+            return f"[claude:timeout] No response after {timeout}s", False
         if proc.returncode == 0 and output.strip():
             return output.strip(), True
         return f"[claude:error] {(err or '').strip() or 'no output'}", False
@@ -307,7 +317,7 @@ def _start_gemini_early(model: str, timeout: int = 45, idle_timeout: int = 15,
             cmd,
             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             stdin=subprocess.PIPE,
-            text=True,
+            text=True, encoding="utf-8", errors="replace",
             cwd=cwd,
             **_popen_kwargs(),
         )
@@ -344,7 +354,7 @@ def _finish_gemini_early(proc, task: str, context: str,
         except (ValueError, OSError):
             pass
 
-    t_out = threading.Thread(target=_read_stream, args=(proc.stdout, stdout_parts), daemon=True)
+    t_out = threading.Thread(target=_read_stream, args=(proc.stdout, stdout_parts, True), daemon=True)
     t_err = threading.Thread(target=_read_stream, args=(proc.stderr, stderr_parts, True), daemon=True)
     t_out.start()
     t_err.start()
@@ -448,7 +458,7 @@ def _run_gemini(task: str, context: str, model: str,
             cmd,
             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             stdin=subprocess.DEVNULL,
-            text=True,
+            text=True, encoding="utf-8", errors="replace",
             cwd=cwd,
             **_popen_kwargs(),
         )
@@ -563,7 +573,7 @@ def _run_codex(task: str, context: str, model: str, sandbox: str,
             cmd,
             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             stdin=subprocess.DEVNULL,
-            text=True,
+            text=True, encoding="utf-8", errors="replace",
             cwd=cwd,
             **_popen_kwargs(),
         )
@@ -592,25 +602,18 @@ def _run_codex_resume(follow_up: str, timeout: int = 120,
     """Resume last Codex session with a follow-up prompt."""
     cmd = ["codex", "exec", "--skip-git-repo-check", "resume", "--last"]
     try:
-        import sys
         proc = subprocess.Popen(
             cmd,
             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             stdin=subprocess.PIPE,
-            text=True,
+            text=True, encoding="utf-8", errors="replace",
             cwd=cwd,
+            **_popen_kwargs(),
         )
         try:
             stdout, stderr = proc.communicate(input=follow_up, timeout=timeout)
         except subprocess.TimeoutExpired:
-            if sys.platform == "win32":
-                subprocess.run(
-                    ["taskkill", "/F", "/T", "/PID", str(proc.pid)],
-                    capture_output=True, stdin=subprocess.DEVNULL,
-                )
-            else:
-                proc.kill()
-            proc.wait(timeout=5)
+            _kill_proc_tree(proc)
             return f"[codex:timeout] Resume timed out after {timeout}s", False
 
         if proc.returncode != 0:
@@ -1166,7 +1169,10 @@ def handle_delegate(task: str, task_type: str, context: str, file_path: str,
                 model=fallback, system=tdef["system"],
                 temperature=tdef.get("temperature", 0.3),
                 max_tokens=int(dcfg.get("max_tokens", 512) or 512),
-            )
+                timeout=timeout_s)
+            if retry_resp is None:
+                # Timeout/failure on the fallback — not a valid empty answer.
+                continue
             retry_conf = _estimate_confidence(task_type, retry_resp, count_tokens(retry_resp))
             if retry_conf != "low":
                 resp = retry_resp