@burdenoff/fe-libs 2026.903.2 → 2026.903.3

package/dist/shared/assistant/index.d.ts

@@ -16,4 +16,7 @@ export { isVoiceTurn, voiceSessionIdOf, voiceMarker, chatTurns, voiceTurnsOnly,
 export type { VoiceSessionGroup, VoiceTranscriptTurn } from './voice/turnVisibility';
 export { useVoiceInput } from './voice/useVoiceInput';
 export type { UseVoiceInputOptions, UseVoiceInputResult, VoiceInputError } from './voice/useVoiceInput';
+export { toCaptionText } from './voice/captionText';
+export { parseConfirmationRefusal, findPendingWrite } from './pendingWrite';
+export type { PendingWrite, PendingWriteValue } from './pendingWrite';
 //# sourceMappingURL=index.d.ts.map

package/dist/shared/assistant/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,QAAQ,EACR,aAAa,EACb,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAKpB,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,qBAAqB,EACrB,4BAA4B,EAC5B,sBAAsB,EACtB,mBAAmB,EACnB,wBAAwB,EACxB,oBAAoB,EACpB,wBAAwB,EACxB,yBAAyB,EACzB,aAAa,EACb,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,OAAO,CAAC;AAEf,YAAY,EACV,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,sBAAsB,EACtB,yBAAyB,EACzB,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,2BAA2B,EAC3B,YAAY,GACb,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,WAAW,EACX,SAAS,EACT,cAAc,EACd,cAAc,EACd,yBAAyB,GAC1B,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,YAAY,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,QAAQ,EACR,aAAa,EACb,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAKpB,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,qBAAqB,EACrB,4BAA4B,EAC5B,sBAAsB,EACtB,mBAAmB,EACnB,wBAAwB,EACxB,oBAAoB,EACpB,wBAAwB,EACxB,yBAAyB,EACzB,aAAa,EACb,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,OAAO,CAAC;AAEf,YAAY,EACV,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,sBAAsB,EACtB,yBAAyB,EACzB,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,2BAA2B,EAC3B,YAAY,GACb,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,WAAW,EACX,SAAS,EACT,cAAc,EACd,cAAc,EACd,yBAAyB,GAC1B,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,YAAY,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxG,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC5E,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/shared/assistant/pendingWrite.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The write the assistant is asking permission for — read from the request
+ * itself, not from the model's description of it.
+ *
+ * ★ WHY THIS EXISTS. In "Take action" mode the in-sandbox helper refuses every
+ * mutation on its first attempt and returns a `CONFIRMATION_REQUIRED` tool
+ * result naming the operation and the exact values it was about to send. The
+ * model is then instructed to describe that change in prose and ask the user.
+ *
+ * So today the user approves a PARAGRAPH. The paragraph is generated by the same
+ * model that wants the write to go through, and nothing checks it against the
+ * payload — a field can be omitted, rounded, or described as something milder
+ * than it is, and the approval still counts.
+ *
+ * The refusal itself is already in the message parts the panel receives, and the
+ * panel throws it away (`getToolProgress` reduces a tool part to
+ * "Completed: <tool>"). Reading it back means the confirmation card can show the
+ * operation and values that will actually be sent.
+ *
+ * ★ WHAT THIS IS NOT. It does not make the UI the authorization boundary. The
+ * approval still travels back through the model, which holds the single-use
+ * token and could in principle retry without asking — see the module docstring
+ * in `ai-assistant/src/write-confirmation.ts`, which names the remaining gap and
+ * the fix ("the UI holding the approval"). This narrows what the user can be
+ * misled about; it does not close that.
+ */
+export interface PendingWriteValue {
+    key: string;
+    /** Already stringified for display; objects and arrays are JSON. */
+    value: string;
+}
+export interface PendingWrite {
+    /** GraphQL operation name, e.g. `createCrop`. */
+    operation: string;
+    /**
+     * The variables, flattened for display. `null` when the refusal reported no
+     * variables or the block could not be parsed — the card then falls back to
+     * naming the operation alone rather than implying there is nothing to send.
+     */
+    values: PendingWriteValue[] | null;
+}
+/**
+ * A tool part as the transport delivers it. Deliberately loose: `state.output`
+ * is typed `unknown` upstream and different agent versions have wrapped the text
+ * differently, so this accepts anything and proves the shape at runtime.
+ */
+interface ToolPartLike {
+    type?: string;
+    state?: {
+        output?: unknown;
+        [key: string]: unknown;
+    } | undefined;
+}
+/**
+ * Parse one refusal.
+ *
+ * ★ The single-use token is deliberately NOT extracted. It is a capability: the
+ * write goes through if it is echoed back, so putting it on screen would invite
+ * a user — or anything reading the page — to replay it, and would turn a
+ * confirmation card into a bypass. The card needs the operation and the values;
+ * it never needs the token.
+ */
+export declare function parseConfirmationRefusal(text: string): PendingWrite | null;
+/**
+ * The pending write in a set of message parts, if the agent refused one.
+ *
+ * Takes the LAST match: within a turn the model may be told to stop after the
+ * first refusal, but a turn that somehow produced two is asking about the most
+ * recent one.
+ */
+export declare function findPendingWrite(parts: readonly ToolPartLike[] | undefined): PendingWrite | null;
+export {};
+//# sourceMappingURL=pendingWrite.d.ts.map

package/dist/shared/assistant/pendingWrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pendingWrite.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/pendingWrite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,MAAM,EAAE,iBAAiB,EAAE,GAAG,IAAI,CAAC;CACpC;AAOD;;;;GAIG;AACH,UAAU,YAAY;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;CAClE;AA+BD;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAsD1E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,SAAS,GAAG,YAAY,GAAG,IAAI,CAWhG"}

package/dist/shared/assistant/pendingWrite.js

@@ -0,0 +1,85 @@
+//#region src/shared/assistant/pendingWrite.ts
+var e = "CONFIRMATION_REQUIRED", t = /CONFIRMATION_REQUIRED: the write "([^"]+)" was NOT sent/, n = "Values you were about to send:";
+function r(e) {
+	if (typeof e == "string") return e;
+	if (e && typeof e == "object" && "output" in e) {
+		let t = e.output;
+		if (typeof t == "string") return t;
+	}
+	return null;
+}
+function i(e) {
+	if (!e || typeof e != "object" || Array.isArray(e)) return null;
+	let t = Object.entries(e);
+	return t.length === 0 ? null : t.map(([e, t]) => ({
+		key: e,
+		value: typeof t == "string" ? t : t == null ? "—" : JSON.stringify(t)
+	}));
+}
+function a(r) {
+	if (!r.includes(e)) return null;
+	let a = t.exec(r)?.[1]?.trim();
+	if (!a) return null;
+	let o = r.indexOf(n);
+	if (o === -1) return {
+		operation: a,
+		values: null
+	};
+	let s = r.slice(o + 30).trim();
+	if (!s || s.startsWith("(no variables)")) return {
+		operation: a,
+		values: null
+	};
+	let c = s.indexOf("{");
+	if (c === -1) return {
+		operation: a,
+		values: null
+	};
+	let l = 0, u = -1, d = !1, f = !1;
+	for (let e = c; e < s.length; e += 1) {
+		let t = s[e];
+		if (f) {
+			f = !1;
+			continue;
+		}
+		if (t === "\\" && d) {
+			f = !0;
+			continue;
+		}
+		if (t === "\"") d = !d;
+		else if (!d && t === "{") l += 1;
+		else if (!d && t === "}" && (--l, l === 0)) {
+			u = e + 1;
+			break;
+		}
+	}
+	if (u === -1) return {
+		operation: a,
+		values: null
+	};
+	try {
+		return {
+			operation: a,
+			values: i(JSON.parse(s.slice(c, u)))
+		};
+	} catch {
+		return {
+			operation: a,
+			values: null
+		};
+	}
+}
+function o(e) {
+	if (!e) return null;
+	let t = null;
+	for (let n of e) {
+		if (n?.type !== "tool") continue;
+		let e = r(n.state?.output);
+		if (!e) continue;
+		let i = a(e);
+		i && (t = i);
+	}
+	return t;
+}
+//#endregion
+export { o as findPendingWrite, a as parseConfirmationRefusal };

package/dist/shared/assistant/voice/captionText.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Markdown → the words, for a caption someone READS.
+ *
+ * The live voice caption is the one surface where the model's raw Markdown was
+ * printed literally: bold stars, hash headings, table pipes, fence backticks.
+ * The audio path has been clean for a while (`toSpeakableText`), but that
+ * function is the wrong tool here and reusing it would be worse than the bug.
+ *
+ * ★ `toSpeakableText` is a SCRIPT FOR A VOICE, not a Markdown cleaner. It
+ * replaces a table with "Table with 40 rows and 2 columns", a fenced block with
+ * "Code block", a link with the word "link", and rewrites `x@y.com` as "x at y
+ * dot com" — sensible in an earpiece, destructive on a screen where the reader
+ * can simply read the thing. Worse, those replacements come from an English
+ * default list only localised inside the speech provider, so reusing it would
+ * print English chrome inside a Tamil or Hindi caption: the exact
+ * mixed-language defect that code exists to prevent.
+ *
+ * So this strips MARKERS and keeps CONTENT. Every cell value, all code text,
+ * bare URLs, email addresses, emoji and punctuation survive verbatim. Nothing
+ * is summarised, truncated or annotated: a caption that quietly drops the
+ * user's numbers is a worse failure than one showing a stray asterisk. Where
+ * this function is unsure, it leaves the text ALONE.
+ *
+ * ★ Newlines are PRESERVED, which only helps where the element renders them.
+ * `VoiceCaption` carries `whitespace-pre-wrap` for exactly that. The mini
+ * controller deliberately does NOT: it is `line-clamp-3`, and real newlines
+ * each burn one of the three lines — measured at the strip's true width, that
+ * cut a 116-character reply to 41 visible characters. Markers still go; the
+ * breaks are allowed to collapse on the clamped surface.
+ *
+ * ★ NO LOOKBEHIND ANYWHERE IN CODE. Safari < 16.4 throws on that assertion
+ * class at PARSE time, not match time — one literal takes down the whole chunk
+ * on those devices, and this ships to phones. Lookahead is fine; where a
+ * leading boundary is needed it is CAPTURED and put back. Same rule as
+ * `speakableText.ts`, and `captionText.test.ts` asserts it on the source.
+ */
+/**
+ * Strip Markdown markers for display, keeping all of the content.
+ *
+ * Safe on plain text: a reply with no Markdown comes back unchanged.
+ */
+export declare function toCaptionText(markdown: string): string;
+//# sourceMappingURL=captionText.d.ts.map

package/dist/shared/assistant/voice/captionText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captionText.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/voice/captionText.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAkKH;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CA2CtD"}

package/dist/shared/assistant/voice/captionText.js

@@ -0,0 +1,49 @@
+//#region src/shared/assistant/voice/captionText.ts
+var e = "", t = "\\uE000", n = /^[\s:|-]*$/, r = /^\s*([-*_])\s*(?:\1\s*){2,}$/, i = /^\s*=+\s*$/;
+function a(e) {
+	return e.includes("|") && e.includes("-") && n.test(e);
+}
+function o(e) {
+	let t = /* @__PURE__ */ new Set();
+	return e.forEach((n, r) => {
+		if (!a(n)) return;
+		let i = e[r - 1];
+		r > 0 && i !== void 0 && i.includes("|") && t.add(r - 1);
+		for (let n = r + 1; n < e.length; n += 1) {
+			let r = e[n];
+			if (r === void 0 || r.trim() === "" || !r.includes("|")) break;
+			t.add(n);
+		}
+	}), t;
+}
+function s(n, r) {
+	let i = (t) => (r.push(t), `${e}${r.length - 1}${e}`);
+	return n.replace(/^ {0,3}```[^\n]*\n([\s\S]*?)^ {0,3}```[^\n]*$/gm, (e, t) => i(t.replace(/\n$/, ""))).replace(/^ {0,3}```[^\n]*\n?([\s\S]*)$/m, (e, t) => i(t)).replace(/`([^`\n]+)`/g, (e, t) => i(t)).replace(RegExp(`<((?:https?://|mailto:)[^>\\s${t}]+)>`, "gi"), (e, t) => i(t)).replace(RegExp(`<([^@<>\\s${t}]+@[^@<>\\s${t}]+\\.[^@<>\\s${t}]+)>`, "g"), (e, t) => i(t)).replace(RegExp(`\\b(?:https?://|www\\.)[^\\s<>()\\[\\]${t}]+`, "gi"), (e) => i(e)).replace(/\b[\w.+-]{1,64}@[\w-]{1,63}\.[\w.-]{1,63}\b/g, (e) => i(e));
+}
+function c(t, n) {
+	let r = RegExp(`${e}(\\d+)${e}`, "g"), i = t;
+	for (let e = 0; e <= n.length; e += 1) {
+		let e = i.replace(r, (e, t) => n[Number(t)] ?? "");
+		if (e === i) break;
+		i = e;
+	}
+	return i;
+}
+function l(e) {
+	return e.replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]*)\]\[[^\]]*\]/g, "$1").replace(/(^|[^\w~])~~(\S(?:[^\n]*?\S)?)~~(?=[^\w~]|$)/g, "$1$2").replace(/(^|[^\w*])\*\*(\S(?:[^\n]*?\S)?)\*\*(?=[^\w*]|$)/g, "$1$2").replace(/(^|[^\p{L}\p{N}_])__(\S(?:[^\n]*?\S)?)__(?=[^\p{L}\p{N}_]|$)/gu, "$1$2").replace(/(^|[^\w*])\*(\S(?:[^*\n]*\S)?)\*(?=[^\w*]|$)/g, "$1$2").replace(/(^|[^\p{L}\p{N}_])_(\S(?:[^_\n]*\S)?)_(?=[^\p{L}\p{N}_]|$)/gu, "$1$2");
+}
+function u(e) {
+	return e.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((e) => e.trim()).join(" · ");
+}
+function d(t) {
+	if (!t) return "";
+	let n = [], d = s(t.replace(/\r\n/g, "\n").replace(new RegExp(e, "g"), ""), n).split("\n"), f = o(d), p = [];
+	return d.forEach((e, t) => {
+		if (a(e) || r.test(e) || i.test(e) && (p[p.length - 1] ?? "").trim() !== "") return;
+		let n = e;
+		for (; /^\s*>\s?/.test(n);) n = n.replace(/^\s*>\s?/, "");
+		n = n.replace(/^\s*#{1,6}\s+/, ""), n = n.replace(/^(\s*)[-*+]\s+/, "$1"), n = n.replace(/^(\s*)\d{1,2}[.)]\s+/, "$1"), f.has(t) && (n = u(n)), p.push(l(n).replace(/\s+$/, ""));
+	}), c(p.join("\n").replace(/\n{3,}/g, "\n\n").trim(), n);
+}
+//#endregion
+export { d as toCaptionText };

package/dist/shared/assistant/voice/speechVoices.d.ts

@@ -0,0 +1,142 @@
+import { Locale } from '../../providers/shell/I18nProvider';
+/**
+ * BCP-47 tag we ask the engine for, per app locale.
+ *
+ * Deliberately identical to `useVoiceInput`'s RECOGNITION_LANG: regional choices
+ * follow where HealthyBowl actually operates (India for ta/hi), because a voice's
+ * pronunciation model is region-specific. Typed `Record<Locale, …>` so adding a
+ * locale to fe-libs fails the build here rather than silently falling back to
+ * English.
+ */
+export declare const SPEECH_LANG: Record<Locale, string>;
+/**
+ * The subset of `SpeechSynthesisVoice` this module needs. Structural on purpose:
+ * `selectVoiceForLocale` returns the caller's own array element, so the browser
+ * engine gets back the real `SpeechSynthesisVoice` instance it must assign to
+ * `utterance.voice`, while tests pass literals.
+ */
+export interface SpeechVoiceLike {
+    readonly name: string;
+    readonly lang: string;
+    /** The engine's default voice (usually the OS UI language). */
+    readonly default?: boolean;
+    /** On-device rather than server-side — no network, no latency, no vendor. */
+    readonly localService?: boolean;
+}
+/** `en_GB`, `EN-gb` and `en-GB` are the same tag as far as matching goes. */
+export declare function normalizeLangTag(tag: string): string;
+/** `ta-IN` → `ta`. The part that decides whether a voice is intelligible at all. */
+export declare function primaryLanguageSubtag(tag: string): string;
+export declare function speechLangForLocale(locale: string): string;
+/**
+ * Pick the best installed voice for an app locale, or `null` when the device has
+ * no voice for that language at all.
+ *
+ * The ladder, in order:
+ *   1. exact tag (`ta-IN` for Tamil);
+ *   2. same language, any region (`en-GB` when only `en-US` was asked for) —
+ *      an accent is a far smaller problem than the wrong language;
+ *   3. within whichever tier matched: the engine's default voice, then an
+ *      on-device voice, then engine order.
+ *
+ * There is intentionally NO cross-language fallback. Reading a Tamil reply with
+ * an English voice produces confident nonsense; the caller disables the control
+ * and says why instead (see `AssistantSpeechProvider`).
+ */
+/**
+ * Every installed voice that can read this language, best first.
+ *
+ * Exposed so the UI can offer a CHOICE. Quality varies enormously between
+ * voices for the same language — Apple's "Enhanced"/"Premium" downloads and
+ * Chrome's network "Google …" voices are markedly better than the compact
+ * on-device defaults — and none of that is machine-readable, so the honest
+ * answer is to rank by the weak signals available and let the listener decide.
+ */
+export declare function voicesForLocale<T extends SpeechVoiceLike>(voices: readonly T[], locale: string): T[];
+/**
+ * Best-effort quality ordering. Higher is better.
+ *
+ * Every signal here is a heuristic on a NAME, which is fragile and locale-
+ * dependent — hence the voice picker: this decides the DEFAULT, not the answer.
+ *
+ * Deliberately NOT preferring `localService`. That is an offline-capability
+ * flag, not a quality one, and on desktop Chrome it actively selects the
+ * compact on-device voice over the better-sounding network one. The previous
+ * ladder preferred it and was therefore choosing the worse voice.
+ */
+export declare function voiceQualityRank(voice: SpeechVoiceLike): number;
+/**
+ * The voice to read this language with: the user's explicit pick if it is still
+ * installed, otherwise the best-ranked one.
+ *
+ * `preferredName` is matched by name because that is the only identifier stable
+ * across sessions — voice objects are recreated on every page load, and
+ * `voiceURI` is not reliably unique across platforms.
+ */
+export declare function selectVoiceForLocale<T extends SpeechVoiceLike>(voices: readonly T[], locale: string, preferredName?: string | null): T | null;
+/**
+ * What the UI should do with the speak control, given what the engine reports.
+ *
+ * `pending` matters: `speechSynthesis.getVoices()` famously returns `[]` on the
+ * first call in Chrome and only fills in after `voiceschanged`. Treating an
+ * empty list as "no voice" would disable the button for a moment on every load
+ * and, on engines that never fire the event, forever — so an empty list stays
+ * enabled and we let the engine resolve `utterance.lang` itself.
+ */
+export type VoiceAvailability = 'unsupported' | 'pending' | 'ready' | 'missing-voice' | 'no-voices';
+/**
+ * `probeSettled` is what separates "the list has not arrived yet" from "this
+ * device genuinely has none".
+ *
+ * Both look like `voices.length === 0`, and the difference is not knowable from
+ * the list alone — only the caller, having waited out `VOICE_LIST_TIMEOUT_MS`
+ * and looked again, can tell them apart. Defaulting to `false` keeps the
+ * optimistic reading (`pending`, control stays enabled) for every caller that
+ * has not probed, which is the pre-existing behaviour.
+ *
+ * Without this distinction the empty list stays `pending` forever, `speechGate`
+ * keeps answering `wait-for-voices`, and the button is enabled but does nothing
+ * on every press — a dead control with no explanation, which is exactly how
+ * this feature looked on any Linux box or bare container.
+ */
+export declare function voiceAvailability(isSupported: boolean, voices: readonly SpeechVoiceLike[], locale: string, probeSettled?: boolean): VoiceAvailability;
+/**
+ * Human name for the language we would have spoken, in the reader's own locale
+ * ("Tamil" for an English UI, "தமிழ்" for a Tamil one).
+ *
+ * Used to make the disabled reason actionable: "No Tamil voice is installed"
+ * tells a user what to go and install; "no voice is installed" does not.
+ * `Intl.DisplayNames` is unavailable in some embedded webviews, so the subtag
+ * itself is the fallback — degraded copy beats a thrown render.
+ */
+export declare function languageDisplayName(languageTag: string, inLocale: string): string;
+/**
+ * What a caller that wants to speak RIGHT NOW should do.
+ *
+ * The one decision every playback path has to make, in one place, because
+ * having it in three (the per-message button, the header toggle, the auto-speak
+ * subscription) is how "there is no cross-language fallback" stopped being true
+ * on two of them: an empty or unmatched voice list means the engine picks its
+ * own default, and a Tamil reply comes out in an English voice.
+ *
+ *  - `speak` — a voice for this language exists; go.
+ *  - `wait-for-voices` — the list has not arrived yet (Chrome's first
+ *    `getVoices()` returns `[]`). Speaking now would gamble on the engine
+ *    default, and refusing forever would disable the control on engines that
+ *    never fire `voiceschanged`; so the caller waits for the list, briefly, and
+ *    asks again. The control stays enabled throughout.
+ *  - `block` — unsupported, or no voice for this language. Say nothing.
+ */
+export type SpeechGate = 'speak' | 'wait-for-voices' | 'block';
+export declare function speechGate(availability: VoiceAvailability): SpeechGate;
+/**
+ * Should the control be visible but inert?
+ *
+ * `pending` deliberately is NOT disabled — see `speechGate`. `no-voices` is,
+ * because by then we have waited and looked again: staying enabled would leave
+ * the user pressing a button that can never do anything.
+ */
+export declare function isSpeechBlocked(availability: VoiceAvailability): boolean;
+/** How long to wait for a late voice list before giving up on one attempt. */
+export declare const VOICE_LIST_TIMEOUT_MS = 2000;
+//# sourceMappingURL=speechVoices.d.ts.map

package/dist/shared/assistant/voice/speechVoices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"speechVoices.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/voice/speechVoices.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oCAAoC,CAAC;AAEjE;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAU9C,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,oFAAoF;AACpF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;;;;;;;;;;;;GAcG;AACH;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,eAAe,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,EAAE,CAYpG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAa/D;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,eAAe,EAC5D,MAAM,EAAE,SAAS,CAAC,EAAE,EACpB,MAAM,EAAE,MAAM,EACd,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,GAC5B,CAAC,GAAG,IAAI,CAQV;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG,SAAS,GAAG,OAAO,GAAG,eAAe,GAAG,WAAW,CAAC;AAEpG;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,OAAO,EACpB,MAAM,EAAE,SAAS,eAAe,EAAE,EAClC,MAAM,EAAE,MAAM,EACd,YAAY,UAAQ,GACnB,iBAAiB,CAInB;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAQjF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,iBAAiB,GAAG,OAAO,CAAC;AAE/D,wBAAgB,UAAU,CAAC,YAAY,EAAE,iBAAiB,GAAG,UAAU,CAItE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,iBAAiB,GAAG,OAAO,CAExE;AAED,8EAA8E;AAC9E,eAAO,MAAM,qBAAqB,OAAQ,CAAC"}

package/dist/shared/assistant/voice/voiceSession.d.ts

@@ -0,0 +1,184 @@
+/**
+ * The voice-conversation state machine (BOFF-7120).
+ *
+ * A live voice session is a loop — listen, submit, wait, speak, listen again —
+ * and every interesting decision in it is about TIMING and INTERRUPTION rather
+ * than about rendering. Those decisions live here, with no DOM, no audio and no
+ * React, for the same reason `browserSpeechEngine` pushed its logic into
+ * `speakableText`/`speechVoices`: this repo's vitest runs in the `node`
+ * environment, so anything touching `window` cannot be tested at all.
+ *
+ * ★ **The microphone is CLOSED while the assistant speaks.** It was open, so
+ * that talking over the assistant could interrupt it, guarded by matching the
+ * transcript against the text being spoken. That guard was too weak to survive
+ * contact with reality: speech recognition of synthesised speech mis-hears it
+ * ("sow ragi" -> "so ragi"), so exact containment fails, the mis-heard echo is
+ * accepted as a new question, submitted, answered, spoken — and round it goes.
+ * The operator hit this loop on a real device.
+ *
+ * Browsers do not give the Web Speech API the acoustic echo cancellation that a
+ * native duplex app has, so there is no text-level fix for this. Interruption is
+ * now an explicit tap instead, which is reliable, and the echo check survives
+ * only as a guard on the moments just after playback stops.
+ *
+ * ★ **Mute is NOT a phase.** It is a property of the microphone, orthogonal to
+ * where the conversation is. Modelling it as a state meant muting while the
+ * assistant was thinking discarded the `thinking` phase, so the reply — already
+ * in flight — was then ignored, and unmuting landed in `listening` with nothing
+ * pending and nothing coming. The session dead-ended and the user's question was
+ * silently lost.
+ *
+ * What this deliberately does NOT model: the assistant is turn-based
+ * (speech -> text -> LLM -> text -> speech), so `thinking` is a real, visible
+ * phase lasting seconds. A native speech-to-speech API would collapse
+ * listening/thinking/speaking into one duplex stream; we are not that, and
+ * pretending otherwise would hide latency the UI must show.
+ */
+/** Where the CONVERSATION is. Independent of whether the mic is capturing. */
+export type VoiceSessionPhase = 'idle' | 'listening' | 'thinking' | 'speaking' | 'ended';
+export interface VoiceSessionSnapshot {
+    phase: VoiceSessionPhase;
+    /** Microphone off. Orthogonal to `phase` — see the header. */
+    muted: boolean;
+    /** FINALISED speech for the turn not yet submitted, accumulated. */
+    pending: string;
+    /** The recogniser's current guess, replaced wholesale until it finalises. */
+    interim: string;
+    /** Why the session stopped, when it stopped abnormally. */
+    error: VoiceSessionError | null;
+}
+/**
+ * Deliberately does NOT include a "playback blocked" variant. Nothing can
+ * detect it — the speech provider does not surface a per-message playback
+ * refusal — and the watchdog in `useVoiceSession` already recovers by handing
+ * the turn back silently, which continues the conversation rather than killing
+ * it. An error the code cannot raise is dead UI copy.
+ */
+export type VoiceSessionError = 'no-speech-support' | 'no-voice-support' | 'mic-denied';
+export type VoiceSessionEvent = 
+/** `final` distinguishes a committed phrase from a revisable guess. */
+{
+    type: 'start';
+} | {
+    type: 'speech';
+    transcript: string;
+    final: boolean;
+}
+/** Nothing heard for `SILENCE_SUBMIT_MS`. */
+ | {
+    type: 'silence';
+} | {
+    type: 'reply';
+    text: string;
+} | {
+    type: 'speech-ended';
+} | {
+    type: 'mute';
+    muted: boolean;
+}
+/** The user tapped to cut the assistant off. Explicit, not inferred. */
+ | {
+    type: 'interrupt';
+} | {
+    type: 'fail';
+    error: VoiceSessionError;
+} | {
+    type: 'end';
+};
+/**
+ * How long the user must stop talking before the turn is submitted.
+ *
+ * Long enough to survive a mid-sentence breath — a farmer describing a problem
+ * pauses — and short enough that the session does not feel unresponsive. A
+ * premature send truncates the question, which costs a whole 2-5s round trip to
+ * recover from.
+ *
+ * ★ Raised from 1200ms because 1.2s does not survive an ordinary pause: the
+ * operator reported being cut off mid-sentence, and the cost is worse than a
+ * truncated prompt — once the turn is submitted the reducer discards every
+ * `speech` event outside `listening`, so the rest of the sentence is not
+ * queued, it is thrown away, and the assistant answers half a question.
+ *
+ * The asymmetry is what settles the number: waiting 800ms longer costs a moment
+ * of silence, while cutting someone off costs the whole round trip AND makes
+ * them repeat themselves.
+ */
+export declare const SILENCE_SUBMIT_MS = 2000;
+/**
+ * Quiet needed before the pause is SHOWN as a pause.
+ *
+ * The submit timer above is armed the instant there is something submittable —
+ * which is mid-sentence — so it cannot itself say whether the user has stopped.
+ * This is the delay before the stage switches to `endpoint-grace`, leaving the
+ * remaining ~1.6s of the window visibly readable as "still listening, finish
+ * your thought" rather than as the session having already moved on.
+ *
+ * Short enough to be seen, long enough that an ordinary breath between words
+ * does not flicker the stage. ★800, not 400: this file already records that
+ * SILENCE_SUBMIT_MS had to go 1200 -> 2000 because ordinary pauses ran longer
+ * than expected, so a 400ms threshold sits inside normal inter-clause silence
+ * and would oscillate the stage mid-sentence. Still leaves ~1.2s visible.
+ */
+export declare const ENDPOINT_GRACE_MS = 800;
+/**
+ * How long the `interrupting` stage may persist without the microphone coming
+ * back. A ceiling, not a duration: the state normally ends the moment capture
+ * resumes. It exists so that a session whose microphone never reopens — the
+ * failure case — cannot latch this on and hide its own error message.
+ */
+export declare const INTERRUPT_MAX_MS = 1500;
+/**
+ * How long the `interrupting` stage is held even once the recogniser reports
+ * back.
+ *
+ * ★ `isListening` waits for the recogniser's own `onstart` as of #367, so it is
+ * now an honest capture signal. The dwell stays: `onstart` can still fire a beat
+ * before audio is usable, and a session whose microphone never opens must not
+ * latch this on and hide its own error.
+ */
+export declare const INTERRUPT_MIN_MS = 500;
+/** A turn is submitted only when there is something worth sending. */
+export declare function isSubmittable(text: string): boolean;
+/** Everything heard this turn: committed phrases plus the current guess. */
+export declare function spokenSoFar(snapshot: VoiceSessionSnapshot): string;
+export declare function isEcho(transcript: string, spokenText: string | null): boolean;
+/**
+ * What to do with a reply the app has just observed.
+ *
+ * Pure, because the rule is subtle and the hook that used to hold it has no
+ * test file at all — which is how the original defect shipped.
+ *
+ * Three outcomes:
+ *  - already claimed -> do nothing (a re-render, or two identical answers)
+ *  - arrived while thinking -> claim it AND advance the turn
+ *  - arrived any other time -> ★ CLAIM IT, but do not advance
+ *
+ * That last case is the one that matters. Interrupting stops playback but
+ * nothing cancels the model, so the abandoned answer still lands seconds later
+ * while the phase is `listening`. Leaving it unclaimed meant the NEXT question
+ * found it waiting and spoke the answer to the question the user had cut off.
+ */
+export declare function planReplyConsumption(replyId: string | null | undefined, phase: VoiceSessionPhase, consumedReplyId: string | null): {
+    claim: boolean;
+    advance: boolean;
+};
+export declare const INITIAL_SESSION: Readonly<VoiceSessionSnapshot>;
+/**
+ * The whole session loop, as one pure reduction.
+ *
+ * `spokenText` is what the assistant is currently saying, supplied so echo can
+ * be told from interruption. It is an argument rather than snapshot state
+ * because it belongs to the speech engine, not to the session.
+ */
+export declare function voiceSessionReducer(snapshot: VoiceSessionSnapshot, event: VoiceSessionEvent, spokenText?: string | null): VoiceSessionSnapshot;
+/**
+ * Is the microphone capturing right now?
+ *
+ * False while the assistant speaks, which is the whole point: an open
+ * microphone during playback is what created the feedback loop. False whenever
+ * muted, whatever the phase.
+ */
+export declare function isCapturing(snapshot: VoiceSessionSnapshot): boolean;
+/** The orb's visual mode. Kept here so the UI has no state logic of its own. */
+export declare function orbMode(snapshot: VoiceSessionSnapshot): 'idle' | 'listening' | 'thinking' | 'speaking';
+//# sourceMappingURL=voiceSession.d.ts.map

package/dist/shared/assistant/voice/voiceSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voiceSession.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/voice/voiceSession.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,8EAA8E;AAC9E,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,WAAW,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC;AAEzF,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,iBAAiB,CAAC;IACzB,8DAA8D;IAC9D,KAAK,EAAE,OAAO,CAAC;IACf,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG,mBAAmB,GAAG,kBAAkB,GAAG,YAAY,CAAC;AAExF,MAAM,MAAM,iBAAiB;AAC3B,uEAAuE;AACrE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE;AACxD,6CAA6C;GAC3C;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,GACxB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE;AAClC,wEAAwE;GACtE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,iBAAiB,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAEpB;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAErC;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,OAAO,CAAC;AAErC;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,sEAAsE;AACtE,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,4EAA4E;AAC5E,wBAAgB,WAAW,CAAC,QAAQ,EAAE,oBAAoB,GAAG,MAAM,CAElE;AAqCD,wBAAgB,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAY7E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAClC,KAAK,EAAE,iBAAiB,EACxB,eAAe,EAAE,MAAM,GAAG,IAAI,GAC7B;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAItC;AAED,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,oBAAoB,CAMzD,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,oBAAoB,EAC9B,KAAK,EAAE,iBAAiB,EACxB,UAAU,GAAE,MAAM,GAAG,IAAW,GAC/B,oBAAoB,CAmFtB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,oBAAoB,GAAG,OAAO,CAKnE;AAED,gFAAgF;AAChF,wBAAgB,OAAO,CAAC,QAAQ,EAAE,oBAAoB,GAAG,MAAM,GAAG,WAAW,GAAG,UAAU,GAAG,UAAU,CAatG"}

package/dist/shared/assistant/voice/voiceStageState.d.ts

@@ -0,0 +1,49 @@
+import { VoiceSessionSnapshot } from './voiceSession';
+export type VoiceStageState = 'connecting' | 'listening' | 'endpoint-grace' | 'thinking' | 'speaking' | 'interrupting' | 'mic-error' | 'ended';
+export interface StageInputs {
+    snapshot: VoiceSessionSnapshot;
+    /** Is the recogniser genuinely running? False during start-up. */
+    capturing: boolean;
+    /** True from the moment the user cuts the assistant off until listening resumes. */
+    interrupting?: boolean;
+    /**
+     * The user has stopped producing new words and the submit timer is running.
+     *
+     * Its own state because the checklist asks for it: the two-second correction
+     * window should look like a deliberate pause the user can still speak into,
+     * not like the session has already moved on.
+     */
+    awaitingEndpoint?: boolean;
+}
+/**
+ * Precedence is the whole design. A failure outranks a phase — a session that
+ * cannot hear must never render as "Listening…", which is precisely the lie the
+ * operator screenshotted.
+ */
+export declare function voiceStageState({ snapshot, capturing, interrupting, awaitingEndpoint, }: StageInputs): VoiceStageState;
+/** Does this stage show the user's live transcript rather than the reply? */
+export declare function showsUserCaption(state: VoiceStageState): boolean;
+/** Does this stage show the assistant's caption? */
+export declare function showsAssistantCaption(state: VoiceStageState): boolean;
+/** Is the microphone control an INTERRUPT rather than a mute toggle? */
+export declare function micIsInterrupt(state: VoiceStageState): boolean;
+/**
+ * Does this stage show a LIVE waveform?
+ *
+ * ★ Shared rather than repeated, because the two surfaces had already drifted:
+ * the full stage and the docked strip each answered this question with their
+ * own inline expression, so teaching one about a new state silently left the
+ * other frozen. `endpoint-grace` in particular MUST animate — it is the window
+ * in which the user may still be talking, and a still waveform beside the words
+ * "still listening" says the opposite of the label.
+ */
+export declare function waveformIsActive(state: VoiceStageState): boolean;
+/**
+ * Is the waveform open but WAITING rather than actively hearing speech?
+ *
+ * The correction window is not the same as mid-sentence listening, and a status
+ * line is a weak way to say so: a calmer, shorter profile makes the pause
+ * visible without implying the microphone closed.
+ */
+export declare function waveformIsSettled(state: VoiceStageState): boolean;
+//# sourceMappingURL=voiceStageState.d.ts.map

package/dist/shared/assistant/voice/voiceStageState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voiceStageState.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/voice/voiceStageState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,MAAM,MAAM,eAAe,GACzB,YAAY,GAAG,WAAW,GAAG,gBAAgB,GAAG,UAAU,GAAG,UAAU,GAAG,cAAc,GAAG,WAAW,GAAG,OAAO,CAAC;AAEnH,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,kEAAkE;IAClE,SAAS,EAAE,OAAO,CAAC;IACnB,oFAAoF;IACpF,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAC9B,QAAQ,EACR,SAAS,EACT,YAAoB,EACpB,gBAAwB,GACzB,EAAE,WAAW,GAAG,eAAe,CAwB/B;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAKhE;AAED,oDAAoD;AACpD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAErE;AAED,wEAAwE;AACxE,wBAAgB,cAAc,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAE9D;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAEhE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAEjE"}

package/dist/shared-assistant.js

@@ -6,4 +6,6 @@ import { buildProgress as y, getAssistantMedia as b, isRecoverable as x, mapSess
 import { createSandboxAssistantTransport as T } from "./shared/assistant/createSandboxAssistantTransport.js";
 import { useSandboxAssistantTransport as E } from "./shared/assistant/useSandboxAssistantTransport.js";
 import { chatTurns as D, groupBySession as O, groupConsecutiveBySession as k, isVoiceTurn as A, voiceMarker as j, voiceSessionIdOf as M, voiceTurnsOnly as N } from "./shared/assistant/voice/turnVisibility.js";
-export { v as AssistantRuntimeManager, y as buildProgress, n as buildPromptRequestBody, D as chatTurns, r as checkAssistantAiCredits, i as createAssistantSandbox, a as createAssistantSession, T as createSandboxAssistantTransport, o as downloadAssistantArtifact, s as extendAssistantSandboxTTL, c as findExistingSandbox, l as getAssistantArtifacts, b as getAssistantMedia, u as getAssistantMessages, d as getAssistantSession, f as getAssistantStreamAccess, O as groupBySession, k as groupConsecutiveBySession, t as isQuotaExhaustedError, x as isRecoverable, A as isVoiceTurn, S as mapSessionToHistory, C as mergeMessagesById, p as reportAssistantAiTokenUsage, w as sanitize, m as sendAssistantPromptAsync, h as sendHeartbeat, E as useSandboxAssistantTransport, e as useVoiceInput, j as voiceMarker, M as voiceSessionIdOf, N as voiceTurnsOnly, g as waitForAssistantServiceReady, _ as waitForSandboxRunning };
+import { toCaptionText as P } from "./shared/assistant/voice/captionText.js";
+import { findPendingWrite as F, parseConfirmationRefusal as I } from "./shared/assistant/pendingWrite.js";
+export { v as AssistantRuntimeManager, y as buildProgress, n as buildPromptRequestBody, D as chatTurns, r as checkAssistantAiCredits, i as createAssistantSandbox, a as createAssistantSession, T as createSandboxAssistantTransport, o as downloadAssistantArtifact, s as extendAssistantSandboxTTL, c as findExistingSandbox, F as findPendingWrite, l as getAssistantArtifacts, b as getAssistantMedia, u as getAssistantMessages, d as getAssistantSession, f as getAssistantStreamAccess, O as groupBySession, k as groupConsecutiveBySession, t as isQuotaExhaustedError, x as isRecoverable, A as isVoiceTurn, S as mapSessionToHistory, C as mergeMessagesById, I as parseConfirmationRefusal, p as reportAssistantAiTokenUsage, w as sanitize, m as sendAssistantPromptAsync, h as sendHeartbeat, P as toCaptionText, E as useSandboxAssistantTransport, e as useVoiceInput, j as voiceMarker, M as voiceSessionIdOf, N as voiceTurnsOnly, g as waitForAssistantServiceReady, _ as waitForSandboxRunning };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burdenoff/fe-libs",
-  "version": "2026.903.2",
+  "version": "2026.903.3",
   "description": "Burdenoff frontend primitives and domain libraries",
   "type": "module",
   "bin": {