@sema-agent/client-core 0.96.0 → 0.97.0

package/dist/fleet/fleetLedger.js

@@ -99,40 +99,48 @@ export function createFleetLedger(hooks = {}, opts = {}) {
     const wfMap = new Map();
     const rowMeta = new Map();
     const retained = new Map();
-    const cycleWatermark = new Map();
-    const CYCLE_WATERMARK_MAX = 512;
-    function raiseCycleWatermark(tail, gen) {
+    const tails = new Map();
+    const TAIL_RECORD_MAX = 512;
+    function touchTail(tail) {
+        const prior = tails.get(tail);
+        tails.delete(tail);
+        if (prior === undefined && tails.size >= TAIL_RECORD_MAX) {
+            const held = new Set();
+            for (const id of taskMap.keys())
+                held.add(rowIdTail(id));
+            for (const id of retained.keys())
+                held.add(rowIdTail(id));
+            for (const candidate of tails.keys()) {
+                if (held.has(candidate))
+                    continue;
+                tails.delete(candidate);
+                break;
+            }
+        }
+        const rec = prior ?? { gen: undefined, settled: undefined };
+        tails.set(tail, rec);
+        return rec;
+    }
+    function raiseTailGen(tail, gen) {
         if (gen === undefined || tail.length === 0)
             return;
-        const prior = cycleWatermark.get(tail);
+        const prior = tails.get(tail)?.gen;
         if (prior !== undefined && cycleSeqOrder(prior, gen) !== 'before')
             return;
-        cycleWatermark.delete(tail);
-        if (cycleWatermark.size >= CYCLE_WATERMARK_MAX) {
-            const oldest = cycleWatermark.keys().next().value;
-            if (oldest !== undefined)
-                cycleWatermark.delete(oldest);
-        }
-        cycleWatermark.set(tail, gen);
+        touchTail(tail).gen = gen;
+    }
+    function isFormerGeneration(tail, gen) {
+        return cycleSeqOrder(gen, tails.get(tail)?.gen) === 'before';
     }
-    const settledTerminal = new Map();
-    const SETTLED_TERMINAL_MAX = 512;
     function noteSettledTerminal(tail, row) {
         if (tail.length === 0 || typeof row.status !== 'string')
             return;
-        const gen = wireCycleSeq(row);
-        const recordedGen = settledTerminal.get(tail)?.cycleSeq;
-        if (cycleSeqOrder(gen, recordedGen) === 'before')
-            return;
-        if (cycleSeqOrder(gen, cycleWatermark.get(tail)) === 'before')
-            return;
-        settledTerminal.delete(tail);
-        if (settledTerminal.size >= SETTLED_TERMINAL_MAX) {
-            const oldest = settledTerminal.keys().next().value;
-            if (oldest !== undefined)
-                settledTerminal.delete(oldest);
-        }
-        settledTerminal.set(tail, { status: row.status, cycleSeq: gen });
+        touchTail(tail).settled = { status: row.status, cycleSeq: wireCycleSeq(row) };
+    }
+    function withdrawSettledTerminal(tail) {
+        const rec = tails.get(tail);
+        if (rec !== undefined)
+            rec.settled = undefined;
     }
     let droppedMalformed = 0;
     let droppedUnknownFrame = 0;
@@ -167,11 +175,16 @@ export function createFleetLedger(hooks = {}, opts = {}) {
             ...(retired ? { retiredByNotification: true } : {}),
         };
     };
-    function settleTerminalRow(row, receivedAtMs) {
+    function settleTerminalRow(row, tail, receivedAtMs) {
         taskMap.delete(row.id);
         rowMeta.delete(row.id);
+        for (const id of taskMap.keys()) {
+            if (rowIdTail(id) === tail) {
+                debug(`[fleet-frame] terminal row not retained: tail still in flight on an alias(row=${row.id} alias=${id})`);
+                return;
+            }
+        }
         retained.set(row.id, { row, expireAt: receivedAtMs + TERMINAL_RETAIN_MS });
-        const tail = rowIdTail(row.id);
         for (const id of [...retained.keys()]) {
             if (id !== row.id && rowIdTail(id) === tail)
                 retained.delete(id);
@@ -179,18 +192,32 @@ export function createFleetLedger(hooks = {}, opts = {}) {
         noteSettledTerminal(tail, row);
     }
     function admitRow(row, receivedAtMs) {
+        const tail = rowIdTail(row.id);
+        const gen = wireCycleSeq(row);
+        if (isFormerGeneration(tail, gen)) {
+            debug(`[fleet-frame] former-generation row ignored(row=${row.id} row-cycle=${gen} tail-cycle=${tails.get(tail)?.gen})`);
+            return;
+        }
+        raiseTailGen(tail, gen);
+        if (gen !== undefined) {
+            for (const [id, alias] of [...taskMap]) {
+                if (id !== row.id && rowIdTail(id) === tail && cycleSeqOrder(wireCycleSeq(alias), gen) === 'before') {
+                    taskMap.delete(id);
+                    rowMeta.delete(id);
+                }
+            }
+        }
         if (isSdkFleetTaskTerminal(row.status)) {
-            settleTerminalRow(row, receivedAtMs);
+            settleTerminalRow(row, tail, receivedAtMs);
             return;
         }
         taskMap.set(row.id, row);
         rowMeta.set(row.id, { receivedAtMs });
-        const tail = rowIdTail(row.id);
         for (const id of [...retained.keys()]) {
             if (rowIdTail(id) === tail)
                 retained.delete(id);
         }
-        settledTerminal.delete(tail);
+        withdrawSettledTerminal(tail);
         clearBgTerminalFacts(tail);
     }
     function forgetSettledTerminalRowOf(id) {
@@ -243,9 +270,6 @@ export function createFleetLedger(hooks = {}, opts = {}) {
                 break;
             }
             case 'snapshot': {
-                taskMap.clear();
-                wfMap.clear();
-                rowMeta.clear();
                 const receivedAtMs = nowFn();
                 const rows = [];
                 for (const row of frame.tasks) {
@@ -256,12 +280,26 @@ export function createFleetLedger(hooks = {}, opts = {}) {
                     }
                     rows.push(row);
                 }
+                const keepTails = new Set();
+                const currentTails = new Set();
+                for (const row of rows) {
+                    const tail = rowIdTail(row.id);
+                    if (isFormerGeneration(tail, wireCycleSeq(row)))
+                        keepTails.add(tail);
+                    else
+                        currentTails.add(tail);
+                }
+                for (const tail of currentTails)
+                    keepTails.delete(tail);
+                for (const id of [...taskMap.keys()]) {
+                    if (keepTails.has(rowIdTail(id)))
+                        continue;
+                    taskMap.delete(id);
+                    rowMeta.delete(id);
+                }
+                wfMap.clear();
                 for (const row of rows)
-                    if (isSdkFleetTaskTerminal(row.status))
-                        admitRow(row, receivedAtMs);
-                for (const row of rows)
-                    if (!isSdkFleetTaskTerminal(row.status))
-                        admitRow(row, receivedAtMs);
+                    admitRow(row, receivedAtMs);
                 for (const row of frame.workflows)
                     wfMap.set(row.id, row);
                 break;
@@ -275,7 +313,6 @@ export function createFleetLedger(hooks = {}, opts = {}) {
                 }
                 const receivedAtMs = nowFn();
                 admitRow(row, receivedAtMs);
-                raiseCycleWatermark(rowIdTail(row.id), wireCycleSeq(row));
                 debug(`[fleet-row] id=${row.id} parent=${row.parentId ?? '-'} agentType=${row.agentType ?? '-'}` +
                     ` agentName=${row.agentName ?? '-'} name=${row.name ?? '-'} status=${row.status ?? '-'}` +
                     ` tokens=${row.tokens ?? '-'} parentToolCallId=${row.parentToolCallId ?? '-'}`);
@@ -420,79 +457,65 @@ export function createFleetLedger(hooks = {}, opts = {}) {
             const writtenIds = new Set();
             let applied = false;
             let washBlocked = false;
-            let staleBlocked = false;
             const notifSeq = cycleSeqValue(n.seq);
-            {
-                const mark = cycleWatermark.get(n.taskId);
-                if (cycleSeqOrder(notifSeq, mark) === 'before') {
-                    staleBlocked = true;
-                    debug(`[fleet-frame] bg_notification stale-cycle ignored(watermark=${mark} notif-seq=${notifSeq})`);
-                }
-            }
-            for (const id of rowIds) {
-                const known = taskMap.get(id);
-                if (!known)
-                    continue;
-                const heldGen = wireCycleSeq(known);
-                if (cycleSeqOrder(notifSeq, heldGen) === 'before') {
-                    staleBlocked = true;
-                    debug(`[fleet-frame] bg_notification stale-cycle ignored(row=${id} row-cycle=${heldGen} notif-seq=${notifSeq})`);
-                    continue;
-                }
-                const started = known.startedAt;
-                const meta = rowMeta.get(id);
-                const frozenElapsed = typeof started === 'number' && started > 0 && started <= nowMs
-                    ? nowMs - started
-                    : meta !== undefined && isElapsedBase(known.elapsedMs)
-                        ? known.elapsedMs + Math.max(0, nowMs - meta.receivedAtMs)
-                        : known.elapsedMs;
-                taskMap.delete(id);
-                rowMeta.delete(id);
-                retained.set(id, {
-                    row: {
-                        ...known,
-                        status: coerced,
-                        ...(typeof frozenElapsed === 'number' ? { elapsedMs: frozenElapsed } : {}),
-                    },
-                    expireAt: nowMs + TERMINAL_RETAIN_MS,
-                    retiredByNotification: true,
-                });
-                writtenIds.add(id);
-                applied = true;
+            const staleBlocked = isFormerGeneration(notifTail, notifSeq);
+            if (staleBlocked) {
+                debug(`[fleet-frame] bg_notification stale-cycle ignored(tail-cycle=${tails.get(notifTail)?.gen} notif-seq=${notifSeq})`);
             }
-            for (const [id, entry] of retained) {
-                if (writtenIds.has(id))
-                    continue;
-                if (rowIdTail(id) !== notifTail)
-                    continue;
-                const retainedGen = wireCycleSeq(entry.row);
-                if (cycleSeqOrder(notifSeq, retainedGen) === 'before') {
-                    staleBlocked = true;
-                    debug(`[fleet-frame] bg_notification stale-cycle ignored(retained=${id} row-cycle=${retainedGen} notif-seq=${notifSeq})`);
-                    continue;
-                }
-                const prior = entry.row.status ?? '';
-                if (prior === n.status) {
+            if (!staleBlocked) {
+                for (const id of rowIds) {
+                    const known = taskMap.get(id);
+                    if (!known)
+                        continue;
+                    const started = known.startedAt;
+                    const meta = rowMeta.get(id);
+                    const frozenElapsed = typeof started === 'number' && started > 0 && started <= nowMs
+                        ? nowMs - started
+                        : meta !== undefined && isElapsedBase(known.elapsedMs)
+                            ? known.elapsedMs + Math.max(0, nowMs - meta.receivedAtMs)
+                            : known.elapsedMs;
+                    taskMap.delete(id);
+                    rowMeta.delete(id);
+                    retained.set(id, {
+                        row: {
+                            ...known,
+                            status: coerced,
+                            ...(typeof frozenElapsed === 'number' ? { elapsedMs: frozenElapsed } : {}),
+                        },
+                        expireAt: nowMs + TERMINAL_RETAIN_MS,
+                        retiredByNotification: true,
+                    });
+                    writtenIds.add(id);
                     applied = true;
-                    continue;
                 }
-                if (isWashGreen(prior, n.status)) {
-                    washBlocked = true;
-                    debug(`[fleet-frame] bg_notification WASH-GREEN blocked(retained=${id} prior=${prior} notif=${n.status})`);
-                    continue;
+                for (const [id, entry] of retained) {
+                    if (writtenIds.has(id))
+                        continue;
+                    if (rowIdTail(id) !== notifTail)
+                        continue;
+                    const prior = entry.row.status ?? '';
+                    if (prior === n.status) {
+                        applied = true;
+                        continue;
+                    }
+                    if (isWashGreen(prior, n.status)) {
+                        washBlocked = true;
+                        debug(`[fleet-frame] bg_notification WASH-GREEN blocked(retained=${id} prior=${prior} notif=${n.status})`);
+                        continue;
+                    }
+                    retained.set(id, {
+                        row: { ...entry.row, status: coerced },
+                        expireAt: nowMs + TERMINAL_RETAIN_MS,
+                        ...(entry.retiredByNotification === true ? { retiredByNotification: true } : {}),
+                    });
+                    applied = true;
                 }
-                retained.set(id, {
-                    row: { ...entry.row, status: coerced },
-                    expireAt: nowMs + TERMINAL_RETAIN_MS,
-                    ...(entry.retiredByNotification === true ? { retiredByNotification: true } : {}),
-                });
-                applied = true;
             }
             const factsAccepted = !staleBlocked &&
                 (applied ||
                     (!washBlocked &&
                         (() => {
-                            for (const prior of [getBgTerminalFacts(n.taskId), settledTerminal.get(notifTail)]) {
+                            for (const prior of [getBgTerminalFacts(n.taskId), tails.get(notifTail)?.settled]) {
                                 if (prior === undefined)
                                     continue;
                                 const order = cycleSeqOrder(notifSeq, prior.cycleSeq);
@@ -506,7 +529,7 @@ export function createFleetLedger(hooks = {}, opts = {}) {
                             return true;
                         })()));
             if (factsAccepted)
-                raiseCycleWatermark(n.taskId, notifSeq);
+                raiseTailGen(notifTail, notifSeq);
             if (factsAccepted) {
                 recordBgTerminalFacts(n.taskId, {
                     status: n.status,
@@ -633,7 +656,8 @@ export function createFleetLedger(hooks = {}, opts = {}) {
         wfMap.clear();
         rowMeta.clear();
         retained.clear();
-        settledTerminal.clear();
+        for (const rec of tails.values())
+            rec.settled = undefined;
         contentAnchorSet = false;
         contentAnchor = undefined;
         debug(`[fleet-frame] 会话锚变更(${from ?? '-'} → ${to ?? '-'})⇒ 清上一会话的行/留存` +

package/dist/gateOutcome.js

@@ -1,7 +1,6 @@
 import { ccToolDenialKindForSettledBy, isCcToolDenialKind, isGateDeniedByWord } from './gateVocabulary.js';
 import { GATE_PARKED_ERROR_CODE } from './engineErrorCodes.js';
 import { CORE_MODE_RELEASE_REASONS, CORE_SETTLEMENT_KINDS } from './generated/engineFactTables.js';
-import { currentEngineWord } from './engineWordRenames.js';
 import { readAskOrigin, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
@@ -19,9 +18,8 @@ export function modeReleaseReasonSentence(reason) {
     try {
         if (typeof reason !== 'string' || reason === '')
             return undefined;
-        const word = currentEngineWord(reason);
-        return Object.hasOwn(MODE_RELEASE_SENTENCE_BY_REASON, word)
-            ? MODE_RELEASE_SENTENCE_BY_REASON[word]
+        return Object.hasOwn(MODE_RELEASE_SENTENCE_BY_REASON, reason)
+            ? MODE_RELEASE_SENTENCE_BY_REASON[reason]
             : MODE_RELEASE_UNRECOGNISED_SENTENCE;
     }
     catch {

package/dist/gateVocabulary.d.ts

@@ -1,5 +1,4 @@
 import { CORE_DENIED_BY_VALUES, CORE_PERSISTED_RULE_MANDATES } from './generated/engineFactTables.js';
-import { PRIOR_ENGINE_WORD_RENAMES, type PriorEngineWord } from './engineWordRenames.js';
 export declare const CC_TOOL_DENIAL_KINDS: readonly ["user-rejected", "permission-rule", "automode-blocked", "automode-unavailable", "automode-parsing-error", "interrupted", "cancelled"];
 export type CcToolDenialKind = (typeof CC_TOOL_DENIAL_KINDS)[number];
 export declare function isCcToolDenialKind(v: unknown): v is CcToolDenialKind;
@@ -11,11 +10,7 @@ export declare function isGateDeniedByWord(v: unknown): v is GateDeniedByWord;
 export declare function gateDeniedByDetail(deniedBy: unknown): string;
 export declare function askOriginDetail(origin: unknown): string;
 export declare function mandatedApprovalDetail(): string;
-type RetiredMandateWord = {
-    [K in PriorEngineWord]: (typeof PRIOR_ENGINE_WORD_RENAMES)[K] extends (typeof CORE_PERSISTED_RULE_MANDATES)[number] ? K : never;
-}[PriorEngineWord];
-export declare const APPROVAL_MANDATE_WORDS: readonly ((typeof CORE_PERSISTED_RULE_MANDATES)[number] | RetiredMandateWord)[];
+export declare const APPROVAL_MANDATE_WORDS: readonly (typeof CORE_PERSISTED_RULE_MANDATES)[number][];
 export type ApprovalMandateWord = (typeof APPROVAL_MANDATE_WORDS)[number];
 export declare function isApprovalMandateWord(v: unknown): v is ApprovalMandateWord;
 export declare function approvalMandateDetail(word: ApprovalMandateWord): string;
-export {};

package/dist/gateVocabulary.js

@@ -1,5 +1,4 @@
 import { CORE_DENIED_BY_VALUES, CORE_PERSISTED_RULE_MANDATES } from './generated/engineFactTables.js';
-import { PRIOR_ENGINE_WORD_RENAMES } from './engineWordRenames.js';
 export const CC_TOOL_DENIAL_KINDS = Object.freeze([
     'user-rejected',
     'permission-rule',
@@ -72,8 +71,7 @@ export function askOriginDetail(origin) {
 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 or by an automatic check the deployment runs — and an answer covers only that call';
 }
-const RETIRED_MANDATE_WORDS = Object.freeze(Object.keys(PRIOR_ENGINE_WORD_RENAMES).filter((k) => CORE_PERSISTED_RULE_MANDATES.includes(PRIOR_ENGINE_WORD_RENAMES[k])));
-export const APPROVAL_MANDATE_WORDS = Object.freeze([...CORE_PERSISTED_RULE_MANDATES, ...RETIRED_MANDATE_WORDS]);
+export const APPROVAL_MANDATE_WORDS = Object.freeze([...CORE_PERSISTED_RULE_MANDATES]);
 const _mandateWordsPin = true;
 void _mandateWordsPin;
 export function isApprovalMandateWord(v) {
@@ -86,9 +84,8 @@ const APPROVAL_MANDATE_SENTENCES = Object.freeze({
     probe_unanswered: 'the check run on this call did not answer (it timed out or failed; this client cannot tell which), so whether the call stays inside the directories allowed for this session is unknown',
     write_protection: "this change lands on a protected location (the agent's own configuration), which is confirmed one change at a time",
     target_unresolved: 'where this change lands on disk could not be determined (a link on the way could not be examined, or the target could not be resolved), so whether it lands on a guarded location is unknown',
-    write_protection_unresolved: 'the protected-location check could not tell where this change lands, so whether it touches a protected location is unknown',
 });
-const APPROVAL_MANDATE_SET = new Set(Object.keys(APPROVAL_MANDATE_SENTENCES));
+const APPROVAL_MANDATE_SET = new Set(APPROVAL_MANDATE_WORDS);
 export function approvalMandateDetail(word) {
     if (typeof word === 'string' && Object.hasOwn(APPROVAL_MANDATE_SENTENCES, word)) {
         return APPROVAL_MANDATE_SENTENCES[word];

package/dist/generated/sdkFactTables.d.ts

@@ -3,3 +3,5 @@ export declare const SDK_STATUS_DERIVED_COARSE_CODES: readonly ["request.rejecte
 export declare const SDK_DENY_REASON_ROUTING_FAILURE: "routing_failure_fail_closed";
 export declare const SDK_ASK_ROW_ENDING_CAUSES: readonly ["routing_failure_fail_closed", "run_cancelled", "run_exited", "batch_aborted", "batch_sibling_withdrawn", "batch_bound_elsewhere", "adhoc_leg_no_durable_domain", "orphan_ttl_exceeded", "crashed_before_park", "shutdown_before_park"];
 export declare const SDK_RUN_DEATH_VERDICT_CODES: readonly ["run.stalled", "run.orphaned", "approval.expired"];
+export declare const SDK_APPROVAL_DECIDE_GATE_KINDS: readonly ["human", "irreversible_ask"];
+export declare const SDK_PLAN_REVIEW_GATE_KINDS: readonly ["plan_review"];

package/dist/generated/sdkFactTables.js

@@ -32,3 +32,10 @@ export const SDK_RUN_DEATH_VERDICT_CODES = Object.freeze([
     "run.orphaned",
     "approval.expired",
 ]);
+export const SDK_APPROVAL_DECIDE_GATE_KINDS = Object.freeze([
+    "human",
+    "irreversible_ask",
+]);
+export const SDK_PLAN_REVIEW_GATE_KINDS = Object.freeze([
+    "plan_review",
+]);

package/dist/generated/toolNameTables.d.ts

@@ -1,3 +1,2 @@
 export declare const CORE_PROTOCOL_PREFIXES: readonly ["mcp__", "a2a__"];
-export declare const CORE_RETIRED_TOOL_CURRENT_NAMES: ReadonlyMap<string, string | null>;
 export declare const CORE_SKILL_TOOL_NAME: "Skill";

package/dist/generated/toolNameTables.js

@@ -1,44 +1,2 @@
 export const CORE_PROTOCOL_PREFIXES = ["mcp__", "a2a__"];
-export const CORE_RETIRED_TOOL_CURRENT_NAMES = new Map([
-    ["read_file", "Read"],
-    ["edit_file", "Edit"],
-    ["write_file", "Write"],
-    ["bash", "Bash"],
-    ["bash_readonly", null],
-    ["glob", "Glob"],
-    ["grep", "Grep"],
-    ["web_fetch", "WebFetch"],
-    ["tool_search", "ToolSearch"],
-    ["skill", "Skill"],
-    ["present_plan", "ExitPlanMode"],
-    ["enter_plan_mode", "EnterPlanMode"],
-    ["spawn_subagent", "Agent"],
-    ["CronCancel", "CronDelete"],
-    ["lsp", "LSP"],
-    ["submit_output", "StructuredOutput"],
-    ["repo_map", "RepoMap"],
-    ["read_tool_result", "ReadToolResult"],
-    ["report_blocked", "ReportBlocked"],
-    ["declare_done", "DeclareDone"],
-    ["run_workflow", "Workflow"],
-    ["RunWorkflow", "Workflow"],
-    ["Task", "Agent"],
-    ["BashOutput", "TaskOutput"],
-    ["AgentOutputTool", "TaskOutput"],
-    ["BashOutputTool", "TaskOutput"],
-    ["AgentOutput", "TaskOutput"],
-    ["WorkflowStatus", null],
-    ["KillShell", "TaskStop"],
-    ["KillBash", "TaskStop"],
-    ["ListMcpResources", "ListMcpResourcesTool"],
-    ["ReadMcpResource", "ReadMcpResourceTool"],
-    ["ReadMcpResourceDir", "ReadMcpResourceDirTool"],
-    ["MultiEdit", null],
-    ["Fork", null],
-    ["Sleep", null],
-    ["Remember", null],
-    ["remember", null],
-    ["Recall", null],
-    ["recall", null],
-]);
 export const CORE_SKILL_TOOL_NAME = "Skill";

package/dist/hitl/approvalDecisionNoteAudit.js

@@ -1,4 +1,4 @@
-import { displayUntrusted } from '../displayUntrusted.js';
+import { displayUntrusted, markerSafeCut } from '../displayUntrusted.js';
 const NOTE_DISPLAY_MAX = 200;
 export const DECISION_NOTE_NOTICE_KEY = 'approval-decision-note';
 function cleanNote(raw) {
@@ -7,7 +7,7 @@ function cleanNote(raw) {
         .trim();
     if (flat === '')
         return undefined;
-    return flat.length <= NOTE_DISPLAY_MAX ? flat : `${flat.slice(0, NOTE_DISPLAY_MAX - 1)}…`;
+    return flat.length <= NOTE_DISPLAY_MAX ? flat : `${flat.slice(0, markerSafeCut(flat, NOTE_DISPLAY_MAX - 1))}…`;
 }
 export function readDecisionNoteAudit(ack) {
     if (ack === null || typeof ack !== 'object')

package/dist/hitl/approvalEndingCause.js

@@ -1,5 +1,6 @@
 import { ASK_GONE_DENIED_WORD } from '../engineErrorCodes.js';
 import { SDK_ASK_ROW_ENDING_CAUSES } from '../generated/sdkFactTables.js';
+import { guardedRead, readOwnDataValue } from '../ownKey.js';
 import { readThrownExtra } from '../wireFailureShape.js';
 export const ASK_ROW_ENDING_CAUSE_WORDS = SDK_ASK_ROW_ENDING_CAUSES;
 const _askRowCausePin = true;
@@ -27,13 +28,7 @@ export function askRowEndingCauseFor(state, word) {
     return undefined;
 }
 function ownDataSlot(o, key) {
-    try {
-        const slot = Object.getOwnPropertyDescriptor(o, key);
-        return slot !== undefined && Object.hasOwn(slot, 'value') ? slot.value : undefined;
-    }
-    catch {
-        return undefined;
-    }
+    return guardedRead(() => readOwnDataValue(o, key));
 }
 export function approvalCompleteCauseOf(frame) {
     try {

package/dist/hitl/approvalHolds.d.ts

@@ -1,4 +1,12 @@
 import type { ApprovalHolderIdentity, FsApprovalOutcome, ToolApprovalFrameOutcome } from './toolApprovalWire.js';
+export declare const APPROVAL_SETTLED_HOWS: readonly ["answered", "interrupted", "closed_by_engine"];
+export type ApprovalSettledHow = (typeof APPROVAL_SETTLED_HOWS)[number];
+export declare const SETTLED_APPROVALS_MAX_ENTRIES = 4096;
+export interface SettledApprovalEntry {
+    readonly how: ApprovalSettledHow;
+    readonly parked: boolean;
+    readonly outcome: ToolApprovalFrameOutcome;
+}
 export interface DurableDecisionHold {
     readonly lane: 'durable';
     readonly outcome: Promise<FsApprovalOutcome>;
@@ -17,7 +25,7 @@ export interface LiveCardHold {
     };
     readonly cardSignal: AbortSignal;
     readonly interrupt: () => void;
-    trailing?: Promise<void>;
+    trailing?: Promise<boolean>;
 }
 export type ApprovalHold = DurableDecisionHold | LiveCardHold;
 export interface LiveCardIdentity {
@@ -27,12 +35,14 @@ export interface LiveCardIdentity {
     readonly sessionId?: string;
 }
 export declare function liveCardHoldFor(who: ApprovalHolderIdentity): LiveCardHold | undefined;
+export declare function settledForDurableLane(entry: SettledApprovalEntry | undefined): boolean;
 export declare function liveCardAnsweredHow(o: ToolApprovalFrameOutcome): 'answered' | 'interrupted' | undefined;
 export declare function awaitLiveCardHolder(hold: LiveCardHold, signal: AbortSignal | undefined): Promise<ToolApprovalFrameOutcome | undefined>;
 export interface ApprovalDecisionHoldTable {
     readonly inFlight: Map<string, ApprovalHold>;
     readonly settled: Map<string, DurableSettledHold>;
     readonly openReads: Set<number>;
+    readonly outcomes: Map<string, SettledApprovalEntry>;
     clock: number;
 }
 export interface DurableSettledHold {
@@ -40,6 +50,11 @@ export interface DurableSettledHold {
     readonly hold: DurableDecisionHold;
 }
 export declare const approvalDecisionHolds: ApprovalDecisionHoldTable;
+export declare function settledApprovalOf(approvalId: string | undefined): SettledApprovalEntry | undefined;
+export declare function clearSettledApprovals(): void;
+export declare function anyApprovalSettled(): boolean;
+export declare function noteEngineClosedApproval(approvalId: string, parked: boolean): void;
+export declare function settledLiveCardOutcome(approvalId: string): ToolApprovalFrameOutcome | undefined;
 export declare function liveCardHoldOf(key: string): LiveCardHold | undefined;
 export declare function holdLiveCard(identity: LiveCardIdentity, callerSignal: AbortSignal | undefined, present: (hold: LiveCardHold) => Promise<ToolApprovalFrameOutcome>): Promise<ToolApprovalFrameOutcome>;
 export declare function joinLiveCard(hold: LiveCardHold, signal: AbortSignal | undefined): Promise<ToolApprovalFrameOutcome>;

package/dist/hitl/approvalHolds.js

@@ -1,6 +1,8 @@
 import { hostLog } from '../host.js';
 import { liveFrameCallKey } from './gateIdentity.js';
 import { approvalResolutionOf } from './approvalResolution.js';
+export const APPROVAL_SETTLED_HOWS = Object.freeze(['answered', 'interrupted', 'closed_by_engine']);
+export const SETTLED_APPROVALS_MAX_ENTRIES = 4096;
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
 export function liveCardHoldFor(who) {
     if (nonEmpty(who.approvalId))
@@ -19,13 +21,8 @@ export function liveCardHoldFor(who) {
     }
     return undefined;
 }
-function liveCardSettledQuestion(hold, o) {
-    const r = approvalResolutionOf(o);
-    if (answeredHowOf(r) !== undefined)
-        return true;
-    if (r.kind === 'unsettled')
-        return false;
-    return hold.superseded !== undefined && !hold.superseded.parked;
+export function settledForDurableLane(entry) {
+    return entry !== undefined && !entry.parked;
 }
 export function liveCardAnsweredHow(o) {
     return answeredHowOf(approvalResolutionOf(o));
@@ -47,9 +44,43 @@ export async function awaitLiveCardHolder(hold, signal) {
     finally {
         unsubscribe();
     }
-    return liveCardSettledQuestion(hold, o) ? { ...o, joinedInFlight: true } : undefined;
+    const stillHeld = approvalDecisionHolds.inFlight.get(liveFrameCallKey(hold.identity.approvalId)) === hold;
+    return stillHeld || settledForDurableLane(settledApprovalOf(hold.identity.approvalId)) ? { ...o, joinedInFlight: true } : undefined;
+}
+export const approvalDecisionHolds = { inFlight: new Map(), settled: new Map(), openReads: new Set(), outcomes: new Map(), clock: 0 };
+export function settledApprovalOf(approvalId) {
+    return typeof approvalId === 'string' && approvalId !== '' ? approvalDecisionHolds.outcomes.get(approvalId) : undefined;
+}
+export function clearSettledApprovals() {
+    approvalDecisionHolds.outcomes.clear();
+}
+export function anyApprovalSettled() {
+    return approvalDecisionHolds.outcomes.size > 0;
+}
+function noteSettled(approvalId, how, parked, outcome) {
+    if (typeof approvalId !== 'string' || approvalId === '')
+        return;
+    if (!APPROVAL_SETTLED_HOWS.includes(how))
+        return;
+    const t = approvalDecisionHolds.outcomes;
+    if (t.has(approvalId))
+        return;
+    t.set(approvalId, Object.freeze({ how, parked, outcome: Object.freeze({ ...outcome }) }));
+    while (t.size > SETTLED_APPROVALS_MAX_ENTRIES) {
+        const oldest = t.keys().next();
+        if (oldest.done === true)
+            break;
+        t.delete(oldest.value);
+    }
+}
+const ENGINE_CLOSED_OUTCOME = Object.freeze({ decision: 'unresolved', retracted: true });
+export function noteEngineClosedApproval(approvalId, parked) {
+    noteSettled(approvalId, 'closed_by_engine', parked, ENGINE_CLOSED_OUTCOME);
+}
+export function settledLiveCardOutcome(approvalId) {
+    const e = settledApprovalOf(approvalId);
+    return e === undefined ? undefined : { ...e.outcome, joinedInFlight: true };
 }
-export const approvalDecisionHolds = { inFlight: new Map(), settled: new Map(), openReads: new Set(), clock: 0 };
 export function liveCardHoldOf(key) {
     const h = approvalDecisionHolds.inFlight.get(key);
     return h !== undefined && h.lane === 'live' ? h : undefined;
@@ -76,7 +107,7 @@ export function holdLiveCard(identity, callerSignal, present) {
         if (h.inFlight.get(key) === hold)
             h.inFlight.delete(key);
     };
-    const settle = (give) => {
+    const settle = (give, onLanded) => {
         settled = true;
         unsubscribe();
         const trailing = hold.trailing;
@@ -86,7 +117,11 @@ export function holdLiveCard(identity, callerSignal, present) {
             return;
         }
         give();
-        trailing.then(release, release);
+        trailing.then((landed) => {
+            if (landed === true)
+                onLanded?.();
+            release();
+        }, release);
     };
     let run;
     try {
@@ -95,7 +130,12 @@ export function holdLiveCard(identity, callerSignal, present) {
     catch (e) {
         run = Promise.reject(e);
     }
-    run.then((o) => settle(() => resolveOutcome(o)), (e) => settle(() => rejectOutcome(e)));
+    run.then((o) => {
+        const how = liveCardAnsweredHow(o);
+        if (how === 'answered')
+            noteSettled(identity.approvalId, how, false, o);
+        settle(() => resolveOutcome(o), how === 'interrupted' ? () => noteSettled(identity.approvalId, how, false, o) : undefined);
+    }, (e) => settle(() => rejectOutcome(e)));
     return outcome;
 }
 export async function joinLiveCard(hold, signal) {