@sema-agent/client-core 0.86.0 → 0.87.0

package/dist/detachWire.js

@@ -1,6 +1,7 @@
 import { hostEnv } from './hostEnv.js';
 import { envFlagOff } from './envFlag.js';
 import { versionSupportsLimits } from './limitsWire.js';
+import { resolveWireAuth } from './engineWireSdk.js';
 export const DETACH_HEADER = 'x-detach-on-disconnect';
 export const HEADLESS_DETACH_ENV = 'SEMA_HEADLESS_DETACH';
 export const DETACH_WIRE_MIN_ENGINE = [1, 196, 0];
@@ -80,6 +81,17 @@ let cancelArm = null;
 export function armDetachCancel(arm) {
     cancelArm = arm;
 }
+function armAuthNow(baseUrl, source) {
+    let token;
+    try {
+        const v = source();
+        token = typeof v === 'string' ? v : undefined;
+    }
+    catch {
+        token = undefined;
+    }
+    return resolveWireAuth(baseUrl, token);
+}
 export function isDetachArmed() {
     return cancelArm !== null;
 }
@@ -87,7 +99,16 @@ export function detachedTaskId() {
     return cancelArm?.getTaskId() ?? null;
 }
 export function detachCancelArm() {
-    return cancelArm;
+    const arm = cancelArm;
+    if (arm === null)
+        return null;
+    const source = arm.authToken;
+    if (typeof source === 'function') {
+        const view = Object.defineProperties(Object.create(Object.getPrototypeOf(arm)), Object.getOwnPropertyDescriptors(arm));
+        Object.defineProperty(view, 'authToken', { value: armAuthNow(arm.baseUrl, source), enumerable: true, writable: true, configurable: true });
+        return view;
+    }
+    return arm;
 }
 export function _resetDetachWireForTest() {
     cancelArm = null;

package/dist/hitl/crashConverged.d.ts

@@ -14,6 +14,7 @@ export interface CrashConvergedRow {
     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

@@ -71,6 +71,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 +105,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/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,7 @@ export * from './principalWire.js';
 export * from './wireErrorTriage.js';
 export * from './corruptSession.js';
 export * from './corruptSessionCopy.js';
+export { classifyToolHistoryMismatch, resolveToolHistoryRewindTarget } from './toolHistoryMismatch.js';
 export * from './resumeRefusalCopy.js';
 export * from './wireRefusalCopy.js';
 export * from './inheritEnvWire.js';

package/dist/index.js

@@ -133,6 +133,7 @@ export * from './principalWire.js';
 export * from './wireErrorTriage.js';
 export * from './corruptSession.js';
 export * from './corruptSessionCopy.js';
+export { classifyToolHistoryMismatch, resolveToolHistoryRewindTarget } from './toolHistoryMismatch.js';
 export * from './resumeRefusalCopy.js';
 export * from './wireRefusalCopy.js';
 export * from './inheritEnvWire.js';

package/dist/resumeRefusalCopy.d.ts

@@ -19,13 +19,8 @@ export interface ResumePolicyBlockDetail {
 }
 export declare function resumePolicyBlockFromError(err: unknown): ResumePolicyBlockDetail | null;
 export declare function resumePolicyBlockContent(detail: ResumePolicyBlockDetail): string;
-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;
+export { resumeReopenFromError, resumeReopenContent } from './hitl/suspendedReopen.js';
+export type { ResumeReopenDetail } from './hitl/suspendedReopen.js';
 export interface ResumeContextUnavailableDetail {
     code: typeof RESUME_CONTEXT_UNAVAILABLE;
     staleAfterSec?: number;

package/dist/resumeRefusalCopy.js

@@ -1,5 +1,5 @@
 import { readErrorNumber, readErrorString } from './wireFailureShape.js';
-import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_REOPEN_CODES, RESUME_ENV_FAILED, RESUME_TOOL_UNAVAILABLE, RESUME_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, isStatusDerivedCoarseCode, } from './engineErrorCodes.js';
+import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, isStatusDerivedCoarseCode, } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { resumeRetryLaterFromError } from './wireErrorTriage.js';
 export const RESUME_REFUSAL_CODES = Object.freeze([
@@ -85,29 +85,7 @@ export function resumePolicyBlockContent(detail) {
         "This refusal does not say whether anything was consumed before it or whether a retry would pass — check the task's current state before deciding again, and ask whoever operates this deployment if it keeps happening",
     ].join(' · ');
 }
-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(' · ');
-}
+export { resumeReopenFromError, resumeReopenContent } from './hitl/suspendedReopen.js';
 export function resumeContextUnavailableFromError(err) {
     if (typeof err !== 'object' || err === null)
         return null;

package/dist/rewindArchiveCapability.js

@@ -1,5 +1,6 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { _wireConversationRewindJudge } from './toolHistoryMismatch.js';
 const CAPS_KEYS = {
     conversationAnchor: 'resumeAt',
     forkRestore: 'rewindFiles',
@@ -37,8 +38,12 @@ const reader = createEngineCapReader({
     makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForRewindArchive(baseUrl, caps, opts) {
+    _wireConversationRewindJudge(conversationRewindJudge);
     reader.note(baseUrl, caps, opts);
 }
+function conversationRewindJudge(engineBaseUrl) {
+    return rewindConversationAvailability(observedRewindArchive(engineBaseUrl));
+}
 export function observedRewindArchive(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }

package/dist/seam.d.ts

@@ -3,6 +3,7 @@ import type { EngineTurnUsage } from './adapter/downstream/turnUsageToModelUsage
 import type { RunCostReconcile } from './adapter/downstream/terminalToSdkResult.js';
 import type { WiringManifestAutoMode, WiringManifestModelGate, WiringManifestMcpEntryView, WiringManifestHookEntryView, WiringManifestLspSeamView, WiringManifestWriteProtectionView, WiringManifestAutoConsolidationView, WiringManifestReadDenyView, ContextUsageSectionView, PromptManifestSectionView, PromptManifestBlockView, PromptManifestToolView } from './adapter/downstream/eventToSdkMessage.js';
 import type { ToolRosterView, ToolRosterDeltaView, WiringManifestHandsView } from './toolRoster.js';
+import type { SuspendedReopenReading } from './hitl/suspendedReopen.js';
 export interface AbortSignalLike {
     readonly aborted: boolean;
 }
@@ -149,7 +150,16 @@ export type ChromeEvent = {
 } | ({
     kind: 'run_cost_reconciled';
     laneProof: LaneProof;
-} & RunCostReconcile) | HumanInputChromeEvent | MessageCommittedChromeEvent | EngineNoticeChromeEvent | TextSegmentEndChromeEvent | ThinkingSegmentEndChromeEvent | ToolDisclosureChromeEvent | ToolProgressChromeEvent | ToolRosterDeltaChromeEvent | ContextUsageChromeEvent | CompactionOutcomeChromeEvent | PromptAssembledChromeEvent | MemorySavedChromeEvent | WiringManifestChromeEvent | ResultTextDivergedChromeEvent | ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent;
+} & RunCostReconcile) | HumanInputChromeEvent | MessageCommittedChromeEvent | EngineNoticeChromeEvent | TextSegmentEndChromeEvent | ThinkingSegmentEndChromeEvent | ToolDisclosureChromeEvent | ToolProgressChromeEvent | ToolRosterDeltaChromeEvent | ContextUsageChromeEvent | CompactionOutcomeChromeEvent | PromptAssembledChromeEvent | MemorySavedChromeEvent | WiringManifestChromeEvent | ResultTextDivergedChromeEvent | ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent | {
+    kind: 'suspended_reopened';
+    laneProof: LaneProof;
+    reopen: Extract<SuspendedReopenReading, {
+        kind: 'reopened';
+    }>;
+    content?: string;
+    eventId?: string;
+    taskId?: string;
+};
 export interface WiringManifestChromeEvent {
     kind: 'wiring_manifest';
     laneProof: LaneProof;

package/dist/seam.js

@@ -126,6 +126,13 @@ const CHROME_ARM_TABLE = {
             '🔴 账本重放的历史帧只用于时间线渲染,卡集的全量对账基准是开流 preamble(它带的 expiresInMs 是铸帧时刻的旧值);' +
             'card 的 message/args 是模型/工具产文,只渲染永不回喂模型',
     },
+    suspended_reopened: {
+        required: false,
+        duty: '可选:引擎确认把一次已送出的决定重新挂回待决 ⇒ 上屏一句「决定没被消费、再决一次」(`content`,单源句;缺席 = 码不在 reopen 族闭集,可照 `reopen.code` 原词显示,开集按成员渲染必带 default 臂)。' +
+            '🔴 按 `eventId` 幂等(同一条流的重放本包已去重;前台腿与接管腿各发一条、同 eventId,去重归宿主);' +
+            '🔴 接管 / 从头重放的腿:本臂之后同流又来「门已不在」的帧(text / tool_start / turn_end / done / failed 或新的挂起)⇒ 那次重开是历史,别当现状上屏;会话已切走的别补发 —— 这两件归宿主判;' +
+            '明说没重开 / 老引擎缺键一条都不发,本臂没来 ≠ 确认没重开;`taskId` 只在帧上自带时在场',
+    },
     approval_revoke: {
         required: true,
         duty: '用 sdk isApprovalRevokeFrameV1 窄化 frame 取 batchId/askIds/taskId;窄不下来按通用撤卡处理(该批本地卡照清);' +

package/dist/toolHistoryMismatch.d.ts

@@ -0,0 +1,63 @@
+export declare const TOOL_HISTORY_MISMATCH_KINDS: readonly ["tool_use_without_result", "orphan_tool_result", "duplicate_tool_use_id"];
+export type ToolHistoryMismatchKind = (typeof TOOL_HISTORY_MISMATCH_KINDS)[number];
+export interface ToolHistoryMismatch {
+    kind: ToolHistoryMismatchKind;
+    toolUseId?: string;
+}
+export interface ToolHistoryErrorCarrier {
+    readonly code?: string | null | undefined;
+    readonly status?: number | null | undefined;
+    readonly message?: string | null | undefined;
+}
+export interface ToolHistoryMismatchAnchor {
+    readonly kind: ToolHistoryMismatchKind;
+    readonly template: RegExp;
+    readonly idAfter: RegExp | null;
+}
+export declare const TOOL_HISTORY_MISMATCH_ANCHORS: readonly ToolHistoryMismatchAnchor[];
+export declare function classifyToolHistoryMismatch(err: ToolHistoryErrorCarrier | null | undefined): ToolHistoryMismatch | null;
+export declare const TOOL_HISTORY_REWIND_SENTENCE = "Run /rewind to recover the conversation.";
+export declare function toolHistoryRepeatSentence(n: number): string;
+type ConversationRewindVerdict = 'available' | 'unavailable' | 'unknown';
+export declare function _wireConversationRewindJudge(judge: (engineBaseUrl: string) => ConversationRewindVerdict): void;
+export declare function toolHistoryRewindOffered(declared: boolean | {
+    readonly engineBaseUrl: string;
+} | undefined): boolean;
+export interface ToolHistoryMismatchRowKey {
+    kind: ToolHistoryMismatchKind;
+    toolUseId?: string;
+    consecutive?: number;
+}
+export declare function toolHistoryMismatchRowKey(m: ToolHistoryMismatch, consecutive: number | undefined): ToolHistoryMismatchRowKey;
+export declare function readToolHistoryMismatchKey(v: object | null | undefined): ToolHistoryMismatchRowKey | undefined;
+export declare const TOOL_HISTORY_LEDGER_CAP = 64;
+export declare function openToolHistoryGeneration(): number;
+export interface ToolHistoryTerminalNote {
+    sessionId: string | undefined;
+    sessionEchoed: boolean;
+    generation: number;
+    runId: string | undefined;
+    replay: boolean;
+    mismatch: ToolHistoryMismatch | null;
+}
+export declare function noteToolHistoryTerminal(note: ToolHistoryTerminalNote): number | undefined;
+export declare function _resetToolHistoryLedgerForTest(): void;
+export interface ToolHistoryRow {
+    readonly toolUseIds?: readonly string[];
+    readonly toolResultIds?: readonly string[];
+    readonly prompt?: boolean;
+    readonly engineHandle?: string;
+    readonly local?: boolean;
+    readonly sessionRoot?: boolean;
+}
+export declare const TOOL_HISTORY_UNDECIDABLE_REASONS: readonly ["no-mismatch", "no-tool-use-id", "id-not-found", "prompt-not-found", "prompt-without-handle", "unreadable-rows"];
+export type ToolHistoryUndecidableReason = (typeof TOOL_HISTORY_UNDECIDABLE_REASONS)[number];
+export type ToolHistoryRewindResolution<R> = {
+    target: R;
+} | {
+    rootReopen: true;
+} | {
+    undecidable: ToolHistoryUndecidableReason;
+};
+export declare function resolveToolHistoryRewindTarget<R extends ToolHistoryRow>(rows: readonly (R | null | undefined)[] | null | undefined, mismatch: ToolHistoryMismatch | null | undefined): ToolHistoryRewindResolution<R>;
+export {};