@heretyc/subagent-mcp 2.8.2 → 2.8.5

package/dist/index.js

@@ -9,11 +9,12 @@ import { isAbsolute, basename, join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { pathToFileURL } from "url";
 import { buildCommand } from "./effort.js";
+import { createProviderDriver } from "./drivers.js";
 import { resolveExeFor } from "./platform.js";
 import { formatLocalIso, selectUnreported } from "./wait-helpers.js";
 import { computeStatusTransition, buildLivenessFields, } from "./status-helpers.js";
 import { extractFinalTurn } from "./output-helpers.js";
-import { consumeStreamChunk, flushStream, retainLastN, } from "./stream-helpers.js";
+import { consumeStreamChunk, flushStream, isTurnCompletedLine, retainLastN, } from "./stream-helpers.js";
 import { loadRoutingTable, buildCandidates, validatePresence, TASK_CATEGORIES, AUTO_HINT, SPLIT_HINT, } from "./routing.js";
 import { createDeadlockWindow } from "./deadlock.js";
 import { createRulesetGate, RULESET_HARD_FAIL_MSG, } from "./ruleset.js";
@@ -27,14 +28,13 @@ const deadlockWindow = createDeadlockWindow();
 // scoping. The env-check runs lazily at the FIRST launch_agent call; success
 // latches enabled/disabled for the process lifetime, failure never latches.
 const rulesetGate = createRulesetGate();
-// Post-spawn grace window (ms). A child that exits within this window after a
-// successful spawn never launched (codex installed but not logged in, expired
-// auth, instant crash) — the attempt loop silently advances instead of falsely
-// reporting success. ANY exit within the window counts, even code 0, EXCEPT a
-// codex child already finalized by its turn.completed marker (legitimate fast
-// completion). SUBAGENT_SPAWN_GRACE_MS overrides (non-negative int; 0 disables
-// detection = legacy spawn-event-only success) — a test seam; production never
-// sets it.
+// Post-spawn grace window (ms). A provider driver that exits within this window
+// after a successful driver start never launched (not logged in, expired auth, instant
+// crash) — the attempt loop silently advances instead of falsely reporting
+// success. ANY exit within the window counts, even code 0, EXCEPT a driver
+// already finalized by its turn-completed marker (legitimate fast completion).
+// SUBAGENT_SPAWN_GRACE_MS overrides (non-negative int; 0 disables only this
+// post-start early-exit detection) — a test seam; production never sets it.
 const SPAWN_GRACE_MS = (() => {
     const raw = process.env.SUBAGENT_SPAWN_GRACE_MS;
     if (raw === undefined || raw === "")
@@ -120,8 +120,8 @@ const ORCHESTRATION_INSTRUCTIONS = "BINDING IN BOTH MODES - SOLE CHANNEL: while
 const SUBAGENT_INSTRUCTIONS = "SUB-AGENT SESSION: you are a child process launched by subagent-mcp. Follow the parent prompt. Do not treat yourself as the orchestrator, do not re-trigger orchestration carryover, and do not launch further sub-agents unless the parent prompt explicitly assigns that.";
 const server = new McpServer({
     name: "subagent-mcp",
-    version: "2.3.9",
-    description: "Spawns the LOCALLY INSTALLED `claude` and `codex` CLI binaries as child processes. Does NOT call the Anthropic or OpenAI HTTP APIs directly (no API keys, no SDK) and there are no plans to — all model access is via the local CLIs.",
+    version: "2.8.5",
+    description: "Launches always-interactive local Claude and Codex sub-agent sessions. Claude uses the Claude Agent SDK over the local Claude Code executable; Codex uses `codex app-server` over stdio. The server does not call Anthropic or OpenAI HTTP APIs directly.",
 }, {
     instructions: process.env.SUBAGENT_MCP_SUBAGENT === "1"
         ? SUBAGENT_INSTRUCTIONS
@@ -140,7 +140,7 @@ function cleanupUcSettingsPath(ucSettingsPath) {
     catch { }
 }
 // Attempt to spawn + register a single candidate. Resolves to the agent_id on a
-// successful spawn, or a launch-time failure reason string (never throws/rejects).
+// successful driver start, or a launch-time failure reason string (never throws/rejects).
 //
 // spawn() failures (ENOENT/EACCES) are ASYNC: a missing/broken CLI emits the
 // child 'error' event AFTER spawn() returns, so a try/catch around spawn cannot
@@ -165,7 +165,7 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
     let buildResult;
     let cmd;
     try {
-        buildResult = buildCommand(candidate.provider, candidate.model, effortForBuild, prompt, agentCwd);
+        buildResult = buildCommand(candidate.provider, candidate.model, effortForBuild, agentCwd);
         cmd = resolveExe(candidate.provider);
     }
     catch (e) {
@@ -177,14 +177,17 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
         cleanupUcSettingsPath(buildResult.ucSettingsPath);
         return { reason: `CLI executable not found: ${cmd}` };
     }
-    const stdinMode = candidate.provider === "claude" ? "pipe" : "ignore";
-    let childProcess;
+    let driver;
     try {
-        childProcess = spawn(cmd, buildResult.args, {
+        driver = await createProviderDriver({
+            provider: candidate.provider,
+            command: cmd,
+            args: buildResult.args,
             cwd: agentCwd,
             env: { ...process.env, SUBAGENT_MCP_SUBAGENT: "1" },
-            stdio: [stdinMode, "pipe", "pipe"],
-            windowsHide: true,
+            model: candidate.model,
+            effort: candidate.effort,
+            ucSettingsPath: buildResult.ucSettingsPath,
         });
     }
     catch (error) {
@@ -192,6 +195,7 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
         cleanupUcSettingsPath(buildResult.ucSettingsPath);
         return { reason: error instanceof Error ? error.message : String(error) };
     }
+    const childProcess = driver.process;
     // Await the one-shot spawn/error race. The 'error' handler is attached BEFORE
     // we await so an async ENOENT cannot escape as an unhandled event.
     try {
@@ -208,7 +212,7 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
         // Launch-time failure (ENOENT/EACCES/etc.) — kill if somehow alive, clean up
         // the settings file, and report so the attempt loop advances.
         try {
-            childProcess.kill();
+            driver.kill();
         }
         catch { }
         cleanupUcSettingsPath(buildResult.ucSettingsPath);
@@ -229,6 +233,7 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
             : {}),
         status: "processing",
         process: childProcess,
+        driver,
         stdout: "",
         stderr: "",
         exitCode: null,
@@ -250,15 +255,6 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
         // item, so it does NOT refresh the heartbeat.
         agentState.stderr += `\n[process error] ${err instanceof Error ? err.message : String(err)}`;
     });
-    if (candidate.provider === "claude" && childProcess.stdin) {
-        // EPIPE if the child dies before draining the prompt (the grace-window
-        // early-exit class) — fold into stderr, never crash the server.
-        childProcess.stdin.on("error", (err) => {
-            agentState.stderr += `\n[stdin error] ${err instanceof Error ? err.message : String(err)}`;
-        });
-        childProcess.stdin.write(prompt);
-        childProcess.stdin.end();
-    }
     if (childProcess.stdout) {
         childProcess.stdout.on("data", (data) => {
             const chunk = data.toString();
@@ -278,17 +274,15 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
                 agentState.lastActivity = at;
                 agentState.visibleStream = retainLastN(agentState.visibleStream, items.map((it) => ({ ...it, at })), 3);
             }
-            // Codex emits JSONL; turn.completed signals task done — kill process. Scan
-            // COMPLETE lines only so a marker split across chunks is matched once
-            // fully assembled (never on a partial fragment).
-            if (agentState.provider === "codex" &&
-                lines.some((l) => l.includes('"type":"turn.completed"'))) {
+            // Provider completion events mark the current turn finished while the
+            // logical interactive session can remain available for later messages.
+            // Scan COMPLETE lines only so a marker split across chunks is matched
+            // once fully assembled (never on a partial fragment).
+            if (lines.some((l) => isTurnCompletedLine(agentState.provider, l))) {
                 agentState.turnCompleted = true;
                 agentState.status = "finished";
-                agentState.exitCode = 0;
                 if (agentState.exitedAt === null)
                     agentState.exitedAt = at;
-                childProcess.kill();
             }
         });
     }
@@ -309,11 +303,13 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
             for (const line of lines) {
                 agentState.stdout += line + "\n";
             }
-            // A turn.completed marker may arrive only in this final flush (no
-            // trailing newline) — the grace window's success exception needs it.
-            if (agentState.provider === "codex" &&
-                lines.some((l) => l.includes('"type":"turn.completed"'))) {
+            // A completion marker may arrive only in this final flush (no trailing
+            // newline) — the grace window's success exception needs it.
+            if (lines.some((l) => isTurnCompletedLine(agentState.provider, l))) {
                 agentState.turnCompleted = true;
+                agentState.status = "finished";
+                if (agentState.exitedAt === null)
+                    agentState.exitedAt = at;
             }
             if (items.length > 0) {
                 agentState.lastActivity = at;
@@ -332,7 +328,12 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
             return;
         }
         if (agentState.status === "finished") {
-            // Already finalized by turn.completed; exitedAt already stamped
+            // Already finalized by turn.completed; record that the interactive
+            // driver is no longer live so poll/list stop advertising alive=true.
+            if (agentState.exitCode === null)
+                agentState.exitCode = code !== null ? code : -1;
+            if (code !== 0)
+                agentState.status = "errored";
             return;
         }
         // Normal exit: set exit code and derive status
@@ -346,28 +347,51 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
     const closedAfterFlush = new Promise((resolve) => {
         childProcess.once("close", () => resolve());
     });
-    // Post-spawn grace window: a 'spawn' win alone is NOT success — a binary that
-    // spawns then dies immediately (codex installed but not logged in) must
-    // advance the attempt loop, not falsely conclude it. AgentState is fully
-    // wired and the claude prompt already written above, so a surviving child
-    // loses no stream output during the wait. Exception: a codex child already
-    // finalized by its turn.completed marker (dedicated turnCompleted flag — the
-    // SOLE in-window success exception; visibility-and-failover.md) completed
-    // the task legitimately fast — that is a success, never a launch failure.
-    // The close handler above cleans up a condemned child (uc settings, stream
-    // flush); the agent is simply never registered.
+    // POSIX seam: a child can die and deliver 'exit' DURING the startup write
+    // below (the write then rejects with EPIPE) — before the grace block attaches
+    // its own listener. Capture that exit here so the grace window still sees it
+    // and reports the exit code, instead of registering a corpse or surfacing the
+    // raw EPIPE as the failure reason.
+    let earlyExitInfo = null;
+    childProcess.once("exit", (code, signal) => {
+        earlyExitInfo = { code, signal };
+    });
+    // The startup write is best-effort. On POSIX, writing to an already-dead
+    // child's stdin rejects with EPIPE; that is NOT itself a launch failure.
+    // Record it and fall through to the grace window, which reports the real exit
+    // code (grace>0) or the legacy startup-write seam registers it (grace=0).
+    let startError = null;
+    try {
+        await driver.start(prompt);
+    }
+    catch (err) {
+        startError = err instanceof Error ? err : new Error(String(err));
+    }
+    // Post-spawn grace window: a 'spawn' win alone is NOT success — a provider
+    // driver that starts then dies immediately must advance the attempt loop, not
+    // falsely conclude it. AgentState is fully wired and the initial turn already
+    // submitted above, so a surviving driver loses no stream output during the
+    // wait. Exception: a driver already finalized by its turn-completion marker
+    // completed the task legitimately fast — that is a success, never a launch
+    // failure. The close handler above cleans up a condemned driver (uc settings,
+    // stream flush); the agent is simply never registered.
     if (SPAWN_GRACE_MS > 0) {
-        const earlyExit = await new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                childProcess.removeListener("exit", onExit);
-                resolve(null);
-            }, SPAWN_GRACE_MS);
-            const onExit = (code, signal) => {
-                clearTimeout(timer);
-                resolve({ code, signal });
-            };
-            childProcess.once("exit", onExit);
-        });
+        const earlyExit = earlyExitInfo ??
+            (await new Promise((resolve) => {
+                if (earlyExitInfo) {
+                    resolve(earlyExitInfo);
+                    return;
+                }
+                const timer = setTimeout(() => {
+                    childProcess.removeListener("exit", onExit);
+                    resolve(null);
+                }, SPAWN_GRACE_MS);
+                const onExit = (code, signal) => {
+                    clearTimeout(timer);
+                    resolve({ code, signal });
+                };
+                childProcess.once("exit", onExit);
+            }));
         if (earlyExit) {
             // 'exit' can be delivered before the final stdout chunk, so wait for
             // 'close' (streams drained, flush scanned) before deciding — a
@@ -381,6 +405,17 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
                 };
             }
         }
+        else if (startError && !agentState.turnCompleted) {
+            // Lived past the grace window but the startup write failed: the child is
+            // not accepting input, so advance the loop rather than register an agent
+            // that never received its prompt.
+            try {
+                driver.kill();
+            }
+            catch { }
+            cleanupUcSettings(agentState);
+            return { reason: startError.message };
+        }
     }
     agents.set(agentId, agentState);
     return { agentId };
@@ -394,7 +429,7 @@ function sameTriples(a, b) {
     return a.every((c, i) => c.provider === b[i].provider && c.model === b[i].model && c.effort === b[i].effort);
 }
 // Tool 1: launch_agent
-server.tool("launch_agent", "Spawn a sub-agent. AUTO MODE (mandatory first attempt unless an override is licensed below): pass only `prompt` + `task_category` and NO overrides; the server picks the best provider/model/effort for that category from its routing table, launches the top candidate, and silently falls back to the next-best on launch failure. `provider`/`model`/`effort` are overrides — licensed on 1st/2nd attempts ONLY when the task verifiably requires a specific capability; STATE that capability when overriding; if you pass `model` you must also pass `provider`, and if you pass `effort` you must pass both `provider` and `model`. SOLE CHANNEL: while this server is connected this tool is the ONLY sanctioned way to spawn sub-agents, in BOTH orchestration states — harness-native Task/Agent tools are FORBIDDEN for sub-agent launches. PROMPT RULE: the FIRST line of every `prompt` MUST be \"<this is a request from a parent process>\" (sub-agent self-identification). Unsure which task_category fits? Don't submit one amorphous task — SPLIT into atomic steps that each map to a single category, one agent per step. ultracode effort is Opus-4.8+ only (induced via a temp `--settings {\"ultracode\":true}` file; the CLI rejects `--effort ultracode`). Each sub-agent is a separate claude/codex CLI child that does NOT inherit this session's MCP servers; children run with env SUBAGENT_MCP_SUBAGENT=1 so the orchestration hooks skip them (they are not orchestrators and don't re-trigger carryover). Launch returns status `processing` (alive); a later `stalled` is alive-but-quiet (thinking or awaiting a temp-file handoff), NOT dead — wait or re-poll, don't kill (see poll_agent). DEADLOCK RULE: you MUST ALWAYS set `deadlock=true` when 2 launch attempts for the SAME atomic task have already failed or been unsatisfactory (the 3rd attempt onward; re-wording or re-splitting the prompt does NOT make it a different task), and NEVER otherwise — from the 3rd attempt deadlock outranks any capability override: drop provider/model/effort.", {
+server.tool("launch_agent", "Spawn a sub-agent session. AUTO MODE (mandatory first attempt unless an override is licensed below): pass only `prompt` + `task_category` and NO overrides; the server picks the best provider/model/effort for that category from its routing table, launches the top candidate, and silently falls back to the next-best on launch failure. `provider`/`model`/`effort` are overrides — licensed on 1st/2nd attempts ONLY when the task verifiably requires a specific capability; STATE that capability when overriding; if you pass `model` you must also pass `provider`, and if you pass `effort` you must pass both `provider` and `model`. SOLE CHANNEL: while this server is connected this tool is the ONLY sanctioned way to spawn sub-agents, in BOTH orchestration states — harness-native Task/Agent tools are FORBIDDEN for sub-agent launches. PROMPT RULE: the FIRST line of every `prompt` MUST be \"<this is a request from a parent process>\" (sub-agent self-identification). Unsure which task_category fits? Don't submit one amorphous task — SPLIT into atomic steps that each map to a single category, one agent per step. ultracode effort is Opus 4.8+ only. Claude uses a Claude Agent SDK logical session over the local Claude executable; Codex uses a `codex app-server` child. Children run with env SUBAGENT_MCP_SUBAGENT=1 so the orchestration hooks skip them (they are not orchestrators and don't re-trigger carryover). Launch returns status `processing` (alive); a later `stalled` is alive-but-quiet (thinking or awaiting a temp-file handoff), NOT dead — wait or re-poll, don't kill (see poll_agent). DEADLOCK RULE: you MUST ALWAYS set `deadlock=true` when 2 launch attempts for the SAME atomic task have already failed or been unsatisfactory (the 3rd attempt onward; re-wording or re-splitting the prompt does NOT make it a different task), and NEVER otherwise — from the 3rd attempt deadlock outranks any capability override: drop provider/model/effort.", {
     task_category: z.enum(TASK_CATEGORIES).describe(TASK_CATEGORY_GLOSS),
     prompt: z.string().min(1),
     provider: z.enum(["claude", "codex"]).optional(),
@@ -491,7 +526,7 @@ server.tool("launch_agent", "Spawn a sub-agent. AUTO MODE (mandatory first attem
         }
         candidates = applied.candidates;
     }
-    // 6. Attempt loop: best→worst. Register on first successful spawn; silently
+    // 6. Attempt loop: best→worst. Register on first successful driver start; silently
     //    advance on launch-time failure. Sub-agent task outcome is NEVER a trigger.
     const skipped = [];
     for (const candidate of candidates) {
@@ -608,7 +643,7 @@ server.tool("poll_agent", "Get an agent's current status and output. Status `pro
     };
 });
 // Tool 3: kill_agent
-server.tool("kill_agent", "Terminate a live agent (status `processing` or `stalled`) by immediately force-killing its managed process tree. No-op for already-terminal agents.", {
+server.tool("kill_agent", "Terminate a live agent/session (status `processing`, `stalled`, or turn-finished but still interactive) by immediately force-killing its managed driver. No-op for already-terminal closed agents.", {
     agent_id: z.string(),
 }, async (params) => {
     const agent = agents.get(params.agent_id);
@@ -623,9 +658,11 @@ server.tool("kill_agent", "Terminate a live agent (status `processing` or `stall
             isError: true,
         };
     }
-    // Kill applies to ALL live states (processing OR stalled). A terminal agent
-    // (finished/errored/stopped) is a no-op.
-    const isLive = agent.status === "processing" || agent.status === "stalled";
+    // Kill applies to ALL live driver states (processing, stalled, or finished
+    // current turn with an open interactive session). Closed terminal agents are
+    // a no-op.
+    const isLive = (agent.status === "processing" || agent.status === "stalled" || agent.status === "finished") &&
+        !agent.driver.closed;
     if (!isLive) {
         return {
             content: [
@@ -645,6 +682,7 @@ server.tool("kill_agent", "Terminate a live agent (status `processing` or `stall
         // grace period. On Windows, taskkill /t /f tears down the whole tree; on
         // POSIX, SIGKILL the process (close handler records the real exit code).
         agent.status = "stopped";
+        agent.driver.kill();
         if (isWindows && agent.process.pid) {
             spawn("taskkill", ["/pid", String(agent.process.pid), "/t", "/f"], {
                 windowsHide: true,
@@ -683,7 +721,7 @@ server.tool("kill_agent", "Terminate a live agent (status `processing` or `stall
     }
 });
 // Tool 4: send_message
-server.tool("send_message", "Send a message to a running agent's stdin", {
+server.tool("send_message", "Enqueue a user message for an open interactive agent session. Observe output with poll_agent or wait.", {
     agent_id: z.string(),
     message: z.string().min(1),
 }, async (params) => {
@@ -699,7 +737,8 @@ server.tool("send_message", "Send a message to a running agent's stdin", {
             isError: true,
         };
     }
-    const isLive = agent.status === "processing" || agent.status === "stalled";
+    const isLive = (agent.status === "processing" || agent.status === "stalled" || agent.status === "finished") &&
+        !agent.driver.closed;
     if (!isLive) {
         return {
             content: [
@@ -711,20 +750,15 @@ server.tool("send_message", "Send a message to a running agent's stdin", {
             isError: true,
         };
     }
-    if (!agent.process.stdin) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error: Agent stdin is not available`,
-                },
-            ],
-            isError: true,
-        };
-    }
     try {
-        agent.process.stdin.write(params.message + "\n");
-        agent.lastActivity = Date.now();
+        await agent.driver.send(params.message);
+        const now = Date.now();
+        agent.status = "processing";
+        agent.exitCode = null;
+        agent.exitedAt = null;
+        agent.waitReported = false;
+        agent.turnCompleted = false;
+        agent.lastActivity = now;
         return {
             content: [
                 {
@@ -732,7 +766,7 @@ server.tool("send_message", "Send a message to a running agent's stdin", {
                     text: JSON.stringify({
                         agent_id: agent.id,
                         status: "sent",
-                        message: "Message written to agent stdin",
+                        message: "Message accepted by provider driver",
                     }),
                 },
             ],
@@ -781,7 +815,7 @@ server.tool("list_agents", "List all agents with token-efficient core metrics (s
     };
 });
 // Tool 6: wait
-server.tool("wait", "Blocks until one or more sub-agents reach a terminal state (finished/errored/stopped), returning each one's exit code + local-time exit timestamp; or returns the live-job list after a 15-minute timeout. A `stalled` agent is still ALIVE and does NOT end the wait — only a terminal exit does. Pass `verbose: true` to add each finished agent's `final_output` (its final assistant turn, extracted from captured stdout).", {
+server.tool("wait", "Blocks until one or more sub-agents reach a reportable state (turn-finished, errored, or stopped), returning exit code when known + local-time timestamp; or returns the live-job list after a 15-minute timeout. A `finished` agent can still be alive and accept `send_message` when exit_code is null. A `stalled` agent is still ALIVE and does NOT end the wait. Pass `verbose: true` to add each finished agent's `final_output`.", {
     verbose: z.boolean().optional().default(false),
 }, async (params) => {
     const { verbose } = params;

package/dist/orchestration/hook-core.js

@@ -179,10 +179,10 @@ export function classifyClaim(owner_session, baseline_turn, current) {
  * temp dir cannot hold the state file would otherwise inject only the compact
  * rule carrier on every prompt and never refresh the LONG block.
  */
-function cadenceEmit(env, adapter, longFile, count, persisted) {
+function cadenceEmit(env, adapter, longFile, shortFile, count, persisted) {
     return !persisted || count % REMINDER_PERIOD === 0
         ? readDirective(env, longFile)
-        : readDirective(env, adapter.offTurnFile);
+        : readDirective(env, shortFile);
 }
 /**
  * Claim (or re-claim) an active marker for the current session and emit the
@@ -237,7 +237,7 @@ export function runHook(payload, env, adapter) {
         if (!marker.isActive(cwd)) {
             // OFF: no claim machinery — just the per-prompt reminder cadence.
             const r = reminder.advance(cwd, current);
-            return cadenceEmit(env, adapter, adapter.reminderOffFile, r.count, r.persisted);
+            return cadenceEmit(env, adapter, adapter.reminderOffFile, adapter.shortOffFile, r.count, r.persisted);
         }
         const m = marker.readMarker(cwd);
         const kind = classifyClaim(m.owner_session, m.baseline_turn, current);
@@ -247,7 +247,7 @@ export function runHook(payload, env, adapter) {
         }
         // SAME-SESSION: per-prompt reminder cadence, ON variant.
         const r = reminder.advance(cwd, current);
-        return cadenceEmit(env, adapter, adapter.reminderOnFile, r.count, r.persisted);
+        return cadenceEmit(env, adapter, adapter.reminderOnFile, adapter.shortOnFile, r.count, r.persisted);
     }
     catch {
         // Any failure -> inject nothing. Never crash or stall the host turn.

package/dist/output-helpers.js

@@ -4,13 +4,36 @@
 function rawFallback(stdout) {
     return (stdout || "").trim();
 }
-// Pull a final assistant-message string out of one parsed codex `--json` event.
-// Codex emits newline-delimited JSON; the final assistant message has appeared
-// under a few shapes across CLI versions, so match tolerantly.
+// Pull a final assistant-message string out of one parsed Codex event. Codex
+// app-server emits JSON-RPC notifications, while older CLI JSONL used top-level
+// event objects, so match tolerantly.
 function codexEventText(evt) {
     if (!evt || typeof evt !== "object")
         return null;
     const e = evt;
+    if (typeof e.method === "string" && e.params && typeof e.params === "object") {
+        const params = e.params;
+        if (e.method === "item/agentMessage/delta" && typeof params.delta === "string") {
+            return params.delta;
+        }
+        if (e.method === "item/completed" && params.item && typeof params.item === "object") {
+            const item = params.item;
+            if (item.type === "agentMessage" && typeof item.text === "string")
+                return item.text;
+        }
+        if (e.method === "turn/completed" && params.turn && typeof params.turn === "object") {
+            const turn = params.turn;
+            const items = Array.isArray(turn.items) ? turn.items : [];
+            for (let i = items.length - 1; i >= 0; i--) {
+                const item = items[i];
+                if (item && typeof item === "object") {
+                    const obj = item;
+                    if (obj.type === "agentMessage" && typeof obj.text === "string")
+                        return obj.text;
+                }
+            }
+        }
+    }
     // Shape A: { type: "agent_message", message: "..." }
     if (e.type === "agent_message" && typeof e.message === "string") {
         return e.message;