agentus 0.12.3 → 0.13.0

package/packages/server/src/settings.ts

@@ -176,7 +176,9 @@ export const CALL_DEFAULT: CallSettings = {
      and a long sentence with a breath in the middle got cut. Both ends of the range still let
      the room decide — this is only where a fresh install starts. */
   interruptMode: "voice", bargeSensitivity: 60, bargeMs: 300, silenceMs: 1500, minChars: 3,
-  wakePhrase: "",
+  /* Tus mode forces keyword interruption, so the shipped phrase has to exist: an empty starter
+     made the mode inert until somebody typed one. Matching strips spaces/punctuation/case. */
+  wakePhrase: "hi, Tus",
 };
 
 export const INTERRUPT_MODES: InterruptMode[] = ["voice", "button", "keyword"];
@@ -393,9 +395,19 @@ function callAtShippedDefaults(r: Record<string, unknown>): boolean {
   const modeShipped = r.interruptMode === undefined || r.interruptMode === CALL_DEFAULT.interruptMode;
   // …and a stored wake phrase is a deliberate choice too: without this, setting one and switching
   // back to 语音打断 would make the whole section look untouched and the phrase would be dropped.
-  const wakeShipped = r.wakePhrase === undefined || r.wakePhrase === CALL_DEFAULT.wakePhrase;
+  // The empty string is ALSO shipped: it was the default until 2026-10-24, and a row that still
+  // carries it together with the old numbers is a row nobody configured. (A row that was cleared
+  // by hand after the new default is indistinguishable — it gets the default back once.)
+  const wakeShipped = r.wakePhrase === undefined || r.wakePhrase === CALL_DEFAULT.wakePhrase
+    || r.wakePhrase === "";
+  // Two generations of numbers count as untouched: the pre-rename row (bargeLevel 0.2 / 1200 / 1)
+  // and the row that already holds what ships today (60 / 300 / 1500 / 3). Without the second one
+  // a new default can never reach an existing install — its row is already at the current numbers,
+  // so it fails the fossil test and keeps the old value (that is how 「hi, Tus」 stayed inert).
+  const silenceShipped = Number(r.silenceMs) === 1200 || Number(r.silenceMs) === CALL_DEFAULT.silenceMs;
+  const minCharsShipped = Number(r.minChars) === 1 || Number(r.minChars) === CALL_DEFAULT.minChars;
   return sens && modeShipped && wakeShipped
-    && Number(r.bargeMs) === 300 && Number(r.silenceMs) === 1200 && Number(r.minChars) === 1;
+    && Number(r.bargeMs) === 300 && silenceShipped && minCharsShipped;
 }
 
 /** What each knob may be. The ranges are the panel's slider ends; the server is the one

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

@@ -2,6 +2,7 @@
 // Design: sessions row carries `pid` (orphan-reclaim anchor, AC5);
 // messages carry monotonic per-session `seq` (reconnect replay anchor, AC6).
 import fs from "node:fs";
+import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import type { BackendId, PlanSnapshot, SessionStatus, StatusNoteItem, StoredMessage } from "../../../shared/src/index.js";
 import type { BackendHandshake, BackendHealth, BackendKind, BackendRow } from "../acp/registry.js";
@@ -42,6 +43,70 @@ const ANON_COVER = 0.6;
 /** How far back an anonymous re-emission is looked for. */
 const ANON_SCAN_ROWS = 80;
 
+/**
+ * Is this row a FRAGMENT of a message rather than a message?
+ *
+ * The store has to tell "one more frame of the reply being built" from "the next message". With no
+ * messageId (qoder) and no turn id (rows written before it existed) the only honest signal left is
+ * shape: a streamed frame is a few characters and never contains a line break. Two short messages in
+ * a row are still two messages, because a tool call or the operator's turn sits between them — and
+ * this is only ever used to decide whether to glue a row onto the row directly above it.
+ */
+/** Print the fold state once per store FILE per process (tests open several). */
+const foldStateLogged = new Set<string>();
+
+function isFragmentText(text: string): boolean {
+  return text.length > 0 && text.length <= 24 && !text.includes("\n");
+}
+
+/**
+ * How far apart two id-less fragments can be written and still belong to one streamed message.
+ *
+ * Frames of one reply land milliseconds apart; a conversation's two short messages are minutes or
+ * hours apart. This is the second half of the pair test — see `sameStream`.
+ */
+const FRAGMENT_WINDOW_MS = 2_000;
+
+/** Where "a full stop" stops being a frame boundary and starts being the end of a message. */
+const FRAGMENT_BOUNDARY_MS = 750;
+
+/** Text that closes a sentence — a plausible end of a message, never the middle of one. */
+const SENTENCE_FINAL = /[。．.!?！？…;；:：]\s*$/;
+/** A frame that is nothing but punctuation: a stream really does end "…works" + "." */
+const PUNCT_ONLY = /^[\s\p{P}\p{S}]+$/u;
+
+/**
+ * Is this row provably the next frame of the SAME streamed message as the row above it?
+ *
+ * Adjacency in the table is NOT adjacency in the stream: the replay dedupe (`#dedupeReplayedRows`)
+ * and the live tool-call upsert both remove rows that used to sit between two messages, so on every
+ * real store two unrelated short messages can end up neighbours. Measured on the operator's own DB:
+ * 24 rows ended up holding two messages ("Operation interrupted." ×2, hours apart) because of it.
+ *
+ * So a pair needs a second witness — the turn both rows belong to, or, for rows written before the
+ * turn id existed, a tight time window plus the fact that no chunk boundary lands after a full stop.
+ */
+function sameStream(prev: RawMessageRow, prevAt: number, cur: RawMessageRow, prevFrame: string, text: string): boolean {
+  // The clock is measured from the LAST FRAME, not from the row's first one: `prev` is the surviving
+  // row and its `created_at` never moves, so using it means "how long has this message been growing"
+  // — which cuts a long stream at its first full stop after 750 ms and unconditionally after 2 s.
+  const gap = Math.abs(cur.created_at - prevAt);
+  // The clock is the one witness that cannot lie. Frames of one reply are milliseconds apart; two
+  // messages a minute apart are two messages — whatever their turn ids say, because a turn holds
+  // MANY messages and the rows between them are exactly what the replay cleanup deletes.
+  if (gap > FRAGMENT_WINDOW_MS) return false;
+  const a = prev.turn_id;
+  const b = cur.turn_id;
+  // A matching turn id is a second witness, never a substitute for the clock: `turnSeq` restarts at 0
+  // after a server restart, so turn 1 of this run and turn 1 of the last run compare equal.
+  if (a !== null && a !== undefined && b !== null && b !== undefined && a !== b) return false;
+  // Judged on the previous FRAME, never on the accumulated text: a reply passes many full stops, and
+  // a full stop deep inside the accumulation says nothing about where this frame begins. A sentence
+  // end is evidence of a boundary only when the write also took long enough to be a real pause.
+  const looksLikeBoundary = SENTENCE_FINAL.test(prevFrame) && !PUNCT_ONLY.test(text);
+  return !(looksLikeBoundary && gap > FRAGMENT_BOUNDARY_MS);
+}
+
 /**
  * Is `incoming` the same block as `blockText` rather than new content?
  *
@@ -145,6 +210,7 @@ function parseJson(v: string | null | undefined): unknown {
 interface RawMessageRow {
   seq: number; session_id: string; kind: StoredMessage["kind"];
   payload: string; tool_call_id: string | null; block_key?: string | null; created_at: number;
+  turn_id?: number | null;
 }
 
 function rowToMessage(r: RawMessageRow): StoredMessage {
@@ -387,6 +453,14 @@ export class Store {
         thought_touched integer not null default 0, -- operator changed depth during the call
         updated_at integer not null
       );
+      -- Which one-time repairs have run, and at what version. The user_version pragma is a single
+      -- number, so two passes that both write it overwrite each other's answer: the store ended up
+      -- at 4 with the fold recorded as done while 311,638 unfolded rows were still in it.
+      create table if not exists repairs (
+        name text primary key,
+        version integer not null,
+        at integer not null
+      );
     `);
     // The DB now holds the speech endpoint's key, so it is the operator's secret material:
     // 0600 like the file it replaced (a default 0644 sqlite file would be a downgrade).
@@ -450,6 +524,12 @@ export class Store {
     );
     if (!mcols.has("block_key")) this.#db.exec("alter table messages add column block_key text");
     this.#db.exec("create index if not exists idx_messages_block on messages (session_id, block_key)");
+    // Which turn a row belongs to (issue #56). Qoder's live stream carries no `messageId`, so the
+    // only identity an id-less chunk has is "the message being built in THIS turn" — without it a
+    // reply is one row per token (measured: 311,638 thought rows in one session, 186 MB store), and
+    // folding on "same kind as the row above" alone would merge two genuinely separate replies.
+    if (!mcols.has("turn_id")) this.#db.exec("alter table messages add column turn_id integer");
+    this.#db.exec("create index if not exists idx_messages_turn on messages (session_id, turn_id)");
     // plans: the one-line TITLE a completion notification reads (issue #11). Additive, and null for
     // every existing plan — a card that has never been given a title falls back to its remark, and
     // then to the last step it closed, so an old store keeps behaving exactly as before.
@@ -479,6 +559,7 @@ export class Store {
     if (!beCols.has("last_check_latency_ms")) {
       this.#db.exec("alter table backends add column last_check_latency_ms integer");
     }
+    this.#migrateLegacyRepairVersions();
     this.#foldStreamedChunks();
     // …then the one-time removal of what the REPLAYS already wrote (see #dedupeReplayedRows), and the
     // clock for a store that predates the column — computed after the cleanup, so a session's time is
@@ -487,6 +568,57 @@ export class Store {
     if (!hadActivityClock) this.#backfillActivity();
   }
 
+  /**
+   * Has this one-time repair already run, and at which version?
+   *
+   * Repairs used to share `pragma user_version`, which is ONE number for the whole file: the fold
+   * set it to 2, the replay cleanup then set it to 4, and the next fold read 4 — "already done" —
+   * while the 311,638 unfolded rows it was written for were still in the table. Each pass keeps its
+   * own row here now. `legacy` is what a store that predates the table reports (it only ever had
+   * user_version to go by), so upgrading in place does not re-walk an already-folded file from 0.
+   */
+  #repairVersion(name: string, legacy: number): number {
+    const row = this.#db.prepare("select version from repairs where name = ?").get(name) as
+      | { version?: number } | undefined;
+    if (row && typeof row.version === "number") return row.version;
+    // Past the one-time migration below, a missing row really does mean "this pass never ran here".
+    return Math.min(this.#legacyUv(), legacy);
+  }
+
+  #legacyUv(): number {
+    const uv = this.#db.prepare("pragma user_version").get() as { user_version?: number } | undefined;
+    return Number(uv?.user_version ?? 0);
+  }
+
+  /**
+   * `pragma user_version` was the shared counter of the pre-`repairs` era, and one pass's number
+   * could satisfy another's — a store whose counter read 4 "had run" the cleanup even when only the
+   * fold had ever recorded anything. Read it as legacy exactly once, write what it implies into
+   * per-pass rows, and leave a marker so the reading never happens again. Without the marker, a
+   * destructive pass runs on a store whose record it cannot interpret (measured on the operator's
+   * file: 767 rows and 15 session clocks moved on a boot that had nothing to do).
+   */
+  #migrateLegacyRepairVersions(): void {
+    const marker = this.#db.prepare("select version from repairs where name = ?").get("per-pass-rows");
+    if (marker) return;
+    const any = this.#db.prepare("select count(*) as c from repairs").get() as { c?: number } | undefined;
+    if (Number(any?.c ?? 0) === 0 && this.#legacyUv() === 0) return;   // brand-new store: nothing to seed
+    const uv = this.#legacyUv();
+    const ins = this.#db.prepare("insert into repairs (name, version, at) values (?,?,?) on conflict(name) do nothing");
+    ins.run("fold", Math.min(uv, 2), Date.now());
+    ins.run("dedupe", uv >= 4 ? 4 : 0, Date.now());
+    ins.run("per-pass-rows", 1, Date.now());
+  }
+
+  #setRepairVersion(name: string, version: number): void {
+    this.#db.prepare("insert into repairs (name, version, at) values (?,?,?) on conflict(name) do update set version = excluded.version, at = excluded.at")
+      .run(name, version, Date.now());
+    // …and keep the old reading monotonic for a build that still asks user_version.
+    const uv = this.#db.prepare("pragma user_version").get() as { user_version?: number } | undefined;
+    const cur = Number(uv?.user_version ?? 0);
+    if (version > cur) this.#db.prepare(`pragma user_version = ${version}`).run();
+  }
+
   /**
    * One-time repair of transcripts written by the chunk-per-row era.
    *
@@ -503,13 +635,40 @@ export class Store {
   #foldStreamedChunks(): void {
     // v2: the anonymous-re-emission rule got sharper (a short block is no longer a fold candidate,
     // but a ≥24-char one that covers most of a block is) — an already-folded DB is worth re-walking.
-    const FOLD_VERSION = 2;
-    const v = this.#db.prepare("pragma user_version").get() as { user_version?: number } | undefined;
-    if (Number(v?.user_version ?? 0) >= FOLD_VERSION) return;
-    if (!this.#backup("fold")) return;
-    const sessions = this.#db.prepare("select distinct session_id as id from messages").all() as unknown as { id: string }[];
+    // v3: id-less FRAGMENTS are glued onto the row directly above (the qoder word-per-line era).
+    // v4: that rule was too eager (it merged messages that only LOOKED adjacent, once the replay
+    // cleanup had removed the rows between them) and too timid (it stopped folding after 24
+    // accumulated characters). A re-walk cannot un-merge what v3 glued — that is
+    // `scripts/repair-glued-rows.py`'s job — but it does re-join rows v3 split and stops new damage.
+    const FOLD_VERSION = 4;
+    // A store that predates the repairs table recorded its fold in user_version (2 = the rules
+    // shipped with it). Anything at 0/1 never folded at all.
+    // Two different questions: whether the pass must run again (the version gate below) and whether
+    // this file was EVER folded — the un-windowed replay rule is only safe on a store that never was,
+    // and it has no time window, so a genuine repeat reads as a copy and the second message is
+    // deleted. `user_version >= 2` is the legacy record of a fold that never wrote a `repairs` row
+    // (a boot whose backup failed returns before recording anything).
+    const seenFold = this.#repairVersion("fold", 2) >= 2 || this.#legacyUv() >= 2;
+    if (this.#repairVersion("fold", 2) >= FOLD_VERSION) {
+      // v3 shipped a rule that could glue two DISTINCT messages when the replay cleanup had removed
+      // the rows between them; a store folded by it keeps those rows — no re-run can un-merge them
+      // (the second half's row is gone). Say the version once per process so "clean" and "folded
+      // before the fix" are not indistinguishable in the log; the split lives in
+      // tasks/20261001-agentus/scripts/repair-glued-rows.py.
+      if (!foldStateLogged.has(this.#path)) {
+        foldStateLogged.add(this.#path);
+        console.log(`[store] 分片折叠：v${FOLD_VERSION}（已是当前版本，本次不改动历史行）`);
+      }
+      return;
+    }
+    if (!this.#backup("fold", FOLD_VERSION)) return;
+    // One transaction for the whole walk: this is a per-row update pass over every message in the
+    // file (430k rows on the operator's store) and autocommit is what made it 46 seconds of boot.
+    this.#db.exec("begin");
     let before = 0;
     let after = 0;
+    try {
+    const sessions = this.#db.prepare("select distinct session_id as id from messages").all() as unknown as { id: string }[];
     const upd = this.#db.prepare("update messages set payload = ?, block_key = ? where session_id = ? and seq = ?");
     const del = this.#db.prepare("delete from messages where session_id = ? and seq = ?");
     for (const { id } of sessions) {
@@ -517,16 +676,35 @@ export class Store {
         .prepare("select * from messages where session_id = ? order by seq asc")
         .all(id) as unknown as RawMessageRow[];
       before += rows.length;
-      const kept: { row: RawMessageRow; text: string | null }[] = [];
+      const kept: { row: RawMessageRow; text: string | null; frame: string; frameAt: number }[] = [];
       const doomed: number[] = [];
       for (const r of rows) {
         if (r.kind !== "agent" && r.kind !== "thought") {
-          kept.push({ row: r, text: null });
+          kept.push({ row: r, text: null, frame: "", frameAt: r.created_at });
           continue;
         }
         const payload = parseJson(r.payload);
         const text = textOf(payload);
         const key = blockKeyOf(r.kind, payload);
+        // A word-per-line stream: rows written before the turn id existed (qoder sends no messageId,
+        // so the era's rows are "There" / " are" / ")" — 311,638 of them in one session). Both sides
+        // must be fragments and the target must be the row immediately above: a real message that
+        // happens to be short twice in a row is separated by the tool/operator row between them.
+        const prev = kept[kept.length - 1];
+        // "Is this a fragment" is a property of ONE FRAME, so it is judged on the last frame that went
+        // into the row above, not on the row's accumulated text: otherwise folding stops as soon as
+        // the message passes 24 characters, which is every message worth folding (measured on the
+        // operator's store: 311,638 one-word thought frames only reached ~6 per row for this reason).
+        if (!key && prev && prev.row.kind === r.kind && prev.text !== null
+            && isFragmentText(prev.frame) && isFragmentText(text)
+            && blockKeyOf(prev.row.kind, parseJson(prev.row.payload)) === null
+            && sameStream(prev.row, prev.frameAt, r, prev.frame, text)) {
+          prev.text += text;
+          prev.frame = text;
+          prev.frameAt = r.created_at;
+          doomed.push(r.seq);
+          continue;
+        }
         // Walk back to the block this row belongs to: the same messageId, or a block whose text
         // already contains this one (the agent replays its own text without an id).
         let hitIdx = -1;
@@ -535,17 +713,27 @@ export class Store {
           if (cand.text === null || cand.row.kind !== r.kind) continue;
           const candText: string = cand.text;
           if (key && blockKeyOf(cand.row.kind, parseJson(cand.row.payload)) === key) { hitIdx = i; break; }
-          if (!key && reemissionTarget(candText, text)) { hitIdx = i; break; }
+          // Replays are only judged here for a store that has never been folded. On a store that has,
+          // the evidence-based pass (#dedupeReplayedRows) owns them — this walk has no time window,
+          // so a genuine repeat would read as a copy.
+          if (!key && !seenFold && reemissionTarget(candText, text)) { hitIdx = i; break; }
           if (kept.length - i > ANON_SCAN_ROWS) break;
         }
         if (hitIdx >= 0) {
           const target = kept[hitIdx];
           const delta = key ? appendedTextDelta(target.text ?? "", text) : "";
+          // Same id, same text: that is a REPLAY, and judging replays is #dedupeReplayedRows' job
+          // (it has the time window and the evidence). Deleting here would also eat a genuine short
+          // repeat — "好的" sent twice is a conversation.
+          if (key && !delta) {
+            kept.push({ row: r, text, frame: text, frameAt: r.created_at });
+            continue;
+          }
           if (delta) target.text = (target.text ?? "") + delta;
           doomed.push(r.seq);
           continue;
         }
-        kept.push({ row: r, text });
+        kept.push({ row: r, text, frame: text, frameAt: r.created_at });
       }
       for (const seq of doomed) del.run(id, seq);
       for (const k of kept) {
@@ -556,7 +744,12 @@ export class Store {
       }
       after += kept.length;
     }
-    this.#db.prepare(`pragma user_version = ${FOLD_VERSION}`).run();
+    this.#setRepairVersion("fold", FOLD_VERSION);
+    this.#db.exec("commit");
+    } catch (e) {
+      this.#db.exec("rollback");
+      throw e;
+    }
     console.log(`[store] 历史分片已折叠：${before} 行 → ${after} 行`);
   }
 
@@ -564,12 +757,38 @@ export class Store {
    * Copy the DB aside ONCE, before a destructive repair pass. False means no backup could be made
    * (a read-only filesystem, a locked file) — the caller must then leave the data alone.
    */
-  #backup(tag: string): boolean {
-    const bak = `${this.#path}.pre-${tag}.bak`;
+  #backup(tag: string, version: number): boolean {
+    // The name carries the pass version AND the moment: a per-tag name (the old behaviour) meant the
+    // second-ever destructive pass silently reused the first one's copy. Measured on the operator's
+    // machine: the fold that rewrote 430,318 rows "backed up" to a file from 19 days earlier that did
+    // not even contain the session being folded, so a bad rule had no safety net at all.
+    const bak = `${this.#path}.pre-${tag}-v${version}-${new Date().toISOString().replace(/[:.]/g, "-")}.bak`;
     try {
-      if (!fs.existsSync(bak)) {
-        this.#db.exec(`vacuum into '${bak.replace(/'/g, "''")}'`);
-        console.log(`[store] 修复前已备份：${bak}`);
+      this.#db.exec(`vacuum into '${bak.replace(/'/g, "''")}'`);
+      console.log(`[store] 修复前已备份：${bak}`);
+      // Keep the newest copy of every pass version (the run before a rule change is the one that may
+      // hold rows the newer rule no longer produces) plus the newest three overall; a 400k-row store
+      // copies to hundreds of MB, so this must not grow with every version bump.
+      try {
+        const dir = path.dirname(this.#path);
+        const base = path.basename(this.#path);
+        const mine = fs
+          .readdirSync(dir)
+          // per tag AND per pass version: bumping the version must not evict the backup of the run
+          // that came before it (the one that may hold the rows the newer rule no longer produces)
+          .filter((f) => f.startsWith(`${base}.pre-${tag}-v`))
+          .map((f) => ({ f, at: fs.statSync(path.join(dir, f)).mtimeMs }))
+          .sort((a, b) => b.at - a.at);
+        const keep = new Set(mine.slice(0, 3).map((x) => x.f));
+        const perVersion = new Set<string>();
+        for (const x of mine) {
+          const m = /-v(\d+)-/.exec(x.f);
+          const v = m?.[1] ?? "";
+          if (!perVersion.has(v)) { perVersion.add(v); keep.add(x.f); }
+        }
+        for (const old of mine) if (!keep.has(old.f)) fs.unlinkSync(path.join(dir, old.f));
+      } catch {
+        /* pruning is a courtesy — never fail the repair over it */
       }
       return true;
     } catch (e) {
@@ -605,9 +824,10 @@ export class Store {
     // already carries v3 therefore still holds them, so the walk is worth repeating; v4 also puts
     // back the activity clock the same replay bumped (see the tail of this method).
     const DEDUPE_VERSION = 4;
-    const v = this.#db.prepare("pragma user_version").get() as { user_version?: number } | undefined;
-    if (Number(v?.user_version ?? 0) >= DEDUPE_VERSION) return;
-    if (!this.#backup("dedupe")) return;
+    // Legacy: this pass wrote its own number into user_version (3, then 4) before the repairs table
+    // existed, so a store carrying 4 has already run it.
+    if (this.#repairVersion("dedupe", 4) >= DEDUPE_VERSION) return;
+    if (!this.#backup("dedupe", DEDUPE_VERSION)) return;
     // The store's own floor for "this is a block, not an utterance" (`reemissionTarget`): below it a
     // repeat is legitimately two messages ("好的" twice) and never a replay of one block.
     const MIN_DUP_CHARS = 24;
@@ -618,6 +838,7 @@ export class Store {
     let toolsDropped = 0;
     let textDropped = 0;
     let kept = 0;
+    const doomedSessions = new Set<string>();
     const sessions = this.#db
       .prepare("select distinct session_id as id from messages")
       .all() as unknown as { id: string }[];
@@ -674,6 +895,7 @@ export class Store {
         textDropped += 1;
       }
       for (const seq of doomed) del.run(id, seq);
+      if (doomed.size > 0) doomedSessions.add(id);
       after += rows.length - doomed.size;
     }
     // The same replay also bumped the session's ACTIVITY clock — `#touch` fires on any write, so a
@@ -681,15 +903,23 @@ export class Store {
     // eleven sessions at once, 10:44:52 → 10:45:20). With the copies now gone, a clock that sits
     // AHEAD of the session's newest surviving row is provably that bump and nothing else, so put it
     // back to the row that is actually there. A session with no messages left keeps what it has.
-    const clock = this.#db
-      .prepare(
-        `update sessions set last_activity_at =
-           (select max(m.created_at) from messages m where m.session_id = sessions.id)
-         where last_activity_at is not null
-           and last_activity_at > (select max(m.created_at) from messages m where m.session_id = sessions.id)`,
-      )
-      .run();
-    this.#db.prepare(`pragma user_version = ${DEDUPE_VERSION}`).run();
+    // …and only where rows were actually removed. A session's clock legitimately sits ahead of its
+    // newest row after any long turn (`#touch` at turn end), so an unscoped version of this rewrote
+    // the rail order of every session in the file — 15 clocks moved on a boot that deleted from 5.
+    let clock = { changes: 0 as number | bigint };
+    if (doomedSessions.size > 0) {
+      const ids = [...doomedSessions];
+      clock = this.#db
+        .prepare(
+          `update sessions set last_activity_at =
+             (select max(m.created_at) from messages m where m.session_id = sessions.id)
+           where id in (${ids.map(() => "?").join(",")})
+             and last_activity_at is not null
+             and last_activity_at > (select max(m.created_at) from messages m where m.session_id = sessions.id)`,
+        )
+        .run(...ids);
+    }
+    this.#setRepairVersion("dedupe", DEDUPE_VERSION);
     if (before !== after) {
       console.log(
         `[store] 重放行清理：${before} 行 → ${after} 行（工具行 ${toolsDropped}、文本行 ${textDropped}；`
@@ -1124,7 +1354,7 @@ export class Store {
    * the frame was a pure re-emission (nothing to emit); an existing row with a non-empty delta means
    * "this row grew" — the client appends instead of inserting a second bubble.
    */
-  appendTextChunk(m: Omit<StoredMessage, "seq"> & { kind: "agent" | "thought" }): {
+  appendTextChunk(m: Omit<StoredMessage, "seq"> & { kind: "agent" | "thought" }, turnId?: number): {
     message: StoredMessage;
     delta: string;
     isNew: boolean;
@@ -1146,13 +1376,41 @@ export class Store {
     if (!key) {
       const row = this.#rowContaining(m.sessionId, m.kind, text);
       if (row) return this.#foldInto(row, text);   // "grew" appends the tail, "same" is a no-op
+      // 3. an id-less DELTA of a message this same turn is still building (issue #56, qoder). Its
+      //    frames carry no messageId at all, so "same kind, same turn, still the newest row" is the
+      //    only identity available — and the turn id is what keeps two separate replies apart
+      //    (a new turn starts a new row, and a tool/plan/user row in between does too).
+      if (turnId !== undefined) {
+        const open = this.#openTurnRow(m.sessionId, m.kind, turnId);
+        if (open) return this.#foldInto(open, text);
+      }
     }
     const stored = this.appendMessage(m);
     if (key) this.#db.prepare("update messages set block_key = ? where session_id = ? and seq = ?")
       .run(key, m.sessionId, stored.seq);
+    if (turnId !== undefined || key) {
+      this.#db.prepare("update messages set turn_id = ? where session_id = ? and seq = ?")
+        .run(turnId ?? null, m.sessionId, stored.seq);
+    }
     return { message: stored, delta: text, isNew: true };
   }
 
+  /** The row an id-less delta continues: same kind, same turn, still the newest row of the session. */
+  #openTurnRow(sessionId: string, kind: string, turnId: number): StoredMessage | undefined {
+    const r = this.#db
+      .prepare("select * from messages where session_id = ? and kind = ? order by seq desc limit 1")
+      .get(sessionId, kind) as unknown as RawMessageRow | undefined;
+    if (!r) return undefined;
+    if ((r as unknown as { turn_id?: number | null }).turn_id !== turnId) return undefined;
+    if ((r as unknown as { block_key?: string | null }).block_key) return undefined;
+    // …and nothing was appended after it (a tool call, a plan, the operator) — that ends the message.
+    const newest = this.#db
+      .prepare("select seq from messages where session_id = ? order by seq desc limit 1")
+      .get(sessionId) as { seq: number } | undefined;
+    if (!newest || newest.seq !== r.seq) return undefined;
+    return rowToMessage(r);
+  }
+
   /** Append to the row that already accumulates this message (or report it as a re-emission). */
   #foldInto(row: StoredMessage, incoming: string): { message: StoredMessage; delta: string; isNew: boolean } {
     const existing = textOf(row.payload);

package/packages/shared/src/index.ts

@@ -16,6 +16,28 @@
 /** Backend ids are registry rows now (M6): the three builtin ones plus anything the operator
  *  adds in the cockpit ("hermes-fork", "hermes-live", …). The literal union keeps autocomplete
  *  for the builtins while letting a row id through. */
+/** 通话表情标签的**规范词表** —— 服务端把它写进提示词，页面按它决定画哪张脸。
+ *
+ *  One list, two consumers: the server composes the instruction, the browser parses what comes
+ *  back. Keeping them apart is how you get a prompt that offers `[emo:excited]` while the face
+ *  silently ignores it, so the vocabulary lives here and the web side carries a superset of
+ *  synonyms on top (see `EMO_MOODS` in tusMood.ts, guarded by the `tus-mood` test). */
+export const EMO_TAG_VALUES = [
+  // Grok Bot 的九个官方表情名（2026-10-24 起提示词照官方词表）
+  "neutral", "happy", "surprised", "inspecting", "sad", "sleepy", "squinted", "calm", "confused",
+  // 我们自己的四张：想、好奇、顶住、害羞（官方没有，或语义不同）
+  "curious", "thinking", "angry", "shy",
+] as const;
+
+/** The sentence the call prompt carries. Kept next to the vocabulary so they cannot drift. */
+export function emoTagHint(): string {
+  return (
+    "（通话界面会跟着你的情绪换表情：想表达情绪时在回复最开头加一个隐藏标记，例如 [emo:happy]；" +
+    `可用值：${EMO_TAG_VALUES.join("/")}。这个标记不会被念出来、也不会显示给用户，` +
+    "所以不必解释它；一轮最多一个，别写进句子中间，也别用代码块或反引号包起来。）"
+  );
+}
+
 export type BackendId = "hermes" | "qoder" | "mock" | (string & {});
 
 export type SessionStatus =