agentus 0.6.1 → 0.7.0

package/README.md

@@ -56,7 +56,7 @@ option instead of being skipped in silence), **background-job completion wake-up
 background process comes back as a turn of its own), 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-20261019-2348`, on Hermes `v0.22.0`.
+`agentus/v0.22.0/merge-20261020-2337`, 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

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

package/docs/installation.md

@@ -39,7 +39,9 @@ mode that survives a restart** and `session/load`, a free-form **context budget*
 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`),
 **background-job completion wake-ups** (a finished `terminal(background=true)` job is relayed back as
-a turn of its own, so the agent resumes instead of the turn simply ending), **project skills the agent
+a turn of its own, so the agent resumes instead of the turn simply ending), and each row of the running
+snapshot now says whether that process is the kind that wakes the session (`notifyOnComplete`) — which
+is how the cockpit shows only the ones that mean 「not finished yet」 instead of a wall of noise, **project skills the agent
 can see, trust and edit** (the cockpit reports which project skills a repo has and which tier you
 trust, and writes the trust level back to config — it rides the same status channel; a released
 Hermes silently skips untrusted project skills without saying so), and a
@@ -58,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-20261019-2348`** — the newest tag on the fork,
+**Current integration build: `agentus/v0.22.0/merge-20261020-2337`** — 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

@@ -35,7 +35,8 @@ brew install node                 # 或者 https://nodejs.org/en/download
 （带 256K/512K/768K/1M 预设）、把记忆召回 / 存记忆提示送进驾驶舱消息流的 **status 通道**，以及
 **按进程指定的技能根**（`HERMES_EXTERNAL_SKILLS_DIRS` —— 驾驶舱靠它让槽位看见自己的 skill，
 不往你的 `~/.hermes` 写任何东西）、**后台任务完成唤醒**（`terminal(background=true)` 的进程跑完会被
-中继成一个新回合，agent 自己接着干，而不是回合就这么结束）、**项目 skill 的可见 / 可信任 / 可写**
+中继成一个新回合，agent 自己接着干，而不是回合就这么结束），快照里的每个进程还会带
+`notifyOnComplete` —— 驾驶舱据此只显示「会唤醒会话」的那些，而不是一屏噪音、**项目 skill 的可见 / 可信任 / 可写**
 （驾驶舱会告诉 agent 这个仓库有哪些项目 skill、你信任哪个层级，并能把信任层级写回配置 —— 信号走
 同一条 status 通道；裸装 Hermes 遇到没信任的项目 skill 是悄悄跳过、不吭声的），以及 **DeepSeek 的 web 后端**
 （`search` + `extract` 都复用
@@ -51,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-20261019-2348`** —— fork 上最新的那个 tag，基座 Hermes
+**当前集成构建：`agentus/v0.22.0/merge-20261020-2337`** —— fork 上最新的那个 tag，基座 Hermes
 `v0.22.0`。这行只为一眼看个大概，不是权威：下面的 `TAG=$(…)` 每次都会自己解析出最新，觉得这行过期就
 以它为准。
 

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "agentus",
- "version": "0.6.1",
+ "version": "0.7.0",
  "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

@@ -480,9 +480,13 @@ const agent = () => ({
         _meta: { hermes: { kind: "background", tasks: rows } },
         content: { type: "text", text: "" },
       });
+      // `notifyOnComplete: true` because this fixture IS the wake shape: it ends with a completion
+      // carrier, i.e. the agent is waiting for that result (issue #35). The cockpit filters silent
+      // processes out by default, so a fixture without the flag would render no row at all — and the
+      // wake sweeps would fail for the right reason but the wrong cause.
       const running = [{
         id: taskId, command: "npm run build --workspace packages/web", pid: 4242,
-        status: "running", uptimeSeconds: 12,
+        status: "running", uptimeSeconds: 12, notifyOnComplete: true,
       }];
       void send(agent._conn, sessionId, snapshot(running)).catch(() => undefined);
       setTimeout(() => {
@@ -503,6 +507,20 @@ const agent = () => ({
       }, runMs + 1200);
     }
 
+    // `[bgquiet]` — a SILENT background process: running, no notify, no completion carrier. This is
+    // what the agent's own polling looks like, and the cockpit hides it by default (issue #35).
+    if (/\[bgquiet\]/.test(text)) {
+      const quietId = `bgq-${sessionId}-1`;
+      void send(agent._conn, sessionId, {
+        sessionUpdate: "agent_thought_chunk",
+        _meta: { hermes: { kind: "background", tasks: [{
+          id: quietId, command: "tail -f /tmp/agentus-qa.log", pid: 4343,
+          status: "running", uptimeSeconds: 5, notifyOnComplete: false,
+        }] } },
+        content: { type: "text", text: "" },
+      }).catch(() => undefined);
+    }
+
     // `[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

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

@@ -47,7 +47,7 @@ import type {
 } from "../../../shared/src/index.js";
 import { acceptsToolWrite, acceptsWriteFrom, clampExplanation, clampTitle, demoteInProgress, foldPlanUpdate, hasUnfinished, normalizeItems, v2PlanEnabled } from "../plan/plan.js";
 import { PLAN_GUIDANCE_ACTIVE, PLAN_GUIDANCE_INTRO, PLAN_GUIDANCE_NATIVE } from "../../../shared/src/index.js";
-import { PREFS_DEFAULT, type PlanHintSettings } from "../settings.js";
+import { PREFS_DEFAULT, agentSettings, type PlanHintSettings } from "../settings.js";
 
 // The cockpit CLI an agent is handed (issue #15). Resolved from THIS module's location, so it points
 // at the same tree the server runs from — a checkout and an installed package alike (`bin/` is in the
@@ -1828,7 +1828,10 @@ export class SessionManager {
    *  reasons, e.g. a title change) then wiped a row the page had just drawn from a `background` frame.
    *  An explicit `[]` is the same discipline the three rail buckets use. */
   backgroundSnapshots(): { sessionId: string; tasks: BackgroundTask[] }[] {
-    return [...this.#sessions.values()].map((s) => ({ sessionId: s.info.id, tasks: s.background }));
+    return [...this.#sessions.values()].map((s) => ({
+      sessionId: s.info.id,
+      tasks: visibleBackgroundTasks(s.background),
+    }));
   }
 
   #emitSessions(): void {
@@ -1933,7 +1936,7 @@ export class SessionManager {
     const bgTasks = backgroundTasksOf(u);
     if (bgTasks) {
       live.background = bgTasks;
-      this.#emit({ t: "background", sessionId: live.info.id, tasks: bgTasks });
+      this.#emit({ t: "background", sessionId: live.info.id, tasks: visibleBackgroundTasks(bgTasks) });
       return;
     }
     const finishedText = completionTextOf(u);
@@ -2698,7 +2701,7 @@ function completionTextOf(u: Record<string, unknown>): string | null {
 
 /** The agent's running-process snapshot (#22). Dropped (not defaulted) when `tasks` is not an array:
  *  a malformed frame must never blank a row the operator is reading. */
-function backgroundTasksOf(u: Record<string, unknown>): BackgroundTask[] | null {
+export function backgroundTasksOf(u: Record<string, unknown>): BackgroundTask[] | null {
   if (hermesKindOf(u) !== "background") return null;
   const raw = hermesPayload(u).tasks;
   if (!Array.isArray(raw)) return null;
@@ -2716,11 +2719,28 @@ function backgroundTasksOf(u: Record<string, unknown>): BackgroundTask[] | null
       status,
       uptimeSeconds: typeof r.uptimeSeconds === "number" ? r.uptimeSeconds : undefined,
       exitCode: typeof r.exitCode === "number" ? r.exitCode : null,
+      // Explicit boolean, never `undefined` by omission (#35): the page filters on this, and an
+      // old agent that does not send it must land on `false` (silent) rather than a third state
+      // nobody renders.
+      notifyOnComplete: r.notifyOnComplete === true,
     });
   }
   return out;
 }
 
+/** 默认降噪 (#35): 只留下「完成后会唤醒 agent」的进程。静默进程是 agent 自己轮询的活,
+ *  操作者不需要看见 —— 而唤醒型才是「这个会话还没收工」的强信号。开关打开才回到全量,
+ *  保留 fork 原本「快照是这个进程存在过的唯一见证」的设计价值, 但决定权交给操作者。
+ *
+ *  WHY THIS IS A SEPARATE STEP FROM PARSING (measured while running the reap/background sweep):
+ *  `live.background` feeds more than rendering — the idle reaper treats a running child as
+ *  「not idle」 and refuses to SIGTERM the agent that owns it. Filtering at parse time made every
+ *  silent process invisible to the reaper too, i.e. a slot could be reaped while it still had a
+ *  live child (the exact orphan #22 removed). So: store everything, hide at the wire. */
+export function visibleBackgroundTasks(tasks: BackgroundTask[]): BackgroundTask[] {
+  return agentSettings().showSilentBackground ? tasks : tasks.filter((t) => t.notifyOnComplete === true);
+}
+
 function statusKindOf(u: Record<string, unknown>): string | undefined {
   const meta = u?._meta as { hermes?: { statusKind?: unknown } } | undefined;
   const kind = meta?.hermes?.statusKind;

package/packages/server/src/dashscope.ts

@@ -15,7 +15,7 @@
 // The base URL is the operator's — every Bailian workspace id is different, and the
 // whole point is that this is NOT the coding-plan endpoint. No URLs or keys are baked in.
 import WebSocket from "ws";
-import { getSettings, dashscopeUrls } from "./settings.js";
+import { getSettings, dashscopeUrls, SUMMARY_MODEL_DEFAULT } from "./settings.js";
 
 export class DashscopeError extends Error {
   constructor(message: string, readonly code: "not_configured" | "upstream" | "timeout" | "bad_audio") {
@@ -241,8 +241,10 @@ export function openDashscopeStream(opts: {
  * the operator's existing voice endpoint and key are enough — there is no second model to
  * configure and no agent, no session and no history involved.
  *
- * The input is capped at `maxChars × 20` characters (30k ≈ 15k tokens is already the ceiling for a
- * 30-second listen): a 200 KB pasted log must not turn a long press into a bill.
+ * The input is NOT truncated any more (#36). It used to be capped at `maxChars × 20` characters,
+ * which punished exactly the case this feature exists for — a long agent reply — while the case
+ * the cap protected against (a pasted 200 KB log) is rare and is now refused outright by the
+ * caller with a visible 409. Half a summary that looks finished is worse than an error.
  */
 export async function summarizeForSpeech(opts: {
   text: string;
@@ -251,18 +253,20 @@ export async function summarizeForSpeech(opts: {
   model: string;
   timeoutSec: number;
   /** Where to send it. Absent = the voice endpoint (settings → 语音), which is the old, always-on
-   *  route. Present = the SESSION's own provider (see speech/route.ts) — the operator asked for the
-   *  summary to be billed to whatever model he is actually talking to, not to a second vendor. */
+   *  route. Present = the SESSION's own provider (see speech/route.ts) — the operator asked for
+   *  the summary to be billed to whatever model he is actually talking to, not to a second vendor. */
   endpoint?: { baseUrl: string; apiKey: string };
-}): Promise<{ text: string; truncated: boolean; ms: number }> {
+  /** qwen3-family only: `enable_thinking: true` + `thinking_budget: N`. The operator's rule is
+   *  「开着思考，但只给一点点」 — a capped think reads the message better than a non-reasoning
+   *  model, without the 235-token wander measured on the default budget (4000). Sending this to
+   *  a non-qwen3 model would be a lie, so the caller decides and we just transmit. */
+  thinkingBudget?: number;
+}): Promise<{ text: string; ms: number }> {
   const { key, compat } = opts.endpoint
     ? { key: opts.endpoint.apiKey, compat: opts.endpoint.baseUrl.replace(/\/+$/, "") }
     : creds();
   const v = getSettings().voice;
-  const limit = Math.max(400, opts.maxChars * 20);
-  const body = opts.text.trim();
-  const truncated = body.length > limit;
-  const input = truncated ? `${body.slice(0, limit)}\n…（后面还有 ${body.length - limit} 字没发）` : body;
+  const input = opts.text.trim();
   const ac = new AbortController();
   const timer = setTimeout(() => ac.abort(), Math.max(5, opts.timeoutSec) * 1000);
   const started = Date.now();
@@ -271,18 +275,25 @@ export async function summarizeForSpeech(opts: {
       method: "POST",
       headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
       body: JSON.stringify({
-        model: opts.model || (opts.endpoint ? "" : "qwen-flash"),
+        model: opts.model || (opts.endpoint ? "" : SUMMARY_MODEL_DEFAULT),
         messages: [
           { role: "system", content: opts.prompt.replace(/\{maxChars\}/g, String(opts.maxChars)) },
           { role: "user", content: input },
         ],
         // No temperature knob: this surface is not a playground, and the default has produced
-        // the steadiest length compliance. `max_tokens` guards against a chatty model — and it
-        // must leave room for REASONING tokens, which count against the same budget: measured on
-        // deepseek-v4-flash, a 480-token cap was spent entirely on reasoning_content and the
-        // visible answer came back empty with finish_reason=length. 1200 is the floor that makes a
-        // reasoning model answer; for a plain one it is only a ceiling nobody reaches.
-        max_tokens: Math.max(1200, opts.maxChars * 6),
+        // the steadiest length compliance. `max_completion_tokens` (NOT `max_tokens`): it bounds
+        // thinking and answer TOGETHER and has no 32768 ceiling, so a capped-think call cannot
+        // come back empty with finish_reason=length. Measured on deepseek-v4-flash, a 480-token
+        // cap was spent entirely on reasoning_content and the visible answer was empty; 1200 is
+        // the floor that makes a reasoning model answer, and for a plain one it is only a ceiling
+        // nobody reaches. The think budget is added on top so capping the think never eats the
+        // answer.
+        max_completion_tokens: Math.max(1200, opts.maxChars * 6) + (opts.thinkingBudget ?? 0),
+        // qwen3 family (#36): thinking ON, budget 200. `thinking_budget` and `reasoning_effort`
+        // must never travel together (the vendor rejects the pair), so this is the only knob.
+        ...(opts.thinkingBudget
+          ? { enable_thinking: true, thinking_budget: opts.thinkingBudget }
+          : {}),
       }),
       signal: ac.signal,
     });
@@ -305,7 +316,7 @@ export async function summarizeForSpeech(opts: {
       throw new DashscopeError(why, "upstream");
     }
     void v;
-    return { text: out, truncated, ms: Date.now() - started };
+    return { text: out, ms: Date.now() - started };
   } catch (e) {
     if ((e as Error).name === "AbortError") {
       throw new DashscopeError(`summary timed out after ${opts.timeoutSec}s`, "timeout");

package/packages/server/src/index.ts

@@ -23,6 +23,7 @@ import { dictationContext, hotwordsFor, vocabularyOf } from "./hotwords.js";
 import { openDashscopeStream, summarizeForSpeech } from "./dashscope.js";
 import {
   SUMMARY_CHARS_RANGE, SUMMARY_MODEL_DEFAULT, SUMMARY_PROMPT_DEFAULT,
+  SUMMARY_MAX_INPUT_CHARS, SUMMARY_THINKING_BUDGET,
   agentSettings, getSettings, initSettings, observerSettings, planHintSettings, publicSettings,
   saveAgent, saveCall, saveObserver, savePrefs, saveSettings, saveSummary, saveTheme, summarySettings,
 } from "./settings.js";
@@ -1592,12 +1593,19 @@ async function post(path){const r=await fetch(path,{method:'POST'});alert(r.ok?'
           const row = store.getSession(id);
           if (!row) return { route: null, why: "会话不在库里" };
           const be = store.listBackends().find((b) => b.id === row.backend);
-          const models = (row.models ?? {}) as { currentModelId?: string | null };
+          // LIVE first, store second (#36). The ACP handshake reports the model, and the live
+          // session object holds it — but `sessions.models` is flushed later (observed: JSON null
+          // for every row on this box), so reading the store alone answered 「agent 未握手」 and
+          // every summary silently fell back to the voice endpoint's qwen-flash.
+          const live = mgr.list().find((s) => s.id === id);
+          const modelId = live?.models?.currentModelId
+            ?? ((row.models ?? {}) as { currentModelId?: string | null }).currentModelId
+            ?? null;
           // The provider keys live in this box's agent home, which is a property of the runtime —
           // not of the vendor that happens to be driving this session. A backend that owns no home
           // (mock, qoder) therefore still resolves a `deepseek:…` model through the Hermes home.
           const home = (be ? planFor(be).home : null) ?? HERMES_DEFAULT_HOME;
-          return routeForModel(models.currentModelId ?? null, home);
+          return routeForModel(modelId, home);
         };
         // 语音总结 (the message speaker's long press): ONE stored message, made listenable.
         //
@@ -1627,6 +1635,18 @@ async function post(path){const r=await fetch(path,{method:'POST'});alert(r.ok?'
         if (spoken.length <= maxChars) {
           return send(res, 200, { ok: true, via: "verbatim", text: spoken, chars: spoken.length, ms: 0, maxChars });
         }
+        // Over the ceiling we REFUSE, loudly (#36). The old behaviour summarised the head and said
+        // so in a footnote — but a summary that drops the second half is worse than none, because
+        // that is where the conclusion lives. 20k chars is far above any reply worth listening to
+        // and still stops a pasted 200 KB log from becoming an invoice.
+        if (spoken.length > SUMMARY_MAX_INPUT_CHARS) {
+          return send(res, 409, {
+            error: `这条消息 ${spoken.length} 字，超出语音总结上限 ${SUMMARY_MAX_INPUT_CHARS} 字 —— 直接朗读，或截取要听的那段`,
+            code: "too_long",
+            chars: spoken.length,
+            limit: SUMMARY_MAX_INPUT_CHARS,
+          });
+        }
         try {
           // The operator's rule: bill this to the model he is already talking to. The voice
           // endpoint stays as the fallback (and is the whole route when followSession is off).
@@ -1638,6 +1658,10 @@ async function post(path){const r=await fetch(path,{method:'POST'});alert(r.ok?'
             prompt: cfg.prompt.trim() || SUMMARY_PROMPT_DEFAULT,
             model,
             timeoutSec: cfg.timeoutSec,
+            // Thinking stays ON for qwen3 models, capped at 200 tokens (operator's call, #36):
+            // a little reasoning reads the sentence better than none, and 200 keeps it from
+            // wandering the way the default 4000 did (measured 235 output tokens on a 40-char ask).
+            thinkingBudget: /^qwen3/i.test(model) ? SUMMARY_THINKING_BUDGET : undefined,
             endpoint: own.route ? { baseUrl: own.route.baseUrl, apiKey: own.route.apiKey } : undefined,
           });
           // Newlines are the one thing the model keeps ignoring: 「不要换行」 in the prompt is a
@@ -1649,7 +1673,7 @@ async function post(path){const r=await fetch(path,{method:'POST'});alert(r.ok?'
             // echo the bucket: the note prints 「约 150 字」 and a summary that silently used the
             // configured number would make the menu look broken
             maxChars,
-            ms: r.ms, truncated: r.truncated, model,
+            ms: r.ms, model,
             // which account this call was billed to — the note prints it, and a fallback that
             // silently used the OTHER provider would be a lie about the cost
             route: own.route ? "session" : "voice",

package/packages/server/src/settings.ts

@@ -189,10 +189,16 @@ export interface AgentSettings {
    *  this is what the CLI and the gateway already do, and the failure it prevents is the silent one —
    *  a session that looks finished while a build is still running, whose result nobody ever reads. */
   completionWake: boolean;
+  /** 显示不唤醒的后台进程 (issue #35). OFF by default: the row and the rail badge answer
+   *  「这个会话还在干活吗」, and a silent process the agent is polling itself is noise — the
+   *  agent knows it is there, the operator does not need to. Turned ON, every running process
+   *  shows, which is what the fork's original "a snapshot is the only witness" design wanted. */
+  showSilentBackground: boolean;
 }
 
 export const AGENT_DEFAULT: AgentSettings = {
   idleKillMin: 5, warmSlots: 5, warmTtlHours: 24, cockpitSend: false, completionWake: true,
+  showSilentBackground: false,
 };
 
 /** The numeric half of `AgentSettings` — the keys the range-checked helpers may write. */
@@ -298,8 +304,26 @@ export const SUMMARY_CHARS_RANGE: [number, number] = [40, 400];
 export const SUMMARY_TIMEOUT_RANGE: [number, number] = [5, 60];
 /** Measured against this operator's workspace, 2026-10-18: `qwen-flash` answered a 40-character
  *  ask with 67 prompt / 20 completion tokens. `qwen3-flash` and `qwen-turbo` are 404 there ("Model
- *  not exist"), and `qwen3.8-flash` spent 235 output tokens thinking about the same sentence. */
-export const SUMMARY_MODEL_DEFAULT = "qwen-flash";
+ *  not exist"), and `qwen3.8-flash` spent 235 output tokens thinking about the same sentence.
+ *
+ *  2026-10-20 (operator's call): the fallback IS `qwen3.8-flash` anyway — it is the model this
+ *  workspace already talks to, and `qwen-flash` was a second vendor's answer to a problem that has
+ *  a proper knob. The 235-token overspend is what `SUMMARY_THINKING_BUDGET` below exists for:
+ *  thinking stays ON (it reads the message better) but is capped at 200 tokens. */
+export const SUMMARY_MODEL_DEFAULT = "qwen3.8-flash";
+
+/** Thinking cap for qwen3-family models, in tokens (`thinking_budget`). 200 is deliberate: enough
+ *  to hold the sentence together, too small to wander — measured 235 → 200 keeps the visible
+ *  answer intact at a fifth of the default 4000. NOT used for non-qwen3 models (DeepSeek ignores
+ *  the field, and sending it there would be a lie about what we asked for). */
+export const SUMMARY_THINKING_BUDGET = 200;
+
+/** The most characters this feature will ever hand a model. Above it the call is REFUSED with a
+ *  visible 409 instead of quietly summarising the head (#36) — a summary that silently drops the
+ *  second half is worse than no summary, because the conclusion usually lives there. 20k ≈ 10k
+ *  tokens: longer than any agent reply worth listening to, short enough that a pasted 200 KB log
+ *  cannot turn one long press into a bill. */
+export const SUMMARY_MAX_INPUT_CHARS = 20_000;
 
 export const SUMMARY_PROMPT_DEFAULT = [
   "下面是我在一个工作会话里拿到的一段输出。请把它改写成一段「用嘴念出来」的摘要：",
@@ -492,6 +516,7 @@ function pickAgent(raw: unknown): AgentSettings {
     take("warmTtlHours", AGENT_WARM_TTL_RANGE);
     if (typeof r.cockpitSend === "boolean") out.cockpitSend = r.cockpitSend;
     if (typeof r.completionWake === "boolean") out.completionWake = r.completionWake;
+    if (typeof r.showSilentBackground === "boolean") out.showSilentBackground = r.showSilentBackground;
   }
   return out;
 }
@@ -807,6 +832,10 @@ export function saveAgent(patch: Record<string, unknown>): Settings {
     if (typeof patch.completionWake !== "boolean") throw new Error("invalid completionWake: expected true or false");
     a.completionWake = patch.completionWake;
   }
+  if ("showSilentBackground" in patch) {
+    if (typeof patch.showSilentBackground !== "boolean") throw new Error("invalid showSilentBackground: expected true or false");
+    a.showSilentBackground = patch.showSilentBackground;
+  }
   cache = { ...cache, agent: a, updatedAt: Date.now() };
   persist();
   return cache;

package/packages/server/src/speech/route.ts

@@ -56,8 +56,10 @@ const BUILTIN: Record<string, { baseUrl: string; keys: string[]; baseEnv?: strin
 
 /**
  * ACP model ids arrive as `deepseek:deepseek-v4-flash` (provider prefix, wire form) or
- * `openrouter:anthropic/claude-x`; older agents use `provider/model`. Returns "" for a bare id
- * with no prefix — the caller then has to ask config.yaml who owns it.
+ * `openrouter:anthropic/claude-x`. Returns "" for a bare id with no prefix — the caller then has to
+ * ask config.yaml who owns it. The `provider/model` form is NOT handled here (a prefix here can be
+ * a vendor namespace rather than a provider); `slashProvider()` below resolves it with the provider
+ * tables in hand (#36).
  */
 export function splitModelId(raw: string | null | undefined): { provider: string; model: string } {
   const id = String(raw ?? "").trim();
@@ -91,6 +93,21 @@ function readConfig(home: string | null): Record<string, unknown> {
 const asString = (v: unknown): string => (typeof v === "string" ? v.trim() : typeof v === "number" ? String(v) : "");
 const trimSlash = (u: string): string => u.replace(/\/+$/, "");
 
+/**
+ * `provider/model` — the second id form a session can report. Only stripped when the prefix really
+ * names a provider this box knows (declared in config.yaml or in the builtin table): a catalogue
+ * slug like `anthropic/claude-x` must survive intact, or an OpenRouter model id would be mangled
+ * into provider `anthropic` + model `claude-x`.
+ */
+function slashProvider(cfgProviders: Record<string, unknown>, model: string): { provider: string; model: string } {
+  const slash = model.indexOf("/");
+  if (slash <= 0) return { provider: "", model };
+  const cand = model.slice(0, slash).trim().toLowerCase();
+  if (!(cand in BUILTIN) && !(cand in cfgProviders)) return { provider: "", model };
+  const rest = model.slice(slash + 1).trim();
+  return rest ? { provider: cand, model: rest } : { provider: "", model };
+}
+
 /**
  * Resolve the route for one session's model. `home` is the home of the backend that session runs
  * on (`planFor(row).home`) — reading a DIFFERENT agent's config would hand this call a key its
@@ -101,10 +118,19 @@ export function routeForModel(modelId: string | null | undefined, home: string |
   why: string;
 } {
   const parsed = splitModelId(modelId);
-  const model = parsed.model;
-  if (!model) return { route: null, why: "会话还没报出模型（agent 未握手）" };
+  if (!parsed.model) return { route: null, why: "会话还没报出模型（agent 未握手）" };
 
   const cfg = readConfig(home);
+  // Slash form is a LAST resort after the colon form (#36): `deepseek/deepseek-v4-flash` is what
+  // this session reports, and before this the split returned no provider at all, so the summary
+  // silently fell back to the voice endpoint on `qwen-flash`.
+  const slash = parsed.provider
+    ? { provider: parsed.provider, model: parsed.model }
+    : slashProvider(
+        (cfg.providers && typeof cfg.providers === "object" ? cfg.providers : {}) as Record<string, unknown>,
+        parsed.model,
+      );
+  const model = slash.model;
   // An alias row may rename the model as well as point at a provider (`lab-qwen38-27b` →
   // `qwen38-27b`); the wire id is not the name the vendor knows.
   const aliasRow = (aliases: Record<string, unknown>): Record<string, unknown> | null => {
@@ -121,7 +147,7 @@ export function routeForModel(modelId: string | null | undefined, home: string |
   // Who owns this model? The id's own prefix wins; otherwise config.yaml's default provider, and
   // only when the model really is that default (a session can be running a model the default no
   // longer names — then guessing the provider would send the request to the wrong vendor).
-  let provider = parsed.provider;
+  let provider = slash.provider;
   if (!provider) {
     if (aliasNow) provider = asString(aliasNow.provider).toLowerCase();
   }

package/packages/shared/src/index.ts

@@ -263,6 +263,11 @@ export interface BackgroundTask {
   status: "running" | "exited";
   uptimeSeconds?: number;
   exitCode?: number | null;
+  /** Does this process OWE the session a wake-up (`notify_on_complete`)? Issue #35: that is the
+   *  difference between 「agent 已经收工」 and 「agent 还在等这次唤醒才能继续」. Optional — an
+   *  older agent never sends it, and `undefined` must read as "silent", never as "unknown so
+   *  show it anyway". */
+  notifyOnComplete?: boolean;
 }
 
 export interface WebNotice {