@armadra/agent 0.6.2 → 0.6.4

package/dist/modes/interactive/event-notices.d.ts

@@ -3,7 +3,8 @@
  *
  * - W5-I：`entry_appended` 里 `reason: "image_budget"` 的 `context_edit`（一次降级会连写多条，每条一个消息）
  *   合并成一条「已省略 N 张早期图片以符合请求上限」，N 按占位文本数；
- * - W5-H1：`compaction_end.error` 的「compaction did not shrink」换成中文说明（其余错误原样）。
+ * - W5-H1：`compaction_end.error` 的「compaction did not shrink」换成中文说明（其余错误原样）；
+ * - W7-C：`subagent_background`（超时自动 / 宿主转后台）一行提示。
  */
 import type { SessionEvent } from "../../agent/types.js";
 /** `compaction_end.error` 的显示文本。 */
@@ -30,3 +31,7 @@ export declare function modelFallbackText(event: Extract<SessionEvent, {
 export declare function backgroundJobText(event: Extract<SessionEvent, {
     type: "background_job";
 }>): string;
+/** [W7-C] `subagent_background`：超时自动 / 宿主转后台的一行提示（人按 Ctrl+B 的已有底部提示）。 */
+export declare function subagentBackgroundText(event: Extract<SessionEvent, {
+    type: "subagent_background";
+}>, agent: string): string;

package/dist/modes/interactive/event-notices.js

@@ -3,7 +3,8 @@
  *
  * - W5-I：`entry_appended` 里 `reason: "image_budget"` 的 `context_edit`（一次降级会连写多条，每条一个消息）
  *   合并成一条「已省略 N 张早期图片以符合请求上限」，N 按占位文本数；
- * - W5-H1：`compaction_end.error` 的「compaction did not shrink」换成中文说明（其余错误原样）。
+ * - W5-H1：`compaction_end.error` 的「compaction did not shrink」换成中文说明（其余错误原样）；
+ * - W7-C：`subagent_background`（超时自动 / 宿主转后台）一行提示。
  */
 import { msg } from "../../i18n/index.js";
 import { IMAGE_OMITTED_FOR_BUDGET, IMAGE_OMITTED_TOO_LARGE, } from "../../compaction/image-budget.js";
@@ -79,3 +80,8 @@ export function backgroundJobText(event) {
             return m.backgroundStopped(event.jobId, short);
     }
 }
+/** [W7-C] `subagent_background`：超时自动 / 宿主转后台的一行提示（人按 Ctrl+B 的已有底部提示）。 */
+export function subagentBackgroundText(event, agent) {
+    const m = msg().agents.background;
+    return event.reason === "timeout" ? m.timeout(event.taskId, agent) : m.host(event.taskId, agent);
+}

package/dist/modes/interactive/interactive-mode.d.ts

@@ -16,8 +16,10 @@
  *   切换（只影响本会话）。
  * - 第五波（W5-U，agent-ui.ts）：计划审批框、子 Agent 折叠视图、`/tasks` `/agents` `/paste` 与 Ctrl+V、审批来源
  *   标注与外部 Agent 首次运行的合并确认（approval-merge.ts）、harness 提示。
- * - 启动头按 `ui.quietStartup`（startup-header.ts）：normal 框 + 模型 / 目录 / 模式 / 资源清单（窄屏或
- *   `ui.compact` 去框），header 一行，silent 不输出。
+ * - [W7-C] 审批接线拆到 approval-ui.ts（合并 → 后台任务停靠 → 对话框）；`Ctrl+B` 转后台与 Esc 提示的数据来自
+ *   task-background.ts。
+ * - 启动头按 `ui.quietStartup`（startup-header.ts）：normal「AMA」字符画 + 信息列（启动时点亮扫描一次，
+ *   startup-logo.ts；窄屏 / `ui.logo: off` / `ui.compact` 不画字符画），header 一行，silent 不输出。
  */
 import type { AgentSession } from "../../agent/types.js";
 import type { ModeContext } from "../../cli/deps.js";

package/dist/modes/interactive/interactive-mode.js

@@ -16,13 +16,14 @@
  *   切换（只影响本会话）。
  * - 第五波（W5-U，agent-ui.ts）：计划审批框、子 Agent 折叠视图、`/tasks` `/agents` `/paste` 与 Ctrl+V、审批来源
  *   标注与外部 Agent 首次运行的合并确认（approval-merge.ts）、harness 提示。
- * - 启动头按 `ui.quietStartup`（startup-header.ts）：normal 框 + 模型 / 目录 / 模式 / 资源清单（窄屏或
- *   `ui.compact` 去框），header 一行，silent 不输出。
+ * - [W7-C] 审批接线拆到 approval-ui.ts（合并 → 后台任务停靠 → 对话框）；`Ctrl+B` 转后台与 Esc 提示的数据来自
+ *   task-background.ts。
+ * - 启动头按 `ui.quietStartup`（startup-header.ts）：normal「AMA」字符画 + 信息列（启动时点亮扫描一次，
+ *   startup-logo.ts；窄屏 / `ui.logo: off` / `ui.compact` 不画字符画），header 一行，silent 不输出。
  */
 import { promptImages, sessionModel } from "../image-input.js";
 import { join } from "node:path";
 import { AgentSessionImpl } from "../../agent/session.js";
-import { taskRegistryView } from "../../agent/subagent-registry.js";
 import { currentSession, switchSession } from "../../cli/compose-session.js";
 import { startupInfo, startupScreenLevel, tildePath } from "../../cli/startup-screen.js";
 import { AmaError, isAmaError } from "../../errors.js";
@@ -31,26 +32,28 @@ import { Container, Editor, Loader, Spacer, TUI, Text, createTheme, detectCapabi
 import { BYPASS_MODE, createBypassGate } from "../../permissions/bypass.js";
 import { onTerminationSignals } from "../shared.js";
 import { AgentUi, agentCommandHooks } from "./agent-ui.js";
-import { ApprovalDialogBroker, approvalOutcomeText } from "./approval-dialog.js";
-import { mergingBroker } from "./approval-merge.js";
+import { approvalOverlayHooks, createApprovalUi } from "./approval-ui.js";
 import { ALL_COMMANDS, runInteractiveCommand } from "./commands.js";
 import { memoryPanelFor } from "./memory-panel.js";
 import { InteractiveCompletion } from "./completion.js";
 import { confirmBypass } from "./confirm-dialog.js";
 import { configUiFor } from "./config-ui.js";
 import { createKeyDispatch } from "./key-dispatch.js";
+import { enterModeOf, interruptKeys, interruptSender } from "./interrupt-send.js";
 import { MessageView, exitSummaryLines } from "./message-view.js";
 import { openPicker } from "./pickers.js";
 import { modelPickerFor } from "./model-picker.js";
 import { createRewindFlow } from "./rewind-flow.js";
 import { openTraceView } from "./trace-view.js";
 import { StartupHeader } from "./startup-header.js";
+import { playStartupAnimation } from "./startup-logo.js";
 import { QueueView, RunIndicator } from "./run-indicator.js";
 import { StatusArea, statusLineSlash } from "./status-area.js";
 import { createSessionEventHandler } from "./session-events.js";
 import { SubagentTracker } from "./subagent-view.js";
 import { loadKeys, processTerminal } from "./terminal-setup.js";
 import { ToolTracker } from "./tool-view.js";
+import { backgroundTasks, blockingTasks, keyLabel, runningBackground } from "./task-background.js";
 const HINT_MS = 2500;
 export function runInteractiveMode(runtime, context, options = {}) {
     const terminal = options.terminal ?? processTerminal();
@@ -82,7 +85,9 @@ export function runInteractiveMode(runtime, context, options = {}) {
         spinner: () => loader.frame,
         subagent: (toolCallId) => subagents.forToolCall(toolCallId),
     });
-    const queueView = new QueueView(theme);
+    const enterMode = () => enterModeOf(runtime);
+    const sendKeys = interruptKeys(keys, enterMode);
+    const queueView = new QueueView(theme, sendKeys.now);
     const loaderSlot = new Container();
     const loader = new Loader(() => tui.requestRender(), {
         theme,
@@ -122,6 +127,7 @@ export function runInteractiveMode(runtime, context, options = {}) {
         requestRender: () => tui.requestRender(),
         ...(historyFile !== undefined ? { historyFile } : {}),
         onSubmit: (text) => submit(text, "enter"),
+        onChange: () => indicator.refreshHints(),
     });
     tui.addChild(view);
     tui.addChild(new Spacer());
@@ -131,6 +137,7 @@ export function runInteractiveMode(runtime, context, options = {}) {
     tui.addChild(hint);
     tui.addChild(area.rate);
     tui.addChild(status);
+    tui.addChild(area.quota);
     // ---- 小工具 ---------------------------------------------------------------
     let finished = false;
     let hintTimer;
@@ -154,7 +161,13 @@ export function runInteractiveMode(runtime, context, options = {}) {
         }
         render();
     };
-    const indicator = new RunIndicator({ theme, loader, slot: loaderSlot, tools, render });
+    const backgroundKey = keyLabel(keys, "app.tasks.background");
+    const indicator = new RunIndicator({
+        ...{ theme, loader, slot: loaderSlot, tools, render },
+        ...(backgroundKey !== undefined ? { backgroundKey } : {}),
+        ...(sendKeys.key !== undefined ? { interruptKey: sendKeys.key } : {}),
+    });
+    Object.assign(indicator, { draft: () => !editor.isEmpty(), enterMode });
     const setQueue = (steering, followUp) => {
         status.setQueue(steering.length, followUp.length);
         queueView.setQueue(steering, followUp);
@@ -177,7 +190,7 @@ export function runInteractiveMode(runtime, context, options = {}) {
     const startupLevel = startupScreenLevel(runtime);
     const home = env["HOME"] ?? env["USERPROFILE"];
     const info = startupInfo(runtime, home);
-    const header = (level) => new StartupHeader(info, { theme, level, ...(ui.compact === true ? { compact: true } : {}) });
+    const header = (level) => new StartupHeader(info, { theme, level, logo: ui.logo, compact: ui.compact });
     /** 清空消息区（切换会话、/tree）：只留一行头。 */
     const resetView = () => {
         view.reset();
@@ -354,25 +367,22 @@ export function runInteractiveMode(runtime, context, options = {}) {
         onPasteImage: () => void agentUi.paste(),
         confirmMode,
         submit: (text, via) => submit(text, via),
+        enterWhileRunning: enterMode,
+        interruptSend: interruptSender({
+            session: () => session,
+            takeImages: () => draftImages.splice(0),
+            showHint,
+        }),
         runCommand: (line) => void runCommand(line),
         exit: (code) => exit(code),
         onInterrupted: (empty) => void rewind.afterInterrupt(empty),
         agents: () => agentUi.keys,
+        downGlyph: theme.glyphs.arrowDown,
+        backgroundTasks: () => backgroundTasks(session),
+        runningBackground: () => runningBackground(session),
     }));
     // ---- 晚绑定 ---------------------------------------------------------------
-    const overlayHooks = {
-        showOverlay: (component) => tui.showOverlay(component, { anchor: "bottom" }),
-        onOpen: () => {
-            editor.disableSubmit = true;
-            tools.setAwaiting(true);
-            indicator.setApproval(true);
-        },
-        onClose: () => {
-            editor.disableSubmit = false;
-            tools.setAwaiting(false);
-            indicator.setApproval(false);
-        },
-    };
+    const overlayHooks = approvalOverlayHooks({ tui, editor, tools: () => tools, indicator });
     const agentUi = new AgentUi({
         theme,
         tui,
@@ -395,28 +405,20 @@ export function runInteractiveMode(runtime, context, options = {}) {
         ...(options.clipboard !== undefined ? { clipboard: options.clipboard } : {}),
         area,
     });
-    const taskAgent = (taskId) => taskRegistryView(session.state.sessionId)?.get(taskId)?.agent;
-    const broker = mergingBroker(new ApprovalDialogBroker({
-        theme,
-        keybindings: keys,
-        cwd: session.state.cwd,
-        permissionMode: () => session.state.permissionMode,
-        taskAgent,
-        externalRunner: (agent) => agentUi.merge.externalRunner(agent),
-        ...overlayHooks,
-        report: (request, outcome) => {
-            if (outcome === "deny" || outcome === "cancelled") {
-                const text = approvalOutcomeText(request, outcome, taskAgent);
-                notice(outcome === "deny" ? "info" : "warn", text);
-            }
-        },
-    }), agentUi.merge, (request) => notice("info", msg().interactive.app.followed(approvalOutcomeText(request, "allow", taskAgent))));
+    indicator.agents = () => agentUi.reachable;
+    const { broker, dock } = createApprovalUi({
+        ...{ theme, keys, tui, editor, indicator, agentUi, notice, render },
+        hooks: overlayHooks,
+        session: () => session,
+    });
+    indicator.background = () => blockingTasks(session).length > 0;
     // ---- 启动与退出 -----------------------------------------------------------
     let offSignals = () => undefined;
     function exit(code) {
         if (finished)
             return;
         finished = true;
+        logoAnimation?.finish();
         if (hintTimer !== undefined)
             clearTimeout(hintTimer);
         loader.stop();
@@ -427,6 +429,7 @@ export function runInteractiveMode(runtime, context, options = {}) {
         tui.addChild(view);
         offSignals();
         agentUi.detach();
+        dock.dispose();
         runtime.approvals.setUiBroker(undefined);
         runtime.notifier.set(undefined);
         tui.stop();
@@ -439,8 +442,10 @@ export function runInteractiveMode(runtime, context, options = {}) {
             resolveExit(code);
         });
     }
-    if (startupLevel !== "silent")
-        view.add(header(startupLevel));
+    const startHeader = startupLevel === "silent" ? undefined : header(startupLevel);
+    let logoAnimation;
+    if (startHeader !== undefined)
+        view.add(startHeader);
     for (const warning of startupWarnings)
         view.addNotice("warn", warning);
     replay();
@@ -460,6 +465,8 @@ export function runInteractiveMode(runtime, context, options = {}) {
         agentUi.attach(session);
         offSignals = onTerminationSignals((code) => exit(code));
         tui.setFocus(editor);
+        const gate = { animation: ui.animation, host: info.host !== undefined, env, ...context };
+        logoAnimation = playStartupAnimation(tui, startHeader, theme, gate);
         options.onReady?.({
             tui,
             editor,

package/dist/modes/interactive/interrupt-send.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 打断并立即发送（交互模式）：运行中按 `app.message.interrupt`（缺省 `Ctrl+X`；`ui.enterWhileRunning:
+ * "interrupt"` 时是 Enter）→ `prompt(text, { interrupt: true })`：取走排队的插话、中止当前回合（工具按
+ * abort 收尾），以「插话… + 本条」开新回合（会话里 origin `interrupt`）。不走「中断即撤回」。
+ */
+import type { AgentSession } from "../../agent/types.js";
+import type { ImageBlock } from "../../ai/types.js";
+import type { Runtime } from "../../cli/runtime.js";
+import type { Keybindings } from "../../tui.js";
+import type { EnterMode } from "./run-indicator.js";
+export interface InterruptSendDeps {
+    session(): AgentSession;
+    /** 取走输入框附带的图片（粘贴的剪贴板图片）。 */
+    takeImages(): ImageBlock[];
+    showHint(text: string): void;
+}
+/** 返回 `interruptSend(text)`：文字可为空（只把排队的插话立即送出）；没有可发的内容给一行提示。 */
+export declare function interruptSender(deps: InterruptSendDeps): (text: string) => void;
+/** `ui.enterWhileRunning`（每次按键时读，`/config` 改了立即生效）。 */
+export declare function enterModeOf(runtime: Pick<Runtime, "config">): EnterMode;
+/** 专用键的标签与「立即送出排队插话」的键（interrupt 模式下是 Enter）。 */
+export declare function interruptKeys(keys: Keybindings, mode: () => EnterMode): {
+    key: string | undefined;
+    now(): string | undefined;
+};

package/dist/modes/interactive/interrupt-send.js

@@ -0,0 +1,32 @@
+/**
+ * 打断并立即发送（交互模式）：运行中按 `app.message.interrupt`（缺省 `Ctrl+X`；`ui.enterWhileRunning:
+ * "interrupt"` 时是 Enter）→ `prompt(text, { interrupt: true })`：取走排队的插话、中止当前回合（工具按
+ * abort 收尾），以「插话… + 本条」开新回合（会话里 origin `interrupt`）。不走「中断即撤回」。
+ */
+import { isAmaError } from "../../errors.js";
+import { msg } from "../../i18n/index.js";
+import { keyLabel } from "./task-background.js";
+/** 返回 `interruptSend(text)`：文字可为空（只把排队的插话立即送出）；没有可发的内容给一行提示。 */
+export function interruptSender(deps) {
+    return (text) => {
+        const images = deps.takeImages();
+        deps.showHint(msg().interactive.keys.interruptSent);
+        const options = images.length > 0 ? { interrupt: true, images } : { interrupt: true };
+        void deps
+            .session()
+            .prompt(text, options)
+            .catch((error) => {
+            if (isAmaError(error) && error.code === "invalid_arguments")
+                deps.showHint(msg().interactive.keys.nothingToSend);
+        });
+    };
+}
+/** `ui.enterWhileRunning`（每次按键时读，`/config` 改了立即生效）。 */
+export function enterModeOf(runtime) {
+    return runtime.config.ui?.enterWhileRunning === "interrupt" ? "interrupt" : "queue";
+}
+/** 专用键的标签与「立即送出排队插话」的键（interrupt 模式下是 Enter）。 */
+export function interruptKeys(keys, mode) {
+    const key = keyLabel(keys, "app.message.interrupt");
+    return { key, now: () => (mode() === "interrupt" ? "Enter" : key) };
+}

package/dist/modes/interactive/key-dispatch.d.ts

@@ -10,20 +10,34 @@
  * [RW-C] 空闲时双击 Esc（`app.rewind`，double-esc.ts）：输入框为空打开回滚列表，有字则清空并存进
  * 输入历史；运行中 Esc 仍为中断，中断后交给 `onInterrupted`（中断即撤回）。
  *
- * [W6-A] Agent 栏（agent-ui.ts）：栏聚焦时它先收键（Esc 是「返回」，不中断、不回滚）；输入为空、补全没开时
- * `app.agents.focus`（缺省 `Ctrl+B` / `↓`）先问它要不要进栏，不要就照常交给编辑器（光标左移、历史下一条）。
+ * [W6-A] Agent 栏（agent-ui.ts）：栏聚焦时它先收键（Esc 是「返回」，不中断、不回滚）；补全没开、没在浏览
+ * 历史时 `app.agents.focus`（缺省 `↓`）先问它要不要进栏，不要就照常交给编辑器（下移、历史下一条）。
+ * [W7-A] 落空给一行提示：输入有字（每段草稿一次，光标在末行时）、栏关闭、没有任务。
+ * [W7-C] `app.tasks.background`（缺省 `Ctrl+B`）：有阻塞中的前台任务时全部转后台（不看输入框），底部提示
+ * 「已转后台：t2 …」；没有时落回编辑器（光标左移），不吞键。Esc 中断只连带前台任务，仍在运行的后台任务
+ * 写进中断提示。
+ * [打断并发送] 运行中 Enter 缺省排队（steer）；`app.message.interrupt`（缺省 `Ctrl+X`）= 打断当前回合并立即
+ * 以输入框的文字（连同排队的插话）开新回合（`prompt{interrupt:true}`）。`ui.enterWhileRunning: "interrupt"`
+ * 时两者互换。补全打开、有覆盖层（审批 / 选择器）时不触发；斜杠命令照常当命令；空闲时专用键等同 Enter。
  */
 import type { AgentSession } from "../../agent/types.js";
 import type { PermissionMode } from "../../permissions/types.js";
 import type { Editor, Keybindings } from "../../tui.js";
 import type { StatusBar } from "./status-bar.js";
 import type { ToolTracker } from "./tool-view.js";
+/** [W7-A] 进栏落空提示的停留时间。 */
+export declare const FOCUS_HINT_MS = 3000;
+/**
+ * [W7-A] 进栏键的结果：true 已进栏；false 不管（交给编辑器，不提示）；其余是落空原因——
+ * `busy-input` 输入框有字、`disabled` `ui.agentBar: "off"`（有任务时）、`empty` 没有任务。
+ */
+export type AgentFocusResult = boolean | "busy-input" | "disabled" | "empty";
 /** [W6-A] Agent 栏的按键入口。 */
 export interface AgentKeys {
     /** 栏聚焦时先消费按键；返回 true 已处理。 */
     handleKey(data: string): boolean;
-    /** `app.agents.focus`（输入为空）：进栏返回 true，否则交给编辑器。 */
-    focus(data: string): boolean;
+    /** `app.agents.focus`：输入为空且有任务时进栏返回 true，否则返回落空原因（按键仍交给编辑器）。 */
+    focus(data: string): AgentFocusResult;
 }
 export interface KeyDispatchDeps {
     keys: Keybindings;
@@ -49,7 +63,11 @@ export interface KeyDispatchDeps {
     confirmMode?(mode: PermissionMode): boolean | Promise<boolean>;
     /** Ctrl+V：粘贴剪贴板图片（W5-U）。 */
     onPasteImage?(): void;
-    submit(text: string, via: "followUp"): void;
+    submit(text: string, via: "enter" | "followUp"): void;
+    /** 运行中 Enter 的语义（`ui.enterWhileRunning`，缺省 `queue`）。 */
+    enterWhileRunning?(): "queue" | "interrupt";
+    /** 打断并立即发送（文字可为空：只把排队的插话立即送出）。没有时专用键不处理。 */
+    interruptSend?(text: string): void;
     runCommand(line: string): void;
     exit(code: number): void;
     /** Esc 中断之后（参数：中断后输入框是否为空）。 */
@@ -58,6 +76,12 @@ export interface KeyDispatchDeps {
     doubleEscMs?: number;
     /** [W6-A] Agent 栏（晚绑定）。 */
     agents?(): AgentKeys | undefined;
+    /** [W7-A] 提示里的 `↓` 字形（ASCII 主题 `v`；缺省 `↓`）。 */
+    downGlyph?: string;
+    /** [W7-C] 有阻塞中的前台任务时全部转后台，返回转了的 taskId；没有返回空（按键交给编辑器）。 */
+    backgroundTasks?(): string[];
+    /** [W7-C] 仍在运行的后台任务（Esc 中断的提示里写明不受影响）。 */
+    runningBackground?(): string[];
 }
 /** 返回输入监听器：已处理返回 true，交给编辑器返回 false。 */
 export declare function createKeyDispatch(deps: KeyDispatchDeps): (data: string) => boolean;

package/dist/modes/interactive/key-dispatch.js

@@ -10,20 +10,34 @@
  * [RW-C] 空闲时双击 Esc（`app.rewind`，double-esc.ts）：输入框为空打开回滚列表，有字则清空并存进
  * 输入历史；运行中 Esc 仍为中断，中断后交给 `onInterrupted`（中断即撤回）。
  *
- * [W6-A] Agent 栏（agent-ui.ts）：栏聚焦时它先收键（Esc 是「返回」，不中断、不回滚）；输入为空、补全没开时
- * `app.agents.focus`（缺省 `Ctrl+B` / `↓`）先问它要不要进栏，不要就照常交给编辑器（光标左移、历史下一条）。
+ * [W6-A] Agent 栏（agent-ui.ts）：栏聚焦时它先收键（Esc 是「返回」，不中断、不回滚）；补全没开、没在浏览
+ * 历史时 `app.agents.focus`（缺省 `↓`）先问它要不要进栏，不要就照常交给编辑器（下移、历史下一条）。
+ * [W7-A] 落空给一行提示：输入有字（每段草稿一次，光标在末行时）、栏关闭、没有任务。
+ * [W7-C] `app.tasks.background`（缺省 `Ctrl+B`）：有阻塞中的前台任务时全部转后台（不看输入框），底部提示
+ * 「已转后台：t2 …」；没有时落回编辑器（光标左移），不吞键。Esc 中断只连带前台任务，仍在运行的后台任务
+ * 写进中断提示。
+ * [打断并发送] 运行中 Enter 缺省排队（steer）；`app.message.interrupt`（缺省 `Ctrl+X`）= 打断当前回合并立即
+ * 以输入框的文字（连同排队的插话）开新回合（`prompt{interrupt:true}`）。`ui.enterWhileRunning: "interrupt"`
+ * 时两者互换。补全打开、有覆盖层（审批 / 选择器）时不触发；斜杠命令照常当命令；空闲时专用键等同 Enter。
  */
 import { msg } from "../../i18n/index.js";
 import { ExitCode } from "../../cli/exit-codes.js";
 import { nextCycleMode, permissionModeLabel } from "../../permissions/modes.js";
 import { DOUBLE_ESC_HINT_MS, DoubleEscape } from "./double-esc.js";
+import { backgroundedText } from "./task-background.js";
 import { statusLineText } from "./status-area.js";
 const DOUBLE_CTRL_C_MS = 1500;
+/** [W7-A] 进栏落空提示的停留时间。 */
+export const FOCUS_HINT_MS = 3000;
 /** 返回输入监听器：已处理返回 true，交给编辑器返回 false。 */
 export function createKeyDispatch(deps) {
     const { keys, editor, tools, status } = deps;
     let ctrlCArmedAt = Number.NEGATIVE_INFINITY;
     const esc = new DoubleEscape(deps.doubleEscMs);
+    /** 本段草稿已给过「输入框有字」提示（输入清空后重置）。 */
+    let busyInputHinted = false;
+    /** 底部正显示着进栏落空提示（进栏后撤掉）。 */
+    let focusHintShown = false;
     const doubleEscape = () => {
         switch (esc.press(deps.now(), editor.isEmpty())) {
             case "arm-rewind":
@@ -88,9 +102,75 @@ export function createKeyDispatch(deps) {
         else
             void answer.then(settle);
     };
+    /**
+     * 运行中的「排队 / 打断并发送」：专用键与（`interrupt` 模式下的）Enter。返回 false 交给编辑器
+     * （Enter 照常提交 = 排队；斜杠命令照常执行）。
+     */
+    const sendKeys = (is) => {
+        if (deps.interruptSend === undefined || editor.isCompletionOpen)
+            return false;
+        const viaKey = is("app.message.interrupt");
+        if (!deps.busy()) {
+            if (!viaKey || editor.isEmpty())
+                return false;
+            const text = editor.takeSubmission();
+            if (text !== null)
+                deps.submit(text, "enter");
+            return true;
+        }
+        const interruptMode = deps.enterWhileRunning?.() === "interrupt";
+        if (!viaKey && !(interruptMode && is("tui.editor.submit")))
+            return false;
+        const command = editor.getExpandedText().trimStart().startsWith("/");
+        if (command || viaKey === interruptMode) {
+            // 排队（interrupt 模式下的专用键）或斜杠命令：同 Enter 提交
+            if (!viaKey)
+                return false;
+            const text = editor.takeSubmission();
+            if (text !== null)
+                deps.submit(text, "enter");
+            return true;
+        }
+        deps.interruptSend(editor.takeSubmission() ?? "");
+        return true;
+    };
+    /** 光标在最后一行（`↓` 不再下移，只会到行尾）。 */
+    const atLastLine = () => editor.cursor.line >= editor.getText().split("\n").length - 1;
+    /** `app.agents.focus`：进栏返回 true；落空给提示后返回 false（按键照常交给编辑器）。 */
+    const focusAgents = (agents, data) => {
+        if (editor.isCompletionOpen || editor.isBrowsingHistory)
+            return false;
+        const result = agents.focus(data);
+        if (result === true) {
+            // 进栏了：撤掉之前的落空提示
+            if (focusHintShown)
+                deps.showHint("");
+            focusHintShown = false;
+            return true;
+        }
+        const m = msg().agents;
+        let text;
+        if (result === "busy-input") {
+            if (busyInputHinted || !atLastLine())
+                return false;
+            busyInputHinted = true;
+            text = m.focus.busyInput(deps.downGlyph ?? "↓");
+        }
+        else if (result === "disabled")
+            text = m.focus.disabled;
+        else if (result === "empty")
+            text = m.bar.empty;
+        if (text !== undefined) {
+            deps.showHint(text, FOCUS_HINT_MS);
+            focusHintShown = true;
+        }
+        return false;
+    };
     return (data) => {
         if (deps.inactive())
             return false;
+        if (editor.isEmpty())
+            busyInputHinted = false;
         const is = (action) => keys.matches(data, action);
         if (!is("app.rewind"))
             esc.reset();
@@ -99,12 +179,16 @@ export function createKeyDispatch(deps) {
             esc.reset();
             return true;
         }
-        if (agents !== undefined &&
-            is("app.agents.focus") &&
-            editor.isEmpty() &&
-            !editor.isCompletionOpen &&
-            agents.focus(data))
+        if (agents !== undefined && is("app.agents.focus") && focusAgents(agents, data))
             return true;
+        if (is("app.tasks.background") && deps.backgroundTasks !== undefined) {
+            const moved = deps.backgroundTasks();
+            if (moved.length > 0) {
+                esc.reset();
+                deps.showHint(backgroundedText(moved), FOCUS_HINT_MS);
+                return true;
+            }
+        }
         if (is("app.clear")) {
             if (!editor.isEmpty()) {
                 editor.clear();
@@ -121,10 +205,15 @@ export function createKeyDispatch(deps) {
             return true;
         }
         ctrlCArmedAt = Number.NEGATIVE_INFINITY;
+        if (sendKeys(is))
+            return true;
         if (is("app.interrupt") && !editor.isCompletionOpen && deps.busy()) {
             esc.reset();
             interrupt();
-            deps.showHint(msg().interactive.keys.interrupted);
+            const left = deps.runningBackground?.() ?? [];
+            deps.showHint(left.length > 0
+                ? msg().agents.background.interrupted(left.join(", "))
+                : msg().interactive.keys.interrupted);
             deps.onInterrupted?.(editor.isEmpty());
             return true;
         }

package/dist/modes/interactive/line/line-mode.d.ts

@@ -3,6 +3,7 @@
  *
  * - stdin 是 TTY 且可开 raw：自带单行编辑器（line-editor.ts：历史、括号粘贴折叠），运行中回车
  *   = steer；Ctrl+C 运行中中断、空闲时连按两次退出（130）；空行 Ctrl+D 退出；审批 y / a / N 单键问答。
+ *   运行中 `/interrupt <文本>` = 打断当前回合并立即以它开新回合（排队的插话在前）。
  *   问句之前逐行打印执行前预览（`request.preview`，W3-B9a-2）。
  * - 否则（管道）：逐行读 stdin，每行依次执行（等上一条运行结束）；没有审批 UI，ask → deny。
  *   模型错误在运行结束时只打印一次（重试中只显示 ↻）；有运行最终失败时退出码 1。

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

@@ -3,6 +3,7 @@
  *
  * - stdin 是 TTY 且可开 raw：自带单行编辑器（line-editor.ts：历史、括号粘贴折叠），运行中回车
  *   = steer；Ctrl+C 运行中中断、空闲时连按两次退出（130）；空行 Ctrl+D 退出；审批 y / a / N 单键问答。
+ *   运行中 `/interrupt <文本>` = 打断当前回合并立即以它开新回合（排队的插话在前）。
  *   问句之前逐行打印执行前预览（`request.preview`，W3-B9a-2）。
  * - 否则（管道）：逐行读 stdin，每行依次执行（等上一条运行结束）；没有审批 UI，ask → deny。
  *   模型错误在运行结束时只打印一次（重试中只显示 ↻）；有运行最终失败时退出码 1。
@@ -134,13 +135,14 @@ export async function runLineMode(runtime, context, options = {}) {
             const question = approvalQuestion(request, (taskId) => taskRegistryView(session.state.sessionId)?.get(taskId)?.agent);
             void ed.ask(`\n${preview.join("")}${question}`, "n").then((answer) => {
                 resolve(answer === "y" ? "allow" : answer === "a" ? "allow_session" : "deny");
-                if (!busy)
+                if (running === 0)
                     ed.render();
             });
         }),
     });
     runtime.notifier.set((message, level) => err(`ama: [${level}] ${message}\n`));
-    let busy = false;
+    /** 进行中的提示（`/interrupt` 开的新回合与被它中止的那一轮可能短暂重叠）；> 0 = 运行中。 */
+    let running = 0;
     let lastInterrupt = 0;
     return new Promise((resolve) => {
         let finished = false;
@@ -164,12 +166,27 @@ export async function runLineMode(runtime, context, options = {}) {
             });
         };
         const run = (text) => {
-            busy = true;
+            running++;
             void handle(text).then((outcome) => {
-                busy = false;
+                running--;
                 if (outcome === "exit")
                     finish(ExitCode.Ok);
-                else
+                else if (running === 0)
+                    ed.render();
+            });
+        };
+        /** 运行中 `/interrupt <文本>`：打断当前回合并立即以它（排队的插话在前）开新回合。 */
+        const interruptWith = (text) => {
+            if (text === "")
+                return err(`ama: ${msg().report.command.interruptUsage}\n`);
+            out(`${msg().report.command.interruptSent(text)}\n`);
+            running++;
+            void session
+                .prompt(text, { interrupt: true })
+                .catch((error) => err(`ama: ${errorText(error)}\n`))
+                .finally(() => {
+                printer.endLine();
+                if (--running === 0)
                     ed.render();
             });
         };
@@ -179,7 +196,7 @@ export async function runLineMode(runtime, context, options = {}) {
                 if (action.kind === "eof")
                     return finish(ExitCode.Ok);
                 if (action.kind === "interrupt") {
-                    if (busy) {
+                    if (running > 0) {
                         void session.abort();
                         err(`${msg().interactive.line.interrupted}\n`);
                     }
@@ -193,7 +210,17 @@ export async function runLineMode(runtime, context, options = {}) {
                     }
                     continue;
                 }
-                if (busy) {
+                if (running > 0) {
+                    const forced = /^\/interrupt(?:\s+([\s\S]*))?$/.exec(action.text.trim());
+                    if (forced !== null) {
+                        interruptWith((forced[1] ?? "").trim());
+                        continue;
+                    }
+                    // [W7-C] 运行中 `/tasks bg [id]` 照样是命令（转后台阻塞中的前台任务），不当插话
+                    if (/^\/tasks\s+bg(\s+\S+)?\s*$/.test(action.text.trim())) {
+                        void handle(action.text.trim());
+                        continue;
+                    }
                     if (action.text.trim() !== "") {
                         void session.steer(action.text).catch(() => undefined);
                         out(`${msg().interactive.line.steer(action.text)}\n`);