@armadra/agent 0.6.3 → 0.6.5

package/CHANGELOG.md

@@ -5,6 +5,35 @@ English · [简体中文](CHANGELOG.zh-CN.md)
 > This file is in English starting with 0.6.0. Release notes for 0.1 through 0.5.1 are in Chinese in
 > [CHANGELOG.zh-CN.md](CHANGELOG.zh-CN.md). New entries go into both files.
 
+## 0.6.5 (2026-10-03)
+
+- **`AcpClient` can pass MCP servers when opening a session**: `newSession`, `resumeSession` and `loadSession` take an
+  optional third argument `{ mcpServers }` that is forwarded as-is in `session/new|resume|load` (default still `[]`, the
+  wire is unchanged when it is omitted). `AcpClient.features.mcpServers` lets a host detect support. ama itself still
+  sends none. Docs: docs/acp.md "As a client".
+
+## 0.6.4 (2026-10-03)
+
+- **Interrupt and send now**: while a run is in progress, Enter still queues the message as a steer (delivered at the next
+  delivery point), and the new `Ctrl+X` (key action `app.message.interrupt`) stops the current turn at once (model stream and
+  running tools; every tool call keeps exactly one result, `aborted by user`) and immediately starts a new turn with the
+  input, queued steers joined in front (`origin: "interrupt"`, `↳ interrupt` in the message area); with an empty input it
+  sends the queued steers now. Esc is unchanged. `ui.enterWhileRunning: "queue" | "interrupt"` (default queue, editable in
+  `/config`) swaps Enter and `Ctrl+X`. The running line shows `Enter queue · Ctrl+X interrupt & send` while the input box has
+  text. The sub-agent view supports the same key: an ama sub-agent stops its turn and starts a new one with the message; an
+  external agent is interrupted when its driver can cancel a single turn (ACP, Claude stream-json, Codex) and otherwise the
+  message is queued with a hint. Line mode accepts `/interrupt <text>`; RPC `prompt` / `steer` and the SDK take
+  `interrupt: true`. The new request keeps the interrupted request as its prefix, so the cache keeps hitting. Docs:
+  docs/tui.md, docs/rpc.md.
+- **Status line split into sides; quota labels fixed**: the `full` layout now keeps state and switches on the left and
+  metrics and the model on the right. The rate line's left side holds `codemode on` (with `net!`) · sandbox · preset ·
+  `→ fallback model` · queue count · host status, and its right side `tps … (avg · ttft) · ↑ ↓ · cache · re-billing · [-]`;
+  the status bar keeps the permission mode and the `shift+tab` hint on the left; the quota line is right-aligned. When
+  narrow, right-side metrics drop before left-side switches; the permission mode, `tps` and `[-]` never drop; the
+  single-line `compact` layout keeps its token order. Quota labels follow the window length: a weekly window sent as
+  primary reads `Weekly` instead of `7d:`, and the 5-hour window comes first; the all-zero "no such window" the server
+  sends is no longer rendered as `0d: 0.0%` (filtered both when parsing and when rendering). Docs: docs/tui.md.
+
 ## 0.6.3 (2026-10-03)
 
 - **TUI: `Ctrl+B` moves foreground tasks to the background; background approvals dock in the agent bar**: while the main

package/CHANGELOG.zh-CN.md

@@ -4,6 +4,27 @@
 
 > 从 0.6.0 起 [CHANGELOG.md](CHANGELOG.md) 为英文，本文件保留中文记录（0.1–0.5.1 的完整历史在此）。新条目两份都要加。
 
+## 0.6.5（2026-10-03）
+
+- **`AcpClient` 开会话可传 MCP 服务器**：`newSession`、`resumeSession`、`loadSession` 新增可选的第三个参数
+  `{ mcpServers }`，原样随 `session/new|resume|load` 发出（缺省仍是 `[]`，不传时线路不变）；宿主用
+  `AcpClient.features.mcpServers` 检测是否支持。ama 自己仍不传。文档：docs/acp.md「作为客户端」。
+
+## 0.6.4（2026-10-03）
+
+- **打断并立即发送**：运行中按 Enter 仍是排队插话（等下一个投递点送达），新增 `Ctrl+X`（键位动作 `app.message.interrupt`）立即中止
+  当前回合（模型流与正在跑的工具，每个工具调用仍恰有一个结果 `aborted by user`），并马上以输入框的文字开新回合，已排队的插话拼在
+  前面（会话里 `origin: "interrupt"`，消息区标 `↳ 打断`）；输入为空时把排队的插话立即送出。Esc 语义不变。配置
+  `ui.enterWhileRunning: "queue" | "interrupt"`（缺省 queue，`/config` 可改）互换 Enter 与 `Ctrl+X`。输入框有字时运行提示行显示
+  `Enter 排队 · Ctrl+X 打断并发送`。子 Agent 视图同样可用：ama 子 Agent 中止本轮后立即以这条消息开新一轮；外部 Agent 的驱动能中断
+  单个回合（ACP、Claude stream-json、Codex）时中断后发送，否则退回排队并提示。line 模式认 `/interrupt <文本>`；RPC `prompt` /
+  `steer` 与 SDK 增 `interrupt: true`。新请求以被打断的那次请求为前缀，缓存照常命中。文档：docs/tui.md、docs/rpc.md。
+- **状态栏左右分区与配额标签修正**：`full` 布局改为左列「状态 / 开关」、右列「度量与模型」——速率行左区是 `codemode on`（含
+  `net!`）· 沙箱 · 预设 · `→ 回退模型` · 排队数 · 宿主状态，右区是 `tps … (avg · ttft) · ↑ ↓ · cache · 重计费 · [-]`；状态栏
+  左区仍是权限模式与 `shift+tab` 提示；配额行右对齐。窄屏先丢右区度量、再丢左区开关，权限模式、`tps` 与 `[-]` 不丢；`compact`
+  单行的记号顺序不变。配额标签按窗口时长认：周窗口放在 primary 时显示「本周 / Weekly」而不是 `7d:`，5 小时窗口排在前面；
+  服务端用全 0 表示的空窗口不再渲染成 `0d: 0.0%`（解析与显示两层都过滤）。文档：docs/tui.md。
+
 ## 0.6.3（2026-10-03）
 
 - **TUI：`Ctrl+B` 前台任务转后台，后台任务审批停靠在 Agent 栏**：主回合在等前台子 Agent 任务（或 `task_ctl wait`）时按

package/dist/agent/queue.d.ts

@@ -4,6 +4,7 @@
  * `one-at-a-time`：每个投递点只取一条；`all`：一次取空。abort 不清队列。
  */
 import type { QueueMode } from "./types.js";
+import type { ImageBlock } from "../ai/types.js";
 import type { AgentMessage } from "../session/types.js";
 export declare class PendingMessageQueue {
     private items;
@@ -23,3 +24,11 @@ export declare class PendingMessageQueue {
 }
 /** 队列消息的显示文本（queue_update 事件用）。 */
 export declare function queuedText(message: AgentMessage): string;
+/**
+ * 打断并立即发送的新回合输入：排队的 steer（按入队顺序）在前、本条在后，文字以空行拼接，图片依次保留。
+ * 全部为空时 undefined（不打断）。
+ */
+export declare function mergeForInterrupt(queued: readonly AgentMessage[], text: string, images?: readonly ImageBlock[]): {
+    text: string;
+    images: ImageBlock[];
+} | undefined;

package/dist/agent/queue.js

@@ -53,3 +53,30 @@ export function queuedText(message) {
         return content;
     return content.map((block) => (block.type === "text" ? block.text : "[image]")).join("");
 }
+/**
+ * 打断并立即发送的新回合输入：排队的 steer（按入队顺序）在前、本条在后，文字以空行拼接，图片依次保留。
+ * 全部为空时 undefined（不打断）。
+ */
+export function mergeForInterrupt(queued, text, images = []) {
+    const texts = [];
+    const merged = [];
+    for (const message of queued) {
+        if (message.role !== "user")
+            continue;
+        const { content } = message;
+        if (typeof content === "string")
+            texts.push(content);
+        else {
+            texts.push(content.map((block) => (block.type === "text" ? block.text : "")).join(""));
+            for (const block of content)
+                if (block.type === "image")
+                    merged.push(block);
+        }
+    }
+    texts.push(text);
+    merged.push(...images);
+    const parts = texts.filter((part) => part.trim() !== "");
+    if (parts.length === 0 && merged.length === 0)
+        return undefined;
+    return { text: parts.join("\n\n"), images: merged };
+}

package/dist/agent/session-subagent.d.ts

@@ -54,6 +54,7 @@ export interface ChildSession {
     readonly messages: readonly AgentMessage[];
     prompt(text: string, options?: {
         origin?: MessageOrigin;
+        interrupt?: boolean;
     }): Promise<unknown>;
     /** [W6-A] 视图里直接发的消息（运行中排到回合结束）。 */
     followUp?(text: string, options?: {

package/dist/agent/session-subagent.js

@@ -186,6 +186,8 @@ async function startAmaChild(parent, spec, createChild, run) {
     run.signal.addEventListener("abort", onAbort, { once: true });
     let billed = { cacheRead: 0, prompt: 0, reBilled: 0 };
     let active = false;
+    /** 视图里「打断并发送」开的回合（runOnce 等它们跑完再收尾）。 */
+    const forced = [];
     const runOnce = async (prompt, origin) => {
         const startTurns = turns;
         let error;
@@ -196,6 +198,8 @@ async function startAmaChild(parent, spec, createChild, run) {
             await child.prompt(prompt, origin === undefined ? {} : { origin });
             // [W6-A] 收尾阶段才入队的 followUp（只可能来自视图）留在队列里：接着再跑一轮
             for (;;) {
+                while (forced.length > 0)
+                    await forced.shift();
                 const left = child.clearQueue?.().followUp ?? [];
                 if (left.length === 0 || run.signal.aborted)
                     break;
@@ -245,6 +249,11 @@ async function startAmaChild(parent, spec, createChild, run) {
             }
             if (!active || child.followUp === undefined)
                 throw new AmaError("task_idle", "the sub-agent is not running");
+            if (when === "interrupt") {
+                // 同步登记：被中止的那一轮一结束，runOnce 就接着等这一轮
+                forced.push(child.prompt(text, { origin: "direct", interrupt: true }));
+                return;
+            }
             await child.followUp(text, { origin: "direct" });
         },
         wait: () => current,

package/dist/agent/session.d.ts

@@ -77,6 +77,11 @@ export declare class AgentSessionImpl implements AgentSession, SessionCore {
     private enqueueOrRun;
     steer(text: string, options?: EnqueueOptions): Promise<"queued" | "handled">;
     followUp(text: string, options?: EnqueueOptions): Promise<"queued" | "handled">;
+    /**
+     * 打断并立即发送：取走排队的 steer、中止当前周期（工具按 abort 收尾），以「steer… + 本条」开新回合；
+     * followUp 留在队列。没有可发的内容 → invalid_arguments（不打断）。
+     */
+    private interruptWith;
     abort(): Promise<void>;
     waitForIdle(): Promise<void>;
     /**

package/dist/agent/session.js

@@ -13,7 +13,7 @@ import { AmaError } from "../errors.js";
 import { createSessionClassifier } from "./session-classifier.js";
 import { buildProjection } from "../session/projection.js";
 import { Agent } from "./agent.js";
-import { queuedText } from "./queue.js";
+import { mergeForInterrupt, queuedText } from "./queue.js";
 import { resolveRetrySettings } from "./retry.js";
 import { SessionCacheController, resolveCacheSettings } from "./session-cache.js";
 import { CompactionController } from "./session-compaction.js";
@@ -278,6 +278,8 @@ export class AgentSessionImpl {
     // -------------------------------------------------------------------------
     async prompt(text, options = {}) {
         this.assertUsable();
+        if (options.interrupt === true && this.cycle !== undefined)
+            return this.interruptWith(text, options.images, options.origin);
         if (this.cycle !== undefined) {
             const behavior = options.streamingBehavior;
             if (behavior === undefined) {
@@ -299,7 +301,9 @@ export class AgentSessionImpl {
     }
     async enqueueOrRun(text, queue, options) {
         this.assertUsable();
-        const origin = normalizeOrigin(options.origin ?? queue);
+        if (options.interrupt === true && this.cycle !== undefined)
+            return this.interruptWith(text, undefined, options.origin).then(() => "handled");
+        const origin = normalizeOrigin(options.origin ?? (options.interrupt === true ? "user" : queue));
         if (this.cycle === undefined) {
             await this.startCycle((signal) => runPrompt(this.runDeps(), text, undefined, origin, signal));
             return "handled";
@@ -313,6 +317,21 @@ export class AgentSessionImpl {
     followUp(text, options = {}) {
         return this.enqueueOrRun(text, "followUp", options);
     }
+    /**
+     * 打断并立即发送：取走排队的 steer、中止当前周期（工具按 abort 收尾），以「steer… + 本条」开新回合；
+     * followUp 留在队列。没有可发的内容 → invalid_arguments（不打断）。
+     */
+    async interruptWith(text, images, origin) {
+        const merged = mergeForInterrupt(this.agent.steeringQueue.snapshot(), text, images);
+        if (merged === undefined)
+            throw new AmaError("invalid_arguments", "nothing to send");
+        this.agent.steeringQueue.clear();
+        this.emitQueue();
+        while (this.cycle !== undefined)
+            await this.abort();
+        const kind = normalizeOrigin(origin ?? "interrupt");
+        return this.startCycle((s) => runPrompt(this.runDeps(), merged.text, merged.images, kind, s));
+    }
     async abort() {
         const cycle = this.cycle;
         if (cycle === undefined)

package/dist/agent/subagent-direct.d.ts

@@ -7,14 +7,17 @@
  *   外部 Agent 运行中 / 还在排队 → 等本次运行结束后续聊（`queued`）；已结束 → 同 `task_ctl send` 的后台续聊
  *   （`resumed`，完成后父会话照常收 `<task-notification>`）。子会话 user 消息记 `origin: "direct"`；
  * - `drainDirect`：运行结束时把排着的消息合成一条续聊；任务被停止时丢弃（停止的一方不想它再跑）。
+ * - 打断并发送（`interrupt`）：ama 运行中 → 子会话 `prompt{interrupt}`（中止本轮、立即开新回合，`interrupted`）；
+ *   外部 Agent 运行中且驱动能中断回合 → 连同排着的消息一起 `handle.interrupt`（`interrupted`）；驱动不能中断
+ *   或任务还在并发池排队 → 照常排到运行结束（`queuedNoInterrupt`，视图提示）；已结束 → 同上的后台续聊。
  */
 import type { TaskLive, TaskRecord } from "../agents/task-record.js";
 import type { SubagentRequest, SubagentResult } from "../tools/types.js";
-export type DirectReply = "steered" | "queued" | "resumed";
+export type DirectReply = "steered" | "queued" | "resumed" | "interrupted" | "queuedNoInterrupt";
 export interface DirectHost {
     spawnSubagent?(request: SubagentRequest): Promise<SubagentResult>;
     log(level: "debug" | "info" | "warn" | "error", message: string): void;
 }
 export declare function liveOf(record: TaskRecord): TaskLive;
-export declare function directMessage(record: TaskRecord, text: string, host: DirectHost): Promise<DirectReply>;
+export declare function directMessage(record: TaskRecord, text: string, host: DirectHost, interrupt?: boolean): Promise<DirectReply>;
 export declare function drainDirect(record: TaskRecord, host: DirectHost): void;

package/dist/agent/subagent-direct.js

@@ -7,6 +7,9 @@
  *   外部 Agent 运行中 / 还在排队 → 等本次运行结束后续聊（`queued`）；已结束 → 同 `task_ctl send` 的后台续聊
  *   （`resumed`，完成后父会话照常收 `<task-notification>`）。子会话 user 消息记 `origin: "direct"`；
  * - `drainDirect`：运行结束时把排着的消息合成一条续聊；任务被停止时丢弃（停止的一方不想它再跑）。
+ * - 打断并发送（`interrupt`）：ama 运行中 → 子会话 `prompt{interrupt}`（中止本轮、立即开新回合，`interrupted`）；
+ *   外部 Agent 运行中且驱动能中断回合 → 连同排着的消息一起 `handle.interrupt`（`interrupted`）；驱动不能中断
+ *   或任务还在并发池排队 → 照常排到运行结束（`queuedNoInterrupt`，视图提示）；已结束 → 同上的后台续聊。
  */
 import { AmaError } from "../errors.js";
 export function liveOf(record) {
@@ -25,11 +28,17 @@ export function liveOf(record) {
         live.entries = () => entries.call(handle);
     return live;
 }
-export async function directMessage(record, text, host) {
+export async function directMessage(record, text, host, interrupt = false) {
     if (text.trim() === "")
         throw new AmaError("invalid_arguments", "empty message");
     if (record.running !== undefined) {
         const handle = record.handle;
+        if (interrupt && record.queued !== true && (await interruptRun(record, text)))
+            return "interrupted";
+        if (interrupt) {
+            (record.direct ??= []).push(text);
+            return "queuedNoInterrupt";
+        }
         if (handle?.message !== undefined && record.queued !== true) {
             try {
                 await handle.message(text, "followUp");
@@ -47,6 +56,30 @@ export async function directMessage(record, text, host) {
     await resumeDirect(record, text, host);
     return "resumed";
 }
+/** 打断运行中的任务并立即发送；做不到返回 false（不改动排队）。 */
+async function interruptRun(record, text) {
+    const handle = record.handle;
+    if (handle?.message !== undefined) {
+        try {
+            await handle.message(text, "interrupt");
+            return true;
+        }
+        catch (error) {
+            if (error instanceof AmaError && error.code === "task_idle")
+                return false;
+            throw error;
+        }
+    }
+    if (handle?.interrupt === undefined)
+        return false;
+    // 外部 Agent：排着的消息（运行中在视图里发的）在前，一起作为新回合
+    const queued = record.direct ?? [];
+    const merged = [...queued, text].join("\n\n");
+    if (!(await handle.interrupt(merged)))
+        return false;
+    queued.splice(0);
+    return true;
+}
 async function resumeDirect(record, text, host) {
     const spawn = host.spawnSubagent;
     if (spawn === undefined)

package/dist/agent/subagent-registry.d.ts

@@ -22,6 +22,7 @@ import { type TaskControl } from "../agents/task-control.js";
 import type { AgentDefinition, AgentInfo } from "../agents/types.js";
 import type { SessionCore } from "./session-core.js";
 import type { SessionTaskStats } from "./types.js";
+import { type DirectReply } from "./subagent-direct.js";
 import { type BackgroundReason } from "./subagent-background.js";
 export declare const DEFAULT_SUBAGENT_CONCURRENCY = 4;
 export declare const DEFAULT_MAX_PENDING = 16;
@@ -95,7 +96,7 @@ export declare class SubagentRegistry implements TaskControl {
     /** [W6-A] 子 Agent 视图读的实时数据；未知任务 undefined。 */
     live(taskId: string): TaskLive | undefined;
     /** [W6-A] 人在子 Agent 视图里发的消息（subagent-direct.ts）。 */
-    message(taskId: string, text: string): Promise<"steered" | "queued" | "resumed">;
+    message(taskId: string, text: string, interrupt?: boolean): Promise<DirectReply>;
     stop(taskId: string): Promise<SubagentResult | undefined>;
     run(request: SubagentRequest, ama: AmaRunnerFactory): Promise<SubagentResult>;
     private continueTask;

package/dist/agent/subagent-registry.js

@@ -148,11 +148,11 @@ export class SubagentRegistry {
         return record === undefined ? undefined : liveOf(record);
     }
     /** [W6-A] 人在子 Agent 视图里发的消息（subagent-direct.ts）。 */
-    async message(taskId, text) {
+    async message(taskId, text, interrupt = false) {
         const record = this.tasks.get(taskId);
         if (record === undefined)
             throw new AmaError("task_not_found", `unknown task ${taskId}`);
-        return directMessage(record, text, this.host);
+        return directMessage(record, text, this.host, interrupt);
     }
     async stop(taskId) {
         const record = this.tasks.get(taskId);

package/dist/agent/types.d.ts

@@ -303,11 +303,18 @@ export interface PromptOptions {
     streamingBehavior?: "steer" | "followUp";
     /** 落盘到 user 消息的 origin（宿主注入为 "host"）；缺省：空闲时不填，入队时为 streamingBehavior。 */
     origin?: MessageOrigin;
+    /**
+     * 打断并立即发送：运行中先取走排队的 steer、中止当前回合（工具按 abort 收尾），再以「steer… + 本条」
+     * 开新回合（origin 缺省 `"interrupt"`）；空闲时等同不填。优先于 `streamingBehavior`。
+     */
+    interrupt?: boolean;
 }
 /** steer / followUp 的可选项。 */
 export interface EnqueueOptions {
     /** 缺省为 "steer" / "followUp"；`"user"` 表示普通用户输入（不写 origin）。 */
     origin?: MessageOrigin;
+    /** 打断并立即发送（同 `PromptOptions.interrupt`；运行中 origin 缺省 `"interrupt"`）。 */
+    interrupt?: boolean;
 }
 export interface SessionState {
     isStreaming: boolean;

package/dist/agents/task-record.d.ts

@@ -67,10 +67,10 @@ export type TaskHandle = RunnerHandle & {
     recent?(): readonly ExternalDisplayEvent[];
     /**
      * [W6-A] 人在子 Agent 视图里直接发的消息（子会话 user 消息 `origin: "direct"`）：`followUp` = 本轮运行中
-     * 排到回合结束（不在运行中抛 `task_idle`，由注册表排队到运行结束后续聊）；`send` = 空闲时开新一轮（同 `send`）。
-     * ama 子会话提供。
+     * 排到回合结束（不在运行中抛 `task_idle`，由注册表排队到运行结束后续聊）；`send` = 空闲时开新一轮（同 `send`）；
+     * `interrupt` = 打断子会话当前回合并立即以它开新回合（不在运行中同样抛 `task_idle`）。ama 子会话提供。
      */
-    message?(text: string, when: "followUp" | "send"): Promise<void>;
+    message?(text: string, when: "followUp" | "send" | "interrupt"): Promise<void>;
 };
 /** [W6-A] 外部 Agent 环形缓冲的上限（docs/wave6-plan.md D2）。 */
 export declare const RING_MAX_EVENTS = 2000;

package/dist/ai/apis/chatgpt-rate-limits.js

@@ -20,18 +20,23 @@ function obj(value) {
         ? value
         : undefined;
 }
+/**
+ * 一个窗口；时长 ≤ 0 视同缺失。[W7] 用量 0、无时长、无重置时间的窗口是服务端的「没有这个窗口」（套餐只有一个
+ * 窗口时另一个槽位送全 0），返回 undefined——0.6.3 把它当成窗口渲染出 `0d: 0.0%`。
+ */
 function window(used, minutes, resetSeconds) {
     const usedPercent = num(used);
     if (usedPercent === undefined)
         return undefined;
     const out = { usedPercent: Math.max(0, Math.min(100, usedPercent)) };
     const m = num(minutes);
-    if (m !== undefined)
+    if (m !== undefined && m > 0)
         out.windowMinutes = m;
     const reset = num(resetSeconds);
     if (reset !== undefined && reset > 0)
         out.resetsAt = reset * 1000;
-    return out;
+    const empty = out.usedPercent === 0 && out.windowMinutes === undefined && out.resetsAt === undefined;
+    return empty ? undefined : out;
 }
 function snapshot(primary, secondary, plan) {
     const out = {};

package/dist/ai/types.d.ts

@@ -136,7 +136,8 @@ export interface SystemMessage {
     toolsRemoved?: string[];
     timestamp: number;
 }
-export type KnownMessageOrigin = "steer" | "followUp" | "host";
+/** `interrupt`：打断当前回合并立即发送（`prompt / steer` 的 `interrupt: true`）开的新回合。 */
+export type KnownMessageOrigin = "steer" | "followUp" | "host" | "interrupt";
 export type MessageOrigin = KnownMessageOrigin | (string & {});
 export interface UserMessage {
     role: "user";