@sema-agent/client-core 0.93.1 → 0.94.0

package/dist/engineErrorCodes.d.ts

@@ -16,6 +16,8 @@ export declare const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = "config.memory_write_s
 export declare const CONFIG_LEGACY_TOOL_NAME = "config.legacy_tool_name";
 export declare const CONFIG_IMAGE_INVALID = "config.image_invalid";
 export declare function imageInvalidFailureNoteOf(code: string | undefined): string | undefined;
+export declare const CONFIG_AGENT_UNKNOWN_TOOL = "config.agent.unknown_tool";
+export declare const CONFIG_OUTPUT_STYLE_INVALID = "config.output_style_invalid";
 export declare const CONFIG_REFUSAL_CODES: ReadonlySet<string>;
 export declare const RULES_LEGACY_TOOL_NAME = "rules.legacy_tool_name";
 export declare function isRulesRefusalCode(code: string | undefined): boolean;
@@ -52,6 +54,7 @@ export declare const RESUME_USAGE_WINDOW_EXHAUSTED = "resume.usage_window_exhaus
 export declare const RESUME_PREFLIGHT_REJECTED = "resume.preflight_rejected";
 export declare const RESUME_SESSION_NOT_FOUND = "resume.session_not_found";
 export declare const REQUEST_FIELD_CONFLICT = "request.field_conflict";
+export declare const REQUEST_AUTONOMY_LANE_REFUSED = "request.autonomy_lane_refused";
 export declare const CHECKPOINT_UNSUPPORTED_VERSION = "checkpoint.unsupported_version";
 export declare function refusalSaysStillPending(err: object): boolean;
 export type StatusDerivedCoarseCode = (typeof STATUS_DERIVED_COARSE_CODES)[number];
@@ -74,7 +77,7 @@ export declare const DECIDE_CLAIM_LOST = "decide.claim_lost";
 export declare const DECIDE_PARK_MOVED_CODES: readonly string[];
 export declare function isDecideParkMovedCode(code: string | null | undefined): boolean;
 export declare const ASK_GONE = "gone.ask";
-export declare const ASK_GONE_DENIED_WORD = "routing_failure_fail_closed";
+export declare const ASK_GONE_DENIED_WORD: "routing_failure_fail_closed";
 export declare const RUN_STALLED = "run.stalled";
 export declare const RUN_ORPHANED = "run.orphaned";
 export declare const APPROVAL_EXPIRED = "approval.expired";
@@ -82,6 +85,7 @@ export declare const RUN_DEATH_VERDICT_CODES: readonly ["run.stalled", "run.orph
 export type RunDeathVerdictCode = (typeof RUN_DEATH_VERDICT_CODES)[number];
 export declare function runDeathVerdictNoteOf(code: string | undefined): string | undefined;
 export declare const CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED = "capability.operator_principals_required";
+export declare const COMPACT_NOT_RUNNING = "compact.not_running";
 export declare function isUnavailableFaceCode(code: string | undefined): boolean;
 export type OperatorGateRefusal = 'operator_only' | 'operators_unconfigured';
 export declare function operatorGateRefusalContent(cause: OperatorGateRefusal): string | undefined;

package/dist/engineErrorCodes.js

@@ -1,5 +1,6 @@
 import { frozenSet } from './frozenSet.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
+import { SDK_DENY_REASON_ROUTING_FAILURE, SDK_STATUS_DERIVED_COARSE_CODES } from './generated/sdkFactTables.js';
 export const LIMITS_MAX_TOKENS_EXCEEDED = 'limits.max_tokens_exceeded';
 export const LIMITS_MAX_COST_EXCEEDED = 'limits.max_cost_exceeded';
 export const LIMITS_MAX_TURNS_EXCEEDED = 'limits.max_turns_exceeded';
@@ -25,6 +26,8 @@ const IMAGE_INVALID_FAILURE_NOTE = 'This run did not start: an image sent with t
 export function imageInvalidFailureNoteOf(code) {
     return code === CONFIG_IMAGE_INVALID ? IMAGE_INVALID_FAILURE_NOTE : undefined;
 }
+export const CONFIG_AGENT_UNKNOWN_TOOL = 'config.agent.unknown_tool';
+export const CONFIG_OUTPUT_STYLE_INVALID = 'config.output_style_invalid';
 export const CONFIG_REFUSAL_CODES = frozenSet([
     CONFIG_LIMIT_INVALID,
     CONFIG_STRATEGY_FIND_LIMIT_INVALID,
@@ -35,6 +38,8 @@ export const CONFIG_REFUSAL_CODES = frozenSet([
     CONFIG_MEMORY_WRITE_SCOPE_MISMATCH,
     CONFIG_LEGACY_TOOL_NAME,
     CONFIG_IMAGE_INVALID,
+    CONFIG_AGENT_UNKNOWN_TOOL,
+    CONFIG_OUTPUT_STYLE_INVALID,
     ...CORE_TOOL_DECLARATION_CODES,
 ]);
 export const RULES_LEGACY_TOOL_NAME = 'rules.legacy_tool_name';
@@ -92,17 +97,7 @@ export const STOP_CONFLICT_CODES = Object.freeze([
 ]);
 export const OUTPUT_INVALID = 'output.invalid';
 export const RESUME_POLICY_FOLD_CODE = 'resume_blocked_by_policy';
-export const STATUS_DERIVED_COARSE_CODES = Object.freeze([
-    'request.rejected',
-    'auth.unauthorized',
-    'auth.forbidden',
-    'not_found.resource',
-    'request.payload_too_large',
-    'request.unprocessable',
-    'limit.rate_exceeded',
-    'capability.unavailable',
-    'internal.error',
-]);
+export const STATUS_DERIVED_COARSE_CODES = SDK_STATUS_DERIVED_COARSE_CODES;
 export function isStatusDerivedCoarseCode(code) {
     return typeof code === 'string' && STATUS_DERIVED_COARSE_CODES.includes(code);
 }
@@ -115,6 +110,7 @@ export const RESUME_USAGE_WINDOW_EXHAUSTED = 'resume.usage_window_exhausted';
 export const RESUME_PREFLIGHT_REJECTED = 'resume.preflight_rejected';
 export const RESUME_SESSION_NOT_FOUND = 'resume.session_not_found';
 export const REQUEST_FIELD_CONFLICT = 'request.field_conflict';
+export const REQUEST_AUTONOMY_LANE_REFUSED = 'request.autonomy_lane_refused';
 export const CHECKPOINT_UNSUPPORTED_VERSION = 'checkpoint.unsupported_version';
 export function refusalSaysStillPending(err) {
     try {
@@ -161,7 +157,7 @@ export function isDecideParkMovedCode(code) {
     return typeof code === 'string' && DECIDE_PARK_MOVED_CODES.includes(code);
 }
 export const ASK_GONE = 'gone.ask';
-export const ASK_GONE_DENIED_WORD = 'routing_failure_fail_closed';
+export const ASK_GONE_DENIED_WORD = SDK_DENY_REASON_ROUTING_FAILURE;
 export const RUN_STALLED = 'run.stalled';
 export const RUN_ORPHANED = 'run.orphaned';
 export const APPROVAL_EXPIRED = 'approval.expired';
@@ -181,6 +177,7 @@ export function runDeathVerdictNoteOf(code) {
     return undefined;
 }
 export const CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED = 'capability.operator_principals_required';
+export const COMPACT_NOT_RUNNING = 'compact.not_running';
 export function isUnavailableFaceCode(code) {
     return typeof code === 'string' && (code.startsWith('capability.') || code.startsWith('feature.'));
 }

package/dist/engineNoticeCodes.d.ts

@@ -1,4 +1,4 @@
-import { CORE_TOOL_TURN_INCOMPLETE_CAUSES, CORE_USER_INPUT_UNDRAINED_CAUSES } from './generated/engineNoticeTables.js';
+import { CORE_TOOL_TURN_INCOMPLETE_CAUSES, CORE_USER_INPUT_UNDRAINED_CAUSES, CORE_USER_INPUT_UNDRAINED_FAMILIES } from './generated/engineNoticeTables.js';
 export type NoticeAudience = 'user' | 'operator';
 export declare const ENGINE_NOTICE_CODES: readonly string[];
 export declare function engineNoticeInCatalog(code: unknown): boolean;
@@ -146,8 +146,27 @@ export interface ModelUnreachableFactsView {
     proxyInUse?: string;
     remedy: string;
     sessionId: string;
+    taskId?: string;
 }
 export declare function readModelUnreachable(notice: unknown): ModelUnreachableFactsView | undefined;
+export interface AllowedToolNotGrantedEntryView {
+    source: string;
+    entry: string;
+    entryShown: string;
+    reason: string;
+    skill?: string;
+    skillShown?: string;
+    list?: string;
+    verdict?: string;
+    currentName?: string;
+    currentNameShown?: string;
+    valueType?: string;
+}
+export interface AllowedToolNotGrantedFactsView {
+    entries: readonly AllowedToolNotGrantedEntryView[];
+    sessionId?: string;
+}
+export declare function readAllowedToolNotGranted(notice: unknown): AllowedToolNotGrantedFactsView | undefined;
 export type ToolTurnIncompleteCause = (typeof CORE_TOOL_TURN_INCOMPLETE_CAUSES)[number];
 export interface ToolTurnIncompleteFactsView {
     cause: string;
@@ -159,7 +178,7 @@ export interface ToolTurnIncompleteFactsView {
 export declare function readToolTurnIncomplete(notice: unknown): ToolTurnIncompleteFactsView | undefined;
 export type UserSteerUndrainedCause = (typeof CORE_USER_INPUT_UNDRAINED_CAUSES)[number];
 export interface UserInputUndrainedFactsView {
-    kind: 'steer' | 'followUp';
+    kind: keyof typeof CORE_USER_INPUT_UNDRAINED_FAMILIES;
     count: number;
     cause?: string;
     taskId?: string;
@@ -199,6 +218,7 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'permission.read_deny_unapplied': typeof readReadDenyUnapplied;
     readonly 'context.tool_turn_repaired': typeof readToolTurnRepaired;
     readonly 'server.model_unreachable': typeof readModelUnreachable;
+    readonly 'permission.allowed_tool_not_granted': typeof readAllowedToolNotGranted;
     readonly 'task.tool_turn_incomplete': typeof readToolTurnIncomplete;
     readonly 'task.user_steer_undrained': typeof readUserInputUndrained;
     readonly 'task.user_followup_undrained': typeof readUserInputUndrained;

package/dist/engineNoticeCodes.js

@@ -1,5 +1,6 @@
 import { AUTO_MODE_UNAVAILABLE_CAUSES } from './autoModeUnavailable.js';
-import { CORE_ENGINE_NOTICE_CODES, CORE_MCP_INJECTION_DROP_REASONS, CORE_NOTICE_AUDIENCE, } from './generated/engineNoticeTables.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { CORE_ENGINE_NOTICE_CODES, CORE_MCP_INJECTION_DROP_REASONS, CORE_NOTICE_AUDIENCE, CORE_USER_INPUT_UNDRAINED_FAMILIES, } from './generated/engineNoticeTables.js';
 import { CORE_ASK_UNRESOLVABLE_CAUSES, CORE_DURABLE_MANDATE_SOURCES, CORE_PERMISSION_MODE_FOLD_REASONS, } from './generated/engineFactTables.js';
 export const ENGINE_NOTICE_CODES = CORE_ENGINE_NOTICE_CODES;
 const CATALOG = new Set(ENGINE_NOTICE_CODES);
@@ -520,7 +521,61 @@ function readModelUnreachableOf(notice) {
     if (code === undefined || targetHost === undefined || remedy === undefined || sessionId === undefined)
         return undefined;
     const proxyInUse = nonEmpty(optionalOwnSeat(o, 'proxyInUse'));
-    return { code, targetHost, ...(proxyInUse !== undefined ? { proxyInUse } : {}), remedy, sessionId };
+    const taskId = nonEmpty(optionalOwnSeat(o, 'taskId'));
+    return { code, targetHost, ...(proxyInUse !== undefined ? { proxyInUse } : {}), remedy, sessionId, ...(taskId !== undefined ? { taskId } : {}) };
+}
+const ALLOWED_TOOL_NOT_GRANTED_MAX_ENTRIES = 10_000;
+export function readAllowedToolNotGranted(notice) {
+    return guardedRead(notice, readAllowedToolNotGrantedOf);
+}
+function readAllowedToolNotGrantedOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (ownSeat(n, 'code') !== 'permission.allowed_tool_not_granted')
+        return undefined;
+    const d = ownSeat(n, 'detail');
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const list = ownSeat(o, 'entries');
+    if (!Array.isArray(list))
+        return undefined;
+    const length = list.length;
+    if (length === 0 || length > ALLOWED_TOOL_NOT_GRANTED_MAX_ENTRIES)
+        return undefined;
+    const entries = [];
+    for (let i = 0; i < length; i++) {
+        if (!Object.hasOwn(list, i))
+            return undefined;
+        const item = list[i];
+        if (typeof item !== 'object' || item === null || Array.isArray(item))
+            return undefined;
+        const e = item;
+        const source = nonEmpty(ownSeat(e, 'source'));
+        const reason = nonEmpty(ownSeat(e, 'reason'));
+        const entry = ownSeat(e, 'entry');
+        if (source === undefined || reason === undefined || typeof entry !== 'string')
+            return undefined;
+        const skill = nonEmpty(optionalOwnSeat(e, 'skill'));
+        const which = nonEmpty(optionalOwnSeat(e, 'list'));
+        const verdict = nonEmpty(optionalOwnSeat(e, 'verdict'));
+        const currentName = nonEmpty(optionalOwnSeat(e, 'currentName'));
+        const valueType = nonEmpty(optionalOwnSeat(e, 'valueType'));
+        entries.push(Object.freeze({
+            source,
+            entry,
+            entryShown: displayUntrusted(entry),
+            reason,
+            ...(skill !== undefined ? { skill, skillShown: displayUntrusted(skill) } : {}),
+            ...(which !== undefined ? { list: which } : {}),
+            ...(verdict !== undefined ? { verdict } : {}),
+            ...(currentName !== undefined ? { currentName, currentNameShown: displayUntrusted(currentName) } : {}),
+            ...(valueType !== undefined ? { valueType } : {}),
+        }));
+    }
+    const sessionId = nonEmpty(optionalOwnSeat(o, 'sessionId'));
+    return { entries: Object.freeze(entries), ...(sessionId !== undefined ? { sessionId } : {}) };
 }
 const positiveInt = (v) => (typeof v === 'number' && Number.isInteger(v) && v > 0 ? v : undefined);
 export function readToolTurnIncomplete(notice) {
@@ -557,19 +612,28 @@ function readToolTurnIncompleteOf(notice) {
 export function readUserInputUndrained(notice) {
     return guardedRead(notice, readUserInputUndrainedOf);
 }
+function isUndrainedLane(v) {
+    return typeof v === 'string' && Object.hasOwn(CORE_USER_INPUT_UNDRAINED_FAMILIES, v);
+}
+function undrainedLaneOfCode(code) {
+    for (const lane of Object.keys(CORE_USER_INPUT_UNDRAINED_FAMILIES)) {
+        if (CORE_USER_INPUT_UNDRAINED_FAMILIES[lane].code === code)
+            return lane;
+    }
+    return undefined;
+}
 function readUserInputUndrainedOf(notice) {
     if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
         return undefined;
     const n = notice;
-    const code = ownSeat(n, 'code');
-    const kind = code === 'task.user_steer_undrained' ? 'steer' : code === 'task.user_followup_undrained' ? 'followUp' : undefined;
+    const kind = undrainedLaneOfCode(ownSeat(n, 'code'));
     if (kind === undefined)
         return undefined;
     const d = ownSeat(n, 'detail');
     if (typeof d !== 'object' || d === null || Array.isArray(d))
         return undefined;
     const o = d;
-    const count = positiveInt(ownSeat(o, kind));
+    const count = positiveInt(ownSeat(o, CORE_USER_INPUT_UNDRAINED_FAMILIES[kind].countKey));
     if (count === undefined)
         return undefined;
     const cause = nonEmpty(optionalOwnSeat(o, 'cause'));
@@ -598,6 +662,8 @@ const STEER_UNDRAINED_SENTENCE = Object.freeze({
 });
 const _steerSentencePin = true;
 void _steerSentencePin;
+const _undrainedLanePin = true;
+void _undrainedLanePin;
 const followUpUndrainedSentence = (n) => `${messagesPhrase(n, 'follow-up message')} you queued ${verbBe(n)} not used before the run ended and will not be delivered. ` +
     `Send ${itThem(n)} again if you still need ${itThem(n)}.`;
 const subagentSteerUndrainedSentence = (n) => `${messagesPhrase(n, 'message')} you sent while the run was in progress ${verbBe(n)} not used before a sub-agent's run ended and will not be delivered. ` +
@@ -629,7 +695,7 @@ export function userInputUndrainedNotice(facts) {
     }
     const fromSubagent = typeof child === 'string' && child.length > 0;
     const n = positiveInt(count);
-    if (n === undefined || (kind !== 'steer' && kind !== 'followUp'))
+    if (n === undefined || !isUndrainedLane(kind))
         return undefined;
     if (kind === 'followUp') {
         if (cause === undefined || cause === 'leg_end')
@@ -730,6 +796,7 @@ export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'permission.read_deny_unapplied': readReadDenyUnapplied,
     'context.tool_turn_repaired': readToolTurnRepaired,
     'server.model_unreachable': readModelUnreachable,
+    'permission.allowed_tool_not_granted': readAllowedToolNotGranted,
     'task.tool_turn_incomplete': readToolTurnIncomplete,
     'task.user_steer_undrained': readUserInputUndrained,
     'task.user_followup_undrained': readUserInputUndrained,

package/dist/engineRefusedToolName.d.ts

@@ -0,0 +1 @@
+export declare function isEngineRefusedToolName(name: string): boolean;

package/dist/engineRefusedToolName.js

@@ -0,0 +1,8 @@
+import { CORE_PROTOCOL_PREFIXES, CORE_RETIRED_TOOL_CURRENT_NAMES } from './generated/toolNameTables.js';
+export function isEngineRefusedToolName(name) {
+    if (typeof name !== 'string')
+        return false;
+    if (CORE_RETIRED_TOOL_CURRENT_NAMES.has(name))
+        return true;
+    return name.includes('__') && !CORE_PROTOCOL_PREFIXES.some((prefix) => name.startsWith(prefix));
+}

package/dist/executionLaneCapability.js

@@ -2,16 +2,21 @@ import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { capsGenerationOf, createEngineCapReader } from './engineCapReader.js';
 export function projectExecutionLaneCapability(caps) {
-    if (caps === null || typeof caps !== 'object')
-        return undefined;
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+    try {
+        if (caps === null || typeof caps !== 'object')
+            return undefined;
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        if (!Object.hasOwn(caps, 'executionLane'))
+            return { kind: 'not_reported' };
+        const lane = caps.executionLane;
+        if (lane === undefined)
+            return { kind: 'not_reported' };
+        return projectExecutionLaneObject(lane, () => capsGenerationOf(caps).generation === 'new');
+    }
+    catch {
         return undefined;
-    if (!Object.hasOwn(caps, 'executionLane'))
-        return { kind: 'not_reported' };
-    const lane = caps.executionLane;
-    if (lane === undefined)
-        return { kind: 'not_reported' };
-    return projectExecutionLaneObject(lane, () => capsGenerationOf(caps).generation === 'new');
+    }
 }
 function projectExecutionLaneObject(lane, newGeneration) {
     if (lane === null || typeof lane !== 'object' || Array.isArray(lane))

package/dist/fileHistoryCaptureCapability.js

@@ -3,16 +3,21 @@ import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
 import { FILE_HISTORY_DISABLED } from './request/taskRequest.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)
+    try {
+        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 };
+    }
+    catch {
         return undefined;
-    return { kind: 'present', word: v };
+    }
 }
 const reader = createEngineCapReader({
     name: 'fileHistoryCapture',

package/dist/fileHistoryLegNotice.d.ts

@@ -12,9 +12,20 @@ export interface FileHistoryLegNoticeInput {
 export declare function fileHistoryLegNoticeVerdict(input: FileHistoryLegNoticeInput): FileHistoryLegNoticeVerdict;
 export declare function fileHistoryLegNoticeSentence(verdict: FileHistoryLegNoticeVerdict): string | null;
 export declare function fileHistoryDeclarationOfBody(body: object | null | undefined): FileHistoryDeclarationFact;
+export type OutboundBodyField = {
+    kind: 'absent';
+} | {
+    kind: 'value';
+    value: unknown;
+} | {
+    kind: 'unprovable';
+};
+export declare function readOutboundBodyField(body: object | null | undefined, key: string): OutboundBodyField;
 export interface FileHistoryDeclarationLedger {
     declared(requestKey: string, fact: FileHistoryDeclarationFact): boolean;
     boundToRun(requestKey: string, runId: string, event: AgentEvent): boolean;
     declarationOf(runId: string): FileHistoryDeclarationFact;
+    declaredLegCwd(requestKey: string, cwd: string | undefined): boolean;
+    legCwdOf(runId: string): string | undefined;
 }
 export declare function createFileHistoryDeclarationLedger(): FileHistoryDeclarationLedger;

package/dist/fileHistoryLegNotice.js

@@ -42,41 +42,78 @@ export function fileHistoryLegNoticeSentence(verdict) {
     return null;
 }
 export function fileHistoryDeclarationOfBody(body) {
-    if (typeof body !== 'object' || body === null)
+    const r = readOutboundBodyField(body, 'fileHistory');
+    if (r.kind === 'unprovable')
         return 'unknown';
+    if (r.kind === 'absent')
+        return 'not_sent';
+    return r.value === FILE_HISTORY_DISABLED ? 'sent' : 'not_sent';
+}
+export function readOutboundBodyField(body, key) {
+    const UNPROVABLE = { kind: 'unprovable' };
+    if (typeof body !== 'object' || body === null)
+        return UNPROVABLE;
     try {
         if (Array.isArray(body))
-            return 'unknown';
+            return UNPROVABLE;
         if (typeof body.toJSON === 'function')
-            return 'unknown';
-        const d = Object.getOwnPropertyDescriptor(body, 'fileHistory');
+            return UNPROVABLE;
+        const d = Object.getOwnPropertyDescriptor(body, key);
         const all = Object.getOwnPropertyDescriptors(body);
         for (const k of Reflect.ownKeys(all)) {
             const x = all[k];
             if (x !== undefined && x.enumerable === true && !Object.hasOwn(x, 'value'))
-                return 'unknown';
+                return UNPROVABLE;
         }
-        const listed = Object.hasOwn(all, 'fileHistory') ? all.fileHistory : undefined;
+        const listed = Object.hasOwn(all, key) ? all[key] : undefined;
         const listedOn = listed !== undefined && listed.enumerable === true;
         if (d === undefined || d.enumerable !== true)
-            return listedOn ? 'unknown' : 'not_sent';
+            return listedOn ? UNPROVABLE : { kind: 'absent' };
         if (!Object.hasOwn(d, 'value') || !listedOn || !Object.hasOwn(listed, 'value') || !Object.is(listed.value, d.value))
-            return 'unknown';
-        if (!Object.is(body.fileHistory, d.value))
-            return 'unknown';
+            return UNPROVABLE;
+        if (!Object.is(body[key], d.value))
+            return UNPROVABLE;
         if (typeof d.value === 'object' && d.value !== null)
-            return 'unknown';
-        return d.value === FILE_HISTORY_DISABLED ? 'sent' : 'not_sent';
+            return UNPROVABLE;
+        return { kind: 'value', value: d.value };
     }
     catch {
-        return 'unknown';
+        return UNPROVABLE;
     }
 }
 const idOk = (v) => typeof v === 'string' && v.length > 0;
 export function createFileHistoryDeclarationLedger() {
     const factsByKey = new Map();
+    const cwdsByKey = new Map();
     const keysByRun = new Map();
     return Object.freeze({
+        declaredLegCwd(requestKey, cwd) {
+            if (!idOk(requestKey) || !idOk(cwd))
+                return false;
+            let set = cwdsByKey.get(requestKey);
+            if (set === undefined)
+                cwdsByKey.set(requestKey, (set = new Set()));
+            set.add(cwd);
+            return true;
+        },
+        legCwdOf(runId) {
+            if (!idOk(runId))
+                return undefined;
+            const keys = keysByRun.get(runId);
+            if (keys === undefined)
+                return undefined;
+            let agreed;
+            for (const k of keys) {
+                const cwds = cwdsByKey.get(k);
+                if (cwds === undefined || cwds.size !== 1)
+                    return undefined;
+                const [only] = cwds;
+                if (only === undefined || (agreed !== undefined && agreed !== only))
+                    return undefined;
+                agreed = only;
+            }
+            return agreed;
+        },
         declared(requestKey, fact) {
             if (!idOk(requestKey) || (fact !== 'sent' && fact !== 'not_sent'))
                 return false;

package/dist/fleet/fleetLedger.js

@@ -8,6 +8,7 @@ import { recordEngineTranscriptId } from '../subagent/engineDelegatedPrompt.js';
 import { recordFleetRowAgentType } from './fleetRowAgentType.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { TERMINAL_FLEET_TASK_STATUSES, projectTasks, projectWorkflows, wireCycleSeq, wireParentId, } from './fleetProjection.js';
+import { isInStreamDrainingEnd } from '../wireErrorTriage.js';
 export const TERMINAL_RETAIN_MS = 60_000;
 const liveBgViews = new Map();
 function viewsFor(sessionKey) {
@@ -293,6 +294,10 @@ export function createFleetLedger(hooks = {}, opts = {}) {
                 applyBgNotification(frame.notification, ing);
                 break;
             default:
+                if (isInStreamDrainingEnd(frame)) {
+                    debug('[fleet-frame] drain end frame — the engine is going down; the host reconnects');
+                    break;
+                }
                 droppedUnknownFrame++;
                 debug(`[fleet-frame] UNKNOWN frame type ignored(type=${String(frame.type)})`);
                 break;

package/dist/gateOutcome.d.ts

@@ -32,7 +32,7 @@ export interface GateModeReleaseView {
     mandate?: string;
     reason?: string;
 }
-export declare const GATE_MODE_RELEASE_REASON_WORDS: readonly ["rule_unreadable"];
+export declare const GATE_MODE_RELEASE_REASON_WORDS: readonly ["rule_unreadable", "write_protection_unresolved"];
 export type GateModeReleaseReasonWord = (typeof CORE_MODE_RELEASE_REASONS)[number];
 export declare function isGateModeReleaseReasonWord(v: unknown): v is GateModeReleaseReasonWord;
 export interface SettlementWhoView {
@@ -61,6 +61,7 @@ export declare function gateApprover(g: GateOutcomeView | undefined): string | u
 export declare function isApprovalWindowExpiredGate(g: GateOutcomeView | undefined): boolean;
 export declare function isDenialLimitAutoDeniedGate(g: GateOutcomeView | undefined): boolean;
 export declare function isParkSlaExpiredGate(g: GateOutcomeView | undefined): boolean;
+export declare function isApproverUnavailableGate(g: GateOutcomeView | undefined): boolean;
 export declare function isHumanSettledGate(g: GateOutcomeView | undefined): boolean;
 export declare function isPolicyRefusedGate(g: GateOutcomeView | undefined): boolean;
 export declare function ccToolDenialKindForToolEnd(frame: unknown): CcToolDenialKind | undefined;

package/dist/gateOutcome.js

@@ -171,6 +171,9 @@ export function isDenialLimitAutoDeniedGate(g) {
 export function isParkSlaExpiredGate(g) {
     return g?.settlement?.kind === 'park_sla_expired';
 }
+export function isApproverUnavailableGate(g) {
+    return isDeniedGate(g) && g?.settlement?.kind === 'approver_unavailable';
+}
 export function isHumanSettledGate(g) {
     const k = g?.settlement?.kind;
     return k === 'human_allowed' || k === 'human_refused';

package/dist/gateVocabulary.js

@@ -69,7 +69,7 @@ export function askOriginDetail(origin) {
     return `this call asks; its origin ${word} is a word newer than this client, so answer it as usual`;
 }
 export function mandatedApprovalDetail() {
-    return 'no saved allow rule and no remembered answer can retire this question; each call is settled on its own — by you here, by a hook, or by an automatic check the deployment runs — and an answer covers only that call';
+    return 'no saved allow rule and no remembered answer can retire this question; each call is settled on its own — by you here or by an automatic check the deployment runs — and an answer covers only that call';
 }
 const _mandateWordsPin = true;
 void _mandateWordsPin;

package/dist/generated/engineAskFaceTables.d.ts

@@ -0,0 +1,3 @@
+export declare const CORE_ASK_FACES: readonly ["shell", "other"];
+export declare const CORE_SHELL_FACE_TOOL_NAMES: readonly string[];
+export declare const CORE_RELEASABLE_ASK_CLASSES_BY_FACE: Readonly<Record<(typeof CORE_ASK_FACES)[number], readonly string[]>>;

package/dist/generated/engineAskFaceTables.js

@@ -0,0 +1,12 @@
+export const CORE_ASK_FACES = Object.freeze([
+    "shell",
+    "other",
+]);
+export const CORE_SHELL_FACE_TOOL_NAMES = Object.freeze([
+    "Bash",
+    "Monitor",
+]);
+export const CORE_RELEASABLE_ASK_CLASSES_BY_FACE = Object.freeze({
+    "shell": Object.freeze(["transcript_write", "rule_unreadable", "write_protection_unresolved", "probe", "write_protection", "tool_marks_mcp", "tool_marks_a2a", "artifact_shared_read", "mode", "unstated", "ordinary"]),
+    "other": Object.freeze(["transcript_write", "rule_unreadable", "probe", "write_protection", "tool_marks_mcp", "tool_marks_a2a", "artifact_shared_read", "mode", "unstated", "ordinary"]),
+});

package/dist/generated/engineFactTables.d.ts

@@ -8,7 +8,7 @@ export declare const CORE_DENIED_BY_VALUES: readonly ["policy", "hook", "org", "
 export declare const CORE_PERMISSION_MODE_FOLD_REASONS: readonly string[];
 export declare const CORE_ENGINE_CARD_TYPES: readonly string[];
 export declare const CORE_TOOL_DECLARATION_CODES: readonly string[];
-export declare const CORE_MODE_RELEASE_REASONS: readonly ["rule_unreadable"];
+export declare const CORE_MODE_RELEASE_REASONS: readonly ["rule_unreadable", "write_protection_unresolved"];
 export declare const CORE_HOOK_TOOL_ALIASES: Readonly<Record<string, string>>;
 export declare const CORE_ASK_EVIDENCE_ABSENCE_VALUES: readonly ["not_wired", "not_adjudicated", "unavailable", "no_match", "not_reported"];
 export declare const CORE_SYSTEM_INJECTION_PRIORITIES: readonly ["now", "next", "later"];
@@ -21,7 +21,7 @@ export interface CoreModeArbitrationRow {
     readonly ruleMayClear: boolean;
     readonly hookAskFloor: boolean;
 }
-export declare const CORE_MODE_ARBITRATION: Readonly<Record<"content_question" | "hook" | "ancestor" | "unverifiable_delete" | "transcript_write" | "org_rule" | "governance_unavailable" | "rule_unreadable" | "ask_rule" | "denial_limit_fallback" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "write_protection_unresolved" | "probe" | "write_protection" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "mode" | "unstated" | "ordinary", CoreModeArbitrationRow>>;
+export declare const CORE_MODE_ARBITRATION: Readonly<Record<"content_question" | "hook" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "transcript_write" | "org_rule" | "governance_unavailable" | "rule_unreadable" | "ask_rule" | "denial_limit_fallback" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "write_protection_unresolved" | "probe" | "write_protection" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "mode" | "unstated" | "ordinary", CoreModeArbitrationRow>>;
 export declare const CORE_SKILL_GRANT_ORIGINS: readonly ["model", "user", "inherited"];
 export declare const CORE_ALLOW_ENTRY_INERT_REASONS: readonly ["wildcard_all", "namespace_wildcard", "path_pattern", "domain", "content_unsupported", "grammar", "tool_name", "near_miss"];
 export declare const CORE_ALLOW_RULE_MEMBERS: readonly ["hook", "deployment", "persisted", "skill", "request"];
@@ -38,3 +38,5 @@ export declare const CORE_RULE_BEHAVIORS: readonly ["deny", "ask", "allow"];
 export declare const CORE_MCP_IMAGE_MAX_BASE64: number;
 export declare const CORE_MAX_PENDING_STEER_CHARS: number;
 export declare const CORE_PROMPT_BLOCK_CAUSES: readonly ["block", "crashed", "timeout", "cancelled"];
+export declare const CORE_PERMISSION_MODES: readonly ["default", "acceptEdits", "plan", "auto", "bypassPermissions", "dontAsk"];
+export declare const CORE_APPROVAL_REACH: readonly ["none"];

package/dist/generated/engineFactTables.js

@@ -113,6 +113,7 @@ export const CORE_TOOL_DECLARATION_CODES = Object.freeze([
 ]);
 export const CORE_MODE_RELEASE_REASONS = Object.freeze([
     "rule_unreadable",
+    "write_protection_unresolved",
 ]);
 export const CORE_HOOK_TOOL_ALIASES = Object.freeze(Object.assign(Object.create(null), Object.fromEntries([
     ["ListPeers", "ListAgents"],
@@ -144,6 +145,7 @@ export const CORE_MODE_ARBITRATION = Object.freeze({
     "content_question": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
     "hook": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
     "ancestor": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "dangerous_delete": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
     "unverifiable_delete": Object.freeze({ bypassImmune: true, classifierEligible: true, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
     "transcript_write": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
     "org_rule": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
@@ -255,3 +257,14 @@ export const CORE_PROMPT_BLOCK_CAUSES = Object.freeze([
     "timeout",
     "cancelled",
 ]);
+export const CORE_PERMISSION_MODES = Object.freeze([
+    "default",
+    "acceptEdits",
+    "plan",
+    "auto",
+    "bypassPermissions",
+    "dontAsk",
+]);
+export const CORE_APPROVAL_REACH = Object.freeze([
+    "none",
+]);

package/dist/generated/engineNoticeTables.d.ts

@@ -4,3 +4,8 @@ export declare const CORE_MCP_INJECTION_DROP_REASONS: readonly string[];
 export declare const CORE_NOTICE_MINTER: Readonly<Record<string, 'engine' | 'server'>>;
 export declare const CORE_USER_INPUT_UNDRAINED_CAUSES: readonly ["leg_end", "crashed"];
 export declare const CORE_TOOL_TURN_INCOMPLETE_CAUSES: readonly ["truncated", "unnamed", "bad_frame", "missing_result_synthesized"];
+export interface CoreUserInputUndrainedFamily {
+    readonly code: string;
+    readonly countKey: string;
+}
+export declare const CORE_USER_INPUT_UNDRAINED_FAMILIES: Readonly<Record<"steer" | "followUp", CoreUserInputUndrainedFamily>>;