@olares/lares-core 0.15.12 → 0.15.14

package/i18n/voice.js

@@ -1,4 +1,56 @@
 export const ZH = {
+  "input.keyboard": "键盘",
+  "input.stopSpeaking": "停止朗读",
+  "gesture.cancelRelease": "松开取消",
+  "gesture.slideCancel": "上滑取消",
+  "gesture.release": "松开发送",
+  "gesture.waiting": "按住说话，松开发送",
+  "gesture.keyboard": "按住空格说话 · Esc 取消 · 回车开始／结束",
+
+  "error.voice_capture_limit": "录音已达到一分钟上限，请重新录制较短内容；本次未自动提交。",
+  "dictation.settings": "听写处理",
+  "dictation.preset": "文字处理方式",
+  "dictation.configure": "配置预设",
+  "dictation.raw": "原文转写",
+  "dictation.clean": "简单清洗",
+  "dictation.outline": "整理提纲",
+  "dictation.summary": "简洁总结",
+  "dictation.model": "处理模型",
+  "dictation.instructions": "处理指令",
+  "dictation.reset": "恢复默认指令",
+  "dictation.noLlm": "直接使用识别结果，不调用语言模型。",
+  "dictation.finish": "完成",
+  "dictation.insert": "放入输入框",
+  "dictation.discard": "放弃",
+  "dictation.original": "查看原文",
+  "dictation.processing": "正在整理文字…",
+  "dictation.preview": "预览并编辑",
+  "dictation.retry": "重试",
+  "dictation.useOriginal": "使用原文",
+  "dictation.replaceEdited": "重新整理将替换你的编辑，是否继续？",
+  "dictation.hold": "按住说话",
+  "dictation.release": "松开发送 · 上滑取消",
+  "dictation.holdHint": "按住说话，松开发送；也可按住空格，或按回车开始／结束。",
+  "dictation.speaking": "正在回复 · 按住说话可打断",
+  "dictation.shortcut": "默认听写快捷键",
+  "dictation.shortcutHint": "按组合键设置，退格清除；仅当前页面生效。",
+  "dictation.shortcutConflict": "快捷键重复、被占用或格式不支持，请换一个组合键。",
+  "error.voice_dictation_model_missing": "请先在设置中选择此预设的处理模型，或使用原文转写。",
+  "error.voice_manual_realtime_unavailable": "Realtime 暂不支持按住说话，请在设置中使用普通语音后端。",
+
+  "panel.title": "语音",
+  "panel.close": "关闭",
+  "panel.paused": "语音已暂停",
+  "panel.start": "开始",
+  "panel.continue": "继续",
+  "panel.pause": "暂停",
+  "panel.complete": "完成听写",
+  "panel.discard": "丢弃听写",
+  "panel.draft": "听写草稿",
+  "panel.draftHint": "识别结果会保留在这里，完成后追加到输入框。",
+  "panel.messages": "完整回复显示在当前会话中。关闭此面板会暂停音频，任务继续执行。",
+  "panel.elapsed": "录音时长",
+
   "settings.backend": "语音后端",
   "settings.backend.pipeline": "STT → Lares → TTS",
   "settings.realtime.model": "Realtime 模型",
@@ -181,6 +233,58 @@ export const ZH = {
 };
 
 export const EN = {
+  "input.keyboard": "Keyboard",
+  "input.stopSpeaking": "Stop speaking",
+  "gesture.cancelRelease": "Release to cancel",
+  "gesture.slideCancel": "Slide up to cancel",
+  "gesture.release": "Release to send",
+  "gesture.waiting": "Hold to speak, release to send",
+  "gesture.keyboard": "Hold Space · Esc to cancel · Enter to start/finish",
+
+  "error.voice_capture_limit": "Recording reached the one-minute limit. Record a shorter take; nothing was submitted.",
+  "dictation.settings": "Dictation processing",
+  "dictation.preset": "Text processing",
+  "dictation.configure": "Configure preset",
+  "dictation.raw": "Original transcript",
+  "dictation.clean": "Light cleanup",
+  "dictation.outline": "Outline",
+  "dictation.summary": "Concise summary",
+  "dictation.model": "Processing model",
+  "dictation.instructions": "Processing instructions",
+  "dictation.reset": "Restore default instructions",
+  "dictation.noLlm": "Use the ASR result directly without a language model.",
+  "dictation.finish": "Done",
+  "dictation.insert": "Insert into composer",
+  "dictation.discard": "Discard",
+  "dictation.original": "View original",
+  "dictation.processing": "Refining text…",
+  "dictation.preview": "Preview and edit",
+  "dictation.retry": "Retry",
+  "dictation.useOriginal": "Use original",
+  "dictation.replaceEdited": "Processing again will replace your edits. Continue?",
+  "dictation.hold": "Hold to speak",
+  "dictation.release": "Release to send · Slide up to cancel",
+  "dictation.holdHint": "Hold to speak, release to send. Hold Space, or press Enter to start/finish.",
+  "dictation.speaking": "Speaking · Hold to interrupt",
+  "dictation.shortcut": "Default dictation shortcut",
+  "dictation.shortcutHint": "Press a key combination; Backspace clears it. Active page only.",
+  "dictation.shortcutConflict": "Duplicate, reserved or unsupported shortcut. Choose another combination.",
+  "error.voice_dictation_model_missing": "Select a processing model in Settings or use the original transcript.",
+  "error.voice_manual_realtime_unavailable": "Realtime does not yet support push-to-talk. Select the pipeline backend in Settings.",
+
+  "panel.title": "Voice",
+  "panel.close": "Close",
+  "panel.paused": "Voice paused",
+  "panel.start": "Start",
+  "panel.continue": "Continue",
+  "panel.pause": "Pause",
+  "panel.complete": "Complete dictation",
+  "panel.discard": "Discard dictation",
+  "panel.draft": "Dictation draft",
+  "panel.draftHint": "Recognized text stays here until you complete dictation.",
+  "panel.messages": "Replies appear in this conversation. Closing pauses audio; tasks keep running.",
+  "panel.elapsed": "Recording time",
+
   "settings.backend": "Voice backend",
   "settings.backend.pipeline": "STT → Lares → TTS",
   "settings.realtime.model": "Realtime model",

package/larepass/runtime.js

@@ -864,11 +864,11 @@ export function createChatRuntime(client) {
     },
     voiceSocket(ticket) { return client.voiceSocket(ticket); },
     voiceRequest(path, options) { return client.voiceRequest(path, options); },
-    transcribe(blob, language, signal) {
+    transcribe(blob, language, signal, model) {
       if (typeof client.transcribe !== "function") {
         return Promise.reject(new Error("voice_failed"));
       }
-      return client.transcribe(blob, language, signal);
+      return client.transcribe(blob, language, signal, model);
     },
     reportLog(scope, event, fields) {
       if (typeof client.reportLog !== "function") return Promise.resolve(false);

package/larepass/settings.js

@@ -8,6 +8,8 @@ import {
 
 const modelsStore = createSnapshotStore();
 const voiceStore = createSnapshotStore();
+const voiceListeners = new Set();
+export function subscribeVoiceSettings(listener) { voiceListeners.add(listener); const current = voiceStore.peek(); if (current) listener(current); return () => voiceListeners.delete(listener); }
 const searchStore = createSnapshotStore();
 const conversationStore = createSnapshotStore();
 const conversationListeners = new Set();
@@ -112,7 +114,9 @@ export function createHostSettings(request) {
         await request("/api/lares/voice/config", { method: "POST", body: patch }),
         "/api/lares/voice/config",
       );
-      return this.voice(true);
+      const value = await this.voice(true);
+      for (const listener of voiceListeners) listener(value);
+      return value;
     },
     async search(options = {}) {
       const query = options.force ? "?refresh=1" : "";

package/larepass/transcript.js

@@ -114,10 +114,15 @@ export function foldTranscript(entries) {
   let utterance = null;
   let streamCursor = { loc: "", kind: "", index: 0 };
   let activeTurn = 0;
+  let activeSeq = -1;
+  let activeRequest = null;
   const ended = new Map();
 
   const tag = (row) => {
     row.turn = activeTurn;
+    row.anchorSeq = activeSeq;
+    row.key ||= `dsh:${activeSeq}:${row.type}`;
+    if (row.type === "user") row.requestId = activeRequest;
     return row;
   };
 
@@ -234,6 +239,8 @@ export function foldTranscript(entries) {
 
   for (const entry of Array.isArray(entries) ? entries : []) {
     const event = eventOf(entry);
+    activeSeq = event?.seq ?? activeSeq;
+    if (event?.type === "user/message") activeRequest = event.data?.requestId ?? event.data?.source?.rpcId ?? null;
     if (!event) continue;
     const data = event.data ?? {};
     const view = entryView(entry, event);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olares/lares-core",
-  "version": "0.15.12",
+  "version": "0.15.14",
   "description": "Lares 共享业务核心：Router、workspace、文件/媒体、Olares 身份（无 UI、无平台壳）",
   "type": "module",
   "repository": {
@@ -189,7 +189,13 @@
     "./voice/external": "./voice/external.js",
     "./voice/composite-gateway": "./voice/composite-gateway.js",
     "./voice/router-audio": "./voice/router-audio.js",
-    "./voice/protocol-client": "./voice/protocol-client.js"
+    "./voice/protocol-client": "./voice/protocol-client.js",
+    "./voice/presentation": "./voice/presentation.js",
+    "./voice/hold": "./voice/hold.js",
+    "./voice/dictation": "./voice/dictation.js",
+    "./voice/shortcuts": "./voice/shortcuts.js",
+    "./voice/panel": "./voice/panel.js",
+    "./voice/projection": "./voice/projection.js"
   },
   "dependencies": {
     "ws": "^8.22.0"

package/voice/agent-session.js

@@ -5,7 +5,7 @@ import { reduceUtterance } from "./speech.js";
 export const SPOKEN_PROMPT = "This is a voice conversation. Keep user-facing answers concise and natural for speech. Do not read reasoning or tool payloads aloud. Preserve the task's factual results and use the user's language.";
 
 /** dsh opens a turn before claiming input; rpcId associates input with that open turn. */
-export function createVoiceAgentSession(api, { sessionId = null, preset, workspaceId, restoredRequests = [], metric = () => {} } = {}) {
+export function createVoiceAgentSession(api, { sessionId = null, preset, workspaceId, restoredRequests = [], onChange = () => {}, metric = () => {} } = {}) {
   let creating;
   let following;
   let closed = false;
@@ -26,7 +26,7 @@ export function createVoiceAgentSession(api, { sessionId = null, preset, workspa
   const decoder = createSessionFollow();
   const unfinished = (task) => ["accepted", "running", "waiting", "unknown"].includes(task.status);
   const snapshot = () => ({ sessionId, running: observedRunning || [...requests.values()].some(unfinished), utterance, error, version,
-    requestId: latestRequest,
+    requestId: latestRequest, cursor,
     tasks: [...requests.values()].map(({ requestId, turn, status, utterance: reply, error: taskError }) => ({ requestId, turn, status, text: reply?.silent ? "" : reply?.text || "", error: taskError })),
   });
   const ensure = async () => {
@@ -68,7 +68,7 @@ export function createVoiceAgentSession(api, { sessionId = null, preset, workspa
       if (!replay && task.requestId === latestRequest) { utterance = task.utterance; error = task.error; }
     }
     if (event.type === "turn/end" && openTurn === event.data?.turn) { openTurn = null; observedRunning = false; }
-    version++;
+    version++; onChange();
   };
   const follow = () => {
     if (following && !following.signal.aborted) return ready;
@@ -100,6 +100,7 @@ export function createVoiceAgentSession(api, { sessionId = null, preset, workspa
   };
   return {
     snapshot,
+    async ensureSession() { await ensure(); await follow(); return snapshot(); },
     async open() { if (sessionId) await follow(); },
     async resume() {
       following?.abort(); await followTask;

package/voice/capture.js

@@ -106,7 +106,7 @@ export function createCaptureSession(io) {
     else job.stop = true;
   }
 
-  async function start() {
+  async function start({ manual = false } = {}) {
     if (job && (job.phase === "preparing" || job.phase === "recording" || job.phase === "transcribing")) {
       const previous = job;
       previous.cancel = true;
@@ -171,7 +171,10 @@ export function createCaptureSession(io) {
           if (run.phase === "recording" && now() - run.seen > CLIENT_LOST_MS) run.cancel = true;
           const available = await io.read(offset);
           const fresh = available.subarray(0, Math.max(0, MAX_CAPTURE_BYTES - pcm.length));
-          if (fresh.length < available.length || now() - started >= MAX_CAPTURE_MS) run.stop = true;
+          if (fresh.length < available.length || now() - started >= MAX_CAPTURE_MS) {
+            if (manual) { await io.close?.(); run.phase = "error"; run.error = "voice_capture_limit"; return; }
+            run.stop = true;
+          }
           offset += fresh.length;
           if (fresh.length) {
             pcm = Buffer.concat([pcm, fresh]);
@@ -192,7 +195,7 @@ export function createCaptureSession(io) {
             }
             if (level.audible) live = true;
             if (level.audible && level.rms >= ENDPOINT.floor) spoke = true;
-            if (live && endpoint.push(1, level.rms, FRAME_MS)) run.stop = true;
+            if (!manual && live && endpoint.push(1, level.rms, FRAME_MS)) run.stop = true;
           }
           if (run.cancel) {
             await io.close?.();

package/voice/client.js

@@ -109,7 +109,9 @@ export async function saveVoiceSettings(patch) {
     body: JSON.stringify(patch),
   });
   if (!res.ok) throw new Error(String(res.status));
-  return loadVoiceSettings({ force: true });
+  const next = await loadVoiceSettings({ force: true });
+  globalThis.window?.dispatchEvent?.(new Event("lares-voice-settings"));
+  return next;
 }
 
 /** Reading mode and the GPU slicing it needs; see core/voice/gpu-mode.js. */
@@ -239,7 +241,10 @@ export async function postBluetoothReady(signal) {
  * do ride the port — all succeed.
  */
 export async function postTranscribe(blob, language, signal, options = {}) {
-  const query = language ? `?language=${encodeURIComponent(language)}` : "";
+  const params = new URLSearchParams();
+  if (language !== undefined) params.set("language", language || "");
+  if (options.model !== undefined) params.set("model", options.model || "");
+  const query = params.size ? `?${params}` : "";
   const base = String(options.baseUrl ?? API).replace(/\/$/, "");
   const url = `${base}/transcribe${query}`;
   const headers = { "content-type": blob.type || "audio/webm" };

package/voice/config.js

@@ -6,6 +6,9 @@ export { STT_LANGUAGE_CHOICES, VOICE_AUTO, voiceMenuValue, voiceValueFromMenu }
 
 import { VOICE_DEFAULTS as DEFAULTS, VOICE_PRESETS } from "./options.js";
 
+import { DICTATION_PRESETS, validateDictationProfiles } from "./dictation.js";
+import { validateVoiceShortcuts } from "./shortcuts.js";
+
 const WRITABLE = new Set(Object.keys(DEFAULTS));
 const SUPPORTED_LANGUAGES = new Set(["", ...STT_LANGUAGE_CHOICES.map((item) => item.id)]);
 const SAFE_MODEL = /^[^\u0000-\u001f\u007f]{0,512}$/;
@@ -20,6 +23,14 @@ export function validateConfigPatch(raw) {
   const patch = {};
   for (const [key, value] of Object.entries(raw)) {
     if (!WRITABLE.has(key)) invalid(`unknown voice setting: ${key}`);
+    if (key === "dictationPreset") {
+      if (!DICTATION_PRESETS.includes(value)) invalid("invalid dictation preset");
+      patch[key] = value; continue;
+    }
+    if (key === "dictationProfiles" || key === "dictationShortcuts") {
+      try { patch[key] = key === "dictationProfiles" ? validateDictationProfiles(value) : validateVoiceShortcuts(value); } catch { invalid("invalid dictation configuration"); }
+      continue;
+    }
     if (key === "preset") {
       if (!VOICE_PRESETS.includes(value)) invalid("invalid voice preset");
       patch[key] = value; continue;
@@ -33,7 +44,7 @@ export function validateConfigPatch(raw) {
       patch[key] = value;
       continue;
     }
-    if (key === "speak" || key === "streaming" || key === "dictationCleanup") {
+    if (key === "speak" || key === "streaming") {
       if (typeof value !== "boolean") invalid(`${key} must be a boolean`);
       patch[key] = value;
       continue;
@@ -61,12 +72,13 @@ function configPath() {
 /** @returns {typeof DEFAULTS} */
 export function readConfig() {
   const stored = readJsonFile(configPath());
-  const merged = { ...DEFAULTS };
+  const merged = structuredClone(DEFAULTS);
   for (const key of Object.keys(DEFAULTS)) {
     if (stored?.[key] !== undefined) {
       try { Object.assign(merged, validateConfigPatch({ [key]: stored[key] })); } catch {}
     }
   }
+  if (!stored?.dictationPreset && typeof stored?.dictationCleanup === "boolean") merged.dictationPreset = stored.dictationCleanup ? "clean" : "raw";
   return merged;
 }
 

package/voice/controller.js

@@ -3,6 +3,7 @@ import { mintRpcId } from "../larepass/rpc.js";
 /** Device, agent and playback ports are injected; UI frameworks own no turn state. */
 export function createVoiceController({ input, agent, output, voiceId = mintRpcId(), metric = () => {}, onTranscript = null, idleTimeoutMs = 300_000, recoveryTimeoutMs = 120_000, onExpired = () => {}, now = Date.now, schedule = setTimeout, unschedule = clearTimeout }) {
   let epoch = 0;
+  let manualTurns = false;
   let take = null;
   let idleTimer = null;
   let recoveryTimer = null;
@@ -19,7 +20,7 @@ export function createVoiceController({ input, agent, output, voiceId = mintRpcI
     idleTimer.unref?.();
   };
   let creating = null;
-  let state = Object.freeze({ voiceId, sessionId: null, connection: "closed", capture: "idle", agent: "idle", playback: "idle", continuous: false, inputPaused: false, userSpeaking: false, inputLevel: null, outputMuted: false, error: null });
+  let state = Object.freeze({ voiceId, sessionId: null, connection: "closed", capture: "idle", agent: "idle", playback: "idle", continuous: false, inputPaused: false, userSpeaking: false, inputLevel: null, inputReady: false, outputMuted: false, error: null });
   const listeners = new Set();
   const change = (patch) => {
     state = Object.freeze({ ...state, ...patch });
@@ -51,15 +52,15 @@ export function createVoiceController({ input, agent, output, voiceId = mintRpcI
   };
   const listen = async () => {
     if (state.connection !== "open" || state.inputPaused || take || state.capture !== "idle") return;
-    if (state.continuous && (
+    if (!manualTurns && state.continuous && (
       (state.agent !== "idle" && !input.capabilities?.listenWhileWorking)
       || (state.playback !== "idle" && !input.capabilities?.bargeIn)
     )) return;
     const run = { epoch, abort: new AbortController(), id: mintRpcId(), started: now() };
     take = run;
-    change({ capture: "recording", error: null });
+    change({ capture: "recording", inputReady: false, error: null });
     try {
-      const text = String(await input.capture({ signal: run.abort.signal, continuous: state.continuous, onLevel: (level) => { if (live(run)) change({ inputLevel: Math.max(0, Math.min(1, level)) }); }, onSpeech: () => {
+      const text = String(await input.capture({ signal: run.abort.signal, continuous: state.continuous && !manualTurns, onReady: () => { if (live(run)) change({ inputReady: true }); }, onLevel: (level) => { if (live(run)) change({ inputLevel: Math.max(0, Math.min(1, level)) }); }, onSpeech: () => {
         if (live(run)) { touch(); change({ userSpeaking: true }); if (input.capabilities?.bargeIn) void stopPlayback(); }
       }, onTranscribing: () => { if (live(run)) change({ capture: "transcribing", userSpeaking: false }); } }) ?? "").trim();
       if (!live(run)) return;
@@ -83,7 +84,7 @@ export function createVoiceController({ input, agent, output, voiceId = mintRpcI
       if (take === run) {
         take = null;
         change({ capture: "idle", userSpeaking: false, inputLevel: null });
-        if (state.continuous && state.connection === "open" && (state.agent === "idle" || input.capabilities?.listenWhileWorking) && state.playback === "idle") {
+        if (!manualTurns && state.continuous && state.connection === "open" && (state.agent === "idle" || input.capabilities?.listenWhileWorking) && state.playback === "idle") {
           queueMicrotask(() => { void listen(); });
         }
       }
@@ -95,16 +96,18 @@ export function createVoiceController({ input, agent, output, voiceId = mintRpcI
     setOutputMuted(outputMuted) { change({ outputMuted }); },
     bindSession(sessionId) { if (sessionId) change({ sessionId }); },
     subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
-    async start({ sessionId = null, continuous = false, running = false } = {}) {
+    async start({ sessionId = null, continuous = false, running = false, manual = false, shouldStart = () => true } = {}) {
+      manualTurns = manual;
       const startedEpoch = ++epoch;
       creating = null;
       await cancelInput();
       if (startedEpoch !== epoch) return;
       await stopPlayback();
       if (startedEpoch !== epoch) return;
+      if (!shouldStart()) return;
       change({ voiceId, sessionId, continuous, inputPaused: false, connection: "open", agent: running ? "running" : "idle", error: null });
       clearTimers(); touch();
-      void listen();
+      if (!manualTurns) void listen();
     },
     listen,
     stopRecording: () => input.stop?.(),
@@ -118,12 +121,19 @@ export function createVoiceController({ input, agent, output, voiceId = mintRpcI
     observeAgent(running, playbackExpected = false) {
       if (playbackExpected && take && !input.capabilities?.bargeIn) void cancelInput();
       change({ agent: running ? "running" : "idle", ...(playbackExpected ? { playback: "pending" } : {}) });
-      if (!running && state.continuous) void listen();
+      if (!manualTurns && !running && state.continuous) void listen();
     },
     observePlayback(playing) {
       if (playing !== (state.playback === "playing")) touch();
       change({ playback: playing ? "playing" : "idle" });
-      if (!playing && state.continuous) void listen();
+      if (!manualTurns && !playing && state.continuous) void listen();
+    },
+    async pause() {
+      clearTimers(); epoch += 1;
+      change({ connection: "paused", error: null });
+      recoveryTimer = schedule(() => { void expire("voice_recovery_expired"); }, recoveryTimeoutMs);
+      recoveryTimer.unref?.();
+      await Promise.allSettled([cancelInput(), stopPlayback()]);
     },
     async disconnect(code = null) {
       clearTimers();
@@ -135,12 +145,14 @@ export function createVoiceController({ input, agent, output, voiceId = mintRpcI
       change({ connection: code ? "paused" : "closed", error: code });
       await Promise.allSettled([cancelInput(), stopPlayback()]);
     },
-    async resume() {
+    async resume({ shouldResume = () => true } = {}) {
+      const resumedEpoch = epoch;
       if (state.connection !== "paused") return;
       const running = state.sessionId ? await agent.running(state.sessionId) : false;
+      if (resumedEpoch !== epoch || !shouldResume()) return;
       clearTimers();
       change({ connection: "open", agent: running ? "running" : "idle", error: null });
-      touch(); void listen();
+      touch(); if (!manualTurns) void listen();
     },
   };
   return controller;

package/voice/conversation.js

@@ -3,7 +3,7 @@ import { createDeviceInput } from "./device-input.js";
 import { createHostInput } from "./host-input.js";
 import { mintRpcId } from "../larepass/rpc.js";
 
-export function createVoiceConversation({ request, transcribe, playback, onReply = () => {}, onPhase, mode = () => "queue", device = "device", metric = () => {}, readAloud = true, preset, endpointSilenceMs, idleTimeoutMs, recoveryTimeoutMs, onText = () => {}, onTranscript = null, input: inputPort }) {
+export function createVoiceConversation({ request, transcribe, playback, onReply = () => {}, onPhase, mode = () => "queue", device = "device", metric = () => {}, readAloud = true, preset, presentationSession = false, endpointSilenceMs, idleTimeoutMs, recoveryTimeoutMs, onText = () => {}, onTranscript = null, input: inputPort, captureConfig }) {
   const voiceId = mintRpcId();
   const headers = { "x-lares-voice-id": voiceId, "x-lares-voice-device": device };
   let timer = null;
@@ -16,6 +16,7 @@ export function createVoiceConversation({ request, transcribe, playback, onReply
   let submitted = false;
   let finalSeen = false;
   let continuous = false;
+  let manualCapture = false;
   let reading = false;
   const call = async (path, body, signal) => {
     const res = await request(`/api/lares/voice${path}`, { method: body === undefined ? "GET" : "POST", headers: { ...headers, "x-lares-voice-speaking": controller.getSnapshot().userSpeaking ? "true" : "false" }, ...(body === undefined ? {} : { body }), signal });
@@ -23,10 +24,10 @@ export function createVoiceConversation({ request, transcribe, playback, onReply
     return res.body;
   };
   const input = inputPort ?? (device === "headset" ? createHostInput({
-    start: (signal) => call("/capture", {}, signal), status: (signal) => call("/capture", undefined, signal),
+    start: (signal) => call("/capture", { config: captureConfig, manual: manualCapture || Boolean(onTranscript) }, signal), status: (signal) => call("/capture", undefined, signal),
     stop: () => call("/capture/stop", {}), cancel: () => call("/capture/cancel", {}),
   }) : createDeviceInput({ transcribe, onPhase, endpointSilenceMs }));
-  const controller = createVoiceController({ voiceId, input, idleTimeoutMs, recoveryTimeoutMs, onExpired: () => stop(), onTranscript: onTranscript ? async (value) => { const cleaned = await call("/dictation/clean", { text: value.text }, value.signal); value.signal.throwIfAborted(); if (typeof cleaned.text !== "string") throw new Error("voice_cleanup_failed"); await onTranscript({ ...value, text: cleaned.text }); if (!continuous) await stop(); } : null, metric: (event) => {
+  const controller = createVoiceController({ voiceId, input, idleTimeoutMs, recoveryTimeoutMs, onExpired: () => stop(), onTranscript: onTranscript ? async (value) => { await onTranscript(value); if (!continuous) await stop(); } : null, metric: (event) => {
     metric(event);
     void call("/session/metric", { stage: event.stage, durationMs: event.durationMs }).catch(() => {});
   }, output: { async stop() { playback.stop(); await call("/playback/stop", {}); } }, agent: {
@@ -55,6 +56,7 @@ export function createVoiceConversation({ request, transcribe, playback, onReply
       if (reply?.text && !reply.silent) onText(reply.text);
       const key = reply ? `${state.sessionId}:${reply.key}` : null;
       lastReplyKey = key;
+      if (["recording", "transcribing"].includes(controller.getSnapshot().capture)) mutedKey = key;
       const reserve = readAloud && key !== mutedKey && reply?.text && !reply.silent && key !== spokenKey;
       if (reserve) spokenKey = key;
       controller.observeAgent(Boolean(state.running), Boolean(reserve));
@@ -91,23 +93,29 @@ export function createVoiceConversation({ request, transcribe, playback, onReply
       else controller.observePlayback(playing);
     },
     get sessionId() { return lastSessionId; },
-    async start({ sessionId = null, continuous: nextContinuous = false } = {}) {
+    async start({ sessionId = null, continuous: nextContinuous = false, manual = false, shouldStart = () => true } = {}) {
+      manualCapture = manual;
       continuous = nextContinuous; submitted = false; finalSeen = false; spokenKey = null;
       disposed = false; version = -1;
       clearTimeout(timer);
-      const initial = onTranscript ? {} : await call("/session", { sessionId, readAloud, ...(preset ? { preset } : {}) });
-      await controller.start({ sessionId, continuous, running: initial.running });
+      const initial = onTranscript ? {} : await call("/session", { sessionId, readAloud, presentationSession, ...(preset ? { preset } : {}) });
+      if (!shouldStart()) { await stop(); return; }
+      await controller.start({ sessionId, continuous, manual, running: initial.running, shouldStart });
       controller.setOutputMuted(!readAloud);
       if (!onTranscript) void watch();
     },
     stop,
-    async resume() {
-      if (onTranscript) { await controller.resume(); return; }
+    async pause() { clearTimeout(timer); await controller.pause(); },
+    async resume(options = {}) {
+      if (onTranscript) { disposed = false; await controller.resume(options); return; }
       const current = await call("/session");
+      version = current.version;
+      mutedKey = current.utterance ? `${current.sessionId}:${current.utterance.key}` : null;
+      spokenKey = mutedKey;
       if (!current.active) await call("/session", { sessionId: lastSessionId, readAloud });
       else await call("/session/resume", {});
       disposed = false;
-      await controller.resume();
+      await controller.resume(options);
       void watch();
     },
     async setReadAloud(value) {

package/voice/device-input.js

@@ -48,7 +48,7 @@ export function createDeviceInput({ transcribe, onPhase = () => {}, endpoint = c
   };
   return {
     capabilities: { duplex: true, bargeIn: false, listenWhileWorking: true, audio: "encoded" },
-    capture({ signal, onTranscribing, onSpeech, onLevel = () => {}, continuous = false } = {}) {
+    capture({ signal, onTranscribing, onReady, onSpeech, onLevel = () => {}, continuous = false } = {}) {
       cancel();
       return new Promise((resolve, reject) => {
         settle = resolve;
@@ -62,6 +62,7 @@ export function createDeviceInput({ transcribe, onPhase = () => {}, endpoint = c
           } }, onSpeech, onLevel, { silenceMs: endpointSilenceMs });
         }, onPhase(phase, extra) {
           onPhase(phase, extra);
+          if (phase === "recording") onReady?.();
           if (phase === "transcribing") onTranscribing?.();
           if (phase === "error") {
             if (continuous && ["voice_no_input", "voice_too_short"].includes(extra.error)) { done(""); return; }
@@ -69,7 +70,7 @@ export function createDeviceInput({ transcribe, onPhase = () => {}, endpoint = c
         } });
         signal?.addEventListener("abort", cancel, { once: true });
         if (signal?.aborted) { cancel(); return; }
-        timer = setTimeout(() => recorder?.stop(), 60_000);
+        timer = setTimeout(() => { if (continuous) recorder?.stop(); else { settle = null; cancel(); reject(new Error("voice_capture_limit")); } }, 60_000);
         void recorder.start();
       });
     },