@sema-agent/client-core 0.108.0 → 0.110.0

package/dist/mcpReconnect.js

@@ -1,12 +1,13 @@
 import { capForDisplay } from './fleetTaskDesc.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_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_UNSETTLED_NOTICE = renderMessage(msg('session.mcpReconnect.unsettled'));
 const UNSETTLED_CODE = 'state.mcp_reconnect_unsettled';
 const _sdkClientIsAnInjection = [true];
 void _sdkClientIsAnInjection;
@@ -82,8 +83,11 @@ export function projectMcpReconnectResult(body) {
         added,
         removed,
     };
-    if ('toolNames' in body && body.toolNames !== undefined) {
-        const toolNames = stringList(body.toolNames);
+    const names = inValueOf(body, 'toolNames');
+    if (names.state === 'unproven')
+        return undefined;
+    if (names.state === 'present' && names.value !== undefined) {
+        const toolNames = stringList(names.value);
         if (toolNames === undefined)
             return undefined;
         view.toolNames = toolNames;
@@ -93,8 +97,11 @@ export function projectMcpReconnectResult(body) {
     const status = projectStatus(body.status);
     if (status !== undefined)
         view.status = status;
-    if ('listingIncomplete' in body && body.listingIncomplete !== undefined) {
-        const li = projectListingIncomplete(body.listingIncomplete);
+    const incomplete = inValueOf(body, 'listingIncomplete');
+    if (incomplete.state === 'unproven')
+        return undefined;
+    if (incomplete.state === 'present' && incomplete.value !== undefined) {
+        const li = projectListingIncomplete(incomplete.value);
         if (li === undefined)
             return undefined;
         view.listingIncomplete = li;
@@ -116,7 +123,7 @@ function unsettledVerdict(carrier) {
 }
 function isUnsettledBody(raw) {
     try {
-        return isRecord(raw) && !('outcome' in raw) && raw.errorCode === UNSETTLED_CODE;
+        return isRecord(raw) && inSlotReadOf(raw, 'outcome').state === 'absent' && raw.errorCode === UNSETTLED_CODE;
     }
     catch {
         return false;
@@ -189,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

@@ -329,7 +329,7 @@ function dropNotice(name, reason, problem, opts, path, transportKind) {
                     : reason === 'elicitation_invalid'
                         ? msg('config.mcp.elicitationInvalid', { name: quoted, where })
                         : reason === 'allow_tools_invalid'
-                            ? msg('config.mcp.allowToolsInvalid', { name: quoted, where, problem: capForDisplay(problem ?? '', DROP_PROBLEM_SHOWN) })
+                            ? msg('config.mcp.allowToolsInvalid', { name: quoted, where, problem: problem ?? '' })
                             : reason === 'identity_headers_both_set'
                                 ? msg('config.mcp.identityHeadersBothSet', { name: quoted, where })
                                 : reason === 'transport_invalid'
@@ -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.144.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.147.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/memoryEntriesWire.d.ts

@@ -61,7 +61,7 @@ export interface MemoryEraseConflictRow {
     id: string;
     reason: string;
 }
-declare const MEMORY_ERASE_CARRIER_CLASSES: readonly ["projection", "shadow", "indexLine", "quarantineCopy", "planArchive", "planWorkbook", "evidenceBinding", "backendDerived"];
+declare const MEMORY_ERASE_CARRIER_CLASSES: readonly ["projection", "shadow", "indexLine", "quarantineCopy", "clearanceCustody", "planArchive", "planWorkbook", "evidenceBinding", "backendDerived"];
 export type MemoryEraseCarrierClass = (typeof MEMORY_ERASE_CARRIER_CLASSES)[number];
 export type MemoryEraseCarrierReading = {
     removed: number;

package/dist/memoryEntriesWire.js

@@ -174,6 +174,7 @@ const MEMORY_ERASE_CARRIER_CLASSES = Object.freeze([
     'shadow',
     'indexLine',
     'quarantineCopy',
+    'clearanceCustody',
     'planArchive',
     'planWorkbook',
     'evidenceBinding',
@@ -237,6 +238,10 @@ function eraseResidualsOf(o, lane) {
             return null;
         const carriers = {};
         for (const cls of MEMORY_ERASE_CARRIER_CLASSES) {
+            if (!Object.hasOwn(rawCarriers, cls)) {
+                carriers[cls] = { unverified: true };
+                continue;
+            }
             const answer = carrierAnswerOf(readThrownSlot(rawCarriers, cls, 'data'));
             if (answer === null)
                 return null;

package/dist/modelCapabilityProbe.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 } };
     }

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

@@ -6,7 +6,9 @@ export interface CutForDisplayResult {
     readonly shown: string;
     readonly truncated: boolean;
 }
+export declare function pairSafeCut(text: string, cut: number): number;
 export declare function cutForDisplay(text: string, budget: number, opts?: CutForDisplayOptions): CutForDisplayResult;
+export declare function elideMiddleForDisplay(text: string, budget: number): string;
 export type NoticePresentationAudience = 'user' | 'operator' | 'unknown';
 export type NoticeOutlet = 'present' | 'absent' | 'unknown';
 export type NoticeOccurrence = {

package/dist/noticePresentation.js

@@ -69,6 +69,14 @@ function pickCut(src, limit, floor, boundary) {
         return clause;
     return word >= floor ? word : -1;
 }
+export function pairSafeCut(text, cut) {
+    if (cut <= 0 || cut >= text.length || text.charAt(cut) !== '\\' || text.charAt(cut - 1) !== '\\')
+        return cut;
+    let start = cut - 1;
+    while (start > 0 && text.charAt(start - 1) === '\\')
+        start--;
+    return (cut - start) % 2 === 1 ? cut - 1 : cut;
+}
 export function cutForDisplay(text, budget, opts) {
     const src = typeof text === 'string' ? text : (guardedRead(() => String(text ?? '')) ?? '');
     if (typeof budget !== 'number' || !Number.isFinite(budget))
@@ -83,9 +91,79 @@ export function cutForDisplay(text, budget, opts) {
     const head = capDisplay(src, room, 'escape');
     const floor = Math.ceil(head.length / CUT_KEEP_DIVISOR);
     const at = pickCut(src, head.length, floor, boundary);
-    const kept = (at === -1 ? head : src.slice(0, at)).trimEnd();
+    const kept = src.slice(0, pairSafeCut(src, at === -1 ? head.length : at)).trimEnd();
     return { shown: `${kept}${mark}`, truncated: true };
 }
+const ELISION_MARK = '…';
+const ELISION_MIN_ROOM = 8;
+const ELISION_SOFT_BACKOFF = 24;
+const CLUSTER_EXTENDER = /^[\p{M}‍︀-️\u{1F3FB}-\u{1F3FF}\u{E0020}-\u{E007F}]/u;
+const REGIONAL_INDICATOR = /^[\u{1F1E6}-\u{1F1FF}]$/u;
+const RTL_LETTER = /^[\p{Script=Arabic}\p{Script=Hebrew}\p{Script=Syriac}\p{Script=Thaana}\p{Script=Nko}\p{Script=Samaritan}\p{Script=Mandaic}]$/u;
+function codePointBefore(text, i) {
+    return text.slice(Math.max(0, i - 2), i).match(/[\s\S]$/u)?.[0] ?? '';
+}
+function codePointAfter(text, i) {
+    const cp = i < text.length ? text.codePointAt(i) : undefined;
+    return cp === undefined ? '' : String.fromCodePoint(cp);
+}
+function hardSafeBoundary(text, i) {
+    return i <= 0 || i >= text.length || (capDisplay(text, i, 'escape').length === i && pairSafeCut(text, i) === i);
+}
+function calmBoundary(text, i) {
+    const before = codePointBefore(text, i);
+    const after = codePointAfter(text, i);
+    if (before === '' || after === '')
+        return true;
+    if (before === '‍' || CLUSTER_EXTENDER.test(after))
+        return false;
+    if (RTL_LETTER.test(before) || RTL_LETTER.test(after))
+        return false;
+    if (REGIONAL_INDICATOR.test(before) && REGIONAL_INDICATOR.test(after)) {
+        let run = 0;
+        for (let j = i; j > 0;) {
+            const cp = codePointBefore(text, j);
+            if (!REGIONAL_INDICATOR.test(cp))
+                break;
+            run++;
+            j -= cp.length;
+        }
+        return run % 2 === 0;
+    }
+    return true;
+}
+function settleOnCalm(text, at, step) {
+    for (let k = 0; k <= ELISION_SOFT_BACKOFF; k++) {
+        const i = at + step * k;
+        if (i < 0 || i > text.length)
+            break;
+        if (hardSafeBoundary(text, i) && calmBoundary(text, i))
+            return i;
+    }
+    return at;
+}
+export function elideMiddleForDisplay(text, budget) {
+    const src = typeof text === 'string' ? text : (guardedRead(() => String(text ?? '')) ?? '');
+    if (typeof budget !== 'number' || !Number.isFinite(budget))
+        return src;
+    const limit = Math.max(0, Math.floor(budget));
+    if (src.length <= limit)
+        return src;
+    const room = limit - ELISION_MARK.length;
+    if (room < ELISION_MIN_ROOM)
+        return cutForDisplay(src, limit).shown;
+    const headRoom = Math.ceil(room / 2);
+    const tailRoom = room - headRoom;
+    let head = headRoom;
+    while (head > 0 && !hardSafeBoundary(src, head))
+        head--;
+    let tail = src.length - tailRoom;
+    while (tail < src.length && !hardSafeBoundary(src, tail))
+        tail++;
+    head = settleOnCalm(src, head, -1);
+    tail = settleOnCalm(src, tail, 1);
+    return `${src.slice(0, head).trimEnd()}${ELISION_MARK}${src.slice(tail)}`;
+}
 export const NOTICE_SEAT_CLASS = Object.freeze({
     user: Object.freeze({ present: 'persistent+hint', unknown: 'persistent+hint', absent: 'persistent' }),
     operator: Object.freeze({ present: 'transient', unknown: 'transient', absent: 'diagnostic' }),

package/dist/notifications.d.ts

@@ -9,6 +9,7 @@ export interface TaskNotificationFields {
     outputFile?: string;
     diagnostics?: string;
     result?: string;
+    error?: string;
     stoppedBy?: string;
     partial?: boolean;
     exitCode?: number;
@@ -93,11 +94,21 @@ 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 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 +122,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;

package/dist/notifications.js

@@ -2,10 +2,11 @@ import { hostEnv } from './hostEnv.js';
 import { unrefTimer } from './unrefTimer.js';
 import { clearEnginePanelTaskResidentByWire, publishEngineAgentPanelEvent, } from './engineAgentPanelStore.js';
 import { panelEndFact } from './panelReduce.js';
-import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess } from './terminalStatuses.js';
+import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess, isCoreWorkflowRunParkedEnd, isCoreWorkflowRunTerminal } from './terminalStatuses.js';
 import { cycleSeqValue } from './cycleOrder.js';
 import { CORE_ENGINE_AUTHORITY_ENVELOPE_TAGS } from './generated/engineFactTables.js';
 import { guardedRead, ownSnapshot, ownSnapshotRecord, ownSnapshotTyped, readOwnDataValue, workflowCompletionExtrasOf } from './ownKey.js';
+import { displayUntrusted } from './displayUntrusted.js';
 function escapeXml(v) {
     return v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -102,6 +103,7 @@ export function freezeTaskNotificationFields(n) {
         ...(n.outputFile !== undefined ? { outputFile: n.outputFile } : {}),
         ...(n.diagnostics !== undefined ? { diagnostics: n.diagnostics } : {}),
         ...(n.result !== undefined ? { result: n.result } : {}),
+        ...(n.error !== undefined ? { error: n.error } : {}),
         ...(n.stoppedBy !== undefined ? { stoppedBy: n.stoppedBy } : {}),
         ...(n.partial !== undefined ? { partial: n.partial } : {}),
         ...(n.exitCode !== undefined ? { exitCode: n.exitCode } : {}),
@@ -128,7 +130,7 @@ export function taskNotificationOf(carrier) {
     if (typeof taskId !== 'string' || taskId.length === 0 || typeof status !== 'string' || typeof summary !== 'string')
         return undefined;
     const out = { taskId, status, summary };
-    for (const k of ['taskType', 'toolUseId', 'outputFile', 'diagnostics', 'result', 'stoppedBy', 'externalSource']) {
+    for (const k of ['taskType', 'toolUseId', 'outputFile', 'diagnostics', 'result', 'error', 'stoppedBy', 'externalSource']) {
         const v = slot(k);
         if (typeof v === 'string')
             out[k] = v;
@@ -478,6 +480,50 @@ const cardEnqueuedRunIds = new Set();
 export function isWorkflowCompletionCardEnqueued(runId) {
     return cardEnqueuedRunIds.has(runId);
 }
+export function workflowRunTerminalReadingOf(body) {
+    const snap = probeAnswerSnapshot(body);
+    if (snap === null)
+        return Object.freeze({ state: 'unknown', why: 'body_unreadable' });
+    const status = guardedRead(() => readOwnDataValue(snap, 'status'));
+    if (typeof status !== 'string')
+        return Object.freeze({ state: 'unknown', why: 'status_unreadable' });
+    if (status === 'running')
+        return Object.freeze({ state: 'running' });
+    if (!isCoreWorkflowRunTerminal(status))
+        return Object.freeze({ state: 'unknown', why: 'status_unrecognized' });
+    if (isCoreWorkflowRunParkedEnd(status, guardedRead(() => readOwnDataValue(snap, 'errorCode'))))
+        return Object.freeze({ state: 'awaiting approval' });
+    const result = guardedRead(() => readOwnDataValue(snap, 'result'));
+    const error = status === 'failed' ? guardedRead(() => readOwnDataValue(snap, 'error')) : undefined;
+    const shownError = typeof error === 'string' && error.length > 0 ? shownRunError(error) : '';
+    return Object.freeze({
+        state: status,
+        ...(typeof result === 'string' && result.length > 0 ? { result } : {}),
+        ...(shownError.length > 0 ? { error: shownError } : {}),
+        pointer: 'absent',
+    });
+}
+const WORKFLOW_RUN_ERROR_MAX = 200;
+function shownRunError(raw) {
+    const opts = { foldLines: false, escapeBackslashes: 'auto' };
+    const whole = displayUntrusted(raw, opts);
+    return whole.length <= WORKFLOW_RUN_ERROR_MAX ? whole : `${displayUntrusted(raw, { ...opts, max: WORKFLOW_RUN_ERROR_MAX - 1 })}…`;
+}
+function workflowPollDecisionOf(delivered, reading) {
+    if (delivered)
+        return { act: 'stop', why: 'delivered' };
+    if (reading.state === 'running')
+        return { act: 'wait', why: 'running' };
+    if (reading.state === 'awaiting approval')
+        return { act: 'wait', why: 'awaiting approval' };
+    if (reading.state === 'unknown')
+        return { act: 'wait', why: 'unknown' };
+    return { act: 'emit', status: reading.state, ...(reading.result !== undefined ? { result: reading.result } : {}), ...(reading.error !== undefined ? { error: reading.error } : {}) };
+}
+function workflowPollCompletionSummary(status, error) {
+    const head = `workflow ${status} (read from its run record; no handle to the full record is available)`;
+    return error === undefined ? head : `${head} — failure reason from the run record: ${error}`;
+}
 const outstandingRuns = new Map();
 const outstandingListeners = new Set();
 function notifyOutstanding() {
@@ -493,7 +539,7 @@ export function outstandingWorkflowCount() {
     return outstandingRuns.size;
 }
 export function outstandingDeliverableWorkflowCount() {
-    return statusProbe ? outstandingRuns.size : 0;
+    return workflowRunReader ? outstandingRuns.size : 0;
 }
 export function subscribeOutstandingWorkflows(listener) {
     outstandingListeners.add(listener);
@@ -531,12 +577,12 @@ export function notificationDropCounters() {
         bgWatchCollectedUnprobed,
     };
 }
-let statusProbe = null;
+let workflowRunReader = null;
 let watchTimer = null;
 const WATCH_INTERVAL_MS = 5000;
 const WATCH_TTL_MS = 2 * 60 * 60 * 1000;
-export function installWorkflowStatusProbe(probe) {
-    statusProbe = probe;
+export function installWorkflowRunReader(reader) {
+    workflowRunReader = reader;
 }
 const BG_FIRST_SEQ = 1;
 function normalizeBgSeq(seq) {
@@ -762,26 +808,25 @@ async function tickWatchInner(now) {
             bgProbeInFlight.delete(key);
         }
     }
-    const probe = statusProbe;
+    const reader = workflowRunReader;
     for (const runId of [...outstandingRuns.keys()]) {
         if (notifiedRunIds.has(runId)) {
             if (outstandingRuns.delete(runId))
                 notifyOutstanding();
             continue;
         }
-        if (!probe)
+        if (!reader)
             continue;
         runProbeInFlight.set(runId, now);
         try {
-            const res = probeAnswerSnapshot(await withProbeDeadline(probe(runId), probeTimeoutMs()));
-            if (res?.terminal) {
-                if (outstandingRuns.delete(runId))
-                    notifyOutstanding();
-                enqueueEngineWorkflowNotification({
-                    runId,
-                    status: res.status,
-                    summary: res.summary,
-                });
+            const reading = workflowRunTerminalReadingOf(await withProbeDeadline(reader(runId), probeTimeoutMs()));
+            const decision = workflowPollDecisionOf(notifiedRunIds.has(runId), reading);
+            if (decision.act === 'wait')
+                continue;
+            if (outstandingRuns.delete(runId))
+                notifyOutstanding();
+            if (decision.act === 'emit') {
+                enqueueWorkflowCompletion({ runId, status: decision.status, summary: workflowPollCompletionSummary(decision.status, decision.error) }, { ...(decision.result !== undefined ? { result: decision.result } : {}), ...(decision.error !== undefined ? { error: decision.error } : {}) });
             }
         }
         catch {
@@ -845,6 +890,9 @@ export function enqueueEngineWorkflowNotification(raw) {
         traceNotif('workflow-notification dropped:payload-unreadable');
         return;
     }
+    enqueueWorkflowCompletion(c, completionIdOnly(workflowCompletionExtrasOf(c)));
+}
+function enqueueWorkflowCompletion(c, body) {
     if (notifiedRunIds.has(c.runId)) {
         workflowDedupDropped++;
         traceNotif(`workflow notification suppressed (run already notified) runId=${c.runId} status=${c.status}`);
@@ -852,7 +900,7 @@ export function enqueueEngineWorkflowNotification(raw) {
     }
     markRunNotified(c.runId);
     cardEnqueuedRunIds.add(c.runId);
-    port()?.enqueuePendingNotification(taskNotificationQueueCommand({ taskId: c.runId, taskType: 'workflow', status: c.status, summary: c.summary, ...completionIdOnly(workflowCompletionExtrasOf(c)) }));
+    port()?.enqueuePendingNotification(taskNotificationQueueCommand({ taskId: c.runId, taskType: 'workflow', status: c.status, summary: c.summary, ...body }));
 }
 export function _resetEngineTaskNotificationForTest() {
     notifiedRunIds.clear();
@@ -867,7 +915,7 @@ export function _resetEngineTaskNotificationForTest() {
     bgProbeInFlight.clear();
     runProbeInFlight.clear();
     tickGeneration = 0;
-    statusProbe = null;
+    workflowRunReader = null;
     bgStatusProbe = null;
     tickStartedAtMs = null;
     abandonedCount = 0;