@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/notifications.js

@@ -2,10 +2,12 @@ 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 { guardedRead, ownSnapshot, ownSnapshotRecord, ownSnapshotTyped, readOwnDataNonEmptyString, readOwnDataValue, resupplyTruncatedFactsOf, resupplyTruncatedOf, workflowCompletionExtrasOf } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { displayUntrustedCapped } from './displayUntrusted.js';
 function escapeXml(v) {
     return v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -102,6 +104,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 +131,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;
@@ -211,6 +214,7 @@ export function normalizeTaskNotification(raw) {
         ? n.lines.filter((l) => typeof l === 'string')
         : [];
     const recentSteps = deriveNotificationResidualLines(n);
+    const failureReason = failureReasonOf(status, n.error);
     return {
         taskId,
         status,
@@ -228,6 +232,7 @@ export function normalizeTaskNotification(raw) {
             ? { diagnostics: n.diagnostics }
             : {}),
         ...(typeof n.result === 'string' && n.result.length > 0 ? { result: n.result } : {}),
+        ...(failureReason !== undefined ? { error: failureReason } : {}),
         ...(typeof n.stoppedBy === 'string' && n.stoppedBy.length > 0 ? { stoppedBy: n.stoppedBy } : {}),
         ...(n.partial === true ? { partial: true } : {}),
         ...(typeof n.exitCode === 'number' ? { exitCode: n.exitCode } : {}),
@@ -420,6 +425,7 @@ export function enqueuePlanReviewOutcome(value, meta) {
         queuePortMisses++;
         return false;
     }
+    const questionId = meta === undefined ? undefined : guardedRead(() => readOwnDataNonEmptyString(meta, 'questionId'));
     p.enqueueMetaPrompt({
         value,
         mode: 'prompt',
@@ -434,12 +440,34 @@ export function enqueuePlanReviewOutcome(value, meta) {
                     decision: meta.decision,
                     effect: meta.effect,
                     ...(meta.effect === 'still_parked' && meta.cause === 'stored_form_unsupported' ? { cause: meta.cause } : {}),
+                    ...(questionId !== undefined ? { questionId } : {}),
                 }),
             }
             : {}),
     });
     return true;
 }
+export function resupplyTruncatedSentence(facts, lang) {
+    try {
+        const f = resupplyTruncatedFactsOf(facts);
+        if (f === undefined)
+            return undefined;
+        const count = f.droppedKeys.length;
+        return renderMessage(msg(count === 1 ? 'notice.resupply.truncated.one' : 'notice.resupply.truncated.other', count === 1 ? { bytes: f.bytes } : { bytes: f.bytes, count }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resupplyTruncatedArmBody(carrier, source, taskId) {
+    const facts = resupplyTruncatedOf(carrier);
+    if (facts === undefined)
+        return undefined;
+    const text = resupplyTruncatedSentence(facts);
+    if (text === undefined)
+        return undefined;
+    return { source, taskId, bytes: facts.bytes, droppedKeys: facts.droppedKeys, text };
+}
 export function dropQueuedNotificationsForRun(taskId) {
     const needle = `<${TASK_ID_TAG}>${escapeXml(taskId)}</${TASK_ID_TAG}>`;
     const p = port();
@@ -478,6 +506,61 @@ 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 shownError = failureReasonOf(status, guardedRead(() => readOwnDataValue(snap, 'error')));
+    const resultFull = guardedRead(() => readOwnDataValue(snap, 'resultFull'));
+    return Object.freeze({
+        state: status,
+        ...(typeof result === 'string' && result.length > 0 ? { result } : {}),
+        ...(shownError !== undefined ? { error: shownError } : {}),
+        pointer: 'absent',
+        ...(typeof resultFull === 'string' && resultFull.length > 0 ? { truncated: true } : {}),
+    });
+}
+const WORKFLOW_RUN_ERROR_MAX = 200;
+function shownRunError(raw) {
+    return displayUntrustedCapped(raw, WORKFLOW_RUN_ERROR_MAX, { foldLines: false, escapeBackslashes: 'auto' });
+}
+function failureReasonOf(status, raw) {
+    if (status !== 'failed' || typeof raw !== 'string' || raw.length === 0)
+        return undefined;
+    const shown = shownRunError(raw);
+    return shown.length > 0 ? shown : undefined;
+}
+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 } : {}),
+        ...(reading.truncated === true ? { truncated: true } : {}),
+    };
+}
+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 +576,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 +614,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 +845,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 } : {}) }, { truncated: decision.truncated === true });
             }
         }
         catch {
@@ -845,6 +927,17 @@ export function enqueueEngineWorkflowNotification(raw) {
         traceNotif('workflow-notification dropped:payload-unreadable');
         return;
     }
+    const extras = workflowCompletionExtrasOf(c);
+    if (notifiedRunIds.has(c.runId)) {
+        const supplement = takeWorkflowPointerSupplement(c.runId, c.status, extras.diagnostics, extras.completionId);
+        if (supplement !== undefined) {
+            port()?.enqueuePendingNotification(taskNotificationQueueCommand(supplement));
+            return;
+        }
+    }
+    enqueueWorkflowCompletion(c, completionIdOnly(extras));
+}
+function enqueueWorkflowCompletion(c, body, poll) {
     if (notifiedRunIds.has(c.runId)) {
         workflowDedupDropped++;
         traceNotif(`workflow notification suppressed (run already notified) runId=${c.runId} status=${c.status}`);
@@ -852,11 +945,68 @@ 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)) }));
+    if (poll !== undefined)
+        notePointerOwed(c.runId, poll.truncated);
+    port()?.enqueuePendingNotification(taskNotificationQueueCommand({ taskId: c.runId, taskType: 'workflow', status: c.status, summary: c.summary, ...body }));
+}
+const pointerOwedRuns = new Map();
+const POINTER_OWED_MAX = 512;
+function notePointerOwed(runId, truncated) {
+    pointerOwedRuns.delete(runId);
+    pointerOwedRuns.set(runId, { truncated });
+    while (pointerOwedRuns.size > POINTER_OWED_MAX) {
+        const oldest = pointerOwedRuns.keys().next();
+        if (oldest.done === true)
+            break;
+        pointerOwedRuns.delete(oldest.value);
+    }
+}
+const WORKFLOW_RECORD_REF_SENTENCE = /Full record \(the result and every agent's row\): read it with ReadToolResult \(ref "([A-Za-z0-9_.~-]{1,518})"\) before assuming an empty or unexpected result\./g;
+export function workflowRecordRefOf(diagnostics) {
+    if (typeof diagnostics !== 'string' || diagnostics.length === 0)
+        return undefined;
+    try {
+        let ref;
+        for (const m of diagnostics.matchAll(WORKFLOW_RECORD_REF_SENTENCE))
+            ref = m[1];
+        return ref;
+    }
+    catch {
+        return undefined;
+    }
+}
+function workflowPointerSupplementSummary(ref, truncated) {
+    const head = `Full record of this workflow run (the result and every agent's row): read it with ReadToolResult (ref "${ref}")`;
+    return truncated ? `${head} — the result delivered earlier was cut short; the full text is in this record.` : `${head}.`;
+}
+export function takeWorkflowPointerSupplement(runId, status, diagnostics, completionId) {
+    try {
+        const owed = pointerOwedRuns.get(runId);
+        if (owed === undefined)
+            return undefined;
+        const ref = workflowRecordRefOf(diagnostics);
+        if (ref === undefined)
+            return undefined;
+        pointerOwedRuns.delete(runId);
+        return freezeTaskNotificationFields({
+            taskId: runId,
+            taskType: 'workflow',
+            status,
+            summary: workflowPointerSupplementSummary(ref, owed.truncated),
+            ...(completionId !== undefined ? { completionId } : {}),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function settleWorkflowPointerOwed(runId) {
+    pointerOwedRuns.delete(runId);
 }
 export function _resetEngineTaskNotificationForTest() {
     notifiedRunIds.clear();
     notifiedBgCycleHigh.clear();
+    pointerOwedRuns.clear();
     cardEnqueuedRunIds.clear();
     outstandingRuns.clear();
     outstandingBgTasks.clear();
@@ -867,7 +1017,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 {
@@ -84,3 +79,9 @@ export declare function workflowCompletionExtrasOf(c: object): {
     completionId?: string;
     diagnostics?: string;
 };
+export interface ResupplyTruncatedFacts {
+    readonly bytes: number;
+    readonly droppedKeys: readonly string[];
+}
+export declare function resupplyTruncatedFactsOf(slot: {} | null | undefined): ResupplyTruncatedFacts | undefined;
+export declare function resupplyTruncatedOf(carrier: object | null | undefined): ResupplyTruncatedFacts | undefined;

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)
@@ -460,3 +453,34 @@ export function workflowCompletionExtrasOf(c) {
         ...(diagnostics !== undefined ? { diagnostics } : {}),
     };
 }
+const DROPPED_KEYS_MAX = 256;
+const DROPPED_KEY_NAME_MAX = 128;
+export function resupplyTruncatedFactsOf(slot) {
+    try {
+        if (typeof slot !== 'object' || slot === null || Array.isArray(slot))
+            return undefined;
+        const bytes = guardedRead(() => readOwnDataValue(slot, 'bytes'));
+        if (typeof bytes !== 'number' || !Number.isSafeInteger(bytes) || bytes <= 0)
+            return undefined;
+        const keys = guardedRead(() => readOwnDataValue(slot, 'droppedKeys'));
+        if (!Array.isArray(keys))
+            return undefined;
+        const length = guardedRead(() => keys.length);
+        if (typeof length !== 'number' || length < 1 || length > DROPPED_KEYS_MAX)
+            return undefined;
+        const names = [];
+        for (let i = 0; i < length; i++) {
+            const name = guardedRead(() => readOwnDataValue(keys, String(i)));
+            if (typeof name !== 'string' || name.length === 0 || name.length > DROPPED_KEY_NAME_MAX)
+                return undefined;
+            appendOwnElement(names, name);
+        }
+        return Object.freeze({ bytes, droppedKeys: Object.freeze(names) });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resupplyTruncatedOf(carrier) {
+    return resupplyTruncatedFactsOf(guardedRead(() => readOwnDataValue(carrier, 'payloadTruncated')));
+}

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;

package/dist/peerFrames.js

@@ -1,4 +1,5 @@
-import { applyDisplayFace, PEER_NAME_FACE } from './displayUntrusted.js';
+import { applyDisplayFace, displayUntrusted, PEER_NAME_FACE } from './displayUntrusted.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { ownSnapshotRecord } from './ownKey.js';
 import { CORE_ENGINE_AUTHORITY_ENVELOPE_TAGS, CORE_PERMISSION_MODE_CLASSES } from './generated/engineFactTables.js';
 const WIRE_KEY_FROM = 'from';
@@ -12,6 +13,20 @@ const WIRE_KEY_AGENT_TYPE = 'agentType';
 const WIRE_KEY_AGENT_MESSAGE = 'agentMessage';
 const WIRE_KEY_CROSS_SESSION_MESSAGE = 'crossSessionMessage';
 const WIRE_KEY_CROSS_SESSION_NOTICE = 'crossSessionNotice';
+const WIRE_KEY_INBOX_NOTICE = 'inboxNotice';
+const WIRE_KEY_PENDING = 'pending';
+const WIRE_KEY_DELIVERED = 'delivered';
+const WIRE_KEY_URGENT = 'urgent';
+const WIRE_KEY_RESUPPLIED = 'resupplied';
+const WIRE_KEY_PEER_META = 'peerMeta';
+const WIRE_KEY_NOTICE = 'notice';
+const WIRE_KEY_STATE = 'state';
+const WIRE_KEY_REF_SEQ = 'refSeq';
+const WIRE_KEY_RECIPIENT = 'recipient';
+const WIRE_KEY_TARGET = 'target';
+const WIRE_KEY_DETAIL = 'detail';
+const WIRE_KEY_DROP_REASON = 'dropReason';
+const WIRE_KEY_FINISHED_AT = 'finishedAt';
 const WIRE_KEY_PROVENANCE = '_sema_provenance';
 const WIRE_KEY_FROM_SESSION = 'fromSession';
 const WIRE_KEY_FROM_NAME = 'fromName';
@@ -20,7 +35,7 @@ const WIRE_KEY_FROM_SCOPE = 'fromScope';
 const FROM_ATTR = WIRE_KEY_FROM;
 export const AGENT_MESSAGE_TAG = 'agent-message';
 export const CROSS_SESSION_MESSAGE_TAG = 'cross-session-message';
-export const PEER_FRAME_LANES = Object.freeze(['agent_message', 'cross_session_message', 'cross_session_notice']);
+export const PEER_FRAME_LANES = Object.freeze(['agent_message', 'cross_session_message', 'cross_session_notice', 'inbox_notice']);
 export const CROSS_SESSION_NOTICE_KINDS = Object.freeze(['delivery_notice', 'idle_notice']);
 export const PEER_MODE_CLASSES = CORE_PERMISSION_MODE_CLASSES;
 function dataProp(o, key) {
@@ -43,6 +58,40 @@ function nonEmptyString(v) {
 function finiteNumber(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
 }
+function countOf(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0 ? v : undefined;
+}
+function shownLabel(v, max) {
+    if (typeof v !== 'string')
+        return undefined;
+    const s = displayUntrusted(v, { blanks: true, max });
+    return s.length > 0 ? s : undefined;
+}
+const NOTICE_LABEL_MAX = 64;
+const NOTICE_TEXT_MAX = 200;
+function peerNoticeOf(n) {
+    const notice = dataProp(dataProp(dataProp(n, WIRE_KEY_PROVENANCE), WIRE_KEY_PEER_META), WIRE_KEY_NOTICE);
+    if (notice === null || typeof notice !== 'object')
+        return undefined;
+    const state = nonEmptyString(dataProp(notice, WIRE_KEY_STATE));
+    if (state === undefined)
+        return undefined;
+    const recipient = shownLabel(dataProp(notice, WIRE_KEY_RECIPIENT), NOTICE_LABEL_MAX);
+    const target = shownLabel(dataProp(notice, WIRE_KEY_TARGET), NOTICE_LABEL_MAX);
+    const detail = shownLabel(dataProp(notice, WIRE_KEY_DETAIL), NOTICE_TEXT_MAX);
+    const dropReason = shownLabel(dataProp(notice, WIRE_KEY_DROP_REASON), NOTICE_TEXT_MAX);
+    const refSeq = countOf(dataProp(notice, WIRE_KEY_REF_SEQ));
+    const finishedAt = countOf(dataProp(notice, WIRE_KEY_FINISHED_AT));
+    return {
+        state,
+        ...(recipient !== undefined ? { recipient } : {}),
+        ...(target !== undefined ? { target } : {}),
+        ...(detail !== undefined ? { detail } : {}),
+        ...(dropReason !== undefined ? { dropReason } : {}),
+        ...(refSeq !== undefined ? { refSeq } : {}),
+        ...(finishedAt !== undefined ? { finishedAt } : {}),
+    };
+}
 function provenanceAgrees(n, lane, carrierFromRaw) {
     const prov = dataProp(n, WIRE_KEY_PROVENANCE);
     if (prov === null || typeof prov !== 'object')
@@ -112,7 +161,24 @@ export function classifyPeerNotification(raw) {
         const text = nonEmptyString(dataProp(crossSessionNotice, WIRE_KEY_TEXT));
         if (kind === undefined || text === undefined || !provenanceAgrees(n, 'cross_session_notice'))
             return null;
-        return { lane: 'cross_session_notice', kind, text };
+        const notice = peerNoticeOf(n);
+        return { lane: 'cross_session_notice', kind, text, ...(notice !== undefined ? { notice } : {}) };
+    }
+    const inboxNotice = dataProp(n, WIRE_KEY_INBOX_NOTICE);
+    if (inboxNotice !== undefined) {
+        const pending = countOf(dataProp(inboxNotice, WIRE_KEY_PENDING));
+        const delivered = countOf(dataProp(inboxNotice, WIRE_KEY_DELIVERED));
+        if (pending === undefined || delivered === undefined || !provenanceAgrees(n, 'inbox_notice'))
+            return null;
+        const urgent = countOf(dataProp(inboxNotice, WIRE_KEY_URGENT));
+        const resupplied = countOf(dataProp(inboxNotice, WIRE_KEY_RESUPPLIED));
+        return {
+            lane: 'inbox_notice',
+            pending,
+            delivered,
+            ...(urgent !== undefined ? { urgent } : {}),
+            ...(resupplied !== undefined ? { resupplied } : {}),
+        };
     }
     return null;
 }
@@ -140,9 +206,98 @@ function attr(v) {
 function unattr(v) {
     return v.replace(/&quot;/g, '"').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
 }
+const DELIVERY_SENTENCE_KEYS = Object.freeze({
+    delivered: 'notice.sessionBox.delivery.delivered',
+    held: 'notice.sessionBox.delivery.held',
+    held_by_policy: 'notice.sessionBox.delivery.heldByPolicy',
+    denied: 'notice.sessionBox.delivery.denied',
+    refused: 'notice.sessionBox.delivery.refused',
+    expired: 'notice.sessionBox.delivery.expired',
+});
+const IDLE_SENTENCE_KEYS = Object.freeze({
+    exited: 'notice.sessionBox.idle.exited',
+    unavailable: 'notice.sessionBox.idle.unavailable',
+    expired: 'notice.sessionBox.idle.expired',
+});
+function sentenceKeyOf(table, word) {
+    return Object.hasOwn(table, word) ? table[word] : undefined;
+}
+function joinParts(parts, lang) {
+    return parts.join(lang === 'zh' ? '' : ' ');
+}
+function inboxLine(pending, urgent, resupplied, lang) {
+    const parts = [renderMessage(pending === 1 ? msg('notice.sessionBox.inbox.one') : msg('notice.sessionBox.inbox.many', { pending }), lang)];
+    if (urgent !== undefined)
+        parts.push(renderMessage(msg('notice.sessionBox.inbox.urgent', { urgent }), lang));
+    if (resupplied !== undefined)
+        parts.push(renderMessage(msg('notice.sessionBox.inbox.resupplied', { resupplied }), lang));
+    return joinParts(parts, lang);
+}
+export function sessionBoxNoticeSentence(facts, lang) {
+    try {
+        const noticeKind = dataProp(facts, 'noticeKind');
+        if (noticeKind === 'inbox') {
+            const pending = countOf(dataProp(facts, WIRE_KEY_PENDING));
+            if (pending === undefined)
+                return undefined;
+            return inboxLine(pending, countOf(dataProp(facts, WIRE_KEY_URGENT)), countOf(dataProp(facts, WIRE_KEY_RESUPPLIED)), lang);
+        }
+        if (noticeKind !== 'delivery' && noticeKind !== 'idle')
+            return undefined;
+        const state = nonEmptyString(dataProp(facts, WIRE_KEY_STATE));
+        if (state === undefined)
+            return undefined;
+        const label = shownLabel(dataProp(facts, 'peerLabel'), NOTICE_LABEL_MAX);
+        const detail = shownLabel(dataProp(facts, WIRE_KEY_DETAIL), NOTICE_TEXT_MAX);
+        const dropReason = shownLabel(dataProp(facts, WIRE_KEY_DROP_REASON), NOTICE_TEXT_MAX);
+        if (noticeKind === 'delivery') {
+            const peer = label ?? renderMessage(msg('notice.sessionBox.peer.another'), lang);
+            if (state === 'dropped')
+                return renderMessage(dropReason !== undefined ? msg('notice.sessionBox.delivery.dropped', { peer, reason: dropReason }) : msg('notice.sessionBox.delivery.droppedPlain', { peer }), lang);
+            return renderMessage(msg(sentenceKeyOf(DELIVERY_SENTENCE_KEYS, state) ?? 'notice.sessionBox.delivery.other', { peer }), lang);
+        }
+        const peer = label ?? renderMessage(msg('notice.sessionBox.peer.anotherStart'), lang);
+        if (state === 'idle')
+            return renderMessage(detail !== undefined ? msg('notice.sessionBox.idle.finishedDetail', { peer, detail }) : msg('notice.sessionBox.idle.finished', { peer }), lang);
+        return renderMessage(msg(sentenceKeyOf(IDLE_SENTENCE_KEYS, state) ?? 'notice.sessionBox.idle.other', { peer }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function sessionBoxNoticeOf(p) {
+    if (p.lane === 'inbox_notice') {
+        const facts = {
+            noticeKind: 'inbox',
+            pending: p.pending,
+            delivered: p.delivered,
+            ...(p.urgent !== undefined ? { urgent: p.urgent } : {}),
+            ...(p.resupplied !== undefined ? { resupplied: p.resupplied } : {}),
+        };
+        const text = sessionBoxNoticeSentence(facts);
+        return text === undefined ? undefined : { ...facts, text };
+    }
+    if (p.lane !== 'cross_session_notice' || p.notice === undefined)
+        return undefined;
+    const delivery = p.kind === 'delivery_notice';
+    const peerLabel = delivery ? (p.notice.recipient ?? p.notice.target) : (p.notice.target ?? p.notice.recipient);
+    const facts = {
+        noticeKind: delivery ? 'delivery' : 'idle',
+        state: p.notice.state,
+        ...(peerLabel !== undefined ? { peerLabel } : {}),
+        ...(p.notice.detail !== undefined ? { detail: p.notice.detail } : {}),
+        ...(p.notice.dropReason !== undefined ? { dropReason: p.notice.dropReason } : {}),
+        ...(p.notice.refSeq !== undefined ? { refSeq: p.notice.refSeq } : {}),
+        ...(p.notice.finishedAt !== undefined ? { finishedAt: p.notice.finishedAt } : {}),
+    };
+    const text = sessionBoxNoticeSentence(facts);
+    return text === undefined ? undefined : { ...facts, text };
+}
 export function renderPeerFrameTranscriptText(p) {
     if (p.lane === 'cross_session_notice')
         return escapeEnvelopeTag(CROSS_SESSION_MESSAGE_TAG, escapeEnvelopeTag(AGENT_MESSAGE_TAG, neutralizeAuthorityTags(p.text)));
+    if (p.lane === 'inbox_notice')
+        return inboxLine(p.pending, p.urgent, p.resupplied, undefined);
     if (p.lane === 'agent_message') {
         const body = escapeEnvelopeTag(AGENT_MESSAGE_TAG, neutralizeAuthorityTags(p.body));
         return `<${AGENT_MESSAGE_TAG} ${FROM_ATTR}="${attr(p.from)}">\n${body}\n</${AGENT_MESSAGE_TAG}>`;

package/dist/pendingUserRow.d.ts

@@ -0,0 +1,4 @@
+export declare const PENDING_USER_ROW_ID_PREFIX = "pending-";
+export declare function pendingUserRowIdOf(uuid: string): string | undefined;
+export declare function pendingUserRowUuidOf(id: string | null | undefined): string | undefined;
+export declare function isPendingUserRowId(id: string | null | undefined): boolean;

package/dist/pendingUserRow.js

@@ -0,0 +1,16 @@
+export const PENDING_USER_ROW_ID_PREFIX = 'pending-';
+const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export function pendingUserRowIdOf(uuid) {
+    if (typeof uuid !== 'string' || !UUID_V4.test(uuid))
+        return undefined;
+    return PENDING_USER_ROW_ID_PREFIX + uuid;
+}
+export function pendingUserRowUuidOf(id) {
+    if (typeof id !== 'string' || !id.startsWith(PENDING_USER_ROW_ID_PREFIX))
+        return undefined;
+    const uuid = id.slice(PENDING_USER_ROW_ID_PREFIX.length);
+    return pendingUserRowIdOf(uuid) === id ? uuid : undefined;
+}
+export function isPendingUserRowId(id) {
+    return pendingUserRowUuidOf(id) !== undefined;
+}