@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/engineDirectory.js

@@ -0,0 +1,186 @@
+import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+const KIND_WORDS = ['managed'];
+const POSTURE_WORDS = ['single', 'multi'];
+const RULE_WORDS = ['only-one', 'none', 'ambiguous'];
+const UNREADABLE = Object.freeze({ kind: 'unreadable' });
+function isCenterRelativePath(path) {
+    if (path.length === 0 || path.charCodeAt(0) !== 0x2f)
+        return false;
+    const second = path.charCodeAt(1);
+    if (second === 0x2f || second === 0x5c)
+        return false;
+    if (/[\s\u0000-\u001f\u007f-\u009f\\?#]/u.test(path))
+        return false;
+    return path.split('/').every((segment) => {
+        const decoded = segment.replace(/%2e/gi, '.');
+        return decoded !== '.' && decoded !== '..';
+    });
+}
+function isObj(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function stringOf(holder, key) {
+    return guardedRead(() => readOwnDataNonEmptyString(holder, key));
+}
+function boolOf(holder, key) {
+    return guardedRead(() => {
+        const v = readOwnDataValue(holder, key);
+        return typeof v === 'boolean' ? v : undefined;
+    });
+}
+function wordOf(holder, key, listed) {
+    const word = stringOf(holder, key);
+    if (word === undefined)
+        return UNREADABLE;
+    const hit = listed.find((w) => w === word);
+    return hit !== undefined ? { kind: 'listed', word: hit } : { kind: 'unlisted', word };
+}
+function rowOf(raw) {
+    try {
+        if (!isObj(raw))
+            return undefined;
+        const name = stringOf(raw, 'name');
+        if (name === undefined)
+            return undefined;
+        const connect = guardedRead(() => readOwnDataValue(raw, 'connect'));
+        if (!isObj(connect))
+            return undefined;
+        const viaCenter = stringOf(connect, 'viaCenter');
+        if (viaCenter === undefined || !isCenterRelativePath(viaCenter))
+            return undefined;
+        return {
+            name,
+            kind: wordOf(raw, 'kind', KIND_WORDS),
+            scope: stringOf(raw, 'scope'),
+            online: boolOf(raw, 'online'),
+            posture: wordOf(raw, 'posture', POSTURE_WORDS),
+            viaCenter,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function rowSetOf(raw) {
+    try {
+        if (!Array.isArray(raw))
+            return undefined;
+        const length = readOwnDataValue(raw, 'length');
+        if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0)
+            return undefined;
+        const rows = [];
+        const unreadableNames = [];
+        let unreadableRows = 0;
+        for (let i = 0; i < length; i += 1) {
+            const element = guardedRead(() => readOwnDataValue(raw, String(i)));
+            const row = rowOf(element);
+            if (row !== undefined) {
+                rows.push(row);
+                continue;
+            }
+            unreadableRows += 1;
+            const name = guardedRead(() => (isObj(element) ? stringOf(element, 'name') : undefined));
+            if (name !== undefined)
+                unreadableNames.push(name);
+        }
+        return { rows, unreadableRows, unreadableNames };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function projectEngineDirectory(body) {
+    try {
+        if (!isObj(body))
+            return undefined;
+        return rowSetOf(readOwnDataValue(body, 'engines'));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function projectMeEngine(body) {
+    try {
+        if (!isObj(body))
+            return undefined;
+        const rule = wordOf(body, 'rule', RULE_WORDS);
+        const rawTarget = guardedRead(() => readOwnDataValue(body, 'target'));
+        let target = UNREADABLE;
+        if (rawTarget === null) {
+            target = { kind: 'null' };
+        }
+        else {
+            const row = rowOf(rawTarget);
+            if (row !== undefined)
+                target = { kind: 'row', row };
+        }
+        const candidates = guardedRead(() => rowSetOf(readOwnDataValue(body, 'candidates')));
+        if (rule.kind === 'unreadable' && target.kind === 'unreadable' && candidates === undefined)
+            return undefined;
+        return { rule, target, candidates };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function decideMeEngine(reading) {
+    try {
+        if (reading === undefined)
+            return { kind: 'unresolved', reason: 'body', rule: UNREADABLE, candidates: undefined };
+        const { rule, target, candidates } = reading;
+        const unresolved = (reason) => ({ kind: 'unresolved', reason, rule, candidates });
+        if (rule.kind === 'unreadable')
+            return unresolved('rule');
+        if (target.kind === 'unreadable')
+            return unresolved('target');
+        if (target.kind === 'row') {
+            if (rule.kind === 'listed' && (rule.word === 'none' || rule.word === 'ambiguous'))
+                return unresolved('conflict');
+            if (candidates === undefined)
+                return unresolved('candidates');
+            const picked = target.row;
+            if (!candidates.rows.some((row) => row.name === picked.name && row.viaCenter === picked.viaCenter))
+                return unresolved('conflict');
+            if (rule.kind === 'listed' && (candidates.rows.length !== 1 || candidates.unreadableRows !== 0))
+                return unresolved('conflict');
+            return { kind: 'connect', engine: picked, rule };
+        }
+        if (rule.kind === 'unlisted')
+            return unresolved('rule-unlisted');
+        if (rule.word === 'only-one')
+            return unresolved('conflict');
+        if (candidates === undefined)
+            return unresolved('candidates');
+        if (rule.word === 'none') {
+            if (candidates.rows.length === 0 && candidates.unreadableRows === 0)
+                return { kind: 'no-engine' };
+            return unresolved('conflict');
+        }
+        if (candidates.rows.length === 0)
+            return unresolved('candidates');
+        return candidates.rows.length + candidates.unreadableRows >= 2 ? { kind: 'choose', candidates } : unresolved('conflict');
+    }
+    catch {
+        return { kind: 'unresolved', reason: 'body', rule: UNREADABLE, candidates: undefined };
+    }
+}
+export function engineOverrideOf(set, requested) {
+    try {
+        if (typeof requested !== 'string' || requested === '')
+            return { kind: 'invalid' };
+        if (set === undefined)
+            return { kind: 'unreadable' };
+        const hits = set.rows.filter((row) => row.name === requested);
+        const hidden = set.unreadableNames.filter((name) => name === requested).length;
+        if (hits.length + hidden > 1)
+            return { kind: 'duplicate', name: requested };
+        if (hits.length === 1)
+            return { kind: 'select', engine: hits[0] };
+        if (hidden === 1)
+            return { kind: 'row-unreadable', name: requested };
+        return { kind: 'not-listed', candidates: set };
+    }
+    catch {
+        return { kind: 'unreadable' };
+    }
+}

package/dist/engineEnvSourcing.d.ts

@@ -0,0 +1,53 @@
+export interface EngineEnvView {
+    raw(key: string): string | undefined;
+    get(key: string): string | undefined;
+}
+export interface EngineEnvGroupDecl {
+    readonly id: string;
+    readonly safety: boolean;
+    readonly keys: readonly string[];
+    readonly dropKeys: readonly string[];
+    refuses(view: EngineEnvView): boolean;
+    readonly skippable?: boolean;
+}
+export interface EngineEnvSourcingInput {
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly caseInsensitive: boolean;
+    readonly sources: ReadonlyArray<{
+        readonly source: string;
+        readonly keys: readonly string[];
+    }>;
+    ignored(key: string, source: string): boolean;
+    readonly aliases?: ReadonlyArray<readonly [from: string, to: string]>;
+    readonly groups: readonly EngineEnvGroupDecl[];
+}
+export interface EngineEnvTouchedKey {
+    readonly key: string;
+    readonly written: string;
+    readonly source: string;
+}
+export interface EngineEnvGroupReading {
+    readonly id: string;
+    readonly touched: readonly EngineEnvTouchedKey[];
+    readonly refuses: boolean;
+    readonly action: 'none' | 'skip' | 'refuse-explained';
+    readonly own: readonly string[];
+}
+export type EngineEnvKeyReason = {
+    readonly key: string;
+    readonly reason: 'repo-half-ignored';
+    readonly written: string;
+    readonly source: string;
+    readonly groups: readonly string[];
+} | {
+    readonly key: string;
+    readonly reason: 'dropped-with-group';
+    readonly groups: readonly string[];
+};
+export interface EngineEnvSourcingVerdict {
+    readonly drop: readonly string[];
+    readonly groups: readonly EngineEnvGroupReading[];
+    readonly keys: readonly EngineEnvKeyReason[];
+}
+export declare function engineEnvView(env: Readonly<Record<string, string | undefined>>, caseInsensitive: boolean): EngineEnvView;
+export declare function resolveEngineEnvSourcing(input: EngineEnvSourcingInput): EngineEnvSourcingVerdict;

package/dist/engineEnvSourcing.js

@@ -0,0 +1,81 @@
+export function engineEnvView(env, caseInsensitive) {
+    const raw = (key) => {
+        const direct = env[key];
+        if (direct !== undefined || !caseInsensitive)
+            return direct;
+        const upper = key.toUpperCase();
+        for (const [k, v] of Object.entries(env))
+            if (k.toUpperCase() === upper)
+                return v;
+        return undefined;
+    };
+    return { raw, get: (key) => { const v = raw(key); return v === undefined || v === '' ? undefined : v; } };
+}
+function safely(f) {
+    try {
+        return f() === true;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveEngineEnvSourcing(input) {
+    const view = engineEnvView(input.env, input.caseInsensitive === true);
+    const alias = new Map((input.aliases ?? []).map(([from, to]) => [from.toUpperCase(), to.toUpperCase()]));
+    const repo = new Map();
+    for (const { source, keys } of input.sources) {
+        for (const k of keys) {
+            if (!safely(() => input.ignored(k, source)))
+                continue;
+            const upper = k.toUpperCase();
+            repo.set(upper, { source, written: k });
+            const target = alias.get(upper);
+            if (target !== undefined && !repo.has(target))
+                repo.set(target, { source, written: k });
+        }
+    }
+    const drop = [];
+    const groups = [];
+    const halfRows = new Map();
+    const dropRows = new Map();
+    for (const g of input.groups) {
+        const touched = [];
+        for (const k of g.keys) {
+            const hit = repo.get(k);
+            if (hit !== undefined && view.get(k) === undefined)
+                touched.push({ key: k, written: hit.written, source: hit.source });
+        }
+        const refuses = touched.length > 0 && safely(() => g.refuses(view));
+        let action = 'none';
+        let own = [];
+        if (refuses) {
+            own = g.dropKeys.filter((k) => view.raw(k) !== undefined);
+            if (g.safety || g.skippable === false)
+                action = 'refuse-explained';
+            else {
+                action = 'skip';
+                drop.push(...g.dropKeys);
+                for (const k of g.dropKeys) {
+                    const row = dropRows.get(k);
+                    if (row === undefined)
+                        dropRows.set(k, { key: k, groups: [g.id] });
+                    else if (!row.groups.includes(g.id))
+                        row.groups.push(g.id);
+                }
+            }
+            for (const t of touched) {
+                const row = halfRows.get(t.key);
+                if (row === undefined)
+                    halfRows.set(t.key, { ...t, groups: [g.id] });
+                else if (!row.groups.includes(g.id))
+                    row.groups.push(g.id);
+            }
+        }
+        groups.push({ id: g.id, touched, refuses, action, own });
+    }
+    const keys = [
+        ...[...halfRows.values()].map((r) => ({ key: r.key, reason: 'repo-half-ignored', written: r.written, source: r.source, groups: r.groups })),
+        ...[...dropRows.values()].map((r) => ({ key: r.key, reason: 'dropped-with-group', groups: r.groups })),
+    ];
+    return { drop, groups, keys };
+}

package/dist/engineErrorCodes.d.ts

@@ -18,7 +18,6 @@ export declare const CONFIG_IMAGE_INVALID = "config.image_invalid";
 export declare function imageInvalidFailureNoteOf(code: string | undefined): string | undefined;
 export declare const CONFIG_AGENT_UNKNOWN_TOOL = "config.agent.unknown_tool";
 export declare const CONFIG_OUTPUT_STYLE_INVALID = "config.output_style_invalid";
-export declare const CONFIG_REFUSAL_CODES: ReadonlySet<string>;
 export declare const RULES_LEGACY_TOOL_NAME = "rules.legacy_tool_name";
 export declare function isRulesRefusalCode(code: string | undefined): boolean;
 export declare const DELEGATION_CONCURRENCY_CAP = "delegation.concurrency_cap";
@@ -33,8 +32,18 @@ export declare const TOOL_END_INTERRUPTED_NEVER_STARTED = "interrupted_never_sta
 export declare const TOOL_END_INTERRUPTED_OUTCOME_UNKNOWN = "interrupted_outcome_unknown";
 export declare function isInterruptedToolEndCode(code: string | undefined): boolean;
 export declare const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = "capability.self_orchestration_required";
+export declare const CAPABILITY_IMAGE_INDEX_REQUIRED = "capability.image_index_required";
 export declare const GATE_PARKED_ERROR_CODE = "gate.parked";
 export declare const ACTIVE_RUN_BUSY_ERROR_CODE = "conflict.session_active_run";
+export interface BusyClassification {
+    readonly busy: boolean;
+    readonly handle: string | null;
+}
+export declare function classifyActiveRunBusy(input: {
+    errorCode: string | undefined;
+    activeTaskId: unknown;
+}): BusyClassification;
+export declare function activeRunBusyCarrierOf(ev: unknown): Record<string, unknown> | null;
 export declare const CORRUPT_SESSION_ERROR_CODE = "corrupt_session";
 export declare function isCorruptSessionCode(code: string | null | undefined): boolean;
 export declare const STOP_PARK_ARBITER_UNREACHABLE = "stop.park_arbiter_unreachable";
@@ -56,7 +65,12 @@ export declare const RESUME_SESSION_NOT_FOUND = "resume.session_not_found";
 export declare const REQUEST_FIELD_CONFLICT = "request.field_conflict";
 export declare const REQUEST_AUTONOMY_LANE_REFUSED = "request.autonomy_lane_refused";
 export declare const CHECKPOINT_UNSUPPORTED_VERSION = "checkpoint.unsupported_version";
+export declare const CHECKPOINT_WALLTIME_AXIS_RETIRED = "checkpoint.walltime_axis_retired";
+export declare const CHECKPOINT_CONFIG_REFUSED = "checkpoint.config_refused";
+export declare const CHECKPOINT_REFUSED_PARK_CODES: readonly string[];
+export declare function isRefusedParkCode(code: string | null | undefined): code is typeof CHECKPOINT_UNSUPPORTED_VERSION | typeof CHECKPOINT_WALLTIME_AXIS_RETIRED | typeof CHECKPOINT_CONFIG_REFUSED;
 export declare function refusalSaysStillPending(err: object): boolean;
+export declare function refusalRetriableReading(err: object): boolean | undefined;
 export type StatusDerivedCoarseCode = (typeof STATUS_DERIVED_COARSE_CODES)[number];
 export declare const RESUME_PLACEMENT_MISMATCH = "resume.placement_mismatch";
 export declare const RESUME_CONTEXT_UNAVAILABLE = "conflict.resume_context_unavailable";
@@ -76,13 +90,23 @@ export declare const DECIDE_GATE_MOVED = "decide.gate_moved";
 export declare const DECIDE_CLAIM_LOST = "decide.claim_lost";
 export declare const DECIDE_PARK_MOVED_CODES: readonly string[];
 export declare function isDecideParkMovedCode(code: string | null | undefined): boolean;
+export declare const APPROVAL_STALE = "approval_stale";
+export declare const APPROVAL_BINDING_MISMATCH = "approval_binding_mismatch";
+export declare const RESUME_OUTCOME_INVALID = "resume_outcome_invalid";
+export declare const CHECKPOINT_ALREADY_RESOLVED = "checkpoint.already_resolved";
+export declare const NOT_FOUND_APPROVAL = "not_found.approval";
+export declare const NOT_FOUND_CHECKPOINT = "not_found.checkpoint";
+export declare const NOT_FOUND_BLOB = "not_found.blob";
+export declare const DECIDE_ALREADY_RESOLVED_CODES: readonly string[];
+export declare function isDecideAlreadyResolvedCode(code: string | null | undefined): boolean;
 export declare const ASK_GONE = "gone.ask";
+export declare const ASK_GONE_PARKED = "gone.ask_parked";
 export declare const ASK_GONE_DENIED_WORD: "routing_failure_fail_closed";
-export declare const RUN_STALLED = "run.stalled";
-export declare const RUN_ORPHANED = "run.orphaned";
-export declare const APPROVAL_EXPIRED = "approval.expired";
 export declare const RUN_DEATH_VERDICT_CODES: readonly ["run.stalled", "run.orphaned", "approval.expired"];
 export type RunDeathVerdictCode = (typeof RUN_DEATH_VERDICT_CODES)[number];
+export declare const RUN_STALLED: "run.stalled";
+export declare const RUN_ORPHANED: "run.orphaned";
+export declare const APPROVAL_EXPIRED: "approval.expired";
 export declare function runDeathVerdictNoteOf(code: string | undefined): string | undefined;
 export declare const CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED = "capability.operator_principals_required";
 export declare const COMPACT_NOT_RUNNING = "compact.not_running";

package/dist/engineErrorCodes.js

@@ -1,6 +1,5 @@
 import { frozenSet } from './frozenSet.js';
-import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
-import { SDK_DENY_REASON_ROUTING_FAILURE, SDK_STATUS_DERIVED_COARSE_CODES } from './generated/sdkFactTables.js';
+import { SDK_DENY_REASON_ROUTING_FAILURE, SDK_RUN_DEATH_VERDICT_CODES, SDK_STATUS_DERIVED_COARSE_CODES } from './generated/sdkFactTables.js';
 export const LIMITS_MAX_TOKENS_EXCEEDED = 'limits.max_tokens_exceeded';
 export const LIMITS_MAX_COST_EXCEEDED = 'limits.max_cost_exceeded';
 export const LIMITS_MAX_TURNS_EXCEEDED = 'limits.max_turns_exceeded';
@@ -28,20 +27,6 @@ export function imageInvalidFailureNoteOf(code) {
 }
 export const CONFIG_AGENT_UNKNOWN_TOOL = 'config.agent.unknown_tool';
 export const CONFIG_OUTPUT_STYLE_INVALID = 'config.output_style_invalid';
-export const CONFIG_REFUSAL_CODES = frozenSet([
-    CONFIG_LIMIT_INVALID,
-    CONFIG_STRATEGY_FIND_LIMIT_INVALID,
-    CONFIG_STRATEGY_MAX_SIZE_INVALID,
-    CONFIG_LIMIT_UNKNOWN_KEY,
-    CONFIG_DELEGATION_ENTRY_CAPS,
-    CONFIG_MEMORY_PROJECT_KEY_SPELLING,
-    CONFIG_MEMORY_WRITE_SCOPE_MISMATCH,
-    CONFIG_LEGACY_TOOL_NAME,
-    CONFIG_IMAGE_INVALID,
-    CONFIG_AGENT_UNKNOWN_TOOL,
-    CONFIG_OUTPUT_STYLE_INVALID,
-    ...CORE_TOOL_DECLARATION_CODES,
-]);
 export const RULES_LEGACY_TOOL_NAME = 'rules.legacy_tool_name';
 const RULES_ERROR_CODE_PREFIX = 'rules.';
 export function isRulesRefusalCode(code) {
@@ -77,8 +62,35 @@ export function isInterruptedToolEndCode(code) {
     return typeof code === 'string' && TOOL_END_INTERRUPTED_CODES.has(code);
 }
 export const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = 'capability.self_orchestration_required';
+export const CAPABILITY_IMAGE_INDEX_REQUIRED = 'capability.image_index_required';
 export const GATE_PARKED_ERROR_CODE = 'gate.parked';
 export const ACTIVE_RUN_BUSY_ERROR_CODE = 'conflict.session_active_run';
+export function classifyActiveRunBusy(input) {
+    const handle = typeof input.activeTaskId === 'string' && input.activeTaskId.length > 0 ? input.activeTaskId : null;
+    if (input.errorCode === ACTIVE_RUN_BUSY_ERROR_CODE)
+        return { busy: true, handle };
+    if (typeof input.activeTaskId === 'string')
+        return { busy: true, handle };
+    return { busy: false, handle };
+}
+export function activeRunBusyCarrierOf(ev) {
+    if (typeof ev !== 'object' || ev === null || !('type' in ev))
+        return null;
+    const type = ev.type;
+    if (type === 'failed')
+        return ev;
+    if (type !== 'done')
+        return null;
+    const result = ev.result;
+    if (typeof result !== 'object' || result === null)
+        return null;
+    const status = result.status;
+    if (status === 'failed')
+        return result;
+    if (status === undefined && !Array.isArray(result) && Object.hasOwn(result, 'terminal'))
+        return result;
+    return null;
+}
 export const CORRUPT_SESSION_ERROR_CODE = 'corrupt_session';
 export function isCorruptSessionCode(code) {
     return code === CORRUPT_SESSION_ERROR_CODE;
@@ -112,12 +124,25 @@ export const RESUME_SESSION_NOT_FOUND = 'resume.session_not_found';
 export const REQUEST_FIELD_CONFLICT = 'request.field_conflict';
 export const REQUEST_AUTONOMY_LANE_REFUSED = 'request.autonomy_lane_refused';
 export const CHECKPOINT_UNSUPPORTED_VERSION = 'checkpoint.unsupported_version';
+export const CHECKPOINT_WALLTIME_AXIS_RETIRED = 'checkpoint.walltime_axis_retired';
+export const CHECKPOINT_CONFIG_REFUSED = 'checkpoint.config_refused';
+export const CHECKPOINT_REFUSED_PARK_CODES = Object.freeze([
+    CHECKPOINT_UNSUPPORTED_VERSION,
+    CHECKPOINT_WALLTIME_AXIS_RETIRED,
+    CHECKPOINT_CONFIG_REFUSED,
+]);
+export function isRefusedParkCode(code) {
+    return typeof code === 'string' && CHECKPOINT_REFUSED_PARK_CODES.includes(code);
+}
 export function refusalSaysStillPending(err) {
+    return refusalRetriableReading(err) === true;
+}
+export function refusalRetriableReading(err) {
     try {
         return Object.hasOwn(err, 'retriable') && err.retriable === true;
     }
     catch {
-        return false;
+        return undefined;
     }
 }
 export const RESUME_PLACEMENT_MISMATCH = 'resume.placement_mismatch';
@@ -156,25 +181,43 @@ export const DECIDE_PARK_MOVED_CODES = Object.freeze([
 export function isDecideParkMovedCode(code) {
     return typeof code === 'string' && DECIDE_PARK_MOVED_CODES.includes(code);
 }
+export const APPROVAL_STALE = 'approval_stale';
+export const APPROVAL_BINDING_MISMATCH = 'approval_binding_mismatch';
+export const RESUME_OUTCOME_INVALID = 'resume_outcome_invalid';
+export const CHECKPOINT_ALREADY_RESOLVED = 'checkpoint.already_resolved';
+export const NOT_FOUND_APPROVAL = 'not_found.approval';
+export const NOT_FOUND_CHECKPOINT = 'not_found.checkpoint';
+export const NOT_FOUND_BLOB = 'not_found.blob';
+export const DECIDE_ALREADY_RESOLVED_CODES = Object.freeze([
+    APPROVAL_STALE,
+    CHECKPOINT_ALREADY_RESOLVED,
+    NOT_FOUND_APPROVAL,
+    NOT_FOUND_CHECKPOINT,
+]);
+export function isDecideAlreadyResolvedCode(code) {
+    return typeof code === 'string' && DECIDE_ALREADY_RESOLVED_CODES.includes(code);
+}
 export const ASK_GONE = 'gone.ask';
+export const ASK_GONE_PARKED = 'gone.ask_parked';
 export const ASK_GONE_DENIED_WORD = SDK_DENY_REASON_ROUTING_FAILURE;
+export const RUN_DEATH_VERDICT_CODES = SDK_RUN_DEATH_VERDICT_CODES;
+const _runDeathVerdictCodePin = true;
+void _runDeathVerdictCodePin;
 export const RUN_STALLED = 'run.stalled';
 export const RUN_ORPHANED = 'run.orphaned';
 export const APPROVAL_EXPIRED = 'approval.expired';
-export const RUN_DEATH_VERDICT_CODES = Object.freeze([RUN_STALLED, RUN_ORPHANED, APPROVAL_EXPIRED]);
 const RUN_HOLDER_LOST_OUTLET = 'The request itself was not at fault, but this run cannot be picked up again; submit the work again as a new task.';
 const RUN_ORPHANED_NOTE = 'This run ended because the engine process that was running it went away (it was restarted) before the run finished. ' + RUN_HOLDER_LOST_OUTLET;
 const RUN_STALLED_NOTE = 'This run ended because the engine process that was running it stopped reporting in before the run finished. ' + RUN_HOLDER_LOST_OUTLET;
 const RUN_APPROVAL_EXPIRED_NOTE = 'This run ended because it was waiting on an approval for too long and the engine retired it. ' +
     'The request itself was not at fault, but this run cannot be picked up again; submit the work again as a new task, and it will ask for the approval again.';
+const RUN_DEATH_VERDICT_NOTES = Object.freeze({
+    [RUN_STALLED]: RUN_STALLED_NOTE,
+    [RUN_ORPHANED]: RUN_ORPHANED_NOTE,
+    [APPROVAL_EXPIRED]: RUN_APPROVAL_EXPIRED_NOTE,
+});
 export function runDeathVerdictNoteOf(code) {
-    if (code === RUN_ORPHANED)
-        return RUN_ORPHANED_NOTE;
-    if (code === RUN_STALLED)
-        return RUN_STALLED_NOTE;
-    if (code === APPROVAL_EXPIRED)
-        return RUN_APPROVAL_EXPIRED_NOTE;
-    return undefined;
+    return typeof code === 'string' && Object.hasOwn(RUN_DEATH_VERDICT_NOTES, code) ? RUN_DEATH_VERDICT_NOTES[code] : undefined;
 }
 export const CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED = 'capability.operator_principals_required';
 export const COMPACT_NOT_RUNNING = 'compact.not_running';

package/dist/engineIdentity.js

@@ -1,3 +1,5 @@
+const _startedAtIsOneQuantity = [true, true, true, true];
+void _startedAtIsOneQuantity;
 export const ENGINE_IDENTITY_ANCHORS = Object.freeze([
     'startedAt',
     'instanceId',

package/dist/engineNoticeCodes.d.ts

@@ -171,6 +171,7 @@ export type ToolTurnIncompleteCause = (typeof CORE_TOOL_TURN_INCOMPLETE_CAUSES)[
 export interface ToolTurnIncompleteFactsView {
     cause: string;
     count: number;
+    outcome?: string;
     toolCallIds?: readonly string[];
     sessionId: string;
     runId: string;
@@ -201,6 +202,20 @@ 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 declare function readFinishReasonUnknown(notice: unknown): FinishReasonUnknownFactsView | undefined;
+export interface StreamEndIgnoredFactsView {
+    statement: string;
+    word: string;
+    frames: number;
+    sessionId: string;
+    runId: string;
+}
+export declare function readStreamEndIgnored(notice: unknown): StreamEndIgnoredFactsView | undefined;
 export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'mcp.injection_dropped': typeof readMcpInjectionDrop;
     readonly 'delegation.ask_unresolvable': typeof readAskUnresolvable;
@@ -223,6 +238,8 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'task.user_steer_undrained': typeof readUserInputUndrained;
     readonly 'task.user_followup_undrained': typeof readUserInputUndrained;
     readonly 'task.turn_interrupted': typeof readTurnInterrupted;
+    readonly 'route.finish_reason_unknown': typeof readFinishReasonUnknown;
+    readonly 'route.stream_end_ignored': typeof readStreamEndIgnored;
 }>;
 type FactReaderTable = typeof ENGINE_NOTICE_FACT_READERS;
 export type EngineNoticeFactsCode = keyof FactReaderTable;