@sema-agent/client-core 0.91.0 → 0.93.0

package/dist/resumeRefusalCopy.js

@@ -1,4 +1,5 @@
 import { readErrorNumber, readErrorString } from './wireFailureShape.js';
+import { readOwnDataNonEmptyString } from './ownKey.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';
@@ -115,7 +116,7 @@ export function requireExistingSessionRefusalFromError(err) {
     }
 }
 const REQUIRE_EXISTING_SESSION_SENTENCES = Object.freeze({
-    session_not_found: 'The engine did not continue this conversation: the conversation it was asked to continue does not exist there (it may have expired, been removed, or never been created on that engine), and this request asked to continue only an existing one, so no new conversation was started · Start a new conversation, or pick another one to continue',
+    session_not_found: 'The engine did not continue this conversation: the conversation it was asked to continue does not exist there (it may have expired, been removed, or never been created on that engine; this client cannot tell which), and this request asked to continue only an existing one, so no new conversation was started · Start a new conversation, or pick another one to continue',
     session_id_missing: 'The engine did not continue this conversation: this request asked to continue only an existing conversation but named none, so there was nothing to continue and no new conversation was started · Name the conversation to continue, or start a new one',
 });
 const REQUIRE_EXISTING_SESSION_GENERIC = 'The engine did not continue this conversation: this request asked to continue only an existing conversation and there was none it could continue, so no new conversation was started · Start a new conversation, or pick another one to continue';
@@ -158,6 +159,26 @@ export function resumeContextUnavailableContent(d) {
         third,
     ].join(' · ');
 }
+function parkedResumeStartupCauseWord(err) {
+    let named;
+    try {
+        named = readOwnDataNonEmptyString(err, 'startupCause');
+    }
+    catch {
+        named = undefined;
+    }
+    if (named !== undefined)
+        return named;
+    try {
+        const extra = err.extra;
+        if (typeof extra !== 'object' || extra === null || Array.isArray(extra))
+            return undefined;
+        return readOwnDataNonEmptyString(extra, 'cause');
+    }
+    catch {
+        return undefined;
+    }
+}
 export function parkedResumeStartupFromError(err, decision) {
     if (typeof err !== 'object' || err === null)
         return null;
@@ -172,10 +193,12 @@ export function parkedResumeStartupFromError(err, decision) {
         return null;
     const rawTaskId = readErrorString(err, 'taskId');
     const taskId = rawTaskId !== undefined && rawTaskId.length > 0 ? rawTaskId : undefined;
+    const startupCause = parkedResumeStartupCauseWord(err);
     return {
         code: PARKED_RESUME_STARTUP_FAILED,
         cause: decision === 'deny' ? 'resume_rejected' : 'undetermined',
         ...(taskId !== undefined ? { taskId } : {}),
+        ...(startupCause !== undefined ? { startupCause } : {}),
         resendable: false,
         denyStaysOpen: true,
     };
@@ -183,7 +206,7 @@ export function parkedResumeStartupFromError(err, decision) {
 const PARKED_RESUME_STARTUP_STATE = 'This refusal does not say whether the card is still waiting — re-fetch the pending approvals';
 const PARKED_RESUME_STARTUP_SENTENCES = Object.freeze({
     resume_rejected: [
-        'The engine could not start the parked work to apply this decision (its session may be gone, or the engine rejected the decision itself)',
+        'The engine could not start the parked work to apply this decision (its session may be gone, or the engine rejected the decision itself; this client cannot tell which)',
         PARKED_RESUME_STARTUP_STATE,
         'If the card is still there, decide it again from the fresh list',
     ].join(' · '),
@@ -249,7 +272,7 @@ export function checkpointUnsupportedVersionContent(detail, ctx) {
     }
     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';
+            'If it was parked before this server was upgraded, submit the work again as a new task (this client cannot tell which kind of parked work this is, so both ways out are given): 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/retryStatus.js

@@ -47,7 +47,7 @@ export function mapBrainStatusToRetry(p, nowMs) {
         case 'reconnecting':
             return { kind: 'stalled', deadline, ...extra, ...stalledDetail };
         case 'rate_limited':
-            return { kind: 'error', deadline, ...extra, error: { formatted: '', rateLimits: {} } };
+            return { kind: 'error', deadline, ...extra, error: { formatted: p.detail ?? '', rateLimits: null } };
         case 'circuit_open':
             return {
                 kind: 'error',
@@ -60,6 +60,7 @@ export function mapBrainStatusToRetry(p, nowMs) {
         case 'waiting_first_token':
             return { kind: 'waiting', deadline, ...extra, error: { formatted: '' } };
         case 'retrying':
+            return { kind: 'error', deadline, ...extra, error: { formatted: p.detail ?? '' } };
         default:
             return { kind: 'error', deadline, ...extra, error: { formatted: '' } };
     }

package/dist/rewindArchiveCapability.js

@@ -77,7 +77,7 @@ export function rewindArchiveDoctorDetail(reading, mode) {
                 ? `${lane} off on this deployment (no file history store) — the working tree cannot be restored here; whether the conversation alone can be rewound is a separate reading`
                 : `${lane} off on this deployment — it needs both a file history store and conversation anchors, and the engine reports at least one missing (it does not say which)`;
         case 'not_reported':
-            return `${lane} not reported by this engine — only newer engines advertise it, so this does not say whether the code archive can be restored`;
+            return `${lane} not reported by this engine, so this does not say whether the code archive can be restored`;
         case 'malformed':
             return `${lane} reported in a shape this reader cannot read — the value is neither true nor false, so the answer is unknown, not "no"`;
     }
@@ -102,7 +102,7 @@ export function rewindConversationDoctorDetail(reading) {
         case 'off':
             return `${lane} off on this deployment (no conversation anchors) — the conversation cannot be moved back to an earlier message here`;
         case 'not_reported':
-            return `conversation anchors not reported by this engine — only newer engines advertise them, so this does not say whether the conversation can be rewound`;
+            return `conversation anchors not reported by this engine, so this does not say whether the conversation can be rewound`;
         case 'malformed':
             return `conversation anchors reported in a shape this reader cannot read — the value is neither true nor false, so the answer is unknown, not "no"`;
     }

package/dist/ruleCompileVerdict.d.ts

@@ -0,0 +1,2 @@
+export type RuleCompileVerdict = 'compiles' | 'refused' | 'unknown';
+export declare function ruleCompileVerdict(rule: string, behavior: 'deny' | 'ask'): RuleCompileVerdict;

package/dist/ruleCompileVerdict.js

@@ -0,0 +1,13 @@
+import { validatePermissionRules } from './coreValuePorts.js';
+const RULE_COMPILE_ROOT = '/';
+export function ruleCompileVerdict(rule, behavior) {
+    try {
+        const issues = validatePermissionRules([{ rule, behavior }], { pathBases: { root: RULE_COMPILE_ROOT } });
+        if (!Array.isArray(issues))
+            return 'unknown';
+        return issues.length === 0 ? 'compiles' : 'refused';
+    }
+    catch {
+        return 'unknown';
+    }
+}

package/dist/ruleRemovalConsequence.d.ts

@@ -1,3 +1,4 @@
-export type RuleRemovalBehavior = 'allow' | 'deny' | 'ask' | undefined;
+import type { RuleBehavior } from '@sema-agent/sdk';
+export type RuleRemovalBehavior = RuleBehavior | undefined;
 export declare function removalConsequenceLineForBehavior(behavior: RuleRemovalBehavior): string;
 export declare function ruleRemovalBehaviorOf(raw: unknown): RuleRemovalBehavior;

package/dist/runCancelContext.d.ts

@@ -15,6 +15,7 @@ import { type RunTerminalRead } from './runTerminal.js';
 export type RunAbortCause = {
     kind: 'cancelled';
     context?: RunCancelContextView;
+    cause?: AbortCauseReading;
 } | {
     kind: 'engine_error';
     code?: string;
@@ -28,3 +29,14 @@ export type RunAbortCause = {
 };
 export declare const RUN_CANCELLED_CODE: "cancelled";
 export declare function classifyRunAbortCause(record: unknown): RunAbortCause;
+export declare const ABORT_CAUSES: readonly ["client_disconnected", "ask_park_grace_exhausted", "cancel_verb"];
+export type AbortCause = (typeof ABORT_CAUSES)[number];
+export type AbortCauseReading = {
+    readonly kind: 'known';
+    readonly cause: AbortCause;
+} | {
+    readonly kind: 'unrecognized';
+    readonly word: string;
+};
+export declare function readAbortCause(frame: unknown): AbortCauseReading | undefined;
+export declare function abortCauseNoteOf(frame: unknown): string | undefined;

package/dist/runCancelContext.js

@@ -45,7 +45,8 @@ export function classifyRunAbortCause(record) {
     if (read !== null && read.kind === 'failed') {
         if (read.code === RUN_CANCELLED_CODE) {
             const cc = readRunCancelContext(record);
-            return { kind: 'cancelled', ...(cc?.kind === 'present' ? { context: cc.context } : {}) };
+            const cause = readAbortCause(record);
+            return { kind: 'cancelled', ...(cc?.kind === 'present' ? { context: cc.context } : {}), ...(cause !== undefined ? { cause } : {}) };
         }
         return { kind: 'engine_error', ...(read.code !== undefined ? { code: read.code } : {}), ...(read.message !== undefined ? { message: read.message } : {}) };
     }
@@ -55,3 +56,84 @@ export function classifyRunAbortCause(record) {
         return { kind: 'run_still_live', status };
     return { kind: 'unknown', ...(read !== null ? { terminal: read.kind } : {}) };
 }
+export const ABORT_CAUSES = Object.freeze(['client_disconnected', 'ask_park_grace_exhausted', 'cancel_verb']);
+function ownDataOf(o, key) {
+    const d = Object.getOwnPropertyDescriptor(o, key);
+    return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+}
+function plainRecordOf(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v) ? v : undefined;
+}
+function cancelledHolderOf(frame) {
+    const f = plainRecordOf(frame);
+    if (f === undefined)
+        return undefined;
+    const type = ownDataOf(f, 'type');
+    if (type === 'failed')
+        return ownDataOf(f, 'errorCode') === RUN_CANCELLED_CODE ? f : undefined;
+    const base = plainRecordOf(type === 'done' ? ownDataOf(f, 'result') : f);
+    if (base === undefined)
+        return undefined;
+    const holder = runResultHolder(base);
+    const t = readRunTerminal(holder);
+    return t !== null && t.kind === 'failed' && t.code === RUN_CANCELLED_CODE ? holder : undefined;
+}
+function abortCauseIn(holder) {
+    const raw = ownDataOf(holder, 'abortCause');
+    if (typeof raw !== 'string' || raw.length === 0)
+        return undefined;
+    return ABORT_CAUSES.includes(raw) ? { kind: 'known', cause: raw } : { kind: 'unrecognized', word: raw };
+}
+export function readAbortCause(frame) {
+    try {
+        const holder = cancelledHolderOf(frame);
+        return holder === undefined ? undefined : abortCauseIn(holder);
+    }
+    catch {
+        return undefined;
+    }
+}
+const ABORT_CAUSE_SENTENCES = Object.freeze({
+    client_disconnected: 'Aborted: the stream connection to the engine dropped, and the engine stopped the run (cause client_disconnected) — not an engine error.',
+    ask_park_grace_exhausted: 'Aborted: the connection dropped while a question or approval was pending, and the run could not be parked for later resumption in time ' +
+        '(cause ask_park_grace_exhausted) — not an engine error.',
+    cancel_verb: 'Cancelled: a cancel request to the engine stopped this run (cause cancel_verb) — not an engine error.',
+});
+const ABORT_CAUSE_UNRECOGNIZED_SENTENCE = 'Aborted by the engine for a reason this client does not recognize — not an engine error.';
+function secondsText(ms) {
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+function cancelContextOf(holder) {
+    try {
+        const r = readRunCancelContext(holder);
+        return r?.kind === 'present' ? r.context : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function cancelContextTail(ctx) {
+    if (ctx === undefined)
+        return '';
+    const parts = [];
+    if (ctx.elapsedMs !== undefined)
+        parts.push(`ran ${secondsText(ctx.elapsedMs)}`);
+    if (ctx.lastEventAgeMs !== undefined)
+        parts.push(`last engine activity ${secondsText(ctx.lastEventAgeMs)} before the stop`);
+    return parts.length > 0 ? ` (${parts.join('; ')})` : '';
+}
+export function abortCauseNoteOf(frame) {
+    try {
+        const holder = cancelledHolderOf(frame);
+        if (holder === undefined)
+            return undefined;
+        const cause = abortCauseIn(holder);
+        if (cause === undefined)
+            return undefined;
+        const sentence = cause.kind === 'known' ? ABORT_CAUSE_SENTENCES[cause.cause] : ABORT_CAUSE_UNRECOGNIZED_SENTENCE;
+        return `${sentence}${cancelContextTail(cancelContextOf(holder))}`;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/runTerminal.d.ts

@@ -16,6 +16,21 @@ export interface RunTerminalFailureDetail {
     status?: number;
     code?: string;
 }
+export declare const PROMPT_BLOCK_CAUSES: readonly ["block", "crashed", "timeout", "cancelled"];
+export type PromptBlockCause = (typeof PROMPT_BLOCK_CAUSES)[number];
+export type RunTerminalBlockedDetail = {
+    kind: 'prompt_blocked_by_hook';
+    cause: PromptBlockCause;
+    hookReason?: string;
+} | {
+    kind: 'prompt_blocked_by_hook';
+    cause: 'unrecognized';
+    word: string;
+    hookReason?: string;
+} | {
+    kind: 'unrecognized';
+    word: string;
+};
 export type RunTerminalRead = {
     kind: 'completed';
     plane: RunTerminalPlane;
@@ -31,6 +46,7 @@ export type RunTerminalRead = {
     plane: RunTerminalPlane;
     reason?: string;
     code?: string;
+    detail?: RunTerminalBlockedDetail;
 } | RunTerminalPausedRead | {
     kind: 'unknown';
     plane: RunTerminalPlane;

package/dist/runTerminal.js

@@ -1,4 +1,6 @@
-import { CORE_TERMINAL_CAUSE_KINDS } from './generated/engineFactTables.js';
+import { CORE_PROMPT_BLOCK_CAUSES, CORE_TERMINAL_CAUSE_KINDS } from './generated/engineFactTables.js';
+export const PROMPT_BLOCK_CAUSES = CORE_PROMPT_BLOCK_CAUSES;
+const PROMPT_BLOCKED_BY_HOOK_DETAIL_KIND = 'prompt_blocked_by_hook';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
@@ -20,10 +22,13 @@ function pauseOf(v) {
         ...(restoreMode !== undefined ? { restoreMode } : {}),
     };
 }
+function ownValueOf(o, k) {
+    return Object.prototype.hasOwnProperty.call(o, k) ? o[k] : undefined;
+}
 const PROVIDER_REJECTED_DETAIL_KIND = 'provider_rejected';
 function failureDetailOf(cause) {
     try {
-        const own = (o, k) => (Object.prototype.hasOwnProperty.call(o, k) ? o[k] : undefined);
+        const own = ownValueOf;
         const v = own(cause, 'detail');
         if (typeof v !== 'object' || v === null || Array.isArray(v))
             return undefined;
@@ -41,6 +46,29 @@ function failureDetailOf(cause) {
         return undefined;
     }
 }
+function blockedDetailOf(cause) {
+    try {
+        const v = ownValueOf(cause, 'detail');
+        if (typeof v !== 'object' || v === null || Array.isArray(v))
+            return undefined;
+        const kind = str(ownValueOf(v, 'kind'));
+        if (kind === undefined)
+            return undefined;
+        if (kind !== PROMPT_BLOCKED_BY_HOOK_DETAIL_KIND)
+            return { kind: 'unrecognized', word: kind };
+        const causeWord = str(ownValueOf(v, 'cause'));
+        if (causeWord === undefined)
+            return undefined;
+        const hookReason = str(ownValueOf(v, 'hookReason'));
+        const hook = hookReason !== undefined ? { hookReason } : {};
+        return PROMPT_BLOCK_CAUSES.includes(causeWord)
+            ? { kind: PROMPT_BLOCKED_BY_HOOK_DETAIL_KIND, cause: causeWord, ...hook }
+            : { kind: PROMPT_BLOCKED_BY_HOOK_DETAIL_KIND, cause: 'unrecognized', word: causeWord, ...hook };
+    }
+    catch {
+        return undefined;
+    }
+}
 const FLAT_PAUSED_STATUSES = ['suspended', 'needs_review'];
 export function readRunTerminal(result) {
     if (typeof result !== 'object' || result === null || Array.isArray(result))
@@ -77,7 +105,8 @@ export function readRunTerminal(result) {
             }
             case 'blocked': {
                 const reason = str(c.reason);
-                return { kind: 'blocked', plane: 'cause', ...(reason !== undefined ? { reason } : {}) };
+                const detail = blockedDetailOf(c);
+                return { kind: 'blocked', plane: 'cause', ...(reason !== undefined ? { reason } : {}), ...(detail !== undefined ? { detail } : {}) };
             }
             case 'paused':
                 return { kind: 'paused', plane: 'cause', ...(pauseOf(c) ?? {}) };

package/dist/seam.d.ts

@@ -15,6 +15,7 @@ export interface InlineTaskTick {
     totalTokens: number;
     durationMs: number;
     currentAction?: string;
+    model?: string;
 }
 export interface AdapterContext {
     sessionId: string;

package/dist/seam.js

@@ -94,7 +94,7 @@ const CHROME_ARM_TABLE = {
     },
     tool_progress: {
         required: false,
-        duty: 'CC-08(0.71.0,C-R50 一帧两拍):按 `toolCallId` 挂到那张工具卡上;`elapsedSeconds` 缺席不是 0、不等于 tool_end 的 duration;' +
+        duty: 'CC-08(0.71.0,一帧两拍):按 `toolCallId` 挂到那张工具卡上;`elapsedSeconds` 缺席不是 0、不等于 tool_end 的 duration;' +
             '`output` 在场 = 命令尾巴窗口(活面板,不是日志;`totalLines`/`totalBytes` 与它同进同退),🔴 它是 UNTRUSTED RAW,可再封顶展示、**绝不回喂**模型;' +
             '子代工具的进度不在这条臂上(三键断闸),fleet 面板另有口。不接 = 看不见进度,不属行为丢失。',
     },

package/dist/seatContract.d.ts

@@ -4,6 +4,7 @@ import type { LaneProof } from "./seam.js";
 import type { QuestionAnswer } from "./liveQuestionStore.js";
 import type { ToolApprovalDelegation } from "./hitl/toolApprovalWire.js";
 import type { ApprovalMandateWord } from "./gateVocabulary.js";
+import type { ModelApiWord } from "./model/providerPresets.js";
 export interface SeatValidationFailure {
     reason: string;
     field?: string;
@@ -240,7 +241,7 @@ export interface SeatCatalogEntry {
     providerId: string;
     providerName: string;
     baseUrl: string;
-    api: "anthropic-messages" | "openai-completions";
+    api: ModelApiWord;
     apiKey?: string;
     modelId: string;
     contextWindow: number;

package/dist/sessionMemoryStatus.d.ts

@@ -1,4 +1,4 @@
-import type { SessionMemoryStatus } from '@sema-agent/sdk';
+import type { SessionMemoryStatus, SessionMemoryStatusResponse } from '@sema-agent/sdk';
 export interface MemoryStatusClientLike {
     sessions: {
         memoryStatus(sessionId: string, opts?: {
@@ -8,9 +8,7 @@ export interface MemoryStatusClientLike {
         } & SessionMemoryStatus>;
     };
 }
-export type MemoryStatusFacts = SessionMemoryStatus & {
-    readonly autoConsolidationArmed?: boolean;
-};
+export type MemoryStatusFacts = Omit<SessionMemoryStatusResponse, 'sessionId'>;
 export type MemoryStatusVerdict = {
     readonly kind: 'ok';
     readonly sessionId: string;

package/dist/sessionPolicyCapability.js

@@ -34,7 +34,7 @@ export function sessionPolicyFaceAvailable(reading) {
 export function sessionPolicyDoctorDetail(reading) {
     switch (reading.kind) {
         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, or the last one was unreadable)';
+            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':
             return 'per-session rule face not reported by this engine — this binary predates the position itself; it says nothing about whether the face exists, so read the rules rather than writing them blind';
         case 'absent':

package/dist/sessionSyncFileHistoryCapability.d.ts

@@ -0,0 +1,18 @@
+export type SessionSyncFileHistoryReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'absent';
+} | {
+    kind: 'present';
+};
+export declare function projectSessionSyncFileHistoryCapability(caps: unknown): SessionSyncFileHistoryReading | undefined;
+export declare function noteEngineCapsForSessionSyncFileHistory(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+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 forgetSessionSyncFileHistoryReading(baseUrl: string | undefined): void;
+export declare function __resetSessionSyncFileHistoryReadingsForTests(): void;

package/dist/sessionSyncFileHistoryCapability.js

@@ -0,0 +1,50 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+export function projectSessionSyncFileHistoryCapability(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    if (!Object.hasOwn(caps, 'sessionSyncFileHistory'))
+        return { kind: 'not_reported' };
+    const v = caps.sessionSyncFileHistory;
+    if (v === undefined)
+        return { kind: 'not_reported' };
+    if (typeof v !== 'boolean')
+        return undefined;
+    return v ? { kind: 'present' } : { kind: 'absent' };
+}
+const reader = createEngineCapReader({
+    name: 'sessionSyncFileHistory',
+    project: projectSessionSyncFileHistoryCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForSessionSyncFileHistory(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedSessionSyncFileHistory(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function sessionSyncFileHistoryAvailable(reading) {
+    if (reading.kind === 'present')
+        return 'yes';
+    if (reading.kind === 'absent')
+        return 'no';
+    return 'unknown';
+}
+export function sessionSyncFileHistoryDoctorDetail(reading) {
+    switch (reading.kind) {
+        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':
+            return 'session-sync file history not reported separately by this engine; this does not say whether file history can be synced';
+        case 'absent':
+            return 'no session-sync file history on this deployment — syncing a session moves the conversation only; edited-file history stays behind';
+        case 'present':
+            return 'session-sync file history on — syncing a session can also move its edited-file history';
+    }
+}
+export function forgetSessionSyncFileHistoryReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetSessionSyncFileHistoryReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/skillToolListsCapability.d.ts

@@ -0,0 +1,18 @@
+export type SkillToolListsReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'absent';
+} | {
+    kind: 'present';
+};
+export declare function projectSkillToolListsCapability(caps: unknown): SkillToolListsReading | undefined;
+export declare function noteEngineCapsForSkillToolLists(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+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 forgetSkillToolListsReading(baseUrl: string | undefined): void;
+export declare function __resetSkillToolListsReadingsForTests(): void;

package/dist/skillToolListsCapability.js

@@ -0,0 +1,50 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+export function projectSkillToolListsCapability(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    if (!Object.hasOwn(caps, 'skillToolLists'))
+        return { kind: 'not_reported' };
+    const v = caps.skillToolLists;
+    if (v === undefined)
+        return { kind: 'not_reported' };
+    if (typeof v !== 'boolean')
+        return undefined;
+    return v ? { kind: 'present' } : { kind: 'absent' };
+}
+const reader = createEngineCapReader({
+    name: 'skillToolLists',
+    project: projectSkillToolListsCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForSkillToolLists(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedSkillToolLists(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function skillToolListsAvailable(reading) {
+    if (reading.kind === 'present')
+        return 'yes';
+    if (reading.kind === 'absent' || reading.kind === 'not_reported')
+        return 'no';
+    return 'unknown';
+}
+export function skillToolListsDoctorDetail(reading) {
+    switch (reading.kind) {
+        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':
+            return 'skill tool lists not reported by this engine — the engine predates them: tool lists on request skills are not read, so they do not limit any tool';
+        case 'absent':
+            return 'skill tool lists off on this deployment — tool lists on request skills are not read';
+        case 'present':
+            return 'skill tool lists on — a request skill’s allowed and disallowed tool lists are read as this run’s rules';
+    }
+}
+export function forgetSkillToolListsReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetSkillToolListsReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/sqlEngineCapability.js

@@ -16,14 +16,7 @@ export function projectSqlEngineCapability(caps) {
             return { kind: 'none' };
         return projectSqlEngineView(nested);
     }
-    if (!Object.hasOwn(caps, 'sql'))
-        return { kind: 'not_reported' };
-    const sql = caps.sql;
-    if (sql === null)
-        return { kind: 'none' };
-    if (sql === undefined)
-        return { kind: 'not_reported' };
-    return projectSqlEngineView(sql);
+    return { kind: 'not_reported' };
 }
 function projectSqlEngineView(sql) {
     if (sql === null || typeof sql !== 'object')
@@ -59,7 +52,7 @@ export function sqlEngineDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
             return ('not observed — the engine reports it on /v1/capabilities; this process has no usable ' +
-                'capabilities reading cached for it (none received, or the last one was unreadable)');
+                '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':
             return 'not reported by this engine — the capability position needs a newer engine';
         case 'none':

package/dist/steerPriorityCapability.d.ts

@@ -0,0 +1,18 @@
+export type SteerPriorityReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'present';
+    word: string;
+};
+export type SteerPriorityMode = 'engine' | 'advisory' | 'unknown';
+export declare function projectSteerPriorityCapability(caps: unknown): SteerPriorityReading | undefined;
+export declare function noteEngineCapsForSteerPriority(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+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 forgetSteerPriorityReading(baseUrl: string | undefined): void;
+export declare function __resetSteerPriorityReadingsForTests(): void;