agentus 0.11.0 → 0.11.2

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-0522`, on Hermes `v0.22.0`.
+`agentus/v0.22.0/merge-20261023-0556`, 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-0522`，基座 Hermes `v0.22.0`。
+`agentus/v0.22.0/merge-20261023-0556`，基座 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-0522`** — the newest tag on the fork,
+**Current integration build: `agentus/v0.22.0/merge-20261023-0556`** — 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-0522`** —— fork 上最新的那个 tag，基座 Hermes
+**当前集成构建：`agentus/v0.22.0/merge-20261023-0556`** —— fork 上最新的那个 tag，基座 Hermes
 `v0.22.0`。这行只为一眼看个大概，不是权威：下面的 `TAG=$(…)` 每次都会自己解析出最新，觉得这行过期就
 以它为准。
 

package/package.json

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

@@ -16,7 +16,7 @@ import type {
 } from "@agentclientprotocol/sdk";
 import { BACKENDS, buildSpawnEnv, nativePlanSourceOf, type BackendSpec } from "./backends.js";
 import { forgetAgentOwner, recordAgentOwner, verifyAgentOwner } from "./agent-owner.js";
-import { thinkingOptionOf, voiceModeBlock } from "./voice-mode.js";
+import { thinkingOptionOf, voiceAppliesToPrompt, voiceModeBlock } from "./voice-mode.js";
 import {
   byActivity,
   coldPage as pageCold,
@@ -318,6 +318,8 @@ export class SessionManager {
    *  answer in this process, and a second source would drift. Optional: with nothing wired the
    *  manager never injects anything, which is the pre-#48 behaviour. */
   #callLive: () => string | null = () => null;
+  /** Serialises call-state transitions (see syncCallState). */
+  #callSync: Promise<void> = Promise.resolve();
   setCallLiveSource(read: () => string | null): void {
     this.#callLive = read;
   }
@@ -449,6 +451,17 @@ export class SessionManager {
    *  answer 「好的，我了解了」 into the microphone. The block rides the next real prompt.
    */
   async syncCallState(): Promise<void> {
+    // Serialised: presence arrives on a 30 s beat AND on every visibility/enter/leave event, and two
+    // overlapping runs used to interleave the dial switch — a hang-up that restored the operator's
+    // level could be overtaken by the lowering of the call that had just ended, leaving the session
+    // stuck on the lowest level with its snapshot already cleared (review B2).
+    this.#callSync = this.#callSync
+      .then(() => this.#syncCallStateOnce())
+      .catch(() => { /* presence is a hint: never break the caller */ });
+    return this.#callSync;
+  }
+
+  async #syncCallStateOnce(): Promise<void> {
     const live = this.#callLive();
     for (const v of this.#store.listInCall()) {
       if (v.sessionId !== live) await this.#endCall(v.sessionId);
@@ -457,49 +470,132 @@ export class SessionManager {
   }
 
   async #beginCall(id: string): Promise<void> {
+    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
     const s = this.#sessions.get(id);
     const choice = s ? thinkingOptionOf(s.info.configOptions) : null;
+    // A snapshot left behind by an earlier call (the restore could not run: slot was cold, or the
+    // process died) is still the operator's real level — never overwrite it with the pressed-down
+    // value we may have persisted onto the session row (review B1).
+    const before = prev.thoughtBefore ?? choice?.current ?? null;
     this.#store.upsertVoiceMode(id, {
       inCall: true, boundary: "enter", turns: 0,
-      thoughtBefore: choice?.current ?? null, thoughtTouched: false,
+      thoughtBefore: before,
+      // 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 #endCall).
-    if (s && choice && choice.lowest && choice.current !== choice.lowest) {
+    // Lower the dial for the call and put the operator's own choice back on hang-up (see #restoreThought).
+    if (s && choice && choice.lowest && before !== choice.lowest && !this.#store.getVoiceMode(id).thoughtTouched) {
       await this.setConfig(id, choice.id, choice.lowest, { internal: true }).catch(() => { /* the block still goes out */ });
+      // A hang-up can land while the switch is in flight: if the call is already over, put it back
+      // now rather than leaving the session on the pressed-down level.
+      if (!this.#store.getVoiceMode(id).inCall) await this.#restoreThought(id);
     }
   }
 
   async #endCall(id: string): Promise<void> {
     const v = this.#store.getVoiceMode(id);
-    this.#store.upsertVoiceMode(id, { inCall: false, boundary: "exit" });
+    // 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
+    // trigger (opening the call overlay and closing it, a denied microphone) (review B3).
+    const owed = v.turns > 0;
+    this.#store.upsertVoiceMode(id, { inCall: false, boundary: owed ? "exit" : null, ...(owed ? {} : { turns: 0 }) });
+    await this.#restoreThought(id);
+  }
+
+  /** Put the operator's thinking level back after a call. Clears the snapshot ONLY when the level
+   *  really went back — a slot that is no longer in memory (idle reap, restart) or a rejected value
+   *  keeps it, so the next resume can finish the job instead of silently staying on the call level
+   *  (review M2). */
+  async #restoreThought(id: string): Promise<boolean> {
+    const v = this.#store.getVoiceMode(id);
+    if (!v.thoughtBefore) return true; // nothing to put back
+    if (v.thoughtTouched) {
+      // The operator picked a level during the call: theirs wins, the snapshot is moot.
+      this.#store.upsertVoiceMode(id, { thoughtBefore: null, thoughtTouched: false });
+      return true;
+    }
     const s = this.#sessions.get(id);
-    // The operator's explicit pick wins: if they changed the dial DURING the call, do not undo it.
-    if (s && v.thoughtBefore && !v.thoughtTouched) {
-      const choice = thinkingOptionOf(s.info.configOptions);
-      if (choice) await this.setConfig(id, choice.id, v.thoughtBefore, { internal: true }).catch(() => { /* keep going */ });
+    if (!s) return false;
+    const choice = thinkingOptionOf(s.info.configOptions);
+    if (!choice || !choice.lowest) return false;
+    try {
+      await this.setConfig(id, choice.id, v.thoughtBefore, { internal: true });
+    } 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).
+    const now = thinkingOptionOf(s.info.configOptions);
+    if (now && now.current && now.current !== v.thoughtBefore) return false;
     this.#store.upsertVoiceMode(id, { thoughtBefore: null, thoughtTouched: false });
+    return true;
+  }
+
+  /** 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. */
-  #applyVoiceMode(s: LiveSession, blocks: unknown[]): void {
+   *  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 {
+    // 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).
+    if (!opts.operator) return () => { /* nothing owed to a synthetic turn */ };
     const live = this.#callLive();
     let v = this.#store.getVoiceMode(s.info.id);
     // Converge on the ONE authority (presence) in both directions: a page that closed mid-call never
     // reports a hang-up, so the exit boundary must be derived here or the model stays on a call for
     // ever; and a call that started while this slot was cold has no enter boundary recorded.
     if (v.inCall && live !== s.info.id) {
-      v = this.#store.upsertVoiceMode(s.info.id, { inCall: false, boundary: "exit" });
+      const owed = v.turns > 0;
+      v = this.#store.upsertVoiceMode(s.info.id, { inCall: false, boundary: owed ? "exit" : null, ...(owed ? {} : { turns: 0 }) });
+      // 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);
-    if (v.boundary) this.#store.upsertVoiceMode(s.info.id, { boundary: null });
-    if (v.inCall) this.#store.upsertVoiceMode(s.info.id, { turns: v.turns + 1 });
+    const seenBoundary = v.boundary;
+    const counted = v.inCall;
+    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 });
+    return (delivered: boolean) => {
+      if (!delivered) {
+        if (counted) {
+          const now = this.#store.getVoiceMode(s.info.id);
+          if (now.inCall && now.turns > 0) this.#store.upsertVoiceMode(s.info.id, { turns: now.turns - 1 });
+        }
+        return;
+      }
+      // Clear only the boundary this turn actually carried: a hang-up during the turn may have
+      // replaced it with an exit boundary the operator still needs to hear (review r2 A-M1).
+      if (seenBoundary) {
+        const cur = this.#store.getVoiceMode(s.info.id);
+        if (cur.boundary === seenBoundary) this.#store.upsertVoiceMode(s.info.id, { boundary: null });
+      }
+    };
   }
 
   /** Bind a freshly spawned agent to (this data dir, this session, this server run). Bookkeeping only:
@@ -978,7 +1074,8 @@ export class SessionManager {
         }
       }
       // 通话中 resume（页面刷新、空闲回收后再唤起）：把通话档位重新压下去，否则「恢复的会话」会带着
-      // 用户平时的高思考档沉默十几秒 —— 正是 issue #48 要消除的那种卡死手感。
+      // 用户平时的高思考档沉默十几秒 —— 正是 issue #48 要消除的那种卡死手感。反过来，通话已经结束却
+      // 留着快照（挂断时会话不在内存，还原没跑成）就要在这里补还原，否则会话永远停在通话档（review M2）。
       {
         const vm = this.#store.getVoiceMode(id);
         if (vm.inCall) {
@@ -986,6 +1083,8 @@ export class SessionManager {
           if (knob && knob.current !== knob.lowest) {
             await this.setConfig(id, knob.id, knob.lowest, { internal: true }).catch(() => { /* keep going */ });
           }
+        } else if (vm.thoughtBefore && !vm.thoughtTouched) {
+          await this.#restoreThought(id);
         }
       }
       live.info.status = "ready";
@@ -1228,8 +1327,9 @@ export class SessionManager {
     // 语音通话模式（issue #48）: entering, staying in, and leaving a call each owe the agent one
     // sentence it cannot infer — that its output is being SPOKEN, or that the speaking is over.
     // Rides the same `_meta`-tagged resource channel as the plan reminder; the operator's own words
-    // are untouched (the transcript stores `text`, never the blocks).
-    this.#applyVoiceMode(s, blocks);
+    // are untouched (the transcript stores `text`, never the blocks). A background wake (`origin`)
+    // is not a spoken turn and must not consume a boundary.
+    const settleVoice = this.#applyVoiceMode(s, blocks, { operator: voiceAppliesToPrompt(opts) });
     s.turnSeq += 1;
     s.busy = true;
     // The operator has spoken: from here anything the agent says is an ANSWER, not its own history
@@ -1267,6 +1367,9 @@ 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);
       this.#finalizePlan(sessionId, terminalState);
       this.#emit({ t: "turn-end", sessionId, stopReason: res?.stopReason, durationMs: Date.now() - turnStartedAt });
     } catch (err) {
@@ -1404,15 +1507,6 @@ export class SessionManager {
     const s = this.#need(sessionId);
     if (!s.conn || !s.info.acpSessionId) throw new Error("session not ready");
     const requested = String(value);
-    // 通话中操作者自己调了思考档位 → 以他为准，挂断时不再还原（issue #48）。`internal` marks the
-    // cockpit's own lowering/restoring, which must NOT count as the operator's choice.
-    if (!opts.internal) {
-      const vm = this.#store.getVoiceMode(sessionId);
-      if (vm.inCall) {
-        const knob = thinkingOptionOf(s.info.configOptions);
-        if (knob && knob.id === configId) this.#store.upsertVoiceMode(sessionId, { thoughtTouched: true });
-      }
-    }
     let actual = requested;
     let rejected = false;
     try {
@@ -1453,6 +1547,17 @@ export class SessionManager {
         this.#settleRow(s, cur.seq, payload);
       }
     }
+    // 通话中操作者自己调了思考档位 → 以他为准，挂断时不再还原（issue #48）。`internal` marks the
+    // cockpit's own lowering/restoring, which must NOT count as the operator's choice. Only a pick the
+    // AGENT actually accepted counts: a rejected value would otherwise make the hang-up skip the
+    // restore and strand the session on the call's level (review m4).
+    if (!opts.internal && !rejected && actual === requested) {
+      const vm = this.#store.getVoiceMode(sessionId);
+      if (vm.inCall) {
+        const knob = thinkingOptionOf(s.info.configOptions);
+        if (knob && knob.id === configId) this.#store.upsertVoiceMode(sessionId, { thoughtTouched: true });
+      }
+    }
     if (rejected) {
       this.#emit({
         t: "config-rejected",

package/packages/server/src/acp/voice-mode.ts

@@ -77,10 +77,16 @@ export function voiceModeBlock(sessionId: string, st: VoiceState): unknown | nul
   };
 }
 
-/** Is this a block we injected (as opposed to something the operator typed)? */
-export function isVoiceBlock(block: unknown): boolean {
-  const meta = (block as { _meta?: Record<string, unknown> } | null)?._meta;
-  return Boolean(meta && meta[VOICE_META_KEY] === true);
+/**
+ * Does this prompt get the call treatment at all?
+ *
+ * Only an OPERATOR prompt does. A background-completion wake rides the same `prompt()` with an
+ * `origin`, and it is a synthetic turn nobody reads: letting it carry the block burned the pending
+ * exit boundary into it (so the operator's next real message never learned the call had ended) and
+ * inflated the turn count that the exit block quotes.
+ */
+export function voiceAppliesToPrompt(opts: { origin?: unknown }): boolean {
+  return !opts.origin;
 }
 
 export interface ThinkingChoice {
@@ -98,6 +104,11 @@ export interface ThinkingChoice {
  * signals that survive across backends (Hermes, the mock, and the adapters we have seen) are the
  * semantic `category: "thought_level"` and an id/name containing think/reason/effort. If neither is
  * present the session simply has no such knob and call mode must not invent one.
+ *
+ * The LOWEST level must also be recognised. ACP puts no ordering on the value list, so falling back
+ * to `options[0]` is a coin flip that can pick "3 档" or `true` — i.e. a call could make the agent
+ * SLOWER, which is the exact failure mode call mode exists to remove (review M3). If no value looks
+ * cheapest, report no knob: worse to press an unknown dial than to leave it alone.
  */
 export function thinkingOptionOf(options: unknown): ThinkingChoice | null {
   if (!Array.isArray(options)) return null;
@@ -112,15 +123,23 @@ export function thinkingOptionOf(options: unknown): ThinkingChoice | null {
   const values = (Array.isArray(found.options) ? found.options : [])
     .map((o) => {
       const v = o as { value?: unknown; name?: unknown };
-      return { value: typeof v.value === "string" ? v.value : "", name: typeof v.name === "string" ? v.name : "" };
+      return {
+        value: typeof v.value === "string" ? v.value : typeof v.value === "number" ? String(v.value) : "",
+        name: typeof v.name === "string" ? v.name : "",
+      };
     })
     .filter((o) => o.value);
   if (values.length < 2) return null;
-  const lowest = values.find((v) => /^(off|none|disabled|min|minimal|low)$/i.test(v.value)
-    || /^(off|none|disabled|low|最低|关闭)$/i.test(v.name))?.value ?? values[0].value;
+  const lowValue = /^(off|none|disabled|min|minimal|low|lowest|quick|fast|1)$/i;
+  const lowName = /^(off|none|disabled|low|lowest|quick|fast|最低|低|关闭|关|快速|最快|1\s*档?)$/i;
+  const pick = values.find((v) => lowValue.test(v.value.trim()) || lowName.test(v.name.trim()));
+  if (!pick) return null;
+  const currentRaw = found.currentValue;
   return {
     id: found.id as string,
-    current: typeof found.currentValue === "string" ? found.currentValue : "",
-    lowest,
+    current: typeof currentRaw === "string"
+      ? currentRaw
+      : typeof currentRaw === "number" || typeof currentRaw === "boolean" ? String(currentRaw) : "",
+    lowest: pick.value,
   };
 }