@jini-ai/daemon 0.6.15-rc.2 → 0.6.16

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.6.16
+
+### Minor Changes
+
+- Remove the GitHub Copilot CLI agent: its def, `createCopilotStreamHandler`/`CopilotStreamEvent`,
+  account model discovery and the `@github/copilot-sdk` optional peer, the MCP installer's `copilot`
+  slug, and its icon. A saved `copilot` agent id no longer resolves (`getAgentDef` returns `null`).
+  CopilotKit/AG-UI is unrelated and unchanged.
+
+  Drop peers no runtime entry loads: `express` from core and http-kit (type-only imports; type
+  consumers keep `@types/express`), `vue` from ui-kit, `react-dom` from vibecoding.
+
 ## 0.6.13
 
 ### Patch Changes

package/README.md

@@ -20,8 +20,18 @@ npm install @jini-ai/daemon
 
 `node-pty` is an **optional peer dependency** — the package boots and every other capability
 (run lifecycle, tool executor, agent executor, routines) works without it. Only
-`createTerminalSessionManager`'s real (non-test) `PtySpawn` — an actual interactive terminal/PTY
-spawn — needs `node-pty` installed; everything else has no native-addon dependency at all.
+the native adapter at `@jini-ai/daemon/terminal` needs `node-pty` installed.
+The default entry's session manager requires a host-supplied `terminalService` or `loadSpawnPty`:
+
+```ts
+import { createTerminalSessionManager } from '@jini-ai/daemon';
+import { loadRealSpawnPty } from '@jini-ai/daemon/terminal';
+
+const manager = createTerminalSessionManager({}, { loadSpawnPty: () => loadRealSpawnPty({}) });
+```
+
+With `@jini-ai/server`, pass that loader as `featureOptions.terminal.loadSpawnPty` to
+`composeJiniKernel`, or as `loadTerminalSpawnPty` to `createLocalNodeDaemon`.
 
 ## What you get
 
@@ -47,8 +57,8 @@ spawn — needs `node-pty` installed; everything else has no native-addon depend
   browser surface) and `createFrontendCapabilityRegistrations` (projects a frontend capability
   manifest into `ToolRegistry` registrations — the only door into it).
 - **Terminal sessions** — `createTerminalSessionManager`, `createTerminalToolRegistrations` — a
-  `node-pty`-backed session manager built on `@jini-ai/platform`'s generic ring-buffer engine, plus
-  session-token gating.
+  session manager built on `@jini-ai/platform`'s generic ring-buffer engine, plus session-token
+  gating. The optional native `loadRealSpawnPty` adapter lives at `@jini-ai/daemon/terminal`.
 - **Routines** — `RoutineService`, `createInMemoryRoutineStore` (`routines/`) — a DST-safe
   wall-clock scheduler plus CRUD + run-history store port.
 - **Run-orchestration helpers** (`run/`) — `runResultFromStatus`, `deriveRunErrorCode`,

package/dist/agent-executor/codex/home-config.js

@@ -103,7 +103,7 @@ function scanBareTomlKeyChar(scan, ch) {
         scan.current += ch;
 }
 // An inline or dotted root `mcp_servers` declaration, which the table scanner below cannot rewrite.
-const INLINE_MCP_SERVERS = /^\s*(?:mcp_servers|"mcp_servers"|'mcp_servers')\s*(?:\.|=)/;
+const INLINE_MCP_SERVERS = /^\s*(?:mcp_servers|"mcp_servers"|'mcp_servers')\s*[.=]/;
 // `[<key>]` optionally followed only by a `# comment`; `[[...]]` never matches (see below).
 const TOML_TABLE_HEADER = /^\s*\[([^[\]]+)\]\s*(#.*)?$/;
 /**
@@ -203,7 +203,8 @@ function stripExistingJiniMcpServerTable(existingRaw, optional = {}) {
  */
 export function buildCodexHomeConfigToml({ existingRaw, entry, inheritUserMcp = true, inheritUserSettings = true }, _optional = {}) {
     const base = stripExistingJiniMcpServerTable(existingRaw ?? '', { allServers: !inheritUserMcp, mcpOnly: !inheritUserSettings });
-    const separator = base.length === 0 ? '' : base.endsWith('\n') ? '\n' : '\n\n';
+    const blockBreak = base.endsWith('\n') ? '\n' : '\n\n';
+    const separator = base.length === 0 ? '' : blockBreak;
     return `${base}${separator}${buildCodexMcpServerToml({ entry: entry })}`;
 }
 //# sourceMappingURL=home-config.js.map

package/dist/agent-executor/codex/home-staging.js

@@ -5,6 +5,7 @@ import { errorMessage } from '../values.js';
 import { defaultReadMcpJsonFile, defaultWriteMcpJsonFile } from '../mcp-bridge.js';
 import { buildCodexHomeConfigToml } from './home-config.js';
 import { assertCodexHomeConfigParses, assertStagedHomeIsolated, CodexMcpIsolationError, codexIsolationRefusalMessage } from './isolation.js';
+import { omitKeys } from '../../core/omit-keys.js';
 /**
  * Where `'codex-toml'` reads the operator's REAL Codex config from, to seed a run's scratch copy —
  * never where it writes. Resolved against the daemon HOST process's own environment (`hostEnv`,
@@ -27,8 +28,7 @@ export function resolveSourceCodexHomeDir({ hostEnv }) {
  * `mcp_skill_dependencies.rs`), and `codex exec` is `codex_exec` without it.
  */
 export function withStagedCodexHome({ env, codexHomeDir }, _options = {}) {
-    const { CODEX_INTERNAL_ORIGINATOR_OVERRIDE: _originator, ...rest } = env;
-    return { ...rest, CODEX_HOME: codexHomeDir };
+    return { ...omitKeys(env, ['CODEX_INTERNAL_ORIGINATOR_OVERRIDE']), CODEX_HOME: codexHomeDir };
 }
 function defaultMkdtempCodexHome({ prefix }) {
     return fsPromises.mkdtemp(join(tmpdir(), prefix));

package/dist/agent-executor/codex/isolation.js

@@ -15,7 +15,8 @@ export function codexIsolationRefusalMessage(reason) {
  * known, and Codex could not load it either.
  * @complexity O(n) in the file length.
  */
-function parseCodexLayer(raw, path) {
+function parseCodexLayer({ raw, path }, _optional = {}) {
+    // Codex isolation is a default security boundary; its parser must ship with the daemon.
     try {
         return parse(raw);
     }
@@ -41,7 +42,7 @@ function assertTrustsNoProject(config, path) {
  */
 export function assertCodexHomeConfigParses({ raw, path }) {
     if (raw !== undefined)
-        parseCodexLayer(raw, path);
+        parseCodexLayer({ raw, path });
 }
 /**
  * The staged home config, parsed: it must declare no MCP server but the bridge and trust no
@@ -54,7 +55,7 @@ export function assertStagedHomeIsolated({ homeConfig, path }) {
     const refusal = new CodexMcpIsolationError(`${path} declares MCP servers that can't be removed safely.`);
     let config;
     try {
-        config = parse(homeConfig);
+        config = parseCodexLayer({ raw: homeConfig, path });
     }
     catch {
         throw refusal;

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

@@ -23,7 +23,7 @@ export type StreamHandler = {
     }): void;
     flush(): void;
 };
-export declare const SUPPORTED_STREAM_FORMATS: readonly ["claude-stream-json", "json-event-stream", "copilot-stream-json", "qoder-stream-json", "acp-json-rpc", "pi-rpc", "plain"];
+export declare const SUPPORTED_STREAM_FORMATS: readonly ["claude-stream-json", "json-event-stream", "qoder-stream-json", "acp-json-rpc", "pi-rpc", "plain"];
 /** The families of the registry's stream-format this driver implements — see index.ts module doc. */
 export type SupportedStreamFormat = (typeof SUPPORTED_STREAM_FORMATS)[number];
 export type JsonStreamFormat = Exclude<SupportedStreamFormat, 'acp-json-rpc' | 'pi-rpc' | 'plain'>;

package/dist/agent-executor/contracts.js

@@ -1,7 +1,6 @@
 export const SUPPORTED_STREAM_FORMATS = [
     'claude-stream-json',
     'json-event-stream',
-    'copilot-stream-json',
     'qoder-stream-json',
     'acp-json-rpc',
     'pi-rpc',

package/dist/agent-executor/event-translation.d.ts

@@ -35,9 +35,9 @@ export declare function translateTurnEndEvent({ rawEvent }: {
  * assertable in isolation.
  *
  * Defensive by construction: several real parser emissions carry fields
- * looser than `RunAgentPayload`'s types promise (e.g. copilot's
- * `tool.execution_start` emits `id: data.toolCallId ?? null` — a literal
- * `null`, not the `string` `RunAgentPayload['tool_use']['id']` demands).
+ * looser than `RunAgentPayload`'s types promise (e.g. an untrusted
+ * tool event can carry a literal `null`, not the `string`
+ * `RunAgentPayload['tool_use']['id']` demands).
  * Every field read here is defensively coerced (`asString`/
  * `asOptionalString`/`asOptionalNumber`) rather than trusted, so a
  * malformed or null field degrades to a safe default instead of

package/dist/agent-executor/event-translation.js

@@ -26,7 +26,7 @@ export function extractUsageTokens({ rawUsage }, _options = {}) {
  * fields beyond the basic counts — `thought_tokens`,
  * `cached_read_tokens`/`cached_write_tokens` (opencode/gemini/codex),
  * `modelUsage`/`stopReason`/`isError` (qoder), a top-level `stopReason`
- * (claude/copilot). Cache/reasoning counters and stop reasons now survive tracing; vendor-only
+ * (claude). Cache/reasoning counters and stop reasons now survive tracing; vendor-only
  * `modelUsage` and `isError` remain outside this neutral usage contract.
  * @param rawEvent - The raw `{type:'usage', ...}` record from a stream parser.
  * @returns The narrowed `RunAgentPayload` `usage` variant.
@@ -164,9 +164,9 @@ const EVENT_TYPE_TRANSLATORS = {
  * assertable in isolation.
  *
  * Defensive by construction: several real parser emissions carry fields
- * looser than `RunAgentPayload`'s types promise (e.g. copilot's
- * `tool.execution_start` emits `id: data.toolCallId ?? null` — a literal
- * `null`, not the `string` `RunAgentPayload['tool_use']['id']` demands).
+ * looser than `RunAgentPayload`'s types promise (e.g. an untrusted
+ * tool event can carry a literal `null`, not the `string`
+ * `RunAgentPayload['tool_use']['id']` demands).
  * Every field read here is defensively coerced (`asString`/
  * `asOptionalString`/`asOptionalNumber`) rather than trusted, so a
  * malformed or null field degrades to a safe default instead of
@@ -227,9 +227,9 @@ export function applyAgentTranslationSideEffects({ payload, sessionId, sink }) {
         sink.onSessionId({ sessionId });
     if (payload.type === 'tool_use') {
         sink.onToolCall({ toolUse: payload });
+        return;
     }
-    else if ((payload.type === 'text_delta' || payload.type === 'thinking_delta') && payload.delta.length > 0) {
+    if ((payload.type === 'text_delta' || payload.type === 'thinking_delta') && payload.delta.length > 0)
         sink.onUserVisibleOutput();
-    }
 }
 //# sourceMappingURL=event-translation.js.map

package/dist/agent-executor/events.js

@@ -7,8 +7,8 @@ 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';
-import { collectProcessTreePids, listProcessSnapshots, stopProcesses, } from '@jini-ai/platform/process';
+import { createClaudeStreamHandler, createJsonEventStreamHandler, createQoderStreamHandler, attachAcpSession, attachPiRpcSession, } from '@jini-ai/agent-runtime';
+import { listProcessSnapshots, stopProcesses, } from '@jini-ai/platform/process';
 import { classifyRunCloseStatus, } from '../close-status.js';
 import { resolveContinuationTransport, } from '../continuation/continuation-transport.js';
 import { resultContent, } from '../delegated-tool-bridge.js';
@@ -42,12 +42,15 @@ function createStreamHandlerForDef(def, streamFormat, onEvent) {
     switch (streamFormat) {
         case 'claude-stream-json':
             return createClaudeStreamHandler({ onEvent: onEvent }, { costBasis: def.usageCostBasis ?? 'run' });
-        case 'copilot-stream-json':
-            return createCopilotStreamHandler({ onEvent: onEvent });
         case 'qoder-stream-json':
             return createQoderStreamHandler({ onEvent: onEvent });
         case 'json-event-stream':
             return createJsonEventStreamHandler({ kind: def.eventParser ?? '', onEvent: onEvent });
+        default: {
+            // Unreachable: every stream format has a case above, and a new one fails typecheck here.
+            const unknownFormat = streamFormat;
+            throw new TypeError(`Unknown agent stream format: ${String(unknownFormat)}`);
+        }
     }
 }
 /**
@@ -463,9 +466,8 @@ export function wireChildLifecycle(ctx) {
      */
     function handleTurnEnd(stopReason) {
         const toolUse = pendingToolUse;
-        const shouldInject = stopReason === 'tool_use' &&
-            toolUse !== undefined &&
-            continuation !== undefined &&
+        const toolTurnPending = stopReason === 'tool_use' && toolUse !== undefined && continuation !== undefined;
+        const shouldInject = toolTurnPending &&
             resolveContinuationTransport({ def: def }) === 'stdin-injection' &&
             continuation.autonomousToolNames.has(toolUse.name);
         if (!shouldInject) {
@@ -547,10 +549,10 @@ export function wireChildLifecycle(ctx) {
                     return lifecycle.emit({ runId, input: { event: 'agent', data: statusWithChildIdentity({ payload, childPid: ctx.child.pid }, {}) } });
                 });
             }
-            else if (translation.kind === 'error') {
+            if (translation.kind === 'error') {
                 enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'error', data: translation.payload } }));
             }
-            else if (translation.kind === 'turn-end') {
+            if (translation.kind === 'turn-end') {
                 handleTurnEnd(translation.stopReason);
             }
         });
@@ -607,7 +609,8 @@ export function wireChildLifecycle(ctx) {
     }
     /**
      * Emits the accumulated `'until-close'` stdout — sanitized — as exactly one raw `'stdout'` echo
-     * plus one `text_delta`, through the same `enqueueEmit` FIFO queue every other emit uses, so the
+     * plus one `text_delta` for plain output, or through the declared structured parser. Both use
+     * the same `enqueueEmit` FIFO queue every other emit uses, so the
      * flush is ordered after every already-queued event and before `finish()`'s `'end'`. A no-op for
      * every live-streaming def (nothing was ever accumulated) and for a buffered run that produced
      * no stdout at all — an empty `text_delta` is noise, not information.
@@ -622,10 +625,19 @@ export function wireChildLifecycle(ctx) {
         const safe = sanitizeBufferedStdout ? sanitizeBufferedStdout({ fullText: bufferedStdout }) : bufferedStdout;
         bufferedStdout = '';
         bufferedStdoutBytes = 0;
-        const text = droppedStdoutBytes > 0
-            ? `${safe}${bufferedStdoutTruncationNotice(droppedStdoutBytes, ctx.bufferedStdoutMaxBytes)}`
-            : safe;
+        const dropped = droppedStdoutBytes;
         droppedStdoutBytes = 0;
+        if (streamHandler !== null) {
+            // Redact the complete wire text before parsing: structured errors can contain sign-in URLs too.
+            stdoutDiagnostics.feed({ text: safe });
+            streamHandler.feed({ chunk: safe });
+            if (dropped > 0)
+                enqueueEmit(() => lifecycle.emit({ runId, input: { event: 'error', data: {
+                            message: bufferedStdoutTruncationNotice(dropped, ctx.bufferedStdoutMaxBytes),
+                        } } }));
+            return;
+        }
+        const text = dropped > 0 ? `${safe}${bufferedStdoutTruncationNotice(dropped, ctx.bufferedStdoutMaxBytes)}` : safe;
         if (text.length === 0)
             return;
         enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'stdout', data: { chunk: text } } }));
@@ -634,27 +646,27 @@ export function wireChildLifecycle(ctx) {
     child.stdout?.on('data', (chunk) => {
         const text = chunk.toString('utf8');
         stdoutDiagnostics.record({ chunk, text });
-        if (streamFormat === 'plain') {
-            if (text.length > 0)
-                userVisibleOutputSeen = true;
-            if (bufferStdoutUntilClose) {
-                // Nothing is emitted on *either* channel yet — see this function's doc on why holding the
-                // raw echo back matters as much as holding back the chat copy.
-                //
-                // Whole chunks only: a chunk that would cross the ceiling is dropped entirely rather than
-                // sliced to fit, which keeps the accumulator free of half-written multi-byte characters (a
-                // `data` event boundary already need not align with one) and makes the kept prefix exactly
-                // the bytes some prefix of chunks produced. Everything after the first refusal is dropped
-                // too — the point is a hard ceiling on resident bytes, not a best-effort tail.
-                const chunkBytes = Buffer.byteLength(text, 'utf8');
-                if (droppedStdoutBytes > 0 || bufferedStdoutBytes + chunkBytes > ctx.bufferedStdoutMaxBytes) {
-                    droppedStdoutBytes += chunkBytes;
-                    return;
-                }
-                bufferedStdout += text;
-                bufferedStdoutBytes += chunkBytes;
+        if (streamFormat === 'plain' && text.length > 0)
+            userVisibleOutputSeen = true;
+        if (bufferStdoutUntilClose) {
+            // Nothing is emitted on *either* channel yet — see this function's doc on why holding the
+            // raw echo back matters as much as holding back the chat copy.
+            //
+            // Whole chunks only: a chunk that would cross the ceiling is dropped entirely rather than
+            // sliced to fit, which keeps the accumulator free of half-written multi-byte characters (a
+            // `data` event boundary already need not align with one) and makes the kept prefix exactly
+            // the bytes some prefix of chunks produced. Everything after the first refusal is dropped
+            // too — the point is a hard ceiling on resident bytes, not a best-effort tail.
+            const chunkBytes = Buffer.byteLength(text, 'utf8');
+            if (droppedStdoutBytes > 0 || bufferedStdoutBytes + chunkBytes > ctx.bufferedStdoutMaxBytes) {
+                droppedStdoutBytes += chunkBytes;
                 return;
             }
+            bufferedStdout += text;
+            bufferedStdoutBytes += chunkBytes;
+            return;
+        }
+        if (streamFormat === 'plain') {
             enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'stdout', data: { chunk: text } } }));
             enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'agent', data: { type: 'text_delta', delta: text } } }));
             return;
@@ -702,12 +714,12 @@ export function wireChildLifecycle(ctx) {
                 feedSessionLine(controlScanBuffer);
                 controlScanBuffer = '';
             }
+            flushBufferedStdout();
             streamHandler?.flush();
             session.endSession();
             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();
+            // The buffered flush is queued before `await emitQueue` so its sanitized events are durable
+            // ahead of `finish()`'s `'end'`, exactly like every live-path emit already is.
             await emitQueue;
             if (cancelRequested)
                 await cancelUnresolvedToolCalls();
@@ -843,7 +855,10 @@ function wireAcpLifecycle(ctx) {
             unsubscribeCancel();
             // Guarded for the same reasons as the child-driven handler above.
             await cleanupStagedFilesSafely(ctx);
-            const status = await output.settle({ status: cancelRequested ? 'cancelled' : controller?.completedSuccessfully() ? 'succeeded' : 'failed' });
+            let finalStatus = 'cancelled';
+            if (!cancelRequested)
+                finalStatus = controller?.completedSuccessfully() ? 'succeeded' : 'failed';
+            const status = await output.settle({ status: finalStatus });
             const resumable = status === 'failed' && classifyFailure !== undefined
                 ? await classifyFailureSafely(ctx, classifyFailure, {
                     runId,
@@ -870,7 +885,7 @@ function wireAcpLifecycle(ctx) {
                         } });
                     enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'agent', data: translation.payload } }));
                 }
-                else if (translation.kind === 'error') {
+                if (translation.kind === 'error') {
                     enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'error', data: translation.payload } }));
                 }
                 return;
@@ -942,7 +957,10 @@ function wirePiRpcLifecycle(ctx) {
             unsubscribeCancel();
             // Guarded for the same reasons as the child-driven handler above.
             await cleanupStagedFilesSafely(ctx);
-            const status = await output.settle({ status: cancelRequested ? 'cancelled' : session?.hasFatalError() ? 'failed' : 'succeeded' });
+            let finalStatus = 'cancelled';
+            if (!cancelRequested)
+                finalStatus = session?.hasFatalError() ? 'failed' : 'succeeded';
+            const status = await output.settle({ status: finalStatus });
             const resumable = status === 'failed' && classifyFailure !== undefined
                 ? await classifyFailureSafely(ctx, classifyFailure, {
                     runId,
@@ -961,18 +979,14 @@ function wirePiRpcLifecycle(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 (translation.payload.type === 'tool_use') {
-                    toolCallSeen = true;
-                }
-                else if ((translation.payload.type === 'text_delta' || translation.payload.type === 'thinking_delta') &&
-                    translation.payload.delta.length > 0) {
-                    userVisibleOutputSeen = true;
-                }
+                applyAgentTranslationSideEffects({ payload: translation.payload, sessionId: translation.sessionId, sink: {
+                        onSessionId: ({ sessionId }) => { capturedSessionId = sessionId; },
+                        onToolCall: () => { toolCallSeen = true; },
+                        onUserVisibleOutput: () => { userVisibleOutputSeen = true; },
+                    } });
                 enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'agent', data: translation.payload } }));
             }
-            else if (translation.kind === 'error') {
+            if (translation.kind === 'error') {
                 enqueueEmit(() => lifecycle.emit({ runId: runId, input: { event: 'error', data: translation.payload } }));
             }
         } }, { cwd: ctx.cwd, ...(ctx.model !== undefined ? { model: ctx.model } : {}), ...(ctx.imagePaths.length > 0 ? { imagePaths: [...ctx.imagePaths] } : {}), ...(ctx.uploadRoot !== undefined ? { uploadRoot: ctx.uploadRoot } : {}) });
@@ -1047,8 +1061,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();
-        // `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)}` });
+        // `failBeforeSpawn` always rejects (`Promise<never>`); awaiting it propagates that rejection.
+        await 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. */
@@ -1080,7 +1094,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();
-        return deps.failBeforeSpawn({ runId: input.runId, code: 'AGENT_SPAWN_FAILED', message: `AgentExecutor: could not attach pi-rpc session for agent "${input.agentId}": ${errorMessage(err)}` });
+        await 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/index.d.ts

@@ -11,12 +11,12 @@
  *
  * ## v1 scope: all 24 registered agent defs
  *
- * `@jini-ai/agent-runtime`'s registry ships 24 built-in defs across four
- * `streamFormat` families. The JSON-stream-parser family — the four
+ * `@jini-ai/agent-runtime`'s registry ships built-in defs across four
+ * `streamFormat` families. The JSON-stream-parser family — the three
  * `createXStreamHandler`-shaped parsers (`claude-stream-json`,
- * `json-event-stream`, `copilot-stream-json`, `qoder-stream-json`), covering
- * 9 defs (amp, codebuddy, claude, codex, cursor-agent, opencode, mimo,
- * copilot, qoder) — plus all 9 `acp-json-rpc` defs, plus the one `pi-rpc`
+ * `json-event-stream`, `qoder-stream-json`), covering
+ * 8 defs (amp, codebuddy, claude, codex, cursor-agent, opencode, mimo,
+ * qoder) — plus all 9 `acp-json-rpc` defs, plus the one `pi-rpc`
  * def (`pi`), are wired here. ACP and pi-rpc each own their own JSON-RPC
  * prompt-delivery protocol, so each takes its own lifecycle branch rather
  * than being treated as a stdout-tail parser; pi-rpc's events arrive through

package/dist/agent-executor/index.js

@@ -11,12 +11,12 @@
  *
  * ## v1 scope: all 24 registered agent defs
  *
- * `@jini-ai/agent-runtime`'s registry ships 24 built-in defs across four
- * `streamFormat` families. The JSON-stream-parser family — the four
+ * `@jini-ai/agent-runtime`'s registry ships built-in defs across four
+ * `streamFormat` families. The JSON-stream-parser family — the three
  * `createXStreamHandler`-shaped parsers (`claude-stream-json`,
- * `json-event-stream`, `copilot-stream-json`, `qoder-stream-json`), covering
- * 9 defs (amp, codebuddy, claude, codex, cursor-agent, opencode, mimo,
- * copilot, qoder) — plus all 9 `acp-json-rpc` defs, plus the one `pi-rpc`
+ * `json-event-stream`, `qoder-stream-json`), covering
+ * 8 defs (amp, codebuddy, claude, codex, cursor-agent, opencode, mimo,
+ * qoder) — plus all 9 `acp-json-rpc` defs, plus the one `pi-rpc`
  * def (`pi`), are wired here. ACP and pi-rpc each own their own JSON-RPC
  * prompt-delivery protocol, so each takes its own lifecycle branch rather
  * than being treated as a stdout-tail parser; pi-rpc's events arrive through