@sema-agent/client-core 0.84.0 → 0.84.1

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -40,14 +40,15 @@ function joinableToolInput(args) {
     if (args === null || typeof args !== 'object' || Array.isArray(args))
         return undefined;
     let nodes = 0;
+    let transportRedacted = false;
     const stack = [{ v: args, depth: 0 }];
     while (stack.length > 0) {
         const { v, depth } = stack.pop();
         if (++nodes > TOOL_INPUT_SCAN_MAX_NODES || depth > TOOL_INPUT_SCAN_MAX_DEPTH)
             return undefined;
         if (typeof v === 'string') {
-            if (v.includes(REDACTION_MARKER_PREFIX) || isTransportPlaceholderLeaf(v))
-                return undefined;
+            if (!transportRedacted && (v.includes(REDACTION_MARKER_PREFIX) || isTransportPlaceholderLeaf(v)))
+                transportRedacted = true;
             continue;
         }
         if (v === null || typeof v !== 'object')
@@ -56,7 +57,7 @@ function joinableToolInput(args) {
         for (const c of children)
             stack.push({ v: c, depth: depth + 1 });
     }
-    return args;
+    return { input: args, transportRedacted };
 }
 const GATE_DENIED_DECISIONS = new Set(['deny']);
 const GATE_NON_DENIAL_DECISIONS = new Set(['allow', 'approve', 'edit', 'reject']);
@@ -92,9 +93,10 @@ function permissionDenialParts(stats, observed) {
         const ledgerInput = rawInput !== null && typeof rawInput === 'object' && !Array.isArray(rawInput)
             ? rawInput
             : undefined;
-        const joinedInput = ledgerInput === undefined && toolUseId !== undefined && toolInputByCallId?.has(toolUseId) === true
+        const joined = ledgerInput === undefined && toolUseId !== undefined && toolInputByCallId?.has(toolUseId) === true
             ? joinableToolInput(toolInputByCallId.get(toolUseId))
             : undefined;
+        const joinedInput = joined?.input;
         const toolInput = ledgerInput ?? joinedInput;
         const ledgerDeniedByRaw = row.deniedBy;
         const ledgerDeniedBy = typeof ledgerDeniedByRaw === 'string' && isGateDeniedByWord(ledgerDeniedByRaw)
@@ -116,6 +118,7 @@ function permissionDenialParts(stats, observed) {
             ...(toolUseId !== undefined ? { tool_use_id: toolUseId } : {}),
             ...(toolInput !== undefined ? { tool_input: toolInput } : {}),
             ...(joinedInput !== undefined ? { _sema_tool_input_source: 'tool_start' } : {}),
+            ...(joined?.transportRedacted === true ? { _sema_tool_input_redacted: true } : {}),
             ...(deniedBy !== undefined ? { deniedBy } : {}),
             ...(joinedDeniedBy !== undefined && ledgerDeniedBy === undefined
                 ? { _sema_denied_by_source: 'tool_end' }
@@ -145,7 +148,8 @@ function permissionDenialParts(stats, observed) {
                 continue;
             }
             const toolName = nonEmptyStr(toolNameRaw);
-            const joinedInput = toolInputByCallId?.has(callId) === true ? joinableToolInput(toolInputByCallId.get(callId)) : undefined;
+            const joined = toolInputByCallId?.has(callId) === true ? joinableToolInput(toolInputByCallId.get(callId)) : undefined;
+            const joinedInput = joined?.input;
             const deniedByRaw = gateDeniedByByCallId?.has(callId) === true ? gateDeniedByByCallId.get(callId) : undefined;
             const deniedBy = typeof deniedByRaw === 'string' && isGateDeniedByWord(deniedByRaw) ? deniedByRaw : undefined;
             const toolDenialKind = isCcToolDenialKind(mergedKind) ? mergedKind : undefined;
@@ -153,6 +157,7 @@ function permissionDenialParts(stats, observed) {
                 ...(toolName !== undefined ? { tool_name: toolName } : {}),
                 tool_use_id: callId,
                 ...(joinedInput !== undefined ? { tool_input: joinedInput, _sema_tool_input_source: 'tool_start' } : {}),
+                ...(joined?.transportRedacted === true ? { _sema_tool_input_redacted: true } : {}),
                 ...(deniedBy !== undefined ? { deniedBy, _sema_denied_by_source: 'tool_end' } : {}),
                 ...(toolDenialKind !== undefined ? { toolDenialKind } : {}),
             });

package/dist/agentsWireCaps.js

@@ -1,6 +1,7 @@
 import { hostEnv } from './hostEnv.js';
 import { makeEngineWireClient } from './engineWireSdk.js';
 import { frozenSet } from './frozenSet.js';
+import { settleWithinDeadline } from './abortableSleep.js';
 export const MAX_TASK_AGENTS = 32;
 export const MAX_AGENT_NAME_CHARS = 64;
 export const MAX_AGENT_TEXT_CHARS = 4_096;
@@ -173,6 +174,13 @@ export function projectAgentsForWire(defs, deps) {
     return { agents: out.length > 0 ? out : undefined, warnings };
 }
 export async function engineSupportsTaskAgents(baseUrl, opts) {
+    if (opts?.client !== undefined) {
+        const injected = opts.client;
+        if (typeof injected?.capabilities !== 'function')
+            return undefined;
+        const got = await settleWithinDeadline(opts.timeoutMs ?? 3000, (signal) => injected.capabilities({ signal }));
+        return got.kind === 'value' ? got.value?.taskAgents === true : undefined;
+    }
     const client = makeEngineWireClient({
         baseUrl,
         ...(opts?.authToken ? { token: opts.authToken } : {}),

package/dist/decideFailureNote.d.ts

@@ -1 +1,2 @@
-export declare function decideFailureNote(err: unknown): string;
+import { type ParkedResumeStartupDecision } from './resumeRefusalCopy.js';
+export declare function decideFailureNote(err: unknown, decision?: ParkedResumeStartupDecision): string;

package/dist/decideFailureNote.js

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

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/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

@@ -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';
@@ -92,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;
@@ -65,7 +66,32 @@ 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 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 {};

package/dist/engineNoticeCodes.js

@@ -74,8 +74,15 @@ export const ENGINE_NOTICE_CODES = Object.freeze([
     'tool_result.offload_put_failed',
 ]);
 const CATALOG = new Set(ENGINE_NOTICE_CODES);
+export const SERVER_NOTICE_AUDIENCE = Object.freeze({
+    'instructions.source_changed': 'user',
+    'memory.layer_locked_legacy': 'operator',
+});
+function audienceRow(table, code) {
+    return Object.hasOwn(table, code) ? table[code] : undefined;
+}
 export function engineNoticeInCatalog(code) {
-    return typeof code === 'string' && CATALOG.has(code);
+    return typeof code === 'string' && (CATALOG.has(code) || Object.hasOwn(SERVER_NOTICE_AUDIENCE, code));
 }
 export const ENGINE_NOTICE_AUDIENCE = Object.freeze({
     'config.autocompact_window_clamped': 'operator',
@@ -153,10 +160,9 @@ export const ENGINE_NOTICE_AUDIENCE = Object.freeze({
     'tool_result.offload_put_failed': 'operator',
 });
 export function noticeAudienceOf(code) {
-    const row = typeof code === 'string' && Object.hasOwn(ENGINE_NOTICE_AUDIENCE, code)
-        ? ENGINE_NOTICE_AUDIENCE[code]
-        : undefined;
-    return row ?? 'operator';
+    if (typeof code !== 'string')
+        return 'operator';
+    return audienceRow(ENGINE_NOTICE_AUDIENCE, code) ?? audienceRow(SERVER_NOTICE_AUDIENCE, code) ?? 'operator';
 }
 export const MCP_INJECTION_DROP_REASONS = Object.freeze([
     'malformed_entry',
@@ -348,3 +354,65 @@ function readRootGrantNoticeOf(notice) {
     const reason = str(o.reason);
     return { outcome: 'rejected', toolCallId, ...(reason !== undefined ? { reason } : {}), ...(sessionId !== undefined ? { sessionId } : {}) };
 }
+function ownPathOrNull(o, key) {
+    if (!Object.hasOwn(o, key))
+        return undefined;
+    const v = o[key];
+    if (v === null)
+        return null;
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+export function readInstructionsSourceChanged(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    try {
+        const n = notice;
+        if (n.code !== 'instructions.source_changed')
+            return undefined;
+        const d = n.detail;
+        if (typeof d !== 'object' || d === null || Array.isArray(d))
+            return undefined;
+        const o = d;
+        const previous = ownPathOrNull(o, 'previous');
+        const current = ownPathOrNull(o, 'current');
+        const sessionId = typeof o.sessionId === 'string' && o.sessionId.length > 0 ? o.sessionId : undefined;
+        if (previous === undefined || current === undefined || sessionId === undefined)
+            return undefined;
+        return { previous, current, sessionId };
+    }
+    catch {
+        return undefined;
+    }
+}
+export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
+    'mcp.injection_dropped': readMcpInjectionDrop,
+    'delegation.ask_unresolvable': readAskUnresolvable,
+    'config.durable_gate_unavailable': readDurableGateUnavailable,
+    'skills.listing_truncated': readSkillsListingTruncated,
+    'mcp.server_redialed': readMcpServerRedialed,
+    'instructions.source_changed': readInstructionsSourceChanged,
+    'approval.read_root_granted': readReadRootGrantNotice,
+    'approval.read_root_grant_rejected': readReadRootGrantNotice,
+});
+const _factReaderTablePin = true;
+void _factReaderTablePin;
+export function readEngineNoticeFacts(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    let code;
+    let detail;
+    try {
+        code = notice.code;
+        if (typeof code !== 'string' || !Object.hasOwn(ENGINE_NOTICE_FACT_READERS, code))
+            return undefined;
+        detail = notice.detail;
+    }
+    catch {
+        return undefined;
+    }
+    const k = code;
+    const facts = ENGINE_NOTICE_FACT_READERS[k]({ code: k, detail });
+    if (facts === undefined)
+        return undefined;
+    return { code: k, audience: noticeAudienceOf(k), facts };
+}

package/dist/engineWireSdk.d.ts

@@ -6,11 +6,13 @@ export type WireAuthTokenSource = string | (() => string | undefined);
 export declare function isLoopbackWireUrl(url: string): boolean;
 export declare function resolveWireAuth(baseUrl: string | undefined, token?: string): WireAuthToken;
 export declare function wireAuthTokenFor(baseUrl: string, token?: string): WireAuthToken;
+export type EngineProbeClient = Pick<AgentClient, 'capabilities' | 'scenarioCapabilities'>;
 export type EngineProbeOpts = {
     fetchImpl?: typeof fetch;
     timeoutMs?: number;
     authToken?: WireAuthTokenSource | undefined;
     principal?: string | undefined;
+    client?: EngineProbeClient;
 };
 export type EngineWireClientConfig = {
     baseUrl: string;

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, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, 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, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, 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/hitlHostSurface.js

@@ -113,7 +113,7 @@ export function observeCancelByDeny(settle, taskId) {
             hostLog('debug', `[hitl-cancel-deny] cancel-by-deny no_pending for run ${taskId} (benign — already resolved)`);
             return;
         }
-        const rowNote = decideFailureNote(e);
+        const rowNote = decideFailureNote(e, 'deny');
         hostLog('error', `[hitl-cancel-deny] cancel-by-deny FAILED for run ${taskId}: ${String(e)}${rowNote}`);
         surfaceCancelDenyWarn(`${CANCEL_DENY_WARN_TEXT}${rowNote}`);
     })

package/dist/hitl/parkResolver.d.ts

@@ -34,6 +34,7 @@ export type GateOutcome = {
 };
 export declare function isAlreadyResolvedGateReason(reason: unknown): boolean;
 export declare function isGateStandingErrorCode(code: string | null | undefined): boolean;
+export declare function isCodeClassifiedGateFailure(code: string | null | undefined): boolean;
 export declare function toAnsweredOutput(questions: unknown[], answer: QuestionAnswer): AskAnsweredOutput;
 export type ParkResolution = {
     kind: 'reattach';