@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/adapt/arms.js

@@ -9,9 +9,11 @@ import { recordEngineToolLabel } from '../engineToolLabelStore.js';
 import { registerSubagentAlias, registerSubagentContentAlias } from '../subagentContentStore.js';
 import { readAsyncLaunchedAgentReceipt } from '../toolResult.js';
 import { recordWorkflowAgentTaskId } from '../workflow.js';
-import { isTerminalStatus } from '../runTerminal.js';
+import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess, isCoreTaskProgressTerminal, isCoreTaskProgressTerminalNotSuccess } from '../terminalStatuses.js';
 import { readToolHistoryMismatchKey } from '../toolHistoryMismatch.js';
 import { readProviderRejectionResendKey } from '../providerRejection.js';
+import { readFrameStringKey } from '../ownKey.js';
+import { washCredentials } from '../displayUntrusted.js';
 import { resolveEnginePanelTaskId } from '../engineAgentPanelStore.js';
 import { fleetRowAgentType } from '../fleet/fleetRowAgentType.js';
 import { chrome, mainLane, transcript, messageIdentityOf } from './ids.js';
@@ -126,12 +128,13 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
     }
     const textBlock = blocks.find(b => b?.type === 'text');
     if (textBlock && typeof textBlock.text === 'string' && textBlock.text.length > 0) {
-        text.appendAnswer(textBlock.text);
+        const rowText = m._sema_api_error_message === true ? washCredentials(textBlock.text) : textBlock.text;
+        text.appendAnswer(rowText);
         text.beginAssistantMessage();
         yield* text.takeThinking();
         yield transcript({
             type: 'assistant',
-            message: { role: 'assistant', content: [{ type: 'text', text: textBlock.text }], ...messageIdentityOf(m, ctx) },
+            message: { role: 'assistant', content: [{ type: 'text', text: rowText }], ...messageIdentityOf(m, ctx) },
             uuid: idOf(m),
             session_id: ctx.sessionId,
             parent_tool_use_id: null,
@@ -139,7 +142,7 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
             ...toolHistoryKeyCarry(m),
             ...providerResendKeyCarry(m),
         }, ctx.now());
-        text.markEmittedText(textBlock.text);
+        text.markEmittedText(rowText);
     }
     const thinkingBlock = blocks.find(b => b?.type === 'thinking');
     if (thinkingBlock && typeof thinkingBlock.thinking === 'string') {
@@ -569,7 +572,6 @@ const toolEndResultArm = function* (m, { idOf, cards, panel }) {
         });
     }
 };
-const TERMINAL_TICK_STATUSES = new Set(['completed', 'failed']);
 const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
     const taskIdRaw = m.taskId;
     const taskId = typeof taskIdRaw === 'string' ? taskIdRaw : undefined;
@@ -658,9 +660,9 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
             totalTokens: typeof usage.totalTokens === 'number' ? usage.totalTokens : 0,
         },
     });
-    if (typeof m.status === 'string' && TERMINAL_TICK_STATUSES.has(m.status) && !panel.isLiveBound(taskId)) {
+    if (isCoreTaskProgressTerminal(m.status) && !panel.isLiveBound(taskId)) {
         ctx.probe?.('tick', JSON.stringify({ t: ctx.now(), taskId, lane: 'foreground', settle: m.status }));
-        yield* panel.settleFromTerminalTick(taskId, m.status === 'failed');
+        yield* panel.settleFromTerminalTick(taskId, isCoreTaskProgressTerminalNotSuccess(m.status));
     }
 };
 const streamEventArm = function* (m, { text }) {
@@ -712,9 +714,9 @@ const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
         return lowerBound && ot === 0 ? undefined : ot;
     });
     yield* text.takeAnswerSegment();
-    const salvaged = m._sema_salvaged_result;
+    const salvaged = readFrameStringKey(m, '_sema_salvaged_result');
     const errorEnvelope = typeof m.subtype === 'string' && m.subtype.startsWith(ERROR_SUBTYPE_PREFIX);
-    const terminalText = typeof salvaged === 'string' ? salvaged : !errorEnvelope && typeof m.result === 'string' ? m.result : '';
+    const terminalText = salvaged !== undefined ? salvaged : !errorEnvelope && typeof m.result === 'string' ? m.result : '';
     const committed = text.lastCommittedAnswerText;
     const terminalIdentity = messageIdentityOf(m, ctx);
     const emitTerminal = function* (body, tag) {
@@ -763,7 +765,7 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
         return;
     const taskId = fields.taskId;
     const rawStatus = fields.status;
-    const terminal = isTerminalStatus(rawStatus);
+    const terminal = isCoreTaskNotificationTerminal(rawStatus);
     const settleAllowed = n.task_type === undefined || n.task_type === 'background_bash' || n.task_type === 'monitor';
     if (settleAllowed && terminal) {
         yield chrome({
@@ -795,7 +797,7 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
         });
         dropQueuedNotificationsForRun(taskId);
         if (n.task_type !== 'background_bash' && n.task_type !== 'monitor') {
-            yield* panel.settleFromNotification(taskId, rawStatus !== 'completed');
+            yield* panel.settleFromNotification(taskId, isCoreTaskNotificationTerminalNotSuccess(rawStatus));
         }
     }
     const peerFrame = classifyPeerNotification(n);

package/dist/adapt/panelTasks.js

@@ -1,9 +1,9 @@
 import { clearEnginePanelTaskResident, clearEnginePanelTaskResidentByWire, markEnginePanelTaskResident } from '../engineAgentPanelStore.js';
+import { panelEndFact } from '../panelReduce.js';
 import { chrome, mainLane } from './ids.js';
 import { SUBAGENT_TOOL_NAMES } from './wireShapes.js';
 export function createPanelTaskLedger(ctx, cards, inst) {
     const taskCardBinding = new Map();
-    const boundToolCalls = new Set();
     const livePanelTasks = new Set();
     const endedPanelTasks = new Set();
     const liveBoundPanelTasks = new Set();
@@ -33,7 +33,6 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 return undefined;
             const target = parentToolCallId;
             taskCardBinding.set(taskId, target);
-            boundToolCalls.add(target);
             if (cards.has(target))
                 liveBoundPanelTasks.add(taskId);
             ctx.probe?.('bind', `bind ${taskId} -> ${target} via=explicit`);
@@ -85,12 +84,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 yield chrome({
                     kind: 'panel_task',
                     laneProof: mintLane(),
-                    event: {
-                        kind: 'end',
-                        taskId,
-                        isError,
-                        ...(cardId !== null && report !== undefined ? { report } : {}),
-                    },
+                    event: panelEndFact(taskId, isError, cardId !== null && report !== undefined ? { report } : undefined),
                 });
             }
         },
@@ -102,7 +96,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
             yield chrome({
                 kind: 'panel_task',
                 laneProof: mainLane(),
-                event: { kind: 'end', taskId, isError },
+                event: panelEndFact(taskId, isError),
             });
             if (inst.hasFiredSubagentStart(taskId)) {
                 yield chrome({
@@ -144,7 +138,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
             yield chrome({
                 kind: 'panel_task',
                 laneProof: mintLane(),
-                event: { kind: 'end', taskId, isError },
+                event: panelEndFact(taskId, isError),
             });
         },
     };

package/dist/adapt/toolCards.js

@@ -34,15 +34,15 @@ export function createToolCardLedger(ctx, idOf) {
     let lastLiveTodos = [];
     function* buildToolResult(p, end) {
         const isError = end?.isError ?? false;
+        const parentToolCallId = end?.parentToolCallId ?? p.parentToolCallId;
         if ((p.name === 'Bash' || p.name === 'Monitor') && !isError) {
             const outputText = end?.output !== undefined ? flattenWireOutput(end.output) : undefined;
             const reg = detectEngineBgShellDetach(p.name, p.rawInput, end?.structured, outputText) ??
                 detectEngineBgShellReceipt(p.name, p.rawInput, outputText, end?.structured);
             if (reg !== null) {
-                yield chrome({ kind: 'bgshell_register', laneProof: mainLane(), taskId: reg.taskId, registration: reg });
+                yield chrome({ kind: 'bgshell_register', laneProof: parentToolCallId === undefined ? mainLane() : { lane: 'subagent', parentToolCallId }, taskId: reg.taskId, registration: reg });
             }
         }
-        const parentToolCallId = end?.parentToolCallId ?? p.parentToolCallId;
         const outcome = toolResultOutcomeOf(p.name, end, p.rawInput, parentToolCallId === undefined ? 'leader' : 'subagent', (err) => {
             if (p.name !== 'TodoWrite')
                 return null;

package/dist/adapt/wireShapes.js

@@ -1,4 +1,5 @@
 import { frozenSet } from '../frozenSet.js';
+import { stripToolUseSideChannels } from '../adapter/types.js';
 export const FLUSH_INTERVAL_MS = 100;
 export const IDLE_FLUSH_MS = 1500;
 export const SUBAGENT_TOOL_NAMES = frozenSet(['Task', 'Agent', 'Fork']);
@@ -47,14 +48,8 @@ export function shortTaskLabel(task) {
     return label || 'subagent';
 }
 export function sanitizeToolUseBlock(block) {
-    const out = { ...block };
-    const rawInput = out.input;
-    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;
+    const rawInput = block.input;
+    const { block: out, eventId, parentToolCallId, label } = stripToolUseSideChannels(block);
     if (out.input && typeof out.input === 'object') {
         const cleaned = {};
         for (const [k, val] of Object.entries(out.input)) {

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -1,5 +1,6 @@
 import type { ActiveRunBusySignal } from './runStream.js';
 import type { PlanReviewReopenTrigger } from '../hitl/planReviewWire.js';
+import { atMostOnceFailureClass } from '../atMostOnce.js';
 export declare const PLAN_REVIEW_GATE_KIND = "plan_review";
 export declare const PLAN_REVIEW_GATE_KINDS: readonly string[];
 export declare const ASK_PARK_GATE_KINDS: readonly string[];
@@ -9,7 +10,6 @@ export declare function askParkForeignGateKind(row: {
 export declare const PLAN_REVIEW_STATES: readonly string[];
 export declare const ASK_PARK_STATES: readonly string[];
 export declare const RUNNING_STATES: readonly string[];
-export declare const CLAIM_RELEASED_STATES: readonly string[];
 export declare const CLAIM_HELD_STATES: readonly string[];
 export interface DurableRunRecordView {
     readonly status?: unknown;
@@ -47,6 +47,7 @@ export interface RunningChoiceRequest {
     status: string;
     canSteer: boolean;
     canCancel: boolean;
+    canAttach?: true;
 }
 export interface StaleParkChoiceRequest {
     taskId: string;
@@ -62,7 +63,8 @@ export interface ActiveRunSelfHealDeps {
         trigger?: PlanReviewReopenTrigger;
     }) => ReopenCardVerdict | Promise<ReopenCardVerdict>;
     reopenAskPark?: (taskId: string) => Promise<ReopenCardVerdict>;
-    offerRunningChoice?: (req: RunningChoiceRequest) => Promise<'steer' | 'cancel' | 'wait'>;
+    offerRunningChoice?: (req: RunningChoiceRequest) => Promise<'steer' | 'cancel' | 'wait' | 'attach'>;
+    canAttachRunning?: boolean;
     offerStaleParkChoice?: (req: StaleParkChoiceRequest) => Promise<'cancel' | 'wait'>;
     deniedMessage?: string;
     signal?: AbortSignal;
@@ -134,6 +136,9 @@ export type SelfHealOutcome = {
     taskId: string;
     detail: string;
     delivery: 'rejected' | 'unknown';
+} | {
+    kind: 'running-attach';
+    taskId: string;
 } | {
     kind: 'running-cancelled';
     taskId: string;
@@ -191,7 +196,7 @@ export interface SelfHealFollowDeclaration {
     following?: boolean;
 }
 export declare function readCancelRequested(body: unknown): boolean | undefined;
-export declare function atMostOnceFailureClass(e: unknown): 'rejected' | 'unknown';
+export { atMostOnceFailureClass };
 export declare function clearRunningChoiceOffer(taskId: string, sessionId?: string): void;
 export declare function __resetRunningChoiceLedgerForTests(): void;
 export interface ClaimReleaseVerdict {

package/dist/adapter/activeRunSelfHeal.js

@@ -1,7 +1,10 @@
 import { abortableSleep } from '../abortableSleep.js';
 import { corruptStoredRowContent, corruptStoredRowWhere, effectiveWireErrorCode } from '../wireErrorTriage.js';
-import { steerBodyOf, steeringRefusedBeforeEngine, steeringStatusIs4xx, UNOBSERVED_STEER_PRIORITY } from '../controlRouter.js';
+import { steerBodyOf, UNOBSERVED_STEER_PRIORITY } from '../controlRouter.js';
+import { atMostOnceFailureClass } from '../atMostOnce.js';
 import { readSteerReceipt } from '../steerReceipt.js';
+import { resumeAttachReplayDisclosure, runningAttachOffered } from '../hitl/resumeRunningCard.js';
+import { isSdkRunTerminal, SDK_PARKED_RUN_STATUSES } from '../terminalStatuses.js';
 export const PLAN_REVIEW_GATE_KIND = 'plan_review';
 export const PLAN_REVIEW_GATE_KINDS = Object.freeze([PLAN_REVIEW_GATE_KIND, 'dry_run_review']);
 export const ASK_PARK_GATE_KINDS = Object.freeze(['human', 'irreversible_ask', 'policy_ask', 'tool_approval']);
@@ -12,8 +15,7 @@ export function askParkForeignGateKind(row) {
 export const PLAN_REVIEW_STATES = Object.freeze(['needs_review']);
 export const ASK_PARK_STATES = Object.freeze(['suspended']);
 export const RUNNING_STATES = Object.freeze(['running']);
-export const CLAIM_RELEASED_STATES = Object.freeze(['completed', 'failed', 'blocked', 'timeout']);
-export const CLAIM_HELD_STATES = Object.freeze(['running', 'suspended', 'needs_review']);
+export const CLAIM_HELD_STATES = Object.freeze(['running', ...SDK_PARKED_RUN_STATUSES]);
 export function selfHealSubmissionDisposition(outcome) {
     switch (outcome.kind) {
         case 'decision-pending':
@@ -29,6 +31,8 @@ export function selfHealSubmissionDisposition(outcome) {
             return 'not-delivered';
         case 'running-steered':
             return 'handed-off';
+        case 'running-attach':
+            return 'not-delivered';
         default:
             return 'not-delivered';
     }
@@ -261,11 +265,7 @@ function reopenedOfOutcome(outcome) {
         return null;
     }
 }
-export function atMostOnceFailureClass(e) {
-    if (typeof e === 'object' && e !== null && steeringStatusIs4xx(e))
-        return 'rejected';
-    return typeof e === 'object' && e !== null && steeringRefusedBeforeEngine(e) !== undefined ? 'rejected' : 'unknown';
-}
+export { atMostOnceFailureClass };
 const CANCEL_RELEASE_WAIT_MS = 10_000;
 const RUNNING_LIVENESS_RECHECK_TIMEOUT_MS = 4_000;
 const runningChoiceDeclined = new Set();
@@ -365,7 +365,7 @@ export async function waitForClaimRelease(taskId, deps) {
         if (holder === 'released') {
             return { released: true, waitedMs: waited(), aborted: false, lastStatus: status, lastHolder: holder };
         }
-        if (status !== null && CLAIM_RELEASED_STATES.includes(status)) {
+        if (isSdkRunTerminal(status)) {
             return { released: true, waitedMs: waited(), aborted: false, lastStatus: status, lastHolder: holder };
         }
     }
@@ -698,7 +698,8 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
     const text = typeof deps?.deniedMessage === 'string' ? deps.deniedMessage : '';
     const canSteer = typeof runs?.steer === 'function' && text.length > 0;
     const canCancel = typeof runs?.cancel === 'function' && typeof runs?.get === 'function';
-    if (!canSteer && !canCancel)
+    const canAttach = runningAttachOffered(deps?.canAttachRunning);
+    if (!canSteer && !canCancel && !canAttach)
         return notParked;
     if (injected && !canSteer)
         return notParked;
@@ -715,7 +716,7 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
                 return planReviewArm(taskId, busy, deps);
             if (ASK_PARK_STATES.includes(fresh))
                 return askParkArm(taskId, busy, runs, deps);
-            if (CLAIM_RELEASED_STATES.includes(fresh))
+            if (isSdkRunTerminal(fresh))
                 return { kind: 'running-settled', taskId, status: fresh };
             return { kind: 'not-parked', taskId, status: fresh };
         }
@@ -733,7 +734,7 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
     }
     else if (typeof offer === 'function') {
         try {
-            choice = (await offer({ taskId, status, canSteer, canCancel })) ?? 'wait';
+            choice = (await offer({ taskId, status, canSteer, canCancel, ...(canAttach ? { canAttach: true } : {}) })) ?? 'wait';
             offerDelivered = true;
         }
         catch {
@@ -783,6 +784,8 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
             confirmedHeld: verdict.confirmedHeld,
         };
     }
+    if (choice === 'attach' && canAttach)
+        return { kind: 'running-attach', taskId };
     return notParked;
 }
 export const INTERACTIVE_WAY_OUT = 'run /clear to keep working in a fresh session';
@@ -841,6 +844,9 @@ const NO_CARD_VIEW_ATTACHED = 'this session has no view attached that can show d
 function injectedSubmissionRow(outcome, following = false) {
     const lead = INJECTED_LEAD;
     const id = 'taskId' in outcome && outcome.taskId ? ` (id ${outcome.taskId})` : '';
+    if (outcome.kind === 'running-attach') {
+        return `${lead} was not delivered: you chose to watch the reply already in progress${id} instead, and sema is replaying that reply here, so the part already shown above will appear again below. sema did not retry, so the model has not seen it.`;
+    }
     if (outcome.kind === 'running-steer-failed') {
         return outcome.delivery === 'unknown'
             ? `${lead} was passed to the reply already in progress${id}, but its delivery could not be confirmed ` +
@@ -1057,6 +1063,8 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
                 `to it (${outcome.detail}). A steer is not safe to send twice, so sema did NOT retry it, and it did NOT ` +
                 `cancel that run. That run may or may not have received your message — watch what it does next ` +
                 `before sending it again.`);
+        case 'running-attach':
+            return (`${resumeAttachReplayDisclosure(outcome.taskId)} Your message was NOT sent; send it again once that run has finished.`);
         case 'running-cancelled':
             return outcome.releaseConfirmedByEngine === true
                 ? `You chose to cancel run ${outcome.taskId}. The engine confirmed it is no longer holding this session, ` +

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -5,8 +5,10 @@ import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../../gateOutcome.js'
 import { projectToolRoster, projectToolRosterDelta } from '../../toolRoster.js';
 import { projectHandsSection } from '../../handsSeam.js';
 import { readMcpLiveness } from '../../mcpLiveness.js';
-import { SEGMENT_END_IDENTITY_KEYS } from '../types.js';
+import { markMcpSectionDroppedNamedRows } from '../../ownKey.js';
+import { SEGMENT_END_IDENTITY_KEYS, stripToolUseSideChannels } from '../types.js';
 import { frozenSet } from '../../frozenSet.js';
+import { isCoreWorkflowRunTerminal } from '../../terminalStatuses.js';
 function armBody(body) {
     return body;
 }
@@ -104,13 +106,13 @@ export function eventToSdkMessage(ev, ctx) {
             if (typeof ev.runId !== 'string' || ev.runId.length === 0) {
                 return dropped('malformed', 'workflow_complete');
             }
-            if (ev.status !== 'completed' && ev.status !== 'failed') {
+            if (!isCoreWorkflowRunTerminal(ev.status)) {
                 return dropped('malformed', 'workflow_complete');
             }
             return projected(stamp(ctx, armBody({
                 type: 'workflow_complete',
                 runId: ev.runId,
-                status: ev.status === 'failed' ? 'failed' : 'completed',
+                status: ev.status,
                 summary: typeof ev.summary === 'string' ? ev.summary : '',
             })));
         }
@@ -126,20 +128,21 @@ export function eventToSdkMessage(ev, ctx) {
                 delta: ev.delta,
                 ...(ev.parentToolCallId !== undefined ? { parentToolCallId: ev.parentToolCallId } : {}),
             }));
-        case 'tool_start':
-            return projected(assistantArm(ctx, [
-                {
-                    type: 'tool_use',
-                    id: ev.toolCallId,
-                    name: ev.toolName,
-                    input: ev.args,
-                    ...(typeof ev.label === 'string' && ev.label.length > 0 ? { label: ev.label } : {}),
-                    ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
-                    ...(ev.parentToolCallId !== undefined
-                        ? { parentToolCallId: ev.parentToolCallId }
-                        : {}),
-                },
-            ], ev.eventId, ev.parentToolCallId));
+        case 'tool_start': {
+            const toolUse = {
+                type: 'tool_use',
+                id: ev.toolCallId,
+                name: ev.toolName,
+                input: ev.args,
+                ...(typeof ev.label === 'string' && ev.label.length > 0 ? { label: ev.label } : {}),
+                ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
+                ...(ev.parentToolCallId !== undefined
+                    ? { parentToolCallId: ev.parentToolCallId }
+                    : {}),
+            };
+            const outBlock = ctx.lane === 'print' ? stripToolUseSideChannels(toolUse).block : toolUse;
+            return projected(assistantArm(ctx, [outBlock], ev.eventId, ev.parentToolCallId));
+        }
         case 'compacted': {
             const raw = ev;
             const freedTokens = typeof raw.freedTokens === 'number' && Number.isFinite(raw.freedTokens) && raw.freedTokens >= 0 ? raw.freedTokens : undefined;
@@ -470,12 +473,15 @@ export function projectMcpSection(raw) {
     if (!Array.isArray(raw))
         return undefined;
     const rows = [];
+    const droppedNamed = new Map();
     for (const e of raw) {
         if (typeof e !== 'object' || e === null || Array.isArray(e))
             continue;
         const r = e;
         const name = typeof r.name === 'string' && r.name.length > 0 ? r.name : undefined;
         const status = typeof r.status === 'string' && r.status.length > 0 ? r.status : undefined;
+        if (name !== undefined && status === undefined)
+            droppedNamed.set(name, (droppedNamed.get(name) ?? 0) + 1);
         if (name === undefined || status === undefined)
             continue;
         rows.push({
@@ -491,6 +497,7 @@ export function projectMcpSection(raw) {
     }
     if (raw.length > 0 && rows.length === 0)
         return undefined;
+    markMcpSectionDroppedNamedRows(rows, droppedNamed);
     return rows;
 }
 function projectModelGateSection(raw) {

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -1,6 +1,6 @@
 import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../../gateVocabulary.js';
 import { stamp } from '../types.js';
-import { putOwnKey } from '../../ownKey.js';
+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';
@@ -79,6 +79,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 +105,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 +158,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 +185,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,
@@ -522,8 +530,7 @@ export function doneToSdkResult(ev, ctx, observed) {
     const durationMs = elapsedMs(ctx);
     const errorCode = runTerminalCode(terminal);
     const degraded = degradedOf(r);
-    const parkFailedRaw = ev._sema_park_failed_reason;
-    const parkFailedReason = typeof parkFailedRaw === 'string' && parkFailedRaw.length > 0 ? parkFailedRaw : undefined;
+    const parkFailedReason = readFrameStringKey(ev, '_sema_park_failed_reason');
     const errorBase = { durationMs, stats, model: r.model, errorCode, degraded, observed, facts: effectiveFactParts(rec), parkFailedReason, abortCause: abortCauseWordOf(ev) };
     if (terminal?.kind === 'failed') {
         const failedCode = terminal.code;

package/dist/adapter/runStream.js

@@ -60,7 +60,8 @@ export function activeRunBusySignal(ev) {
         const result = ev.result;
         if (typeof result !== 'object' || result === null)
             return null;
-        if (result.status !== 'failed')
+        const status = result.status;
+        if (status !== 'failed' && (status !== undefined || Array.isArray(result)))
             return null;
         carrier = result;
     }

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,6 @@
 import { errCodes } from '../controlRouter.js';
 import { hostLog } from '../host.js';
+import { isSessionIdPathSegment } from '../sessionIdSegment.js';
 const unavailable = (why) => ({
     kind: 'unavailable',
     why,
@@ -95,7 +96,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

@@ -3,9 +3,11 @@ 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}`;
@@ -164,7 +166,7 @@ function classifyFailure(e) {
     try {
         if (typeof e !== 'object' || e === null) {
             note('error (non-object failure)');
-            return { kind: 'error', detail: `the stop request failed: ${String(e).slice(0, 200)}` };
+            return { kind: 'error', detail: `the stop request failed: ${wireFailureTextsOf(e).reason.slice(0, 200)}` };
         }
         const d = diagOf(e);
         if (d.status === undefined && d.errorCode === undefined) {
@@ -201,7 +203,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

@@ -1,5 +1,6 @@
 import { type EngineProbeOpts, type WireAuthTokenSource } from './engineWireSdk.js';
 import type { ReasoningEffort } from './effortWire.js';
+import type { ToolRosterView } from './toolRoster.js';
 export declare const MAX_TASK_AGENTS = 32;
 export declare const MAX_AGENT_NAME_CHARS = 64;
 export declare const MAX_AGENT_TEXT_CHARS = 4096;
@@ -14,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 = {
@@ -56,11 +59,25 @@ export type ProjectAgentsDeps = {
     };
     effortToThinking: (effort: unknown) => WireThinkingLevel | undefined;
     skillSpecs?: TaskAgentWireSkill[];
+    toolRoster?: ToolRosterView | null;
+    withholdRefusedDenyLists?: boolean;
+    agentSourceLabel?: (agentName: string) => string | undefined;
 };
 export type ProjectAgentsResult = {
     agents: TaskAgentWireItem[] | undefined;
     warnings: string[];
+    toolListFlaws?: readonly AgentToolListFlaw[];
 };
+export type AgentToolListFlawKind = 'retired' | 'unprefixed_namespace' | 'case_twin';
+export interface AgentToolListFlaw {
+    readonly agent: string;
+    readonly list: 'tools' | 'disallowedTools';
+    readonly entry: string;
+    readonly kind: AgentToolListFlawKind;
+    readonly currentName?: string;
+    readonly toolName?: string;
+}
+export declare function agentToolListFlaws(agents: readonly TaskAgentWireItem[] | undefined, roster?: ToolRosterView | null): AgentToolListFlaw[];
 export declare function projectAgentsForWire(defs: readonly AgentDefLike[], deps: ProjectAgentsDeps): ProjectAgentsResult;
 export declare function engineSupportsTaskAgents(baseUrl: string, opts?: EngineProbeOpts): Promise<boolean | undefined>;
 export type WireConfig = {