@belonguniverseai/react-sdk 0.6.0 → 0.6.2

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

@@ -2,33 +2,62 @@ import { z } from 'zod';
 declare const callActiveMarkerSchema: z.ZodObject<{
     active: z.ZodLiteral<true>;
     startedAtMs: z.ZodNumber;
-    /** Recap of the call so far, same shape/cap as `buildCallContextDigest()`.
-     * Empty until the first user/agent timeline row lands. */
+    updatedAtMs: z.ZodNumber;
+    redialCount: z.ZodNumber;
     contextDigest: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    active: true;
-    startedAtMs: number;
-    contextDigest: string;
-}, {
-    active: true;
-    startedAtMs: number;
-    contextDigest: string;
-}>;
+}, z.core.$strip>;
 export type CallActiveMarker = z.infer<typeof callActiveMarkerSchema>;
 /** The tab's persisted call marker, or null when absent/malformed — a
  * corrupted or pre-this-feature record just means "nothing to redial". */
 export declare const readCallActiveMarker: () => CallActiveMarker | null;
-/** Mark the call live — called on the `in_call` transition. Starts with an
- * empty digest; {@link refreshCallActiveMarkerContext} fills it in as the
- * call progresses. */
-export declare const writeCallActiveMarker: () => void;
+/**
+ * Why the call that just reached `in_call` was dialled.
+ *
+ * `"user"` — a dial the user asked for outright, which is a fresh intent: it
+ * inherits nothing from an interrupted call, redial streak included.
+ * `"redial"` — a reconnect of an interrupted call, which CONTINUES that
+ * streak. `voice-call.ts` maps its `startCall({ isReconnect })` option
+ * straight onto this, so the rail's manual "Reconnect" click also continues
+ * the streak rather than resetting it: the count only ever gates the
+ * AUTOMATIC redial, so continuing it errs toward asking the user again rather
+ * than toward reopening the microphone on its own.
+ */
+export type CallDialOrigin = "user" | "redial";
+/** Mark the call live — called on the `in_call` transition. `updatedAtMs`
+ * starts equal to `startedAtMs` (no heartbeat has ticked yet). `redialCount`
+ * carries over from the interrupted call on a `"redial"` (see the module doc:
+ * reaching `in_call` is NOT proof a redial worked — only the 30s healthy-call
+ * timer's {@link resetRedialCount} is) and starts at zero on a `"user"` dial.
+ * Starts with an empty digest; {@link refreshCallActiveMarkerContext} fills it
+ * in as the call progresses. */
+export declare const writeCallActiveMarker: (origin: CallDialOrigin) => void;
 /** Update the persisted digest of an already-active marker. No-op when no
  * marker is active — a digest has nothing to attach itself to once the call
  * has ended. */
 export declare const refreshCallActiveMarkerContext: (contextDigest: string) => void;
+/** How often `voice-call.ts` re-stamps `updatedAtMs` while a call is
+ * `in_call` — the proof-of-life cadence a future reload's staleness check is
+ * accurate to. */
+export declare const MARKER_HEARTBEAT_MS = 10000;
+/** Refresh the marker's proof-of-life stamp. Called on a
+ * `MARKER_HEARTBEAT_MS` interval for as long as the call is live — see the
+ * module doc comment for why this can't just ride `refreshCallActiveMarkerContext`.
+ * No-op when no marker is active, mirroring `refreshCallActiveMarkerContext`:
+ * a heartbeat has nothing left to touch once the call has ended. */
+export declare const touchCallActiveMarker: () => void;
+/** Record one more auto-redial attempt against the persisted marker. No-op
+ * when no marker is active — mirrors `refreshCallActiveMarkerContext`. */
+export declare const noteRedialAttempt: () => void;
+/** Zero the redial counter — called once a (re)dialed call has stayed up long
+ * enough to call healthy, so it stops counting against the next drop. No-op
+ * when no marker is active — mirrors `refreshCallActiveMarkerContext`. */
+export declare const resetRedialCount: () => void;
 /** Call ended (explicit hangup or terminal error) — no reload should redial. */
 export declare const clearCallActiveMarker: () => void;
-export type ReconnectOfferDecision = "offer" | "skip";
+/** What the dock's boot effect should do about an interrupted call: dial it
+ * back automatically, put the one-click offer on the rail's call button, or
+ * leave the dock alone. */
+export type ReconnectAction = "redial" | "offer" | "skip";
 /**
  * How long after the interrupted call started we still OFFER to reconnect. A
  * reload lands in seconds; a tab the browser restored from a much older session
@@ -37,29 +66,37 @@ export type ReconnectOfferDecision = "offer" | "skip";
  */
 export declare const RECONNECT_OFFER_MAX_AGE_MS = 600000;
 /**
- * Whether the dock's boot effect should OFFER to reconnect an interrupted call.
- *
- * This deliberately decides an offer, never a dial. Auto-dialing on load opens
- * the MICROPHONE with no user gesture: the origin already holds mic permission
- * (a call was live moments ago), so the browser does not re-prompt and the mic
- * would come back silently on the next page load — on hosts that receive the
- * SDK through an unpinnable bundle, with no opt-in of their own. Requiring one
- * click to redial is both the honest consent story and what browsers' autoplay/
- * gesture rules expect; the marker is kept either way so the redial can still
- * carry the interrupted call's `contextDigest`.
+ * How stale the marker may be and still earn an AUTOMATIC redial. A reload
+ * lands within a couple of seconds; a tab the browser restored from a much
+ * older session must not silently reopen the microphone. Read against
+ * `updatedAtMs` (the heartbeat), never `startedAtMs` — a call that has been
+ * live for 20 minutes must still come back.
+ */
+export declare const REDIAL_MAX_STALENESS_MS = 120000;
+/** Consecutive automatic redials before falling back to the button. A host
+ * that crash-loops must not reopen the mic on every load. */
+export declare const MAX_CONSECUTIVE_REDIALS = 2;
+/**
+ * What the dock's boot effect should do about a call this tab was in when the
+ * page went away.
  *
  * Pure so the branching is unit-testable without React or WebRTC: a marker
  * means a call was live when the page went away; `tokenReady` mirrors the same
  * auth-readiness gate the login screen polls; `alreadyOffered` is the one-shot
- * guard (the offer is raised at most once per page load); and `startedAtMs` is
- * consumed against `nowMs` so a stale marker cannot offer forever.
+ * guard (the decision is acted on at most once per page load); and the
+ * marker's timestamps are consumed against `nowMs` so a stale marker can
+ * neither dial nor offer forever.
+ *
+ * The gates are what make an unattended `"redial"` acceptable — see the module
+ * doc. `"offer"` is the same one-click fallback this file has always decided,
+ * now reached only when a redial's gates say no.
  */
-export declare const decideReconnectOffer: (input: {
+export declare const decideReconnectAction: (input: {
     readonly marker: CallActiveMarker | null;
     readonly tokenReady: boolean;
     readonly alreadyOffered: boolean;
     readonly nowMs: number;
-}) => ReconnectOfferDecision;
+}) => ReconnectAction;
 export declare const peekReconnectOffered: () => boolean;
 export declare const markReconnectOffered: () => void;
 /** Test-only: forget the one-shot guard between test cases. */

package/dist/embed/voice/line-dispatch.d.ts

@@ -17,14 +17,14 @@
  * a workspace must land in THAT workspace, not the shared legacy root — so the
  * create body carries the effective `workspaceExternalId` (absent when the host
  * runs unscoped). The line's registry label seeds the session title when one
- * exists; otherwise (U4 — the common case for a freshly materialized line,
- * since `dispatchToBackgroundLine` no longer seeds the registry label with the
- * agent's own name) the REQUEST itself does, so the sessions list still names
- * the background conversation by what it's actually about ("Reconcile the
- * July invoices"), not the agent that happened to run it.
+ * exists; otherwise (U4 — the common case, since nothing seeds a freshly
+ * materialized line's registry label any more) the REQUEST itself does, so the
+ * sessions list still names the background conversation by what it's actually
+ * about ("Reconcile the July invoices"), not the agent that happened to run
+ * it.
  *
  * BOOT RE-ATTACH (F3/R4): `attachLineReader` below is the ONE seam that wires
- * a VOICE-dispatched line-run reader onto a line, shared by a fresh dispatch
+ * a SLOT-tracked line-run reader onto a line, shared by a fresh dispatch
  * (this module, right after a POST accepts a run) and `reattachPendingLineRuns`
  * (called once at boot, after `initAgentLines()` rehydrates the registry)
  * resuming a run that was still going when the page reloaded. Both paths
@@ -32,26 +32,28 @@
  * navigate/artifact/finish/error callbacks — a reload must behave exactly like
  * the live dispatch it is standing in for, not a parallel, easier-to-drift copy.
  *
- * TWO READER KINDS (BEL-90). This module now attaches two, and which callback
- * set a caller gets is a correctness question, not a style one:
+ * TWO READER KINDS (BEL-90). This module attaches two, and which callback set
+ * a caller gets is a correctness question, not a style one. NEITHER speaks —
+ * a background line never reaches the call (see voice-call.ts's agent-line
+ * section) — but they write different things:
  *
- *   - `attachLineReader` — the voice-NARRATION reader. Its callbacks are not
- *     plain setters: `deliverLineReply`/`deliverLineFailure` push
- *     `conversation.item.create` events into an active voice call and ask the
- *     model to respond, `notifyLinePhase` appends timeline rows and nudges
- *     spoken progress, `deliverLineArtifact` opens a preview panel. Correct
- *     for a run the operator dispatched BY VOICE.
+ *   - `attachLineReader` — the SLOT reader, for a run this module dispatched.
+ *     It owns the durable slot runId (`persistSlotRun`, set on dispatch and
+ *     cleared on terminal), writes the registry through
+ *     `deliverLineReply`/`deliverLineFailure`/`notifyLinePhase`/
+ *     `notifyLineApprovalNeeded`, and additionally opens an artifact preview
+ *     and dispatches host route navigation.
  *   - `attachLineProgressReader` — the plain-progress reader, for a run the
  *     user started by TYPING that was still in flight at reload. It goes
- *     through `reportRunLineProgress` and touches only the registry, so a
- *     typed run can never make the agent start talking about background
- *     progress mid-call.
+ *     through `reportRunLineProgress`, touches only the registry, and — see
+ *     its own doc — deliberately writes no slot runId, opens no panel, and
+ *     drives no navigation.
  */
 /** Abort every live line reader and invalidate their callbacks (call teardown).
  * Subscribed below to fire whenever a call leaves in_call/connecting. */
 export declare const abortAllLineReaders: () => void;
 /** Test-only: drop every plain-progress reader (and the active-session latch)
- * so a case never inherits either from the previous case. The narration
+ * so a case never inherits either from the previous case. The slot
  * readers have `abortAllLineReaders`; these deliberately do NOT ride on it — a
  * voice call ending has nothing to do with a typed run still streaming. */
 export declare const __detachLineProgressReadersForTest: () => void;
@@ -66,8 +68,8 @@ export declare const __detachLineProgressReadersForTest: () => void;
  * TWO paths, because the two dispatch kinds have genuinely different
  * contracts (BEL-90 / B1 — see `attachLineProgressReader`'s doc):
  *
- *  - F3/R4, UNCHANGED — a line whose durable SLOT carries a runId was
- *    dispatched by voice. It gets the narration reader, on every line that has
+ *  - F3/R4, UNCHANGED — a line whose durable SLOT carries a runId went
+ *    through `dispatchToLine`. It gets the slot reader, on every line that has
  *    one, INCLUDING when its session is the one on screen. That last part is
  *    load-bearing: `persistSlotRun(line, null)` in that reader's terminal
  *    callbacks is the durable slot's clearer, and skipping the on-screen line

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

@@ -26,6 +26,12 @@ export type RealtimeCallHandle = {
     readonly sendEvent: (event: Record<string, unknown>) => void;
     /** Toggle the local mic track without renegotiating. */
     readonly setMuted: (muted: boolean) => void;
+    /** Ask the browser to play the agent's audio again after it refused (see
+     * {@link ConnectRealtimeCallInput.onAudioBlocked}). Resolves true only when
+     * playback actually started. Call it STRAIGHT from the user's tap handler:
+     * the `play()` inside runs before the first await, so the gesture the
+     * browser is holding out for is still on the stack. */
+    readonly resumeAudio: () => Promise<boolean>;
     /** Tear down mic, peer connection, and audio playback. Idempotent. */
     readonly close: () => void;
 };
@@ -52,5 +58,11 @@ export type ConnectRealtimeCallInput = {
         readonly local: MediaStream;
         readonly remote: MediaStream;
     }) => void;
+    /** Fired when the browser REFUSES to play the agent's audio. `autoplay` is
+     * a request, not a guarantee — a page that reloaded mid-call has no fresh
+     * user gesture behind it — and a refusal we never asked about is completely
+     * silent: the call looks connected and says nothing. The store turns this
+     * into a one-tap "Tap to hear" control (`resumeAudio` above). */
+    readonly onAudioBlocked?: () => void;
 };
 export declare const connectRealtimeCall: (input: ConnectRealtimeCallInput) => Promise<ConnectRealtimeCallResult>;

package/dist/embed/voice/reconnect-offer.d.ts

@@ -2,12 +2,19 @@
  * "A call was interrupted — tap to reconnect" — the one-bit store that turns a
  * surviving call marker (`call-active-marker.ts`) into a USER-DRIVEN redial.
  *
- * The dock's boot effect raises the offer; the rail's CallButton reads it and,
- * while it stands, dials with `{ isReconnect: true }` (carrying the interrupted
+ * This is the FALLBACK half of reload survival: the dock's boot effect dials
+ * an interrupted call back on its own when the marker clears
+ * `decideReconnectAction`'s gates, and raises this offer when it does not —
+ * a marker too stale to prove the call was live moments ago, or one already
+ * redialed up to the consecutive-redial cap. It raises the offer again when a
+ * redial the gates DID allow fails to connect, so a flaky call-token endpoint
+ * costs the user one automatic attempt rather than the whole call (see
+ * `watchRedialForFallback` in BelongDock.tsx). Whenever it stands, the rail's
+ * CallButton dials with `{ isReconnect: true }` (carrying the interrupted
  * call's context digest) and labels itself "Reconnect" instead of "Start voice
  * call". That is the whole mechanism: ONE user click, on a control that is
- * already always visible in the rail — no new surface, and crucially no
- * microphone access without a gesture.
+ * already always visible in the rail — no new surface, and no microphone
+ * access without a gesture on exactly the marker the gates declined to trust.
  *
  * Why a separate store rather than a field on `CallState`: the call state is
  * rebuilt from `IDLE` on every dial and every terminal error, which would wipe
@@ -18,7 +25,9 @@
  */
 export declare const peekReconnectOffer: () => boolean;
 export declare const subscribeReconnectOffer: (listener: () => void) => (() => void);
-/** Raise the offer (dock boot, when `decideReconnectOffer` says so). */
+/** Raise the offer: at dock boot when `decideReconnectAction` says `"offer"`
+ * (a marker too stale, or too many redials deep, to dial back on its own), and
+ * when a redial it DID allow ends in `error` without ever reaching the call. */
 export declare const offerReconnect: () => void;
 /**
  * Take the offer down. Called when the user acts on it (the reconnect click),

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

@@ -6,20 +6,10 @@ import { z } from 'zod';
  */
 declare const voiceTokensSchema: z.ZodObject<{
     deepgramToken: z.ZodString;
-    deepgramWssUrl: z.ZodString;
+    deepgramWssUrl: z.ZodURL;
     elevenlabsToken: z.ZodString;
     voiceId: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    deepgramToken: string;
-    deepgramWssUrl: string;
-    elevenlabsToken: string;
-    voiceId: string;
-}, {
-    deepgramToken: string;
-    deepgramWssUrl: string;
-    elevenlabsToken: string;
-    voiceId: string;
-}>;
+}, z.core.$strip>;
 export type VoiceTokens = z.infer<typeof voiceTokensSchema>;
 export type VoiceTokenResult = {
     ok: true;

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;