@sema-agent/client-core 0.95.0 → 0.96.0

package/dist/engineCapsCache.d.ts

@@ -14,10 +14,13 @@ export declare function engineCapStateVia(baseUrl: string | undefined, key: stri
 }): 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 declare function engineCapNestedValue(baseUrl: string | undefined, parentKey: string, key: string): EngineCapValueState;
 export type EngineCapValueState = {
     kind: 'unobserved';
 } | {
     kind: 'not_reported';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'null';
 } | {
@@ -27,4 +30,7 @@ export type EngineCapValueState = {
 export declare function engineCapValue(baseUrl: string | undefined, key: string): EngineCapValueState;
 export declare function engineCapString(baseUrl: string | undefined, key: string): string | undefined;
 export declare function invalidateEngineCaps(baseUrl: string | undefined, probe?: () => Promise<unknown>): void;
+export declare function refreshEngineCapsOnce(baseUrl: string | undefined, opts?: {
+    withinMs?: number;
+}): Promise<'settled' | 'timed_out' | 'no_probe'>;
 export declare function __resetEngineCapsCacheForTests(): void;

package/dist/engineCapsCache.js

@@ -1,7 +1,11 @@
+import { settleWithinDeadline } from './abortableSleep.js';
+import { ownDataField } from './ownKey.js';
 const capsByBase = new Map();
 const inFlight = new Set();
 const settleByBase = new Map();
 const genByBase = new Map();
+const probeByBase = new Map();
+const refreshByBase = new Map();
 function capsGeneration(baseUrl) {
     return genByBase.get(baseUrl) ?? 0;
 }
@@ -14,6 +18,7 @@ export function engineCapsLandingOf(baseUrl) {
 export function kickEngineCapsProbe(baseUrl, probe) {
     if (!baseUrl || capsByBase.has(baseUrl) || inFlight.has(baseUrl))
         return;
+    probeByBase.set(baseUrl, probe);
     const gen = capsGeneration(baseUrl);
     inFlight.add(baseUrl);
     let wake = () => { };
@@ -30,9 +35,8 @@ export function kickEngineCapsProbe(baseUrl, probe) {
             const caps = await probe();
             if (gen !== capsGeneration(baseUrl))
                 return;
-            if (caps && typeof caps === 'object') {
-                capsByBase.set(baseUrl, Object.freeze({ caps: caps }));
-            }
+            if (caps && typeof caps === 'object')
+                landCapsSnapshot(baseUrl, gen, caps);
         }
         catch {
         }
@@ -118,21 +122,132 @@ export function engineCapState(baseUrl, key) {
         return 'unprobed';
     return capStateIn(capsByBase.get(baseUrl)?.caps, key);
 }
-function capStateIn(caps, key) {
+const SNAPSHOT_MAX_DEPTH = 64;
+const SNAPSHOT_MAX_NODES = 100_000;
+const SNAPSHOT_PROBE_KEY = '\u0000capabilities-snapshot-probe\u0000';
+const FOREIGN_PROTOTYPE = Object.freeze(Object.create(null));
+function unreadableError() {
+    return new TypeError('capabilities body position is not readable (accessor or throwing proxy)');
+}
+const UNREADABLE_NODE = new Proxy(Object.freeze({}), {
+    getOwnPropertyDescriptor: () => {
+        throw unreadableError();
+    },
+    ownKeys: () => {
+        throw unreadableError();
+    },
+    has: () => {
+        throw unreadableError();
+    },
+    get: () => {
+        throw unreadableError();
+    },
+    getPrototypeOf: () => {
+        throw unreadableError();
+    },
+});
+function throwingAccessor() {
+    return {
+        get: () => {
+            throw unreadableError();
+        },
+        enumerable: true,
+        configurable: false,
+    };
+}
+function landCapsSnapshot(baseUrl, gen, caps) {
+    const snapshot = snapshotCapsBody(caps);
+    if (gen !== capsGeneration(baseUrl))
+        return;
+    capsByBase.set(baseUrl, Object.freeze({ caps: snapshot }));
+}
+function snapshotCapsBody(body) {
+    if (body === null || typeof body !== 'object')
+        return body;
+    const seen = new WeakMap();
+    let nodes = 0;
+    const copy = (src, depth) => {
+        const known = seen.get(src);
+        if (known !== undefined)
+            return known;
+        if (depth > SNAPSHOT_MAX_DEPTH || ++nodes > SNAPSHOT_MAX_NODES)
+            return UNREADABLE_NODE;
+        let keys;
+        let out;
+        let isArray;
+        try {
+            isArray = Array.isArray(src);
+            keys = Object.getOwnPropertyNames(src);
+            Object.getOwnPropertyDescriptor(src, SNAPSHOT_PROBE_KEY);
+            let length = 0;
+            if (isArray) {
+                const ld = Object.getOwnPropertyDescriptor(src, 'length');
+                if (ld === undefined || !Object.hasOwn(ld, 'value') || typeof ld.value !== 'number')
+                    return UNREADABLE_NODE;
+                length = ld.value;
+            }
+            const proto = isArray ? null : Object.getPrototypeOf(src);
+            out = isArray ? new Array(length) : proto === Object.prototype || proto === null ? {} : Object.create(FOREIGN_PROTOTYPE);
+        }
+        catch {
+            return UNREADABLE_NODE;
+        }
+        seen.set(src, out);
+        for (const k of keys) {
+            if (isArray && k === 'length')
+                continue;
+            let d;
+            try {
+                d = Object.getOwnPropertyDescriptor(src, k);
+            }
+            catch {
+                Object.defineProperty(out, k, throwingAccessor());
+                continue;
+            }
+            if (d === undefined)
+                continue;
+            if (!Object.hasOwn(d, 'value')) {
+                Object.defineProperty(out, k, throwingAccessor());
+                continue;
+            }
+            const v = d.value;
+            Object.defineProperty(out, k, {
+                value: v !== null && typeof v === 'object' ? copy(v, depth + 1) : v,
+                enumerable: d.enumerable === true,
+                writable: false,
+                configurable: false,
+            });
+        }
+        Object.freeze(out);
+        return out;
+    };
+    return copy(body, 0);
+}
+const SLOT_UNOBSERVED = Object.freeze({ kind: 'unobserved' });
+const SLOT_ABSENT = Object.freeze({ kind: 'absent' });
+const SLOT_UNREADABLE = Object.freeze({ kind: 'unreadable' });
+function capSlotIn(caps, key) {
     if (caps === undefined || caps === null || typeof caps !== 'object')
-        return 'unprobed';
+        return SLOT_UNOBSERVED;
     try {
-        if (!(key in caps))
-            return 'absent';
-        const v = caps[key];
-        if (v === true)
-            return 'true';
-        if (v === false)
-            return 'false';
-        return 'non_boolean';
+        const v = ownDataField(caps, key);
+        return v === undefined ? SLOT_ABSENT : { kind: 'present', value: v };
     }
     catch {
-        return 'unprobed';
+        return SLOT_UNREADABLE;
+    }
+}
+function capStateIn(caps, key) {
+    const slot = capSlotIn(caps, key);
+    switch (slot.kind) {
+        case 'unobserved':
+            return 'unprobed';
+        case 'absent':
+            return 'absent';
+        case 'unreadable':
+            return 'non_boolean';
+        case 'present':
+            return slot.value === true ? 'true' : slot.value === false ? 'false' : 'non_boolean';
     }
 }
 async function untilSettledOrAborted(p, signal) {
@@ -178,37 +293,48 @@ export function engineCapTrue(baseUrl, key) {
     return engineCapState(baseUrl, key) === 'true';
 }
 export function engineCapNestedTrue(baseUrl, parentKey, key) {
+    const state = engineCapNestedValue(baseUrl, parentKey, key);
+    return state.kind === 'value' && state.value === true;
+}
+export function engineCapNestedValue(baseUrl, parentKey, key) {
     if (!baseUrl)
-        return false;
-    const parent = capsByBase.get(baseUrl)?.caps[parentKey];
-    if (parent === null || typeof parent !== 'object')
-        return false;
-    return parent[key] === true;
+        return { kind: 'unobserved' };
+    const parent = capSlotIn(capsByBase.get(baseUrl)?.caps, parentKey);
+    if (parent.kind !== 'present')
+        return valueStateOfSlot(parent);
+    const group = parent.value;
+    if (group === null || typeof group !== 'object')
+        return { kind: 'not_reported' };
+    return valueStateOfSlot(capSlotIn(group, key));
 }
 export function engineCapValue(baseUrl, key) {
     if (!baseUrl)
         return { kind: 'unobserved' };
-    const caps = capsByBase.get(baseUrl)?.caps;
-    if (caps === undefined)
-        return { kind: 'unobserved' };
-    if (!(key in caps))
-        return { kind: 'not_reported' };
-    const v = caps[key];
-    if (v === undefined)
-        return { kind: 'not_reported' };
-    if (v === null)
-        return { kind: 'null' };
-    return { kind: 'value', value: v };
+    return valueStateOfSlot(capSlotIn(capsByBase.get(baseUrl)?.caps, key));
+}
+function valueStateOfSlot(slot) {
+    switch (slot.kind) {
+        case 'unobserved':
+            return { kind: 'unobserved' };
+        case 'absent':
+            return { kind: 'not_reported' };
+        case 'unreadable':
+            return { kind: 'unreadable' };
+        case 'present':
+            return slot.value === null ? { kind: 'null' } : { kind: 'value', value: slot.value };
+    }
 }
 export function engineCapString(baseUrl, key) {
     if (!baseUrl)
         return undefined;
-    const v = capsByBase.get(baseUrl)?.caps[key];
-    return typeof v === 'string' && v.length > 0 ? v : undefined;
+    const slot = capSlotIn(capsByBase.get(baseUrl)?.caps, key);
+    return slot.kind === 'present' && typeof slot.value === 'string' && slot.value.length > 0 ? slot.value : undefined;
 }
 export function invalidateEngineCaps(baseUrl, probe) {
     if (!baseUrl)
         return;
+    if (probe === undefined)
+        probeByBase.delete(baseUrl);
     const hadState = capsByBase.has(baseUrl) ||
         inFlight.has(baseUrl) ||
         settleByBase.has(baseUrl) ||
@@ -222,9 +348,77 @@ export function invalidateEngineCaps(baseUrl, probe) {
     if (probe !== undefined)
         kickEngineCapsProbe(baseUrl, probe);
 }
+export async function refreshEngineCapsOnce(baseUrl, opts) {
+    try {
+        if (typeof baseUrl !== 'string' || baseUrl === '')
+            return 'no_probe';
+        const budget = waitBudgetOf(opts);
+        const probe = probeByBase.get(baseUrl);
+        if (probe === undefined)
+            return 'no_probe';
+        const flying = refreshByBase.get(baseUrl);
+        if (flying !== undefined && flying.gen === capsGeneration(baseUrl))
+            return await awaitRefreshWithin(flying, budget);
+        if (!capsByBase.has(baseUrl)) {
+            kickEngineCapsProbe(baseUrl, probe);
+            return await engineCapsSettled(baseUrl, budget === undefined ? undefined : { withinMs: budget });
+        }
+        const gen = capsGeneration(baseUrl);
+        let finish = () => { };
+        const entry = { gen, promise: new Promise((resolve) => { finish = resolve; }) };
+        refreshByBase.set(baseUrl, entry);
+        void (async () => {
+            try {
+                const caps = await probe();
+                if (gen !== capsGeneration(baseUrl) || !capsByBase.has(baseUrl) || !isPlainCapsBody(caps))
+                    return false;
+                landCapsSnapshot(baseUrl, gen, caps);
+                return gen === capsGeneration(baseUrl);
+            }
+            catch {
+                return false;
+            }
+            finally {
+                if (refreshByBase.get(baseUrl) === entry)
+                    refreshByBase.delete(baseUrl);
+            }
+        })().then(finish);
+        return await awaitRefreshWithin(entry, budget);
+    }
+    catch {
+        return 'timed_out';
+    }
+}
+function isPlainCapsBody(caps) {
+    try {
+        if (typeof caps !== 'object' || caps === null)
+            return false;
+        const proto = Object.getPrototypeOf(caps);
+        if (proto !== null && Object.getPrototypeOf(proto) !== null)
+            return false;
+        for (const key of Reflect.ownKeys(caps))
+            Object.getOwnPropertyDescriptor(caps, key);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function awaitRefreshWithin(entry, budget) {
+    if (budget === undefined) {
+        await entry.promise;
+        return 'settled';
+    }
+    if (budget === 0)
+        return 'timed_out';
+    const out = await settleWithinDeadline(budget, () => entry.promise);
+    return out.kind === 'deadline' ? 'timed_out' : 'settled';
+}
 export function __resetEngineCapsCacheForTests() {
     capsByBase.clear();
     inFlight.clear();
     settleByBase.clear();
     genByBase.clear();
+    probeByBase.clear();
+    refreshByBase.clear();
 }

package/dist/engineDirectory.d.ts

@@ -0,0 +1,79 @@
+declare const KIND_WORDS: readonly ["managed"];
+declare const POSTURE_WORDS: readonly ["single", "multi"];
+declare const RULE_WORDS: readonly ["only-one", "none", "ambiguous"];
+export type EngineKindWord = (typeof KIND_WORDS)[number];
+export type EnginePostureWord = (typeof POSTURE_WORDS)[number];
+export type MeEngineRuleWord = (typeof RULE_WORDS)[number];
+export type OpenWordReading<K extends string> = {
+    readonly kind: 'listed';
+    readonly word: K;
+} | {
+    readonly kind: 'unlisted';
+    readonly word: string;
+} | {
+    readonly kind: 'unreadable';
+};
+export interface EngineRowReading {
+    readonly name: string;
+    readonly kind: OpenWordReading<EngineKindWord>;
+    readonly scope: string | undefined;
+    readonly online: boolean | undefined;
+    readonly posture: OpenWordReading<EnginePostureWord>;
+    readonly viaCenter: string;
+}
+export interface EngineRowSet {
+    readonly rows: readonly EngineRowReading[];
+    readonly unreadableRows: number;
+    readonly unreadableNames: readonly string[];
+}
+export type MeEngineTargetReading = {
+    readonly kind: 'row';
+    readonly row: EngineRowReading;
+} | {
+    readonly kind: 'null';
+} | {
+    readonly kind: 'unreadable';
+};
+export interface MeEngineReading {
+    readonly rule: OpenWordReading<MeEngineRuleWord>;
+    readonly target: MeEngineTargetReading;
+    readonly candidates: EngineRowSet | undefined;
+}
+export type MeEngineUnresolvedReason = 'body' | 'rule' | 'rule-unlisted' | 'target' | 'candidates' | 'conflict';
+export type MeEngineDecision = {
+    readonly kind: 'connect';
+    readonly engine: EngineRowReading;
+    readonly rule: OpenWordReading<MeEngineRuleWord>;
+} | {
+    readonly kind: 'no-engine';
+} | {
+    readonly kind: 'choose';
+    readonly candidates: EngineRowSet;
+} | {
+    readonly kind: 'unresolved';
+    readonly reason: MeEngineUnresolvedReason;
+    readonly rule: OpenWordReading<MeEngineRuleWord>;
+    readonly candidates: EngineRowSet | undefined;
+};
+export type EngineOverrideDecision = {
+    readonly kind: 'select';
+    readonly engine: EngineRowReading;
+} | {
+    readonly kind: 'not-listed';
+    readonly candidates: EngineRowSet;
+} | {
+    readonly kind: 'duplicate';
+    readonly name: string;
+} | {
+    readonly kind: 'row-unreadable';
+    readonly name: string;
+} | {
+    readonly kind: 'unreadable';
+} | {
+    readonly kind: 'invalid';
+};
+export declare function projectEngineDirectory(body: unknown): EngineRowSet | undefined;
+export declare function projectMeEngine(body: unknown): MeEngineReading | undefined;
+export declare function decideMeEngine(reading: MeEngineReading | undefined): MeEngineDecision;
+export declare function engineOverrideOf(set: EngineRowSet | undefined, requested: unknown): EngineOverrideDecision;
+export {};

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/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";
@@ -58,6 +67,8 @@ export declare const REQUEST_AUTONOMY_LANE_REFUSED = "request.autonomy_lane_refu
 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];
@@ -85,9 +96,11 @@ 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_DEATH_VERDICT_CODES: readonly ["run.stalled", "run.orphaned", "approval.expired"];
 export type RunDeathVerdictCode = (typeof RUN_DEATH_VERDICT_CODES)[number];