@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -4,9 +4,11 @@ import { putOwnKey, readFrameStringKey } from '../../ownKey.js';
 import { REDACTION_MARKER_PREFIX, washCredentials } from '../../displayUntrusted.js';
 import { readEffectiveReasoning, readEffectiveMemoryScopes } from '../../effectiveFacts.js';
 import { isReviewPark, readRunTerminal, runTerminalCode, runTerminalGateToolName, } from '../../runTerminal.js';
+import { doneResultView } from '../../replayBody.js';
 import { toCcModelUsage } from './turnUsageToModelUsage.js';
 import { LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, OUTPUT_INVALID, isCorruptSessionCode, isRewindFamilyCode, } from '../../engineErrorCodes.js';
 import { corruptSessionContent } from '../../corruptSessionCopy.js';
+import { runBlockedText } from '../../promptBlockedCopy.js';
 import { abortCauseNoteOf, readAbortCause } from '../../runCancelContext.js';
 function withTerminalNote(text, code, frame) {
     const withCorrupt = isCorruptSessionCode(code) ? `${text}\n${corruptSessionContent()}` : text;
@@ -79,6 +81,11 @@ function permissionDenialParts(stats, observed) {
     const hr = stats?.humanReview;
     const gatesRaw = hr !== null && typeof hr === 'object' ? hr.gates : undefined;
     const denials = [];
+    const mergedKindOf = (callId) => (denialKindByCallId?.has(callId) === true ? denialKindByCallId.get(callId) : undefined);
+    const settledAsAbort = (callId) => {
+        const k = mergedKindOf(callId);
+        return isCcToolDenialKind(k) && !isCcToolDenialKindADenial(k);
+    };
     const gates = Array.isArray(gatesRaw) ? gatesRaw : [];
     let complete = Array.isArray(gatesRaw);
     for (const g of gates) {
@@ -100,6 +107,8 @@ function permissionDenialParts(stats, observed) {
         const toolName = nonEmptyStr(row.toolName);
         const toolArg = nonEmptyStr(row.toolArg);
         const toolUseId = nonEmptyStr(row.toolCallId);
+        if (toolUseId !== undefined && settledAsAbort(toolUseId))
+            continue;
         const rawInput = row.toolInput;
         const ledgerInput = rawInput !== null && typeof rawInput === 'object' && !Array.isArray(rawInput)
             ? rawInput
@@ -151,9 +160,9 @@ function permissionDenialParts(stats, observed) {
         for (const [callId, toolNameRaw] of deniedToolNameByCallId) {
             if (typeof callId !== 'string' || callId.length === 0 || ledgerDeniedIds.has(callId))
                 continue;
-            const mergedKind = denialKindByCallId?.has(callId) === true ? denialKindByCallId.get(callId) : undefined;
-            if (isCcToolDenialKind(mergedKind) && !isCcToolDenialKindADenial(mergedKind))
+            if (settledAsAbort(callId))
                 continue;
+            const mergedKind = mergedKindOf(callId);
             if (ledgerHasIdlessDenial) {
                 complete = false;
                 continue;
@@ -178,7 +187,8 @@ function permissionDenialParts(stats, observed) {
             complete = false;
     }
     const ccList = denials.filter((d) => d.tool_name !== undefined && d.tool_use_id !== undefined && d.tool_input !== undefined);
-    const claimable = complete && ccList.length === denials.length;
+    const streamCoversRun = observed?.streamSawRunOpen === true && observed.deniedToolNameByCallId !== undefined;
+    const claimable = complete && ccList.length === denials.length && streamCoversRun;
     const zeroOutputDenied = denials.length > 0 && observed?.streamSawRunOpen === true && observed.successfulToolEndObserved === false;
     return {
         permission_denials: ccList,
@@ -511,14 +521,16 @@ function errorResult(ctx, parts) {
     });
 }
 export function doneToSdkResult(ev, ctx, observed) {
-    const rRaw = ev.result;
+    const view = doneResultView(ev.result);
+    const rRaw = view.engine;
     const rec = typeof rRaw === 'object' && rRaw !== null ? rRaw : {};
     const r = rec;
     const stats = r.stats;
-    const echoedSid = r.sessionId;
+    const nestedSid = r.sessionId;
+    const echoedSid = typeof nestedSid === 'string' && nestedSid.length > 0 ? nestedSid : view.row?.sessionId;
     if (typeof echoedSid === 'string' && echoedSid.length > 0)
         ctx.sessionId = echoedSid;
-    const terminal = readRunTerminal(rRaw);
+    const terminal = readRunTerminal(ev.result);
     const durationMs = elapsedMs(ctx);
     const errorCode = runTerminalCode(terminal);
     const degraded = degradedOf(r);
@@ -548,15 +560,10 @@ export function doneToSdkResult(ev, ctx, observed) {
         });
     }
     if (terminal?.kind === 'blocked') {
-        const blockedReason = terminal.reason;
         return errorResult(ctx, {
             ...errorBase,
             subtype: 'error_during_execution',
-            errors: [
-                blockedReason !== undefined
-                    ? `Run blocked: ${blockedReason}`
-                    : 'Run blocked (the agent reported it cannot proceed)',
-            ],
+            errors: [runBlockedText(terminal)],
         });
     }
     if (terminal?.kind === 'paused') {

package/dist/adapter/runStream.js

@@ -3,13 +3,15 @@ import { eventToSdkMessage, turnEndUsage } from './downstream/eventToSdkMessage.
 import { turnUsageToModelUsage } from './downstream/turnUsageToModelUsage.js';
 import { readRunCostFacts, terminalToSdkResult, TOOL_INPUT_JOIN_MAX_CALLS } from './downstream/terminalToSdkResult.js';
 import { coerceOutput, publishSubagentContentEvent } from '../subagentContentStore.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
+import { OUTPUT_INVALID, activeRunBusyCarrierOf, classifyActiveRunBusy, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
+import { doneResultView } from '../replayBody.js';
 import { corruptSessionContent } from '../corruptSessionCopy.js';
 import { abortCauseNoteOf } from '../runCancelContext.js';
 import { classifyToolHistoryMismatch, noteToolHistoryTerminal, openToolHistoryGeneration, TOOL_HISTORY_REWIND_SENTENCE, toolHistoryMismatchRowKey, toolHistoryRepeatSentence, toolHistoryRewindOffered, } from '../toolHistoryMismatch.js';
 import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
 import { providerRejectionResend } from '../providerRejection.js';
 import { washCredentials } from '../displayUntrusted.js';
+import { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD, runBlockedText } from '../promptBlockedCopy.js';
 import { ccToolDenialKindForToolEnd, gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
 import { resumeReopenContent, resumeReopenFromError, suspendedReopenOf } from '../hitl/suspendedReopen.js';
 import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../gateVocabulary.js';
@@ -52,30 +54,10 @@ export function pendingGateIsProvablyDifferent(prev, next) {
     return a !== b;
 }
 export function activeRunBusySignal(ev) {
-    if (typeof ev !== 'object' || ev === null || !('type' in ev))
-        return null;
-    const type = ev.type;
-    let carrier;
-    if (type === 'done') {
-        const result = ev.result;
-        if (typeof result !== 'object' || result === null)
-            return null;
-        if (result.status !== 'failed')
-            return null;
-        carrier = result;
-    }
-    else if (type === 'failed') {
-        carrier = ev;
-    }
-    else {
-        return null;
-    }
-    const cls = classifyActiveRunBusy({
-        errorCode: typeof carrier.errorCode === 'string' ? carrier.errorCode : undefined,
-        activeTaskId: carrier.activeTaskId,
-    });
-    if (!cls.busy)
+    const read = busyReadOfFrame(ev);
+    if (read === null || !read.cls.busy)
         return null;
+    const { carrier, cls } = read;
     const status = carrier.activeTaskStatus;
     const rawGate = carrier.pendingGate;
     let pendingGate = null;
@@ -99,19 +81,22 @@ export function activeRunBusySignal(ev) {
         ...(typeof msIdle === 'number' && Number.isFinite(msIdle) && msIdle >= 0 ? { msSinceLastActivity: msIdle } : {}),
     };
 }
-function classifyActiveRunBusy(input) {
-    const handle = typeof input.activeTaskId === 'string' && input.activeTaskId.length > 0 ? input.activeTaskId : null;
-    if (input.errorCode === ACTIVE_RUN_BUSY_ERROR_CODE)
-        return { busy: true, handle };
-    if (typeof input.activeTaskId === 'string')
-        return { busy: true, handle };
-    return { busy: false, handle };
+function busyReadOfFrame(ev, doneTerminal, preReadActiveTaskId) {
+    const carrier = activeRunBusyCarrierOf(ev);
+    if (carrier === null)
+        return null;
+    const isDone = ev.type === 'done';
+    const terminal = isDone ? (doneTerminal !== undefined ? doneTerminal : readRunTerminal(ev.result)) : null;
+    const flatCode = typeof carrier.errorCode === 'string' ? carrier.errorCode : undefined;
+    const activeTaskId = preReadActiveTaskId !== undefined ? preReadActiveTaskId.value : carrier.activeTaskId;
+    const cls = classifyActiveRunBusy({ errorCode: (isDone ? runTerminalCode(terminal) : undefined) ?? flatCode, activeTaskId });
+    return { carrier, cls };
 }
 export const RUN_STOPPED_MESSAGE_PREFIX = 'Run stopped';
 export const RUN_BLOCKED_MESSAGE_PREFIX = 'Run blocked';
 export function isGovernanceStopRowText(text) {
     const t = text.trimStart();
-    return t.startsWith(`${RUN_STOPPED_MESSAGE_PREFIX}:`) || t.startsWith(`${RUN_BLOCKED_MESSAGE_PREFIX}`);
+    return t.startsWith(`${RUN_STOPPED_MESSAGE_PREFIX}:`) || t.startsWith(`${RUN_BLOCKED_MESSAGE_PREFIX}`) || t.startsWith(PROMPT_BLOCKED_BY_HOOK_ROW_LEAD);
 }
 export const MODEL_OUTPUT_ERROR_PREFIX = 'Model output error';
 export function isModelOutputErrorText(text) {
@@ -132,13 +117,17 @@ function syntheticTerminalRow(ctx, text, historyKey, resend) {
         parent_tool_use_id: null,
         _sema_api_error_message: true,
         ...(historyKey !== undefined ? { _sema_tool_history_mismatch: historyKey } : {}),
-        ...(resend !== undefined ? { _sema_provider_rejection_resend: { resend: resend.resend, text: resend.text } } : {}),
+        ...(resend !== undefined ? { _sema_provider_rejection_resend: { resend: resend.resend, text: resend.text, kind: resend.kind } } : {}),
     });
 }
 function engineRunIdOf(result) {
     const v = result?.runId;
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
+function engineResultOf(result) {
+    const v = doneResultView(result);
+    return v.replay ? (v.engine ?? result) : result;
+}
 function engineSessionIdOf(result) {
     const v = result?.sessionId;
     return typeof v === 'string' && v.length > 0 ? v : undefined;
@@ -160,19 +149,14 @@ function terminalRowFacts(ev) {
         : doneTerminal?.kind === 'failed'
             ? (doneTerminal.message ?? doneTerminal.code ?? 'run failed')
             : doneTerminal?.kind === 'blocked'
-                ? (doneTerminal.reason
-                    ? `Run blocked: ${doneTerminal.reason}`
-                    : 'Run blocked (the agent reported it cannot proceed)')
+                ? runBlockedText(doneTerminal)
                 : null;
     const errText = errTextRaw === '' ? null : errTextRaw;
     if (errText === null)
         return { doneTerminal, errText, activeTaskId: undefined, busy: { busy: false, handle: null }, governance: false };
     const activeTaskId = (ev.type === 'done' ? ev.result?.activeTaskId : undefined) ??
         (ev.type === 'failed' ? ev.activeTaskId : undefined);
-    const busy = classifyActiveRunBusy({
-        errorCode: ev.type === 'failed' ? ev.errorCode : runTerminalCode(doneTerminal),
-        activeTaskId,
-    });
+    const busy = busyReadOfFrame(ev, doneTerminal, { value: activeTaskId })?.cls ?? { busy: false, handle: null };
     const governance = isGovernanceTerminal({
         status: ev.type === 'failed' ? undefined : doneTerminal?.kind === 'blocked' ? 'blocked' : undefined,
         errorCode: ev.type === 'failed' ? ev.errorCode : runTerminalCode(doneTerminal),
@@ -283,7 +267,7 @@ function apiErrorTerminalFromFacts(x, facts) {
             return none();
         if (type === 'failed')
             return { carrier: mintToolHistoryCarrier(nonEmptyStr(ownDataBit(x, 'errorCode')), undefined, nonEmptyStr(ownDataBit(x, 'errorMessage'))), detail: undefined };
-        const result = type === 'done' ? plainObjectOf(ownDataBit(x, 'result')) : x;
+        const result = type === 'done' ? plainObjectOf(engineResultOf(ownDataBit(x, 'result'))) : x;
         if (result === undefined)
             return none();
         const snap = ownTerminalSnapshot(result);
@@ -666,12 +650,12 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 const abortNote = abortCauseNoteOf(ev);
                 const historyTerminal = apiErrorTerminalOfRowFrame(ev, rowFacts);
                 const historyMismatch = classifyToolHistoryMismatch(historyTerminal.carrier);
-                const historyEchoedSid = ev.type === 'done' ? engineSessionIdOf(ev.result) : undefined;
+                const historyEchoedSid = ev.type === 'done' ? engineSessionIdOf(engineResultOf(ev.result)) : undefined;
                 const historyRepeat = noteToolHistoryTerminal({
                     sessionId: historyEchoedSid ?? ctx.sessionId,
                     sessionEchoed: historyEchoedSid !== undefined,
                     generation: historyGeneration,
-                    runId: ev.type === 'done' ? engineRunIdOf(ev.result) : undefined,
+                    runId: ev.type === 'done' ? engineRunIdOf(engineResultOf(ev.result)) : undefined,
                     replay: ev.type === 'done' && ev.replay === true,
                     mismatch: historyMismatch,
                 });
@@ -684,12 +668,12 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 yield syntheticTerminalRow(ctx, `${sessionUnreadable ? `${rowText}\n${corruptSessionContent()}` : rowText}${abortNote !== undefined ? `\n${abortNote}` : ''}${rewindLine}${resendLine}`, historyMismatch === null ? undefined : toolHistoryMismatchRowKey(historyMismatch, historyRepeat, rewindOffered), resend);
             }
             else {
-                const echoedSid = ev.type === 'done' ? engineSessionIdOf(ev.result) : undefined;
+                const echoedSid = ev.type === 'done' ? engineSessionIdOf(engineResultOf(ev.result)) : undefined;
                 noteToolHistoryTerminal({
                     sessionId: echoedSid ?? ctx.sessionId,
                     sessionEchoed: echoedSid !== undefined,
                     generation: historyGeneration,
-                    runId: ev.type === 'done' ? engineRunIdOf(ev.result) : undefined,
+                    runId: ev.type === 'done' ? engineRunIdOf(engineResultOf(ev.result)) : undefined,
                     replay: ev.type === 'done' && ev.replay === true,
                     mismatch: null,
                 });
@@ -701,7 +685,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 catch { }
             }
             if (ev.type === 'done' && ctx.emitChrome) {
-                const doneStats = ev.result?.stats;
+                const doneStats = engineResultOf(ev.result)?.stats;
                 const costFacts = readRunCostFacts(doneStats, { usageMissingObserved });
                 if (costFacts !== undefined) {
                     emitChromeFireAndForget(ctx, { kind: 'run_cost_reconciled', laneProof: mainLane(), ...costFacts.reconcile });

package/dist/adapter/types.d.ts

@@ -31,6 +31,13 @@ export declare function stamp<T extends {
     uuid: string;
     session_id: string;
 };
+export interface ToolUseSideChannelsStripped<B extends object> {
+    readonly block: Omit<B, 'label' | 'eventId' | 'parentToolCallId'>;
+    readonly eventId?: string;
+    readonly parentToolCallId?: string;
+    readonly label?: string;
+}
+export declare function stripToolUseSideChannels<B extends object>(block: B): ToolUseSideChannelsStripped<B>;
 export declare const SEGMENT_END_IDENTITY_KEYS: readonly ["parentToolCallId", "sourceTaskId", "bgAgentId"];
 export declare function isSubFlowSegmentEnd(m: object): boolean;
 export declare function snapshotSegmentIdentity(m: object): Record<string, unknown> | null;

package/dist/adapter/types.js

@@ -14,6 +14,21 @@ export function uuid() {
 export function stamp(ctx, body) {
     return { ...body, uuid: body.uuid ?? uuid(), session_id: ctx.sessionId };
 }
+export function stripToolUseSideChannels(block) {
+    const out = { ...block };
+    const eventId = typeof out.eventId === 'string' ? out.eventId : undefined;
+    const parentToolCallId = typeof out.parentToolCallId === 'string' ? out.parentToolCallId : undefined;
+    const label = typeof out.label === 'string' ? out.label : undefined;
+    delete out.label;
+    delete out.eventId;
+    delete out.parentToolCallId;
+    return {
+        block: out,
+        ...(eventId !== undefined ? { eventId } : {}),
+        ...(parentToolCallId !== undefined ? { parentToolCallId } : {}),
+        ...(label !== undefined ? { label } : {}),
+    };
+}
 export const SEGMENT_END_IDENTITY_KEYS = Object.freeze(['parentToolCallId', 'sourceTaskId', 'bgAgentId']);
 export function isSubFlowSegmentEnd(m) {
     const rec = m;

package/dist/agentSession/backgroundView.js

@@ -157,7 +157,11 @@ export function createBackgroundView(client, opts) {
         }
         catch (err) {
             debugLog(`assistant.tasks degrade: ${String(err)}`);
-            const health = capsApprovals === false || isNotImplemented(err) ? 'not-configured' : 'unavailable';
+            const health = capsApprovals === false || isNotImplemented(err)
+                ? 'not-configured'
+                : isReadCredentialRefusal(err)
+                    ? 'unauthorized'
+                    : 'unavailable';
             return { health, tasks: [] };
         }
     }

package/dist/agentSession/engineAgentRegistryRead.js

@@ -1,5 +1,7 @@
 import { errCodes } from '../controlRouter.js';
 import { hostLog } from '../host.js';
+import { isSessionIdPathSegment } from '../sessionIdSegment.js';
+import { ownDataField } from '../ownKey.js';
 const unavailable = (why) => ({
     kind: 'unavailable',
     why,
@@ -57,12 +59,12 @@ export function isEngineAgentRegistryListingSuperseded(listing) {
     return registryListingProvenanceOf(listing)?.superseded === true;
 }
 function listFaceOn(caps) {
-    if (typeof caps !== 'object' || caps === null || !Object.hasOwn(caps, 'background'))
+    if (typeof caps !== 'object' || caps === null)
         return false;
-    const bg = caps.background;
-    if (typeof bg !== 'object' || bg === null || !Object.hasOwn(bg, 'listFace'))
+    const bg = ownDataField(caps, 'background');
+    if (typeof bg !== 'object' || bg === null)
         return false;
-    return bg.listFace === true;
+    return ownDataField(bg, 'listFace') === true;
 }
 function readRow(v) {
     if (typeof v !== 'object' || v === null || Array.isArray(v))
@@ -95,7 +97,7 @@ export async function readEngineAgentRegistry(client, sessionId, caps, opts) {
 async function readOnce(client, sessionId, caps, opts) {
     if (!listFaceOn(caps))
         return unavailable('no_list_face');
-    if (typeof sessionId !== 'string' || sessionId.length === 0) {
+    if (!isSessionIdPathSegment(sessionId)) {
         noteReadFailed('bad session id');
         return unavailable('read_failed');
     }

package/dist/agentSession/engineSessionBackgroundStop.js

@@ -1,12 +1,13 @@
-import { engineCapValue } from '../engineCapsCache.js';
+import { engineCapNestedValue } from '../engineCapsCache.js';
 import { isStatusDerivedCoarseCode } from '../engineErrorCodes.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
 import { engineWireDebugEnabled } from '../engineWireTarget.js';
 import { hostLog } from '../host.js';
+import { isSessionIdPathSegment } from '../sessionIdSegment.js';
 import { wireFailureTextsOf } from '../wireFailureShape.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 const NOTHING_SENT = ' — nothing sent';
-const DETAIL_BAD_SESSION = `the session id must be a non-empty string${NOTHING_SENT}`;
+const DETAIL_BAD_SESSION = `the session id must be a non-empty string that is not a dot segment${NOTHING_SENT}`;
 const DETAIL_BAD_INCLUDE_RETAINED = `includeRetained must be true or false (the engine has no default for it)${NOTHING_SENT}`;
 const DETAIL_BAD_OPTIONS = `the options could not be read${NOTHING_SENT}`;
 const DETAIL_BAD_ARGUMENTS = `the arguments could not be read${NOTHING_SENT}`;
@@ -17,6 +18,8 @@ const DETAIL_NO_TARGET = `no engine connection is installed for this session${NO
 const DETAIL_NO_CLIENT = `an engine client could not be built from the installed connection${NOTHING_SENT}`;
 const DETAIL_CAPS_KEY_REQUIRED = `capability evidence for background.exitFaces is not available under the key the host named (capsBaseUrl)${NOTHING_SENT}`;
 const DETAIL_CAPS_UNOBSERVED = `the engine capabilities have not been read for this connection yet — wait for the capability probe to settle, then call again${NOTHING_SENT}`;
+const DETAIL_CAPS_UNREADABLE = `the engine reported its capabilities in a form this client cannot read, so whether it offers the session background stop is unknown — calling again on this connection will not change that${NOTHING_SENT}`;
+const DETAIL_CAPS_UNKNOWN_GENERIC = `whether the engine offers the session background stop is unknown${NOTHING_SENT}`;
 const DETAIL_NO_EXIT_FACE = `this engine does not offer the session background stop (capabilities.background.exitFaces is not true); background tasks may keep running${NOTHING_SENT}`;
 function refusedDetail(why) {
     switch (why) {
@@ -66,22 +69,27 @@ function unavailable(why, detail) {
 function usableStopClient(client) {
     return clientHasVerbs(client, [['sessions', 'backgroundStop']]);
 }
-function exitFaceGate(capsKey) {
-    try {
-        const v = engineCapValue(capsKey, 'background');
-        if (v.kind === 'unobserved')
-            return { why: 'capability_unknown', detail: DETAIL_CAPS_UNOBSERVED };
-        if (v.kind !== 'value')
-            return { why: 'no_exit_face', detail: DETAIL_NO_EXIT_FACE };
-        const bg = v.value;
-        if (typeof bg !== 'object' || bg === null || !Object.hasOwn(bg, 'exitFaces'))
-            return { why: 'no_exit_face', detail: DETAIL_NO_EXIT_FACE };
-        return bg.exitFaces === true ? null : { why: 'no_exit_face', detail: DETAIL_NO_EXIT_FACE };
-    }
-    catch {
-        return { why: 'capability_unknown', detail: DETAIL_CAPS_UNOBSERVED };
+function capsUnknownDetail(reason) {
+    switch (reason) {
+        case 'unobserved':
+            return DETAIL_CAPS_UNOBSERVED;
+        case 'unreadable':
+            return DETAIL_CAPS_UNREADABLE;
+        default: {
+            const unreachable = reason;
+            void unreachable;
+            return DETAIL_CAPS_UNKNOWN_GENERIC;
+        }
     }
 }
+function exitFaceGate(capsKey) {
+    const v = engineCapNestedValue(capsKey, 'background', 'exitFaces');
+    if (v.kind === 'unobserved')
+        return { why: 'capability_unknown', detail: capsUnknownDetail('unobserved') };
+    if (v.kind === 'unreadable')
+        return { why: 'capability_unknown', detail: capsUnknownDetail('unreadable') };
+    return v.kind === 'value' && v.value === true ? null : { why: 'no_exit_face', detail: DETAIL_NO_EXIT_FACE };
+}
 function readReceipt(v) {
     if (typeof v !== 'object' || v === null || Array.isArray(v))
         return undefined;
@@ -202,7 +210,7 @@ export async function stopEngineSessionBackground(sessionId, body, opts) {
     let signal;
     let sessionKey;
     try {
-        if (typeof sessionId !== 'string' || sessionId.length === 0)
+        if (!isSessionIdPathSegment(sessionId))
             return unavailable('bad_input', DETAIL_BAD_SESSION);
         const flag = typeof body === 'object' && body !== null && Object.hasOwn(body, 'includeRetained') ? body.includeRetained : undefined;
         if (typeof flag !== 'boolean')

package/dist/agentsWireCaps.d.ts

@@ -15,6 +15,8 @@ export type TaskAgentWireSkill = {
     name: string;
     description: string;
     content: string;
+    allowedTools?: string[];
+    disallowedTools?: string[];
 };
 export declare const AGENT_MEMORY_WORDS: ReadonlySet<string>;
 export type TaskAgentWireMemory = {

package/dist/agentsWireCaps.js

@@ -1,4 +1,5 @@
 import { hostEnv } from './hostEnv.js';
+import { ownDataField } from './ownKey.js';
 import { makeEngineWireClient } from './engineWireSdk.js';
 import { frozenSet } from './frozenSet.js';
 import { settleWithinDeadline } from './abortableSleep.js';
@@ -289,7 +290,7 @@ export async function engineSupportsTaskAgents(baseUrl, opts) {
         if (typeof injected?.capabilities !== 'function')
             return undefined;
         const got = await settleWithinDeadline(opts.timeoutMs ?? 3000, (signal) => injected.capabilities({ signal }));
-        return got.kind === 'value' ? got.value?.taskAgents === true : undefined;
+        return got.kind === 'value' ? taskAgentsOf(got.value) : undefined;
     }
     const client = makeEngineWireClient({
         baseUrl,
@@ -302,7 +303,17 @@ export async function engineSupportsTaskAgents(baseUrl, opts) {
         return undefined;
     try {
         const caps = await client.capabilities();
-        return caps?.taskAgents === true;
+        return taskAgentsOf(caps);
+    }
+    catch {
+        return undefined;
+    }
+}
+function taskAgentsOf(caps) {
+    if (caps === null || typeof caps !== 'object')
+        return false;
+    try {
+        return ownDataField(caps, 'taskAgents') === true;
     }
     catch {
         return undefined;

package/dist/approvalDecidedByCapability.d.ts

@@ -12,5 +12,4 @@ export declare function noteEngineCapsForApprovalDecidedBy(baseUrl: string, caps
 }): void;
 export declare function observedApprovalDecidedBy(baseUrl?: string | undefined): ApprovalDecidedByReading;
 export declare function approvalDecidedByAdmitted(reading: ApprovalDecidedByReading | undefined): boolean;
-export declare function forgetApprovalDecidedByReading(baseUrl: string | undefined): void;
 export declare function __resetApprovalDecidedByReadingsForTests(): void;

package/dist/approvalDecidedByCapability.js

@@ -1,13 +1,11 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
-import { readOwnDataValue } from './ownKey.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
 export function projectApprovalDecidedByCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'approvalDecidedBy'))
-            return { kind: 'not_reported' };
-        const v = caps.approvalDecidedBy;
+        const v = ownDataField(caps, 'approvalDecidedBy');
         if (v === undefined)
             return { kind: 'not_reported' };
         return v === true ? { kind: 'present', value: true } : undefined;
@@ -39,9 +37,6 @@ export function approvalDecidedByAdmitted(reading) {
         return false;
     }
 }
-export function forgetApprovalDecidedByReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetApprovalDecidedByReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/approvalsStreamLiveCapability.d.ts

@@ -13,5 +13,4 @@ export declare function noteEngineCapsForApprovalsStreamLive(baseUrl: string, ca
 export declare function observedApprovalsStreamLive(baseUrl?: string | undefined): ApprovalsStreamLiveReading;
 export declare function livePendingNeedsReconcile(reading: ApprovalsStreamLiveReading): boolean;
 export declare function approvalsStreamLiveDoctorDetail(reading: ApprovalsStreamLiveReading): string;
-export declare function forgetApprovalsStreamLiveReading(baseUrl: string | undefined): void;
 export declare function __resetApprovalsStreamLiveReadingsForTests(): void;

package/dist/approvalsStreamLiveCapability.js

@@ -1,14 +1,13 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectApprovalsStreamLiveCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object')
             return undefined;
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'approvalsStreamLive'))
-            return { kind: 'not_reported' };
-        const v = caps.approvalsStreamLive;
+        const v = ownDataField(caps, 'approvalsStreamLive');
         if (v === undefined)
             return { kind: 'not_reported' };
         if (typeof v !== 'boolean')
@@ -45,9 +44,6 @@ export function approvalsStreamLiveDoctorDetail(reading) {
                 : 'live approval push off on this deployment (no checkpoint store or tool approvals disabled; the engine reports one bit for both, so this client cannot tell which) — suspended asks are only visible through the reconcile cadence, so the client polls for them';
     }
 }
-export function forgetApprovalsStreamLiveReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetApprovalsStreamLiveReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/atMostOnce.d.ts

@@ -0,0 +1,8 @@
+export declare function atMostOnceFailureClass(e: unknown): 'rejected' | 'unknown';
+export interface AtMostOnceVerdict {
+    readonly delivery: 'rejected' | 'unknown';
+    readonly status?: number;
+    readonly code?: string;
+    readonly name?: string;
+}
+export declare function atMostOnceVerdictOf(e: unknown): AtMostOnceVerdict;

package/dist/atMostOnce.js

@@ -0,0 +1,36 @@
+import { errCodes, steeringRefusedBeforeEngine, steeringStatusIs4xx } from './controlRouter.js';
+function errorSlot(e, key) {
+    if (e === null || e === undefined)
+        return undefined;
+    try {
+        return e[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+export function atMostOnceFailureClass(e) {
+    const s = atMostOnceSnapshotOf(e);
+    if (steeringStatusIs4xx(s))
+        return 'rejected';
+    return steeringRefusedBeforeEngine(s) !== undefined ? 'rejected' : 'unknown';
+}
+function atMostOnceSnapshotOf(e) {
+    return {
+        status: errorSlot(e, 'status'),
+        statusCode: errorSlot(e, 'statusCode'),
+        errorCode: errorSlot(e, 'errorCode'),
+        name: errorSlot(e, 'name'),
+    };
+}
+export function atMostOnceVerdictOf(e) {
+    const snapshot = atMostOnceSnapshotOf(e);
+    const delivery = atMostOnceFailureClass(snapshot);
+    const { status, code, name } = errCodes(snapshot);
+    return {
+        delivery,
+        ...(status !== undefined ? { status } : {}),
+        ...(code !== undefined && code !== '' ? { code } : {}),
+        ...(name !== undefined && name !== '' ? { name } : {}),
+    };
+}

package/dist/attachmentSeatCapability.d.ts

@@ -7,5 +7,4 @@ export declare function noteEngineCapsForAttachmentSeat(baseUrl: string, caps: u
     generation?: number;
 }): void;
 export declare function observedAttachmentSeat(baseUrl?: string | undefined): AttachmentSeatReading;
-export declare function forgetAttachmentSeatReading(baseUrl: string | undefined): void;
 export declare function __resetAttachmentSeatReadingsForTests(): void;

package/dist/attachmentSeatCapability.js

@@ -19,9 +19,6 @@ export function noteEngineCapsForAttachmentSeat(baseUrl, caps, opts) {
 export function observedAttachmentSeat(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
-export function forgetAttachmentSeatReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetAttachmentSeatReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/attachmentsWireCaps.js

@@ -23,8 +23,14 @@ const OPT_IN_KEYS = [
     'mcpInstructions',
 ];
 const DEFAULT_ON_ONLY_KEYS = ['agentListing', 'skillsListing'];
-const DEFAULT_PAIR = ['backgroundTasks', 'toolsDelta'];
-const _attachmentsKeyPins = [true, true, true, true, true, true];
+const PRODUCT_DEFAULT_KEYS = ['backgroundTasks', 'toolsDelta', 'todoReminder'];
+function productDefaultAttachments() {
+    const out = {};
+    for (const k of PRODUCT_DEFAULT_KEYS)
+        out[k] = true;
+    return out;
+}
+const _attachmentsKeyPins = [true, true, true, true, true, true, true];
 void _attachmentsKeyPins;
 const TODO_REMINDER_MODES = ['baseline', 'off'];
 export class AttachmentsSpecRefused extends TypeError {
@@ -61,11 +67,11 @@ function judgeAttachmentsEnv(raw) {
             return { ok: false, refusal: { kind: 'retired_key', token, why: named.why, entry: i + 1, key: named.key, retired: named } };
     }
     if (tokens.length === 0)
-        return { ok: true, spec: { backgroundTasks: true, toolsDelta: true } };
+        return { ok: true, spec: productDefaultAttachments() };
     if (tokens.length === 1 && (tokens[0] === 'full' || tokens[0] === 'all'))
         return { ok: true, spec: allLiteralTrue() };
     if (tokens.length === 1 && !isKnownToken(tokens[0])) {
-        return { ok: true, spec: { backgroundTasks: true, toolsDelta: true } };
+        return { ok: true, spec: productDefaultAttachments() };
     }
     const spec = {};
     for (const [i, token] of tokens.entries()) {
@@ -74,8 +80,7 @@ function judgeAttachmentsEnv(raw) {
             continue;
         }
         if (token === 'default') {
-            for (const k of DEFAULT_PAIR)
-                spec[k] = true;
+            Object.assign(spec, productDefaultAttachments());
             continue;
         }
         if (token.startsWith('-')) {