@jini-ai/daemon 0.6.8 → 0.6.10

package/dist/agent-executor/events.js

@@ -1,5 +1,8 @@
+import { createToolResultDiagnosticProjection, projectDiagnosticFrame } from '../tool-result-diagnostics.js';
+import { appendSerialTask } from "@jini-ai/core/primitives";
 import { randomUUID } from 'node:crypto';
 import { createModelReceiptTracker } from './model-receipts.js';
+import { observeRunOutput } from './run-output.js';
 import { messageContentWithImages } from '../attachment-content.js';
 import { redactSecrets, } from '@jini-ai/core';
 import { createClaudeStreamHandler, createCopilotStreamHandler, createJsonEventStreamHandler, createQoderStreamHandler, attachAcpSession, attachPiRpcSession, } from '@jini-ai/agent-runtime';
@@ -7,7 +10,7 @@ import { collectProcessTreePids, listProcessSnapshots, stopProcesses, } from '@j
 import { classifyRunCloseStatus, } from '../close-status.js';
 import { resolveContinuationTransport, } from '../continuation/continuation-transport.js';
 import { resultContent, } from '../delegated-tool-bridge.js';
-import { extractResultMedia, } from '../tool-result-media.js';
+import { projectToolResultEvent, } from '../tool-result-media.js';
 import { translateAgentRuntimeEvent, translateAcpError, applyAgentTranslationSideEffects, } from './event-translation.js';
 import { errorMessage, isRecord, } from './values.js';
 import { MCP_BRIDGE_UNAVAILABLE, unavailableJiniBridgeStatus, bridgeUnavailableMessage, } from './mcp-bridge.js';
@@ -61,6 +64,11 @@ async function terminateChildTree(deps, child) {
     const pids = deps.collectProcessTreePids({ processes, rootPids: [child.pid] });
     await deps.stopProcesses({ pids });
 }
+// A late emit can race a terminal run. Keep later events/cleanup ordered even after failure;
+// lifecycle exceptions can contain provider text, so report only this fixed diagnostic.
+function reportDroppedEmit() {
+    console.warn('[daemon] Queued lifecycle event could not be delivered.');
+}
 /** Default sink when a host does not supply `onCleanupFailure`: still observable, never silent. Redacted per SEC-007 (a spawn/permission error can embed paths/host detail). */
 export function defaultCleanupFailureSink(context) {
     // eslint-disable-next-line no-console
@@ -195,6 +203,35 @@ export const DEFAULT_BUFFERED_STDOUT_MAX_BYTES = 8 * 1024 * 1024;
 function bufferedStdoutTruncationNotice(droppedBytes, maxBytes) {
     return `\n[jini] agent stdout truncated: ${droppedBytes} byte(s) dropped after the ${maxBytes}-byte buffer limit was reached.\n`;
 }
+/** Keeps exact-byte auditing separate from retained diagnostics on the run's existing FIFO.
+ * Projection retains at most one bounded frame; ordinary stdout keeps its legacy byte journal. */
+function createStdoutDiagnostics({ ctx, enqueueEmit }, _options = {}) {
+    const { runId, lifecycle, journal, stdoutJournalBlobs } = ctx;
+    const projection = ctx.delegatedResultCorrelation && ctx.streamFormat === 'claude-stream-json'
+        ? createToolResultDiagnosticProjection({}) : undefined;
+    function emit({ text }) {
+        if (text)
+            enqueueEmit(() => lifecycle.emit({ runId, input: { event: 'stdout', data: { chunk: text } } }));
+    }
+    return {
+        record({ chunk, text }) {
+            if (!journal)
+                return;
+            if (projection && stdoutJournalBlobs) {
+                enqueueEmit(() => stdoutJournalBlobs.record({ runId, chunk }));
+            }
+            else {
+                enqueueEmit(() => journal.record({ runId, entry: receivedJournalEntry('stdout', text) }));
+            }
+        },
+        feed({ text }) {
+            emit({ text: projection ? projection.feed({ chunk: text }) : text });
+        },
+        flush() {
+            emit({ text: projection?.flush({}) ?? '' });
+        },
+    };
+}
 /**
  * Wires one spawned child's full observable lifecycle: raw stdout/stderr
  * forwarding, structured stream-parser dispatch (translated via
@@ -257,6 +294,8 @@ function bufferedStdoutTruncationNotice(droppedBytes, maxBytes) {
  */
 export function wireChildLifecycle(ctx) {
     const { runId, def, streamFormat, child, lifecycle, journal, continuation, classifyFailure } = ctx;
+    const stdoutDiagnostics = createStdoutDiagnostics({ ctx, enqueueEmit });
+    const output = observeRunOutput({ lifecycle, runId, agentName: def.name }, { plainStdout: streamFormat === 'plain' });
     const modelReceipt = createModelReceiptTracker(ctx.startingModel, ctx.modelCatalog?.models);
     let stdinClosed = false;
     let cancelRequested = false;
@@ -324,16 +363,7 @@ export function wireChildLifecycle(ctx) {
     /** Bytes the ceiling refused, reported verbatim on flush so truncation is never silent. */
     let droppedStdoutBytes = 0;
     function enqueueEmit(task) {
-        emitQueue = emitQueue.then(async () => {
-            try {
-                await task();
-            }
-            catch {
-                // A single emit failing (e.g. a race against an already-terminal
-                // run) must not block delivery of subsequently queued events —
-                // see this function's own doc.
-            }
-        });
+        emitQueue = appendSerialTask({ previous: emitQueue, task, onError: reportDroppedEmit });
     }
     if (ctx.startingModel)
         enqueueEmit(() => lifecycle.emit({ runId, input: { event: 'agent', data: { type: 'status', label: 'starting_model', model: ctx.startingModel } } }));
@@ -398,8 +428,10 @@ export function wireChildLifecycle(ctx) {
         controlScanBuffer += text;
         if (!text.includes('\n'))
             return;
-        const lines = controlScanBuffer.split('\n');
-        controlScanBuffer = lines.pop() ?? '';
+        // `text` holds a newline, so the buffer does: split off the complete lines, keep the partial tail.
+        const lastNewline = controlScanBuffer.lastIndexOf('\n');
+        const lines = controlScanBuffer.slice(0, lastNewline).split('\n');
+        controlScanBuffer = controlScanBuffer.slice(lastNewline + 1);
         for (const line of lines) {
             // Both checked: either word can also appear inside the other kind of line's text.
             if (line.includes('"control_response"'))
@@ -477,11 +509,8 @@ export function wireChildLifecycle(ctx) {
             const run = { id: runId };
             let content;
             let isError;
-            // Same extraction `delegated-tool-bridge.ts`'s `execute()` runs, kept consistent per
-            // `resultContent`'s own doc ("both callers share one mapping"). This path never ran
-            // `splitToolResultSurfaces` (it has no `mcp-ui` withhold-from-model concept — the flattened
-            // `content` below already carries the whole raw output, a pre-existing, unrelated gap), so
-            // there is no `remainder` to thread back in — only the extracted blocks are used here.
+            // Event projection removes pixels only from saved content; stdin keeps the original.
+            let eventContent;
             let media = [];
             // Suspend the slow-run watchdog for the duration of this daemon-awaited execution: the daemon
             // knows exactly why the run is quiet here (it dispatched the tool itself and is waiting on it),
@@ -493,11 +522,14 @@ export function wireChildLifecycle(ctx) {
             try {
                 const result = await continuation.toolExecutor.execute({ principal: continuation.principal, run: run, toolId: toolUse.name, input: toolUse.input });
                 content = resultContent({ result: result });
-                isError = result.status !== 'completed';
-                media = extractResultMedia({ output: result.output }).media;
+                const projection = projectToolResultEvent({ result });
+                eventContent = projection.content;
+                isError = projection.isError === true;
+                media = projection.media ?? [];
             }
             catch (error) {
                 content = errorMessage(error);
+                eventContent = content;
                 isError = true;
             }
             finally {
@@ -508,7 +540,7 @@ export function wireChildLifecycle(ctx) {
                     data: {
                         type: 'tool_result',
                         toolUseId: toolUse.id,
-                        content,
+                        content: eventContent,
                         ...(isError ? { isError: true } : {}),
                         ...(media.length > 0 ? { media } : {}),
                     },
@@ -526,25 +558,22 @@ export function wireChildLifecycle(ctx) {
                 const receipt = modelReceipt(translation.payload);
                 if (receipt)
                     enqueueEmit(() => lifecycle.emit({ runId, input: { event: 'agent', data: receipt } }));
-                if (translation.sessionId !== undefined)
-                    capturedSessionId = translation.sessionId;
-                if (!bridgeChecked && translation.payload.type === 'status' && translation.payload.label === 'initializing') {
-                    bridgeChecked = true;
-                    const bridgeStatus = unavailableJiniBridgeStatus({ rawEvent: rawEvent });
-                    if (bridgeStatus !== undefined) {
-                        stopForUnavailableBridge(translation.payload, bridgeStatus);
-                        return;
-                    }
-                }
-                if (translation.payload.type === 'tool_use') {
-                    pendingToolUse = { id: translation.payload.id, name: translation.payload.name, input: translation.payload.input };
-                    toolCallSeen = true;
-                }
-                else if ((translation.payload.type === 'text_delta' || translation.payload.type === 'thinking_delta') &&
-                    translation.payload.delta.length > 0) {
-                    userVisibleOutputSeen = true;
-                }
-                enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'agent', data: statusWithChildIdentity({ payload: translation.payload, childPid: ctx.child.pid }, {}) } }));
+                applyAgentTranslationSideEffects({ payload: translation.payload, sessionId: translation.sessionId, sink: {
+                        onSessionId: ({ sessionId }) => { capturedSessionId = sessionId; },
+                        onToolCall: ({ toolUse }) => {
+                            // A tool signal always carries the tool_use variant (the sink hands it over narrowed);
+                            // retain its full input for continuation.
+                            pendingToolUse = { id: toolUse.id, name: toolUse.name, input: toolUse.input };
+                            toolCallSeen = true;
+                        },
+                        onUserVisibleOutput: () => { userVisibleOutputSeen = true; },
+                    } });
+                if (rejectUnavailableBridge({ payload: translation.payload, rawEvent }, {}))
+                    return;
+                enqueueEmit(() => {
+                    const payload = projectEcho({ payload: translation.payload, rawEvent }, {});
+                    return lifecycle.emit({ runId, input: { event: 'agent', data: statusWithChildIdentity({ payload, childPid: ctx.child.pid }, {}) } });
+                });
             }
             else if (translation.kind === 'error') {
                 enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'error', data: translation.payload } }));
@@ -553,6 +582,28 @@ export function wireChildLifecycle(ctx) {
                 handleTurnEnd(translation.stopReason);
             }
         });
+    /** Verify against an already-saved call in this run; unverified metadata preserves all output. */
+    function projectEcho({ payload, rawEvent }, _options = {}) {
+        if (!ctx.delegatedResultCorrelation)
+            return payload;
+        if (payload.type === 'raw')
+            return { ...payload, line: projectDiagnosticFrame({ line: payload.line }) };
+        if (payload.type !== 'tool_result' || !payload.delegatedToolUseId || !Array.isArray(rawEvent.delegatedResultContent))
+            return payload;
+        const matches = ctx.delegatedResultCorrelation.matches({ runId, toolUseId: payload.delegatedToolUseId, content: rawEvent.delegatedResultContent, isError: payload.isError === true });
+        return matches ? { ...payload, content: `Result shown by delegated call ${payload.delegatedToolUseId}.` } : payload;
+    }
+    function rejectUnavailableBridge({ payload, rawEvent }, _options = {}) {
+        if (!bridgeChecked && payload.type === 'status' && payload.label === 'initializing') {
+            bridgeChecked = true;
+            const bridgeStatus = unavailableJiniBridgeStatus({ rawEvent });
+            if (bridgeStatus !== undefined) {
+                stopForUnavailableBridge(payload, bridgeStatus);
+                return true;
+            }
+        }
+        return false;
+    }
     /**
      * Ends a run whose CLI started without the `jini` bridge: emits the init status and a
      * {@link MCP_BRIDGE_UNAVAILABLE} error, then stops the child's process tree before the model can
@@ -610,8 +661,7 @@ export function wireChildLifecycle(ctx) {
     }
     child.stdout?.on('data', (chunk) => {
         const text = chunk.toString('utf8');
-        if (journal)
-            enqueueEmit(() => journal.record({ runId: runId, entry: receivedJournalEntry('stdout', text) }));
+        stdoutDiagnostics.record({ chunk, text });
         if (streamFormat === 'plain') {
             if (text.length > 0)
                 userVisibleOutputSeen = true;
@@ -637,7 +687,7 @@ export function wireChildLifecycle(ctx) {
             enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'agent', data: { type: 'text_delta', delta: text } } }));
             return;
         }
-        enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'stdout', data: { chunk: text } } }));
+        stdoutDiagnostics.feed({ text });
         // Before the parser: an ack and the aborted turn's end can share a chunk, and the turn end must
         // see that no interrupt is still waiting (see `stdinHoldAfterTurnEnd`); a background task
         // starting and the turn's end can share one too.
@@ -680,6 +730,7 @@ export function wireChildLifecycle(ctx) {
             // driver dispatches to. `streamHandler` is null for `'plain'` (no
             // parser, hence nothing to flush) — `?.` skips it cleanly.
             streamHandler?.flush();
+            stdoutDiagnostics.flush();
             // Queued before `await emitQueue` so the flushed text is durably appended ahead of
             // `finish()`'s `'end'` event, exactly like every live-path emit already is.
             flushBufferedStdout();
@@ -693,20 +744,23 @@ export function wireChildLifecycle(ctx) {
             // Both of the next two steps are guarded: neither a failed cleanup nor a rejecting host
             // classifier may prevent the terminal transition below — see each helper's own doc.
             await cleanupStagedFilesSafely(ctx);
-            const status = bridgeUnavailable ? 'failed' : classifyRunCloseStatus({ cancelRequested, code }, { signal });
-            // A bridge failure is not resumable: resuming would start the same CLI with the same bridge.
-            const resumable = status === 'failed' && !bridgeUnavailable && classifyFailure !== undefined
-                ? await classifyFailureSafely(ctx, classifyFailure, {
-                    runId,
-                    agentId: def.id,
-                    code,
-                    signal: signal ?? null,
-                    sideEffects: { userVisibleOutputSeen, toolCallSeen },
-                })
-                : false;
+            const status = await output.settle({ status: bridgeUnavailable ? 'failed' : classifyRunCloseStatus({ cancelRequested, code }, { signal }) });
+            const resumable = await resolveChildResumable({ status, code, signal }, {});
             await lifecycle.finish({ runId, status, code, signal: signal ?? null, resumable }, { ...(capturedSessionId !== undefined ? { sessionRef: capturedSessionId } : {}) });
         })();
     });
+    async function resolveChildResumable({ status, code, signal }, _options = {}) {
+        // A bridge failure is not resumable: resuming would start the same CLI with the same bridge.
+        return status === 'failed' && !bridgeUnavailable && classifyFailure !== undefined
+            ? await classifyFailureSafely(ctx, classifyFailure, {
+                runId,
+                agentId: def.id,
+                code,
+                signal: signal ?? null,
+                sideEffects: { userVisibleOutputSeen, toolCallSeen },
+            })
+            : false;
+    }
     /**
      * A mid-run message: first an `interrupt` control request on the still-open stdin, so the agent
      * stops generating (or abandons the tool it is running) at once instead of finishing its whole
@@ -718,8 +772,10 @@ export function wireChildLifecycle(ctx) {
      * `turn_end` has closed stdin, or the process exits before the ack, there is no session left to
      * reach — `'not-running'`. Between turns, while stdin is held only for background tasks, there is
      * no generation to stop: the line is written at once and starts the next turn.
+     * Host-prepared images use the same content blocks as the initial stdin turn; no file tools
+     * or new directory grants are needed to see these pixels.
      */
-    async function sendUserMessage(text) {
+    async function sendUserMessage(text, images = []) {
         if (!acceptsMidRunUserMessages({ def: def }))
             return 'unsupported';
         const stdin = child.stdin;
@@ -727,7 +783,7 @@ export function wireChildLifecycle(ctx) {
             return 'not-running';
         if (heldForBackgroundTasks) {
             heldForBackgroundTasks = false;
-            writeUserMessage(stdin, text);
+            writeUserMessage(stdin, text, images);
             return 'delivered';
         }
         const requestId = `jini-interrupt-${randomUUID()}`;
@@ -753,12 +809,12 @@ export function wireChildLifecycle(ctx) {
         pendingInterruptAcks.delete(requestId);
         if (!processAlive || stdinClosed)
             return 'not-running';
-        writeUserMessage(stdin, text);
+        writeUserMessage(stdin, text, images);
         return 'delivered';
     }
-    /** Writes a mid-run message as the next user line, journals it, and emits its `user_message` run event. */
-    function writeUserMessage(stdin, text) {
-        stdin.write(`${JSON.stringify(streamJsonUserMessage({ content: [{ type: 'text', text: text }] }))}\n`, 'utf8');
+    /** Writes a complete mid-run turn using the idle image encoder; journals text without base64. */
+    function writeUserMessage(stdin, text, images) {
+        stdin.write(`${JSON.stringify(streamJsonUserMessage({ content: messageContentWithImages({ prompt: text, images }, {}) }))}\n`, 'utf8');
         if (journal)
             enqueueEmit(() => journal.record({ runId: runId, entry: sentJournalEntry(text) }));
         enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'agent', data: { type: 'user_message', id: randomUUID(), text: text } } }));
@@ -815,6 +871,22 @@ function backgroundTaskListLength({ line }) {
 function streamJsonUserMessage({ content }) {
     return { type: 'user', message: { role: 'user', content: content } };
 }
+/** Preserve ACP's distinction between absent fields and explicitly supplied empty values. */
+function acpSessionOptions({ ctx }, _options = {}) {
+    return {
+        cwd: ctx.cwd,
+        ...(ctx.cliParity ? { cliParity: true, stageTimeoutMs: 0 } : {}),
+        ...(ctx.permissionMode !== undefined ? { permissionMode: ctx.permissionMode } : {}),
+        ...(ctx.model !== undefined ? { model: ctx.model } : {}),
+        ...(ctx.imagePaths.length > 0 ? { imagePaths: [...ctx.imagePaths] } : {}),
+        ...(ctx.envFormat !== undefined ? { envFormat: ctx.envFormat } : {}),
+        // Spread-when-present rather than always: passing `mcpServers: []` is not the same as passing
+        // nothing for every downstream ACP agent, and "no bridge configured" must stay byte-identical
+        // to before this field existed.
+        ...(ctx.mcpServers !== undefined && ctx.mcpServers.length > 0 ? { mcpServers: [...ctx.mcpServers] } : {}),
+        ...(ctx.onPermissionRequest !== undefined ? { onPermissionRequest: ctx.onPermissionRequest } : {}),
+    };
+}
 /**
  * Wires an ACP child to a run. Unlike the JSON-stream path, ACP owns the
  * prompt protocol and reports its parsed events through `attachAcpSession`'s
@@ -827,6 +899,7 @@ function streamJsonUserMessage({ content }) {
 function wireAcpLifecycle(ctx) {
     const modelReceipt = createModelReceiptTracker(ctx.model, ctx.modelCatalog?.models);
     const { runId, agentId, child, lifecycle, journal, classifyFailure } = ctx;
+    const output = observeRunOutput({ lifecycle, runId, agentName: agentId });
     let cancelRequested = false;
     let emitQueue = Promise.resolve();
     // Gap 5 (session resume) — see wireChildLifecycle's identical local for the full rationale.
@@ -835,15 +908,7 @@ function wireAcpLifecycle(ctx) {
     let userVisibleOutputSeen = false;
     let toolCallSeen = false;
     function enqueueEmit(task) {
-        emitQueue = emitQueue.then(async () => {
-            try {
-                await task();
-            }
-            catch {
-                // A late event racing a terminal lifecycle is intentionally dropped;
-                // it must not prevent subsequent queued cleanup from running.
-            }
-        });
+        emitQueue = appendSerialTask({ previous: emitQueue, task, onError: reportDroppedEmit });
     }
     if (ctx.model)
         enqueueEmit(() => lifecycle.emit({ runId, input: { event: 'agent', data: { type: 'status', label: 'starting_model', model: ctx.model } } }));
@@ -873,7 +938,7 @@ function wireAcpLifecycle(ctx) {
             unsubscribeCancel();
             // Guarded for the same reasons as the child-driven handler above.
             await cleanupStagedFilesSafely(ctx);
-            const status = cancelRequested ? 'cancelled' : controller?.completedSuccessfully() ? 'succeeded' : 'failed';
+            const status = await output.settle({ status: cancelRequested ? 'cancelled' : controller?.completedSuccessfully() ? 'succeeded' : 'failed' });
             const resumable = status === 'failed' && classifyFailure !== undefined
                 ? await classifyFailureSafely(ctx, classifyFailure, {
                     runId,
@@ -908,11 +973,7 @@ function wireAcpLifecycle(ctx) {
             if (event === 'error') {
                 enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'error', data: translateAcpError(payload) } }));
             }
-        } }, { cwd: ctx.cwd, ...(ctx.permissionMode !== undefined ? { permissionMode: ctx.permissionMode } : {}), ...(ctx.model !== undefined ? { model: ctx.model } : {}), ...(ctx.imagePaths.length > 0 ? { imagePaths: [...ctx.imagePaths] } : {}), ...(ctx.envFormat !== undefined ? { envFormat: ctx.envFormat } : {}),
-        // Spread-when-present rather than always: passing `mcpServers: []` is not the same as passing
-        // nothing for every downstream ACP agent, and "no bridge configured" must stay byte-identical
-        // to before this field existed.
-        ...(ctx.mcpServers !== undefined && ctx.mcpServers.length > 0 ? { mcpServers: [...ctx.mcpServers] } : {}), ...(ctx.onPermissionRequest !== undefined ? { onPermissionRequest: ctx.onPermissionRequest } : {}) });
+        } }, acpSessionOptions({ ctx }, {}));
     return controller;
 }
 /**
@@ -937,6 +998,7 @@ function wireAcpLifecycle(ctx) {
 function wirePiRpcLifecycle(ctx) {
     const modelReceipt = createModelReceiptTracker(ctx.model, ctx.modelCatalog?.models);
     const { runId, agentId, child, lifecycle, journal, classifyFailure } = ctx;
+    const output = observeRunOutput({ lifecycle, runId, agentName: agentId });
     let cancelRequested = false;
     let emitQueue = Promise.resolve();
     // Gap 5 (session resume) — see wireChildLifecycle's identical local for the full rationale.
@@ -945,15 +1007,7 @@ function wirePiRpcLifecycle(ctx) {
     let userVisibleOutputSeen = false;
     let toolCallSeen = false;
     function enqueueEmit(task) {
-        emitQueue = emitQueue.then(async () => {
-            try {
-                await task();
-            }
-            catch {
-                // A late event racing a terminal lifecycle is intentionally dropped;
-                // it must not prevent subsequent queued cleanup from running.
-            }
-        });
+        emitQueue = appendSerialTask({ previous: emitQueue, task, onError: reportDroppedEmit });
     }
     if (ctx.model)
         enqueueEmit(() => lifecycle.emit({ runId, input: { event: 'agent', data: { type: 'status', label: 'starting_model', model: ctx.model } } }));
@@ -983,7 +1037,7 @@ function wirePiRpcLifecycle(ctx) {
             unsubscribeCancel();
             // Guarded for the same reasons as the child-driven handler above.
             await cleanupStagedFilesSafely(ctx);
-            const status = cancelRequested ? 'cancelled' : session?.hasFatalError() ? 'failed' : 'succeeded';
+            const status = await output.settle({ status: cancelRequested ? 'cancelled' : session?.hasFatalError() ? 'failed' : 'succeeded' });
             const resumable = status === 'failed' && classifyFailure !== undefined
                 ? await classifyFailureSafely(ctx, classifyFailure, {
                     runId,
@@ -1062,6 +1116,7 @@ export async function runAcpDispatch({ input, deps }) {
             prompt: input.prompt,
             cwd: input.cwd,
             permissionMode: input.permissionMode,
+            cliParity: input.cliParity,
             model: input.model,
             ...(input.modelCatalog ? { modelCatalog: input.modelCatalog } : {}),
             imagePaths: input.imagePaths,
@@ -1086,7 +1141,8 @@ export async function runAcpDispatch({ input, deps }) {
         // fired-and-forgotten (SEC-007: "await where lifecycle ordering allows it").
         await terminateChildTreeBestEffort({ listProcessSnapshots: deps.listProcessSnapshots, collectProcessTreePids: deps.collectProcessTreePids, stopProcesses: deps.stopProcesses }, input.child, input.runId, 'acp-attach-failure', deps.onCleanupFailure);
         await deps.releaseStagedResources();
-        await deps.failBeforeSpawn({ runId: input.runId, code: 'AGENT_SPAWN_FAILED', message: `AgentExecutor: could not attach ACP session for agent "${input.agentId}": ${errorMessage(err)}` });
+        // `failBeforeSpawn` always rejects (`Promise<never>`); returning it propagates that rejection.
+        return deps.failBeforeSpawn({ runId: input.runId, code: 'AGENT_SPAWN_FAILED', message: `AgentExecutor: could not attach ACP session for agent "${input.agentId}": ${errorMessage(err)}` });
     }
 }
 /** Phase 15 (pi-rpc branch): same discipline as {@link runAcpDispatch}, for the one `'pi-rpc'` def. */
@@ -1118,7 +1174,7 @@ export async function runPiRpcDispatch({ input, deps }) {
         // fire-and-forget (SEC-007).
         await terminateChildTreeBestEffort({ listProcessSnapshots: deps.listProcessSnapshots, collectProcessTreePids: deps.collectProcessTreePids, stopProcesses: deps.stopProcesses }, input.child, input.runId, 'pi-rpc-attach-failure', deps.onCleanupFailure);
         await deps.releaseStagedResources();
-        await deps.failBeforeSpawn({ runId: input.runId, code: 'AGENT_SPAWN_FAILED', message: `AgentExecutor: could not attach pi-rpc session for agent "${input.agentId}": ${errorMessage(err)}` });
+        return deps.failBeforeSpawn({ runId: input.runId, code: 'AGENT_SPAWN_FAILED', message: `AgentExecutor: could not attach pi-rpc session for agent "${input.agentId}": ${errorMessage(err)}` });
     }
 }
 //# sourceMappingURL=events.js.map

package/dist/agent-executor/launch.d.ts

@@ -189,9 +189,9 @@ export declare function computeRuntimeContext({ preparedPromptFile, preparedLogF
 /** Phase 9a: the def's `buildArgs` 4th argument. Historically omitted when every override was absent;
  * that let defs silently enable auto-approval. Always supply the validated restricted default now. Pure. */
 export declare function buildAgentBuildArgsOptions({ input, systemPromptOverlay }: {
-    readonly input: Pick<AgentExecutorRunInput, 'model' | 'reasoning' | 'permissionMode' | 'disallowedTools' | 'allowedTools' | 'settingSources' | 'settings'>;
+    readonly input: Pick<AgentExecutorRunInput, 'model' | 'reasoning' | 'permissionMode' | 'nativeToolAccess' | 'nativeCapabilities' | 'cliParity' | 'disallowedTools' | 'allowedTools' | 'settingSources' | 'settings' | 'chromeIntegration'>;
     readonly systemPromptOverlay: string | null | undefined;
-}): RuntimeBuildOptions | undefined;
+}): RuntimeBuildOptions;
 /**
  * **The single dispatch point from a computed system-prompt overlay to its delivery mechanism** —
  * see `RuntimeAgentDef.systemPromptDelivery`'s own doc for the declared shape. Pure and
@@ -290,6 +290,7 @@ export declare function buildRunArgs({ input, deps }: {
  * a defensive extra.
  * @param input.def - Only used for its `id`, in the failure message, and its `systemPromptDelivery` declaration.
  * @param input.overlay - The computed `PromptAugmenter.systemOverlay()` result for this run.
+ * @param deps.mkdtemp - Creates the run-scoped directory from a prefix; default a fresh `mkdtemp` under `os.tmpdir()`.
  * @complexity O(1) plus one directory creation and one file write.
  * @overallScore 100/100
  */
@@ -302,6 +303,7 @@ export declare function prepareSystemPromptOverlayFileIfNeeded({ input, deps }:
     readonly deps: {
         readonly releaseStagedResources: () => Promise<void>;
         readonly failBeforeSpawn: FailBeforeSpawn;
+        readonly mkdtemp?: (prefix: string) => Promise<string>;
     };
 }): Promise<PreparedSystemPromptOverlayFile | null>;
 /** Phase 11: post-`buildArgs` guard for argv-bound defs whose resolved binary is a Windows shim/.exe — a no-op off-Windows and for non-argv-bound defs. */
@@ -379,6 +381,6 @@ export declare function confirmChildSpawned({ input, deps }: {
  * @complexity `run()`'s own setup is O(1); steady-state cost is the chosen stream parser's.
  * @overallScore 100/100
  */
-export declare function createAgentExecutor(requiredArgs: Pick<CreateAgentExecutorOptions, "lifecycle">, optionalArgs?: Pick<CreateAgentExecutorOptions, "runtimeState" | "codexDisablePlugins" | "piGracefulShutdownMs" | "hostEnv" | "getAgentDef" | "resolveAgentLaunch" | "resolveModelForLaunch" | "ensureAgentCapabilities" | "applyAgentLaunchEnv" | "createCommandInvocation" | "spawn" | "probeMcpBridge" | "attachAcpSession" | "acpPermissionHandler" | "attachPiRpcSession" | "preparePromptFileForAgent" | "prepareAgentLogFile" | "listProcessSnapshots" | "collectProcessTreePids" | "stopProcesses" | "onCleanupFailure" | "journal" | "continuation" | "classifyFailure" | "mcpJsonInjection" | "claudeConfigDirIsolation" | "claudeConfigDirIsolationEnabled" | "bufferedStdoutMaxBytes" | "promptAugmenter">): AgentExecutor;
+export declare function createAgentExecutor(requiredArgs: Pick<CreateAgentExecutorOptions, "lifecycle">, optionalArgs?: Pick<CreateAgentExecutorOptions, "runtimeState" | "codexDisablePlugins" | "piGracefulShutdownMs" | "hostEnv" | "getAgentDef" | "resolveAgentLaunch" | "resolveModelForLaunch" | "ensureAgentCapabilities" | "applyAgentLaunchEnv" | "createCommandInvocation" | "spawn" | "probeMcpBridge" | "attachAcpSession" | "acpPermissionHandler" | "attachPiRpcSession" | "preparePromptFileForAgent" | "prepareAgentLogFile" | "listProcessSnapshots" | "collectProcessTreePids" | "stopProcesses" | "onCleanupFailure" | "journal" | "delegatedResultCorrelation" | "stdoutJournalBlobs" | "continuation" | "classifyFailure" | "mcpJsonInjection" | "claudeConfigDirIsolation" | "claudeConfigDirIsolationEnabled" | "bufferedStdoutMaxBytes" | "promptAugmenter">): AgentExecutor;
 export {};
 //# sourceMappingURL=launch.d.ts.map