@sema-agent/client-core 0.99.0 → 0.101.0

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

@@ -65,11 +65,6 @@ export interface EventLegIdleTriagePorts {
     readonly baseUrl: string;
 }
 export type EventLegTap = (frame: AgentEvent) => void;
-export type EventLegStreamDecorator = (stream: AsyncGenerator<AgentEvent>, ctx: EventLegStreamContext) => AsyncGenerator<AgentEvent>;
-export interface EventLegStreamContext {
-    readonly leg: EventLegKind;
-    readonly runId: string | undefined;
-}
 export interface ApprovalFrameContext {
     readonly leg: EventLegKind;
     readonly windowIsCurrent: boolean;
@@ -85,9 +80,8 @@ export interface EventLegPorts {
     readonly idleTriage?: EventLegIdleTriagePorts;
     readonly signal?: AbortSignal;
     readonly taps?: readonly EventLegTap[];
-    readonly perStream?: readonly EventLegStreamDecorator[];
 }
-export type EventLegPortName = 'run.headerRunId' | 'run.onBound' | 'run.onRefused' | 'run.onTerminal' | 'run.isCurrent' | 'hitl.question' | 'hitl.elicitation' | 'hitl.toolApproval' | 'askBridge.respondToolApproval' | 'taps' | 'perStream';
+export type EventLegPortName = 'run.headerRunId' | 'run.onBound' | 'run.onRefused' | 'run.onTerminal' | 'run.isCurrent' | 'hitl.question' | 'hitl.elicitation' | 'hitl.toolApproval' | 'askBridge.respondToolApproval' | 'taps';
 export interface EventLegReport {
     readonly missingPorts: readonly EventLegPortName[];
     readonly portFaults: Readonly<Partial<Record<EventLegPortName, number>>>;

package/dist/eventLeg.js

@@ -22,6 +22,12 @@ const FRAME_STAGE_DOMAINS = makeFrameStageDomains({
     stampOwner: Object.freeze(['task_progress']),
     hitlFrames: Object.freeze(['question', 'question_complete', 'elicitation', 'elicitation_complete', 'tool_approval', 'tool_approval_complete', 'approval_request', 'approval_revoke']),
 });
+const HITL_FRAMES_PROJECTED = Object.freeze(['human_input']);
+const _hitlFrameTypesPin = [true, true];
+const _hitlProjectedDisjointPin = true;
+void _hitlFrameTypesPin;
+void _hitlProjectedDisjointPin;
+void HITL_FRAMES_PROJECTED;
 const HITL_PORT_OF = Object.freeze({
     question: 'question',
     question_complete: 'question',
@@ -130,7 +136,6 @@ export function composeEventLeg(source, leg, ports) {
     };
     const sessionKey = typeof ports.owner?.sessionKey === 'string' && ports.owner.sessionKey !== '' ? ports.owner.sessionKey : undefined;
     const taps = (ports.taps ?? []).filter((t) => typeof t === 'function');
-    const decorators = (ports.perStream ?? []).filter((d) => typeof d === 'function');
     const info = Object.freeze({ leg: kind });
     const runSessions = new Map();
     let lastBound;
@@ -218,13 +223,7 @@ export function composeEventLeg(source, leg, ports) {
             ended.abort();
         }
     }
-    const streamOf = (raw, streamKind, streamRunId) => {
-        let s = generatorOf(raw);
-        const ctx = Object.freeze({ leg: streamKind, runId: streamRunId });
-        for (const d of decorators)
-            s = d(s, ctx);
-        return frameLevel(s, streamKind, streamRunId);
-    };
+    const streamOf = (raw, streamKind, streamRunId) => frameLevel(generatorOf(raw), streamKind, streamRunId);
     let inner = streamOf(source, kind, legRunId);
     if (hostBridge !== undefined) {
         let windowOpen = row.windowIsCurrent;

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

@@ -13,9 +13,6 @@ export type FileHistoryCaptureMode = 'off' | 'on-optional' | 'unknown';
 export declare function projectFileHistoryCaptureCapability(caps: unknown): FileHistoryCaptureReading | undefined;
 export declare function observedFileHistoryCapture(baseUrl?: string | undefined): FileHistoryCaptureReading;
 export declare function fileHistoryCaptureMode(reading: FileHistoryCaptureReading): FileHistoryCaptureMode;
-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;

package/dist/fileHistoryCaptureCapability.js

@@ -1,10 +1,9 @@
 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';
-import { FILE_HISTORY_DISABLED } from './request/taskRequest.js';
 export function projectFileHistoryCaptureCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
@@ -24,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) {
@@ -47,9 +46,6 @@ export function fileHistoryCaptureMode(reading) {
         return 'on-optional';
     return 'unknown';
 }
-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)
@@ -122,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;

package/dist/flagInput.js

@@ -0,0 +1,24 @@
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+function flagSlot(flags, key) {
+    return guardedRead(() => readOwnDataValue(flags, key));
+}
+export function flagObject(flags, key) {
+    const v = flagSlot(flags, key);
+    try {
+        return typeof v === 'object' && v !== null && !Array.isArray(v) ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function flagIsWronglyTyped(flags, key) {
+    const v = flagSlot(flags, key);
+    return v !== undefined && typeof v !== 'string';
+}
+export function flagString(flags, key) {
+    const v = flagSlot(flags, key);
+    return typeof v === 'string' ? v : undefined;
+}
+export function flagTrue(flags, key) {
+    return flagSlot(flags, key) === true;
+}

package/dist/fleet/fleetLedger.js

@@ -12,6 +12,7 @@ import { isSdkFleetTaskTerminal, isSdkFleetTaskTerminalNotSuccess } from '../ter
 import { projectTasks, projectWorkflows, wireCycleSeq, wireParentId, } from './fleetProjection.js';
 import { isInStreamDrainingEnd } from '../wireErrorTriage.js';
 import { cycleSeqOrder, cycleSeqValue } from '../cycleOrder.js';
+import { guardedRead, ownSnapshotRecord, readOwnDataValue } from '../ownKey.js';
 export const TERMINAL_RETAIN_MS = 60_000;
 function hasRowId(row) {
     const id = row?.id;
@@ -382,7 +383,7 @@ export function createFleetLedger(hooks = {}, opts = {}) {
                 hooks.onHookNotice?.(frame, sessionScopedMeta === true);
                 break;
             case 'bg_notification':
-                applyBgNotification(frame.notification, ing);
+                applyBgNotification(guardedRead(() => readOwnDataValue(frame, 'notification')), ing);
                 break;
             default:
                 if (isInStreamDrainingEnd(frame)) {
@@ -394,7 +395,8 @@ export function createFleetLedger(hooks = {}, opts = {}) {
                 break;
         }
     }
-    function applyBgNotification(n, ing) {
+    function applyBgNotification(raw, ing) {
+        const n = ownSnapshotRecord(raw);
         if (typeof n?.taskId !== 'string' || typeof n?.status !== 'string') {
             droppedMalformed++;
             debug('[fleet-frame] MALFORMED bg_notification dropped(taskId 或 status 缺席/非串)');
@@ -554,6 +556,7 @@ export function createFleetLedger(hooks = {}, opts = {}) {
             status: n.status,
             ...(typeof n.seq === 'number' ? { seq: n.seq } : {}),
             ...(typeof n.summary === 'string' ? { summary: n.summary } : {}),
+            ...(typeof n.completionId === 'string' && n.completionId.length > 0 ? { completionId: n.completionId } : {}),
         });
     }
     function project(nowMs, opts) {

package/dist/fleet/fleetProjection.d.ts

@@ -54,6 +54,7 @@ export interface FleetWorkflowView {
 }
 export declare function coerceTaskStatus(s: string): FleetTaskStatus;
 export declare function coerceWorkflowStatus(s: string | undefined): FleetTaskStatus;
+export declare function workflowRunDisplayStatusOf(run: object | null | undefined): FleetTaskStatus;
 export declare const CONTROL_TOOL_VERBS: ReadonlySet<string>;
 export declare function projectDescription(description: string | undefined): string;
 export declare function wireParentId(r: Pick<FleetTaskRow, 'parentId'>): string | undefined;