@sema-agent/client-core 0.84.0 → 0.85.0

package/dist/decideFailureNote.js

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

package/dist/decideReceipt.d.ts

@@ -21,3 +21,9 @@ export interface DecideRefusalDetail {
     resendable: boolean;
 }
 export declare function decideRefusalFromError(e: unknown): DecideRefusalDetail | null;
+export interface DecideParkMovedDetail {
+    code: string;
+    taskId?: string;
+}
+export declare function decideParkMovedFromError(e: unknown): DecideParkMovedDetail | null;
+export declare function decideParkMovedContent(detail: Pick<DecideParkMovedDetail, 'code'>): string;

package/dist/decideReceipt.js

@@ -1,6 +1,8 @@
 import { gateOutcomeOf } from './gateOutcome.js';
 import { resumeReopenFromError } from './resumeRefusalCopy.js';
-import { DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, } from './engineErrorCodes.js';
+import { DECIDE_CLAIM_LOST, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
+import { effectiveWireErrorCode } from './wireErrorTriage.js';
+import { readErrorString } from './wireFailureShape.js';
 const STATUS_RESUMING = 'resuming';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
@@ -77,3 +79,30 @@ export function decideRefusalFromError(e) {
         resendable: Object.hasOwn(DECIDE_RESENDABLE, code) ? DECIDE_RESENDABLE[code] === true : false,
     };
 }
+export function decideParkMovedFromError(e) {
+    const code = effectiveWireErrorCode(e);
+    if (code === undefined || !isDecideParkMovedCode(code))
+        return null;
+    const taskId = readErrorString(e, 'taskId');
+    return { code, ...(taskId !== undefined && taskId.length > 0 ? { taskId } : {}) };
+}
+const DECIDE_PARK_MOVED_WHAT = Object.freeze({
+    [DECIDE_NOT_PARKED]: 'This approval was no longer waiting when the decision arrived (the agent was stopped, the approval was decided elsewhere, or the session it belongs to was deleted)',
+    [DECIDE_GATE_MOVED]: 'This approval moved while the decision was on its way (it was parked again, or settled elsewhere)',
+    [DECIDE_CLAIM_LOST]: 'Another decision on this approval got there first, or an earlier attempt is still holding it until the engine clears that hold on its own',
+});
+export function decideParkMovedContent(detail) {
+    let code;
+    try {
+        const raw = detail !== null && typeof detail === 'object' ? detail.code : undefined;
+        code = typeof raw === 'string' ? raw : undefined;
+    }
+    catch {
+        code = undefined;
+    }
+    const what = code !== undefined && Object.hasOwn(DECIDE_PARK_MOVED_WHAT, code)
+        ? DECIDE_PARK_MOVED_WHAT[code]
+        : 'This approval changed state while the decision was on its way';
+    const extra = code === DECIDE_CLAIM_LOST ? '; if this approval is still listed, wait a little before deciding it again' : '';
+    return `${what} · This decision was not applied — fetch the pending approvals again and decide from what is pending now${extra}`;
+}

package/dist/detachWire.d.ts

@@ -26,6 +26,7 @@ export declare function resolveHeadlessDetach(baseUrl: string, env?: EnvLike, op
     timeoutMs?: number;
 }): Promise<DetachResolution>;
 export declare const DETACH_DURABLE_OFF_400_ANCHOR = "x-detach-on-disconnect requires a durable run";
+export declare function isDetachDurableOff400(err: unknown): boolean;
 export declare function detachDurableOffHint(err: unknown): string | null;
 export interface DetachCancelArm {
     baseUrl: string;

package/dist/detachWire.js

@@ -57,14 +57,22 @@ export async function resolveHeadlessDetach(baseUrl, env = hostEnv(), opts) {
     return { on: true, reason: 'default-on' };
 }
 export const DETACH_DURABLE_OFF_400_ANCHOR = 'x-detach-on-disconnect requires a durable run';
+export function isDetachDurableOff400(err) {
+    try {
+        const e = err;
+        if (e?.status !== 400)
+            return false;
+        const msg = e?.message;
+        return typeof msg === 'string' && msg.includes(DETACH_DURABLE_OFF_400_ANCHOR);
+    }
+    catch {
+        return false;
+    }
+}
 export function detachDurableOffHint(err) {
     if (!isDetachArmed())
         return null;
-    const e = err;
-    if (e?.status !== 400)
-        return null;
-    const msg = typeof e?.message === 'string' ? e.message : '';
-    if (!msg.includes(DETACH_DURABLE_OFF_400_ANCHOR))
+    if (!isDetachDurableOff400(err))
         return null;
     return 'engine has durable runs disabled — detach-on-disconnect unavailable; interrupted turns will abort (SEMA_HEADLESS_DETACH=false to silence)';
 }

package/dist/displayUntrusted.js

@@ -23,6 +23,10 @@ function pushEdit(edits, src, start, end, text) {
         return;
     edits.push({ start: a, end: b, text });
 }
+const UNIT_NONE = 0;
+const UNIT_SEQUENCE = 1;
+const UNIT_SINGLE = 2;
+const NO_UNITS = () => UNIT_NONE;
 function applyEdits(text, edits) {
     if (edits.length === 0)
         return text;
@@ -48,6 +52,9 @@ class PlainTarget {
             this.origin = editedOrigin(this.origin, this.text.length, edits);
         this.text = applyEdits(this.text, edits);
     }
+    unitAt() {
+        return UNIT_NONE;
+    }
 }
 const traced = (text, origin) => (origin === undefined ? { text } : { text, origin });
 function editedOrigin(prev, length, edits) {
@@ -87,13 +94,19 @@ class TrackedTarget {
     src;
     spans = [];
     viewLength;
-    constructor(text, viewLength) {
+    units;
+    constructor(text, viewLength, units) {
         this.text = text;
         this.viewLength = viewLength;
+        this.units = units;
         this.src = new Int32Array(text.length);
         for (let k = 0; k < text.length; k++)
             this.src[k] = k;
     }
+    unitAt(k) {
+        const s = this.src[k] ?? -1;
+        return s >= 0 && this.units !== undefined ? (this.units[s] ?? UNIT_NONE) : UNIT_NONE;
+    }
     rangeStart(k) {
         const s = this.src[k] ?? 0;
         return s >= 0 ? s : (this.spans[2 * (-1 - s)] ?? 0);
@@ -344,17 +357,20 @@ function markerSpans(text) {
         spans.push(hit.index, hit.index + hit[0].length);
     return spans;
 }
-function schemelessUserinfoEdits(text) {
+function schemelessUserinfoEdits(text, unitAt = NO_UNITS) {
     const edits = [];
     const markers = markerSpans(text);
     let m = 0;
     let floor = 0;
-    for (let at = text.indexOf('@'); at !== -1; at = text.indexOf('@', at + 1)) {
-        const hostEnd = schemelessHostEnd(text, at + 1);
+    for (let at = text.indexOf('@'), prevAt = -1; at !== -1; prevAt = at, at = text.indexOf('@', at + 1)) {
+        let hostEnd = schemelessHostEnd(text, at + 1);
+        const hidden = hostEnd === -1;
+        if (hidden)
+            hostEnd = hiddenHostEnd(text, at + 1, unitAt);
         if (hostEnd === -1)
             continue;
         let runStart = at;
-        while (runStart > floor && !breaksUserinfo(text.charCodeAt(runStart - 1)))
+        while (runStart > floor && (!breaksUserinfo(text.charCodeAt(runStart - 1)) || (hidden && unitAt(runStart - 1) !== UNIT_NONE)))
             runStart--;
         if (text.charCodeAt(runStart) === 0x3a && runStart > floor && text[runStart - 1] === VIEW_SEPARATOR) {
             while (runStart > floor && text[runStart - 1] === VIEW_SEPARATOR)
@@ -391,16 +407,63 @@ function schemelessUserinfoEdits(text) {
         }
         if (found === -1)
             continue;
+        if (hidden && credentialWordAttached(text, prevAt + 1, found, at, unitAt))
+            continue;
         pushEdit(edits, text, found, at, REDACTED_USERINFO);
         floor = hostEnd;
     }
     return edits;
 }
+function credentialWordAttached(text, lo, found, at, unitAt) {
+    if (credentialWordEndsFrom(text.slice(lo, at), found - lo))
+        return true;
+    const kept = [];
+    let joinedFound = -1;
+    for (let k = lo; k < at; k++) {
+        if (k === found)
+            joinedFound = kept.length;
+        if (unitAt(k) === UNIT_NONE)
+            kept.push(text.charAt(k));
+    }
+    return joinedFound !== -1 && credentialWordEndsFrom(kept.join(''), joinedFound);
+}
+function credentialWordEndsFrom(seg, from) {
+    for (const word of [SECRET_LABELLED_WORD, SECRET_SCHEME_WORD]) {
+        const re = new RegExp(word.source, 'gi');
+        for (let hit = re.exec(seg); hit !== null; hit = re.exec(seg)) {
+            if (hit.index + hit[0].length >= from)
+                return true;
+            if (hit[0].length === 0)
+                re.lastIndex++;
+        }
+    }
+    return false;
+}
+function unitRunEnd(text, from, unitAt) {
+    let k = from;
+    while (k < text.length && unitAt(k) !== UNIT_NONE)
+        k++;
+    return k > from ? k : -1;
+}
+function hiddenHostEnd(text, from, unitAt) {
+    let k = unitRunEnd(text, from, unitAt);
+    if (k === -1)
+        return -1;
+    if (text.charCodeAt(k) === 0x3a) {
+        let d = k + 1;
+        while (d < text.length && text.charCodeAt(d) >= 0x30 && text.charCodeAt(d) <= 0x39)
+            d++;
+        if (d > k + 1)
+            k = d;
+    }
+    const c = text.charCodeAt(k);
+    return endsSchemelessHost(c) || c === 0x40 ? k : -1;
+}
 const MAX_URL_WASH_PASSES = 4;
 function washUrlNets(target) {
     for (let pass = 0; pass < MAX_URL_WASH_PASSES; pass++) {
         target.apply(urlTokenEdits(target.text));
-        const handedOff = schemelessUserinfoEdits(target.text);
+        const handedOff = schemelessUserinfoEdits(target.text, (k) => target.unitAt(k));
         target.apply(handedOff);
         if (handedOff.length === 0)
             return;
@@ -735,6 +798,24 @@ function exemptAddressEdits(src, from, to, edits) {
 function isAddressShaped(value, raw = value) {
     return value.startsWith(`${REDACTED_USERINFO}@`) || ADDRESS_SCHEME_RE.test(raw);
 }
+function gluedToSingleUnit(at, floor, unitAt) {
+    for (let k = at - 1; k >= floor; k--) {
+        const u = unitAt(k);
+        if (u === UNIT_SINGLE)
+            return true;
+        if (u === UNIT_NONE)
+            return false;
+    }
+    return false;
+}
+function userinfoHostHidden(text, at, unitAt) {
+    if (!text.startsWith(REDACTED_USERINFO, at))
+        return false;
+    let k = at + REDACTED_USERINFO.length;
+    while (text[k] === VIEW_SEPARATOR)
+        k++;
+    return text[k] === '@' && unitRunEnd(text, k + 1, unitAt) !== -1;
+}
 function addressExtentEnd(text, from) {
     let end = from;
     while (end < text.length) {
@@ -800,7 +881,7 @@ function trailingLabelStart(text, from, end) {
 }
 const withoutSeparators = (s) => (s.includes(VIEW_SEPARATOR) ? s.split(VIEW_SEPARATOR).join('') : s);
 const isHorizontalSpace = (ch) => ch === ' ' || ch === '\t' || ch === '\u00a0' || ch === VIEW_SEPARATOR;
-function labelEdits(text, re, literalBlanks = false) {
+function labelEdits(text, re, literalBlanks = false, unitAt = NO_UNITS) {
     const edits = [];
     const schemePass = re === SECRET_SCHEME_WORD;
     const idx = new InnerWordIndex(text);
@@ -864,6 +945,18 @@ function labelEdits(text, re, literalBlanks = false) {
                 const trailing = trailingLabelStart(text, v.start, end);
                 if (trailing !== -1)
                     end = v.start + trailing;
+                if (gluedToSingleUnit(v.start, hit.index, unitAt) || userinfoHostHidden(text, v.start, unitAt)) {
+                    const cut = trailing !== -1 ? end : Math.max(end, v.end);
+                    const keep = ADDRESS_SCHEME_RE.exec(text.slice(v.start, v.start + 20))?.[0].length ?? 0;
+                    const q = text.slice(v.start, cut).search(/[?#]/);
+                    const bodyEnd = q === -1 ? cut : v.start + q;
+                    if (withoutSeparators(text.slice(v.start + keep, bodyEnd)) !== '')
+                        pushEdit(edits, text, v.start + keep, bodyEnd, REDACTED_SECRET);
+                    if (q !== -1 && v.start + q + 1 < cut)
+                        pushEdit(edits, text, v.start + q + 1, cut, text.charAt(v.start + q) === '#' ? REDACTED_FRAGMENT : REDACTED_QUERY);
+                    re.lastIndex = cut;
+                    continue;
+                }
                 exemptAddressEdits(text, v.start, end, edits);
                 re.lastIndex = end;
                 continue;
@@ -1096,9 +1189,10 @@ function proseLiteralEdits(text) {
     return edits;
 }
 function washWordNets(target, literalBlanks = false) {
+    const unitAt = (k) => target.unitAt(k);
     target.apply(pemEdits(target.text));
-    target.apply(labelEdits(target.text, SECRET_SCHEME_WORD, literalBlanks));
-    target.apply(labelEdits(target.text, SECRET_LABELLED_WORD, literalBlanks));
+    target.apply(labelEdits(target.text, SECRET_SCHEME_WORD, literalBlanks, unitAt));
+    target.apply(labelEdits(target.text, SECRET_LABELLED_WORD, literalBlanks, unitAt));
     target.apply(authParamEdits(target.text));
     target.apply(proseLiteralEdits(target.text));
 }
@@ -1264,35 +1358,37 @@ function buildCredentialView(text, separated, wordLetters = false, blankTokens =
     const chars = [];
     const starts = [];
     const ends = [];
+    const units = [];
     let changed = false;
     let splitAny = false;
     const seq = new SequenceReader(text, blankTokens === 'blank' || blankTokens === 'fold' ? 'all' : blankTokens === 'foldlit' ? 'folded' : 'none', folding);
-    const keep = (ch, s, e) => {
+    const keep = (ch, s, e, unit = UNIT_NONE) => {
         chars.push(ch);
         starts.push(s);
         ends.push(e);
+        units.push(unit);
     };
-    const drop = (s, e, placeholder = VIEW_SEPARATOR) => {
+    const drop = (s, e, placeholder = VIEW_SEPARATOR, unit = UNIT_SINGLE) => {
         changed = true;
         if (separated)
-            keep(placeholder, s, e);
+            keep(placeholder, s, e, unit);
     };
     const dropUnit = (s, unit) => {
         const last = unit.end - 1;
         if ((blankTokens === 'literal' || blankTokens === 'foldlit') && last > s && text.charCodeAt(last) === 0x5c && nameBlankTokenAt(text, last) !== -1) {
-            drop(s, last);
+            drop(s, last, VIEW_SEPARATOR, UNIT_SEQUENCE);
             keep(text.charAt(last + 1), last, last + 6);
             for (let u = 2; u < 6; u++)
                 keep(text.charAt(last + u), last + 6, last + 6);
             return last + 6;
         }
         if (wordLetters && unit.content === undefined && last > s && (credentialWordBeginsWith(text, last) || finalIsStructural(text, last))) {
-            drop(s, last);
+            drop(s, last, VIEW_SEPARATOR, UNIT_SEQUENCE);
             keep(text.charAt(last), last, unit.end);
             splitAny = true;
             return unit.end;
         }
-        drop(s, unit.end);
+        drop(s, unit.end, VIEW_SEPARATOR, UNIT_SEQUENCE);
         return unit.end;
     };
     let i = 0;
@@ -1326,7 +1422,7 @@ function buildCredentialView(text, separated, wordLetters = false, blankTokens =
                     i = dropUnit(i, unit);
                     continue;
                 }
-                drop(i, tok.end, ' ');
+                drop(i, tok.end, ' ', isRegexSpace(tok.cp) && tok.cp !== 0xfeff ? UNIT_NONE : UNIT_SINGLE);
                 i = tok.end;
                 continue;
             }
@@ -1373,7 +1469,7 @@ function buildCredentialView(text, separated, wordLetters = false, blankTokens =
     }
     if (!changed || (wordLetters && !splitAny))
         return null;
-    return { view: chars.join(''), starts: Int32Array.from(starts), ends: Int32Array.from(ends) };
+    return { view: chars.join(''), starts: Int32Array.from(starts), ends: Int32Array.from(ends), units: Uint8Array.from(units) };
 }
 function finalIsStructural(text, at) {
     if (text.charCodeAt(at) !== 0x5c)
@@ -1460,7 +1556,7 @@ function rebuildFromView(original, view, target, trace = false) {
     return origin === null ? { text: rebuilt } : { text: rebuilt, origin: Int32Array.from(origin) };
 }
 function washThroughView(original, view, urls, words, trace = false, literalBlanks = false) {
-    const target = new TrackedTarget(view.view, view.view.length);
+    const target = new TrackedTarget(view.view, view.view.length, view.units);
     runCredentialNets(target, urls, words, literalBlanks);
     return target.text === view.view ? { text: original } : rebuildFromView(original, view, target, trace);
 }

package/dist/effortWire.d.ts

@@ -1,2 +1,3 @@
-export type ReasoningEffort = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+import { type TaskRequestReasoningEffort } from './taskRequestWords.js';
+export type ReasoningEffort = TaskRequestReasoningEffort;
 export declare function effortToReasoningEffort(effort: unknown): ReasoningEffort | undefined;

package/dist/effortWire.js

@@ -1,7 +1,5 @@
-const REASONING_EFFORT_TUPLE = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
-const _effortPins = [true, true];
-void _effortPins;
-const REASONING_EFFORTS = new Set(REASONING_EFFORT_TUPLE);
+import { REASONING_EFFORT_WORDS } from './taskRequestWords.js';
+const REASONING_EFFORTS = new Set(REASONING_EFFORT_WORDS);
 export function effortToReasoningEffort(effort) {
     return typeof effort === 'string' && REASONING_EFFORTS.has(effort) ? effort : undefined;
 }

package/dist/engineErrorCodes.d.ts

@@ -12,6 +12,7 @@ export declare const CONFIG_LIMIT_UNKNOWN_KEY = "config.limit_unknown_key";
 export declare const CONFIG_DELEGATION_ENTRY_CAPS = "config.delegation_entry_caps";
 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_REFUSAL_CODES: ReadonlySet<string>;
 export declare const DELEGATION_CONCURRENCY_CAP = "delegation.concurrency_cap";
 export declare const DELEGATION_SESSION_CAP = "delegation.session_cap";
@@ -27,6 +28,8 @@ export declare function isInterruptedToolEndCode(code: string | undefined): bool
 export declare const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = "capability.self_orchestration_required";
 export declare const GATE_PARKED_ERROR_CODE = "gate.parked";
 export declare const ACTIVE_RUN_BUSY_ERROR_CODE = "conflict.session_active_run";
+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";
 export declare const STOP_PARK_RESUME_WON = "stop.park_resume_won";
 export declare const STOP_NOT_LANDED = "stop.not_landed";
@@ -35,6 +38,8 @@ export declare const STOP_PARKED = "stop.parked";
 export declare const STOP_CONFLICT_CODES: readonly ["stop.park_arbiter_unreachable", "stop.park_resume_won", "stop.not_landed", "stop.not_local", "stop.parked"];
 export declare const OUTPUT_INVALID = "output.invalid";
 export declare const RESUME_POLICY_FOLD_CODE = "resume_blocked_by_policy";
+export declare const STATUS_DERIVED_COARSE_CODES: readonly ["request.rejected", "auth.unauthorized", "auth.forbidden", "not_found.resource", "request.payload_too_large", "request.unprocessable", "limit.rate_exceeded", "capability.unavailable", "internal.error"];
+export declare function isStatusDerivedCoarseCode(code: string | null | undefined): boolean;
 export declare const RESUME_AT_ERROR_CODE_PREFIX = "resume_at.";
 export declare const REWIND_ERROR_CODE_PREFIXES: readonly ["resume_at.", "rewind_snapshot."];
 export declare function isRewindFamilyCode(code: string | undefined): boolean;
@@ -47,9 +52,15 @@ export declare const RESUME_ENV_FAILED = "resume.env_failed";
 export declare const RESUME_TOOL_UNAVAILABLE = "resume.tool_unavailable";
 export declare const RESUME_TOOL_CONTRACT_MISMATCH = "resume.tool_contract_mismatch";
 export declare const RESUME_REOPEN_CODES: readonly string[];
+export declare const PARKED_RESUME_STARTUP_FAILED = "parked_resume.startup_failed";
 export declare const DECIDE_WORKFLOW_HOST_UNKNOWN = "decide.workflow_host_unknown";
 export declare const DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED = "decide.workflow_remember_unsupported";
 export declare const DECIDE_WORKFLOW_LANE_CODES: readonly string[];
+export declare const DECIDE_NOT_PARKED = "decide.not_parked";
+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 WORKFLOW_PARK_REFUSAL_CODES: readonly string[];
 export declare function isWorkflowParkRefusalCode(code: unknown): boolean;
 export declare const DRAINING_ERROR_CODE = "draining";

package/dist/engineErrorCodes.js

@@ -16,6 +16,7 @@ export const CONFIG_LIMIT_UNKNOWN_KEY = 'config.limit_unknown_key';
 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_REFUSAL_CODES = frozenSet([
     CONFIG_LIMIT_INVALID,
     CONFIG_STRATEGY_FIND_LIMIT_INVALID,
@@ -24,6 +25,7 @@ export const CONFIG_REFUSAL_CODES = frozenSet([
     CONFIG_DELEGATION_ENTRY_CAPS,
     CONFIG_MEMORY_PROJECT_KEY_SPELLING,
     CONFIG_MEMORY_WRITE_SCOPE_MISMATCH,
+    CONFIG_LEGACY_TOOL_NAME,
 ]);
 export const DELEGATION_CONCURRENCY_CAP = 'delegation.concurrency_cap';
 export const DELEGATION_SESSION_CAP = 'delegation.session_cap';
@@ -57,6 +59,10 @@ export function isInterruptedToolEndCode(code) {
 export const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = 'capability.self_orchestration_required';
 export const GATE_PARKED_ERROR_CODE = 'gate.parked';
 export const ACTIVE_RUN_BUSY_ERROR_CODE = 'conflict.session_active_run';
+export const CORRUPT_SESSION_ERROR_CODE = 'corrupt_session';
+export function isCorruptSessionCode(code) {
+    return code === CORRUPT_SESSION_ERROR_CODE;
+}
 export const STOP_PARK_ARBITER_UNREACHABLE = 'stop.park_arbiter_unreachable';
 export const STOP_PARK_RESUME_WON = 'stop.park_resume_won';
 export const STOP_NOT_LANDED = 'stop.not_landed';
@@ -71,6 +77,20 @@ 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 function isStatusDerivedCoarseCode(code) {
+    return typeof code === 'string' && STATUS_DERIVED_COARSE_CODES.includes(code);
+}
 export const RESUME_AT_ERROR_CODE_PREFIX = 'resume_at.';
 export const REWIND_ERROR_CODE_PREFIXES = Object.freeze([RESUME_AT_ERROR_CODE_PREFIX, 'rewind_snapshot.']);
 export function isRewindFamilyCode(code) {
@@ -92,12 +112,24 @@ export const RESUME_REOPEN_CODES = Object.freeze([
     RESUME_TOOL_UNAVAILABLE,
     RESUME_TOOL_CONTRACT_MISMATCH,
 ]);
+export const PARKED_RESUME_STARTUP_FAILED = 'parked_resume.startup_failed';
 export const DECIDE_WORKFLOW_HOST_UNKNOWN = 'decide.workflow_host_unknown';
 export const DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED = 'decide.workflow_remember_unsupported';
 export const DECIDE_WORKFLOW_LANE_CODES = Object.freeze([
     DECIDE_WORKFLOW_HOST_UNKNOWN,
     DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED,
 ]);
+export const DECIDE_NOT_PARKED = 'decide.not_parked';
+export const DECIDE_GATE_MOVED = 'decide.gate_moved';
+export const DECIDE_CLAIM_LOST = 'decide.claim_lost';
+export const DECIDE_PARK_MOVED_CODES = Object.freeze([
+    DECIDE_NOT_PARKED,
+    DECIDE_GATE_MOVED,
+    DECIDE_CLAIM_LOST,
+]);
+export function isDecideParkMovedCode(code) {
+    return typeof code === 'string' && DECIDE_PARK_MOVED_CODES.includes(code);
+}
 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

@@ -1,5 +1,6 @@
 export type NoticeAudience = 'user' | 'operator';
 export declare const ENGINE_NOTICE_CODES: readonly string[];
+export declare const SERVER_NOTICE_AUDIENCE: Readonly<Record<string, NoticeAudience>>;
 export declare function engineNoticeInCatalog(code: unknown): boolean;
 export declare const ENGINE_NOTICE_AUDIENCE: Readonly<Record<string, NoticeAudience>>;
 export declare function noticeAudienceOf(code: unknown): NoticeAudience;
@@ -65,7 +66,41 @@ export type ReadRootGrantNoticeFactsView = {
     reason?: string;
     sessionId?: string;
 };
-export declare function readReadRootGrantNotice(notice: {
-    readonly code?: string;
-    readonly detail?: object | null;
-} | null | undefined): ReadRootGrantNoticeFactsView | undefined;
+export declare function readReadRootGrantNotice(notice: unknown): ReadRootGrantNoticeFactsView | undefined;
+export interface InstructionsSourceChangedFactsView {
+    previous: string | null;
+    current: string | null;
+    sessionId: string;
+}
+export declare function readInstructionsSourceChanged(notice: unknown): InstructionsSourceChangedFactsView | undefined;
+export type NoticeCountReading = number | 'unknown';
+export interface SessionRecordsSkippedFactsView {
+    dropped: NoticeCountReading;
+    entriesKept: NoticeCountReading;
+    sessionId: string;
+}
+export declare function readSessionRecordsSkipped(notice: unknown): SessionRecordsSkippedFactsView | undefined;
+export declare function sessionRecordsSkippedNote(facts: Pick<SessionRecordsSkippedFactsView, 'entriesKept'>): string | undefined;
+export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
+    readonly 'mcp.injection_dropped': typeof readMcpInjectionDrop;
+    readonly 'delegation.ask_unresolvable': typeof readAskUnresolvable;
+    readonly 'config.durable_gate_unavailable': typeof readDurableGateUnavailable;
+    readonly 'skills.listing_truncated': typeof readSkillsListingTruncated;
+    readonly 'mcp.server_redialed': typeof readMcpServerRedialed;
+    readonly 'instructions.source_changed': typeof readInstructionsSourceChanged;
+    readonly 'approval.read_root_granted': typeof readReadRootGrantNotice;
+    readonly 'approval.read_root_grant_rejected': typeof readReadRootGrantNotice;
+    readonly 'session.records_skipped': typeof readSessionRecordsSkipped;
+}>;
+type FactReaderTable = typeof ENGINE_NOTICE_FACT_READERS;
+export type EngineNoticeFactsCode = keyof FactReaderTable;
+export interface EngineNoticeFactsOf<K extends EngineNoticeFactsCode> {
+    code: K;
+    audience: NoticeAudience;
+    facts: Exclude<ReturnType<FactReaderTable[K]>, undefined>;
+}
+export type EngineNoticeFacts = {
+    [K in EngineNoticeFactsCode]: EngineNoticeFactsOf<K>;
+}[EngineNoticeFactsCode];
+export declare function readEngineNoticeFacts(notice: unknown): EngineNoticeFacts | undefined;
+export {};