@olares/lares-core 0.15.6 → 0.15.9

package/i18n/voice.js

@@ -8,28 +8,63 @@ export const ZH = {
   "error.voice_no_input": "没有检测到声音",
   "error.voice_failed": "转写失败，请重试",
   "error.voice_unsupported": "当前浏览器不支持录音",
+  "error.voice_bluetooth_not_ready": "蓝牙麦克风还没连上，请重试",
+  "error.voice_bluetooth_unavailable": "这台机器的蓝牙还没就绪",
+  "error.voice_bluetooth_scan_failed": "扫描附近设备失败",
+  "error.voice_bluetooth_connect_failed": "连接失败，请确认设备仍在等待连接",
+  "error.voice_bluetooth_invalid": "蓝牙地址无效",
+  "error.voice_tts_unavailable": "没有可用的语音播报模型，请先在语音设置里安装",
+  "error.voice_speak_disabled": "语音播报是关着的",
+  "error.voice_speak_failed": "语音播报失败，请重试",
+  "error.voice_speak_timeout": "语音播报超时，请重试",
+  "error.voice_speak_unready": "当前不能保存语音播报开关",
+  "mic.preparing": "正在连接蓝牙麦克风…",
   "mic.stop": "点击结束录音",
   "mic.transcribing": "转写中…",
   "mic.idle": "语音输入",
   "mic.blocked": "当前无法输入",
   "lang.auto": "自动检测",
   "status.auto": "自动",
-  "settings.title": "语音输入",
-  "settings.intro": "在输入框旁点击麦克风录音，录完自动转写并填入文本。转写由 Olares Router 的语音模型提供。",
+  "settings.title": "语音设置",
+  "settings.intro": "点击麦克风开始说话，说完自动转成文字。语音播报开启后，只朗读这一轮的最终回答。",
   "settings.refresh": "刷新",
   "settings.refreshing": "刷新中…",
   "settings.router": "Router 控制台",
-  "settings.loading": "正在读取语音输入配置…",
-  "settings.loadFailed": "读取语音输入配置失败",
+  "settings.loading": "正在读取语音设置…",
+  "settings.loadFailed": "读取语音设置失败",
   "settings.refreshFailed": "刷新语音模型列表失败",
-  "settings.status.ready": "语音就绪 · 模型 {model}",
-  "settings.status.notReady": "语音模型尚不可用，请先在 Olares 模型控制台安装语音识别应用",
-  "settings.model.title": "语音模型",
-  "settings.model.hint": "留空则自动选择目录中的语音模型",
-  "settings.model.auto": "自动选择",
+  "settings.status.ready": "识别就绪 · {model}",
+  "settings.status.notReady": "还没有语音识别模型",
+  "settings.stt.title": "语音识别",
+  "settings.stt.hint": "把麦克风里的话转成文字",
+  "settings.tts.title": "语音播报",
+  "settings.tts.hint": "只朗读最终回答，思考和工具调用不播报",
+  "settings.speak.label": "开启语音播报",
+  "settings.install": "安装",
+  "settings.installing": "安装中…",
+  "settings.installStarted": "已开始安装，模型下载完成后点刷新",
+  "settings.installFailed": "安装失败",
+  "settings.probe": "检测",
+  "settings.probing": "检测中…",
+  "settings.probeOk": "连通正常",
+  "settings.probeFailed": "连通失败",
+  "settings.stop": "停用",
+  "settings.stopping": "停用中…",
+  "settings.stopFailed": "停用失败",
+  "settings.resume": "启用",
+  "settings.resuming": "启用中…",
+  "settings.resumeFailed": "启用失败",
   "settings.language.title": "识别语言",
   "settings.language.hint": "指定语言可提升准确度与速度",
   "settings.saveFailed": "保存失败",
+  "settings.bluetooth.title": "蓝牙设备",
+  "settings.bluetooth.hint": "连上后可以用这台设备说话，回答也会从它播出来",
+  "settings.bluetooth.scan": "扫描",
+  "settings.bluetooth.scanning": "扫描中…",
+  "settings.bluetooth.connect": "连接",
+  "settings.bluetooth.connecting": "连接中…",
+  "settings.bluetooth.connected": "已连接",
+  "settings.bluetooth.empty": "附近没有正在等待连接的设备",
 };
 
 export const EN = {
@@ -43,28 +78,62 @@ export const EN = {
   "error.voice_no_input": "No voice detected",
   "error.voice_failed": "Transcription failed, please retry",
   "error.voice_unsupported": "This browser does not support recording",
+  "error.voice_bluetooth_not_ready": "Bluetooth microphone is not ready, please retry",
+  "error.voice_bluetooth_unavailable": "Bluetooth is not ready on this machine",
+  "error.voice_bluetooth_scan_failed": "Failed to scan for nearby devices",
+  "error.voice_bluetooth_connect_failed": "Connection failed. Confirm the device is still waiting to connect",
+  "error.voice_bluetooth_invalid": "Invalid Bluetooth address",
+  "error.voice_tts_unavailable": "No speech model is available. Install one in voice settings first",
+  "error.voice_speak_disabled": "Speech playback is off",
+  "error.voice_speak_failed": "Couldn't speak the answer, please retry",
+  "error.voice_speak_timeout": "Speech timed out, please retry",
+  "error.voice_speak_unready": "Speech playback can't be saved right now",
+  "mic.preparing": "Connecting the Bluetooth microphone…",
   "mic.stop": "Click to stop recording",
   "mic.transcribing": "Transcribing…",
   "mic.idle": "Voice input",
   "mic.blocked": "Input unavailable",
   "lang.auto": "Auto-detect",
   "status.auto": "auto",
-  "settings.title": "Voice input",
+  "settings.title": "Voice settings",
   "settings.intro":
-    "Click the microphone beside the composer to record; the take is transcribed and inserted automatically. Transcription is served by an Olares Router voice model.",
+    "Click the microphone to start speaking; the take is transcribed into the composer. With playback on, only the turn's final answer is spoken.",
   "settings.refresh": "Refresh",
   "settings.refreshing": "Refreshing…",
   "settings.router": "Router console",
-  "settings.loading": "Loading voice input settings…",
-  "settings.loadFailed": "Failed to load voice input settings",
+  "settings.loading": "Loading voice settings…",
+  "settings.loadFailed": "Failed to load voice settings",
   "settings.refreshFailed": "Failed to refresh voice models",
-  "settings.status.ready": "Voice ready · model {model}",
-  "settings.status.notReady":
-    "Voice model not available yet; install a speech-recognition app in the Olares Model Console first",
-  "settings.model.title": "Voice model",
-  "settings.model.hint": "Leave empty to auto-pick a voice model from the catalog",
-  "settings.model.auto": "Auto",
+  "settings.status.ready": "Recognition ready · {model}",
+  "settings.status.notReady": "No speech-recognition model yet",
+  "settings.stt.title": "Speech recognition",
+  "settings.stt.hint": "Turn the microphone into text",
+  "settings.tts.title": "Speech playback",
+  "settings.tts.hint": "Read only the final answer, not reasoning or tool calls",
+  "settings.speak.label": "Speak the final answer",
+  "settings.install": "Install",
+  "settings.installing": "Installing…",
+  "settings.installStarted": "Install started. Refresh after the model finishes downloading",
+  "settings.installFailed": "Install failed",
+  "settings.probe": "Check",
+  "settings.probing": "Checking…",
+  "settings.probeOk": "Connected",
+  "settings.probeFailed": "Unreachable",
+  "settings.stop": "Stop",
+  "settings.stopping": "Stopping…",
+  "settings.stopFailed": "Stop failed",
+  "settings.resume": "Start",
+  "settings.resuming": "Starting…",
+  "settings.resumeFailed": "Start failed",
   "settings.language.title": "Recognition language",
   "settings.language.hint": "Specifying a language improves accuracy and speed",
   "settings.saveFailed": "Failed to save",
+  "settings.bluetooth.title": "Bluetooth devices",
+  "settings.bluetooth.hint": "After connecting, speak into this device and hear answers from it",
+  "settings.bluetooth.scan": "Scan",
+  "settings.bluetooth.scanning": "Scanning…",
+  "settings.bluetooth.connect": "Connect",
+  "settings.bluetooth.connecting": "Connecting…",
+  "settings.bluetooth.connected": "Connected",
+  "settings.bluetooth.empty": "No nearby device is waiting to connect",
 };

package/larepass/chat.js

@@ -29,6 +29,13 @@ export async function callRpc(request, method, payload = {}) {
   }
   const parsed = unwrapServerResponse(res.body);
   if (!parsed.ok) return { ...parsed, status: "rpc-error", http };
+  // dsh 0.2 session/page returns records. Callers still read `events`.
+  if (Array.isArray(parsed.value?.records) && !Array.isArray(parsed.value?.events)) {
+    parsed.value = {
+      ...parsed.value,
+      events: parsed.value.records.map((record) => record?.event).filter(Boolean),
+    };
+  }
   return { ...parsed, status: "ok", http };
 }
 
@@ -96,6 +103,8 @@ export function summarizeSession(row) {
     ...(projections.contextBreakdown ? { contextBreakdown: projections.contextBreakdown } : {}),
     ...(projections.goal ? { goal: projections.goal } : {}),
     ...(Array.isArray(projections.todos) ? { todos: projections.todos } : {}),
+    ...(projections.modelSelection ? { modelSelection: projections.modelSelection } : {}),
+    ...(Number.isInteger(row?.projections?.asOfSeq) ? { asOfSeq: row.projections.asOfSeq } : {}),
   };
 }
 

package/larepass/host.js

@@ -51,7 +51,7 @@ export function hostConfigFromEnv(env = {}) {
  * object, so a key that exists in one place and not the other is dropped in
  * silence — which is how `socketProtocol` shipped inert once already.
  */
-export const HOST_PORT_KEYS = ["baseUrl", "proxyPrefix", "env", "request", "socketProtocol"];
+export const HOST_PORT_KEYS = ["baseUrl", "proxyPrefix", "env", "request", "socketProtocol", "missing"];
 
 /** Collect the port keys off any carrier (a component instance included). */
 export function pickHostPorts(source = {}) {
@@ -86,7 +86,12 @@ export function laresPortsFromAccount({ env, apps } = {}) {
     return { env, proxyPrefix: fromEnv.proxyPrefix, baseUrl: undefined };
   }
   const baseUrl = findLaresEntrance(apps);
-  return { baseUrl: baseUrl || undefined, env: undefined, proxyPrefix: undefined };
+  if (!baseUrl) {
+    // LarePass lives on another origin. No myApps hit means there is no Host
+    // to call. The entrance page never uses this function: it is already there.
+    return { baseUrl: undefined, env: undefined, proxyPrefix: undefined, missing: true };
+  }
+  return { baseUrl, env: undefined, proxyPrefix: undefined };
 }
 
 export function hostUrl({ baseUrl = "", proxyPrefix = "", path }) {

package/larepass/mux.js

@@ -1,6 +1,7 @@
 import { normalizeQueueItems } from "./queue.js";
 
-export const MUX_PATH = "/api/events.mux";
+/** Gateway WebSocket. A bare socket stays up on ping/pong; logical streams are separate. */
+export const MUX_PATH = "/api/remote.mux";
 
 export const MUX_FETCH_HEADERS = {
   accept: "text/event-stream",
@@ -14,6 +15,213 @@ export function muxWsUrl(httpUrl, origin = "http://localhost") {
   return url.href;
 }
 
+/** One logical stream on `/api/remote.mux`. `workspace/follow` has no arguments. */
+export function remoteStreamOpen(streamId, endpoint, args = {}) {
+  return {
+    type: "open",
+    streamId,
+    endpoint,
+    payload: { args },
+  };
+}
+
+/** Same `session/follow` open the dsh web client sends on this socket. */
+export function sessionFollowOpen(streamId, sessionId) {
+  return remoteStreamOpen(streamId, "session/follow", {
+    request: {
+      address: { kind: "session", sessionId },
+      assistantStream: true,
+    },
+  });
+}
+
+/** Host-forwarded Cordis events; questions and approvals arrive here as waterfalls. */
+export function remoteEventsOpen(streamId) {
+  return remoteStreamOpen(streamId, "$events");
+}
+
+/**
+ * One `$events` item. A waterfall this client does not answer passes as
+ * `next` so the Host is not left waiting on it; `agentId` is the session.
+ */
+export function classifyRemoteEvent(value) {
+  if (!value || typeof value !== "object") return null;
+  if (value.type === "ready" && typeof value.clientId === "string") {
+    return { kind: "ready", clientId: value.clientId };
+  }
+  if (value.type === "cancel" && typeof value.eventId === "string") {
+    return { kind: "cancel", eventId: value.eventId };
+  }
+  if (value.type !== "waterfall" || typeof value.eventId !== "string") return null;
+  const request = value.request && typeof value.request === "object" ? value.request : {};
+  const sessionId = typeof value.agentId === "string" ? value.agentId : "";
+  if (value.event === "user-questions/request" && Array.isArray(request.questions) && sessionId) {
+    return {
+      kind: "question",
+      eventId: value.eventId,
+      sessionId,
+      callId: request.wait?.callId,
+      questions: request.questions,
+    };
+  }
+  if (value.event === "approval/request" && typeof request.toolName === "string" && sessionId) {
+    return {
+      kind: "approval",
+      eventId: value.eventId,
+      sessionId,
+      toolName: request.toolName,
+      callId: request.callId,
+      reason: request.displayReason ?? request.reason,
+    };
+  }
+  return { kind: "pass", eventId: value.eventId };
+}
+
+function liveChunkEvent(seq, turn, step, chunk) {
+  if (!chunk || typeof chunk !== "object") return null;
+  if (chunk.type !== "text-delta" && chunk.type !== "reasoning-delta" && chunk.type !== "block-end") {
+    return null;
+  }
+  return {
+    type: "assistant/chunk",
+    seq,
+    live: true,
+    data: { turn, step, chunk },
+  };
+}
+
+/**
+ * Fold one `session/follow` downlink into transcript events.
+ * Snapshot and durable `event` frames are the session log. `assistant-stream`
+ * frames are the in-progress think and reply, placed just after the latest
+ * durable seq so a later `assistant/message` replaces them.
+ */
+export function createSessionFollow() {
+  let cursor = -1;
+  let liveCount = 0;
+  let attempt = null;
+
+  const note = (event) => {
+    if (typeof event?.seq !== "number" || event.seq <= cursor) return;
+    cursor = event.seq;
+    liveCount = 0;
+  };
+
+  const nextLiveSeq = () => {
+    liveCount += 1;
+    return cursor + 1 - 1 / (liveCount + 1);
+  };
+
+  const fromChunk = (turn, step, chunk) => liveChunkEvent(nextLiveSeq(), turn, step, chunk);
+
+  const fromCompact = (turn, step, stream, limit) => {
+    const events = [];
+    let seen = 0;
+    const push = (chunk) => {
+      if (seen >= limit) return false;
+      seen += 1;
+      const event = fromChunk(turn, step, chunk);
+      if (event) events.push(event);
+      return true;
+    };
+    for (const record of Array.isArray(stream) ? stream : []) {
+      if (record?.type === "text-chunks" || record?.type === "reasoning-chunks") {
+        const type = record.type === "text-chunks" ? "text-delta" : "reasoning-delta";
+        for (const text of record.texts ?? []) {
+          if (!push({ type, index: record.index, text: String(text ?? "") })) return events;
+        }
+        continue;
+      }
+      if (record?.type === "chunk" && !push(record.chunk)) return events;
+    }
+    return events;
+  };
+
+  return {
+    reset() {
+      cursor = -1;
+      liveCount = 0;
+      attempt = null;
+    },
+    push(frame) {
+      if (!frame || typeof frame !== "object") return null;
+      if (frame.type === "snapshot") {
+        const events = [];
+        for (const record of Array.isArray(frame.records) ? frame.records : []) {
+          const event = record?.event;
+          if (!event || typeof event.seq !== "number") continue;
+          note(event);
+          events.push(event);
+        }
+        const opening = frame.assistantStream?.activeAttempt;
+        attempt = opening
+          ? {
+            attemptId: opening.attemptId,
+            turn: opening.turn,
+            step: opening.step,
+            nextIndex: opening.nextIndex ?? 0,
+          }
+          : null;
+        if (opening) {
+          const limit = Number.isInteger(opening.nextIndex) ? opening.nextIndex : Number.POSITIVE_INFINITY;
+          events.push(...fromCompact(opening.turn, opening.step, opening.stream, limit));
+        }
+        return { events, ready: true, projections: frame.projections };
+      }
+      if (frame.type === "event" && frame.event && typeof frame.event.seq === "number") {
+        const event = frame.event;
+        note(event);
+        const settles = event.type === "assistant/message" || event.type === "turn/end";
+        if (settles) attempt = null;
+        return { events: [event], dropLive: settles };
+      }
+      if (frame.type !== "assistant-stream" || !frame.frame || typeof frame.frame !== "object") return null;
+      const live = frame.frame;
+      if (live.type === "start") {
+        attempt = {
+          attemptId: live.attemptId,
+          turn: live.turn,
+          step: live.step,
+          nextIndex: 0,
+        };
+        return { events: [] };
+      }
+      if (live.type === "chunk") {
+        if (!attempt || attempt.attemptId !== live.attemptId) return { events: [] };
+        if (live.index !== attempt.nextIndex) {
+          attempt = null;
+          return { events: [], resync: true };
+        }
+        attempt.nextIndex += 1;
+        const event = fromChunk(attempt.turn, attempt.step, live.chunk);
+        return { events: event ? [event] : [] };
+      }
+      if (live.type === "end") {
+        const abandoned = attempt?.attemptId === live.attemptId && live.outcome?.kind === "abandoned";
+        attempt = null;
+        return { events: [], dropLive: abandoned };
+      }
+      return null;
+    },
+  };
+}
+
+export function classifyStreamFrame(message) {
+  if (!message || typeof message.streamId !== "string" || !message.streamId) return null;
+  if (message.type === "item") return { kind: "stream", streamId: message.streamId, value: message.value };
+  if (message.type === "end") return { kind: "stream-end", streamId: message.streamId };
+  if (message.type === "error") return { kind: "stream-error", streamId: message.streamId, error: message.error };
+  return null;
+}
+
+/** The first `workspace/follow` item is the full workspace projection. */
+export function workspaceBaseline(message) {
+  if (message?.type !== "item") return null;
+  const frame = message.value;
+  if (frame?.type !== "baseline" || !frame.value || typeof frame.value !== "object") return null;
+  return frame.value;
+}
+
 export function splitSseBlocks(buffer) {
   const blocks = [];
   let rest = String(buffer ?? "").replace(/\r\n/g, "\n");
@@ -210,7 +418,7 @@ export async function* consumeMuxInbox(source) {
     ? iterateSseJson(bytesOf(source))
     : iterateWsJson(source);
   for await (const envelope of envelopes) {
-    const item = classifyMuxEnvelope(envelope);
+    const item = classifyMuxEnvelope(envelope) ?? classifyStreamFrame(envelope);
     if (item) yield item;
   }
 }

package/larepass/process-fold.js

@@ -0,0 +1,239 @@
+/**
+ * One disclosure for a turn's reasoning and tool calls, matching dsh chat.
+ * A settled turn uses the "completed in" control. While the turn is still
+ * running, the same rows sit behind one live activity line (or a finished
+ * activity summary once the reply has started). The person's message and the
+ * final answer stay outside. A turn that ended in error or abort stays open.
+ */
+
+const DETAIL_LIMIT = 160;
+const DETAIL_KEYS = [
+  "title", "description", "objective", "task", "task_name", "name",
+  "question", "questions", "prompt", "message", "command", "cmd",
+  "queries", "query", "pattern", "url", "uri", "file_path", "path",
+  "target", "action", "status",
+];
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+const PROCESS = new Set(["reasoning", "tool", "retry", "context"]);
+
+function lastAssistant(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (entries[i].row?.type === "assistant") return i;
+  }
+  return -1;
+}
+
+function isWaitingQuestion(row) {
+  return row?.type === "tool" && row.name === "ask_user_question" && row.status === "running";
+}
+
+function isProcess(row, index, answerAt) {
+  if (isWaitingQuestion(row)) return false;
+  if (row?.type === "assistant") return index !== answerAt;
+  return PROCESS.has(row?.type);
+}
+
+function activity(name) {
+  if (name === "read") return "read";
+  if (name === "read_image") return "readImage";
+  if (name === "grep" || name === "glob" || name?.endsWith("_inspect")) return "search";
+  if (name === "write") return "write";
+  if (name === "edit" || name === "apply_patch") return "edit";
+  if (["bash", "pwsh", "exec_command", "write_stdin"].includes(name) || name?.startsWith("terminal_")) return "commands";
+  if (name === "run_code") return "code";
+  if (name === "web_search") return "webSearch";
+  if (name === "web_fetch") return "webFetch";
+  if (name === "subagent" || name?.startsWith("subagent_")) return "subagents";
+  if (["todo_write", "create_goal", "update_goal", "get_goal"].includes(name)) return "plan";
+  if (name === "ask_user_question" || name === "request_user_input") return "questions";
+  return "tools";
+}
+
+function clipDetail(value) {
+  const normalized = String(value ?? "").replace(/\s+/g, " ").trim();
+  const chars = Array.from(segmenter.segment(normalized), (part) => part.segment);
+  if (chars.length <= DETAIL_LIMIT) return normalized;
+  return `${chars.slice(0, DETAIL_LIMIT - 1).join("").trimEnd()}…`;
+}
+
+function toolDetail(row) {
+  let args;
+  try {
+    args = JSON.parse(row?.argsRaw ?? "");
+  } catch {
+    return clipDetail(row?.name);
+  }
+  if (args === null || typeof args !== "object") return clipDetail(row?.name);
+  for (const key of DETAIL_KEYS) {
+    if (!(key in args)) continue;
+    const value = args[key];
+    if (key === "questions" && Array.isArray(value)) {
+      const question = value.find((item) => item && typeof item.question === "string")?.question;
+      const detail = clipDetail(question);
+      if (detail) return detail;
+      continue;
+    }
+    const detail = clipDetail(typeof value === "string" || (Array.isArray(value) && value.every((item) => typeof item === "string"))
+      ? (Array.isArray(value) ? value.join(", ") : value)
+      : "");
+    if (detail) return detail;
+  }
+  return clipDetail(row?.name);
+}
+
+function reasoningDetail(members) {
+  for (let i = members.length - 1; i >= 0; i--) {
+    if (members[i].row?.type !== "reasoning") continue;
+    const paragraphs = String(members[i].row.text ?? "").split(/\r?\n[\t ]*\r?\n/);
+    for (let p = paragraphs.length - 1; p >= 0; p--) {
+      const detail = clipDetail(paragraphs[p].replaceAll("**", ""));
+      if (detail) return detail;
+    }
+  }
+  return "";
+}
+
+function runningTool(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const row = entries[i].row;
+    if (row?.type === "tool" && row.status === "running") return row;
+  }
+  return null;
+}
+
+function toolCounts(members) {
+  const counts = new Map();
+  const order = [];
+  for (const { row } of members) {
+    if (row?.type !== "tool") continue;
+    const kind = activity(row.name);
+    if (!counts.has(kind)) order.push(kind);
+    counts.set(kind, (counts.get(kind) ?? 0) + 1);
+  }
+  return order.map((kind) => ({ kind, count: counts.get(kind) }));
+}
+
+function processTitle(t, counts) {
+  const ranked = [...counts].sort((left, right) => right.count - left.count);
+  const labels = ranked.slice(0, 3).map(({ kind }) => t(`message.stepProcess.done.${kind}`));
+  const first = labels[0];
+  if (first === undefined) return t("message.stepProcess.done.thinking");
+  const continuation = (label) => label.charAt(0).toLowerCase() + label.slice(1);
+  if (labels.length === 1) return first;
+  if (labels.length === 2) {
+    const prefix = t("message.stepProcess.sharedPrefix");
+    const second = labels[1];
+    const trimmed = prefix !== "" && first.startsWith(prefix) && second.startsWith(prefix)
+      ? second.slice(prefix.length)
+      : second;
+    return t("message.stepProcess.joinTwo", { first, second: continuation(trimmed) });
+  }
+  const title = [first, ...labels.slice(1).map(continuation)].join(t("message.stepProcess.comma"));
+  return ranked.length > 3 ? t("message.stepProcess.more", { title }) : title;
+}
+
+function liveTitle(t, block) {
+  const tool = block.runningTool;
+  const kind = tool ? activity(tool.name) : "thinking";
+  const label = t(`message.stepProcess.${kind}`);
+  const detail = tool ? toolDetail(tool) : reasoningDetail(block.members);
+  if (!detail) return label;
+  return `${label}${t("message.turnProcess.separator")}${detail}`;
+}
+
+function runMsOf(entries, answerAt) {
+  if (answerAt >= 0 && entries[answerAt].row.metrics?.runMs != null) {
+    return entries[answerAt].row.metrics.runMs;
+  }
+  return entries.find((entry) => entry.row.turnRunMs != null)?.row.turnRunMs;
+}
+
+/** Wall-clock run length the way dsh prints it: hours, then minutes once a minute is reached, then seconds. */
+export function formatRunDuration(ms, unit) {
+  const total = Math.max(0, Math.floor((Number(ms) || 0) / 1000));
+  const hours = Math.floor(total / 3600);
+  const minutes = Math.floor(total / 60) % 60;
+  const seconds = total % 60;
+  let text = "";
+  if (hours > 0) text += `${hours}${unit.hour}`;
+  if (total >= 60) text += `${minutes}${unit.minute}`;
+  text += `${seconds}${unit.second}`;
+  return text;
+}
+
+export function processFoldLabel(t, block = {}) {
+  if (block.phase === "live") return liveTitle(t, block);
+  if (block.phase === "summary") return processTitle(t, toolCounts(block.members ?? []));
+  const reason = block.reason ?? "completed";
+  if (reason === "aborted") return t("message.stopped");
+  if (reason === "error") return t("message.turnProcess.failed");
+  if (block.runMs == null) return t("message.turnProcess.worked");
+  const duration = formatRunDuration(Math.max(1000, block.runMs), {
+    hour: t("duration.hourUnit"),
+    minute: t("duration.minuteUnit"),
+    second: t("duration.secondUnit"),
+  });
+  return t("message.turnProcess.took", { duration });
+}
+
+/** The live activity line replaces the bottom running clock. */
+export function hidesRunningClock(blocks) {
+  return (Array.isArray(blocks) ? blocks : []).some((block) =>
+    block?.phase === "live"
+    || (block?.row?.type === "tool" && block.row.name === "ask_user_question" && block.row.status === "running"));
+}
+
+export function transcriptBlocks(items, { running = false } = {}) {
+  const list = Array.isArray(items) ? items : [];
+  const groups = [];
+  for (let index = 0; index < list.length; index++) {
+    const row = list[index];
+    const prev = groups[groups.length - 1];
+    const turn = Number.isInteger(row?.turn) ? row.turn : null;
+    const split = !prev
+      || row?.type === "user"
+      || (turn != null && prev.turn != null && turn !== prev.turn);
+    if (split) groups.push({ turn, entries: [] });
+    const group = groups[groups.length - 1];
+    if (group.turn == null && turn != null) group.turn = turn;
+    group.entries.push({ row, index });
+  }
+
+  const blocks = [];
+  groups.forEach((group, groupIndex) => {
+    const closed = groupIndex < groups.length - 1 || !running;
+    const answerAt = lastAssistant(group.entries);
+    const members = group.entries.filter((entry, index) => isProcess(entry.row, index, answerAt));
+    const hasWork = members.some((entry) => entry.row.type !== "context");
+    const reason = group.entries.find((entry) => entry.row.turnReason)?.row.turnReason || "completed";
+    const runMs = runMsOf(group.entries, answerAt);
+    const showHeader = hasWork;
+    const openTurn = !closed;
+    const tool = openTurn ? runningTool(group.entries) : null;
+    const phase = !showHeader ? "" : openTurn ? (tool || answerAt < 0 ? "live" : "summary") : "turn";
+    const foldable = showHeader && phase !== "turn"
+      ? true
+      : showHeader && reason !== "error" && reason !== "aborted";
+    const memberSet = new Set(members);
+    let folded = false;
+    for (const entry of group.entries) {
+      if (showHeader && !folded && memberSet.has(entry)) {
+        blocks.push({
+          kind: "fold",
+          key: `fold-${group.turn ?? `g${groupIndex}`}-${entry.index}`,
+          phase,
+          foldable,
+          reason,
+          runMs,
+          members,
+          runningTool: tool,
+        });
+        folded = true;
+      }
+      if (memberSet.has(entry) && showHeader) continue;
+      blocks.push({ kind: "row", key: `row-${entry.index}`, index: entry.index, row: entry.row });
+    }
+  });
+  return blocks;
+}