@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/engineCapReader.js

@@ -1,5 +1,5 @@
-import { snapshotCapsGeneration, capsGenerationStillCurrent } from './engineCapsGenerationGuard.js';
-import { capsGenerationMarkOf, retainCapsGenerationMark } from './engineCapsCache.js';
+import { engineCapsLandingOf } from './engineCapsCache.js';
+import { ownDataField } from './ownKey.js';
 function freezeReading(reading, seen = new Set()) {
     if (reading === null || typeof reading !== 'object' || seen.has(reading))
         return reading;
@@ -11,67 +11,54 @@ function freezeReading(reading, seen = new Set()) {
     }
     return reading;
 }
+const PROJECTING = Symbol('projecting');
 export function createEngineCapReader(spec) {
-    const cellByBase = new Map();
+    let memo = new WeakMap();
     return {
-        note(baseUrl, caps, opts) {
+        note(_baseUrl, _caps, _opts) { },
+        observed(baseUrl) {
             if (typeof baseUrl !== 'string' || baseUrl === '')
-                return;
-            const gen = snapshotCapsGeneration(opts);
-            if (gen === null)
-                return;
-            if (!capsGenerationStillCurrent(baseUrl, gen))
-                return;
-            const mark = retainCapsGenerationMark(baseUrl);
+                return spec.makeUnobserved();
+            const landing = engineCapsLandingOf(baseUrl);
+            if (landing === undefined)
+                return spec.makeUnobserved();
+            const hit = memo.get(landing);
+            if (hit === PROJECTING)
+                return spec.makeUnobserved();
+            if (hit !== undefined)
+                return hit.reading === undefined ? spec.makeUnobserved() : hit.reading;
+            const mine = memo;
+            mine.set(landing, PROJECTING);
             let reading;
             try {
-                reading = spec.project(caps);
+                reading = spec.project(landing.caps);
             }
             catch {
                 reading = undefined;
             }
-            if (capsGenerationMarkOf(baseUrl) !== mark)
-                return;
-            if (reading === undefined) {
-                cellByBase.delete(baseUrl);
-                return;
-            }
-            cellByBase.set(baseUrl, { reading: freezeReading(reading), mark });
-        },
-        observed(baseUrl) {
-            if (typeof baseUrl !== 'string' || baseUrl === '')
-                return spec.makeUnobserved();
-            const cell = cellByBase.get(baseUrl);
-            if (cell === undefined)
-                return spec.makeUnobserved();
-            if (cell.mark !== capsGenerationMarkOf(baseUrl)) {
-                cellByBase.delete(baseUrl);
+            if (engineCapsLandingOf(baseUrl) !== landing) {
+                mine.delete(landing);
                 return spec.makeUnobserved();
             }
-            return cell.reading;
-        },
-        forget(baseUrl) {
-            if (typeof baseUrl !== 'string' || baseUrl === '')
-                return;
-            cellByBase.delete(baseUrl);
+            const done = { reading: reading === undefined ? undefined : freezeReading(reading) };
+            mine.set(landing, done);
+            return done.reading === undefined ? spec.makeUnobserved() : done.reading;
         },
         __resetForTests() {
-            cellByBase.clear();
+            memo = new WeakMap();
         },
     };
 }
-export function capsGenerationOf(caps) {
+export function storeSeatOf(caps) {
     try {
-        if (!Object.hasOwn(caps, 'store'))
-            return { generation: 'old', store: 'absent' };
-        const store = caps.store;
+        const store = ownDataField(caps, 'store');
         if (store === undefined)
-            return { generation: 'old', store: 'absent' };
+            return { kind: 'absent' };
         if (typeof store !== 'object' || store === null || Array.isArray(store))
-            return { generation: 'old', store: 'malformed' };
-        return { generation: 'new', store };
+            return { kind: 'malformed' };
+        return { kind: 'object', store };
     }
     catch {
-        return { generation: 'old', store: 'malformed' };
+        return { kind: 'malformed' };
     }
 }

package/dist/engineCapsCache.d.ts

@@ -1,12 +1,17 @@
 export declare function engineCapsGeneration(baseUrl: string): number;
-export declare function capsGenerationMarkOf(baseUrl: string): object | undefined;
-export declare function retainCapsGenerationMark(baseUrl: string): object;
+export declare function engineCapsLandingOf(baseUrl: string): {
+    readonly caps: object;
+} | undefined;
 export declare function kickEngineCapsProbe(baseUrl: string, probe: () => Promise<unknown>): void;
 export declare function engineCapsSettled(baseUrl: string | undefined, opts?: {
     withinMs?: number;
 }): Promise<'settled' | 'timed_out'>;
 export type EngineCapState = 'true' | 'false' | 'unprobed' | 'absent' | 'non_boolean';
 export declare function engineCapState(baseUrl: string | undefined, key: string): EngineCapState;
+export declare function engineCapStateVia(baseUrl: string | undefined, key: string, probe: (signal?: AbortSignal) => Promise<unknown>, opts?: {
+    withinMs?: number;
+    signal?: AbortSignal;
+}): Promise<EngineCapState>;
 export declare function engineCapTrue(baseUrl: string | undefined, key: string): boolean;
 export declare function engineCapNestedTrue(baseUrl: string | undefined, parentKey: string, key: string): boolean;
 export type EngineCapValueState = {

package/dist/engineCapsCache.js

@@ -3,21 +3,13 @@ const inFlight = new Set();
 const settleByBase = new Map();
 const genByBase = new Map();
 function capsGeneration(baseUrl) {
-    return genByBase.get(baseUrl)?.n ?? 0;
+    return genByBase.get(baseUrl) ?? 0;
 }
 export function engineCapsGeneration(baseUrl) {
     return capsGeneration(baseUrl);
 }
-export function capsGenerationMarkOf(baseUrl) {
-    return genByBase.get(baseUrl);
-}
-export function retainCapsGenerationMark(baseUrl) {
-    let mark = genByBase.get(baseUrl);
-    if (mark === undefined) {
-        mark = Object.freeze({ n: 0 });
-        genByBase.set(baseUrl, mark);
-    }
-    return mark;
+export function engineCapsLandingOf(baseUrl) {
+    return capsByBase.get(baseUrl);
 }
 export function kickEngineCapsProbe(baseUrl, probe) {
     if (!baseUrl || capsByBase.has(baseUrl) || inFlight.has(baseUrl))
@@ -39,7 +31,7 @@ export function kickEngineCapsProbe(baseUrl, probe) {
             if (gen !== capsGeneration(baseUrl))
                 return;
             if (caps && typeof caps === 'object') {
-                capsByBase.set(baseUrl, caps);
+                capsByBase.set(baseUrl, Object.freeze({ caps: caps }));
             }
         }
         catch {
@@ -124,17 +116,63 @@ export async function engineCapsSettled(baseUrl, opts) {
 export function engineCapState(baseUrl, key) {
     if (!baseUrl)
         return 'unprobed';
-    const caps = capsByBase.get(baseUrl);
-    if (caps === undefined)
+    return capStateIn(capsByBase.get(baseUrl)?.caps, key);
+}
+function capStateIn(caps, key) {
+    if (caps === undefined || caps === null || typeof caps !== 'object')
         return 'unprobed';
-    if (!(key in caps))
-        return 'absent';
-    const v = caps[key];
-    if (v === true)
-        return 'true';
-    if (v === false)
-        return 'false';
-    return 'non_boolean';
+    try {
+        if (!(key in caps))
+            return 'absent';
+        const v = caps[key];
+        if (v === true)
+            return 'true';
+        if (v === false)
+            return 'false';
+        return 'non_boolean';
+    }
+    catch {
+        return 'unprobed';
+    }
+}
+async function untilSettledOrAborted(p, signal) {
+    if (signal === undefined) {
+        await p.catch(() => undefined);
+        return;
+    }
+    if (signal.aborted)
+        return;
+    let onAbort;
+    const aborted = new Promise((resolve) => {
+        onAbort = () => resolve();
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+    try {
+        await Promise.race([p.then(() => undefined, () => undefined), aborted]);
+    }
+    finally {
+        if (onAbort !== undefined)
+            signal.removeEventListener('abort', onAbort);
+    }
+}
+export async function engineCapStateVia(baseUrl, key, probe, opts) {
+    const signal = opts?.signal;
+    if (!baseUrl) {
+        try {
+            if (signal?.aborted)
+                return 'unprobed';
+            return capStateIn(await probe(signal), key);
+        }
+        catch {
+            return 'unprobed';
+        }
+    }
+    const now = engineCapState(baseUrl, key);
+    if (now !== 'unprobed')
+        return now;
+    kickEngineCapsProbe(baseUrl, () => probe());
+    await untilSettledOrAborted(engineCapsSettled(baseUrl, opts?.withinMs !== undefined ? { withinMs: opts.withinMs } : undefined), signal);
+    return engineCapState(baseUrl, key);
 }
 export function engineCapTrue(baseUrl, key) {
     return engineCapState(baseUrl, key) === 'true';
@@ -142,7 +180,7 @@ export function engineCapTrue(baseUrl, key) {
 export function engineCapNestedTrue(baseUrl, parentKey, key) {
     if (!baseUrl)
         return false;
-    const parent = capsByBase.get(baseUrl)?.[parentKey];
+    const parent = capsByBase.get(baseUrl)?.caps[parentKey];
     if (parent === null || typeof parent !== 'object')
         return false;
     return parent[key] === true;
@@ -150,7 +188,7 @@ export function engineCapNestedTrue(baseUrl, parentKey, key) {
 export function engineCapValue(baseUrl, key) {
     if (!baseUrl)
         return { kind: 'unobserved' };
-    const caps = capsByBase.get(baseUrl);
+    const caps = capsByBase.get(baseUrl)?.caps;
     if (caps === undefined)
         return { kind: 'unobserved' };
     if (!(key in caps))
@@ -165,7 +203,7 @@ export function engineCapValue(baseUrl, key) {
 export function engineCapString(baseUrl, key) {
     if (!baseUrl)
         return undefined;
-    const v = capsByBase.get(baseUrl)?.[key];
+    const v = capsByBase.get(baseUrl)?.caps[key];
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
 export function invalidateEngineCaps(baseUrl, probe) {
@@ -176,7 +214,7 @@ export function invalidateEngineCaps(baseUrl, probe) {
         settleByBase.has(baseUrl) ||
         genByBase.has(baseUrl);
     if (hadState) {
-        genByBase.set(baseUrl, Object.freeze({ n: capsGeneration(baseUrl) + 1 }));
+        genByBase.set(baseUrl, capsGeneration(baseUrl) + 1);
         capsByBase.delete(baseUrl);
         inFlight.delete(baseUrl);
         settleByBase.get(baseUrl)?.wake();

package/dist/engineCredentialRequirement.d.ts

@@ -0,0 +1,9 @@
+export type EngineProbeAnswer = {
+    readonly ok: true;
+} | {
+    readonly status: number;
+} | {
+    readonly transport: true;
+};
+export type EngineCredentialNeed = 'open' | 'requires' | 'undetermined';
+export declare function engineCredentialRequirementOf(answer: EngineProbeAnswer): EngineCredentialNeed;

package/dist/engineCredentialRequirement.js

@@ -0,0 +1,23 @@
+export function engineCredentialRequirementOf(answer) {
+    try {
+        const a = answer;
+        if (typeof a !== 'object' || a === null || Array.isArray(a))
+            return 'undetermined';
+        const ok = Object.getOwnPropertyDescriptor(a, 'ok');
+        const status = Object.getOwnPropertyDescriptor(a, 'status');
+        const transport = Object.getOwnPropertyDescriptor(a, 'transport');
+        const arms = (ok !== undefined ? 1 : 0) + (status !== undefined ? 1 : 0) + (transport !== undefined ? 1 : 0);
+        if (arms !== 1)
+            return 'undetermined';
+        if (ok !== undefined)
+            return Object.hasOwn(ok, 'value') && ok.value === true ? 'open' : 'undetermined';
+        if (status !== undefined) {
+            const value = Object.hasOwn(status, 'value') ? status.value : undefined;
+            return value === 401 || value === 403 ? 'requires' : 'undetermined';
+        }
+        return 'undetermined';
+    }
+    catch {
+        return 'undetermined';
+    }
+}

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

@@ -16,6 +16,8 @@ export declare const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = "config.memory_write_s
 export declare const CONFIG_LEGACY_TOOL_NAME = "config.legacy_tool_name";
 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;
@@ -52,8 +54,12 @@ export declare const RESUME_USAGE_WINDOW_EXHAUSTED = "resume.usage_window_exhaus
 export declare const RESUME_PREFLIGHT_REJECTED = "resume.preflight_rejected";
 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 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";
@@ -73,15 +79,24 @@ 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 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_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 ASK_GONE_DENIED_WORD: "routing_failure_fail_closed";
 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";
 export declare function isUnavailableFaceCode(code: string | undefined): boolean;
 export type OperatorGateRefusal = 'operator_only' | 'operators_unconfigured';
 export declare function operatorGateRefusalContent(cause: OperatorGateRefusal): string | undefined;

package/dist/engineErrorCodes.js

@@ -1,5 +1,6 @@
 import { frozenSet } from './frozenSet.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.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';
@@ -25,6 +26,8 @@ const IMAGE_INVALID_FAILURE_NOTE = 'This run did not start: an image sent with t
 export function imageInvalidFailureNoteOf(code) {
     return code === CONFIG_IMAGE_INVALID ? IMAGE_INVALID_FAILURE_NOTE : undefined;
 }
+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,
@@ -35,6 +38,8 @@ export const CONFIG_REFUSAL_CODES = frozenSet([
     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';
@@ -92,17 +97,7 @@ export const STOP_CONFLICT_CODES = Object.freeze([
 ]);
 export const OUTPUT_INVALID = 'output.invalid';
 export const RESUME_POLICY_FOLD_CODE = 'resume_blocked_by_policy';
-export const STATUS_DERIVED_COARSE_CODES = Object.freeze([
-    'request.rejected',
-    'auth.unauthorized',
-    'auth.forbidden',
-    'not_found.resource',
-    'request.payload_too_large',
-    'request.unprocessable',
-    'limit.rate_exceeded',
-    'capability.unavailable',
-    'internal.error',
-]);
+export const STATUS_DERIVED_COARSE_CODES = SDK_STATUS_DERIVED_COARSE_CODES;
 export function isStatusDerivedCoarseCode(code) {
     return typeof code === 'string' && STATUS_DERIVED_COARSE_CODES.includes(code);
 }
@@ -115,13 +110,19 @@ export const RESUME_USAGE_WINDOW_EXHAUSTED = 'resume.usage_window_exhausted';
 export const RESUME_PREFLIGHT_REJECTED = 'resume.preflight_rejected';
 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 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';
@@ -160,27 +161,44 @@ 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 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_DENIED_WORD = 'routing_failure_fail_closed';
+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';
 export function isUnavailableFaceCode(code) {
     return typeof code === 'string' && (code.startsWith('capability.') || code.startsWith('feature.'));
 }

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

@@ -1,4 +1,4 @@
-import { CORE_TOOL_TURN_INCOMPLETE_CAUSES, CORE_USER_INPUT_UNDRAINED_CAUSES } from './generated/engineNoticeTables.js';
+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[];
 export declare function engineNoticeInCatalog(code: unknown): boolean;
@@ -146,8 +146,27 @@ export interface ModelUnreachableFactsView {
     proxyInUse?: string;
     remedy: string;
     sessionId: string;
+    taskId?: string;
 }
 export declare function readModelUnreachable(notice: unknown): ModelUnreachableFactsView | undefined;
+export interface AllowedToolNotGrantedEntryView {
+    source: string;
+    entry: string;
+    entryShown: string;
+    reason: string;
+    skill?: string;
+    skillShown?: string;
+    list?: string;
+    verdict?: string;
+    currentName?: string;
+    currentNameShown?: string;
+    valueType?: string;
+}
+export interface AllowedToolNotGrantedFactsView {
+    entries: readonly AllowedToolNotGrantedEntryView[];
+    sessionId?: string;
+}
+export declare function readAllowedToolNotGranted(notice: unknown): AllowedToolNotGrantedFactsView | undefined;
 export type ToolTurnIncompleteCause = (typeof CORE_TOOL_TURN_INCOMPLETE_CAUSES)[number];
 export interface ToolTurnIncompleteFactsView {
     cause: string;
@@ -159,7 +178,7 @@ export interface ToolTurnIncompleteFactsView {
 export declare function readToolTurnIncomplete(notice: unknown): ToolTurnIncompleteFactsView | undefined;
 export type UserSteerUndrainedCause = (typeof CORE_USER_INPUT_UNDRAINED_CAUSES)[number];
 export interface UserInputUndrainedFactsView {
-    kind: 'steer' | 'followUp';
+    kind: keyof typeof CORE_USER_INPUT_UNDRAINED_FAMILIES;
     count: number;
     cause?: string;
     taskId?: string;
@@ -199,6 +218,7 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'permission.read_deny_unapplied': typeof readReadDenyUnapplied;
     readonly 'context.tool_turn_repaired': typeof readToolTurnRepaired;
     readonly 'server.model_unreachable': typeof readModelUnreachable;
+    readonly 'permission.allowed_tool_not_granted': typeof readAllowedToolNotGranted;
     readonly 'task.tool_turn_incomplete': typeof readToolTurnIncomplete;
     readonly 'task.user_steer_undrained': typeof readUserInputUndrained;
     readonly 'task.user_followup_undrained': typeof readUserInputUndrained;