@sema-agent/client-core 0.90.0 → 0.91.0

package/dist/promptDelivery.js

@@ -1,8 +1,43 @@
 import { activeRunBusySignal } from './adapter/runStream.js';
 import { selfHealSubmissionDisposition } from './adapter/activeRunSelfHeal.js';
 const uuidOk = (u) => typeof u === 'string' && u.length > 0;
+function isArraySafe(v) {
+    try {
+        return Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+const generationOk = (g) => typeof g === 'number' && Number.isSafeInteger(g) && g >= 0;
+function generationOpt(opts) {
+    if (typeof opts !== 'object' || opts === null)
+        return undefined;
+    try {
+        const g = opts.generation;
+        return generationOk(g) ? g : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const levelOf = (rec) => !Object.hasOwn(rec, 'by') ? 1 : Object.hasOwn(rec, 'share') && rec.share === 'partial' ? 2 : 3;
+function deliveredByWord(v) {
+    const words = { frame: true, steer_receipt: true };
+    return typeof v === 'string' && Object.hasOwn(words, v) ? v : undefined;
+}
+function deliveredShareWord(v) {
+    const words = { full: true, partial: true };
+    return typeof v === 'string' && Object.hasOwn(words, v) ? v : undefined;
+}
+function ownExtension(rec, key) {
+    const desc = Object.getOwnPropertyDescriptor(rec, key);
+    if (desc === undefined)
+        return key in rec ? { kind: 'unreadable' } : { kind: 'absent' };
+    return 'value' in desc ? { kind: 'value', value: desc.value } : { kind: 'unreadable' };
+}
 function cleanBatch(batch) {
-    if (!Array.isArray(batch))
+    if (!isArraySafe(batch))
         return [];
     const out = [];
     const seen = new Set();
@@ -19,17 +54,73 @@ function cleanBatch(batch) {
     }
     return out;
 }
-function readRecord(rec) {
-    if (typeof rec !== 'object' || rec === null || Array.isArray(rec))
+function readRecord(raw) {
+    if (typeof raw !== 'object' || raw === null)
         return undefined;
+    let u;
+    let s;
     try {
-        const u = rec.u;
-        const s = rec.s;
-        return uuidOk(u) && (s === 'a' || s === 'd') ? { u, s } : undefined;
+        if (Array.isArray(raw))
+            return undefined;
+        u = raw.u;
+        s = raw.s;
     }
     catch {
         return undefined;
     }
+    if (!uuidOk(u) || (s !== 'a' && s !== 'd'))
+        return undefined;
+    const legacy = { u, s };
+    try {
+        let rec = legacy;
+        if (s === 'd') {
+            const byExt = ownExtension(raw, 'by');
+            const shareExt = ownExtension(raw, 'share');
+            const by = byExt.kind === 'value' ? deliveredByWord(byExt.value) : undefined;
+            const share = shareExt.kind === 'value' ? deliveredShareWord(shareExt.value) : undefined;
+            if (by !== undefined && (shareExt.kind === 'absent' || share !== undefined))
+                rec = share === undefined ? { u, s, by } : { u, s, by, share };
+        }
+        const dropped = Object.keys(raw).filter((k) => !Object.hasOwn(rec, k)).length;
+        return { rec, dropped };
+    }
+    catch {
+        return { rec: legacy, dropped: 0 };
+    }
+}
+function readTierStrict(holder, key) {
+    try {
+        if (!Object.hasOwn(holder, key))
+            return [];
+        const raw = holder[key];
+        if (!Array.isArray(raw))
+            return null;
+        const out = [];
+        const seen = new Set();
+        for (const u of raw) {
+            if (!uuidOk(u) || seen.has(u))
+                continue;
+            seen.add(u);
+            out.push(u);
+        }
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
+function batchTiers(batch) {
+    const none = { full: [], partial: [] };
+    if (isArraySafe(batch))
+        return { full: cleanBatch(batch), partial: [] };
+    if (typeof batch !== 'object' || batch === null)
+        return none;
+    const full = readTierStrict(batch, 'full');
+    const partial = readTierStrict(batch, 'partial');
+    if (full === null || partial === null)
+        return none;
+    const inFull = new Set(full);
+    return { full, partial: partial.filter((u) => !inFull.has(u)) };
 }
 const PRE_RUN_FRAME_TYPES = new Set(['meta', 'approval_request', 'approval_revoke']);
 export function frameProvesDelivery(event) {
@@ -56,9 +147,11 @@ export function frameProvesDelivery(event) {
     }
 }
 function outcomeProvesDelivery(outcome) {
-    if (typeof outcome !== 'object' || outcome === null || Array.isArray(outcome))
+    if (typeof outcome !== 'object' || outcome === null)
         return false;
     try {
+        if (Array.isArray(outcome))
+            return false;
         return selfHealSubmissionDisposition(outcome) === 'handed-off';
     }
     catch {
@@ -67,48 +160,88 @@ function outcomeProvesDelivery(outcome) {
 }
 export function createPromptDeliveryLedger() {
     const attemptedSet = new Set();
-    const deliveredSet = new Set();
+    const deliveredLevel = new Map();
     const batchOfMap = new Map();
+    const generationOf = new Map();
     const log = [];
-    const add = (u, s, into) => {
-        const set = s === 'a' ? attemptedSet : deliveredSet;
-        if (set.has(u))
+    let droppedKeys = 0;
+    const keep = (rec, into) => {
+        const frozen = Object.freeze(rec);
+        log.push(frozen);
+        into.push(frozen);
+    };
+    const add = (rec, into) => {
+        if (rec.s === 'a') {
+            if (attemptedSet.has(rec.u))
+                return;
+            attemptedSet.add(rec.u);
+            keep(rec, into);
             return;
-        set.add(u);
-        const rec = Object.freeze({ u, s });
-        log.push(rec);
-        into.push(rec);
+        }
+        const level = levelOf(rec);
+        if ((deliveredLevel.get(rec.u) ?? 0) >= level)
+            return;
+        deliveredLevel.set(rec.u, level);
+        keep(rec, into);
     };
-    const markDelivered = (batchUuids) => {
+    const markDelivered = (batch, by) => {
         const added = [];
-        for (const u of cleanBatch(batchUuids))
-            add(u, 'd', added);
+        const { full, partial } = batchTiers(batch);
+        for (const u of full)
+            add({ u, s: 'd', by }, added);
+        for (const u of partial)
+            add({ u, s: 'd', by, share: 'partial' }, added);
         return Object.freeze(added);
     };
+    const levelNow = (uuid) => (uuidOk(uuid) ? (deliveredLevel.get(uuid) ?? 0) : 0);
+    const knownUndeliveredUuid = (uuid) => uuidOk(uuid) && attemptedSet.has(uuid) && !deliveredLevel.has(uuid);
     const ledger = Object.freeze({
-        attempted(batchUuids) {
+        attempted(batchUuids, opts) {
+            const generation = generationOpt(opts);
             const batch = Object.freeze(cleanBatch(batchUuids));
             const added = [];
             for (const u of batch) {
                 batchOfMap.set(u, batch);
-                add(u, 'a', added);
+                if (generation !== undefined) {
+                    generationOf.delete(u);
+                    generationOf.set(u, generation);
+                }
+                add({ u, s: 'a' }, added);
             }
             return Object.freeze(added);
         },
         deliveredByFrame(batchUuids, event) {
-            return frameProvesDelivery(event) ? markDelivered(batchUuids) : Object.freeze([]);
+            return frameProvesDelivery(event) ? markDelivered(batchUuids, 'frame') : Object.freeze([]);
         },
         deliveredBySteerReceipt(batchUuids, outcome) {
-            return outcomeProvesDelivery(outcome) ? markDelivered(batchUuids) : Object.freeze([]);
+            return outcomeProvesDelivery(outcome) ? markDelivered(batchUuids, 'steer_receipt') : Object.freeze([]);
         },
         isAttempted: (uuid) => uuidOk(uuid) && attemptedSet.has(uuid),
-        isDelivered: (uuid) => uuidOk(uuid) && deliveredSet.has(uuid),
-        knownUndelivered: (uuid) => uuidOk(uuid) && attemptedSet.has(uuid) && !deliveredSet.has(uuid),
+        isDelivered: (uuid) => levelNow(uuid) >= 2,
+        knownUndelivered: (uuid) => knownUndeliveredUuid(uuid),
+        deliveryShareOf: (uuid) => {
+            const level = levelNow(uuid);
+            return level === 3 ? 'full' : level === 2 ? 'partial' : undefined;
+        },
+        undeliveredInGeneration(generation) {
+            const out = [];
+            if (!generationOk(generation))
+                return Object.freeze(out);
+            for (const [u, g] of generationOf) {
+                if (g !== generation)
+                    continue;
+                generationOf.delete(u);
+                if (knownUndeliveredUuid(u))
+                    out.push(u);
+            }
+            return Object.freeze(out);
+        },
+        droppedKeyCount: () => droppedKeys,
         batchOf: (uuid) => (uuidOk(uuid) ? batchOfMap.get(uuid) : undefined),
         toRecords: () => Object.freeze([...log]),
         fromRecords(records) {
             const added = [];
-            if (!Array.isArray(records))
+            if (!isArraySafe(records))
                 return Object.freeze(added);
             let list;
             try {
@@ -118,9 +251,11 @@ export function createPromptDeliveryLedger() {
                 return Object.freeze(added);
             }
             for (const raw of list) {
-                const rec = readRecord(raw);
-                if (rec !== undefined)
-                    add(rec.u, rec.s, added);
+                const read = readRecord(raw);
+                if (read === undefined)
+                    continue;
+                droppedKeys += read.dropped;
+                add(read.rec, added);
             }
             return Object.freeze(added);
         },
@@ -152,7 +287,7 @@ export function promptKnownUndelivered(ledger, message) {
 }
 export function withoutUndeliveredPrompts(ledger, messages) {
     assertLedger(ledger, 'withoutUndeliveredPrompts');
-    if (!Array.isArray(messages))
+    if (!isArraySafe(messages))
         return [];
     return messages.filter((m) => !promptKnownUndelivered(ledger, m));
 }

package/dist/providerRejection.d.ts

@@ -4,4 +4,5 @@ export interface ProviderRejectionResend {
     resend: 'edit_and_resend' | 'not_by_editing';
     text: string;
 }
+export declare function readProviderRejectionResendKey(v: object | null | undefined): ProviderRejectionResend | undefined;
 export declare function providerRejectionResend(detail: RunTerminalFailureDetail | null | undefined, carrier?: ToolHistoryErrorCarrier | null): ProviderRejectionResend | undefined;

package/dist/providerRejection.js

@@ -29,6 +29,26 @@ function toolHistoryMismatchCarrier(carrier) {
     return carrier !== undefined && carrier !== null && classifyToolHistoryMismatch(carrier) !== null;
 }
 const PROVIDER_REJECTED = 'provider_rejected';
+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 {

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,6 +1,6 @@
 import { refuseBadDisableSkills, refuseDisableSkillsConflict } from '../disableSkillsWire.js';
 import { ATTACHMENTS_SPEC_KEYS, AttachmentsSpecRefused } from '../attachmentsWireCaps.js';
-import { retiredAttachmentsKeyWhy } from '../taskRequestWords.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(壳另铸一个,绝不复用用户会话那一个 —— 复用会把这次提交的转录混进用户会话)' },
@@ -458,7 +458,7 @@ const withoutRetiredAttachmentsKeys = (v) => {
         return v;
     let drop;
     for (const key of Object.keys(v)) {
-        const why = retiredAttachmentsKeyWhy(key, 'key');
+        const why = retiredAttachmentsKeyOf(key, 'key')?.why;
         if (why === undefined)
             continue;
         const d = Object.getOwnPropertyDescriptor(v, key);

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/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/taskRequestWords.d.ts

@@ -3,4 +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 declare function retiredAttachmentsKeyWhy(nameOrToken: string, form?: 'token' | 'key'): string | undefined;
+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,17 +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 retiredAttachmentsKeyWhy(nameOrToken, form = 'token') {
+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;
-    if (bare !== 'planmodereminder')
+    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 = '"planModeReminder" was retired with core 7.39.0 / server 7.113.0 — the engine now states the plan posture itself whenever the permission mode is "plan"';
-    if (form === 'token')
-        return `${head}, and a request carrying the key is answered 400 request.field_invalid; remove the token (send permissionMode "plan" for the plan posture)`;
-    return nameOrToken === 'planModeReminder'
-        ? `${head}, and a request carrying this key is answered 400 request.field_invalid; remove the key (send permissionMode "plan" for the plan posture)`
-        : `${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 (send permissionMode "plan" for the plan posture)`;
+    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;