@sema-agent/client-core 0.89.0 → 0.91.0

package/dist/providerRejection.js

@@ -1,4 +1,5 @@
 import { readRunTerminal } from './runTerminal.js';
+import { classifyToolHistoryMismatch } from './toolHistoryMismatch.js';
 const PROVIDER_STATUS_TIERS = Object.freeze([
     Object.freeze([400, 400, 'invalid_request']),
     Object.freeze([401, 401, 'authentication_failed']),
@@ -24,8 +25,31 @@ const NOT_BY_EDITING_TAIL = new Map([
     ['server_error', ': the provider reported an internal error — try again later.'],
     [UNTIERED, ' for a reason that editing it will not fix — check the provider account or try again later.'],
 ]);
+function toolHistoryMismatchCarrier(carrier) {
+    return carrier !== undefined && carrier !== null && classifyToolHistoryMismatch(carrier) !== null;
+}
 const PROVIDER_REJECTED = 'provider_rejected';
-export function providerRejectionResend(detail) {
+const RESEND_TEXT_STATUS = /\(HTTP (\d{3})\)/;
+export function readProviderRejectionResendKey(v) {
+    try {
+        if (typeof v !== 'object' || v === null || Array.isArray(v))
+            return undefined;
+        const got = v;
+        const resend = got.resend;
+        const text = got.text;
+        if (typeof text !== 'string' || (resend !== 'edit_and_resend' && resend !== 'not_by_editing'))
+            return undefined;
+        const hit = RESEND_TEXT_STATUS.exec(text);
+        if (hit === null || hit[1] === undefined)
+            return undefined;
+        const again = providerRejectionResend({ kind: PROVIDER_REJECTED, status: Number(hit[1]) });
+        return again !== undefined && again.resend === resend && again.text === text ? { resend: again.resend, text: again.text } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function providerRejectionResend(detail, carrier) {
     let read;
     try {
         const r = readRunTerminal({ terminal: { kind: 'failed', detail } });
@@ -39,6 +63,8 @@ export function providerRejectionResend(detail) {
     const status = Object.hasOwn(read, 'status') ? read.status : undefined;
     if (status === undefined)
         return undefined;
+    if (toolHistoryMismatchCarrier(carrier))
+        return undefined;
     const tier = providerStatusTier(status);
     return tier === EDITABLE_TIER
         ? {

package/dist/readDenyTiers.d.ts

@@ -0,0 +1,10 @@
+export declare const READ_DENY_BUILTIN_TIERS: readonly ["credentials", "shell-history", "browser", "wallet", "agent-config"];
+export declare const READ_DENY_DEFAULT_TIERS: readonly ["credentials", "agent-config"];
+export type ReadDenyBuiltinTiersParse = {
+    readonly ok: true;
+    readonly value: string | null;
+} | {
+    readonly ok: false;
+    readonly why: string;
+};
+export declare function parseReadDenyBuiltinTiers(input: string): ReadDenyBuiltinTiersParse;

package/dist/readDenyTiers.js

@@ -0,0 +1,29 @@
+import { displayUntrusted } from './displayUntrusted.js';
+import { CORE_READ_DENY_BUILTIN_TIERS, CORE_READ_DENY_DEFAULT_TIERS } from './generated/engineFactTables.js';
+export const READ_DENY_BUILTIN_TIERS = CORE_READ_DENY_BUILTIN_TIERS;
+export const READ_DENY_DEFAULT_TIERS = CORE_READ_DENY_DEFAULT_TIERS;
+const NONE_WORD = 'none';
+const SHOWN_ITEM_MAX = 40;
+const SHOWN_ITEM_WINDOW = 2000;
+const refuse = (why) => ({ ok: false, why });
+const shown = (item) => displayUntrusted(item.length > SHOWN_ITEM_WINDOW ? item.slice(0, SHOWN_ITEM_WINDOW) : item, { max: SHOWN_ITEM_MAX });
+export function parseReadDenyBuiltinTiers(input) {
+    if (typeof input !== 'string')
+        return refuse(`expected a string: comma-separated tier names, or the single word "${NONE_WORD}"`);
+    const text = input.trim();
+    if (text === '')
+        return { ok: true, value: null };
+    const parts = text.split(',').map((p) => p.trim());
+    if (parts.some((p) => p === ''))
+        return refuse('an empty entry between commas');
+    if (parts.includes(NONE_WORD)) {
+        return parts.length === 1 ? { ok: true, value: NONE_WORD } : refuse(`"${NONE_WORD}" must be the only entry`);
+    }
+    const known = READ_DENY_BUILTIN_TIERS;
+    const unknown = parts.filter((p) => !known.includes(p));
+    if (unknown.length > 0) {
+        const more = unknown.length > 1 ? ` (and ${unknown.length - 1} more)` : '';
+        return refuse(`unknown tier "${shown(unknown[0])}"${more}; known tiers: ${known.join(', ')}`);
+    }
+    return { ok: true, value: parts.join(',') };
+}

package/dist/request/taskRequest.js

@@ -1,4 +1,6 @@
 import { refuseBadDisableSkills, refuseDisableSkillsConflict } from '../disableSkillsWire.js';
+import { ATTACHMENTS_SPEC_KEYS, AttachmentsSpecRefused } from '../attachmentsWireCaps.js';
+import { retiredAttachmentsKeyOf } from '../taskRequestWords.js';
 export const REQUEST_FIELD_MATRIX = [
     { field: 'objective', lanes: ['interactive', 'print', 'utility'], live: false, why: '本 turn 的真实输入,每条车道都必需', whyUtilityLane: '恒座:三条车道都必须带上本次提交的模型面输入' },
     { field: 'sessionId', lanes: ['interactive', 'print', 'utility'], live: false, why: '单命名空间(TP-A Step 2):壳 id 即引擎 session id;print 在非 live 下保留 mock 常量', whyUtilityLane: '恒座:side-channel 提交走**独立**会话 id(壳另铸一个,绝不复用用户会话那一个 —— 复用会把这次提交的转录混进用户会话)' },
@@ -451,6 +453,29 @@ const refuseBadMemoryOff = (v) => {
         '`"on"`,`{ enabled: false }` 对象形也不是 wire 拼法)且对坏拼写**响亮拒**(server 400 `request.field_invalid`)。' +
         '本层若静默删键,这一次运行会照常挂上记忆面而声明人不会知道 —— 与 memoryCapture 同一条纪律。错误文本只报形状,不回显值。');
 };
+const withoutRetiredAttachmentsKeys = (v) => {
+    if (typeof v !== 'object' || v === null)
+        return v;
+    let drop;
+    for (const key of Object.keys(v)) {
+        const why = retiredAttachmentsKeyOf(key, 'key')?.why;
+        if (why === undefined)
+            continue;
+        const d = Object.getOwnPropertyDescriptor(v, key);
+        if (d !== undefined && Object.prototype.hasOwnProperty.call(d, 'value') && d.value === undefined) {
+            ;
+            (drop ??= []).push(key);
+            continue;
+        }
+        throw new AttachmentsSpecRefused(`buildTaskRequest: refusing attachments key ${JSON.stringify(key)} — ${why}`, { token: key, why, allowed: ATTACHMENTS_SPEC_KEYS, key });
+    }
+    if (drop === undefined)
+        return v;
+    const copy = { ...v };
+    for (const key of drop)
+        delete copy[key];
+    return copy;
+};
 const refuseBadExcludeAllTools = (v) => {
     if (v === undefined || v === null || v === true || v === false)
         return;
@@ -784,6 +809,7 @@ export function assembleTaskRequest(input, lane) {
         ...(onSetting('hooks') ? { hooks: s.hooks } : {}),
         ...(s.outputStyle !== undefined ? { outputStyle: s.outputStyle } : {}),
     };
+    const attachmentsForWire = on('attachments') ? withoutRetiredAttachmentsKeys(i.attachments) : undefined;
     const out = {
         objective: i.objective,
         sessionId: i.sessionId,
@@ -802,7 +828,7 @@ export function assembleTaskRequest(input, lane) {
         ...(on('retainBackgroundProcesses') ? { retainBackgroundProcesses: i.retainBackgroundProcesses } : {}),
         ...(on('promptProfile') ? { promptProfile: i.promptProfile } : {}),
         ...(on('enableFork') ? { enableFork: i.enableFork } : {}),
-        ...(on('attachments') ? { attachments: i.attachments } : {}),
+        ...(on('attachments') ? { attachments: attachmentsForWire } : {}),
         ...(on('repo') ? { repo: i.repo } : {}),
         ...(on('council') ? { council: true } : {}),
         ...(on('debate') ? { debate: true } : {}),

package/dist/resumeRefusalCopy.d.ts

@@ -46,3 +46,14 @@ export interface ParkedResumeStartupDetail {
 }
 export declare function parkedResumeStartupFromError(err: unknown, decision?: ParkedResumeStartupDecision): ParkedResumeStartupDetail | null;
 export declare function parkedResumeStartupContent(detail: ParkedResumeStartupDetail): string;
+export interface CheckpointUnsupportedVersionDetail {
+    code: 'checkpoint.unsupported_version';
+    retriable: true;
+}
+export declare function checkpointUnsupportedVersionFromError(err: unknown): CheckpointUnsupportedVersionDetail | null;
+export type CheckpointUnsupportedParkKind = 'tool_approval' | 'plan_review' | 'resource_park' | 'wake' | 'workflow_host';
+export interface CheckpointUnsupportedVersionContext {
+    readonly parkKind?: CheckpointUnsupportedParkKind;
+    readonly runId?: string;
+}
+export declare function checkpointUnsupportedVersionContent(detail: CheckpointUnsupportedVersionDetail, ctx?: CheckpointUnsupportedVersionContext): string;

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_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, isStatusDerivedCoarseCode, RESUME_SESSION_NOT_FOUND, } from './engineErrorCodes.js';
+import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, isStatusDerivedCoarseCode, RESUME_SESSION_NOT_FOUND, REQUEST_FIELD_CONFLICT, CHECKPOINT_UNSUPPORTED_VERSION, refusalSaysStillPending, } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { resumeRetryLaterFromError } from './wireErrorTriage.js';
 export const RESUME_REFUSAL_CODES = Object.freeze([
@@ -88,8 +88,8 @@ export function resumePolicyBlockContent(detail) {
 export { resumeReopenFromError, resumeReopenContent } from './hitl/suspendedReopen.js';
 const RESUME_SESSION_NOT_FOUND_TAIL = `(${RESUME_SESSION_NOT_FOUND})`;
 const REQUIRE_EXISTING_BY_STATUS = new Map([
-    [404, Object.freeze({ form: 'session_not_found', coarse: 'not_found.resource' })],
-    [422, Object.freeze({ form: 'session_id_missing', coarse: 'request.unprocessable' })],
+    [404, Object.freeze({ form: 'session_not_found', code: RESUME_SESSION_NOT_FOUND, coarse: 'not_found.resource' })],
+    [422, Object.freeze({ form: 'session_id_missing', code: REQUEST_FIELD_CONFLICT, coarse: 'request.unprocessable' })],
 ]);
 export function requireExistingSessionRefusalFromError(err) {
     if (typeof err !== 'object' || err === null)
@@ -101,7 +101,7 @@ export function requireExistingSessionRefusalFromError(err) {
         if (byStatus === undefined)
             return null;
         const code = o['errorCode'];
-        if (code === RESUME_SESSION_NOT_FOUND)
+        if (code === byStatus.code)
             return Object.freeze({ code: RESUME_SESSION_NOT_FOUND, form: byStatus.form });
         if (code !== byStatus.coarse)
             return null;
@@ -196,3 +196,60 @@ const PARKED_RESUME_STARTUP_SENTENCES = Object.freeze({
 export function parkedResumeStartupContent(detail) {
     return detail.cause === 'resume_rejected' ? PARKED_RESUME_STARTUP_SENTENCES.resume_rejected : PARKED_RESUME_STARTUP_SENTENCES.undetermined;
 }
+export function checkpointUnsupportedVersionFromError(err) {
+    if (typeof err !== 'object' || err === null)
+        return null;
+    let code;
+    try {
+        code = err.errorCode;
+    }
+    catch {
+        return null;
+    }
+    if (code !== CHECKPOINT_UNSUPPORTED_VERSION || !refusalSaysStillPending(err))
+        return null;
+    return { code: CHECKPOINT_UNSUPPORTED_VERSION, retriable: true };
+}
+function checkpointUnsupportedHasRun(kind) {
+    switch (kind) {
+        case 'tool_approval':
+        case 'plan_review':
+        case 'resource_park':
+            return true;
+        case 'wake':
+        case 'workflow_host':
+            return false;
+        default:
+            return undefined;
+    }
+}
+const CHECKPOINT_UNSUPPORTED_WHAT = 'This server cannot continue this parked work in the form it was stored in';
+const CHECKPOINT_UNSUPPORTED_STILL_WAITING = 'Nothing was decided or resumed and the parked work is still waiting, but sending the same request again will not by itself continue it';
+const CHECKPOINT_UNSUPPORTED_DRAIN = " — whoever operates this deployment can find such parked work before an upgrade with the server's pre-upgrade drain check";
+export function checkpointUnsupportedVersionContent(detail, ctx) {
+    void detail;
+    let kind;
+    let runId;
+    try {
+        kind = ctx?.parkKind;
+        runId = ctx?.runId;
+    }
+    catch {
+        kind = undefined;
+        runId = undefined;
+    }
+    const hasRun = checkpointUnsupportedHasRun(kind);
+    let outlet;
+    if (hasRun === true) {
+        const named = typeof runId === 'string' && runId.length > 0 ? ` (${capForDisplay(runId, 80)})` : '';
+        outlet = `If it was parked before this server was upgraded, cancel its run${named} first, then submit the work again as a new task`;
+    }
+    else if (hasRun === false) {
+        outlet = 'If it was parked before this server was upgraded, there is no run to cancel: start a new task in that conversation';
+    }
+    else {
+        outlet =
+            'If it was parked before this server was upgraded, submit the work again as a new task: when it still has a run waiting on it (a tool approval, a plan review or a paused resource), cancel that run first; when it was waiting to be woken up, or was a workflow step continuing its host conversation, there is no run to cancel, so start a new task in that conversation';
+    }
+    return [CHECKPOINT_UNSUPPORTED_WHAT, CHECKPOINT_UNSUPPORTED_STILL_WAITING, outlet + CHECKPOINT_UNSUPPORTED_DRAIN].join(' · ');
+}

package/dist/rewindArchiveCapability.js

@@ -109,17 +109,17 @@ export function rewindConversationDoctorDetail(reading) {
 }
 export function rewindRestoreFilesEpochDetail(reading) {
     if (reading.kind !== 'present') {
-        return 'restore-files request spelling not observed — this process has no usable capabilities reading for this engine';
+        return 'restore-files request key not observed — this process has no usable capabilities reading for this engine, so a rewind with code restore still sends the key';
     }
     switch (reading.restoreFilesEpoch) {
         case 'on':
             return 'this engine announces the restore-files request key (tracked-set restore semantics)';
         case 'off':
-            return 'this engine does not announce the restore-files request key; the client sends it anyway because the older spelling is rejected outright by current engines';
+            return 'this engine does not announce the restore-files request key, so a rewind with code restore built from this reading leaves the key out and moves the conversation only';
         case 'not_reported':
-            return 'this engine does not report the restore-files epoch bit (older engine); the client sends the current spelling regardless';
+            return 'this engine does not report the restore-files epoch bit (older engine), so a rewind with code restore built from this reading leaves the key out and moves the conversation only';
         case 'malformed':
-            return 'the restore-files epoch bit is reported in an unreadable shape; the client sends the current spelling regardless';
+            return 'the restore-files epoch bit is reported in an unreadable shape, so a rewind with code restore built from this reading leaves the key out and moves the conversation only';
     }
 }
 export function forgetRewindArchiveReading(baseUrl) {

package/dist/rewindWireCaps.d.ts

@@ -1,3 +1,4 @@
+import type { RewindArchiveReading } from './rewindArchiveCapability.js';
 export interface SeamRewindSpec {
     resumeAt?: string;
     resumeAtMode?: 'at' | 'before';
@@ -5,5 +6,5 @@ export interface SeamRewindSpec {
     rewindFilesTo?: string;
 }
 export type RewindMode = 'both' | 'conversation' | 'code';
-export declare function rewindSpecForMode(mode: RewindMode, targetEntryId: string): SeamRewindSpec;
+export declare function rewindSpecForMode(mode: RewindMode, targetEntryId: string, reading?: RewindArchiveReading): SeamRewindSpec;
 export declare function projectRewind(pending: SeamRewindSpec | undefined): SeamRewindSpec;

package/dist/rewindWireCaps.js

@@ -1,7 +1,24 @@
-export function rewindSpecForMode(mode, targetEntryId) {
+function restoreFilesKeyMaySend(reading) {
+    if (reading === undefined)
+        return true;
+    try {
+        if (reading === null || typeof reading !== 'object')
+            return false;
+        const kind = reading.kind;
+        if (kind === 'unobserved')
+            return true;
+        return kind === 'present' && reading.restoreFilesEpoch === 'on';
+    }
+    catch {
+        return false;
+    }
+}
+export function rewindSpecForMode(mode, targetEntryId, reading) {
     switch (mode) {
         case 'both':
-            return { resumeAt: targetEntryId, resumeAtMode: 'before', restoreFiles: true };
+            return restoreFilesKeyMaySend(reading)
+                ? { resumeAt: targetEntryId, resumeAtMode: 'before', restoreFiles: true }
+                : { resumeAt: targetEntryId, resumeAtMode: 'before' };
         case 'conversation':
             return { resumeAt: targetEntryId, resumeAtMode: 'before' };
         case 'code':

package/dist/sdkRegistryTransit.d.ts

@@ -2,5 +2,6 @@ export { RegistryClient } from '@sema-agent/sdk/registry';
 export { getMeConfig, getScopeConfigDraft, getEffective } from '@sema-agent/sdk/registry';
 export { probeRegistryHealth, postFeedback } from '@sema-agent/sdk/registry';
 export { REGISTRY_AUTH_PATHS, skillContentAddress } from '@sema-agent/sdk/registry';
+export { requestDeviceCode, pollUntilApproved, refreshTokens, listScopes, switchScope } from '@sema-agent/sdk/registry';
 export { RegistryApiError, OAuthFlowError } from '@sema-agent/sdk/registry';
 export type { RegistryTokens, TokenProvider, } from '@sema-agent/sdk/registry';

package/dist/sdkRegistryTransit.js

@@ -2,4 +2,5 @@ export { RegistryClient } from '@sema-agent/sdk/registry';
 export { getMeConfig, getScopeConfigDraft, getEffective } from '@sema-agent/sdk/registry';
 export { probeRegistryHealth, postFeedback } from '@sema-agent/sdk/registry';
 export { REGISTRY_AUTH_PATHS, skillContentAddress } from '@sema-agent/sdk/registry';
+export { requestDeviceCode, pollUntilApproved, refreshTokens, listScopes, switchScope } from '@sema-agent/sdk/registry';
 export { RegistryApiError, OAuthFlowError } from '@sema-agent/sdk/registry';

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 { WiringManifestFleetView } from './adapter/downstream/wiringManifestView.js';
 import type { SuspendedReopenReading } from './hitl/suspendedReopen.js';
 export interface AbortSignalLike {
     readonly aborted: boolean;
@@ -177,6 +178,7 @@ export interface WiringManifestChromeEvent {
     instructions?: {
         readonly selected: readonly string[];
     };
+    fleet?: WiringManifestFleetView;
     eventId?: string;
 }
 export interface TextSegmentCommittedRow {

package/dist/supportFloor.d.ts

@@ -0,0 +1,10 @@
+export type SupportFloorComponent = 'server' | 'core' | 'sdk';
+export interface SupportFloor {
+    readonly server: string;
+    readonly core: string;
+    readonly sdk: string;
+}
+export declare const SUPPORT_FLOOR: Readonly<SupportFloor>;
+export declare function supportFloorOf(component: unknown): string | undefined;
+export type EngineVersionTier = 'engine' | 'legacy' | 'unknown';
+export declare function engineVersionTier(version: unknown, floor?: string): EngineVersionTier;

package/dist/supportFloor.js

@@ -0,0 +1,42 @@
+export const SUPPORT_FLOOR = Object.freeze({
+    server: '7.104.0',
+    core: '7.33.8',
+    sdk: '12.0.1',
+});
+export function supportFloorOf(component) {
+    if (component === 'server' || component === 'core' || component === 'sdk')
+        return SUPPORT_FLOOR[component];
+    return undefined;
+}
+function releaseTriple(v) {
+    if (typeof v !== 'string')
+        return undefined;
+    const m = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(v);
+    if (m === null)
+        return undefined;
+    return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+function compareTriple(a, b) {
+    for (let i = 0; i < 3; i++) {
+        const x = a[i];
+        const y = b[i];
+        if (x !== y)
+            return x < y ? -1 : 1;
+    }
+    return 0;
+}
+export function engineVersionTier(version, floor) {
+    let need = releaseTriple(SUPPORT_FLOOR.server);
+    if (floor !== undefined) {
+        const own = releaseTriple(floor);
+        if (own === undefined) {
+            throw new TypeError(`engineVersionTier: floor 只接受纯 x.y.z 版本串(整串、无前导零、无前后缀)或缺席 —— 收到 typeof=${floor === null ? 'null' : typeof floor}。错误文本只报形状,不回显值。`);
+        }
+        if (compareTriple(own, need) > 0)
+            need = own;
+    }
+    const got = releaseTriple(version);
+    if (got === undefined)
+        return 'unknown';
+    return compareTriple(got, need) >= 0 ? 'engine' : 'legacy';
+}

package/dist/taskRequestWords.d.ts

@@ -3,3 +3,10 @@ export type TaskRequestReasoningEffort = NonNullable<TaskRequest['reasoningEffor
 export declare const REASONING_EFFORT_WORDS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 export type TaskRequestPermissionMode = NonNullable<TaskRequest['permissionMode']>;
 export declare const PERMISSION_MODE_WORDS: readonly ["default", "plan", "acceptEdits", "bypassPermissions", "auto"];
+export interface RetiredAttachmentsKey {
+    readonly key: string;
+    readonly why: string;
+    readonly because: string;
+    readonly remedy: string;
+}
+export declare function retiredAttachmentsKeyOf(nameOrToken: string, form?: 'token' | 'key'): RetiredAttachmentsKey | undefined;

package/dist/taskRequestWords.js

@@ -2,3 +2,27 @@ export const REASONING_EFFORT_WORDS = ['off', 'minimal', 'low', 'medium', 'high'
 export const PERMISSION_MODE_WORDS = ['default', 'plan', 'acceptEdits', 'bypassPermissions', 'auto'];
 const _taskRequestWordPins = [true, true, true, true];
 void _taskRequestWordPins;
+export function retiredAttachmentsKeyOf(nameOrToken, form = 'token') {
+    const lower = nameOrToken.trim().toLowerCase();
+    const eq = lower.indexOf('=');
+    const lhs = (eq < 0 ? lower : lower.slice(0, eq)).trim();
+    const bare = lhs.startsWith('+') || lhs.startsWith('-') ? lhs.slice(1).trim() : lhs;
+    const retiredRows = [
+        {
+            key: 'planModeReminder',
+            since: 'core 7.39.0 / server 7.113.0',
+            because: 'the engine now states the plan posture itself whenever the permission mode is "plan"',
+            remedy: 'send permissionMode "plan" for the plan posture',
+        },
+    ];
+    const row = retiredRows.find((r) => r.key.toLowerCase() === bare);
+    if (row === undefined)
+        return undefined;
+    const head = `"${row.key}" was retired with ${row.since} — ${row.because}`;
+    const why = form === 'token'
+        ? `${head}, and a request carrying the key is answered 400 request.field_invalid; remove the token (${row.remedy})`
+        : nameOrToken === row.key
+            ? `${head}, and a request carrying this key is answered 400 request.field_invalid; remove the key (${row.remedy})`
+            : `${head}; the server ignores this spelling of it, but it is refused here so the retired key is not sent under any spelling; remove the key (${row.remedy})`;
+    return { key: row.key, why, because: row.because, remedy: row.remedy };
+}

package/dist/toolHistoryBadTurn.d.ts

@@ -0,0 +1 @@
+export declare function toolHistoryBadTurnSentence(promptText: unknown): string;

package/dist/toolHistoryBadTurn.js

@@ -0,0 +1,89 @@
+import { displayUntrusted } from './displayUntrusted.js';
+const BAD_TURN_PREVIEW_MAX = 60;
+export function toolHistoryBadTurnSentence(promptText) {
+    const text = typeof promptText === 'string' ? promptText : '';
+    const flat = stripDisplayTagBlocks(text).replace(/\s+/g, ' ').trim();
+    const washed = displayUntrusted(flat, { foldLines: false, mark: 'dot' });
+    const points = Array.from(washed);
+    const preview = points.length > BAD_TURN_PREVIEW_MAX ? `${points.slice(0, BAD_TURN_PREVIEW_MAX).join('')}...` : washed;
+    return preview.length > 0
+        ? `The broken record is in the turn you started with "${preview}"; /rewind has that prompt preselected, so restore the conversation to before it.`
+        : 'The broken record is in the turn /rewind has preselected; restore the conversation to before it.';
+}
+function lowerBound(arr, p) {
+    let lo = 0;
+    let hi = arr.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >>> 1;
+        const v = arr[mid];
+        if (v !== undefined && v < p)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+function isTagNameChar(c) {
+    return (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95 || c === 45;
+}
+const TAG_WS = /\s/;
+function stripDisplayTagBlocks(text) {
+    const n = text.length;
+    const closesByName = new Map();
+    for (let i = text.indexOf('</'); i >= 0; i = text.indexOf('</', i + 1)) {
+        let k = i + 2;
+        while (k < n && isTagNameChar(text.charCodeAt(k)))
+            k++;
+        if (k > i + 2 && text.charCodeAt(k) === 62) {
+            const name = text.slice(i + 2, k);
+            const bucket = closesByName.get(name);
+            if (bucket !== undefined)
+                bucket.push(i);
+            else
+                closesByName.set(name, [i]);
+        }
+    }
+    if (closesByName.size === 0)
+        return keepIfEmpty(text, text);
+    const gts = [];
+    for (let i = text.indexOf('>'); i >= 0; i = text.indexOf('>', i + 1))
+        gts.push(i);
+    let out = '';
+    let pos = 0;
+    for (let i = text.indexOf('<'); i >= 0;) {
+        const first = text.charCodeAt(i + 1);
+        if (!(first >= 97 && first <= 122)) {
+            i = text.indexOf('<', i + 1);
+            continue;
+        }
+        let k = i + 2;
+        while (k < n && isTagNameChar(text.charCodeAt(k)))
+            k++;
+        const name = text.slice(i + 1, k);
+        let openEnd = -1;
+        if (text.charCodeAt(k) === 62)
+            openEnd = k + 1;
+        else if (k < n && TAG_WS.test(text.charAt(k))) {
+            const g = gts[lowerBound(gts, k)];
+            if (g !== undefined)
+                openEnd = g + 1;
+        }
+        const bucket = openEnd >= 0 ? closesByName.get(name) : undefined;
+        const close = bucket === undefined ? undefined : bucket[lowerBound(bucket, openEnd)];
+        if (close === undefined) {
+            i = text.indexOf('<', i + 1);
+            continue;
+        }
+        let end = close + name.length + 3;
+        if (text.charCodeAt(end) === 10)
+            end++;
+        out += text.slice(pos, i);
+        pos = end;
+        i = text.indexOf('<', end);
+    }
+    return keepIfEmpty(pos === 0 ? text : out + text.slice(pos), text);
+}
+function keepIfEmpty(stripped, original) {
+    const t = stripped.trim();
+    return t.length > 0 ? t : original;
+}

package/dist/toolHistoryMismatch.d.ts

@@ -27,8 +27,9 @@ export interface ToolHistoryMismatchRowKey {
     kind: ToolHistoryMismatchKind;
     toolUseId?: string;
     consecutive?: number;
+    rewindOffered?: boolean;
 }
-export declare function toolHistoryMismatchRowKey(m: ToolHistoryMismatch, consecutive: number | undefined): 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 TOOL_HISTORY_LEDGER_CAP = 64;
 export declare function openToolHistoryGeneration(): number;

package/dist/toolHistoryMismatch.js

@@ -249,33 +249,46 @@ export function toolHistoryRewindOffered(declared) {
 }
 const isKind = (v) => typeof v === 'string' && TOOL_HISTORY_MISMATCH_KINDS.includes(v);
 const ROW_KEY_ID = /^[A-Za-z0-9_.:-]{1,128}$/;
-export function toolHistoryMismatchRowKey(m, consecutive) {
+export function toolHistoryMismatchRowKey(m, consecutive, rewindOffered) {
     return {
         kind: m.kind,
         ...(m.toolUseId !== undefined ? { toolUseId: m.toolUseId } : {}),
         ...(consecutive !== undefined && consecutive >= 2 ? { consecutive } : {}),
+        rewindOffered,
     };
 }
 export function readToolHistoryMismatchKey(v) {
-    if (typeof v !== 'object' || v === null || Array.isArray(v))
+    if (typeof v !== 'object' || v === null)
         return undefined;
     try {
-        const got = v;
-        const kind = got.kind;
+        if (Array.isArray(v))
+            return undefined;
+        const kind = ownDataMember(v, 'kind');
         if (!isKind(kind))
             return undefined;
-        const id = got.toolUseId;
-        const n = got.consecutive;
+        const id = ownDataMember(v, 'toolUseId');
+        const n = ownDataMember(v, 'consecutive');
+        const offered = ownDataMember(v, 'rewindOffered');
         return {
             kind,
             ...(typeof id === 'string' && ROW_KEY_ID.test(id) ? { toolUseId: id } : {}),
             ...(typeof n === 'number' && Number.isSafeInteger(n) && n >= 2 ? { consecutive: n } : {}),
+            ...(typeof offered === 'boolean' ? { rewindOffered: offered } : {}),
         };
     }
     catch {
         return undefined;
     }
 }
+function ownDataMember(o, k) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(o, k);
+        return d !== undefined && Object.prototype.hasOwnProperty.call(d, 'value') ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export const TOOL_HISTORY_LEDGER_CAP = 64;
 const PRIOR_RUN_IDS_CAP = 16;
 const ECHOED_SESSION_IDS_CAP = TOOL_HISTORY_LEDGER_CAP * 4;