agentus 0.6.1 → 0.8.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-20261021-1400`, 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-20261021-1400`，基座 Hermes `v0.22.0`。
 
 你启动的第一个 slot 会使用**你自己的 agent 已经在用的**那个 Hermes home（`~/.hermes`），除非后端那一行
 指定了另一个 —— 见下面的「HERMES_HOME」。

package/bin/agentus.mjs

@@ -49,7 +49,9 @@ Commands (client side — they need the identity the cockpit gives an agent it s
   agentus session show <id>            one session in detail + any approval it waits on
   agentus session messages <id> [--tail N]
   agentus session plan <id>
-  agentus session send <id> <text…>    deliver a message into another session (operator-gated)
+  agentus session send <id> <text…>    deliver a message into another session (operator-gated);
+                                       add --wake to also start a cold target
+  agentus session wake <id>            start a cold session's process (same switch as send)
   agentus capabilities                 the CLI's contract, self-describing
   agentus skill [--path]               the CLI's manual, as shipped in the package
 

package/bin/cli.mjs

@@ -54,7 +54,10 @@ another one
   agentus session messages <id> [--tail N]
                                       the last N messages, each cut to the documented size
   agentus session plan <id>           the plan object the operator's card renders
-  agentus session send <id> <text…>   deliver a message into another session (stdin if no text)
+  agentus session send <id> <text…> [--wake]
+                                       deliver a message into another session (stdin if no text);
+                                       --wake also starts the target when it is cold
+  agentus session wake <id>            start a cold session's process (same switch as send)
 
   agentus capabilities                the contract: commands, fields, truncation, scope, send state
   agentus skill [--path]              this CLI's manual, as shipped in the package
@@ -292,7 +295,7 @@ if (cmd === "capabilities") {
     // The text is the plain words after the id — an agent writing a sentence should not have to
     // build JSON to say it. With no words, stdin is accepted: either a JSON `{"message": "…"}` (what
     // older callers sent) or the raw text.
-    let message = args.slice(1).join(" ").trim();
+    let message = args.slice(1).filter((a) => a !== "--wake").join(" ").trim();
     if (!message) {
       const raw = await readStdin();
       if (raw) {
@@ -310,7 +313,7 @@ if (cmd === "capabilities") {
       res = await fetch(`${EP}/api/cockpit/send`, {
         method: "POST",
         headers: headers(true),
-        body: JSON.stringify({ to: id, message }),
+        body: JSON.stringify({ to: id, message, ...(args.includes("--wake") ? { wake: true } : {}) }),
       });
     } catch (e) {
       fail("unreachable", `the cockpit did not answer: ${e?.message ?? e}`);
@@ -319,14 +322,46 @@ if (cmd === "capabilities") {
     if (!res.ok) {
       // The refusal meanings a model must not blur (see `capabilities.discipline`): none of these is
       // "delivered", and target_busy specifically means the target saw NOTHING.
-      fail(String(body?.error ?? `http_${res.status}`), String(body?.error ?? `the cockpit answered HTTP ${res.status}`));
+      // The refusal's MESSAGE is the part a model can act on (it names --wake, or that a box is
+      // archived); the code stays the stable token. Dropping the message made `target_cold` a dead
+      // end that looked identical to a true prohibition.
+      fail(String(body?.error ?? `http_${res.status}`),
+        String(body?.message ?? body?.error ?? `the cockpit answered HTTP ${res.status}`));
     }
     out({
       success: true,
       data: body,
       meta: {
         schema_version: 1,
-        note: "delivered means the target agent received it and started a turn — it does NOT mean it read or agreed. Only the operator sees the reply.",
+        note: body?.delivered_after_wake
+          ? "the target was COLD: this call woke it (a process now exists) and then delivered. delivered means it received the message and started a turn — not that it read or agreed."
+          : "delivered means the target agent received it and started a turn — it does NOT mean it read or agreed. Only the operator sees the reply.",
+      },
+    });
+  } else if (verb === "wake") {
+    // #41: the explicit, gated version of what opening a cold session in the rail does. Kept separate
+    // from send because it is a DECISION with a cost (a process, its memory) — an agent must be able
+    // to say 「I woke it」 without also having said something.
+    if (!id) fail("bad_request", "usage: agentus session wake <id>");
+    if (args.length > 1) fail("bad_request", `unexpected argument "${args[1]}" (usage: agentus session wake <id>)`);
+    let res;
+    try {
+      res = await fetch(`${EP}/api/cockpit/wake`, { method: "POST", headers: headers(true), body: JSON.stringify({ id }) });
+    } catch (e) {
+      fail("unreachable", `the cockpit did not answer: ${e?.message ?? e}`);
+    }
+    const body = await res.json().catch(() => null);
+    if (!res.ok) {
+      fail(String(body?.error ?? `http_${res.status}`), String(body?.message ?? body?.error ?? `the cockpit answered HTTP ${res.status}`));
+    }
+    out({
+      success: true,
+      data: body,
+      meta: {
+        schema_version: 1,
+        note: body?.woke
+          ? "the target now has a process and accepts send. Waking costs one process — do it for work you actually need."
+          : "the target was already live: nothing was started.",
       },
     });
   } else {

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-20261021-1400`** — 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-20261021-1400`** —— fork 上最新的那个 tag，基座 Hermes
 `v0.22.0`。这行只为一眼看个大概，不是权威：下面的 `TAG=$(…)` 每次都会自己解析出最新，觉得这行过期就
 以它为准。
 

package/package.json

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

@@ -451,6 +451,33 @@ const agent = () => ({
       }
     }
 
+    // `[recall]` — 记忆召回行带条目（issue #37）：与 `[status]` 同一个载体，多一个 `items`，
+    // 形状照 fork `acp_adapter/events.py:make_status_cb`。故意给一条带 tags、一条超长（验证展开后
+    // 换行而不是把行撑破），并用 `truncated` 说明后面还有 —— 界面上要能看出折叠、展开、截断三件事。
+    // `[recall:N]` 出 N 条（上限 60）：一轮召回几十条是线上的常态，而「展开就刷屏」只有在条目多到
+    // 超过定高时才看得出来 —— 3 条永远撑不满那个框（操作者 2026-10-21 要求定高可滚动）。
+    const recallM = /\[recall(?::(\d+))?\]/.exec(text);
+    if (/recall/.test(text)) { const fs = await import("node:fs"); fs.appendFileSync("/tmp/mock-recall.log", `text=${JSON.stringify(text)} m=${JSON.stringify(recallM && recallM[0])}\n`); }
+    if (recallM) {
+      const want = Math.min(Math.max(Number(recallM[1] ?? 3), 1), 60);
+      const seed = [
+        { text: "用户偏好：回复一律中文，技术术语可留英文" },
+        { text: "Agentus 的 live 端口是 8788，dev 是 8901，端口权威在 ~/.hermes/cache/agentus/ports.env", tags: ["port", "agentus"] },
+        { text: "发布红线：会重启 live 的改动必须等明确指令；纯前端可以直接 promote" + "（这段故意写得长一些，用来验证展开后的条目会换行而不是把行撑破）".repeat(2) },
+      ];
+      const items = Array.from({ length: want }, (_, i) => {
+        const base = seed[i % seed.length];
+        return i < seed.length ? base : { ...base, text: `第 ${i + 1} 条：${base.text}` };
+      });
+      setTimeout(() => {
+        void send(agent._conn, sessionId, {
+          sessionUpdate: "agent_thought_chunk",
+          _meta: { hermes: { kind: "status", statusKind: "lifecycle", text: `👁️ Hindsight — recalled ${want} memories`, items, truncated: true } },
+          content: { type: "text", text: "" },
+        }).catch(() => undefined);
+      }, Math.min(slow * 2, 900));
+    }
+
     // `[blank]` — the SAME carrier with its `_meta` stripped, i.e. the shape a status line takes when
     // the sentence is lost before us (measured 2026-10-17: hermes set `update._meta` while the ACP
     // model's field is `field_meta`, so every status shipped as a bare empty thought). The cockpit must
@@ -480,9 +507,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 +534,54 @@ const agent = () => ({
       }, runMs + 1200);
     }
 
+    // `[bg-delegation]` — the OTHER producer of background frames (issue #39): a live
+    // `delegate_task(background=true)`. Same carrier as `[bg]`, but the row is a subagent: no pid, no
+    // command line, a GOAL, and `taskCount` children behind one row. This is what the fork's relay now
+    // sends; before the fix it sent nothing at all, so the cockpit had nothing to draw while two
+    // children ran for minutes.
+    if (/\[bg-delegation\]/.test(text)) {
+      const subId = `deleg-${sessionId}-1`;
+      const snapshot = (rows) => ({
+        sessionUpdate: "agent_thought_chunk",
+        _meta: { hermes: { kind: "background", tasks: rows } },
+        content: { type: "text", text: "" },
+      });
+      const row = {
+        id: subId, kind: "delegation", command: "读一遍 packages/web 的检索链路，写出结论",
+        pid: null, status: "running", phase: "running", uptimeSeconds: 95,
+        notifyOnComplete: true, taskCount: 2,
+      };
+      void send(agent._conn, sessionId, snapshot([row])).catch(() => undefined);
+      setTimeout(() => {
+        void send(agent._conn, sessionId, {
+          sessionUpdate: "agent_thought_chunk",
+          _meta: { hermes: {
+            kind: "completion",
+            text: "委派的子任务已完成：读一遍 packages/web 的检索链路，写出结论",
+            processId: subId,
+          } },
+          content: { type: "text", text: "" },
+        }).catch(() => undefined);
+      }, 1600);
+      setTimeout(() => {
+        void send(agent._conn, sessionId, snapshot([])).catch(() => undefined);
+      }, 2800);
+    }
+
+    // `[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
@@ -688,6 +767,34 @@ const agent = () => ({
       }
     }
 
+    // `[tool-many]` — 一个回合改了三个文件（issue #38：回合末尾的「N 个文件变更」）。
+    // 三个刻意不同的形状：同一文件**改两刀**（合并成一条、edits=2）、一个 40 行文件只改中间
+    // 一行（必须走 hunk 折叠）、一个新文件（oldText 为空 → 不能编造删除行）。
+    // 这个 fixture **不发权限请求**，形状就是 accept_edits 那种「不问就写」的回合 —— 也正因此
+    // 它同时是「这一块不依赖审批」的证据：从审批路径拿不到任何 diff 的回合，面板照样得有内容。
+    if (/\[tool-many\]/.test(text)) {
+      const big = Array.from({ length: 40 }, (_, i) => `export const line${i} = ${i};`).join("\n") + "\n";
+      const bigEdit = big.replace("export const line20 = 20;", "export const line20 = 'twenty';");
+      const calls = [
+        { id: `tc-many-1-${sessionId}`, path: "/repo/src/app.ts", oldText: "const x = 1;\nconst y = 2;\n", newText: "const x = 1;\nconst y = 20;\n" },
+        { id: `tc-many-2-${sessionId}`, path: "/repo/src/app.ts", oldText: "const x = 1;\nconst y = 20;\n", newText: "const x = 1;\nconst y = 20;\nconst z = 3;\n" },
+        { id: `tc-many-3-${sessionId}`, path: "/repo/src/big.ts", oldText: big, newText: bigEdit },
+        { id: `tc-many-4-${sessionId}`, path: "/repo/docs/new.md", oldText: "", newText: "# 新文件\n" },
+      ];
+      for (const c of calls) {
+        await send(agent._conn, sessionId, {
+          sessionUpdate: "tool_call", toolCallId: c.id,
+          title: `Edit file: ${c.path}`, kind: "edit", status: "pending",
+          content: [{ type: "diff", path: c.path, oldText: c.oldText, newText: c.newText }],
+          rawInput: { tool: "patch", arguments: { path: c.path } },
+        });
+        await send(agent._conn, sessionId, {
+          sessionUpdate: "tool_call_update", toolCallId: c.id,
+          status: "completed", rawOutput: `wrote ${c.path}`,
+        });
+      }
+    }
+
     // `[plan-long]` — the same frame with steps long enough to wrap on a phone. The operator's
     // complaint (2026-10-18) is about exactly this: a step that runs onto a second line on a 360px
     // screen. Short English steps hide it, so the fixture has to carry the long shape.

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

@@ -3,6 +3,7 @@
 // loop, event fan-out with monotonic seq, permission pending-map with timeout,
 // mode/config plumbing. UI holds zero intelligence (red line D): we only relay.
 import { spawn } from "node:child_process";
+import fs from "node:fs";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { Readable, Writable } from "node:stream";
@@ -43,11 +44,12 @@ import type {
   ServerEvent,
   SessionInfo,
   SessionModeState,
+  StatusNoteItem,
   TurnTrace,
 } 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
@@ -58,6 +60,16 @@ import { PREFS_DEFAULT, type PlanHintSettings } from "../settings.js";
 // never see it, so it must not become a second thing users have to learn.)
 const COCKPIT_BIN = path.join(path.dirname(fileURLToPath(import.meta.url)), "../../../../bin/agentus.mjs");
 
+// #40: a git checkout keeps `bin/agentus.mjs` at mode 100644 (the blob has no exec bit), so the very
+// first thing an agent does with the path we hand it — `$AGENTUS_COCKPIT_BIN session list` — dies with
+// `Permission denied`, and there is no npm shim to fall back on in a checkout (that is the deployment
+// form this project recommends). Fix the mode where we resolve the path: idempotent, best effort (a
+// read-only install stays usable — the agent just has to spell `node <path>`), and it also covers the
+// copies that lose the bit in tar/CI caches. The blob mode is fixed too, so a fresh clone is correct.
+try {
+  if ((fs.statSync(COCKPIT_BIN).mode & 0o111) === 0) fs.chmodSync(COCKPIT_BIN, 0o755);
+} catch { /* read-only tree: not fatal, only a worse error message for the agent */ }
+
 // Permission prompts must not hang a session forever (design.md §8-4).
 // Env-tunable so QA can exercise the timeout path in seconds instead of minutes.
 const PERMISSION_TIMEOUT_MS = Number(process.env.AGENTUS_PERM_TIMEOUT_MS || 5 * 60_000);
@@ -1828,7 +1840,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 +1948,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);
@@ -1976,7 +1991,10 @@ export class SessionManager {
         // 落库（操作者 2026-10-18 选的 A 档）：刷新页面、重连、换设备之后，这行还在。
         // 折叠在 store 里做（见 Store.appendNote），因为「压缩开始 → 心跳 → 完成」和每回合的
         // 一次回忆都必须收敛成一行 —— 客户端折只治屏幕噪音，库里照样长心跳。
-        const row = this.#store.appendNote(live.info.id, { category, text: statusText });
+        const detail = category === "memory" ? statusItemsOf(u) : undefined;
+        const row = this.#store.appendNote(live.info.id, {
+          category, text: statusText, items: detail?.items, truncated: detail?.truncated,
+        });
         this.#emit({ t: "message", message: row });
       } else {
         // 剩下的（provider 等待的倒计时、租约闲聊）本来就是一秒就作废的呼吸声：只走 live 通道。
@@ -2698,7 +2716,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 +2734,65 @@ 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,
+      // #39: subagents ride the same frame. `kind` defaults to `process` — the page renders the
+      // legacy shape unchanged for every agent that never sends it.
+      kind: r.kind === "delegation" ? "delegation" : "process",
+      phase: typeof r.phase === "string" ? r.phase : undefined,
+      taskCount: typeof r.taskCount === "number" ? r.taskCount : undefined,
     });
   }
   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);
+}
+
+/** 一帧状态自带的条目（`_meta.hermes.items`），只有 memory 行用得上 —— issue #37。
+ *
+ *  形状（fork `acp_adapter/events.py:make_status_cb`）：与状态句同一条 thought 帧，
+ *  `items: [{text, tags?, type?}]`、`truncated` 说明 agent 侧已经截断过。**在这里限一次量**
+ *  是因为这串东西来自 agent 进程、还要落库：provider 已经按 200 字符/条、6K/轮截过，但那是
+ *  agent 的承诺，不是我们的保证。上限与前端展开的容量对齐，绝不把一帧 200KB 的 memory 写进 SQLite。
+ */
+export const NOTE_ITEMS_MAX = 20;
+export const NOTE_ITEM_CHARS = 300;
+
+export function statusItemsOf(u: Record<string, unknown>): { items: StatusNoteItem[]; truncated: boolean } | undefined {
+  const raw = hermesPayload(u).items;
+  if (!Array.isArray(raw)) return undefined;
+  const items: StatusNoteItem[] = [];
+  for (const entry of raw) {
+    if (items.length >= NOTE_ITEMS_MAX) break;
+    const text = typeof entry === "object" && entry ? (entry as { text?: unknown }).text : undefined;
+    if (typeof text !== "string" || !text.trim()) continue;
+    const item: StatusNoteItem = { text: text.trim().slice(0, NOTE_ITEM_CHARS) };
+    const tags = (entry as { tags?: unknown }).tags;
+    if (Array.isArray(tags)) {
+      const clean = tags.filter((t): t is string => typeof t === "string" && !!t).slice(0, 8);
+      if (clean.length) item.tags = clean;
+    }
+    const kind = (entry as { type?: unknown }).type;
+    if (typeof kind === "string" && kind) item.type = kind;
+    items.push(item);
+  }
+  if (!items.length) return undefined;
+  return { items, truncated: hermesPayload(u).truncated === true || raw.length > items.length };
+}
+
 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

@@ -56,6 +56,10 @@ export type CockpitSessionRow = {
   self?: boolean;
   /** no agent process: the message would have to wake it first */
   cold: boolean;
+  /** you MAY wake this row (issue #41): it is cold, not archived, so `session wake` / `send --wake`
+   *  can start it. Capability, not permission — whether waking is allowed at all is the operator's
+   *  驾驶舱互发消息 switch, reported once in `capabilities.scope.wake`. */
+  wakeable: boolean;
   /** on the operator's 已归档 shelf — OUT of scope for the cockpit channel */
   archived: boolean;
   /** last talked to (wall clock) */
@@ -97,7 +101,8 @@ export function capabilities(sendEnabled: boolean): Record<string, unknown> {
       { name: "session show", args: ["<id>"], returns: "one session in detail, including any approval it is waiting on" },
       { name: "session messages", args: ["<id>", "--tail N"], returns: `the last N messages (default ${MESSAGES_TAIL_DEFAULT}, max ${MESSAGES_TAIL_MAX}), each cut to ${MESSAGE_CHARS} chars` },
       { name: "session plan", args: ["<id>"], returns: "the plan object the operator's card renders (title/items/explanation/terminal)" },
-      { name: "session send", args: ["<id>", "<text…>"], returns: "deliver a message into another session (text after the id, or on stdin)" },
+      { name: "session send", args: ["<id>", "<text…>", "--wake"], returns: "deliver a message into another session (text after the id, or on stdin). A COLD target answers cold_target unless you pass --wake" },
+      { name: "session wake", args: ["<id>"], returns: "start a cold session's agent process — the same thing the operator's rail does when they open it; the session then accepts send. Gated by the same 驾驶舱互发消息 switch as send" },
     ],
     truncation: {
       messages: `each message's text is cut to ${MESSAGE_CHARS} characters; a cut one ends with … and reports truncated:true`,
@@ -122,6 +127,13 @@ export function capabilities(sendEnabled: boolean): Record<string, unknown> {
         ? "ENABLED: you may deliver a message into another session in scope"
         : "DISABLED: the operator has not turned 驾驶舱互发消息 on; send answers code:sends_disabled",
       send_semantics: "delivered means the target agent RECEIVED the message and started a turn — never that it read it or agreed. Nothing is claimed about a reply.",
+      // #41: waking is a step with a COST (a process, its memory, a spot in the warm set), so it is
+      // never implicit. `send` to a cold target answers target_cold and names both ways forward; the
+      // caller decides whether the conversation is worth a process.
+      wake: sendEnabled
+        ? "ENABLED (same switch as send): `session wake <id>` starts a cold row, or `session send <id> --wake` wakes then delivers (answer carries delivered_after_wake). Rows carry `wakeable` — a cold, non-archived session. Wake sparingly: each one costs a process."
+        : "DISABLED: 驾驶舱互发消息 is off; wake answers code:sends_disabled (wake+send are one intent).",
+      cold_targets: "`session send` to a cold session answers code:target_cold — that is NOT a refusal of the conversation, only of the implicit process. Check `wakeable` on the row.",
     },
     discipline: [
       "read before you assert: call `context` instead of trusting your memory of another session",
@@ -148,6 +160,7 @@ export function sessionRow(
     workspace: info.workspace || info.cwd,
     createdAt: info.createdAt,...(info.titleBy ? { titleBy: info.titleBy } : {}),
     cold: Boolean(info.cold),
+    wakeable: Boolean(info.cold) && !info.archivedAt,
     archived: Boolean(info.archivedAt),
     lastAt: info.lastAt ?? info.createdAt,
     plan: {
@@ -409,6 +422,7 @@ export const COCKPIT_ERRORS = {
   sendsDisabled: "sends_disabled",
   targetBusy: "target_busy",
   targetCold: "target_cold",
+  wakeFailed: "wake_failed",
   rateLimited: "rate_limited",
   badRequest: "bad_request",
 } as const;

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");