@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/mcpReconnect.js

@@ -1,13 +1,13 @@
 import { capForDisplay } from './fleetTaskDesc.js';
+import { STEERING_NOT_RUNNING } from './engineErrorCodes.js';
 import { ownDataField } from './ownKey.js';
 import { isSessionIdPathSegment } from './sessionIdSegment.js';
-import { inSlotReadOf, inValueOf } from './wireFailureShape.js';
+import { inSlotReadOf, inValueOf, slotReadOf } from './wireFailureShape.js';
 import { readMcpAuthorization } from './mcpLiveness.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export const MCP_RECONNECT_OUTCOMES = Object.freeze(['accepted', 'refused', 'unsupported']);
-export const MCP_RECONNECT_TRANSACTION_NOTICE = 'Reconnecting closes the current connection before dialing again. On a healthy server this is a transaction, ' +
-    'not a refresh: a failed re-dial leaves the server down and withdraws its tools from the model until a later re-dial succeeds.';
-export const MCP_RECONNECT_UNSETTLED_NOTICE = 'The MCP re-dial did not settle within the time this request waits, so there is no result yet: the re-dial was not cancelled and may still be running. ' +
-    "Check the server's state before re-dialing it again — a second request that arrives after the dial has settled closes the connection and dials once more.";
+export const MCP_RECONNECT_TRANSACTION_NOTICE = renderMessage(msg('session.mcpReconnect.transaction'));
+export const MCP_RECONNECT_UNSETTLED_NOTICE = renderMessage(msg('session.mcpReconnect.unsettled'));
 const UNSETTLED_CODE = 'state.mcp_reconnect_unsettled';
 const _sdkClientIsAnInjection = [true];
 void _sdkClientIsAnInjection;
@@ -141,7 +141,7 @@ export function classifyMcpReconnectFailure(e) {
         return unsettledVerdict(e);
     if (code === 'steering.invalid_content')
         return { kind: 'invalid' };
-    if (code === 'steering.not_running')
+    if (code === STEERING_NOT_RUNNING)
         return { kind: 'not_running' };
     if (typeof code === 'string' && code.startsWith('capability.'))
         return { kind: 'unsupported', reason: 'capability' };
@@ -196,23 +196,128 @@ export function projectMcpReconnectCapability(caps) {
         return undefined;
     }
 }
-export function mcpReconnectOutcomeDetail(view) {
+function reasonTailOf(reason, lang) {
+    return reason === undefined ? '' : renderMessage(msg('session.mcpReconnect.reasonTail', { reason }), lang);
+}
+function outcomeSentence(f, lang) {
+    switch (f.outcome) {
+        case 'accepted':
+            return renderMessage(msg(f.toolCount === 1 ? 'session.mcpReconnect.accepted.one' : 'session.mcpReconnect.accepted.other', { server: f.name, toolCount: f.toolCount, added: f.added, removed: f.removed }), lang);
+        case 'refused': {
+            const why = reasonTailOf(f.reason, lang);
+            if (f.roster === undefined)
+                return renderMessage(msg('session.mcpReconnect.refused.untouched', { server: f.name, why }), lang);
+            if (f.roster === 0)
+                return renderMessage(msg('session.mcpReconnect.refused.noTools', { server: f.name, why }), lang);
+            return renderMessage(msg(f.roster === 1 ? 'session.mcpReconnect.refused.listed.one' : 'session.mcpReconnect.refused.listed.other', { server: f.name, toolCount: f.roster, why }), lang);
+        }
+        case 'unsupported':
+            return renderMessage(msg('session.mcpReconnect.undeclared', { server: f.name, why: reasonTailOf(f.reason, lang) }), lang);
+    }
+}
+export function mcpReconnectOutcomeDetail(view, lang) {
     const name = capForDisplay(view.server, RECONNECT_WORD_MAX);
     switch (view.outcome) {
         case 'accepted':
-            return `MCP server ${name} was re-dialed: ${view.toolCount} tool${view.toolCount === 1 ? '' : 's'} mounted for this run (${view.added.length} added, ${view.removed.length} removed)`;
+            return outcomeSentence({ outcome: 'accepted', name, toolCount: view.toolCount, added: view.added.length, removed: view.removed.length }, lang);
+        case 'refused':
+            return outcomeSentence({ outcome: 'refused', name, roster: view.toolNames?.length, reason: view.reason }, lang);
+        case 'unsupported':
+            return outcomeSentence({ outcome: 'unsupported', name, reason: view.reason }, lang);
+    }
+}
+function verdictDetailKey(kind) {
+    switch (kind) {
+        case 'not_running':
+            return 'session.mcpReconnect.notRunning';
+        case 'unsupported':
+            return 'session.mcpReconnect.unsupported';
+        case 'not_found':
+            return 'session.mcpReconnect.notFound';
+        case 'invalid':
+            return 'session.mcpReconnect.invalid';
+        case 'failed':
+            return 'session.mcpReconnect.failed';
+        case 'no_session':
+            return 'session.mcpReconnect.noSession';
+        case 'unavailable':
+            return 'session.mcpReconnect.unavailable';
+        case 'unsettled':
+            return 'session.mcpReconnect.unsettled';
+        default:
+            return undefined;
+    }
+}
+function fieldOf(o, key) {
+    const s = slotReadOf(o, key);
+    return s.presence === 'present' ? { kind: 'value', value: s.value } : s.presence === 'absent' ? { kind: 'absent' } : { kind: 'unreadable' };
+}
+function okOutcomeFactsOf(verdict, server) {
+    const slot = fieldOf(verdict, 'result');
+    if (slot.kind !== 'value')
+        return undefined;
+    const r = slot.value;
+    if (r === null || typeof r !== 'object' || Array.isArray(r))
+        return undefined;
+    const outcome = fieldOf(r, 'outcome');
+    const echoed = fieldOf(r, 'server');
+    if (outcome.kind !== 'value' || echoed.kind !== 'value' || echoed.value !== server)
+        return undefined;
+    const rs = fieldOf(r, 'reason');
+    if (rs.kind === 'unreadable' || (rs.kind === 'value' && typeof rs.value !== 'string'))
+        return undefined;
+    const reason = rs.kind === 'value' ? rs.value : undefined;
+    const name = capForDisplay(server, RECONNECT_WORD_MAX);
+    switch (outcome.value) {
+        case 'unsupported':
+            return { outcome: 'unsupported', name, reason };
+        case 'accepted': {
+            const toolCount = fieldOf(r, 'toolCount');
+            const added = fieldOf(r, 'added');
+            const removed = fieldOf(r, 'removed');
+            if (toolCount.kind !== 'value' || added.kind !== 'value' || removed.kind !== 'value')
+                return undefined;
+            const n = toolCount.value;
+            const addedList = stringList(added.value);
+            const removedList = stringList(removed.value);
+            if (typeof n !== 'number' || !Number.isInteger(n) || n < 0 || addedList === undefined || removedList === undefined)
+                return undefined;
+            return { outcome: 'accepted', name, toolCount: n, added: addedList.length, removed: removedList.length };
+        }
         case 'refused': {
-            const why = view.reason !== undefined ? ` — ${view.reason}` : '';
-            if (view.toolNames === undefined) {
-                return `MCP server ${name} was NOT re-dialed; its connection and tools were left untouched${why}`;
-            }
-            if (view.toolNames.length === 0) {
-                return `MCP server ${name} was NOT re-dialed; this run's tool list has no tools from it right now (the dial failed, or this run's tool settings let none of its tools through)${why}`;
-            }
-            return `MCP server ${name} was NOT re-dialed; the engine reports ${view.toolNames.length} tool${view.toolNames.length === 1 ? '' : 's'} for it after this attempt${why}`;
+            const names = fieldOf(r, 'toolNames');
+            if (names.kind === 'unreadable')
+                return undefined;
+            if (names.kind === 'absent')
+                return { outcome: 'refused', name, roster: undefined, reason };
+            const roster = stringList(names.value);
+            if (roster === undefined)
+                return undefined;
+            return { outcome: 'refused', name, roster: roster.length, reason };
         }
-        case 'unsupported':
-            return (`This run declared no MCP servers, so there is nothing to re-dial (${name} is not part of this run)` +
-                (view.reason !== undefined ? ` — ${view.reason}` : ''));
+        default:
+            return undefined;
+    }
+}
+export function mcpReconnectVerdictDetail(verdict, server, lang) {
+    try {
+        if (verdict === null || typeof verdict !== 'object')
+            return undefined;
+        const kindSlot = slotReadOf(verdict, 'kind');
+        if (kindSlot.presence !== 'present' || typeof kindSlot.value !== 'string')
+            return undefined;
+        if (!nonEmpty(server))
+            return undefined;
+        if (kindSlot.value === 'ok') {
+            const facts = okOutcomeFactsOf(verdict, server);
+            return facts === undefined ? undefined : outcomeSentence(facts, lang);
+        }
+        const key = verdictDetailKey(kindSlot.value);
+        if (key === undefined)
+            return undefined;
+        return renderMessage(msg(key, { server: capForDisplay(server, RECONNECT_WORD_MAX) }), lang);
+    }
+    catch {
+        return undefined;
     }
 }

package/dist/mcpWireCaps.js

@@ -448,6 +448,6 @@ export function mcpAssertionHeaderNotSentNotice(specs) {
     const parts = distinct.slice(0, ASSERTION_NOTICE_NAMES_SHOWN).map((x) => `"${x}"`);
     if (distinct.length > ASSERTION_NOTICE_NAMES_SHOWN)
         parts.push(`+${distinct.length - ASSERTION_NOTICE_NAMES_SHOWN} more`);
-    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.147.0 accept this setting but do not send the header, ` +
+    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.148.0 accept this setting but do not send the header, ` +
         'and this client cannot tell whether the engine it uses sends it; a connector that requires the header will refuse requests from these servers');
 }

package/dist/model/engineModelWords.d.ts

@@ -0,0 +1,3 @@
+export type EngineModelWordKind = 'tier' | 'cc-alias' | 'best' | 'default';
+export declare const ENGINE_MODEL_WORDS: readonly string[];
+export declare function engineModelWordKindOf(word: string): EngineModelWordKind | undefined;

package/dist/model/engineModelWords.js

@@ -0,0 +1,13 @@
+import { CC_TIER_ALIASES, TIER_ORDER } from './tierVocabulary.js';
+export const ENGINE_MODEL_WORDS = Object.freeze([...TIER_ORDER, ...Object.keys(CC_TIER_ALIASES), 'best', 'default']);
+export function engineModelWordKindOf(word) {
+    if (typeof word !== 'string')
+        return undefined;
+    if (TIER_ORDER.includes(word))
+        return 'tier';
+    if (Object.hasOwn(CC_TIER_ALIASES, word))
+        return 'cc-alias';
+    if (word === 'best')
+        return 'best';
+    return word === 'default' ? 'default' : undefined;
+}

package/dist/model/subagentModelWord.d.ts

@@ -1,9 +1,9 @@
 import { type LiveModelCatalog } from '../liveModelCatalog.js';
 import type { UiLanguage } from '../env/uiLanguage.js';
-export type SubagentModelWordKind = 'inherit' | 'catalog' | 'tier' | 'cc-alias' | 'best' | 'model-id' | 'passthrough' | 'catalog-unknown' | 'ambiguous' | 'unbound';
+export type SubagentModelWordKind = 'inherit' | 'catalog' | 'tier' | 'cc-alias' | 'best' | 'default' | 'model-id' | 'passthrough' | 'catalog-unknown' | 'ambiguous' | 'unbound';
 export type SubagentModelWordProblem = 'tiers-inert' | 'chain-unbound' | 'binding-not-in-catalog';
 export interface SubagentModelLocalEngine {
-    readonly engine: 'started-by-this-process';
+    readonly engine: 'reads-this-config' | 'started-by-this-process';
     readonly tiers: Readonly<Record<string, string>> | undefined;
     readonly pool?: readonly {
         readonly name: string;
@@ -29,3 +29,22 @@ export interface SubagentModelWordReading {
 }
 export declare function resolveSubagentModelWord(input: SubagentModelWordInput | null | undefined): SubagentModelWordReading;
 export declare function subagentModelWordProblemLine(word: string, reading: SubagentModelWordReading, lang?: UiLanguage): string | undefined;
+export declare function subagentModelCallRefusalReason(word: string, reading: SubagentModelWordReading, lang?: UiLanguage): string | undefined;
+export type SubagentModelAdmission = {
+    readonly verdict: 'accepted';
+    readonly why: 'not_sent';
+} | {
+    readonly verdict: 'accepted';
+    readonly why: 'served';
+    readonly model: string;
+} | {
+    readonly verdict: 'refused';
+    readonly why: 'not_listed' | 'not_served' | 'disabled';
+    readonly model: string;
+} | {
+    readonly verdict: 'unknown';
+    readonly why: 'catalog_absent' | 'catalog_unreadable' | 'catalog_incomplete' | 'reserved_word';
+    readonly model: string;
+};
+export declare function subagentModelAdmissionOf(input: SubagentModelWordInput | null | undefined): SubagentModelAdmission;
+export declare function subagentModelAdmissionLine(word: string, admission: SubagentModelAdmission, lang?: UiLanguage): string | undefined;

package/dist/model/subagentModelWord.js

@@ -1,8 +1,10 @@
 import { CC_TIER_ALIASES, TIER_ORDER } from './tierVocabulary.js';
-import { liveModelRowsOf } from '../liveModelCatalog.js';
+import { ENGINE_MODEL_WORDS, engineModelWordKindOf } from './engineModelWords.js';
+import { liveModelRowsOf, modelAcceptanceOf } from '../liveModelCatalog.js';
 import { quoteUntrustedForSentence } from '../displayUntrusted.js';
 import { msg, renderMessage } from '../i18n/translate.js';
-const STARTED_BY_THIS_PROCESS = 'started-by-this-process';
+const READS_THIS_CONFIG = 'reads-this-config';
+const LEGACY_LOCAL_ENGINE_WORD = 'started-by-this-process';
 function ownData(v, key) {
     if (v === null || typeof v !== 'object')
         return undefined;
@@ -46,7 +48,8 @@ function localOf(input) {
     const local = ownData(input, 'local');
     if (local === null || typeof local !== 'object')
         return undefined;
-    return ownData(local, 'engine') === STARTED_BY_THIS_PROCESS ? local : undefined;
+    const engine = ownData(local, 'engine');
+    return engine === READS_THIS_CONFIG || engine === LEGACY_LOCAL_ENGINE_WORD ? local : undefined;
 }
 function catalogOf(input, local) {
     const live = ownData(input, 'liveCatalog');
@@ -115,14 +118,7 @@ function tiersOf(local) {
     }
     return out;
 }
-const BUILTIN_VOCAB = [...TIER_ORDER, ...Object.keys(CC_TIER_ALIASES), 'best'];
-function builtinKindOf(w) {
-    if (TIER_ORDER.includes(w))
-        return 'tier';
-    if (Object.hasOwn(CC_TIER_ALIASES, w))
-        return 'cc-alias';
-    return w === 'best' ? 'best' : undefined;
-}
+const builtinKindOf = engineModelWordKindOf;
 class BrokenBinding {
 }
 function landingOf(word, kind, tiers, cat) {
@@ -203,21 +199,22 @@ function resolveIn(input) {
         return { kind, model: w, landing: { name: l.name, via: l.via, source: 'local-config' }, label: `${l.name} (${label})` };
     };
     const asCatalog = (name) => ({ kind: 'catalog', model: name, label: name });
+    const asDefault = (w) => ({ kind: 'default', model: w, label: w });
+    const vocab = (w, b) => (b === 'default' ? asDefault(w) : tierClass(w, b));
     const classify = (k) => {
         if (cat?.nameSet.has(k))
             return asCatalog(k);
-        const b = builtinKindOf(k);
-        return tierClass(k, b ?? 'tier');
+        return vocab(k, builtinKindOf(k) ?? 'tier');
     };
     if (cat?.nameSet.has(word))
         return freezeReading(asCatalog(word));
     const exact = builtinKindOf(word);
     if (exact !== undefined)
-        return freezeReading(tierClass(word, exact));
+        return freezeReading(vocab(word, exact));
     if (tiers?.has(word))
         return freezeReading(tierClass(word, 'tier'));
     const lower = word.toLowerCase();
-    const space = new Set([...(cat?.names ?? []), ...BUILTIN_VOCAB, ...customTierKeys]);
+    const space = new Set([...(cat?.names ?? []), ...ENGINE_MODEL_WORDS, ...customTierKeys]);
     const ciMatches = [...space].filter((k) => k.toLowerCase() === lower);
     if (builtinKindOf(lower) !== undefined) {
         return freezeReading(ciMatches.length === 1 ? classify(ciMatches[0]) : { kind: 'ambiguous' });
@@ -241,21 +238,95 @@ export function resolveSubagentModelWord(input) {
         return freezeReading(word === '' ? { kind: 'inherit' } : { kind: 'catalog-unknown', model: word, label: word });
     }
 }
-export function subagentModelWordProblemLine(word, reading, lang) {
-    const ref = problemRefOf(word, reading);
-    return ref === undefined ? undefined : renderMessage(ref, lang);
-}
-function problemRefOf(word, reading) {
+function wordCauseOf(reading) {
     const kind = ownData(reading, 'kind');
-    if (kind !== 'unbound' && kind !== 'ambiguous')
-        return undefined;
-    const quoted = quoteUntrustedForSentence(typeof word === 'string' ? word.trim() : '', 80) ?? '""';
     if (kind === 'ambiguous')
-        return msg('model.subagent.ambiguous', { word: quoted });
+        return 'ambiguous';
+    if (kind !== 'unbound')
+        return undefined;
     const problem = ownData(reading, 'problem');
-    if (problem === 'tiers-inert')
-        return msg('model.subagent.tiersInert', { word: quoted });
-    if (problem === 'binding-not-in-catalog')
-        return msg('model.subagent.bindingNotInCatalog', { word: quoted });
-    return msg('model.subagent.chainUnbound', { word: quoted });
+    return problem === 'tiers-inert' || problem === 'binding-not-in-catalog' ? problem : 'chain-unbound';
+}
+const PROBLEM_LINE_KEYS = Object.freeze({
+    ambiguous: 'model.subagent.ambiguous',
+    'tiers-inert': 'model.subagent.tiersInert',
+    'chain-unbound': 'model.subagent.chainUnbound',
+    'binding-not-in-catalog': 'model.subagent.bindingNotInCatalog',
+});
+const CALL_REFUSAL_KEYS = Object.freeze({
+    ambiguous: 'model.subagent.call.ambiguous',
+    'tiers-inert': 'model.subagent.call.tiersInert',
+    'chain-unbound': 'model.subagent.call.chainUnbound',
+    'binding-not-in-catalog': 'model.subagent.call.bindingNotInCatalog',
+});
+const WORD_SHOWN_MAX = 80;
+function quotedWord(word) {
+    return quoteUntrustedForSentence(typeof word === 'string' ? word.trim() : '', WORD_SHOWN_MAX) ?? '""';
+}
+export function subagentModelWordProblemLine(word, reading, lang) {
+    const cause = wordCauseOf(reading);
+    return cause === undefined ? undefined : renderMessage(msg(PROBLEM_LINE_KEYS[cause], { word: quotedWord(word) }), lang);
+}
+export function subagentModelCallRefusalReason(word, reading, lang) {
+    try {
+        const cause = wordCauseOf(reading);
+        if (cause === undefined)
+            return undefined;
+        const label = ownData(reading, 'label');
+        const tier = typeof label === 'string' && label.trim() !== '' ? label : word;
+        return renderMessage(msg(CALL_REFUSAL_KEYS[cause], { word: quotedWord(word), tier: quotedWord(tier) }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
+const notSent = () => Object.freeze({ verdict: 'accepted', why: 'not_sent' });
+const isVocabKind = (k) => k === 'tier' || k === 'cc-alias' || k === 'best' || k === 'default';
+function admissionIn(input) {
+    const reading = resolveIn(input);
+    const model = reading.model;
+    if (model === undefined)
+        return notSent();
+    const live = ownData(input, 'liveCatalog');
+    if (live === undefined || live === null)
+        return Object.freeze({ verdict: 'unknown', why: 'catalog_absent', model });
+    const a = modelAcceptanceOf(model, live);
+    if (a.verdict === 'accepted')
+        return Object.freeze({ verdict: 'accepted', why: 'served', model });
+    if (a.verdict === 'refused') {
+        if (a.why === 'not_at_mentionable')
+            return Object.freeze({ verdict: 'accepted', why: 'served', model });
+        if (a.why === 'disabled')
+            return Object.freeze({ verdict: 'refused', why: 'disabled', model });
+        return Object.freeze({ verdict: 'refused', why: isVocabKind(reading.kind) ? 'not_served' : 'not_listed', model });
+    }
+    return Object.freeze({ verdict: 'unknown', why: a.why === 'model_absent' ? 'catalog_unreadable' : a.why, model });
+}
+export function subagentModelAdmissionOf(input) {
+    try {
+        return admissionIn(input);
+    }
+    catch {
+        const w = ownData(input, 'word');
+        const word = typeof w === 'string' ? w.trim() : '';
+        return word === '' ? notSent() : Object.freeze({ verdict: 'unknown', why: 'catalog_unreadable', model: word });
+    }
+}
+const ADMISSION_LINE_KEYS = Object.freeze({
+    not_listed: 'model.subagent.refused.notListed',
+    not_served: 'model.subagent.refused.notServed',
+    disabled: 'model.subagent.refused.disabled',
+});
+export function subagentModelAdmissionLine(word, admission, lang) {
+    try {
+        if (ownData(admission, 'verdict') !== 'refused')
+            return undefined;
+        const why = ownData(admission, 'why');
+        if (why !== 'not_listed' && why !== 'not_served' && why !== 'disabled')
+            return undefined;
+        return renderMessage(msg(ADMISSION_LINE_KEYS[why], { word: quotedWord(word) }), lang);
+    }
+    catch {
+        return undefined;
+    }
 }

package/dist/modelCapabilityProbe.js

@@ -1,5 +1,5 @@
 import { displayUntrusted } from './displayUntrusted.js';
-import { abortableSleep } from './abortableSleep.js';
+import { requestDeadline } from './abortableSleep.js';
 import { causeSlotProtected, walkCauseChain } from './engineWireFor.js';
 import { readThrownSlot } from './wireFailureShape.js';
 import { guardedRead, readOwnDataValue } from './ownKey.js';
@@ -128,15 +128,16 @@ export async function probeModelCapability(entry, send) {
         evidence: { baseline, attempts, lowEffortAccepted: !low.refused },
     };
 }
+const _capabilityBitsPin = true;
+void _capabilityBitsPin;
 export function applyProbeToEntry(entry, result) {
     if (result.verdict === 'inconclusive')
         return entry;
     const compatIn = typeof entry.compat === 'object' && entry.compat !== null && !Array.isArray(entry.compat)
         ? entry.compat
         : undefined;
-    if (result.verdict === 'no_reasoning') {
-        return { ...entry, reasoning: false };
-    }
+    if (result.verdict === 'no_reasoning')
+        return entry;
     if (result.verdict === 'disabled_via' && typeof result.thinkingFormat === 'string') {
         return { ...entry, reasoning: true, compat: { ...compatIn, thinkingFormat: result.thinkingFormat } };
     }
@@ -521,45 +522,8 @@ function shownCause(e, redact) {
     const shown = displayUntrusted(masked, { max: 160 });
     return shown.trim() === '' ? undefined : shown;
 }
-const MAX_TIMER_MS = 2_147_483_647;
-function probeDeadline(ms, cancel) {
-    const ctl = new AbortController();
-    const stop = new AbortController();
-    let expired = false;
-    const gone = new Promise((_resolve, reject) => {
-        const fire = () => reject(Object.assign(new Error('aborted'), { name: 'AbortError' }));
-        if (ctl.signal.aborted)
-            fire();
-        else
-            ctl.signal.addEventListener('abort', fire, { once: true });
-    });
-    gone.catch(() => undefined);
-    void abortableSleep(Math.min(ms, MAX_TIMER_MS), stop.signal).then(() => {
-        if (stop.signal.aborted)
-            return;
-        expired = true;
-        ctl.abort();
-    });
-    const onCancel = () => ctl.abort();
-    if (cancel !== undefined) {
-        if (cancel.aborted)
-            ctl.abort();
-        else
-            cancel.addEventListener('abort', onCancel, { once: true });
-    }
-    return {
-        signal: ctl.signal,
-        expired: () => expired,
-        abort: () => {
-            stop.abort();
-            cancel?.removeEventListener('abort', onCancel);
-            ctl.abort();
-        },
-        race: (p) => Promise.race([p, gone]),
-    };
-}
 async function getCatalogText(fetchIt, url, headers, timeoutMs, cancel) {
-    const d = probeDeadline(timeoutMs, cancel);
+    const d = requestDeadline(timeoutMs, cancel);
     try {
         const res = await d.race(fetchIt(url, { method: 'GET', headers, signal: d.signal }));
         let text = '';
@@ -576,7 +540,7 @@ async function getCatalogText(fetchIt, url, headers, timeoutMs, cancel) {
     }
 }
 async function postForFirstToken(fetchIt, api, url, path, headers, body, deadlineMs, cancel, now, redact) {
-    const d = probeDeadline(deadlineMs, cancel);
+    const d = requestDeadline(deadlineMs, cancel);
     const startedAt = now();
     try {
         const res = await d.race(fetchIt(url, { method: 'POST', headers, body, signal: d.signal }));

package/dist/modsFace.d.ts

@@ -1,8 +1,15 @@
-import type { WiringManifestModRefusedView } from './adapter/downstream/eventToSdkMessage.js';
+import type { WiringManifestModRefusedView, WiringManifestModView } from './adapter/downstream/eventToSdkMessage.js';
+import type { SessionModsView } from './seatContract.js';
+import type { DeviceUnreadable } from './deviceRebind.js';
 import type { EngineNoticeChromeEvent } from './seam.js';
 import type { UiLanguage } from './env/uiLanguage.js';
+import { type ApprovalRequestedBy } from './hitl/approvalAskers.js';
 export declare const MOD_LOADER_VERBS: readonly ["list", "load", "unload", "status"];
 export type ModLoaderVerb = (typeof MOD_LOADER_VERBS)[number];
 export declare function readModRegistrationRefusedNotice(ev: EngineNoticeChromeEvent): WiringManifestModRefusedView | undefined;
+export declare function sessionModsOf(manifest: {
+    readonly mods?: readonly WiringManifestModView[];
+} | null | undefined): SessionModsView | DeviceUnreadable;
 export declare function modCardSentence(input: object | null | undefined, lang?: UiLanguage): string | undefined;
+export declare function approvalRequestedBySentence(by: ApprovalRequestedBy | null | undefined, lang?: UiLanguage): string | undefined;
 export declare function modLoaderFailureSentence(name: string, error: unknown, lang?: UiLanguage): string;

package/dist/modsFace.js

@@ -4,6 +4,7 @@ import { displayUntrusted } from './displayUntrusted.js';
 import { WIRE_FAILURE_UNRENDERABLE_TEXT, wireFailureTextsOf } from './wireFailureShape.js';
 import { gateOutcomeOf, isDeniedGate, rewriteExtensionNamesOf, toolInputRewriteOf } from './gateOutcome.js';
 import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue, toolResultBlockOf } from './ownKey.js';
+import { requestedByViewOf } from './hitl/approvalAskers.js';
 const isCardRecordObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 export const MOD_LOADER_VERBS = Object.freeze(['list', 'load', 'unload', 'status']);
 const modRowOf = (r) => modRowsOf([r])?.[0];
@@ -21,6 +22,18 @@ export function readModRegistrationRefusedNotice(ev) {
         return undefined;
     }
 }
+export function sessionModsOf(manifest) {
+    try {
+        if (!isCardRecordObject(manifest))
+            return sessionModsUnreadable();
+        const rows = modRowsOf(readOwnDataValue(manifest, 'mods'));
+        return rows === undefined ? sessionModsUnreadable() : Object.freeze({ rows: Object.freeze(rows.slice()) });
+    }
+    catch {
+        return sessionModsUnreadable();
+    }
+}
+const sessionModsUnreadable = () => Object.freeze({ kind: 'unreadable', why: renderMessage(msg('config.mods.session.unreadable')) });
 const MOD_NAME_SHOWN_MAX = 64;
 const MOD_REASON_SHOWN_MAX = 160;
 const shownName = (s) => displayUntrusted(s, { blanks: true, max: MOD_NAME_SHOWN_MAX });
@@ -54,6 +67,20 @@ export function modCardSentence(input, lang) {
         return undefined;
     }
 }
+export function approvalRequestedBySentence(by, lang) {
+    try {
+        const view = requestedByViewOf(by);
+        if (view === undefined)
+            return undefined;
+        const name = shownName(view.name);
+        if (name.trim() === '')
+            return undefined;
+        return renderMessage(msg('config.mods.request.by', { by: name }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
 export function modLoaderFailureSentence(name, error, lang) {
     const shown = guardedRead(() => (typeof name === 'string' ? shownName(name) : undefined)) ?? '';
     const { reason } = wireFailureTextsOf(error);

package/dist/notifications.d.ts

@@ -1,4 +1,5 @@
 import type { PlanReviewOutcomeMeta } from './hitl/planReviewWire.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 import type { SubmissionKind } from './request/submissionIdentity.js';
 export interface TaskNotificationFields {
     taskId: string;
@@ -9,6 +10,7 @@ export interface TaskNotificationFields {
     outputFile?: string;
     diagnostics?: string;
     result?: string;
+    error?: string;
     stoppedBy?: string;
     partial?: boolean;
     exitCode?: number;
@@ -86,6 +88,19 @@ export declare function installNotificationQueuePort(port: NotificationQueuePort
 export declare function notificationQueuePortMisses(): number;
 export declare function _resetNotificationQueuePortForTest(): void;
 export declare function enqueuePlanReviewOutcome(value: string, meta?: PlanReviewOutcomeMeta): boolean;
+export type ResupplyTruncatedSource = 'task_notification' | 'workflow_complete';
+export declare function resupplyTruncatedSentence(facts: {
+    readonly bytes: number;
+    readonly droppedKeys: readonly string[];
+} | null | undefined, lang?: UiLanguage): string | undefined;
+export interface ResupplyTruncatedArmBody {
+    readonly source: ResupplyTruncatedSource;
+    readonly taskId: string;
+    readonly bytes: number;
+    readonly droppedKeys: readonly string[];
+    readonly text: string;
+}
+export declare function resupplyTruncatedArmBody(carrier: object | null | undefined, source: ResupplyTruncatedSource, taskId: string): ResupplyTruncatedArmBody | undefined;
 export declare function dropQueuedNotificationsForRun(taskId: string): number;
 export declare function markEngineWorkflowNotified(runId: string): void;
 export declare function isEngineWorkflowNotified(runId: string): boolean;
@@ -93,11 +108,22 @@ export declare function noteWorkflowCompletionCardEnqueued(runId: string): void;
 export declare function listNotifiedRuns(): string[];
 export declare function listWorkflowCompletionCardsEnqueued(): string[];
 export declare function isWorkflowCompletionCardEnqueued(runId: string): boolean;
-type WorkflowStatusProbe = (runId: string) => Promise<{
-    terminal: boolean;
-    status: 'completed' | 'failed';
-    summary: string;
-} | null>;
+export type WorkflowRunReader = (runId: string) => Promise<unknown>;
+export type WorkflowRunTerminalReading = {
+    readonly state: 'running';
+} | {
+    readonly state: 'awaiting approval';
+} | {
+    readonly state: 'completed' | 'failed';
+    readonly result?: string;
+    readonly error?: string;
+    readonly pointer: 'absent';
+    readonly truncated?: true;
+} | {
+    readonly state: 'unknown';
+    readonly why: 'body_unreadable' | 'status_unreadable' | 'status_unrecognized';
+};
+export declare function workflowRunTerminalReadingOf(body: unknown): WorkflowRunTerminalReading;
 export declare function outstandingWorkflowCount(): number;
 export declare function outstandingDeliverableWorkflowCount(): number;
 export declare function subscribeOutstandingWorkflows(listener: () => void): () => void;
@@ -111,7 +137,7 @@ export interface NotificationDropCounters {
     bgWatchCollectedUnprobed: number;
 }
 export declare function notificationDropCounters(): NotificationDropCounters;
-export declare function installWorkflowStatusProbe(probe: WorkflowStatusProbe): void;
+export declare function installWorkflowRunReader(reader: WorkflowRunReader | null): void;
 type BgTaskStatusProbe = (taskId: string) => Promise<{
     terminal: boolean;
     status: string;
@@ -129,6 +155,7 @@ export interface EngineWorkflowCompletion {
     status: 'completed' | 'failed';
     summary: string;
     completionId?: string;
+    diagnostics?: string;
 }
 export declare function enqueueBgChildNotification(raw: {
     taskId: string;
@@ -138,6 +165,9 @@ export declare function enqueueBgChildNotification(raw: {
     completionId?: string;
 }): void;
 export declare function enqueueEngineWorkflowNotification(raw: EngineWorkflowCompletion): void;
+export declare function workflowRecordRefOf(diagnostics: string | undefined): string | undefined;
+export declare function takeWorkflowPointerSupplement(runId: string, status: string, diagnostics: string | undefined, completionId?: string): Readonly<TaskNotificationFields> | undefined;
+export declare function settleWorkflowPointerOwed(runId: string): void;
 export declare function _resetEngineTaskNotificationForTest(): void;
 export declare function _tickWatchOnceForTest(nowMs?: number): Promise<void>;
 export declare function _setWatcherTimingForTest(o: {