@sema-agent/client-core 0.95.0 → 0.97.0

package/dist/sessionPolicyCapability.js

@@ -1,5 +1,5 @@
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectSessionPolicyCapability(caps) {
     try {
@@ -20,7 +20,6 @@ export function projectSessionPolicyCapability(caps) {
 const reader = createEngineCapReader({
     name: 'sessionPolicy',
     project: projectSessionPolicyCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForSessionPolicy(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -37,6 +36,8 @@ export function sessionPolicyFaceAvailable(reading) {
 }
 export function sessionPolicyDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('per-session rule face');
         case 'unobserved':
             return 'per-session rule face not observed — the engine reports it on /v1/capabilities (sessionPolicy); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':

package/dist/sessionReadRedactionCapability.d.ts

@@ -1,5 +1,7 @@
 export type SessionReadRedactionReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {
@@ -7,9 +9,5 @@ export type SessionReadRedactionReading = {
     value: true;
 };
 export declare function projectSessionReadRedactionCapability(caps: unknown): SessionReadRedactionReading | undefined;
-export declare function noteEngineCapsForSessionReadRedaction(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedSessionReadRedaction(baseUrl?: string | undefined): SessionReadRedactionReading;
 export declare function sessionReadRedactionAdmitted(reading: SessionReadRedactionReading | undefined): boolean;
-export declare function __resetSessionReadRedactionReadingsForTests(): void;

package/dist/sessionReadRedactionCapability.js

@@ -17,11 +17,7 @@ export function projectSessionReadRedactionCapability(caps) {
 const reader = createEngineCapReader({
     name: 'sessionReadRedaction',
     project: projectSessionReadRedactionCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
-export function noteEngineCapsForSessionReadRedaction(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedSessionReadRedaction(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -37,6 +33,3 @@ export function sessionReadRedactionAdmitted(reading) {
         return false;
     }
 }
-export function __resetSessionReadRedactionReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/sessionSyncFileHistory.d.ts

@@ -0,0 +1,4 @@
+export declare const FILE_HISTORY_SKIPPED_NOTICE: string;
+export declare function fileHistorySyncNotice(result: unknown): string | undefined;
+export declare function fileHistorySyncNoticeIdentity(result: unknown): string | undefined;
+export declare function isFileHistoryBlobMissing(err: unknown): boolean;

package/dist/sessionSyncFileHistory.js

@@ -0,0 +1,66 @@
+import { NOT_FOUND_BLOB } from './engineErrorCodes.js';
+import { effectiveWireErrorCode } from './wireErrorTriage.js';
+import { readThrownSlot } from './wireFailureShape.js';
+export const FILE_HISTORY_SKIPPED_NOTICE = 'File history was not copied: only the conversation was synced, because one of the two engines does not confirm that it can ' +
+    'transfer file history (the record /rewind uses to restore files). Syncing this session again will not add it until ' +
+    'the conversation has new turns and both engines can transfer file history.';
+function getOwn(o, key) {
+    return Object.hasOwn(o, key) ? o[key] : undefined;
+}
+function envelopeSaidEmpty(result) {
+    try {
+        const manifest = getOwn(result, 'manifest');
+        if (manifest === null || typeof manifest !== 'object')
+            return false;
+        const fh = getOwn(manifest, 'fileHistory');
+        if (fh === null || typeof fh !== 'object')
+            return false;
+        const tracked = getOwn(fh, 'tracked');
+        const boundaries = getOwn(fh, 'boundaries');
+        return Array.isArray(tracked) && tracked.length === 0 && Array.isArray(boundaries) && boundaries.length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function fileHistorySyncNotice(result) {
+    if (result === null || typeof result !== 'object')
+        return undefined;
+    try {
+        if (getOwn(result, 'fileHistory') !== 'skipped')
+            return undefined;
+        return envelopeSaidEmpty(result) ? undefined : FILE_HISTORY_SKIPPED_NOTICE;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function fileHistorySyncNoticeIdentity(result) {
+    if (fileHistorySyncNotice(result) === undefined)
+        return undefined;
+    try {
+        const manifest = getOwn(result, 'manifest');
+        if (manifest === null || typeof manifest !== 'object')
+            return undefined;
+        const sessionId = getOwn(manifest, 'sessionId');
+        const leafId = getOwn(manifest, 'leafId');
+        if (typeof sessionId !== 'string' || sessionId === '' || typeof leafId !== 'string' || leafId === '')
+            return undefined;
+        return JSON.stringify([sessionId, leafId]);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function isFileHistoryBlobMissing(err) {
+    if (typeof err !== 'object' || err === null)
+        return false;
+    try {
+        if (readThrownSlot(err, 'status') !== 404)
+            return false;
+        return effectiveWireErrorCode(err) === NOT_FOUND_BLOB;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/sessionSyncFileHistoryCapability.d.ts

@@ -1,5 +1,7 @@
 export type SessionSyncFileHistoryReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {
@@ -14,4 +16,3 @@ export declare function noteEngineCapsForSessionSyncFileHistory(baseUrl: string,
 export declare function observedSessionSyncFileHistory(baseUrl?: string | undefined): SessionSyncFileHistoryReading;
 export declare function sessionSyncFileHistoryAvailable(reading: SessionSyncFileHistoryReading): 'yes' | 'no' | 'unknown';
 export declare function sessionSyncFileHistoryDoctorDetail(reading: SessionSyncFileHistoryReading): string;
-export declare function __resetSessionSyncFileHistoryReadingsForTests(): void;

package/dist/sessionSyncFileHistoryCapability.js

@@ -1,5 +1,5 @@
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectSessionSyncFileHistoryCapability(caps) {
     try {
@@ -19,7 +19,6 @@ export function projectSessionSyncFileHistoryCapability(caps) {
 const reader = createEngineCapReader({
     name: 'sessionSyncFileHistory',
     project: projectSessionSyncFileHistoryCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForSessionSyncFileHistory(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -36,6 +35,8 @@ export function sessionSyncFileHistoryAvailable(reading) {
 }
 export function sessionSyncFileHistoryDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('session-sync file history');
         case 'unobserved':
             return 'session-sync file history not observed — the engine reports it on /v1/capabilities (sessionSyncFileHistory); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':
@@ -46,6 +47,3 @@ export function sessionSyncFileHistoryDoctorDetail(reading) {
             return 'session-sync file history on — syncing a session can also move its edited-file history';
     }
 }
-export function __resetSessionSyncFileHistoryReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/skillToolListsCapability.d.ts

@@ -1,5 +1,7 @@
 export type SkillToolListsReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {
@@ -14,4 +16,3 @@ export declare function noteEngineCapsForSkillToolLists(baseUrl: string, caps: u
 export declare function observedSkillToolLists(baseUrl?: string | undefined): SkillToolListsReading;
 export declare function skillToolListsAvailable(reading: SkillToolListsReading): 'yes' | 'no' | 'unknown';
 export declare function skillToolListsDoctorDetail(reading: SkillToolListsReading): string;
-export declare function __resetSkillToolListsReadingsForTests(): void;

package/dist/skillToolListsCapability.js

@@ -1,5 +1,5 @@
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectSkillToolListsCapability(caps) {
     try {
@@ -19,7 +19,6 @@ export function projectSkillToolListsCapability(caps) {
 const reader = createEngineCapReader({
     name: 'skillToolLists',
     project: projectSkillToolListsCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForSkillToolLists(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -36,6 +35,8 @@ export function skillToolListsAvailable(reading) {
 }
 export function skillToolListsDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('skill tool lists');
         case 'unobserved':
             return 'skill tool lists not observed — the engine reports it on /v1/capabilities (skillToolLists); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':
@@ -46,6 +47,3 @@ export function skillToolListsDoctorDetail(reading) {
             return 'skill tool lists on — a request skill’s allowed and disallowed tool lists are read as this run’s rules';
     }
 }
-export function __resetSkillToolListsReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/sqlEngineCapability.d.ts

@@ -5,6 +5,8 @@ export interface SqlEngineCapabilityView {
 }
 export type SqlEngineReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {

package/dist/sqlEngineCapability.js

@@ -1,6 +1,6 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { storeSeatOf, createEngineCapReader } from './engineCapReader.js';
+import { storeSeatOf, createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectSqlEngineCapability(caps) {
     try {
@@ -16,7 +16,7 @@ export function projectSqlEngineCapability(caps) {
                 return { kind: 'none' };
             return projectSqlEngineView(nested);
         }
-        return { kind: 'not_reported' };
+        return seat.kind === 'absent' ? { kind: 'not_reported' } : undefined;
     }
     catch {
         return undefined;
@@ -39,7 +39,6 @@ function projectSqlEngineView(sql) {
 const reader = createEngineCapReader({
     name: 'sql',
     project: projectSqlEngineCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForSqlEngine(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -53,6 +52,8 @@ function cleanSqlDetailScalar(v) {
 }
 export function sqlEngineDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail();
         case 'unobserved':
             return ('not observed — the engine reports it on /v1/capabilities; this process has no usable ' +
                 'capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)');

package/dist/steerPriorityCapability.d.ts

@@ -1,5 +1,7 @@
 export type SteerPriorityReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {
@@ -14,4 +16,3 @@ export declare function noteEngineCapsForSteerPriority(baseUrl: string, caps: un
 export declare function observedSteerPriority(baseUrl?: string | undefined): SteerPriorityReading;
 export declare function steerPriorityMode(reading: SteerPriorityReading): SteerPriorityMode;
 export declare function steerPriorityDoctorDetail(reading: SteerPriorityReading): string;
-export declare function __resetSteerPriorityReadingsForTests(): void;

package/dist/steerPriorityCapability.js

@@ -1,6 +1,6 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectSteerPriorityCapability(caps) {
     try {
@@ -25,7 +25,6 @@ export function projectSteerPriorityCapability(caps) {
 const reader = createEngineCapReader({
     name: 'fleet.steerPriority',
     project: projectSteerPriorityCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForSteerPriority(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -65,6 +64,8 @@ export function steerPriorityDoctorDetail(reading) {
     if (kind === 'not_reported') {
         return 'steer priority not reported by this engine — its capabilities reading carries no fleet.steerPriority (the fleet face is not reported, or the face carries no such field; this client cannot tell which), so a "now" or "later" steer is not sent (steers without a priority work as before)';
     }
+    if (kind === 'unreadable')
+        return unreadableReadingDetail('steer priority');
     if (kind !== 'present' || typeof word !== 'string' || word.length === 0)
         return unobserved;
     if (word === 'engine')
@@ -74,6 +75,3 @@ export function steerPriorityDoctorDetail(reading) {
     }
     return `steer priority reported as "${capForDisplay(word, WORD_DETAIL_MAX)}" — a value this client does not know yet, so whether it is applied is unknown and a "now" or "later" steer is not sent`;
 }
-export function __resetSteerPriorityReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/storePostureCapability.d.ts

@@ -8,6 +8,8 @@ export interface StorePostureView {
 }
 export type StorePostureReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {
@@ -15,11 +17,7 @@ export type StorePostureReading = {
     view: StorePostureView;
 };
 export declare function projectStorePostureCapability(caps: unknown): StorePostureReading | undefined;
-export declare function noteEngineCapsForStorePosture(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedStorePosture(baseUrl?: string | undefined): StorePostureReading;
 export declare function storePersistence(reading: StorePostureReading): 'durable' | 'not_durable' | 'unknown';
 export declare function storePostureHeadWord(reading: StorePostureReading): string | undefined;
 export declare function storePostureDoctorDetail(reading: StorePostureReading): string;
-export declare function __resetStorePostureReadingsForTests(): void;

package/dist/storePostureCapability.js

@@ -1,6 +1,6 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { storeSeatOf, createEngineCapReader } from './engineCapReader.js';
+import { storeSeatOf, createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { projectSqlEngineCapability } from './sqlEngineCapability.js';
 import { ownDataField } from './ownKey.js';
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
@@ -44,11 +44,7 @@ function projectStorePostureOf(caps) {
 const reader = createEngineCapReader({
     name: 'store',
     project: projectStorePostureCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
-export function noteEngineCapsForStorePosture(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedStorePosture(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -57,7 +53,7 @@ function presentView(reading) {
         return undefined;
     try {
         const kind = reading.kind;
-        if (kind === 'not_reported' || kind === 'unobserved')
+        if (kind === 'not_reported' || kind === 'unobserved' || kind === 'unreadable')
             return { kind };
         if (kind !== 'present')
             return undefined;
@@ -92,6 +88,8 @@ const word = (v) => capForDisplay(v, WORD_DETAIL_MAX);
 export function storePostureDoctorDetail(reading) {
     const unobserved = 'store posture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment persists its state is unknown';
     const r = presentView(reading);
+    if (r?.kind === 'unreadable')
+        return unreadableReadingDetail('store posture');
     if (r?.kind === 'not_reported') {
         return 'store posture not reported by this engine; this does not say whether this deployment persists its state';
     }
@@ -127,6 +125,3 @@ export function storePostureDoctorDetail(reading) {
     }
     return `${assembled} — ${lost} (degraded for a reason this client does not know yet: "${word(reason)}")`;
 }
-export function __resetStorePostureReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/subagent/engineSubagentSteer.js

@@ -5,6 +5,7 @@ import { resolveOwnerContext, resolveOwnerRunId } from './engineSubagentResume.j
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 import { errCodes, steeringRefusedBeforeEngine } from '../controlRouter.js';
 import { ownNonEmptyStringOf } from '../steerReceipt.js';
+import { wireFailureTextsOf } from '../wireFailureShape.js';
 function usableSteerClient(client) {
     return clientHasVerbs(client, [['runs', 'steerSubagent']]);
 }
@@ -53,14 +54,14 @@ export async function steerEngineSubagent(target, text, childTaskId, opts) {
             status = undefined;
         }
         if (status !== undefined) {
-            const detail = e instanceof Error ? e.message : String(e);
-            hostLog('debug', `engineSubagentSteer: ${status} ${detail.slice(0, 200)}`);
+            const texts = wireFailureTextsOf(e);
+            hostLog('debug', `engineSubagentSteer: ${status} ${texts.log.slice(0, 200)}`);
             const refused = typeof e === 'object' && e !== null ? steeringRefusedBeforeEngine(e) : undefined;
             if (refused !== undefined && refused.safety === 'ledger_unavailable') {
                 return { ok: false, reason: 'not-delivered', safety: refused.safety, detail: refused.advice };
             }
             if (status === 409 || status === 404) {
-                return { ok: false, reason: 'not-running', detail };
+                return { ok: false, reason: 'not-running', detail: texts.reason };
             }
             return { ok: false, reason: 'error', detail: `${status}` };
         }
@@ -69,7 +70,8 @@ export async function steerEngineSubagent(target, text, childTaskId, opts) {
             hostLog('debug', `engineSubagentSteer: may have been received, no answer — ${noAnswer}`);
             return { ok: false, reason: 'error', detail: noAnswer, unconfirmed: true };
         }
-        hostLog('debug', `engineSubagentSteer: fetch failed ${String(e)}`);
-        return { ok: false, reason: 'error', detail: String(e) };
+        const texts = wireFailureTextsOf(e);
+        hostLog('debug', `engineSubagentSteer: fetch failed ${texts.log}`);
+        return { ok: false, reason: 'error', detail: texts.reason };
     }
 }

package/dist/subagentContentStore.js

@@ -1,22 +1,11 @@
 import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
+import { toolEndOutputText } from './toolResultContent.js';
 export function coerceOutput(v) {
     if (v === undefined || v === null)
         return undefined;
-    if (typeof v === 'string')
-        return v;
-    if (Array.isArray(v)) {
-        const parts = [];
-        for (const block of v) {
-            if (block && typeof block === 'object') {
-                const b = block;
-                if (b.type === 'text' && typeof b.text === 'string')
-                    parts.push(b.text);
-                else if (b.type === 'image')
-                    parts.push('[image]');
-            }
-        }
-        return parts.join('');
-    }
+    const text = toolEndOutputText(v);
+    if (text !== undefined)
+        return text;
     try {
         return JSON.stringify(v);
     }

package/dist/supportFloor.d.ts

@@ -8,4 +8,5 @@ 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;
+export declare function engineSupportFloorEffective(floor?: string): string;
 export declare function coreVersionTier(version: unknown, floor?: string): EngineVersionTier;

package/dist/supportFloor.js

@@ -11,7 +11,8 @@ function releaseTriple(v) {
     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])];
+    const t = [Number(m[1]), Number(m[2]), Number(m[3])];
+    return t.every(Number.isSafeInteger) ? t : undefined;
 }
 function compareTriple(a, b) {
     for (let i = 0; i < 3; i++) {
@@ -22,28 +23,31 @@ function compareTriple(a, b) {
     }
     return 0;
 }
-function versionTierAgainst(version, base, floor, caller) {
+function judgeAgainst(version, base, floor, caller) {
     const baseTriple = releaseTriple(base);
     if (baseTriple === undefined) {
         throw new TypeError(`${caller}: 门槛只接受纯 x.y.z 版本串(整串、无前导零、无前后缀)—— 收到 typeof=${base === null ? 'null' : typeof base}。错误文本只报形状,不回显值。`);
     }
-    let need = baseTriple;
+    let need = { triple: baseTriple, text: base };
     if (floor !== undefined) {
         const own = releaseTriple(floor);
         if (own === undefined) {
             throw new TypeError(`${caller}: floor 只接受纯 x.y.z 版本串(整串、无前导零、无前后缀)或缺席 —— 收到 typeof=${floor === null ? 'null' : typeof floor}。错误文本只报形状,不回显值。`);
         }
-        if (compareTriple(own, need) > 0)
-            need = own;
+        if (compareTriple(own, need.triple) > 0)
+            need = { triple: own, text: floor };
     }
     const got = releaseTriple(version);
     if (got === undefined)
-        return 'unknown';
-    return compareTriple(got, need) >= 0 ? 'engine' : 'legacy';
+        return { need: need.text, tier: 'unknown' };
+    return { need: need.text, tier: compareTriple(got, need.triple) >= 0 ? 'engine' : 'legacy' };
 }
 export function engineVersionTier(version, floor) {
-    return versionTierAgainst(version, SUPPORT_FLOOR.server, floor, 'engineVersionTier');
+    return judgeAgainst(version, SUPPORT_FLOOR.server, floor, 'engineVersionTier').tier;
+}
+export function engineSupportFloorEffective(floor) {
+    return judgeAgainst(undefined, SUPPORT_FLOOR.server, floor, 'engineSupportFloorEffective').need;
 }
 export function coreVersionTier(version, floor) {
-    return versionTierAgainst(version, SUPPORT_FLOOR.core, floor, 'coreVersionTier');
+    return judgeAgainst(version, SUPPORT_FLOOR.core, floor, 'coreVersionTier').tier;
 }

package/dist/systemReminderTag.d.ts

@@ -5,3 +5,4 @@ export interface SystemReminderOpenTagSpan {
 export declare function findSystemReminderOpenTag(text: string, from?: number): SystemReminderOpenTagSpan | null;
 export declare function unwrapSystemReminder(text: string): string;
 export declare function stripSystemReminderBlocks(text: string): string;
+export declare function stripSystemReminderTagTokens(text: string): string;

package/dist/systemReminderTag.js

@@ -39,3 +39,11 @@ export function stripSystemReminderBlocks(text) {
     }
     return pos === 0 ? text : out + text.slice(pos);
 }
+const SYSTEM_REMINDER_TAG_TOKEN = /<[^A-Za-z0-9>]{0,12}system-reminder(?:[^>]{0,200}>)?/gi;
+const SYSTEM_REMINDER_TAG_HEAD = /<[^A-Za-z0-9>]{0,12}system-reminder/i;
+export function stripSystemReminderTagTokens(text) {
+    if (typeof text !== 'string')
+        return text;
+    const once = text.replace(SYSTEM_REMINDER_TAG_TOKEN, ' ');
+    return SYSTEM_REMINDER_TAG_HEAD.test(once) ? once.replace(/</g, '&lt;') : once;
+}

package/dist/toolHistoryBadTurn.js

@@ -1,10 +1,11 @@
-import { displayUntrusted } from './displayUntrusted.js';
+import { displayUntrusted, markerSafeCut } from './displayUntrusted.js';
 const BAD_TURN_PREVIEW_MAX = 60;
 export function toolHistoryBadTurnSentence(promptText) {
     const text = typeof promptText === 'string' ? promptText : '';
     const washed = displayUntrusted(stripDisplayTagBlocks(text), { mark: 'dot' }).replace(/\s+/g, ' ').trim();
     const points = Array.from(washed);
-    const preview = points.length > BAD_TURN_PREVIEW_MAX ? `${points.slice(0, BAD_TURN_PREVIEW_MAX).join('')}...` : washed;
+    const head = points.length > BAD_TURN_PREVIEW_MAX ? points.slice(0, BAD_TURN_PREVIEW_MAX).join('') : undefined;
+    const preview = head === undefined ? washed : `${washed.slice(0, markerSafeCut(washed, head.length))}...`;
     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.';

package/dist/toolHistoryMismatch.d.ts

@@ -18,8 +18,6 @@ export declare const TOOL_HISTORY_MISMATCH_ANCHORS: readonly ToolHistoryMismatch
 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;
@@ -61,4 +59,3 @@ export type ToolHistoryRewindResolution<R> = {
     undecidable: ToolHistoryUndecidableReason;
 };
 export declare function resolveToolHistoryRewindTarget<R extends ToolHistoryRow>(rows: readonly (R | null | undefined)[] | null | undefined, mismatch: ToolHistoryMismatch | null | undefined): ToolHistoryRewindResolution<R>;
-export {};

package/dist/toolHistoryMismatch.js

@@ -1,3 +1,4 @@
+import { rewindArchiveReadingAt, rewindConversationAvailability } from './rewindArchiveReading.js';
 export const TOOL_HISTORY_MISMATCH_KINDS = Object.freeze([
     'tool_use_without_result',
     'orphan_tool_result',
@@ -224,10 +225,6 @@ export const TOOL_HISTORY_REWIND_SENTENCE = 'Run /rewind to recover the conversa
 export function toolHistoryRepeatSentence(n) {
     return `The same error has now happened ${n} times in a row; /rewind is the only way to recover this conversation.`;
 }
-let conversationRewindJudge;
-export function _wireConversationRewindJudge(judge) {
-    conversationRewindJudge = judge;
-}
 export function toolHistoryRewindOffered(declared) {
     const decl = declared;
     if (decl === true)
@@ -238,10 +235,9 @@ export function toolHistoryRewindOffered(declared) {
         if (Array.isArray(decl))
             return false;
         const base = decl.engineBaseUrl;
-        const judge = conversationRewindJudge;
-        if (typeof base !== 'string' || base.length === 0 || judge === undefined)
+        if (typeof base !== 'string' || base.length === 0)
             return true;
-        return judge(base) !== 'unavailable';
+        return rewindConversationAvailability(rewindArchiveReadingAt(base)) !== 'unavailable';
     }
     catch {
         return true;

package/dist/toolResult.d.ts

@@ -86,12 +86,23 @@ export declare function _resetBackgroundReceiptParseCountForTest(): void;
 export type FlattenWireOutput = (output: unknown) => string;
 export declare const TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT: "wire_carried_no_output";
 export interface ToolResultBody {
-    content: unknown;
+    content: string | unknown[];
     isError: boolean;
     toolUseResult?: unknown;
     degraded?: typeof TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT;
 }
 export declare function degradedToolResultBody(isError: boolean): ToolResultBody;
+export type ToolCardDegradedCause = 'not-executed' | 'error-without-detail' | 'no-result' | 'unrecognised';
+export type ToolCardOutcomeReading = {
+    readonly kind: 'normal';
+} | {
+    readonly kind: 'degraded';
+    readonly cause: ToolCardDegradedCause;
+    readonly text: string;
+} | {
+    readonly kind: 'unreadable';
+};
+export declare function readToolCardOutcome(record: object | null | undefined): ToolCardOutcomeReading;
 export declare function wireOutputToBody(toolName: string, output: unknown, isError: boolean, truncated: boolean, flatten: FlattenWireOutput, structured?: unknown, leaderLedger?: boolean): ToolResultBody;
 export declare function structuredToToolUseResult(structured: unknown, modelText?: string, leaderLedger?: boolean): {
     toolUseResult: unknown;