@belonguniverseai/react-sdk 0.5.0 → 0.6.1

package/dist/embed/voice-call-lines.d.ts

@@ -4,9 +4,9 @@ export declare const MAX_AGENT_LINES = 3;
  * "idle" is the not-busy resting state — no work in flight, and nothing
  * completed/failed yet worth reporting (a fresh call, or a line rebound onto
  * a persisted session with no activity this call). "ready" is the DISTINCT
- * terminal state after a run actually finished successfully — it carries a
- * result (`lastText`) worth showing, unlike "idle" which never conflates the
- * two anymore (pre-CallScreen-board, both were folded into "ready").
+ * terminal state after a run actually finished successfully, unlike "idle"
+ * which never conflates the two anymore (pre-CallScreen-board, both were
+ * folded into "ready").
  */
 export type AgentLineStatus = "idle" | "working" | "ready" | "failed" | "needs_approval";
 export type AgentLine = {
@@ -28,7 +28,6 @@ export type AgentLine = {
     readonly sessionId: string | null;
     readonly label: string;
     readonly status: AgentLineStatus;
-    readonly lastText: string;
     /** The line's current run, for `stop_agent` to target — bound by the
      * line-run reader once a background dispatch's POST returns a runId, and
      * cleared back to `null` when that run reaches a terminal state.
@@ -158,26 +157,6 @@ export declare const isBoundToAnotherLine: (sessionId: string) => boolean;
  */
 export declare const foregroundLineNumber: (sessionId: string | null) => number;
 export declare const openAgentLine: (label: string) => AgentLine | null;
-/**
- * Materialize a line AT A GIVEN NUMBER, unlike `openAgentLine`'s lowest-FREE
- * allocation. F1: role→line is fixed and positional (main=1, cli=2,
- * consulting=3 — `call-roster-store.ts`), so a background dispatch to a role
- * whose line has never been touched must land EXACTLY on that role's number,
- * never wherever happens to be free. `dispatchToBackgroundLine`
- * (voice-call.ts) is the one production caller: "asking the CLI agent for
- * something IS bringing it on" (design doc) means the line materializes on
- * first use instead of reporting `unknown_line` for a line that simply
- * hasn't been dispatched to yet.
- *
- * Returns `null` when `line` is outside the switchboard's
- * 1..MAX_AGENT_LINES range, or when it is already occupied — the caller's
- * own `getLine(line) === undefined` check is expected to make the second
- * case unreachable in practice (this function is only ever called after
- * that check fails), but the guard keeps the contract sound on its own
- * terms rather than trusting every future caller to get the check right
- * (§28).
- */
-export declare const openAgentLineAt: (line: number, label: string) => AgentLine | null;
 /**
  * RELEASE a line — the mirror of `persistSlotBinding`'s adoption: clears the
  * in-memory entry AND its durable slot together, so the freed number is
@@ -266,7 +245,7 @@ export declare const bindLineRun: (line: number, runId: string | null) => void;
  * is a harmless no-op, which is what keeps the terminal path above uniform.
  */
 export declare const persistSlotRun: (line: number, runId: string | null) => void;
-export declare const setLineStatus: (line: number, status: AgentLineStatus, lastText?: string) => void;
+export declare const setLineStatus: (line: number, status: AgentLineStatus) => void;
 /** CallScreen's agent board reads this as the live "what is it doing right
  * now" line under a working line's status dot — written on every phase
  * notification (`notifyLinePhase`) and cleared (`null`) once the line's run

package/dist/embed/voice-call.d.ts

@@ -1,5 +1,6 @@
 import { AgentLineStatus } from './voice-call-lines.ts';
 import { WorkPhase } from './voice-narration.ts';
+import { CallDialOrigin } from './voice/call-active-marker.ts';
 export type CallStatus = "idle" | "connecting" | "in_call" | "error";
 /**
  * One row of the call's execution timeline (the CallScreen activity card):
@@ -11,12 +12,15 @@ export type CallTimelineEntry = {
     readonly id: number;
     readonly atMs: number;
     readonly kind: "user" | "agent" | "step" | "success" | "error" | "skill" | "schedule";
+    /** What the row SAYS. Empty for the two terminal kinds (`success`/`error`),
+     * whose whole meaning is the kind itself — CallScreen renders their own
+     * label and ignores this. See {@link TEXTLESS_KINDS}. */
     readonly text: string;
     /** The switchboard line this row concerns; `null` for a foreground (line 1)
-     * row. CallScreen's `labelFor` resolves `line ?? 1` to look up the agent's
-     * short board label for `step`/`success`/`error` rows (X2b) — the label
-     * column names the agent, so `text` itself never repeats a title prefix or
-     * an "A2"-style tag. */
+     * row. Bookkeeping only — no surface labels a row with an agent name any
+     * more (there is one agent, and it is the chat on screen), so this exists
+     * so a marker written for a background line can be told apart from one
+     * written for the foreground. */
     readonly line: number | null;
 };
 export type CallState = {
@@ -39,20 +43,63 @@ export type CallState = {
     /** True between the user finishing an utterance and the model responding —
      * the "Thinking…" window on the call screen. */
     readonly thinking: boolean;
+    /**
+     * Why the dial currently in flight (or the call it produced) happened —
+     * `"user"` for one the user asked for, `"redial"` for a reconnect. Set on
+     * the `connecting` transition and read back by two very different consumers:
+     * the marker write below (a reconnect CONTINUES the interrupted call's
+     * redial streak) and CallScreen, which says "Reconnecting…" rather than
+     * "Connecting…" so a microphone that reopened on its own explains itself.
+     */
+    readonly dialOrigin: CallDialOrigin;
     /** Wall-clock start of the current call; 0 while idle. */
     readonly callStartedAtMs: number;
     /** Rolling execution timeline, oldest first (capped). */
     readonly timeline: readonly CallTimelineEntry[];
+    /** The browser REFUSED to play the agent's audio (autoplay is a request,
+     * not a guarantee — an automatically redialed call after a page reload has
+     * no fresh user gesture behind it). Drives CallScreen's one-tap "Tap to
+     * hear" control; {@link resumeCallAudio} clears it. */
+    readonly audioBlocked: boolean;
     readonly errorMessage?: string;
 };
 /**
- * ChatRoute pushes Belong-agent progress into the call timeline (tool-phase
- * steps while a delegated run streams). No-op when no call is active.
+ * ChatRoute pushes a call-relevant NOTICE onto the timeline — the sentences
+ * that explain why nothing ran (a skill lookup miss, a catalog that hasn't
+ * loaded), an artifact that opened on screen, a voice-resolved approval.
+ * No-op when no call is active.
+ *
+ * `step` is the only kind ChatRoute writes: it is the one kind whose TEXT is
+ * rendered (a `success`/`error` row is its kind label and nothing else — see
+ * {@link TEXTLESS_KINDS}), so a notice pushed as anything else would have its
+ * sentence silently dropped.
+ *
+ * Keeps the consecutive-identical-row window: these are free-form sentences
+ * written from event handlers that can fire twice on one underlying fact (the
+ * voice re-asking for the same missing skill, say), and a verbatim repeat
+ * seconds apart says nothing new. The agent's own ACTION rows are the
+ * opposite case and have their own entry point — {@link pushCallAction}.
  */
 export declare const pushCallStep: (text: string) => void;
-/** ChatRoute surfaces call-relevant notices (skill lookup misses, catalog
- * failures) on the timeline so the user can SEE why nothing ran. */
-export declare const pushCallNotice: (kind: "step" | "error", text: string) => void;
+/**
+ * ChatRoute pushes one ACTION onto the call timeline — one line per thing the
+ * agent did ("Read a file", "Ran a command"). No-op when no call is active.
+ *
+ * Deliberately NOT {@link pushCallStep}: the action vocabulary
+ * (`tool-action-label.ts`) is a fixed ~15-string set of parameterless
+ * constants, so "read three files" is three BYTE-IDENTICAL rows and the
+ * dedupe window folded them into one — an agent that read three files logged
+ * one, and five unrecognized tools (all "Worked on it") logged one. On a
+ * surface whose whole job is "let me follow along while I listen", that is
+ * the difference between working and not.
+ *
+ * Safe to opt out because this call site is already idempotent at source:
+ * chat.tsx's `loggedActionPartIdsRef` keys on the tool-call PART id, so the
+ * same call re-arriving as started → completed writes exactly one row. Same
+ * reasoning, same opt-out, as the terminal markers in `deliverAgentReply` /
+ * `deliverAgentFailure`.
+ */
+export declare const pushCallAction: (text: string) => void;
 /** Hard ceiling on the rendered digest — a compact recap, not a transcript. */
 export declare const CONTEXT_DIGEST_MAX_CHARS = 1000;
 /**
@@ -116,44 +163,6 @@ declare let lineDispatcher: ((req: {
     readonly isNewLine: boolean;
 }) => void) | null;
 export declare const registerCallLineDispatcher: (dispatcher: NonNullable<typeof lineDispatcher>) => (() => void);
-/**
- * Last-resort delivery for `flushLineQueuesOnCallEnd` when no `lineDispatcher`
- * is wired (the M7 gap — ChatRoute unmounted). Self-registered by
- * line-dispatch.ts (see the bottom of that file) with the real
- * `dispatchToLine` — deliberately NOT imported here directly. `line-dispatch.ts`
- * already imports six functions FROM this module (buildCallContextDigest,
- * the deliver/notify callbacks, peekCallState, subscribeCallState), so a
- * static import the other way would close a two-way cycle between
- * voice-call.ts and line-dispatch.ts — forbidden outright by
- * `.dependency-cruiser.cjs`'s `no-circular` rule (severity: error, applies
- * everywhere, not just the hexagonal backend layers). Registering FROM
- * line-dispatch.ts, in the SAME direction its existing dependency already
- * runs, avoids the cycle entirely; that file's own `subscribeCallState`
- * self-subscribe (its module doc, right above `abortAllLineReaders`) is the
- * identical idiom already established there.
- *
- * Investigated and confirmed SOUND as a fallback: chat.tsx's own
- * `registerCallLineDispatcher` wrapper does nothing beyond routing line 1 to
- * `sendCallText` and calling this exact function, unmodified, for any other
- * line — see that effect in chat.tsx. Held/queued items only ever exist for
- * background lines (line 1 never enqueues — see the busy-line branch above),
- * so every item this fallback ever sees is exactly the shape ChatRoute's
- * wrapper would have passed through unchanged. No ChatRoute-specific
- * behavior is lost by calling it directly.
- *
- * Deliberately SEPARATE from `lineDispatcher` — not folded into
- * `releaseHeldRequest` itself — so `pumpLineQueue`'s live-queue draining is
- * UNAFFECTED: it must keep checking `lineDispatcher` and leaving an item
- * queued (not popped) when nothing is wired, per its own doc. Only the
- * end-of-call flush, which has nothing left to leave a drained item queued
- * IN, reaches for this.
- */
-declare let lineDispatchFallback: ((req: {
-    readonly line: number;
-    readonly request: string;
-    readonly isNewLine: boolean;
-}) => Promise<void>) | null;
-export declare const registerLineDispatchFallback: (dispatcher: NonNullable<typeof lineDispatchFallback>) => (() => void);
 export declare const registerCallLineViewSwitcher: (switcher: (sessionId: string) => void) => (() => void);
 export declare const registerCallClearNotifier: (notifier: (sessionId: string) => void) => (() => void);
 /**
@@ -174,10 +183,11 @@ export declare const notifyCallProgress: (hint: string) => void;
  * small work badge while the agent is busy. */
 export declare const setCallWorkPhase: (phase: CallState["workPhase"]) => void;
 /**
- * Click-path twin of `show_agent`: the lines strip chip on CallScreen
- * calls this directly (no tool-call round trip, no ack). No-op when the line
- * is unknown, never bound to a session, or no view switcher is registered
- * (e.g. ChatRoute hasn't mounted).
+ * The lines strip chip on CallScreen calls this directly (no tool-call round
+ * trip, no ack — there is no voice tool for it any more, which is why nothing
+ * here reports an outcome): switch the chat panel to the line's session and
+ * minimize the call screen. No-op when the line is unknown, never bound to a
+ * session, or no view switcher is registered (e.g. ChatRoute hasn't mounted).
  */
 export declare const showLineOnScreen: (line: number) => void;
 /**
@@ -198,7 +208,41 @@ export declare const showLineOnScreen: (line: number) => void;
 export declare const startCall: (options?: {
     readonly isReconnect?: boolean;
 }) => Promise<void>;
+/**
+ * The error panel's "Call again". Dials as a RECONNECT whenever an interrupted
+ * call's marker is still there — which, by `keepsCallActiveMarker`, is exactly
+ * the case worth reconnecting to: a redial that never became a call. Its
+ * `contextDigest` is the only surviving record of what the user was doing, so
+ * a bare `startCall()` here opened a COLD call the user had to re-explain,
+ * while the recap the failure path deliberately preserved went unread.
+ *
+ * Deliberately does NOT dismiss the error first: `dismissCallError`'s idle
+ * transition is one of the two moments allowed to keep the marker, but only
+ * because ✕ means "put the panel away" — routing a RETRY through it would
+ * still hand `startCall` a marker whose digest it had to re-read after a
+ * needless round trip. `startCall`'s own `connecting` patch replaces the error
+ * state (and its panel) synchronously, so there is nothing left to dismiss.
+ */
+export declare const retryCall: () => Promise<void>;
+/**
+ * Hang up. The one ending that is an explicit GIVE-UP, so it always takes the
+ * interrupted call's marker and any standing reconnect offer with it — stated
+ * here rather than left to `keepsCallActiveMarker`, whose `error → idle`
+ * branch exists for the ✕ that merely puts the error panel away. Both clears
+ * run BEFORE the transition, so that branch sees no marker and agrees.
+ */
 export declare const endCall: () => void;
+/**
+ * The user tapped "Tap to hear" — ask the browser to play the agent's audio
+ * again, now that a real gesture is on the stack, and take the control down
+ * only once playback has ACTUALLY started. Clearing it optimistically would
+ * leave a silent call with nothing left to tap.
+ *
+ * Deliberately not `async`: CallScreen calls this straight from the click
+ * handler, and the transport's `play()` runs before the first await, so the
+ * gesture the browser is holding out for is still on the stack.
+ */
+export declare const resumeCallAudio: () => void;
 export declare const toggleCallMuted: () => void;
 /** Dismiss a sticky error state (the overlay's ✕). */
 export declare const dismissCallError: () => void;
@@ -218,9 +262,9 @@ export declare const deliverAgentReply: (text: string) => void;
  * must tell the user something went wrong and offer to retry.
  */
 export declare const deliverAgentFailure: (message: string) => void;
-/** A background line finished: relay its final text, naming the agent by
- * role. */
-export declare const deliverLineReply: (line: number, text: string) => void;
+/** A background line finished: converge its chip. Nothing is spoken — see
+ * this section's header. */
+export declare const deliverLineReply: (line: number) => void;
 /**
  * A background line published an artifact: OPEN it on screen, mirroring
  * chat.tsx's foreground auto-open effect exactly — ALWAYS docked (a persisted
@@ -234,26 +278,21 @@ export declare const deliverLineArtifact: (line: number, artifact: {
     readonly title: string;
     readonly mimeType: string;
 }) => void;
-/** A background line failed: tell the user, naming the agent by role. */
-export declare const deliverLineFailure: (line: number, message: string) => void;
-/** A background line is blocked on a tool approval — steer the user to it,
- * by role, and tell the model WHAT it wants to do. W3: the old text asked
- * the user to say a magic phrase ("show <title>") and never said what was
- * being approved — unanswerable on a phone call, where there is no screen to
- * "go look at". `reason` is the approval part's own `reason` field, threaded
- * from the run stream via `onApprovalNeeded` (line-run-reader.ts). */
-export declare const notifyLineApprovalNeeded: (line: number, timelineText: string, reason: string) => void;
+/** A background line failed: converge its chip. Nothing is spoken — see this
+ * section's header. */
+export declare const deliverLineFailure: (line: number) => void;
+/** A background line is blocked on a tool approval — paint its chip. The
+ * approval itself is resolved from the rail's typed chat, on screen, where
+ * the user can read what is being approved; the call is not told, and takes
+ * no `reason`, because it has no way to name whose approval it is. */
+export declare const notifyLineApprovalNeeded: (line: number) => void;
 /** A background line advanced a phase — record it as the line's live step
- * (CallScreen's agent board reads `currentStepLabel`/`currentPhase` off the
- * registry) and nudge a spoken update. X2a: deliberately NO timeline row per
- * phase change any more — the board's own card already shows the identical
- * string live, and a 12-step run used to write 12 near-identical Activity
- * rows that buried the actual results; the durable Activity-log row for a
- * background line's work is the ONE `dispatchToBackgroundLine` appends up
- * front. The registry write is unconditional (line-dispatch's own `isStale`
- * guard already keeps a stale-call phase from ever reaching here); the
- * spoken nudge stays guarded like its delivery siblings so a phase that DOES
- * arrive with no live call just updates the board silently. */
+ * (CallScreen's agent board and the rail read `currentStepLabel`/
+ * `currentPhase` off the registry). X2a: deliberately NO timeline row per
+ * phase change — the board's own card already shows the identical string
+ * live, and a 12-step run used to write 12 near-identical Activity rows that
+ * buried the actual results. The write is unconditional: line-dispatch's own
+ * `isStale` guard already keeps a stale-call phase from ever reaching here. */
 export declare const notifyLinePhase: (line: number, phaseLabel: string, phase?: WorkPhase | null) => void;
 /** True while a call holds the audio path — ChatRoute gates TTS autoplay on it. */
 export declare const isCallActive: () => boolean;

package/dist/i18n/messages/en.d.ts

@@ -44,6 +44,14 @@ export declare const en: {
         readonly toolGenericDone: "Finished {{tool}}";
         readonly toolGenericFailed: "{{tool}} didn't complete";
         readonly toolGenericDetail: "Used the {{tool}} capability.";
+        readonly toolRememberRunning: "Saving a note";
+        readonly toolRememberDone: "Saved a note";
+        readonly toolRememberFailed: "Couldn't save the note";
+        readonly toolRememberDetail: "Saved a note about you for future conversations.";
+        readonly toolForgetRunning: "Forgetting a note";
+        readonly toolForgetDone: "Forgot a note";
+        readonly toolForgetFailed: "Couldn't forget the note";
+        readonly toolForgetDetail: "Deleted a saved note about you.";
         readonly browserSnapshot: "Took a snapshot";
         readonly browserRead: "Read the page";
         readonly browserClick: "Clicked an element";
@@ -55,9 +63,25 @@ export declare const en: {
         readonly browserAssertCreated: "Checked for an existing resource";
         readonly browserRefreshView: "Refreshed the page";
         readonly failedBadge: "failed";
+        readonly actionReadFile: "Read a file";
+        readonly actionWroteFile: "Updated a file";
+        readonly actionPublishedArtifact: "Put a report on screen";
+        readonly actionLookedUpSkill: "Looked up a skill";
+        readonly actionSubTask: "Worked through a sub-task";
+        readonly actionMadePlan: "Put a plan together";
+        readonly actionCheckedRules: "Checked the rules";
+        readonly actionScheduledTask: "Set up a scheduled task";
+        readonly actionGeneric: "Worked on it";
         readonly executingTasks: "Working on it…";
         readonly workedSteps_one: "Worked · {{count}} step";
         readonly workedSteps_other: "Worked · {{count}} steps";
+        readonly subagentRunning: "Subagent · {{description}}…";
+        readonly subagentDone: "Subagent · {{description}}";
+        readonly subagentDoneSteps_one: "Subagent · {{description}} · {{count}} step";
+        readonly subagentDoneSteps_other: "Subagent · {{description}} · {{count}} steps";
+        readonly subagentFailed: "Subagent · {{description}} · didn't finish";
+        readonly subagentTimedOut: "Subagent · {{description}} · ran out of time";
+        readonly subagentVia: "via {{name}}";
         readonly cliAuthStop: {
             readonly noGrant: "Connect to Simetrik to continue";
             readonly reconnectFailed: "Couldn't connect to Simetrik";
@@ -317,7 +341,6 @@ export declare const en: {
         readonly thisFile: "this file";
         readonly download: "Download";
         readonly loadingPreview: "Loading preview…";
-        readonly poweredByBelong: "Powered by Belong";
         readonly devDefault: "default";
         readonly devModelIdPlaceholder: "model id (blank = env default)";
         readonly devModelIdTitle: "Exact model id for the selected provider — overrides the env pin";
@@ -474,6 +497,7 @@ export declare const en: {
     readonly callScreen: {
         readonly title: "Voice call";
         readonly connecting: "Connecting the call…";
+        readonly reconnecting: "Reconnecting the call…";
         readonly listening: "Listening";
         readonly speaking: "Speaking";
         readonly working: "Working on it…";
@@ -481,6 +505,7 @@ export declare const en: {
         readonly youSaid: "You said";
         readonly agentSaid: "Agent";
         readonly speakHint: "Speak to the agent…";
+        readonly tapToHear: "Tap to hear the call";
         readonly readyHint: "I'm listening — speak when you're ready.";
         readonly thinkingHint: "Thinking…";
         readonly speakingHint: "Speaking…";
@@ -501,13 +526,9 @@ export declare const en: {
         readonly phaseCoding: "Putting the steps together";
         readonly phaseFiles: "Going through your data";
         readonly phaseActions: "Running the steps";
-        readonly lines: "Agents";
+        readonly agentStatus: "Agent status";
         readonly lineLabel: "Agent {{line}}";
         readonly mainAgentLabel: "Main agent";
-        readonly roleLabelMain: "Main agent";
-        readonly roleLabelData: "{{product}} data agent";
-        readonly roleLabelDataGeneric: "Data agent";
-        readonly roleLabelAnalyst: "Analyst";
         readonly lineNeedsApproval: "Needs your OK";
         readonly lineWorking: "Working…";
         readonly lineReady: "Done";

package/dist/i18n/messages/surfaces/embedMisc.d.ts

@@ -31,7 +31,6 @@ export declare const embedMiscEn: {
         readonly thisFile: "this file";
         readonly download: "Download";
         readonly loadingPreview: "Loading preview…";
-        readonly poweredByBelong: "Powered by Belong";
         readonly devDefault: "default";
         readonly devModelIdPlaceholder: "model id (blank = env default)";
         readonly devModelIdTitle: "Exact model id for the selected provider — overrides the env pin";
@@ -77,7 +76,6 @@ export declare const embedMiscEs: {
         thisFile: string;
         download: string;
         loadingPreview: string;
-        poweredByBelong: string;
         devDefault: string;
         devModelIdPlaceholder: string;
         devModelIdTitle: string;
@@ -123,7 +121,6 @@ export declare const embedMiscPt: {
         thisFile: string;
         download: string;
         loadingPreview: string;
-        poweredByBelong: string;
         devDefault: string;
         devModelIdPlaceholder: string;
         devModelIdTitle: string;

package/dist/i18n/messages/surfaces/stream.d.ts

@@ -44,6 +44,14 @@ export declare const streamEn: {
         readonly toolGenericDone: "Finished {{tool}}";
         readonly toolGenericFailed: "{{tool}} didn't complete";
         readonly toolGenericDetail: "Used the {{tool}} capability.";
+        readonly toolRememberRunning: "Saving a note";
+        readonly toolRememberDone: "Saved a note";
+        readonly toolRememberFailed: "Couldn't save the note";
+        readonly toolRememberDetail: "Saved a note about you for future conversations.";
+        readonly toolForgetRunning: "Forgetting a note";
+        readonly toolForgetDone: "Forgot a note";
+        readonly toolForgetFailed: "Couldn't forget the note";
+        readonly toolForgetDetail: "Deleted a saved note about you.";
         readonly browserSnapshot: "Took a snapshot";
         readonly browserRead: "Read the page";
         readonly browserClick: "Clicked an element";
@@ -55,9 +63,27 @@ export declare const streamEn: {
         readonly browserAssertCreated: "Checked for an existing resource";
         readonly browserRefreshView: "Refreshed the page";
         readonly failedBadge: "failed";
+        readonly actionReadFile: "Read a file";
+        readonly actionWroteFile: "Updated a file";
+        readonly actionPublishedArtifact: "Put a report on screen";
+        readonly actionLookedUpSkill: "Looked up a skill";
+        readonly actionSubTask: "Worked through a sub-task";
+        readonly actionMadePlan: "Put a plan together";
+        readonly actionCheckedRules: "Checked the rules";
+        readonly actionScheduledTask: "Set up a scheduled task";
+        /** A tool this build has no copy for — a neutral line, never its name. */
+        readonly actionGeneric: "Worked on it";
         readonly executingTasks: "Working on it…";
         readonly workedSteps_one: "Worked · {{count}} step";
         readonly workedSteps_other: "Worked · {{count}} steps";
+        readonly subagentRunning: "Subagent · {{description}}…";
+        readonly subagentDone: "Subagent · {{description}}";
+        readonly subagentDoneSteps_one: "Subagent · {{description}} · {{count}} step";
+        readonly subagentDoneSteps_other: "Subagent · {{description}} · {{count}} steps";
+        readonly subagentFailed: "Subagent · {{description}} · didn't finish";
+        readonly subagentTimedOut: "Subagent · {{description}} · ran out of time";
+        /** Attribution chip on an inner tool card. Attribution, not nesting. */
+        readonly subagentVia: "via {{name}}";
         readonly cliAuthStop: {
             readonly noGrant: "Connect to Simetrik to continue";
             readonly reconnectFailed: "Couldn't connect to Simetrik";
@@ -109,6 +135,14 @@ export declare const streamEs: {
         toolGenericDone: string;
         toolGenericFailed: string;
         toolGenericDetail: string;
+        toolRememberRunning: string;
+        toolRememberDone: string;
+        toolRememberFailed: string;
+        toolRememberDetail: string;
+        toolForgetRunning: string;
+        toolForgetDone: string;
+        toolForgetFailed: string;
+        toolForgetDetail: string;
         browserSnapshot: string;
         browserRead: string;
         browserClick: string;
@@ -120,9 +154,25 @@ export declare const streamEs: {
         browserAssertCreated: string;
         browserRefreshView: string;
         failedBadge: string;
+        actionReadFile: string;
+        actionWroteFile: string;
+        actionPublishedArtifact: string;
+        actionLookedUpSkill: string;
+        actionSubTask: string;
+        actionMadePlan: string;
+        actionCheckedRules: string;
+        actionScheduledTask: string;
+        actionGeneric: string;
         executingTasks: string;
         workedSteps_one: string;
         workedSteps_other: string;
+        subagentRunning: string;
+        subagentDone: string;
+        subagentDoneSteps_one: string;
+        subagentDoneSteps_other: string;
+        subagentFailed: string;
+        subagentTimedOut: string;
+        subagentVia: string;
         cliAuthStop: {
             noGrant: string;
             reconnectFailed: string;
@@ -174,6 +224,14 @@ export declare const streamPt: {
         toolGenericDone: string;
         toolGenericFailed: string;
         toolGenericDetail: string;
+        toolRememberRunning: string;
+        toolRememberDone: string;
+        toolRememberFailed: string;
+        toolRememberDetail: string;
+        toolForgetRunning: string;
+        toolForgetDone: string;
+        toolForgetFailed: string;
+        toolForgetDetail: string;
         browserSnapshot: string;
         browserRead: string;
         browserClick: string;
@@ -185,9 +243,25 @@ export declare const streamPt: {
         browserAssertCreated: string;
         browserRefreshView: string;
         failedBadge: string;
+        actionReadFile: string;
+        actionWroteFile: string;
+        actionPublishedArtifact: string;
+        actionLookedUpSkill: string;
+        actionSubTask: string;
+        actionMadePlan: string;
+        actionCheckedRules: string;
+        actionScheduledTask: string;
+        actionGeneric: string;
         executingTasks: string;
         workedSteps_one: string;
         workedSteps_other: string;
+        subagentRunning: string;
+        subagentDone: string;
+        subagentDoneSteps_one: string;
+        subagentDoneSteps_other: string;
+        subagentFailed: string;
+        subagentTimedOut: string;
+        subagentVia: string;
         cliAuthStop: {
             noGrant: string;
             reconnectFailed: string;

package/dist/stream/ai-sdk-part-renderers.d.ts

@@ -1,4 +1,26 @@
-import { BelongDataParts, BelongUIMessage, SandboxCommandData, ToolCallData } from './belong-data-parts.ts';
+import { BelongDataParts, BelongUIMessage, SandboxCommandData, SubagentData, ToolCallData } from './belong-data-parts.ts';
+/** One tool call in an activity run, paired (for shell) with its same-id output. */
+export type ToolActivityItem = {
+    readonly tool: ToolCallData;
+    readonly output: SandboxCommandData | null;
+};
+/**
+ * BEL-199 — a delegated subagent in an activity run. It sits INSIDE the one
+ * collapsed line beside the tool items, never beside the group.
+ */
+export type SubagentActivityItem = {
+    readonly kind: "subagent";
+    readonly subagentId: string;
+    readonly data: SubagentData;
+};
+/**
+ * Deliberate shape note: the TOOL variant carries no `kind` discriminant. It is
+ * the shape every existing fixture and story already builds, and a subagent item
+ * is distinguishable without one (`"kind" in item`) — so this stays a sound
+ * union while a required discriminant would have churned ~25 unrelated call
+ * sites across four story files for no safety the guard below doesn't give.
+ */
+export type ActivityItem = ToolActivityItem | SubagentActivityItem;
 export declare const ActivityGroup: ({ items, live, }: {
     readonly items: readonly ActivityItem[];
     readonly live?: boolean | undefined;
@@ -44,11 +66,6 @@ export type PartRendererProps = {
  * `reasoning` parts.
  */
 export declare const PartRenderer: ({ part, onExecutePlan, historical }: PartRendererProps) => import("react").JSX.Element | null;
-/** One tool call in an activity run, paired (for shell) with its same-id output. */
-export type ActivityItem = {
-    readonly tool: ToolCallData;
-    readonly output: SandboxCommandData | null;
-};
 export type RenderGroup = {
     readonly kind: "part";
     readonly part: BelongMessagePart;