@belonguniverseai/react-sdk 0.6.0 → 0.6.1

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

@@ -63,6 +63,15 @@ 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";
@@ -332,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";
@@ -489,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…";
@@ -496,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…";
@@ -516,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 roleLabelCli: "{{product}} CLI agent";
-        readonly roleLabelTerminal: "Terminal 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

@@ -63,6 +63,16 @@ 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";
@@ -144,6 +154,15 @@ 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;
@@ -224,6 +243,15 @@ 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;

package/dist/stream/run-line-progress.d.ts

@@ -6,11 +6,12 @@ import { RunStatusKind } from './belong-data-parts.ts';
  * turn that only writes text calls no tools, so `tool_started` never fires and
  * the chip would otherwise sit at "idle" through the whole answer.
  *
- * There is deliberately NO `text` variant. An accumulator feeding
- * `AgentLine.lastText` was specified and dropped: nothing in the dock renders
- * `lastText`, and because this seam no-ops while the session is on screen the
- * accumulator could only ever have collected the post-switch TAIL of an
- * answer. Re-add it when something renders it.
+ * There is deliberately NO `text` variant. An accumulator feeding a per-line
+ * "last result text" field was specified and dropped: nothing in the dock
+ * renders such a field (the registry no longer even carries one), and because
+ * this seam no-ops while the session is on screen the accumulator could only
+ * ever have collected the post-switch TAIL of an answer. Re-add both when
+ * something renders it.
  *
  * `terminal` carries the run's OWN id, and it is not decoration: the durable
  * slot runId this seam clears is shared with the voice dispatch, and a line can

package/dist/stream/tool-action-label.d.ts

@@ -0,0 +1,16 @@
+import { TFunction } from 'i18next';
+export type ToolActionLabel = {
+    readonly key: string;
+};
+/**
+ * The neutral line for a tool this build has never heard of. Exported because
+ * `browserStepMeta` branches on it: an unrecognized `browser_*` suffix keeps
+ * the chat's own sentence-cased fallback instead of this.
+ */
+export declare const GENERIC_ACTION_KEY = "stream.actionGeneric";
+/**
+ * `t(...)` over a `ToolActionLabel` — the ONE way either surface renders one,
+ * so the two can't drift into two different names for the same action.
+ */
+export declare const translateAction: (t: TFunction, action: ToolActionLabel) => string;
+export declare const toolActionLabel: (toolName: string) => ToolActionLabel | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@belonguniverseai/react-sdk",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Belong — embeddable React AI assistant dock. Mount <BelongWidget> in your app tree with getToken dependency-injection auth.",
   "license": "UNLICENSED",
   "type": "module",

package/dist/components/embed/PoweredByBelong.d.ts

@@ -1,7 +0,0 @@
-/** Fixed footer height (px) so the terminal overlay can reserve exact space. */
-export declare const POWERED_BY_BELONG_HEIGHT_PX = 28;
-/**
- * Persistent attribution strip pinned to the bottom of the dock panel when a
- * tenant brand is active. Always the Belong mark (not the tenant BrandMark).
- */
-export declare function PoweredByBelong(): import("react").JSX.Element;

package/dist/embed/voice/agent-queue.d.ts

@@ -1,106 +0,0 @@
-/**
- * Per-line FIFO for work an operator asks an agent to do WHILE that agent is
- * already busy — the structure behind "queue two things on Agent 2, then
- * drop one" (Slice 3 of the voice-operator plan). File-scope-singleton
- * idiom, same as `line-slots.ts` / `voice-call-lines.ts` beside it: one
- * module-level `Map<number, QueuedRequest[]>`, no class, no React.
- *
- * WHAT THIS REPLACES: today, sending work to a busy agent POSTs it
- * immediately — the message lands in Postgres and the server's own drain
- * loop (SAD §5.1 / CLAUDE.md §37) gets to it whenever the agent frees up.
- * That queue is invisible (no way to ask "what's waiting for Agent 2?"),
- * unorderable (no way to promote the third ask over the second), and
- * undroppable (no way to take one back). This module is the queue moved
- * into the browser, so a caller can read it back, drop an entry, or reorder
- * it before anything is sent. (Wiring `dispatchToLine`'s busy-line path
- * through this queue, and adding the voice-facing `manage_queue` tool, are
- * later tasks — see NOT WIRED IN YET below.)
- *
- * WHY CALL-SCOPED AND NOT DURABLE — the trade-off, spelled out:
- *
- *   - A held `QueuedRequest` lives ONLY in this in-memory Map. Today's
- *     behavior is strictly more durable: a queued follow-up is already
- *     POSTed and sitting in Postgres the instant the operator says it, so it
- *     survives a tab crash, a network blip, anything short of the session
- *     itself being deleted. Moving the queue into the browser gives up that
- *     durability in exchange for the operator being able to see and steer
- *     it — that is the entire point, and the trade needs to be made with
- *     open eyes, not by accident.
- *   - `drainAllQueues()` is what keeps that loss narrow. It is the hang-up
- *     flush: called as part of ending a call normally, it empties every
- *     line's queue and hands back everything that was waiting so it can be
- *     POSTed to the server exactly as if this module had never sat in front
- *     of it. A normal end-of-call therefore loses nothing — the queue is
- *     just a staging area the operator got to look inside before the same
- *     dispatch that would have happened anyway.
- *   - The durability genuinely AT RISK is narrower still than it first
- *     sounds: a live voice call is not something a page reload survives
- *     regardless of this module — there is no reload-resume contract for
- *     the call itself (unlike the §41 guarantee for an already-dispatched
- *     agent turn, which is a Postgres/Redis-backed run, not the call). So
- *     "a reload loses the queue" is not a NEW failure this module
- *     introduces; the call was already gone. What is genuinely new is the
- *     sliver between "something got queued" and "the call ends" during
- *     which the tab could crash before `drainAllQueues()` ever runs — a
- *     real but narrow window, and the one honest cost of this design.
- *
- * NOT WIRED IN YET: this ships as a standalone module with its own tests
- * and no production caller. A later task connects `enqueueForLine` /
- * `dequeueForLine` to `dispatchToLine`'s busy-line path and `drainAllQueues`
- * to the hang-up handler; another adds the voice-facing `manage_queue` tool
- * on top of `peekQueue` / `dropQueuedAt` / `moveQueued`.
- */
-export type QueuedRequest = {
-    readonly id: string;
-    readonly request: string;
-};
-/** Append `request` to the back of `line`'s queue, minting a fresh id
- * (`nanoid()`, the same generator `line-dispatch.ts` uses for
- * `clientMessageId`). Always succeeds — there is no bound on queue depth. */
-export declare const enqueueForLine: (line: number, request: string) => QueuedRequest;
-/** Pop and return the FRONT of `line`'s queue, or `null` when it's empty. */
-export declare const dequeueForLine: (line: number) => QueuedRequest | null;
-/** A read-only snapshot of `line`'s queue, front to back. Never mutates. */
-export declare const peekQueue: (line: number) => readonly QueuedRequest[];
-/** How many requests are waiting on `line`. */
-export declare const queueDepth: (line: number) => number;
-/** Remove and return the item at `index` in `line`'s queue, or `null` when
- * `index` is out of range — an explicit `< 0 || >= length` bound (§10: never
- * truthiness on a length or index), so a bad index is an honest miss rather
- * than a silent no-op that could be mistaken for success. */
-export declare const dropQueuedAt: (line: number, index: number) => QueuedRequest | null;
-/** Move the item at `from` to position `to` in `line`'s queue (both bounds
- * explicit, same discipline as `dropQueuedAt`). Returns `false` — leaving
- * the queue completely untouched — when either index is out of range;
- * `true` on success, including the no-op case `from === to` (a valid index
- * moved to itself: nothing changes, but the request was satisfied, not
- * refused). `to` is a position in the queue AFTER `from` is removed — the
- * standard "move to position N" reading: moving the last item to `to: 0`
- * makes it the new front. */
-export declare const moveQueued: (line: number, from: number, to: number) => boolean;
-/** The hang-up flush: empty EVERY line's queue and return everything that
- * was waiting, in line-then-position order (line ascending, FIFO within a
- * line) — the order a normal end-of-call should hand work to the server in.
- * Exhaustive by construction: every line the map holds is visited and
- * cleared, so nothing can be left behind. See the module doc for why this
- * is what makes the queue's in-memory-only durability trade-off safe for a
- * normal call end. */
-export declare const drainAllQueues: () => readonly {
-    readonly line: number;
-    readonly request: string;
-}[];
-/** The call-teardown clear: drop every line's queue without returning
- * anything. Unlike `drainAllQueues`, this is for the paths that must not
- * re-POST stale work — e.g. resetting state at the START of a fresh call. */
-export declare const resetQueues: () => void;
-/** Drop `line`'s held queue and report how many items were discarded — the
- * ONE-line counterpart to `resetQueues()` (every line). For the paths that
- * must not re-POST or re-dispatch one line's stale work without touching any
- * other line's: `stop_agent` (voice-call.ts) clearing exactly the queue it
- * just told the user was dropped, and `closeAgentLine` (voice-call-lines.ts)
- * releasing a line whose held work must not resurrect onto the next
- * occupant of the same number. An explicit `=== 0` check rather than
- * truthiness (§10), same discipline as `dropQueuedAt`/`moveQueued`: a
- * nothing-to-drop line reports `0` honestly instead of writing an empty
- * array through `setQueue` for no reason. */
-export declare const clearQueueForLine: (line: number) => number;