@sema-agent/client-core 0.86.0 → 0.88.0

package/dist/engineErrorCodes.d.ts

@@ -48,6 +48,8 @@ export declare const REWIND_ERROR_CODE_PREFIXES: readonly ["resume_at.", "rewind
 export declare function isRewindFamilyCode(code: string | undefined): boolean;
 export declare const RESUME_USAGE_WINDOW_EXHAUSTED = "resume.usage_window_exhausted";
 export declare const RESUME_PREFLIGHT_REJECTED = "resume.preflight_rejected";
+export declare const RESUME_SESSION_NOT_FOUND = "resume.session_not_found";
+export type StatusDerivedCoarseCode = (typeof STATUS_DERIVED_COARSE_CODES)[number];
 export declare const RESUME_PLACEMENT_MISMATCH = "resume.placement_mismatch";
 export declare const RESUME_CONTEXT_UNAVAILABLE = "conflict.resume_context_unavailable";
 export declare const RESUME_RETRY_LATER_CODES: readonly string[];

package/dist/engineErrorCodes.js

@@ -106,6 +106,7 @@ export function isRewindFamilyCode(code) {
 }
 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 RESUME_PLACEMENT_MISMATCH = 'resume.placement_mismatch';
 export const RESUME_CONTEXT_UNAVAILABLE = 'conflict.resume_context_unavailable';
 export const RESUME_RETRY_LATER_CODES = Object.freeze([

package/dist/engineNoticeCodes.d.ts

@@ -137,6 +137,24 @@ export interface LegacyModeSeedMigratedFactsView {
     runId: string;
 }
 export declare function readLegacyModeSeedMigrated(notice: unknown): LegacyModeSeedMigratedFactsView | undefined;
+export interface ToolTurnRepairView {
+    form: string;
+    toolCallIds: readonly string[];
+}
+export interface ToolTurnRepairedFactsView {
+    repairs: readonly ToolTurnRepairView[];
+    sessionId: string;
+    runId: string;
+}
+export declare function readToolTurnRepaired(notice: unknown): ToolTurnRepairedFactsView | undefined;
+export interface ModelUnreachableFactsView {
+    code: string;
+    targetHost: string;
+    proxyInUse?: string;
+    remedy: string;
+    sessionId: string;
+}
+export declare function readModelUnreachable(notice: unknown): ModelUnreachableFactsView | undefined;
 export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'mcp.injection_dropped': typeof readMcpInjectionDrop;
     readonly 'delegation.ask_unresolvable': typeof readAskUnresolvable;
@@ -153,6 +171,8 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'permission.ask_released_by_mode': typeof readAskReleasedByMode;
     readonly 'permission.read_deny_unapplied': typeof readReadDenyUnapplied;
     readonly 'resume.legacy_mode_seed_migrated': typeof readLegacyModeSeedMigrated;
+    readonly 'context.tool_turn_repaired': typeof readToolTurnRepaired;
+    readonly 'server.model_unreachable': typeof readModelUnreachable;
 }>;
 type FactReaderTable = typeof ENGINE_NOTICE_FACT_READERS;
 export type EngineNoticeFactsCode = keyof FactReaderTable;

package/dist/engineNoticeCodes.js

@@ -7,6 +7,7 @@ export const SERVER_NOTICE_AUDIENCE = Object.freeze({
     'instructions.source_changed': 'user',
     'memory.layer_locked_legacy': 'operator',
     'session.records_skipped': 'user',
+    'server.model_unreachable': 'user',
 });
 function audienceRow(table, code) {
     return Object.hasOwn(table, code) ? table[code] : undefined;
@@ -483,6 +484,74 @@ function readLegacyModeSeedMigratedOf(notice) {
     const permissionMode = nonEmpty(optionalSeat(mo, 'permissionMode'));
     return { ...(permissionMode !== undefined ? { permissionMode } : {}), droppedKeys, sessionId, runId };
 }
+export function readToolTurnRepaired(notice) {
+    return guardedRead(notice, readToolTurnRepairedOf);
+}
+function ownSeat(o, key) {
+    return Object.hasOwn(o, key) ? o[key] : undefined;
+}
+function optionalOwnSeat(o, key) {
+    try {
+        return ownSeat(o, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readToolTurnRepairedOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (n.code !== 'context.tool_turn_repaired')
+        return undefined;
+    const d = n.detail;
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const rawRepairs = ownSeat(o, 'repairs');
+    if (!Array.isArray(rawRepairs) || rawRepairs.length === 0)
+        return undefined;
+    const count = rawRepairs.length;
+    const repairs = [];
+    for (let i = 0; i < count; i++) {
+        const item = rawRepairs[i];
+        if (typeof item !== 'object' || item === null || Array.isArray(item))
+            return undefined;
+        const it = item;
+        const form = nonEmpty(ownSeat(it, 'form'));
+        const toolCallIds = nameList(ownSeat(it, 'toolCallIds'));
+        if (form === undefined || toolCallIds === undefined || toolCallIds.length === 0)
+            return undefined;
+        repairs.push(Object.freeze({ form, toolCallIds }));
+    }
+    const sessionId = nonEmpty(ownSeat(o, 'sessionId'));
+    const runId = nonEmpty(ownSeat(o, 'runId'));
+    if (sessionId === undefined || runId === undefined)
+        return undefined;
+    return { repairs: Object.freeze(repairs), sessionId, runId };
+}
+export function readModelUnreachable(notice) {
+    return guardedRead(notice, readModelUnreachableOf);
+}
+function readModelUnreachableOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (n.code !== 'server.model_unreachable')
+        return undefined;
+    const d = n.detail;
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const code = nonEmpty(ownSeat(o, 'code'));
+    const targetHost = nonEmpty(ownSeat(o, 'targetHost'));
+    const remedy = nonEmpty(ownSeat(o, 'remedy'));
+    const sessionId = nonEmpty(ownSeat(o, 'sessionId'));
+    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 };
+}
 export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'mcp.injection_dropped': readMcpInjectionDrop,
     'delegation.ask_unresolvable': readAskUnresolvable,
@@ -499,6 +568,8 @@ export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'permission.ask_released_by_mode': readAskReleasedByMode,
     'permission.read_deny_unapplied': readReadDenyUnapplied,
     'resume.legacy_mode_seed_migrated': readLegacyModeSeedMigrated,
+    'context.tool_turn_repaired': readToolTurnRepaired,
+    'server.model_unreachable': readModelUnreachable,
 });
 const _factReaderTablePin = true;
 void _factReaderTablePin;

package/dist/engineWireFor.d.ts

@@ -40,4 +40,5 @@ export type EngineWireNoAnswerKind = 'deadline' | 'time-limit' | 'connection-los
 export declare function noAnswerKindOf(e: object | null | undefined): EngineWireNoAnswerKind | null;
 export declare function noAnswerDetailFrom(e: object | null | undefined): string | null;
 export declare function sendOnce<T>(signal: AbortSignal | null | undefined, run: () => Promise<T>): Promise<T>;
+export declare function provablyNotSent(e: object | null | undefined): boolean;
 export declare function settleInjected<T>(ms: number, signal: AbortSignal | null | undefined, run: (signal: AbortSignal) => Promise<T>): Promise<T>;

package/dist/engineWireFor.js

@@ -331,7 +331,7 @@ export async function sendOnce(signal, run) {
         throw error;
     }
 }
-function provablyNotSent(e) {
+export function provablyNotSent(e) {
     try {
         return e !== null && typeof e === 'object' && (markedNotSent(e) || failedBeforeSend(e));
     }

package/dist/gateOutcome.d.ts

@@ -1,5 +1,6 @@
 import type { DeniedBy, Settlement } from '@sema-agent/sdk';
 import { type CcToolDenialKind } from './gateVocabulary.js';
+import { CORE_MODE_RELEASE_REASONS } from './generated/engineFactTables.js';
 export type GateDispositionView = {
     kind: 'allowed';
     classifier?: GateClassifierRoundView;
@@ -31,6 +32,9 @@ export interface GateModeReleaseView {
     mandate?: string;
     reason?: string;
 }
+export declare const GATE_MODE_RELEASE_REASON_WORDS: readonly ["rule_unreadable"];
+export type GateModeReleaseReasonWord = (typeof CORE_MODE_RELEASE_REASONS)[number];
+export declare function isGateModeReleaseReasonWord(v: unknown): v is GateModeReleaseReasonWord;
 export interface SettlementWhoView {
     party: string;
     approver?: string;

package/dist/gateOutcome.js

@@ -1,8 +1,13 @@
 import { ccToolDenialKindForSettledBy, isCcToolDenialKind, isGateDeniedByWord } from './gateVocabulary.js';
 import { GATE_PARKED_ERROR_CODE } from './engineErrorCodes.js';
+import { CORE_MODE_RELEASE_REASONS } from './generated/engineFactTables.js';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
+export const GATE_MODE_RELEASE_REASON_WORDS = CORE_MODE_RELEASE_REASONS;
+export function isGateModeReleaseReasonWord(v) {
+    return typeof v === 'string' && CORE_MODE_RELEASE_REASONS.includes(v);
+}
 export const SETTLEMENT_KIND_WORDS = Object.freeze([
     'human_allowed',
     'human_refused',

package/dist/generated/engineFactTables.d.ts

@@ -8,3 +8,4 @@ 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"];

package/dist/generated/engineFactTables.js

@@ -111,3 +111,6 @@ export const CORE_TOOL_DECLARATION_CODES = Object.freeze([
     "config.egress_requires_write_effect",
     "config.reserved_tool_name",
 ]);
+export const CORE_MODE_RELEASE_REASONS = Object.freeze([
+    "rule_unreadable",
+]);

package/dist/generated/engineNoticeTables.js

@@ -65,6 +65,7 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "route.base_url_changed_key_unchanged",
     "route.response_model_mismatch",
     "route.tool_call_id_folded",
+    "context.tool_turn_repaired",
     "task.user_steer_undrained",
     "task.user_followup_undrained",
     "steering.parked_input_blocked",
@@ -147,6 +148,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "route.base_url_changed_key_unchanged": "operator",
     "route.response_model_mismatch": "operator",
     "route.tool_call_id_folded": "operator",
+    "context.tool_turn_repaired": "operator",
     "task.user_steer_undrained": "user",
     "task.user_followup_undrained": "user",
     "steering.parked_input_blocked": "user",

package/dist/hitl/crashConverged.d.ts

@@ -8,12 +8,13 @@ export interface CrashConvergedRow {
     readonly ts: number;
     readonly expiresAtMs: number;
     readonly decision: 'denied';
-    readonly cause: 'crashed_before_park';
+    readonly cause: 'crashed_before_park' | 'shutdown_before_park';
     readonly orphanState: CrashConvergedOrphanState;
     readonly originalDecision?: 'approve';
     readonly decidedAtMs?: number;
     readonly convergedAtMs: number;
     readonly resumeSafe: boolean;
+    readonly needsHumanReason?: 'approved_then_interrupted' | 'pending_unsafe' | 'unstable_row' | 'contradictory';
 }
 export interface ApprovalsListEnvelope {
     pending: PendingCheckpoint[];

package/dist/hitl/crashConverged.js

@@ -1,3 +1,8 @@
+const CRASH_CONVERGED_CAUSE_WORDS = Object.freeze({
+    crashed_before_park: true,
+    shutdown_before_park: true,
+});
+const isCrashConvergedCause = (v) => typeof v === 'string' && Object.hasOwn(CRASH_CONVERGED_CAUSE_WORDS, v);
 const isString = (v) => typeof v === 'string';
 const isNumber = (v) => typeof v === 'number';
 const nonEmptyString = (v) => typeof v === 'string' && v.length > 0;
@@ -45,7 +50,7 @@ function readCrashConvergedRow(v) {
             return null;
         if (o.decision !== 'denied')
             return null;
-        if (o.cause !== 'crashed_before_park')
+        if (!isCrashConvergedCause(o.cause))
             return null;
         if (o.orphanState !== 'pending' && o.orphanState !== 'decided')
             return null;
@@ -71,6 +76,15 @@ function readCrashConvergedRow(v) {
         return null;
     }
 }
+function needsHumanReasonOf(reading) {
+    if (reading.unstable)
+        return 'unstable_row';
+    if (reading.orphanState === 'pending' ? reading.hasApprovalEvidence : reading.resumeSafe === true)
+        return 'contradictory';
+    if (reading.orphanState === 'decided')
+        return 'approved_then_interrupted';
+    return 'pending_unsafe';
+}
 export function projectCrashConverged(env) {
     const resumeSafe = [];
     const needsHuman = [];
@@ -96,10 +110,16 @@ export function projectCrashConverged(env) {
             }
             const row = reading.row;
             const consistentlyUnexecuted = reading.orphanState === 'pending' && !reading.hasApprovalEvidence;
-            if (!reading.unstable && consistentlyUnexecuted && reading.resumeSafe === true)
+            if (!reading.unstable && consistentlyUnexecuted && reading.resumeSafe === true) {
+                Reflect.deleteProperty(row, 'needsHumanReason');
                 resumeSafe.push(row);
-            else
+            }
+            else {
+                Object.defineProperty(row, 'needsHumanReason', {
+                    value: needsHumanReasonOf(reading), enumerable: true, writable: true, configurable: true,
+                });
                 needsHuman.push(row);
+            }
         }
     }
     catch {

package/dist/hitl/hitlBridge.d.ts

@@ -47,6 +47,10 @@ export type PlanReviewModeAfter = (typeof PLAN_REVIEW_MODE_AFTER_WORDS)[number];
 export declare function isPlanReviewModeAfter(v: string | undefined): v is PlanReviewModeAfter;
 export type HitlSafetyCode = 'binding_mismatch' | 'no_pending' | 'wrong_gate' | 'bad_plan_edit' | 'bad_plan_mode' | 'empty_answer';
 export type HitlFailureStage = 'fetch' | 'input' | 'card' | 'decide' | 'orchestration';
+export declare const NO_APPROVAL_CARD_PORT_REASON = "no approval card port installed (print/non-REPL mode, or host forgot installApprovalCardPort)";
+export declare const APPROVAL_CARD_PORT_KEY_MISMATCH_REASON = "no approval card port installed for the default session key, but a non-default sessionKey has one \u2014 likely a keyed-install/default-read mismatch (installApprovalCardPortFor vs the zero-arg default-key read), not a missing install";
+export declare const NO_QUESTION_OVERLAY_REASON = "no question overlay mounted (print/non-REPL mode)";
+export declare function isNoDecisionSurfaceReason(reason: string): boolean;
 export interface HitlDecideDenyOutcome {
     decision: 'deny';
     reason?: string | undefined;

package/dist/hitl/hitlBridge.js

@@ -25,6 +25,12 @@ export const PLAN_REVIEW_MODE_AFTER_WORDS = Object.freeze(['default', 'acceptEdi
 export function isPlanReviewModeAfter(v) {
     return v !== undefined && PLAN_REVIEW_MODE_AFTER_WORDS.includes(v);
 }
+export const NO_APPROVAL_CARD_PORT_REASON = 'no approval card port installed (print/non-REPL mode, or host forgot installApprovalCardPort)';
+export const APPROVAL_CARD_PORT_KEY_MISMATCH_REASON = 'no approval card port installed for the default session key, but a non-default sessionKey has one — likely a keyed-install/default-read mismatch (installApprovalCardPortFor vs the zero-arg default-key read), not a missing install';
+export const NO_QUESTION_OVERLAY_REASON = 'no question overlay mounted (print/non-REPL mode)';
+export function isNoDecisionSurfaceReason(reason) {
+    return reason === NO_APPROVAL_CARD_PORT_REASON || reason === APPROVAL_CARD_PORT_KEY_MISMATCH_REASON || reason === NO_QUESTION_OVERLAY_REASON;
+}
 export class HitlSafetyError extends Error {
     code;
     constructor(message, code) {

package/dist/hitl/parkResolver.js

@@ -1,5 +1,5 @@
 import { putOwnKey } from '../ownKey.js';
-import { DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, findPendingForTask, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
+import { DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, NO_QUESTION_OVERLAY_REASON, findPendingForTask, isNoDecisionSurfaceReason, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
 import { PARKED_RESUME_STARTUP_FAILED, RESUME_POLICY_FOLD_CODE, isDecideParkMovedCode } from '../engineErrorCodes.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
@@ -75,7 +75,7 @@ export function toAnsweredOutput(questions, answer) {
 }
 async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGatedCallId, onPresented) {
     if (!hasQuestionOverlay()) {
-        return { kind: 'failed', stage: 'card', reason: 'no question overlay mounted (print/non-REPL mode)' };
+        return { kind: 'failed', stage: 'card', reason: NO_QUESTION_OVERLAY_REASON };
     }
     const found = await findPendingForTask(deps.client, taskId, isAskTool, signal ? { signal } : undefined, parkGatedCallId, (row) => isAskTool(typeof row.toolName === 'string' ? row.toolName : undefined));
     if (!found.ok)
@@ -301,7 +301,8 @@ export async function resolvePark(park, ctx) {
             : outcome.kind === 'retracted'
                 ? 'the approval card was retracted by the host without a decision (nothing was sent; the run stays parked and remains decidable elsewhere)'
                 : undefined;
-        return { kind: 'failsoft', events: failsoftEvents(park, ctx, outcome.kind === 'aborted', failedReason) };
+        const noDecisionSurface = outcome.kind === 'failed' && outcome.stage === 'card' && isNoDecisionSurfaceReason(outcome.reason);
+        return { kind: 'failsoft', events: failsoftEvents(park, ctx, outcome.kind === 'aborted', failedReason, undefined, noDecisionSurface) };
     }
     led.dropHeldForDecidedPark(outcome.gatedCallId, park.gatedCallId);
     if (outcome.gatedCallId) {
@@ -324,7 +325,15 @@ export async function resolvePark(park, ctx) {
         ...(handoffTaskId !== undefined ? { handoffTaskId } : {}),
     };
 }
-function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal) {
+function failsoftReasonSentence(park, failedReason, terminal) {
+    if (terminal !== undefined)
+        return terminal.errorMessage;
+    if (failedReason === undefined)
+        return undefined;
+    return (`${park.gate === 'fs' ? 'Tool approval' : 'AskUserQuestion'} gate could not be answered: ${failedReason}` +
+        ' — the run is still parked on this approval: decide it on the card when it is shown again, or cancel the run.');
+}
+function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, noDecisionSurface = false) {
     const events = [
         ...flushHeldWithInterruptRewrite(ctx.led, {
             terminal: park.pendingDone,
@@ -332,19 +341,15 @@ function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal) {
             gateAbortedByUser,
         }),
     ];
+    const reason = failsoftReasonSentence(park, failedReason, terminal);
     if (park.pendingDone) {
-        events.push(park.pendingDone);
+        events.push(reason === undefined || noDecisionSurface ? park.pendingDone : { ...park.pendingDone, _sema_park_failed_reason: reason });
     }
     else if (terminal !== undefined) {
         events.push({ type: 'failed', ...terminal });
     }
-    else if (failedReason !== undefined) {
-        events.push({
-            type: 'failed',
-            errorCode: 'hitl_unanswered',
-            errorMessage: `${park.gate === 'fs' ? 'Tool approval' : 'AskUserQuestion'} gate could not be answered: ${failedReason}` +
-                ' — the run is still parked on this approval: decide it on the card when it is shown again, or cancel the run.',
-        });
+    else if (reason !== undefined) {
+        events.push({ type: 'failed', errorCode: 'hitl_unanswered', errorMessage: reason });
     }
     return events;
 }

package/dist/hitl/planReviewWire.js

@@ -346,9 +346,11 @@ let decideDispatchSeq = 0;
 function planReviewOpsOf(taskId) {
     return planReviewDecisionOps.filter((op) => op.taskId === taskId);
 }
-function settlePlanReviewDecisionOp(op) {
-    if (op.settledAt === null)
-        op.settledAt = ++planReviewLedgerClock;
+function settlePlanReviewDecisionOp(op, by) {
+    if (op.settledAt !== null)
+        return;
+    op.settledAt = ++planReviewLedgerClock;
+    op.settler = by;
 }
 function pushPlanReviewDecisionOp(op) {
     planReviewDecisionOps.push(op);
@@ -366,18 +368,31 @@ function dropPlanReviewDecisionOp(op) {
     if (i >= 0)
         planReviewDecisionOps.splice(i, 1);
 }
+function claimablePlanReviewDecisionOp(taskId) {
+    const open = planReviewDecisionOps.find((o) => o.taskId === taskId && o.phase === 'handed' && o.settledAt === null);
+    if (open !== undefined)
+        return open;
+    let leftBehind;
+    for (const o of planReviewDecisionOps) {
+        if (o.taskId !== taskId || o.phase !== 'handed' || o.settler !== 'gate_left')
+            continue;
+        if (leftBehind === undefined || o.handedAt > leftBehind.handedAt)
+            leftBehind = o;
+    }
+    return leftBehind;
+}
 export function notePlanReviewDecisionHandedOver(taskId) {
     if (typeof taskId !== 'string' || taskId === '')
         return null;
     if (planReviewDecisionOps.some((op) => op.taskId === taskId && op.settledAt === null))
         return null;
-    const op = { taskId, handedAt: ++planReviewLedgerClock, settledAt: null, phase: 'handed', notApplied: false, ownCallOpen: false };
+    const op = { taskId, handedAt: ++planReviewLedgerClock, settledAt: null, settler: null, phase: 'handed', notApplied: false, ownCallOpen: false };
     pushPlanReviewDecisionOp(op);
     return {
         settle: () => {
             if (op.phase !== 'handed')
                 return;
-            settlePlanReviewDecisionOp(op);
+            settlePlanReviewDecisionOp(op, 'host');
         },
         revoke: () => {
             if (op.phase !== 'handed' || op.settledAt !== null)
@@ -412,7 +427,7 @@ export function notePlanReviewGateLeft(taskId) {
     if (typeof taskId !== 'string' || taskId === '')
         return;
     for (const op of planReviewOpsOf(taskId))
-        settlePlanReviewDecisionOp(op);
+        settlePlanReviewDecisionOp(op, 'gate_left');
 }
 export function latestPlanReviewDecisionMark(taskId) {
     if (typeof taskId !== 'string' || taskId === '')
@@ -434,12 +449,17 @@ async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts,
         hostLog('error', `planReviewWire: decidePlanReview(${decision}) for task ${taskId} REFUSED — a decision for this task is already in flight (duplicate delivery latched)`);
         return;
     }
-    let op = planReviewDecisionOps.find((o) => o.taskId === taskId && o.phase === 'handed' && o.settledAt === null);
+    let op = claimablePlanReviewDecisionOp(taskId);
     if (op === undefined) {
-        op = { taskId: typeof taskId === 'string' ? taskId : String(taskId), handedAt: ++planReviewLedgerClock, settledAt: null, phase: 'posting', notApplied: false, ownCallOpen: true };
+        op = { taskId: typeof taskId === 'string' ? taskId : String(taskId), handedAt: ++planReviewLedgerClock, settledAt: null, settler: null, phase: 'posting', notApplied: false, ownCallOpen: true };
         pushPlanReviewDecisionOp(op);
     }
     else {
+        if (op.settler === 'gate_left') {
+            op.settledAt = null;
+            op.settler = null;
+            op.notApplied = false;
+        }
         op.phase = 'posting';
         op.ownCallOpen = true;
     }
@@ -451,7 +471,7 @@ async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts,
     const settle = (notApplied) => {
         if (notApplied)
             mine.notApplied = true;
-        settlePlanReviewDecisionOp(mine);
+        settlePlanReviewDecisionOp(mine, 'package');
     };
     const dispatchNo = ++decideDispatchSeq;
     hostLog('debug', `planReviewWire: decidePlanReview dispatch #${dispatchNo} task=${taskId} decision=${decision} mode=${permissionModeAfter ?? '-'}`);
@@ -460,7 +480,7 @@ async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts,
     }
     finally {
         releaseLatch();
-        settlePlanReviewDecisionOp(mine);
+        settlePlanReviewDecisionOp(mine, 'package');
         mine.ownCallOpen = false;
     }
 }

package/dist/hitl/suspendedReopen.d.ts

@@ -7,3 +7,10 @@ export type SuspendedReopenReading = {
     readonly kind: 'unstated';
 };
 export declare function suspendedReopenOf(ev: unknown): SuspendedReopenReading;
+export interface ResumeReopenDetail {
+    code: string;
+    reason: 'env_failed' | 'tool_unavailable' | 'tool_contract_mismatch';
+    retriable: true;
+}
+export declare function resumeReopenFromError(err: unknown): ResumeReopenDetail | null;
+export declare function resumeReopenContent(detail: ResumeReopenDetail): string;

package/dist/hitl/suspendedReopen.js

@@ -1,13 +1,44 @@
+import { RESUME_REOPEN_CODES, RESUME_ENV_FAILED, RESUME_TOOL_UNAVAILABLE } from '../engineErrorCodes.js';
 const UNSTATED = Object.freeze({ kind: 'unstated' });
 const NOT_REOPENED = Object.freeze({ kind: 'not_reopened' });
 export function suspendedReopenOf(ev) {
-    if (ev === null || typeof ev !== 'object' || Array.isArray(ev))
+    if (ev === null || typeof ev !== 'object')
         return UNSTATED;
-    const o = ev;
-    if (!Object.hasOwn(o, 'reopened'))
+    try {
+        if (Array.isArray(ev))
+            return UNSTATED;
+        const o = ev;
+        if (!Object.hasOwn(o, 'reopened'))
+            return UNSTATED;
+        const v = o.reopened;
+        if (v === null)
+            return NOT_REOPENED;
+        return typeof v === 'string' && v.length > 0 ? { kind: 'reopened', code: v } : UNSTATED;
+    }
+    catch {
         return UNSTATED;
-    const v = o.reopened;
-    if (v === null)
-        return NOT_REOPENED;
-    return typeof v === 'string' && v.length > 0 ? { kind: 'reopened', code: v } : UNSTATED;
+    }
+}
+export function resumeReopenFromError(err) {
+    if (typeof err !== 'object' || err === null)
+        return null;
+    const code = err.errorCode;
+    if (typeof code !== 'string' || !RESUME_REOPEN_CODES.includes(code))
+        return null;
+    if (err.retriable !== true)
+        return null;
+    const reason = code.slice('resume.'.length);
+    return { code, reason, retriable: true };
+}
+export function resumeReopenContent(detail) {
+    const first = detail.code === RESUME_ENV_FAILED
+        ? 'The execution environment for this parked work could not be brought back'
+        : detail.code === RESUME_TOOL_UNAVAILABLE
+            ? 'The tool this approval was granted for is not available on this engine'
+            : 'The tool this approval was granted for has changed since the approval was recorded';
+    return [
+        first,
+        'The engine re-parked the work before consuming anything — the approval is still pending and your decision was not consumed',
+        'Re-fetch the pending approvals and decide again on an engine where the same tool is available',
+    ].join(' · ');
 }

package/dist/hitl/toolApprovalWire.js

@@ -1,4 +1,4 @@
-import { DEFAULT_DENY_REASON, DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, denyReasonForWire, findPendingForTask, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
+import { APPROVAL_CARD_PORT_KEY_MISMATCH_REASON, DEFAULT_DENY_REASON, DecideTransportRetryExhaustedError, HitlBridge, NO_APPROVAL_CARD_PORT_REASON, HitlSafetyError, denyReasonForWire, findPendingForTask, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
 import { askParkRowArm } from './askParkRowRouting.js';
 import { hostLog } from '../host.js';
 import { readOwnNonEmptyString } from '../ownKey.js';
@@ -120,10 +120,9 @@ function cardPortMissReason() {
     const otherKeysInstalled = cardPortByKey
         .keys()
         .some((k) => k !== DEFAULT_SESSION_KEY && cardPortByKey.get(k) != null);
-    if (otherKeysInstalled) {
-        return 'no approval card port installed for the default session key, but a non-default sessionKey has one — likely a keyed-install/default-read mismatch (installApprovalCardPortFor vs the zero-arg default-key read), not a missing install';
-    }
-    return 'no approval card port installed (print/non-REPL mode, or host forgot installApprovalCardPort)';
+    if (otherKeysInstalled)
+        return APPROVAL_CARD_PORT_KEY_MISMATCH_REASON;
+    return NO_APPROVAL_CARD_PORT_REASON;
 }
 function rememberRefusedByServer(e) {
     switch (readWireErrorCode(e)) {

package/dist/index.d.ts

@@ -145,6 +145,11 @@ export * from './principalWire.js';
 export * from './wireErrorTriage.js';
 export * from './corruptSession.js';
 export * from './corruptSessionCopy.js';
+export { classifyToolHistoryMismatch, resolveToolHistoryRewindTarget } from './toolHistoryMismatch.js';
+export { classifyRegistryConflict, isScopeGoneError } from './registryConflict.js';
+export type { RegistryConflictClass } from './registryConflict.js';
+export { createPromptDeliveryLedger, promptKnownUndelivered, withoutUndeliveredPrompts } from './promptDelivery.js';
+export type { PromptDeliveryLedger, PromptDeliveryRecord } from './promptDelivery.js';
 export * from './resumeRefusalCopy.js';
 export * from './wireRefusalCopy.js';
 export * from './inheritEnvWire.js';
@@ -197,6 +202,8 @@ export { readEngineAgentRegistry, isEngineAgentRegistryListingSuperseded } from
 export type { EngineAgentRegistryClient } from './agentSession/engineAgentRegistryRead.js';
 export { stopEngineSessionBackground, engineSessionBackgroundReceiptReadingOf, ENGINE_SESSION_BACKGROUND_RECEIPT_STATES, } from './agentSession/engineSessionBackgroundStop.js';
 export type { EngineSessionBackgroundStopClient, EngineSessionBackgroundStopWire, EngineSessionBackgroundStopOptions, EngineSessionBackgroundReceipt, EngineSessionBackgroundStopUnavailableWhy, EngineSessionBackgroundStopRefusedWhy, EngineSessionBackgroundStopResult, EngineSessionBackgroundReceiptState, EngineSessionBackgroundReceiptReading, } from './agentSession/engineSessionBackgroundStop.js';
+export { eraseSessionMemory, sessionMemoryEraseOutcome, SESSION_MEMORY_ERASE_REFUSAL_REASONS, SESSION_MEMORY_ERASE_UNCONFIRMED_WHYS, SESSION_MEMORY_ERASE_RETRIES, } from './sessionMemoryErase.js';
+export type { SessionMemoryEraseWire, SessionMemoryEraseCall, SessionMemoryEraseOptions, SessionMemoryEraseSent, SessionMemoryEraseNotSentWhy, SessionMemoryEraseJson, SessionMemoryEraseAnswer, SessionMemoryEraseRefusalReason, SessionMemoryEraseUnconfirmedWhy, SessionMemoryEraseRetry, SessionMemoryEraseOutcome, } from './sessionMemoryErase.js';
 export * from './model/catalog.js';
 export * from './model/catalogLoader.js';
 export * from './model/providerAuth.js';

package/dist/index.js

@@ -133,6 +133,9 @@ export * from './principalWire.js';
 export * from './wireErrorTriage.js';
 export * from './corruptSession.js';
 export * from './corruptSessionCopy.js';
+export { classifyToolHistoryMismatch, resolveToolHistoryRewindTarget } from './toolHistoryMismatch.js';
+export { classifyRegistryConflict, isScopeGoneError } from './registryConflict.js';
+export { createPromptDeliveryLedger, promptKnownUndelivered, withoutUndeliveredPrompts } from './promptDelivery.js';
 export * from './resumeRefusalCopy.js';
 export * from './wireRefusalCopy.js';
 export * from './inheritEnvWire.js';
@@ -181,6 +184,7 @@ export * from './agentSession/backgroundView.js';
 export { READ_CREDENTIAL_NOT_ACCEPTED_NOTICE } from './readCredentialRefusal.js';
 export { readEngineAgentRegistry, isEngineAgentRegistryListingSuperseded } from './agentSession/engineAgentRegistryRead.js';
 export { stopEngineSessionBackground, engineSessionBackgroundReceiptReadingOf, ENGINE_SESSION_BACKGROUND_RECEIPT_STATES, } from './agentSession/engineSessionBackgroundStop.js';
+export { eraseSessionMemory, sessionMemoryEraseOutcome, SESSION_MEMORY_ERASE_REFUSAL_REASONS, SESSION_MEMORY_ERASE_UNCONFIRMED_WHYS, SESSION_MEMORY_ERASE_RETRIES, } from './sessionMemoryErase.js';
 export * from './model/catalog.js';
 export * from './model/catalogLoader.js';
 export * from './model/providerAuth.js';

package/dist/promptDelivery.d.ts

@@ -0,0 +1,20 @@
+import type { AgentEvent } from '@sema-agent/sdk';
+import { type SelfHealOutcome } from './adapter/activeRunSelfHeal.js';
+export interface PromptDeliveryRecord {
+    readonly u: string;
+    readonly s: 'a' | 'd';
+}
+export interface PromptDeliveryLedger {
+    attempted(batchUuids: readonly string[]): readonly PromptDeliveryRecord[];
+    deliveredByFrame(batchUuids: readonly string[], event: AgentEvent): readonly PromptDeliveryRecord[];
+    deliveredBySteerReceipt(batchUuids: readonly string[], outcome: SelfHealOutcome): readonly PromptDeliveryRecord[];
+    isAttempted(uuid: string): boolean;
+    isDelivered(uuid: string): boolean;
+    knownUndelivered(uuid: string): boolean;
+    batchOf(uuid: string): readonly string[] | undefined;
+    toRecords(): readonly PromptDeliveryRecord[];
+    fromRecords(records: readonly PromptDeliveryRecord[]): readonly PromptDeliveryRecord[];
+}
+export declare function createPromptDeliveryLedger(): PromptDeliveryLedger;
+export declare function promptKnownUndelivered(ledger: PromptDeliveryLedger, message: object | null | undefined): boolean;
+export declare function withoutUndeliveredPrompts<T>(ledger: PromptDeliveryLedger, messages: readonly T[]): T[];