@sema-agent/client-core 0.83.6 → 0.84.1

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/engineAgentAbsence.d.ts

@@ -49,4 +49,41 @@ export interface EngineAgentAbsenceReapOptions {
 export declare function reapEngineAgentAbsentRows(rows: Readonly<Record<string, EngineAgentAbsenceReapRow | null | undefined>>, opts: EngineAgentAbsenceReapOptions): EngineAgentAbsenceReap;
 export declare function engineAgentAbsenceDroppedLine(label: string, ttlMs?: number, removeReason?: string | null): string;
 export declare function engineAgentTerminalAfterDropLine(label: string, status: RunTerminalStatus, hasReport: boolean): string;
+export interface EngineAgentRegistryRowView {
+    readonly id: string;
+    readonly type: string;
+    readonly status: string;
+    readonly description?: string;
+    readonly createdAt?: number;
+}
+export type EngineAgentRegistryUnavailableWhy = 'no_list_face' | 'route_absent' | 'ownership_required' | 'read_failed';
+export type EngineAgentRegistryListing = {
+    readonly kind: 'rows';
+    readonly rows: readonly EngineAgentRegistryRowView[];
+    readonly sessionId: string;
+    readonly seq: number;
+} | {
+    readonly kind: 'unavailable';
+    readonly why: EngineAgentRegistryUnavailableWhy;
+    readonly status?: number;
+    readonly errorCode?: string;
+};
+export declare function engineAgentRegistryKeyOf(ev: Pick<EngineAgentPanelAbsence, 'taskId' | 'wireTaskId'> | null | undefined): string | undefined;
+export interface EngineAgentRegistryReadingOptions {
+    readonly singleReplica?: true;
+    readonly sessionId?: string;
+}
+export declare function engineAgentRegistryReadingOf(listing: EngineAgentRegistryListing | null | undefined, registryKey: string | null | undefined, opts?: EngineAgentRegistryReadingOptions | null): EngineAgentRegistryReading;
+export interface EngineAgentRegistryMissingRow {
+    readonly id: string;
+    readonly status: string;
+    readonly description?: string;
+    readonly createdAt: number;
+}
+export interface EngineAgentRegistryFillOptions {
+    readonly nowMs?: number;
+    readonly goneSinceRead?: ReadonlySet<string> | readonly string[];
+    readonly sessionId?: string;
+}
+export declare function engineAgentRegistryRowsMissingFromHost(listing: EngineAgentRegistryListing | null | undefined, hostRegistryKeys: ReadonlySet<string> | readonly string[], opts?: EngineAgentRegistryFillOptions | null): readonly EngineAgentRegistryMissingRow[];
 export {};

package/dist/engineAgentAbsence.js

@@ -1,4 +1,6 @@
+import { registryClockNowMs, registryListingProvenanceOf } from './agentSession/engineAgentRegistryRead.js';
 import { displayUntrusted } from './displayUntrusted.js';
+import { ABSENT_SETTLE_MS } from './fleetAgentPanelProjection.js';
 import { isEnginePanelTaskResident, isStaleEngineAgentPanelEnd, } from './engineAgentPanelStore.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;
@@ -129,3 +131,143 @@ export function engineAgentTerminalAfterDropLine(label, status, hasReport) {
     const tail = hasReport ? ' · its final report arrived too late to keep in the panel' : '';
     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_TYPE = 'background_agent';
+function registryStatusReading(status) {
+    const s = status;
+    switch (s) {
+        case 'pending':
+        case 'running':
+        case 'parked':
+            return 'running';
+        case 'completed':
+        case 'failed':
+        case 'killed':
+        case 'cancelled':
+            return 'ended';
+        default: {
+            const unhandled = s;
+            void unhandled;
+            return 'unknown';
+        }
+    }
+}
+export function engineAgentRegistryKeyOf(ev) {
+    if (typeof ev !== 'object' || ev === null)
+        return undefined;
+    const w = ev.wireTaskId;
+    const t = ev.taskId;
+    const wire = typeof w === 'string' && w.length > 0 ? w : undefined;
+    const task = typeof t === 'string' && t.length > 0 ? t : undefined;
+    if (wire !== undefined && REGISTRY_AGENT_HANDLE_RE.test(wire))
+        return wire;
+    if (task !== undefined && REGISTRY_AGENT_HANDLE_RE.test(task))
+        return task;
+    return wire ?? task;
+}
+function ownOpt(opts, key) {
+    if (typeof opts !== 'object' || opts === null || !Object.hasOwn(opts, key))
+        return { given: false, value: undefined };
+    const value = opts[key];
+    return { given: value !== undefined, value };
+}
+function sessionMismatch(readSessionId, opts) {
+    const { given, value } = ownOpt(opts, 'sessionId');
+    if (!given)
+        return false;
+    return typeof value !== 'string' || value.length === 0 || readSessionId !== value;
+}
+export function engineAgentRegistryReadingOf(listing, registryKey, opts) {
+    try {
+        return readingOf(listing, registryKey, opts);
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function readingOf(listing, registryKey, opts) {
+    const rec = registryListingProvenanceOf(listing);
+    if (rec === undefined || rec.superseded)
+        return 'unknown';
+    if (sessionMismatch(rec.sessionId, opts))
+        return 'unknown';
+    return readingFromRecord(rec, registryKey, opts);
+}
+function readingFromRecord(rec, registryKey, opts) {
+    if (typeof registryKey !== 'string' || registryKey.length === 0)
+        return 'unknown';
+    let reading;
+    for (const r of rec.rows) {
+        if (r.id !== registryKey)
+            continue;
+        const here = r.type === REGISTRY_AGENT_TYPE ? registryStatusReading(r.status) : 'unknown';
+        reading = reading === undefined || reading === here ? here : 'unknown';
+    }
+    if (reading !== undefined)
+        return reading;
+    if (rec.rawRowCount >= REGISTRY_LIST_LIMIT)
+        return 'unknown';
+    if (!ownOpt(opts, 'sessionId').given)
+        return 'unknown';
+    const single = ownOpt(opts, 'singleReplica');
+    return single.given && single.value === true && REGISTRY_AGENT_HANDLE_RE.test(registryKey) ? 'not_listed' : 'unknown';
+}
+function keySetOf(v) {
+    if (v instanceof Set)
+        return (k) => v.has(k);
+    if (Array.isArray(v))
+        return (k) => v.includes(k);
+    return undefined;
+}
+export function engineAgentRegistryRowsMissingFromHost(listing, hostRegistryKeys, opts) {
+    try {
+        return rowsMissingFromHost(listing, hostRegistryKeys, opts);
+    }
+    catch {
+        return [];
+    }
+}
+function rowsMissingFromHost(listing, hostRegistryKeys, opts) {
+    const rec = registryListingProvenanceOf(listing);
+    if (rec === undefined || rec.superseded)
+        return [];
+    if (sessionMismatch(rec.sessionId, opts))
+        return [];
+    const has = keySetOf(hostRegistryKeys);
+    if (has === undefined)
+        return [];
+    const goneOpt = ownOpt(opts, 'goneSinceRead');
+    const gone = goneOpt.given ? keySetOf(goneOpt.value) : () => false;
+    if (gone === undefined)
+        return [];
+    const nowOpt = ownOpt(opts, 'nowMs');
+    const now = nowOpt.given ? nowOpt.value : registryClockNowMs();
+    if (typeof now !== 'number' || !Number.isFinite(now))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const r of rec.rows) {
+        if (r.type !== REGISTRY_AGENT_TYPE)
+            continue;
+        if (seen.has(r.id))
+            continue;
+        if (readingFromRecord(rec, r.id, undefined) !== 'running')
+            continue;
+        seen.add(r.id);
+        if (has(r.id) || gone(r.id))
+            continue;
+        const firstSeen = rec.firstSeenAtMs(r.id);
+        if (firstSeen === undefined || now - firstSeen <= ABSENT_SETTLE_MS)
+            continue;
+        if (typeof r.createdAt !== 'number' || !Number.isFinite(r.createdAt))
+            continue;
+        out.push({
+            id: r.id,
+            status: r.status,
+            ...(typeof r.description === 'string' && r.description.length > 0 ? { description: r.description } : {}),
+            createdAt: r.createdAt,
+        });
+    }
+    return out;
+}

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";
@@ -47,6 +48,7 @@ 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[];

package/dist/engineErrorCodes.js

@@ -1,3 +1,4 @@
+import { frozenSet } from './frozenSet.js';
 export const LIMITS_MAX_TOKENS_EXCEEDED = 'limits.max_tokens_exceeded';
 export const LIMITS_MAX_COST_EXCEEDED = 'limits.max_cost_exceeded';
 export const LIMITS_MAX_TURNS_EXCEEDED = 'limits.max_turns_exceeded';
@@ -15,7 +16,8 @@ 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_REFUSAL_CODES = new Set([
+export const CONFIG_LEGACY_TOOL_NAME = 'config.legacy_tool_name';
+export const CONFIG_REFUSAL_CODES = frozenSet([
     CONFIG_LIMIT_INVALID,
     CONFIG_STRATEGY_FIND_LIMIT_INVALID,
     CONFIG_STRATEGY_MAX_SIZE_INVALID,
@@ -23,10 +25,11 @@ export const CONFIG_REFUSAL_CODES = new Set([
     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';
-export const DELEGATION_CAP_CODES = new Set([
+export const DELEGATION_CAP_CODES = frozenSet([
     DELEGATION_CONCURRENCY_CAP,
     DELEGATION_SESSION_CAP,
 ]);
@@ -61,17 +64,17 @@ export const STOP_PARK_RESUME_WON = 'stop.park_resume_won';
 export const STOP_NOT_LANDED = 'stop.not_landed';
 export const STOP_NOT_LOCAL = 'stop.not_local';
 export const STOP_PARKED = 'stop.parked';
-export const STOP_CONFLICT_CODES = [
+export const STOP_CONFLICT_CODES = Object.freeze([
     STOP_PARK_ARBITER_UNREACHABLE,
     STOP_PARK_RESUME_WON,
     STOP_NOT_LANDED,
     STOP_NOT_LOCAL,
     STOP_PARKED,
-];
+]);
 export const OUTPUT_INVALID = 'output.invalid';
 export const RESUME_POLICY_FOLD_CODE = 'resume_blocked_by_policy';
 export const RESUME_AT_ERROR_CODE_PREFIX = 'resume_at.';
-export const REWIND_ERROR_CODE_PREFIXES = [RESUME_AT_ERROR_CODE_PREFIX, 'rewind_snapshot.'];
+export const REWIND_ERROR_CODE_PREFIXES = Object.freeze([RESUME_AT_ERROR_CODE_PREFIX, 'rewind_snapshot.']);
 export function isRewindFamilyCode(code) {
     return typeof code === 'string' && REWIND_ERROR_CODE_PREFIXES.some((p) => code.startsWith(p));
 }
@@ -91,6 +94,7 @@ 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([

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;
@@ -52,3 +53,45 @@ export interface McpServerRedialedFactsView {
     runId: string;
 }
 export declare function readMcpServerRedialed(notice: unknown): McpServerRedialedFactsView | undefined;
+export type ReadRootGrantNoticeFactsView = {
+    outcome: 'granted';
+    toolCallId: string;
+    dir: string;
+    root: string;
+    covers?: 'exact';
+    sessionId?: string;
+} | {
+    outcome: 'rejected';
+    toolCallId: string;
+    reason?: string;
+    sessionId?: string;
+};
+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 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;
+}>;
+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 {};