agentus 0.6.0 → 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,12 @@ 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), and a
+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
 **DeepSeek web backend** (`search` + `extract` on top of `DEEPSEEK_API_KEY` — DeepSeek has no separate
 search key).
 They live on the ACP branches of the fork
@@ -55,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,10 @@ brew install node                 # 或者 https://nodejs.org/en/download
 （带 256K/512K/768K/1M 预设）、把记忆召回 / 存记忆提示送进驾驶舱消息流的 **status 通道**，以及
 **按进程指定的技能根**（`HERMES_EXTERNAL_SKILLS_DIRS` —— 驾驶舱靠它让槽位看见自己的 skill，
 不往你的 `~/.hermes` 写任何东西）、**后台任务完成唤醒**（`terminal(background=true)` 的进程跑完会被
-中继成一个新回合，agent 自己接着干，而不是回合就这么结束），以及 **DeepSeek 的 web 后端**
+中继成一个新回合，agent 自己接着干，而不是回合就这么结束），快照里的每个进程还会带
+`notifyOnComplete` —— 驾驶舱据此只显示「会唤醒会话」的那些，而不是一屏噪音、**项目 skill 的可见 / 可信任 / 可写**
+（驾驶舱会告诉 agent 这个仓库有哪些项目 skill、你信任哪个层级，并能把信任层级写回配置 —— 信号走
+同一条 status 通道；裸装 Hermes 遇到没信任的项目 skill 是悄悄跳过、不吭声的），以及 **DeepSeek 的 web 后端**
 （`search` + `extract` 都复用
 `DEEPSEEK_API_KEY` —— DeepSeek 没有单独的搜索密钥）。它们在 fork
 [`LiangYang666/hermes-agent`](https://github.com/LiangYang666/hermes-agent) 的 ACP 分支上，
@@ -49,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.0",
+ "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": {
@@ -59,6 +59,7 @@
   "terminal-palette": "tsx scripts/qa/terminal-palette.mts",
   "android-trust-merge": "node scripts/qa/android-trust-merge.mjs",
   "cards-persist": "node scripts/qa/cards-persist.mjs",
+  "cold-paging": "tsx scripts/qa/cold-paging.mts",
   "plan-hint-sweep": "node scripts/qa/plan-hint-sweep.mjs",
   "plan-service-sweep": "node scripts/qa/plan-service-sweep.mjs",
   "plan-mcp-sweep": "node scripts/qa/plan-mcp-sweep.mjs",

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/cold-page.ts

@@ -0,0 +1,82 @@
+/** Paging for the COLD session list — the rows that exist on disk with no process behind them.
+ *
+ *  Issue #34: the page used to be ONE global top-N by `lastAt`. Every consumer (rail grouping, the
+ *  rail's 展开其余 counter, search, `cockpit session list --workspace`) then treated that page as the
+ *  complete set, so the busiest workspace ate the whole page and every other workspace's cold
+ *  sessions vanished. It is not a cosmetic loss: a cold row is the ONLY handle that can wake that
+ *  session, so "not in the page" means "unreachable from the UI, even though the transcript is fine".
+ *
+ *  The intent behind the old cap is still real — crash debris accumulates without anyone choosing it
+ *  — so it is kept, but moved to the right axis: **N per workspace** (the same axis the rail already
+ *  groups by) plus a much larger total ceiling as the anti-bloat backstop.
+ *
+ *  Pure on purpose: the caller decides which rows EXIST (the cockpit's own scope rule), this decides
+ *  which of them survive the page. That way the rule is tested without a server or a browser. */
+
+import type { SessionInfo } from "@agentus/shared";
+
+/** How many cold rows a single workspace keeps by default. The rail shows `RAIL_RECENT` (5) before
+ *  「展开其余」, so 20 is the expand depth, not the visible depth. */
+export const COLD_PER_WORKSPACE = 20;
+
+/** Hard ceiling across all workspaces. Chosen to be far above any real installation's workspace
+ *  count × 20 while still bounding what a crash-storm can push into one WS frame. */
+export const COLD_TOTAL_MAX = 400;
+
+/** The cockpit CLI asks for a deeper page than the rail: an agent asking "what is going on in this
+ *  workspace" is not browsing, and it filters by `--workspace` on top. */
+export const COLD_PER_WORKSPACE_COCKPIT = 50;
+
+export interface ColdPage<T> {
+  /** Newest-first, at most `perWorkspace` per workspace and `totalMax` overall. */
+  rows: T[];
+  /** How many cold rows existed before paging — so a caller can tell an empty cockpit from a
+   *  truncated one. */
+  total: number;
+  /** `total - rows.length`: the rows this page left out. Non-zero means "this is a partial view". */
+  omitted: number;
+}
+
+/** Which bucket a cold row belongs to: the workspace the operator sees in the rail, falling back to
+ *  the cwd exactly like `sessionRow()` does — the two must not disagree, or a row would be paged by
+ *  one key and displayed under another. */
+export function coldKeyOf(row: Pick<SessionInfo, "workspace" | "cwd">): string {
+  return row.workspace || row.cwd || "/";
+}
+
+/** Sort rule shared with `list()`: recent activity first, ties broken by creation. */
+export function byActivity(a: Pick<SessionInfo, "lastAt" | "createdAt">, b: Pick<SessionInfo, "lastAt" | "createdAt">): number {
+  return (b.lastAt ?? 0) - (a.lastAt ?? 0) || b.createdAt - a.createdAt;
+}
+
+/**
+ * Bucket-aware cold paging.
+ *
+ * `sorted` must already be in the caller's display order (newest first). Each workspace keeps the
+ * first `perWorkspace` rows of that order; the survivors are merged and re-sorted so the overall list
+ * still reads newest-first, then cut at `totalMax` only if the merge exceeds it.
+ */
+export function coldPage<T extends Pick<SessionInfo, "workspace" | "cwd" | "lastAt" | "createdAt">>(
+  sorted: readonly T[],
+  perWorkspace: number = COLD_PER_WORKSPACE,
+  totalMax: number = COLD_TOTAL_MAX,
+): ColdPage<T> {
+  const total = sorted.length;
+  const per = Math.max(1, Math.floor(perWorkspace));
+  const cap = Math.max(per, Math.floor(totalMax));
+
+  const buckets = new Map<string, T[]>();
+  for (const row of sorted) {
+    const key = coldKeyOf(row);
+    const bucket = buckets.get(key);
+    if (!bucket) buckets.set(key, [row]);
+    else if (bucket.length < per) bucket.push(row);
+    // else: this workspace already has its page — the rest of its rows are the ones we omit
+  }
+
+  const kept: T[] = [];
+  for (const bucket of buckets.values()) kept.push(...bucket);
+  kept.sort(byActivity);
+  const rows = kept.length > cap ? kept.slice(0, cap) : kept;
+  return { rows, total, omitted: total - rows.length };
+}

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

@@ -14,6 +14,14 @@ import type {
   RequestPermissionResponse,
 } from "@agentclientprotocol/sdk";
 import { BACKENDS, buildSpawnEnv, nativePlanSourceOf, type BackendSpec } from "./backends.js";
+import {
+  byActivity,
+  coldPage as pageCold,
+  COLD_PER_WORKSPACE,
+  COLD_PER_WORKSPACE_COCKPIT,
+  COLD_TOTAL_MAX,
+  type ColdPage,
+} from "./cold-page.js";
 import { SKILLS_ROOT, installSkills, resolveSkillsDir } from "../skills/install.js";
 import { classifyError, checkedHealth, effectiveArgs, handshakeFrom, rowToSpec } from "./registry.js";
 import type { BackendHandshake, CheckErrorCode } from "./registry.js";
@@ -39,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
@@ -945,17 +953,26 @@ export class SessionManager {
    *  reachable in the rail (the old rule showed them under 已归档; the older one dropped them out of
    *  the list entirely, which is how a transcript became unreachable while still on disk).
    *
-   *  Capped, unlike `archived()`: crash debris accumulates without anyone choosing it, and the rail
-   *  has its own recent-N rule anyway. */
-  cold(limit = 20): SessionInfo[] {
-    return this.#store
+   *  Paged **per workspace** (#34), unlike `archived()` which is complete: crash debris accumulates
+   *  without anyone choosing it, so a cap is still right — but the axis has to be the one the rail
+   *  groups by. A global top-N let the busiest workspace eat the page, and since a cold row is the
+   *  only handle that can wake its session, everything it pushed out became unreachable from the UI
+   *  while the transcript sat fine on disk. See `cold-page.ts`. */
+  cold(perWorkspace = COLD_PER_WORKSPACE, totalMax = COLD_TOTAL_MAX): SessionInfo[] {
+    return this.coldPage(perWorkspace, totalMax).rows;
+  }
+
+  /** The same page plus `total`/`omitted`, so a caller can say "this is a partial view" instead of
+   *  presenting a truncated list as the whole cockpit. */
+  coldPage(perWorkspace = COLD_PER_WORKSPACE, totalMax = COLD_TOTAL_MAX): ColdPage<SessionInfo> {
+    const sorted = this.#store
       .listSessions(true)
       // system rows are the cockpit's own (see list()): never offered as a slot to wake
       .filter((r) => r.archivedAt == null && !r.system && !this.#sessions.has(r.id))
       .map((r) => this.#infoFromRow(r))
       // cold rows by the same rule as live ones (recent chat first), THEN take the page
-      .sort((a, b) => (b.lastAt ?? 0) - (a.lastAt ?? 0) || b.createdAt - a.createdAt)
-      .slice(0, limit);
+      .sort(byActivity);
+    return pageCold(sorted, perWorkspace, totalMax);
   }
 
   /** One row in the shape list()/cold()/archived() produce, from a stored row. */
@@ -1811,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 {
@@ -1916,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);
@@ -2233,10 +2253,17 @@ export class SessionManager {
   /** The cockpit CLI's read view (issue #15): the sessions the OPERATOR can see, in one list —
    *  live and cold, never 已归档 (that is the operator's shelf, not work in flight).
    *
-   *  Cold rows are capped by `cold()`'s own page size on purpose: an agent asking "what is going on"
-   *  gets the recent cockpit, not a scrollback of every session this install ever made. */
+   *  Cold rows are paged per workspace by `cold()`, deeper than the rail's own expand depth: an agent
+   *  asking "what is going on" is not browsing, and it filters by `--workspace` on top — but it still
+   *  must not receive a scrollback of every session this install ever made. */
   cockpitRows(): SessionInfo[] {
-    return [...this.list(), ...this.cold(50)];
+    return [...this.list(), ...this.cold(COLD_PER_WORKSPACE_COCKPIT)];
+  }
+
+  /** The cockpit's cold page together with what it left out, so `session list` can report
+   *  `capped` honestly instead of presenting a truncated view as the whole cockpit (#34). */
+  cockpitCold(): ColdPage<SessionInfo> {
+    return this.coldPage(COLD_PER_WORKSPACE_COCKPIT);
   }
 
   /** Approvals a session is WAITING on right now — the one fact worth waking another agent for. */
@@ -2674,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;
@@ -2692,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/cockpit/api.ts

@@ -195,6 +195,10 @@ export interface ListQuery {
   /** bucket the page instead of returning it flat. `workspace` is the only dimension today because it
    *  is the one the operator's rail groups by — anything else would be an invented taxonomy. */
   by?: "workspace";
+  /** How many cold rows the caller's own page left out (issue #34). Set by the route from
+   *  `cockpitCold()`: absent/0 means "you are looking at everything", non-zero means the view is
+   *  partial and the answer must say so. Never a wire parameter. */
+  coldOmitted?: number;
   /** fixed clock for tests; never set by a caller over the wire */
   now?: number;
 }
@@ -207,7 +211,12 @@ export interface ListResult {
   meta: {
     total: number;
     returned: number;
+    /** TRUE means "this is not the whole answer" — either the list limit cut it, or (`cold_omitted`)
+     *  the cold page itself did. Before #34 only the first was visible, so an agent could not tell a
+     *  complete view from a truncated one. */
     capped: boolean;
+    /** cold rows that existed but never reached this function (0 = nothing was hidden) */
+    cold_omitted: number;
     /** the filters that were actually applied, echoed back so a caller cannot misread an empty list
      *  as "there is nothing" when what happened is "your filter matched nothing" */
     applied: Record<string, string | number | boolean>;
@@ -308,7 +317,10 @@ export function listSessions(rows: CockpitSessionRow[], q: ListQuery = {}): List
   const limit = Math.max(1, Math.min(LIST_LIMIT_MAX, Math.round(q.limit ?? LIST_LIMIT_DEFAULT)));
   applied.limit = limit;
   const total = out.length;
-  const capped = total > limit;
+  const coldOmitted = Math.max(0, Math.floor(q.coldOmitted ?? 0));
+  // `capped` answers "can I trust this as the whole picture?", so a cold page that dropped rows counts
+  // even when the list limit itself did not bite (#34).
+  const capped = total > limit || coldOmitted > 0;
   const page = out.slice(0, limit);
 
   let groups: ListResult["groups"];
@@ -331,7 +343,7 @@ export function listSessions(rows: CockpitSessionRow[], q: ListQuery = {}): List
     }));
   }
 
-  return { rows: page, ...(groups ? { groups } : {}), meta: { total, returned: Math.min(total, limit), capped, applied } };
+  return { rows: page, ...(groups ? { groups } : {}), meta: { total, returned: Math.min(total, limit), capped, cold_omitted: coldOmitted, applied } };
 }
 
 function normPath(p: string): string {

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";
@@ -635,7 +636,9 @@ const handleRequest = async (req: IncomingMessage, res: ServerResponse) => {
       const isOperator = !caller && auth.verifyMachineToken(/^Bearer\s+(.+)$/i.exec(String(req.headers.authorization ?? ""))?.[1] ?? undefined);
       if (!caller && !isOperator) return send(res, 403, { error: COCKPIT_ERRORS.badToken });
       // Scope: what the operator can see. 已归档 is out, on purpose — see `cockpitRows`.
-      const rows = mgr.cockpitRows();
+      // The cold page is taken once so its `omitted` count can travel with the answer (#34).
+      const cold = mgr.cockpitCold();
+      const rows = [...mgr.list(), ...cold.rows];
       const rowOf = (id: string): SessionInfo | null => rows.find((s) => s.id === id) ?? null;
       const summarize = (s: SessionInfo) => sessionRow(s, {
         plan: store.getPlan(s.id),
@@ -673,6 +676,7 @@ const handleRequest = async (req: IncomingMessage, res: ServerResponse) => {
           all: sp.get("all") === "1" || sp.get("all") === "true",
           includeSelf: sp.get("include_self") === "1" || sp.get("include_self") === "true",
           by: by as ListQuery["by"],
+          coldOmitted: cold.omitted,
         };
         if (query.sort && !["last", "created", "name"].includes(query.sort)) {
           return send(res, 400, { error: COCKPIT_ERRORS.badRequest, message: `--sort wants last|created|name, got "${query.sort}"` });
@@ -1589,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.
         //
@@ -1624,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).
@@ -1635,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
@@ -1646,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;