@sema-agent/client-core 0.93.0 → 0.94.0

package/dist/wireErrorTriage.js

@@ -1,5 +1,6 @@
 import { readErrorNumber, readErrorString, readErrorStringList } from './wireFailureShape.js';
 import { capForDisplay } from './fleetTaskDesc.js';
+import { readOwnDataValue } from './ownKey.js';
 import { fleetLeaseUnavailableFromError } from './wireRefusalCopy.js';
 import { DRAINING_ERROR_CODE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, RESUME_POLICY_FOLD_CODE, RESUME_RETRY_LATER_CODES, RESUME_USAGE_WINDOW_EXHAUSTED, SCENARIO_NOT_ALLOWED_ERROR_CODE, } from './engineErrorCodes.js';
 export const WIRE_NETWORK_ERROR_PATTERN = /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|EHOSTUNREACH|ENETUNREACH|EPIPE|socket hang up|UND_ERR|terminated|other side closed/i;
@@ -87,6 +88,40 @@ export function drainingRetryDelayMs(err, attempt, opts) {
     const ladder = opts?.ladder && opts.ladder.length > 0 ? opts.ladder : [1_000, 2_000, 4_000];
     return ladder[Math.min(attempt, ladder.length - 1)] ?? 1_000;
 }
+export function isInStreamDrainingEnd(frame) {
+    try {
+        if (typeof frame !== 'object' || frame === null)
+            return false;
+        if (typeof readOwnDataValue(frame, 'status') === 'number')
+            return false;
+        const typeSlot = Object.getOwnPropertyDescriptor(frame, 'type');
+        const outerType = typeSlot !== undefined && Object.hasOwn(typeSlot, 'value') ? typeSlot.value : undefined;
+        if (outerType === 'error')
+            return readOwnDataValue(frame, 'errorCode') === DRAINING_ERROR_CODE;
+        if (typeSlot !== undefined && outerType !== 'unknown')
+            return false;
+        if (readOwnDataValue(frame, 'event') !== 'error')
+            return false;
+        const data = readOwnDataValue(frame, 'data');
+        if (typeof data !== 'object' || data === null)
+            return false;
+        const dataType = readOwnDataValue(data, 'type');
+        if (dataType !== undefined && dataType !== 'error')
+            return false;
+        return readOwnDataValue(data, 'errorCode') === DRAINING_ERROR_CODE;
+    }
+    catch {
+        return false;
+    }
+}
+export const STREAM_DRAINING_RECONNECT_MAX = 3;
+export function streamDrainingDecision(frame, attempt, opts) {
+    if (!isInStreamDrainingEnd(frame))
+        return { giveUp: 'not_draining_end' };
+    if (!Number.isSafeInteger(attempt) || attempt < 0 || attempt >= STREAM_DRAINING_RECONNECT_MAX)
+        return { giveUp: 'attempts_exhausted' };
+    return { reconnectAfterMs: drainingRetryDelayMs(null, attempt, opts?.ladder !== undefined ? { ladder: opts.ladder } : undefined) };
+}
 export function scenarioDenyFromError(err) {
     if (typeof err !== 'object' || err === null)
         return null;

package/dist/wireFailureShape.d.ts

@@ -8,6 +8,7 @@ interface WireFailureShape {
     bodyVerdict?: string;
     bodyCurrentName?: string;
     message: string;
+    ownMessage?: string;
 }
 export declare function readErrorNumber(o: object, key: string): number | undefined;
 export declare function readErrorRecord(o: object, key: string): object | undefined;
@@ -15,4 +16,9 @@ export declare function readErrorString(o: object, key: string): string | undefi
 export declare function readErrorStringList(o: object, key: string): readonly string[] | undefined;
 export declare function readErrorStrictStringList(o: object, key: string): readonly string[] | undefined;
 export declare function wireFailureShapeOf(e: unknown): WireFailureShape;
+export declare const WIRE_FAILURE_UNRENDERABLE_TEXT = "the call failed with an error this client could not render";
+export declare function wireFailureTextsOf(e: unknown): {
+    reason: string;
+    log: string;
+};
 export {};

package/dist/wireFailureShape.js

@@ -97,7 +97,14 @@ export function wireFailureShapeOf(e) {
     catch {
         extraUnreadable = true;
     }
-    const extraObj = typeof extra === 'object' && extra !== null && !Array.isArray(extra) ? extra : undefined;
+    let extraObj;
+    try {
+        extraObj = typeof extra === 'object' && extra !== null && !Array.isArray(extra) ? extra : undefined;
+    }
+    catch {
+        extraObj = undefined;
+        extraUnreadable = true;
+    }
     let committedPresent = false;
     let committedRaw;
     if (extraObj !== undefined) {
@@ -133,12 +140,13 @@ export function wireFailureShapeOf(e) {
     const bodyName = ownString('name');
     const bodyVerdict = ownString('verdict');
     const bodyCurrentName = ownString('currentName');
+    const ownMessage = typeof rawMessage === 'string' && rawMessage !== '' ? rawMessage : undefined;
     let message;
     try {
-        message = typeof rawMessage === 'string' && rawMessage !== '' ? rawMessage : String(e);
+        message = ownMessage !== undefined ? ownMessage : String(e);
     }
     catch {
-        message = 'the call failed with an error this client could not render';
+        message = WIRE_FAILURE_UNRENDERABLE_TEXT;
     }
     const sec = typeof retryAfterMs === 'number' && Number.isFinite(retryAfterMs) && retryAfterMs >= 0
         ? Math.ceil(retryAfterMs / 1000)
@@ -160,5 +168,24 @@ export function wireFailureShapeOf(e) {
         ...(bodyVerdict !== undefined ? { bodyVerdict } : {}),
         ...(bodyCurrentName !== undefined ? { bodyCurrentName } : {}),
         message,
+        ...(ownMessage !== undefined ? { ownMessage } : {}),
     };
 }
+export const WIRE_FAILURE_UNRENDERABLE_TEXT = 'the call failed with an error this client could not render';
+export function wireFailureTextsOf(e) {
+    const { ownMessage } = wireFailureShapeOf(e);
+    let log;
+    try {
+        log = String(e).slice(0, 300);
+    }
+    catch {
+        log = '<unprintable thrown value>';
+    }
+    if (ownMessage !== undefined)
+        return { reason: ownMessage, log };
+    if (typeof e === 'string')
+        return { reason: e !== '' ? e : WIRE_FAILURE_UNRENDERABLE_TEXT, log };
+    if (typeof e === 'number' || typeof e === 'boolean' || typeof e === 'bigint')
+        return { reason: String(e), log };
+    return { reason: WIRE_FAILURE_UNRENDERABLE_TEXT, log };
+}

package/dist/wireRefusalCopy.d.ts

@@ -1,4 +1,4 @@
-import { FLEET_LEASE_UNAVAILABLE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
 import type { TaskRequestLike } from './request/taskRequest.js';
 export declare const CONFLICT_APPROVAL_SETTLED = "conflict.approval_settled";
 export declare const CONFLICT_RUN_NOT_RUNNING = "conflict.run_not_running";
@@ -83,3 +83,8 @@ export interface HookMatcherRefusal {
     readonly canonical: string;
 }
 export declare function hookMatcherRefusalFromError(err: unknown): HookMatcherRefusal | undefined;
+export interface AutonomyLaneRefusalDetail {
+    readonly code: typeof REQUEST_AUTONOMY_LANE_REFUSED;
+}
+export declare function autonomyLaneRefusalFromError(err: unknown): AutonomyLaneRefusalDetail | null;
+export declare function autonomyLaneRefusalContent(): string;

package/dist/wireRefusalCopy.js

@@ -1,6 +1,6 @@
 import { readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList } from './wireFailureShape.js';
 import { readOwnNonEmptyString } from './ownKey.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_FIELD_CONFLICT, RESUME_POLICY_FOLD_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_POLICY_FOLD_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
@@ -11,24 +11,31 @@ function readStringField(o, key) {
     return typeof v === 'string' && v !== '' ? v : undefined;
 }
 export function cancelConflictFromError(err) {
+    let o;
     try {
         if (err === null || typeof err !== 'object')
             return null;
-        const o = err;
+        o = err;
         const rawStatus = o.status ?? o.statusCode;
         const is409 = rawStatus === 409 || (rawStatus === undefined && o.name === 'ConflictError');
         if (!is409)
             return null;
-        const code = readStringField(o, 'errorCode');
-        if (code === CONFLICT_APPROVAL_SETTLED)
-            return { kind: 'approval_settled', code };
-        if (code === CONFLICT_RUN_NOT_RUNNING)
-            return { kind: 'run_not_running', code };
-        return { kind: 'unrecognized', ...(code !== undefined ? { code } : {}) };
     }
     catch {
         return null;
     }
+    let code;
+    try {
+        code = readStringField(o, 'errorCode');
+    }
+    catch {
+        code = undefined;
+    }
+    if (code === CONFLICT_APPROVAL_SETTLED)
+        return { kind: 'approval_settled', code };
+    if (code === CONFLICT_RUN_NOT_RUNNING)
+        return { kind: 'run_not_running', code };
+    return { kind: 'unrecognized', ...(code !== undefined ? { code } : {}) };
 }
 export function cancelConflictContent(detail) {
     switch (detail.kind) {
@@ -619,3 +626,10 @@ export function hookMatcherRefusalFromError(err) {
         return undefined;
     }
 }
+export function autonomyLaneRefusalFromError(err) {
+    return effectiveWireErrorCode(err) === REQUEST_AUTONOMY_LANE_REFUSED ? { code: REQUEST_AUTONOMY_LANE_REFUSED } : null;
+}
+export function autonomyLaneRefusalContent() {
+    return ('The engine did not start this leader run: this deployment runs in plan-only autonomy, and a leader run has no way to have its plan reviewed, ' +
+        'so nothing was started · Submit the work as a regular run instead, or ask whoever operates the engine to change its autonomy setting');
+}

package/dist/wiringInstructionsAttribution.d.ts

@@ -0,0 +1,10 @@
+import { type CallerCwdReading } from './callerCwdCapability.js';
+export declare function legCwdOfBody(body: object | null | undefined, callerCwd: CallerCwdReading | undefined): string | undefined;
+export interface InstructionsAttributionInput {
+    legCwd: string | undefined;
+    currentCwd: string;
+    realPathOf: (path: string) => string;
+}
+export declare function engineSelectedInstructionsFile(view: {
+    readonly selected: readonly string[];
+} | null | undefined, input: InstructionsAttributionInput): string | undefined;

package/dist/wiringInstructionsAttribution.js

@@ -0,0 +1,67 @@
+import { callerCwdAdmitted } from './callerCwdCapability.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { readOutboundBodyField } from './fileHistoryLegNotice.js';
+export function legCwdOfBody(body, callerCwd) {
+    if (!callerCwdAdmitted(callerCwd))
+        return undefined;
+    const r = readOutboundBodyField(body, 'cwd');
+    return r.kind === 'value' && typeof r.value === 'string' && r.value.length > 0 ? r.value : undefined;
+}
+function realOf(realPathOf, path) {
+    try {
+        if (typeof realPathOf !== 'function')
+            return undefined;
+        const r = realPathOf(path);
+        return typeof r === 'string' && r.length > 0 ? r : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function safeRelativeMember(member) {
+    if (typeof member !== 'string' || member.length === 0)
+        return false;
+    if (displayUntrusted(member) !== member)
+        return false;
+    if (member.includes('\\') || member.startsWith('/') || /^[A-Za-z]:/.test(member))
+        return false;
+    return member.split('/').every((seg) => seg !== '' && seg !== '..');
+}
+function isSep(path, c) {
+    return c === '/' || (!path.startsWith('/') && c === '\\');
+}
+function trimSeps(path) {
+    let end = path.length;
+    while (end > 0 && isSep(path, path.charAt(end - 1)))
+        end--;
+    return path.slice(0, end);
+}
+function strictlyWithin(child, dir) {
+    const trimmed = trimSeps(dir);
+    if (!child.startsWith(trimmed) || child.length <= trimmed.length)
+        return false;
+    return isSep(dir, child.charAt(trimmed.length));
+}
+export function engineSelectedInstructionsFile(view, input) {
+    try {
+        if (view === null || typeof view !== 'object' || input === null || typeof input !== 'object')
+            return undefined;
+        const { legCwd, currentCwd, realPathOf } = input;
+        if (typeof legCwd !== 'string' || legCwd.length === 0 || legCwd !== currentCwd)
+            return undefined;
+        const selected = view.selected;
+        if (!Array.isArray(selected) || selected.length === 0)
+            return undefined;
+        const member = selected[0];
+        if (!safeRelativeMember(member))
+            return undefined;
+        const realDir = realOf(realPathOf, currentCwd);
+        const realFile = realOf(realPathOf, `${trimSeps(currentCwd)}/${member}`);
+        if (realDir === undefined || realFile === undefined || !strictlyWithin(realFile, realDir))
+            return undefined;
+        return member;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/workflowClient.js

@@ -5,6 +5,7 @@ import { makeEngineWireClient } from './engineWireSdk.js';
 import { engineWireDebugEnabled } from './engineWireTarget.js';
 import { hostLog } from './host.js';
 import { isReadCredentialRefusal } from './readCredentialRefusal.js';
+import { isInStreamDrainingEnd, streamDrainingDecision } from './wireErrorTriage.js';
 function coerceRunStatus(s) {
     switch (s) {
         case 'completed':
@@ -584,9 +585,11 @@ async function consumeWorkflowActivity(l, cfg) {
         emitActivityTick(l);
         return;
     }
+    let drainEnds = 0;
     while (!l.closed && !l.abort.signal.aborted) {
         let sawFrame = false;
         let threw = false;
+        let lastDrainEnd;
         try {
             const stream = client.workflows.stream(l.workflowId, {
                 signal: l.abort.signal,
@@ -597,6 +600,12 @@ async function consumeWorkflowActivity(l, cfg) {
                     return;
                 sawFrame = true;
                 l.connected = true;
+                if (isInStreamDrainingEnd(frame)) {
+                    lastDrainEnd = frame;
+                    continue;
+                }
+                lastDrainEnd = undefined;
+                drainEnds = 0;
                 try {
                     foldWorkflowActivityFrame(l, frame);
                 }
@@ -632,9 +641,21 @@ async function consumeWorkflowActivity(l, cfg) {
                 return;
             }
         }
+        let waitMs = WORKFLOW_ACTIVITY_RECONNECT_MS;
+        if (lastDrainEnd !== undefined) {
+            const decision = streamDrainingDecision(lastDrainEnd, drainEnds++);
+            if ('giveUp' in decision) {
+                l.closed = true;
+                l.closedReason = 'error';
+                l.lastError = 'the engine kept ending this stream because it is going down (drain end frames)';
+                emitActivityTick(l);
+                return;
+            }
+            waitMs = decision.reconnectAfterMs;
+        }
         emitActivityTick(l);
         if (!l.closed && !l.abort.signal.aborted) {
-            await abortableSleep(WORKFLOW_ACTIVITY_RECONNECT_MS, l.abort.signal);
+            await abortableSleep(waitMs, l.abort.signal);
         }
     }
     emitActivityTick(l);

package/dist/workflowsJournalCapability.js

@@ -1,16 +1,21 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
 export function projectWorkflowsJournalCapability(caps) {
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'workflowsJournal'))
-        return { kind: 'not_reported' };
-    const v = caps.workflowsJournal;
-    if (v === undefined)
-        return { kind: 'not_reported' };
-    if (typeof v !== 'boolean')
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        if (!Object.hasOwn(caps, 'workflowsJournal'))
+            return { kind: 'not_reported' };
+        const v = caps.workflowsJournal;
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        if (typeof v !== 'boolean')
+            return undefined;
+        return v ? { kind: 'present' } : { kind: 'absent' };
+    }
+    catch {
         return undefined;
-    return v ? { kind: 'present' } : { kind: 'absent' };
+    }
 }
 const reader = createEngineCapReader({
     name: 'workflowsJournal',

package/dist/writeProtectionCapability.js

@@ -2,30 +2,35 @@ import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
 export function projectWriteProtectionCapability(caps) {
-    if (caps === null || typeof caps !== 'object')
-        return undefined;
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'writeProtection'))
-        return { kind: 'not_reported' };
-    const wp = caps.writeProtection;
-    if (wp === null)
-        return { kind: 'none' };
-    if (wp === undefined)
-        return { kind: 'not_reported' };
-    if (typeof wp !== 'object' || Array.isArray(wp))
-        return undefined;
-    const w = wp;
-    const armed = w.armed;
-    const replaced = w.replaced;
-    const rows = w.rows;
-    if (typeof armed !== 'boolean')
-        return undefined;
-    if (typeof replaced !== 'boolean')
-        return undefined;
-    if (typeof rows !== 'number' || !Number.isInteger(rows) || rows < 0)
+    try {
+        if (caps === null || typeof caps !== 'object')
+            return undefined;
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        if (!Object.hasOwn(caps, 'writeProtection'))
+            return { kind: 'not_reported' };
+        const wp = caps.writeProtection;
+        if (wp === null)
+            return { kind: 'none' };
+        if (wp === undefined)
+            return { kind: 'not_reported' };
+        if (typeof wp !== 'object' || Array.isArray(wp))
+            return undefined;
+        const w = wp;
+        const armed = w.armed;
+        const replaced = w.replaced;
+        const rows = w.rows;
+        if (typeof armed !== 'boolean')
+            return undefined;
+        if (typeof replaced !== 'boolean')
+            return undefined;
+        if (typeof rows !== 'number' || !Number.isInteger(rows) || rows < 0)
+            return undefined;
+        return { kind: 'present', view: { armed, rows, replaced } };
+    }
+    catch {
         return undefined;
-    return { kind: 'present', view: { armed, rows, replaced } };
+    }
 }
 export function projectWriteProtectionPosture(wiring) {
     if (wiring === null || typeof wiring !== 'object')