@sema-agent/client-core 0.94.0 → 0.95.0

package/dist/subagent/engineDelegatedPrompt.js

@@ -1,23 +1,25 @@
 import { stripSystemReminderBlocks } from '../systemReminderTag.js';
 import { hostLog } from '../host.js';
+import { isSessionIdPathSegment } from '../sessionIdSegment.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected } from '../engineWireFor.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
+import { panelAnchorOf } from '../panelReduce.js';
+import { clearEnginePanelAnchors, panelStateNow, stepEnginePanel } from '../panelStateHolder.js';
 function usableDelegatedPromptClient(client) {
     return clientHasVerbs(client, [['sessions', 'get']]);
 }
 const TAIL_WINDOW = 200;
 const BLOB_CAP = 8 * 1024;
-const transcriptIdByTask = new Map();
 export function recordEngineTranscriptId(taskId, transcriptId) {
     if (!taskId || !transcriptId)
         return;
-    transcriptIdByTask.set(taskId, transcriptId);
+    stepEnginePanel({ kind: 'anchor', taskId, transcriptId });
 }
 export function getEngineTranscriptId(taskId) {
-    return transcriptIdByTask.get(taskId);
+    return panelAnchorOf(panelStateNow(), taskId);
 }
 export function __resetEngineDelegatedPromptForTests() {
-    transcriptIdByTask.clear();
+    clearEnginePanelAnchors();
     promptHydrateInFlight.clear();
 }
 const promptHydrateInFlight = new Set();
@@ -94,6 +96,8 @@ export function __setTranscriptWindowReaderForTests(r) {
 async function readTranscriptWindow(transcriptId, sessionKey, injectedWire) {
     if (transcriptWindowReader)
         return transcriptWindowReader(transcriptId);
+    if (!isSessionIdPathSegment(transcriptId))
+        return null;
     const wire = engineWireFor(injectedWire, sessionKey, usableDelegatedPromptClient);
     if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
         return null;
@@ -112,8 +116,8 @@ async function readTranscriptWindow(transcriptId, sessionKey, injectedWire) {
 export async function fetchDelegatedPrompt(taskId, opts) {
     if (promptHydrateInFlight.has(taskId))
         return { outcome: 'skipped' };
-    const transcriptId = transcriptIdByTask.get(taskId);
-    if (!transcriptId)
+    const transcriptId = getEngineTranscriptId(taskId);
+    if (!isSessionIdPathSegment(transcriptId))
         return { outcome: 'skipped' };
     promptHydrateInFlight.add(taskId);
     let msgs = null;

package/dist/subagent/engineSubagentOutput.d.ts

@@ -5,7 +5,6 @@ export type SubagentReportWireClient = {
     runs: Pick<AgentClient['runs'], 'subagentOutput'>;
 };
 export type SubagentReportWire = EngineWireInjection<SubagentReportWireClient>;
-export declare function __resetSubagentOutputCapCacheForTests(): void;
 export interface EngineSubagentReport {
     content: string;
     status?: string;

package/dist/subagent/engineSubagentOutput.js

@@ -1,32 +1,17 @@
 import { hostLog } from '../host.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected } from '../engineWireFor.js';
+import { engineCapStateVia } from '../engineCapsCache.js';
 import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 function usableReportClient(client) {
     return clientHasVerbs(client, [['capabilities'], ['runs', 'subagentOutput']]);
 }
-const capByBase = new Map();
-const CAP_FALSE_RETRY_TTL_MS = 5 * 60_000;
 async function subagentOutputCapable(client, cacheKey, signal, deadlineMs) {
-    const hit = cacheKey !== undefined ? capByBase.get(cacheKey) : undefined;
-    if (hit && (hit.ok || Date.now() - hit.at < CAP_FALSE_RETRY_TTL_MS))
-        return hit.ok;
-    try {
-        const caps = deadlineMs !== undefined
-            ? await settleInjected(deadlineMs, signal, (s) => client.capabilities({ signal: s }))
-            : await client.capabilities({ ...(signal ? { signal } : {}) });
-        const ok = caps.subagentOutput === true;
-        if (cacheKey !== undefined)
-            capByBase.set(cacheKey, { ok, at: Date.now() });
-        return ok;
-    }
-    catch {
-        return false;
-    }
-}
-export function __resetSubagentOutputCapCacheForTests() {
-    capByBase.clear();
+    const state = await engineCapStateVia(cacheKey, 'subagentOutput', (s) => deadlineMs !== undefined
+        ? settleInjected(deadlineMs, s, (x) => client.capabilities({ signal: x }))
+        : client.capabilities({ ...(s ? { signal: s } : {}) }), { withinMs: deadlineMs ?? INJECTED_WIRE_SETTLE_MS, ...(signal ? { signal } : {}) });
+    return state === 'true';
 }
 export async function fetchEngineSubagentReport(taskId, opts) {
     const { record: owner, runId, key } = resolveOwnerContext(taskId);

package/dist/subagent/engineSubagentTail.d.ts

@@ -5,7 +5,6 @@ export type SubagentTailWireClient = {
     runs: Pick<AgentClient['runs'], 'subagentStream'>;
 };
 export type SubagentTailWire = EngineWireInjection<SubagentTailWireClient>;
-export declare function __resetSubagentStreamCapCacheForTests(): void;
 export interface SubagentActivity {
     taskId: string;
     toolName: string;

package/dist/subagent/engineSubagentTail.js

@@ -1,5 +1,7 @@
 import { hostLog } from '../host.js';
+import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected } from '../engineWireFor.js';
+import { engineCapStateVia } from '../engineCapsCache.js';
 import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { coerceOutput, parentToolCallIdOf, publishSubagentContentEvent, settleSubagentContent, } from '../subagentContentStore.js';
@@ -7,27 +9,11 @@ import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 function usableTailClient(client) {
     return clientHasVerbs(client, [['capabilities'], ['runs', 'subagentStream']]);
 }
-const capByBase = new Map();
-const CAP_FALSE_RETRY_TTL_MS = 5 * 60_000;
 async function subagentStreamCapable(client, cacheKey, signal, deadlineMs) {
-    const hit = cacheKey !== undefined ? capByBase.get(cacheKey) : undefined;
-    if (hit && (hit.ok || Date.now() - hit.at < CAP_FALSE_RETRY_TTL_MS))
-        return hit.ok;
-    try {
-        const caps = deadlineMs !== undefined
-            ? await settleInjected(deadlineMs, signal, (s) => client.capabilities({ signal: s }))
-            : await client.capabilities({ ...(signal ? { signal } : {}) });
-        const ok = caps.subagentStream === true;
-        if (cacheKey !== undefined)
-            capByBase.set(cacheKey, { ok, at: Date.now() });
-        return ok;
-    }
-    catch {
-        return false;
-    }
-}
-export function __resetSubagentStreamCapCacheForTests() {
-    capByBase.clear();
+    const state = await engineCapStateVia(cacheKey, 'subagentStream', (s) => deadlineMs !== undefined
+        ? settleInjected(deadlineMs, s, (x) => client.capabilities({ signal: x }))
+        : client.capabilities({ ...(s ? { signal: s } : {}) }), { withinMs: deadlineMs ?? INJECTED_WIRE_SETTLE_MS, ...(signal ? { signal } : {}) });
+    return state === 'true';
 }
 const activeTails = new Map();
 let activitySink = null;
@@ -106,18 +92,7 @@ export function tailEngineSubagent(taskId, opts) {
                 }
                 switch (ev.event) {
                     case 'meta':
-                        try {
-                            const out = tailMetaSink?.({ taskId, meta: ev.data });
-                            if (out !== null && typeof out === 'object' && typeof out.then === 'function') {
-                                ;
-                                out.then(undefined, (e) => {
-                                    hostLog('debug', `[subagent-tail] ${taskId} meta sink rejected: ${String(e).slice(0, 160)}`);
-                                });
-                            }
-                        }
-                        catch (e) {
-                            hostLog('debug', `[subagent-tail] ${taskId} meta sink threw: ${String(e).slice(0, 160)}`);
-                        }
+                        invokeHostCallbackIsolated(`[subagent-tail] ${taskId} meta sink`, () => tailMetaSink?.({ taskId, meta: ev.data }));
                         continue;
                     case 'forward':
                         break;

package/dist/subagentContentStore.js

@@ -1,3 +1,4 @@
+import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
 export function coerceOutput(v) {
     if (v === undefined || v === null)
         return undefined;
@@ -648,7 +649,6 @@ export function getBgTerminalFacts(taskId) {
 }
 const MAX_BG_PARENT_RUNS = 320;
 const bgParentRun = new Map();
-const DEFAULT_OWNER_SLOT = '__default__';
 let ownerSessionConflictCount = 0;
 let lastOwnerSessionConflict;
 const conflictQuarantine = new Map();
@@ -703,8 +703,8 @@ export function recordSubagentOwner(taskId, runId, sessionId, sessionKey) {
             },
             next: { ...nextPair },
         };
-        const priorSlot = prior?.sessionKey ?? DEFAULT_OWNER_SLOT;
-        const nextSlot = nextPair.sessionKey ?? DEFAULT_OWNER_SLOT;
+        const priorSlot = prior?.sessionKey ?? DEFAULT_SESSION_KEY;
+        const nextSlot = nextPair.sessionKey ?? DEFAULT_SESSION_KEY;
         if (priorSlot !== nextSlot) {
             bgParentRun.delete(taskId);
             if (conflictQuarantine.size >= MAX_BG_PARENT_RUNS && !conflictQuarantine.has(taskId)) {

package/dist/supportFloor.js

@@ -1,8 +1,5 @@
-export const SUPPORT_FLOOR = Object.freeze({
-    server: '7.106.0',
-    core: '7.35.2',
-    sdk: '18.1.0',
-});
+import { DECLARED_SUPPORT_FLOOR } from './declared/supportFloorDeclared.js';
+export const SUPPORT_FLOOR = DECLARED_SUPPORT_FLOOR;
 export function supportFloorOf(component) {
     if (component === 'server' || component === 'core' || component === 'sdk')
         return SUPPORT_FLOOR[component];

package/dist/terminalStatuses.d.ts

@@ -0,0 +1,30 @@
+import type { SDKTaskUpdatedMessage } from '@sema-agent/agent-types';
+import { CORE_TERMINAL_CAUSE_KINDS } from './generated/engineFactTables.js';
+export { CORE_TERMINAL_CAUSE_KINDS };
+export type CoreTerminalCauseKind = (typeof CORE_TERMINAL_CAUSE_KINDS)[number];
+export declare function isCoreTerminalCauseKind(kind: unknown): kind is CoreTerminalCauseKind;
+export declare const SDK_RUN_TERMINAL_STATUSES: readonly ["completed", "failed", "blocked", "timeout"];
+export type SdkRunTerminalStatus = (typeof SDK_RUN_TERMINAL_STATUSES)[number];
+export declare function isSdkRunTerminal(status: unknown): status is SdkRunTerminalStatus;
+export declare function isSdkRunTerminalNotSuccess(status: unknown): status is Exclude<SdkRunTerminalStatus, 'completed'>;
+export declare const SDK_PARKED_RUN_STATUSES: readonly ["suspended", "needs_review"];
+export declare function isSdkRunParked(status: unknown): status is (typeof SDK_PARKED_RUN_STATUSES)[number];
+export declare function isSdkRunFrameSynthesizable(status: unknown): boolean;
+export declare const SDK_FLEET_TASK_TERMINAL_STATUSES: readonly ["completed", "failed", "killed"];
+export type SdkFleetTaskTerminalStatus = (typeof SDK_FLEET_TASK_TERMINAL_STATUSES)[number];
+export declare function isSdkFleetTaskTerminal(status: unknown): status is SdkFleetTaskTerminalStatus;
+export declare function isSdkFleetTaskTerminalNotSuccess(status: unknown): status is Exclude<SdkFleetTaskTerminalStatus, 'completed'>;
+export declare const CORE_TASK_NOTIFICATION_TERMINAL_STATUSES: readonly ["completed", "failed", "killed", "cancelled"];
+export type CoreTaskNotificationTerminalStatus = (typeof CORE_TASK_NOTIFICATION_TERMINAL_STATUSES)[number];
+export declare function isCoreTaskNotificationTerminal(status: unknown): status is CoreTaskNotificationTerminalStatus;
+export declare function isCoreTaskNotificationTerminalNotSuccess(status: unknown): status is Exclude<CoreTaskNotificationTerminalStatus, 'completed'>;
+export declare const CORE_SEMA_TASK_TERMINAL_STATUSES: readonly ["completed", "failed", "killed", "cancelled"];
+export type CoreSemaTaskTerminalStatus = (typeof CORE_SEMA_TASK_TERMINAL_STATUSES)[number];
+export declare function isCoreSemaTaskTerminal(status: unknown): status is CoreSemaTaskTerminalStatus;
+export declare const CORE_WORKFLOW_RUN_TERMINAL_STATUSES: readonly ["completed", "failed"];
+export declare function isCoreWorkflowRunTerminal(status: unknown): status is (typeof CORE_WORKFLOW_RUN_TERMINAL_STATUSES)[number];
+export declare const CORE_TASK_PROGRESS_TERMINAL_STATUSES: readonly ["completed", "failed"];
+export declare function isCoreTaskProgressTerminal(status: unknown): status is (typeof CORE_TASK_PROGRESS_TERMINAL_STATUSES)[number];
+export declare function isCoreTaskProgressTerminalNotSuccess(status: unknown): status is 'failed';
+export type CcTaskTerminalStatus = Extract<NonNullable<SDKTaskUpdatedMessage['patch']['status']>, 'completed' | 'failed' | 'killed'>;
+export declare function ccTaskTerminalStatusOf(status: unknown): CcTaskTerminalStatus | undefined;

package/dist/terminalStatuses.js

@@ -0,0 +1,67 @@
+import { CORE_TERMINAL_CAUSE_KINDS } from './generated/engineFactTables.js';
+function memberOf(table, word) {
+    return typeof word === 'string' && table.includes(word);
+}
+function terminalNotSuccessOf(table, word) {
+    return word !== 'completed' && memberOf(table, word);
+}
+export { CORE_TERMINAL_CAUSE_KINDS };
+export function isCoreTerminalCauseKind(kind) {
+    return memberOf(CORE_TERMINAL_CAUSE_KINDS, kind);
+}
+export const SDK_RUN_TERMINAL_STATUSES = Object.freeze(['completed', 'failed', 'blocked', 'timeout']);
+export function isSdkRunTerminal(status) {
+    return memberOf(SDK_RUN_TERMINAL_STATUSES, status);
+}
+export function isSdkRunTerminalNotSuccess(status) {
+    return terminalNotSuccessOf(SDK_RUN_TERMINAL_STATUSES, status);
+}
+export const SDK_PARKED_RUN_STATUSES = Object.freeze(['suspended', 'needs_review']);
+export function isSdkRunParked(status) {
+    return memberOf(SDK_PARKED_RUN_STATUSES, status);
+}
+export function isSdkRunFrameSynthesizable(status) {
+    return isSdkRunTerminal(status) || isSdkRunParked(status);
+}
+export const SDK_FLEET_TASK_TERMINAL_STATUSES = Object.freeze(['completed', 'failed', 'killed']);
+export function isSdkFleetTaskTerminal(status) {
+    return memberOf(SDK_FLEET_TASK_TERMINAL_STATUSES, status);
+}
+export function isSdkFleetTaskTerminalNotSuccess(status) {
+    return terminalNotSuccessOf(SDK_FLEET_TASK_TERMINAL_STATUSES, status);
+}
+export const CORE_TASK_NOTIFICATION_TERMINAL_STATUSES = Object.freeze(['completed', 'failed', 'killed', 'cancelled']);
+export function isCoreTaskNotificationTerminal(status) {
+    return memberOf(CORE_TASK_NOTIFICATION_TERMINAL_STATUSES, status);
+}
+export function isCoreTaskNotificationTerminalNotSuccess(status) {
+    return terminalNotSuccessOf(CORE_TASK_NOTIFICATION_TERMINAL_STATUSES, status);
+}
+export const CORE_SEMA_TASK_TERMINAL_STATUSES = Object.freeze(['completed', 'failed', 'killed', 'cancelled']);
+export function isCoreSemaTaskTerminal(status) {
+    return memberOf(CORE_SEMA_TASK_TERMINAL_STATUSES, status);
+}
+export const CORE_WORKFLOW_RUN_TERMINAL_STATUSES = Object.freeze(['completed', 'failed']);
+export function isCoreWorkflowRunTerminal(status) {
+    return memberOf(CORE_WORKFLOW_RUN_TERMINAL_STATUSES, status);
+}
+export const CORE_TASK_PROGRESS_TERMINAL_STATUSES = Object.freeze(['completed', 'failed']);
+export function isCoreTaskProgressTerminal(status) {
+    return memberOf(CORE_TASK_PROGRESS_TERMINAL_STATUSES, status);
+}
+export function isCoreTaskProgressTerminalNotSuccess(status) {
+    return terminalNotSuccessOf(CORE_TASK_PROGRESS_TERMINAL_STATUSES, status);
+}
+const CC_TASK_TERMINAL_STATUS_OF = Object.freeze({
+    completed: 'completed',
+    failed: 'failed',
+    killed: 'killed',
+    cancelled: 'killed',
+    blocked: 'failed',
+    timeout: 'failed',
+});
+export function ccTaskTerminalStatusOf(status) {
+    return typeof status === 'string' && Object.hasOwn(CC_TASK_TERMINAL_STATUS_OF, status)
+        ? CC_TASK_TERMINAL_STATUS_OF[status]
+        : undefined;
+}

package/dist/toolResult.d.ts

@@ -13,6 +13,7 @@ export declare const PROTOCOL_MARKERS: {
     readonly delegationNoTextResult: "(no text result)";
     readonly delegationTrailer: "Verify this result before concluding. If it leaves more to do, continue or delegate again.";
     readonly delegationTrailerFork: "Verify this result before concluding. If it leaves more to do, continue the work yourself or fork again.";
+    readonly delegationFieldLine: RegExp;
     readonly taskOutputLabel: RegExp;
     readonly taskOutputStatus: RegExp;
     readonly taskOutputHeadSlots: RegExp;
@@ -52,6 +53,10 @@ export type DelegationReportFrame = {
     before: string;
     after: string;
     section: 'result' | 'partial_findings' | 'no_text_result';
+    status?: string;
+    error?: string;
+    stats?: string;
+    headRest?: string;
 };
 export declare function displayBody(text: unknown, origin?: DisplayBodyOrigin): DisplayBody | undefined;
 export type ModelFacingTaskOutput = {

package/dist/toolResult.js

@@ -3,6 +3,8 @@ import { markEngineWorkflowNotified, registerOutstandingBgTask, registerOutstand
 import { parseWorkflowPollEnvelope, projectWorkflowTaskOutput } from './workflow.js';
 import { asModelFallbackReason } from './engineErrorCodes.js';
 import { frozenSet } from './frozenSet.js';
+import { bashExitOf, bashExitReadingFailed } from './bashExitReading.js';
+import { isCoreSemaTaskTerminal } from './terminalStatuses.js';
 import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
 export const STRUCTURED_DETAIL_TYPES = frozenSet(CORE_ENGINE_CARD_TYPES);
 export function structuredDetailType(structured) {
@@ -12,11 +14,6 @@ export function structuredDetailType(structured) {
     return typeof t === 'string' && STRUCTURED_DETAIL_TYPES.has(t) ? t : undefined;
 }
 const MAX_STRUCTURED_FIELD_CHARS = 1_000_000;
-const WF_TERMINAL_STATUSES = new Set([
-    'completed',
-    'failed',
-    'cancelled',
-]);
 export const PROTOCOL_MARKERS = {
     bashHead: /^exit code: (-?\d+)(?: \(([^)\n]*)\))?\n(--- stdout ---\n)?/,
     bashStderrSep: '\n--- stderr ---\n',
@@ -28,6 +25,7 @@ export const PROTOCOL_MARKERS = {
     delegationNoTextResult: '(no text result)',
     delegationTrailer: 'Verify this result before concluding. If it leaves more to do, continue or delegate again.',
     delegationTrailerFork: 'Verify this result before concluding. If it leaves more to do, continue the work yourself or fork again.',
+    delegationFieldLine: /^(status|error|error_kind|observer|stats|worktree):(?: ([^\r\u2028\u2029\u0085]*))?/,
     taskOutputLabel: /^TaskOutput\s+(\S+)$/,
     taskOutputStatus: /^status:\s*(.+)$/m,
     taskOutputHeadSlots: /^(\r?\n)(?:(state: ([^\r\n\u2028\u2029\u0085]*)(?:\r?\n|$)))?(?:(error: ([^\r\n\u2028\u2029\u0085]*)(?:\r?\n|$)))?/,
@@ -35,7 +33,7 @@ export const PROTOCOL_MARKERS = {
     taskOutputNoneSentinel: '(none)',
     taskOutputStdoutLine: /^--- (?:new )?stdout[^\n]*---\n?/m,
     taskOutputStderrLine: /^--- (?:new )?stderr[^\n]*---\n?/m,
-    taskOutputResultLine: /^--- result(?: \([^)\n]*\))? ---\n?/m,
+    taskOutputResultLine: /^--- result(?: \((?:[^)\n\r\u2028\u2029]|[\r\u2028\u2029](?!--- result))*\))? ---\n?/m,
     spoolStdoutFull: '--- stdout (full, re-readable) ---',
     spoolStdoutIncremental: '--- new stdout ---',
 };
@@ -78,6 +76,59 @@ export function stripUntrustedFence(text) {
         return null;
     return { label: m[1] ?? '', body: m[2] ?? '' };
 }
+function delegationFrameSlots(lines, headAt, labelAt, fromAt) {
+    const read = (i) => {
+        const line = lines[i] ?? '';
+        const hit = PROTOCOL_MARKERS.delegationFieldLine.exec(line);
+        if (hit === null)
+            return null;
+        const value = hit[2];
+        return { key: hit[1] ?? '', value: value !== undefined && hit[0].length === line.length && value.trim() !== '' ? value : undefined };
+    };
+    const fields = [];
+    for (let i = headAt + 1; i < labelAt; i++)
+        fields.push(read(i));
+    const errorFollowedByEngineField = (at) => {
+        const next = fields[at + 1];
+        return next !== null && next !== undefined && next.value !== undefined && (next.key === 'error_kind' || next.key === 'observer' || next.key === 'stats');
+    };
+    const worktreeBefore = (at) => fields.slice(0, at).some((f) => f?.key === 'worktree');
+    const soleAt = (key) => {
+        let at = -1;
+        for (let i = 0; i < fields.length; i++) {
+            if (fields[i]?.key !== key)
+                continue;
+            if (at >= 0)
+                return -1;
+            at = i;
+        }
+        return at;
+    };
+    const claimed = new Set([headAt, labelAt]);
+    if (fromAt > labelAt + 1)
+        claimed.add(labelAt + 1);
+    const slots = {};
+    const first = fields[0] ?? null;
+    if (first !== null && first.key === 'status' && first.value !== undefined && soleAt('status') === 0) {
+        slots.status = first.value.trim();
+        claimed.add(headAt + 1);
+        for (const key of ['error', 'stats']) {
+            const at = soleAt(key);
+            const value = at >= 0 ? fields[at]?.value : undefined;
+            if (value === undefined || (key === 'error' && (!errorFollowedByEngineField(at) || worktreeBefore(at))))
+                continue;
+            slots[key] = value;
+            claimed.add(headAt + 1 + at);
+        }
+    }
+    let rest = '';
+    for (let i = 0; i < fromAt; i++)
+        if (!claimed.has(i))
+            rest += `${lines[i] ?? ''}\n`;
+    if (rest.trim() !== '')
+        slots.headRest = rest;
+    return slots;
+}
 function locateDelegationResultSection(text) {
     const lines = text.split('\n');
     const soleLineAt = (hit) => {
@@ -107,14 +158,14 @@ function locateDelegationResultSection(text) {
     };
     if (trailerAt === labelAt + 2 && lines[labelAt + 1] === PROTOCOL_MARKERS.delegationNoTextResult) {
         const c = cut(labelAt + 1);
-        return { section: 'no_text_result', before: c.before, after: c.after };
+        return { section: 'no_text_result', before: c.before, after: c.after, slots: delegationFrameSlots(lines, headAt, labelAt, labelAt + 1) };
     }
     const partial = lines[labelAt + 1] === PROTOCOL_MARKERS.delegationPartialFindingsLabel;
     const from = partial ? labelAt + 2 : labelAt + 1;
     if (from >= trailerAt)
         return null;
     const c = cut(from);
-    return { section: partial ? 'partial_findings' : 'result', before: c.before, fenceText: c.middle, after: c.after };
+    return { section: partial ? 'partial_findings' : 'result', before: c.before, fenceText: c.middle, after: c.after, slots: delegationFrameSlots(lines, headAt, labelAt, from) };
 }
 export function displayBody(text, origin = 'any_tool_result') {
     if (typeof text !== 'string')
@@ -128,14 +179,14 @@ export function displayBody(text, origin = 'any_tool_result') {
     if (located === null)
         return { fenced: false, body: text };
     if (located.section === 'no_text_result') {
-        const { before, after, section } = located;
-        return { fenced: false, body: '', frame: { before, after, section } };
+        const { before, after, section, slots } = located;
+        return { fenced: false, body: '', frame: { before, after, section, ...slots } };
     }
     const inner = stripUntrustedFence(located.fenceText);
     if (inner === null)
         return { fenced: false, body: text };
-    const { before, after, section } = located;
-    return { fenced: true, label: inner.label, body: inner.body, frame: { before, after, section } };
+    const { before, after, section, slots } = located;
+    return { fenced: true, label: inner.label, body: inner.body, frame: { before, after, section, ...slots } };
 }
 export function parseModelFacingTaskOutput(text) {
     modelFacingParseCount++;
@@ -241,7 +292,7 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
                         : typeof bgBlock?.task_id === 'string'
                             ? bgBlock.task_id
                             : undefined;
-                if (s?.detached === true)
+                if (readBashDetachView(structured)?.handoffTaskId !== undefined)
                     bgTaskId = undefined;
             }
             else {
@@ -255,20 +306,23 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
                 };
             }
         }
-        const slots = sType === 'bash' && (typeof s?.stdout === 'string' || typeof s?.stderr === 'string')
+        let parsedMemo;
+        const parseOnce = () => (parsedMemo === undefined ? (parsedMemo = parseModelFacingBash(text)) : parsedMemo);
+        const exit = bashExitOf(structured, parseOnce);
+        const structuredSlots = sType === 'bash' && (typeof s?.stdout === 'string' || typeof s?.stderr === 'string');
+        const textSlots = structuredSlots ? null : parseOnce();
+        const slots = structuredSlots
             ? {
                 stdout: typeof s?.stdout === 'string' ? s.stdout : '',
                 stderr: typeof s?.stderr === 'string' ? s.stderr : '',
-                exitCode: typeof s?.exitCode === 'number' ? s.exitCode : null,
+                exitCode: exit.exitCode,
             }
-            : parseModelFacingBash(text);
+            : textSlots !== null
+                ? { ...textSlots, exitCode: exit.exitCode }
+                : null;
         if (slots) {
-            const benignInterp = typeof s?.returnCodeInterpretation === 'string' && s.returnCodeInterpretation.length > 0
-                ? s.returnCodeInterpretation
-                : 'note' in slots && typeof slots.note === 'string' && slots.note.length > 0
-                    ? slots.note
-                    : undefined;
-            const failed = isError || (slots.exitCode != null && slots.exitCode !== 0 && benignInterp === undefined);
+            const benignInterp = exit.benignNote;
+            const failed = isError || bashExitReadingFailed(exit);
             if (failed) {
                 const reason = slots.stderr.length > 0 ? slots.stderr : slots.stdout;
                 let body = slots.exitCode != null ? `Exit code ${slots.exitCode}\n${reason}` : reason;
@@ -293,7 +347,7 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
             };
         }
         const stdout = truncated ? `${text}\n…(truncated)` : text;
-        if (isError)
+        if (isError || bashExitReadingFailed(exit))
             return { content: stdout, isError: true };
         return { content: stdout, isError, toolUseResult: { stdout, stderr: '', interrupted: false } };
     }
@@ -316,7 +370,7 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
         }
         const wfEnvelope = parseWorkflowPollEnvelope(text);
         if (wfEnvelope) {
-            if (leaderLedger && WF_TERMINAL_STATUSES.has(wfEnvelope.status))
+            if (leaderLedger && isCoreSemaTaskTerminal(wfEnvelope.status))
                 markEngineWorkflowNotified(wfEnvelope.taskId);
             return wrap({
                 task_id: wfEnvelope.taskId,
@@ -362,23 +416,22 @@ export function structuredToToolUseResult(structured, modelText, leaderLedger =
             };
         }
         case 'bash': {
-            if (s.detached === true && typeof s.task_id === 'string') {
+            const handoffTaskId = readBashDetachView(structured)?.handoffTaskId;
+            if (handoffTaskId !== undefined) {
                 return {
                     toolUseResult: {
                         stdout: '',
                         stderr: '',
                         interrupted: false,
-                        backgroundTaskId: s.task_id,
+                        backgroundTaskId: handoffTaskId,
                         backgroundedByUser: true,
                     },
                 };
             }
             if (typeof s.stdout !== 'string' && typeof s.stderr !== 'string')
                 return null;
-            const exitCode = typeof s.exitCode === 'number' ? s.exitCode : null;
-            const benignInterp = typeof s.returnCodeInterpretation === 'string' && s.returnCodeInterpretation.length > 0
-                ? s.returnCodeInterpretation
-                : undefined;
+            const exit = bashExitOf(structured, () => null);
+            const benignInterp = exit.benignNote;
             return {
                 toolUseResult: {
                     stdout: typeof s.stdout === 'string' ? s.stdout : '',
@@ -386,7 +439,7 @@ export function structuredToToolUseResult(structured, modelText, leaderLedger =
                     interrupted: false,
                     ...(benignInterp !== undefined ? { returnCodeInterpretation: benignInterp } : {}),
                 },
-                ...(exitCode !== null && exitCode !== 0 && benignInterp === undefined ? { isError: true } : {}),
+                ...(bashExitReadingFailed(exit) ? { isError: true } : {}),
             };
         }
         case 'edit': {
@@ -650,7 +703,7 @@ export function structuredToToolUseResult(structured, modelText, leaderLedger =
             const runErrorCode = typeof s.errorCode === 'string' && s.errorCode.length > 0 ? s.errorCode : undefined;
             let output = bodyText ?? '';
             if (taskType === 'workflow') {
-                if (leaderLedger && WF_TERMINAL_STATUSES.has(status))
+                if (leaderLedger && isCoreSemaTaskTerminal(status))
                     markEngineWorkflowNotified(taskId);
                 const jsonSrc = output.length > 0 ? output : (modelText ?? '');
                 output = projectWorkflowTaskOutput(jsonSrc);
@@ -716,9 +769,9 @@ export function detectEngineBgShellDetach(toolName, rawInput, structured, output
     if (toolName !== 'Bash')
         return null;
     const view = readBashDetachView(structured);
-    if (view === null || !view.detached || view.registerFailed || view.taskId === undefined)
+    if (view === null || view.registerFailed || view.handoffTaskId === undefined)
         return null;
-    return engineBgShellRegistrationBody(view.taskId, rawInput, typeof outputText === 'string' ? outputText : '', 'bash');
+    return engineBgShellRegistrationBody(view.handoffTaskId, rawInput, typeof outputText === 'string' ? outputText : '', 'bash');
 }
 function readBashDetachView(structured) {
     if (typeof structured !== 'object' || structured === null)
@@ -731,9 +784,8 @@ function readBashDetachView(structured) {
     const registerFailed = s.registerFailed;
     const taskId = s.task_id;
     return {
-        detached: detached === true,
+        handoffTaskId: detached === true && typeof taskId === 'string' && taskId.length > 0 ? taskId : undefined,
         registerFailed: registerFailed === true,
-        taskId: typeof taskId === 'string' && taskId.length > 0 ? taskId : undefined,
     };
 }
 export function todoWriteToolUseResult(rawInput, oldTodos, isError) {

package/dist/types/engineState.d.ts

@@ -1,5 +1,5 @@
 import type { EngineHealth } from '@sema-agent/sdk';
-export interface HealthResponse extends Pick<EngineHealth, 'status' | 'model' | 'sessionBackend' | 'sessions' | 'instanceId' | 'dataRoot' | 'configHash' | 'pid' | 'port' | 'restartRequired' | 'version' | 'restart'> {
+export interface HealthResponse extends Pick<EngineHealth, 'status' | 'model' | 'sessionBackend' | 'sessions' | 'instanceId' | 'dataRoot' | 'configHash' | 'pid' | 'port' | 'restartRequired' | 'version' | 'startedAt'> {
 }
 export interface EnginePortFile {
     port: number;
@@ -19,6 +19,7 @@ export interface EngineInstance {
     instanceId?: string;
     dataRoot?: string;
     configHash?: string;
+    startedAt?: number;
     logPath?: string;
     ownedByThisShell: boolean;
     child?: unknown;