agentus 0.12.3 → 0.13.1

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

@@ -14,7 +14,7 @@ import type {
   RequestPermissionRequest,
   RequestPermissionResponse,
 } from "@agentclientprotocol/sdk";
-import { BACKENDS, buildSpawnEnv, nativePlanSourceOf, type BackendSpec } from "./backends.js";
+import { applyContextWindow, BACKENDS, buildSpawnEnv, nativePlanSourceOf, type BackendSpec } from "./backends.js";
 import { forgetAgentOwner, recordAgentOwner, verifyAgentOwner } from "./agent-owner.js";
 import { thinkingOptionOf, voiceAppliesToPrompt, voiceModeBlock } from "./voice-mode.js";
 import {
@@ -186,6 +186,25 @@ export class SessionUnavailable extends Error {
   }
 }
 
+/** 一条「目标回合结束后回我一声」的登记（#59）。origin 是 send 的发起方会话。 */
+export interface TurnReply {
+  origin: string;
+  originTitle: string | null;
+  at: number;
+  /** The turn this registration is about. `#settleTurnReplies` only settles entries whose turn is
+   *  this one or older, so a second `--interrupt` dispatch cannot be swallowed by the turn it killed. */
+  turnSeq: number | null;
+}
+
+/** A queued "wake this session with a notice" item. Two kinds share the queue but not the rules:
+ *  `background` is the operator's 「后台任务完成唤醒」 noise, `reply` is the receipt another session
+ *  is actively waiting for. */
+interface PendingCompletion {
+  text: string;
+  kind: "background" | "reply";
+  origin?: { sessionId: string; title: string | null };
+}
+
 interface LiveSession {
   info: SessionInfo;
   child?: ReturnType<typeof spawn>;
@@ -271,7 +290,7 @@ interface LiveSession {
    *  dropped: the agent is the intended reader, and a completion lost to bad timing means work the
    *  operator has to notice and redo by hand. Drained one at a time at turn-end — each opens its own
    *  turn, and two at once is a race the agent cannot mediate. */
-  pendingCompletions: string[];
+  pendingCompletions: PendingCompletion[];
 }
 
 type Emitter = (evt: ServerEvent) => void;
@@ -289,6 +308,17 @@ export class SessionManager {
    *  to hibernate. Default ON — this is the CLI/gateway behaviour, and the whole point is that the
    *  agent takes its own result instead of the operator noticing a stale screen. */
   #completionWake: () => boolean = () => true;
+  /** 跨会话 send 的「它跑完回我一声」登记（#59）。
+   *
+   *  内存而已，刻意不落库：这是一次性通知，不是数据 —— 服务端重启后那条回合早就结束了，
+   *  回一条「几分钟前跑完了」既没用又会把调用方凭空叫起来。目标 id → 登记项。
+   *  `origin` 是发起方会话（send 的调用者），投递走的是 #39 那条「唤醒某会话」的链子。 */
+  #turnReplies = new Map<string, Map<string, TurnReply>>();
+  #replySeq = 0;
+  /** The newest turn a session has already finished. A registration that arrives with an older (or
+   *  equal) number is describing a turn that is over: it is answered at once instead of being stored,
+   *  because the settle that should have delivered it has already run. */
+  #lastSettledTurn = new Map<string, number>();
   /** The data directory this server owns, and the id of THIS run. Both come from the instance lock
    *  in index.ts; together they are the only evidence that a recorded pid is an agent OF THIS STORE
    *  from a PREVIOUS run — see `agent-owner.ts` and the 2026-10-22 incident. */
@@ -383,6 +413,48 @@ export class SessionManager {
     return this.#sessions.get(id)?.busy ?? false;
   }
 
+  /** 登记一条「目标回合自然结束后，通知这个发起方」（#59）。返回 id，用于事后撤销
+   *  （投递本身失败、或操作者把它打断成了另一件事）。
+   *
+   *  Returns the registration id; `dropTurnReply` cancels it. */
+  expectTurnReply(target: string, r: { origin: string; originTitle?: string | null; turnSeq?: number | null }): string {
+    const id = `reply-${++this.#replySeq}`;
+    const entry: TurnReply = {
+      origin: r.origin, originTitle: r.originTitle ?? null, at: Date.now(), turnSeq: r.turnSeq ?? null,
+    };
+    const settled = this.#lastSettledTurn.get(target);
+    if (r.turnSeq != null && settled != null && r.turnSeq <= settled) {
+      // That turn is already over (a prompt that threw after it started, a settle that ran before
+      // this bookkeeping landed). Storing it would deliver it one turn late, describing the wrong
+      // turn — so answer now, honestly.
+      // NOT a failure: the turn may have succeeded. It simply cannot be reported by this receipt.
+      void this.#deliverTurnReplies(target, [entry], { note: "这一轮在你登记之前就结束了" });
+      return id;
+    }
+    const rows = this.#turnReplies.get(target) ?? new Map<string, TurnReply>();
+    rows.set(id, entry);
+    this.#turnReplies.set(target, rows);
+    return id;
+  }
+
+  dropTurnReply(target: string, id: string): void {
+    const rows = this.#turnReplies.get(target);
+    if (!rows) return;
+    rows.delete(id);
+    if (!rows.size) this.#turnReplies.delete(target);
+  }
+
+  /** send 本身送不进去（抢话头没抢到、目标进程死了…）：登记项不能就那么悬着，否则调用方
+   *  永远不知道消息根本没落地。把它当成一次「失败回推」投出去。 */
+  failTurnReply(target: string, id: string, why: string): void {
+    const rows = this.#turnReplies.get(target);
+    const entry = rows?.get(id);
+    if (!entry) return;
+    rows!.delete(id);
+    if (!rows!.size) this.#turnReplies.delete(target);
+    void this.#deliverTurnReplies(target, [entry], { failed: why });
+  }
+
   /** Reclaim orphans from a previous server run (AC5): kill recorded pids — but only the ones that are
    *  provably agents of THIS data dir (see `agent-owner.ts`).
    *
@@ -668,6 +740,14 @@ export class SessionManager {
 
   /** Graceful shutdown: SIGTERM every live child before server exit. */
   async shutdown(): Promise<void> {
+    // No time to deliver these properly (we are going down), but the registrations must not outlive
+    // the process as a promise nobody keeps: log one line per waiter so the trace exists.
+    for (const [target, rows] of this.#turnReplies) {
+      for (const r of rows.values()) {
+        console.log(`[agentus] turn reply dropped on shutdown: ${target} -> ${r.origin}`);
+      }
+    }
+    this.#turnReplies.clear();
     const kills = [...this.#sessions.values()].map(async (s) => {
       this.#dropPending(s);
       s.child?.kill("SIGTERM");
@@ -681,11 +761,17 @@ export class SessionManager {
    * row was touched never breaks. argv comes from registry.effectiveArgs — that is where the
    * hermes profile flag (`-p <profile>`) is composed.
    */
-  #spawnShape(id: string): { spec: BackendSpec; args: string[] } | null {
+  #spawnShape(id: string, contextLimit?: number | null): { spec: BackendSpec; args: string[] } | null {
     const row = this.#store.getBackend(id);
-    if (row) return { spec: rowToSpec(row), args: effectiveArgs(row) };
-    const builtin = BACKENDS[id];
-    return builtin ? { spec: builtin, args: builtin.args } : null;
+    const shape = row
+      ? { spec: rowToSpec(row), args: effectiveArgs(row) }
+      : BACKENDS[id] ? { spec: BACKENDS[id], args: [...BACKENDS[id].args] } : null;
+    if (!shape) return null;
+    // The declared window rides argv only where that is the only channel the backend has (qoder) —
+    // see applyContextWindow. Deliberately not passed on create: a brand-new session has nothing
+    // declared yet, and resume is where a declaration first exists.
+    shape.args = applyContextWindow(id, shape.spec, shape.args, contextLimit);
+    return shape;
   }
 
   /**
@@ -784,6 +870,10 @@ export class SessionManager {
       child, busy: false, pendingPermissions: new Map(), alwaysAllow: new Set(),
       approvalSeq: new Map(), skillNoticeSeq: new Map(), stderrBuf: [],
       background: [], pendingCompletions: [],
+      // A rebuilt LiveSession restarts its turn counter at 0, so the "which turn has this session
+      // already finished" watermark no longer describes the same numbering — keeping it would make
+      // every registration of the new run look older than the last settled turn and be answered with
+      // a false 「已经结束了」.
       caps: { fork: false, load: false, image: false }, turnSeq: 0, collectors: new Map(), planReminderPending: true,
       planToken: randomUUID(),
       cockpitToken,
@@ -798,6 +888,7 @@ export class SessionManager {
       replaying: true,
     };
     this.#sessions.set(id, live);
+    this.#lastSettledTurn.delete(id);   // the counter just went back to 0 — see the comment above
     live.info.lastAt = this.#store.lastActivityAt().get(id) ?? live.info.createdAt;
     // the home is recorded with the row: it is the thing a later resume has to be checked against
     this.#store.upsertSession(sessionRow(live.info, plan.home));
@@ -903,7 +994,19 @@ export class SessionManager {
     const row = this.#store.getSession(id);
     if (!row) throw new Error(`unknown session: ${id}`);
     if (!row.acpSessionId) throw new Error(`session ${id} was never handed to an agent`);
-    const shape = this.#spawnShape(row.backend);
+    // The declared window is a DISPLAY number the operator typed; handing it to the agent is a real
+    // decision (Qoder's `--context-window` REPLACES the window it would restore from the resumed
+    // session). Too small silently truncates the history the agent keeps; above the model's real
+    // window every later request fails. So it is clamped to the window remembered for this model,
+    // and the effective value is logged — the panel says "takes effect on the next start", and this
+    // is the line that says what actually took effect.
+    const modelLimit = this.#store.getModelLimit((row.models as { currentModelId?: string | null } | null)?.currentModelId ?? null);
+    const declared = row.contextLimit && row.contextLimit > 0 ? Math.round(row.contextLimit) : null;
+    const effective = declared && modelLimit && modelLimit > 0 ? Math.min(declared, Math.round(modelLimit)) : declared;
+    if (declared && effective !== declared) {
+      console.log(`[agentus] context window for ${id} clamped ${declared} -> ${effective} (model remembers ${modelLimit})`);
+    }
+    const shape = this.#spawnShape(row.backend, effective);
     if (!shape) throw new Error(`unknown backend: ${row.backend}`);
     const { spec, args } = shape;
 
@@ -972,6 +1075,10 @@ export class SessionManager {
       child, busy: false, pendingPermissions: new Map(), alwaysAllow: new Set(),
       approvalSeq: new Map(), skillNoticeSeq: new Map(), stderrBuf: [],
       background: [], pendingCompletions: [],
+      // A rebuilt LiveSession restarts its turn counter at 0, so the "which turn has this session
+      // already finished" watermark no longer describes the same numbering — keeping it would make
+      // every registration of the new run look older than the last settled turn and be answered with
+      // a false 「已经结束了」.
       caps: { fork: false, load: false, image: false }, turnSeq: 0, collectors: new Map(), planReminderPending: true,
       planToken: randomUUID(),
       cockpitToken,
@@ -986,6 +1093,7 @@ export class SessionManager {
       replaying: true,
     };
     this.#sessions.set(id, live);
+    this.#lastSettledTurn.delete(id);
     live.info.lastAt = this.#store.lastActivityAt().get(id) ?? live.info.createdAt;
     this.#store.upsertSession(sessionRow(live.info));
 
@@ -1155,6 +1263,7 @@ export class SessionManager {
     // operator watched their slot flicker into the archive for a second — measured on :8901).
     // Mark the swap BEFORE the signal, so the exit we are causing is not read as a dead agent.
     live.replacing = true;
+    this.#settleTurnReplies(id, live.turnSeq, { failed: "目标会话正在重启", failureKind: "turn" });
     this.#dropPending(live);
     live.busy = false;
     // show the swap honestly: "starting" with no pid, not a pid that is already gone
@@ -1285,6 +1394,13 @@ export class SessionManager {
        * something. Opaque to the server: it comes back unchanged, it is never stored.
        */
       pid?: string;
+      /**
+       * Called the instant this prompt takes the floor, with the turn number it owns — before the
+       * agent is asked, so a caller can bind a one-shot notification to THIS turn. Registering on the
+       * session instead means the notification describes whichever turn ends next: with
+       * `--interrupt` that is the turn this call just killed.
+       */
+      onTurnStarted?: (turnSeq: number) => void;
     } = {},
   ): Promise<void> {
     const s = this.#need(sessionId);
@@ -1349,6 +1465,11 @@ export class SessionManager {
     const settleVoice = this.#applyVoiceMode(s, blocks, { operator: voiceAppliesToPrompt(opts) });
     s.turnSeq += 1;
     s.busy = true;
+    // Read ONCE, here. A `--interrupt` prompt leaves `busy` before this turn ends, so `s.turnSeq` at
+    // settle time can already be the NEXT turn's number — settling "up to" that number would mark a
+    // turn that has only just started as finished (and reject its own registration).
+    const mine = s.turnSeq;
+    try { opts.onTurnStarted?.(mine); } catch { /* a bookkeeping callback must never break a turn */ }
     // The operator has spoken: from here anything the agent says is an ANSWER, not its own history
     // being replayed (see the replay window in #onSessionUpdate).
     s.replaying = false;
@@ -1392,10 +1513,13 @@ export class SessionManager {
       // #touch.
       this.#touch(s);
       this.#emit({ t: "turn-end", sessionId, stopReason: res?.stopReason, durationMs: Date.now() - turnStartedAt });
+      // #59: 谁在等这一轮结束（跨会话 send --reply-on-done）
+      this.#settleTurnReplies(sessionId, mine, { stopReason: res?.stopReason ?? null, durationMs: Date.now() - turnStartedAt });
     } catch (err) {
       this.#finalizePlan(sessionId, "failed");
       this.#touch(s);
       this.#emit({ t: "turn-end", sessionId, error: errMessage(err), durationMs: Date.now() - turnStartedAt });
+      this.#settleTurnReplies(sessionId, mine, { failed: errMessage(err), failureKind: "turn", durationMs: Date.now() - turnStartedAt });
     } finally {
       s.busy = false;
       if (s.info.status === "running") {
@@ -1417,32 +1541,103 @@ export class SessionManager {
    *  with the operator's switch off we say so in the log and drop it (that is the switch's meaning), and
    *  while a turn is running we hold it, because a prompt would otherwise interrupt work the operator
    *  started. */
-  #queueOrWakeCompletion(s: LiveSession, text: string): void {
-    if (!text) return;
-    if (!this.#completionWake()) {
+  #queueOrWakeCompletion(s: LiveSession, item: PendingCompletion): void {
+    if (!item.text) return;
+    // 开关关掉的是「后台任务跑完了把我叫醒」，那是噪音；跨会话派活的回推是调用方正在等的回执，
+    // 一并关掉就是让它在另一头永远等下去（而它已经收到 delivered: true 了）。
+    if (item.kind === "background" && !this.#completionWake()) {
       console.log(`[agentus] background completion dropped for ${s.info.id}: 唤醒关闭`);
       return;
     }
     if (s.busy) {
-      s.pendingCompletions.push(text);
+      s.pendingCompletions.push(item);
       return;
     }
-    void this.#wakeWithCompletion(s, text);
+    void this.#wakeWithCompletion(s, item);
   }
 
-  async #wakeWithCompletion(s: LiveSession, text: string): Promise<void> {
+  async #wakeWithCompletion(s: LiveSession, item: PendingCompletion): Promise<void> {
     try {
-      // `origin` so the page labels the bubble as a background notice instead of presenting it as
-      // something the operator typed — the same mechanism the cockpit's cross-session `send` uses.
-      await this.prompt(s.info.id, text, [], { origin: { sessionId: "background", title: "后台任务完成" } });
+      // `origin` so the page labels the bubble as a notice instead of presenting it as something the
+      // operator typed — the same mechanism the cockpit's cross-session `send` uses. A turn reply
+      // names the session that finished rather than "background", so the receiving agent can tell a
+      // peer's receipt from a log tail.
+      await this.prompt(s.info.id, item.text, [], {
+        origin: item.origin ?? { sessionId: "background", title: "后台任务完成" },
+      });
     } catch (err) {
       // Lost a race for the floor (an operator prompt landed first): keep it for the next turn end
       // instead of throwing away the agent's own result.
-      s.pendingCompletions.unshift(text);
+      s.pendingCompletions.unshift(item);
       console.log(`[agentus] completion held for ${s.info.id}: ${errMessage(err)}`);
     }
   }
 
+  /** 把「目标跑完了」投给发起方（#59）。走的是 #39 同一条链：目标冷着就 resume，忙就挂到
+   *  它下一回合结束时再投 —— 回推是**一条新消息**，agent 因此被叫醒，而不是我们自己伪造一帧。
+   *
+   *  `failed` 存在时说明消息根本没送进目标（而不是目标跑完了）。 */
+  async #deliverTurnReplies(
+    target: string,
+    entries: (TurnReply & { id?: string })[],
+    outcome: { failed?: string; failureKind?: "send" | "turn"; note?: string; durationMs?: number; stopReason?: string | null } = {},
+  ): Promise<void> {
+    if (!entries.length) return;
+    const title = this.#store.getSession(target)?.title ?? target.slice(0, 8);
+    const secs = outcome.durationMs ? Math.round(outcome.durationMs / 1000) : null;
+    for (const e of entries) {
+      const text = outcome.note
+        ? `【完成回推】「${title}」${outcome.note}。结果以 session messages ${target} 为准。`
+        : outcome.failed
+        ? outcome.failureKind === "turn"
+          ? `【完成回推】「${title}」这一轮跑失败了：${outcome.failed}。消息送到了，别重发。`
+          : `【完成回推】给「${title}」的消息没送进去：${outcome.failed}。它这一轮不会跑，别等了。`
+        : outcome.stopReason === "cancelled"
+          ? `【完成回推】「${title}」这一轮被取消了（${secs ?? "?"} 秒）。结果以 session messages 为准。`
+          : `【完成回推】「${title}」这一轮跑完了${secs != null ? `（${secs} 秒）` : ""}。`
+            + `要看内容用 session messages ${target}；这条只是通知，正文不在这里。`;
+      // 自己发给自己的那种派活不回推：那就是一次普通发言，回一条「你跑完了」会变成乒乓。
+      if (e.origin === target) continue;
+      const live = this.#sessions.get(e.origin);
+      if (live) {
+        this.#queueOrWakeCompletion(live, { text, kind: "reply", origin: { sessionId: target, title } });
+        continue;
+      }
+      // 发起方已经冷了：和 `--wake` 同一个动作（起进程），起来以后再投。
+      try {
+        await this.resume(e.origin);
+        const back = this.#sessions.get(e.origin);
+        if (back) this.#queueOrWakeCompletion(back, { text, kind: "reply", origin: { sessionId: target, title } });
+      } catch (err) {
+        console.log(`[agentus] turn reply dropped for ${e.origin}: ${errMessage(err)}`);
+      }
+    }
+  }
+
+  /** 一个回合结束了 —— 有登记就投。只在这里汇总，散落在三处 `busy = false` 的写法会互相漏。 */
+  #settleTurnReplies(
+    target: string,
+    upToTurn: number | null,
+    outcome: { failed?: string; failureKind?: "send" | "turn"; durationMs?: number; stopReason?: string | null },
+  ): void {
+    if (upToTurn !== null) {
+      const before = this.#lastSettledTurn.get(target);
+      if (before === undefined || upToTurn > before) this.#lastSettledTurn.set(target, upToTurn);
+    }
+    const rows = this.#turnReplies.get(target);
+    if (!rows || !rows.size) return;
+    const entries: (TurnReply & { id?: string })[] = [];
+    for (const [id, r] of [...rows.entries()]) {
+      // 只结算「这一回合及更早」的登记。后来的登记属于后面的回合 —— 把它一起吞掉，调用方就再也
+      // 收不到回执（这正是 --interrupt 派活时会发生的事：被取消的那一轮结束时把人家的登记吃掉了）。
+      if (upToTurn !== null && r.turnSeq !== null && r.turnSeq > upToTurn) continue;
+      rows.delete(id);
+      entries.push({ id, ...r });
+    }
+    if (!rows.size) this.#turnReplies.delete(target);
+    void this.#deliverTurnReplies(target, entries, outcome);
+  }
+
   #drainHeldCompletion(s: LiveSession): void {
     if (!s.pendingCompletions.length || s.busy) return;
     const next = s.pendingCompletions.shift();
@@ -1450,9 +1645,13 @@ export class SessionManager {
     setTimeout(() => void this.#wakeWithCompletion(s, next), 0).unref?.();
   }
 
-  async cancel(sessionId: string): Promise<void> {
-    const s = this.#need(sessionId);
-    if (!s.conn || !s.info.acpSessionId) return;
+  /** @returns whether a turn was actually interrupted — `false` for an idle/absent slot, so a caller
+   *  (the cockpit CLI's `session stop`) can tell the operator "nothing was running" instead of
+   *  reporting a stop that never happened. */
+  async cancel(sessionId: string): Promise<boolean> {
+    const s = this.#sessions.get(sessionId);
+    if (!s) return false;
+    if (!s.conn || !s.info.acpSessionId) return false;
     // An idle session must NOT be cancelled. On the agent side this is not a no-op: Hermes' ACP
     // `session/cancel` sets the hard-interrupt flag unconditionally (`request_hard_interrupt`) and
     // clears it only at a turn boundary, so the NEXT turn aborts before it starts — at its
@@ -1463,10 +1662,11 @@ export class SessionManager {
     // barge-in's cancel landed on an idle session.
     if (!s.busy) {
       console.log(`[agentus] cancel ignored for ${sessionId}: no turn is running`);
-      return;
+      return false;
     }
     console.log(`[agentus] cancel sent for ${sessionId}`);
     await s.conn.cancel({ sessionId: s.info.acpSessionId }).catch(() => {});
+    return true;
   }
 
   /**
@@ -1964,6 +2164,10 @@ export class SessionManager {
     // lands and `error` (with `lastError`) when it fails — and a handshake that failed on its own has a
     // better answer than 「closed」, so it keeps it.
     if (live.info.status !== "error") live.info.status = why === "reaped" ? "reaped" : "closed";
+    // Anyone waiting for this session's turn gets an answer: the child is about to be signalled and
+    // #onChildExit will bail out early (the slot is deleted below), so this is the last moment that
+    // can tell a dispatcher "it is not coming" instead of leaving it waiting forever.
+    this.#settleTurnReplies(live.info.id, live.turnSeq, { failed: "目标会话被关闭了", failureKind: "turn" });
     live.info.pid = null;
     live.child?.kill("SIGTERM");
     const row = this.#store.getSession(live.info.id);
@@ -2240,7 +2444,7 @@ export class SessionManager {
     }
     const finishedText = completionTextOf(u);
     if (finishedText) {
-      this.#queueOrWakeCompletion(live, finishedText);
+      this.#queueOrWakeCompletion(live, { text: finishedText, kind: "background" });
       return;
     }
     // Project skills the agent is NOT loading (fork: `_meta.hermes = {kind:"project_skills"}`).
@@ -2407,7 +2611,7 @@ export class SessionManager {
       // is ONE row, not 1259. The client gets the row plus the part that is genuinely new, so a live
       // turn stays a small delta on the wire while the store stays the source of truth.
       if (msg.kind === "agent" || msg.kind === "thought") {
-        const r = this.#store.appendTextChunk({ ...msg, kind: msg.kind });
+        const r = this.#store.appendTextChunk({ ...msg, kind: msg.kind }, live.turnSeq);
         if (r.delta || r.isNew) {
           // A row that did NOT move is not activity. Neither is one that DID move — a long reply arrives
           // as dozens of chunks, and touching per chunk re-sorted the rail on every token (issue #50:
@@ -2501,6 +2705,8 @@ export class SessionManager {
       this.#emit({ t: "background", sessionId: live.info.id, tasks: [] });
     }
     live.pendingCompletions = [];
+    // #59：等这一轮的调用方不能永远等下去 —— agent 死了，那一轮不会有结尾
+    this.#settleTurnReplies(live.info.id, live.turnSeq, { failed: "agent 进程退出了", failureKind: "turn" });
     live.info.status = "error";
     live.info.lastError = `agent process exited (code=${code} sig=${sig})` + stderrTail(live);
     const row = this.#store.getSession(live.info.id);

package/packages/server/src/acp/voice-mode.ts

@@ -6,6 +6,9 @@
 //
 //   · the three-state lifecycle (enter → constraint every turn → exit) as a pure decision, so the
 //     trickiest part — WHICH block is owed on THIS prompt — is testable without an agent;
+//   · the emotion tag (`[emo:x]`): the face on the call screen can only follow the agent if the
+//     agent knows the channel exists. The vocabulary lives in shared/ so the prompt and the parser
+//     can never disagree about which words are real;
 //   · the thinking-depth lookup, because a call is full-duplex and a 20-second first token is
 //     indistinguishable from a hang-up.
 //
@@ -15,6 +18,8 @@
 /** The `_meta` key that marks a block as OURS — never the operator's words. */
 export const VOICE_META_KEY = "agentus/voice-mode";
 
+import { emoTagHint } from "../../../shared/src/index.js";
+
 export type VoiceBoundary = "enter" | "exit";
 
 /** What the store remembers about one session's call state. */
@@ -31,11 +36,12 @@ export const VOICE_ENTER_TEXT = [
   "现在开始语音通话：你接下来的回复会被 TTS 朗读出来，用户是用耳朵听的。",
   "请用口语化的短句回答（几句话以内），不要表格、代码块、列表符号、链接和 Markdown 标记；",
   "需要列举时用「第一/第二」这样的口语说法。数字、专有名词、路径要念得出来。",
+  emoTagHint(),
 ].join("");
 
 /** 通话中每一轮都带：单轮指令会被后续对话冲淡，也会被压缩摘要吃掉。 */
 export const VOICE_STEADY_TEXT =
-  "（仍在语音通话中：继续用口语短句回答，不要表格、代码块、列表符号。）";
+  "（仍在语音通话中：继续用口语短句回答，不要表格、代码块、列表符号。）" + emoTagHint();
 
 /** 退出通话：不只说「结束了」，还要解释刚才那段的性质 —— 否则模型会接着用通话腔回文字提问。 */
 export function voiceExitText(turns: number): string {

package/packages/server/src/cockpit/api.ts

@@ -101,8 +101,10 @@ 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…>", "--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 send", args: ["<id>", "<text…>", "--wake", "--interrupt", "--reply-on-done"], returns: "deliver a message into another session (text after the id, or on stdin). A COLD target answers cold_target unless you pass --wake. A BUSY target answers target_busy unless you pass --interrupt, which cancels the running turn, waits for it to really stop and then starts yours — the answer then carries interrupted:true. Interrupting is never implicit: it takes a turn away from whoever started it. --reply-on-done answers AT ONCE (reply_on_done:true) instead of waiting for the target's turn to finish, and when that turn ends naturally the cockpit drops a 【完成回推】 notice into YOUR session and wakes you — so you can hand out work and stop polling session messages; the notice carries the duration and the target id, NOT the answer body, which you still read with session messages <id>. An interrupted or failed target turn reports that too. Combine with --interrupt to take the floor AND get told when it is done" },
       { 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" },
+      { name: "session create", args: ["<cwd>", "--backend <id>", "--title <text>"], returns: "create a session in <cwd> and answer with its row (id included), so the caller can send into it at once. --backend defaults to the first registered backend; ~ is expanded and a path that is not a directory answers bad_cwd. Gated by the same 驾驶舱互发消息 switch as send — a create costs one agent process, so do it for work you actually need" },
+      { name: "session stop", args: ["<id>", "--close"], returns: "interrupt the turn the target is running (default: the session stays alive and keeps its transcript) — answers stopped:true, or stopped:false when nothing was running. --close stops the agent PROCESS instead (the slot becomes cold, the transcript stays); a cold target answers closed:false. 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`,

package/packages/server/src/index.ts

@@ -822,20 +822,144 @@ const handleRequest = async (req: IncomingMessage, res: ServerResponse) => {
             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.
+        // NOT interrupt by DEFAULT: 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.
+        // #55: the caller may ASK for the floor (`--interrupt`), which reuses prompt()'s existing
+        // cancel → wait-until-really-stopped → new-turn path. The抢话头 is therefore always explicit
+        // and always visible in the command that did it; nothing on this channel interrupts silently.
+        const wantInterrupt = body.interrupt === true;
+        // #59：`replyOnDone` = 「它跑完回我一声」。这是一条**异步派活**：调用方不该被目标回合绑架
+        // （普通 send 今天会一直等到回合结束才返回，几十秒到几十分钟），所以带这个标志时我们
+        // 只等「消息进了目标的回合队列」，然后把回合结束那一刻的通知登记下来，立即回执。
+        // 之后目标回合自然结束 → 服务端往调用方会话里投一条【完成回推】并把它唤醒（#39 的链子）。
+        const wantReply = body.replyOnDone === true;
+        if (wantReply && !caller) {
+          return send(res, 400, {
+            error: COCKPIT_ERRORS.badRequest,
+            message: "reply-on-done 只能由另一个会话发起（要有一个可以回推的 origin）；操作者模式下没人接这条通知",
+          });
+        }
+        // 忙的目标照旧拒收：带 --reply-on-done 不等于可以插队，抢话头仍然只有 --interrupt 一条路。
+        if (wantReply && mgr.isBusy(to) && !wantInterrupt) {
+          return send(res, 409, { error: COCKPIT_ERRORS.targetBusy });
+        }
+        if (wantReply && caller === to) {
+          return send(res, 400, {
+            error: COCKPIT_ERRORS.badRequest,
+            message: "reply-on-done 不能发给自己：那是一次普通发言，回一条「你跑完了」只会变成乒乓",
+          });
+        }
+        // 登记必须绑在**这一轮**上，而不是绑在会话上：先登记再 prompt，被 --interrupt 干掉的那一轮
+        // 结束时会把后来的登记一起吞掉，调用方就永远收不到回执（review 实测的形状）。所以登记在
+        // 「prompt 真的拿到话筒」那一刻发生，并带上它自己那一轮的编号。
+        let turnStartedSeq: number | null = null;
+        let onTurnStarted: ((seq: number) => void) | null = null;
+        const turnStarted = new Promise<void>((resolve) => { onTurnStarted = (seq) => { turnStartedSeq = seq; resolve(); }; });
+        let promptErr: unknown = null;
         try {
           // `origin` is not decoration: without it the target's page shows this as a message the
           // OPERATOR typed. With it the bubble says which session it came from.
-          await mgr.prompt(to, message, [], {
-            interrupt: false,
+          const turn = mgr.prompt(to, message, [], {
+            interrupt: wantInterrupt,
             origin: caller ? { sessionId: caller, title: rows.find((s) => s.id === caller)?.title ?? null } : undefined,
+            ...(wantReply ? { onTurnStarted: (seq: number) => onTurnStarted?.(seq) } : {}),
           });
+          if (wantReply) {
+            // 只等到「回合真的开始了」——那正是这个标志要消灭的那段长等待之外的全部代价。
+            // 回合启动前的失败（没抢到话筒、目标进程死了、空 prompt）必须报失败，不能回 delivered。
+            const started = await Promise.race([
+              turnStarted.then(() => true),
+              turn.then(() => false, (e) => { promptErr = e; return false; }),
+            ]);
+            if (!started) {
+              const why = String((promptErr as Error)?.message ?? promptErr ?? "turn did not start");
+              return send(res, 409, { error: why.includes("turn already running") ? COCKPIT_ERRORS.targetBusy : why });
+            }
+            const replyId = mgr.expectTurnReply(to, {
+              origin: caller!,
+              originTitle: rows.find((s) => s.id === caller)?.title ?? null,
+              turnSeq: turnStartedSeq,
+            });
+            // 回合结束会由 #settleTurnReplies 投递。这里兜的是「回合开过之后 prompt 才抛错」——
+            // 那条路径的 settle 可能早于本次登记（登记是微任务之后才落地的），所以不能靠它：
+            // 明确投一条失败回推，否则调用方等一个永远不会来的回执。
+            void turn.catch((e) => mgr.failTurnReply(to, replyId, String((e as Error)?.message ?? e)));
+            return send(res, 200, {
+              delivered: true, to, code: "delivered", reply_on_done: true,
+              ...(woke ? { delivered_after_wake: true } : {}),
+              ...(wantInterrupt ? { interrupted: true } : {}),
+            });
+          }
+          await turn;
         } catch (e) {
           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", ...(woke ? { delivered_after_wake: true } : {}) });
+        return send(res, 200, {
+          delivered: true, to, code: "delivered",
+          ...(woke ? { delivered_after_wake: true } : {}),
+          ...(wantInterrupt ? { interrupted: true } : {}),
+        });
+      }
+      if (url.pathname === "/api/cockpit/create" && req.method === "POST") {
+        const body = await readJson(req);
+        if (!sendOk) return send(res, 403, { error: COCKPIT_ERRORS.sendsDisabled });
+        const backendRaw = String(body.backend ?? "").trim();
+        // Same resolution as the operator's own "+" (POST /api/sessions): a registry row wins, a
+        // builtin id still resolves. An empty backend means "the one this cockpit would default to",
+        // which is what a caller that does not care should get instead of an error.
+        const beRow = backendRaw ? store.getBackend(backendRaw) : null;
+        const backend = backendRaw
+          ? (beRow || Object.prototype.hasOwnProperty.call(BACKENDS, backendRaw) ? (backendRaw as BackendId) : null)
+          : (store.listBackends()[0]?.id as BackendId | undefined) ?? null;
+        if (!backend) {
+          return send(res, 400, {
+            error: "unknown backend",
+            message: `unknown backend: ${backendRaw}`,
+            backends: store.listBackends().map((b) => b.id),
+          });
+        }
+        let cwd = String(body.cwd ?? "").trim();
+        if (!cwd || cwd === "~") cwd = homedir();
+        else if (cwd.startsWith("~/")) cwd = path.join(homedir(), cwd.slice(2));
+        if (!cwd) return send(res, 400, { error: "bad_request", message: "cwd is required: which directory should the new session work in?" });
+        if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) {
+          return send(res, 400, { error: "bad_cwd", message: `cwd not a directory: ${cwd}` });
+        }
+        try {
+          const info = await mgr.create(backend, cwd, body.title ? String(body.title) : undefined);
+          emit(sessionsEvent());
+          // The same row shape `session show` answers with, so a caller can use the new id at once.
+          return send(res, 201, { schema_version: COCKPIT_SCHEMA_VERSION, session: summarize(info) });
+        } catch (e) {
+          return send(res, 409, { error: "create_failed", message: String((e as Error)?.message ?? e) });
+        }
+      }
+      if (url.pathname === "/api/cockpit/stop" && req.method === "POST") {
+        const body = await readJson(req);
+        const id = String(body.id ?? "");
+        if (!id) return send(res, 400, { error: COCKPIT_ERRORS.badRequest });
+        // Stopping is as costly as starting (it throws away a turn in flight), so it answers to the
+        // same switch. `close` is the only command in this channel that ends a PROCESS; when the
+        // target is already cold there is nothing to end and the answer says so rather than
+        // pretending. Deliberately NOT DELETE /api/sessions/:id: for a cold row that route PURGES the
+        // transcript, and no cross-session caller gets to delete the operator's history.
+        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 (body.close === true) {
+          if (target.cold) return send(res, 200, { schema_version: COCKPIT_SCHEMA_VERSION, id, closed: false, already_cold: true });
+          await mgr.closeSession(id);
+          emit(sessionsEvent());
+          return send(res, 200, { schema_version: COCKPIT_SCHEMA_VERSION, id, closed: true });
+        }
+        const stopped = await mgr.cancel(id);
+        return send(res, 200, {
+          schema_version: COCKPIT_SCHEMA_VERSION,
+          id,
+          stopped,
+          ...(stopped ? {} : { message: "no turn was running — nothing to interrupt" }),
+        });
       }
       if (url.pathname === "/api/cockpit/wake" && req.method === "POST") {
         const body = await readJson(req);