agentus 0.4.5 → 0.6.0

package/README.md

@@ -50,12 +50,13 @@ logs in — you just have no backend to start a session on.
 
 A plain Hermes install drives sessions; the cockpit's own extras — per-session **thinking
 depth**, a permission mode that survives a restart, the **context-budget** field, the **status
-channel** (memory recall/save hints in the message stream), per-process skill roots, **background-job
-completion wake-ups** (a finished 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:
+channel** (memory recall/save hints in the message stream), per-process skill roots, **project
+skills made visible and switchable** (a repo's `.agents/skills` shows up as a `project_skills`
+option instead of being skipped in silence), **background-job completion wake-ups** (a finished
+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-20261018-1617`, on Hermes `v0.22.0`.
+`agentus/v0.22.0/merge-20261019-2348`, 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

@@ -45,11 +45,12 @@ web bundle、配套 APK —— 然后直接退出，不启动任何东西）。
 
 裸装的 Hermes 就能跑会话；驾驶舱自己的那几项能力 —— 按会话切换的**思考深度**、跨重启存活的**权限模式**、
 **上下文预算**输入框、把记忆召回 / 存记忆提示送进消息流的 **status 通道**、按进程指定的技能根、
+**项目 skill 可见可设**（仓库的 `.agents/skills` 会以 `project_skills` 选项出现，而不是被无声跳过）、
 **后台任务完成唤醒**（后台进程跑完会自己开一个回合回来），
 以及 **DeepSeek 的 web 后端**（搜索 + 正文抓取，共用模型 key）—— 来自 fork 的集成构建（tag）。
 装法就五行：
 [§ 该跑哪份 Hermes](docs/installation.zh-CN.md#该跑哪份-hermes) —— 当前是 tag
-`agentus/v0.22.0/merge-20261018-1617`，基座 Hermes `v0.22.0`。
+`agentus/v0.22.0/merge-20261019-2348`，基座 Hermes `v0.22.0`。
 
 你启动的第一个 slot 会使用**你自己的 agent 已经在用的**那个 Hermes home（`~/.hermes`），除非后端那一行
 指定了另一个 —— 见下面的「HERMES_HOME」。

package/docs/installation.md

@@ -55,7 +55,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-20261018-1617`** — the newest tag on the fork,
+**Current integration build: `agentus/v0.22.0/merge-20261019-2348`** — 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

@@ -49,7 +49,7 @@ agentus/<hermes 内部版本>/merge-<YYYYMMDD-HHMM>
 tag。`agentus/` 这个前缀也把它和上游自己的 tag（`v0.22.0`、`v0.22.0+canary.*`）分开；最后一段是时间戳，
 可排序，所以「最新」就是一次 `sort -V`。
 
-**当前集成构建：`agentus/v0.22.0/merge-20261018-1617`** —— fork 上最新的那个 tag，基座 Hermes
+**当前集成构建：`agentus/v0.22.0/merge-20261019-2348`** —— fork 上最新的那个 tag，基座 Hermes
 `v0.22.0`。这行只为一眼看个大概，不是权威：下面的 `TAG=$(…)` 每次都会自己解析出最新，觉得这行过期就
 以它为准。
 

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "agentus",
- "version": "0.4.5",
+ "version": "0.6.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": {
@@ -58,6 +58,7 @@
   "token-format": "tsx scripts/qa/token-format.mts",
   "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",
   "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",
@@ -65,6 +66,10 @@
   "notify-testbed": "tsx scripts/notify-testbed.mts",
   "notify-smoke": "tsx scripts/notify-smoke.mts",
   "web-notify-rules": "tsx scripts/qa/web-notify-rules.mts",
+  "notify-chime": "tsx scripts/qa/notify-chime.mts",
+  "ws-send-ack": "node scripts/qa/ws-send-ack.mjs",
+  "send-ack": "node scripts/qa/send-ack-page.mjs",
+  "composer-input": "node scripts/qa/composer-input-sweep.mjs",
   "web-notify-sweep": "node scripts/qa/web-notify-sweep.mjs",
   "apk": "bash scripts/build-apk.sh",
   "transcript-fold": "tsx scripts/qa/transcript-fold.mts",

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

@@ -177,6 +177,12 @@ interface LiveSession {
     timer: NodeJS.Timeout;
   }>;
   alwaysAllow: Set<string>; // "allow_always" remembered per live session only (AionUi F-PERM-05)
+  /** requestId → seq of the `approval` row this request already wrote into the transcript, so the
+   *  decision can be filled into the SAME row instead of appending a second one. */
+  approvalSeq: Map<string, number>;
+  /** repo root → the `project-skills` row this session already shows, with its payload, so a
+   *  second "untrusted" notice never stacks and a decision can rewrite the row in place. */
+  skillNoticeSeq: Map<string, { seq: number; payload: Record<string, unknown> }>;
   stderrBuf: string[];
   /** What the agent says it can do (initialize.agentCapabilities). `fork` gates title
    *  regeneration, `load` gates resume; `image` is the one a TURN can be refused on — see
@@ -382,12 +388,25 @@ export class SessionManager {
    *
    * The decision is `cancelled` — what the agent would have received had nobody ever answered.
    */
+  /** 把一条已经落库的卡片换成新 payload，并推给所有客户端。
+   *
+   *  审批卡与项目 skill 卡都是「先落行、后补决定」：行必须在请求到达那一刻就写进转录（否则
+   *  刷新之后「弹过这张卡」这件事就不存在了），决定要等操作者点。改 payload 而不改 seq ——
+   *  seq 决定它在聊天记录里的位置，改了它会跳到别的地方。 */
+  #settleRow(live: LiveSession, seq: number | undefined, payload: Record<string, unknown>): void {
+    if (seq === undefined) return;
+    const row = this.#store.updateMessagePayload(seq, live.info.id, payload);
+    if (row) this.#emit({ t: "message", message: row });
+  }
+
   #dropPending(live: LiveSession, decision: PermissionDecision = { outcome: "cancelled" }): void {
     if (!live.pendingPermissions.size) return;
-    for (const [requestId, { resolve, timer }] of live.pendingPermissions) {
+    for (const [requestId, { resolve, timer, view }] of live.pendingPermissions) {
       clearTimeout(timer);
       resolve({ outcome: decision });
       this.#emit({ t: "permission-resolved", requestId, decision });
+      this.#settleRow(live, live.approvalSeq.get(requestId), { ...view, decision });
+      live.approvalSeq.delete(requestId);
     }
     live.pendingPermissions.clear();
   }
@@ -501,7 +520,8 @@ export class SessionManager {
         ...(opts.system ? { system: true } : {}),
         createdAt: now, modes: null, configOptions: [], commands: [],
       },
-      child, busy: false, pendingPermissions: new Map(), alwaysAllow: new Set(), stderrBuf: [],
+      child, busy: false, pendingPermissions: new Map(), alwaysAllow: new Set(),
+      approvalSeq: new Map(), skillNoticeSeq: new Map(), stderrBuf: [],
       background: [], pendingCompletions: [],
       caps: { fork: false, load: false, image: false }, turnSeq: 0, collectors: new Map(), planReminderPending: true,
       planToken: randomUUID(),
@@ -686,7 +706,8 @@ export class SessionManager {
         usage: (row.usage ?? null) as SessionInfo["usage"],
         commands: normCommands(row.commands),
       },
-      child, busy: false, pendingPermissions: new Map(), alwaysAllow: new Set(), stderrBuf: [],
+      child, busy: false, pendingPermissions: new Map(), alwaysAllow: new Set(),
+      approvalSeq: new Map(), skillNoticeSeq: new Map(), stderrBuf: [],
       background: [], pendingCompletions: [],
       caps: { fork: false, load: false, image: false }, turnSeq: 0, collectors: new Map(), planReminderPending: true,
       planToken: randomUUID(),
@@ -972,6 +993,12 @@ export class SessionManager {
        * message, no attribution, indistinguishable from something they typed).
        */
       origin?: { sessionId: string; title?: string | null };
+      /**
+       * Client-generated id of the prompt that is being sent (issue #26). Echoed on the `turn-start`
+       * this call causes, so a page can prove its frame landed instead of assuming `ws.send()` did
+       * something. Opaque to the server: it comes back unchanged, it is never stored.
+       */
+      pid?: string;
     } = {},
   ): Promise<void> {
     const s = this.#need(sessionId);
@@ -1038,7 +1065,7 @@ export class SessionManager {
     // Timed from the announcement, not from the prompt call: the operator's wait INCLUDES the
     // moment the card lit up. Only the queue-wait above is excluded (that is other turns' time).
     const turnStartedAt = Date.now();
-    this.#emit({ t: "turn-start", sessionId, trace: this.#turnTrace(s) });
+    this.#emit({ t: "turn-start", sessionId, trace: this.#turnTrace(s), ...(opts.pid ? { pid: opts.pid } : {}) });
     const msg = this.#store.appendMessage({
       sessionId,
       kind: "user",
@@ -1233,6 +1260,15 @@ export class SessionManager {
       rejected = true;
       actual = String(s.info.configOptions.find((o) => o.id === configId)?.currentValue ?? "");
     }
+    if (configId === "project_skills" && !rejected) {
+      // 决定落在卡上：卡片是「问过」的证据，改配置却不改卡，读起来就像问完没下文。
+      for (const [root, cur] of s.skillNoticeSeq) {
+        if (cur.payload.root && String(cur.payload.root) !== root) continue;
+        const payload = { ...cur.payload, state: actual };
+        cur.payload = payload;
+        this.#settleRow(s, cur.seq, payload);
+      }
+    }
     if (rejected) {
       this.#emit({
         t: "config-rejected",
@@ -1826,6 +1862,8 @@ export class SessionManager {
     s.pendingPermissions.delete(requestId);
     pending.resolve({ outcome: decision });
     this.#emit({ t: "permission-resolved", requestId, decision });
+    this.#settleRow(s, s.approvalSeq.get(requestId), { ...pending.view, decision });
+    s.approvalSeq.delete(requestId);
     return true;
   }
 
@@ -1886,6 +1924,33 @@ export class SessionManager {
       this.#queueOrWakeCompletion(live, finishedText);
       return;
     }
+    // Project skills the agent is NOT loading (fork: `_meta.hermes = {kind:"project_skills"}`).
+    // The same door, one more kind. It rides the live status channel on purpose: the sentence is
+    // about THIS open, and persisting it would put 「这个仓库有 N 个 skill 未启用」 above a
+    // conversation from last month — the very thing the status path already refuses to store.
+    const projectSkills = projectSkillsNoticeOf(u);
+    if (projectSkills) {
+      // 一张卡而不是一行闪现的状态：操作者要能在聊天记录里看到「这个仓库有 N 个 skill 没启用」，
+      // 并就地做决定（信任 / 先不）。每个 repo root 只落一次，重复打开不会堆卡片。
+      const rootKey = projectSkills.root || "(no root)";
+      if (!live.skillNoticeSeq.has(rootKey)) {
+        const payload: Record<string, unknown> = {
+          root: projectSkills.root,
+          count: projectSkills.count,
+          text: projectSkills.text,
+          state: "ask",
+        };
+        const row = this.#store.appendMessage({
+          sessionId: live.info.id,
+          kind: "project-skills",
+          payload,
+          createdAt: Date.now(),
+        });
+        live.skillNoticeSeq.set(rootKey, { seq: row.seq, payload });
+        this.#emit({ t: "message", message: row });
+      }
+      return;
+    }
     const statusText = statusLineOf(u);
     if (statusText) {
       const statusKind = statusKindOf(u);
@@ -2068,6 +2133,18 @@ export class SessionManager {
         outcome: { outcome: "selected", optionId: remembered.optionId } as never,
       });
     }
+    // 落一行再弹卡（操作者 2026-10-19）：审批只以 transient 事件存在时，弹窗关掉/刷新/换设备之后
+    // 就什么都不剩了 —— 「刚才那个请求我批的什么」无从查起。行在请求到达这一刻写，决定稍后补进
+    // 同一行（#settleRow），于是聊天记录里留下一条带结论的记录。
+    const approvalRow = this.#store.appendMessage({
+      sessionId: live.info.id,
+      kind: "approval",
+      payload: { ...view, decision: null },
+      createdAt: view.createdAt,
+    });
+    live.approvalSeq.set(requestId, approvalRow.seq);
+    this.#touch(live, approvalRow.createdAt);
+    this.#emit({ t: "message", message: approvalRow });
     this.#emit({ t: "permission", request: view });
     return new Promise<RequestPermissionResponse>((resolve) => {
       const timer = setTimeout(() => {
@@ -2075,6 +2152,9 @@ export class SessionManager {
         const d: PermissionDecision = { outcome: "cancelled" };
         resolve({ outcome: d });
         this.#emit({ t: "permission-resolved", requestId, decision: d });
+        // 超时也是「有结论」：卡片上要留下「没人答，已取消」，不能一直挂着等批准。
+        this.#settleRow(live, live.approvalSeq.get(requestId), { ...view, decision: d });
+        live.approvalSeq.delete(requestId);
       }, PERMISSION_TIMEOUT_MS);
       live.pendingPermissions.set(requestId, { view, resolve, timer });
     });
@@ -2563,6 +2643,28 @@ function hermesPayload(u: Record<string, unknown>): Record<string, unknown> {
   return meta?.hermes ?? {};
 }
 
+/** Untrusted project skills the agent reported at session open, or null.
+ *
+ *  Shape (fork `acp_adapter/server.py::_notify_project_skills`): empty thought chunk with
+ *  `_meta.hermes = {kind:"project_skills", state:"untrusted", root, skillCount, text}`. The agent
+ *  sends it only when the repo actually carries skills AND nobody has decided yet — so a plain
+ *  checkout never produces one, and an unknown kind is still ignored silently (that is what lets
+ *  the two repositories ship independently).
+ */
+function projectSkillsNoticeOf(
+  u: Record<string, unknown>,
+): { text: string; root: string; count: number } | null {
+  if (hermesKindOf(u) !== "project_skills") return null;
+  const payload = hermesPayload(u);
+  const text = typeof payload.text === "string" ? payload.text.trim() : "";
+  if (!text) return null;
+  return {
+    text,
+    root: typeof payload.root === "string" ? payload.root : "",
+    count: typeof payload.skillCount === "number" ? payload.skillCount : 0,
+  };
+}
+
 /** The completion sentence a finished background process produced (#22), or null. */
 function completionTextOf(u: Record<string, unknown>): string | null {
   if (hermesKindOf(u) !== "completion") return null;

package/packages/server/src/index.ts

@@ -450,8 +450,9 @@ function runPrompt(
   text: string,
   attachments: PromptAttachment[] = [],
   interrupt = false,
+  pid?: string,
 ): void {
-  void mgr.prompt(sessionId, text, attachments, { interrupt }).catch((e: unknown) => {
+  void mgr.prompt(sessionId, text, attachments, { interrupt, pid }).catch((e: unknown) => {
     const msg = describeAcpError(e);
     const tail = mgr.stderrTail(sessionId);
     console.error(`[agentus] prompt failed for ${sessionId}: ${msg}${tail ? `\n  agent stderr tail:\n  ${tail}` : ""}`);
@@ -463,7 +464,10 @@ function runPrompt(
     const lost = msg === "turn already running" || msg === IMAGE_UNSUPPORTED;
     emit({ t: "message", message: {
       seq: -1, sessionId, kind: "meta",
-      payload: { text: `turn failed: ${msg}`, ...(lost ? { rejectedPrompt: text } : {}) },
+      // `pid` rides along (issue #26) so the page can pair this refusal with the prompt it is still
+      // waiting to acknowledge: without it the refusal and the ack timeout both put the same sentence
+      // back in line, and the operator sees his message twice.
+      payload: { text: `turn failed: ${msg}`, ...(lost ? { rejectedPrompt: text } : {}), ...(pid ? { pid } : {}) },
       createdAt: Date.now(),
     } });
     // `turn-end` is the frame that says A TURN IS OVER. For the two "nothing left the client" refusals
@@ -1510,7 +1514,7 @@ async function post(path){const r=await fetch(path,{method:'POST'});alert(r.ok?'
         const attachments = Array.isArray(body.attachments) ? (body.attachments as PromptAttachment[]) : [];
         if (!text && !attachments.length) return send(res, 400, { error: "empty prompt" });
         // fire & forget: stream arrives via WS; client watches turn-start/end
-        void runPrompt(id, text, attachments, body.interrupt === true);
+        void runPrompt(id, text, attachments, body.interrupt === true, typeof body.pid === "string" ? body.pid : undefined);
         return send(res, 202, { ok: true });
       }
       if (req.method === "POST" && sub === "/workspace") {
@@ -1795,6 +1799,9 @@ const handleUpgrade = (req: IncomingMessage, socket: Duplex, head: Buffer) => {
 httpServer.on("upgrade", handleUpgrade);
 wss.on("connection", (ws) => {
   const clientId = randomUUID().slice(0, 8);
+  // Any frame — including a pong — proves the peer is alive (see the heartbeat below).
+  (ws as WebSocket & { isAlive?: boolean }).isAlive = true;
+  ws.on("pong", () => { (ws as WebSocket & { isAlive?: boolean }).isAlive = true; });
   clients.set(clientId, { ws, lastSeen: new Map() });
   const sendEvt = (e: ServerEvent) => {
     if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(e));
@@ -1831,7 +1838,7 @@ wss.on("connection", (ws) => {
           break;
         }
         case "prompt":
-          void runPrompt(cmd.sessionId, cmd.text, cmd.attachments ?? [], cmd.interrupt === true);
+          void runPrompt(cmd.sessionId, cmd.text, cmd.attachments ?? [], cmd.interrupt === true, cmd.pid);
           break;
         case "cancel":
           await mgr.cancel(cmd.sessionId);
@@ -1865,6 +1872,35 @@ wss.on("connection", (ws) => {
   ws.on("close", () => clients.delete(clientId));
 });
 
+// ---- liveness: the half-open socket ---------------------------------------------------------
+// A TCP connection that dies without a FIN (Wi-Fi switch, laptop sleep, NAT timeout) stays OPEN in
+// BOTH ends: the page's `send()` succeeds into the void, and this server keeps a client that will
+// never read again. There is no traffic to fail on, so nothing above this line can notice — and the
+// operator's message is written into a socket nobody owns, with no bubble and no error (issue #26,
+// measured live 2026-10-11 with the network cut). Ping/pong is the only detector the protocol gives
+// us: browsers answer `ping` automatically, so a missing pong means the peer is gone.
+//
+// 20s, not 60s: the window between "socket died" and "page knows" is exactly how long a prompt can
+// vanish, and the ack timeout on the client (8s) covers what happens inside one beat. An idle
+// cockpit costs 3 tiny frames a minute.
+const HEARTBEAT_MS = Number(process.env.AGENTUS_WS_HEARTBEAT_MS ?? "") || 20_000;
+const heartbeat = setInterval(() => {
+  for (const [id, client] of clients) {
+    const ws = client.ws as WebSocket & { isAlive?: boolean };
+    if (ws.isAlive === false) {
+      // No pong since the last beat: the peer is not there. `terminate()` (not `close()`) because a
+      // half-open peer never answers the closing handshake either — this is the only way out.
+      ws.terminate();
+      clients.delete(id);
+      continue;
+    }
+    ws.isAlive = false;
+    try { ws.ping(); } catch { /* already gone; the next beat reaps it */ }
+  }
+}, HEARTBEAT_MS);
+heartbeat.unref();
+
+
 // ---- the workspace panel's terminal -----------------------------------------
 // A shell is a stream, so it gets its own socket instead of riding the event bus:
 // one socket = one shell, and closing the socket (or the tab) kills the shell.

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

@@ -924,6 +924,34 @@ export class Store {
     return { ...m, seq };
   }
 
+  /**
+   * 换掉一行已有消息的 payload（seq 与 created_at 不动）。
+   *
+   * 为什么需要：审批卡、项目 skill 卡都**先生成一模一样的行、随后才由操作者做决定**。行必须在
+   * 请求到达那一刻就落库（否则「弹出来过」这件事在刷新后就不存在），而决定要在几秒/几分钟后
+   * 补上。改 seq 会让它在转录里换位置，改 created_at 会让「什么时候问的」变成「什么时候答的」。
+   */
+  updateMessagePayload(seq: number, sessionId: string, payload: unknown): StoredMessage | null {
+    this.#db
+      .prepare("update messages set payload = ? where session_id = ? and seq = ?")
+      .run(JSON.stringify(payload), sessionId, seq);
+    const row = this.#db
+      .prepare("select seq, session_id, kind, payload, tool_call_id, created_at from messages where session_id = ? and seq = ?")
+      .get(sessionId, seq) as
+      | { seq: number; session_id: string; kind: string; payload: string; tool_call_id: string | null; created_at: number }
+      | undefined;
+    if (!row) return null;
+    return {
+      seq: row.seq,
+      sessionId: row.session_id,
+      kind: row.kind as StoredMessage["kind"],
+      payload: JSON.parse(row.payload) as unknown,
+      toolCallId: row.tool_call_id ?? undefined,
+      createdAt: row.created_at,
+    };
+  }
+
+
   /**
    * 一条「状态行」落库（操作者 2026-10-18）：回忆了几条记忆、上下文压缩了、有警告。
    *

package/packages/shared/src/index.ts

@@ -206,7 +206,10 @@ export type ServerEvent =
       durationMs?: number }
   /** per-turn trace: what model/effort/mode this turn is actually running with
    *  (AionUi F-DISPLAY-11 lineage — "why did it behave differently?" ) */
-  | { t: "turn-start"; sessionId: string; trace?: TurnTrace }
+  /** `pid` is the id of the prompt that started this turn, copied from the client's command (issue
+   *  #26): it is the only thing that can prove a particular frame landed. Absent for turns the page
+   *  did not start (a call utterance, the cockpit's cross-session `send`, a resumed transcript). */
+  | { t: "turn-start"; sessionId: string; trace?: TurnTrace; pid?: string }
   /** A one-line status from the AGENT itself (issue #18): `👁️ Hindsight — recalled 8 memories`,
    *  a compaction countdown, a provider wait. Deliberately NOT a transcript row and not persisted —
    *  it describes what the process is doing NOW, so the page shows the latest one beside the running
@@ -407,7 +410,12 @@ export type ClientCommand =
    *  wait for it to actually stop before sending this prompt. Call mode sends every utterance
    *  this way (the operator speaking over the agent IS the interrupt), which is also what
    *  removes the race between an async cancel and the next prompt. */
-  | { t: "prompt"; sessionId: string; text: string; attachments?: PromptAttachment[]; interrupt?: boolean }
+  | { t: "prompt"; sessionId: string; text: string; attachments?: PromptAttachment[]; interrupt?: boolean;
+      /** Client-generated id for THIS prompt, echoed back on the `turn-start` it causes (issue #26).
+       *  Without it a page can only guess whether its frame landed: a socket that dies without a FIN
+       *  stays `OPEN` in JS, so `send()` returns true for a frame nobody received and the operator's
+       *  words vanish with no error. With it, "the server started a turn for prompt X" is a fact. */
+      pid?: string }
   | { t: "cancel"; sessionId: string }
   | { t: "set-mode"; sessionId: string; modeId: string }
   | { t: "set-config"; sessionId: string; configId: string; value: string | number | boolean }
@@ -427,8 +435,12 @@ export interface StoredMessage {
   /** `note` = a 「状态行」 that is not a message: 「recalled 8 memories」 / 「compacting」 / a warning.
    *  Deliberately a transcript row (not a separate table): its position IS the seq — after the
    *  operator's sentence, before the reply — and the page already orders, pages and replays by seq.
-   *  `meta` stays what it was: a line the HOST says (a rejected send), never persisted. */
-  kind: "user" | "agent" | "thought" | "tool" | "plan" | "meta" | "note";
+   *  `meta` stays what it was: a line the HOST says (a rejected send), never persisted.
+   *  `approval` = an approval request as a transcript row (it asks a question, then carries the
+   *  decision), and `project-skills` = the agent reporting that this repo ships skills it is NOT
+   *  loading. Both are DUrable on purpose: a modal that vanishes leaves no record of what was
+   *  asked or what was answered. */
+  kind: "user" | "agent" | "thought" | "tool" | "plan" | "meta" | "note" | "approval" | "project-skills";
   payload: unknown; // raw ACP content/update fragment (kept lossless)
   toolCallId?: string; // set for kind=tool; upsert key
   createdAt: number;