@sema-agent/client-core 0.109.0 → 0.110.0

package/dist/mcpReconnect.js

@@ -1,13 +1,13 @@
 import { capForDisplay } from './fleetTaskDesc.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_UNSETTLED_NOTICE = renderMessage(msg('session.mcpReconnect.unsettled'));
 const UNSETTLED_CODE = 'state.mcp_reconnect_unsettled';
 const _sdkClientIsAnInjection = [true];
 void _sdkClientIsAnInjection;
@@ -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/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/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;

package/dist/ownKey.d.ts

@@ -39,11 +39,6 @@ export interface HumanInputAttachmentDeclinedByView {
     name: string;
 }
 export declare function humanInputAttachmentsOf(frame: {} | null | undefined): HumanInputAttachmentView[] | undefined;
-export interface HumanInputAuthorKeys {
-    author?: string;
-    extension?: string;
-}
-export declare function humanInputAuthorKeys(frame: {} | null | undefined): HumanInputAuthorKeys;
 export declare function markMcpSectionDroppedNamedRows(rows: object, dropped: ReadonlyMap<string, number>): void;
 export declare function mcpSectionDroppedNamedRowsOf(rows: object | null | undefined, name: string): number;
 export interface PromptManifestSectionRow {

package/dist/ownKey.js

@@ -193,13 +193,6 @@ export function humanInputAttachmentsOf(frame) {
         return undefined;
     }
 }
-export function humanInputAuthorKeys(frame) {
-    if (typeof frame !== 'object' || frame === null || Array.isArray(frame))
-        return {};
-    const author = guardedRead(() => readOwnDataNonEmptyString(frame, 'author'));
-    const extension = guardedRead(() => readOwnDataNonEmptyString(frame, 'extension'));
-    return { ...(author !== undefined ? { author } : {}), ...(extension !== undefined ? { extension } : {}) };
-}
 const DROPPED_NAMED_ROWS = Symbol.for('@sema-agent/client-core/mcpSectionDroppedNamedRows');
 export function markMcpSectionDroppedNamedRows(rows, dropped) {
     if (dropped.size === 0)

package/dist/peerFrames.d.ts

@@ -1,6 +1,7 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export declare const AGENT_MESSAGE_TAG = "agent-message";
 export declare const CROSS_SESSION_MESSAGE_TAG = "cross-session-message";
-export declare const PEER_FRAME_LANES: readonly ["agent_message", "cross_session_message", "cross_session_notice"];
+export declare const PEER_FRAME_LANES: readonly ["agent_message", "cross_session_message", "cross_session_notice", "inbox_notice"];
 export declare const CROSS_SESSION_NOTICE_KINDS: readonly ["delivery_notice", "idle_notice"];
 export type CrossSessionNoticeKind = (typeof CROSS_SESSION_NOTICE_KINDS)[number];
 export declare const PEER_MODE_CLASSES: readonly ["bypass", "prompting"];
@@ -22,13 +23,50 @@ export type CrossSessionMessageFrame = {
     fromScope?: string;
     seq?: number;
 };
+export type PeerNoticeFacts = {
+    state: string;
+    recipient?: string;
+    target?: string;
+    detail?: string;
+    dropReason?: string;
+    refSeq?: number;
+    finishedAt?: number;
+};
 export type CrossSessionNoticeFrame = {
     lane: 'cross_session_notice';
     kind: CrossSessionNoticeKind;
     text: string;
+    notice?: PeerNoticeFacts;
+};
+export type InboxNoticeFrame = {
+    lane: 'inbox_notice';
+    pending: number;
+    delivered: number;
+    urgent?: number;
+    resupplied?: number;
 };
-export type PeerFrameProjection = AgentMessageFrame | CrossSessionMessageFrame | CrossSessionNoticeFrame;
+export type PeerFrameProjection = AgentMessageFrame | CrossSessionMessageFrame | CrossSessionNoticeFrame | InboxNoticeFrame;
 export declare function classifyPeerNotification(raw: Record<string, unknown>): PeerFrameProjection | null;
+export type SessionBoxNoticeFacts = {
+    noticeKind: 'inbox';
+    pending: number;
+    delivered: number;
+    urgent?: number;
+    resupplied?: number;
+} | {
+    noticeKind: 'delivery' | 'idle';
+    state: string;
+    peerLabel?: string;
+    detail?: string;
+    dropReason?: string;
+    refSeq?: number;
+    finishedAt?: number;
+};
+export type SessionBoxNoticeBody = SessionBoxNoticeFacts & {
+    text: string;
+};
+export declare function sessionBoxNoticeSentence(facts: SessionBoxNoticeFacts, lang?: UiLanguage): string | undefined;
+export declare function sessionBoxNoticeOf(p: PeerFrameProjection): SessionBoxNoticeBody | undefined;
 export declare function renderPeerFrameTranscriptText(p: PeerFrameProjection): string;
 export declare function parsePeerFrameText(text: string): AgentMessageFrame | CrossSessionMessageFrame | null;
 export declare function peerFrameDisplayName(p: AgentMessageFrame | CrossSessionMessageFrame): string;