@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/agentsWireCaps.js

@@ -2,6 +2,10 @@ import { hostEnv } from './hostEnv.js';
 import { makeEngineWireClient } from './engineWireSdk.js';
 import { frozenSet } from './frozenSet.js';
 import { settleWithinDeadline } from './abortableSleep.js';
+import { isEngineRefusedToolName } from './engineRefusedToolName.js';
+import { CORE_PROTOCOL_PREFIXES, CORE_RETIRED_TOOL_CURRENT_NAMES } from './generated/toolNameTables.js';
+import { rosterMountedNames } from './rosterMountedNames.js';
+import { capForDisplay } from './fleetTaskDesc.js';
 export const MAX_TASK_AGENTS = 32;
 export const MAX_AGENT_NAME_CHARS = 64;
 export const MAX_AGENT_TEXT_CHARS = 4_096;
@@ -38,6 +42,82 @@ const SOURCE_RANK = {
 function sourceRank(source) {
     return SOURCE_RANK[source] ?? 5;
 }
+const RETIRED_TABLE_CURRENT_NAMES = frozenSet([...CORE_RETIRED_TOOL_CURRENT_NAMES.values()].filter((v) => typeof v === 'string'));
+function unescapedIndexOf(s, ch, last) {
+    for (let k = 0; k < s.length; k++) {
+        const i = last ? s.length - 1 - k : k;
+        if (s[i] !== ch)
+            continue;
+        let backslashes = 0;
+        for (let j = i - 1; j >= 0 && s[j] === '\\'; j--)
+            backslashes++;
+        if (backslashes % 2 === 0)
+            return i;
+    }
+    return -1;
+}
+function deniedEntryToolName(entry) {
+    if (entry !== entry.trim())
+        return undefined;
+    const open = unescapedIndexOf(entry, '(', false);
+    if (open === -1)
+        return entry;
+    const close = unescapedIndexOf(entry, ')', true);
+    if (close === -1 || close <= open || close !== entry.length - 1)
+        return entry;
+    const name = entry.substring(0, open);
+    return name.length === 0 ? entry : name.trim();
+}
+function toolNameFlawOf(entry, names, list) {
+    if (typeof entry !== 'string' || entry.length === 0 || entry === '*')
+        return undefined;
+    const name = list === 'disallowedTools' ? deniedEntryToolName(entry) : entry.includes('(') ? undefined : entry;
+    if (name === undefined || name.length === 0 || name === '*' || names.has(name))
+        return undefined;
+    const named = name !== entry ? { toolName: name } : {};
+    if (isEngineRefusedToolName(name)) {
+        const current = CORE_RETIRED_TOOL_CURRENT_NAMES.get(name);
+        if (current === undefined)
+            return { kind: 'unprefixed_namespace', ...named };
+        return typeof current === 'string' ? { kind: 'retired', currentName: current, ...named } : { kind: 'retired', ...named };
+    }
+    if (CORE_PROTOCOL_PREFIXES.some((prefix) => name.startsWith(prefix)))
+        return undefined;
+    const folded = name.toLowerCase();
+    for (const n of names)
+        if (n !== name && n.toLowerCase() === folded)
+            return { kind: 'case_twin', currentName: n, ...named };
+    return undefined;
+}
+export function agentToolListFlaws(agents, roster) {
+    if (!Array.isArray(agents) || agents.length === 0)
+        return [];
+    const mounted = rosterMountedNames(roster);
+    const names = typeof mounted === 'object' ? mounted : RETIRED_TABLE_CURRENT_NAMES;
+    const out = [];
+    for (const a of agents) {
+        if (a === null || typeof a !== 'object' || typeof a.name !== 'string')
+            continue;
+        for (const [list, entries] of [['disallowedTools', a.denyTools], ['tools', a.allowTools]]) {
+            if (!Array.isArray(entries))
+                continue;
+            for (const entry of entries) {
+                const f = toolNameFlawOf(entry, names, list);
+                if (f !== undefined)
+                    out.push({ agent: a.name, list, entry: entry, ...f });
+            }
+        }
+    }
+    return out;
+}
+function toolListFlawPhrase(f) {
+    const entry = f.toolName !== undefined ? `${JSON.stringify(f.entry)} names the tool ${JSON.stringify(f.toolName)}, which` : JSON.stringify(f.entry);
+    if (f.kind === 'retired')
+        return `${entry} is a retired tool name${f.currentName !== undefined ? ` (now ${JSON.stringify(f.currentName)})` : ' (no longer available under any name)'}`;
+    if (f.kind === 'unprefixed_namespace')
+        return `${entry} contains "__" but does not start with a tool protocol prefix`;
+    return `${entry} differs from the tool ${JSON.stringify(f.currentName ?? '')} only in letter case`;
+}
 export function projectAgentsForWire(defs, deps) {
     const warnings = [];
     const customs = defs
@@ -51,6 +131,7 @@ export function projectAgentsForWire(defs, deps) {
         warnings.push(`agents wire: ${customs.length} custom agents exceed the engine cap of ${MAX_TASK_AGENTS} — keeping the ${MAX_TASK_AGENTS} highest-precedence definitions, dropped: ${dropped.join(', ')}`);
     }
     const out = [];
+    const toolListFlaws = [];
     const seen = new Set();
     for (const def of capped) {
         const name = def.agentType;
@@ -94,6 +175,35 @@ export function projectAgentsForWire(defs, deps) {
         const denyTools = projectTools(def.disallowedTools, 'disallowedTools');
         if (denyTools)
             item.denyTools = denyTools;
+        const flaws = agentToolListFlaws([item], deps.toolRoster);
+        if (flaws.length > 0) {
+            let source;
+            try {
+                source = deps.agentSourceLabel?.(name);
+            }
+            catch {
+                source = undefined;
+            }
+            const who = `agent "${name}"${typeof source === 'string' && source.length > 0 ? ` (${capForDisplay(source, 120)})` : ''}`;
+            toolListFlaws.push(...flaws);
+            const denyFlaws = flaws.filter(f => f.list === 'disallowedTools');
+            const withhold = denyFlaws.length > 0 && deps.withholdRefusedDenyLists === true;
+            if (denyFlaws.length > 0) {
+                const what = `its disallowedTools ${denyFlaws.length === 1 ? 'entry' : 'entries'} ${denyFlaws.map(toolListFlawPhrase).join('; ')}`;
+                warnings.push(withhold
+                    ? `agents wire: ${who} is not sent to the engine — ${what}, and this engine refuses to start a run whose agent definitions name a tool that way. Fix the entry in the agent definition; until then this agent is not available.`
+                    : `agents wire: ${who}: ${what} — tool names are matched exactly, so ${denyFlaws.length === 1 ? 'this entry hides' : 'these entries hide'} nothing from the agent, and newer engines refuse to start a run with it. Fix the entry in the agent definition.`);
+            }
+            if (!withhold) {
+                for (const f of flaws) {
+                    if (f.list !== 'tools')
+                        continue;
+                    warnings.push(`agents wire: ${who}: its tools entry ${toolListFlawPhrase(f)} — tool names are matched exactly, so this entry does not give the agent that tool. Fix the entry in the agent definition.`);
+                }
+            }
+            if (withhold)
+                continue;
+        }
         if (def.memory !== undefined) {
             if (typeof def.memory === 'string' && AGENT_MEMORY_WORDS.has(def.memory)) {
                 item.memory = { scopes: [`agent:${name}`], writeScope: `agent:${name}` };
@@ -171,7 +281,7 @@ export function projectAgentsForWire(defs, deps) {
         }
         out.push(item);
     }
-    return { agents: out.length > 0 ? out : undefined, warnings };
+    return { agents: out.length > 0 ? out : undefined, warnings, ...(toolListFlaws.length > 0 ? { toolListFlaws } : {}) };
 }
 export async function engineSupportsTaskAgents(baseUrl, opts) {
     if (opts?.client !== undefined) {

package/dist/approvalDecidedByCapability.d.ts

@@ -12,5 +12,4 @@ export declare function noteEngineCapsForApprovalDecidedBy(baseUrl: string, caps
 }): void;
 export declare function observedApprovalDecidedBy(baseUrl?: string | undefined): ApprovalDecidedByReading;
 export declare function approvalDecidedByAdmitted(reading: ApprovalDecidedByReading | undefined): boolean;
-export declare function forgetApprovalDecidedByReading(baseUrl: string | undefined): void;
 export declare function __resetApprovalDecidedByReadingsForTests(): void;

package/dist/approvalDecidedByCapability.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 projectApprovalDecidedByCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'approvalDecidedBy'))
-            return { kind: 'not_reported' };
-        const v = caps.approvalDecidedBy;
+        const v = ownDataField(caps, 'approvalDecidedBy');
         if (v === undefined)
             return { kind: 'not_reported' };
         return v === true ? { kind: 'present', value: true } : undefined;
@@ -39,9 +37,6 @@ export function approvalDecidedByAdmitted(reading) {
         return false;
     }
 }
-export function forgetApprovalDecidedByReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetApprovalDecidedByReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/approvalReachWire.d.ts

@@ -0,0 +1,18 @@
+import { CORE_APPROVAL_REACH } from './generated/engineFactTables.js';
+export type ApprovalReachWord = (typeof CORE_APPROVAL_REACH)[number];
+export declare function refuseBadApprovalReach(v: unknown, who: string): void;
+export type ApprovalReachWithheldCause = 'not_reported' | 'unsupported' | 'unprobed' | 'unreadable';
+export type ApprovalReachDeclaration = {
+    readonly field: {
+        readonly approvalReach: Extract<ApprovalReachWord, 'none'>;
+    };
+    readonly withheld?: undefined;
+} | {
+    readonly field: Readonly<Record<string, never>>;
+    readonly withheld?: {
+        readonly cause: ApprovalReachWithheldCause;
+        readonly text: string;
+    };
+};
+export declare function approvalReachDeclaration(approverReachable: boolean | null | undefined, baseUrl: string | undefined): ApprovalReachDeclaration;
+export declare function approvalReachDeclarationSettled(approverReachable: boolean | null | undefined, baseUrl: string | undefined, withinMs: number): Promise<ApprovalReachDeclaration>;

package/dist/approvalReachWire.js

@@ -0,0 +1,58 @@
+import { CORE_APPROVAL_REACH } from './generated/engineFactTables.js';
+import { engineCapState, engineCapsSettled } from './engineCapsCache.js';
+const KEY = 'approvalReach';
+const APPROVAL_REACH_NONE = 'none';
+const WORDS = new Set(CORE_APPROVAL_REACH);
+const shapeOf = (v) => {
+    try {
+        return v === null ? 'null' : Array.isArray(v) ? 'typeof=object / array' : typeof v === 'string' ? `typeof=string(长 ${v.length})` : `typeof=${typeof v}`;
+    }
+    catch {
+        return `typeof=${typeof v} / unreadable`;
+    }
+};
+export function refuseBadApprovalReach(v, who) {
+    if (v === undefined || v === null)
+        return;
+    if (typeof v === 'string' && WORDS.has(v))
+        return;
+    throw new TypeError(`${who}: approvalReach 只接受引擎闭集里的词(${[...CORE_APPROVAL_REACH].join(' / ')})或缺席(undefined/null)—— 收到 ${shapeOf(v)}。` +
+        '这一位是「这条运行上没有人能答审批」的声明,值只经片段口 approvalReachDeclaration 铸;本层若把坏值折成缺席,这一发会照常发审批卡而声明方不会知道。' +
+        '上游对闭集外的值同样拒收。错误文本只报形状,不回显值。');
+}
+function refuseBadApproverReachable(v, who) {
+    if (v === undefined || v === null || v === true || v === false)
+        return;
+    throw new TypeError(`${who}: approverReachable 只接受布尔或缺席(undefined/null)—— 收到 ${shapeOf(v)}。` +
+        '这一位是「这一车道上有没有能答审批的面」这一事实:false = 没有(片段口据此声明),true / 缺席 = 有或没说(不声明,与今天的行为相同)。错误文本只报形状,不回显值。');
+}
+const WITHHELD_TEXT = Object.freeze({
+    not_reported: 'Approval requests on this run will still be sent to this session: the connected engine does not report that it can be told nobody here can answer them, and an engine that does not know this setting rejects the whole request, so the setting was left out.',
+    unsupported: 'Approval requests on this run will still be sent to this session: the connected engine reports that it cannot be told nobody here can answer them, so the setting was left out.',
+    unprobed: 'Approval requests on this run will still be sent to this session: what the connected engine supports has not been read yet, and an engine that does not know this setting rejects the whole request, so the setting was held back.',
+    unreadable: 'Approval requests on this run will still be sent to this session: the connected engine reported whether it can be told nobody here can answer them in a form this version cannot read, so the setting was left out.',
+});
+const WITHHELD_CAUSE_OF = {
+    absent: 'not_reported',
+    false: 'unsupported',
+    unprobed: 'unprobed',
+    non_boolean: 'unreadable',
+};
+const EMPTY = Object.freeze({ field: Object.freeze({}) });
+export function approvalReachDeclaration(approverReachable, baseUrl) {
+    refuseBadApproverReachable(approverReachable, 'approvalReachDeclaration');
+    if (approverReachable !== false)
+        return EMPTY;
+    const state = engineCapState(baseUrl, KEY);
+    if (state === 'true')
+        return Object.freeze({ field: Object.freeze({ approvalReach: APPROVAL_REACH_NONE }) });
+    const cause = WITHHELD_CAUSE_OF[state];
+    return Object.freeze({ field: Object.freeze({}), withheld: Object.freeze({ cause, text: WITHHELD_TEXT[cause] }) });
+}
+export async function approvalReachDeclarationSettled(approverReachable, baseUrl, withinMs) {
+    refuseBadApproverReachable(approverReachable, 'approvalReachDeclarationSettled');
+    if (approverReachable !== false)
+        return approvalReachDeclaration(approverReachable, baseUrl);
+    await engineCapsSettled(baseUrl, { withinMs: typeof withinMs === 'number' ? withinMs : 0 });
+    return approvalReachDeclaration(approverReachable, baseUrl);
+}

package/dist/approvalsStreamLiveCapability.d.ts

@@ -13,5 +13,4 @@ export declare function noteEngineCapsForApprovalsStreamLive(baseUrl: string, ca
 export declare function observedApprovalsStreamLive(baseUrl?: string | undefined): ApprovalsStreamLiveReading;
 export declare function livePendingNeedsReconcile(reading: ApprovalsStreamLiveReading): boolean;
 export declare function approvalsStreamLiveDoctorDetail(reading: ApprovalsStreamLiveReading): string;
-export declare function forgetApprovalsStreamLiveReading(baseUrl: string | undefined): void;
 export declare function __resetApprovalsStreamLiveReadingsForTests(): void;

package/dist/approvalsStreamLiveCapability.js

@@ -1,18 +1,22 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectApprovalsStreamLiveCapability(caps) {
-    if (caps === null || typeof caps !== 'object')
-        return undefined;
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'approvalsStreamLive'))
-        return { kind: 'not_reported' };
-    const v = caps.approvalsStreamLive;
-    if (v === undefined)
-        return { kind: 'not_reported' };
-    if (typeof v !== 'boolean')
+    try {
+        if (caps === null || typeof caps !== 'object')
+            return undefined;
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const v = ownDataField(caps, 'approvalsStreamLive');
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        if (typeof v !== 'boolean')
+            return undefined;
+        return { kind: 'present', live: v };
+    }
+    catch {
         return undefined;
-    return { kind: 'present', live: v };
+    }
 }
 const reader = createEngineCapReader({
     name: 'approvalsStreamLive',
@@ -40,9 +44,6 @@ export function approvalsStreamLiveDoctorDetail(reading) {
                 : 'live approval push off on this deployment (no checkpoint store or tool approvals disabled; the engine reports one bit for both, so this client cannot tell which) — suspended asks are only visible through the reconcile cadence, so the client polls for them';
     }
 }
-export function forgetApprovalsStreamLiveReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetApprovalsStreamLiveReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/atMostOnce.d.ts

@@ -0,0 +1,8 @@
+export declare function atMostOnceFailureClass(e: unknown): 'rejected' | 'unknown';
+export interface AtMostOnceVerdict {
+    readonly delivery: 'rejected' | 'unknown';
+    readonly status?: number;
+    readonly code?: string;
+    readonly name?: string;
+}
+export declare function atMostOnceVerdictOf(e: unknown): AtMostOnceVerdict;

package/dist/atMostOnce.js

@@ -0,0 +1,36 @@
+import { errCodes, steeringRefusedBeforeEngine, steeringStatusIs4xx } from './controlRouter.js';
+function errorSlot(e, key) {
+    if (e === null || e === undefined)
+        return undefined;
+    try {
+        return e[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+export function atMostOnceFailureClass(e) {
+    const s = atMostOnceSnapshotOf(e);
+    if (steeringStatusIs4xx(s))
+        return 'rejected';
+    return steeringRefusedBeforeEngine(s) !== undefined ? 'rejected' : 'unknown';
+}
+function atMostOnceSnapshotOf(e) {
+    return {
+        status: errorSlot(e, 'status'),
+        statusCode: errorSlot(e, 'statusCode'),
+        errorCode: errorSlot(e, 'errorCode'),
+        name: errorSlot(e, 'name'),
+    };
+}
+export function atMostOnceVerdictOf(e) {
+    const snapshot = atMostOnceSnapshotOf(e);
+    const delivery = atMostOnceFailureClass(snapshot);
+    const { status, code, name } = errCodes(snapshot);
+    return {
+        delivery,
+        ...(status !== undefined ? { status } : {}),
+        ...(code !== undefined && code !== '' ? { code } : {}),
+        ...(name !== undefined && name !== '' ? { name } : {}),
+    };
+}

package/dist/attachmentSeatCapability.d.ts

@@ -7,5 +7,4 @@ export declare function noteEngineCapsForAttachmentSeat(baseUrl: string, caps: u
     generation?: number;
 }): void;
 export declare function observedAttachmentSeat(baseUrl?: string | undefined): AttachmentSeatReading;
-export declare function forgetAttachmentSeatReading(baseUrl: string | undefined): void;
 export declare function __resetAttachmentSeatReadingsForTests(): void;

package/dist/attachmentSeatCapability.js

@@ -19,9 +19,6 @@ export function noteEngineCapsForAttachmentSeat(baseUrl, caps, opts) {
 export function observedAttachmentSeat(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
-export function forgetAttachmentSeatReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetAttachmentSeatReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/attachmentsWireCaps.js

@@ -23,8 +23,14 @@ const OPT_IN_KEYS = [
     'mcpInstructions',
 ];
 const DEFAULT_ON_ONLY_KEYS = ['agentListing', 'skillsListing'];
-const DEFAULT_PAIR = ['backgroundTasks', 'toolsDelta'];
-const _attachmentsKeyPins = [true, true, true, true, true, true];
+const PRODUCT_DEFAULT_KEYS = ['backgroundTasks', 'toolsDelta', 'todoReminder'];
+function productDefaultAttachments() {
+    const out = {};
+    for (const k of PRODUCT_DEFAULT_KEYS)
+        out[k] = true;
+    return out;
+}
+const _attachmentsKeyPins = [true, true, true, true, true, true, true];
 void _attachmentsKeyPins;
 const TODO_REMINDER_MODES = ['baseline', 'off'];
 export class AttachmentsSpecRefused extends TypeError {
@@ -61,11 +67,11 @@ function judgeAttachmentsEnv(raw) {
             return { ok: false, refusal: { kind: 'retired_key', token, why: named.why, entry: i + 1, key: named.key, retired: named } };
     }
     if (tokens.length === 0)
-        return { ok: true, spec: { backgroundTasks: true, toolsDelta: true } };
+        return { ok: true, spec: productDefaultAttachments() };
     if (tokens.length === 1 && (tokens[0] === 'full' || tokens[0] === 'all'))
         return { ok: true, spec: allLiteralTrue() };
     if (tokens.length === 1 && !isKnownToken(tokens[0])) {
-        return { ok: true, spec: { backgroundTasks: true, toolsDelta: true } };
+        return { ok: true, spec: productDefaultAttachments() };
     }
     const spec = {};
     for (const [i, token] of tokens.entries()) {
@@ -74,8 +80,7 @@ function judgeAttachmentsEnv(raw) {
             continue;
         }
         if (token === 'default') {
-            for (const k of DEFAULT_PAIR)
-                spec[k] = true;
+            Object.assign(spec, productDefaultAttachments());
             continue;
         }
         if (token.startsWith('-')) {

package/dist/bashExitReading.d.ts

@@ -0,0 +1,10 @@
+export interface BashFrameExit {
+    readonly exitCode: number | null;
+    readonly note?: string;
+}
+export interface BashExitReading {
+    readonly exitCode: number | null;
+    readonly benignNote: string | undefined;
+}
+export declare function bashExitOf(structured: unknown, parseFrame: () => BashFrameExit | null): BashExitReading;
+export declare function bashExitReadingFailed(r: BashExitReading): boolean;

package/dist/bashExitReading.js

@@ -0,0 +1,12 @@
+export function bashExitOf(structured, parseFrame) {
+    const s = typeof structured === 'object' && structured !== null ? structured : undefined;
+    const interp = typeof s?.returnCodeInterpretation === 'string' && s.returnCodeInterpretation.length > 0 ? s.returnCodeInterpretation : undefined;
+    if (s?.type === 'bash' && typeof s.exitCode === 'number')
+        return { exitCode: s.exitCode, benignNote: interp };
+    const parsed = parseFrame();
+    const note = typeof parsed?.note === 'string' && parsed.note.length > 0 ? parsed.note : undefined;
+    return { exitCode: parsed?.exitCode ?? null, benignNote: interp ?? note };
+}
+export function bashExitReadingFailed(r) {
+    return r.exitCode !== null && r.exitCode !== 0 && r.benignNote === undefined;
+}

package/dist/callerCwdCapability.d.ts

@@ -0,0 +1,15 @@
+export type CallerCwdReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'present';
+    value: boolean;
+};
+export declare function projectCallerCwdCapability(caps: unknown): CallerCwdReading | undefined;
+export declare function noteEngineCapsForCallerCwd(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedCallerCwd(baseUrl?: string | undefined): CallerCwdReading;
+export declare function callerCwdAdmitted(reading: CallerCwdReading | undefined): boolean;
+export declare function __resetCallerCwdReadingsForTests(): void;

package/dist/callerCwdCapability.js

@@ -0,0 +1,42 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
+export function projectCallerCwdCapability(caps) {
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const v = ownDataField(caps, 'callerCwd');
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        return typeof v === 'boolean' ? { kind: 'present', value: v } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const reader = createEngineCapReader({
+    name: 'callerCwd',
+    project: projectCallerCwdCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForCallerCwd(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedCallerCwd(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function callerCwdAdmitted(reading) {
+    try {
+        if (reading === null || reading === undefined || typeof reading !== 'object' || Array.isArray(reading))
+            return false;
+        if (readOwnDataValue(reading, 'kind') !== 'present')
+            return false;
+        return readOwnDataValue(reading, 'value') === true;
+    }
+    catch {
+        return false;
+    }
+}
+export function __resetCallerCwdReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/centerWiringCapability.d.ts

@@ -15,11 +15,10 @@ export interface CenterWiringView {
     usageReport: boolean;
     issuer: string;
     caller?: CenterWiringCallerView;
+    worker?: string;
 }
 export type CenterWiringReading = {
     kind: 'unobserved';
-} | {
-    kind: 'not_reported';
 } | {
     kind: 'none';
 } | {
@@ -34,5 +33,4 @@ export declare function observedCenterWiring(baseUrl?: string | undefined): Cent
 export type CallerQuotaLease = 'enforced' | 'not-enforced' | 'exhausted' | 'unobserved' | 'no-lease' | 'unknown';
 export declare function callerQuotaLease(reading: CenterWiringReading): CallerQuotaLease;
 export declare function centerWiringDoctorDetail(reading: CenterWiringReading): string;
-export declare function forgetCenterWiringReading(baseUrl: string | undefined): void;
 export declare function __resetCenterWiringReadingsForTests(): void;

package/dist/centerWiringCapability.js

@@ -1,12 +1,11 @@
 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';
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
 const isPlainObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 function optionalSeat(o, key) {
-    if (!Object.hasOwn(o, key))
-        return { state: 'absent' };
-    const value = o[key];
+    const value = ownDataField(o, key);
     return value === undefined ? { state: 'absent' } : { state: 'value', value };
 }
 export function projectCenterWiringCapability(caps) {
@@ -20,16 +19,16 @@ export function projectCenterWiringCapability(caps) {
 function projectCenterWiringOf(caps) {
     if (!isPlainObject(caps))
         return undefined;
-    const cw = Object.hasOwn(caps, 'centerWiring') ? caps.centerWiring : undefined;
+    const cw = ownDataField(caps, 'centerWiring');
     if (cw === undefined)
-        return capsGenerationOf(caps).generation === 'new' ? { kind: 'none' } : { kind: 'not_reported' };
+        return { kind: 'none' };
     if (!isPlainObject(cw))
         return undefined;
-    const effectivePull = cw.effectivePull;
-    const revisionRaw = cw.effectiveRevision;
-    const lease = cw.lease;
-    const usageReport = cw.usageReport;
-    const issuer = cw.issuer;
+    const effectivePull = ownDataField(cw, 'effectivePull');
+    const revisionRaw = ownDataField(cw, 'effectiveRevision');
+    const lease = ownDataField(cw, 'lease');
+    const usageReport = ownDataField(cw, 'usageReport');
+    const issuer = ownDataField(cw, 'issuer');
     if (typeof effectivePull !== 'boolean' || typeof usageReport !== 'boolean')
         return undefined;
     if (!nonEmpty(lease) || !nonEmpty(issuer))
@@ -41,8 +40,8 @@ function projectCenterWiringOf(caps) {
     else {
         if (!isPlainObject(revisionRaw))
             return undefined;
-        const version = revisionRaw.version;
-        const updatedAt = revisionRaw.updatedAt;
+        const version = ownDataField(revisionRaw, 'version');
+        const updatedAt = ownDataField(revisionRaw, 'updatedAt');
         if (typeof version !== 'number' || !Number.isFinite(version) || !nonEmpty(updatedAt))
             return undefined;
         effectiveRevision = { version, updatedAt };
@@ -58,7 +57,7 @@ function projectCenterWiringOf(caps) {
     if (callerSeat.state === 'value') {
         if (!isPlainObject(callerSeat.value))
             return undefined;
-        const callerLease = callerSeat.value.lease;
+        const callerLease = ownDataField(callerSeat.value, 'lease');
         if (!nonEmpty(callerLease))
             return undefined;
         const wait = optionalSeat(callerSeat.value, 'retryAfterSec');
@@ -66,6 +65,9 @@ function projectCenterWiringOf(caps) {
             return undefined;
         caller = { lease: callerLease, ...(wait.state === 'value' ? { retryAfterSec: wait.value } : {}) };
     }
+    const workerSeat = optionalSeat(cw, 'worker');
+    if (workerSeat.state === 'value' && !nonEmpty(workerSeat.value))
+        return undefined;
     return {
         kind: 'present',
         view: {
@@ -77,6 +79,7 @@ function projectCenterWiringOf(caps) {
             usageReport,
             issuer,
             ...(caller !== undefined ? { caller } : {}),
+            ...(workerSeat.state === 'value' ? { worker: workerSeat.value } : {}),
         },
     };
 }
@@ -96,7 +99,7 @@ function guarded(reading) {
         return undefined;
     try {
         const kind = reading.kind;
-        if (kind === 'not_reported' || kind === 'unobserved' || kind === 'none')
+        if (kind === 'unobserved' || kind === 'none')
             return { kind };
         if (kind !== 'present')
             return undefined;
@@ -158,9 +161,6 @@ function failModeClause(v) {
 export function centerWiringDoctorDetail(reading) {
     const unobserved = 'center wiring not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this engine is connected to a configuration center is unknown';
     const r = guarded(reading);
-    if (r?.kind === 'not_reported') {
-        return 'center wiring not reported by this engine; this does not say whether the engine is connected to a configuration center';
-    }
     if (r?.kind === 'none') {
         return 'no configuration center on this deployment — the engine runs on its own local configuration; no quota lease or usage reporting goes through a center';
     }
@@ -194,9 +194,6 @@ export function centerWiringDoctorDetail(reading) {
         return unobserved;
     }
 }
-export function forgetCenterWiringReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetCenterWiringReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/classifierStatus.js

@@ -1,4 +1,5 @@
 import { classifierDenyCauseOf } from './autoModeUnavailable.js';
+import { readAskOrigin } from './ownKey.js';
 export const CLASSIFIER_STATUS_STATES = Object.freeze([
     'armed',
     'available',
@@ -8,14 +9,13 @@ const CLASSIFIER_RAN_ORIGINS = new Set(['denial_limit_fallback']);
 function askOriginOf(ask) {
     if (typeof ask !== 'object' || ask === null || Array.isArray(ask))
         return undefined;
-    const top = ask.origin;
-    if (typeof top === 'string' && top.length > 0)
+    const top = readAskOrigin(ask);
+    if (top !== undefined)
         return top;
     const gate = ask.gate;
     if (typeof gate !== 'object' || gate === null || Array.isArray(gate))
         return undefined;
-    const inner = gate.origin;
-    return typeof inner === 'string' && inner.length > 0 ? inner : undefined;
+    return readAskOrigin(gate);
 }
 const NOT_A_ROUND_FAILURE = new Set(['parse_error']);
 export function classifierStatusOf(autoMode, ask) {