@armadra/agent 0.6.3 → 0.6.5

package/dist/modes/interactive/status-line.js

@@ -2,23 +2,24 @@
  * 速率行（第五波 §1.1，D1、D2）：`ui.statusLine: "full"` 时在状态栏上方多一行。[W5-A]
  *
  * ```text
- * tps: 100 tok/s • 546 tok / 5.5s (avg 100 · ttft 1.4s)                ↑12.3k ↓1.2k · cache 83% ♨ · [-]
+ * codemode on · preset x            tps: 100 tok/s • 546 tok / 5.5s (avg 100 · ttft 1.4s) · ↑12.3k ↓1.2k · cache 83% ♨ · [-]
  * ```
  *
- * - 左区（用户样例）：`tps: <速率>`（流式中是最近 2 s 窗口的瞬时值、前缀 accent；结束后是该请求的平均值；
- *   还没有请求时 `tps: —`）• `<输出 token> tok / <耗时>`（首 token 起算）`(avg <会话均速> · ttft <首 token 延迟>)`；
- *   `•` 走字形表（ASCII `*`）；
- * - 右区：从状态栏迁来的用量类项 `↑ ↓` · cache · rebill · queue · codemode · 预设 · [宿主]，行尾 `[-]`
- *   （折叠提示：Ctrl+G 或 `/statusline compact`）；
+ * - [W7] 左右分区：左 = 状态 / 开关（`codemode on|only`〔网络未隔离追加 `net!`〕· `沙箱` · `preset 名` ·
+ *   `→ 回退模型` · `queue N` · [宿主]），没有开关时左区为空、右区右对齐；右 = 度量：
+ *   `tps: <速率>`（流式中是最近 2 s 窗口的瞬时值、前缀 accent；结束后是该请求的平均值；还没有请求时 `tps: —`）
+ *   • `<输出 token> tok / <耗时>`（首 token 起算）`(avg <会话均速> · ttft <首 token 延迟>)` · `↑ ↓` · cache ·
+ *   rebill，行尾 `[-]`（折叠提示：Ctrl+G 或 `/statusline compact`）；`•` 走字形表（ASCII `*`）；
  * - 数据：`StatusBar.current()` 的 `telemetry` 与用量（同一次 getStats）；流式中 `telemetry_tick` 时刷新；
- * - 丢弃顺序（§1.2，数字大先丢；`tps` 与 `[-]` 永不丢）：tok/耗时 10 → codemode 9 → queue 8 → token 7 →
- *   cache 6 → rebill 5 → 预设 4 → 宿主 3 → avg 2 → ttft 1；数字按最宽形状占位，不随数值抖动；
+ * - 丢弃顺序（数字大先丢；`tps` 与 `[-]` 永不丢）：右区度量先丢——tok/耗时 12 → token 11 → cache 10 →
+ *   rebill 9 → avg 8 → ttft 7，左区开关最后丢——宿主 6 → queue 5 → 预设 4 → 回退 3 → 沙箱 2 → codemode 1；
+ *   数字按最宽形状占位，不随数值抖动；
  * - `compact` 时不占行（render 返回空）。
  * - [W6] 配色（用户参考）：标签、单位、`•`、括号 dim；速率数字 `tool`（紫）；输出量与耗时、avg 数字 accent（蓝）；
- *   ttft 数字 `tool`；右区用量项不变。
+ *   ttft 数字 `tool`；用量项 dim；回退模型 warning。
  */
 import { truncateToWidth } from "../../tui.js";
-import { formatTokens, layoutRow, usageItems, } from "./status-bar.js";
+import { abbreviateModel, formatTokens, layoutRow, usageItems, } from "./status-bar.js";
 /** 速率：< 10 保留一位小数，其余取整。 */
 export function formatRate(tps) {
     return tps < 10 ? tps.toFixed(1) : String(Math.round(tps));
@@ -34,19 +35,21 @@ export function formatSeconds(ms) {
 /** 占位宽度（常见的最宽形状）：`tps: 999 tok/s`、`1.2k tok / 59.9s`、`avg 999`、`ttft 9.9s`。 */
 const RESERVE = { tps: 14, amount: 16, avg: 7, ttft: 9 };
 const PRIORITY = {
-    ttft: 1,
-    avg: 2,
-    host: 3,
+    codemode: 1,
+    sandbox: 2,
+    fallback: 3,
     preset: 4,
-    rebill: 5,
-    cache: 6,
-    tokens: 7,
-    queue: 8,
-    codemode: 9,
-    amount: 10,
+    queue: 5,
+    host: 6,
+    ttft: 7,
+    avg: 8,
+    rebill: 9,
+    cache: 10,
+    tokens: 11,
+    amount: 12,
 };
 export const COLLAPSE_HINT = "[-]";
-/** 用户样例：`tps: 100 tok/s • 546 tok / 5.5s (avg 100 · ttft 1.4s)`；右区用量项仍以 ` · ` 分隔。 */
+/** 用户样例：`tps: 100 tok/s • 546 tok / 5.5s (avg 100 · ttft 1.4s)`；其后的用量项与左区开关以 ` · ` 分隔。 */
 const RATE_STYLE = { groups: { stats: { glue: " · ", open: "(", close: ")" } } };
 export class StatusLine {
     bar;
@@ -57,7 +60,7 @@ export class StatusLine {
         this.source = source;
         this.theme = theme;
     }
-    parts() {
+    parts(width) {
         const theme = this.theme;
         const dim = (text) => theme.fg("dim", text);
         const stats = this.bar.current();
@@ -65,10 +68,10 @@ export class StatusLine {
         const live = telemetry?.live;
         const last = telemetry?.last;
         const parts = [];
-        const left = (text, priority, reserve, extra = {}) => void parts.push({ text, priority, zone: "left", reserve, ...extra });
-        const right = (text, priority) => {
+        const metric = (text, priority, reserve, extra = {}) => void parts.push({ text, priority, zone: "right", reserve, ...extra });
+        const add = (zone, text, priority) => {
             if (text !== undefined)
-                parts.push({ text, priority, zone: "right" });
+                parts.push({ text, priority, zone });
         };
         const blue = (text) => theme.fg("accent", text);
         const purple = (text) => theme.fg("tool", text);
@@ -86,33 +89,38 @@ export class StatusLine {
             }
         }
         const label = live !== undefined ? theme.fg("accent", "tps:") : dim("tps:");
-        left(`${label} ${tps === undefined ? dim("—") : `${purple(formatRate(tps))}${dim(" tok/s")}`}`, undefined, RESERVE.tps);
+        metric(`${label} ${tps === undefined ? dim("—") : `${purple(formatRate(tps))}${dim(" tok/s")}`}`, undefined, RESERVE.tps);
         if (amount !== undefined) {
-            left(amount, PRIORITY.amount, RESERVE.amount, { lead: ` ${theme.glyphs.dot} ` });
+            metric(amount, PRIORITY.amount, RESERVE.amount, { lead: ` ${theme.glyphs.dot} ` });
         }
         const stat = { group: "stats", lead: " " };
         if (telemetry?.avgTps !== undefined) {
-            left(`${dim("avg ")}${blue(formatRate(telemetry.avgTps))}`, PRIORITY.avg, RESERVE.avg, stat);
+            metric(`${dim("avg ")}${blue(formatRate(telemetry.avgTps))}`, PRIORITY.avg, RESERVE.avg, stat);
         }
         if (last?.ttftMs !== undefined) {
-            left(`${dim("ttft ")}${purple(formatSeconds(last.ttftMs))}`, PRIORITY.ttft, RESERVE.ttft, stat);
+            metric(`${dim("ttft ")}${purple(formatSeconds(last.ttftMs))}`, PRIORITY.ttft, RESERVE.ttft, stat);
         }
         const usage = usageItems(stats, this.bar.queued(), this.source, theme);
-        right(usage.tokens, PRIORITY.tokens);
-        right(usage.cache, PRIORITY.cache);
-        right(usage.rebill, PRIORITY.rebill);
-        right(usage.queue, PRIORITY.queue);
-        right(usage.codemode, PRIORITY.codemode);
-        right(usage.sandbox, PRIORITY.codemode);
-        right(usage.preset, PRIORITY.preset);
-        right(usage.host, PRIORITY.host);
-        right(dim(COLLAPSE_HINT), undefined);
+        add("right", usage.tokens, PRIORITY.tokens);
+        add("right", usage.cache, PRIORITY.cache);
+        add("right", usage.rebill, PRIORITY.rebill);
+        add("right", dim(COLLAPSE_HINT), undefined);
+        add("left", usage.codemode, PRIORITY.codemode);
+        add("left", usage.sandbox, PRIORITY.sandbox);
+        add("left", usage.preset, PRIORITY.preset);
+        const fallback = this.source.fallback?.();
+        if (fallback !== undefined) {
+            const arrow = theme.glyphs.ascii ? "-> " : "→ ";
+            add("left", dim(arrow) + theme.fg("warning", abbreviateModel(fallback.to, width)), PRIORITY.fallback);
+        }
+        add("left", usage.queue, PRIORITY.queue);
+        add("left", usage.host, PRIORITY.host);
         return parts;
     }
     render(width) {
         if (this.bar.layout() !== "full")
             return [];
-        return [truncateToWidth(layoutRow(this.parts(), width, this.theme, RATE_STYLE), width)];
+        return [truncateToWidth(layoutRow(this.parts(width), width, this.theme, RATE_STYLE), width)];
     }
     invalidate() { }
 }

package/dist/modes/interactive/status-quota.d.ts

@@ -7,14 +7,15 @@
  * ```
  *
  * - 数据：会话的 `quota_update`（codex flavor 的 `x-codex-primary/secondary-*` 头、`codex.rate_limits` 事件；
- *   SIWC 只有 429）。primary = 5 小时窗口、secondary = 周窗口；窗口长度不是 5 h / 7 d 时标签换成实际时长。
+ *   SIWC 只有 429）。[W7] 标签按窗口时长认（300 分钟 = 5 小时 / Session、10080 = 本周 / Weekly，其它用实际时长），
+ *   缺时长时按槽位推断（primary 5 小时、secondary 本周）；按时长从短到长排；全 0 的窗口不显示。
  * - 只在当前模型走 ChatGPT 订阅（compat `chatgptBackend`）时出现；codex flavor 还没有数据时显示
  *   「配额：首次请求后显示」（第一次请求就会带回配额，先占住行免得行数跳动），SIWC 没有数据时不占行
  *   （只有超限才有配额，占位会一直挂着误导）。
  * - 着色：标签与分隔 dim；百分比按阈值（≥ 70% warning、≥ 90% error，否则 success）；重置时间 `tool`（紫）。
  * - 重置时间是相对时长（`2h 18m`、`6d 5h`），按渲染时刻算；StatusArea 每分钟重画一次。
  */
-import type { QuotaUpdateEvent } from "../../agent/types-w6.js";
+import type { QuotaUpdateEvent, QuotaWindow } from "../../agent/types-w6.js";
 import type { StatusLineMode } from "../../config/types.js";
 import { type Component, type Theme } from "../../tui.js";
 import { type Part } from "./status-bar.js";
@@ -26,6 +27,18 @@ export type QuotaView = {
 export declare const QUOTA_NARROW_WIDTH = 80;
 /** 距重置：`6d 5h` / `2h 18m` / `18m`（已过或不足一分钟 `0m`）；`tight` 去掉空格。 */
 export declare function formatRemaining(ms: number, tight?: boolean): string;
+/**
+ * [W7] 一个窗口显示成什么：按**窗口时长**认（300 = 5 小时、10080 = 本周），不按 primary / secondary 槽位——
+ * 有的套餐 codex 把周窗口放在 primary（0.6.3 因此显示成 `7d:`）。缺时长时按槽位推断（primary 5 小时、
+ * secondary 本周），与另一个窗口撞名时取另一种；时长 ≤ 0 视同缺失（0.6.3 把它渲染成 `0d`）。
+ */
+type WindowKind = "session" | "weekly" | number;
+interface Shown {
+    kind: WindowKind;
+    window: QuotaWindow;
+}
+/** 要显示的窗口，按时长从短到长（5 小时在前、本周在后）。 */
+export declare function shownWindows(quota: QuotaUpdateEvent): Shown[];
 /** compact 行尾的短项 `5h 10% wk 31%`（项内只用空格，不含 ` · `，宿主解析不受影响）。 */
 export declare function compactQuotaItem(quota: QuotaUpdateEvent, theme: Theme): string | undefined;
 /** 配额行各项（宽 / 窄两种格式）；重置时间先丢，主窗口百分比永不丢。 */
@@ -42,3 +55,4 @@ export declare class QuotaLine implements Component {
     render(width: number): string[];
     invalidate(): void;
 }
+export {};

package/dist/modes/interactive/status-quota.js

@@ -7,7 +7,8 @@
  * ```
  *
  * - 数据：会话的 `quota_update`（codex flavor 的 `x-codex-primary/secondary-*` 头、`codex.rate_limits` 事件；
- *   SIWC 只有 429）。primary = 5 小时窗口、secondary = 周窗口；窗口长度不是 5 h / 7 d 时标签换成实际时长。
+ *   SIWC 只有 429）。[W7] 标签按窗口时长认（300 分钟 = 5 小时 / Session、10080 = 本周 / Weekly，其它用实际时长），
+ *   缺时长时按槽位推断（primary 5 小时、secondary 本周）；按时长从短到长排；全 0 的窗口不显示。
  * - 只在当前模型走 ChatGPT 订阅（compat `chatgptBackend`）时出现；codex flavor 还没有数据时显示
  *   「配额：首次请求后显示」（第一次请求就会带回配额，先占住行免得行数跳动），SIWC 没有数据时不占行
  *   （只有超限才有配额，占位会一直挂着误导）。
@@ -15,7 +16,7 @@
  * - 重置时间是相对时长（`2h 18m`、`6d 5h`），按渲染时刻算；StatusArea 每分钟重画一次。
  */
 import { msg } from "../../i18n/index.js";
-import { levelColor, truncateToWidth, visibleWidth, } from "../../tui.js";
+import { levelColor, visibleWidth } from "../../tui.js";
 import { layoutRow } from "./status-bar.js";
 /** 第三行改用短格式的宽度。 */
 export const QUOTA_NARROW_WIDTH = 80;
@@ -41,40 +42,57 @@ function windowSpan(minutes) {
         return `${minutes / 60}h`;
     return `${Math.round(minutes)}m`;
 }
-function labels(w, which) {
-    const m = msg().interactive.statusLine.quota;
-    const minutes = w.windowMinutes;
-    const standard = minutes === undefined || minutes === (which === "primary" ? FIVE_HOURS : WEEK);
-    if (!standard)
-        return { pct: m.window(windowSpan(minutes)), reset: m.windowReset(windowSpan(minutes)) };
-    return which === "primary"
-        ? { pct: m.session, reset: m.reset }
-        : { pct: m.weekly, reset: m.weeklyReset };
+function minutesOf(w) {
+    const m = w.windowMinutes;
+    return m !== undefined && Number.isFinite(m) && m > 0 ? m : undefined;
+}
+function kindOf(minutes) {
+    if (minutes === FIVE_HOURS)
+        return "session";
+    if (minutes === WEEK)
+        return "weekly";
+    return minutes;
 }
-function shortLabel(w, which) {
+const SPAN = { session: FIVE_HOURS, weekly: WEEK };
+function labels(kind) {
     const m = msg().interactive.statusLine.quota;
-    const minutes = w.windowMinutes;
-    if (minutes === FIVE_HOURS || (minutes === undefined && which === "primary"))
-        return m.short5h;
-    if (minutes === WEEK || (minutes === undefined && which === "secondary"))
-        return m.shortWeek;
-    return windowSpan(minutes);
+    if (kind === "session")
+        return { pct: m.session, reset: m.reset, short: m.short5h };
+    if (kind === "weekly")
+        return { pct: m.weekly, reset: m.weeklyReset, short: m.shortWeek };
+    const span = windowSpan(kind);
+    return { pct: m.window(span), reset: m.windowReset(span), short: span };
 }
 function percent(theme, used, decimal) {
     return theme.fg(levelColor(used / 100), decimal ? `${used.toFixed(1)}%` : `${Math.round(used)}%`);
 }
-function windows(quota) {
-    const out = [];
-    if (quota.primary !== undefined)
-        out.push(["primary", quota.primary]);
-    if (quota.secondary !== undefined)
-        out.push(["secondary", quota.secondary]);
-    return out;
+/** 没有任何数据的窗口（0%、无时长、无重置时间）不占位——服务端用全 0 表示「没有这个窗口」。 */
+function hasData(w) {
+    return w.usedPercent !== 0 || minutesOf(w) !== undefined || w.resetsAt !== undefined;
+}
+/** 要显示的窗口，按时长从短到长（5 小时在前、本周在后）。 */
+export function shownWindows(quota) {
+    const slots = ["primary", "secondary"]
+        .map((which) => ({ which, w: quota[which] }))
+        .filter((x) => x.w !== undefined)
+        .filter((x) => hasData(x.w));
+    const known = slots.map((x) => kindOf(minutesOf(x.w)));
+    const out = slots.map((x, i) => {
+        const own = known[i];
+        if (own !== undefined)
+            return { kind: own, window: x.w };
+        const guess = x.which === "primary" ? "session" : "weekly";
+        const taken = known.some((k, j) => j !== i && k === guess);
+        const kind = taken ? (guess === "session" ? "weekly" : "session") : guess;
+        return { kind, window: x.w };
+    });
+    const span = (k) => (typeof k === "number" ? k : SPAN[k]);
+    return out.sort((a, b) => span(a.kind) - span(b.kind));
 }
 /** compact 行尾的短项 `5h 10% wk 31%`（项内只用空格，不含 ` · `，宿主解析不受影响）。 */
 export function compactQuotaItem(quota, theme) {
     const dim = (text) => theme.fg("dim", text);
-    const items = windows(quota).map(([which, w]) => `${dim(shortLabel(w, which))} ${percent(theme, w.usedPercent, false)}`);
+    const items = shownWindows(quota).map(({ kind, window: w }) => `${dim(labels(kind).short)} ${percent(theme, w.usedPercent, false)}`);
     return items.length === 0 ? undefined : items.join(" ");
 }
 /** 配额行各项（宽 / 窄两种格式）；重置时间先丢，主窗口百分比永不丢。 */
@@ -82,14 +100,15 @@ export function quotaParts(quota, width, now, theme) {
     const dim = (text) => theme.fg("dim", text);
     const narrow = width < QUOTA_NARROW_WIDTH;
     const parts = [];
-    windows(quota).forEach(([which, w], i) => {
+    shownWindows(quota).forEach(({ kind, window: w }, i) => {
         const first = i === 0;
-        const group = narrow ? which : undefined;
-        const name = narrow ? `${shortLabel(w, which)} ` : labels(w, which).pct;
+        const group = narrow ? `w${i}` : undefined;
+        const label = labels(kind);
+        const name = narrow ? `${label.short} ` : label.pct;
         parts.push({
             text: dim(name) + percent(theme, w.usedPercent, !narrow),
             priority: first ? undefined : 2,
-            zone: "left",
+            zone: "right",
             ...(group !== undefined ? { group } : {}),
         });
         if (w.resetsAt === undefined)
@@ -98,11 +117,11 @@ export function quotaParts(quota, width, now, theme) {
         parts.push({
             text: narrow
                 ? theme.fg("tool", `${theme.glyphs.retry}${left}`)
-                : dim(labels(w, which).reset) + theme.fg("tool", left),
+                : dim(label.reset) + theme.fg("tool", left),
             priority: first ? 3 : 1,
-            zone: "left",
+            zone: "right",
             // 宽格式按最宽形状占位（`23h 59m`），数值变化不让某项时有时无
-            reserve: narrow ? 0 : visibleWidth(labels(w, which).reset) + 7,
+            reserve: narrow ? 0 : visibleWidth(label.reset) + 7,
             ...(group !== undefined ? { group } : {}),
         });
     });
@@ -123,7 +142,8 @@ export class QuotaLine {
             return [];
         const theme = this.theme;
         if (view === "pending") {
-            return [truncateToWidth(theme.fg("dim", msg().interactive.statusLine.quota.pending), width)];
+            const text = theme.fg("dim", msg().interactive.statusLine.quota.pending);
+            return [layoutRow([{ text, priority: undefined, zone: "right" }], width, theme)];
         }
         const parts = quotaParts(view.quota, width, this.source.now(), theme);
         if (parts.length === 0)

package/dist/modes/interactive/task-background.d.ts

@@ -8,7 +8,7 @@
  * - Esc 中断只连带前台任务：仍在运行的后台任务写进中断提示（`runningBackground`）。
  */
 import type { AgentSession } from "../../agent/types.js";
-import type { Keybindings } from "../../tui.js";
+import type { ActionId, Keybindings } from "../../tui.js";
 /** 栏内 `x` 两次之间的最长间隔。 */
 export declare const STOP_CONFIRM_MS = 1500;
 /** 正在阻塞父回合的任务（前台运行中、或有 `task_ctl wait` 在等）。 */
@@ -20,7 +20,7 @@ export declare function runningBackground(session: AgentSession): string[];
 /** 转后台后的一行提示；没有转任何任务时给「没有可转的」。 */
 export declare function backgroundedText(ids: readonly string[]): string;
 /** `ctrl+b` → `Ctrl+B`（提示行用）；动作没有绑定时 undefined。 */
-export declare function keyLabel(keys: Keybindings, action: "app.tasks.background"): string | undefined;
+export declare function keyLabel(keys: Keybindings, action: ActionId): string | undefined;
 /** 栏内 `x` 的双击确认：第一次 `arm`（提示「再按 x 停止」），间隔内对同一任务再按为 `stop`。 */
 export declare class StopArm {
     private readonly windowMs;

package/dist/modes/rpc/commands.d.ts

@@ -12,6 +12,8 @@
  *   `plan.unattended`；`approve_fresh` 在这里新建会话并以计划全文开新回合。`get_tasks / get_agents`
  *   读 `RpcContext.tasks / agents`（W5-G 的注册表与发现结果；未装配时回空表）。
  * - [W7-B2] `background_task { taskId? }` → `{ backgrounded }`（`session.backgroundTask`，B1）。
+ * - 打断并发送：`prompt / steer` 的 `interrupt: true` → `session.prompt(message, { interrupt })`（中止当前回合、
+ *   立刻以「排队的 steer + 本条」开新回合），应答 `started`。
  */
 import type { AgentInfo } from "../../agents/types.js";
 import type { TaskRegistryView } from "../../tools/types.js";

package/dist/modes/rpc/commands.js

@@ -12,6 +12,8 @@
  *   `plan.unattended`；`approve_fresh` 在这里新建会话并以计划全文开新回合。`get_tasks / get_agents`
  *   读 `RpcContext.tasks / agents`（W5-G 的注册表与发现结果；未装配时回空表）。
  * - [W7-B2] `background_task { taskId? }` → `{ backgrounded }`（`session.backgroundTask`，B1）。
+ * - 打断并发送：`prompt / steer` 的 `interrupt: true` → `session.prompt(message, { interrupt })`（中止当前回合、
+ *   立刻以「排队的 steer + 本条」开新回合），应答 `started`。
  */
 import { formatModelRef } from "../../ai/providers/channels.js";
 import { AgentSessionImpl } from "../../agent/session.js";
@@ -82,6 +84,12 @@ function applyPlanAttendance(ctx) {
     planController(ctx.session())?.setAttendance(ctx.capabilities.has("plans") ? "client" : "unattended");
 }
 /** 开始一次运行：开始 / 入队 / 被处理后即返回，不等运行结束。 */
+/** `prompt / steer` 的 `interrupt`：可选布尔。 */
+function interruptFlag(value) {
+    if (value !== undefined && typeof value !== "boolean")
+        throw new AmaError("invalid_arguments", "interrupt must be a boolean");
+    return value === true;
+}
 async function startRun(ctx, run) {
     const session = ctx.session();
     let settled = false;
@@ -155,8 +163,14 @@ export const handlers = {
     prompt: (p, ctx) => startRun(ctx, () => ctx.session().prompt(p.message, {
         ...(p.images !== undefined ? { images: p.images } : {}),
         ...(p.streamingBehavior !== undefined ? { streamingBehavior: p.streamingBehavior } : {}),
+        ...(interruptFlag(p.interrupt) ? { interrupt: true } : {}),
     })),
-    steer: (p, ctx) => startRun(ctx, () => ctx.session().steer(p.message)),
+    steer: (p, ctx) => startRun(ctx, () => interruptFlag(p.interrupt)
+        ? ctx.session().prompt(p.message, {
+            interrupt: true,
+            ...(p.images !== undefined ? { images: p.images } : {}),
+        })
+        : ctx.session().steer(p.message)),
     follow_up: (p, ctx) => startRun(ctx, () => ctx.session().followUp(p.message)),
     abort: async (_p, ctx) => {
         await ctx.session().abort();

package/dist/rpc.d.ts

@@ -45,14 +45,21 @@ export interface RpcHello {
 /** 无参数命令。 */
 export type NoParams = Record<never, never>;
 export interface RpcCommandMap {
+    /**
+     * `interrupt: true`：运行中中止当前回合（工具按 abort 收尾），立刻以「排队的 steer + 本条」开新回合
+     * （user 消息 origin `interrupt`），应答 `started`；空闲时等同不填。优先于 `streamingBehavior`。
+     */
     prompt: {
         message: string;
         images?: ImageBlock[];
         streamingBehavior?: "steer" | "followUp";
+        interrupt?: boolean;
     };
+    /** `interrupt: true` 同 `prompt`。 */
     steer: {
         message: string;
         images?: ImageBlock[];
+        interrupt?: boolean;
     };
     follow_up: {
         message: string;

package/dist/tools/types.d.ts

@@ -181,6 +181,12 @@ export interface RunnerHandle {
     send(text: string): Promise<void>;
     wait(): Promise<SubagentResult>;
     stop(): Promise<void>;
+    /**
+     * 打断当前回合并立即以 `text` 开下一回合（子 Agent 视图的「打断并发送」）；`wait()` 跟到这一回合结束。
+     * 驱动能中断回合（ACP `session/cancel`、Claude stream-json interrupt、Codex `turn/interrupt`）且正在
+     * 运行时返回 true；否则 false（调用方退回排队）。
+     */
+    interrupt?(text: string): Promise<boolean>;
 }
 /** `ama`（AmaRunner）| `claude` | `codex` | `acp:<program>`（ProcessRunner，W5-E）| 宿主 id。 */
 export interface SubagentRunner {

package/dist/tui/keybindings.d.ts

@@ -36,6 +36,13 @@ export declare const DEFAULT_KEYBINDINGS: {
     readonly "app.exit": readonly ["ctrl+d"];
     readonly "app.message.followUp": readonly ["alt+enter"];
     readonly "app.message.dequeue": readonly ["alt+up"];
+    /**
+     * 运行中打断当前回合并立即发送输入框的文字（连同排队的插话）；`ui.enterWhileRunning: "interrupt"` 时与
+     * Enter 互换（它变成排队）。缺省 `Ctrl+X`：各终端（macOS Terminal、iTerm2、tmux、Windows Terminal）都原样
+     * 送达 0x18，且没有别的绑定；`Ctrl+Enter` 不开 kitty 键盘协议时与 Enter 无法区分，`Ctrl+S` 可能被 XOFF
+     * 流控吃掉，`Alt+Enter` 已是 followUp，`Alt+<字母>` 在 macOS 缺省不送 Meta，`Ctrl+]` 在非美式键盘难按。
+     */
+    readonly "app.message.interrupt": readonly ["ctrl+x"];
     readonly "app.permission.cycle": readonly ["shift+tab", "tab"];
     readonly "app.tools.expand": readonly ["ctrl+o"];
     readonly "app.model.select": readonly ["ctrl+l"];

package/dist/tui/keybindings.js

@@ -39,6 +39,13 @@ export const DEFAULT_KEYBINDINGS = {
     "app.exit": ["ctrl+d"],
     "app.message.followUp": ["alt+enter"],
     "app.message.dequeue": ["alt+up"],
+    /**
+     * 运行中打断当前回合并立即发送输入框的文字（连同排队的插话）；`ui.enterWhileRunning: "interrupt"` 时与
+     * Enter 互换（它变成排队）。缺省 `Ctrl+X`：各终端（macOS Terminal、iTerm2、tmux、Windows Terminal）都原样
+     * 送达 0x18，且没有别的绑定；`Ctrl+Enter` 不开 kitty 键盘协议时与 Enter 无法区分，`Ctrl+S` 可能被 XOFF
+     * 流控吃掉，`Alt+Enter` 已是 followUp，`Alt+<字母>` 在 macOS 缺省不送 Meta，`Ctrl+]` 在非美式键盘难按。
+     */
+    "app.message.interrupt": ["ctrl+x"],
     "app.permission.cycle": ["shift+tab", "tab"],
     "app.tools.expand": ["ctrl+o"],
     "app.model.select": ["ctrl+l"],

package/docs/acp.md

@@ -64,6 +64,9 @@ stdin 关闭后等已开始的运行结束再退出（0）；SIGINT / SIGTERM
 - `session/request_permission` 交给 `onPermission`；没有处理器时回首个 `reject_once`（无人值守）。
 - `cancel(sessionId)` 发 `session/cancel`，并让该会话挂起的权限请求回 `cancelled`（规范要求）。
 - 只接受 Agent 自己给出的 `optionId`。
+- 开会话（`newSession` / `resumeSession` / `loadSession`）的 `mcpServers` 缺省为空数组；宿主可传第三个参数
+  `{ mcpServers }`（如 stdio 的 `{ name, command, args, env: [{ name, value }] }`），原样转发给 Agent。
+  `AcpClient.features.mcpServers === true` 表示支持（旧版没有 `features`）。ama 自己作客户端时仍不传。
 
 `AcpDriver` 在客户端之上实现驱动契约（`AgentDriver`）：续接优先 `session/resume`，其次 `session/load`（回放的历史丢弃），都不支持就新开并提示；按 ama 模式 `session/set_mode`，只读模式找不到对应模式 id 时拒绝启动。
 

package/docs/en/rpc.md

@@ -41,16 +41,18 @@ A command has the shape `{ "id"?: string, "type": <command name>, ...parameters
 
 ### Prompts
 
-| Command       | Parameters                                                                              | `data`                                                          |
-| ------------- | --------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
-| `prompt`      | `message: string`, `images?: ImageBlock[]`, `streamingBehavior?: "steer" \| "followUp"` | `{ disposition: "started" \| "queued" \| "handled" }`           |
-| `steer`       | `message`, `images?`                                                                    | Same as above                                                   |
-| `follow_up`   | `message`, `images?`                                                                    | Same as above                                                   |
-| `abort`       | —                                                                                       | `{}` (answered once idle again; the queue is not cleared)       |
-| `clear_queue` | —                                                                                       | `{ steering: string[], followUp: string[] }` (the cleared text) |
+| Command       | Parameters                                                                                                     | `data`                                                          |
+| ------------- | -------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
+| `prompt`      | `message: string`, `images?: ImageBlock[]`, `streamingBehavior?: "steer" \| "followUp"`, `interrupt?: boolean` | `{ disposition: "started" \| "queued" \| "handled" }`           |
+| `steer`       | `message`, `images?`, `interrupt?: boolean`                                                                    | Same as above                                                   |
+| `follow_up`   | `message`, `images?`                                                                                           | Same as above                                                   |
+| `abort`       | —                                                                                                              | `{}` (answered once idle again; the queue is not cleared)       |
+| `clear_queue` | —                                                                                                              | `{ steering: string[], followUp: string[] }` (the cleared text) |
 
 Prompt commands **do not wait for the run to finish**: they are answered as soon as the session starts running (`before_agent_start` / `agent_start`), or the message is queued or handled (for example a slash command, or a hook block); progress arrives as events. Sending `prompt` while running without `streamingBehavior` fails with `code: "busy"`; with `steer` / `followUp` it is queued. Run failures after the response are reported as `{"type":"notification","level":"error","message":…}`.
 
+**Interrupt and send now**: with `interrupt: true` on `prompt` / `steer` (it takes precedence over `streamingBehavior`), a running session first takes the queued steers, stops the current turn (the model stream is cut, running tools finish as interrupted so every tool call has exactly one `aborted by user` result, and the interrupted assistant message is persisted with `stopReason: "aborted"`), then immediately starts a new turn with "queued steers… + this message" (joined by blank lines) and answers `{ disposition: "started" }`; the new user message has `origin: "interrupt"`. followUp messages stay queued and are delivered after the new turn; background sub-agents are not affected. When idle it is the same as leaving it out. A non-boolean `interrupt` → `invalid_arguments`; running with both the message and the queued steers empty → `invalid_arguments` (nothing is interrupted). Event order: `queue_update` (steers taken) → the old turn's `message_end` (aborted) → `agent_settled` → `agent_start` → the response → the new user `message_end` … (golden record `test/fixtures/rpc/interrupt.out.jsonl`). The new request starts with every message of the interrupted request, so the cache keeps hitting. In the SDK: `session.prompt(text, { interrupt: true })` / `session.steer(text, { interrupt: true })`.
+
 ### State
 
 | Command                   | Parameters | `data`                                                      |