agentus 0.4.0 → 0.4.2

package/README.md

@@ -49,10 +49,12 @@ first, else `newSession` fails with `-32000`). Without one the cockpit still run
 logs in — you just have no backend to start a session on.
 
 A plain Hermes install drives sessions; the cockpit's own extras — per-session **thinking
-depth**, a permission mode that survives a restart, the **context-budget** field — come from the
-fork's integration build instead. That is a five-line install:
+depth**, a permission mode that survives a restart, the **context-budget** field, the **status
+channel** (memory recall/save hints in the message stream), per-process skill roots, and a
+**DeepSeek web backend** (search + extract on the model key) — come from the fork's integration
+build instead. That is a five-line install:
 [§ Which Hermes to run](docs/installation.md#which-hermes-to-run) — currently the tag
-`agentus/v0.22.0/merge-20261015-0014`, on Hermes `v0.22.0`.
+`agentus/v0.22.0/merge-20261018-1005`, on Hermes `v0.22.0`.
 
 The first slot you start will use the Hermes home **your own agent already uses**
 (`~/.hermes`) unless the backend row names another one — see "HERMES_HOME" below.

package/README.zh-CN.md

@@ -44,9 +44,11 @@ web bundle、配套 APK —— 然后直接退出，不启动任何东西）。
 照样能跑、照样能登录 —— 只是没有后端可以开会话。
 
 裸装的 Hermes 就能跑会话；驾驶舱自己的那几项能力 —— 按会话切换的**思考深度**、跨重启存活的**权限模式**、
-**上下文预算**输入框 —— 来自 fork 的集成构建（tag）。装法就五行：
+**上下文预算**输入框、把记忆召回 / 存记忆提示送进消息流的 **status 通道**、按进程指定的技能根，
+以及 **DeepSeek 的 web 后端**（搜索 + 正文抓取，共用模型 key）—— 来自 fork 的集成构建（tag）。
+装法就五行：
 [§ 该跑哪份 Hermes](docs/installation.zh-CN.md#该跑哪份-hermes) —— 当前是 tag
-`agentus/v0.22.0/merge-20261015-0014`，基座 Hermes `v0.22.0`。
+`agentus/v0.22.0/merge-20261018-1005`，基座 Hermes `v0.22.0`。
 
 你启动的第一个 slot 会使用**你自己的 agent 已经在用的**那个 Hermes home（`~/.hermes`），除非后端那一行
 指定了另一个 —— 见下面的「HERMES_HOME」。

package/docs/installation.md

@@ -34,8 +34,13 @@ brew install node                 # or https://nodejs.org/en/download
 
 Plain Hermes is enough to drive sessions. The capabilities this cockpit itself leans on are **not**
 in the released build — a per-session **thinking depth** (ACP `reasoning_effort`), a **permission
-mode that survives a restart** and `session/load`, and a free-form **context budget** (with
-256K/512K/768K/1M presets). They live on the ACP branches of the fork
+mode that survives a restart** and `session/load`, a free-form **context budget** (with
+256K/512K/768K/1M presets), the **status channel** that carries memory-recall / save hints into the
+cockpit's message stream, **per-process skill roots** (`HERMES_EXTERNAL_SKILLS_DIRS`, which is how a
+slot sees the cockpit's own skill without anything being written into your `~/.hermes`), and a
+**DeepSeek web backend** (`search` + `extract` on top of `DEEPSEEK_API_KEY` — DeepSeek has no separate
+search key).
+They live on the ACP branches of the fork
 [`LiangYang666/hermes-agent`](https://github.com/LiangYang666/hermes-agent), and reach the cockpit
 through one **tag per integration build**, in a namespace of its own:
 
@@ -48,7 +53,7 @@ ref and gets rebuilt, while a tag never moves — so pin the tag. The `agentus/`
 ours apart from upstream's own tags (`v0.22.0`, `v0.22.0+canary.*`), and the timestamp in the
 last segment sorts, so "newest" is a `sort -V`.
 
-**Current integration build: `agentus/v0.22.0/merge-20261015-0014`** — the newest tag on the fork,
+**Current integration build: `agentus/v0.22.0/merge-20261018-1005`** — the newest tag on the fork,
 built on Hermes `v0.22.0`. This line is for orientation only, not the source of truth: the
 `TAG=$(…)` step below resolves the newest one on every run, so read it there if this sentence
 ever looks stale.

package/docs/installation.zh-CN.md

@@ -31,8 +31,11 @@ brew install node                 # 或者 https://nodejs.org/en/download
 ### 该跑哪份 Hermes
 
 裸装的 Hermes 足够跑会话。但驾驶舱自己依赖的那几项能力**不在发布版里** —— 按会话切换的**思考深度**
-（ACP `reasoning_effort`）、**跨重启 / `session/load` 存活的权限模式**，以及可自由填写的**上下文预算**
-（带 256K/512K/768K/1M 预设）。它们在 fork
+（ACP `reasoning_effort`）、**跨重启 / `session/load` 存活的权限模式**、可自由填写的**上下文预算**
+（带 256K/512K/768K/1M 预设）、把记忆召回 / 存记忆提示送进驾驶舱消息流的 **status 通道**，以及
+**按进程指定的技能根**（`HERMES_EXTERNAL_SKILLS_DIRS` —— 驾驶舱靠它让槽位看见自己的 skill，
+不往你的 `~/.hermes` 写任何东西），以及 **DeepSeek 的 web 后端**（`search` + `extract` 都复用
+`DEEPSEEK_API_KEY` —— DeepSeek 没有单独的搜索密钥）。它们在 fork
 [`LiangYang666/hermes-agent`](https://github.com/LiangYang666/hermes-agent) 的 ACP 分支上，
 按基座版本各有一个**集成构建的 tag**，自成命名空间：
 
@@ -44,7 +47,7 @@ agentus/<hermes 内部版本>/merge-<YYYYMMDD-HHMM>
 tag。`agentus/` 这个前缀也把它和上游自己的 tag（`v0.22.0`、`v0.22.0+canary.*`）分开；最后一段是时间戳，
 可排序，所以「最新」就是一次 `sort -V`。
 
-**当前集成构建：`agentus/v0.22.0/merge-20261015-0014`** —— fork 上最新的那个 tag，基座 Hermes
+**当前集成构建：`agentus/v0.22.0/merge-20261018-1005`** —— fork 上最新的那个 tag，基座 Hermes
 `v0.22.0`。这行只为一眼看个大概，不是权威：下面的 `TAG=$(…)` 每次都会自己解析出最新，觉得这行过期就
 以它为准。
 

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "agentus",
- "version": "0.4.0",
+ "version": "0.4.2",
  "description": "Multi-session web cockpit for ACP-speaking coding agents (Qoder CLI / Hermes). UI has no intelligence — the agent lives in spawned CLI subprocesses.",
  "license": "Apache-2.0",
  "repository": {

package/packages/server/mock/agent.mjs

@@ -430,6 +430,19 @@ const agent = () => ({
       }, Math.min(slow * 2, 1200));
     }
 
+    // `[blank]` — the SAME carrier with its `_meta` stripped, i.e. the shape a status line takes when
+    // the sentence is lost before us (measured 2026-10-17: hermes set `update._meta` while the ACP
+    // model's field is `field_meta`, so every status shipped as a bare empty thought). The cockpit must
+    // store nothing and draw nothing for it — an unreadable carrier is not 「思考 0 字」.
+    if (/\[blank\]/.test(text)) {
+      setTimeout(() => {
+        void send(agent._conn, sessionId, {
+          sessionUpdate: "agent_thought_chunk",
+          content: { type: "text", text: "" },
+        }).catch(() => undefined);
+      }, Math.min(slow * 2, 1000));
+    }
+
     // `[table]` — a table fixture for the sorting / full-screen sweep (scripts/qa/table-sweep.mjs).
     // Numeric AND text cells, deliberately NOT in any sorted order, and a local file link plus a
     // relative image, so "clicking a header reorders the rows" and "a relative path resolves" are
@@ -615,6 +628,20 @@ const agent = () => ({
       }
     }
 
+    // `[plan-long]` — the same frame with steps long enough to wrap on a phone. The operator's
+    // complaint (2026-10-18) is about exactly this: a step that runs onto a second line on a 360px
+    // screen. Short English steps hide it, so the fixture has to carry the long shape.
+    if (/\[plan-long\]/.test(text)) {
+      await send(agent._conn, sessionId, {
+        sessionUpdate: "plan",
+        entries: [
+          { content: "读一遍失败用例，确认它失败在断言上而不是环境上", status: "completed", priority: "medium" },
+          { content: "把时间相关的 flaky 断言改成注入时钟，然后跑完整套件确认不再抖动", status: "in_progress", priority: "high" },
+          { content: "run full suite", status: "pending", priority: "medium" },
+        ],
+      });
+    }
+
     if (wantPlan) {
       // ACP requires content+priority+status on every PlanEntry: @agentclientprotocol/sdk
       // silently DROPS entries that fail validation (spec-conformant, but hostile — the

package/packages/server/src/acp/session-manager.ts

@@ -20,7 +20,7 @@ import type { BackendHandshake, CheckErrorCode } from "./registry.js";
 import {
   cleanAgentTitle, deriveTitle, titleFromLatestPrompt, TITLE_INSTRUCTION,
 } from "../title.js";
-import type { Store, SessionRow } from "../store/store.js";
+import type { Store, SessionRow, TitleSrc } from "../store/store.js";
 import { textOf, withText } from "../store/store.js";
 import type {
   AttachmentSummary,
@@ -1786,6 +1786,12 @@ export class SessionManager {
         msg = { sessionId: live.info.id, kind: "agent", payload: u, createdAt: Date.now() };
         break;
       case "agent_thought_chunk":
+        // An EMPTY thought is not a thought. A status carrier we cannot read (its `_meta` lost on the
+        // way out, an agent using a carrier we do not know) lands here as "" — persisting it drew a
+        // 「思考 0 字」 bubble that never filled, and a row in the store that says the agent thought
+        // nothing. The honest degradation for an unknown extension is to render NOTHING (that is what
+        // hermes' own carrier docstring promises a client), so the frame is dropped rather than stored.
+        if (!textOf(u).trim()) return;
         msg = { sessionId: live.info.id, kind: "thought", payload: u, createdAt: Date.now() };
         break;
       case "tool_call": {
@@ -1861,7 +1867,10 @@ export class SessionManager {
         // provenance updates where the title is unchanged — a no-op here). This is why the
         // cockpit shows generated names at all: the intelligence stays in the CLI.
         const t = cleanAgentTitle((u as { title?: string | null }).title ?? null);
-        if (t) this.#applyAutoTitle(live.info.id, t, false);
+        // ONE name per session. Hermes re-generates a title on every turn (auxiliary `title_generation`
+        // in `agent/turn_context.py`), and this frame is how it arrives — subscribing to all of them was
+        // the churn: the rail kept renaming a conversation the operator was reading.
+        if (t) this.#applyAutoTitle(live.info.id, t, false, "agent");
         return;
       }
       case "usage_update": {
@@ -2115,12 +2124,16 @@ export class SessionManager {
     if (row.autoTitle && row.autoTitle !== placeholder) return;
     const t = deriveTitle(text);
     if (!t || t === row.autoTitle) return;
-    this.#applyAutoTitle(s.info.id, t, false);
+    this.#applyAutoTitle(s.info.id, t, false, "derived");
   }
 
-  /** Write a generated title and tell everyone who renders a row about it. */
-  #applyAutoTitle(id: string, title: string, force: boolean): SessionRow | null {
-    const row = this.#store.setAutoTitle(id, title, { force });
+  /** Write a generated title and tell everyone who renders a row about it.
+   *
+   *  `src` is the provenance the store ranks on (derived < agent < operator): a name only moves the
+   *  row when it comes from a better source, which is what keeps Hermes' per-turn regeneration from
+   *  renaming a running conversation. */
+  #applyAutoTitle(id: string, title: string, force: boolean, src: TitleSrc = "agent"): SessionRow | null {
+    const row = this.#store.setAutoTitle(id, title, { force, src });
     if (!row) return null;
     const live = this.#sessions.get(id);
     if (live) {
@@ -2165,7 +2178,7 @@ export class SessionManager {
     }
     if (!title) title = titleFromLatestPrompt(msgs);
     if (!title) throw new Error("这个会话还没有可以用来生成标题的对话内容");
-    if (!this.#applyAutoTitle(id, title, true)) throw new Error(`no such session: ${id}`);
+    if (!this.#applyAutoTitle(id, title, true, via)) throw new Error(`no such session: ${id}`);
     this.lastTitleVia = via;
     const info = this.#sessions.get(id)?.info ?? this.#coldInfo(id);
     this.#emit({ t: "session", session: info });

package/packages/server/src/hotwords.ts

@@ -48,7 +48,11 @@ const WORD_RE = /[A-Za-z][A-Za-z0-9_+.-]{2,}|[一-龥]{2,8}/g;
 /** Term-frequency over the operator's recent text, filtered and ranked. Returns at most
  *  `limit` terms; fixed hotwords always survive the cap separately. */
 export function extractDynamicHotwords(texts: string[], limit = 20): Hotword[] {
-  const counts = new Map<string, { n: number; sample: string }>();
+  // One entry per WORD, not per spelling: `Release` / `release` are one word to a recogniser, so
+  // counting them apart spends two of the operator's slots on one term and sends both as separate
+  // vocabulary keys. Keyed lowercase; the emitted spelling is the one seen most often (ties keep
+  // whichever appeared first — usually the sentence that introduced the term).
+  const counts = new Map<string, { n: number; forms: Map<string, number> }>();
   for (const text of texts) {
     for (const m of text.matchAll(WORD_RE)) {
       const raw = m[0];
@@ -62,25 +66,73 @@ export function extractDynamicHotwords(texts: string[], limit = 20): Hotword[] {
       } else if (raw.length > 8) {
         continue;
       }
-      const prev = counts.get(raw);
-      if (prev) prev.n += 1;
-      else counts.set(raw, { n: 1, sample: raw });
+      // Base16 fragments (`a551e`, `9f2c1ab`) pass every length/letters test but are never spoken:
+      // they are commit shas and ids the transcript cites. Require a digit so real hex-ish words
+      // (`LITE`, `NVDA`, `ACP`) survive.
+      if (/^(?=.*\d)[0-9a-f]{5,}$/i.test(raw)) continue;
+      const prev = counts.get(lower);
+      if (prev) {
+        prev.n += 1;
+        prev.forms.set(raw, (prev.forms.get(raw) ?? 0) + 1);
+      } else {
+        counts.set(lower, { n: 1, forms: new Map([[raw, 1]]) });
+      }
     }
   }
+  const spelled = (forms: Map<string, number>): string => {
+    let best = "";
+    let bestN = 0;
+    for (const [form, n] of forms) if (n > bestN) { best = form; bestN = n; }
+    return best;
+  };
   const ranked = [...counts.entries()]
     .filter(([, v]) => v.n >= 2)
-    .sort((a, b) => b[1].n - a[1].n || a[0].localeCompare(b[0]))
+    .map(([lower, v]) => ({ lower, word: spelled(v.forms), n: v.n }))
+    .sort((a, b) => b.n - a.n || a.lower.localeCompare(b.lower))
     .slice(0, limit);
-  return ranked.map(([word, v]) => ({
+  return ranked.map(({ word, n }) => ({
     word,
-    weight: v.n >= 5 ? 5 : 4,
+    weight: n >= 5 ? 5 : 4,
     origin: "dynamic" as const,
   }));
 }
 
+/** The natural-language text of one stored message, wherever its kind puts it.
+ *
+ *  Each shape has already been read wrong once, so they are spelled out here instead of being
+ *  re-guessed at every call site:
+ *  * `user` rows carry `payload.text`;
+ *  * ACP rows (`agent`, `thought`) carry the frame as `payload.content = { text }` — reading
+ *    `payload.text` gives undefined, and `String(payload.content)` gives `"[object Object]"`
+ *    (which is how `object` ended up in the word pool);
+ *  * `tool` rows carry `payload.title`, and that title is the COMMAND (`execute_code: import
+ *    sqlite3 …`). A tool command is not something the operator is about to say, so this
+ *    returns "" for them — identifiers like `input_mouse`/`emulation`/`https` came in from here.
+ *
+ *  Callers still choose which kinds to feed (see `contextTexts`); this only answers "where is
+ *  this row's text", never "is this row worth reading". */
+export function rowText(row: { kind: string; payload: unknown }): string {
+  const p = row.payload as { text?: unknown; content?: { text?: unknown } | unknown } | null;
+  if (row.kind === "user") return typeof p?.text === "string" ? p.text : "";
+  if (row.kind === "agent" || row.kind === "thought") {
+    const c = p?.content as { text?: unknown } | undefined;
+    return typeof c?.text === "string" ? c.text : "";
+  }
+  return "";
+}
+
+/** Drop fenced code blocks before mining: a model pasting `input_mouse` into a snippet is not
+ *  the model about to SAY `input_mouse`. Inline `code spans` are deliberately kept — they are
+ *  usually the very terms worth biasing (`kasmvnc`, `betabox`). */
+export function stripFencedCode(text: string): string {
+  return text.replace(/```[\s\S]*?```/g, " ").replace(/\s+/g, " ").trim();
+}
+
 /** Recent transcript text to mine hotwords from: the given session first (its messages
  *  are the conversation the operator is dictating INTO), then the other sessions so a
- *  term used across the cockpit today also surfaces. */
+ *  term used across the cockpit today also surfaces. Only natural-language rows feed the
+ *  pool (`user` + `agent`): tool calls and reasoning carry identifiers the operator will
+ *  never pronounce, and they used to fill most of the dynamic slots. */
 export function contextTexts(store: Store, sessionId?: string, budgetChars = 24_000): string[] {
   const out: string[] = [];
   let used = 0;
@@ -88,8 +140,8 @@ export function contextTexts(store: Store, sessionId?: string, budgetChars = 24_
     let n = 0;
     for (const r of rows) {
       if (n >= cap || used > budgetChars) break;
-      const p = r.payload as { text?: string; title?: string; content?: string };
-      const t = String(p?.text ?? p?.title ?? p?.content ?? "");
+      if (r.kind !== "user" && r.kind !== "agent") continue;
+      const t = stripFencedCode(rowText(r));
       if (t.length > 1 && t.length < 4000) {
         out.push(t);
         used += t.length;
@@ -97,27 +149,52 @@ export function contextTexts(store: Store, sessionId?: string, budgetChars = 24_
       }
     }
   };
-  if (sessionId) take(store.messagesTail(sessionId, 60).messages, 40);
+  // Ask the store for natural-language rows; a row window (`tail(60)`) is routinely all tool calls.
+  if (sessionId) take(store.messagesLastKinds(sessionId, ["user", "agent"], 40), 40);
   for (const s of store.listSessions(false)) {
     if (s.id === sessionId) continue;
-    take(store.messagesTail(s.id, 12).messages, 8);
+    take(store.messagesLastKinds(s.id, ["user", "agent"], 8), 8);
   }
   return out;
 }
 
+/** The tail of a session for DashScope's context enhancement ("根据上下文"): user/assistant turns
+ *  only, capped at 5 by the API.
+ *
+ *  The window used to be measured on ROWS and then filtered by KIND (`tail(8)`, then skip everything
+ *  that is not user/agent), which is empty almost always: dictation happens right after the agent
+ *  finished a burst of work, and 40+ consecutive `tool`/`thought` rows are normal here (measured on a
+ *  live session: zero natural-language rows in its last 40). So read a wide tail and take the last 5
+ *  SURVIVORS. Lives next to the pool because both answer the same question with the same row shapes. */
+export function dictationContext(store: Store, sessionId?: string, turns = 5): { role: "user" | "assistant"; text: string }[] {
+  if (!sessionId) return [];
+  // Read MORE than `turns` natural-language rows (a fenced-only reply can filter out) but never
+  // by row count: 200 rows of a busy session is 0 sentences, which is how this returned `[]` for
+  // a session with seven user turns in it.
+  const out: { role: "user" | "assistant"; text: string }[] = [];
+  for (const row of store.messagesLastKinds(sessionId, ["user", "agent"], turns + 5)) {
+    const text = stripFencedCode(rowText(row)).slice(0, 200);
+    if (text) out.push({ role: row.kind === "user" ? "user" : "assistant", text });
+  }
+  return out.slice(-turns);
+}
+
 /** The full list an ASR request should carry: fixed first (they may use =50), dynamic
  *  filling the rest up to the configured limit. */
 export function hotwordsFor(store: Store, sessionId?: string): Hotword[] {
   const v = getSettings().voice;
   const fixed = v.hotwords.map(parseHotword).filter((h): h is Hotword => Boolean(h));
-  const seen = new Set(fixed.map((h) => h.word));
+  // lowercase on purpose: a dynamic `hermes` must not ride along beside a fixed `Hermes` (same word to
+  // the recogniser, two vocabulary keys and two slots for us)
+  const seen = new Set(fixed.map((h) => h.word.toLowerCase()));
   const limit = Math.max(0, Math.min(200, v.hotwordLimit));
   const out: Hotword[] = fixed.slice(0, limit);
   if (v.dynamicHotwords) {
     const dyn = extractDynamicHotwords(contextTexts(store, sessionId), Math.max(0, limit - out.length));
     for (const h of dyn) {
-      if (seen.has(h.word)) continue;
-      seen.add(h.word);
+      const key = h.word.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
       out.push(h);
     }
   }

package/packages/server/src/index.ts

@@ -3,6 +3,7 @@
 import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
 import type { Duplex } from "node:stream";
 import { createHash, randomUUID } from "node:crypto";
+import { execFileSync } from "node:child_process";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
@@ -17,7 +18,7 @@ import { classifyError, checkedHealth, coerceRow, inspectRow, planFor, rowWarnin
 import { ChangedOnDiskError, FsError, listDirs, readTextFile, statFile, writeTextFile } from "./fs.js";
 import { terms } from "./term.js";
 import { VoiceError, listVoiceModels, setHotwordSource, synthesize, transcribe, voiceCapabilities } from "./voice.js";
-import { hotwordsFor, vocabularyOf } from "./hotwords.js";
+import { dictationContext, hotwordsFor, vocabularyOf } from "./hotwords.js";
 import { openDashscopeStream } from "./dashscope.js";
 import {
   agentSettings, getSettings, initSettings, observerSettings, planHintSettings, publicSettings,
@@ -71,6 +72,23 @@ const DATA_DIR_SOURCE = ENV_DATA_DIR
   : DATA_DIR === REPO_DATA_DIR
     ? "in-repo packages/server/.data"
     : hasData(DEFAULT_DATA_DIR) ? "existing ~/.agentus" : "default ~/.agentus (created on this boot)";
+// WHICH CODE THIS PROCESS IS RUNNING — resolved once, at boot, on purpose.
+//
+// The live server has no watcher, so the only thing that decides "is this release live?" is what
+// this process loaded. A promote used to compare the live tree's previous checkout with the new
+// tip, which stops being true the moment anything moves the tree first (an earlier promote that
+// died after checkout, a manual `git checkout`, a re-run): every later promote then saw a zero
+// diff, printed "no server-side change" and left the old process serving — the release looked
+// green while the code was a commit behind. This is that fact, from the process itself: promote
+// asks the server what it booted, and restarts because the answer is not the target commit.
+const BOOT_COMMIT = (() => {
+  try {
+    const out = execFileSync("git", ["rev-parse", "--short", "HEAD"], {
+      cwd: path.resolve(HERE, "../.."), encoding: "utf8", stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    return out || null;
+  } catch { return null; } // a published install has no .git — nothing to name
+})();
 const WEB_DIST = process.env.AGENTUS_WEB_DIST ?? path.resolve(HERE, "../../web/dist");
 // The Android companion artifact (/notify links to it, /agentus-companion.apk streams it).
 // First candidate is relative to THIS FILE (src → packages/server → packages → repo root,
@@ -374,19 +392,6 @@ setHotwordSource((sessionId) => hotwordsFor(store, sessionId).map((h) => h.word)
   });
 }
 
-/** The tail of the session being dictated into, for DashScope's context enhancement
- *  ("根据上下文"): user/assistant turns only, capped at 5 by the API. */
-function dictationContext(sessionId?: string): { role: "user" | "assistant"; text: string }[] {
-  if (!sessionId) return [];
-  const out: { role: "user" | "assistant"; text: string }[] = [];
-  for (const row of store.messagesTail(sessionId, 8).messages) {
-    if (row.kind !== "user" && row.kind !== "agent") continue;
-    const text = String((row.payload as { text?: string })?.text ?? "").trim().slice(0, 200);
-    if (text) out.push({ role: row.kind === "user" ? "user" : "assistant", text });
-  }
-  return out.slice(-5);
-}
-
 /**
  * Single prompt entry point (REST + WS both use it).
  * A failed turn must never be silent: the UI used to show a bare
@@ -1199,10 +1204,16 @@ async function post(path){const r=await fetch(path,{method:'POST'});alert(r.ok?'
     if (url.pathname === "/api/voice/hotwords" && req.method === "GET") {
       const sid = url.searchParams.get("sessionId") || undefined;
       const words = hotwordsFor(store, sid);
+      // contextTurns is the half of the request the settings page could not see: it is the
+      // count of natural-language turns the next recognition would carry, and it used to be
+      // 0 forever because the window was applied before the kind filter (issue #21).
+      const context = dictationContext(store, sid);
       return send(res, 200, {
         words: words.map((h) => ({ word: h.word, weight: h.weight, origin: h.origin })),
         fixed: words.filter((h) => h.origin === "fixed").length,
         dynamic: words.filter((h) => h.origin === "dynamic").length,
+        contextTurns: context.length,
+        context: context.map((c) => ({ role: c.role, text: c.text.slice(0, 80) })),
       });
     }
     // What the browser should offer: it can always speak/read text itself, and the
@@ -1536,7 +1547,9 @@ async function post(path){const r=await fetch(path,{method:'POST'});alert(r.ok?'
       // launcher sets neither, so live answers false. An instance-level fact, so it rides the
       // endpoint that already describes the instance rather than every backend row.
       const dev = Boolean(process.env.DEV_TREE) || process.env.AGENTUS_DEV === "1";
-      return send(res, 200, { asset, dev });
+      // `commit`: the code THIS process booted from (see BOOT_COMMIT). It is the only honest answer
+      // to "did the release actually land", because the tree can be moved under a running server.
+      return send(res, 200, { asset, dev, commit: BOOT_COMMIT });
     }
     if (url.pathname.startsWith("/api/")) return send(res, 404, { error: "not_found" });
     return serveStatic(req, res);
@@ -1790,7 +1803,7 @@ asrWss.on("connection", (ws: WebSocket, _req: IncomingMessage, url: URL) => {
   try {
     live = openDashscopeStream({
       vocabulary: vocabularyOf(words),
-      context: dictationContext(sessionId),
+      context: dictationContext(store, sessionId),
       onPartial: (text) => reply({ t: "asr-partial", text }),
       onFinal: (text) => reply({ t: "asr-final", text }),
       onError: (error) => reply({ t: "asr-error", error }),

package/packages/server/src/store/store.ts

@@ -62,6 +62,11 @@ function reemissionTarget(blockText: string, incoming: string): "same" | "grew"
 /** A page also stops on bytes, so one 30 KB message cannot overflow a phone-sized fetch. */
 const PAGE_BYTES = 256 * 1024;
 
+/** Provenance of a session's name, ranked: a name may only be overwritten by a BETTER source
+ *  (or by the operator asking for a new one). See `setAutoTitle`. */
+export type TitleSrc = "derived" | "agent" | "operator";
+const TITLE_RANK: Record<TitleSrc, number> = { derived: 1, agent: 2, operator: 3 };
+
 export interface SessionRow {
   id: string;
   backend: BackendId;
@@ -73,6 +78,9 @@ export interface SessionRow {
   autoTitle?: string | null;
   /** session id of whoever renamed it through the cockpit CLI; null = the operator's own name */
   titleBy?: string | null;
+  /** Where the CURRENT name came from — see the `title_src` migration below. Not part of SessionInfo:
+   *  it is bookkeeping that decides who may overwrite the row, not something the page draws. */
+  titleSrc?: TitleSrc | null;
   status: SessionStatus;
   pid: number | null;
   createdAt: number;
@@ -113,7 +121,8 @@ export interface SessionRow {
 
 interface RawSessionRow {
   id: string; backend: BackendId; acp_session_id: string | null; cwd: string;
-  title: string; auto_title?: string | null; title_by?: string | null; status: SessionStatus; pid: number | null;
+  title: string; auto_title?: string | null; title_by?: string | null; title_src?: string | null;
+  status: SessionStatus; pid: number | null;
   created_at: number; closed_at: number | null; archived_at?: number | null;
   modes?: string | null; config_options?: string | null;
   usage?: string | null; commands?: string | null;
@@ -178,7 +187,8 @@ function blockKeyOf(kind: string, payload: unknown): string | null {
 function rowToSession(r: RawSessionRow): SessionRow {
   return {
     id: r.id, backend: r.backend, acpSessionId: r.acp_session_id, cwd: r.cwd,
-    title: r.title, autoTitle: r.auto_title ?? null, titleBy: r.title_by ?? null, status: r.status, pid: r.pid,
+    title: r.title, autoTitle: r.auto_title ?? null, titleBy: r.title_by ?? null,
+    titleSrc: (r.title_src as TitleSrc | null) ?? null, status: r.status, pid: r.pid,
     createdAt: r.created_at, closedAt: r.closed_at, archivedAt: r.archived_at ?? null,
     modes: parseJson(r.modes), configOptions: parseJson(r.config_options) ?? [],
     usage: parseJson(r.usage), commands: parseJson(r.commands) ?? [],
@@ -376,6 +386,19 @@ export class Store {
     // rail would show it as fact. NULL = the operator (every existing row), a session id = that
     // session's agent renamed it through the cockpit CLI.
     if (!cols.has("title_by")) this.#db.exec("alter table sessions add column title_by text");
+    // WHERE THE CURRENT NAME CAME FROM, which `title_by` cannot answer: a generated name has no author
+    // (title_by is NULL) — exactly like a name the operator typed. Without this column the store cannot
+    // tell 「the operator named this」 from 「we generated this」, so every later generated name looked
+    // like the first one and moved the display title. Measured 2026-10-17: Hermes regenerates a title
+    // on EVERY turn (auxiliary `title_generation`), so a running conversation was renamed each time.
+    //   'derived'  — truncated from the operator's first prompt (no model, instant)
+    //   'agent'    — the agent announced a name (session_info_update / the 重新生成 fork)
+    //   'operator' — the operator typed it; nothing generated may move it
+    // NULL on existing rows = generated before this column existed; treated as 'agent'.
+    if (!cols.has("title_src")) this.#db.exec("alter table sessions add column title_src text");
+    // Existing rows get NULL here, i.e. "no generated name was ever recorded" — harmless: a legacy row
+    // that already wears a generated name is protected by `#autoTitleFrom`'s placeholder test, which
+    // only ever re-derives a name for a row still showing "Hermes @ tmp".
     // The session's own ACTIVITY clock — when the operator or the agent last really said something
     // in it. A COLUMN, not a derived `max(messages.created_at)` (AionUi's model: `modified_at` on
     // the conversation row, indexed, which is what its sidebar sorts by): every ingestion path
@@ -1069,6 +1092,23 @@ export class Store {
     return { hasMore: hasMore || page.length < capped.length, messages: page.reverse().map(rowToMessage) };
   }
 
+  /** The newest rows of the given KINDS, ignoring whatever sits in between.
+   *
+   *  A row window is the wrong unit when the question is "what did the humans say": one agentic
+   *  turn emits hundreds of `tool`/`thought` rows between two sentences, so `messagesTail(200)`
+   *  legitimately contains zero natural-language rows (measured on a live session: 275 rows, 153
+   *  tool + 106 thought, and every user/agent row older than the window). Filtering by kind in
+   *  SQL is the only way to ask for "the last 5 sentences" and actually get them.
+   */
+  messagesLastKinds(sessionId: string, kinds: string[], limit = 5): StoredMessage[] {
+    if (!kinds.length || limit <= 0) return [];
+    const marks = kinds.map(() => "?").join(",");
+    const rows = this.#db
+      .prepare(`select * from messages where session_id = ? and kind in (${marks}) order by seq desc limit ?`)
+      .all(sessionId, ...kinds, limit) as unknown as RawMessageRow[];
+    return rows.reverse().map(rowToMessage);
+  }
+
   messagesAfter(sessionId: string, afterSeq: number, limit = 500): StoredMessage[] {
     const rows = this.#db
       .prepare(
@@ -1099,10 +1139,15 @@ export class Store {
       | { title: string; auto_title: string | null }
       | undefined;
     if (!row) return false;
-    const next = title == null || !title.length ? (row.auto_title ?? row.title) : title;
+    const named = title != null && title.length > 0;
+    const next = named ? title : (row.auto_title ?? row.title);
     // `by` rides along on every write, including a reset: after `--auto` the name is generated again,
     // and the note that an agent once renamed it would be a lie about the CURRENT name.
-    const info = this.#db.prepare("update sessions set title = ?, title_by = ? where id = ?").run(next, by, id);
+    // `title_src` is what PINS the row: a hand-written name must survive every later generated one,
+    // while a reset hands the name back to whichever generator wrote `auto_title`.
+    const src = named ? "operator" : (row.auto_title ? "agent" : null);
+    const info = this.#db.prepare("update sessions set title = ?, title_by = ?, title_src = ? where id = ?")
+      .run(next, by, src, id);
     return Number(info.changes ?? 0) > 0;
   }
 
@@ -1115,18 +1160,30 @@ export class Store {
    *  the fallback and leaves the visible row alone. `force` is for the operator asking for a
    *  new name on purpose (the rail's 重新生成), where the new title is the point.
    *  Returns the row it ended up with, so callers can broadcast exactly what changed. */
-  setAutoTitle(id: string, title: string, { force = false }: { force?: boolean } = {}): SessionRow | null {
-    const row = this.#db.prepare("select title, auto_title from sessions where id = ?").get(id) as
-      | { title: string; auto_title: string | null }
+  setAutoTitle(
+    id: string, title: string, { force = false, src = "agent" }: { force?: boolean; src?: TitleSrc } = {},
+  ): SessionRow | null {
+    const row = this.#db.prepare("select title, auto_title, title_src from sessions where id = ?").get(id) as
+      | { title: string; auto_title: string | null; title_src: string | null }
       | undefined;
     if (!row) return null;
     const clean = title.replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 120).trim();
     if (!clean) return null;
-    const wasAuto = row.auto_title == null || row.auto_title === "" || row.title === row.auto_title;
-    const nextTitle = force || wasAuto ? clean : row.title;
+    // WHO WINS, by rank — derived < agent < operator. A name only moves the row when it comes from a
+    // BETTER source than the one already on it (or when there is nothing yet, or the operator asked
+    // for a new one). This is what stops 「跑着跑着标题就变了」: Hermes regenerates a title every turn,
+    // and every one of those is an `agent` name arriving over an `agent` name — the same generator
+    // saying the same thing again, not news. A `derived` guess still yields to the first real one.
+    // `null` = nothing has NAMED this row yet. That is not the same as "the operator named it": every
+    // row is INSERTED with `auto_title = title` (the placeholder "Hermes @ tmp"), so the column alone
+    // cannot say whether a name was ever generated — only `title_src` can.
+    const current = row.title_src as TitleSrc | null;
+    const named = current != null && row.auto_title != null && row.auto_title !== "";
+    const wins = force || !named || TITLE_RANK[src] > TITLE_RANK[current];
+    if (!wins) return this.getSession(id) ?? null;
     this.#db
-      .prepare("update sessions set auto_title = ?, title = ? where id = ?")
-      .run(clean, nextTitle, id);
+      .prepare("update sessions set auto_title = ?, title = ?, title_src = ? where id = ?")
+      .run(clean, clean, src, id);
     return this.getSession(id) ?? null;
   }