@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/engineNoticeCodes.js

@@ -1,5 +1,6 @@
 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;
@@ -8,13 +9,13 @@ function audienceRow(table, code) {
     return Object.hasOwn(table, code) ? table[code] : undefined;
 }
 export function engineNoticeInCatalog(code) {
-    return typeof code === 'string' && CATALOG.has(code);
+    return typeof code === 'string' && (CATALOG.has(code) || CATALOG.has(currentEngineWord(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) ?? 'operator';
+    return audienceRow(ENGINE_NOTICE_AUDIENCE, code) ?? audienceRow(ENGINE_NOTICE_AUDIENCE, currentEngineWord(code)) ?? 'operator';
 }
 export const MCP_INJECTION_DROP_REASONS = CORE_MCP_INJECTION_DROP_REASONS;
 const DROP_REASONS = new Set(MCP_INJECTION_DROP_REASONS);
@@ -602,12 +603,21 @@ function readToolTurnIncompleteOf(notice) {
     const o = d;
     const cause = nonEmpty(ownSeat(o, 'cause'));
     const count = positiveInt(ownSeat(o, 'count'));
+    const outcome = optionalNonEmpty(o, 'outcome');
     const toolCallIds = optionalNameList(o, 'toolCallIds');
     const sessionId = nonEmpty(ownSeat(o, 'sessionId'));
     const runId = nonEmpty(ownSeat(o, 'runId'));
     if (cause === undefined || count === undefined || sessionId === undefined || runId === undefined)
         return undefined;
-    return { cause, count, ...(toolCallIds !== undefined ? { toolCallIds } : {}), sessionId, runId };
+    return { cause, count, ...(outcome !== undefined ? { outcome } : {}), ...(toolCallIds !== undefined ? { toolCallIds } : {}), sessionId, runId };
+}
+function optionalNonEmpty(o, key) {
+    try {
+        return nonEmpty(ownSeat(o, key));
+    }
+    catch {
+        return undefined;
+    }
 }
 export function readUserInputUndrained(notice) {
     return guardedRead(notice, readUserInputUndrainedOf);
@@ -779,6 +789,48 @@ export function steerCutVerdict(notice, messageId) {
         return 'unattributed';
     return facts.inputId === messageId ? 'this_input' : 'other_input';
 }
+export function readFinishReasonUnknown(notice) {
+    return guardedRead(notice, readFinishReasonUnknownOf);
+}
+function readFinishReasonUnknownOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (ownSeat(n, 'code') !== 'route.finish_reason_unknown')
+        return undefined;
+    const d = ownSeat(n, 'detail');
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const finishReason = nonEmpty(ownSeat(o, 'finishReason'));
+    const sessionId = nonEmpty(ownSeat(o, 'sessionId'));
+    const runId = nonEmpty(ownSeat(o, 'runId'));
+    if (finishReason === undefined || sessionId === undefined || runId === undefined)
+        return undefined;
+    return { finishReason, sessionId, runId };
+}
+export function readStreamEndIgnored(notice) {
+    return guardedRead(notice, readStreamEndIgnoredOf);
+}
+function readStreamEndIgnoredOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (ownSeat(n, 'code') !== 'route.stream_end_ignored')
+        return undefined;
+    const d = ownSeat(n, 'detail');
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const statement = nonEmpty(ownSeat(o, 'statement'));
+    const word = nonEmpty(ownSeat(o, 'word'));
+    const frames = positiveInt(ownSeat(o, 'frames'));
+    const sessionId = nonEmpty(ownSeat(o, 'sessionId'));
+    const runId = nonEmpty(ownSeat(o, 'runId'));
+    if (statement === undefined || word === undefined || frames === undefined || sessionId === undefined || runId === undefined)
+        return undefined;
+    return { statement, word, frames, sessionId, runId };
+}
 export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'mcp.injection_dropped': readMcpInjectionDrop,
     'delegation.ask_unresolvable': readAskUnresolvable,
@@ -801,6 +853,8 @@ export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'task.user_steer_undrained': readUserInputUndrained,
     'task.user_followup_undrained': readUserInputUndrained,
     'task.turn_interrupted': readTurnInterrupted,
+    'route.finish_reason_unknown': readFinishReasonUnknown,
+    'route.stream_end_ignored': readStreamEndIgnored,
 });
 const _factReaderTablePin = true;
 void _factReaderTablePin;

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/engineWordRenames.d.ts

@@ -0,0 +1,8 @@
+export declare const PRIOR_ENGINE_WORD_RENAMES: Readonly<{
+    readonly write_protection_unresolved: "target_unresolved";
+}>;
+export declare const PRIOR_ENGINE_NOTICE_CODE_RENAMES: Readonly<{
+    readonly 'config.write_protection_unresolved': "config.path_view_unresolved";
+}>;
+export type PriorEngineWord = keyof typeof PRIOR_ENGINE_WORD_RENAMES;
+export declare function currentEngineWord(word: string): string;

package/dist/engineWordRenames.js

@@ -0,0 +1,13 @@
+export const PRIOR_ENGINE_WORD_RENAMES = Object.freeze({
+    write_protection_unresolved: 'target_unresolved',
+});
+export const PRIOR_ENGINE_NOTICE_CODE_RENAMES = Object.freeze({
+    'config.write_protection_unresolved': 'config.path_view_unresolved',
+});
+export function currentEngineWord(word) {
+    if (Object.hasOwn(PRIOR_ENGINE_WORD_RENAMES, word))
+        return PRIOR_ENGINE_WORD_RENAMES[word];
+    if (Object.hasOwn(PRIOR_ENGINE_NOTICE_CODE_RENAMES, word))
+        return PRIOR_ENGINE_NOTICE_CODE_RENAMES[word];
+    return word;
+}

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,28 +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) {
     try {
         if (caps === null || typeof caps !== 'object')
             return undefined;
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'executionLane'))
-            return { kind: 'not_reported' };
-        const lane = caps.executionLane;
+        const lane = ownDataField(caps, 'executionLane');
         if (lane === undefined)
             return { kind: 'not_reported' };
-        return projectExecutionLaneObject(lane, () => capsGenerationOf(caps).generation === 'new');
+        return projectExecutionLaneObject(lane);
     }
     catch {
         return undefined;
     }
 }
-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')
@@ -30,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;
@@ -66,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)
@@ -105,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) {
@@ -118,9 +116,6 @@ export function executionLaneDoctorDetail(reading) {
         }
     }
 }
-export function forgetExecutionLaneReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetExecutionLaneReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/fileHistoryCaptureCapability.d.ts

@@ -16,6 +16,19 @@ export declare function fileHistoryCaptureMode(reading: FileHistoryCaptureReadin
 export declare function fileHistoryDeclarationField(reading: FileHistoryCaptureReading, captureOff: boolean): {
     fileHistory: 'disabled';
 } | Record<string, never>;
+export declare const FILE_HISTORY_TIGHTEN_VERDICTS: readonly ["not_requested", "declare", "already_off", "unjudged"];
+export type FileHistoryTightenVerdict = (typeof FILE_HISTORY_TIGHTEN_VERDICTS)[number];
+export declare function fileHistoryTightenVerdict(reading: FileHistoryCaptureReading, captureOffByUser: boolean): FileHistoryTightenVerdict;
+export declare function fileHistoryUnjudgedRefusal(reading: FileHistoryCaptureReading, captureOffByUser: boolean): string | undefined;
+export interface FileHistoryTightenJudgement {
+    readonly verdict: FileHistoryTightenVerdict;
+    readonly reading: FileHistoryCaptureReading;
+    readonly refreshed: boolean;
+    readonly refusal: string | undefined;
+}
+export declare function judgeFileHistoryTighten(captureOffByUser: boolean, opts?: {
+    baseUrl?: string;
+    withinMs?: number;
+}): Promise<FileHistoryTightenJudgement>;
 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,14 +1,14 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { refreshEngineCapsOnce } from './engineCapsCache.js';
+import { ownDataField } from './ownKey.js';
 import { FILE_HISTORY_DISABLED } from './request/taskRequest.js';
 export function projectFileHistoryCaptureCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'fileHistoryCapture'))
-            return { kind: 'not_reported' };
-        const v = caps.fileHistoryCapture;
+        const v = ownDataField(caps, 'fileHistoryCapture');
         if (v === undefined)
             return { kind: 'not_reported' };
         if (typeof v !== 'string' || v.length === 0)
@@ -53,6 +53,75 @@ export function fileHistoryCaptureMode(reading) {
 export function fileHistoryDeclarationField(reading, captureOff) {
     return captureOff === true && fileHistoryCaptureMode(reading) === 'on-optional' ? { fileHistory: FILE_HISTORY_DISABLED } : {};
 }
+export const FILE_HISTORY_TIGHTEN_VERDICTS = Object.freeze(['not_requested', 'declare', 'already_off', 'unjudged']);
+export function fileHistoryTightenVerdict(reading, captureOffByUser) {
+    if (captureOffByUser !== true)
+        return 'not_requested';
+    const mode = fileHistoryCaptureMode(reading);
+    if (mode === 'on-optional')
+        return 'declare';
+    if (mode === 'off')
+        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.';
+export function fileHistoryUnjudgedRefusal(reading, captureOffByUser) {
+    return fileHistoryTightenVerdict(reading, captureOffByUser) === 'unjudged' ? FILE_HISTORY_UNJUDGED_REFUSAL : undefined;
+}
+const FILE_HISTORY_REFRESH_WITHIN_MS = 3000;
+export async function judgeFileHistoryTighten(captureOffByUser, opts) {
+    const closed = captureOffByUser === true;
+    const failClosed = () => {
+        const reading = { kind: 'unobserved' };
+        return closed
+            ? { verdict: 'unjudged', reading, refreshed: false, refusal: FILE_HISTORY_UNJUDGED_REFUSAL }
+            : { verdict: 'not_requested', reading, refreshed: false, refusal: undefined };
+    };
+    try {
+        let explicitBase;
+        let withinMs = FILE_HISTORY_REFRESH_WITHIN_MS;
+        if (typeof opts === 'object' && opts !== null) {
+            try {
+                const b = opts.baseUrl;
+                if (b !== undefined) {
+                    if (typeof b !== 'string' || b === '')
+                        return failClosed();
+                    explicitBase = b;
+                }
+            }
+            catch {
+                return failClosed();
+            }
+            try {
+                const w = opts.withinMs;
+                if (w !== undefined)
+                    withinMs = typeof w === 'number' ? w : 0;
+            }
+            catch {
+                withinMs = 0;
+            }
+        }
+        const baseUrl = explicitBase ?? engineWireTarget()?.baseUrl;
+        const first = observedFileHistoryCapture(baseUrl);
+        const v1 = fileHistoryTightenVerdict(first, captureOffByUser);
+        if (v1 !== 'unjudged')
+            return { verdict: v1, reading: first, refreshed: false, refusal: undefined };
+        const outcome = await refreshEngineCapsOnce(baseUrl, { withinMs });
+        const second = observedFileHistoryCapture(baseUrl);
+        const v2 = fileHistoryTightenVerdict(second, captureOffByUser);
+        return {
+            verdict: v2,
+            reading: second,
+            refreshed: outcome !== 'no_probe',
+            refusal: v2 === 'unjudged' ? FILE_HISTORY_UNJUDGED_REFUSAL : undefined,
+        };
+    }
+    catch {
+        return failClosed();
+    }
+}
 const WORD_DETAIL_MAX = 40;
 export function fileHistoryCaptureDoctorDetail(reading) {
     const unobserved = 'file history capture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment captures file history is unknown';
@@ -84,9 +153,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;
@@ -22,10 +22,11 @@ export type OutboundBodyField = {
 };
 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');
@@ -82,10 +82,35 @@ export function readOutboundBodyField(body, key) {
     }
 }
 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({
         declaredLegCwd(requestKey, cwd) {
             if (!idOk(requestKey) || !idOk(cwd))
@@ -114,15 +139,39 @@ export function createFileHistoryDeclarationLedger() {
             }
             return agreed;
         },
-        declared(requestKey, fact) {
+        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/bgSubagentRow.d.ts

@@ -0,0 +1,15 @@
+import type { FleetTaskRow } from '@sema-agent/sdk';
+export declare const DURABLE_AGENT_HANDLE_RE: RegExp;
+export declare function isAgentHandle(rowId: string): boolean;
+export type NonAgentHandleKind = 'background_bash' | 'monitor';
+export declare function nonAgentHandleKind(rowId: string): NonAgentHandleKind | null;
+export type BgSubagentRowFacts = Pick<FleetTaskRow, 'id' | 'parentId' | 'sourceLane'>;
+export declare function isBackgroundSubagentRow(row: BgSubagentRowFacts): boolean;
+export declare function isBackgroundWorkRow(row: BgSubagentRowFacts): boolean;
+export interface BgRowOwnership {
+    readonly scoped: boolean;
+    readonly isOwnRun: (taskIdTail: string) => boolean;
+}
+export declare function liveBgRowOwnership(): BgRowOwnership;
+export declare function liveBgRowOwnershipFor(sessionKey: string): BgRowOwnership;
+export declare function isOwnBackgroundSubagentRow(row: BgSubagentRowFacts, own: BgRowOwnership): boolean;

package/dist/fleet/bgSubagentRow.js

@@ -0,0 +1,67 @@
+import { CORE_DURABLE_AGENT_HANDLE_RE, CORE_TASK_HANDLE_PREFIXES } from '../generated/engineFactTables.js';
+import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
+import { isOwnEngineRun } from '../subagentContentStore.js';
+import { isWorkflowAgentTaskId, rowIdTail } from '../workflow.js';
+import { isFleetSessionScopedFor } from './fleetLedger.js';
+import { wireParentId } from './fleetProjection.js';
+const _taskTypePins = [true, true];
+void _taskTypePins;
+export const DURABLE_AGENT_HANDLE_RE = CORE_DURABLE_AGENT_HANDLE_RE;
+export function isAgentHandle(rowId) {
+    if (typeof rowId !== 'string' || rowId.length === 0)
+        return false;
+    if (rowIdTail(rowId) !== rowId)
+        return false;
+    return DURABLE_AGENT_HANDLE_RE.test(rowId) || isWorkflowAgentTaskId(rowId);
+}
+const NON_AGENT_HANDLE_TYPES = ['background_bash', 'monitor'];
+export function nonAgentHandleKind(rowId) {
+    if (typeof rowId !== 'string')
+        return null;
+    const prefix = /^([a-z])[0-9a-f]{16}$/.exec(rowIdTail(rowId))?.[1];
+    if (prefix === undefined)
+        return null;
+    for (const type of NON_AGENT_HANDLE_TYPES)
+        if (CORE_TASK_HANDLE_PREFIXES[type] === prefix)
+            return type;
+    return null;
+}
+const RUN_LEG_LANE = 'run-leg';
+function isForegroundDelegationRow(row) {
+    return rowIdTail(row.id) !== row.id || row.sourceLane === RUN_LEG_LANE;
+}
+function hasRowId(row) {
+    return typeof row?.id === 'string' && row.id.length > 0;
+}
+export function isBackgroundSubagentRow(row) {
+    if (!hasRowId(row))
+        return false;
+    if (isForegroundDelegationRow(row))
+        return false;
+    if (nonAgentHandleKind(row.id) !== null)
+        return false;
+    if (wireParentId(row) !== undefined)
+        return true;
+    return isAgentHandle(row.id);
+}
+export function isBackgroundWorkRow(row) {
+    if (isBackgroundSubagentRow(row))
+        return true;
+    if (!hasRowId(row))
+        return false;
+    return !isForegroundDelegationRow(row) && nonAgentHandleKind(row.id) !== null;
+}
+export function liveBgRowOwnership() {
+    return liveBgRowOwnershipFor(DEFAULT_SESSION_KEY);
+}
+export function liveBgRowOwnershipFor(sessionKey) {
+    return { scoped: isFleetSessionScopedFor(sessionKey), isOwnRun: isOwnEngineRun };
+}
+export function isOwnBackgroundSubagentRow(row, own) {
+    if (!isBackgroundSubagentRow(row))
+        return false;
+    if (own.scoped)
+        return true;
+    const parentId = wireParentId(row);
+    return own.isOwnRun(rowIdTail(row.id)) || (parentId !== undefined && own.isOwnRun(rowIdTail(parentId)));
+}

package/dist/fleet/fleetLedger.d.ts

@@ -6,6 +6,7 @@ export interface EngineActiveBgTask {
     name?: string;
     status: string;
     parentId?: string;
+    sourceLane?: string;
     retiredByNotification?: boolean;
 }
 export interface EngineActiveBgReading {
@@ -18,6 +19,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;