@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/subagent/engineDelegatedPrompt.d.ts

@@ -1,4 +1,5 @@
 import type { AgentClient } from '@sema-agent/sdk';
+import type { UiLanguage } from '../env/uiLanguage.js';
 import type { EngineWireInjection } from '../engineWireSdk.js';
 export type DelegatedPromptWireClient = {
     sessions: Pick<AgentClient['sessions'], 'get'>;
@@ -11,9 +12,17 @@ export declare function delegatedPromptText(content: unknown): string | undefine
 export declare function pickDelegatedPrompt(messages: readonly unknown[]): string | undefined;
 type TranscriptWindowReader = (transcriptId: string) => Promise<readonly unknown[] | null>;
 export declare function __setTranscriptWindowReaderForTests(r: TranscriptWindowReader | null): void;
+export declare const DELEGATED_PROMPT_ABSENCE_CAUSES: readonly ["not_owned_after_restart", "not_in_store", "forbidden", "prompt_absent", "unknown"];
+export type DelegatedPromptAbsenceCause = (typeof DELEGATED_PROMPT_ABSENCE_CAUSES)[number];
+export interface DelegatedPromptAbsence {
+    readonly cause: DelegatedPromptAbsenceCause;
+    readonly text: string;
+}
+export declare function delegatedPromptAbsenceSentence(cause: DelegatedPromptAbsenceCause | string, lang?: UiLanguage): string;
 export interface DelegatedPromptFetch {
     prompt?: string;
     outcome: 'hit' | 'skipped' | 'unreadable' | 'absent';
+    absence?: DelegatedPromptAbsence;
 }
 export declare function fetchDelegatedPrompt(taskId: string, opts?: {
     wire?: DelegatedPromptWire;

package/dist/subagent/engineDelegatedPrompt.js

@@ -1,6 +1,8 @@
 import { stripSystemReminderBlocks } from '../systemReminderTag.js';
 import { hostLog } from '../host.js';
 import { isSessionIdPathSegment } from '../sessionIdSegment.js';
+import { msg, renderMessage } from '../i18n/translate.js';
+import { readThrownSlot } from '../wireFailureShape.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected } from '../engineWireFor.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { panelAnchorOf } from '../panelReduce.js';
@@ -22,7 +24,7 @@ export function __resetEngineDelegatedPromptForTests() {
     clearEnginePanelAnchors();
     promptHydrateInFlight.clear();
 }
-const promptHydrateInFlight = new Set();
+const promptHydrateInFlight = new Map();
 function roleOf(entry) {
     if (typeof entry !== 'object' || entry === null)
         return undefined;
@@ -113,13 +115,38 @@ async function readTranscriptWindow(transcriptId, sessionKey, injectedWire) {
     const msgs = rec.messages;
     return Array.isArray(msgs) ? msgs : null;
 }
+export const DELEGATED_PROMPT_ABSENCE_CAUSES = Object.freeze(['not_owned_after_restart', 'not_in_store', 'forbidden', 'prompt_absent', 'unknown']);
+const ABSENCE_KEY = {
+    not_owned_after_restart: 'session.subagent.delegatedPrompt.absence.notOwnedAfterRestart',
+    not_in_store: 'session.subagent.delegatedPrompt.absence.notInStore',
+    forbidden: 'session.subagent.delegatedPrompt.absence.forbidden',
+    prompt_absent: 'session.subagent.delegatedPrompt.absence.promptAbsent',
+    unknown: 'session.subagent.delegatedPrompt.absence.unknown',
+};
+export function delegatedPromptAbsenceSentence(cause, lang) {
+    const known = typeof cause === 'string' && Object.hasOwn(ABSENCE_KEY, cause);
+    return renderMessage(msg(known ? ABSENCE_KEY[cause] : ABSENCE_KEY.unknown), lang);
+}
+function absenceOf(cause) {
+    return Object.freeze({ cause, text: delegatedPromptAbsenceSentence(cause) });
+}
+function absenceOfThrown(e) {
+    const status = readThrownSlot(e, 'status');
+    if (status === 404)
+        return absenceOf('not_in_store');
+    if (status === 401 || status === 403)
+        return absenceOf('forbidden');
+    return absenceOf('unknown');
+}
 export async function fetchDelegatedPrompt(taskId, opts) {
-    if (promptHydrateInFlight.has(taskId))
-        return { outcome: 'skipped' };
+    if (promptHydrateInFlight.has(taskId)) {
+        const settled = promptHydrateInFlight.get(taskId);
+        return settled ? { outcome: 'skipped', absence: settled } : { outcome: 'skipped' };
+    }
     const transcriptId = getEngineTranscriptId(taskId);
     if (!isSessionIdPathSegment(transcriptId))
-        return { outcome: 'skipped' };
-    promptHydrateInFlight.add(taskId);
+        return { outcome: 'skipped', absence: absenceOf(transcriptId === undefined ? 'not_owned_after_restart' : 'unknown') };
+    promptHydrateInFlight.set(taskId, null);
     let msgs = null;
     try {
         msgs = await readTranscriptWindow(transcriptId, resolveOwnerContext(taskId).key, opts?.wire);
@@ -127,14 +154,18 @@ export async function fetchDelegatedPrompt(taskId, opts) {
     catch (e) {
         promptHydrateInFlight.delete(taskId);
         hostLog('debug', `[delegated-prompt] ${taskId} transcript ${transcriptId} read failed: ${String(e).slice(0, 160)}`);
-        return { outcome: 'unreadable' };
+        return { outcome: 'unreadable', absence: absenceOfThrown(e) };
     }
     const prompt = msgs ? pickDelegatedPrompt(msgs) : undefined;
     if (!prompt) {
         if (msgs === null)
             promptHydrateInFlight.delete(taskId);
         hostLog('debug', `[delegated-prompt] ${taskId} transcript ${transcriptId}: ${msgs === null ? 'transcript unreadable (retryable)' : 'no delegated user message (final)'}`);
-        return { outcome: msgs === null ? 'unreadable' : 'absent' };
+        if (msgs === null)
+            return { outcome: 'unreadable', absence: absenceOf('unknown') };
+        const settled = absenceOf('prompt_absent');
+        promptHydrateInFlight.set(taskId, settled);
+        return { outcome: 'absent', absence: settled };
     }
     hostLog('debug', `[delegated-prompt] ${taskId} <- transcript ${transcriptId} (${prompt.length} chars) head=${JSON.stringify(prompt.slice(0, 60))}`);
     return { prompt, outcome: 'hit' };

package/dist/subagent/engineRowStopGate.js

@@ -1,5 +1,5 @@
 import { engineCapTrue } from '../engineCapsCache.js';
-import { engineWireTargetFor } from '../engineWireTarget.js';
+import { engineWireTargetBaseUrl } from '../engineWireTarget.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 export const engineOwnedRowIds = new Set();
 export const fleetViewStubRowIds = new Set();
@@ -7,7 +7,7 @@ export function isEngineViewRow(taskId) {
     return engineOwnedRowIds.has(taskId) || fleetViewStubRowIds.has(taskId);
 }
 export function engineTaskHandlesCapable(sessionKey = DEFAULT_SESSION_KEY, capsBaseUrl) {
-    return engineCapTrue(capsBaseUrl ?? engineWireTargetFor(sessionKey)?.baseUrl, 'taskHandles');
+    return engineCapTrue(capsBaseUrl ?? engineWireTargetBaseUrl(sessionKey), 'taskHandles');
 }
 export function engineRowNeedsStopConfirm(taskId, sessionKey, capsBaseUrl) {
     return isEngineViewRow(taskId) && engineTaskHandlesCapable(sessionKey ?? DEFAULT_SESSION_KEY, capsBaseUrl);

package/dist/subagent/engineSubagentResume.js

@@ -5,13 +5,13 @@ import { RESUME_SESSION_NOT_FOUND } from '../engineErrorCodes.js';
 import { displayUntrusted } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
-import { engineWireTargetFor } from '../engineWireTarget.js';
+import { engineWireTargetBaseUrl } from '../engineWireTarget.js';
 import { activeEngineRunId, engineSessionParamFor } from '../engineSessionParam.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { getBgParentRunOwner, parentToolCallIdOf, } from '../subagentContentStore.js';
 export const SUBAGENT_RESUME_CAP = 'subagentResume';
 export function subagentResumeAvailable(baseUrl, sessionKey = DEFAULT_SESSION_KEY) {
-    return engineCapTrue(baseUrl ?? engineWireTargetFor(sessionKey)?.baseUrl, SUBAGENT_RESUME_CAP);
+    return engineCapTrue(baseUrl ?? engineWireTargetBaseUrl(sessionKey), SUBAGENT_RESUME_CAP);
 }
 export function resolveSubagentContinueTarget(rowId, displayName) {
     const precise = parentToolCallIdOf(rowId);
@@ -149,7 +149,7 @@ export async function resumeSettledSubagent(facade, runId, target, content, opts
 }
 const warnedRetainWithoutWake = new Set();
 export function auditRetainWithoutWake(input) {
-    const baseUrl = input.baseUrl ?? engineWireTargetFor(input.sessionKey ?? DEFAULT_SESSION_KEY)?.baseUrl;
+    const baseUrl = input.baseUrl ?? engineWireTargetBaseUrl(input.sessionKey ?? DEFAULT_SESSION_KEY);
     if (!engineCapTrue(baseUrl, SUBAGENT_RESUME_CAP))
         return undefined;
     if (input.retainRequested === false)

package/dist/subagent/engineTaskHandleWire.d.ts

@@ -13,6 +13,7 @@ export interface EngineTaskOutputResult {
     status?: string;
     stoppedBy?: string;
     partialResult?: boolean;
+    exitCode?: number;
 }
 export declare function __resetTaskHandleWireForTests(): void;
 export declare function fetchEngineTaskOutput(handle: string, opts?: {

package/dist/subagent/engineTaskHandleWire.js

@@ -6,6 +6,7 @@ import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { engineTaskHandlesCapable } from './engineRowStopGate.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
+import { guardedRead, readOwnDataValue } from '../ownKey.js';
 function usableTaskOutputClient(client) {
     return clientHasVerbs(client, [['runs', 'taskOutput']]);
 }
@@ -27,6 +28,13 @@ function sessionOf(ctx) {
     const s = ctx.record?.sessionId ?? engineSessionParamFor(ctx.key);
     return s !== undefined ? { session: s } : {};
 }
+function exitCodeOfTaskOutput(output) {
+    const details = guardedRead(() => readOwnDataValue(output, 'details'));
+    if (typeof details !== 'object' || details === null)
+        return undefined;
+    const code = guardedRead(() => readOwnDataValue(details, 'exitCode'));
+    return typeof code === 'number' && Number.isInteger(code) ? code : undefined;
+}
 const accumulated = new Map();
 export function __resetTaskHandleWireForTests() {
     accumulated.clear();
@@ -67,11 +75,13 @@ export async function fetchEngineTaskOutput(handle, opts) {
         if (engineWireDebugEnabled()) {
             hostLog('debug', `[task-handle] output ${handle} via run ${runId}: ok fresh=${fresh.length}b merged=${merged.length}b status=${typeof out.status === 'string' ? out.status : '-'}`);
         }
+        const exitCode = exitCodeOfTaskOutput(out);
         return {
             content: merged,
             ...(typeof out.status === 'string' ? { status: out.status } : {}),
             ...(typeof out.stoppedBy === 'string' ? { stoppedBy: out.stoppedBy } : {}),
             ...(out.partial_result === true ? { partialResult: true } : {}),
+            ...(exitCode !== undefined ? { exitCode } : {}),
         };
     }
     catch (e) {

package/dist/submitFailure.d.ts

@@ -0,0 +1,8 @@
+import type { SDKAssistantMessageError } from '@sema-agent/agent-types';
+import type { SemaRowKind } from './rowKind.js';
+export interface SubmitFailureClass {
+    readonly kind: Extract<SemaRowKind, 'api_error' | 'model_output_error'>;
+    readonly errorCode?: string;
+    readonly ccError?: SDKAssistantMessageError;
+}
+export declare function classifySubmitFailure(err: {} | null | undefined): SubmitFailureClass;

package/dist/submitFailure.js

@@ -0,0 +1,17 @@
+import { isModelOutputErrorText } from './adapter/runStream.js';
+import { ccErrorOfProviderStatus } from './providerRejection.js';
+import { classifyTurnWireError } from './wireErrorTriage.js';
+export function classifySubmitFailure(err) {
+    const verdict = classifyTurnWireError(err);
+    const status = verdict.kind === 'http' ? verdict.status : undefined;
+    const errorCode = verdict.kind === 'http' && verdict.errorCode !== undefined && verdict.errorCode.length > 0 ? verdict.errorCode : undefined;
+    const text = verdict.kind === 'http' ? verdict.message : verdict.kind === 'transport' || verdict.kind === 'internal' ? verdict.detail : '';
+    const kind = isModelOutputErrorText(text) ? 'model_output_error' : 'api_error';
+    const mapped = status === undefined ? undefined : ccErrorOfProviderStatus(status);
+    const ccError = mapped === 'model_not_found' && errorCode !== undefined ? undefined : mapped;
+    return {
+        kind,
+        ...(errorCode !== undefined ? { errorCode } : {}),
+        ...(ccError !== undefined ? { ccError } : {}),
+    };
+}

package/dist/supportFloor.d.ts

@@ -10,3 +10,4 @@ export type EngineVersionTier = 'engine' | 'legacy' | 'unknown';
 export declare function engineVersionTier(version: unknown, floor?: string): EngineVersionTier;
 export declare function engineSupportFloorEffective(floor?: string): string;
 export declare function coreVersionTier(version: unknown, floor?: string): EngineVersionTier;
+export declare function compareReleaseVersions(a: string, b: string): -1 | 0 | 1 | undefined;

package/dist/supportFloor.js

@@ -51,3 +51,10 @@ export function engineSupportFloorEffective(floor) {
 export function coreVersionTier(version, floor) {
     return judgeAgainst(version, SUPPORT_FLOOR.core, floor, 'coreVersionTier').tier;
 }
+export function compareReleaseVersions(a, b) {
+    const ta = releaseTriple(a);
+    const tb = releaseTriple(b);
+    if (ta === undefined || tb === undefined)
+        return undefined;
+    return compareTriple(ta, tb);
+}

package/dist/terminationIntent.d.ts

@@ -0,0 +1,55 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare const TERMINATION_INTENT_TTL_MS = 60000;
+export declare const TERMINATION_INTENT_WEAK_SOURCE = "esc-abort";
+export declare const INTERRUPTED_SETTLE_BUDGET_MS = 10000;
+export declare const INTERRUPTED_SETTLE_POLL_MS = 1000;
+export type TerminationIntentSource = string;
+export interface TerminationIntentSnapshot {
+    readonly source: TerminationIntentSource;
+    readonly at: number;
+    readonly abortAt: number | null;
+}
+export interface TerminationIntentLedgerOptions {
+    readonly now: () => number;
+    readonly ttlMs?: number;
+    readonly exemptAbortReasons?: readonly string[];
+}
+export interface TerminationIntentLedger {
+    record(taskId: string | null | undefined, source: TerminationIntentSource): number;
+    snapshot(taskId: string | null | undefined): TerminationIntentSnapshot | null;
+    restoreIf(taskId: string | null | undefined, version: number, snapshot: TerminationIntentSnapshot | null): boolean;
+    rollbackIf(taskId: string | null | undefined, version: number, prior: TerminationIntentSource | null): boolean;
+    rollback(taskId: string | null | undefined, prior: TerminationIntentSource | null): void;
+    wasRecentlyTerminatedByUs(taskId: string | null | undefined): boolean;
+    sourceOf(taskId: string | null | undefined): TerminationIntentSource | null;
+    armOnAbort(signal: AbortSignal | undefined, taskId: string): void;
+    forget(taskId: string | null | undefined): void;
+    size(): number;
+}
+export declare function createTerminationIntentLedger(options: TerminationIntentLedgerOptions): TerminationIntentLedger;
+export type InterruptedRunSettleVerdict = {
+    readonly kind: 'settled';
+    readonly status: string;
+} | {
+    readonly kind: 'still-running';
+    readonly waitedMs: number;
+} | {
+    readonly kind: 'parked';
+    readonly status: string;
+} | {
+    readonly kind: 'unknown';
+};
+export interface InterruptedRunRow {
+    readonly status?: string | null;
+}
+export interface InterruptedRunSettleDeps {
+    readonly getRun?: (taskId: string, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<InterruptedRunRow | null>;
+    readonly signal?: AbortSignal;
+    readonly budgetMs?: number;
+    readonly intervalMs?: number;
+    readonly now?: () => number;
+}
+export declare function awaitInterruptedRunSettle(taskId: string, deps: InterruptedRunSettleDeps): Promise<InterruptedRunSettleVerdict>;
+export declare function interruptedRunSettleRow(taskId: string, verdict: InterruptedRunSettleVerdict, lang?: UiLanguage): string | null;

package/dist/terminationIntent.js

@@ -0,0 +1,352 @@
+import { usableClockMs } from './clockReading.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { linkedAbortSignal, readSignalAborted, readSignalReason, tryListenAbortOnce, tryUnlistenAbort } from './engineWireFor.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { abortableSleep } from './abortableSleep.js';
+import { isSdkRunParked, isSdkRunTerminal } from './terminalStatuses.js';
+export const TERMINATION_INTENT_TTL_MS = 60_000;
+export const TERMINATION_INTENT_WEAK_SOURCE = 'esc-abort';
+export const INTERRUPTED_SETTLE_BUDGET_MS = 10_000;
+export const INTERRUPTED_SETTLE_POLL_MS = 1_000;
+const MAX_ROWS = 256;
+const MAX_TRACKED_WRITES = 1024;
+const validId = (taskId) => typeof taskId === 'string' && taskId.length > 0;
+const validSource = (s) => typeof s === 'string' && s.length > 0;
+function readSnapshot(s) {
+    try {
+        if (typeof s !== 'object' || s === null)
+            return null;
+        const raw = s;
+        const source = raw.source;
+        const at = raw.at;
+        const abortAt = raw.abortAt;
+        if (!validSource(source) || usableClockMs(at) === null)
+            return null;
+        return { source, at: at, abortAt: typeof abortAt === 'number' && usableClockMs(abortAt) !== null ? abortAt : null };
+    }
+    catch {
+        return null;
+    }
+}
+export function createTerminationIntentLedger(options) {
+    if (typeof options !== 'object' || options === null || typeof options.now !== 'function') {
+        throw new TypeError('createTerminationIntentLedger: options.now must be a function returning milliseconds');
+    }
+    const readClock = options.now;
+    const ttl = typeof options.ttlMs === 'number' && Number.isFinite(options.ttlMs) && options.ttlMs > 0 ? options.ttlMs : TERMINATION_INTENT_TTL_MS;
+    const exempt = Object.freeze([...(options.exemptAbortReasons ?? ['background'])]);
+    const rows = new Map();
+    let nextVersion = 1;
+    const priors = new Map();
+    const refused = new Set();
+    const trackBounded = (m, k, v) => {
+        m.set(k, v);
+        while (m.size > MAX_TRACKED_WRITES) {
+            const oldest = m.keys().next();
+            if (oldest.done === true)
+                break;
+            m.delete(oldest.value);
+        }
+    };
+    const markRefused = (version) => {
+        if (typeof version !== 'number')
+            return;
+        refused.add(version);
+        while (refused.size > MAX_TRACKED_WRITES) {
+            const oldest = refused.values().next();
+            if (oldest.done === true)
+                break;
+            refused.delete(oldest.value);
+        }
+    };
+    const effectivePrior = (version) => {
+        if (!priors.has(version))
+            return { known: false, row: null };
+        let row = priors.get(version) ?? null;
+        for (let hops = 0; row !== null && refused.has(row.version) && priors.has(row.version) && hops < MAX_TRACKED_WRITES; hops += 1)
+            row = priors.get(row.version) ?? null;
+        return { known: true, row };
+    };
+    const clock = () => {
+        try {
+            return usableClockMs(readClock());
+        }
+        catch {
+            return null;
+        }
+    };
+    const isFresh = (now, at) => {
+        const age = now - at;
+        return age >= 0 && age < ttl;
+    };
+    const purge = (now) => {
+        for (const [taskId, row] of rows) {
+            if (isFresh(now, row.at))
+                continue;
+            if (row.abortAt !== null && isFresh(now, row.abortAt)) {
+                rows.set(taskId, { at: row.abortAt, source: TERMINATION_INTENT_WEAK_SOURCE, abortAt: row.abortAt, version: nextVersion++ });
+            }
+            else {
+                rows.delete(taskId);
+            }
+        }
+    };
+    const put = (taskId, row) => {
+        rows.delete(taskId);
+        while (rows.size >= MAX_ROWS) {
+            const oldest = rows.keys().next();
+            if (oldest.done === true)
+                break;
+            rows.delete(oldest.value);
+        }
+        rows.set(taskId, row);
+    };
+    const record = (taskId, source) => {
+        if (!validId(taskId) || !validSource(source))
+            return 0;
+        const now = clock();
+        if (now === null)
+            return 0;
+        purge(now);
+        const prev = rows.get(taskId);
+        const abortAt = prev?.abortAt ?? (source === TERMINATION_INTENT_WEAK_SOURCE ? now : null);
+        const version = nextVersion++;
+        trackBounded(priors, version, prev ?? null);
+        put(taskId, { at: now, source, abortAt, version });
+        return version;
+    };
+    const rollback = (taskId, prior) => {
+        if (!validId(taskId))
+            return;
+        const now = clock();
+        if (now === null)
+            return;
+        purge(now);
+        if (prior !== null && validSource(prior) && prior !== TERMINATION_INTENT_WEAK_SOURCE) {
+            record(taskId, prior);
+            return;
+        }
+        const row = rows.get(taskId);
+        const abortAt = row?.abortAt ?? null;
+        if (abortAt !== null && isFresh(now, abortAt)) {
+            put(taskId, { at: abortAt, source: TERMINATION_INTENT_WEAK_SOURCE, abortAt, version: nextVersion++ });
+            return;
+        }
+        rows.delete(taskId);
+    };
+    const restoreTo = (taskId, row, target, now) => {
+        if (target === null) {
+            rollback(taskId, null);
+            return;
+        }
+        const abortAt = target.abortAt === null ? row.abortAt : row.abortAt === null ? target.abortAt : Math.max(target.abortAt, row.abortAt);
+        put(taskId, { at: target.at, source: target.source, abortAt, version: target.version ?? nextVersion++ });
+        purge(now);
+    };
+    return {
+        record,
+        snapshot(taskId) {
+            if (!validId(taskId))
+                return null;
+            const now = clock();
+            if (now === null)
+                return null;
+            purge(now);
+            const row = rows.get(taskId);
+            return row === undefined ? null : Object.freeze({ source: row.source, at: row.at, abortAt: row.abortAt });
+        },
+        restoreIf(taskId, version, snapshot) {
+            if (!validId(taskId))
+                return false;
+            const now = clock();
+            if (now === null)
+                return false;
+            purge(now);
+            markRefused(version);
+            const row = rows.get(taskId);
+            if (row === undefined || row.version !== version)
+                return false;
+            const eff = effectivePrior(version);
+            restoreTo(taskId, row, eff.known ? eff.row : readSnapshot(snapshot), now);
+            return true;
+        },
+        rollbackIf(taskId, version, prior) {
+            if (!validId(taskId))
+                return false;
+            const now = clock();
+            if (now === null)
+                return false;
+            purge(now);
+            markRefused(version);
+            const row = rows.get(taskId);
+            if (row === undefined || row.version !== version)
+                return false;
+            const eff = effectivePrior(version);
+            if (eff.known)
+                restoreTo(taskId, row, eff.row, now);
+            else
+                rollback(taskId, prior);
+            return true;
+        },
+        rollback,
+        wasRecentlyTerminatedByUs(taskId) {
+            if (!validId(taskId))
+                return false;
+            const now = clock();
+            if (now === null)
+                return false;
+            purge(now);
+            return rows.has(taskId);
+        },
+        sourceOf(taskId) {
+            if (!validId(taskId))
+                return null;
+            const now = clock();
+            if (now === null)
+                return null;
+            purge(now);
+            return rows.get(taskId)?.source ?? null;
+        },
+        armOnAbort(signal, taskId) {
+            if (signal === undefined || signal === null || !validId(taskId))
+                return;
+            const onAbort = () => {
+                const read = readSignalReason(signal);
+                if (read === null)
+                    return;
+                if (typeof read.reason === 'string' && exempt.includes(read.reason))
+                    return;
+                const now = clock();
+                if (now === null)
+                    return;
+                purge(now);
+                const existing = rows.get(taskId);
+                if (existing !== undefined && existing.source !== TERMINATION_INTENT_WEAK_SOURCE) {
+                    put(taskId, { ...existing, abortAt: now });
+                    return;
+                }
+                put(taskId, { at: now, source: TERMINATION_INTENT_WEAK_SOURCE, abortAt: now, version: nextVersion++ });
+            };
+            const aborted = readSignalAborted(signal);
+            if (aborted === null)
+                return;
+            if (aborted) {
+                onAbort();
+                return;
+            }
+            tryListenAbortOnce(signal, onAbort);
+        },
+        forget(taskId) {
+            if (!validId(taskId))
+                return;
+            rows.delete(taskId);
+        },
+        size() {
+            const now = clock();
+            if (now !== null)
+                purge(now);
+            return rows.size;
+        },
+    };
+}
+function readStatus(row) {
+    try {
+        const s = row?.status;
+        return typeof s === 'string' && s.length > 0 ? s : null;
+    }
+    catch {
+        return null;
+    }
+}
+const PROBE_STOPPED = Symbol('sema.interruptedSettleProbeStopped');
+const PROBE_FAILED = Symbol('sema.interruptedSettleProbeFailed');
+const positive = (v, fallback) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : fallback);
+export async function awaitInterruptedRunSettle(taskId, deps) {
+    const getRun = deps?.getRun;
+    if (typeof getRun !== 'function')
+        return { kind: 'unknown' };
+    if (!validId(taskId))
+        return { kind: 'unknown' };
+    const budgetMs = positive(deps.budgetMs, INTERRUPTED_SETTLE_BUDGET_MS);
+    const intervalMs = positive(deps.intervalMs, INTERRUPTED_SETTLE_POLL_MS);
+    const clockNow = typeof deps.now === 'function' ? deps.now : () => performance.now();
+    const readNow = () => {
+        try {
+            const t = clockNow();
+            return Number.isFinite(t) ? t : 0;
+        }
+        catch {
+            return 0;
+        }
+    };
+    const started = readNow();
+    let sawRunning = false;
+    const isAborted = () => deps.signal?.aborted === true;
+    const budgetAc = new AbortController();
+    let budgetSpent = false;
+    let markStopped = () => { };
+    const stopped = new Promise((resolve) => {
+        markStopped = () => resolve(PROBE_STOPPED);
+    });
+    const onCallerAbort = () => markStopped();
+    const budgetTimer = setTimeout(() => {
+        budgetSpent = true;
+        budgetAc.abort();
+        markStopped();
+    }, budgetMs);
+    if (deps.signal !== undefined)
+        tryListenAbortOnce(deps.signal, onCallerAbort);
+    if (isAborted())
+        markStopped();
+    const linked = linkedAbortSignal(deps.signal, budgetAc.signal);
+    const probeSignal = linked.signal;
+    try {
+        for (;;) {
+            if (isAborted())
+                return { kind: 'unknown' };
+            if (budgetSpent)
+                break;
+            let probe;
+            try {
+                probe = Promise.resolve(getRun(taskId, { signal: probeSignal })).then((row) => row, () => PROBE_FAILED);
+            }
+            catch {
+                probe = Promise.resolve(PROBE_FAILED);
+            }
+            const outcome = await Promise.race([probe, stopped]);
+            if (isAborted())
+                return { kind: 'unknown' };
+            const status = outcome === PROBE_STOPPED || outcome === PROBE_FAILED ? null : readStatus(outcome);
+            if (status !== null) {
+                if (isSdkRunTerminal(status))
+                    return { kind: 'settled', status };
+                if (isSdkRunParked(status))
+                    return { kind: 'parked', status };
+                if (status === 'running')
+                    sawRunning = true;
+            }
+            if (budgetSpent)
+                break;
+            const left = started + budgetMs - readNow();
+            if (left <= 0)
+                break;
+            await abortableSleep(Math.min(intervalMs, left), probeSignal);
+            if (isAborted())
+                return { kind: 'unknown' };
+        }
+        if (isAborted())
+            return { kind: 'unknown' };
+        return sawRunning ? { kind: 'still-running', waitedMs: Math.max(0, readNow() - started) } : { kind: 'unknown' };
+    }
+    finally {
+        clearTimeout(budgetTimer);
+        linked.dispose();
+        if (deps.signal !== undefined)
+            tryUnlistenAbort(deps.signal, onCallerAbort);
+    }
+}
+export function interruptedRunSettleRow(taskId, verdict, lang) {
+    if (typeof verdict !== 'object' || verdict === null || verdict.kind !== 'settled')
+        return null;
+    return renderMessage(msg('session.selfHeal.row.interrupted.settled', { taskId: displayUntrusted(String(taskId), { max: 120 }) }), lang);
+}

package/dist/toolHistoryMismatch.d.ts

@@ -29,6 +29,8 @@ export interface ToolHistoryMismatchRowKey {
 }
 export declare function toolHistoryMismatchRowKey(m: ToolHistoryMismatch, consecutive: number | undefined, rewindOffered: boolean): ToolHistoryMismatchRowKey;
 export declare function readToolHistoryMismatchKey(v: object | null | undefined): ToolHistoryMismatchRowKey | undefined;
+export declare const SEMA_TOOL_HISTORY_ACCEPTED_KEY = "_sema_tool_history_accepted";
+export declare function readToolHistoryAcceptedKey(frame: object | null | undefined): true | undefined;
 export declare const TOOL_HISTORY_LEDGER_CAP = 64;
 export declare function openToolHistoryGeneration(): number;
 export interface ToolHistoryTerminalNote {
@@ -38,8 +40,14 @@ export interface ToolHistoryTerminalNote {
     runId: string | undefined;
     replay: boolean;
     mismatch: ToolHistoryMismatch | null;
+    accepted?: boolean;
+}
+export interface ToolHistoryTerminalFacts {
+    readonly consecutive: number | undefined;
+    readonly acceptedSinceMismatch: true | undefined;
 }
 export declare function noteToolHistoryTerminal(note: ToolHistoryTerminalNote): number | undefined;
+export declare function noteToolHistoryTerminalFacts(note: ToolHistoryTerminalNote): ToolHistoryTerminalFacts;
 export declare function _resetToolHistoryLedgerForTest(): void;
 export interface ToolHistoryRow {
     readonly toolUseIds?: readonly string[];