@sema-agent/client-core 0.110.0 → 0.111.0

package/dist/localEngineSpawn.js

@@ -61,14 +61,6 @@ function stringOf(x) {
         return undefined;
     }
 }
-function parseJsonLine(t) {
-    try {
-        return JSON.parse(t);
-    }
-    catch {
-        return undefined;
-    }
-}
 function freezeRecord(rows) {
     const out = {};
     for (const [k, v] of rows)
@@ -397,90 +389,6 @@ export function localEnginePrincipalSentence(p, lang) {
         return undefined;
     }
 }
-const BOOT_REFUSAL_MAX_CHARS = 800;
-const BOOT_REFUSAL_MAX_HINTS = 2;
-const CONFIG_CODE = /^config\.[A-Za-z0-9_.-]+$/;
-function capSentence(s) {
-    const t = s.trim();
-    return t.length > BOOT_REFUSAL_MAX_CHARS ? `${t.slice(0, BOOT_REFUSAL_MAX_CHARS)}…` : t;
-}
-export function engineBootRefusalOf(lines, scrub) {
-    try {
-        const clean = (s) => {
-            try {
-                const out = scrub(s);
-                return typeof out === 'string' ? out : undefined;
-            }
-            catch {
-                return undefined;
-            }
-        };
-        const hints = [];
-        let code;
-        let hint;
-        let fatal;
-        const list = Array.isArray(lines) ? [...lines] : [];
-        for (const raw of list) {
-            if (typeof raw !== 'string')
-                continue;
-            const line = clean(raw);
-            if (line === undefined)
-                continue;
-            const t = line.trim();
-            if (!t.startsWith('{'))
-                continue;
-            const o = parseJsonLine(t);
-            if (!isRecord(o))
-                continue;
-            const m = own(o, 'msg');
-            const err = own(o, 'err');
-            if (m === 'fatal' && typeof err === 'string' && err.trim() !== '') {
-                const full = clean(err);
-                const s = full === undefined ? undefined : full.replace(/^\s*Error:\s*/, '');
-                if (s !== undefined && s.trim() !== '')
-                    fatal = capSentence(s);
-                continue;
-            }
-            const c = own(o, 'code');
-            const h = own(o, 'hint');
-            if (typeof c === 'string' && CONFIG_CODE.test(c) && typeof h === 'string' && h.trim() !== '') {
-                const model = own(o, 'model');
-                const who = typeof model === 'string' && model !== '' ? `"${model}": ` : '';
-                const s = clean(`${who}${h}`);
-                const cc = clean(c);
-                if (s === undefined || cc === undefined || !CONFIG_CODE.test(cc))
-                    continue;
-                const sentence = capSentence(s);
-                code = cc;
-                const ch = clean(h);
-                hint = ch === undefined ? undefined : capSentence(ch);
-                if (hints.includes(sentence))
-                    continue;
-                hints.push(sentence);
-                if (hints.length > BOOT_REFUSAL_MAX_HINTS)
-                    hints.shift();
-            }
-        }
-        const parts = [...hints, ...(fatal !== undefined ? [fatal] : [])];
-        if (parts.length === 0)
-            return undefined;
-        return Object.freeze({ ...(code !== undefined ? { code } : {}), ...(hint !== undefined ? { hint } : {}), text: parts.join('\n') });
-    }
-    catch {
-        return undefined;
-    }
-}
-export function engineBootRefusalSentence(refusal, lang) {
-    try {
-        const text = own(refusal, 'text');
-        if (typeof text !== 'string' || text.trim() === '')
-            return undefined;
-        return renderMessage(msg('localEngine.bootRefusal', { reason: text }), lang);
-    }
-    catch {
-        return undefined;
-    }
-}
 export function localEngineFirstShareSentence(lang) {
     return renderMessage(msg('localEngine.firstShare'), lang);
 }

package/dist/localEngineStep.d.ts

@@ -14,7 +14,7 @@ export interface LocalEngineStepOccupancy extends LocalEngineOccupancy {
     readonly bgIds: readonly string[] | null;
 }
 export type LocalEngineTarget = EngineSwapCardTarget;
-export type LocalEngineStateDownReason = 'lock-unavailable' | 'spawn-failed' | 'spawn-refused' | 'stop-failed' | 'crash-loop' | 'high-water-unreadable';
+export type LocalEngineStateDownReason = 'lock-unavailable' | 'spawn-failed' | 'spawn-refused' | 'stop-failed' | 'crash-loop' | 'high-water-unreadable' | 'exited-once';
 export interface LocalEngineCauseEntry {
     readonly cause: LocalEngineSwapCause;
     readonly fingerprint: string;
@@ -189,7 +189,7 @@ export type LocalEngineEvent = {
     readonly clean: boolean | 'unknown';
     readonly nowMs: number;
 };
-export declare const LOCAL_ENGINE_FAIL_CODES: readonly ["local_engine.behind", "local_engine.legacy_below_floor", "local_engine.unresponsive", "local_engine.swap_pending", "local_engine.drain_overdue", "local_engine.unanswered_unverifiable", "local_engine.lock_unavailable", "local_engine.spawn_failed", "local_engine.spawn_refused", "local_engine.stop_failed", "local_engine.crash_loop", "local_engine.high_water_unreadable", "local_engine.principal_unknown"];
+export declare const LOCAL_ENGINE_FAIL_CODES: readonly ["local_engine.behind", "local_engine.legacy_below_floor", "local_engine.unresponsive", "local_engine.swap_pending", "local_engine.drain_overdue", "local_engine.unanswered_unverifiable", "local_engine.lock_unavailable", "local_engine.spawn_failed", "local_engine.spawn_refused", "local_engine.stop_failed", "local_engine.crash_loop", "local_engine.high_water_unreadable", "local_engine.exited_once", "local_engine.principal_unknown"];
 export type LocalEngineFailCode = (typeof LOCAL_ENGINE_FAIL_CODES)[number];
 export type LocalEngineNotice = {
     readonly key: 'versionUnknown';

package/dist/localEngineStep.js

@@ -18,6 +18,7 @@ export const LOCAL_ENGINE_FAIL_CODES = Object.freeze([
     'local_engine.stop_failed',
     'local_engine.crash_loop',
     'local_engine.high_water_unreadable',
+    'local_engine.exited_once',
     'local_engine.principal_unknown',
 ]);
 function isRecord(v) {
@@ -210,6 +211,7 @@ const DOWN_FAIL = Object.freeze({
     'stop-failed': 'local_engine.stop_failed',
     'crash-loop': 'local_engine.crash_loop',
     'high-water-unreadable': 'local_engine.high_water_unreadable',
+    'exited-once': 'local_engine.exited_once',
 });
 function showCard(p, hold, occ, fx, policy) {
     if (headless(policy)) {

package/dist/mcpReconnect.js

@@ -1,12 +1,12 @@
 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, 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_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];
@@ -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' };

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';
@@ -522,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 = '';
@@ -577,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/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;
@@ -87,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;
@@ -104,6 +118,7 @@ export type WorkflowRunTerminalReading = {
     readonly result?: string;
     readonly error?: string;
     readonly pointer: 'absent';
+    readonly truncated?: true;
 } | {
     readonly state: 'unknown';
     readonly why: 'body_unreadable' | 'status_unreadable' | 'status_unrecognized';
@@ -140,6 +155,7 @@ export interface EngineWorkflowCompletion {
     status: 'completed' | 'failed';
     summary: string;
     completionId?: string;
+    diagnostics?: string;
 }
 export declare function enqueueBgChildNotification(raw: {
     taskId: string;
@@ -149,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: {