agentus 0.7.0 → 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-20261020-2337`, 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-20261020-2337`，基座 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

@@ -60,7 +60,7 @@ ref and gets rebuilt, while a tag never moves — so pin the tag. The `agentus/`
 ours apart from upstream's own tags (`v0.22.0`, `v0.22.0+canary.*`), and the timestamp in the
 last segment sorts, so "newest" is a `sort -V`.
 
-**Current integration build: `agentus/v0.22.0/merge-20261020-2337`** — 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

@@ -52,7 +52,7 @@ agentus/<hermes 内部版本>/merge-<YYYYMMDD-HHMM>
 tag。`agentus/` 这个前缀也把它和上游自己的 tag（`v0.22.0`、`v0.22.0+canary.*`）分开；最后一段是时间戳，
 可排序，所以「最新」就是一次 `sort -V`。
 
-**当前集成构建：`agentus/v0.22.0/merge-20261020-2337`** —— 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.7.0",
+ "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
@@ -507,6 +534,40 @@ 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)) {
@@ -706,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,6 +44,7 @@ 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";
@@ -58,6 +60,16 @@ import { PREFS_DEFAULT, agentSettings, type PlanHintSettings } from "../settings
 // 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);
@@ -1979,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 通道。
@@ -2723,6 +2738,11 @@ export function backgroundTasksOf(u: Record<string, unknown>): BackgroundTask[]
       // 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;
@@ -2741,6 +2761,38 @@ 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/index.ts

@@ -761,7 +761,26 @@ const handleRequest = async (req: IncomingMessage, res: ServerResponse) => {
         if (!sendOk) return send(res, 403, { error: COCKPIT_ERRORS.sendsDisabled });
         const target = rowOf(to);
         if (!target) return send(res, 404, { error: COCKPIT_ERRORS.outOfScope });
-        if (target.cold) return send(res, 409, { error: COCKPIT_ERRORS.targetCold });
+        // #41: a cold target used to end the conversation here. Waking is now EXPLICIT (`--wake`),
+        // because it costs a process — but refusing every cold send made cross-session work
+        // unusable, since the idle reaper keeps targets cold by design.
+        const wantWake = body.wake === true;
+        let woke = false;
+        if (target.cold) {
+          if (!wantWake) {
+            return send(res, 409, {
+              error: COCKPIT_ERRORS.targetCold,
+              message: "the target has no running process; pass --wake (wake:true) to start it, then the message is delivered in the same call",
+              wakeable: !target.archivedAt,
+            });
+          }
+          try {
+            await mgr.resume(to);
+            woke = true;
+          } catch (e) {
+            return send(res, 409, { error: COCKPIT_ERRORS.wakeFailed, message: String((e as Error)?.message ?? e) });
+          }
+        }
         // Deliberately NOT `interrupt`: a cross-session message must never take the floor from a turn
         // the OPERATOR started. A busy target answers `target_busy` and the caller reports it as such.
         try {
@@ -775,7 +794,24 @@ const handleRequest = async (req: IncomingMessage, res: ServerResponse) => {
           const why = String((e as Error)?.message ?? e);
           return send(res, 409, { error: why.includes("turn already running") ? COCKPIT_ERRORS.targetBusy : why });
         }
-        return send(res, 200, { delivered: true, to, code: "delivered" });
+        return send(res, 200, { delivered: true, to, code: "delivered", ...(woke ? { delivered_after_wake: true } : {}) });
+      }
+      if (url.pathname === "/api/cockpit/wake" && req.method === "POST") {
+        const body = await readJson(req);
+        const id = String(body.id ?? "");
+        if (!id) return send(res, 400, { error: COCKPIT_ERRORS.badRequest });
+        // Same gate as send (#41): waking is what makes a send possible, so the two answers must
+        // never disagree about whether an agent may pull another session's process up.
+        if (!sendOk) return send(res, 403, { error: COCKPIT_ERRORS.sendsDisabled });
+        const target = rowOf(id);
+        if (!target) return send(res, 404, { error: COCKPIT_ERRORS.outOfScope });
+        if (!target.cold) return send(res, 200, { schema_version: COCKPIT_SCHEMA_VERSION, woke: false, already_live: true, id });
+        try {
+          const info = await mgr.resume(id);
+          return send(res, 200, { schema_version: COCKPIT_SCHEMA_VERSION, woke: true, id, status: info.status });
+        } catch (e) {
+          return send(res, 409, { error: COCKPIT_ERRORS.wakeFailed, message: String((e as Error)?.message ?? e) });
+        }
       }
       return send(res, 404, { error: "unknown cockpit command" });
     }

package/packages/server/src/store/store.ts

@@ -3,7 +3,7 @@
 // messages carry monotonic per-session `seq` (reconnect replay anchor, AC6).
 import fs from "node:fs";
 import { DatabaseSync } from "node:sqlite";
-import type { BackendId, PlanSnapshot, SessionStatus, StoredMessage } from "../../../shared/src/index.js";
+import type { BackendId, PlanSnapshot, SessionStatus, StatusNoteItem, StoredMessage } from "../../../shared/src/index.js";
 import type { BackendHandshake, BackendHealth, BackendKind, BackendRow } from "../acp/registry.js";
 import { normalizeItems } from "../plan/plan.js";
 import { DEFAULT_NATIVE_PLAN_SOURCE } from "../acp/backends.js";
@@ -965,7 +965,11 @@ export class Store {
    * （说明这中间没有别的消息落下），就更新它，而不是再加一行；位置变了（新消息进来了）就另起一行。
    * 于是「压缩中 → 完成」收敛成一行（保留开始时间），一个回合一次回忆也只留一行。
    */
-  appendNote(sessionId: string, note: { category: string; text: string; createdAt?: number }): StoredMessage {
+  appendNote(sessionId: string, note: {
+    category: string; text: string; createdAt?: number;
+    /** memory 行的条目（issue #37）—— 只在 category==="memory" 时有意义。 */
+    items?: StatusNoteItem[]; truncated?: boolean;
+  }): StoredMessage {
     const createdAt = note.createdAt ?? Date.now();
     const edge = this.#db
       .prepare("select coalesce(max(seq),0) as seq from messages where session_id = ?")
@@ -974,9 +978,18 @@ export class Store {
       .prepare("select seq, payload, created_at from messages where session_id = ? and kind = 'note' order by seq desc limit 1")
       .get(sessionId) as { seq: number; payload: string; created_at: number } | undefined;
     if (last && last.seq === edge.seq) {
-      const prev = JSON.parse(last.payload) as { category?: string; text?: string; hits?: number };
+      const prev = JSON.parse(last.payload) as {
+        category?: string; text?: string; hits?: number; items?: StatusNoteItem[]; truncated?: boolean;
+      };
       if (prev.category === note.category) {
-        const payload = { category: note.category, text: note.text, hits: (prev.hits ?? 1) + 1 };
+        // 折叠只发生在「位置上没有别的消息插进来」时（压缩的开始/心跳/完成）。条目取**最新一次**：
+        // 折叠出来的是同一行，这行的内容是最后一次召回，而不是第一次的残留。
+        const payload: Record<string, unknown> = {
+          category: note.category, text: note.text, hits: (prev.hits ?? 1) + 1,
+        };
+        const items = note.items ?? prev.items;
+        if (items?.length) payload.items = items;
+        if (note.truncated ?? prev.truncated) payload.truncated = true;
         // `created_at` stays: it answers "这一轮什么时候开始回忆/压缩的", and the heartbeat is not news.
         this.#db
           .prepare("update messages set payload = ? where session_id = ? and seq = ?")
@@ -986,9 +999,10 @@ export class Store {
         };
       }
     }
-    const row = this.appendMessage({
-      sessionId, kind: "note", payload: { category: note.category, text: note.text, hits: 1 }, createdAt,
-    });
+    const payload: Record<string, unknown> = { category: note.category, text: note.text, hits: 1 };
+    if (note.items?.length) payload.items = note.items;
+    if (note.truncated) payload.truncated = true;
+    const row = this.appendMessage({ sessionId, kind: "note", payload, createdAt });
     // Bounded: a session left open for weeks must not keep every recall it ever did. 80 is well past
     // what any transcript page shows, and a note is ~120 bytes.
     const over = this.#db

package/packages/shared/src/index.ts

@@ -263,6 +263,16 @@ export interface BackgroundTask {
   status: "running" | "exited";
   uptimeSeconds?: number;
   exitCode?: number | null;
+  /** What this row IS (issue #39). `process` = a `terminal(background=true)` child in the process
+   *  registry; `delegation` = a live `delegate_task(background=true)` subagent, which never appears
+   *  there. Absent on frames from an older agent, and absent must read as `process`: that is what
+   *  every field above has always meant. */
+  kind?: "process" | "delegation";
+  /** Delegations only: the ledger's own phase (`running` / `stalling` / `finalizing`). `status`
+   *  stays the host's two-state vocabulary, so a `finalizing` child still reads as running. */
+  phase?: string;
+  /** Delegations only: how many children one row stands for (a batch of N counts N). */
+  taskCount?: number;
   /** 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
@@ -434,6 +444,18 @@ export type ClientCommand =
       signature?: string; // "<kind>:<toolCallTitle>" for always-allow memory
     };
 
+/** 一条记忆召回条目 —— `note` 行 `payload.items` 的元素（issue #37）。
+ *
+ *  「recalled 8 memories」只说记忆被用上了，没说用上的是哪几条，于是「召回错了/召回旧了」和
+ *  「召回得好」在屏幕上长得一模一样。条目由 provider 侧截断（200 字符/条、6K/轮），server 再按
+ *  自己的上限（20 条 / 300 字符）限一次，因为这条数据来自 agent 进程并且要落库。
+ */
+export interface StatusNoteItem {
+  text: string;
+  tags?: string[];
+  type?: string;
+}
+
 export interface StoredMessage {
   seq: number; // monotonic per session — reconnect dedup anchor
   sessionId: string;