@sema-agent/client-core 0.94.0 → 0.95.0

package/dist/sessionIdSegment.d.ts

@@ -0,0 +1 @@
+export declare function isSessionIdPathSegment(id: unknown): id is string;

package/dist/sessionIdSegment.js

@@ -0,0 +1,11 @@
+export function isSessionIdPathSegment(id) {
+    if (typeof id !== 'string' || id === '' || id === '.' || id === '..')
+        return false;
+    try {
+        encodeURIComponent(id);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/sessionMemoryErase.d.ts

@@ -34,7 +34,7 @@ export type SessionMemoryEraseAnswer = {
 };
 export declare function eraseSessionMemory(call: SessionMemoryEraseCall, wire: SessionMemoryEraseWire, opts?: SessionMemoryEraseOptions): Promise<SessionMemoryEraseAnswer>;
 export type SessionMemoryEraseRefusalReason = 'bad_input' | 'no_connection' | 'cancelled_before_send' | 'credentials_required' | 'not_permitted' | 'memory_engine_absent' | 'session_not_found' | 'route_absent' | 'request_rejected' | 'evidence_unavailable' | 'request_id_reused' | 'store_unreadable';
-export type SessionMemoryEraseUnconfirmedWhy = 'no_answer' | 'receipt_unreadable' | 'receipt_mismatch' | 'store_link_outside' | 'control_plane_corrupt' | 'engine_fault' | 'unclassified' | 'no_code' | 'unreadable';
+export type SessionMemoryEraseUnconfirmedWhy = 'no_answer' | 'receipt_unreadable' | 'receipt_mismatch' | 'store_link_outside' | 'store_home_not_directory' | 'control_plane_corrupt' | 'engine_fault' | 'unclassified' | 'no_code' | 'unreadable';
 export type SessionMemoryEraseRetry = 'not_needed' | 'same_request_id' | 'new_request_id' | 'needs_operator' | 'needs_consent' | 'human_decision' | 'pointless';
 type SessionMemoryEraseReceipt = Extract<MemoryEraseReceiptReading, {
     kind: 'present';

package/dist/sessionMemoryErase.js

@@ -2,6 +2,7 @@ import { isLoopbackWireUrl, resolveWireAuth } from './engineWireSdk.js';
 import { INJECTED_WIRE_SETTLE_MS, connectionLostDetail, noAnswerDetailFrom, noAnswerKindOf, provablyNotSent, settleInjected } from './engineWireFor.js';
 import { memoryEraseReplayPosture, readMemoryEraseReceipt } from './memoryEntriesWire.js';
 import { normalizeWirePrincipal } from './principalWire.js';
+import { isSessionIdPathSegment } from './sessionIdSegment.js';
 const PRINCIPAL_HEADER = 'x-agent-principal';
 const MAX_TIMER_MS = 2_147_483_647;
 const NOT_SENT = ' — nothing was sent';
@@ -117,7 +118,7 @@ export async function eraseSessionMemory(call, wire, opts) {
         const allowUnevidenced = Object.hasOwn(call, 'allowUnevidenced') ? call.allowUnevidenced : undefined;
         if (!nonEmptyString(sessionId) || !nonEmptyString(requestId))
             return notSent('bad_input', DETAIL_BAD_CALL);
-        if (sessionId === '.' || sessionId === '..')
+        if (!isSessionIdPathSegment(sessionId))
             return notSent('bad_input', DETAIL_BAD_CALL);
         if (allowUnevidenced !== undefined && typeof allowUnevidenced !== 'boolean')
             return notSent('bad_input', DETAIL_BAD_CALL);
@@ -236,6 +237,7 @@ const UNCONFIRMED_TEXT = {
     receipt_unreadable: 'Not confirmed: the engine answered, but its erase receipt could not be read.',
     receipt_mismatch: 'Not confirmed: the engine answered with a receipt for a different erase request.',
     store_link_outside: 'Not confirmed: the memory store contains a link that leads outside it, so the erase stopped before finishing and may have erased part of this memory or none of it; the deployment operator needs to remove the link.',
+    store_home_not_directory: 'Not confirmed: a folder in the memory store that holds this memory has turned into a link or a plain file, so the erase stopped before finishing and may have erased part of this memory or none of it; the deployment operator needs to restore the real folder.',
     control_plane_corrupt: "Not confirmed: the memory store's own records could not be read cleanly, so the erase may have changed nothing or may already be committed; the deployment operator needs to repair them.",
     engine_fault: 'Not confirmed: the engine reported an internal failure during the erase, so it may or may not have happened.',
     unclassified: 'Not confirmed: the engine refused in a way this client does not recognise.',
@@ -280,6 +282,7 @@ function unconfirmedRetry(why, allowUnevidenced) {
         return 'human_decision';
     switch (why) {
         case 'store_link_outside':
+        case 'store_home_not_directory':
         case 'control_plane_corrupt':
             return 'needs_operator';
         case 'receipt_mismatch':
@@ -327,6 +330,8 @@ function bandOfCode(code) {
             return { refused: 'store_unreadable' };
         case 'memory.target_outside_store':
             return { unconfirmed: 'store_link_outside' };
+        case 'memory.scope_home_not_directory':
+            return { unconfirmed: 'store_home_not_directory' };
         case 'internal.memory_control_plane_corrupt':
             return { unconfirmed: 'control_plane_corrupt' };
         case 'internal.error':

package/dist/sessionMemoryStatus.js

@@ -1,3 +1,4 @@
+import { isSessionIdPathSegment } from './sessionIdSegment.js';
 export function classifyMemoryStatusFailure(e) {
     let code;
     let status;
@@ -44,8 +45,8 @@ export function readLastCapture(s) {
     return { state: 'indeterminate' };
 }
 export async function readSessionMemoryStatus(client, sessionId, opts) {
-    if (typeof sessionId !== 'string' || sessionId.length === 0) {
-        return { kind: 'failed', error: new Error('memoryStatus: empty sessionId') };
+    if (!isSessionIdPathSegment(sessionId)) {
+        return { kind: 'failed', error: new Error('memoryStatus: sessionId is not usable as a URL path segment') };
     }
     try {
         const raw = await client.sessions.memoryStatus(sessionId, opts?.signal ? { signal: opts.signal } : {});

package/dist/sessionPolicyCapability.d.ts

@@ -14,5 +14,4 @@ export declare function noteEngineCapsForSessionPolicy(baseUrl: string, caps: un
 export declare function observedSessionPolicy(baseUrl?: string | undefined): SessionPolicyReading;
 export declare function sessionPolicyFaceAvailable(reading: SessionPolicyReading): 'yes' | 'no' | 'unknown';
 export declare function sessionPolicyDoctorDetail(reading: SessionPolicyReading): string;
-export declare function forgetSessionPolicyReading(baseUrl: string | undefined): void;
 export declare function __resetSessionPolicyReadingsForTests(): void;

package/dist/sessionPolicyCapability.js

@@ -1,13 +1,12 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectSessionPolicyCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
         const c = caps;
-        if (!Object.hasOwn(c, 'sessionPolicy'))
-            return { kind: 'not_reported' };
-        const v = c.sessionPolicy;
+        const v = ownDataField(c, 'sessionPolicy');
         if (v === undefined)
             return { kind: 'not_reported' };
         if (typeof v !== 'boolean')
@@ -48,9 +47,6 @@ export function sessionPolicyDoctorDetail(reading) {
             return 'per-session rule face on — this session’s tool rules can be read, and a tightening write is accepted or refused by the engine call by call';
     }
 }
-export function forgetSessionPolicyReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetSessionPolicyReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/sessionReadRedactionCapability.d.ts

@@ -12,5 +12,4 @@ export declare function noteEngineCapsForSessionReadRedaction(baseUrl: string, c
 }): void;
 export declare function observedSessionReadRedaction(baseUrl?: string | undefined): SessionReadRedactionReading;
 export declare function sessionReadRedactionAdmitted(reading: SessionReadRedactionReading | undefined): boolean;
-export declare function forgetSessionReadRedactionReading(baseUrl: string | undefined): void;
 export declare function __resetSessionReadRedactionReadingsForTests(): void;

package/dist/sessionReadRedactionCapability.js

@@ -1,13 +1,11 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
-import { readOwnDataValue } from './ownKey.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
 export function projectSessionReadRedactionCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'sessionReadRedaction'))
-            return { kind: 'not_reported' };
-        const v = caps.sessionReadRedaction;
+        const v = ownDataField(caps, 'sessionReadRedaction');
         if (v === undefined)
             return { kind: 'not_reported' };
         return v === true ? { kind: 'present', value: true } : undefined;
@@ -39,9 +37,6 @@ export function sessionReadRedactionAdmitted(reading) {
         return false;
     }
 }
-export function forgetSessionReadRedactionReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetSessionReadRedactionReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/sessionSyncFileHistoryCapability.d.ts

@@ -14,5 +14,4 @@ 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 forgetSessionSyncFileHistoryReading(baseUrl: string | undefined): void;
 export declare function __resetSessionSyncFileHistoryReadingsForTests(): void;

package/dist/sessionSyncFileHistoryCapability.js

@@ -1,12 +1,11 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectSessionSyncFileHistoryCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'sessionSyncFileHistory'))
-            return { kind: 'not_reported' };
-        const v = caps.sessionSyncFileHistory;
+        const v = ownDataField(caps, 'sessionSyncFileHistory');
         if (v === undefined)
             return { kind: 'not_reported' };
         if (typeof v !== 'boolean')
@@ -47,9 +46,6 @@ export function sessionSyncFileHistoryDoctorDetail(reading) {
             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

@@ -14,5 +14,4 @@ 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 forgetSkillToolListsReading(baseUrl: string | undefined): void;
 export declare function __resetSkillToolListsReadingsForTests(): void;

package/dist/skillToolListsCapability.js

@@ -1,12 +1,11 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectSkillToolListsCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'skillToolLists'))
-            return { kind: 'not_reported' };
-        const v = caps.skillToolLists;
+        const v = ownDataField(caps, 'skillToolLists');
         if (v === undefined)
             return { kind: 'not_reported' };
         if (typeof v !== 'boolean')
@@ -47,9 +46,6 @@ 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 forgetSkillToolListsReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetSkillToolListsReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/skillsWireCaps.d.ts

@@ -1,4 +1,5 @@
 import type { SkillSpec } from '@sema-agent/sdk';
+import { type SkillToolListsReading } from './skillToolListsCapability.js';
 export declare const SKILL_CAPS: {
     readonly content: 1048576;
 };
@@ -10,6 +11,8 @@ export interface SkillCmdLike {
     source?: string;
     disableModelInvocation?: boolean;
     skillRoot?: string;
+    allowedTools?: readonly string[];
+    disallowedTools?: readonly string[];
 }
 export declare function toCappedSpec(name: string, description: string, whenToUse: string, body: string): SkillSpec | null;
 export type SkillSpecOnWire = SkillSpec & {
@@ -18,6 +21,7 @@ export type SkillSpecOnWire = SkillSpec & {
 export interface SkillSpecsOptions {
     toolsRunHere?: boolean;
     platform?: 'posix' | 'win32';
+    skillToolLists?: SkillToolListsReading;
 }
 export declare function skillBaseDirOf(skillRoot: string | undefined, platform?: 'posix' | 'win32'): string | undefined;
 export declare function skillCommandsToSpecs(cmds: SkillCmdLike[], resolveBody: (cmd: SkillCmdLike) => string | null, opts?: SkillSpecsOptions): SkillSpecOnWire[];

package/dist/skillsWireCaps.js

@@ -1,3 +1,4 @@
+import { skillToolListsAvailable } from './skillToolListsCapability.js';
 export const SKILL_CAPS = { content: 1_048_576 };
 export function toCappedSpec(name, description, whenToUse, body) {
     const n = name.trim();
@@ -27,9 +28,64 @@ export function skillBaseDirOf(skillRoot, platform = 'posix') {
         return undefined;
     return skillRoot;
 }
+function readSkillToolList(skillName, key, cmd) {
+    const who = `skillCommandsToSpecs: skill ${JSON.stringify(skillName.slice(0, 80))} ${key}`;
+    const hint = 'The list is the skill’s own tool rule list and is sent exactly as given (entries are never dropped, repaired, reordered or truncated here), ' +
+        'so a value that is not a list of strings is refused instead of being silently reduced.';
+    const unreadable = () => new TypeError(`${who} could not be read — reading it (the property, the array length or an entry) threw. ${hint}`);
+    let v;
+    try {
+        v = cmd[key];
+    }
+    catch {
+        throw unreadable();
+    }
+    if (v === undefined)
+        return undefined;
+    let isArray;
+    try {
+        isArray = Array.isArray(v);
+    }
+    catch {
+        throw unreadable();
+    }
+    if (!isArray) {
+        throw new TypeError(`${who} must be an array of strings or absent — got ${v === null ? 'null' : typeof v === 'object' ? 'a non-array object' : `typeof ${typeof v}`}. ${hint}`);
+    }
+    const list = v;
+    let lengthRead;
+    try {
+        lengthRead = list.length;
+    }
+    catch {
+        throw unreadable();
+    }
+    if (typeof lengthRead !== 'number' || !Number.isSafeInteger(lengthRead) || lengthRead < 0 || lengthRead > 4_294_967_295) {
+        throw new TypeError(`${who} must be an array of strings or absent — its length is not a valid array length. ${hint}`);
+    }
+    const n = lengthRead;
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        let e;
+        try {
+            e = list[i];
+        }
+        catch {
+            throw unreadable();
+        }
+        if (typeof e !== 'string') {
+            throw new TypeError(`${who} must be an array of strings or absent — the entry at index ${i} is ${e === null ? 'null' : `typeof ${typeof e}`}. ${hint}`);
+        }
+        out.push(e);
+    }
+    return out;
+}
 export function skillCommandsToSpecs(cmds, resolveBody, opts) {
     const specs = [];
     const seen = new Set();
+    const reading = opts?.skillToolLists;
+    const wired = reading !== undefined;
+    const toolListsOn = wired && skillToolListsAvailable(reading ?? { kind: 'unobserved' }) === 'yes';
     for (const cmd of cmds) {
         if (cmd.type !== 'prompt' || cmd.disableModelInvocation)
             continue;
@@ -41,7 +97,16 @@ export function skillCommandsToSpecs(cmds, resolveBody, opts) {
             continue;
         seen.add(spec.name);
         const baseDir = opts?.toolsRunHere === true ? skillBaseDirOf(cmd.skillRoot, opts.platform ?? 'posix') : undefined;
-        specs.push(baseDir !== undefined ? { ...spec, baseDir } : spec);
+        const allowedTools = wired ? readSkillToolList(spec.name, 'allowedTools', cmd) : undefined;
+        const disallowedTools = wired ? readSkillToolList(spec.name, 'disallowedTools', cmd) : undefined;
+        let wire = spec;
+        if (baseDir !== undefined)
+            wire = { ...wire, baseDir };
+        if (toolListsOn && allowedTools !== undefined)
+            wire = { ...wire, allowedTools };
+        if (toolListsOn && disallowedTools !== undefined)
+            wire = { ...wire, disallowedTools };
+        specs.push(wire);
     }
     return specs;
 }

package/dist/sqlEngineCapability.d.ts

@@ -19,5 +19,4 @@ export declare function noteEngineCapsForSqlEngine(baseUrl: string, caps: unknow
 }): void;
 export declare function observedSqlEngine(baseUrl?: string | undefined): SqlEngineReading;
 export declare function sqlEngineDoctorDetail(reading: SqlEngineReading): string;
-export declare function forgetSqlEngineReading(baseUrl: string | undefined): void;
 export declare function __resetSqlEngineReadingsForTests(): void;

package/dist/sqlEngineCapability.js

@@ -1,18 +1,17 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { capsGenerationOf, createEngineCapReader } from './engineCapReader.js';
+import { storeSeatOf, createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectSqlEngineCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object')
             return undefined;
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        const gen = capsGenerationOf(caps);
-        if (gen.generation === 'new') {
-            const store = gen.store;
-            if (!Object.hasOwn(store, 'sql'))
-                return { kind: 'none' };
-            const nested = store.sql;
+        const seat = storeSeatOf(caps);
+        if (seat.kind === 'object') {
+            const store = seat.store;
+            const nested = ownDataField(store, 'sql');
             if (nested === undefined)
                 return { kind: 'none' };
             return projectSqlEngineView(nested);
@@ -26,10 +25,9 @@ export function projectSqlEngineCapability(caps) {
 function projectSqlEngineView(sql) {
     if (sql === null || typeof sql !== 'object')
         return undefined;
-    const s = sql;
-    const engine = s.engine;
-    const isolation = s.isolation;
-    const txnMode = s.txnMode;
+    const engine = ownDataField(sql, 'engine');
+    const isolation = ownDataField(sql, 'isolation');
+    const txnMode = ownDataField(sql, 'txnMode');
     if (typeof engine !== 'string' || engine === '')
         return undefined;
     if (typeof isolation !== 'string' || isolation === '')
@@ -73,9 +71,6 @@ export function sqlEngineDoctorDetail(reading) {
         }
     }
 }
-export function forgetSqlEngineReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetSqlEngineReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/steerPriorityCapability.d.ts

@@ -14,5 +14,4 @@ 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 forgetSteerPriorityReading(baseUrl: string | undefined): void;
 export declare function __resetSteerPriorityReadingsForTests(): void;

package/dist/steerPriorityCapability.js

@@ -1,20 +1,17 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectSteerPriorityCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'fleet'))
-            return { kind: 'not_reported' };
-        const fleet = caps.fleet;
+        const fleet = ownDataField(caps, 'fleet');
         if (fleet === undefined || fleet === false)
             return { kind: 'not_reported' };
         if (fleet === null || typeof fleet !== 'object' || Array.isArray(fleet))
             return undefined;
-        if (!Object.hasOwn(fleet, 'steerPriority'))
-            return { kind: 'not_reported' };
-        const v = fleet.steerPriority;
+        const v = ownDataField(fleet, 'steerPriority');
         if (v === undefined)
             return { kind: 'not_reported' };
         if (typeof v !== 'string' || v.length === 0)
@@ -77,9 +74,6 @@ 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 forgetSteerPriorityReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetSteerPriorityReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/storePostureCapability.d.ts

@@ -20,6 +20,6 @@ export declare function noteEngineCapsForStorePosture(baseUrl: string, caps: unk
 }): 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 forgetStorePostureReading(baseUrl: string | undefined): void;
 export declare function __resetStorePostureReadingsForTests(): void;

package/dist/storePostureCapability.js

@@ -1,7 +1,8 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { capsGenerationOf, createEngineCapReader } from './engineCapReader.js';
+import { storeSeatOf, createEngineCapReader } from './engineCapReader.js';
 import { projectSqlEngineCapability } from './sqlEngineCapability.js';
+import { ownDataField } from './ownKey.js';
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
 export function projectStorePostureCapability(caps) {
     try {
@@ -14,19 +15,17 @@ export function projectStorePostureCapability(caps) {
 function projectStorePostureOf(caps) {
     if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
         return undefined;
-    const gen = capsGenerationOf(caps);
-    if (gen.generation === 'old')
-        return gen.store === 'absent' ? { kind: 'not_reported' } : undefined;
-    const store = gen.store;
-    const s = store;
-    const declared = s.declared;
-    const backend = s.backend;
-    const durable = s.durable;
+    const seat = storeSeatOf(caps);
+    if (seat.kind !== 'object')
+        return seat.kind === 'absent' ? { kind: 'not_reported' } : undefined;
+    const store = seat.store;
+    const declared = ownDataField(store, 'declared');
+    const backend = ownDataField(store, 'backend');
+    const durable = ownDataField(store, 'durable');
     if (!nonEmpty(declared) || !nonEmpty(backend) || typeof durable !== 'boolean')
         return undefined;
-    const hasReason = Object.hasOwn(store, 'degradedReason');
-    const reason = hasReason ? s.degradedReason : undefined;
-    if (hasReason && reason !== undefined && !nonEmpty(reason))
+    const reason = ownDataField(store, 'degradedReason');
+    if (reason !== undefined && !nonEmpty(reason))
         return undefined;
     const sqlReading = projectSqlEngineCapability({ store });
     if (sqlReading === undefined)
@@ -84,6 +83,10 @@ export function storePersistence(reading) {
     }
     return durable === true ? 'durable' : durable === false ? 'not_durable' : 'unknown';
 }
+const STORE_NOT_DURABLE_HEAD = 'NOT durable';
+export function storePostureHeadWord(reading) {
+    return storePersistence(reading) === 'not_durable' ? STORE_NOT_DURABLE_HEAD : undefined;
+}
 const WORD_DETAIL_MAX = 40;
 const word = (v) => capForDisplay(v, WORD_DETAIL_MAX);
 export function storePostureDoctorDetail(reading) {
@@ -113,7 +116,7 @@ export function storePostureDoctorDetail(reading) {
     if (durable) {
         return `${assembled} — durable: this replica persists its state, so it survives a restart`;
     }
-    const lost = 'NOT durable: this replica holds its state in memory and loses it on restart';
+    const lost = `${STORE_NOT_DURABLE_HEAD}: this replica holds its state in memory and loses it on restart`;
     if (!nonEmpty(reason))
         return `${assembled} — ${lost}`;
     if (reason === 'db_unreachable') {
@@ -124,9 +127,6 @@ export function storePostureDoctorDetail(reading) {
     }
     return `${assembled} — ${lost} (degraded for a reason this client does not know yet: "${word(reason)}")`;
 }
-export function forgetStorePostureReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetStorePostureReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/streamDrainingLegs.d.ts

@@ -0,0 +1,6 @@
+import { type StreamDrainingDecision } from './wireErrorTriage.js';
+export interface StreamDrainingLegs<F> {
+    see(frame: F): boolean;
+    legEnded(how: 'returned' | 'threw'): StreamDrainingDecision | undefined;
+}
+export declare function createStreamDrainingLegs<F>(): StreamDrainingLegs<F>;

package/dist/streamDrainingLegs.js

@@ -0,0 +1,23 @@
+import { isInStreamDrainingEnd, streamDrainingDecision } from './wireErrorTriage.js';
+export function createStreamDrainingLegs() {
+    let consecutive = 0;
+    let drainEnd;
+    return {
+        see(frame) {
+            if (isInStreamDrainingEnd(frame)) {
+                drainEnd = { frame };
+                return true;
+            }
+            drainEnd = undefined;
+            consecutive = 0;
+            return false;
+        },
+        legEnded(how) {
+            const ended = drainEnd;
+            drainEnd = undefined;
+            if (how !== 'returned' || ended === undefined)
+                return undefined;
+            return streamDrainingDecision(ended.frame, consecutive++);
+        },
+    };
+}

package/dist/subagent/engineCompactWire.js

@@ -1,10 +1,12 @@
 import { hostLog, hostTimersFor } from '../host.js';
+import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { COMPACT_NOT_RUNNING, isUnavailableFaceCode } from '../engineErrorCodes.js';
 import { surfaceCompactNotRunning } from '../hitl/hitlHostSurface.js';
 import { wireFailureShapeOf, wireFailureTextsOf } from '../wireFailureShape.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, settleInjected, } from '../engineWireFor.js';
 import { activeEngineRunIdFor, engineSessionParamFor } from '../engineSessionParam.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
+import { engineCapState, kickEngineCapsProbe } from '../engineCapsCache.js';
 function usableCompactClient(client) {
     return clientHasVerbs(client, [['capabilities'], ['runs', 'compact']]);
 }
@@ -14,43 +16,21 @@ const pendingCompactSinks = new Map();
 export function isEngineCompactPending(sessionKey = DEFAULT_SESSION_KEY) {
     return pendingCompactKeys.has(sessionKey);
 }
-const manualCompactCapableByBase = new Map();
-const capabilitiesProbeByBase = new Map();
 function probeManualCompactCapability(wire) {
     const base = wire.kind === 'injected' ? wire.capsBaseUrl : wire.target.baseUrl;
     if (base === undefined)
         return;
-    if (capabilitiesProbeByBase.has(base))
+    if (wire.kind === 'injected') {
+        const injected = wire.client;
+        kickEngineCapsProbe(base, () => settleInjected(COMPACT_PROBE_SETTLE_MS, undefined, (signal) => injected.capabilities({ signal })));
         return;
-    capabilitiesProbeByBase.set(base, (async () => {
-        try {
-            let caps;
-            if (wire.kind === 'injected') {
-                const injected = wire.client;
-                caps = await settleInjected(COMPACT_PROBE_SETTLE_MS, undefined, (signal) => injected.capabilities({ signal }));
-            }
-            else {
-                const client = wire.make({ timeoutMs: 5000 });
-                if (!client) {
-                    capabilitiesProbeByBase.delete(base);
-                    return;
-                }
-                caps = await client.capabilities();
-            }
-            if (typeof caps.manualCompact === 'boolean')
-                manualCompactCapableByBase.set(base, caps.manualCompact);
-            else
-                capabilitiesProbeByBase.delete(base);
-        }
-        catch {
-            capabilitiesProbeByBase.delete(base);
-        }
-    })());
-}
-export function resetManualCompactCapability() {
-    manualCompactCapableByBase.clear();
-    capabilitiesProbeByBase.clear();
+    }
+    const client = wire.make({ timeoutMs: 5000 });
+    if (!client)
+        return;
+    kickEngineCapsProbe(base, () => client.capabilities());
 }
+export function resetManualCompactCapability() { }
 export function __resetEngineCompactArmForTests() {
     pendingCompactKeys.clear();
     pendingCompactSinks.clear();
@@ -91,12 +71,7 @@ function emitCompactOutcome(sink, outcome) {
     void Promise.resolve().then(() => callSinkIsolated(sink, outcome));
 }
 function callSinkIsolated(sink, outcome) {
-    try {
-        sink(outcome);
-    }
-    catch (e) {
-        hostLog('debug', `engineCompactWire: onSettled sink threw (ignored): ${wireFailureTextsOf(e).log}`);
-    }
+    invokeHostCallbackIsolated('engineCompactWire: onSettled sink', () => sink(outcome));
 }
 function fanOutCompactSinks(sinks) {
     if (sinks === undefined || sinks.length === 0)
@@ -157,7 +132,7 @@ export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY, opts) {
         return 'offline';
     probeManualCompactCapability(wire);
     const capsKey = wire.kind === 'injected' ? wire.capsBaseUrl : wire.target.baseUrl;
-    if (capsKey !== undefined && manualCompactCapableByBase.get(capsKey) === false) {
+    if (engineCapState(capsKey, 'manualCompact') === 'false') {
         hostLog('debug', 'engineCompactWire: engine capabilities report manualCompact:false — verb suppressed (TOC-local runStore-less engine, [488])');
         return 'unsupported';
     }