@sema-agent/client-core 0.90.0 → 0.92.0

package/dist/displayUntrusted.js

@@ -1,3 +1,4 @@
+import { SETTINGS_SECRET_LITERAL_RE } from './generated/settingsSchemaTables.js';
 export const REDACTION_MARKER_PREFIX = '\u00abredacted';
 const MARKER_RE = /^\u00abredacted(?::[a-z-]{1,16}){0,2}\u00bb$/;
 const REDACTED_USERINFO = '\u00abredacted:userinfo\u00bb';
@@ -26,7 +27,7 @@ function pushEdit(edits, src, start, end, text) {
 const UNIT_NONE = 0;
 const UNIT_SEQUENCE = 1;
 const UNIT_SINGLE = 2;
-const SECRET_LITERAL_RE = /^(sk-|gh[opus]_|github_pat_|xox[baprse]-|xapp-|bearer\s|basic\s|eyJ[A-Za-z0-9_-]{10,}\.|AKIA[0-9A-Z]{12,}|AIza[0-9A-Za-z_-]{20,}|-----BEGIN[A-Z0-9 ]*PRIVATE KEY)/i;
+const SECRET_LITERAL_RE = SETTINGS_SECRET_LITERAL_RE;
 const SCHEME_TOKEN_RE = /(?:^|[^A-Za-z0-9_-])(?:bearer|basic)[ \t]+\S{8,4096}/i;
 const JWT_RE = /(?:^|[^A-Za-z0-9_-])eyJ[A-Za-z0-9_-]{8,2048}\.[A-Za-z0-9_-]{8,2048}\.[A-Za-z0-9_-]{4,2048}/i;
 function scanForSecretLiteral(s) {
@@ -1473,7 +1474,7 @@ function quotedAddressEnd(S, from, to) {
     }
     return to;
 }
-function labelCandidates(S, pass, regions, out) {
+function labelCandidates(S, pass, regions, out, blocks) {
     const text = S.text;
     const unitAt = (k) => S.unitAt(k);
     const re = pass === 'label' ? SECRET_LABELLED_WORD : SECRET_SCHEME_WORD;
@@ -1642,6 +1643,11 @@ function labelCandidates(S, pass, regions, out) {
         if (schemePass && labelStartsAt(text, hit.index))
             continue;
         const from = hit.index + hit[0].length;
+        if (blocks !== undefined && (text.charCodeAt(from) === 0x7c || text.charCodeAt(from) === 0x3e) && isColonSeparator(hit[0].slice((hit[1] ?? '').length))) {
+            const blk = blockScalarExtent(blocks, S.rawStart(from), S.rawStart(hit.index));
+            if (blk !== null)
+                blocks.out.push({ start: blk.start, end: blk.end, kind: 'secret', cls: 'word', tokenEnd: blk.end, pretrimmed: true });
+        }
         if (credentialWordStartsAt(text, from, idx.tokenInner)) {
             pushInnerRemainder(from);
             re.lastIndex = from;
@@ -1886,6 +1892,149 @@ function lineBreakLengthBefore(text, at) {
         return 2;
     return 0;
 }
+const isRawBlank = (c) => (isRegexSpace(c) && c !== 0xfeff) || isNameBlank(c);
+function isColonSeparator(sep) {
+    let colon = false;
+    for (let k = 0; k < sep.length; k++) {
+        const c = sep.charCodeAt(k);
+        if (c === 0x3d || c === 0xff1d)
+            return false;
+        if (c === 0x3a || c === 0xff1a)
+            colon = true;
+    }
+    return colon;
+}
+function blockBreakAt(raw, at, escaped) {
+    const n = lineBreakLengthAt(raw, at);
+    return n > 0 && (raw.charCodeAt(at) === 0x5c) === escaped ? n : 0;
+}
+function blockMarks(scan) {
+    if (scan.marks !== null)
+        return scan.marks;
+    const V = scan.view;
+    const seq = new Uint8Array(scan.raw.length);
+    const payload = new Uint8Array(scan.raw.length);
+    for (let k = 0; k < V.view.length; k++) {
+        if (V.dropped[k] !== 1 || V.units[k] !== UNIT_SEQUENCE)
+            continue;
+        for (let x = V.starts[k] ?? 0; x < (V.ends[k] ?? 0); x++)
+            seq[x] = 1;
+    }
+    for (const [a, b] of V.contents)
+        for (let x = a; x < b; x++)
+            payload[x] = 1;
+    scan.marks = { seq, payload };
+    return scan.marks;
+}
+function blockLines(scan, escaped) {
+    const slot = escaped ? 1 : 0;
+    const have = scan.lines[slot];
+    if (have !== null)
+        return have;
+    const raw = scan.raw;
+    const unit = scan.view.rawUnit;
+    const { seq, payload } = blockMarks(scan);
+    const starts = [];
+    const ends = [];
+    const indent = [];
+    let pos = 0;
+    for (;;) {
+        let k = pos;
+        let n = 0;
+        let width = 0;
+        let lead = true;
+        let visible = false;
+        while (k < raw.length && (n = blockBreakAt(raw, k, escaped)) === 0) {
+            if (lead) {
+                const c = raw.charCodeAt(k);
+                if (payload[k] === 1)
+                    visible = true;
+                if (seq[k] === 1) {
+                }
+                else if (isRawBlank(c))
+                    width++;
+                else if (unit[k] !== 1) {
+                    visible = true;
+                    lead = false;
+                }
+            }
+            k++;
+        }
+        starts.push(pos);
+        ends.push(k);
+        indent.push(visible ? width : -1);
+        if (k >= raw.length)
+            break;
+        pos = k + n;
+    }
+    const nextContent = new Int32Array(starts.length + 1);
+    nextContent[starts.length] = starts.length;
+    for (let i = starts.length - 1; i >= 0; i--)
+        nextContent[i] = (indent[i] ?? -1) !== -1 ? i : (nextContent[i + 1] ?? starts.length);
+    const built = { starts, ends, indent, nextContent, memo: new Map() };
+    scan.lines[slot] = built;
+    return built;
+}
+function blockLineOf(lines, p) {
+    let lo = 0;
+    let hi = lines.starts.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >> 1;
+        if ((lines.starts[mid] ?? 0) <= p)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    return lo;
+}
+function blockScalarExtent(scan, at, labelAt) {
+    const raw = scan.raw;
+    const mark = raw.charCodeAt(at);
+    if (mark !== 0x7c && mark !== 0x3e)
+        return null;
+    const unit = scan.view.rawUnit;
+    let k = at + 1;
+    while (k < raw.length && lineBreakLengthAt(raw, k) === 0) {
+        const c = raw.charCodeAt(k);
+        if (c === 0x2d || c === 0x2b || (c >= 0x30 && c <= 0x39) || (unit[k] === 1 && !isRawBlank(c)))
+            k++;
+        else
+            break;
+    }
+    while (k < raw.length && lineBreakLengthAt(raw, k) === 0 && (isRawBlank(raw.charCodeAt(k)) || unit[k] === 1))
+        k++;
+    if (k >= raw.length)
+        return null;
+    let escaped;
+    if (lineBreakLengthAt(raw, k) > 0)
+        escaped = raw.charCodeAt(k) === 0x5c;
+    else if (raw.charCodeAt(k) === 0x23) {
+        const real = blockLines(scan, false);
+        if ((real.ends[blockLineOf(real, k)] ?? raw.length) < raw.length)
+            escaped = false;
+        else {
+            const lit = blockLines(scan, true);
+            if ((lit.ends[blockLineOf(lit, k)] ?? raw.length) >= raw.length)
+                return null;
+            escaped = true;
+        }
+    }
+    else
+        return null;
+    const lines = blockLines(scan, escaped);
+    const head = blockLineOf(lines, at);
+    const limit = Math.max(0, lines.indent[blockLineOf(lines, labelAt)] ?? 0);
+    const key = head * (raw.length + 1) + limit;
+    let end = lines.memo.get(key);
+    if (end === undefined) {
+        end = lines.ends[head] ?? raw.length;
+        for (let i = lines.nextContent[head + 1] ?? lines.starts.length; i < lines.starts.length && (lines.indent[i] ?? -1) > limit; i = lines.nextContent[i + 1] ?? lines.starts.length) {
+            end = lines.ends[i] ?? end;
+        }
+        lines.memo.set(key, end);
+    }
+    return { start: at, end };
+}
 function pemBodyEndWithoutTrailer(text, from) {
     let pos = from;
     let inBody = false;
@@ -2779,6 +2928,7 @@ function collectCandidates(text, o, nested) {
     const screen = screenSurfaces(text, o);
     surfaces.push(...screen.surfaces);
     const raw = [];
+    const blocks = { raw: text, view: V, out: raw, lines: [null, null], marks: null };
     const regionSurface = screen.surfaces[0] ?? separated;
     const pemBlocksSeen = [];
     for (const S of surfaces) {
@@ -2792,9 +2942,9 @@ function collectCandidates(text, o, nested) {
         if (o.words) {
             editsToCandidates(pemEdits(S, (blk) => { if (S === regionSurface)
                 pemBlocksSeen.push(pemBlockToRaw(S, blk)); }), 'pem', cands);
-            labelCandidates(S, 'scheme', regions, cands);
-            labelCandidates(S, 'token', regions, cands);
-            labelCandidates(S, 'label', regions, cands);
+            labelCandidates(S, 'scheme', regions, cands, blocks);
+            labelCandidates(S, 'token', regions, cands, blocks);
+            labelCandidates(S, 'label', regions, cands, blocks);
             editsToCandidates(authParamEdits(S.text), 'param', cands);
             editsToCandidates(proseLiteralEdits(S.text), 'prose', cands);
         }

package/dist/effectiveFacts.d.ts

@@ -7,15 +7,25 @@ export interface EffectiveReasoningView {
     endpoint: string;
     dropped?: true;
 }
+export type EffectiveMemoryProjectKey = {
+    readonly scope: string;
+    readonly absent?: never;
+} | {
+    readonly absent: string;
+    readonly scope?: never;
+};
+export interface EffectiveMemoryScopeRow {
+    scope: string;
+    origin: 'deployment' | 'request';
+    shadowed?: number;
+}
 export interface EffectiveMemoryScopesView {
     state: 'mounted' | 'memoryless' | 'none';
     reason?: string;
     contract?: 'v2' | 'legacy';
-    scopes: readonly {
-        scope: string;
-        origin: 'deployment' | 'request';
-    }[];
+    scopes: readonly EffectiveMemoryScopeRow[];
     writeScope: string | null;
+    projectKey?: EffectiveMemoryProjectKey;
     materializedResidue?: readonly string[];
 }
 export declare function readEffectiveReasoning(v: unknown): EffectiveReasoningView | undefined;

package/dist/effectiveFacts.js

@@ -1,4 +1,37 @@
 const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
+const nonBlank = (v) => typeof v === 'string' && v.trim().length > 0;
+const UNREADABLE = Symbol('unreadable');
+const protectedRead = (o, key) => {
+    try {
+        return o[key];
+    }
+    catch {
+        return UNREADABLE;
+    }
+};
+function readProjectKey(v) {
+    try {
+        if (typeof v !== 'object' || v === null || Array.isArray(v))
+            return undefined;
+        const o = v;
+        const scope = protectedRead(o, 'scope');
+        const absent = protectedRead(o, 'absent');
+        if (scope === UNREADABLE || absent === UNREADABLE)
+            return undefined;
+        if ((scope === undefined) === (absent === undefined))
+            return undefined;
+        if (scope !== undefined)
+            return nonBlank(scope) ? { scope } : undefined;
+        return nonBlank(absent) ? { absent } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readShadowed(r, isWriteHome) {
+    const n = protectedRead(r, 'shadowed');
+    return !isWriteHome && typeof n === 'number' && Number.isSafeInteger(n) && n > 0 ? n : undefined;
+}
 export function readEffectiveReasoning(v) {
     if (typeof v !== 'object' || v === null)
         return undefined;
@@ -27,7 +60,8 @@ export function readEffectiveMemoryScopes(v) {
         return undefined;
     if (!Array.isArray(o.scopes))
         return undefined;
-    if (o.writeScope !== null && typeof o.writeScope !== 'string')
+    const writeScope = o.writeScope;
+    if (writeScope !== null && typeof writeScope !== 'string')
         return undefined;
     const contract = o.contract === 'v2' || o.contract === 'legacy' ? o.contract : undefined;
     const reason = nonEmpty(o.reason) ? o.reason : undefined;
@@ -39,13 +73,19 @@ export function readEffectiveMemoryScopes(v) {
             if (typeof row !== 'object' || row === null)
                 continue;
             const r = row;
-            if (!nonEmpty(r.scope) || typeof r.origin !== 'string' || !ORIGINS.has(r.origin))
+            const scope = r.scope;
+            if (!nonEmpty(scope))
+                continue;
+            const origin = r.origin;
+            if (typeof origin !== 'string' || !ORIGINS.has(origin))
                 continue;
-            scopes.push({ scope: r.scope, origin: r.origin });
+            const shadowed = readShadowed(r, scope === writeScope);
+            scopes.push({ scope, origin: origin, ...(shadowed !== undefined ? { shadowed } : {}) });
         }
-        return { state: 'mounted', contract, scopes, writeScope: o.writeScope };
+        const projectKey = readProjectKey(protectedRead(o, 'projectKey'));
+        return { state: 'mounted', contract, scopes, writeScope, ...(projectKey !== undefined ? { projectKey } : {}) };
     }
-    if (o.scopes.length !== 0 || o.writeScope !== null)
+    if (o.scopes.length !== 0 || writeScope !== null)
         return undefined;
     if (o.state === 'memoryless') {
         if (reason !== 'mount-failed' && reason !== 'no-backend')

package/dist/engineAgentAbsence.js

@@ -2,6 +2,7 @@ import { registryClockNowMs, registryListingProvenanceOf } from './agentSession/
 import { displayUntrusted } from './displayUntrusted.js';
 import { ABSENT_SETTLE_MS } from './fleetAgentPanelProjection.js';
 import { isEnginePanelTaskResident, isStaleEngineAgentPanelEnd, } from './engineAgentPanelStore.js';
+import { CORE_DURABLE_AGENT_HANDLE_RE } from './generated/engineFactTables.js';
 export const ENGINE_AGENT_ABSENT_ROW_TEXT = 'engine no longer reports this agent · it may still be running';
 export const ENGINE_AGENT_ABSENCE_TTL_MS = 30 * 60_000;
 function effectiveTtl(ttlMs) {
@@ -132,7 +133,7 @@ export function engineAgentTerminalAfterDropLine(label, status, hasReport) {
     return `${displayUntrusted(label)} reported ${displayUntrusted(status)} after it was dropped from the task panel${tail}`;
 }
 const REGISTRY_LIST_LIMIT = 500;
-const REGISTRY_AGENT_HANDLE_RE = /^a[0-9a-f]{6,32}$/;
+const REGISTRY_AGENT_HANDLE_RE = CORE_DURABLE_AGENT_HANDLE_RE;
 const REGISTRY_AGENT_TYPE = 'background_agent';
 function registryStatusReading(status) {
     const s = status;

package/dist/engineCapReader.js

@@ -1,4 +1,5 @@
 import { snapshotCapsGeneration, capsGenerationStillCurrent } from './engineCapsGenerationGuard.js';
+import { capsGenerationMarkOf, retainCapsGenerationMark } from './engineCapsCache.js';
 function freezeReading(reading, seen = new Set()) {
     if (reading === null || typeof reading !== 'object' || seen.has(reading))
         return reading;
@@ -11,7 +12,7 @@ function freezeReading(reading, seen = new Set()) {
     return reading;
 }
 export function createEngineCapReader(spec) {
-    const readingByBase = new Map();
+    const cellByBase = new Map();
     return {
         note(baseUrl, caps, opts) {
             if (typeof baseUrl !== 'string' || baseUrl === '')
@@ -21,6 +22,7 @@ export function createEngineCapReader(spec) {
                 return;
             if (!capsGenerationStillCurrent(baseUrl, gen))
                 return;
+            const mark = retainCapsGenerationMark(baseUrl);
             let reading;
             try {
                 reading = spec.project(caps);
@@ -28,29 +30,33 @@ export function createEngineCapReader(spec) {
             catch {
                 reading = undefined;
             }
-            if (!capsGenerationStillCurrent(baseUrl, gen))
+            if (capsGenerationMarkOf(baseUrl) !== mark)
                 return;
             if (reading === undefined) {
-                readingByBase.delete(baseUrl);
+                cellByBase.delete(baseUrl);
                 return;
             }
-            readingByBase.set(baseUrl, freezeReading(reading));
+            cellByBase.set(baseUrl, { reading: freezeReading(reading), mark });
         },
         observed(baseUrl) {
             if (typeof baseUrl !== 'string' || baseUrl === '')
                 return spec.makeUnobserved();
-            const hit = readingByBase.get(baseUrl);
-            if (hit !== undefined)
-                return hit;
-            return spec.makeUnobserved();
+            const cell = cellByBase.get(baseUrl);
+            if (cell === undefined)
+                return spec.makeUnobserved();
+            if (cell.mark !== capsGenerationMarkOf(baseUrl)) {
+                cellByBase.delete(baseUrl);
+                return spec.makeUnobserved();
+            }
+            return cell.reading;
         },
         forget(baseUrl) {
             if (typeof baseUrl !== 'string' || baseUrl === '')
                 return;
-            readingByBase.delete(baseUrl);
+            cellByBase.delete(baseUrl);
         },
         __resetForTests() {
-            readingByBase.clear();
+            cellByBase.clear();
         },
     };
 }

package/dist/engineCapsCache.d.ts

@@ -1,6 +1,10 @@
 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 kickEngineCapsProbe(baseUrl: string, probe: () => Promise<unknown>): void;
-export declare function engineCapsSettled(baseUrl: string | undefined): Promise<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 engineCapTrue(baseUrl: string | undefined, key: string): boolean;

package/dist/engineCapsCache.js

@@ -3,11 +3,22 @@ const inFlight = new Set();
 const settleByBase = new Map();
 const genByBase = new Map();
 function capsGeneration(baseUrl) {
-    return genByBase.get(baseUrl) ?? 0;
+    return genByBase.get(baseUrl)?.n ?? 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 kickEngineCapsProbe(baseUrl, probe) {
     if (!baseUrl || capsByBase.has(baseUrl) || inFlight.has(baseUrl))
         return;
@@ -43,21 +54,71 @@ export function kickEngineCapsProbe(baseUrl, probe) {
         }
     })();
 }
-export async function engineCapsSettled(baseUrl) {
-    if (!baseUrl)
-        return;
+const MAX_WITHIN_MS = 2_147_483_647;
+function waitBudgetOf(opts) {
+    try {
+        if (opts === undefined || opts === null)
+            return undefined;
+        if (typeof opts !== 'object')
+            return 0;
+        const v = opts.withinMs;
+        if (v === undefined)
+            return undefined;
+        if (typeof v !== 'number' || !Number.isFinite(v) || !(v > 0))
+            return 0;
+        return v > MAX_WITHIN_MS ? MAX_WITHIN_MS : v;
+    }
+    catch {
+        return 0;
+    }
+}
+async function relaySettled(baseUrl, deadline) {
     for (;;) {
         const entry = settleByBase.get(baseUrl);
         if (entry === undefined)
-            return;
+            return 'settled';
         const awaitedGen = entry.gen;
-        await Promise.race([
+        const landed = Promise.race([
             entry.promise.then(() => undefined, () => undefined),
             entry.superseded,
         ]);
+        if (deadline === undefined) {
+            await landed;
+        }
+        else {
+            const first = await Promise.race([landed.then(() => 'landed'), deadline]);
+            if (first === 'timed_out')
+                return 'timed_out';
+        }
         const next = settleByBase.get(baseUrl);
         if (next === undefined || next.gen <= awaitedGen)
-            return;
+            return 'settled';
+    }
+}
+export async function engineCapsSettled(baseUrl, opts) {
+    const budget = waitBudgetOf(opts);
+    if (!baseUrl)
+        return 'settled';
+    if (budget === undefined)
+        return relaySettled(baseUrl, undefined);
+    if (settleByBase.get(baseUrl) === undefined)
+        return 'settled';
+    if (budget === 0)
+        return 'timed_out';
+    let timer;
+    try {
+        const deadline = new Promise((resolve) => {
+            timer = setTimeout(() => resolve('timed_out'), budget);
+        });
+        deadline.catch(() => undefined);
+        return await relaySettled(baseUrl, deadline);
+    }
+    catch {
+        return 'timed_out';
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
     }
 }
 export function engineCapState(baseUrl, key) {
@@ -115,7 +176,7 @@ export function invalidateEngineCaps(baseUrl, probe) {
         settleByBase.has(baseUrl) ||
         genByBase.has(baseUrl);
     if (hadState) {
-        genByBase.set(baseUrl, capsGeneration(baseUrl) + 1);
+        genByBase.set(baseUrl, Object.freeze({ n: capsGeneration(baseUrl) + 1 }));
         capsByBase.delete(baseUrl);
         inFlight.delete(baseUrl);
         settleByBase.get(baseUrl)?.wake();

package/dist/engineClosedSets.d.ts

@@ -0,0 +1,2 @@
+export declare const ASK_EVIDENCE_ABSENCE_VALUES: readonly ["not_wired", "not_adjudicated", "unavailable", "no_match", "not_reported"];
+export declare const SYSTEM_INJECTION_PRIORITIES: readonly ["now", "next", "later"];

package/dist/engineClosedSets.js

@@ -0,0 +1,3 @@
+import { CORE_ASK_EVIDENCE_ABSENCE_VALUES, CORE_SYSTEM_INJECTION_PRIORITIES } from './generated/engineFactTables.js';
+export const ASK_EVIDENCE_ABSENCE_VALUES = CORE_ASK_EVIDENCE_ABSENCE_VALUES;
+export const SYSTEM_INJECTION_PRIORITIES = CORE_SYSTEM_INJECTION_PRIORITIES;

package/dist/engineErrorCodes.d.ts

@@ -14,6 +14,8 @@ export declare const CONFIG_DELEGATION_ENTRY_CAPS = "config.delegation_entry_cap
 export declare const CONFIG_MEMORY_PROJECT_KEY_SPELLING = "config.memory_project_key_spelling";
 export declare const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = "config.memory_write_scope_mismatch";
 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_REFUSAL_CODES: ReadonlySet<string>;
 export declare const RULES_LEGACY_TOOL_NAME = "rules.legacy_tool_name";
 export declare function isRulesRefusalCode(code: string | undefined): boolean;
@@ -49,6 +51,9 @@ export declare function isRewindFamilyCode(code: string | undefined): boolean;
 export declare const RESUME_USAGE_WINDOW_EXHAUSTED = "resume.usage_window_exhausted";
 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 CHECKPOINT_UNSUPPORTED_VERSION = "checkpoint.unsupported_version";
+export declare function refusalSaysStillPending(err: object): boolean;
 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";
@@ -66,6 +71,18 @@ 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 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 RUN_DEATH_VERDICT_CODES: readonly ["run.stalled", "run.orphaned", "approval.expired"];
+export type RunDeathVerdictCode = (typeof RUN_DEATH_VERDICT_CODES)[number];
+export declare function runDeathVerdictNoteOf(code: string | undefined): string | undefined;
+export declare const CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED = "capability.operator_principals_required";
+export declare function isUnavailableFaceCode(code: string | undefined): boolean;
+export type OperatorGateRefusal = 'operator_only' | 'operators_unconfigured';
+export declare function operatorGateRefusalContent(cause: OperatorGateRefusal): string | undefined;
 export declare const WORKFLOW_PARK_REFUSAL_CODES: readonly string[];
 export declare function isWorkflowParkRefusalCode(code: unknown): boolean;
 export declare const DRAINING_ERROR_CODE = "draining";

package/dist/engineErrorCodes.js

@@ -19,6 +19,12 @@ export const CONFIG_DELEGATION_ENTRY_CAPS = 'config.delegation_entry_caps';
 export const CONFIG_MEMORY_PROJECT_KEY_SPELLING = 'config.memory_project_key_spelling';
 export const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = 'config.memory_write_scope_mismatch';
 export const CONFIG_LEGACY_TOOL_NAME = 'config.legacy_tool_name';
+export const CONFIG_IMAGE_INVALID = 'config.image_invalid';
+const IMAGE_INVALID_FAILURE_NOTE = 'This run did not start: an image sent with the message was refused before the model was called — the engine’s own error text says which image and what is wrong with it. ' +
+    'Nothing was sent to the model; remove or replace that image, then send the message again.';
+export function imageInvalidFailureNoteOf(code) {
+    return code === CONFIG_IMAGE_INVALID ? IMAGE_INVALID_FAILURE_NOTE : undefined;
+}
 export const CONFIG_REFUSAL_CODES = frozenSet([
     CONFIG_LIMIT_INVALID,
     CONFIG_STRATEGY_FIND_LIMIT_INVALID,
@@ -28,6 +34,7 @@ export const CONFIG_REFUSAL_CODES = frozenSet([
     CONFIG_MEMORY_PROJECT_KEY_SPELLING,
     CONFIG_MEMORY_WRITE_SCOPE_MISMATCH,
     CONFIG_LEGACY_TOOL_NAME,
+    CONFIG_IMAGE_INVALID,
     ...CORE_TOOL_DECLARATION_CODES,
 ]);
 export const RULES_LEGACY_TOOL_NAME = 'rules.legacy_tool_name';
@@ -107,6 +114,16 @@ export function isRewindFamilyCode(code) {
 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 CHECKPOINT_UNSUPPORTED_VERSION = 'checkpoint.unsupported_version';
+export function refusalSaysStillPending(err) {
+    try {
+        return Object.hasOwn(err, 'retriable') && err.retriable === true;
+    }
+    catch {
+        return false;
+    }
+}
 export const RESUME_PLACEMENT_MISMATCH = 'resume.placement_mismatch';
 export const RESUME_CONTEXT_UNAVAILABLE = 'conflict.resume_context_unavailable';
 export const RESUME_RETRY_LATER_CODES = Object.freeze([
@@ -139,6 +156,36 @@ export const DECIDE_PARK_MOVED_CODES = Object.freeze([
 export function isDecideParkMovedCode(code) {
     return typeof code === 'string' && DECIDE_PARK_MOVED_CODES.includes(code);
 }
+export const ASK_GONE = 'gone.ask';
+export const ASK_GONE_DENIED_WORD = 'routing_failure_fail_closed';
+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_NOTE = 'This run ended because the engine process that was running it went away (it was restarted, or stopped answering) before the run finished. ' +
+    '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_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.';
+export function runDeathVerdictNoteOf(code) {
+    if (code === RUN_STALLED || code === RUN_ORPHANED)
+        return RUN_HOLDER_LOST_NOTE;
+    if (code === APPROVAL_EXPIRED)
+        return RUN_APPROVAL_EXPIRED_NOTE;
+    return undefined;
+}
+export const CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED = 'capability.operator_principals_required';
+export function isUnavailableFaceCode(code) {
+    return typeof code === 'string' && (code.startsWith('capability.') || code.startsWith('feature.'));
+}
+export function operatorGateRefusalContent(cause) {
+    if (cause === 'operator_only') {
+        return 'Nothing was done: this is an operator-only action and the caller is not one of this deployment’s operators.';
+    }
+    if (cause === 'operators_unconfigured') {
+        return 'Nothing was done: this is an operator-only action and this deployment has no operators configured, so no caller can perform it here — whoever runs the deployment has to name its operators first.';
+    }
+    return undefined;
+}
 const WORKFLOW_PARK_TRUTH_UNREADABLE = 'workflow.park_truth_unreadable';
 const WORKFLOW_PARK_NOT_PENDING = 'workflow.park_not_pending';
 const WORKFLOW_PARK_BINDING_BROKEN = 'workflow.park_binding_broken';

package/dist/engineNoticeCodes.d.ts

@@ -169,6 +169,19 @@ export interface UserInputUndrainedFactsView {
 }
 export declare function readUserInputUndrained(notice: unknown): UserInputUndrainedFactsView | undefined;
 export declare function userInputUndrainedNotice(facts: Pick<UserInputUndrainedFactsView, 'kind' | 'count' | 'cause' | 'childSessionId'>): string | undefined;
+export interface TurnInterruptedFactsView {
+    lane: 'input_now' | 'user_halt' | 'unrecognized';
+    inputId?: string;
+    cause?: string;
+    sessionId?: string;
+    runId?: string;
+    taskId?: string;
+    actorId?: string;
+}
+export declare function readTurnInterrupted(notice: unknown): TurnInterruptedFactsView | undefined;
+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 declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'mcp.injection_dropped': typeof readMcpInjectionDrop;
     readonly 'delegation.ask_unresolvable': typeof readAskUnresolvable;
@@ -189,6 +202,7 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'task.tool_turn_incomplete': typeof readToolTurnIncomplete;
     readonly 'task.user_steer_undrained': typeof readUserInputUndrained;
     readonly 'task.user_followup_undrained': typeof readUserInputUndrained;
+    readonly 'task.turn_interrupted': typeof readTurnInterrupted;
 }>;
 type FactReaderTable = typeof ENGINE_NOTICE_FACT_READERS;
 export type EngineNoticeFactsCode = keyof FactReaderTable;