@belonguniverseai/react-sdk 0.4.3 → 0.6.0

package/dist/component/{mindmap-definition-RKZ34NQL-BND7KvId.js → mindmap-definition-RKZ34NQL-wo3l0Jy7.js}

@@ -1,6 +1,6 @@
-import { g as oe } from "./chunk-55IACEB6-DnliqOsL.js";
-import { s as ae } from "./chunk-2J33WTMH-Bsl2GBCp.js";
-import { _ as l, l as C, p as ce, r as le, G as he, K as G, c as B, i as F, b6 as de, af as ge, ag as ue, ah as pe } from "./mermaid-GHXKKRXX-DiPCfS1n.js";
+import { g as oe } from "./chunk-55IACEB6-BOiOLlJY.js";
+import { s as ae } from "./chunk-2J33WTMH-CUyqMMUN.js";
+import { _ as l, l as C, p as ce, r as le, G as he, K as G, c as B, i as F, b6 as de, af as ge, ag as ue, ah as pe } from "./mermaid-GHXKKRXX-BEhqkLaB.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 const b = [];
@@ -830,4 +830,4 @@ var _e = Y, ke = 12, N = {
 export {
   we as diagram
 };
-//# sourceMappingURL=mindmap-definition-RKZ34NQL-BND7KvId.js.map
+//# sourceMappingURL=mindmap-definition-RKZ34NQL-wo3l0Jy7.js.map

package/dist/component/{pieDiagram-4H26LBE5-CvDdRFnN.js → pieDiagram-4H26LBE5-TtxT_WMN.js}

@@ -1,7 +1,7 @@
-import { a0 as S, S as R, b5 as J, g as Q, s as Y, a as tt, b as et, t as at, q as nt, _ as g, l as W, c as rt, I as it, N as st, a7 as lt, e as ot, B as ct, K as ut } from "./mermaid-GHXKKRXX-DiPCfS1n.js";
-import { p as gt } from "./chunk-4BX2VUAB-BKmdmdRY.js";
+import { a0 as S, S as R, b5 as J, g as Q, s as Y, a as tt, b as et, t as at, q as nt, _ as g, l as W, c as rt, I as it, N as st, a7 as lt, e as ot, B as ct, K as ut } from "./mermaid-GHXKKRXX-BEhqkLaB.js";
+import { p as gt } from "./chunk-4BX2VUAB-4MjzMD47.js";
 import { p as dt } from "./wardley-L42UT6IY-HA1eSIS_.js";
-import { d as P } from "./arc-ByLm_58u.js";
+import { d as P } from "./arc-DpA4gw3l.js";
 import { o as pt } from "./ordinal-D0x7izaa.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
@@ -163,4 +163,4 @@ var vt = ut.pie, z = {
 export {
   Lt as diagram
 };
-//# sourceMappingURL=pieDiagram-4H26LBE5-CvDdRFnN.js.map
+//# sourceMappingURL=pieDiagram-4H26LBE5-TtxT_WMN.js.map

package/dist/component/{quadrantDiagram-W4KKPZXB-DMHCLEev.js → quadrantDiagram-W4KKPZXB-DK6ShvdY.js}

@@ -1,5 +1,5 @@
-import { s as Se, g as _e, t as ee, q as Ae, a as ke, b as Fe, _ as r, c as Et, l as qt, d as vt, e as Pe, B as ve, K as z, i as Ce, a4 as Le } from "./mermaid-GHXKKRXX-DiPCfS1n.js";
-import { l as te } from "./linear-BcyQd0z0.js";
+import { s as Se, g as _e, t as ee, q as Ae, a as ke, b as Fe, _ as r, c as Et, l as qt, d as vt, e as Pe, B as ve, K as z, i as Ce, a4 as Le } from "./mermaid-GHXKKRXX-BEhqkLaB.js";
+import { l as te } from "./linear-BVVr39mA.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var Ct = (function() {
@@ -1030,4 +1030,4 @@ var Ve = /* @__PURE__ */ r(function() {
 export {
   We as diagram
 };
-//# sourceMappingURL=quadrantDiagram-W4KKPZXB-DMHCLEev.js.map
+//# sourceMappingURL=quadrantDiagram-W4KKPZXB-DK6ShvdY.js.map

package/dist/component/{requirementDiagram-4Y6WPE33-BomcVKb4.js → requirementDiagram-4Y6WPE33-Z0IavHMQ.js}

@@ -1,6 +1,6 @@
-import { g as Ge } from "./chunk-55IACEB6-DnliqOsL.js";
-import { s as ze } from "./chunk-2J33WTMH-Bsl2GBCp.js";
-import { _ as h, G as Ye, b as Xe, a as Je, s as Ze, g as et, q as tt, t as st, c as ke, l as Ne, B as it, F as rt, p as nt, r as at, u as lt } from "./mermaid-GHXKKRXX-DiPCfS1n.js";
+import { g as Ge } from "./chunk-55IACEB6-BOiOLlJY.js";
+import { s as ze } from "./chunk-2J33WTMH-CUyqMMUN.js";
+import { _ as h, G as Ye, b as Xe, a as Je, s as Ze, g as et, q as tt, t as st, c as ke, l as Ne, B as it, F as rt, p as nt, r as at, u as lt } from "./mermaid-GHXKKRXX-BEhqkLaB.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var qe = (function() {
@@ -885,4 +885,4 @@ var mt = /* @__PURE__ */ h(async function(e, u, o, n) {
 export {
   Rt as diagram
 };
-//# sourceMappingURL=requirementDiagram-4Y6WPE33-BomcVKb4.js.map
+//# sourceMappingURL=requirementDiagram-4Y6WPE33-Z0IavHMQ.js.map

package/dist/component/{sankeyDiagram-5OEKKPKP-D4rmtFCn.js → sankeyDiagram-5OEKKPKP-C408nFHk.js}

@@ -1,4 +1,4 @@
-import { q as kt, t as mt, s as xt, g as _t, b as vt, a as bt, _ as y, c as ot, C as St, d as G, ai as wt, B as Lt, k as Et } from "./mermaid-GHXKKRXX-DiPCfS1n.js";
+import { q as kt, t as mt, s as xt, g as _t, b as vt, a as bt, _ as y, c as ot, C as St, d as G, ai as wt, B as Lt, k as Et } from "./mermaid-GHXKKRXX-BEhqkLaB.js";
 import { o as Tt } from "./ordinal-D0x7izaa.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
@@ -859,4 +859,4 @@ var ge = {
 export {
   ge as diagram
 };
-//# sourceMappingURL=sankeyDiagram-5OEKKPKP-D4rmtFCn.js.map
+//# sourceMappingURL=sankeyDiagram-5OEKKPKP-C408nFHk.js.map

package/dist/component/{sequenceDiagram-3UESZ5HK-C0iEDbuE.js → sequenceDiagram-3UESZ5HK-CMFVhmkn.js}

@@ -1,6 +1,6 @@
-import { _ as g, o as tr, c as $, d as Mt, l as at, j as Ce, e as er, f as rr, k as P, b as ke, s as ar, q as sr, a as ir, g as nr, t as or, v as cr, J as lr, B as hr, i as Bt, u as Z, a5 as Q, a6 as wt, a7 as Me, a8 as dr, G as Yt, a9 as Tr, aa as Be } from "./mermaid-GHXKKRXX-DiPCfS1n.js";
-import { a as pr, b as ee, g as dt, d as Er, e as re, f as ae } from "./chunk-ND2GUHAM-COsoTCa0.js";
-import { I as ur } from "./chunk-QZHKN3VN-9FjIin4_.js";
+import { _ as g, o as tr, c as $, d as Mt, l as at, j as Ce, e as er, f as rr, k as P, b as ke, s as ar, q as sr, a as ir, g as nr, t as or, v as cr, J as lr, B as hr, i as Bt, u as Z, a5 as Q, a6 as wt, a7 as Me, a8 as dr, G as Yt, a9 as Tr, aa as Be } from "./mermaid-GHXKKRXX-BEhqkLaB.js";
+import { a as pr, b as ee, g as dt, d as Er, e as re, f as ae } from "./chunk-ND2GUHAM-BAq6BoPv.js";
+import { I as ur } from "./chunk-QZHKN3VN-DSE2KpkL.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var $t = (function() {
@@ -2894,4 +2894,4 @@ var ra = /* @__PURE__ */ g(async function(e, t, a) {
 export {
   Ta as diagram
 };
-//# sourceMappingURL=sequenceDiagram-3UESZ5HK-C0iEDbuE.js.map
+//# sourceMappingURL=sequenceDiagram-3UESZ5HK-CMFVhmkn.js.map

package/dist/component/{stateDiagram-AJRCARHV-x0PonbWT.js → stateDiagram-AJRCARHV-C6Z5V-Yt.js}

@@ -1,5 +1,5 @@
-import { s as R, a as W, S as N } from "./chunk-AQP2D5EJ-CwBA3VVY.js";
-import { _ as f, c as t, d as M, l as S, e as P, k as z, ac as _, ad as U, a9 as C, u as F } from "./mermaid-GHXKKRXX-DiPCfS1n.js";
+import { s as R, a as W, S as N } from "./chunk-AQP2D5EJ-B4yIZLgM.js";
+import { _ as f, c as t, d as M, l as S, e as P, k as z, ac as _, ad as U, a9 as C, u as F } from "./mermaid-GHXKKRXX-BEhqkLaB.js";
 import { G as O } from "./graph-BZLHvygk.js";
 import { l as J } from "./layout-Bu6nRdWm.js";
 globalThis.process = globalThis.process || { env: {} };
@@ -263,4 +263,4 @@ var X = /* @__PURE__ */ f((e) => e.append("circle").attr("class", "start-state")
 export {
   ot as diagram
 };
-//# sourceMappingURL=stateDiagram-AJRCARHV-x0PonbWT.js.map
+//# sourceMappingURL=stateDiagram-AJRCARHV-C6Z5V-Yt.js.map

package/dist/component/{stateDiagram-v2-BHNVJYJU-6Lq1LlSV.js → stateDiagram-v2-BHNVJYJU-CztCn1yf.js}

@@ -1,5 +1,5 @@
-import { s as e, b as r, a as s, S as t } from "./chunk-AQP2D5EJ-CwBA3VVY.js";
-import { _ as l } from "./mermaid-GHXKKRXX-DiPCfS1n.js";
+import { s as e, b as r, a as s, S as t } from "./chunk-AQP2D5EJ-B4yIZLgM.js";
+import { _ as l } from "./mermaid-GHXKKRXX-BEhqkLaB.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var b = {
@@ -16,4 +16,4 @@ var b = {
 export {
   b as diagram
 };
-//# sourceMappingURL=stateDiagram-v2-BHNVJYJU-6Lq1LlSV.js.map
+//# sourceMappingURL=stateDiagram-v2-BHNVJYJU-CztCn1yf.js.map

package/dist/component/{timeline-definition-PNZ67QCA-CIx8lwoQ.js → timeline-definition-PNZ67QCA-D_9a8hKa.js}

@@ -1,5 +1,5 @@
-import { _ as o, G as gt, af as Rt, ag as Ct, ah as Wt, c as pt, l as E, N as Pt, a7 as Bt, ai as ft, d as U, F as Vt, aj as Ft, B as zt } from "./mermaid-GHXKKRXX-DiPCfS1n.js";
-import { d as ot } from "./arc-ByLm_58u.js";
+import { _ as o, G as gt, af as Rt, ag as Ct, ah as Wt, c as pt, l as E, N as Pt, a7 as Bt, ai as ft, d as U, F as Vt, aj as Ft, B as zt } from "./mermaid-GHXKKRXX-BEhqkLaB.js";
+import { d as ot } from "./arc-DpA4gw3l.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var tt = (function() {
@@ -1055,4 +1055,4 @@ var Qt = /* @__PURE__ */ o(function(e, t, n, i, r, h = !1) {
 export {
   me as diagram
 };
-//# sourceMappingURL=timeline-definition-PNZ67QCA-CIx8lwoQ.js.map
+//# sourceMappingURL=timeline-definition-PNZ67QCA-D_9a8hKa.js.map

package/dist/component/{vennDiagram-CIIHVFJN-B27Ya-3D.js → vennDiagram-CIIHVFJN-HuWQgr4e.js}

@@ -1,4 +1,4 @@
-import { aX as Gt, s as Wt, g as Kt, t as Ht, q as Xt, a as Yt, b as Zt, _ as w, G as wt, N as Jt, d as ot, ao as Qt, af as $t, ag as te, ah as ee, e as ne, B as se, I as ie, K as oe } from "./mermaid-GHXKKRXX-DiPCfS1n.js";
+import { aX as Gt, s as Wt, g as Kt, t as Ht, q as Xt, a as Yt, b as Zt, _ as w, G as wt, N as Jt, d as ot, ao as Qt, af as $t, ag as te, ah as ee, e as ne, B as se, I as ie, K as oe } from "./mermaid-GHXKKRXX-BEhqkLaB.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 const kt = (t, n) => Gt(t, "a", -n), _t = 1e-10;
@@ -1557,4 +1557,4 @@ var qe = { draw: Ve }, Ge = {
 export {
   Ge as diagram
 };
-//# sourceMappingURL=vennDiagram-CIIHVFJN-B27Ya-3D.js.map
+//# sourceMappingURL=vennDiagram-CIIHVFJN-HuWQgr4e.js.map

package/dist/component/{wardleyDiagram-YWT4CUSO-efmvFwPj.js → wardleyDiagram-YWT4CUSO-CeUvdi76.js}

@@ -1,5 +1,5 @@
-import { s as St, g as Mt, t as Nt, q as Tt, a as zt, b as Lt, _ as u, a4 as At, G as Xt, I as U, l as K, N as Et, e as Yt, B as It, c as j } from "./mermaid-GHXKKRXX-DiPCfS1n.js";
-import { p as Bt } from "./chunk-4BX2VUAB-BKmdmdRY.js";
+import { s as St, g as Mt, t as Nt, q as Tt, a as zt, b as Lt, _ as u, a4 as At, G as Xt, I as U, l as K, N as Et, e as Yt, B as It, c as j } from "./mermaid-GHXKKRXX-BEhqkLaB.js";
+import { p as Bt } from "./chunk-4BX2VUAB-4MjzMD47.js";
 import { p as Ft } from "./wardley-L42UT6IY-HA1eSIS_.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
@@ -678,4 +678,4 @@ var Dt = {
 export {
   Qt as diagram
 };
-//# sourceMappingURL=wardleyDiagram-YWT4CUSO-efmvFwPj.js.map
+//# sourceMappingURL=wardleyDiagram-YWT4CUSO-CeUvdi76.js.map

package/dist/component/{xychartDiagram-2RQKCTM6-DNJmorKa.js → xychartDiagram-2RQKCTM6-DNmBGn_r.js}

@@ -1,7 +1,7 @@
-import { s as ei, g as si, t as Lt, q as ni, a as ai, b as oi, _ as a, l as Et, N as ri, e as hi, B as li, G as dt, i as ci, I as It, K as ui, a4 as gi, ap as xi, ac as Rt } from "./mermaid-GHXKKRXX-DiPCfS1n.js";
+import { s as ei, g as si, t as Lt, q as ni, a as ai, b as oi, _ as a, l as Et, N as ri, e as hi, B as li, G as dt, i as ci, I as It, K as ui, a4 as gi, ap as xi, ac as Rt } from "./mermaid-GHXKKRXX-BEhqkLaB.js";
 import { i as di } from "./init-BOu0eQYQ.js";
 import { o as fi } from "./ordinal-D0x7izaa.js";
-import { l as Dt } from "./linear-BcyQd0z0.js";
+import { l as Dt } from "./linear-BVVr39mA.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 function pi(t, i, e) {
@@ -1372,4 +1372,4 @@ var Ti = /* @__PURE__ */ a(function() {
 export {
   Mi as diagram
 };
-//# sourceMappingURL=xychartDiagram-2RQKCTM6-DNJmorKa.js.map
+//# sourceMappingURL=xychartDiagram-2RQKCTM6-DNmBGn_r.js.map

package/dist/components/ui/badge.d.ts

@@ -1,7 +1,7 @@
 import { VariantProps } from 'class-variance-authority';
 import * as React from "react";
 declare const badgeVariants: (props?: ({
-    variant?: "default" | "link" | "destructive" | "outline" | "secondary" | "ghost" | "notice" | null | undefined;
+    variant?: "default" | "link" | "destructive" | "notice" | "outline" | "secondary" | "ghost" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 declare function Badge({ className, variant, asChild, ...props }: React.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
     asChild?: boolean;

package/dist/embed/approval-bus.d.ts

@@ -9,6 +9,11 @@ export type ApprovalCardDecision = "approved" | "rejected" | "amend_requested";
 export type PendingApproval = {
     readonly approvalId: string;
     readonly resolve: (decision: ApprovalCardDecision) => void;
+    /** Why the agent needs this approval, straight off the wire part's own
+     * `reason` field (see `ApprovalRequestData` in belong-data-parts.ts) — a
+     * live call reads this so the operator can tell the user WHAT it is
+     * approving instead of just THAT approval is needed. */
+    readonly reason: string;
 };
 export declare const registerPendingApproval: (entry: PendingApproval) => (() => void);
 export declare const peekPendingApproval: () => PendingApproval | null;

package/dist/embed/slash-commands.d.ts

@@ -1,12 +1,18 @@
 import { CommandSummary, SkillSummary } from '../api/skills.ts';
-/** The group label workspace-tree commands render under in the slash menu. */
+/** Fallback group label for a workspace command the backend could not
+ *  attribute to a plugin (flat project commands). Plugin-attributed commands
+ *  render under their own section instead — see `cmd.group` below. */
 export declare const COMMAND_GROUP = "Commands";
 /**
  * Map a workspace-tree command onto the `SkillSummary` shape the picker
- * renders — display only. At submit time a command token is deliberately NOT
- * matched by {@link parseSlashSubmission} (commands aren't in the skills
- * list), so the draft falls through and posts as RAW text: the worker-side
- * Agent SDK parses the leading-slash message against its command registry.
+ * renders — display only. A command the backend attributed to a discovered
+ * plugin (`cmd.group` set — e.g. "sk-data-lab", "implementation-playbook")
+ * renders under that plugin's own section; a flat command with no plugin
+ * falls back to the generic {@link COMMAND_GROUP}. At submit time a command
+ * token is deliberately NOT matched by {@link parseSlashSubmission} (commands
+ * aren't in the skills list), so the draft falls through and posts as RAW
+ * text: the worker-side Agent SDK parses the leading-slash message against
+ * its command registry.
  */
 export declare const commandOptions: (commands: readonly CommandSummary[]) => readonly SkillSummary[];
 /**
@@ -52,7 +58,10 @@ export declare const parseBuiltinCommand: (draft: string) => BuiltinCommand | nu
 /**
  * The slash menu's option list: built-ins merged ahead of the skills, ranked
  * by {@link filterSkills} (prefix matches first; input order — built-ins
- * before skills — breaks ties within each bucket).
+ * before skills — breaks ties within each bucket), then bucketed into
+ * contiguous per-group sections by {@link bucketByGroup} — see that
+ * function's comment for why grouping is a required SECOND pass over the
+ * ranked list, not something ranking alone gives you for free.
  *
  * Built-ins are offered for a token at ANY position (BEL-167). They used to be
  * withheld from a mid-message token because {@link parseBuiltinCommand} could
@@ -123,5 +132,13 @@ export declare const hoistCommandSubmission: (draft: string, commands: readonly
  * The argument-taking builtins ROTATE rather than splice — see below.
  */
 export declare const hoistBuiltinCommand: (draft: string) => string;
-/** Name-prefix matches first, then other name/description substring matches. */
+/**
+ * Name-prefix matches first, then other name/description substring matches,
+ * then GROUP word-prefix matches (plugin-section search, ≥3 chars — see
+ * {@link GROUP_MATCH_MIN_QUERY_LENGTH}): typing "impl", "data", or a plugin's
+ * name (e.g. "sk-data-lab") surfaces every entry in that section even when
+ * the query hits neither the name nor the description. Ranked last so an
+ * entry actually named after the query still takes the top slot — a query
+ * that happens to also be a group name doesn't bump a direct name match down.
+ */
 export declare const filterSkills: (skills: readonly SkillSummary[], query: string) => readonly SkillSummary[];

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

@@ -0,0 +1,106 @@
+/**
+ * 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;

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

@@ -0,0 +1,110 @@
+/**
+ * The voice call's agent ROSTER — the browser-side twin of the tenant
+ * roster minted server-side (`buildCallRoster` in
+ * apps/belong-cloud/src/features/voice/call-roster.ts) and threaded through
+ * `POST /v1/voice/call-token`'s `agents` field (`callAgentSpecSchema`,
+ * voice.schemas.ts). This is what lets the dock's rail, the call screen's
+ * agent board, and every spoken announcement address an agent by ROLE
+ * ("cli", "consulting") instead of a bare line number — and do so from the
+ * moment the dock boots, before any call has ever been started: the rail
+ * renders dock-wide with no call active, so it needs the LAST-KNOWN roster,
+ * not only one handed to it live off a fresh mint.
+ *
+ * Persisted per workspace, exactly like `line-slots.ts` beside it
+ * (`belong:voice-call-roster`, suffixed `:ws:<id>` when a workspace is in
+ * effect via `peekWorkspaceId()`) — a host workspace switch must not hand
+ * tenant A's roster (its titles, its CLI agent) to a rail rendering for
+ * tenant B.
+ *
+ * localStorage is a perimeter: the persisted roster is zod-validated on read
+ * and any junk (corrupted JSON, wrong shape, storage disabled) degrades to
+ * an EMPTY roster — same as "no call minted yet". The schema below is a
+ * deliberately independent, by-hand copy of the server's
+ * `callAgentSpecSchema`: the two packages ship separately and share no type
+ * module, so this is what keeps them honest (mirrors the existing
+ * `CallAgentSpec`/`callAgentSpecSchema` split already living server-side in
+ * `call-roster.ts` / `voice.schemas.ts`).
+ *
+ * Two fallback rules, and they are NOT the same rule:
+ *
+ *   - `lineForRole` / `roleForLine` on an EMPTY roster (nothing ever minted,
+ *     or a mint whose body failed to parse) fall back to the POSITIONAL
+ *     default that's been true since roles didn't exist: main=1, cli=2,
+ *     consulting=3. This is what stops a parse failure from bricking role
+ *     addressing mid-call — the switchboard still answers to
+ *     main/cli/consulting by position.
+ *   - On a NON-empty roster that simply doesn't have that role/line (a
+ *     tenant with no CLI), the same lookups return `null` instead — the
+ *     honest signal that THIS workspace has no such agent, which is what
+ *     later produces an `unknown_role` tool response rather than silently
+ *     addressing the wrong agent.
+ *
+ * `titleForRole` / `titleForLine` never return `null` — a title is always
+ * needed for display/announcement, so THEIR fallback is a string, applied
+ * uniformly regardless of whether the roster is empty or merely missing
+ * that entry. The two fallbacks are deliberately DIFFERENT shapes, not the
+ * same rule twice:
+ *
+ *   - `titleForRole` falls back to a ROLE-derived phrase ("the main agent" /
+ *     "the CLI agent" / "the analyst") — never a switchboard
+ *     number. Every voice tool call carries a role (it is the operator's
+ *     entire addressing vocabulary — see `voice-call.ts`'s
+ *     `resolveRoleLine`), so this fallback is always reachable from a role
+ *     the model already said out loud, and it feeds prose the model
+ *     SPEAKS: an empty roster (nothing minted yet, or a pre-roster backend
+ *     mid rolling deploy — `callTokenResponseSchema`'s `agents` field
+ *     legitimately defaults to `[]`) must not leak a bare "Agent 2" into
+ *     that prose.
+ *   - `titleForLine` falls back to `"the main agent"` for line 1 and
+ *     `` `Agent ${line}` `` otherwise — the "Agent N" convention the
+ *     switchboard used before roles existed. This one serves the UI's
+ *     numbered rail, which genuinely displays a switchboard slot number, so
+ *     a line-derived fallback is correct there and stays as-is.
+ */
+export type CallAgentRole = "main" | "cli" | "consulting";
+export type CallAgentSpec = {
+    readonly role: CallAgentRole;
+    /** The durable switchboard line underneath (`line-slots.ts`). */
+    readonly line: number;
+    /** What the voice calls this agent out loud. */
+    readonly title: string;
+    /** One sentence describing what this agent is for. */
+    readonly purpose: string;
+};
+/** Persist the roster minted for the current call. A whole-roster replace —
+ * never a per-entry patch — of whatever this workspace held before. */
+export declare const setCallRoster: (roster: readonly CallAgentSpec[]) => void;
+/** The current workspace's roster, or an empty array when nothing has been
+ * minted yet (or storage held junk). */
+export declare const peekCallRoster: () => readonly CallAgentSpec[];
+/** Persist the tenant's product name minted alongside the roster (U2) — a
+ * whole-value replace, same discipline as `setCallRoster`. */
+export declare const setProductName: (productName: string | null) => void;
+/** The current workspace's product name, or `null` when nothing has been
+ * minted yet, the tenant has none, or storage held junk. Used ONLY to
+ * localize the SDK's own UI copy (CallScreen's agent board, U2) — never fed
+ * into any string the model speaks or receives. */
+export declare const peekProductName: () => string | null;
+/** Resolve a role to its switchboard line. See the module doc: `null` only
+ * ever means "this NON-empty roster doesn't have that role" — an EMPTY
+ * roster falls back to the positional default instead. */
+export declare const lineForRole: (role: CallAgentRole) => number | null;
+/** Resolve a switchboard line to its role — the inverse of `lineForRole`,
+ * with the same two-rule fallback (EMPTY roster → positional; non-empty and
+ * missing → `null`). */
+export declare const roleForLine: (line: number) => CallAgentRole | null;
+/** What the voice calls this role out loud. Always a string — falls back to
+ * a ROLE-derived title (never a switchboard number, never `null`) when the
+ * roster has no entry for this role, whether the roster is empty or just
+ * missing it. */
+export declare const titleForRole: (role: CallAgentRole) => string;
+/** What the voice calls this line out loud. Always a string — falls back to
+ * `"the main agent"` (line 1) or `` `Agent ${line}` `` otherwise when the
+ * roster has no entry for this line, whether the roster is empty or just
+ * missing it. */
+export declare const titleForLine: (line: number) => string;
+/** Test-only: drop the persisted roster AND product name for the current
+ * workspace scope — they are minted together (the same call-token mint), so
+ * a test resetting one without the other would leak a stale product name
+ * (or roster) into the next case. */
+export declare const __clearCallRosterForTest: () => void;

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

@@ -16,8 +16,12 @@
  * Workspace isolation (§28): a background line opened while the host is inside
  * 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, so the
- * sessions list names the background conversation.
+ * 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.
  *
  * 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

package/dist/embed/voice/line-run-reader.d.ts

@@ -2,7 +2,9 @@ import { RunStatusKind } from '../../stream/belong-data-parts.ts';
 export type WatchLineRunInput = {
     readonly runId: string;
     readonly onPhase: (toolName: string) => void;
-    readonly onApprovalNeeded: () => void;
+    /** `reason` is the wire part's own `data.reason` — "" when the part omitted
+     * it (never `undefined`; the caller decides the fallback wording). */
+    readonly onApprovalNeeded: (reason: string) => void;
     readonly onNavigate: (data: {
         readonly routeName: string;
         readonly params: Readonly<Record<string, string>>;

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

@@ -158,6 +158,26 @@ 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

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

@@ -8,9 +8,10 @@
  *
  * Agent-initiated utterances (function acks, result relays, progress nudges,
  * the greeting) are paced from AUDIO PLAYOUT END, not generation end: the next
- * one may only dispatch once both generation (`responseActive`) and playback
- * (`audioPlaying`) are idle, plus a breath (`UTTERANCE_GAP_MS`). User turns go
- * through server VAD directly and never touch this logic.
+ * one may only dispatch once generation (`responseActive`), playback
+ * (`audioPlaying`), and the USER FLOOR (`userFloor` — the user is speaking, or
+ * only just stopped) are all idle, plus a breath (`UTTERANCE_GAP_MS`). User
+ * turns go through server VAD directly and never touch this logic.
  */
 /**
  * Breath between agent-initiated utterances, measured from AUDIO PLAYOUT END
@@ -29,13 +30,45 @@ export declare const UTTERANCE_GAP_MS = 700;
  */
 export declare const AUDIO_IDLE_SAFETY_MS = 30000;
 /**
- * Hold a follow-up `response.create` while a response is still generating OR
- * its audio is still playing out. Both must be idle before the pause timer may
- * run and the create may be sent.
+ * How long the user keeps the floor after `input_audio_buffer.speech_stopped`
+ * before an agent-initiated utterance may be released. Covers the case
+ * semantic VAD is deliberately patient about: a breath drawn mid-sentence,
+ * where the user has not actually finished. At 600ms (plus
+ * {@link UTTERANCE_GAP_MS}'s 700ms breath), an agent-initiated relay could
+ * start barely 1.3s after the user stopped — while semantic VAD is still
+ * deciding whether they are actually done. 1200ms buys the classifier more
+ * room before an agent-initiated utterance is allowed to land. This ONLY
+ * delays agent-*initiated* speech (progress nudges, result relays); the
+ * model's own response to the user's turn is untouched — that path never
+ * goes through this floor.
+ */
+export declare const USER_FLOOR_GRACE_MS = 1200;
+/**
+ * Ceiling on how long the user floor may hold an utterance, measured from the
+ * moment the floor was TAKEN (`speech_started`). This is an ANTI-WEDGE
+ * fallback, not a tuning knob: {@link USER_FLOOR_GRACE_MS}'s grace timer
+ * already releases the floor shortly after every `speech_stopped`, so in
+ * ordinary speech the floor never survives to see this ceiling at all. Its
+ * only job is the case grace can't cover — a `speech_stopped` that never
+ * arrives (a genuinely stuck VAD) — which is why it must stay far above any
+ * real utterance: a tight ceiling here doesn't add safety, it just yanks the
+ * floor out from under a user who is still mid-sentence and dispatches a
+ * held relay over their voice, which is the exact bug this feature exists to
+ * prevent. Set at 45s — well above semantic VAD's own ceiling (8s at `low`
+ * eagerness, 4s at `medium`) — so it is reachable only when something has
+ * actually gone wrong, never in the course of normal speech. Same discipline
+ * as {@link AUDIO_IDLE_SAFETY_MS} — the pacer must never wedge.
+ */
+export declare const USER_FLOOR_MAX_HOLD_MS = 45000;
+/**
+ * Hold a follow-up `response.create` while a response is still generating, its
+ * audio is still playing out, OR the user holds the floor. All three must be
+ * clear before the pause timer may run and the create may be sent.
  */
 export declare const shouldHoldDispatch: (input: {
     readonly responseActive: boolean;
     readonly audioPlaying: boolean;
+    readonly userFloor: boolean;
 }) => boolean;
 /**
  * On `response.done`, decide whether to release a queued follow-up immediately.
@@ -63,10 +96,15 @@ export type UtterancePacer = {
     /** Audio playout ended (`output_audio_buffer.stopped`) — the anchor the next
      * agent-initiated breath is measured from. */
     readonly onAudioStopped: () => void;
-    /** The user took the floor (`input_audio_buffer.speech_started`). Clears the
-     * playout gate and timers; a follow-up already counting down its breath is
-     * DEFERRED behind the user's turn (re-queued as pending), never dropped. */
+    /** The user took the floor (`input_audio_buffer.speech_started`). TAKES the
+     * user floor (arming the max-hold ceiling) and clears the playout gate and
+     * timers; a follow-up already counting down its breath is DEFERRED behind
+     * the user's turn (re-queued as pending), never dropped. */
     readonly onBargeIn: () => void;
+    /** The user stopped talking (`input_audio_buffer.speech_stopped`). Starts
+     * the grace countdown; the floor is not released until it expires (or the
+     * model takes the turn, or the max-hold ceiling trips). */
+    readonly onUserSpeechStopped: () => void;
     /** Call teardown: clear all flags and timers so nothing leaks forward. */
     readonly reset: () => void;
 };