@sema-agent/client-core 0.90.0 → 0.91.0

package/dist/controlRouter.js

@@ -3,11 +3,17 @@ import { uuid } from './adapter/types.js';
 export class ControlSafetyError extends Error {
     code;
     cause;
-    constructor(message, code, cause) {
+    constructor(message, code, cause, detail) {
         super(message);
         this.code = code;
         this.cause = cause;
         this.name = 'ControlSafetyError';
+        const advice = detail?.advice;
+        const status = detail?.status;
+        if (typeof advice === 'string' && advice.length > 0)
+            this.advice = advice;
+        if (typeof status === 'number')
+            this.status = status;
     }
 }
 const BAND_RANK = { now: 0, next: 1, later: 2 };
@@ -55,39 +61,38 @@ export class ControlRouter {
     }
     async steer(text, mode, opts) {
         if (this.taskId === null) {
-            throw new ControlSafetyError('no run in flight to steer — submit a turn first', 'not_running');
+            throw controlSafetyRefusal('not_running', 'no run in flight to steer', 'submit a turn first');
         }
         const body = mode !== undefined ? { text, mode } : { text };
         try {
             return await this.client.runs.steer(this.taskId, body, opts?.signal !== undefined ? { signal: opts.signal } : undefined);
         }
         catch (e) {
-            const verdict = steeringVerdict(e);
-            if (verdict !== undefined) {
-                const safety = steeringSafetyOf(e, verdict);
-                const wireCode = errCodes(e).code ?? errCodes(e).name ?? 'steering.<unknown>';
-                throw new ControlSafetyError(`${wireCode} — ${steeringAdviceOf(e, safety) ?? 'steering refused'}`, safety, e);
+            if (typeof e === 'object' && e !== null) {
+                const refusal = steerRefusalAdviceOf(e);
+                if (refusal !== undefined)
+                    throw controlSafetyRefusal(refusal.safety, steerRefusalWireLabel(e), refusal.advice, e);
             }
             throw e;
         }
     }
     async cancel(opts) {
         if (this.taskId === null) {
-            throw new ControlSafetyError('no run in flight to cancel', 'not_found');
+            throw controlSafetyRefusal('not_found', 'no run in flight to cancel');
         }
         try {
             return await this.client.runs.cancel(this.taskId, opts?.signal !== undefined ? { signal: opts.signal } : undefined);
         }
         catch (e) {
             if (cancelConflictFromError(e)?.kind === 'run_not_running') {
-                throw new ControlSafetyError(`runs.cancel 409 conflict.run_not_running — ${cancelConflictContent({ kind: 'run_not_running' })}`, 'cancel_run_not_running', e);
+                throw controlSafetyRefusal('cancel_run_not_running', 'runs.cancel 409 conflict.run_not_running', cancelConflictContent({ kind: 'run_not_running' }), e);
             }
             if (isCancelSuspendedConflict(e)) {
-                throw new ControlSafetyError('runs.cancel 409 — the pending gate was decided or expired concurrently (lost CAS race); ' +
-                    'check what that decision did to the run before retrying the cancel', 'cancel_lost_race', e);
+                throw controlSafetyRefusal('cancel_lost_race', 'runs.cancel 409', 'the pending gate was decided or expired concurrently (lost CAS race); ' +
+                    'check what that decision did to the run before retrying the cancel', e);
             }
             if (isNotFound(e)) {
-                throw new ControlSafetyError('runs.cancel 404 — non-owner / unknown run (no existence leak)', 'not_found', e);
+                throw controlSafetyRefusal('not_found', 'runs.cancel 404 — non-owner / unknown run (no existence leak)', undefined, e);
             }
             throw e;
         }
@@ -149,17 +154,17 @@ const STEERING_NAME_TO_SAFETY = new Map([
     ['SteeringLedgerUnavailableError', 'ledger_unavailable'],
     ['SteeringError', 'steering_other'],
 ]);
-const STEERING_ADVICE = new Map([
-    ['not_running', 'the run is suspended/terminal/on another replica — resolve its gate via decide, do not steer'],
-    ['invalid_content', 'the steer text carried a control-plane escape; surface it, do not strip-and-retry'],
-    ['queue_full', 'the parked steering queue on this checkpoint is full (core fails loud rather than evicting an accepted instruction) — wait for it to drain, do not resend'],
-    ['duplicate_input_id', 'this Idempotency-Key is already parked with DIFFERENT steering content — reissue with a fresh key, resending verbatim will never succeed'],
-    ['ambiguous_target', 'more than one live target matches — address it uniquely (sub-agent: parentToolCallId; workflow: a more specific label); retrying verbatim yields the same result'],
-    ['still_running', 'the target is STILL RUNNING — steer it instead of resuming, or wait for it to settle (this is the exact opposite of not_running: never collapse the two)'],
-    ['blocked_by_hook', "this deployment's userPromptSubmit gate refused the input (block, timeout and crash all report this one code, fail-closed) — the input was NOT accepted: no human_input frame, the inputId is not on the ledger, so editing the text and sending again is a normal retry, not a duplicate"],
-    ['ledger_unavailable', 'the server could not record this steer in its user-input ledger and refused it before anything reached the engine — the input was NOT delivered; resend the same text later (the same Idempotency-Key is fine)'],
-    ['steering_other', 'an unrecognized steering.* refusal (open set) — the steer did NOT land; log the errorCode verbatim, do not guess its meaning'],
-]);
+const STEERING_ADVICE = {
+    not_running: 'the run is suspended/terminal/on another replica — resolve its gate via decide, do not steer',
+    invalid_content: 'the steer text carried a control-plane escape; surface it, do not strip-and-retry',
+    queue_full: 'the parked steering queue on this checkpoint is full (core fails loud rather than evicting an accepted instruction) — wait for it to drain, do not resend',
+    duplicate_input_id: 'this Idempotency-Key is already parked with DIFFERENT steering content — reissue with a fresh key, resending verbatim will never succeed',
+    ambiguous_target: 'more than one live target matches — address it uniquely (sub-agent: parentToolCallId; workflow: a more specific label); retrying verbatim yields the same result',
+    still_running: 'the target is STILL RUNNING — steer it instead of resuming, or wait for it to settle (this is the exact opposite of not_running: never collapse the two)',
+    blocked_by_hook: "this deployment's userPromptSubmit gate refused the input (block, timeout and crash all report this one code, fail-closed) — the input was NOT accepted: no human_input frame, the inputId is not on the ledger, so editing the text and sending again is a normal retry, not a duplicate",
+    ledger_unavailable: 'the server could not record this steer in its user-input ledger and refused it before anything reached the engine — the input was NOT delivered; resend the same text later (the same Idempotency-Key is fine)',
+    steering_other: 'an unrecognized steering.* refusal (open set) — the steer did NOT land; log the errorCode verbatim, do not guess its meaning',
+};
 const STEERING_OTHER_UNKNOWN_ADVICE = 'an unrecognized steering.* refusal (open set) — treat delivery as unknown (do not resend as if it had certainly been dropped); log the errorCode verbatim, do not guess its meaning';
 export function steeringStatusIs4xx(e) {
     let status;
@@ -172,9 +177,9 @@ export function steeringStatusIs4xx(e) {
     return status !== undefined && status >= 400 && status < 500;
 }
 function steeringAdviceOf(e, safety) {
-    if (safety === 'steering_other' && !(typeof e === 'object' && e !== null && steeringStatusIs4xx(e)))
+    if (safety === 'steering_other' && !steeringStatusIs4xx(e))
         return STEERING_OTHER_UNKNOWN_ADVICE;
-    return STEERING_ADVICE.get(safety);
+    return STEERING_ADVICE[safety];
 }
 const STEERING_REFUSED_BEFORE_ENGINE = new Map([['ledger_unavailable', 503]]);
 export function steeringRefusedBeforeEngine(e) {
@@ -185,8 +190,7 @@ export function steeringRefusedBeforeEngine(e) {
         const safety = steeringVerdict(e);
         if (safety === undefined || STEERING_REFUSED_BEFORE_ENGINE.get(safety) !== status)
             return undefined;
-        const advice = STEERING_ADVICE.get(safety);
-        return advice === undefined ? undefined : { safety, advice };
+        return { safety, advice: STEERING_ADVICE[safety] };
     }
     catch {
         return undefined;
@@ -195,7 +199,7 @@ export function steeringRefusedBeforeEngine(e) {
 function steeringSafetyOf(e, verdict) {
     if (!STEERING_REFUSED_BEFORE_ENGINE.has(verdict))
         return verdict;
-    const refused = typeof e === 'object' && e !== null ? steeringRefusedBeforeEngine(e) : undefined;
+    const refused = steeringRefusedBeforeEngine(e);
     return refused !== undefined && refused.safety === verdict ? verdict : 'steering_other';
 }
 function steeringVerdict(e) {
@@ -207,6 +211,40 @@ function steeringVerdict(e) {
         return STEERING_NAME_TO_SAFETY.get(name);
     return undefined;
 }
+export function steerRefusalAdviceOf(e) {
+    try {
+        const verdict = steeringVerdict(e);
+        if (verdict === undefined)
+            return undefined;
+        const safety = steeringSafetyOf(e, verdict);
+        return { safety, advice: steeringAdviceOf(e, safety) };
+    }
+    catch {
+        return undefined;
+    }
+}
+function steerRefusalWireLabel(e) {
+    try {
+        const { code, name } = errCodes(e);
+        return code ?? name ?? 'steering.<unknown>';
+    }
+    catch {
+        return 'steering.<unknown>';
+    }
+}
+function statusOfThrown(e) {
+    try {
+        return errCodes(e).status;
+    }
+    catch {
+        return undefined;
+    }
+}
+function controlSafetyRefusal(code, head, advice, cause) {
+    const status = statusOfThrown(cause);
+    const detail = { ...(advice !== undefined ? { advice } : {}), ...(status !== undefined ? { status } : {}) };
+    return new ControlSafetyError(advice === undefined ? head : `${head} — ${advice}`, code, cause, detail);
+}
 function isCancelSuspendedConflict(e) {
     const { name, status } = errCodes(e);
     return name === 'ConflictError' || status === 409;

package/dist/decideFailureNote.js

@@ -1,5 +1,5 @@
 import { corruptStoredRowContent, corruptStoredRowWhere } from './wireErrorTriage.js';
-import { parkedResumeStartupContent, parkedResumeStartupFromError, resumePolicyBlockContent, resumePolicyBlockFromError, } from './resumeRefusalCopy.js';
+import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, parkedResumeStartupContent, parkedResumeStartupFromError, resumePolicyBlockContent, resumePolicyBlockFromError, } from './resumeRefusalCopy.js';
 import { decideParkMovedContent, decideParkMovedFromError } from './decideReceipt.js';
 import { settingsPermissionBucketRefusalContent, settingsPermissionBucketRefusalFromError } from './wireRefusalCopy.js';
 export function decideFailureNote(err, decision) {
@@ -8,9 +8,11 @@ export function decideFailureNote(err, decision) {
     const startup = parkedResumeStartupFromError(err, decision);
     const moved = decideParkMovedFromError(err);
     const bucket = settingsPermissionBucketRefusalFromError(err);
+    const unsupported = checkpointUnsupportedVersionFromError(err);
     return ((where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`) +
         (fold === null ? '' : ` — ${resumePolicyBlockContent(fold)}`) +
         (bucket === null ? '' : ` — ${settingsPermissionBucketRefusalContent(bucket)}`) +
         (startup === null ? '' : ` — ${parkedResumeStartupContent(startup)}`) +
-        (moved === null ? '' : ` — ${decideParkMovedContent(moved)}`));
+        (moved === null ? '' : ` — ${decideParkMovedContent(moved)}`) +
+        (unsupported === null ? '' : ` — ${checkpointUnsupportedVersionContent(unsupported)}`));
 }

package/dist/disableSkillsWire.d.ts

@@ -14,4 +14,5 @@ export type DisableSkillsDeclaration = {
     };
 };
 export declare function disableSkillsDeclaration(want: unknown, baseUrl: string | undefined): DisableSkillsDeclaration;
+export declare function disableSkillsDeclarationSettled(want: boolean | null | undefined, baseUrl: string | undefined, withinMs: number): Promise<DisableSkillsDeclaration>;
 export {};

package/dist/disableSkillsWire.js

@@ -1,4 +1,4 @@
-import { engineCapState } from './engineCapsCache.js';
+import { engineCapState, engineCapsSettled } from './engineCapsCache.js';
 const KEY = 'disableSkills';
 const shapeOf = (v) => {
     try {
@@ -50,3 +50,10 @@ export function disableSkillsDeclaration(want, baseUrl) {
     const cause = WITHHELD_CAUSE_OF[state];
     return Object.freeze({ field: Object.freeze({}), withheld: Object.freeze({ cause, text: WITHHELD_TEXT[cause] }) });
 }
+export async function disableSkillsDeclarationSettled(want, baseUrl, withinMs) {
+    refuseBadDisableSkills(want, 'disableSkillsDeclarationSettled');
+    if (want !== true)
+        return disableSkillsDeclaration(want, baseUrl);
+    await engineCapsSettled(baseUrl, { withinMs: typeof withinMs === 'number' ? withinMs : 0 });
+    return disableSkillsDeclaration(want, baseUrl);
+}

package/dist/displayUntrusted.js

@@ -1473,7 +1473,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 +1642,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 +1891,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 +2927,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 +2941,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/engineCapsCache.d.ts

@@ -1,6 +1,8 @@
 export declare function engineCapsGeneration(baseUrl: string): number;
 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

@@ -43,21 +43,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) {

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

@@ -49,6 +49,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";

package/dist/engineErrorCodes.js

@@ -107,6 +107,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([

package/dist/generated/engineFactTables.d.ts

@@ -10,3 +10,15 @@ export declare const CORE_ENGINE_CARD_TYPES: readonly string[];
 export declare const CORE_TOOL_DECLARATION_CODES: readonly string[];
 export declare const CORE_MODE_RELEASE_REASONS: readonly ["rule_unreadable"];
 export declare const CORE_HOOK_TOOL_ALIASES: Readonly<Record<string, string>>;
+export declare const CORE_ASK_EVIDENCE_ABSENCE_VALUES: readonly ["not_wired", "not_adjudicated", "unavailable", "no_match", "not_reported"];
+export declare const CORE_SYSTEM_INJECTION_PRIORITIES: readonly ["now", "next", "later"];
+export declare const CORE_READ_DENY_BUILTIN_TIERS: readonly ["credentials", "shell-history", "browser", "wallet", "agent-config"];
+export declare const CORE_READ_DENY_DEFAULT_TIERS: readonly ["credentials", "agent-config"];
+export interface CoreModeArbitrationRow {
+    readonly bypassImmune: boolean;
+    readonly classifierEligible: boolean;
+    readonly sandboxAdmission: boolean;
+    readonly ruleMayClear: boolean;
+    readonly hookAskFloor: boolean;
+}
+export declare const CORE_MODE_ARBITRATION: Readonly<Record<"content_question" | "hook" | "ancestor" | "unverifiable_delete" | "transcript_write" | "org_rule" | "governance_unavailable" | "rule_unreadable" | "ask_rule" | "denial_limit_fallback" | "operator_forced" | "shell_floor" | "write_protection_unresolved" | "probe" | "write_protection" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "mode" | "unstated" | "ordinary", CoreModeArbitrationRow>>;

package/dist/generated/engineFactTables.js

@@ -117,3 +117,50 @@ export const CORE_MODE_RELEASE_REASONS = Object.freeze([
 export const CORE_HOOK_TOOL_ALIASES = Object.freeze(Object.assign(Object.create(null), Object.fromEntries([
     ["ListPeers", "ListAgents"],
 ])));
+export const CORE_ASK_EVIDENCE_ABSENCE_VALUES = Object.freeze([
+    "not_wired",
+    "not_adjudicated",
+    "unavailable",
+    "no_match",
+    "not_reported",
+]);
+export const CORE_SYSTEM_INJECTION_PRIORITIES = Object.freeze([
+    "now",
+    "next",
+    "later",
+]);
+export const CORE_READ_DENY_BUILTIN_TIERS = Object.freeze([
+    "credentials",
+    "shell-history",
+    "browser",
+    "wallet",
+    "agent-config",
+]);
+export const CORE_READ_DENY_DEFAULT_TIERS = Object.freeze([
+    "credentials",
+    "agent-config",
+]);
+export const CORE_MODE_ARBITRATION = Object.freeze({
+    "content_question": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
+    "hook": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "ancestor": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "unverifiable_delete": Object.freeze({ bypassImmune: true, classifierEligible: true, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
+    "transcript_write": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
+    "org_rule": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "governance_unavailable": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "rule_unreadable": Object.freeze({ bypassImmune: false, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "ask_rule": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
+    "denial_limit_fallback": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "operator_forced": Object.freeze({ bypassImmune: true, classifierEligible: true, sandboxAdmission: true, ruleMayClear: false, hookAskFloor: false }),
+    "shell_floor": Object.freeze({ bypassImmune: true, classifierEligible: true, sandboxAdmission: true, ruleMayClear: false, hookAskFloor: false }),
+    "write_protection_unresolved": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: true, ruleMayClear: false, hookAskFloor: true }),
+    "probe": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "write_protection": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: true, ruleMayClear: false, hookAskFloor: true }),
+    "tool_marks_mcp": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: true, ruleMayClear: false, hookAskFloor: false }),
+    "tool_marks_a2a": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: true, ruleMayClear: false, hookAskFloor: false }),
+    "policy_rra": Object.freeze({ bypassImmune: true, classifierEligible: true, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "artifact_shared_read": Object.freeze({ bypassImmune: false, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
+    "mode": Object.freeze({ bypassImmune: false, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "unstated": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: false, ruleMayClear: true, hookAskFloor: false }),
+    "ordinary": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: true, ruleMayClear: true, hookAskFloor: false }),
+});

package/dist/hitl/askGateWire.d.ts

@@ -8,7 +8,7 @@ export type { AskAnsweredOutput } from './gateLedger.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
 export type { GateDenyAttribution } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedFailure, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export type { HopBudget, HopRound } from './parkResolver.js';
 export type { GateOutcome, GateFailureCode } from './parkResolver.js';
 export declare function bridgeAskUserQuestionGates(source: AsyncGenerator<AgentEvent>, deps: AskGateWireDeps, opts?: {

package/dist/hitl/askGateWire.js

@@ -6,7 +6,7 @@ export { HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE } from './frameRouter.js';
 export { HITL_POLICY_DENY_MESSAGE } from './frameRouter.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedFailure, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export async function* bridgeAskUserQuestionGates(source, deps, opts) {
     const led = createGateLedger();
     const taskId = { current: opts?.taskId };

package/dist/hitl/crashConverged.d.ts

@@ -28,3 +28,10 @@ export interface CrashConvergedProjection {
     readonly dropped: number;
 }
 export declare function projectCrashConverged(env: unknown): CrashConvergedProjection | undefined;
+export interface CrashConvergedNoticeFacts {
+    readonly total: number;
+    readonly dropped: number;
+    readonly needsHumanReasons: readonly (string | undefined)[];
+    readonly causes: readonly CrashConvergedRow['cause'][] | undefined;
+}
+export declare function readCrashConvergedNoticeFacts(projection: CrashConvergedProjection | undefined): CrashConvergedNoticeFacts | undefined;