@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/engineNoticeCodes.js

@@ -1,5 +1,6 @@
 import { AUTO_MODE_UNAVAILABLE_CAUSES } from './autoModeUnavailable.js';
-import { CORE_ENGINE_NOTICE_CODES, CORE_MCP_INJECTION_DROP_REASONS, CORE_NOTICE_AUDIENCE, } from './generated/engineNoticeTables.js';
+import { displayUntrusted } from './displayUntrusted.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;
 const CATALOG = new Set(ENGINE_NOTICE_CODES);
@@ -520,7 +521,61 @@ function readModelUnreachableOf(notice) {
     if (code === undefined || targetHost === undefined || remedy === undefined || sessionId === undefined)
         return undefined;
     const proxyInUse = nonEmpty(optionalOwnSeat(o, 'proxyInUse'));
-    return { code, targetHost, ...(proxyInUse !== undefined ? { proxyInUse } : {}), remedy, sessionId };
+    const taskId = nonEmpty(optionalOwnSeat(o, 'taskId'));
+    return { code, targetHost, ...(proxyInUse !== undefined ? { proxyInUse } : {}), remedy, sessionId, ...(taskId !== undefined ? { taskId } : {}) };
+}
+const ALLOWED_TOOL_NOT_GRANTED_MAX_ENTRIES = 10_000;
+export function readAllowedToolNotGranted(notice) {
+    return guardedRead(notice, readAllowedToolNotGrantedOf);
+}
+function readAllowedToolNotGrantedOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (ownSeat(n, 'code') !== 'permission.allowed_tool_not_granted')
+        return undefined;
+    const d = ownSeat(n, 'detail');
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const list = ownSeat(o, 'entries');
+    if (!Array.isArray(list))
+        return undefined;
+    const length = list.length;
+    if (length === 0 || length > ALLOWED_TOOL_NOT_GRANTED_MAX_ENTRIES)
+        return undefined;
+    const entries = [];
+    for (let i = 0; i < length; i++) {
+        if (!Object.hasOwn(list, i))
+            return undefined;
+        const item = list[i];
+        if (typeof item !== 'object' || item === null || Array.isArray(item))
+            return undefined;
+        const e = item;
+        const source = nonEmpty(ownSeat(e, 'source'));
+        const reason = nonEmpty(ownSeat(e, 'reason'));
+        const entry = ownSeat(e, 'entry');
+        if (source === undefined || reason === undefined || typeof entry !== 'string')
+            return undefined;
+        const skill = nonEmpty(optionalOwnSeat(e, 'skill'));
+        const which = nonEmpty(optionalOwnSeat(e, 'list'));
+        const verdict = nonEmpty(optionalOwnSeat(e, 'verdict'));
+        const currentName = nonEmpty(optionalOwnSeat(e, 'currentName'));
+        const valueType = nonEmpty(optionalOwnSeat(e, 'valueType'));
+        entries.push(Object.freeze({
+            source,
+            entry,
+            entryShown: displayUntrusted(entry),
+            reason,
+            ...(skill !== undefined ? { skill, skillShown: displayUntrusted(skill) } : {}),
+            ...(which !== undefined ? { list: which } : {}),
+            ...(verdict !== undefined ? { verdict } : {}),
+            ...(currentName !== undefined ? { currentName, currentNameShown: displayUntrusted(currentName) } : {}),
+            ...(valueType !== undefined ? { valueType } : {}),
+        }));
+    }
+    const sessionId = nonEmpty(optionalOwnSeat(o, 'sessionId'));
+    return { entries: Object.freeze(entries), ...(sessionId !== undefined ? { sessionId } : {}) };
 }
 const positiveInt = (v) => (typeof v === 'number' && Number.isInteger(v) && v > 0 ? v : undefined);
 export function readToolTurnIncomplete(notice) {
@@ -557,19 +612,28 @@ function readToolTurnIncompleteOf(notice) {
 export function readUserInputUndrained(notice) {
     return guardedRead(notice, readUserInputUndrainedOf);
 }
+function isUndrainedLane(v) {
+    return typeof v === 'string' && Object.hasOwn(CORE_USER_INPUT_UNDRAINED_FAMILIES, v);
+}
+function undrainedLaneOfCode(code) {
+    for (const lane of Object.keys(CORE_USER_INPUT_UNDRAINED_FAMILIES)) {
+        if (CORE_USER_INPUT_UNDRAINED_FAMILIES[lane].code === code)
+            return lane;
+    }
+    return undefined;
+}
 function readUserInputUndrainedOf(notice) {
     if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
         return undefined;
     const n = notice;
-    const code = ownSeat(n, 'code');
-    const kind = code === 'task.user_steer_undrained' ? 'steer' : code === 'task.user_followup_undrained' ? 'followUp' : undefined;
+    const kind = undrainedLaneOfCode(ownSeat(n, 'code'));
     if (kind === undefined)
         return undefined;
     const d = ownSeat(n, 'detail');
     if (typeof d !== 'object' || d === null || Array.isArray(d))
         return undefined;
     const o = d;
-    const count = positiveInt(ownSeat(o, kind));
+    const count = positiveInt(ownSeat(o, CORE_USER_INPUT_UNDRAINED_FAMILIES[kind].countKey));
     if (count === undefined)
         return undefined;
     const cause = nonEmpty(optionalOwnSeat(o, 'cause'));
@@ -598,6 +662,8 @@ const STEER_UNDRAINED_SENTENCE = Object.freeze({
 });
 const _steerSentencePin = true;
 void _steerSentencePin;
+const _undrainedLanePin = true;
+void _undrainedLanePin;
 const followUpUndrainedSentence = (n) => `${messagesPhrase(n, 'follow-up message')} you queued ${verbBe(n)} not used before the run ended and will not be delivered. ` +
     `Send ${itThem(n)} again if you still need ${itThem(n)}.`;
 const subagentSteerUndrainedSentence = (n) => `${messagesPhrase(n, 'message')} you sent while the run was in progress ${verbBe(n)} not used before a sub-agent's run ended and will not be delivered. ` +
@@ -629,7 +695,7 @@ export function userInputUndrainedNotice(facts) {
     }
     const fromSubagent = typeof child === 'string' && child.length > 0;
     const n = positiveInt(count);
-    if (n === undefined || (kind !== 'steer' && kind !== 'followUp'))
+    if (n === undefined || !isUndrainedLane(kind))
         return undefined;
     if (kind === 'followUp') {
         if (cause === undefined || cause === 'leg_end')
@@ -730,6 +796,7 @@ export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'permission.read_deny_unapplied': readReadDenyUnapplied,
     'context.tool_turn_repaired': readToolTurnRepaired,
     'server.model_unreachable': readModelUnreachable,
+    'permission.allowed_tool_not_granted': readAllowedToolNotGranted,
     'task.tool_turn_incomplete': readToolTurnIncomplete,
     'task.user_steer_undrained': readUserInputUndrained,
     'task.user_followup_undrained': readUserInputUndrained,

package/dist/engineRefusedToolName.d.ts

@@ -0,0 +1 @@
+export declare function isEngineRefusedToolName(name: string): boolean;

package/dist/engineRefusedToolName.js

@@ -0,0 +1,8 @@
+import { CORE_PROTOCOL_PREFIXES, CORE_RETIRED_TOOL_CURRENT_NAMES } from './generated/toolNameTables.js';
+export function isEngineRefusedToolName(name) {
+    if (typeof name !== 'string')
+        return false;
+    if (CORE_RETIRED_TOOL_CURRENT_NAMES.has(name))
+        return true;
+    return name.includes('__') && !CORE_PROTOCOL_PREFIXES.some((prefix) => name.startsWith(prefix));
+}

package/dist/engineWireSdk.js

@@ -1,9 +1,9 @@
 import { AgentClient } from '@sema-agent/sdk';
+import { SETTINGS_IS_LOOPBACK_AUTH_HOST } from './generated/settingsSchemaFns.js';
 import { normalizeWirePrincipal } from './principalWire.js';
 export function isLoopbackWireUrl(url) {
     try {
-        const h = new URL(url).hostname;
-        return h === '127.0.0.1' || h === 'localhost' || h === '::1' || h === '[::1]';
+        return SETTINGS_IS_LOOPBACK_AUTH_HOST(new URL(url).hostname);
     }
     catch {
         return false;

package/dist/executionLaneCapability.d.ts

@@ -1,4 +1,4 @@
-export type ExecutionLaneIsolatedAbsence = 'no_hands' | 'not_reported' | 'unreadable';
+export type ExecutionLaneIsolatedAbsence = 'no_hands' | 'unreadable';
 export interface ExecutionLaneCapabilityView {
     provider: string;
     toolsOnThisHost: boolean;
@@ -19,9 +19,8 @@ export declare function noteEngineCapsForExecutionLane(baseUrl: string, caps: un
     generation?: number;
 }): void;
 export declare function observedExecutionLane(baseUrl?: string | undefined): ExecutionLaneReading;
-export declare function toolsRunHereFromExecutionLane(reading: ExecutionLaneReading, legacyInference: boolean): boolean;
+export declare function toolsRunHereFromExecutionLane(reading: ExecutionLaneReading): boolean;
 export declare function noOsSandboxOnThisHost(reading: ExecutionLaneReading): 'yes' | 'no' | 'unknown';
 export declare function noOsSandboxContent(): string;
 export declare function executionLaneDoctorDetail(reading: ExecutionLaneReading): string;
-export declare function forgetExecutionLaneReading(baseUrl: string | undefined): void;
 export declare function __resetExecutionLaneReadingsForTests(): void;

package/dist/executionLaneCapability.js

@@ -1,23 +1,27 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { capsGenerationOf, createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectExecutionLaneCapability(caps) {
-    if (caps === null || typeof caps !== 'object')
-        return undefined;
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+    try {
+        if (caps === null || typeof caps !== 'object')
+            return undefined;
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const lane = ownDataField(caps, 'executionLane');
+        if (lane === undefined)
+            return { kind: 'not_reported' };
+        return projectExecutionLaneObject(lane);
+    }
+    catch {
         return undefined;
-    if (!Object.hasOwn(caps, 'executionLane'))
-        return { kind: 'not_reported' };
-    const lane = caps.executionLane;
-    if (lane === undefined)
-        return { kind: 'not_reported' };
-    return projectExecutionLaneObject(lane, () => capsGenerationOf(caps).generation === 'new');
+    }
 }
-function projectExecutionLaneObject(lane, newGeneration) {
+function projectExecutionLaneObject(lane) {
     if (lane === null || typeof lane !== 'object' || Array.isArray(lane))
         return undefined;
-    const provider = lane.provider;
-    const toolsOnThisHost = lane.toolsOnThisHost;
+    const provider = ownDataField(lane, 'provider');
+    const toolsOnThisHost = ownDataField(lane, 'toolsOnThisHost');
     if (typeof provider !== 'string' || provider === '')
         return undefined;
     if (typeof toolsOnThisHost !== 'boolean')
@@ -25,26 +29,24 @@ function projectExecutionLaneObject(lane, newGeneration) {
     let isolated;
     let isolatedThrew = false;
     try {
-        isolated = Object.hasOwn(lane, 'isolated') ? lane.isolated : undefined;
+        isolated = ownDataField(lane, 'isolated');
     }
     catch {
         isolatedThrew = true;
     }
     if (!isolatedThrew && typeof isolated === 'boolean')
         return { kind: 'present', view: { provider, toolsOnThisHost, isolated } };
-    const isolatedAbsent = isolatedThrew || isolated !== undefined ? 'unreadable' : !newGeneration() ? 'not_reported' : toolsOnThisHost ? 'unreadable' : 'no_hands';
+    const isolatedAbsent = isolatedThrew || isolated !== undefined ? 'unreadable' : toolsOnThisHost ? 'unreadable' : 'no_hands';
     return { kind: 'present', view: { provider, toolsOnThisHost, isolatedAbsent } };
 }
 export function projectExecutionLaneWiring(wiring) {
     try {
         if (wiring === null || typeof wiring !== 'object' || Array.isArray(wiring))
             return undefined;
-        if (!Object.hasOwn(wiring, 'executionLane'))
-            return { kind: 'not_reported' };
-        const lane = wiring.executionLane;
+        const lane = ownDataField(wiring, 'executionLane');
         if (lane === undefined)
             return { kind: 'not_reported' };
-        return projectExecutionLaneObject(lane, () => true);
+        return projectExecutionLaneObject(lane);
     }
     catch {
         return undefined;
@@ -61,12 +63,13 @@ export function noteEngineCapsForExecutionLane(baseUrl, caps, opts) {
 export function observedExecutionLane(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
-export function toolsRunHereFromExecutionLane(reading, legacyInference) {
-    if (reading.kind === 'present')
-        return reading.view.toolsOnThisHost;
-    if (reading.kind === 'not_reported')
+export function toolsRunHereFromExecutionLane(reading) {
+    try {
+        return reading.kind === 'present' && reading.view.toolsOnThisHost === true;
+    }
+    catch {
         return false;
-    return legacyInference;
+    }
 }
 export function noOsSandboxOnThisHost(reading) {
     if (typeof reading !== 'object' || reading === null)
@@ -100,7 +103,7 @@ export function executionLaneDoctorDetail(reading) {
                 '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 ('execution lane not reported by this engine; ' +
-                'this does not say where tools run, so the client keeps inferring it the way it did before');
+                'this does not say where tools run, so skill baseDir is not sent until the engine reports it');
         case 'present': {
             const lane = capForDisplay(reading.view.provider, LANE_DETAIL_MAX);
             if (reading.view.toolsOnThisHost) {
@@ -113,9 +116,6 @@ export function executionLaneDoctorDetail(reading) {
         }
     }
 }
-export function forgetExecutionLaneReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetExecutionLaneReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/fileHistoryCaptureCapability.d.ts

@@ -17,5 +17,4 @@ export declare function fileHistoryDeclarationField(reading: FileHistoryCaptureR
     fileHistory: 'disabled';
 } | Record<string, never>;
 export declare function fileHistoryCaptureDoctorDetail(reading: FileHistoryCaptureReading): string;
-export declare function forgetFileHistoryCaptureReading(baseUrl: string | undefined): void;
 export declare function __resetFileHistoryCaptureReadingsForTests(): void;

package/dist/fileHistoryCaptureCapability.js

@@ -1,18 +1,22 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 import { FILE_HISTORY_DISABLED } from './request/taskRequest.js';
 export function projectFileHistoryCaptureCapability(caps) {
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'fileHistoryCapture'))
-        return { kind: 'not_reported' };
-    const v = caps.fileHistoryCapture;
-    if (v === undefined)
-        return { kind: 'not_reported' };
-    if (typeof v !== 'string' || v.length === 0)
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const v = ownDataField(caps, 'fileHistoryCapture');
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        if (typeof v !== 'string' || v.length === 0)
+            return undefined;
+        return { kind: 'present', word: v };
+    }
+    catch {
         return undefined;
-    return { kind: 'present', word: v };
+    }
 }
 const reader = createEngineCapReader({
     name: 'fileHistoryCapture',
@@ -79,9 +83,6 @@ export function fileHistoryCaptureDoctorDetail(reading) {
             return unobserved;
     }
 }
-export function forgetFileHistoryCaptureReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetFileHistoryCaptureReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/fileHistoryLegNotice.d.ts

@@ -4,7 +4,7 @@ export type FileHistoryDeclarationFact = 'sent' | 'not_sent' | 'unknown';
 export declare const FILE_HISTORY_LEG_VERDICTS: readonly ["not_honored", "honored", "not_declared", "unknown"];
 export type FileHistoryLegNoticeVerdict = (typeof FILE_HISTORY_LEG_VERDICTS)[number];
 export interface FileHistoryLegNoticeInput {
-    readonly capability: FileHistoryCaptureReading;
+    readonly assemblyCapability: FileHistoryCaptureReading;
     readonly declaration: FileHistoryDeclarationFact;
     readonly captureOffByUser: boolean;
     readonly legWord: string | undefined;
@@ -12,9 +12,21 @@ export interface FileHistoryLegNoticeInput {
 export declare function fileHistoryLegNoticeVerdict(input: FileHistoryLegNoticeInput): FileHistoryLegNoticeVerdict;
 export declare function fileHistoryLegNoticeSentence(verdict: FileHistoryLegNoticeVerdict): string | null;
 export declare function fileHistoryDeclarationOfBody(body: object | null | undefined): FileHistoryDeclarationFact;
+export type OutboundBodyField = {
+    kind: 'absent';
+} | {
+    kind: 'value';
+    value: unknown;
+} | {
+    kind: 'unprovable';
+};
+export declare function readOutboundBodyField(body: object | null | undefined, key: string): OutboundBodyField;
 export interface FileHistoryDeclarationLedger {
-    declared(requestKey: string, fact: FileHistoryDeclarationFact): boolean;
+    declared(requestKey: string, fact: FileHistoryDeclarationFact, capabilityAtAssembly?: FileHistoryCaptureReading): boolean;
     boundToRun(requestKey: string, runId: string, event: AgentEvent): boolean;
     declarationOf(runId: string): FileHistoryDeclarationFact;
+    declaredLegCwd(requestKey: string, cwd: string | undefined): boolean;
+    legCwdOf(runId: string): string | undefined;
+    capabilityAtAssemblyOf(runId: string): FileHistoryCaptureReading;
 }
 export declare function createFileHistoryDeclarationLedger(): FileHistoryDeclarationLedger;

package/dist/fileHistoryLegNotice.js

@@ -16,7 +16,7 @@ export function fileHistoryLegNoticeVerdict(input) {
     let offByUser;
     let legWord;
     try {
-        capability = ownRead(input, 'capability');
+        capability = ownRead(input, 'assemblyCapability');
         declaration = declarationOfInput(ownRead(input, 'declaration'));
         offByUser = ownRead(input, 'captureOffByUser') === true;
         legWord = ownRead(input, 'legWord');
@@ -42,50 +42,136 @@ export function fileHistoryLegNoticeSentence(verdict) {
     return null;
 }
 export function fileHistoryDeclarationOfBody(body) {
-    if (typeof body !== 'object' || body === null)
+    const r = readOutboundBodyField(body, 'fileHistory');
+    if (r.kind === 'unprovable')
         return 'unknown';
+    if (r.kind === 'absent')
+        return 'not_sent';
+    return r.value === FILE_HISTORY_DISABLED ? 'sent' : 'not_sent';
+}
+export function readOutboundBodyField(body, key) {
+    const UNPROVABLE = { kind: 'unprovable' };
+    if (typeof body !== 'object' || body === null)
+        return UNPROVABLE;
     try {
         if (Array.isArray(body))
-            return 'unknown';
+            return UNPROVABLE;
         if (typeof body.toJSON === 'function')
-            return 'unknown';
-        const d = Object.getOwnPropertyDescriptor(body, 'fileHistory');
+            return UNPROVABLE;
+        const d = Object.getOwnPropertyDescriptor(body, key);
         const all = Object.getOwnPropertyDescriptors(body);
         for (const k of Reflect.ownKeys(all)) {
             const x = all[k];
             if (x !== undefined && x.enumerable === true && !Object.hasOwn(x, 'value'))
-                return 'unknown';
+                return UNPROVABLE;
         }
-        const listed = Object.hasOwn(all, 'fileHistory') ? all.fileHistory : undefined;
+        const listed = Object.hasOwn(all, key) ? all[key] : undefined;
         const listedOn = listed !== undefined && listed.enumerable === true;
         if (d === undefined || d.enumerable !== true)
-            return listedOn ? 'unknown' : 'not_sent';
+            return listedOn ? UNPROVABLE : { kind: 'absent' };
         if (!Object.hasOwn(d, 'value') || !listedOn || !Object.hasOwn(listed, 'value') || !Object.is(listed.value, d.value))
-            return 'unknown';
-        if (!Object.is(body.fileHistory, d.value))
-            return 'unknown';
+            return UNPROVABLE;
+        if (!Object.is(body[key], d.value))
+            return UNPROVABLE;
         if (typeof d.value === 'object' && d.value !== null)
-            return 'unknown';
-        return d.value === FILE_HISTORY_DISABLED ? 'sent' : 'not_sent';
+            return UNPROVABLE;
+        return { kind: 'value', value: d.value };
     }
     catch {
-        return 'unknown';
+        return UNPROVABLE;
     }
 }
 const idOk = (v) => typeof v === 'string' && v.length > 0;
+function canonReading(r) {
+    try {
+        if (typeof r !== 'object' || r === null)
+            return 'unobserved';
+        const kind = r.kind;
+        if (kind === 'not_reported')
+            return 'not_reported';
+        if (kind === 'present') {
+            const word = r.word;
+            return typeof word === 'string' && word.length > 0 ? `present:${word}` : 'unobserved';
+        }
+        return 'unobserved';
+    }
+    catch {
+        return 'unobserved';
+    }
+}
+function readingOfCanon(c) {
+    if (c === 'not_reported')
+        return { kind: 'not_reported' };
+    if (c.startsWith('present:'))
+        return { kind: 'present', word: c.slice('present:'.length) };
+    return { kind: 'unobserved' };
+}
 export function createFileHistoryDeclarationLedger() {
     const factsByKey = new Map();
+    const cwdsByKey = new Map();
     const keysByRun = new Map();
+    const readingsByKey = new Map();
     return Object.freeze({
-        declared(requestKey, fact) {
+        declaredLegCwd(requestKey, cwd) {
+            if (!idOk(requestKey) || !idOk(cwd))
+                return false;
+            let set = cwdsByKey.get(requestKey);
+            if (set === undefined)
+                cwdsByKey.set(requestKey, (set = new Set()));
+            set.add(cwd);
+            return true;
+        },
+        legCwdOf(runId) {
+            if (!idOk(runId))
+                return undefined;
+            const keys = keysByRun.get(runId);
+            if (keys === undefined)
+                return undefined;
+            let agreed;
+            for (const k of keys) {
+                const cwds = cwdsByKey.get(k);
+                if (cwds === undefined || cwds.size !== 1)
+                    return undefined;
+                const [only] = cwds;
+                if (only === undefined || (agreed !== undefined && agreed !== only))
+                    return undefined;
+                agreed = only;
+            }
+            return agreed;
+        },
+        declared(requestKey, fact, capabilityAtAssembly) {
             if (!idOk(requestKey) || (fact !== 'sent' && fact !== 'not_sent'))
                 return false;
             let set = factsByKey.get(requestKey);
             if (set === undefined)
                 factsByKey.set(requestKey, (set = new Set()));
             set.add(fact);
+            if (capabilityAtAssembly !== undefined) {
+                let rs = readingsByKey.get(requestKey);
+                if (rs === undefined)
+                    readingsByKey.set(requestKey, (rs = new Set()));
+                rs.add(canonReading(capabilityAtAssembly));
+            }
             return true;
         },
+        capabilityAtAssemblyOf(runId) {
+            if (!idOk(runId))
+                return { kind: 'unobserved' };
+            const keys = keysByRun.get(runId);
+            if (keys === undefined)
+                return { kind: 'unobserved' };
+            let agreed;
+            for (const k of keys) {
+                const rs = readingsByKey.get(k);
+                if (rs === undefined || rs.size !== 1)
+                    return { kind: 'unobserved' };
+                const [only] = rs;
+                if (only === undefined || (agreed !== undefined && agreed !== only))
+                    return { kind: 'unobserved' };
+                agreed = only;
+            }
+            return agreed === undefined ? { kind: 'unobserved' } : readingOfCanon(agreed);
+        },
         boundToRun(requestKey, runId, event) {
             if (!idOk(requestKey) || !idOk(runId) || !frameProvesDelivery(event))
                 return false;

package/dist/fleet/fleetLedger.d.ts

@@ -18,6 +18,8 @@ export declare function readEngineActiveBgTasks(): EngineActiveBgReading;
 export declare function readEngineActiveBgTasksFor(sessionKey: string): EngineActiveBgReading;
 export declare function clearAllRetainedFleetRows(): void;
 export declare function clearAllRetainedFleetRowsFor(sessionKey: string): void;
+export declare function forgetSettledTerminalRow(id: string): boolean;
+export declare function forgetSettledTerminalRowFor(sessionKey: string, id: string): boolean;
 export declare function __resetFleetLedgerRegistryForTests(): void;
 export declare function fleetStreamOptions(): {
     session?: string;