imprint-mcp 0.6.1 → 0.6.2

package/src/imprint/cdp-browser-fetch.ts

@@ -94,6 +94,27 @@ export function jarCookiesValidated(cookies: Array<{ name: string; value: string
   return cookies.some((c) => c.name === 'bm_sv');
 }
 
+export function buildNavigationSelectorExpression(selector: string): string {
+  return `document.querySelector(${JSON.stringify(selector)}) !== null`;
+}
+
+export function buildNavigationClickTargetExpression(selector: string): string {
+  return `(() => {
+    const target = document.querySelector(${JSON.stringify(selector)});
+    if (!(target instanceof Element)) return null;
+    target.scrollIntoView({ block: 'center', inline: 'center' });
+    const rect = target.getBoundingClientRect();
+    if (rect.width <= 0 || rect.height <= 0) return null;
+    if (target.matches(':disabled')) return null;
+    const x = rect.left + rect.width / 2;
+    const y = rect.top + rect.height / 2;
+    const hit = document.elementFromPoint(x, y);
+    if (hit !== target && !target.contains(hit) && !hit?.contains(target)) return null;
+    target.focus();
+    return { x, y };
+  })()`;
+}
+
 export interface CdpBrowserFetch {
   /** typeof fetch — executes the request inside the live trusted Chrome page. */
   readonly fetchImpl: typeof fetch;
@@ -109,6 +130,9 @@ export interface CdpBrowserFetch {
       timeoutMs?: number;
       pollIntervalMs?: number;
       urlIncludes?: string;
+      selector?: string;
+      actions?: Array<{ action: 'click'; selector: string }>;
+      resultSelector?: string;
       cookie?: { name: string; domain?: string; path?: string };
     },
   ): Promise<Response>;
@@ -1253,6 +1277,49 @@ export function createCdpBrowserFetch(opts: CdpBrowserFetchOptions): CdpBrowserF
     return currentPageUrl;
   };
 
+  const dispatchTrustedClick = async (
+    c: CdpClient,
+    x: number,
+    y: number,
+    label: string,
+    timeoutMs: number,
+  ): Promise<void> => {
+    await withTimeout(c.Page.bringToFront(), `CDP Page.bringToFront(${label})`, timeoutMs);
+    const timestamp = Date.now() / 1000;
+    await withTimeout(
+      c.Input.dispatchMouseEvent({ type: 'mouseMoved', x, y, timestamp }),
+      `CDP Input.dispatchMouseEvent(${label} mouseMoved)`,
+      timeoutMs,
+    );
+    await sleep(100);
+    await withTimeout(
+      c.Input.dispatchMouseEvent({
+        type: 'mousePressed',
+        button: 'left',
+        buttons: 1,
+        clickCount: 1,
+        x,
+        y,
+        timestamp,
+      }),
+      `CDP Input.dispatchMouseEvent(${label} mousePressed)`,
+      timeoutMs,
+    );
+    await sleep(50);
+    await withTimeout(
+      c.Input.dispatchMouseEvent({
+        type: 'mouseReleased',
+        button: 'left',
+        clickCount: 1,
+        x,
+        y,
+        timestamp: Date.now() / 1000,
+      }),
+      `CDP Input.dispatchMouseEvent(${label} mouseReleased)`,
+      timeoutMs,
+    );
+  };
+
   const navigate = async (
     rawUrl: string,
     options: {
@@ -1263,6 +1330,9 @@ export function createCdpBrowserFetch(opts: CdpBrowserFetchOptions): CdpBrowserF
       timeoutMs?: number;
       pollIntervalMs?: number;
       urlIncludes?: string;
+      selector?: string;
+      actions?: Array<{ action: 'click'; selector: string }>;
+      resultSelector?: string;
       cookie?: { name: string; domain?: string; path?: string };
     } = {},
   ): Promise<Response> => {
@@ -1402,44 +1472,7 @@ export function createCdpBrowserFetch(opts: CdpBrowserFetchOptions): CdpBrowserF
         log(
           `form POST: trusted click on ${String(directive.tag ?? 'control')} type=${String(directive.type ?? 'unknown')} focused=${focusProbe.result.value === true} hit=${liveTarget.hit === true}`,
         );
-        const timestamp = Date.now() / 1000;
-        await withTimeout(
-          c.Input.dispatchMouseEvent({
-            type: 'mouseMoved',
-            x: clickX,
-            y: clickY,
-            timestamp,
-          }),
-          'CDP Input.dispatchMouseEvent(form mouseMoved)',
-          cdpCommandTimeoutMs,
-        );
-        await sleep(100);
-        await withTimeout(
-          c.Input.dispatchMouseEvent({
-            type: 'mousePressed',
-            button: 'left',
-            buttons: 1,
-            clickCount: 1,
-            x: clickX,
-            y: clickY,
-            timestamp,
-          }),
-          'CDP Input.dispatchMouseEvent(form mousePressed)',
-          cdpCommandTimeoutMs,
-        );
-        await sleep(50);
-        await withTimeout(
-          c.Input.dispatchMouseEvent({
-            type: 'mouseReleased',
-            button: 'left',
-            clickCount: 1,
-            x: clickX,
-            y: clickY,
-            timestamp: Date.now() / 1000,
-          }),
-          'CDP Input.dispatchMouseEvent(form mouseReleased)',
-          cdpCommandTimeoutMs,
-        );
+        await dispatchTrustedClick(c, clickX, clickY, 'form', cdpCommandTimeoutMs);
         await sleep(250);
         const clickProbe = await withTimeout(
           c.Runtime.evaluate({
@@ -1491,15 +1524,28 @@ export function createCdpBrowserFetch(opts: CdpBrowserFetchOptions): CdpBrowserF
       }
     }
 
-    const hasPredicate = Boolean(options.urlIncludes || options.cookie);
+    const selectorExists = async (selector?: string): Promise<boolean> => {
+      if (!selector) return true;
+      const evaluated = await withTimeout(
+        c.Runtime.evaluate({
+          expression: buildNavigationSelectorExpression(selector),
+          returnByValue: true,
+        }),
+        'CDP Runtime.evaluate(navigation selector)',
+        cdpCommandTimeoutMs,
+      );
+      return evaluated.result.value === true;
+    };
+    const hasPredicate = Boolean(options.urlIncludes || options.selector || options.cookie);
+    const deadline = Date.now() + timeoutMs;
     if (!hasPredicate) {
       await withTimeout(lifecyclePromise, `CDP Page.${options.waitUntil ?? 'load'}`, timeoutMs);
     } else {
-      const deadline = Date.now() + timeoutMs;
       let lastUrl = targetUrl;
       while (Date.now() < deadline) {
         lastUrl = await readCurrentPageUrl(c);
         const urlMatches = !options.urlIncludes || lastUrl.includes(options.urlIncludes);
+        const selectorMatches = await selectorExists(options.selector);
         let cookieMatches = !options.cookie;
         if (options.cookie) {
           const expectedDomain = options.cookie.domain?.replace(/^\./, '').toLowerCase();
@@ -1515,7 +1561,7 @@ export function createCdpBrowserFetch(opts: CdpBrowserFetchOptions): CdpBrowserF
             return !options.cookie?.path || cookie.path === options.cookie.path;
           });
         }
-        if (urlMatches && cookieMatches) break;
+        if (urlMatches && selectorMatches && cookieMatches) break;
         await sleep(Math.min(pollIntervalMs, Math.max(1, deadline - Date.now())));
       }
 
@@ -1528,6 +1574,7 @@ export function createCdpBrowserFetch(opts: CdpBrowserFetchOptions): CdpBrowserF
       await sleep(Math.min(500, Math.max(1, deadline - Date.now())));
 
       const finalUrl = await readCurrentPageUrl(c);
+      const finalSelectorMatches = await selectorExists(options.selector);
       const allCookies = await snapshotAllCookies(c);
       const expectedDomain = options.cookie?.domain?.replace(/^\./, '').toLowerCase();
       const matchedCookie = !options.cookie
@@ -1542,9 +1589,14 @@ export function createCdpBrowserFetch(opts: CdpBrowserFetchOptions): CdpBrowserF
             }
             return !options.cookie?.path || cookie.path === options.cookie.path;
           });
-      if ((options.urlIncludes && !finalUrl.includes(options.urlIncludes)) || !matchedCookie) {
+      if (
+        (options.urlIncludes && !finalUrl.includes(options.urlIncludes)) ||
+        !finalSelectorMatches ||
+        !matchedCookie
+      ) {
         const criteria = [
           options.urlIncludes ? `URL containing ${JSON.stringify(options.urlIncludes)}` : null,
+          options.selector ? `CSS selector ${JSON.stringify(options.selector)}` : null,
           options.cookie ? `cookie ${options.cookie.name}` : null,
         ]
           .filter(Boolean)
@@ -1555,6 +1607,47 @@ export function createCdpBrowserFetch(opts: CdpBrowserFetchOptions): CdpBrowserF
       }
     }
 
+    for (const interaction of options.actions ?? []) {
+      if (interaction.action !== 'click') continue;
+      const target = await withTimeout(
+        c.Runtime.evaluate({
+          expression: buildNavigationClickTargetExpression(interaction.selector),
+          returnByValue: true,
+        }),
+        `CDP Runtime.evaluate(navigation click target ${JSON.stringify(interaction.selector)})`,
+        Math.max(1, deadline - Date.now()),
+      ).catch(() => null);
+      const point = target?.result.value as { x?: unknown; y?: unknown } | null | undefined;
+      if (typeof point?.x !== 'number' || typeof point.y !== 'number') {
+        throw new Error(
+          `browser navigation action could not find a visible click target for ${JSON.stringify(interaction.selector)}`,
+        );
+      }
+      await dispatchTrustedClick(
+        c,
+        point.x,
+        point.y,
+        'navigation',
+        Math.max(1, deadline - Date.now()),
+      );
+      await sleep(150);
+    }
+
+    if (options.resultSelector) {
+      let matched = false;
+      while (Date.now() < deadline) {
+        matched = await selectorExists(options.resultSelector).catch(() => false);
+        if (matched) break;
+        await sleep(Math.min(pollIntervalMs, Math.max(1, deadline - Date.now())));
+      }
+      if (!matched) {
+        throw new Error(
+          `browser navigation timed out after ${timeoutMs}ms waiting for post-action CSS selector ${JSON.stringify(options.resultSelector)}`,
+        );
+      }
+      await sleep(Math.min(500, Math.max(1, deadline - Date.now())));
+    }
+
     currentPageUrl = await readCurrentPageUrl(c);
     let html = '';
     try {

package/src/imprint/claude-cli-compile.ts

@@ -39,7 +39,7 @@ import type {
 import { formatCandidateContext, formatToolPlan } from './compile-agent-types.ts';
 import { preferredAgentModel } from './llm.ts';
 import { createLog } from './log.ts';
-import { COMPILE_SENTINELS } from './mcp-compile-server.ts';
+import { COMPILE_SENTINELS, compileDeadlineAfterVerification } from './mcp-compile-server.ts';
 import type { SharedCompileContext, ToolCandidate } from './tool-candidates.ts';
 import {
   endTraceSpan,
@@ -60,6 +60,12 @@ const CLI_PATH = pathJoin(REPO_ROOT, 'src', 'cli.ts');
 const MCP_SERVER_NAME = 'imprint-compile';
 const MAX_VERIFICATION_CYCLES = 5;
 
+function formatRevisionMode(enabled: boolean | undefined): string {
+  return enabled
+    ? 'REVISION MODE: inspect read_session_summary.revisionContext and the listed existing artifacts/diagnostics first. Preserve proven behavior; repair or honestly narrow only what evidence contradicts.'
+    : '';
+}
+
 /**
  * Thinking effort for the compile agent. Deliberately `high`, not `max`:
  * empirically, max-effort thinking generates a large volume of reasoning tokens
@@ -110,6 +116,8 @@ interface CompileViaClaudeCliOptions {
   sharedModules?: SharedModuleManifestEntry[];
   /** Per-tool implementation plan injected into the agent's initial message. */
   toolPlan?: string;
+  /** Revise existing generated artifacts from durable verification feedback. */
+  revisionMode?: boolean;
   /** Present → drive an auth compile rather than a data compile. */
   authMode?: AuthCliCompileMode;
   /** Auth segments only: resume a prior segment's claude session with a new user
@@ -275,6 +283,7 @@ async function runClaudeCliAttempt(opts: CompileViaClaudeCliOptions): Promise<Co
     COMPILE_SENTINELS.done,
     COMPILE_SENTINELS.giveUp,
     COMPILE_SENTINELS.checkpoint,
+    COMPILE_SENTINELS.verificationState,
   ]) {
     const p = pathJoin(opts.absoluteToolDir, name);
     if (existsSync(p)) {
@@ -325,10 +334,13 @@ async function runClaudeCliAttempt(opts: CompileViaClaudeCliOptions): Promise<Co
       sessionPathAbs,
       '--tool-dir',
       opts.absoluteToolDir,
+      '--provider',
+      'claude-cli',
       ...(opts.candidate ? ['--candidate-json', JSON.stringify(opts.candidate)] : []),
       ...(opts.sharedContext ? ['--shared-context-json', JSON.stringify(opts.sharedContext)] : []),
       ...(opts.buildPlanPath ? ['--build-plan-path', opts.buildPlanPath] : []),
       ...(opts.sharedModules ? ['--shared-modules-json', JSON.stringify(opts.sharedModules)] : []),
+      ...(opts.revisionMode ? ['--revision-mode'] : []),
     ];
     allowedToolNames = [
       'read_session_summary',
@@ -355,6 +367,7 @@ Tool directory: ${opts.absoluteToolDir}
 You will write artifacts into the tool directory.
 ${formatCandidateContext(opts.candidate, opts.sharedContext, assignedSharedModules)}
 ${formatToolPlan(opts.toolPlan)}
+${formatRevisionMode(opts.revisionMode)}
 
 Begin by calling read_session_summary to orient yourself, then proceed per the system prompt.`;
   }
@@ -425,19 +438,14 @@ Begin by calling read_session_summary to orient yourself, then proceed per the s
     child = spawn('claude', args, {
       cwd: REPO_ROOT,
       // Claude CLI's default MCP_TOOL_TIMEOUT is 60s. The compile MCP
-      // server's `done` tool runs external verification inline — bun test
-      // (up to 60s × 3 retries for the integration suite + 120s for the
-      // parser suite) plus typechecking. On bot-protected sites where the
-      // integration test escalates fetch → fetch-bootstrap → stealth-fetch
-      // for every assertion, a single bun test pass can run 30s × 3
-      // rungs × N tests = 10-15 min before the outer wrapper kills it,
-      // and 3 retries push the total well past 30 min. A 10-min cap was
-      // not enough — set 30 min so the worst-case verification can
-      // actually complete and the agent receives the failure feedback
-      // (and ships with `liveVerified: false` via the waiver path)
-      // rather than getting `-32000: Connection closed` mid-call and
-      // wasting the rest of its turn budget. Honor user-set env so an
-      // operator on a fast network can tighten without editing source.
+      // server's `done` tool runs external verification inline: one live
+      // integration suite, parser tests, typechecking, and a fresh semantic
+      // verifier agent that may make a narrowly targeted follow-up call. On
+      // bot-protected sites one suite can still take 10-15 minutes as each
+      // assertion escalates fetch → fetch-bootstrap → stealth-fetch. Keep the
+      // 30-minute cap so the agent receives semantic feedback rather than an
+      // MCP connection-close midway through review. Honor user-set env so an
+      // operator on a fast network can tighten it without editing source.
       // Connection-startup timeout stays at 60s for cold Playwright boot.
       env: {
         ...process.env,
@@ -516,9 +524,19 @@ async function driveStreamJson(
   };
 
   const scheduleDeadlineCheck = (): ReturnType<typeof setTimeout> => {
-    const remaining = Math.max(0, currentDeadlineMs - Date.now());
+    const effectiveDeadlineMs = compileDeadlineAfterVerification(
+      opts.absoluteToolDir,
+      currentDeadlineMs,
+    );
+    const remaining = Math.max(0, effectiveDeadlineMs - Date.now());
     return setTimeout(async () => {
       if (childExited) return;
+      // done() verification runs in the MCP child. Re-read its lifecycle clock
+      // before killing the compiler so only reasoning time counts here.
+      if (Date.now() < compileDeadlineAfterVerification(opts.absoluteToolDir, currentDeadlineMs)) {
+        deadlineTimer = scheduleDeadlineCheck();
+        return;
+      }
       if (opts.onDeadlineReached) {
         const extensionMs = await opts.onDeadlineReached();
         if (childExited) return;
@@ -748,7 +766,11 @@ async function driveStreamJson(
   }
 
   // Wall-clock deadline exceeded?
-  if (Date.now() > currentDeadlineMs && !existsSync(doneSentinel) && !existsSync(giveUpSentinel)) {
+  if (
+    Date.now() > compileDeadlineAfterVerification(opts.absoluteToolDir, currentDeadlineMs) &&
+    !existsSync(doneSentinel) &&
+    !existsSync(giveUpSentinel)
+  ) {
     return {
       success: false,
       outcome: 'timeout',

package/src/imprint/codex-cli-compile.ts

@@ -7,7 +7,7 @@
  * success only after the MCP done() tool writes the verified sentinel.
  */
 
-import { type ChildProcess, spawn } from 'node:child_process';
+import { type ChildProcess, spawn, spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { isAbsolute as pathIsAbsolute, join as pathJoin } from 'node:path';
 import type { Span } from '@opentelemetry/api';
@@ -21,7 +21,7 @@ import type {
 import { formatCandidateContext, formatToolPlan } from './compile-agent-types.ts';
 import { preferredAgentModel } from './llm.ts';
 import { createLog } from './log.ts';
-import { COMPILE_SENTINELS } from './mcp-compile-server.ts';
+import { COMPILE_SENTINELS, compileDeadlineAfterVerification } from './mcp-compile-server.ts';
 import type { SharedCompileContext, ToolCandidate } from './tool-candidates.ts';
 import {
   endTraceSpan,
@@ -43,9 +43,14 @@ const REPO_ROOT = pathJoin(import.meta.dir, '..', '..');
 const CLI_PATH = pathJoin(REPO_ROOT, 'src', 'cli.ts');
 const MCP_SERVER_NAME = 'imprint-compile';
 const MAX_VERIFICATION_CYCLES = 5;
-const MIN_MCP_TOOL_TIMEOUT_SEC = 300;
 const MAX_MCP_TOOL_TIMEOUT_SEC = 1800;
 
+function formatRevisionMode(enabled: boolean | undefined): string {
+  return enabled
+    ? 'REVISION MODE: inspect read_session_summary.revisionContext and the listed existing artifacts/diagnostics first. Preserve proven behavior; repair or honestly narrow only what evidence contradicts.'
+    : '';
+}
+
 interface CompileViaCodexCliOptions {
   session: Session;
   absoluteToolDir: string;
@@ -63,6 +68,8 @@ interface CompileViaCodexCliOptions {
   sharedModules?: SharedModuleManifestEntry[];
   /** Per-tool implementation plan injected into the agent's initial message. */
   toolPlan?: string;
+  /** Revise existing generated artifacts from durable verification feedback. */
+  revisionMode?: boolean;
   /** Present → drive an auth compile rather than a data compile. */
   authMode?: AuthCliCompileMode;
   /** Auth segments only: resume the same non-interactive Codex session. */
@@ -143,6 +150,7 @@ async function compileViaCodexCliImpl(
     COMPILE_SENTINELS.done,
     COMPILE_SENTINELS.giveUp,
     COMPILE_SENTINELS.checkpoint,
+    COMPILE_SENTINELS.verificationState,
   ]) {
     const p = pathJoin(opts.absoluteToolDir, name);
     if (existsSync(p)) {
@@ -199,10 +207,13 @@ async function compileViaCodexCliImpl(
       sessionPathAbs,
       '--tool-dir',
       opts.absoluteToolDir,
+      '--provider',
+      'codex-cli',
       ...(opts.candidate ? ['--candidate-json', JSON.stringify(opts.candidate)] : []),
       ...(opts.sharedContext ? ['--shared-context-json', JSON.stringify(opts.sharedContext)] : []),
       ...(opts.buildPlanPath ? ['--build-plan-path', opts.buildPlanPath] : []),
       ...(opts.sharedModules ? ['--shared-modules-json', JSON.stringify(opts.sharedModules)] : []),
+      ...(opts.revisionMode ? ['--revision-mode'] : []),
     ];
     const { assignedSharedModules } = resolvePlanSliceFromFile(
       opts.buildPlanPath,
@@ -220,6 +231,7 @@ Tool directory: ${opts.absoluteToolDir}
 You will write artifacts into the tool directory.
 ${formatCandidateContext(opts.candidate, opts.sharedContext, assignedSharedModules)}
 ${formatToolPlan(opts.toolPlan)}
+${formatRevisionMode(opts.revisionMode)}
 
 Use the imprint-compile MCP tools to inspect the session, write artifacts, run tests, and call done(). Begin by calling read_session_summary, then proceed per the system instructions.`;
   }
@@ -227,7 +239,9 @@ Use the imprint-compile MCP tools to inspect the session, write artifacts, run t
   const model = opts.model ?? preferredAgentModel('codex-cli');
   const initialTokenCount = resolveTraceTokenCount(null, initialPrompt);
   const captureLlmIo = traceLlmIoEnabled();
-  const mcpToolTimeoutSec = resolveMcpToolTimeoutSec(opts.deadlineMs);
+  // done() owns a separately bounded live-verification phase, so its transport
+  // timeout cannot be derived from the compiler's remaining reasoning budget.
+  const mcpToolTimeoutSec = MAX_MCP_TOOL_TIMEOUT_SEC;
   setSpanAttributes(traceSpan, {
     ...llmSpanAttributes({
       provider: 'codex-cli',
@@ -324,7 +338,20 @@ Use the imprint-compile MCP tools to inspect the session, write artifacts, run t
     return finalErrorResult(opts, `failed to send prompt to codex-cli: ${errMsg(err)}`);
   }
 
-  const result = await driveJsonl(child, opts, traceSpan);
+  const terminateOnParentExit = (): void => {
+    try {
+      signalCodexProcessTree(child, 'SIGTERM');
+    } catch {
+      // Parent shutdown is best-effort; the OS may already have reaped the child.
+    }
+  };
+  process.once('exit', terminateOnParentExit);
+  let result: CompileAgentResult;
+  try {
+    result = await driveJsonl(child, opts, traceSpan);
+  } finally {
+    process.removeListener('exit', terminateOnParentExit);
+  }
   const hasActualUsage = result.inputTokens > 0 || result.outputTokens > 0;
   const inputTokenCount = resolveTraceTokenCount(
     hasActualUsage ? result.inputTokens : null,
@@ -350,14 +377,6 @@ Use the imprint-compile MCP tools to inspect the session, write artifacts, run t
   return result;
 }
 
-function resolveMcpToolTimeoutSec(deadlineMs: number, now = Date.now()): number {
-  const remainingSec = Math.ceil(Math.max(0, deadlineMs - now) / 1000);
-  return Math.max(
-    MIN_MCP_TOOL_TIMEOUT_SEC,
-    Math.min(MAX_MCP_TOOL_TIMEOUT_SEC, remainingSec || MIN_MCP_TOOL_TIMEOUT_SEC),
-  );
-}
-
 function buildAuthCodexInitialPrompt(systemPrompt: string, initialPrompt: string): string {
   return `<system_instructions>
 ${systemPrompt}
@@ -382,6 +401,15 @@ async function driveJsonl(
       writeFileSync(conversationLogPath, JSON.stringify(conversationLog, null, 2), 'utf8');
     } catch {}
   };
+  let flushLogTimer: ReturnType<typeof setTimeout> | undefined;
+  const scheduleLogFlush = (): void => {
+    if (flushLogTimer) return;
+    flushLogTimer = setTimeout(() => {
+      flushLogTimer = undefined;
+      flushLog();
+    }, 50);
+    flushLogTimer.unref?.();
+  };
   const rawStdoutChunks: string[] = [];
   const rawStderrChunks: string[] = [];
   let inputTokens = 0;
@@ -430,13 +458,26 @@ async function driveJsonl(
     }, graceMs);
     forceTimer.unref?.();
   };
-  const deadlineTimer = setTimeout(
-    () => {
-      log('wall-clock deadline exceeded, terminating codex');
-      terminateChild(5000);
-    },
-    Math.max(0, opts.deadlineMs - Date.now()),
-  );
+  let childExited = false;
+  const scheduleDeadlineCheck = (): ReturnType<typeof setTimeout> => {
+    const effectiveDeadlineMs = compileDeadlineAfterVerification(
+      opts.absoluteToolDir,
+      opts.deadlineMs,
+    );
+    return setTimeout(
+      () => {
+        if (childExited) return;
+        if (Date.now() < compileDeadlineAfterVerification(opts.absoluteToolDir, opts.deadlineMs)) {
+          deadlineTimer = scheduleDeadlineCheck();
+          return;
+        }
+        log('wall-clock deadline exceeded, terminating codex');
+        terminateChild(5000);
+      },
+      Math.max(0, effectiveDeadlineMs - Date.now()),
+    );
+  };
+  let deadlineTimer = scheduleDeadlineCheck();
 
   let stdoutBuf = '';
   child.stdout?.on('data', (chunk: Buffer) => {
@@ -459,6 +500,11 @@ async function driveJsonl(
       }
 
       conversationLog.push(evt);
+      // Keep the human-readable compile log current during a long agent turn.
+      // Rewriting is throttled so streamed bursts do not cause one full-file
+      // write per JSONL event, while a stalled/crashed turn still leaves the
+      // latest tool activity visible on disk.
+      scheduleLogFlush();
 
       if (evt.type === 'thread.started') {
         log(`thread_id=${evt.thread_id ?? '(none)'}`);
@@ -582,6 +628,7 @@ async function driveJsonl(
       finish(-1);
     });
   });
+  childExited = true;
   clearTimeout(deadlineTimer);
   if (currentTurnSpan) endTraceSpan(currentTurnSpan);
   for (const span of toolSpans.values()) endTraceSpan(span);
@@ -597,6 +644,7 @@ async function driveJsonl(
   } catch {
     // best effort diagnostics
   }
+  if (flushLogTimer) clearTimeout(flushLogTimer);
   flushLog();
 
   const verifiedOk =
@@ -712,7 +760,7 @@ async function driveJsonl(
     };
   }
 
-  if (Date.now() > opts.deadlineMs) {
+  if (Date.now() > compileDeadlineAfterVerification(opts.absoluteToolDir, opts.deadlineMs)) {
     return {
       success: false,
       outcome: 'timeout',
@@ -739,8 +787,59 @@ async function driveJsonl(
   };
 }
 
+export function collectDescendantPids(
+  rows: Array<{ pid: number; ppid: number }>,
+  rootPid: number,
+): number[] {
+  const childrenByParent = new Map<number, number[]>();
+  for (const row of rows) {
+    const children = childrenByParent.get(row.ppid) ?? [];
+    children.push(row.pid);
+    childrenByParent.set(row.ppid, children);
+  }
+  const descendants: number[] = [];
+  const visit = (pid: number): void => {
+    for (const childPid of childrenByParent.get(pid) ?? []) {
+      visit(childPid);
+      descendants.push(childPid);
+    }
+  };
+  visit(rootPid);
+  return descendants;
+}
+
+function liveDescendantPids(rootPid: number): number[] {
+  const ps = spawnSync('ps', ['-axo', 'pid=,ppid='], { encoding: 'utf8' });
+  if (ps.status !== 0 || typeof ps.stdout !== 'string') return [];
+  const rows = ps.stdout
+    .split('\n')
+    .map((line) => line.trim().split(/\s+/).map(Number))
+    .filter((pair): pair is [number, number] => pair.length === 2 && pair.every(Number.isFinite))
+    .map(([pid, ppid]) => ({ pid, ppid }));
+  return collectDescendantPids(rows, rootPid);
+}
+
+function signalPidOrGroup(pid: number, signal: NodeJS.Signals): void {
+  try {
+    process.kill(-pid, signal);
+    return;
+  } catch {
+    // The descendant may not lead its own group. Fall back to the process itself.
+  }
+  try {
+    process.kill(pid, signal);
+  } catch {
+    // already gone
+  }
+}
+
 function signalCodexProcessTree(child: ChildProcess, signal: NodeJS.Signals): void {
   if (child.pid !== undefined) {
+    // Codex-launched MCP servers may create their own process groups. Killing only
+    // the detached Codex group leaves those grandchildren running after Ctrl-C,
+    // where they can keep compiling and issuing live calls. Snapshot and terminate
+    // descendants deepest-first while the parent relationship still exists.
+    for (const pid of liveDescendantPids(child.pid)) signalPidOrGroup(pid, signal);
     try {
       process.kill(-child.pid, signal);
       return;