@sema-agent/client-core 0.82.0 → 0.82.1

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/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`;
         }
     }

package/dist/fileHistoryCaptureCapability.d.ts

@@ -0,0 +1,18 @@
+export type FileHistoryCaptureReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'present';
+    word: string;
+};
+export type FileHistoryCaptureMode = 'off' | 'on-always' | 'unknown';
+export declare function projectFileHistoryCaptureCapability(caps: unknown): FileHistoryCaptureReading | undefined;
+export declare function noteEngineCapsForFileHistoryCapture(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedFileHistoryCapture(baseUrl?: string | undefined): FileHistoryCaptureReading;
+export declare function fileHistoryCaptureMode(reading: FileHistoryCaptureReading): FileHistoryCaptureMode;
+export declare function fileHistoryCaptureDoctorDetail(reading: FileHistoryCaptureReading): string;
+export declare function forgetFileHistoryCaptureReading(baseUrl: string | undefined): void;
+export declare function __resetFileHistoryCaptureReadingsForTests(): void;

package/dist/fileHistoryCaptureCapability.js

@@ -0,0 +1,58 @@
+import { capForDisplay } from './fleetTaskDesc.js';
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+export function projectFileHistoryCaptureCapability(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    if (!Object.hasOwn(caps, 'fileHistoryCapture'))
+        return { kind: 'not_reported' };
+    const v = caps.fileHistoryCapture;
+    if (v === undefined)
+        return { kind: 'not_reported' };
+    if (typeof v !== 'string' || v.length === 0)
+        return undefined;
+    return { kind: 'present', word: v };
+}
+const reader = createEngineCapReader({
+    name: 'fileHistoryCapture',
+    project: projectFileHistoryCaptureCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForFileHistoryCapture(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedFileHistoryCapture(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function fileHistoryCaptureMode(reading) {
+    if (reading.kind !== 'present')
+        return 'unknown';
+    if (reading.word === 'off')
+        return 'off';
+    if (reading.word === 'on-always')
+        return 'on-always';
+    return 'unknown';
+}
+const WORD_DETAIL_MAX = 40;
+export function fileHistoryCaptureDoctorDetail(reading) {
+    switch (reading.kind) {
+        case 'unobserved':
+            return 'file history capture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment captures file history is unknown';
+        case 'not_reported':
+            return 'file history capture not reported by this engine — only newer engines advertise it; this does not say whether file history is captured here';
+        case 'present':
+            if (reading.word === 'off') {
+                return 'file history capture off on this deployment — the engine takes no snapshots of the files it changes; whether code can be rewound here is answered separately by the rewind readings';
+            }
+            if (reading.word === 'on-always') {
+                return 'file history capture always on — the engine snapshots files before changing them in every session, and it cannot be turned off for a single session here';
+            }
+            return `file history capture reported as "${capForDisplay(reading.word, WORD_DETAIL_MAX)}" — a mode this client does not know yet, so whether it captures is shown as unknown`;
+    }
+}
+export function forgetFileHistoryCaptureReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetFileHistoryCaptureReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/gateOutcome.js

@@ -146,6 +146,8 @@ export function ccToolDenialKindForToolEnd(frame) {
     const stamped = frame._sema_denial_kind;
     if (isCcToolDenialKind(stamped))
         return stamped;
+    if (frame._sema_denial_unclassified === true)
+        return undefined;
     const outcome = gateOutcomeOf(frame);
     const kind = outcome?.settlement?.kind;
     if (kind === 'human_refused')

package/dist/hitl/askGateWire.d.ts

@@ -8,7 +8,7 @@ export type { AskAnsweredOutput } from './gateLedger.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
 export type { GateDenyAttribution } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedGateReason, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedGateReason, isGateStandingErrorCode, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export type { HopBudget, HopRound } from './parkResolver.js';
 export type { GateOutcome, GateFailureCode } from './parkResolver.js';
 export declare function bridgeAskUserQuestionGates(source: AsyncGenerator<AgentEvent>, deps: AskGateWireDeps, opts?: {

package/dist/hitl/askGateWire.js

@@ -6,7 +6,7 @@ export { HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE } from './frameRouter.js';
 export { HITL_POLICY_DENY_MESSAGE } from './frameRouter.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedGateReason, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedGateReason, isGateStandingErrorCode, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export async function* bridgeAskUserQuestionGates(source, deps, opts) {
     const led = createGateLedger();
     const taskId = { current: opts?.taskId };

package/dist/hitl/hitlHostSurface.js

@@ -1,7 +1,7 @@
 import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { hostLog } from '../host.js';
 import { unrefTimer } from '../unrefTimer.js';
-import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTriage.js';
+import { decideFailureNote } from '../decideFailureNote.js';
 import { HitlSafetyError } from './hitlBridge.js';
 const hostSurfaceByKey = createSessionSlot();
 const hostSurfaceMissesByKey = new Map();
@@ -113,8 +113,7 @@ export function observeCancelByDeny(settle, taskId) {
             hostLog('debug', `[hitl-cancel-deny] cancel-by-deny no_pending for run ${taskId} (benign — already resolved)`);
             return;
         }
-        const where = corruptStoredRowWhere(e);
-        const rowNote = where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`;
+        const rowNote = decideFailureNote(e);
         hostLog('error', `[hitl-cancel-deny] cancel-by-deny FAILED for run ${taskId}: ${String(e)}${rowNote}`);
         surfaceCancelDenyWarn(`${CANCEL_DENY_WARN_TEXT}${rowNote}`);
     })

package/dist/hitl/parkResolver.d.ts

@@ -33,6 +33,7 @@ export type GateOutcome = {
     currentPending?: GateCurrentPending | undefined;
 };
 export declare function isAlreadyResolvedGateReason(reason: unknown): boolean;
+export declare function isGateStandingErrorCode(code: string | null | undefined): boolean;
 export declare function toAnsweredOutput(questions: unknown[], answer: QuestionAnswer): AskAnsweredOutput;
 export type ParkResolution = {
     kind: 'reattach';

package/dist/hitl/parkResolver.js

@@ -1,5 +1,6 @@
 import { putOwnKey } from '../ownKey.js';
 import { DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, findPendingForTask, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
+import { RESUME_POLICY_FOLD_CODE } from '../engineErrorCodes.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
@@ -7,7 +8,7 @@ import { observeCancelByDeny } from './hitlHostSurface.js';
 import { flushHeldWithInterruptRewrite, isAskTool } from './frameRouter.js';
 import { approvalCallKey, askGateQuestionId } from './gateIdentity.js';
 import { readDecideReceipt } from '../decideReceipt.js';
-import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTriage.js';
+import { decideFailureNote } from '../decideFailureNote.js';
 export const MAX_GATE_HOPS = 2;
 export function nextHopBudget(prev, round) {
     const total = (prev?.total ?? 0) + 1;
@@ -41,7 +42,14 @@ function alreadyResolvedReasonToken(reason) {
 }
 function isAlreadyResolvedFailure(outcome) {
     const code = 'code' in outcome && isGateFailureCode(outcome.code) ? outcome.code : undefined;
-    return code !== undefined ? code === 'no_pending' : isAlreadyResolvedGateReason(outcome.reason);
+    if (code !== undefined)
+        return code === 'no_pending';
+    if ('errorCode' in outcome && isGateStandingErrorCode(outcome.errorCode))
+        return false;
+    return isAlreadyResolvedGateReason(outcome.reason);
+}
+export function isGateStandingErrorCode(code) {
+    return code === RESUME_POLICY_FOLD_CODE || code === 'corrupt';
 }
 export function toAnsweredOutput(questions, answer) {
     const answers = {};
@@ -141,7 +149,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
             kind: 'failed',
             stage: 'decide',
             gatedCallId,
-            reason: withCorruptStoredRow(`decide failed: ${String(e)}`, e),
+            reason: `decide failed: ${String(e)}${decideFailureNote(e)}`,
             ...(code !== undefined ? { code } : {}),
             ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
             ...(currentPending !== undefined ? { currentPending } : {}),
@@ -149,10 +157,6 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
         };
     }
 }
-function withCorruptStoredRow(reason, err) {
-    const where = corruptStoredRowWhere(err);
-    return where === undefined ? reason : `${reason} — ${corruptStoredRowContent(where)}`;
-}
 function argsByCallOf(led) {
     return new Map(led.gatedStartArgs());
 }