@sema-agent/client-core 0.96.0 → 0.97.1

package/dist/engineCapsCache.js

@@ -1,5 +1,6 @@
 import { settleWithinDeadline } from './abortableSleep.js';
 import { ownDataField } from './ownKey.js';
+const NOT_LANDED = Object.freeze({ kind: 'not_landed' });
 const capsByBase = new Map();
 const inFlight = new Set();
 const settleByBase = new Map();
@@ -13,11 +14,16 @@ export function engineCapsGeneration(baseUrl) {
     return capsGeneration(baseUrl);
 }
 export function engineCapsLandingOf(baseUrl) {
-    return capsByBase.get(baseUrl);
+    if (typeof baseUrl !== 'string' || baseUrl === '')
+        return NOT_LANDED;
+    return capsByBase.get(baseUrl) ?? NOT_LANDED;
 }
 export function kickEngineCapsProbe(baseUrl, probe) {
+    startEngineCapsProbe(baseUrl, probe);
+}
+function startEngineCapsProbe(baseUrl, probe) {
     if (!baseUrl || capsByBase.has(baseUrl) || inFlight.has(baseUrl))
-        return;
+        return false;
     probeByBase.set(baseUrl, probe);
     const gen = capsGeneration(baseUrl);
     inFlight.add(baseUrl);
@@ -35,8 +41,7 @@ export function kickEngineCapsProbe(baseUrl, probe) {
             const caps = await probe();
             if (gen !== capsGeneration(baseUrl))
                 return;
-            if (caps && typeof caps === 'object')
-                landCapsSnapshot(baseUrl, gen, caps);
+            landCapsSnapshot(baseUrl, gen, caps);
         }
         catch {
         }
@@ -49,6 +54,7 @@ export function kickEngineCapsProbe(baseUrl, probe) {
             markSettled();
         }
     })();
+    return true;
 }
 const MAX_WITHIN_MS = 2_147_483_647;
 function waitBudgetOf(opts) {
@@ -118,9 +124,7 @@ export async function engineCapsSettled(baseUrl, opts) {
     }
 }
 export function engineCapState(baseUrl, key) {
-    if (!baseUrl)
-        return 'unprobed';
-    return capStateIn(capsByBase.get(baseUrl)?.caps, key);
+    return stateOfSlot(slotInLanding(engineCapsLandingOf(baseUrl), key));
 }
 const SNAPSHOT_MAX_DEPTH = 64;
 const SNAPSHOT_MAX_NODES = 100_000;
@@ -156,10 +160,16 @@ function throwingAccessor() {
     };
 }
 function landCapsSnapshot(baseUrl, gen, caps) {
+    if (!isPlainCapsBody(caps))
+        return 'not_a_record';
     const snapshot = snapshotCapsBody(caps);
     if (gen !== capsGeneration(baseUrl))
-        return;
-    capsByBase.set(baseUrl, Object.freeze({ caps: snapshot }));
+        return 'superseded';
+    const record = snapshot === UNREADABLE_NODE
+        ? Object.freeze({ kind: 'unreadable' })
+        : Object.freeze({ kind: 'landed', caps: snapshot });
+    capsByBase.set(baseUrl, record);
+    return 'landed';
 }
 function snapshotCapsBody(body) {
     if (body === null || typeof body !== 'object')
@@ -237,8 +247,20 @@ function capSlotIn(caps, key) {
         return SLOT_UNREADABLE;
     }
 }
+function slotInLanding(landing, key) {
+    switch (landing.kind) {
+        case 'not_landed':
+            return SLOT_UNOBSERVED;
+        case 'unreadable':
+            return SLOT_UNREADABLE;
+        case 'landed':
+            return capSlotIn(landing.caps, key);
+    }
+}
 function capStateIn(caps, key) {
-    const slot = capSlotIn(caps, key);
+    return stateOfSlot(capSlotIn(caps, key));
+}
+function stateOfSlot(slot) {
     switch (slot.kind) {
         case 'unobserved':
             return 'unprobed';
@@ -276,7 +298,8 @@ export async function engineCapStateVia(baseUrl, key, probe, opts) {
         try {
             if (signal?.aborted)
                 return 'unprobed';
-            return capStateIn(await probe(signal), key);
+            const body = await probe(signal);
+            return isPlainCapsBody(body) ? capStateIn(body, key) : 'unprobed';
         }
         catch {
             return 'unprobed';
@@ -297,9 +320,7 @@ export function engineCapNestedTrue(baseUrl, parentKey, key) {
     return state.kind === 'value' && state.value === true;
 }
 export function engineCapNestedValue(baseUrl, parentKey, key) {
-    if (!baseUrl)
-        return { kind: 'unobserved' };
-    const parent = capSlotIn(capsByBase.get(baseUrl)?.caps, parentKey);
+    const parent = slotInLanding(engineCapsLandingOf(baseUrl), parentKey);
     if (parent.kind !== 'present')
         return valueStateOfSlot(parent);
     const group = parent.value;
@@ -308,9 +329,7 @@ export function engineCapNestedValue(baseUrl, parentKey, key) {
     return valueStateOfSlot(capSlotIn(group, key));
 }
 export function engineCapValue(baseUrl, key) {
-    if (!baseUrl)
-        return { kind: 'unobserved' };
-    return valueStateOfSlot(capSlotIn(capsByBase.get(baseUrl)?.caps, key));
+    return valueStateOfSlot(slotInLanding(engineCapsLandingOf(baseUrl), key));
 }
 function valueStateOfSlot(slot) {
     switch (slot.kind) {
@@ -325,9 +344,7 @@ function valueStateOfSlot(slot) {
     }
 }
 export function engineCapString(baseUrl, key) {
-    if (!baseUrl)
-        return undefined;
-    const slot = capSlotIn(capsByBase.get(baseUrl)?.caps, key);
+    const slot = slotInLanding(engineCapsLandingOf(baseUrl), key);
     return slot.kind === 'present' && typeof slot.value === 'string' && slot.value.length > 0 ? slot.value : undefined;
 }
 export function invalidateEngineCaps(baseUrl, probe) {
@@ -348,6 +365,19 @@ export function invalidateEngineCaps(baseUrl, probe) {
     if (probe !== undefined)
         kickEngineCapsProbe(baseUrl, probe);
 }
+export function rotateEngineCapsProbe(baseUrl, probe) {
+    try {
+        if (typeof baseUrl !== 'string' || baseUrl === '' || typeof probe !== 'function')
+            return 'ignored';
+        if (startEngineCapsProbe(baseUrl, probe))
+            return 'started';
+        probeByBase.set(baseUrl, probe);
+        return 'registered';
+    }
+    catch {
+        return 'ignored';
+    }
+}
 export async function refreshEngineCapsOnce(baseUrl, opts) {
     try {
         if (typeof baseUrl !== 'string' || baseUrl === '')
@@ -370,10 +400,9 @@ export async function refreshEngineCapsOnce(baseUrl, opts) {
         void (async () => {
             try {
                 const caps = await probe();
-                if (gen !== capsGeneration(baseUrl) || !capsByBase.has(baseUrl) || !isPlainCapsBody(caps))
+                if (gen !== capsGeneration(baseUrl) || !capsByBase.has(baseUrl))
                     return false;
-                landCapsSnapshot(baseUrl, gen, caps);
-                return gen === capsGeneration(baseUrl);
+                return landCapsSnapshot(baseUrl, gen, caps) === 'landed';
             }
             catch {
                 return false;
@@ -393,6 +422,8 @@ function isPlainCapsBody(caps) {
     try {
         if (typeof caps !== 'object' || caps === null)
             return false;
+        if (Array.isArray(caps))
+            return false;
         const proto = Object.getPrototypeOf(caps);
         if (proto !== null && Object.getPrototypeOf(proto) !== null)
             return false;

package/dist/engineErrorCodes.d.ts

@@ -35,6 +35,9 @@ export declare const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = "capability.self_o
 export declare const CAPABILITY_IMAGE_INDEX_REQUIRED = "capability.image_index_required";
 export declare const GATE_PARKED_ERROR_CODE = "gate.parked";
 export declare const ACTIVE_RUN_BUSY_ERROR_CODE = "conflict.session_active_run";
+export declare const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = "conflict.idempotency_payload_mismatch";
+export declare function isIdempotencyPayloadMismatchCode(code: string | null | undefined): boolean;
+export declare function idempotencyPayloadMismatchContent(): string;
 export interface BusyClassification {
     readonly busy: boolean;
     readonly handle: string | null;

package/dist/engineErrorCodes.js

@@ -1,4 +1,5 @@
 import { frozenSet } from './frozenSet.js';
+import { ownDataField } from './ownKey.js';
 import { SDK_DENY_REASON_ROUTING_FAILURE, SDK_RUN_DEATH_VERDICT_CODES, SDK_STATUS_DERIVED_COARSE_CODES } from './generated/sdkFactTables.js';
 export const LIMITS_MAX_TOKENS_EXCEEDED = 'limits.max_tokens_exceeded';
 export const LIMITS_MAX_COST_EXCEEDED = 'limits.max_cost_exceeded';
@@ -65,6 +66,13 @@ export const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = 'capability.self_orchestra
 export const CAPABILITY_IMAGE_INDEX_REQUIRED = 'capability.image_index_required';
 export const GATE_PARKED_ERROR_CODE = 'gate.parked';
 export const ACTIVE_RUN_BUSY_ERROR_CODE = 'conflict.session_active_run';
+export const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = 'conflict.idempotency_payload_mismatch';
+export function isIdempotencyPayloadMismatchCode(code) {
+    return code === CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH;
+}
+export function idempotencyPayloadMismatchContent() {
+    return 'This request reused an idempotency key that is already bound to a different request body, so the engine refused it and nothing ran · To retry, send exactly the same request again; to send a different request, use a new idempotency key';
+}
 export function classifyActiveRunBusy(input) {
     const handle = typeof input.activeTaskId === 'string' && input.activeTaskId.length > 0 ? input.activeTaskId : null;
     if (input.errorCode === ACTIVE_RUN_BUSY_ERROR_CODE)
@@ -139,7 +147,7 @@ export function refusalSaysStillPending(err) {
 }
 export function refusalRetriableReading(err) {
     try {
-        return Object.hasOwn(err, 'retriable') && err.retriable === true;
+        return ownDataField(err, 'retriable') === true;
     }
     catch {
         return undefined;

package/dist/engineNoticeCodes.js

@@ -1,6 +1,5 @@
 import { AUTO_MODE_UNAVAILABLE_CAUSES } from './autoModeUnavailable.js';
 import { displayUntrusted } from './displayUntrusted.js';
-import { currentEngineWord } from './engineWordRenames.js';
 import { CORE_ENGINE_NOTICE_CODES, CORE_MCP_INJECTION_DROP_REASONS, CORE_NOTICE_AUDIENCE, CORE_USER_INPUT_UNDRAINED_FAMILIES, } from './generated/engineNoticeTables.js';
 import { CORE_ASK_UNRESOLVABLE_CAUSES, CORE_DURABLE_MANDATE_SOURCES, CORE_PERMISSION_MODE_FOLD_REASONS, } from './generated/engineFactTables.js';
 export const ENGINE_NOTICE_CODES = CORE_ENGINE_NOTICE_CODES;
@@ -9,13 +8,13 @@ function audienceRow(table, code) {
     return Object.hasOwn(table, code) ? table[code] : undefined;
 }
 export function engineNoticeInCatalog(code) {
-    return typeof code === 'string' && (CATALOG.has(code) || CATALOG.has(currentEngineWord(code)));
+    return typeof code === 'string' && CATALOG.has(code);
 }
 export const ENGINE_NOTICE_AUDIENCE = CORE_NOTICE_AUDIENCE;
 export function noticeAudienceOf(code) {
     if (typeof code !== 'string')
         return 'operator';
-    return audienceRow(ENGINE_NOTICE_AUDIENCE, code) ?? audienceRow(ENGINE_NOTICE_AUDIENCE, currentEngineWord(code)) ?? 'operator';
+    return audienceRow(ENGINE_NOTICE_AUDIENCE, code) ?? 'operator';
 }
 export const MCP_INJECTION_DROP_REASONS = CORE_MCP_INJECTION_DROP_REASONS;
 const DROP_REASONS = new Set(MCP_INJECTION_DROP_REASONS);

package/dist/engineToolDirectory.d.ts

@@ -0,0 +1,27 @@
+export interface EngineToolDirectorySource {
+    readonly requestMcpServers?: readonly {
+        readonly name: string;
+    }[] | null;
+    readonly deploymentMcpServers?: readonly {
+        readonly name: string;
+    }[] | null;
+}
+export type EngineToolDirectory = {
+    readonly state: 'not_landed';
+} | {
+    readonly state: 'unreadable';
+} | {
+    readonly state: 'directory';
+    readonly mcpServerPrefixes: ReadonlySet<string>;
+};
+export declare function engineToolDirectoryOf(source: EngineToolDirectorySource | null | undefined): EngineToolDirectory;
+export type McpEntryReading = 'outside' | 'unchecked' | 'unparsable' | 'answers' | 'unanswered';
+export declare function mcpEntryReadingOf(toolName: string, directory: EngineToolDirectory | undefined): McpEntryReading;
+export declare function deniedEntryToolName(entry: string): string | undefined;
+export interface ExcludeToolsAgainstDirectory {
+    readonly send: string[];
+    readonly omitted: string[];
+    readonly verdict: 'directory_absent' | 'filtered';
+    readonly disclosure?: string;
+}
+export declare function excludeToolsAgainstDirectory(exclude: readonly string[], directory: EngineToolDirectory | undefined): ExcludeToolsAgainstDirectory;

package/dist/engineToolDirectory.js

@@ -0,0 +1,178 @@
+import { frozenSet } from './frozenSet.js';
+import { ownDataField } from './ownKey.js';
+import { hasCoreValuePort, mcpNamespace, mintNamespacePrefix, protocolOf } from './coreValuePorts.js';
+import { CORE_PROTOCOL_PREFIXES } from './generated/toolNameTables.js';
+const notLanded = () => Object.freeze({ state: 'not_landed' });
+const unreadable = () => Object.freeze({ state: 'unreadable' });
+function readHalf(half) {
+    if (half === undefined || half === null)
+        return 'absent';
+    if (!Array.isArray(half))
+        return 'unreadable';
+    const names = [];
+    const n = ownDataField(half, 'length');
+    if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+        return 'unreadable';
+    for (let i = 0; i < n; i++) {
+        if (!Object.hasOwn(half, i))
+            return 'unreadable';
+        const row = ownDataField(half, String(i));
+        if (row === null || typeof row !== 'object')
+            return 'unreadable';
+        const name = ownDataField(row, 'name');
+        if (typeof name !== 'string' || name.length === 0)
+            return 'unreadable';
+        names.push(name);
+    }
+    return names;
+}
+export function engineToolDirectoryOf(source) {
+    if (source === undefined || source === null)
+        return notLanded();
+    try {
+        if (typeof source !== 'object')
+            return unreadable();
+        const request = readHalf(ownDataField(source, 'requestMcpServers'));
+        const deployment = readHalf(ownDataField(source, 'deploymentMcpServers'));
+        if (request === 'unreadable' || deployment === 'unreadable')
+            return unreadable();
+        if (request === 'absent' || deployment === 'absent')
+            return notLanded();
+        const ns = namingPorts();
+        if (ns === undefined)
+            return unreadable();
+        const prefixes = [];
+        for (const name of [...request, ...deployment]) {
+            const prefix = mintNamespacePrefix(ns, name);
+            if (typeof prefix !== 'string' || prefix.length === 0)
+                return unreadable();
+            prefixes.push(prefix);
+        }
+        return Object.freeze({ state: 'directory', mcpServerPrefixes: frozenSet(prefixes) });
+    }
+    catch {
+        return unreadable();
+    }
+}
+export function mcpEntryReadingOf(toolName, directory) {
+    let ns;
+    try {
+        const mcp = namingPorts();
+        if (mcp === undefined)
+            return CORE_PROTOCOL_PREFIXES.some((p) => toolName.startsWith(p)) ? 'unchecked' : 'outside';
+        ns = protocolOf(toolName);
+        if (ns === undefined || ns.id !== mcp.id)
+            return 'outside';
+    }
+    catch {
+        return CORE_PROTOCOL_PREFIXES.some((p) => toolName.startsWith(p)) ? 'unchecked' : 'outside';
+    }
+    const prefixes = prefixesInHand(directory);
+    if (prefixes === undefined)
+        return 'unchecked';
+    let prefix;
+    try {
+        const peer = peerSegmentOf(ns, toolName);
+        if (peer === undefined || peer.includes('*'))
+            return 'unparsable';
+        prefix = mintNamespacePrefix(ns, peer);
+    }
+    catch {
+        return 'unparsable';
+    }
+    if (typeof prefix !== 'string' || prefix.length === 0)
+        return 'unchecked';
+    try {
+        return prefixes.has(prefix) ? 'answers' : 'unanswered';
+    }
+    catch {
+        return 'unchecked';
+    }
+}
+function prefixesInHand(directory) {
+    try {
+        if (directory === undefined || directory === null || typeof directory !== 'object' || directory.state !== 'directory')
+            return undefined;
+        const prefixes = directory.mcpServerPrefixes;
+        if (prefixes === null || typeof prefixes !== 'object' || typeof prefixes.has !== 'function')
+            return undefined;
+        return prefixes;
+    }
+    catch {
+        return undefined;
+    }
+}
+function namingPorts() {
+    if (!hasCoreValuePort('protocolOf') || !hasCoreValuePort('mintNamespacePrefix'))
+        return undefined;
+    return mcpNamespace();
+}
+function peerSegmentOf(ns, toolName) {
+    const read = (n) => {
+        const parsed = ns.parse(n);
+        if (parsed === null || typeof parsed !== 'object')
+            return undefined;
+        const peer = ownDataField(parsed, 'peer');
+        return typeof peer === 'string' && peer.length > 0 ? peer : undefined;
+    };
+    const direct = read(toolName);
+    if (direct !== undefined)
+        return direct;
+    if (!toolName.startsWith(ns.prefix))
+        return undefined;
+    const rest = toolName.slice(ns.prefix.length);
+    if (rest.length === 0)
+        return undefined;
+    return read(ns.makeName(rest, 'x')) === rest ? rest : undefined;
+}
+function unescapedIndexOf(s, ch, last) {
+    for (let k = 0; k < s.length; k++) {
+        const i = last ? s.length - 1 - k : k;
+        if (s[i] !== ch)
+            continue;
+        let backslashes = 0;
+        for (let j = i - 1; j >= 0 && s[j] === '\\'; j--)
+            backslashes++;
+        if (backslashes % 2 === 0)
+            return i;
+    }
+    return -1;
+}
+export function deniedEntryToolName(entry) {
+    if (entry !== entry.trim())
+        return undefined;
+    const open = unescapedIndexOf(entry, '(', false);
+    if (open === -1)
+        return entry;
+    const close = unescapedIndexOf(entry, ')', true);
+    if (close === -1 || close <= open || close !== entry.length - 1)
+        return entry;
+    const name = entry.substring(0, open);
+    return name.length === 0 ? entry : name.trim();
+}
+export function excludeToolsAgainstDirectory(exclude, directory) {
+    if (!Array.isArray(exclude))
+        throw new TypeError('excludeToolsAgainstDirectory: exclude must be an array of tool names');
+    const verdict = prefixesInHand(directory) !== undefined ? 'filtered' : 'directory_absent';
+    const send = [];
+    const omitted = [];
+    for (const entry of exclude) {
+        if (verdict === 'filtered' && typeof entry === 'string') {
+            const name = deniedEntryToolName(entry);
+            if (name !== undefined && mcpEntryReadingOf(name, directory) === 'unanswered') {
+                omitted.push(entry);
+                continue;
+            }
+        }
+        send.push(entry);
+    }
+    if (omitted.length === 0)
+        return { send, omitted, verdict };
+    const one = omitted.length === 1;
+    return {
+        send,
+        omitted,
+        verdict,
+        disclosure: `excludeTools: ${omitted.map((e) => JSON.stringify(e)).join(', ')} ${one ? 'names' : 'name'} no tool this deployment answers to (no MCP server of that name is declared for this session) — omitted. Excluding a tool that cannot be mounted changes nothing; the engine refuses a request that names one.`,
+    };
+}

package/dist/executionLaneCapability.d.ts

@@ -7,6 +7,8 @@ export interface ExecutionLaneCapabilityView {
 }
 export type ExecutionLaneReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {

package/dist/executionLaneCapability.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 projectExecutionLaneCapability(caps) {
     try {
@@ -55,7 +55,6 @@ export function projectExecutionLaneWiring(wiring) {
 const reader = createEngineCapReader({
     name: 'executionLane',
     project: projectExecutionLaneCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForExecutionLane(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -98,6 +97,8 @@ export function noOsSandboxContent() {
 const LANE_DETAIL_MAX = 40;
 export function executionLaneDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('execution lane');
         case 'unobserved':
             return ('execution lane 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/fileHistoryCaptureCapability.d.ts

@@ -1,5 +1,7 @@
 export type FileHistoryCaptureReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {

package/dist/fileHistoryCaptureCapability.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 { refreshEngineCapsOnce } from './engineCapsCache.js';
 import { ownDataField } from './ownKey.js';
 import { FILE_HISTORY_DISABLED } from './request/taskRequest.js';
@@ -22,7 +22,6 @@ export function projectFileHistoryCaptureCapability(caps) {
 const reader = createEngineCapReader({
     name: 'fileHistoryCapture',
     project: projectFileHistoryCaptureCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForFileHistoryCapture(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -64,11 +63,36 @@ export function fileHistoryTightenVerdict(reading, captureOffByUser) {
         return 'already_off';
     return 'unjudged';
 }
-const FILE_HISTORY_UNJUDGED_REFUSAL = 'Nothing was sent: file checkpointing is turned off in your settings, but this engine did not report whether it can ' +
-    'stop recording file history for a session, so sending now could record it anyway. Try again in a moment; to send ' +
-    'regardless and let file history be recorded this time, turn file checkpointing back on in your settings.';
+const FILE_HISTORY_REFUSAL_NOT_YET = "Nothing was sent: file checkpointing is turned off in your settings, but this engine's capabilities have not been read " +
+    'yet, so whether it can stop recording file history for a session is unknown and sending now could record it anyway. ' +
+    'Try again in a moment; to send regardless and let file history be recorded this time, turn file checkpointing back on in your settings.';
+const FILE_HISTORY_REFUSAL_NOT_SAID = 'Nothing was sent: file checkpointing is turned off in your settings, but this engine did not report whether it can ' +
+    'stop recording file history for a session, so sending now could record it anyway. Trying again will not change that ' +
+    'while this engine reports the same; to send and let file history be recorded this time, turn file checkpointing back on in your settings.';
+const FILE_HISTORY_REFUSAL_UNREADABLE = "Nothing was sent: file checkpointing is turned off in your settings, but this engine's report on whether it can stop " +
+    'recording file history for a session could not be read by this client, so sending now could record it anyway. Trying ' +
+    'again will not change that while this engine reports the same; to send and let file history be recorded this time, ' +
+    'turn file checkpointing back on in your settings.';
+function unjudgedRefusalOf(reading) {
+    let kind;
+    let word;
+    try {
+        kind = typeof reading === 'object' && reading !== null ? reading.kind : undefined;
+        word = kind === 'present' ? reading.word : undefined;
+    }
+    catch {
+        return FILE_HISTORY_REFUSAL_NOT_YET;
+    }
+    if (kind === 'unreadable')
+        return FILE_HISTORY_REFUSAL_UNREADABLE;
+    if (kind === 'not_reported')
+        return FILE_HISTORY_REFUSAL_NOT_SAID;
+    if (kind === 'present' && typeof word === 'string' && word.length > 0)
+        return FILE_HISTORY_REFUSAL_NOT_SAID;
+    return FILE_HISTORY_REFUSAL_NOT_YET;
+}
 export function fileHistoryUnjudgedRefusal(reading, captureOffByUser) {
-    return fileHistoryTightenVerdict(reading, captureOffByUser) === 'unjudged' ? FILE_HISTORY_UNJUDGED_REFUSAL : undefined;
+    return fileHistoryTightenVerdict(reading, captureOffByUser) === 'unjudged' ? unjudgedRefusalOf(reading) : undefined;
 }
 const FILE_HISTORY_REFRESH_WITHIN_MS = 3000;
 export async function judgeFileHistoryTighten(captureOffByUser, opts) {
@@ -76,7 +100,7 @@ export async function judgeFileHistoryTighten(captureOffByUser, opts) {
     const failClosed = () => {
         const reading = { kind: 'unobserved' };
         return closed
-            ? { verdict: 'unjudged', reading, refreshed: false, refusal: FILE_HISTORY_UNJUDGED_REFUSAL }
+            ? { verdict: 'unjudged', reading, refreshed: false, refusal: FILE_HISTORY_REFUSAL_NOT_YET }
             : { verdict: 'not_requested', reading, refreshed: false, refusal: undefined };
     };
     try {
@@ -115,7 +139,7 @@ export async function judgeFileHistoryTighten(captureOffByUser, opts) {
             verdict: v2,
             reading: second,
             refreshed: outcome !== 'no_probe',
-            refusal: v2 === 'unjudged' ? FILE_HISTORY_UNJUDGED_REFUSAL : undefined,
+            refusal: v2 === 'unjudged' ? unjudgedRefusalOf(second) : undefined,
         };
     }
     catch {
@@ -137,6 +161,8 @@ export function fileHistoryCaptureDoctorDetail(reading) {
         return unobserved;
     }
     switch (kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('file history capture');
         case 'not_reported':
             return 'file history capture not reported by this engine; this does not say whether file history is captured here';
         case 'present':

package/dist/fileHistoryLegNotice.js

@@ -89,6 +89,8 @@ function canonReading(r) {
         const kind = r.kind;
         if (kind === 'not_reported')
             return 'not_reported';
+        if (kind === 'unreadable')
+            return 'unreadable';
         if (kind === 'present') {
             const word = r.word;
             return typeof word === 'string' && word.length > 0 ? `present:${word}` : 'unobserved';
@@ -102,6 +104,8 @@ function canonReading(r) {
 function readingOfCanon(c) {
     if (c === 'not_reported')
         return { kind: 'not_reported' };
+    if (c === 'unreadable')
+        return { kind: 'unreadable' };
     if (c.startsWith('present:'))
         return { kind: 'present', word: c.slice('present:'.length) };
     return { kind: 'unobserved' };