@sema-agent/client-core 0.100.0 → 0.102.0

package/dist/engineNoticeCodes.d.ts

@@ -1,3 +1,4 @@
+import type { FinishReasonUnknownDetail } from '@sema-agent/sdk';
 import { CORE_TOOL_TURN_INCOMPLETE_CAUSES, CORE_USER_INPUT_UNDRAINED_CAUSES, CORE_USER_INPUT_UNDRAINED_FAMILIES } from './generated/engineNoticeTables.js';
 export type NoticeAudience = 'user' | 'operator';
 export declare const ENGINE_NOTICE_CODES: readonly string[];
@@ -202,11 +203,7 @@ export declare function readTurnInterrupted(notice: unknown): TurnInterruptedFac
 export declare function turnInterruptedNotice(facts: Pick<TurnInterruptedFactsView, 'lane'>): string | undefined;
 export type SteerCutVerdict = 'this_input' | 'other_input' | 'user_halt' | 'unattributed' | 'not_a_cut';
 export declare function steerCutVerdict(notice: unknown, messageId: string | undefined): SteerCutVerdict;
-export interface FinishReasonUnknownFactsView {
-    finishReason: string;
-    sessionId: string;
-    runId: string;
-}
+export type FinishReasonUnknownFactsView = FinishReasonUnknownDetail;
 export declare function readFinishReasonUnknown(notice: unknown): FinishReasonUnknownFactsView | undefined;
 export interface StreamEndIgnoredFactsView {
     statement: string;

package/dist/engineRowRef.js

@@ -97,6 +97,10 @@ export const TRANSCRIPT_ROW_SIDECAR_KEYS = Object.freeze([
     '_sema_api_error_code',
     '_sema_provider_condition',
     '_sema_terminal_owner',
+    '_sema_row_kind',
+    '_sema_coded_detail',
+    '_sema_task_notification',
+    '_sema_answered_by',
 ]);
 export function parkHeldCallIdOf(carrier) {
     return readFrameStringKey(carrier, 'toolCallId');

package/dist/engineSessionMessages.js

@@ -1,5 +1,5 @@
 import { isGateParkedToolEnd } from './gateOutcome.js';
-import { ownDataField, ownSendableField } from './ownKey.js';
+import { appendOwnElement, ownDataField, ownSendableField } from './ownKey.js';
 const isObjectLike = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 function optionalOwn(o, key) {
     try {
@@ -17,7 +17,7 @@ function itemsOf(a) {
         return undefined;
     const out = [];
     for (let i = 0; i < n; i += 1)
-        out.push(ownDataField(a, String(i)));
+        appendOwnElement(out, ownDataField(a, String(i)));
     return out;
 }
 const JSON_MAX_DEPTH = 64;

package/dist/engineToolDirectory.js

@@ -1,5 +1,5 @@
 import { frozenSet } from './frozenSet.js';
-import { ownDataField } from './ownKey.js';
+import { appendOwnElement, ownDataField } from './ownKey.js';
 import { hasCoreValuePort, mcpNamespace, mintNamespacePrefix } from './coreValuePorts.js';
 const notLanded = () => Object.freeze({ state: 'not_landed' });
 const unreadable = () => Object.freeze({ state: 'unreadable' });
@@ -21,7 +21,7 @@ function readHalf(half) {
         const name = ownDataField(row, 'name');
         if (typeof name !== 'string' || name.length === 0)
             return 'unreadable';
-        names.push(name);
+        appendOwnElement(names, name);
     }
     return names;
 }

package/dist/engineWireFor.d.ts

@@ -1,6 +1,7 @@
 import type { AgentClient } from '@sema-agent/sdk';
 import { type EngineWireClientConfig, type EngineWireInjection } from './engineWireSdk.js';
 import { type EngineWireTarget } from './engineWireTarget.js';
+import { THROWN_SLOT_UNREADABLE, type SlotPresence } from './wireFailureShape.js';
 export declare const INJECTED_WIRE_SETTLE_MS = 60000;
 export type EngineWireTargetClientOptions = Pick<EngineWireClientConfig, 'timeoutMs' | 'maxRetries'>;
 export interface EngineWireInjected<C> {
@@ -22,6 +23,12 @@ export interface EngineWireNoTarget {
 export type EngineWireResolution<C> = EngineWireInjected<C> | EngineWireFromTarget | EngineWireInjectedUnusable | EngineWireNoTarget;
 export declare function engineWireFor<C extends object>(wire: EngineWireInjection<C> | undefined, sessionKey: string, usable: (client: object) => client is C): EngineWireResolution<C>;
 export declare function clientHasVerbs(client: object, verbs: ReadonlyArray<ReadonlyArray<string>>): boolean;
+export declare function readSignalAborted(signal: AbortSignal): boolean | null;
+export declare function readSignalReason(signal: AbortSignal): {
+    readonly reason: {} | null | undefined;
+} | null;
+export declare function tryListenAbortOnce(signal: AbortSignal, listener: () => void): boolean;
+export declare function tryUnlistenAbort(signal: AbortSignal, listener: () => void): boolean;
 export interface LinkedAbortSignal {
     signal: AbortSignal;
     dispose: () => void;
@@ -36,6 +43,97 @@ export declare class EngineWireCancelledError extends Error {
     constructor();
 }
 export declare function connectionLostDetail(): string;
+export type CauseSlotValue = {} | null | undefined;
+type CauseChainEnd = 'complete' | 'depth_cap' | 'unreadable';
+export declare function walkCauseChain(e: CauseSlotValue, visit: (layer: object, depth: number) => 'stop' | undefined, readCause?: (layer: object) => CauseSlotValue | typeof THROWN_SLOT_UNREADABLE, callableReach?: boolean): {
+    stopped: true;
+} | {
+    stopped: false;
+    end: CauseChainEnd;
+};
+export declare const causeSlotProtected: (layer: object) => CauseSlotValue | typeof THROWN_SLOT_UNREADABLE;
+export declare function causeSlotReadOf(layer: object): CauseSlotRead;
+export interface CauseSlotRead {
+    readonly value: CauseSlotValue | typeof THROWN_SLOT_UNREADABLE;
+    readonly presence: SlotPresence;
+}
+export declare const TRANSIENT_TRANSPORT_CODES: readonly string[];
+export type TransportChainReading = 'transient' | 'answered' | 'blocked' | 'none';
+export interface ChainAnswer {
+    readonly layer: object;
+    readonly status: number;
+}
+export interface TransportChainVerdict {
+    readonly reading: TransportChainReading;
+    readonly answer?: ChainAnswer;
+    readonly chainEnd?: 'unreadable';
+}
+export declare function transportChainReading(e: CauseSlotValue, facets: 'retry' | 'code', stopOn?: (layer: object) => boolean, topStatusAlreadyRead?: boolean): TransportChainReading;
+export declare function transportChainVerdict(e: CauseSlotValue, facets: 'retry' | 'code', stopOn?: (layer: object) => boolean, topStatusAlreadyRead?: boolean, noteTopCause?: (read: CauseSlotRead) => void, noteTopLocalCode?: (value: {} | null | undefined) => void): TransportChainVerdict;
+export interface AnswerReading {
+    readonly answer: ChainAnswer | typeof THROWN_SLOT_UNREADABLE | undefined;
+    readonly chain: TransportChainVerdict;
+    readonly topCause?: CauseSlotRead;
+    readonly topLocalCode?: {
+        readonly value: CapturedLocalCode;
+    };
+    readonly topStatusSlot?: SlotPresence;
+}
+export declare function answerReadingOf(e: CauseSlotValue): AnswerReading;
+export declare function answeringLayerOf(e: CauseSlotValue): ChainAnswer | typeof THROWN_SLOT_UNREADABLE | undefined;
+export type CapturedCode = {
+    readonly state: 'read';
+    readonly wire?: string;
+    readonly blockedBy?: string;
+} | {
+    readonly state: 'unreadable';
+};
+export type CapturedLocalCode = string | undefined | typeof THROWN_SLOT_UNREADABLE;
+declare class AnswerCaptureRecord implements ChainAnswer {
+    protected readonly answerCaptureBrand: true;
+    readonly layer: object;
+    readonly status: number;
+    readonly code: CapturedCode;
+    readonly localCode: CapturedLocalCode;
+    constructor(layer: object, status: number, code: CapturedCode, localCode: CapturedLocalCode);
+}
+export type AnswerCapture = AnswerCaptureRecord;
+export declare const CODE_UNREADABLE: CapturedCode;
+export declare function captureAnswer(answer: ChainAnswer, codeSlot: {} | null | undefined): AnswerCapture;
+declare class UnansweredCaptureRecord {
+    protected readonly unansweredCaptureBrand: true;
+    readonly layer: object;
+    readonly status: undefined;
+    readonly code: CapturedCode;
+    readonly localCode: CapturedLocalCode;
+    readonly statusSlot: SlotPresence;
+    constructor(layer: object, code: CapturedCode, localCode: CapturedLocalCode, statusSlot: SlotPresence);
+}
+export type UnansweredCapture = UnansweredCaptureRecord;
+export declare function captureUnanswered(layer: object, codeSlot: {} | null | undefined, localCodeRead: {
+    readonly value: CapturedLocalCode;
+} | undefined, statusSlot?: SlotPresence): UnansweredCapture;
+export declare function effectiveCodeOf(code: CapturedCode): string | undefined;
+export interface TriageReading {
+    readonly answer: AnswerCapture | typeof THROWN_SLOT_UNREADABLE | undefined;
+    readonly unanswered?: UnansweredCapture;
+    readonly topLocalCode?: TopLocalCodeReading;
+    readonly topCause?: TopCauseReading;
+    readonly transport: boolean;
+    readonly chainEnd?: 'unreadable';
+}
+export interface TopLocalCodeReading {
+    readonly layer: object;
+    readonly localCode: CapturedLocalCode;
+}
+export interface TopCauseReading {
+    readonly layer: object;
+    readonly read: CauseSlotRead;
+}
+export declare function ownReadingSlot<T extends object, K extends keyof T & string>(record: T | undefined, key: K): T[K] | undefined;
+export declare function noteTriageReading(verdict: object, reading: TriageReading): void;
+export declare function triageReadingOf(verdict: object): TriageReading | undefined;
+export declare function attemptTimeoutOnChain(e: CauseSlotValue): boolean;
 export type EngineWireNoAnswerKind = 'deadline' | 'time-limit' | 'connection-lost' | 'cancelled';
 export declare function noAnswerKindOf(e: object | null | undefined): EngineWireNoAnswerKind | null;
 export declare function noAnswerDetailFrom(e: object | null | undefined): string | null;
@@ -64,3 +162,4 @@ export interface TransportFailureScene {
 }
 export declare function transportFailureScene(error: unknown): TransportFailureScene;
 export declare function settleInjected<T>(ms: number, signal: AbortSignal | null | undefined, run: (signal: AbortSignal) => Promise<T>): Promise<T>;
+export {};

package/dist/engineWireFor.js

@@ -1,7 +1,8 @@
 import { settleWithinDeadline } from './abortableSleep.js';
 import { makeEngineWireClient } from './engineWireSdk.js';
 import { engineWireTargetFor } from './engineWireTarget.js';
-import { readThrownSlot } from './wireFailureShape.js';
+import { foldedWireCodeReading, readThrownSlot, readThrownStatusSlot, slotReadOf, THROWN_SLOT_UNREADABLE } from './wireFailureShape.js';
+import { guardedRead, readOwnDataValue } from './ownKey.js';
 export const INJECTED_WIRE_SETTLE_MS = 60_000;
 export function engineWireFor(wire, sessionKey, usable) {
     if (wire !== undefined) {
@@ -73,6 +74,40 @@ function quietlyRemoveAbortListener(signal, listener) {
     catch {
     }
 }
+export function readSignalAborted(signal) {
+    try {
+        return signal.aborted === true;
+    }
+    catch {
+        return null;
+    }
+}
+export function readSignalReason(signal) {
+    try {
+        return { reason: signal.reason };
+    }
+    catch {
+        return null;
+    }
+}
+export function tryListenAbortOnce(signal, listener) {
+    try {
+        signal.addEventListener('abort', listener, { once: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function tryUnlistenAbort(signal, listener) {
+    try {
+        signal.removeEventListener('abort', listener);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function linkedAbortSignal(caller, deadline) {
     const from = callerSignalOf(caller);
     if (from === undefined)
@@ -208,15 +243,38 @@ function allAttemptsFailedBeforeSend(errors) {
     return errors.every((x) => x !== null && typeof x === 'object' && isPreSendCode(x.code, x.syscall));
 }
 const CAUSE_CHAIN_MAX_LAYERS = 4;
-function walkCauseChain(e, visit) {
+export function walkCauseChain(e, visit, readCause, callableReach = false) {
+    const seen = readCause === undefined ? undefined : new Set();
     let cur = e;
-    for (let depth = 0; depth < CAUSE_CHAIN_MAX_LAYERS && cur !== null && typeof cur === 'object'; depth++) {
+    let depth = 0;
+    for (; depth < CAUSE_CHAIN_MAX_LAYERS && isChainLayer(cur, depth, callableReach); depth++) {
+        if (seen !== undefined) {
+            if (seen.has(cur))
+                return { stopped: false, end: 'complete' };
+            seen.add(cur);
+        }
         if (visit(cur, depth) === 'stop')
             return { stopped: true };
-        cur = cur.cause;
+        cur = readCause === undefined ? cur.cause : readCause(cur);
+        if (cur === THROWN_SLOT_UNREADABLE)
+            return { stopped: false, end: 'unreadable' };
     }
-    return { stopped: false, end: cur !== null && typeof cur === 'object' ? 'depth_cap' : 'complete' };
-}
+    return { stopped: false, end: isChainLayer(cur, depth, callableReach) && seen?.has(cur) !== true ? 'depth_cap' : 'complete' };
+}
+const CALLABLE_LAYER_REACH = 1;
+function isChainLayer(v, depth, callableReach) {
+    return (typeof v === 'object' && v !== null) || (callableReach && typeof v === 'function' && depth <= CALLABLE_LAYER_REACH);
+}
+export const causeSlotProtected = (layer) => causeSlotReadOf(layer).value;
+export function causeSlotReadOf(layer) {
+    const read = slotReadOf(layer, 'cause');
+    if (read.presence === 'unreadable')
+        return CAUSE_SLOT_UNREADABLE;
+    if (read.presence === 'present')
+        return Object.freeze({ value: read.value, presence: 'present' });
+    return readThrownSlot(layer, 'cause') === undefined ? Object.freeze({ value: undefined, presence: 'absent' }) : CAUSE_SLOT_UNREADABLE;
+}
+const CAUSE_SLOT_UNREADABLE = Object.freeze({ value: THROWN_SLOT_UNREADABLE, presence: 'unreadable' });
 function readLayerEvidence(layer) {
     const o = layer;
     const code = o.code;
@@ -230,6 +288,190 @@ function readLayerEvidence(layer) {
 function failedBeforeSend(e) {
     return walkCauseChain(e, (layer) => (readLayerEvidence(layer).proof !== null ? 'stop' : undefined)).stopped;
 }
+export const TRANSIENT_TRANSPORT_CODES = Object.freeze([
+    'ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'EPIPE', 'EAI_AGAIN',
+    'ENETUNREACH', 'EHOSTUNREACH', 'ECONNABORTED',
+    'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_HEADERS_TIMEOUT', 'UND_ERR_BODY_TIMEOUT', 'UND_ERR_SOCKET',
+]);
+function readLayerTransience(layer, facets, statusAlreadyRead = false, noteCode) {
+    if (!statusAlreadyRead) {
+        const status = readAnsweredStatus(layer);
+        if (typeof status === 'number')
+            return { t: 'answered', status };
+        if (status === THROWN_SLOT_UNREADABLE)
+            return { t: 'answered', status: undefined };
+    }
+    const callable = typeof layer === 'function';
+    if (facets === 'retry' && !callable) {
+        const name = readThrownSlot(layer, 'name');
+        if (name === 'TimeoutError' || name === 'AbortError')
+            return TRANSIENT_LAYER;
+    }
+    const code = readThrownSlot(layer, 'code', 'data');
+    noteCode?.(code);
+    if (callable)
+        return NONE_LAYER;
+    if (typeof code === 'string' && TRANSIENT_TRANSPORT_CODES.includes(code))
+        return TRANSIENT_LAYER;
+    if (facets === 'retry') {
+        const message = readThrownSlot(layer, 'message');
+        if (typeof message === 'string' && message.toLowerCase().includes('fetch failed'))
+            return TRANSIENT_LAYER;
+    }
+    return NONE_LAYER;
+}
+const TRANSIENT_LAYER = Object.freeze({ t: 'transient' });
+const NONE_LAYER = Object.freeze({ t: 'none' });
+export function transportChainReading(e, facets, stopOn, topStatusAlreadyRead = false) {
+    return transportChainVerdict(e, facets, stopOn, topStatusAlreadyRead).reading;
+}
+export function transportChainVerdict(e, facets, stopOn, topStatusAlreadyRead = false, noteTopCause, noteTopLocalCode) {
+    let reading = 'none';
+    let answer;
+    let layerIndex = 0;
+    let topCauseNoted = false;
+    const readCause = noteTopCause === undefined
+        ? causeSlotProtected
+        : (layer) => {
+            if (topCauseNoted || layer !== e)
+                return causeSlotProtected(layer);
+            topCauseNoted = true;
+            const read = causeSlotReadOf(layer);
+            noteTopCause(read);
+            return read.value;
+        };
+    const callableReach = facets === 'code';
+    const walked = walkCauseChain(e, (layer) => {
+        const isTop = layerIndex === 0;
+        const skipStatus = topStatusAlreadyRead && isTop;
+        layerIndex += 1;
+        if (stopOn !== undefined) {
+            let blocked;
+            try {
+                blocked = stopOn(layer);
+            }
+            catch {
+                blocked = true;
+            }
+            if (blocked) {
+                reading = 'blocked';
+                return 'stop';
+            }
+        }
+        const t = readLayerTransience(layer, facets, skipStatus, isTop ? noteTopLocalCode : undefined);
+        if (t.t === 'none')
+            return undefined;
+        reading = t.t;
+        if (t.t === 'answered' && t.status !== undefined)
+            answer = Object.freeze({ layer, status: t.status });
+        return 'stop';
+    }, readCause, callableReach);
+    const unreadableEnd = !walked.stopped && walked.end === 'unreadable';
+    return { reading, ...(answer !== undefined ? { answer } : {}), ...(unreadableEnd ? { chainEnd: 'unreadable' } : {}) };
+}
+function isHttpStatus(n) {
+    return Number.isInteger(n) && n >= 100 && n <= 599;
+}
+function readAnsweredStatus(o, notePresence) {
+    const s = readThrownStatusSlot(o, notePresence);
+    return typeof s === 'number' && !isHttpStatus(s) ? undefined : s;
+}
+const NO_CHAIN_VERDICT = Object.freeze({ reading: 'none' });
+const NO_ANSWER = Object.freeze({ answer: undefined, chain: NO_CHAIN_VERDICT });
+export function answerReadingOf(e) {
+    if (e === null || e === undefined || (typeof e !== 'object' && typeof e !== 'function'))
+        return NO_ANSWER;
+    let topStatusSlot = 'unreadable';
+    const status = readAnsweredStatus(e, (presence) => {
+        topStatusSlot = presence;
+    });
+    if (status === THROWN_SLOT_UNREADABLE)
+        return Object.freeze({ answer: THROWN_SLOT_UNREADABLE, chain: NO_CHAIN_VERDICT });
+    if (typeof status === 'number')
+        return Object.freeze({ answer: Object.freeze({ layer: e, status }), chain: NO_CHAIN_VERDICT });
+    let topCause;
+    let topLocalCode;
+    const chain = transportChainVerdict(e, 'code', undefined, true, (read) => {
+        topCause = read;
+    }, (value) => {
+        topLocalCode = Object.freeze({ value: localCodeOfSlot(value) });
+    });
+    const tc = {
+        ...(topCause !== undefined ? { topCause } : {}),
+        ...(topLocalCode !== undefined ? { topLocalCode } : {}),
+        topStatusSlot,
+    };
+    const chainAnswer = ownReadingSlot(chain, 'answer');
+    if (chain.reading === 'answered' && chainAnswer === undefined)
+        return Object.freeze({ answer: THROWN_SLOT_UNREADABLE, chain, ...tc });
+    return Object.freeze({ answer: chainAnswer, chain, ...tc });
+}
+export function answeringLayerOf(e) {
+    return answerReadingOf(e).answer;
+}
+function localCodeOfSlot(raw) {
+    return raw === THROWN_SLOT_UNREADABLE ? raw : typeof raw === 'string' ? raw : undefined;
+}
+class AnswerCaptureRecord {
+    layer;
+    status;
+    code;
+    localCode;
+    constructor(layer, status, code, localCode) {
+        this.layer = layer;
+        this.status = status;
+        this.code = code;
+        this.localCode = localCode;
+    }
+}
+export const CODE_UNREADABLE = Object.freeze(Object.assign(Object.create(null), { state: 'unreadable' }));
+function capturedCodeOfSlot(layer, codeSlot) {
+    if (codeSlot === THROWN_SLOT_UNREADABLE)
+        return CODE_UNREADABLE;
+    const wire = typeof codeSlot === 'string' && codeSlot.length > 0 ? codeSlot : undefined;
+    const folded = foldedWireCodeReading(layer, wire);
+    return Object.freeze(Object.assign(Object.create(null), { state: 'read', ...(wire !== undefined ? { wire } : {}), ...(folded.folded && folded.code !== undefined ? { blockedBy: folded.code } : {}) }));
+}
+export function captureAnswer(answer, codeSlot) {
+    const captured = new AnswerCaptureRecord(answer.layer, answer.status, capturedCodeOfSlot(answer.layer, codeSlot), localCodeOfSlot(readThrownSlot(answer.layer, 'code', 'data')));
+    Object.freeze(captured);
+    return captured;
+}
+class UnansweredCaptureRecord {
+    layer;
+    status;
+    code;
+    localCode;
+    statusSlot;
+    constructor(layer, code, localCode, statusSlot) {
+        this.layer = layer;
+        this.status = undefined;
+        this.code = code;
+        this.localCode = localCode;
+        this.statusSlot = statusSlot;
+    }
+}
+export function captureUnanswered(layer, codeSlot, localCodeRead, statusSlot) {
+    const captured = new UnansweredCaptureRecord(layer, capturedCodeOfSlot(layer, codeSlot), localCodeRead !== undefined ? localCodeRead.value : THROWN_SLOT_UNREADABLE, statusSlot ?? 'unreadable');
+    Object.freeze(captured);
+    return captured;
+}
+export function effectiveCodeOf(code) {
+    return code.state === 'read' ? (code.blockedBy ?? code.wire) : undefined;
+}
+const TRIAGE_READINGS = new WeakMap();
+export function ownReadingSlot(record, key) {
+    return record === undefined ? undefined : guardedRead(() => readOwnDataValue(record, key));
+}
+export function noteTriageReading(verdict, reading) {
+    TRIAGE_READINGS.set(verdict, Object.freeze({ ...reading }));
+}
+export function triageReadingOf(verdict) {
+    return TRIAGE_READINGS.get(verdict);
+}
+export function attemptTimeoutOnChain(e) {
+    return walkCauseChain(e, (layer) => (readThrownSlot(layer, 'name') === 'TimeoutError' ? 'stop' : undefined), causeSlotProtected).stopped;
+}
 export function noAnswerKindOf(e) {
     return noAnswerKindWith(e, () => failedBeforeSend(e));
 }

package/dist/engineWireTarget.d.ts

@@ -7,4 +7,5 @@ export declare function installEngineWireTarget(t: EngineWireTarget | null): ()
 export declare function installEngineWireTargetFor(sessionKey: string, t: EngineWireTarget | null): () => void;
 export declare function engineWireTarget(): EngineWireTarget | null;
 export declare function engineWireTargetFor(sessionKey: string): EngineWireTarget | null;
+export declare function engineWireTargetBaseUrl(sessionKey?: string): string | undefined;
 export declare function engineWireDebugEnabled(): boolean;

package/dist/engineWireTarget.js

@@ -35,6 +35,14 @@ export function engineWireTargetFor(sessionKey) {
         ...(envPrincipal !== undefined ? { principal: envPrincipal } : {}),
     };
 }
+export function engineWireTargetBaseUrl(sessionKey = DEFAULT_SESSION_KEY) {
+    try {
+        return engineWireTargetFor(sessionKey)?.baseUrl;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function engineWireDebugEnabled() {
     return Boolean(hostEnv().SEMA_DEBUG);
 }

package/dist/env/uiLanguage.js

@@ -17,7 +17,7 @@ function ownDataOf(v, key) {
         return undefined;
     try {
         const d = Object.getOwnPropertyDescriptor(v, key);
-        return d !== undefined && 'value' in d ? d.value : undefined;
+        return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
     }
     catch {
         return undefined;

package/dist/errorSupplementRoles.d.ts

@@ -0,0 +1,3 @@
+export type ErrorSupplementRole = 'replacement' | 'supplement';
+export type ErrorSupplementReader = (...args: never[]) => string;
+export declare function errorSupplementRoleOf(reader: ErrorSupplementReader): ErrorSupplementRole;

package/dist/errorSupplementRoles.js

@@ -0,0 +1,37 @@
+import { corruptSessionContent } from './corruptSessionCopy.js';
+import { corruptStoredRowContent } from './wireErrorTriage.js';
+import { resumeRefusalContent, resumeContextUnavailableContent, requireExistingSessionRefusalContent, checkpointUnsupportedVersionContent, } from './resumeRefusalCopy.js';
+import { resumeReopenContent } from './hitl/suspendedReopen.js';
+import { idempotencyPayloadMismatchContent } from './engineErrorCodes.js';
+import { inheritEnvRefusalContent } from './inheritEnvWire.js';
+import { usageWindowExhaustedContent, fleetLeaseUnavailableContent, settingsPermissionBucketRefusalContent, fieldLimitRefusalContent, autonomyLaneRefusalContent, userAttachmentRefusalContent, userInvokedSkillRefusalContent, unsupportedRuleRefusalContent, admissionWallRefusalContent, hostPostureRefusalContent, toolDeclarationRefusalContent, } from './wireRefusalCopy.js';
+const ROLE_BY_READER = new Map([
+    [corruptSessionContent, 'replacement'],
+    [corruptStoredRowContent, 'replacement'],
+    [resumeRefusalContent, 'replacement'],
+    [resumeContextUnavailableContent, 'replacement'],
+    [requireExistingSessionRefusalContent, 'replacement'],
+    [checkpointUnsupportedVersionContent, 'replacement'],
+    [resumeReopenContent, 'replacement'],
+    [usageWindowExhaustedContent, 'replacement'],
+    [fleetLeaseUnavailableContent, 'replacement'],
+    [settingsPermissionBucketRefusalContent, 'replacement'],
+    [fieldLimitRefusalContent, 'replacement'],
+    [autonomyLaneRefusalContent, 'replacement'],
+    [idempotencyPayloadMismatchContent, 'replacement'],
+    [userAttachmentRefusalContent, 'replacement'],
+    [userInvokedSkillRefusalContent, 'replacement'],
+    [unsupportedRuleRefusalContent, 'replacement'],
+    [admissionWallRefusalContent, 'supplement'],
+    [hostPostureRefusalContent, 'supplement'],
+    [toolDeclarationRefusalContent, 'supplement'],
+    [inheritEnvRefusalContent, 'supplement'],
+]);
+export function errorSupplementRoleOf(reader) {
+    try {
+        return ROLE_BY_READER.get(reader) ?? 'supplement';
+    }
+    catch {
+        return 'supplement';
+    }
+}

package/dist/executionLaneCapability.js

@@ -1,5 +1,5 @@
 import { capForDisplay } from './fleetTaskDesc.js';
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectExecutionLaneCapability(caps) {
@@ -49,7 +49,7 @@ const reader = createEngineCapReader({
     name: 'executionLane',
     project: projectExecutionLaneCapability,
 });
-export function observedExecutionLane(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedExecutionLane(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function toolsRunHereFromExecutionLane(reading) {

package/dist/fileHistoryCaptureCapability.js

@@ -1,6 +1,6 @@
 import { msg, renderMessage } from './i18n/translate.js';
 import { capForDisplay } from './fleetTaskDesc.js';
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { refreshEngineCapsOnce } from './engineCapsCache.js';
 import { ownDataField } from './ownKey.js';
@@ -23,7 +23,7 @@ const reader = createEngineCapReader({
     name: 'fileHistoryCapture',
     project: projectFileHistoryCaptureCapability,
 });
-export function observedFileHistoryCapture(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedFileHistoryCapture(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function fileHistoryCaptureMode(reading) {
@@ -118,7 +118,7 @@ export async function judgeFileHistoryTighten(captureOffByUser, opts) {
                 withinMs = 0;
             }
         }
-        const baseUrl = explicitBase ?? engineWireTarget()?.baseUrl;
+        const baseUrl = explicitBase ?? engineWireTargetBaseUrl();
         const first = observedFileHistoryCapture(baseUrl);
         const v1 = fileHistoryTightenVerdict(first, captureOffByUser);
         if (v1 !== 'unjudged')

package/dist/finalVerifyWire.d.ts

@@ -2,11 +2,14 @@ import type { SemaSettings } from '@sema-agent/sdk';
 import { type EnvLike } from './hostEnv.js';
 export type WireHooksConfig = NonNullable<SemaSettings['hooks']>;
 export declare const HEADLESS_FINAL_VERIFY_ENV = "SEMA_HEADLESS_FINAL_VERIFY";
-export declare function parseNoFinalVerifyArgv(argv: string[]): boolean;
+export interface HeadlessFinalVerifyFlags {
+    readonly noFinalVerify?: boolean;
+    readonly finalVerify?: boolean;
+}
 export declare function headlessFinalVerifyDisabledByEnv(env?: EnvLike): boolean;
 export declare function hasUserStopHook(wireHooks: WireHooksConfig | undefined): boolean;
-export declare function resolveHeadlessFinalVerify(argv: string[], env?: EnvLike, wireHooks?: WireHooksConfig): boolean;
-export declare function resolveHeadlessFinalVerifyDetail(argv: string[], env?: EnvLike, wireHooks?: WireHooksConfig): {
+export declare function resolveHeadlessFinalVerify(flags: HeadlessFinalVerifyFlags | undefined, env?: EnvLike, wireHooks?: WireHooksConfig): boolean;
+export declare function resolveHeadlessFinalVerifyDetail(flags: HeadlessFinalVerifyFlags | undefined, env?: EnvLike, wireHooks?: WireHooksConfig): {
     on: boolean;
     offReason?: 'flag' | 'env' | 'stop-hook';
 };

package/dist/finalVerifyWire.js

@@ -1,24 +1,7 @@
 import { hostEnv } from './hostEnv.js';
 import { envFlagOff, envFlagOn } from './envFlag.js';
+import { flagTrue } from './flagInput.js';
 export const HEADLESS_FINAL_VERIFY_ENV = 'SEMA_HEADLESS_FINAL_VERIFY';
-export function parseNoFinalVerifyArgv(argv) {
-    for (const a of argv) {
-        if (a === '--')
-            break;
-        if (a === '--no-final-verify')
-            return true;
-    }
-    return false;
-}
-function parseFinalVerifyArgv(argv) {
-    for (const a of argv) {
-        if (a === '--')
-            break;
-        if (a === '--final-verify')
-            return true;
-    }
-    return false;
-}
 export function headlessFinalVerifyDisabledByEnv(env = hostEnv()) {
     return envFlagOff(env[HEADLESS_FINAL_VERIFY_ENV]);
 }
@@ -26,15 +9,15 @@ export function hasUserStopHook(wireHooks) {
     const groups = wireHooks?.['Stop'];
     return Array.isArray(groups) && groups.length > 0;
 }
-export function resolveHeadlessFinalVerify(argv, env = hostEnv(), wireHooks) {
-    return resolveHeadlessFinalVerifyDetail(argv, env, wireHooks).on;
+export function resolveHeadlessFinalVerify(flags, env = hostEnv(), wireHooks) {
+    return resolveHeadlessFinalVerifyDetail(flags, env, wireHooks).on;
 }
-export function resolveHeadlessFinalVerifyDetail(argv, env = hostEnv(), wireHooks) {
-    if (parseNoFinalVerifyArgv(argv))
+export function resolveHeadlessFinalVerifyDetail(flags, env = hostEnv(), wireHooks) {
+    if (flagTrue(flags, 'noFinalVerify'))
         return { on: false, offReason: 'flag' };
     if (headlessFinalVerifyDisabledByEnv(env))
         return { on: false, offReason: 'env' };
-    const explicitOn = parseFinalVerifyArgv(argv) || envFlagOn(env[HEADLESS_FINAL_VERIFY_ENV]);
+    const explicitOn = flagTrue(flags, 'finalVerify') || envFlagOn(env[HEADLESS_FINAL_VERIFY_ENV]);
     if (explicitOn) {
         if (hasUserStopHook(wireHooks))
             return { on: false, offReason: 'stop-hook' };

package/dist/flagInput.d.ts

@@ -0,0 +1,4 @@
+export declare function flagObject(flags: object | null | undefined, key: string): object | undefined;
+export declare function flagIsWronglyTyped(flags: object | null | undefined, key: string): boolean;
+export declare function flagString(flags: object | null | undefined, key: string): string | undefined;
+export declare function flagTrue(flags: object | null | undefined, key: string): boolean;