@belonguniverseai/react-sdk 0.3.6 → 0.4.1

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

@@ -1,31 +1,258 @@
+import { WorkPhase } from './voice-narration.ts';
+export declare const MAX_AGENT_LINES = 3;
 /**
- * Agent lines registry — the Operator's switchboard. Line 1 is the
- * FOREGROUND chat (existing single-line behavior, unchanged); lines 2+ are
- * background sessions dispatched over plain HTTP and monitored by the
- * line-run reader. External-store singleton, same idiom as voice-bus.ts.
+ * "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").
  */
-export declare const MAX_AGENT_LINES = 3;
-export type AgentLineStatus = "working" | "ready" | "failed" | "needs_approval";
+export type AgentLineStatus = "idle" | "working" | "ready" | "failed" | "needs_approval";
 export type AgentLine = {
     readonly line: number;
+    /**
+     * Monotonic stamp identifying THIS occupancy of the slot — bumped every time
+     * a line entry is CREATED (`openAgentLine`, a line-1 reset, a rehydrate), and
+     * carried unchanged through every later write (they all spread `...l`).
+     *
+     * The line NUMBER is not an identity: `closeAgentLine(2)` frees it and the
+     * very next `openAgentLine` hands the same number to a different reservation.
+     * Anything holding a line across an await (`spawnAgentLine`'s session mint,
+     * line-dispatch's find-or-create) must therefore re-check the epoch, not just
+     * that "line 2 exists" — otherwise a spawn whose chip the user closed
+     * mid-mint binds its session onto the NEXT spawn's line. Compare via
+     * `isLineReservation` below.
+     */
+    readonly epoch: number;
     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. Line 1
+     * (foreground) never gets this written: its runId is resolved at stop-time
+     * from the stream-state store instead (the same source the on-screen Stop
+     * button reads), so this stays `null` for line 1 always. */
+    readonly runId: string | null;
+    /** The live "what is it doing right now" label (e.g. "writing code"),
+     * written by `setLineStep` as phase notifications arrive while `status`
+     * is `"working"`. Cleared back to `null` once the line reaches a terminal
+     * status (ready/failed) or starts a fresh dispatch — CallScreen's agent
+     * board reads this to show a step under the status dot instead of just a
+     * bare "working" chip. */
+    readonly currentStepLabel: string | null;
+    /** The step's phase classification — what KIND of work the line is doing
+     * right now (`classifyToolPhase`), so a working card wears the same phase
+     * icon the orb's work badge does (code / files / actions; spinner while
+     * unknown). Written and cleared together with `currentStepLabel` by
+     * `setLineStep`. */
+    readonly currentPhase: WorkPhase | null;
+    /** True when this line reached a terminal status (ready/failed) while its
+     * session was NOT the one on screen — a finished result the user hasn't
+     * looked at yet (product vision: the rail's green "unseen" dot). Written by
+     * `deliverLineReply`/`deliverLineFailure` (voice-call.ts) for background
+     * lines; line 1's own terminal writes never set it (the foreground chat IS
+     * what's on screen, so its own results are seen by definition). Cleared by
+     * `markLineSeen` once the user actually views that line's session. */
+    readonly unseenResult: boolean;
 };
 export declare const peekAgentLines: () => readonly AgentLine[];
 export declare const subscribeAgentLines: (listener: () => void) => (() => void);
+/** Hard reset: rebuilds every line from its persisted slot, ephemeral fields
+ * clean. Used by `initAgentLines()`, a host workspace switch, and the
+ * `__forceAgentLines` test/E2E harness —
+ * NOT on a call boundary any more (see the module doc's "CALL BOUNDARY"
+ * section); a live call uses `resetForCallStart()` below instead. */
 export declare const resetAgentLines: () => void;
+/**
+ * The registry's FIRST read of the durable slots, and the one that binds it to
+ * the host's workspace. The dock calls this once on mount — i.e. after
+ * `configureWorkspaceScope` / `setWorkspace` have run — so the boot rehydrate
+ * uses the workspace-suffixed storage key that every later write also uses
+ * (a module-eval read would have used the legacy unsuffixed one).
+ *
+ * It also subscribes to the workspace-scope store: a host workspace switch
+ * hard-resets the registry and re-reads the slots under the NEW key, so the
+ * rail can never keep offering the previous workspace's sessions. Idempotent —
+ * a second call just re-reads; only one subscription is ever held.
+ */
+export declare const initAgentLines: () => void;
+/** Test-only: drop the workspace subscription so each case starts unsubscribed. */
+export declare const __resetAgentLinesInitForTest: () => void;
+/**
+ * Call-boundary reset — narrower than `resetAgentLines()`. A call ENDING no
+ * longer touches the registry at all (a finished result and its
+ * `unseenResult` flag must survive the hang-up). By the time the NEXT call
+ * starts, the only genuinely stale ephemera left behind is a line stuck at
+ * "working": its reader was torn down mid-flight when the previous call ended
+ * (`abortAllLineReaders` in line-dispatch.ts) without the run ever reaching a
+ * terminal status. Everything else — bindings, terminal statuses,
+ * `unseenResult` — is left exactly as it is. No-op (no emit) when nothing was
+ * actually "working".
+ */
+export declare const resetForCallStart: () => void;
 export declare const getLine: (line: number) => AgentLine | undefined;
 /**
- * The "foreground-routed alias": a background line (≥ 2) bound to the SAME
- * session line 1 currently shows (the user opened it in the chat via
- * `show_agent_line`). New work for that line is routed through the foreground
- * pipeline so the visible chat renders the run — but the background line's
- * strip status must still be kept truthful, and this finds the line to update.
- * Returns `undefined` when line 1 is unbound or no background line aliases it.
+ * Is the slot `line` STILL held by the reservation stamped `epoch`? The check
+ * every holder of a line across an await owes the registry before it adopts a
+ * session into that line (see `AgentLine.epoch`). False means the reservation
+ * is gone — released outright, or already replaced by a different one that
+ * happens to wear the same number.
+ */
+export declare const isLineReservation: (line: number, epoch: number) => boolean;
+/** The line (other than 1) currently bound to `sessionId`, or `undefined` when
+ * no background line holds it — the shared scan behind `isBoundToAnotherLine`
+ * (the boolean chat.tsx's aliasing guard needs) and `markLineSeen`'s callers
+ * (which need the actual line number to mark seen). */
+export declare const lineBoundToSession: (sessionId: string) => AgentLine | undefined;
+/** The line — INCLUDING line 1 — currently bound to `sessionId`, or `undefined`
+ * when no agent holds it. Unlike `lineBoundToSession` (deliberately line-1-blind
+ * for the aliasing guard), this is the honest "which agent already owns this
+ * conversation" lookup a History reopen needs: reopening a session that Agent 1
+ * already holds must SWITCH to Agent 1, not adopt (duplicate) it onto whatever
+ * background line the user happens to be viewing. */
+export declare const lineOwningSession: (sessionId: string) => AgentLine | undefined;
+/** True when `sessionId` is already the session of some line OTHER than line
+ * 1 — chat.tsx's line-1 aliasing guard uses this to skip rebinding line 1
+ * onto a background line's session while the user is viewing it via
+ * `show_agent_line` (rebinding would overwrite line 1's own identity). */
+export declare const isBoundToAnotherLine: (sessionId: string) => boolean;
+/**
+ * The line number the FOREGROUND chat's registry writes belong to. The visible
+ * chat is NOT always line 1: the rail's spawn flow and `show_agent_line` both
+ * put a BACKGROUND line's session on screen, and work done there must light
+ * that line's badge — not line 1's, which would leave the agent the user is
+ * actually watching sitting idle. Falls back to line 1 when the on-screen
+ * session is line 1's own (or unknown), which is the common case.
+ *
+ * This SUPERSEDED the old `findAliasedLine()` helper, which served the INVERSE
+ * premise: line 1 having ADOPTED a background line's session, so a line-1 write
+ * had to be mirrored onto the aliased background line. The aliasing guards
+ * (`isBoundToAnotherLine`, in chat.tsx's line-1 bind effect and voice-call.ts's
+ * eager foreground mint) now stop line 1 from ever adopting another line's
+ * session, so that premise can no longer hold in production — the helper was
+ * permanently `undefined`, i.e. dead code that read as live, and was deleted.
+ * Every foreground write resolves its ONE target through this function instead.
  */
-export declare const findAliasedLine: () => AgentLine | undefined;
+export declare const foregroundLineNumber: (sessionId: string | null) => number;
 export declare const openAgentLine: (label: string) => AgentLine | null;
-export declare const bindLineSession: (line: number, sessionId: string) => void;
+/**
+ * RELEASE a line — the mirror of `persistSlotBinding`'s adoption: clears the
+ * in-memory entry AND its durable slot together, so the freed number is
+ * immediately re-mintable by `openAgentLine` and does not rehydrate on the next
+ * boot. Called when a spawn's session mint fails (otherwise the slot is burned
+ * until reload) and when the user deletes a session a line was bound to
+ * (otherwise the rail keeps offering a chip that opens a session that is gone).
+ *
+ * Line 1 is the foreground chat and is never REMOVED — releasing it resets it
+ * to the familiar fresh/unbound line 1 instead. No-op on an unknown line.
+ */
+export declare const closeAgentLine: (line: number) => void;
+/**
+ * TEST/HARNESS-ONLY memory-only bind — the `__` prefix is load-bearing. This
+ * writes the in-memory registry WITHOUT the durable slot, which is precisely
+ * the divergence `persistSlotBinding` exists to eliminate: a line bound only in
+ * memory looks right until the next rehydrate, then silently reverts (or, after
+ * a workspace switch, rehydrates onto the OTHER workspace's session). Production
+ * adoption has exactly one seam and it is `persistSlotBinding`.
+ *
+ * It stays exported solely so unit tests, the rail stories, and the
+ * `__forceAgentLines` E2E hook can construct a registry state without writing
+ * durable slots that would then leak across cases (and, for `__forceAgentLines`,
+ * survive an E2E reload as phantom agents). Renamed from the old public
+ * `bindLineSession` so no production writer can reach for it by accident.
+ */
+export declare const __bindLineSessionForTest: (line: number, sessionId: string) => void;
+/**
+ * The ADOPTION seam (the one rule for what "Agent N" means): call this
+ * whenever `sessionId` becomes the ACTIVE session for `line` — line 1's
+ * foreground bind effect, the eager foreground mint at call start, and a
+ * background line's find-or-create dispatch. Updates the in-memory registry
+ * and the durable slot together, so a slot's identity never drifts between
+ * the two. No-ops on an unchanged binding, so calling this on every render
+ * (chat.tsx's bind effect has no dep array) is cheap.
+ *
+ * The two halves must move TOGETHER — both of these were real divergences:
+ *
+ *  - An UNKNOWN line writes nothing. Every adoption site has an async gap
+ *    between reserving the line and minting its session (`spawnAgentLine`,
+ *    line-dispatch's find-or-create), and the line can be released inside that
+ *    gap — a failed sibling spawn, a deleted session, a workspace switch that
+ *    re-reads the slots. Writing the slot anyway left a durable binding for a
+ *    line the registry does not hold, which rehydrates on the next boot as a
+ *    phantom agent (and, after a workspace switch, one pointing at the OTHER
+ *    workspace's session).
+ *  - The `label` is written to memory too, not only to storage. Adopting under
+ *    a new label with an unchanged `sessionId` used to update the durable slot
+ *    while the in-memory line kept the old label, so the rail's chip and the
+ *    label that survives a reload disagreed until the next rehydration.
+ */
+export declare const persistSlotBinding: (line: number, sessionId: string, label: string) => void;
+/** `stop_agent`'s target: bound by the line-run reader once a background
+ * dispatch's POST returns a runId, and cleared to `null` when that run
+ * reaches a confirmed terminal state — a stopped or finished run must not look
+ * stoppable again. Transport-only failures deliberately retain it for
+ * re-attachment. No-op on an unknown line or an unchanged value (mirrors
+ * `setLineStatus`'s re-write-on-every-render tolerance). In-memory only —
+ * production code wanting the binding to SURVIVE a reload calls
+ * `persistSlotRun` below instead; this stays exported for the `__force*` /
+ * `__bindLineSessionForTest` style test harnesses that intentionally want
+ * the memory-only half. */
+export declare const bindLineRun: (line: number, runId: string | null) => void;
+/**
+ * The durable half of `bindLineRun` (F3/R4): call this — not the bare
+ * `bindLineRun` — whenever a background dispatch's POST accepts a run, and
+ * again when that run reaches a terminal state (`onFinish`/`onError`
+ * clearing it back to `null`). Updates the in-memory registry AND the
+ * persisted slot together, so the ONE thing a page reload cannot observe by
+ * itself — "is this line's run still going?" — survives the reload instead
+ * of silently reverting to a lying "idle". `line-dispatch.ts`'s
+ * `attachLineReader` is the ONE seam that calls this, shared by a live
+ * dispatch and the boot re-attach (`reattachPendingLineRuns`) alike — same
+ * discipline as `persistSlotBinding`'s ADOPTION seam.
+ *
+ * Line 1 never goes through this (line-dispatch.ts never dispatches to line
+ * 1 — see its module doc): its `runId` stays the always-`null` value
+ * `bindLineRun` already tolerates, and its own run is resolved at stop-time
+ * from the stream-state store instead (`AgentLine.runId`'s doc).
+ */
+export declare const persistSlotRun: (line: number, runId: string | null) => void;
 export declare const setLineStatus: (line: number, status: AgentLineStatus, lastText?: string) => 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
+ * reaches a terminal state. `phase` rides along so the working card can wear
+ * the matching phase icon (omitted/null = kind unknown → spinner); a `null`
+ * label always clears both. No-op on an unknown line or unchanged values
+ * (mirrors `setLineStatus`'s tolerance). */
+export declare const setLineStep: (line: number, label: string | null, phase?: WorkPhase | null) => void;
+/** Write a line's `unseenResult` flag directly — `deliverLineReply`/
+ * `deliverLineFailure` (voice-call.ts) call this alongside `setLineStatus` to
+ * mark a background line's finish/failure unseen when its session isn't the
+ * one on screen. No-op on an unknown line or an unchanged value (mirrors
+ * `setLineStatus`'s tolerance). Most callers want `markLineSeen` below rather
+ * than calling this with `false` directly. */
+export declare const setLineUnseenResult: (line: number, unseenResult: boolean) => void;
+/** The user is now looking at this line's session — clear its unseen-result
+ * flag. Called from BelongDock's `onSelectSession` (any surface that opens a
+ * session — the sessions list, `show_agent_line`, a notification click) once
+ * it resolves which line, if any, owns the opened session. */
+export declare const markLineSeen: (line: number) => void;
+/**
+ * The user opened `sessionId` — clear the unseen-result flag on EVERY line
+ * bound to it. More than one line can share a session: line 1 aliases whatever
+ * the chat is showing, so a background line the user opened is held by both.
+ * Marking only the FIRST match (line 1, which sorts first) left the background
+ * agent's green dot lit forever with no way to clear it. No-op when no line
+ * owns the session.
+ */
+export declare const markSessionSeen: (sessionId: string) => void;
+/**
+ * The session behind `sessionId` is gone (the user deleted it) — RELEASE every
+ * line bound to it, in memory and durably. Without this the registry and its
+ * reload-surviving slot keep pointing at a session that no longer exists, so
+ * the rail goes on offering a chip that opens nothing.
+ */
+export declare const releaseLinesForSession: (sessionId: string) => void;

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

@@ -1,4 +1,5 @@
 import { AgentLineStatus } from './voice-call-lines.ts';
+import { WorkPhase } from './voice-narration.ts';
 export type CallStatus = "idle" | "connecting" | "in_call" | "error";
 /**
  * One row of the call's execution timeline (the CallScreen activity card):
@@ -112,6 +113,7 @@ declare let lineDispatcher: ((req: {
 }) => void) | null;
 export declare const registerCallLineDispatcher: (dispatcher: NonNullable<typeof lineDispatcher>) => (() => void);
 export declare const registerCallLineViewSwitcher: (switcher: (sessionId: string) => void) => (() => void);
+export declare const registerCallClearNotifier: (notifier: (sessionId: string) => void) => (() => void);
 /**
  * ChatRoute calls this when a tool-approval card appears while a call is
  * live: the ask lands on the timeline and the voice model asks the user to
@@ -133,7 +135,24 @@ export declare const setCallWorkPhase: (phase: CallState["workPhase"]) => void;
  * (e.g. ChatRoute hasn't mounted).
  */
 export declare const showLineOnScreen: (line: number) => void;
-export declare const startCall: () => Promise<void>;
+/**
+ * `isReconnect`: set by the dock's boot-time auto-redial (BEL — call survives
+ * page reload) when a per-tab {@link readCallActiveMarker} marker says a call
+ * was live when the page went away. Everything else about starting the call
+ * is identical to a manual dial — a fresh page load already rehydrates every
+ * line straight from its persisted slot session at MODULE BOOT (the registry's
+ * own initializer, `voice-call-lines.ts`), and `ensureForegroundLineSession`
+ * reuses line 1's persisted session pointer (stream-state-store.ts), so no
+ * line state is lost either way; `resetForCallStart()` below only clears a
+ * line that was genuinely left stuck "working" by an earlier call's teardown.
+ * The ONE thing a fresh page load can't recover on its own is the call's
+ * spoken timeline (in-memory, wiped by definition) — `resumeDigest`, captured
+ * from the marker BEFORE this call's own lifecycle overwrites it, carries that
+ * recap into the reconnected realtime session (see `onOpen` below).
+ */
+export declare const startCall: (options?: {
+    readonly isReconnect?: boolean;
+}) => Promise<void>;
 export declare const endCall: () => void;
 export declare const toggleCallMuted: () => void;
 /** Dismiss a sticky error state (the overlay's ✕). */
@@ -173,10 +192,13 @@ export declare const deliverLineArtifact: (line: number, artifact: {
 export declare const deliverLineFailure: (line: number, message: string) => void;
 /** A background line is blocked on a tool approval — steer the user to it. */
 export declare const notifyLineApprovalNeeded: (line: number, timelineText: string) => void;
-/** A background line advanced a phase — land a tagged row + a spoken nudge.
- * Guarded like its delivery siblings: a stale phase from an ended call (there
- * is no registry write here) must not touch a new call's timeline. */
-export declare const notifyLinePhase: (line: number, phaseLabel: string) => void;
+/** A background line advanced a phase — record it as the line's live step
+ * (CallScreen's agent board), land a tagged timeline row, and nudge a spoken
+ * update. The registry write is unconditional (line-dispatch's own `isStale`
+ * guard already keeps a stale-call phase from ever reaching here); the
+ * timeline/spoken half stays guarded like its delivery siblings so a phase
+ * that DOES arrive with no live call just updates the board silently. */
+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;
 /**
@@ -196,7 +218,7 @@ export declare const __forceCallAudioLevel: (level: number) => void;
  * CallScreen lines strip in E2E and sandboxed browsers. Resets the registry,
  * then replays the same store calls a live Operator run makes: `openAgentLine`
  * to create each background line (sequential, mirroring real dispatch),
- * `bindLineSession` + `setLineStatus` to fill it in. Line 1 is the existing
+ * `__bindLineSessionForTest` + `setLineStatus` to fill it in. Line 1 is the existing
  * foreground line and is updated in place rather than opened. Entries are
  * replayed in ascending `line` order regardless of input order, so lines 2/3
  * always land on their expected slots.
@@ -206,5 +228,11 @@ export declare const __forceAgentLines: (forced: readonly {
     label: string;
     status: AgentLineStatus;
     sessionId?: string;
+    /** Optional live step label (CallScreen's agent board) — mirrors what
+     * `notifyLinePhase` writes on a real background dispatch. */
+    currentStepLabel?: string;
+    /** Optional phase classification for the step — drives the working
+     * card's phase icon (omitted = spinner). */
+    currentPhase?: WorkPhase;
 }[]) => void;
 export {};

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

@@ -57,6 +57,7 @@ export declare const en: {
         readonly executingTasks: "Working on it…";
         readonly workedSteps_one: "Worked · {{count}} step";
         readonly workedSteps_other: "Worked · {{count}} steps";
+        readonly resumingAfterPause: "Taking longer than expected — picking it back up…";
         readonly open: "Open";
         readonly reconnectNeeded: "The {{provider}} session needs reconnecting to continue.";
         readonly reconnect: "Reconnect";
@@ -64,6 +65,22 @@ export declare const en: {
         readonly reconnected: "Reconnected";
         readonly retry: "Retry";
     };
+    readonly stats: {
+        readonly title: "Session stats";
+        readonly input: "Input";
+        readonly output: "Output";
+        readonly total: "Total";
+        readonly timeRunning: "Time running";
+        readonly turns: "Turns";
+        readonly toolCalls: "Tool calls";
+        readonly runtime: "Runtime";
+        readonly empty: "No activity yet";
+        readonly loading: "Loading…";
+        readonly loadError: "Could not load stats";
+        readonly retry: "Retry";
+        readonly exportThis: "Export this session (CSV)";
+        readonly exportAll: "Export all sessions (CSV)";
+    };
     readonly sessions: {
         readonly chats: "Chats";
         readonly newChat: "New chat";
@@ -82,6 +99,8 @@ export declare const en: {
         readonly noSessionsYet: "No sessions yet.";
         readonly untitledSession: "Untitled session";
         readonly updated: "updated";
+        readonly loadedIntoAgent: "Loaded into Agent {{line}}";
+        readonly loadingChat: "Loading chat…";
     };
     readonly scheduled: {
         readonly viewTitle: "Scheduled";
@@ -211,6 +230,12 @@ export declare const en: {
         readonly hotkeyHint: "Hold {{key}} to talk — chat can stay closed";
         readonly expand: "Expand";
         readonly collapse: "Collapse";
+        readonly spawnAgent: "New agent";
+        readonly closeChat: "Close this chat";
+        readonly closeAgent: "Close {{label}}";
+        readonly exportChat: "Download chat (JSON)";
+        readonly exportChatGenerating: "Preparing chat export…";
+        readonly exportChatLast: "Download chat (JSON) — last export {{time}}";
     };
     readonly files: {
         readonly refreshFiles: "Refresh files";
@@ -384,6 +409,7 @@ export declare const en: {
     readonly conversation: {
         readonly thinking: "Thinking…";
         readonly followerBanner: "This conversation is open in another tab";
+        readonly historyUnavailable: "Couldn't load this conversation — try reopening it.";
     };
     readonly compaction: {
         readonly compacted: "Compacted {{count}} earlier messages into a summary.";
@@ -434,6 +460,7 @@ export declare const en: {
         readonly endCall: "End call";
         readonly dismiss: "Dismiss";
         readonly startCall: "Start voice call";
+        readonly reconnectCall: "Reconnect voice call";
     };
     readonly callScreen: {
         readonly title: "Voice call";
@@ -475,6 +502,12 @@ export declare const en: {
         readonly lineWorking: "working";
         readonly lineReady: "ready";
         readonly lineFailed: "failed";
+        readonly lineIdle: "idle";
+        readonly lineNotStarted: "not started";
+        readonly lineNoChat: "no chat yet";
+        readonly activity: "Activity";
+        readonly showConversationLog: "Show conversation log";
+        readonly hideConversationLog: "Hide conversation log";
         readonly ambientTypingCode: "Typing code…";
         readonly ambientReviewingDiff: "Reviewing the diff…";
         readonly ambientRunningChecks: "Running checks…";

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

@@ -15,6 +15,12 @@ export declare const headerEn: {
         readonly hotkeyHint: "Hold {{key}} to talk — chat can stay closed";
         readonly expand: "Expand";
         readonly collapse: "Collapse";
+        readonly spawnAgent: "New agent";
+        readonly closeChat: "Close this chat";
+        readonly closeAgent: "Close {{label}}";
+        readonly exportChat: "Download chat (JSON)";
+        readonly exportChatGenerating: "Preparing chat export…";
+        readonly exportChatLast: "Download chat (JSON) — last export {{time}}";
     };
 };
 export declare const headerEs: {
@@ -33,6 +39,12 @@ export declare const headerEs: {
         hotkeyHint: string;
         expand: string;
         collapse: string;
+        spawnAgent: string;
+        closeChat: string;
+        closeAgent: string;
+        exportChat: string;
+        exportChatGenerating: string;
+        exportChatLast: string;
     };
 };
 export declare const headerPt: {
@@ -51,5 +63,11 @@ export declare const headerPt: {
         hotkeyHint: string;
         expand: string;
         collapse: string;
+        spawnAgent: string;
+        closeChat: string;
+        closeAgent: string;
+        exportChat: string;
+        exportChatGenerating: string;
+        exportChatLast: string;
     };
 };

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

@@ -18,6 +18,8 @@ export declare const sessionsEn: {
         readonly noSessionsYet: "No sessions yet.";
         readonly untitledSession: "Untitled session";
         readonly updated: "updated";
+        readonly loadedIntoAgent: "Loaded into Agent {{line}}";
+        readonly loadingChat: "Loading chat…";
     };
 };
 export declare const sessionsEs: {
@@ -39,6 +41,8 @@ export declare const sessionsEs: {
         noSessionsYet: string;
         untitledSession: string;
         updated: string;
+        loadedIntoAgent: string;
+        loadingChat: string;
     };
 };
 export declare const sessionsPt: {
@@ -60,5 +64,7 @@ export declare const sessionsPt: {
         noSessionsYet: string;
         untitledSession: string;
         updated: string;
+        loadedIntoAgent: string;
+        loadingChat: string;
     };
 };

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

@@ -0,0 +1,55 @@
+/** Session stats panel strings. */
+export declare const statsEn: {
+    readonly stats: {
+        readonly title: "Session stats";
+        readonly input: "Input";
+        readonly output: "Output";
+        readonly total: "Total";
+        readonly timeRunning: "Time running";
+        readonly turns: "Turns";
+        readonly toolCalls: "Tool calls";
+        readonly runtime: "Runtime";
+        readonly empty: "No activity yet";
+        readonly loading: "Loading…";
+        readonly loadError: "Could not load stats";
+        readonly retry: "Retry";
+        readonly exportThis: "Export this session (CSV)";
+        readonly exportAll: "Export all sessions (CSV)";
+    };
+};
+export declare const statsEs: {
+    stats: {
+        title: string;
+        input: string;
+        output: string;
+        total: string;
+        timeRunning: string;
+        turns: string;
+        toolCalls: string;
+        runtime: string;
+        empty: string;
+        loading: string;
+        loadError: string;
+        retry: string;
+        exportThis: string;
+        exportAll: string;
+    };
+};
+export declare const statsPt: {
+    stats: {
+        title: string;
+        input: string;
+        output: string;
+        total: string;
+        timeRunning: string;
+        turns: string;
+        toolCalls: string;
+        runtime: string;
+        empty: string;
+        loading: string;
+        loadError: string;
+        retry: string;
+        exportThis: string;
+        exportAll: string;
+    };
+};

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

@@ -57,6 +57,7 @@ export declare const streamEn: {
         readonly executingTasks: "Working on it…";
         readonly workedSteps_one: "Worked · {{count}} step";
         readonly workedSteps_other: "Worked · {{count}} steps";
+        readonly resumingAfterPause: "Taking longer than expected — picking it back up…";
         readonly open: "Open";
         readonly reconnectNeeded: "The {{provider}} session needs reconnecting to continue.";
         readonly reconnect: "Reconnect";
@@ -116,6 +117,7 @@ export declare const streamEs: {
         executingTasks: string;
         workedSteps_one: string;
         workedSteps_other: string;
+        resumingAfterPause: string;
         open: string;
         reconnectNeeded: string;
         reconnect: string;
@@ -175,6 +177,7 @@ export declare const streamPt: {
         executingTasks: string;
         workedSteps_one: string;
         workedSteps_other: string;
+        resumingAfterPause: string;
         open: string;
         reconnectNeeded: string;
         reconnect: string;