@burdenoff/fe-libs 2026.1004.3 → 2026.1004.5

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

@@ -0,0 +1,160 @@
+/**
+ * Hands-free voice, steps H1 and H2 — the pure rules (BOFF hands-free slice).
+ *
+ * Everything here is data in, decision out: no DOM, no timers, no React, for
+ * the reason `voiceSession.ts` gives (this repo's unit runner has no browser).
+ * The hook (`useVoiceSession`) owns the clock and the recogniser; this file
+ * owns what the words and the preference MEAN.
+ *
+ * ★ H1 — the end-of-speech grace is a USER PREFERENCE (2 s default, 3 s, 5 s),
+ * and there is exactly ONE timing owner: `planSubmitTimer`. The old
+ * `SILENCE_SUBMIT_MS` constant is gone; the value the timer waits is the
+ * preference, resolved by `resolveVoiceGraceMs`. Nothing else in the package
+ * waits before submitting a spoken turn (`ENDPOINT_GRACE_MS` only decides when
+ * the stage SHOWS the pause, and is clamped inside the grace).
+ *
+ * ★ H2 — corrections while the assistant is still PREPARING an answer. The
+ * microphone stays open in `thinking`, so a recogniser can deliver three kinds
+ * of result there, and telling them apart is the whole difficulty:
+ *   1. a trailing result of the turn JUST submitted (Chrome finalises late;
+ *      Chrome Android re-sends the whole utterance, sometimes revised) — must
+ *      be ignored, or every spoken question is aborted and sent twice;
+ *   2. noise and fillers ("uh", "hmm") — must not abort a model turn;
+ *   3. a person speaking — a correction: the turn is superseded.
+ * `planThinkingSpeech` is that classification.
+ *
+ * A spoken "yes" never commits a business write. In `thinking` a bare
+ * affirmation is therefore NOT a correction at all: it neither aborts the turn
+ * nor withdraws anything (`classifyWriteReply` is the same classifier the 5a
+ * binder uses). The binder, and the card's button, stay the only way a change
+ * is confirmed.
+ */
+/** The choices offered in the voice settings, shortest first. */
+export declare const VOICE_GRACE_CHOICES_MS: readonly [2000, 3000, 5000];
+export type VoiceGraceMs = (typeof VOICE_GRACE_CHOICES_MS)[number];
+/**
+ * How long the user must stop talking before the turn is submitted, until they
+ * choose otherwise.
+ *
+ * ★ 2000, not 1200: 1.2 s does not survive an ordinary pause. Once a turn is
+ * submitted the reducer discards the rest of the sentence, so cutting someone
+ * off costs the whole round trip AND makes them repeat themselves — waiting
+ * 800 ms longer costs only a moment of silence. The asymmetry is what settled
+ * the number, and it is why the longer choices exist for people who pause more.
+ */
+export declare const DEFAULT_VOICE_GRACE_MS: VoiceGraceMs;
+/**
+ * Read a stored or passed value as one of the offered choices.
+ *
+ * Anything else — a stale number from an older build, a string, `null`, a value
+ * hand-edited into storage — is the default, never a nearby choice: a grace of
+ * 0 or 600000 ms read back from storage would either submit mid-word or never
+ * submit at all.
+ */
+export declare function resolveVoiceGraceMs(value: unknown): VoiceGraceMs;
+/**
+ * The ONE decision about the submit timer.
+ *
+ * `arm` is true only for a listening, unmuted session with something worth
+ * sending, and NOT while the person asked to finish in their own time
+ * ("Let me finish", `holding`). `delayMs` is the preference. The hook re-asks
+ * on every change of the session, so new speech cancels a pending submit and
+ * the turn continues — there is no second timer to forget.
+ */
+export declare function planSubmitTimer(input: {
+    phase: string;
+    muted: boolean;
+    /** Everything heard this turn (`spokenSoFar`). */
+    spoken: string;
+    /** "Let me finish" is on: nothing is submitted until the person says done. */
+    holding: boolean;
+    /** The preference, in ms. */
+    graceMs: number;
+}): {
+    arm: boolean;
+    delayMs: number;
+};
+/**
+ * The comparable words of a transcript: letters, marks and digits only (marks
+ * kept — Tamil and Hindi vowel signs are marks), lower-cased. Punctuation and
+ * capitals a final adds are not speech.
+ */
+export declare function speechWords(text: string): string[];
+/**
+ * Add a newly finalised phrase to the turn heard so far.
+ *
+ * ★ Chrome Android duplicates finals. With `continuous` on, a restarted
+ * recogniser can re-send the phrase it just finalised, and it often re-sends
+ * the WHOLE utterance so far with a few words added. Plain concatenation turned
+ * "when should I sow" into "when should I sow when should I sow ragi" and sent
+ * that. So:
+ *  - a phrase that STARTS WITH everything heard is the same utterance, longer
+ *    or equal: it replaces what was heard;
+ *  - a phrase of two or more words that the turn already ENDS with is a
+ *    repeat: dropped;
+ *  - anything else is new speech: appended.
+ * A single repeated word is kept unless it is the whole turn — "no no" is
+ * emphasis, but a lone "hello" arriving twice is the recogniser.
+ */
+export declare function mergeFinalPhrase(pending: string, phrase: string): string;
+/**
+ * A transcript without the words of the turn it follows, when it starts with
+ * them (a cumulative result: "when should I sow ragi" after "when should I
+ * sow"). Anything else is returned unchanged.
+ */
+export declare function stripSubmittedPrefix(transcript: string, submitted: string): string;
+/**
+ * How long after a turn is submitted its OWN trailing results may still arrive.
+ *
+ * The person was silent for the whole grace (2 s at least), so anything
+ * arriving this soon after the submit and resembling what was sent is the
+ * recogniser finishing the sentence, not a correction. Past it, only an exact
+ * repeat is ignored — a person correcting "plant ragi in June" with "no plant
+ * ragi in July" is speaking, however alike the words are.
+ */
+export declare const TRAILING_RESULT_WINDOW_MS = 1500;
+/**
+ * Is this transcript the recogniser finishing, repeating or revising the turn
+ * that was just submitted?
+ *
+ * `sinceSubmitMs` is null when unknown (no clock): then only an exact repeat
+ * counts, which can only ever err towards treating speech as speech.
+ */
+export declare function isTrailingResultOfSubmitted(transcript: string, submitted: string, sinceSubmitMs: number | null): boolean;
+/**
+ * Is this a person speaking, rather than noise?
+ *
+ * Aborting a model turn costs the turn, so the bar is two letters or digits
+ * that are not all filler. "no" and "ok" pass; "a", "uh" and "hmm" do not. A
+ * single Han, kana or Hangul character passes — "不" is a whole word.
+ */
+export declare function isGenuineUserSpeech(text: string): boolean;
+/** What a result heard while the answer is being prepared amounts to. */
+export type ThinkingSpeechPlan = {
+    kind: "ignore";
+    reason: "empty" | "trailing" | "noise" | "affirmation";
+} | {
+    kind: "supersede";
+    /** What the person said, without the words of the turn it corrects. */
+    text: string;
+};
+/**
+ * Classify a result that arrives while the assistant is PREPARING an answer.
+ *
+ * Ignored: nothing; the recogniser finishing, repeating or revising the turn
+ * just submitted; noise; and a bare affirmation (a spoken "yes" is never a
+ * correction, and never commits a write — see the header). Everything else is
+ * a correction.
+ *
+ * Echo is not checked here: nothing plays during `thinking`. The caller still
+ * passes the previous reply through `isEcho` first, because its tail can sound
+ * for a moment after playback ends.
+ */
+export declare function planThinkingSpeech(input: {
+    transcript: string;
+    /** The turn in flight, as it was sent. */
+    submitted: string;
+    /** Milliseconds since it was sent, or null when no clock was given. */
+    sinceSubmitMs: number | null;
+}): ThinkingSpeechPlan;
+//# sourceMappingURL=handsFree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handsFree.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/voice/handsFree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAQH,iEAAiE;AACjE,eAAO,MAAM,sBAAsB,6BAA8B,CAAC;AAElE,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnE;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,EAAE,YAAmB,CAAC;AAEzD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAEhE;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;IACf,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,OAAO,EAAE,OAAO,CAAC;IACjB,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAIpC;AAMD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAMlD;AA6BD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAQxE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAelF;AAMD;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAK9C;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,GAAG,IAAI,GAC3B,OAAO,CAYT;AAyBD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOzD;AAED,yEAAyE;AACzE,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,OAAO,GAAG,UAAU,GAAG,OAAO,GAAG,aAAa,CAAA;CAAE,GAC1E;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEN;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B,GAAG,kBAAkB,CASrB"}

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

@@ -0,0 +1,104 @@
+import { classifyWriteReply as e } from "../writeReplyBinder.js";
+//#region src/shared/assistant/voice/handsFree.ts
+var t = [
+	2e3,
+	3e3,
+	5e3
+], n = 2e3;
+function r(e) {
+	return t.find((t) => t === e) ?? 2e3;
+}
+function i(e) {
+	let t = r(e.graceMs);
+	return {
+		arm: e.phase === "listening" && !e.muted && !e.holding && e.spoken.trim().length > 0,
+		delayMs: t
+	};
+}
+function a(e) {
+	let t = e.toLowerCase().replace(/[^\p{L}\p{M}\p{N}]+/gu, " ").trim();
+	return t ? t.split(" ") : [];
+}
+var o = (e, t) => t.length <= e.length && t.every((t, n) => e[n] === t), s = (e, t) => t.length <= e.length && t.every((n, r) => e[e.length - t.length + r] === n), c = (e, t) => {
+	if (t.length === 0) return !0;
+	for (let n = 0; n + t.length <= e.length; n += 1) if (t.every((t, r) => e[n + r] === t)) return !0;
+	return !1;
+};
+function l(e, t) {
+	let n = Array(t.length + 1).fill(0);
+	for (let r of e) {
+		let e = Array(t.length + 1).fill(0);
+		for (let i = 1; i <= t.length; i += 1) e[i] = r === t[i - 1] ? (n[i - 1] ?? 0) + 1 : Math.max(n[i] ?? 0, e[i - 1] ?? 0);
+		n = e;
+	}
+	return n[t.length] ?? 0;
+}
+function u(e, t) {
+	let n = a(e), r = a(t);
+	return r.length === 0 ? e : n.length === 0 || o(r, n) ? t.replace(/\s+/g, " ").trim() : r.length >= 2 && s(n, r) ? e : `${e} ${t}`.replace(/\s+/g, " ").trim();
+}
+function d(e, t) {
+	let n = a(t);
+	if (n.length === 0) return e.replace(/\s+/g, " ").trim();
+	let r = e.split(/\s+/).filter(Boolean), i = 0;
+	for (let t = 0; t < r.length; t += 1) {
+		let o = a(r[t] ?? "");
+		if (o.length !== 0) for (let a of o) {
+			if (a !== n[i]) return e.replace(/\s+/g, " ").trim();
+			if (i += 1, i === n.length) return r.slice(t + 1).join(" ").trim();
+		}
+	}
+	return e.replace(/\s+/g, " ").trim();
+}
+var f = 1500, p = .6;
+function m(e, t, n) {
+	let r = a(e), i = a(t);
+	return r.length === 0 ? !0 : i.length === 0 ? !1 : r.length === i.length && r.every((e, t) => e === i[t]) ? !0 : n === null || n >= 1500 ? !1 : c(i, r) ? !0 : o(r, i) && r.length - i.length >= 2 ? !1 : l(r, i) / Math.max(r.length, i.length) >= p;
+}
+var h = new Set([
+	"uh",
+	"um",
+	"uhm",
+	"umm",
+	"er",
+	"erm",
+	"eh",
+	"ah",
+	"hm",
+	"hmm",
+	"hmmm",
+	"mm",
+	"mmm",
+	"mhm",
+	"huh",
+	"oh"
+]), g = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+function _(e) {
+	let t = a(e);
+	if (t.length === 0 || t.every((e) => h.has(e))) return !1;
+	let n = [...t.join("")];
+	return n.length >= 2 ? !0 : n.length === 1 && g.test(n[0] ?? "");
+}
+function v(t) {
+	if (a(t.transcript).length === 0) return {
+		kind: "ignore",
+		reason: "empty"
+	};
+	if (m(t.transcript, t.submitted, t.sinceSubmitMs)) return {
+		kind: "ignore",
+		reason: "trailing"
+	};
+	let n = d(t.transcript, t.submitted);
+	return _(n) ? e(n, "en") === "affirm" ? {
+		kind: "ignore",
+		reason: "affirmation"
+	} : {
+		kind: "supersede",
+		text: n
+	} : {
+		kind: "ignore",
+		reason: "noise"
+	};
+}
+//#endregion
+export { n as DEFAULT_VOICE_GRACE_MS, f as TRAILING_RESULT_WINDOW_MS, t as VOICE_GRACE_CHOICES_MS, _ as isGenuineUserSpeech, m as isTrailingResultOfSubmitted, u as mergeFinalPhrase, i as planSubmitTimer, v as planThinkingSpeech, r as resolveVoiceGraceMs, a as speechWords, d as stripSubmittedPrefix };

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

@@ -0,0 +1,29 @@
+/**
+ * The turns a person has superseded — the stale-turn guard of hands-free
+ * corrections (H2).
+ *
+ * When someone speaks a correction while the assistant is still PREPARING an
+ * answer, the in-flight turn is aborted (`POST /sessions/:id/abort`) and then
+ * recorded here. Aborting is best-effort and asynchronous, so the old turn can
+ * still deliver something afterwards: its reply landing, its speech starting
+ * from the speech feed, its text becoming the "latest reply" the caption and
+ * the echo reference are built from. Every one of those paths asks THIS module
+ * whether the message belongs to a turn that was superseded, and refuses if so:
+ * the late answer never restarts audio, never replaces a caption and never
+ * advances the next turn.
+ *
+ * ★ Module scope on purpose, like `speechFeed`: the publisher (the chat area),
+ * the speaker (the speech provider) and the voice session are three components
+ * that do not know each other, and the guard has to hold across a remount.
+ *
+ * ★ Bounded. A session is a handful of turns; the oldest ids are dropped first
+ * so a long-lived page cannot grow this without limit, and an id this old can
+ * no longer be in flight.
+ */
+/** Record that the turn that produced assistant message `messageId` was superseded. */
+export declare function markTurnSuperseded(messageId: string): void;
+/** Was the turn behind `messageId` superseded? Null and undefined never were. */
+export declare function isTurnSuperseded(messageId: string | null | undefined): boolean;
+/** Tests only. */
+export declare function resetSupersededTurnsForTest(): void;
+//# sourceMappingURL=supersededTurns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"supersededTurns.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/voice/supersededTurns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAOH,uFAAuF;AACvF,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAQ1D;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAE9E;AAED,kBAAkB;AAClB,wBAAgB,2BAA2B,IAAI,IAAI,CAElD"}

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

@@ -0,0 +1,17 @@
+//#region src/shared/assistant/voice/supersededTurns.ts
+var e = 64, t = /* @__PURE__ */ new Set();
+function n(n) {
+	for (t.delete(n), t.add(n); t.size > e;) {
+		let e = t.values().next();
+		if (e.done) break;
+		t.delete(e.value);
+	}
+}
+function r(e) {
+	return typeof e == "string" && t.has(e);
+}
+function i() {
+	t.clear();
+}
+//#endregion
+export { r as isTurnSuperseded, n as markTurnSuperseded, i as resetSupersededTurnsForTest };

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

@@ -31,6 +31,13 @@
  *  - **`stop()` resolves the final transcript** through `onFinalize`, so the
  *    composer can commit exactly once when the user stops.
  */
+/**
+ * Can this browser recognise speech at all? The same test `useVoiceInput`
+ * reports as `isSupported`, for surfaces that must decide whether to OFFER a
+ * voice setting without mounting the hook (a settings row for a recogniser
+ * that does not exist is a control that cannot do anything).
+ */
+export declare function isSpeechRecognitionSupported(): boolean;
 /**
  * How long to refuse a restart after `recognition.start()` THREW.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"useVoiceInput.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/voice/useVoiceInput.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AA+DH;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAW5C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9E;AAED,MAAM,MAAM,eAAe,GACzB,aAAa,GAAG,WAAW,GAAG,eAAe,GAAG,SAAS,GAAG,wBAAwB,GAAG,SAAS,CAAC;AA+BnG,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,8EAA8E;IAC9E,UAAU,EAAE,OAAO,CAAC;IACpB;;;;;;OAMG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,sEAAsE;IACtE,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,IAAI,CAAC;IACtC,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,uEAAuE;IACvE,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED,wBAAgB,aAAa,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,oBAAoB,GAAG,mBAAmB,CAmO5G"}
+{"version":3,"file":"useVoiceInput.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/voice/useVoiceInput.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AA+DH;;;;;GAKG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CAEtD;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAW5C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9E;AAED,MAAM,MAAM,eAAe,GACzB,aAAa,GAAG,WAAW,GAAG,eAAe,GAAG,SAAS,GAAG,wBAAwB,GAAG,SAAS,CAAC;AA+BnG,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,8EAA8E;IAC9E,UAAU,EAAE,OAAO,CAAC;IACpB;;;;;;OAMG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,sEAAsE;IACtE,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,IAAI,CAAC;IACtC,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,uEAAuE;IACvE,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED,wBAAgB,aAAa,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,oBAAoB,GAAG,mBAAmB,CAmO5G"}

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

@@ -17,11 +17,14 @@ function o() {
 	let e = window;
 	return e.SpeechRecognition ?? e.webkitSpeechRecognition ?? null;
 }
-var s = 2e3, c = 2;
-function l(e, t) {
-	return t - e < s;
+function s() {
+	return o() !== null;
 }
-function u(e) {
+var c = 2e3, l = 2;
+function u(e, t) {
+	return t - e < c;
+}
+function d(e) {
 	switch (e) {
 		case "not-allowed":
 		case "service-not-allowed": return "not-allowed";
@@ -32,18 +35,18 @@ function u(e) {
 		default: return "unknown";
 	}
 }
-function d({ onFinalize: s, language: d }) {
+function f({ onFinalize: s, language: c }) {
 	let { locale: f } = e(), [p, m] = i(!1), [h, g] = i(!1), [_, v] = i(""), [y, b] = i(null), x = r(null), S = r(0), C = r(-Infinity), w = r(0), T = r(s);
 	n(() => {
 		T.current = s;
 	}, [s]);
-	let E = o() !== null, D = d ?? a[f] ?? "en-US";
+	let E = o() !== null, D = c ?? a[f] ?? "en-US";
 	n(() => () => {
 		x.current?.abort(), x.current = null;
 	}, []);
 	let O = t((e = "manual") => {
 		let t = o();
-		if (!t || x.current || e === "auto" && l(C.current, performance.now())) return;
+		if (!t || x.current || e === "auto" && u(C.current, performance.now())) return;
 		let n = new t();
 		n.continuous = !0, n.interimResults = !0, n.lang = D;
 		let r = S.current;
@@ -57,7 +60,7 @@ function d({ onFinalize: s, language: d }) {
 			t.trim() && T.current(t.trim()), v(n.trim());
 		}, n.onerror = (e) => {
 			if (r !== S.current) return;
-			let t = u(e.error);
+			let t = d(e.error);
 			t !== "no-speech" && b(t);
 		}, n.onend = () => {
 			r === S.current && (x.current = null, g(!1), m(!1), v(""));
@@ -67,7 +70,7 @@ function d({ onFinalize: s, language: d }) {
 		try {
 			n.start();
 		} catch {
-			C.current = performance.now(), w.current += 1, w.current >= c && b("unknown"), x.current = null, g(!1), m(!1);
+			C.current = performance.now(), w.current += 1, w.current >= l && b("unknown"), x.current = null, g(!1), m(!1);
 			return;
 		}
 		x.current = n, w.current = 0, b(null), v("");
@@ -101,4 +104,4 @@ function d({ onFinalize: s, language: d }) {
 	};
 }
 //#endregion
-export { s as START_RETRY_COOLDOWN_MS, l as startIsCoolingDown, d as useVoiceInput };
+export { c as START_RETRY_COOLDOWN_MS, s as isSpeechRecognitionSupported, u as startIsCoolingDown, f as useVoiceInput };

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

@@ -46,6 +46,28 @@ export interface VoiceSessionSnapshot {
     interim: string;
     /** Why the session stopped, when it stopped abnormally. */
     error: VoiceSessionError | null;
+    /**
+     * H2: what the turn in flight was sent as, while there is one ('' otherwise).
+     * Kept so a result that is only the recogniser finishing, repeating or
+     * revising it is not mistaken for a correction, and so a cumulative result
+     * ("<sent words> <new words>") contributes only the new words.
+     */
+    submitted: string;
+    /** H2: when `submitted` was sent (the `at` of the `silence` that sent it). */
+    submittedAt: number | null;
+    /**
+     * H2: the words being collected, or the turn in flight, are a CORRECTION of
+     * a turn that was superseded. Cleared when the corrected turn is answered,
+     * interrupted or the session ends.
+     */
+    correcting: boolean;
+    /**
+     * H2: how many times an in-flight turn has been superseded this session.
+     * A counter, not a flag, so the hook can act exactly once per supersession
+     * (abort the model turn, withdraw outdated proposals) without the reducer
+     * doing anything impure. Reset by `start`.
+     */
+    superseded: number;
 }
 /**
  * Deliberately does NOT include a "playback blocked" variant. Nothing can
@@ -63,10 +85,13 @@ export type VoiceSessionEvent =
     type: 'speech';
     transcript: string;
     final: boolean;
+    /** Wall-clock ms when it was heard — what the H2 trailing-result window is measured with. */
+    at?: number;
 }
-/** Nothing heard for `SILENCE_SUBMIT_MS`. */
+/** Nothing heard for the person's grace (`resolveVoiceGraceMs`). */
  | {
     type: 'silence';
+    at?: number;
 } | {
     type: 'reply';
     text: string;
@@ -116,24 +141,19 @@ export type VoiceSessionEvent =
     type: 'end';
 };
 /**
- * How long the user must stop talking before the turn is submitted.
+ * How long the user must stop talking before the turn is submitted is a USER
+ * PREFERENCE (H1): `DEFAULT_VOICE_GRACE_MS` (2 s), 3 s or 5 s, resolved by
+ * `resolveVoiceGraceMs` and applied by `planSubmitTimer` in `./handsFree` —
+ * the only place that waits. (`SILENCE_SUBMIT_MS`, which used to live here, is
+ * gone: a second constant was a second owner.)
  *
- * 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.
+ * Why the default is 2 s and not the 1.2 s it started at: 1.2 s does not
+ * survive an ordinary pause — 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. Waiting
+ * 800ms longer costs a moment of silence; 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.
  *
@@ -145,7 +165,7 @@ export declare const SILENCE_SUBMIT_MS = 2000;
  *
  * 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
+ * the grace 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.
  */
@@ -213,7 +233,14 @@ export declare function isEcho(transcript: string, spokenText: string | null): b
  * 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): {
+export declare function planReplyConsumption(replyId: string | null | undefined, phase: VoiceSessionPhase, consumedReplyId: string | null, 
+/**
+ * H2: the reply belongs to a turn the person superseded (`isTurnSuperseded`).
+ * It is claimed and never advances the session, whatever the phase — a late
+ * answer to a question the person has since corrected must not move the
+ * turn that REPLACED it out of `thinking`.
+ */
+supersededReply?: boolean): {
     claim: boolean;
     advance: boolean;
 };
@@ -265,13 +292,30 @@ export declare function planListeningHold(input: {
     held: boolean;
 };
 /**
- * Is the microphone capturing right now?
+ * Is the microphone capturing right now — in the sense the AUDIO guards mean?
  *
  * 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.
+ *
+ * ★ Deliberately still `listening` only, though the recogniser now also runs in
+ * `thinking` (see `shouldRecognise`). This is what the speech provider is told
+ * ("the microphone is open: refuse to auto-speak a reply into it"), and the
+ * not-capturing notice is judged by. A correction heard in `thinking` supersedes
+ * the turn and returns the phase to `listening`, so a late reply is then refused
+ * by exactly this guard — it is not weakened by listening for corrections.
  */
 export declare function isCapturing(snapshot: VoiceSessionSnapshot): boolean;
+/**
+ * Should the recogniser be RUNNING right now (H2)?
+ *
+ * While `listening`, and also while the assistant is `thinking`: nothing plays
+ * then, so there is no echo to fear, and keeping the microphone open is what
+ * lets a person correct themselves without tapping. Closed for the whole of
+ * `speaking`, and whenever muted. Barge-in while SPEAKING is a separate step
+ * (H3) and is NOT enabled here.
+ */
+export declare function shouldRecognise(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

@@ -1 +1 @@
-{"version":3,"file":"voiceSession.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/voice/voiceSession.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"voiceSession.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/voice/voiceSession.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAQH,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;IAChC;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,8EAA8E;IAC9E,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;;;OAIG;IACH,UAAU,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB;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;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;IACf,6FAA6F;IAC7F,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AACH,oEAAoE;GAClE;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AACjC;;;;;;;GAOG;GACD;IAAE,IAAI,EAAE,qBAAqB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAChD;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;AACvB;;;;GAIG;GACD;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE;AACtB;;;;;;GAMG;GACD;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,iBAAiB,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAEpB;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;;;;;;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;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CACnB;AAED,eAAO,MAAM,aAAa,EAAE,UAAmC,CAAC;AAIhE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,oBAAoB,EAAE,GAAG,EAAE,MAAM,GAAG,UAAU,CAc5G;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;AAC9B;;;;;GAKG;AACH,eAAe,UAAQ,GACtB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAKtC;AAED,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,oBAAoB,CAUzD,CAAC;AA0CH;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,oBAAoB,EAC9B,KAAK,EAAE,iBAAiB,EACxB,UAAU,GAAE,MAAM,GAAG,IAAW,GAC/B,oBAAoB,CA6ItB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAUhG;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IACvC,sCAAsC;IACtC,SAAS,EAAE,OAAO,CAAC;IACnB,uDAAuD;IACvD,IAAI,EAAE,OAAO,CAAC;IACd,8EAA8E;IAC9E,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG;IAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAY1C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,oBAAoB,GAAG,OAAO,CAKnE;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,oBAAoB,GAAG,OAAO,CAGvE;AAED,gFAAgF;AAChF,wBAAgB,OAAO,CAAC,QAAQ,EAAE,oBAAoB,GAAG,MAAM,GAAG,WAAW,GAAG,UAAU,GAAG,UAAU,CAatG"}