@sema-agent/client-core 0.81.1 → 0.82.1

package/dist/adapter/activeRunSelfHeal.js

@@ -1,4 +1,5 @@
 import { abortableSleep } from '../abortableSleep.js';
+import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTriage.js';
 export const PLAN_REVIEW_GATE_KIND = 'plan_review';
 export const PLAN_REVIEW_GATE_KINDS = [PLAN_REVIEW_GATE_KIND, 'dry_run_review'];
 export const ASK_PARK_GATE_KINDS = ['human', 'irreversible_ask', 'policy_ask', 'tool_approval'];
@@ -45,12 +46,14 @@ function sessionOpts(deps) {
     return typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {};
 }
 function describeFailure(e) {
+    const where = corruptStoredRowWhere(e);
+    const rowNote = where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`;
     if (typeof e === 'object' && e !== null && 'message' in e) {
         const m = e.message;
         if (typeof m === 'string' && m.length > 0)
-            return m.length > 200 ? `${m.slice(0, 200)}…` : m;
+            return `${m.length > 200 ? `${m.slice(0, 200)}…` : m}${rowNote}`;
     }
-    return 'the engine gave no detail';
+    return `the engine gave no detail${rowNote}`;
 }
 function readStatus(record) {
     const st = record?.status;
@@ -76,6 +79,9 @@ export function readCancelRequested(body) {
     const v = body.cancelRequested;
     return typeof v === 'boolean' ? v : undefined;
 }
+function reopenRefusedForDecisionInFlight(verdict) {
+    return verdict !== null && verdict.reopened === false && verdict._sema_decisionInFlight === true;
+}
 function reopenDelivered(verdict) {
     return verdict.reopened === true && verdict.presented !== false;
 }
@@ -297,9 +303,14 @@ async function askVerdict(taskId, deps) {
 }
 async function planReviewArm(taskId, signal, deps) {
     const verdict = await planVerdict(taskId, deps);
-    return reopenDelivered(verdict)
-        ? { kind: 'plan-review-reopened', taskId, firstSight: verdict.firstSight === true }
-        : { kind: 'plan-review-reopen-failed', taskId, decidePath: signal.pendingGate?.decidePath ?? null };
+    if (reopenDelivered(verdict))
+        return { kind: 'plan-review-reopened', taskId, firstSight: verdict.firstSight === true };
+    return {
+        kind: 'plan-review-reopen-failed',
+        taskId,
+        decidePath: signal.pendingGate?.decidePath ?? null,
+        ...(reopenRefusedForDecisionInFlight(verdict) ? { decisionInFlight: true } : {}),
+    };
 }
 async function askParkArm(taskId, signal, runs, deps) {
     const verdict = await askVerdict(taskId, deps);
@@ -323,10 +334,16 @@ async function askParkArm(taskId, signal, runs, deps) {
         }
         return { kind: 'ask-decided-release-unknown', taskId, lastStatus: release.lastStatus };
     }
-    if (verdict.reopened === false && verdict.decidedWithoutCard !== true && verdict.pendingRowGone === true) {
+    const inFlight = reopenRefusedForDecisionInFlight(verdict);
+    if (verdict.reopened === false && verdict.decidedWithoutCard !== true && verdict.pendingRowGone === true && !inFlight) {
         return staleParkArm(taskId, signal, runs, deps);
     }
-    return { kind: 'ask-reopen-failed', taskId, decidePath: signal.pendingGate?.decidePath ?? null };
+    return {
+        kind: 'ask-reopen-failed',
+        taskId,
+        decidePath: signal.pendingGate?.decidePath ?? null,
+        ...(inFlight ? { decisionInFlight: true } : {}),
+    };
 }
 async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
     let status = null;
@@ -608,6 +625,10 @@ function injectedSubmissionRow(outcome, following = false) {
             : `A system notification was NOT delivered: the engine refused it for the run that is already working${handle} ` +
                 `(${outcome.detail}); sema did not retry. The model was not told about it.`;
     }
+    if ((outcome.kind === 'ask-reopen-failed' || outcome.kind === 'plan-review-reopen-failed') && outcome.decisionInFlight === true) {
+        return (`A system notification was NOT delivered: this session is still held by an earlier run${handle} whose decision ` +
+            `is still on its way to the engine, so sema did not retry. The model was not told about it.`);
+    }
     switch (selfHealSubmissionDisposition(outcome)) {
         case 'held-for-decision':
             return (`A system notification could not be delivered while an earlier turn${handle} is waiting on a ` +
@@ -625,6 +646,11 @@ function injectedSubmissionRow(outcome, following = false) {
                 `sema could not put a decision for it on screen, so it did not retry. The model was not told about it.`);
     }
 }
+function decisionInFlightRow(parkedOn) {
+    return (`The previous turn is parked ${parkedOn} and your answer to that card is still on its way to the engine, so ` +
+        `sema did not show the card again — answering it a second time would send a second decision. It did NOT ` +
+        `cancel the run. Your message was NOT sent; send it again in a moment, once the engine has applied that decision.`);
+}
 function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false) {
     switch (outcome.kind) {
         case 'decision-pending':
@@ -662,6 +688,8 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false) {
                 (outcome.lastStatus ? ` (last engine status: ${outcome.lastStatus})` : '') +
                 `. sema could not yet confirm it finished, so your message was not sent — wait a moment and send it again.`);
         case 'ask-reopen-failed': {
+            if (outcome.decisionInFlight === true)
+                return decisionInFlightRow(`waiting for your decision (run ${outcome.taskId})`);
             const viaEngine = outcome.decidePath
                 ? ` You can also decide it on the engine directly: POST ${outcome.decidePath}.`
                 : '';
@@ -670,6 +698,8 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false) {
                 `Your message was NOT sent; ${wayOut} if you no longer want it.${viaEngine}`);
         }
         case 'plan-review-reopen-failed': {
+            if (outcome.decisionInFlight === true)
+                return decisionInFlightRow(`on a plan review (run ${outcome.taskId})`);
             const viaEngine = outcome.decidePath
                 ? ` You can also decide it on the engine directly: POST ${outcome.decidePath}.`
                 : '';
@@ -692,8 +722,11 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false) {
                 const parked = outcome.status ? `parked (status ${outcome.status})` : 'parked';
                 const next = outcome.reopened !== null && reopenDelivered(outcome.reopened)
                     ? `sema has surfaced that decision card — answering it is what lets that run resume and pick your message up.`
-                    : `sema could not surface that decision card here, so nothing will resume that run until that decision is made; ` +
-                        `${wayOut} if you no longer want it.`;
+                    : reopenRefusedForDecisionInFlight(outcome.reopened)
+                        ? `Your answer to that decision is still on its way to the engine, so sema did not show the card again; ` +
+                            `that run moves on once the engine applies it.`
+                        : `sema could not surface that decision card here, so nothing will resume that run until that decision is made; ` +
+                            `${wayOut} if you no longer want it.`;
                 return (`${handle} is not actually working right now: the engine reports it ${parked} on a decision it needs ` +
                     `from you, so it queued your message on that park instead of running it. ${next} ${textOnly} ` +
                     `Nothing was cancelled, and your message did NOT start a new turn.`);

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -36,9 +36,10 @@ export const INTERNAL_SDK_ARM_TYPES = new Set([
     'approval_revoke',
     'message_committed',
 ]);
-function assistantArm(ctx, content, eventId) {
+function assistantArm(ctx, content, eventId, parentToolCallId) {
     const id = typeof eventId === 'string' && eventId.length > 0 ? eventId : undefined;
-    const model = typeof ctx.model === 'string' && ctx.model.length > 0 ? ctx.model : undefined;
+    const parent = typeof parentToolCallId === 'string' && parentToolCallId.length > 0 ? parentToolCallId : undefined;
+    const model = parent === undefined && typeof ctx.model === 'string' && ctx.model.length > 0 ? ctx.model : undefined;
     return stamp(ctx, armBody({
         type: 'assistant',
         message: {
@@ -47,7 +48,7 @@ function assistantArm(ctx, content, eventId) {
             ...(id !== undefined ? { id } : {}),
             ...(model !== undefined ? { model } : {}),
         },
-        parent_tool_use_id: null,
+        parent_tool_use_id: parent ?? null,
     }));
 }
 function streamEventArm(ctx, event) {
@@ -136,7 +137,7 @@ export function eventToSdkMessage(ev, ctx) {
                         ? { parentToolCallId: ev.parentToolCallId }
                         : {}),
                 },
-            ], ev.eventId));
+            ], 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;
@@ -171,6 +172,7 @@ export function eventToSdkMessage(ev, ctx) {
             const toolEndGatedCallId = ev.gatedCallId;
             const collateralAbort = ev._sema_collateral_abort;
             const denialKind = ccToolDenialKindForToolEnd(ev);
+            const denialUnclassified = denialKind === undefined && toolEndGate?.disposition.kind === 'denied';
             return projected(stamp(ctx, armBody({
                 type: 'tool_end_result',
                 toolCallId: ev.toolCallId,
@@ -192,6 +194,7 @@ export function eventToSdkMessage(ev, ctx) {
                     : {}),
                 ...(collateralAbort === true ? { _sema_collateral_abort: true } : {}),
                 ...(denialKind !== undefined ? { _sema_denial_kind: denialKind } : {}),
+                ...(denialUnclassified ? { _sema_denial_unclassified: true } : {}),
                 ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
                 ...(ev.parentToolCallId !== undefined
                     ? { parentToolCallId: ev.parentToolCallId }

package/dist/adapter/downstream/terminalToSdkResult.d.ts

@@ -20,6 +20,8 @@ export interface TerminalStreamObserved {
     readonly denialKindByCallId?: ReadonlyMap<string, string>;
     readonly successfulToolEndObserved?: boolean;
     readonly streamSawRunOpen?: boolean;
+    readonly deniedToolNameByCallId?: ReadonlyMap<string, string | undefined>;
+    readonly deniedCallsOverflowed?: boolean;
 }
 export declare const TOOL_INPUT_JOIN_MAX_CALLS = 4096;
 export interface SemaPermissionDenial {

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -1,4 +1,4 @@
-import { isCcToolDenialKind, isGateDeniedByWord } from '../../gateVocabulary.js';
+import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../../gateVocabulary.js';
 import { stamp } from '../types.js';
 import { putOwnKey } from '../../ownKey.js';
 import { readEffectiveReasoning, readEffectiveMemoryScopes } from '../../effectiveFacts.js';
@@ -65,11 +65,10 @@ function permissionDenialParts(stats, observed) {
     const gateDeniedByByCallId = observed?.gateDeniedByByCallId;
     const denialKindByCallId = observed?.denialKindByCallId;
     const hr = stats?.humanReview;
-    const gates = hr !== null && typeof hr === 'object' ? hr.gates : undefined;
-    if (!Array.isArray(gates))
-        return { permission_denials: [], _sema_permission_denials_absent: true };
+    const gatesRaw = hr !== null && typeof hr === 'object' ? hr.gates : undefined;
     const denials = [];
-    let complete = true;
+    const gates = Array.isArray(gatesRaw) ? gatesRaw : [];
+    let complete = Array.isArray(gatesRaw);
     for (const g of gates) {
         if (g === null || typeof g !== 'object') {
             complete = false;
@@ -125,6 +124,43 @@ function permissionDenialParts(stats, observed) {
             ...(toolArg !== undefined ? { _sema_tool_arg: toolArg } : {}),
         });
     }
+    const deniedToolNameByCallId = observed?.deniedToolNameByCallId;
+    if (deniedToolNameByCallId !== undefined) {
+        const ledgerDeniedIds = new Set();
+        let ledgerHasIdlessDenial = false;
+        for (const d of denials) {
+            if (d.tool_use_id !== undefined)
+                ledgerDeniedIds.add(d.tool_use_id);
+            else
+                ledgerHasIdlessDenial = true;
+        }
+        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))
+                continue;
+            if (ledgerHasIdlessDenial) {
+                complete = false;
+                continue;
+            }
+            const toolName = nonEmptyStr(toolNameRaw);
+            const joinedInput = toolInputByCallId?.has(callId) === true ? joinableToolInput(toolInputByCallId.get(callId)) : undefined;
+            const deniedByRaw = gateDeniedByByCallId?.has(callId) === true ? gateDeniedByByCallId.get(callId) : undefined;
+            const deniedBy = typeof deniedByRaw === 'string' && isGateDeniedByWord(deniedByRaw) ? deniedByRaw : undefined;
+            const toolDenialKind = isCcToolDenialKind(mergedKind) ? mergedKind : undefined;
+            denials.push({
+                ...(toolName !== undefined ? { tool_name: toolName } : {}),
+                tool_use_id: callId,
+                ...(joinedInput !== undefined ? { tool_input: joinedInput, _sema_tool_input_source: 'tool_start' } : {}),
+                ...(deniedBy !== undefined ? { deniedBy, _sema_denied_by_source: 'tool_end' } : {}),
+                ...(toolDenialKind !== undefined ? { toolDenialKind } : {}),
+            });
+            ledgerDeniedIds.add(callId);
+        }
+        if (observed?.deniedCallsOverflowed === true)
+            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 zeroOutputDenied = denials.length > 0 && observed?.streamSawRunOpen === true && observed.successfulToolEndObserved === false;
@@ -200,15 +236,18 @@ function structuredOutputParts(r) {
 function effectiveFactParts(rec) {
     const reasoning = readEffectiveReasoning(rec.effectiveReasoning);
     const scopes = readEffectiveMemoryScopes(rec.effectiveMemoryScopes);
+    const responseModel = rec.responseModel;
     return {
         ...(reasoning !== undefined ? { _sema_effective_reasoning: reasoning } : {}),
         ...(scopes !== undefined ? { _sema_effective_memory_scopes: scopes } : {}),
+        ...(typeof responseModel === 'string' && responseModel.length > 0 ? { _sema_response_model: responseModel } : {}),
     };
 }
 function reemitEffectiveFacts(f) {
     const out = {
         ...(f?._sema_effective_reasoning !== undefined ? { _sema_effective_reasoning: f._sema_effective_reasoning } : {}),
         ...(f?._sema_effective_memory_scopes !== undefined ? { _sema_effective_memory_scopes: f._sema_effective_memory_scopes } : {}),
+        ...(f?._sema_response_model !== undefined ? { _sema_response_model: f._sema_response_model } : {}),
     };
     const _keySetPin = true;
     void _keySetPin;

package/dist/adapter/runStream.js

@@ -6,7 +6,7 @@ import { coerceOutput, publishSubagentContentEvent } from '../subagentContentSto
 import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isLimitsExceededCode } from '../engineErrorCodes.js';
 import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
 import { ccToolDenialKindForToolEnd, gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
-import { isCcToolDenialKind, isGateDeniedByWord } from '../gateVocabulary.js';
+import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../gateVocabulary.js';
 const mainLane = () => ({ lane: 'main' });
 function emitChromeFireAndForget(ctx, event) {
     try {
@@ -185,6 +185,8 @@ async function* runStreamInner(events, ctx, handle = {}) {
     const denialKindSourceByCallId = new Map();
     const denialAmbiguous = new Set();
     let denialJoinOverflowed = false;
+    const deniedToolNameByCallId = new Map();
+    let deniedCallsOverflowed = false;
     let successfulToolEndObserved = false;
     let streamSawRunOpen = false;
     const sameArgs = (a, b) => {
@@ -229,7 +231,8 @@ async function* runStreamInner(events, ctx, handle = {}) {
         if (ev.type === 'tool_end') {
             const endCallId = ev.toolCallId;
             if (typeof endCallId === 'string' && endCallId.length > 0) {
-                const deniedByRaw = gateDeniedBy(gateOutcomeOf(ev));
+                const endGate = gateOutcomeOf(ev);
+                const deniedByRaw = gateDeniedBy(endGate);
                 const deniedBy = isGateDeniedByWord(deniedByRaw) ? deniedByRaw : undefined;
                 const kind = ccToolDenialKindForToolEnd(ev);
                 const kindSource = kind === undefined
@@ -237,6 +240,23 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     : isCcToolDenialKind(ev._sema_denial_kind)
                         ? 'local'
                         : 'wire';
+                const deniedCall = endGate !== undefined
+                    ? endGate.disposition.kind === 'denied' && (kind === undefined || isCcToolDenialKindADenial(kind))
+                    : kind !== undefined && isCcToolDenialKindADenial(kind);
+                if (deniedCall) {
+                    const endToolNameRaw = ev.toolName;
+                    const endToolName = typeof endToolNameRaw === 'string' && endToolNameRaw.length > 0 ? endToolNameRaw : undefined;
+                    if (deniedToolNameByCallId.has(endCallId)) {
+                        if (deniedToolNameByCallId.get(endCallId) !== endToolName)
+                            deniedToolNameByCallId.set(endCallId, undefined);
+                    }
+                    else if (deniedToolNameByCallId.size >= TOOL_INPUT_JOIN_MAX_CALLS) {
+                        deniedCallsOverflowed = true;
+                    }
+                    else if (!deniedCallsOverflowed) {
+                        deniedToolNameByCallId.set(endCallId, endToolName);
+                    }
+                }
                 if (deniedBy !== undefined || kind !== undefined) {
                     const isNew = (deniedBy !== undefined && !gateDeniedByByCallId.has(endCallId)) ||
                         (kind !== undefined && !denialKindByCallId.has(endCallId));
@@ -298,14 +318,18 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 output: coerceOutput(sub.output),
                 isError: sub.isError,
             });
-            continue;
+            if (!(ctx.lane === 'print' && (sub.type === 'tool_start' || sub.type === 'tool_end')))
+                continue;
         }
         if (ev.type === 'turn_end') {
             const usageMissing = ev.usageMissing === true;
             if (usageMissing)
                 usageMissingObserved = true;
-            const stopReasonRaw = ev.stopReason;
+            const turnEndLoose = ev;
+            const stopReasonRaw = turnEndLoose.stopReason;
             const stopWord = typeof stopReasonRaw === 'string' && stopReasonRaw.length > 0 ? stopReasonRaw : undefined;
+            const responseModelRaw = turnEndLoose.responseModel;
+            const responseModelWord = typeof responseModelRaw === 'string' && responseModelRaw.length > 0 ? responseModelRaw : undefined;
             const rawUsage = ev.usage;
             const engineUsage = typeof rawUsage === 'object' && rawUsage !== null && !Array.isArray(rawUsage)
                 ? rawUsage
@@ -340,6 +364,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                             engineUsage,
                             ...(usageMissing ? { usageMissing: true } : {}),
                             ...(stopWord !== undefined ? { stopReason: stopWord } : {}),
+                            ...(responseModelWord !== undefined ? { responseModel: responseModelWord } : {}),
                         });
                     }
                 }
@@ -362,6 +387,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                             engineUsage,
                             ...(usageMissing ? { usageMissing: true } : {}),
                             ...(stopWord !== undefined ? { stopReason: stopWord } : {}),
+                            ...(responseModelWord !== undefined ? { responseModel: responseModelWord } : {}),
                         });
                     }
                     const rowKey = sourceTaskId !== undefined ? `s:${sourceTaskId}` : `p:${taskId}`;
@@ -389,6 +415,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                         ? { outputTokens }
                         : {}),
                     ...(stopWord !== undefined ? { _sema_stop_reason: stopWord } : {}),
+                    ...(responseModelWord !== undefined ? { _sema_response_model: responseModelWord } : {}),
                 };
             }
             continue;
@@ -453,6 +480,8 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 denialKindByCallId,
                 successfulToolEndObserved,
                 streamSawRunOpen,
+                deniedToolNameByCallId,
+                deniedCallsOverflowed,
             });
             const outcome = resultFrame.
                 _sema_outcome;

package/dist/adapter/types.d.ts

@@ -1,6 +1,7 @@
 import type { AgentEvent } from '@sema-agent/sdk';
 import type { ModelUsage, SDKMessage } from '@sema-agent/agent-types';
 import type { ChromeEvent } from '../seam.js';
+import type { RequestLane } from '../request/taskRequest.js';
 export type { ModelUsage, SDKMessage };
 export type StampedAgentEvent = AgentEvent & {
     id?: string;
@@ -16,6 +17,7 @@ export interface EmitContext {
     sessionId: string;
     startedAtMs?: number;
     model?: string;
+    lane?: RequestLane;
     emitChrome?(event: ChromeEvent): void | Promise<void>;
     onDroppedFrame?(info: DroppedFrameInfo): void;
 }

package/dist/agentsWireCaps.d.ts

@@ -69,6 +69,7 @@ export type WireConfig = {
 };
 export type ProjectorFn = () => Promise<ProjectAgentsResult>;
 export declare function prepareTaskAgentsWireWith(cfg: WireConfig, projector: ProjectorFn): Promise<void>;
+export declare function invalidateTaskAgentsWire(): Promise<void>;
 export declare function awaitTaskAgentsWire(timeoutMs?: number): Promise<void>;
 export declare function taskAgentsField(): {
     agents?: TaskAgentWireItem[];

package/dist/agentsWireCaps.js

@@ -194,6 +194,7 @@ let preparedKey = null;
 let preparedPromise = null;
 let payload;
 let capsVerdict;
+let settleGeneration = null;
 const emittedWarnings = new Set();
 function warnOnce(msg) {
     if (emittedWarnings.has(msg))
@@ -201,30 +202,57 @@ function warnOnce(msg) {
     emittedWarnings.add(msg);
     console.error(`[sema] ${msg}`);
 }
-async function runPrepare(cfg, projector) {
-    try {
-        const [caps, projected] = await Promise.all([
-            engineSupportsTaskAgents(cfg.baseUrl, {
-                authToken: cfg.authToken,
-                principal: cfg.principal,
-            }),
-            projector(),
-        ]);
-        capsVerdict = caps;
-        if (projected.agents && caps === false) {
-            warnOnce(`agents wire: this engine does not support per-task custom agents (capabilities.taskAgents absent/false — server <1.205 or multi-tenant) — ${projected.agents.length} custom agent definition(s) will NOT be sent`);
-            payload = undefined;
-            return;
-        }
+function applyProjectionIfCurrent(generation, projected) {
+    if (generation === null || preparedPromise !== generation)
+        return false;
+    const accepted = capsVerdict !== false;
+    if (accepted) {
         for (const w of projected.warnings)
             warnOnce(w);
         payload = projected.agents;
+    }
+    settleGeneration?.();
+    return accepted;
+}
+function startCapsProbe(cfg) {
+    const land = (verdict) => {
+        if (capsVerdict !== probe)
+            return verdict;
+        capsVerdict = verdict;
+        if (verdict === false) {
+            payload = undefined;
+            settleGeneration?.();
+        }
+        return verdict;
+    };
+    const probe = engineSupportsTaskAgents(cfg.baseUrl, {
+        authToken: cfg.authToken,
+        principal: cfg.principal,
+    }).then(land, () => land(undefined));
+    capsVerdict = probe;
+    return probe;
+}
+function capsSettled() {
+    return capsVerdict instanceof Promise ? capsVerdict : Promise.resolve();
+}
+async function runPrepare(cfg, projector, probe, generation) {
+    try {
+        const [caps, projected] = await Promise.all([probe, projector()]);
+        if (caps === false) {
+            if (projected.agents && preparedKey === cfg.baseUrl) {
+                warnOnce(`agents wire: this engine does not support per-task custom agents (capabilities.taskAgents absent/false — server <1.205 or multi-tenant) — ${projected.agents.length} custom agent definition(s) will NOT be sent`);
+            }
+            return;
+        }
+        if (!applyProjectionIfCurrent(generation, projected))
+            return;
         if (payload && hostEnv().SEMA_DEBUG) {
             console.error(`[sema] agents wire: ${payload.length} custom agent(s) → TaskRequest.agents (${payload.map(a => a.name).join(', ')})`);
         }
     }
     catch (e) {
-        payload = undefined;
+        if (preparedPromise === generation)
+            payload = undefined;
         if (hostEnv().SEMA_DEBUG) {
             console.error('[sema] agents wire prepare soft-failed (no agents stamped):', e);
         }
@@ -235,21 +263,66 @@ export function prepareTaskAgentsWireWith(cfg, projector) {
     if (preparedPromise && preparedKey === key)
         return preparedPromise;
     preparedKey = key;
-    preparedPromise = runPrepare(cfg, projector);
     activeProjector = projector;
-    return preparedPromise;
+    const probe = startCapsProbe(cfg);
+    return startGeneration(generation => runPrepare(cfg, projector, probe, generation));
+}
+function startGeneration(run) {
+    let settle;
+    const generation = new Promise(resolve => {
+        settle = resolve;
+    });
+    const superseded = settleGeneration;
+    preparedPromise = generation;
+    settleGeneration = settle;
+    superseded?.();
+    void run(generation).then(settle, settle);
+    return generation;
+}
+export function invalidateTaskAgentsWire() {
+    const projector = activeProjector;
+    if (!preparedPromise || !projector)
+        return Promise.resolve();
+    payload = undefined;
+    return startGeneration(generation => runReproject(projector, generation));
+}
+async function runReproject(projector, generation) {
+    try {
+        let projected;
+        try {
+            projected = await projector();
+        }
+        catch (e) {
+            if (hostEnv().SEMA_DEBUG) {
+                console.error('[sema] agents wire re-project soft-failed (no agents stamped until the next successful projection):', e);
+            }
+            return;
+        }
+        await capsSettled();
+        applyProjectionIfCurrent(generation, projected);
+    }
+    catch {
+    }
 }
 export async function awaitTaskAgentsWire(timeoutMs = 4000) {
     if (!preparedPromise)
         return;
+    if (capsVerdict === false)
+        return;
     let timeoutHandle;
+    let timedOut = false;
+    const deadline = new Promise(resolve => {
+        timeoutHandle = setTimeout(() => {
+            timedOut = true;
+            resolve();
+        }, timeoutMs);
+    });
     try {
-        await Promise.race([
-            preparedPromise.catch(() => { }),
-            new Promise(resolve => {
-                timeoutHandle = setTimeout(resolve, timeoutMs);
-            }),
-        ]);
+        let waited = null;
+        while (!timedOut && preparedPromise !== null && preparedPromise !== waited) {
+            waited = preparedPromise;
+            await Promise.race([waited.catch(() => { }), deadline]);
+        }
     }
     finally {
         if (timeoutHandle !== undefined)
@@ -259,11 +332,18 @@ export async function awaitTaskAgentsWire(timeoutMs = 4000) {
 export function taskAgentsField() {
     const current = payload;
     if (preparedPromise && capsVerdict !== false && activeProjector) {
-        void activeProjector()
-            .then(p => {
-            for (const w of p.warnings)
-                warnOnce(w);
-            payload = p.agents;
+        const generation = preparedPromise;
+        let refreshing;
+        try {
+            refreshing = activeProjector();
+        }
+        catch {
+            return current ? { agents: current } : {};
+        }
+        void refreshing
+            .then(async (p) => {
+            await capsSettled();
+            applyProjectionIfCurrent(generation, p);
         })
             .catch(() => { });
     }
@@ -273,6 +353,7 @@ export function _resetAgentsWireForTest() {
     activeProjector = null;
     preparedKey = null;
     preparedPromise = null;
+    settleGeneration = null;
     payload = undefined;
     capsVerdict = undefined;
     emittedWarnings.clear();

package/dist/decideFailureNote.d.ts

@@ -0,0 +1 @@
+export declare function decideFailureNote(err: unknown): string;

package/dist/decideFailureNote.js

@@ -0,0 +1,8 @@
+import { corruptStoredRowContent, corruptStoredRowWhere } from './wireErrorTriage.js';
+import { resumePolicyBlockContent, resumePolicyBlockFromError } from './resumeRefusalCopy.js';
+export function decideFailureNote(err) {
+    const where = corruptStoredRowWhere(err);
+    const fold = resumePolicyBlockFromError(err);
+    return ((where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`) +
+        (fold === null ? '' : ` — ${resumePolicyBlockContent(fold)}`));
+}

package/dist/engineErrorCodes.d.ts

@@ -34,6 +34,7 @@ export declare const STOP_NOT_LOCAL = "stop.not_local";
 export declare const STOP_PARKED = "stop.parked";
 export declare const STOP_CONFLICT_CODES: readonly ["stop.park_arbiter_unreachable", "stop.park_resume_won", "stop.not_landed", "stop.not_local", "stop.parked"];
 export declare const OUTPUT_INVALID = "output.invalid";
+export declare const RESUME_POLICY_FOLD_CODE = "resume_blocked_by_policy";
 export declare const RESUME_AT_ERROR_CODE_PREFIX = "resume_at.";
 export declare const REWIND_ERROR_CODE_PREFIXES: readonly ["resume_at.", "rewind_snapshot."];
 export declare function isRewindFamilyCode(code: string | undefined): boolean;

package/dist/engineErrorCodes.js

@@ -69,6 +69,7 @@ export const STOP_CONFLICT_CODES = [
     STOP_PARKED,
 ];
 export const OUTPUT_INVALID = 'output.invalid';
+export const RESUME_POLICY_FOLD_CODE = 'resume_blocked_by_policy';
 export const RESUME_AT_ERROR_CODE_PREFIX = 'resume_at.';
 export const REWIND_ERROR_CODE_PREFIXES = [RESUME_AT_ERROR_CODE_PREFIX, 'rewind_snapshot.'];
 export function isRewindFamilyCode(code) {

package/dist/engineNoticeCodes.js

@@ -55,6 +55,7 @@ export const ENGINE_NOTICE_CODES = Object.freeze([
     'route.fallback_to_primary',
     'route.classifier_unroutable',
     'route.base_url_changed_key_unchanged',
+    'route.response_model_mismatch',
     'task.user_steer_undrained',
     'task.user_followup_undrained',
     'steering.parked_input_blocked',
@@ -129,6 +130,7 @@ export const ENGINE_NOTICE_AUDIENCE = Object.freeze({
     'route.fallback_to_primary': 'operator',
     'route.classifier_unroutable': 'operator',
     'route.base_url_changed_key_unchanged': 'operator',
+    'route.response_model_mismatch': 'operator',
     'task.user_steer_undrained': 'user',
     'task.user_followup_undrained': 'user',
     'steering.parked_input_blocked': 'user',

package/dist/executionLaneCapability.js

@@ -51,6 +51,9 @@ export function executionLaneDoctorDetail(reading) {
             if (reading.view.toolsOnThisHost) {
                 return `execution lane ${lane} — tools run on the engine host (same filesystem), so skills that have a directory of their own can carry a baseDir`;
             }
+            if (reading.view.provider === 'in-process') {
+                return 'no execution lane on this deployment (in-process) — the engine has no machine of its own for running tools here, so its built-in file and shell tools are not mounted and skill baseDir is never sent; whether a given run had tools is answered by its tool roster';
+            }
             return `execution lane ${lane} — tools run on a different machine than the engine, so skill baseDir is never sent on this deployment`;
         }
     }