agentus 0.11.1 → 0.11.3

package/README.md

@@ -57,7 +57,7 @@ background process comes back as a turn of its own), an **ACP session that write
 cockpit-side failure is diagnosable afterwards), 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-20261023-0540`, on Hermes `v0.22.0`.
+`agentus/v0.22.0/merge-20261023-0607`, 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

@@ -51,7 +51,7 @@ web bundle、配套 APK —— 然后直接退出，不启动任何东西）。
 以及 **DeepSeek 的 web 后端**（搜索 + 正文抓取，共用模型 key）—— 来自 fork 的集成构建（tag）。
 装法就五行：
 [§ 该跑哪份 Hermes](docs/installation.zh-CN.md#该跑哪份-hermes) —— 当前是 tag
-`agentus/v0.22.0/merge-20261023-0540`，基座 Hermes `v0.22.0`。
+`agentus/v0.22.0/merge-20261023-0607`，基座 Hermes `v0.22.0`。
 
 你启动的第一个 slot 会使用**你自己的 agent 已经在用的**那个 Hermes home（`~/.hermes`），除非后端那一行
 指定了另一个 —— 见下面的「HERMES_HOME」。

package/docs/installation.md

@@ -60,7 +60,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-20261023-0540`** — the newest tag on the fork,
+**Current integration build: `agentus/v0.22.0/merge-20261023-0607`** — 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

@@ -52,7 +52,7 @@ agentus/<hermes 内部版本>/merge-<YYYYMMDD-HHMM>
 tag。`agentus/` 这个前缀也把它和上游自己的 tag（`v0.22.0`、`v0.22.0+canary.*`）分开；最后一段是时间戳，
 可排序，所以「最新」就是一次 `sort -V`。
 
-**当前集成构建：`agentus/v0.22.0/merge-20261023-0540`** —— fork 上最新的那个 tag，基座 Hermes
+**当前集成构建：`agentus/v0.22.0/merge-20261023-0607`** —— fork 上最新的那个 tag，基座 Hermes
 `v0.22.0`。这行只为一眼看个大概，不是权威：下面的 `TAG=$(…)` 每次都会自己解析出最新，觉得这行过期就
 以它为准。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentus",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "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/src/acp/session-manager.ts

@@ -320,6 +320,8 @@ export class SessionManager {
   #callLive: () => string | null = () => null;
   /** Serialises call-state transitions (see syncCallState). */
   #callSync: Promise<void> = Promise.resolve();
+  /** Per-session call generation (see #callGen). */
+  #callGens = new Map<string, number>();
   setCallLiveSource(read: () => string | null): void {
     this.#callLive = read;
   }
@@ -470,6 +472,7 @@ export class SessionManager {
   }
 
   async #beginCall(id: string): Promise<void> {
+    this.#bumpCallGen(id);
     const prev = this.#store.getVoiceMode(id);
     if (prev.inCall) return; // idempotent: a second presence beat for the same call changes nothing
     if (!this.#store.getSession(id)) return; // a call with a session this store has never seen
@@ -482,7 +485,10 @@ export class SessionManager {
     this.#store.upsertVoiceMode(id, {
       inCall: true, boundary: "enter", turns: 0,
       thoughtBefore: before,
-      thoughtTouched: prev.thoughtBefore ? prev.thoughtTouched : false,
+      // A new call starts untouched even if the PREVIOUS call ended with the operator's own pick
+      // still recorded: that pick was already honoured (by not restoring it), and inheriting the
+      // flag here would skip the lowering for this whole call (review round 2, A-m2).
+      thoughtTouched: false,
     });
     // A call is full-duplex: waiting 20 s for a first token reads as a dead line to the operator.
     // Lower the dial for the call and put the operator's own choice back on hang-up (see #restoreThought).
@@ -495,6 +501,7 @@ export class SessionManager {
   }
 
   async #endCall(id: string): Promise<void> {
+    this.#bumpCallGen(id);
     const v = this.#store.getVoiceMode(id);
     // Nothing was actually said (no prompt ever rode this call): owe nothing. An exit block here
     // would tell the agent "the conversation above was spoken", which is false — and it is cheap to
@@ -525,16 +532,44 @@ export class SessionManager {
     } catch {
       return false;
     }
+    // A new call may have started while this round-trip was in flight: it needs the snapshot, so
+    // leave it alone (the new call will restore it on ITS hang-up).
+    if (this.#store.getVoiceMode(id).inCall) return false;
+    // `setConfig` reports a rejected value by emitting, not by throwing: verify against what the
+    // agent actually advertises before declaring the level restored (review round 2, A-m1). The
+    // knob must still be the SAME one (a model/mode switch changes the list) and an answer without
+    // `currentValue` proves nothing — in both cases keep the snapshot rather than silently staying
+    // on the call level (review r3 A-③).
+    const now = thinkingOptionOf(s.info.configOptions);
+    if (!now || now.id !== choice.id || !now.current) return false;
+    if (now.current !== v.thoughtBefore) return false;
     this.#store.upsertVoiceMode(id, { thoughtBefore: null, thoughtTouched: false });
     return true;
   }
 
+  /** Monotonic per-session call generation: every begin/end is a new one. Used to make sure a
+   *  settle() only touches the call it was created in (review r3 A-②). */
+  #callGen(id: string): number {
+    return this.#callGens.get(id) ?? 0;
+  }
+
+  #bumpCallGen(id: string): void {
+    this.#callGens.set(id, (this.#callGens.get(id) ?? 0) + 1);
+  }
+
+  /** Run a restore on the call-state chain instead of behind its back. */
+  #queueRestore(id: string): void {
+    this.#callSync = this.#callSync
+      .then(() => this.#restoreThought(id))
+      .then(() => undefined, () => undefined);
+  }
+
   /** Attach this prompt's voice block, and settle what it settles. Synchronous on purpose: it runs
    *  inside the send path, and a slow store write must not delay the operator's words.
    *
-   *  Returns a settle() to call once the turn is actually delivered: a prompt that threw before the
-   *  agent saw it must not consume a boundary or count as a spoken turn (review m1). */
-  #applyVoiceMode(s: LiveSession, blocks: unknown[], opts: { operator: boolean }): (delivered: boolean) => void {
+   *  Returns a settle() to call once the turn has been dispatched: before that point the boundary is
+   *  still owed, so a failed send does not burn it (review m1). */
+  #applyVoiceMode(s: LiveSession, blocks: unknown[], opts: { operator: boolean }): () => void {
     // A background-completion wake is not a spoken turn: letting it consume the boundary injected
     // "the call is over" into a synthetic turn nobody reads, so the operator's next real message
     // never learned it, and each wake inflated the turn count (review M1).
@@ -547,19 +582,36 @@ export class SessionManager {
     if (v.inCall && live !== s.info.id) {
       const owed = v.turns > 0;
       v = this.#store.upsertVoiceMode(s.info.id, { inCall: false, boundary: owed ? "exit" : null, ...(owed ? {} : { turns: 0 }) });
-      void this.#restoreThought(s.info.id);
+      // On the SAME chain as every other transition: a fire-and-forget restore could finish after a
+      // new call had already pressed the level down, clear the snapshot, and strand the session on
+      // the call level (review round 2, A-M2).
+      this.#queueRestore(s.info.id);
     } else if (!v.inCall && live === s.info.id) {
       v = this.#store.upsertVoiceMode(s.info.id, { inCall: true, boundary: v.boundary ?? "enter", turns: 0 });
     }
     const block = voiceModeBlock(s.info.id, { inCall: v.inCall, boundary: v.boundary, turns: v.turns });
     if (block) blocks.push(block);
-    const hadBoundary = Boolean(v.boundary);
+    const seenBoundary = v.boundary;
     const counted = v.inCall;
-    if (!hadBoundary && !counted) return () => { /* steady state, nothing to settle */ };
-    return (delivered: boolean) => {
-      if (!delivered) return;
-      if (hadBoundary) this.#store.upsertVoiceMode(s.info.id, { boundary: null });
-      if (counted) this.#store.upsertVoiceMode(s.info.id, { turns: this.#store.getVoiceMode(s.info.id).turns + 1 });
+    if (!seenBoundary && !counted) return () => { /* steady state, nothing to settle */ };
+    // The turn is counted NOW, not when the prompt returns: hanging up while the agent is still
+    // answering is the ordinary way a call ends, and `#endCall` must already see that something was
+    // said or it owes no exit boundary (review round 2, A-M1). A prompt that never reaches the agent
+    // rolls the count back.
+    if (counted) this.#store.upsertVoiceMode(s.info.id, { turns: v.turns + 1 });
+    // No rollback on a thrown prompt, deliberately: "the frame went out and the answer never came
+    // back" cannot be told apart from "the frame never went out", and the two mistakes are not
+    // symmetric — over-counting costs one extra sentence in the exit block, under-counting means the
+    // exit boundary is never owed at all and the agent keeps answering text in spoken-word style
+    // (review r3 A-①).
+    // The generation guards against a same-shaped boundary that arrived AFTER this turn started:
+    // consume the enter boundary, hang up and dial again → the new call's enter must survive.
+    const gen = this.#callGen(s.info.id);
+    return () => {
+      if (seenBoundary && this.#callGen(s.info.id) === gen) {
+        const cur = this.#store.getVoiceMode(s.info.id);
+        if (cur.boundary === seenBoundary) this.#store.upsertVoiceMode(s.info.id, { boundary: null });
+      }
     };
   }
 
@@ -1332,9 +1384,8 @@ export class SessionManager {
         prompt: blocks as any,
       });
       const terminalState = res?.stopReason === "cancelled" ? "interrupted" : "ended";
-      // The agent has the block (a cancelled turn still received it): NOW the boundary is spent and
-      // the turn counts.
-      settleVoice(true);
+      // The agent has the block (a cancelled turn still received it): NOW the boundary is spent.
+      settleVoice();
       this.#finalizePlan(sessionId, terminalState);
       this.#emit({ t: "turn-end", sessionId, stopReason: res?.stopReason, durationMs: Date.now() - turnStartedAt });
     } catch (err) {