@olares/lares-core 0.15.17 → 0.15.18

package/voice/shortcuts.js

@@ -5,17 +5,66 @@ export function shortcutFromEvent(event) {
   if (!key || ["Control", "Meta", "Alt", "Shift"].includes(key)) return "";
   return [event.ctrlKey && "Ctrl", event.metaKey && "Meta", event.altKey && "Alt", event.shiftKey && "Shift", key].filter(Boolean).join("+");
 }
+export function voiceShortcutProblem(key, action, value) {
+  if (typeof key !== "string" || key && (!/^(?:Ctrl\+)?(?:Meta\+)?(?:Alt\+)?(?:Shift\+)?(?:[a-z0-9]|F(?:[1-9]|1[0-2]))$/.test(key) || !/^(Ctrl|Meta|Alt)\+/.test(key))) return "invalid";
+  if (RESERVED.has(key)) return "reserved";
+  if (key && ACTIONS.some(id => id !== action && value[id] === key)) return "duplicate";
+  return null;
+}
 export function validateVoiceShortcuts(value) {
   if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join() !== [...ACTIONS].sort().join()) throw new Error("voice_shortcut_invalid");
-  const seen = new Set(); const result = {};
+  const result = {};
   for (const action of ACTIONS) {
-    const key = value[action];
-    if (typeof key !== "string" || (key && ((!/^(?:Ctrl\+)?(?:Meta\+)?(?:Alt\+)?(?:Shift\+)?(?:[a-z0-9]|F(?:[1-9]|1[0-2]))$/.test(key) || !/^(Ctrl|Meta|Alt)\+/.test(key)) || RESERVED.has(key) || seen.has(key)))) throw new Error("voice_shortcut_invalid");
-    if (key) seen.add(key);
-    result[action] = key;
+    const reason = voiceShortcutProblem(value[action], action, value);
+    if (reason) throw Object.assign(new Error("voice_shortcut_invalid"), { reason });
+    result[action] = value[action];
   }
   return result;
 }
+export function formatVoiceShortcut(value, mac = false) {
+  if (!value) return "";
+  return value.split("+").map(key => mac ? ({ Meta: "⌘", Alt: "⌥", Ctrl: "⌃", Shift: "⇧" })[key] || key.toUpperCase() : key.length === 1 ? key.toUpperCase() : key).join(mac ? "" : "+");
+}
+
+/** One recorder per settings page; only release of the chosen main key can commit it. */
+export function createVoiceShortcutRecorder({ current, save }) {
+  let state = { action: null, candidate: "", errors: {}, pending: {}, failed: {} }, code = null;
+  const listeners = new Set();
+  const emit = patch => { state = { ...state, ...patch }; for (const listener of listeners) listener(); };
+  const commit = async (action, key) => {
+    if (state.pending[action]) return;
+    emit({ action: null, candidate: "", pending: { ...state.pending, [action]: true }, errors: { ...state.errors, [action]: null } });
+    try { await save(action, key); emit({ failed: { ...state.failed, [action]: null } }); }
+    catch (error) { emit({ errors: { ...state.errors, [action]: error.reason || "save" }, failed: { ...state.failed, [action]: key } }); }
+    finally { emit({ pending: { ...state.pending, [action]: false } }); }
+  };
+  return {
+    getSnapshot: () => state,
+    subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+    begin(action) { if (!state.pending[action]) { code = null; emit({ action, candidate: "", errors: { ...state.errors, [action]: null } }); } },
+    cancel() { code = null; emit({ action: null, candidate: "" }); },
+    keydown(event) {
+      if (!state.action) return false;
+      if (event.key === "Tab") { this.cancel(); return false; }
+      if (event.key === "Escape") { this.cancel(); return true; }
+      if (event.repeat || event.isComposing) return true;
+      const key = shortcutFromEvent(event);
+      if (!key) return true;
+      const error = voiceShortcutProblem(key, state.action, current());
+      code = error ? null : event.code || event.key;
+      emit({ candidate: error ? "" : key, errors: { ...state.errors, [state.action]: error } });
+      return true;
+    },
+    keyup(event) {
+      if (!state.action) return false;
+      if (event.isComposing || event.repeat) return true;
+      if (code && (event.code || event.key) === code && state.candidate) { const action = state.action, key = state.candidate; code = null; void commit(action, key); }
+      return true;
+    },
+    clear: action => commit(action, ""),
+    retry: action => state.failed[action] != null ? commit(action, state.failed[action]) : Promise.resolve(),
+  };
+}
 export function matchVoiceShortcut(event, shortcuts) {
   if (event.repeat || event.isComposing || event.defaultPrevented) return null;
   const key = shortcutFromEvent(event);

package/voice/speech-segmenter.js

@@ -0,0 +1,119 @@
+import { segment } from "sentencex";
+import { spokenBlocks } from "./spoken-text.js";
+
+const LIMIT = 80, TARGET = 40;
+export const LIST_WAIT_MS = 250;
+const pairs = new Map([["（", "）"], ["(", ")"], ["[", "]"], ["【", "】"], ["{", "}"], ["“", "”"], ["‘", "’"], ["「", "」"], ["『", "』"]]);
+const weight = text => [...text].reduce((n, c) => n + (/\p{Script=Han}|[\u3000-\u303f\uff00-\uffef]/u.test(c) ? 1 : 1 / 3), 0);
+
+function boundaries(text) {
+  const stack = [], positions = new Set();
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === "'" && !(/[\p{L}\p{N}]/u.test(text[i - 1] || "") && /[\p{L}\p{N}]/u.test(text[i + 1] || ""))) {
+      if (stack.at(-1) === "'") stack.pop(); else stack.push("'");
+    } else if (c === '"') { if (stack.at(-1) === '"') stack.pop(); else stack.push('"'); }
+    else if (pairs.has(c)) stack.push(pairs.get(c));
+    else if (stack.at(-1) === c) stack.pop();
+    if (!stack.length) positions.add(i + 1);
+  }
+  return { positions, balanced: !stack.length };
+}
+
+function sentences(text, closed) {
+  const { positions, balanced } = boundaries(text);
+  const ends = new Set();
+  let from = 0;
+  const parts = segment("en", text);
+  for (let i = 0; i < parts.length; i++) {
+    const at = text.indexOf(parts[i], from); if (at < 0) continue;
+    from = at + parts[i].length;
+    if (i < parts.length - 1 || closed) ends.add(from);
+  }
+  for (let i = 0; i < text.length; i++) {
+    if (/[。！？]/.test(text[i])) {
+      let end = i + 1;
+      while (/[”’」』）)\]]/.test(text[end] || "") && end < text.length) end++;
+      ends.add(end);
+    }
+  }
+  if (closed) ends.add(text.length);
+  const out = []; let consumed = 0;
+  for (const end of [...ends].sort((a, b) => a - b)) {
+    if (!positions.has(end) && !(closed && end === text.length)) continue;
+    const sentence = text.slice(consumed, end).trim();
+    if (sentence.includes("\uFFFC")) break;
+    if (sentence) out.push(sentence);
+    consumed = end;
+  }
+  return { out, consumed, balanced };
+}
+
+function clauses(text) {
+  if (weight(text) <= LIMIT) return [text];
+  const { positions } = boundaries(text);
+  const out = []; let start = 0, lastSafe = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (positions.has(i + 1) && /^(?:[，；：]|[,;:](?=\s))/.test(text.slice(i, i + 2))) lastSafe = i + 1;
+    if (lastSafe > start && weight(text.slice(start, i + 1)) >= LIMIT) {
+      out.push(text.slice(start, lastSafe).trim()); start = lastSafe;
+    } else if (lastSafe === i + 1 && weight(text.slice(start, i + 1)) >= TARGET) {
+      out.push(text.slice(start, i + 1).trim()); start = i + 1;
+    }
+  }
+  if (text.slice(start).trim()) out.push(text.slice(start).trim());
+  return out;
+}
+
+/** A turn owns this state. Deadlines are serviced by Host orchestration, not UI timers. */
+export function createNaturalSegmenter({ now = Date.now } = {}) {
+  let source = "", seen = new Map(), pending = [], group = null, deadline = null, ended = false;
+  const listText = items => items.map(item => /[。！？!?；;]$/.test(item) ? item : `${item}；`).join("");
+  const emitList = out => {
+    if (pending.length) out.push(listText(pending));
+    pending = []; group = null; deadline = null;
+  };
+  const update = (text, { done = false } = {}) => {
+    if (ended) { if (text !== source) throw new Error("voice_reply_rewritten"); return []; }
+    source = text;
+    const out = [];
+    if (deadline !== null && now() >= deadline) emitList(out);
+    const blocks = spokenBlocks(source, { done });
+    const present = new Set(blocks.map(block => block.id));
+    for (const id of seen.keys()) if (!present.has(id)) throw new Error("voice_reply_rewritten");
+    for (const block of blocks) {
+      const previous = seen.get(block.id) || "";
+      if (!block.text.startsWith(previous)) throw new Error("voice_reply_rewritten");
+      const text = block.text.slice(previous.length);
+      if (!text) continue;
+      if (block.kind === "list") {
+        if (pending.length && group !== block.group) emitList(out);
+        if (!block.closed || !done && !boundaries(text).balanced || text.includes("\uFFFC")) break;
+        if (weight(listText([text])) > LIMIT) {
+          emitList(out); out.push(...sentences(text, true).out.flatMap(clauses));
+          seen.set(block.id, block.text); continue;
+        }
+        if (pending.length && weight(listText([...pending, text])) > LIMIT) emitList(out);
+        if (!pending.length) { group = block.group; deadline = now() + LIST_WAIT_MS; }
+        pending.push(text); seen.set(block.id, block.text);
+        if (pending.length >= 3 || weight(listText(pending)) >= LIMIT) emitList(out);
+      } else {
+        emitList(out);
+        const ready = sentences(text, block.closed && (done || boundaries(text).balanced));
+        for (const sentence of ready.out) out.push(...clauses(sentence));
+        if (ready.consumed) seen.set(block.id, (previous + text.slice(0, ready.consumed)).trimEnd());
+        if (ready.consumed < text.length) break;
+      }
+    }
+    if (done) { emitList(out); ended = true; }
+    return out;
+  };
+  return {
+    update,
+    push(chunk, options) { return update(source + chunk, options); },
+    finish() { return update(source, { done: true }); },
+    flush() { return update(source); },
+    get deadline() { return deadline; },
+    reset() { source = ""; seen = new Map(); pending = []; group = null; deadline = null; ended = false; },
+  };
+}

package/voice/speech.js

@@ -1,3 +1,14 @@
+let readout = null;
+const readoutListeners = new Set();
+export const readoutState = {
+  getSnapshot: () => readout,
+  subscribe(listener) { readoutListeners.add(listener); return () => readoutListeners.delete(listener); },
+  publish(value) {
+    readout = value ? { ...(readout?.key === value.key ? readout : {}), ...value } : null;
+    for (const listener of readoutListeners) listener();
+  },
+};
+
 /**
  * The utterance a turn may speak: the text of the step being written, read
  * while it streams. Only a step that ends without a tool call answers the
@@ -67,15 +78,22 @@ function withBlock(state, index, text) {
 export function reduceUtterance(state, event) {
   const type = event?.type;
   if (type === "turn/start") return null;
-  if (type === "turn/end") return state && !state.done ? { ...state, done: true } : state;
+  if (type === "turn/end") {
+    if (state && state.turn !== turnOf(event)) return state;
+    const failed = ["error", "cancelled"].includes(event.data?.reason?.kind);
+    return state ? { ...state, done: true, silent: state.silent || failed } : state;
+  }
   const turn = turnOf(event);
   if (turn === null) return state;
   const step = stepOf(event);
-  const same = state?.turn === turn && state.step === step;
+  if (state && (turn < state.turn || turn === state.turn && step < state.step)) return state;
+  const same = state?.turn === turn && state.step === step && (!event.data?.attemptId || state.attemptId === event.data.attemptId);
   if (isChunkEvent(event)) {
     if (same && state.done) return state;
     const chunk = event.data?.chunk;
-    const current = same ? state : stepUtterance(turn, step);
+    let current = same ? state : { ...stepUtterance(turn, step), attemptId: event.data?.attemptId };
+    if (Number.isInteger(event.data?.chunkIndex) && event.data.chunkIndex <= (current.chunkIndex ?? -1)) return current;
+    if (Number.isInteger(event.data?.chunkIndex)) current = { ...current, chunkIndex: event.data.chunkIndex };
     if (opensToolCall(chunk)) return current.silent ? current : { ...current, silent: true };
     const index = Number.isInteger(chunk?.index) ? chunk.index : 0;
     if (chunk?.type === "text-delta" && typeof chunk.text === "string") {
@@ -91,6 +109,8 @@ export function reduceUtterance(state, event) {
     return {
       ...stepUtterance(turn, step),
       text: assistantText(event),
+      messageId: event.data?.message?.id ?? event.data?.messageId,
+      attemptId: same ? state.attemptId : undefined,
       done: true,
       silent: Boolean(event.data?.interrupted) || content.some((block) => block?.type === "tool-call"),
     };
@@ -165,24 +185,33 @@ const BOUNDARY = /[.!?;。！？；…\n]/;
  *   fail?: (err: unknown) => void,
  * }} io
  */
-export function createSentencePlayer({ send, play, halt, silence, fail = () => {}, onState = () => {} }) {
+export function createSentencePlayer({ send, play, halt, silence, fail = () => {}, onState = () => {}, onOutput = readoutState.publish, stream }) {
   let gen = 0;
   let current = null;
   // An utterance is read once: finishing it, failing, or being stopped all end it for good.
   let lastKey = null;
   let silencedKey = null;
+  const consumed = new Set();
+  const mutedTurns = new Set();
+  let lastTurn = null;
+  const turnKey = (value) => Number.isFinite(value.turn) ? `${value.sessionId ?? ""}:${value.turn}` : null;
+  const mark = (set, key) => { if (key != null) set.add(key); };
 
+  const emitOutput = value => {
+    if (value || readoutState.getSnapshot()?.key === lastKey || onOutput !== readoutState.publish) onOutput(value);
+  };
   const failed = (run, err) => {
     if (run.gen !== gen) return;
+    run.abort?.abort();
     gen += 1;
     run.wake?.();
     current = null;
-    onState(false);
-    if (err?.code !== "voice_cancelled") fail(err);
+    onState(false); emitOutput(null);
+    if (!["voice_cancelled", "voice_output_owned"].includes(err?.code || err?.message)) { emitOutput({ ...run.identity, status: "error", error: err?.code || err?.message || "voice_playback_failed", stop: () => emitOutput(null) }); fail(err); }
   };
 
   const handOver = (run) => {
-    if (run.sending || run.gen !== gen) return;
+    if (stream || run.sending || run.gen !== gen) return;
     const due = (run.done && !run.sentDone) || BOUNDARY.test(run.text.slice(run.sentLength));
     if (!due) return;
     const { text, done } = run;
@@ -207,6 +236,11 @@ export function createSentencePlayer({ send, play, halt, silence, fail = () => {
   };
 
   const read = async (run) => {
+    if (stream) {
+      await stream({ key: run.key, text: run.text, source: run.source, signal: run.abort.signal, controls: (value) => { if (run.gen === gen) run.controls = value; }, onStatus: (status) => { if (run.gen === gen) { if (status === "playing") onState(true); emitOutput({ key: run.key, status }); } } });
+      if (run.gen === gen) { current = null; onState(false); emitOutput(null); }
+      return;
+    }
     let next = null;
     for (let part = 0; run.gen === gen;) {
       if (part >= run.sent) {
@@ -220,15 +254,16 @@ export function createSentencePlayer({ send, play, halt, silence, fail = () => {
       await play(sentence);
       part += 1;
     }
-    if (run.gen === gen) { current = null; onState(false); }
+    if (run.gen === gen) { current = null; onState(false); emitOutput(null); }
   };
 
   const stop = () => {
     gen += 1;
+    current?.abort?.abort();
     current?.wake?.();
     if (current) halt();
     current = null;
-    onState(false);
+    onState(false); emitOutput(null);
   };
 
   return {
@@ -243,14 +278,20 @@ export function createSentencePlayer({ send, play, halt, silence, fail = () => {
         return;
       }
       if (!utterance.text) return;
+      const identity = turnKey(utterance);
+      if (identity && mutedTurns.has(identity)) return;
+      // A later tool call can invalidate uncommitted assistant text.
+      if (stream && !utterance.done && !utterance.source) return;
       if (current?.key !== utterance.key) {
-        if (utterance.key === lastKey) return;
-        if (current) stop();
+        if (consumed.has(utterance.key)) return;
+        if (current) { mark(mutedTurns, lastTurn); stop(); }
         gen += 1;
-        lastKey = utterance.key;
+        lastKey = utterance.key; lastTurn = identity; mark(consumed, lastKey);
         current = {
           gen,
+          abort: new AbortController(),
           key: utterance.key,
+          source: utterance.source,
           text: utterance.text,
           done: utterance.done,
           sent: 0,
@@ -259,8 +300,9 @@ export function createSentencePlayer({ send, play, halt, silence, fail = () => {
           sending: null,
           wake: null,
         };
+        current.identity = utterance;
         const run = current;
-        onState(true);
+        onState(true); emitOutput({ ...utterance, status: "preparing", stop: () => { mark(mutedTurns, lastTurn); stop(); silence(); } });
         handOver(run);
         read(run).catch((err) => failed(run, err));
         return;
@@ -269,7 +311,12 @@ export function createSentencePlayer({ send, play, halt, silence, fail = () => {
       current.done = utterance.done;
       handOver(current);
     },
+    get key() { return current?.key; },
+    get canPause() { return current?.controls?.canPause === true; },
+    pause() { if (!current?.controls?.canPause) return false; current.controls.pause(); emitOutput({ key: current.key, status: "confirming" }); return true; },
+    resume() { if (!current?.controls?.canPause) return false; current.controls.resume(); emitOutput({ key: current.key, status: "playing" }); return true; },
     stop() {
+      mark(mutedTurns, lastTurn);
       stop();
       silence();
     },

package/voice/spoken-text.js

@@ -0,0 +1,196 @@
+import emojiRegex from "emoji-regex";
+import MarkdownIt from "markdown-it";
+
+const markdown = new MarkdownIt({ html: false, linkify: false, typographer: false });
+const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+markdown.inline.ruler.before("backticks", "speech_open_code", (state, silent) => {
+  if (!silent && state.env.streaming && state.src[state.pos] === "`") {
+    const marks = state.src.slice(state.pos).match(/^`+/)[0];
+    const rest = state.src.slice(state.pos + marks.length);
+    if (![...rest.matchAll(/`+/g)].some((match) => match[0].length === marks.length)) {
+      state.env.pending = Math.min(state.env.pending, state.pos);
+    }
+  }
+  return false;
+});
+
+// Retain parser positions only for this invocation; no state survives a turn.
+markdown.inline.ruler.before("strikethrough", "speech_delimiters", (state, silent) => {
+  if (silent || !state.env.streaming || !/[*_~]/.test(state.src[state.pos])) return false;
+  const positions = state.env.states.get(state) ?? new Map();
+  state.env.states.set(state, positions);
+  const scanned = state.scanDelims(state.pos, state.src[state.pos] !== "_");
+  const first = state.tokens.length + (state.pending ? 1 : 0);
+  for (let index = 0; index < scanned.length; index++) positions.set(first + index, state.pos + index);
+  return false;
+});
+markdown.inline.ruler2.before("fragments_join", "speech_unclosed_pairs", (state) => {
+  if (!state.env.streaming) return;
+  const positions = state.env.states.get(state);
+  for (const delimiter of state.delimiters) {
+    if (delimiter.open && delimiter.end < 0 && state.tokens[delimiter.token]?.type === "text") {
+      state.env.pending = Math.min(state.env.pending, positions?.get(delimiter.token) ?? Infinity);
+    }
+  }
+});
+markdown.inline.ruler.push("speech_incomplete", (state, silent) => {
+  if (!silent && state.env.streaming && /[\[!`<&\\]/.test(state.src[state.pos])) {
+    state.env.pending = Math.min(state.env.pending, state.pos);
+  }
+  return false;
+});
+
+function tokensText(tokens) {
+  return tokens.map((token) => {
+    if (token.type === "image") return tokensText(token.children ?? []);
+    if (token.type === "softbreak" || token.type === "hardbreak") return "\n";
+    return token.type === "text" || token.type === "code_inline" ? token.content : "";
+  }).join("");
+}
+
+function inlineText(source, streaming, references) {
+  const env = { streaming, references, pending: Infinity, states: new Map() };
+  let tokens = markdown.parseInline(source, env)[0].children;
+  if (Number.isFinite(env.pending)) tokens = markdown.parseInline(source.slice(0, env.pending), { references })[0].children;
+  const last = tokens.findLast((token) => token.type === "image" || token.content?.trim());
+  return { text: tokensText(tokens), pending: Number.isFinite(env.pending) || last?.type === "image" && !tokensText(last.children ?? []).trim() };
+}
+
+const RULE_LINE = /^\s*(?:\|?\s*:?-{3,}:?\s*)+\|?\s*$|^\s*([-*_])(?:\s*\1){2,}\s*$/;
+const BLOCK_MARK = /^\s*(?:>(?:[ \t]+|$))*(?:#{1,6}\s+|[-*+]\s+(?:\[[ xX]\]\s+)?|\d{1,9}[.)]\s+)?/;
+
+function blockLine(line, table = false) {
+  if (RULE_LINE.test(line)) return "";
+  let content = line.replace(BLOCK_MARK, "");
+  if (/^\s*(?:>\s*)*#{1,6}\s+/.test(line)) content = content.replace(/[ \t]+#+[ \t]*$/, "");
+  if (!table && !/^\s*\|.*\|\s*$/.test(content)) return content;
+  // Only table framing is removed; inline code and escaped pipes are content.
+  return content.trim().replace(/^\||(?<!\\)\|$/g, "").replace(/\\.|(`+)[\s\S]*?\1|\|/g, (match) => match === "|" ? " " : match);
+}
+
+function pipeAt(line) {
+  return [...line.matchAll(/\\.|(`+)[\s\S]*?\1|\|/g)].find((match) => match[0] === "|")?.index;
+}
+
+function blockText(source, done) {
+  const rows = new Set(), visible = new Set(), env = {};
+  for (const token of markdown.parse(source, env)) {
+    if (token.type === "tr_open" && token.map) rows.add(token.map[0]);
+    if (["inline", "code_block", "tr_open"].includes(token.type) && token.map) {
+      for (let line = token.map[0]; line < token.map[1]; line++) visible.add(line);
+    }
+  }
+  if (!done) {
+    const complete = {};
+    markdown.parse(source.slice(0, source.lastIndexOf("\n") + 1), complete);
+    env.references = complete.references;
+  }
+  return {
+    text: source.split("\n").map((line, index) => visible.has(index) ? blockLine(line, rows.has(index)) : "").join("\n"),
+    references: env.references,
+  };
+}
+
+function withoutEmoji(text) {
+  return text.replace(emojiRegex(), (match) => {
+    if (/^[0-9#*]\uFE0F?\u20E3$/.test(match)) return match[0];
+    if (/^[©®™]$/.test(match)) return match;
+    return " ";
+  });
+}
+
+/** The assistant's spoken copy; never apply this to stored messages or raw TTS API input. */
+function prepareSource(text, done, structural = false) {
+  let pending = false;
+  const skip = (match, offset, source) => {
+    if (offset + match.length >= source.trimEnd().length) pending = true;
+    return structural ? "\n\n---\n\n" : " ";
+  };
+  let source = String(text ?? "")
+    .replace(/<think\b[^>]*>[\s\S]*?<\/think>/gi, skip)
+    .replace(/^[\s\S]*?<\/think>/i, skip)
+    .replace(/<think\b[\s\S]*$/i, () => { pending = true; return ""; })
+    .replace(/(`{3,}|~{3,})[\s\S]*?\1/g, (match, _marks, offset, source) => skip(match, offset, source));
+  const openFence = /`{3,}|~{3,}/.exec(source);
+  if (openFence) { pending = true; source = source.slice(0, openFence.index); }
+  if (!done) {
+    const lines = source.split("\n");
+    let candidate = lines.length - 1;
+    // An unfinished separator can still turn the preceding line into a table.
+    if (candidate > 0 && /^[\s|:-]*$/.test(lines[candidate]) && !RULE_LINE.test(lines[candidate - 1]) && pipeAt(lines[candidate - 1]) !== undefined) candidate--;
+    const pipe = pipeAt(lines[candidate]);
+    if (pipe !== undefined) {
+      source = [...lines.slice(0, candidate), lines[candidate].slice(0, pipe)].join("\n");
+      pending = true;
+    }
+  }
+  return { source, pending };
+}
+
+export function spokenLines(text, { done = true } = {}) {
+  let { source, pending } = prepareSource(text, done);
+  const blocks = blockText(source, done);
+  const inline = inlineText(blocks.text, !done, blocks.references);
+  // An opaque unfinished tail keeps earlier completed sentences eligible. It
+  // is always the final, withheld sentence and never reaches synthesis.
+  let plain = inline.text;
+  if (!done) {
+    const lineStart = plain.lastIndexOf("\n") + 1;
+    const end = plain.slice(lineStart).trimEnd();
+    const tail = [...graphemes.segment(end)].at(-1);
+    if (tail && (emojiRegex().test(tail.segment) || /[\uD800-\uDBFF]$/.test(tail.segment))) {
+      plain = plain.slice(0, lineStart) + end.slice(0, tail.index);
+      pending = true;
+    }
+    if (pending || inline.pending) plain += "\uFFFC";
+  }
+  return withoutEmoji(plain).split("\n").map((line) => line.replace(/\s+/g, " ").trim());
+}
+
+
+/** Structural units for speech aggregation; rendered/stored Markdown is untouched. */
+export function spokenBlocks(text, { done = true } = {}) {
+  const { source, pending } = prepareSource(text, done, true);
+  const env = {}, tokens = markdown.parse(source, env);
+  const references = blockText(source, done).references;
+  const last = tokens.findLastIndex(token => ["inline", "code_block"].includes(token.type));
+  const lists = [], items = [], result = [];
+  let heading = false, barrier = 0, rowLine = 0;
+  const paragraphs = new Set(), tableRows = new Set();
+  for (const [index, token] of tokens.entries()) {
+    if (token.type === "tr_open") { rowLine = token.map[0]; }
+    if (token.type === "hr" || token.type === "fence") barrier++;
+    if (token.type.endsWith("list_open")) lists.push(`${token.map[0]}:${token.level}`);
+    else if (token.type.endsWith("list_close")) lists.pop();
+    else if (token.type === "list_item_open") items.push(token.map[0]);
+    else if (token.type === "list_item_close") items.pop();
+    else if (token.type === "heading_open") heading = true;
+    else if (token.type === "heading_close") heading = false;
+    else if (["inline", "code_block"].includes(token.type)) {
+      if (!token.map && tableRows.has(rowLine)) continue;
+      if (!token.map) tableRows.add(rowLine);
+      const map = token.map || [rowLine, rowLine + 1];
+      const id = token.map ? `${map[0]}:${token.type}` : `${map[0]}:table`;
+      const nextBlock = tokens.slice(index + 1).some(next => next.map && next.map[0] >= map[1]);
+      const closed = done || nextBlock || (token.map ? index < last || map[1] < source.split("\n").length - 1 : map[1] <= source.split("\n").length - 1);
+      const content = token.type === "inline" && token.map
+        ? source.split("\n").slice(map[0], map[1]).map(line => blockLine(line)).join("\n")
+        : token.map ? token.content : blockLine(source.split("\n")[rowLine], true);
+      const inline = inlineText(content, !done, references);
+      let plain = inline.text, opaque = inline.pending || index === last && pending && map[1] >= source.split("\n").length;
+      if (!done && !closed) {
+        const tail = [...graphemes.segment(plain.trimEnd())].at(-1);
+        if (tail && (emojiRegex().test(tail.segment) || /[\uD800-\uDBFF]$/.test(tail.segment))) { plain = plain.slice(0, tail.index); opaque = true; }
+      }
+      if (!done && opaque) plain += "\uFFFC";
+      plain = withoutEmoji(plain).replace(/\s+/g, " ").trim();
+      const continuation = lists.length && paragraphs.has(items.at(-1));
+      if (lists.length) paragraphs.add(items.at(-1));
+      if (plain) result.push({ id, text: plain, closed,
+        kind: lists.length && !continuation ? "list" : heading ? "heading" : "paragraph",
+        group: `${lists.at(-1)}:${barrier}`, item: items.at(-1), depth: lists.length });
+    }
+  }
+  return result;
+}

package/voice/startup.js

@@ -0,0 +1,9 @@
+/** Startup timing contains only a stage and duration, never content or credentials. */
+export function recordVoiceStartup(stage, durationMs) {
+  const fields = { stage, durationMs: Math.max(0, durationMs) };
+  try {
+    const clock = globalThis.performance;
+    clock?.measure?.(`lares.voice.startup.${stage}`, { start: Math.max(0, clock.now() - fields.durationMs), duration: fields.durationMs, detail: fields });
+    globalThis.console?.debug?.("[lares.voice.startup]", fields);
+  } catch { /* Observability cannot block recording. */ }
+}