@armadra/agent 0.6.2 → 0.6.3

package/dist/bundle/ama.cjs

@@ -41,7 +41,7 @@ var AMA_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    AMA_VERSION = true ? "0.6.2" : readPackageVersion();
+    AMA_VERSION = true ? "0.6.3" : readPackageVersion();
   }
 });
 
@@ -117,7 +117,7 @@ function agentEntry(agents, agentId) {
   const entry = agents[agentId];
   return typeof entry === "object" && !Array.isArray(entry) ? entry : void 0;
 }
-var STATUS_LINE_MODES, IMAGE_RESIZE_MODES, PLAN_BASH_MODES_STRICT_FIRST, PLAN_UNATTENDED_MODES, AGENTS_RESERVED_KEYS, MODELS_ENABLED_REF;
+var STATUS_LINE_MODES, IMAGE_RESIZE_MODES, PLAN_BASH_MODES_STRICT_FIRST, PLAN_UNATTENDED_MODES, AGENTS_RESERVED_KEYS, SUBAGENT_BACKGROUND_MODES, MODELS_ENABLED_REF;
 var init_types_w5 = __esm({
   "src/config/types-w5.ts"() {
     "use strict";
@@ -126,6 +126,7 @@ var init_types_w5 = __esm({
     PLAN_BASH_MODES_STRICT_FIRST = ["deny", "readonly", "ask"];
     PLAN_UNATTENDED_MODES = ["stop", "approve"];
     AGENTS_RESERVED_KEYS = ["maxConcurrent", "sessionBudgetUsd", "dirs"];
+    SUBAGENT_BACKGROUND_MODES = ["auto", "always", "never"];
     MODELS_ENABLED_REF = /^[^/\s]+\/\S+$/;
   }
 });
@@ -898,6 +899,9 @@ Wrote ${path}: ${provider} +${plural(added, "model")}${kept > 0 ? `, ${kept} alr
         found: (provider, count2, url) => `${provider}: found ${plural(count2, "model")} (${url})
 `,
         unmatched: "  models.dev: no match",
+        fromBackend: " (backend)",
+        noBackendWindow: (ids) => `The backend did not report a context window for ${ids}; using models.dev (128k when unmatched)
+`,
         image: " · image",
         reasoning: " · reasoning",
         noTools: " · no tool calling",
@@ -971,6 +975,9 @@ Probing protocols: ${plural(count2, "model")} (${order}), at most ${plural(reque
         found: (provider, count2, url) => `${provider}：发现 ${count2} 个模型（${url}）
 `,
         unmatched: "  models.dev 未匹配",
+        fromBackend: "（后端）",
+        noBackendWindow: (ids) => `后端没有给出 ${ids} 的上下文窗口，改用 models.dev 的值（未匹配时按 128k）
+`,
         image: " · 图片",
         reasoning: " · 思考",
         noTools: " · 不支持工具调用",
@@ -1274,7 +1281,7 @@ Estimated cost: ${estimate} (2 × ${tokens} tokens × catalog price)
         needsYes: "ama: cache-probe sends two billed requests; add --yes in non-interactive environments\n",
         requestFailed: (n, error2) => `ama: request ${n} failed: ${error2}
 `,
-        share: (percent2) => ` (the second request read ${percent2}% of the prefix)`,
+        share: (percent3) => ` (the second request read ${percent3}% of the prefix)`,
         usageFields: (api, fields) => `usage fields (read for ${api}): ${fields.join(" / ")}`,
         verdict: (verdict, share) => `Verdict: ${verdict}${share}`,
         advice: (advice) => `Advice: ${advice}`
@@ -1526,7 +1533,7 @@ Estimated cost: ${estimate} (2 × ${tokens} tokens × catalog price)
         needsYes: "ama: cache-probe 会发两次计费请求，非交互环境需加 --yes\n",
         requestFailed: (n, error2) => `ama: 第 ${n} 次请求失败：${error2}
 `,
-        share: (percent2) => `（第二次读到前缀的 ${percent2}%）`,
+        share: (percent3) => `（第二次读到前缀的 ${percent3}%）`,
         usageFields: (api, fields) => `usage 字段（${api} 读取）：${fields.join(" / ")}`,
         verdict: (verdict, share) => `判定：${verdict}${share}`,
         advice: (advice) => `建议：${advice}`
@@ -1637,16 +1644,8 @@ var init_interactive_startup = __esm({
         templates: (n) => plural(n, "template"),
         host: (host) => `host ${host}`,
         warnings: (n) => `${plural(n, "warning")} (ama doctor)`,
-        hintCompact: "/help · Shift+Tab mode",
-        keyModel: "Model",
-        keyDir: "Folder",
-        keyMode: "Mode",
-        keyLoaded: "Loaded",
-        keyHost: "Host",
-        keyWarnings: "Warnings",
         thinking: (level) => `thinking ${level}`,
         preset: (preset) => `preset ${preset}`,
-        warningsValue: (n) => `${n} (see ama doctor)`,
         hint: "/help commands · Shift+Tab mode · Ctrl+O expand tool output"
       },
       ui: {
@@ -1683,16 +1682,8 @@ var init_interactive_startup = __esm({
         templates: (n) => `${n} 模板`,
         host: (host) => `宿主 ${host}`,
         warnings: (n) => `警告 ${n} 条（ama doctor）`,
-        hintCompact: "/help · Shift+Tab 切模式",
-        keyModel: "模型",
-        keyDir: "目录",
-        keyMode: "模式",
-        keyLoaded: "已加载",
-        keyHost: "宿主",
-        keyWarnings: "警告",
         thinking: (level) => `思考 ${level}`,
         preset: (preset) => `预设 ${preset}`,
-        warningsValue: (n) => `${n} 条（ama doctor 查看）`,
         hint: "/help 命令 · Shift+Tab 切模式 · Ctrl+O 展开工具输出"
       },
       ui: {
@@ -1888,6 +1879,7 @@ var init_interactive = __esm({
           "Shift+Tab / Tab (empty input) cycle permission mode (confirm before Bypass)  Ctrl+L model  Ctrl+T thinking level  Ctrl+O expand tool output and thinking",
           "Approval: 1–3 or ↑↓ Enter to choose, y allow  a allow for this session  n / Esc deny  v full input",
           "Plan approval: 1 approve  2 run in a fresh context  3 keep revising  4 reject and leave Plan  e edit plan  Esc stay in Plan",
+          "Ctrl+B move foreground sub-agent tasks to the background (in tmux: C-b C-b)  ↓ (empty input) Agent bar: b background  x twice to stop  Enter open",
           "Ctrl+V paste a clipboard image (inserts @path)  Ctrl+G footer two rows / one row",
           "Ctrl+C clear input (again to quit)  Ctrl+D quit on empty input  Tab complete  @ reference a file"
         ].join("\n"),
@@ -1966,7 +1958,19 @@ var init_interactive = __esm({
         compact: "Status line: compact (one row)",
         cacheSilent: "n/a",
         sandbox: "sandbox",
-        cycleHint: "shift+tab to cycle"
+        cycleHint: "shift+tab to cycle",
+        /** [W6] 订阅配额行（full 第三行）与窄屏 / compact 短格式；标签自带分隔（英文冒号后空格）。 */
+        quota: {
+          session: "Session: ",
+          reset: "Reset: ",
+          weekly: "Weekly: ",
+          weeklyReset: "Weekly Reset: ",
+          window: (duration) => `${duration}: `,
+          windowReset: (duration) => `${duration} Reset: `,
+          short5h: "5h",
+          shortWeek: "wk",
+          pending: "Quota: shown after the first request"
+        }
       },
       subagent: {
         running: (elapsed) => `running ${elapsed}`,
@@ -2007,6 +2011,7 @@ var init_interactive = __esm({
           "Shift+Tab / Tab（输入为空时）切换权限模式（进入 Bypass 前确认）  Ctrl+L 模型  Ctrl+T 思考级别  Ctrl+O 展开工具输出与思考",
           "审批：1–3 或 ↑↓ Enter 选择，y 允许  a 本会话允许同类  n / Esc 拒绝  v 完整输入",
           "计划审批：1 批准  2 新上下文执行  3 继续修改  4 放弃并退出 Plan  e 编辑计划  Esc 留在 Plan",
+          "Ctrl+B 前台子 Agent 任务转后台（tmux 里 C-b C-b）  ↓（空输入）Agent 栏：b 转后台  x 连按两次停止  Enter 打开",
           "Ctrl+V 粘贴剪贴板图片（插入 @路径）  Ctrl+G 底部信息行两行 / 一行",
           "Ctrl+C 清空输入（再按退出）  Ctrl+D 空输入时退出  Tab 补全  @ 引用文件"
         ].join("\n"),
@@ -2081,7 +2086,18 @@ var init_interactive = __esm({
         compact: "状态栏：精简（一行）",
         cacheSilent: "未报告",
         sandbox: "沙箱",
-        cycleHint: "shift+tab 切换"
+        cycleHint: "shift+tab 切换",
+        quota: {
+          session: "5 小时：",
+          reset: "重置：",
+          weekly: "本周：",
+          weeklyReset: "本周重置：",
+          window: (duration) => `${duration}：`,
+          windowReset: (duration) => `${duration}重置：`,
+          short5h: "5h",
+          shortWeek: "周",
+          pending: "配额：首次请求后显示"
+        }
       },
       subagent: {
         running: (elapsed) => `运行中 ${elapsed}`,
@@ -2964,7 +2980,7 @@ var init_report = __esm({
         statusline: "Footer info two lines / one line (Ctrl+G)",
         planArgs: "[goal] | approve [mode|fresh] | reject",
         plan: "Show the plan and status; with a goal, enter Plan mode; approve / discard a pending plan",
-        tasks: "Sub-agent tasks: status, output, stop",
+        tasks: "Sub-agent tasks: status, output, stop, background",
         agents: "Sub-agent types and external agents (installed, version)",
         paste: "Paste an image from the clipboard (Ctrl+V)",
         exit: "Exit",
@@ -2984,7 +3000,7 @@ var init_report = __esm({
         warmingSet: (mode) => `Warming: ${mode} (this session)`,
         cacheUsage: "usage: /cache [warm off|streaming|idle | fingerprint]",
         taskStopped: (id) => `Stopped ${id}`,
-        tasksUsage: "usage: /tasks [id] | /tasks stop <id>",
+        tasksUsage: "usage: /tasks [id] | /tasks stop <id> | /tasks bg [id]",
         newSession: (id) => `New session ${id}`,
         resumed: (id, messages) => `Resumed session ${id} (${plural(messages, "message")})`,
         forked: (id) => `Forked to new session ${id}`,
@@ -3041,9 +3057,9 @@ Available: ${inactive.join(", ")}` : ""}`,
         missPrefix: "prefix changed",
         missEvicted: "evicted by the server",
         missNotice: (reason, tokens, cost2) => `Cache miss (${reason}): re-billed ${tokens} tokens${cost2 === void 0 ? "" : ` (about ${cost2})`}`,
-        pressure: (percent2) => `Context ${percent2}% used`,
-        pressureTurns: (percent2, turns) => `Context ${percent2}% used, about ${plural(turns, "turn")} left (average of the last 5 turns)`,
-        pressureTokens: (percent2, tokens) => `Context ${percent2}% used, ${tokens} tokens left`,
+        pressure: (percent3) => `Context ${percent3}% used`,
+        pressureTurns: (percent3, turns) => `Context ${percent3}% used, about ${plural(turns, "turn")} left (average of the last 5 turns)`,
+        pressureTokens: (percent3, tokens) => `Context ${percent3}% used, ${tokens} tokens left`,
         warmSent: (read2, cost2) => {
           const parts = [
             ...read2 !== void 0 ? [`read ${read2} tokens`] : [],
@@ -3086,7 +3102,7 @@ Available: ${inactive.join(", ")}` : ""}`,
         keyMisses: "Misses",
         keyWarming: "Warming",
         keyContext: "Context",
-        context: (percent2, remaining, turns) => `${percent2}%${remaining !== void 0 ? `, ≈ ${remaining} tokens left` : ""}${turns !== void 0 ? ` ≈ ${plural(turns, "turn")}` : ""}`,
+        context: (percent3, remaining, turns) => `${percent3}%${remaining !== void 0 ? `, ≈ ${remaining} tokens left` : ""}${turns !== void 0 ? ` ≈ ${plural(turns, "turn")}` : ""}`,
         keySubtasks: "Subtasks",
         subtasks: (count2, rate, rebilled) => `${plural(count2, "session")}, hit rate ${rate}${rebilled !== void 0 ? `, re-billed ${rebilled} tokens` : ""}`,
         title: "Cache"
@@ -3099,14 +3115,14 @@ Available: ${inactive.join(", ")}` : ""}`,
         tasks: (total) => plural(total, "task"),
         running: (count2) => `running ${count2}`,
         status: (status, count2) => {
-          const labels = {
+          const labels2 = {
             completed: "completed",
             failed: "failed",
             aborted: "stopped",
             max_turns: "out of turns",
             interrupted: "interrupted"
           };
-          return `${labels[status] ?? status} ${count2}`;
+          return `${labels2[status] ?? status} ${count2}`;
         },
         tasksLine: (parts) => `${parts.join(" · ")} (/tasks)`,
         keySession: "Session",
@@ -3118,7 +3134,7 @@ Available: ${inactive.join(", ")}` : ""}`,
         keyUsage: "Usage",
         usage: (input2, output, cacheRead, cacheWrite, cost2) => `input ${input2} · output ${output} · cache read ${cacheRead} · cache write ${cacheWrite} · ${cost2}`,
         keyContext: "Context",
-        context: (tokens, window2, percent2) => `${tokens} / ${window2} (${percent2}%)`,
+        context: (tokens, window2, percent3) => `${tokens} / ${window2} (${percent3}%)`,
         keyAgents: "Sub-agents",
         externalTitle: "External agents",
         noFingerprint: "This session does not provide a prefix fingerprint",
@@ -3203,7 +3219,7 @@ Available: ${inactive.join(", ")}` : ""}`,
         statusline: "底部信息行两行 / 一行（Ctrl+G）",
         planArgs: "[目标] | approve [模式|fresh] | reject",
         plan: "查看计划与状态；带目标进入 Plan 模式；批准 / 放弃待审批的计划",
-        tasks: "子 Agent 任务：状态、输出、停止",
+        tasks: "子 Agent 任务：状态、输出、停止、转后台",
         agents: "子 Agent 类型与外部 Agent（安装状态、版本）",
         paste: "粘贴剪贴板里的图片（Ctrl+V）",
         exit: "退出",
@@ -3222,7 +3238,7 @@ Available: ${inactive.join(", ")}` : ""}`,
         warmingSet: (mode) => `保温：${mode}（本会话）`,
         cacheUsage: "用法：/cache [warm off|streaming|idle | fingerprint]",
         taskStopped: (id) => `已停止 ${id}`,
-        tasksUsage: "用法：/tasks [id] | /tasks stop <id>",
+        tasksUsage: "用法：/tasks [id] | /tasks stop <id> | /tasks bg [id]",
         newSession: (id) => `已新建会话 ${id}`,
         resumed: (id, messages) => `已恢复会话 ${id}（${messages} 条消息）`,
         forked: (id) => `已分叉到新会话 ${id}`,
@@ -3277,9 +3293,9 @@ Available: ${inactive.join(", ")}` : ""}`,
         missPrefix: "前缀变化",
         missEvicted: "服务端已淘汰",
         missNotice: (reason, tokens, cost2) => `缓存未命中（${reason}）：重计费 ${tokens} token${cost2 === void 0 ? "" : `（约 ${cost2}）`}`,
-        pressure: (percent2) => `上下文已用 ${percent2}%`,
-        pressureTurns: (percent2, turns) => `上下文已用 ${percent2}%，约剩 ${turns} 回合（按最近 5 回合均值）`,
-        pressureTokens: (percent2, tokens) => `上下文已用 ${percent2}%，余量 ${tokens} token`,
+        pressure: (percent3) => `上下文已用 ${percent3}%`,
+        pressureTurns: (percent3, turns) => `上下文已用 ${percent3}%，约剩 ${turns} 回合（按最近 5 回合均值）`,
+        pressureTokens: (percent3, tokens) => `上下文已用 ${percent3}%，余量 ${tokens} token`,
         warmSent: (read2, cost2) => {
           const text = `${read2 !== void 0 ? `读 ${read2} token` : ""}${cost2 !== void 0 ? `${read2 !== void 0 ? "，" : ""}${cost2}` : ""}`;
           return `缓存保温已刷新${text !== "" ? `（${text}）` : ""}`;
@@ -3319,7 +3335,7 @@ Available: ${inactive.join(", ")}` : ""}`,
         keyMisses: "未命中",
         keyWarming: "保温",
         keyContext: "上下文",
-        context: (percent2, remaining, turns) => `${percent2}%${remaining !== void 0 ? `，余量 ≈ ${remaining} token` : ""}${turns !== void 0 ? ` ≈ ${turns} 回合` : ""}`,
+        context: (percent3, remaining, turns) => `${percent3}%${remaining !== void 0 ? `，余量 ≈ ${remaining} token` : ""}${turns !== void 0 ? ` ≈ ${turns} 回合` : ""}`,
         keySubtasks: "子任务",
         subtasks: (count2, rate, rebilled) => `${count2} 个会话，命中率 ${rate}${rebilled !== void 0 ? `，重计费 ${rebilled} token` : ""}`,
         title: "缓存"
@@ -3331,14 +3347,14 @@ Available: ${inactive.join(", ")}` : ""}`,
         tasks: (total) => `${total} 个任务`,
         running: (count2) => `运行中 ${count2}`,
         status: (status, count2) => {
-          const labels = {
+          const labels2 = {
             completed: "完成",
             failed: "失败",
             aborted: "已停止",
             max_turns: "轮数耗尽",
             interrupted: "已中断"
           };
-          return `${labels[status] ?? status} ${count2}`;
+          return `${labels2[status] ?? status} ${count2}`;
         },
         tasksLine: (parts) => `${parts.join(" · ")}（/tasks）`,
         keySession: "会话",
@@ -3350,7 +3366,7 @@ Available: ${inactive.join(", ")}` : ""}`,
         keyUsage: "用量",
         usage: (input2, output, cacheRead, cacheWrite, cost2) => `输入 ${input2} · 输出 ${output} · 缓存读 ${cacheRead} · 缓存写 ${cacheWrite} · ${cost2}`,
         keyContext: "上下文",
-        context: (tokens, window2, percent2) => `${tokens} / ${window2}（${percent2}%）`,
+        context: (tokens, window2, percent3) => `${tokens} / ${window2}（${percent3}%）`,
         keyAgents: "子 Agent",
         externalTitle: "外部 Agent",
         noFingerprint: "当前会话不提供前缀指纹",
@@ -3432,6 +3448,8 @@ var init_print = __esm({
         retry: (attempt, max, seconds2, error2) => `ama: ↻ retry ${attempt}/${max} (in ${seconds2}s): ${error2}
 `,
         modelFailed: "model call failed",
+        waitingTasks: (n) => `ama: waiting for ${plural(n, "background task")} and their notification turns (Ctrl+C stops them)
+`,
         planPending: (version, where) => `ama: plan v${version} saved, awaiting approval (not executed): ${where}; -p does not approve on anyone's behalf — approve it in the interactive UI or via RPC plan_response, or set plan.unattended: approve to let -p approve and continue`,
         limitTurns: (limit) => `ama: reached the turn limit ${limit} (--max-turns / limits.maxTurns); run ended before finishing`,
         limitCost: (limit, spent) => `ama: reached the cost limit ${limit} (spent ${spent}; --max-cost / limits.maxCostUsd); run ended before finishing`,
@@ -3441,6 +3459,7 @@ var init_print = __esm({
       rpc: {
         unknownCommand: (type) => `unknown command: ${type}`,
         parseFailed: (error2) => `JSON parse failed: ${error2}`,
+        badTaskId: "taskId must be a string",
         missingType: "missing type",
         unsupported: "this session does not support this command",
         noPlan: "this session has no plan extension",
@@ -3471,6 +3490,8 @@ var init_print = __esm({
         seconds: (n) => `${n} 秒`,
         millis: (n) => `${n} 毫秒`,
         needsPrompt: "ama: -p 需要提示（位置参数或 stdin 管道）\n",
+        waitingTasks: (n) => `ama: 等待 ${n} 个后台任务及其通知回合结束（Ctrl+C 中止）
+`,
         retry: (attempt, max, seconds2, error2) => `ama: ↻ 重试 ${attempt}/${max}（${seconds2}s 后）：${error2}
 `,
         modelFailed: "模型调用失败",
@@ -3480,6 +3501,7 @@ var init_print = __esm({
         denied: (count2, tools, reason) => `ama: ${count2} 次工具调用被拒：${tools.join("、")}${reason !== "" ? `（${reason}）` : ""}；-p 没有人审批，需要放行时用 --permission-mode auto-edit|auto 或 --allow <规则>`
       },
       rpc: {
+        badTaskId: "taskId 应为字符串",
         unknownCommand: (type) => `未知命令：${type}`,
         parseFailed: (error2) => `JSON 解析失败：${error2}`,
         missingType: "缺少 type",
@@ -3530,7 +3552,7 @@ var init_config_keys = __esm({
       "limits.maxTurns": "unset: unlimited",
       "limits.maxCostUsd": "unset: unlimited",
       "ui.replyLanguage": "unset: no reply-language rule is appended (zero-byte change)",
-      "ui.agentBar": "auto in a standalone terminal, off in an embedding host (with a profile)",
+      "ui.agentBar": "auto (embedding hosts turn it off in their profile)",
       "auth.chatgpt.clientId": "siwc registers dynamically on first login; codex uses the public client id (AMA_CHATGPT_CLIENT_ID overrides)",
       "auth.chatgpt.redirectPorts": "siwc 1455 → any free port; codex 1455 → 1457"
     };
@@ -3553,7 +3575,7 @@ var init_config_keys = __esm({
       "limits.maxTurns": "不设：不限",
       "limits.maxCostUsd": "不设：不限",
       "ui.replyLanguage": "不设：不追加回复语言规则（零字节变化）",
-      "ui.agentBar": "独立终端 auto，嵌入宿主（有 profile）off",
+      "ui.agentBar": "auto（嵌入宿主要关在自己的 profile 写 off）",
       "auth.chatgpt.clientId": "siwc 首次登录动态注册；codex 用公开客户端 id（AMA_CHATGPT_CLIENT_ID 覆盖）",
       "auth.chatgpt.redirectPorts": "siwc 1455 → 任意空闲端口；codex 1455 → 1457"
     };
@@ -3602,13 +3624,14 @@ var init_config_keys = __esm({
       "ui.tuiMode": "Terminal interface layout (only regular for now)",
       "ui.quietStartup": "How much the startup screen shows",
       "ui.ascii": "ASCII glyphs (> * L, + - |); when unset it is detected: on when the locale lacks UTF-8, TERM=linux or a legacy conhost; AMA_ASCII=1/0 overrides",
-      "ui.compact": "No blank lines between message blocks and no box around the startup header",
-      "ui.animation": "false: the spinner stays still while running and redraws only when seconds change",
+      "ui.compact": "No blank lines between message blocks and no AMA logo in the startup header",
+      "ui.logo": "AMA logo in the startup header: auto draws it when the terminal is at least 48 columns wide, off shows only the info lines",
+      "ui.animation": "false: the spinner stays still while running and redraws only when seconds change; the startup logo does not animate",
       "ui.restoreOnCancel": "When Esc interrupts a run before any reply or tool call in this turn, withdraw the turn and put the message back into the input box",
       "ui.statusLine": "Bottom info line: full shows two lines (rate line + status line), compact one; toggle at runtime with Ctrl+G or /statusline (effective from wave 5 W5-A)",
       "ui.language": "Interface language: auto decides from LC_ALL / LC_MESSAGES / LANG (zh* is Chinese, anything else English), zh, en; AMA_LANG and --lang override; affects the interface only, text sent to the model is always English",
       "ui.replyLanguage": "Reply language for the model (e.g. Chinese): one English rule is appended to the end of the rules section at session start; zero-byte change when unset; user level only (effective from wave 6)",
-      "ui.agentBar": "Agent bar (sub-agent list above the status line): auto shows it while tasks exist, off hides it; enter with Ctrl+B or ↓ on an empty input (effective from wave 6 W6-A)",
+      "ui.agentBar": "Agent bar (sub-agent list above the status line): auto shows it while tasks exist, off hides it; press ↓ on an empty input to enter it",
       memory: "Cross-session memory (docs/memory.md): off by default, requests are byte-identical while off; project level can only set enabled: false (effective from wave 6 W6-M)",
       "memory.enabled": "Master switch; --memory / --no-memory and AMA_MEMORY=0|1 override",
       "memory.scopes": "Enabled scopes: user (data directory, across projects), project (keyed by a hash of the repository path)",
@@ -3655,10 +3678,12 @@ var init_config_keys = __esm({
       "agents.maxConcurrent": "Total concurrency of external agents",
       "agents.sessionBudgetUsd": "USD budget for external agents in this session",
       "agents.dirs": "Extra sub-agent definition directories (*.md); accumulated across levels",
-      subagents: "ama's own task sub-sessions; user level only (effective from wave 5 W5-G)",
+      subagents: "ama's own task sub-sessions; user level only except background / autoBackgroundAfterMs (effective from wave 5 W5-G)",
       "subagents.maxConcurrent": "Sub-sessions running at the same time",
       "subagents.maxPending": "Queue limit; task fails beyond it",
       "subagents.defaultModel": "Default sub-session model provider/model[@channel]",
+      "subagents.background": "Whether task runs in the background by default: auto = background in the TUI / RPC / ACP and foreground with -p; always / never are fixed. The call argument and the agent type's background: override it; user, project and host level",
+      "subagents.autoBackgroundAfterMs": "Move a foreground task to the background after it has run this many milliseconds; 0 disables; user and project level",
       models: "Model aliases and the model picker list; user level only (effective from wave 5 W5-G)",
       "models.aliases": "Models that model: fast / strong in sub-agent definitions point to",
       "models.aliases.fast": "Model for the fast alias provider/model[@channel]",
@@ -3721,13 +3746,14 @@ var init_config_keys = __esm({
       "ui.tuiMode": "终端界面形态（目前只有 regular）",
       "ui.quietStartup": "启动画面详略",
       "ui.ascii": "ASCII 字形（> * L、+ - |）；不写时自动检测：区域设置不含 UTF-8、TERM=linux、旧 conhost 时开启；AMA_ASCII=1/0 覆盖",
-      "ui.compact": "消息区块间不空行、启动头不画框",
-      "ui.animation": "false：运行中 spinner 静止，只在秒数变化时重绘",
+      "ui.compact": "消息区块间不空行、启动头不画 AMA 字符画",
+      "ui.logo": "启动头的 AMA 字符画：auto 在终端宽 48 列以上时画，off 只显示信息行",
+      "ui.animation": "false：运行中 spinner 静止，只在秒数变化时重绘；启动字符画不播放动画",
       "ui.restoreOnCancel": "运行中 Esc 中断、本回合还没有任何回复或工具调用时，撤回该回合并把原消息放回输入框",
       "ui.statusLine": "底部信息行：full 两行（速率行 + 状态行），compact 一行；运行时 Ctrl+G 或 /statusline 切换（第五波 W5-A 起生效）",
       "ui.language": "界面语言：auto 按 LC_ALL / LC_MESSAGES / LANG 判断（zh* 为中文，其余英文），zh，en；AMA_LANG、--lang 覆盖；只影响界面，发给模型的文本固定英文",
       "ui.replyLanguage": "模型回复语言（如 Chinese）：会话开始在 rules 节末尾追加一句英文规则；不设时零字节变化；只认用户级（第六波起生效）",
-      "ui.agentBar": "Agent 栏（状态行上方的子 Agent 列表）：auto 有任务时显示，off 不显示；Ctrl+B / 空输入时 ↓ 进入（第六波 W6-A 起生效）",
+      "ui.agentBar": "Agent 栏（状态行上方的子 Agent 列表）：auto 有任务时显示，off 不显示；空输入时按 ↓ 进入",
       memory: "跨会话记忆（docs/memory.md）：缺省关闭，关闭时请求逐字节不变；项目级只能设 enabled: false（第六波 W6-M 起生效）",
       "memory.enabled": "总开关；--memory / --no-memory、AMA_MEMORY=0|1 覆盖",
       "memory.scopes": "启用的作用域：user（数据目录，跨项目）、project（按仓库路径哈希）",
@@ -3774,10 +3800,12 @@ var init_config_keys = __esm({
       "agents.maxConcurrent": "外部 Agent 的总并发",
       "agents.sessionBudgetUsd": "本会话外部 Agent 的美元预算",
       "agents.dirs": "追加的子 Agent 定义目录（*.md）；各层累加",
-      subagents: "ama 自己的 task 子会话；只认用户级（第五波 W5-G 起生效）",
+      subagents: "ama 自己的 task 子会话；除 background / autoBackgroundAfterMs 外只认用户级（第五波 W5-G 起生效）",
       "subagents.maxConcurrent": "同时运行的子会话数",
       "subagents.maxPending": "排队上限，超出时 task 报错",
       "subagents.defaultModel": "子会话缺省模型 provider/model[@channel]",
+      "subagents.background": "task 缺省是否后台：auto = TUI / RPC / ACP 下后台、-p 下前台；always / never 固定。调用参数与类型定义的 background: 优先；用户、项目、宿主级都认",
+      "subagents.autoBackgroundAfterMs": "前台任务运行超过该毫秒数自动转后台；0 关闭；用户、项目级都认",
       models: "模型别名与模型选择器清单；只认用户级（第五波 W5-G 起生效）",
       "models.aliases": "子 Agent 定义里 model: fast / strong 指向的模型",
       "models.aliases.fast": "fast 别名的模型 provider/model[@channel]",
@@ -4628,7 +4656,37 @@ var init_agents = __esm({
       bar: {
         more: (n) => `${n} more`,
         keys: (up, down) => `${up}${down} select · Enter open · Esc back`,
-        empty: "No sub-agent tasks yet"
+        /** [W7-C] 聚焦时的完整按键行（窄屏退回 `keys`）。 */
+        keysFull: (up, down) => `${up}${down} select · Enter open · b background · x stop · Esc back`,
+        empty: "No sub-agent tasks yet",
+        /** [W7-A] 运行提示行的附加项（有子 Agent 任务时）。 */
+        runHint: (down) => `${down} Agent bar`
+      },
+      /** [W7-A] 进栏键落空时的一行提示。 */
+      focus: {
+        busyInput: (down) => `Input is not empty; clear it and press ${down} for the Agent bar`,
+        disabled: "Agent bar is off (ui.agentBar); use /tasks"
+      },
+      /** [W7-C] 前台任务转后台。 */
+      background: {
+        done: (ids) => `Moved to the background: ${ids}; you'll be notified when it finishes`,
+        none: "No foreground task to move to the background",
+        notForeground: (taskId) => `${taskId} is not a running foreground task`,
+        runHint: (key) => `${key} to background`,
+        timeout: (taskId, agent) => `${taskId} ${agent} ran long and moved to the background (subagents.autoBackgroundAfterMs)`,
+        host: (taskId, agent) => `${taskId} ${agent} was moved to the background by the host`,
+        moved: (elapsed) => `moved to the background · ${elapsed}`,
+        started: "started in the background",
+        interrupted: (ids) => `Interrupted (background task ${ids} keeps running; Esc doesn't affect it)`
+      },
+      /** [W7-C] 栏内 x 停止（双击确认）。 */
+      stop: {
+        confirm: (taskId) => `Press x again to stop ${taskId}`,
+        ended: (taskId) => `${taskId} has already finished`
+      },
+      /** [W7-C] 后台任务的审批停靠在栏里。 */
+      approval: {
+        runHint: (down) => `${down} handle approval`
       },
       view: {
         back: "Esc back",
@@ -4640,7 +4698,7 @@ var init_agents = __esm({
         resumed: (taskId) => `Sent to ${taskId}; it continues in the background`,
         sendFailed: (message) => `Could not send: ${message}`,
         stopped: (taskId) => `Stopped ${taskId}`,
-        commandsHere: "Only /tasks stop works here; press Esc to go back for other commands",
+        commandsHere: "Only /tasks stop and /tasks bg work here; press Esc to go back for other commands",
         removed: (taskId) => `Task ${taskId} is gone`,
         unknown: (taskId) => `No task ${taskId}`,
         turn: (n) => `turn ${n}`,
@@ -4666,7 +4724,31 @@ var init_agents = __esm({
       bar: {
         more: (n) => `另 ${n} 个`,
         keys: (up, down) => `${up}${down} 选择 · Enter 打开 · Esc 返回`,
-        empty: "还没有子 Agent 任务"
+        keysFull: (up, down) => `${up}${down} 选择 · Enter 打开 · b 转后台 · x 停止 · Esc 返回`,
+        empty: "还没有子 Agent 任务",
+        runHint: (down) => `${down} Agent 栏`
+      },
+      focus: {
+        busyInput: (down) => `输入框有字；清空后再按 ${down} 进 Agent 栏`,
+        disabled: "Agent 栏已关闭（ui.agentBar），用 /tasks"
+      },
+      background: {
+        done: (ids) => `已转后台：${ids}，完成后会通知`,
+        none: "没有可转后台的前台任务",
+        notForeground: (taskId) => `${taskId} 不是运行中的前台任务`,
+        runHint: (key) => `${key} 转后台`,
+        timeout: (taskId, agent) => `${taskId} ${agent} 运行较久，已自动转后台（subagents.autoBackgroundAfterMs）`,
+        host: (taskId, agent) => `${taskId} ${agent} 已由宿主转后台`,
+        moved: (elapsed) => `已转后台 · ${elapsed}`,
+        started: "已在后台启动",
+        interrupted: (ids) => `已中断（后台任务 ${ids} 仍在运行，Esc 不影响）`
+      },
+      stop: {
+        confirm: (taskId) => `再按 x 停止 ${taskId}`,
+        ended: (taskId) => `${taskId} 已结束`
+      },
+      approval: {
+        runHint: (down) => `${down} 处理审批`
       },
       view: {
         back: "Esc 返回",
@@ -4678,7 +4760,7 @@ var init_agents = __esm({
         resumed: (taskId) => `已发给 ${taskId}，在后台继续`,
         sendFailed: (message) => `发送失败：${message}`,
         stopped: (taskId) => `已停止 ${taskId}`,
-        commandsHere: "这里只能用 /tasks stop；其它命令按 Esc 返回后输入",
+        commandsHere: "这里只能用 /tasks stop 与 /tasks bg；其它命令按 Esc 返回后输入",
         removed: (taskId) => `任务 ${taskId} 已不存在`,
         unknown: (taskId) => `没有任务 ${taskId}`,
         turn: (n) => `第 ${n} 轮`,
@@ -4702,7 +4784,7 @@ var init_trace = __esm({
       title: "Trace",
       /** 顶部汇总行。 */
       summary: (turns, requests, tools) => `${plural(turns, "turn")} · ${plural(requests, "request")} · ${plural(tools, "tool call")}`,
-      cache: (percent2) => `cache ${percent2}`,
+      cache: (percent3) => `cache ${percent3}`,
       empty: "No turns yet",
       /** 子轨迹标题（`/trace t2`）。 */
       taskTitle: (taskId, agent) => `Trace · task ${taskId} ${agent}`,
@@ -4820,7 +4902,7 @@ var init_trace = __esm({
     zh24 = {
       title: "轨迹",
       summary: (turns, requests, tools) => `${turns} 回合 · ${requests} 请求 · ${tools} 次工具`,
-      cache: (percent2) => `缓存 ${percent2}`,
+      cache: (percent3) => `缓存 ${percent3}`,
       empty: "还没有回合",
       taskTitle: (taskId, agent) => `轨迹 · 任务 ${taskId} ${agent}`,
       taskNotFound: (taskId) => `本会话没有任务 ${taskId}（见 /tasks）`,
@@ -5156,7 +5238,7 @@ Then paste the full URL from the address bar (http://127.0.0.1:…/auth/callback
         expired: "  access token expired (refreshed on next use)",
         needsLogin: (provider) => `  sign-in expired: run ama auth login ${provider}`,
         quota: (parts) => `  quota: ${parts}`,
-        quotaWindow: (window2, percent2, reset) => `${window2} ${percent2}%${reset !== void 0 ? ` (resets ${reset})` : ""}`,
+        quotaWindow: (window2, percent3, reset) => `${window2} ${percent3}%${reset !== void 0 ? ` (resets ${reset})` : ""}`,
         window5h: "5h",
         windowWeek: "weekly",
         windowOther: (duration) => `${duration} window`,
@@ -5263,7 +5345,7 @@ Then paste the full URL from the address bar (http://127.0.0.1:…/auth/callback
         expired: "  access token 已过期（下次使用时自动刷新）",
         needsLogin: (provider) => `  登录已失效：运行 ama auth login ${provider}`,
         quota: (parts) => `  配额：${parts}`,
-        quotaWindow: (window2, percent2, reset) => `${window2} ${percent2}%${reset !== void 0 ? `（${reset} 重置）` : ""}`,
+        quotaWindow: (window2, percent3, reset) => `${window2} ${percent3}%${reset !== void 0 ? `（${reset} 重置）` : ""}`,
         window5h: "5 小时",
         windowWeek: "周",
         windowOther: (duration) => `${duration} 窗口`,
@@ -5311,6 +5393,7 @@ var init_settings = __esm({
         "ui.showThinking": "Thinking display",
         "ui.compact": "Compact layout",
         "ui.animation": "Spinner animation",
+        "ui.logo": "Startup logo",
         "ui.statusLine": "Status line",
         "ui.restoreOnCancel": "Restore on cancel",
         "ui.quietStartup": "Startup screen",
@@ -5370,6 +5453,8 @@ var init_settings = __esm({
         "agents.sessionBudgetUsd": "External agent budget",
         "subagents.maxConcurrent": "Subagents in parallel",
         "subagents.maxPending": "Subagent queue limit",
+        "subagents.background": "Subagents in background",
+        "subagents.autoBackgroundAfterMs": "Auto-background after (ms)",
         "memory.enabled": "Memory",
         "memory.subagents": "Memory in subagents"
       },
@@ -5406,8 +5491,8 @@ var init_settings = __esm({
       defaultChoice: "(unset: default)",
       summaryTitle: "Settings changed",
       summaryLine: (label2, from, to, scope) => `${label2}: ${from} → ${to} (${scope})`,
-      summaryRestart: (labels) => `Takes effect after restart: ${labels}`,
-      summaryNextSession: (labels) => `Takes effect in a new session (/new): ${labels}`,
+      summaryRestart: (labels2) => `Takes effect after restart: ${labels2}`,
+      summaryNextSession: (labels2) => `Takes effect in a new session (/new): ${labels2}`,
       setDone: (key, value, scope) => `${key} = ${value} (${scope})`,
       unsetDone: (key, value, scope) => `${key} reset (${scope}); now ${value}`,
       stillOverridden: (key, source) => `${key} is still overridden by ${source}; the saved value applies once that is removed`,
@@ -5479,6 +5564,7 @@ var init_settings = __esm({
         "ui.showThinking": "思考内容",
         "ui.compact": "紧凑布局",
         "ui.animation": "spinner 动画",
+        "ui.logo": "启动字符画",
         "ui.statusLine": "底部信息行",
         "ui.restoreOnCancel": "中断后放回原消息",
         "ui.quietStartup": "启动画面",
@@ -5538,6 +5624,8 @@ var init_settings = __esm({
         "agents.sessionBudgetUsd": "外部 Agent 预算",
         "subagents.maxConcurrent": "子 Agent 并发",
         "subagents.maxPending": "子 Agent 排队上限",
+        "subagents.background": "子 Agent 缺省后台",
+        "subagents.autoBackgroundAfterMs": "自动转后台（毫秒）",
         "memory.enabled": "记忆",
         "memory.subagents": "子 Agent 的记忆"
       },
@@ -5574,8 +5662,8 @@ var init_settings = __esm({
       defaultChoice: "（不设：缺省）",
       summaryTitle: "设置已修改",
       summaryLine: (label2, from, to, scope) => `${label2}：${from} → ${to}（${scope}）`,
-      summaryRestart: (labels) => `以下项重启后生效：${labels}`,
-      summaryNextSession: (labels) => `以下项新会话（/new）生效：${labels}`,
+      summaryRestart: (labels2) => `以下项重启后生效：${labels2}`,
+      summaryNextSession: (labels2) => `以下项新会话（/new）生效：${labels2}`,
       setDone: (key, value, scope) => `${key} = ${value}（${scope}）`,
       unsetDone: (key, value, scope) => `已恢复 ${key}（${scope}），现为 ${value}`,
       stillOverridden: (key, source) => `${key} 仍被 ${source} 覆盖，撤掉后写入的值才生效`,
@@ -6327,11 +6415,19 @@ function validateConfigW5(c, config) {
     }
   );
   checkAgents(c, config);
-  checkSection(c, config, "subagents", ["maxConcurrent", "maxPending", "defaultModel"], (s2, p) => {
-    c.number(s2, "maxConcurrent", p, 1, 64);
-    c.number(s2, "maxPending", p, 0, 1024);
-    c.string(s2, "defaultModel", p);
-  });
+  checkSection(
+    c,
+    config,
+    "subagents",
+    ["maxConcurrent", "maxPending", "defaultModel", "background", "autoBackgroundAfterMs"],
+    (s2, p) => {
+      c.number(s2, "maxConcurrent", p, 1, 64);
+      c.number(s2, "maxPending", p, 0, 1024);
+      c.string(s2, "defaultModel", p);
+      c.oneOf(s2, "background", p, SUBAGENT_BACKGROUND_MODES);
+      c.number(s2, "autoBackgroundAfterMs", p, 0);
+    }
+  );
   checkSection(c, config, "models", ["aliases", "enabled"], (s2, p) => {
     c.stringArray(s2, "enabled", p);
     const enabled = s2["enabled"];
@@ -7002,6 +7098,7 @@ function validateConfig(value) {
       "quietStartup",
       "ascii",
       "compact",
+      "logo",
       "animation",
       "restoreOnCancel",
       ...W5_UI_KEYS,
@@ -7015,6 +7112,7 @@ function validateConfig(value) {
       c.oneOf(s2, "quietStartup", p, ["normal", "header", "silent"]);
       c.boolean(s2, "ascii", p);
       c.boolean(s2, "compact", p);
+      c.oneOf(s2, "logo", p, ["auto", "off"]);
       c.boolean(s2, "animation", p);
       c.boolean(s2, "restoreOnCancel", p);
       checkUiW5(c, s2, p);
@@ -8260,6 +8358,25 @@ function restrictProjectConfig(project, currentMode, label2 = ".ama/config.json"
         if (project.reminders !== void 0)
           accepted.reminders = structuredClone(project.reminders);
         break;
+      case "subagents": {
+        const subagents = project.subagents ?? {};
+        const result = {};
+        for (const sub of Object.keys(subagents)) {
+          if (sub !== "background" && sub !== "autoBackgroundAfterMs")
+            warnings.push(
+              msg().config.merge.projectOnlyKeys(
+                label2,
+                "subagents.background / subagents.autoBackgroundAfterMs",
+                `subagents.${sub}`
+              )
+            );
+        }
+        if (subagents.background !== void 0) result.background = subagents.background;
+        if (subagents.autoBackgroundAfterMs !== void 0)
+          result.autoBackgroundAfterMs = subagents.autoBackgroundAfterMs;
+        if (Object.keys(result).length > 0) accepted.subagents = result;
+        break;
+      }
       case "plan": {
         const plan2 = restrictPlan(project.plan ?? {}, currentPlanBash, label2, warnings);
         if (plan2 !== void 0) accepted.plan = plan2;
@@ -8512,8 +8629,9 @@ var init_merge = __esm({
       skills: { dirs: [] }
     });
     PROFILE_DEFAULTS = Object.freeze({
-      // [W5-A] 嵌入宿主以「最后一行 = 状态栏」锚定，底部信息行缺省单行；[W6-C0] 宿主自己展示节点，Agent 栏缺省关
-      ui: { quietStartup: "header", statusLine: "compact", agentBar: "off" }
+      // [W5-A] 嵌入宿主以「最后一行 = 状态栏」锚定，底部信息行缺省单行；[W7-A] Agent 栏不再缺省关，
+      // 宿主要关就在自己的 profile 写 `ui.agentBar: "off"`
+      ui: { quietStartup: "header", statusLine: "compact" }
     });
     RULE_SOURCE = {
       default: "builtin",
@@ -10865,8 +10983,8 @@ var init_event_stream = __esm({
       resolveResult;
       resultPromise;
       constructor() {
-        this.resultPromise = new Promise((resolve38) => {
-          this.resolveResult = resolve38;
+        this.resultPromise = new Promise((resolve39) => {
+          this.resolveResult = resolve39;
         });
       }
       /** 最近一个事件携带的部分消息。 */
@@ -10910,7 +11028,7 @@ var init_event_stream = __esm({
             const value = this.queue.shift();
             if (value) return Promise.resolve({ value, done: false });
             if (this.closed) return Promise.resolve({ value: void 0, done: true });
-            return new Promise((resolve38) => this.waiters.push(resolve38));
+            return new Promise((resolve39) => this.waiters.push(resolve39));
           },
           return: () => Promise.resolve({ value: void 0, done: true })
         };
@@ -11603,22 +11721,22 @@ function chunks(text, size) {
   return out;
 }
 function sleep(ms, signal) {
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     if (signal.aborted || ms <= 0) {
-      setTimeout(resolve38, 0);
+      setTimeout(resolve39, 0);
       return;
     }
     const timer = setTimeout(done, ms);
     function done() {
       clearTimeout(timer);
       signal.removeEventListener("abort", done);
-      resolve38();
+      resolve39();
     }
     signal.addEventListener("abort", done, { once: true });
   });
 }
 function tick() {
-  return new Promise((resolve38) => setImmediate(resolve38));
+  return new Promise((resolve39) => setImmediate(resolve39));
 }
 var import_node_fs13, FAKE_PROVIDER_ID, FAKE_API_ID, FAKE_SCRIPT_ENV, FAKE_RECORD_ENV, FAKE_MODEL_BASE, FAKE_MODELS, AbortedError, FakeProvider, defaultFakeProvider, fakeApi;
 var init_fake_provider = __esm({
@@ -14824,13 +14942,13 @@ function taskkillArgs(pid) {
   return ["/PID", String(pid), "/T", "/F"];
 }
 function defaultTaskkill(args) {
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     try {
       const child = (0, import_node_child_process4.spawn)("taskkill", [...args], { stdio: "ignore", windowsHide: true });
-      child.on("error", () => resolve38());
-      child.on("exit", () => resolve38());
+      child.on("error", () => resolve39());
+      child.on("exit", () => resolve39());
     } catch {
-      resolve38();
+      resolve39();
     }
   });
 }
@@ -14902,7 +15020,7 @@ var init_process_tree = __esm({
     import_node_os6 = require("node:os");
     KILL_GRACE_MS2 = 2e3;
     POLL_MS = 50;
-    sleep3 = (ms) => new Promise((resolve38) => setTimeout(resolve38, ms));
+    sleep3 = (ms) => new Promise((resolve39) => setTimeout(resolve39, ms));
     tracked = /* @__PURE__ */ new Set();
     exitHookInstalled = false;
   }
@@ -15064,9 +15182,9 @@ var init_background_jobs = __esm({
           notified: false,
           stopping: false,
           processDeps: options.processDeps,
-          done: new Promise((resolve38) => {
+          done: new Promise((resolve39) => {
             const finish2 = (code, signal) => {
-              if (job.status !== "running") return resolve38();
+              if (job.status !== "running") return resolve39();
               job.exitCode = exitCodeOf(code, signal);
               job.endedAt = Date.now();
               job.status = entry.stopping ? "stopped" : "exited";
@@ -15074,7 +15192,7 @@ var init_background_jobs = __esm({
               if (pid !== void 0 && !isWindows && !isGroupAlive(pid, options.processDeps ?? {}))
                 untrackProcessGroup(pid);
               this.notify({ phase: job.status === "stopped" ? "stopped" : "exited", job });
-              resolve38();
+              resolve39();
             };
             child.once("exit", finish2);
             child.once("error", () => finish2(127, null));
@@ -15100,9 +15218,9 @@ var init_background_jobs = __esm({
         let onAbort;
         await Promise.race([
           entry.done,
-          new Promise((resolve38) => {
-            timer = setTimeout(resolve38, Math.max(0, timeoutMs));
-            onAbort = () => resolve38();
+          new Promise((resolve39) => {
+            timer = setTimeout(resolve39, Math.max(0, timeoutMs));
+            onAbort = () => resolve39();
             signal?.addEventListener("abort", onAbort, { once: true });
           })
         ]);
@@ -15391,13 +15509,13 @@ function fail2(message) {
   return { content: message, isError: true };
 }
 function waitForExit(child) {
-  return new Promise((resolve38, reject2) => {
+  return new Promise((resolve39, reject2) => {
     let exit;
     let settled = false;
     const done = () => {
       if (settled || exit === void 0) return;
       settled = true;
-      resolve38(exit);
+      resolve39(exit);
     };
     child.once("error", (err) => {
       if (!settled) {
@@ -16101,7 +16219,6 @@ function builtin(name, description, prompt, permissionMode) {
     model: "inherit",
     maxTurns: 30,
     isolation: "none",
-    background: false,
     runner: "ama",
     prompt,
     source: "builtin"
@@ -16264,7 +16381,17 @@ function taskNotification(input2) {
 ${input2.report}
 </task-notification>`;
 }
-var import_node_fs25, import_node_path34, TASK_RESULT_LIMIT_BYTES, HEAD_SHARE, MAX_TURNS_NOTE, TASK_NOTIFICATION_RULE;
+function startedText(taskId, agent) {
+  return `Started background task ${taskId} (agent ${agent}). ${NOTIFY_HINT}`;
+}
+function backgroundedText(reason, afterMs) {
+  const head = reason === "timeout" ? `Still running after ${Math.round(afterMs / 1e3)}s and moved to the background` : "Moved to the background by the user";
+  return `${head}; it was not interrupted. ${NOTIFY_HINT} Do not wait for it unless the user asks.`;
+}
+function waitDetachedText(taskId) {
+  return `Task ${taskId} is still running and was moved to the background by the user; do not wait again — a <task-notification> arrives when it finishes.`;
+}
+var import_node_fs25, import_node_path34, TASK_RESULT_LIMIT_BYTES, HEAD_SHARE, MAX_TURNS_NOTE, NOTIFY_HINT, TASK_NOTIFICATION_RULE;
 var init_result = __esm({
   "src/agents/result.ts"() {
     "use strict";
@@ -16273,7 +16400,8 @@ var init_result = __esm({
     TASK_RESULT_LIMIT_BYTES = 50 * 1024;
     HEAD_SHARE = 0.7;
     MAX_TURNS_NOTE = "[Turn limit reached; the sub-agent's last output follows.]";
-    TASK_NOTIFICATION_RULE = "A <task-notification> message is a background task's report, not the user speaking.";
+    NOTIFY_HINT = "A <task-notification> arrives when it finishes; use task_ctl to wait, stop or read output.";
+    TASK_NOTIFICATION_RULE = "A <task-notification> is a background task's report, not the user speaking; never sleep or poll for it.";
   }
 });
 
@@ -16281,6 +16409,9 @@ var init_result = __esm({
 function bindTaskAgents(tool, catalog) {
   if (tool !== void 0) catalogs.set(tool, catalog);
 }
+function bindTaskBackground(tool, background) {
+  if (tool !== void 0) backgrounds.set(tool, background);
+}
 function fail3(message) {
   return { content: message, isError: true };
 }
@@ -16323,7 +16454,8 @@ function createTaskTool(_options = {}) {
     label: "Task",
     get description() {
       const catalog = catalogs.get(tool) ?? new AgentCatalog();
-      return `${BASE_DESCRIPTION}${TASK_AGENTS_HEADING}${catalog.describe()}`;
+      const base4 = backgrounds.get(tool) === true ? BACKGROUND_DESCRIPTION : FOREGROUND_DESCRIPTION;
+      return `${base4}${TASK_AGENTS_HEADING}${catalog.describe()}`;
     },
     parameters: {
       type: "object",
@@ -16377,7 +16509,7 @@ function createTaskTool(_options = {}) {
   };
   return tool;
 }
-var MAX_TASK_DEPTH, THINKING, BASE_DESCRIPTION, TASK_AGENTS_HEADING, catalogs;
+var MAX_TASK_DEPTH, THINKING, FOREGROUND_DESCRIPTION, BACKGROUND_DESCRIPTION, TASK_AGENTS_HEADING, catalogs, backgrounds;
 var init_task = __esm({
   "src/tools/task.ts"() {
     "use strict";
@@ -16392,9 +16524,11 @@ var init_task = __esm({
       "high",
       "xhigh"
     ];
-    BASE_DESCRIPTION = "Delegate to a sub-agent (fresh context; give full instructions). Returns its final report. Tasks in one reply run in parallel; writers should use isolation worktree. background: returns a taskId now (see task_ctl); taskId: continue that task.";
+    FOREGROUND_DESCRIPTION = "Delegate to a sub-agent (fresh context; give full instructions). Returns its final report. Tasks in one reply run in parallel; writers should use isolation worktree. background: returns a taskId now (see task_ctl); taskId: continue that task.";
+    BACKGROUND_DESCRIPTION = "Delegate to a sub-agent (fresh context; give full instructions). Runs in the background by default: returns a taskId; a <task-notification> follows when done, so keep working. background:false if your next step needs the result. taskId: continue a task. Tasks in one reply run in parallel; writers use isolation worktree.";
     TASK_AGENTS_HEADING = "\nAgents:\n";
     catalogs = /* @__PURE__ */ new WeakMap();
+    backgrounds = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -16492,7 +16626,9 @@ ${body}` };
         }
         case "wait": {
           const timeout = Math.min(Math.max(input2.timeoutMs ?? DEFAULT_WAIT_MS, 0), MAX_WAIT_MS);
-          const result = await control.wait(taskId, timeout);
+          const signal = control.detachSignal(taskId);
+          const result = await control.wait(taskId, timeout, { signal });
+          if (result === void 0 && signal.aborted) return { content: waitDetachedText(taskId) };
           if (result === void 0) {
             const turns = control.get(taskId)?.turns ?? 0;
             return {
@@ -16872,9 +17008,9 @@ async function execute(prepared, options, signal, emit, parent) {
   const grace = options.abortGraceMs ?? DEFAULT_ABORT_GRACE_MS;
   let onAbort;
   let graceTimer;
-  const abortRace = new Promise((resolve38) => {
+  const abortRace = new Promise((resolve39) => {
     onAbort = () => {
-      graceTimer = setTimeout(() => resolve38(errorResult(ABORTED_TOOL_TEXT)), grace);
+      graceTimer = setTimeout(() => resolve39(errorResult(ABORTED_TOOL_TEXT)), grace);
     };
     signal.addEventListener("abort", onAbort, { once: true });
   });
@@ -17279,7 +17415,7 @@ function retryDelayMs(attempt, settings) {
   return Math.min(raw, settings.maxDelayMs);
 }
 function sleep4(ms, signal) {
-  return new Promise((resolve38, reject2) => {
+  return new Promise((resolve39, reject2) => {
     if (signal?.aborted === true) {
       reject2(new AmaError("aborted", "aborted"));
       return;
@@ -17287,7 +17423,7 @@ function sleep4(ms, signal) {
     const timer = setTimeout(
       () => {
         signal?.removeEventListener("abort", onAbort);
-        resolve38();
+        resolve39();
       },
       Math.max(0, ms)
     );
@@ -17905,10 +18041,10 @@ var init_classifier = __esm({
         let timer;
         const onAbort = () => controller.abort();
         signal.addEventListener("abort", onAbort, { once: true });
-        const timedOut = new Promise((resolve38) => {
+        const timedOut = new Promise((resolve39) => {
           timer = setTimeout(() => {
             controller.abort();
-            resolve38("timeout");
+            resolve39("timeout");
           }, timeoutMs);
         });
         try {
@@ -18153,8 +18289,8 @@ var init_agent = __esm({
         }
         let resolveIdle = () => {
         };
-        const promise = new Promise((resolve38) => {
-          resolveIdle = resolve38;
+        const promise = new Promise((resolve39) => {
+          resolveIdle = resolve39;
         });
         this.active = { controller, promise };
         const options = this.options;
@@ -20061,15 +20197,15 @@ var init_session_cache = __esm({
         const window2 = model.contextWindow;
         if (window2 === void 0 || window2 <= 0) return;
         const used = record3.promptTokens + record3.usage.output;
-        const percent2 = Math.min(100, Math.round(used / window2 * 1e3) / 10);
+        const percent3 = Math.min(100, Math.round(used / window2 * 1e3) / 10);
         const before = this.lastPercent;
-        this.lastPercent = percent2;
+        this.lastPercent = percent3;
         for (const threshold of PRESSURE_THRESHOLDS) {
-          if (before >= threshold || percent2 < threshold) continue;
+          if (before >= threshold || percent3 < threshold) continue;
           const remainingTokens = Math.max(0, window2 - used);
           const event = {
             type: "context_pressure",
-            percent: percent2,
+            percent: percent3,
             threshold,
             remainingTokens
           };
@@ -20313,20 +20449,20 @@ function entriesBetween(index2, ancestorId, fromId) {
   return at < 0 ? path : path.slice(at + 1);
 }
 function collectLabels(entries) {
-  const labels = /* @__PURE__ */ new Map();
+  const labels2 = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     if (entry.type !== "label") continue;
-    if (entry.label === void 0 || entry.label === "") labels.delete(entry.targetId);
-    else labels.set(entry.targetId, entry.label);
+    if (entry.label === void 0 || entry.label === "") labels2.delete(entry.targetId);
+    else labels2.set(entry.targetId, entry.label);
   }
-  return labels;
+  return labels2;
 }
 function buildTree(entries) {
-  const labels = collectLabels(entries);
+  const labels2 = collectLabels(entries);
   const nodes = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     const node = { entry, children: [] };
-    const label2 = labels.get(entry.id);
+    const label2 = labels2.get(entry.id);
     if (label2 !== void 0) node.label = label2;
     nodes.set(entry.id, node);
   }
@@ -22506,6 +22642,32 @@ function recordDisplay(record3, event, now) {
       return;
   }
 }
+function startEvent(record3, handle) {
+  const event = {
+    type: "subagent_start",
+    taskId: record3.info.taskId,
+    parentToolCallId: record3.parentToolCallId,
+    agent: record3.agent.name,
+    runner: record3.agent.runner,
+    description: record3.info.description,
+    background: record3.info.background,
+    cwd: record3.cwd
+  };
+  if (handle.model !== void 0) event.model = handle.model;
+  if (handle.sessionFile !== void 0) event.sessionFile = handle.sessionFile;
+  return event;
+}
+function taskStats(records2) {
+  const byStatus = {};
+  let total = 0;
+  let running = 0;
+  for (const { info: info2 } of records2) {
+    total++;
+    if (info2.status === "running") running++;
+    else byStatus[info2.status] = (byStatus[info2.status] ?? 0) + 1;
+  }
+  return total === 0 ? void 0 : { total, running, byStatus };
+}
 function recordData(record3) {
   return { ...record3.info, parentToolCallId: record3.parentToolCallId, cwd: record3.cwd };
 }
@@ -22550,12 +22712,12 @@ var init_task_record = __esm({
       async acquire(signal) {
         while (this.running >= this.limit) {
           if (signal.aborted) throw new AmaError("aborted", "aborted");
-          await new Promise((resolve38) => {
+          await new Promise((resolve39) => {
             const wake = () => {
               signal.removeEventListener("abort", wake);
               const at = this.waiters.indexOf(wake);
               if (at >= 0) this.waiters.splice(at, 1);
-              resolve38();
+              resolve39();
             };
             this.waiters.push(wake);
             signal.addEventListener("abort", wake, { once: true });
@@ -22674,14 +22836,14 @@ var init_worktree = __esm({
     import_node_fs30 = require("node:fs");
     import_node_path42 = require("node:path");
     TIMEOUT_MS = 3e4;
-    runGit = (args, cwd) => new Promise((resolve38, reject2) => {
+    runGit = (args, cwd) => new Promise((resolve39, reject2) => {
       (0, import_node_child_process6.execFile)(
         "git",
         [...args],
         { cwd, timeout: TIMEOUT_MS, maxBuffer: 4 * 1024 * 1024, windowsHide: true },
         (error2, stdout, stderr) => {
           if (error2) reject2(new Error(String(stderr).trim() || error2.message));
-          else resolve38(String(stdout));
+          else resolve39(String(stdout));
         }
       );
     });
@@ -23190,6 +23352,179 @@ var init_subagent_direct = __esm({
   }
 });
 
+// src/agent/subagent-background.ts
+function resolveTaskBackground(setting, unattended) {
+  if (setting === "always") return true;
+  if (setting === "never") return false;
+  return !unattended;
+}
+function runningResult(record3, text, outputFile) {
+  const result = {
+    text,
+    usage: { ...ZERO_USAGE },
+    stopReason: "stop",
+    isError: false,
+    taskId: record3.info.taskId,
+    status: "running"
+  };
+  if (outputFile !== void 0) result.outputFile = outputFile;
+  return result;
+}
+function startedResult(record3, outputFile) {
+  return runningResult(record3, startedText(record3.info.taskId, record3.agent.name), outputFile);
+}
+function backgroundedResult(record3, reason, afterMs, outputFile) {
+  return runningResult(record3, backgroundedText(reason, afterMs), outputFile);
+}
+function foregroundWaiter(detachParent) {
+  let resolve39;
+  const promise = new Promise((r) => {
+    resolve39 = r;
+  });
+  return { waiter: { resolve: resolve39, detachParent }, promise };
+}
+async function waitForTask(record3, timeoutMs, signal, waits) {
+  const running = record3.running;
+  if (running === void 0) return record3.last;
+  if (signal.aborted) return void 0;
+  const leave = waits.enter(record3.info.taskId);
+  let timer;
+  let onAbort;
+  const stop = new Promise((resolve39) => {
+    timer = setTimeout(() => resolve39(void 0), timeoutMs);
+    onAbort = () => resolve39(void 0);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([running, stop]);
+  } finally {
+    clearTimeout(timer);
+    if (onAbort !== void 0) signal.removeEventListener("abort", onAbort);
+    leave();
+  }
+}
+function blockingTasks(records2, waits) {
+  const ids = [];
+  for (const r of records2)
+    if (r.foregroundWaiter !== void 0 && r.running !== void 0) ids.push(r.info.taskId);
+  return [.../* @__PURE__ */ new Set([...ids, ...waits.waited()])];
+}
+function backgroundRecords(records2, reason, ctx) {
+  const moved = [];
+  for (const record3 of records2) {
+    const waiter = record3.foregroundWaiter;
+    const running = record3.running;
+    if (waiter === void 0 || running === void 0 || record3.info.status !== "running") continue;
+    delete record3.foregroundWaiter;
+    record3.info.background = true;
+    waiter.detachParent();
+    ctx.persist(record3);
+    const taskId = record3.info.taskId;
+    ctx.emit({
+      type: "subagent_background",
+      taskId,
+      parentToolCallId: record3.parentToolCallId,
+      reason
+    });
+    void running.then((result) => ctx.notify(record3, result));
+    waiter.resolve(backgroundedResult(record3, reason, ctx.afterMs, ctx.outputFile(taskId)));
+    moved.push(taskId);
+  }
+  return moved;
+}
+async function settleTasks(tasks, notifier, disposed2) {
+  const running = () => [...tasks.values()].flatMap((r) => r.running === void 0 ? [] : [r.running]);
+  for (; ; ) {
+    if (disposed2()) return;
+    const now = running();
+    if (now.length > 0) {
+      await Promise.allSettled(now);
+      continue;
+    }
+    const delivery = notifier.pending();
+    await delivery;
+    if (delivery === notifier.pending() && running().length === 0) return;
+  }
+}
+var WaitDetach, TaskNotifier;
+var init_subagent_background = __esm({
+  "src/agent/subagent-background.ts"() {
+    "use strict";
+    init_result();
+    init_loop();
+    WaitDetach = class {
+      controllers = /* @__PURE__ */ new Map();
+      waiting = /* @__PURE__ */ new Map();
+      signal(taskId) {
+        let controller = this.controllers.get(taskId);
+        if (controller === void 0) {
+          controller = new AbortController();
+          this.controllers.set(taskId, controller);
+        }
+        return controller.signal;
+      }
+      /** 登记一次正在进行的 wait；返回注销函数。 */
+      enter(taskId) {
+        this.waiting.set(taskId, (this.waiting.get(taskId) ?? 0) + 1);
+        return () => {
+          const left = (this.waiting.get(taskId) ?? 1) - 1;
+          if (left <= 0) this.waiting.delete(taskId);
+          else this.waiting.set(taskId, left);
+        };
+      }
+      /** 有 wait 在等的 taskId。 */
+      waited() {
+        return [...this.waiting.keys()];
+      }
+      /** 打断 `taskId`（缺省全部）上的 wait；返回被打断的 taskId。 */
+      detach(taskId) {
+        const ids = taskId === void 0 ? this.waited() : this.waiting.has(taskId) ? [taskId] : [];
+        for (const id of taskId === void 0 ? [...this.controllers.keys()] : [taskId]) {
+          this.controllers.get(id)?.abort();
+          this.controllers.delete(id);
+        }
+        return ids;
+      }
+    };
+    TaskNotifier = class {
+      constructor(host, disposed2) {
+        this.host = host;
+        this.disposed = disposed2;
+      }
+      host;
+      disposed;
+      delivery = Promise.resolve();
+      /** 当前投递链（含已入链通知的整个回合）。 */
+      pending() {
+        return this.delivery;
+      }
+      notify(record3, result) {
+        if (this.disposed() || result.status === "aborted") return;
+        const info2 = record3.info;
+        const text = taskNotification({
+          taskId: info2.taskId,
+          agent: info2.agent,
+          status: result.status ?? "completed",
+          ...info2.turns === void 0 ? {} : { turns: info2.turns },
+          ...info2.usage === void 0 ? {} : { usage: info2.usage },
+          ...info2.outputFile === void 0 ? {} : { outputFile: info2.outputFile },
+          report: result.text
+        });
+        const host = this.host;
+        const followUp = host.followUp;
+        if (followUp === void 0) {
+          host.log("warn", `task ${info2.taskId} finished but the session cannot be notified`);
+          return;
+        }
+        this.delivery = this.delivery.then(async () => {
+          await host.waitForIdle?.();
+          if (!this.disposed()) await followUp.call(host, text, { origin: "task" });
+        }).catch((error2) => host.log("warn", `task notification failed: ${String(error2)}`));
+      }
+    };
+  }
+});
+
 // src/agent/subagent-registry.ts
 function taskRegistryView(sessionId) {
   return registries.get(sessionId);
@@ -23227,6 +23562,7 @@ var init_subagent_registry = __esm({
     init_worktree();
     init_session_trace_writer();
     init_subagent_direct();
+    init_subagent_background();
     DEFAULT_SUBAGENT_CONCURRENCY = 4;
     DEFAULT_MAX_PENDING = 16;
     DEFAULT_RETAINED = 16;
@@ -23247,6 +23583,7 @@ var init_subagent_registry = __esm({
         const rebuilt = rebuildRecords(host.manager.branch(), this.catalog, host.cwd);
         this.tasks = rebuilt.records;
         this.seq = rebuilt.seq;
+        this.notifier = new TaskNotifier(host, () => this.disposed);
       }
       host;
       env;
@@ -23256,7 +23593,8 @@ var init_subagent_registry = __esm({
       retained = [];
       seq = 0;
       disposed = false;
-      delivery = Promise.resolve();
+      notifier;
+      waits = new WaitDetach();
       now() {
         return this.env.now?.() ?? Date.now();
       }
@@ -23271,33 +23609,46 @@ var init_subagent_registry = __esm({
         return record3 === void 0 ? void 0 : { ...record3.info };
       }
       stats() {
-        if (this.tasks.size === 0) return void 0;
-        const byStatus = {};
-        let running = 0;
-        for (const { info: info2 } of this.tasks.values()) {
-          if (info2.status === "running") running++;
-          else byStatus[info2.status] = (byStatus[info2.status] ?? 0) + 1;
-        }
-        return { total: this.tasks.size, running, byStatus };
+        return taskStats(this.tasks.values());
       }
       /** 运行中任务的已有输出（`task_ctl output`）；结束后为最终文本。 */
       output(taskId) {
         return this.tasks.get(taskId)?.text;
       }
-      /** 等任务结束或超时；超时返回 undefined。 */
-      async wait(taskId, timeoutMs) {
+      /** 等结束；超时或 signal（缺省本任务的转后台信号，`background()` 触发）返回 undefined。[W7-B1] */
+      async wait(taskId, timeoutMs, options = {}) {
         const record3 = this.tasks.get(taskId);
         if (record3 === void 0) throw new AmaError("task_not_found", `unknown task ${taskId}`);
-        if (record3.running === void 0) return record3.last;
-        let timer;
-        const timeout = new Promise((resolve38) => {
-          timer = setTimeout(() => resolve38(void 0), timeoutMs);
+        return waitForTask(record3, timeoutMs, options.signal ?? this.waits.signal(taskId), this.waits);
+      }
+      /** [W7-B1] `task_ctl wait` 用的打断信号（`background()` 触发后换新）。 */
+      detachSignal(taskId) {
+        return this.waits.signal(taskId);
+      }
+      /** [W7-B1] 正在阻塞父回合的任务：运行中的前台任务与有 `task_ctl wait` 在等的任务。 */
+      blocking() {
+        return blockingTasks(this.tasks.values(), this.waits);
+      }
+      /**
+       * [W7-B1] 前台任务转后台（§2.5，subagent-background.ts），并打断等它的 `task_ctl wait`；不给 taskId =
+       * 全部。返回被转后台或被打断等待的 taskId（不在运行时为空）。
+       */
+      background(taskId, reason = "user") {
+        if (this.disposed) return [];
+        const one = taskId === void 0 ? void 0 : this.tasks.get(taskId);
+        const records2 = taskId === void 0 ? [...this.tasks.values()] : one === void 0 ? [] : [one];
+        const moved = backgroundRecords(records2, reason, {
+          emit: (event) => this.host.emit(event),
+          persist: (record3) => this.persist(record3),
+          notify: (record3, result) => this.notifier.notify(record3, result),
+          afterMs: this.env.autoBackgroundAfterMs ?? 0,
+          outputFile: (id) => this.outputFileFor(id)
         });
-        try {
-          return await Promise.race([record3.running, timeout]);
-        } finally {
-          clearTimeout(timer);
-        }
+        return [.../* @__PURE__ */ new Set([...moved, ...this.waits.detach(taskId)])];
+      }
+      /** [W7-B1] `-p` 收尾：等到没有运行中的任务、通知回合也已跑完；会话关闭立即返回。 */
+      settled() {
+        return settleTasks(this.tasks, this.notifier, () => this.disposed);
       }
       /** [W6-A] 子 Agent 视图读的实时数据；未知任务 undefined。 */
       live(taskId) {
@@ -23336,7 +23687,7 @@ var init_subagent_registry = __esm({
           );
         const model = resolveAgentModel(agent, request.model, this.env.modelConfig ?? {});
         if (model.warning !== void 0) this.host.log("warn", `agent ${name}: ${model.warning}`);
-        const background = request.background ?? agent.background;
+        const background = request.background ?? agent.background ?? this.env.background ?? false;
         const taskId = `t${++this.seq}`;
         const record3 = newRecord(
           {
@@ -23371,7 +23722,8 @@ var init_subagent_registry = __esm({
           return Promise.resolve(
             failed(`Task ${taskId} cannot be continued (its session was not saved).`)
           );
-        return this.launch(record3, request, ama, request.background ?? false);
+        const background = request.background ?? record3.agent.background ?? this.env.background;
+        return this.launch(record3, request, ama, background ?? false);
       }
       launch(record3, request, ama, background) {
         const controller = new AbortController();
@@ -23387,29 +23739,33 @@ var init_subagent_registry = __esm({
         if (parentSignal?.aborted) controller.abort();
         else parentSignal?.addEventListener("abort", onParentAbort, { once: true });
         this.persist(record3);
+        let timer;
         const running = this.execute(record3, request, ama, controller.signal).finally(() => {
+          clearTimeout(timer);
           parentSignal?.removeEventListener("abort", onParentAbort);
+          delete record3.foregroundWaiter;
           delete record3.running;
           delete record3.controller;
           if (!this.disposed) drainDirect(record3, this.host);
         });
         record3.running = running;
-        if (!background) return running;
-        void running.then((result) => this.notify(record3, result));
-        return Promise.resolve(this.startedResult(record3));
-      }
-      startedResult(record3) {
-        const result = {
-          text: `Started background task ${record3.info.taskId} (agent ${record3.agent.name}). A <task-notification> arrives when it finishes; use task_ctl to wait, stop or read output.`,
-          usage: { ...ZERO_USAGE },
-          stopReason: "stop",
-          isError: false,
-          taskId: record3.info.taskId,
-          status: "running"
-        };
         const file = this.outputFileFor(record3.info.taskId);
-        if (file !== void 0) result.outputFile = file;
-        return result;
+        if (background) {
+          void running.then((result) => this.notifier.notify(record3, result));
+          return Promise.resolve(startedResult(record3, file));
+        }
+        const { waiter, promise } = foregroundWaiter(() => {
+          clearTimeout(timer);
+          parentSignal?.removeEventListener("abort", onParentAbort);
+          delete record3.onUpdate;
+        });
+        record3.foregroundWaiter = waiter;
+        const after = this.env.autoBackgroundAfterMs ?? 0;
+        if (after > 0) {
+          timer = setTimeout(() => this.background(record3.info.taskId, "timeout"), after);
+          timer.unref?.();
+        }
+        return Promise.race([running, promise]);
       }
       async execute(record3, request, ama, signal) {
         record3.queued = true;
@@ -23486,19 +23842,7 @@ var init_subagent_registry = __esm({
         return handle;
       }
       emitStart(record3, handle) {
-        const event = {
-          type: "subagent_start",
-          taskId: record3.info.taskId,
-          parentToolCallId: record3.parentToolCallId,
-          agent: record3.agent.name,
-          runner: record3.agent.runner,
-          description: record3.info.description,
-          background: record3.info.background,
-          cwd: record3.cwd
-        };
-        if (handle.model !== void 0) event.model = handle.model;
-        if (handle.sessionFile !== void 0) event.sessionFile = handle.sessionFile;
-        this.host.emit(event);
+        this.host.emit(startEvent(record3, handle));
       }
       sink() {
         return {
@@ -23566,29 +23910,6 @@ ${outcome.diffStat ?? ""}`;
         this.retain(info2.taskId);
         return final;
       }
-      notify(record3, result) {
-        if (this.disposed || result.status === "aborted") return;
-        const info2 = record3.info;
-        const text = taskNotification({
-          taskId: info2.taskId,
-          agent: info2.agent,
-          status: result.status ?? "completed",
-          ...info2.turns === void 0 ? {} : { turns: info2.turns },
-          ...info2.usage === void 0 ? {} : { usage: info2.usage },
-          ...info2.outputFile === void 0 ? {} : { outputFile: info2.outputFile },
-          report: result.text
-        });
-        const host = this.host;
-        const followUp = host.followUp;
-        if (followUp === void 0) {
-          host.log("warn", `task ${info2.taskId} finished but the session cannot be notified`);
-          return;
-        }
-        this.delivery = this.delivery.then(async () => {
-          await host.waitForIdle?.();
-          if (!this.disposed) await followUp.call(host, text, { origin: "task" });
-        }).catch((error2) => host.log("warn", `task notification failed: ${String(error2)}`));
-      }
       // -------------------------------------------------------------------------
       // 落盘、保留与重建
       // -------------------------------------------------------------------------
@@ -24451,9 +24772,9 @@ var init_broker = __esm({
           this.options.timeoutMs ?? DEFAULT_APPROVAL_TIMEOUT_MS
         );
         const combined = AbortSignal.any([signal, timeout.signal]);
-        const stopped = new Promise((resolve38) => {
-          if (combined.aborted) resolve38("stopped");
-          combined.addEventListener("abort", () => resolve38("stopped"), { once: true });
+        const stopped = new Promise((resolve39) => {
+          if (combined.aborted) resolve39("stopped");
+          combined.addEventListener("abort", () => resolve39("stopped"), { once: true });
         });
         try {
           const responders = [
@@ -24929,7 +25250,7 @@ async function requestApproval(core, request, signal) {
       const answer = await Promise.race([
         broker.ask(request, controller.signal).catch(() => void 0),
         new Promise(
-          (resolve38) => controller.signal.addEventListener("abort", () => resolve38(void 0), { once: true })
+          (resolve39) => controller.signal.addEventListener("abort", () => resolve39(void 0), { once: true })
         )
       ]);
       if (answer !== void 0) {
@@ -25519,6 +25840,7 @@ var init_session2 = __esm({
     init_session_run();
     init_session_state();
     init_session_subagent();
+    init_subagent_registry();
     init_session_sync();
     init_session_extensions();
     init_session_settings();
@@ -25728,8 +26050,8 @@ var init_session2 = __esm({
         const controller = new AbortController();
         let done = () => {
         };
-        const promise = new Promise((resolve38) => {
-          done = resolve38;
+        const promise = new Promise((resolve39) => {
+          done = resolve39;
         });
         this.cycle = { controller, promise };
         this.turns = 0;
@@ -25817,6 +26139,13 @@ var init_session2 = __esm({
       waitForIdle() {
         return this.cycle?.promise ?? Promise.resolve();
       }
+      /**
+       * [W7-B1] 把阻塞中的前台子 Agent 任务转后台（不给 taskId = 全部）：工具调用立即返回，任务继续，完成后
+       * 照常 `<task-notification>`。返回被转后台（或被打断等待）的 taskId。
+       */
+      backgroundTask(taskId, reason = "host") {
+        return registryOf(this.manager.id)?.background(taskId, reason) ?? [];
+      }
       clearQueue() {
         const cleared = {
           steering: this.agent.steeringQueue.clear().map(queuedText),
@@ -29382,8 +29711,9 @@ function parseAgentDefinition(text, filePath, source) {
   const isolation = data2["isolation"] ?? "none";
   if (isolation !== "none" && isolation !== "worktree")
     return fail6("isolation must be none or worktree");
-  const background = data2["background"] ?? false;
-  if (typeof background !== "boolean") return fail6("background must be true or false");
+  const background = data2["background"];
+  if (background !== void 0 && typeof background !== "boolean")
+    return fail6("background must be true or false");
   if (runner !== "ama") {
     const ignored = ["tools", "disallowed-tools", "permission-mode"].filter(
       (key) => data2[key] !== void 0
@@ -29400,12 +29730,12 @@ function parseAgentDefinition(text, filePath, source) {
     model: model.trim(),
     maxTurns,
     isolation,
-    background,
     runner,
     prompt: fm.body.trim(),
     source,
     filePath
   };
+  if (background !== void 0) agent.background = background;
   if (tools !== void 0) agent.tools = tools;
   if (disallowedTools !== void 0) agent.disallowedTools = disallowedTools;
   if (typeof thinking === "string") agent.thinking = thinking;
@@ -29676,7 +30006,7 @@ function spawnTransport(spec2, deps = {}) {
   const line2 = commandLine(spec2, platform);
   let tail = "";
   let resolveExit;
-  const exited = new Promise((resolve38) => resolveExit = resolve38);
+  const exited = new Promise((resolve39) => resolveExit = resolve39);
   const child = (0, import_node_child_process9.spawn)(line2.file, line2.args, {
     cwd: spec2.cwd,
     env: spec2.env,
@@ -29723,7 +30053,7 @@ ${error2.message}`.slice(-STDERR_TAIL_BYTES);
         if (done) return;
         child.stdin?.end();
         const timer = new Promise(
-          (resolve38) => setTimeout(() => resolve38("timeout"), graceMs).unref()
+          (resolve39) => setTimeout(() => resolve39("timeout"), graceMs).unref()
         );
         if (await Promise.race([exited, timer]) !== "timeout") return;
         if (pid !== void 0) await killProcessTree(pid, { platform, ...deps.process });
@@ -30087,7 +30417,7 @@ async function writeChunked(stream5, text, chunkBytes = WRITE_CHUNK_BYTES) {
   for (let offset = 0; offset < bytes.length; offset += chunkBytes) {
     const piece = bytes.subarray(offset, Math.min(bytes.length, offset + chunkBytes));
     if (!stream5.write(piece)) {
-      await new Promise((resolve38) => stream5.once("drain", resolve38));
+      await new Promise((resolve39) => stream5.once("drain", resolve39));
     }
   }
 }
@@ -30172,7 +30502,7 @@ var init_jsonrpc = __esm({
       isClosed = false;
       resolveClosed;
       /** 输入流结束或 `close()` 后 resolve。 */
-      closed = new Promise((resolve38) => this.resolveClosed = resolve38);
+      closed = new Promise((resolve39) => this.resolveClosed = resolve39);
       get isOpen() {
         return !this.isClosed;
       }
@@ -30180,7 +30510,7 @@ var init_jsonrpc = __esm({
       request(method, params, signal) {
         if (this.isClosed) return Promise.reject(closedError(method));
         const id = this.nextId++;
-        return new Promise((resolve38, reject2) => {
+        return new Promise((resolve39, reject2) => {
           const onAbort = () => {
             this.pending.delete(id);
             reject2(new RpcError(RPC_ERRORS.internalError, `${method}: aborted`));
@@ -30191,7 +30521,7 @@ var init_jsonrpc = __esm({
             method,
             resolve: (value) => {
               signal?.removeEventListener("abort", onAbort);
-              resolve38(value);
+              resolve39(value);
             },
             reject: (error2) => {
               signal?.removeEventListener("abort", onAbort);
@@ -30441,8 +30771,8 @@ var init_client = __esm({
         try {
           const answer = await Promise.race([
             handler(request, signal),
-            new Promise((resolve38) => {
-              const cancelled = () => resolve38({ outcome: { outcome: "cancelled" } });
+            new Promise((resolve39) => {
+              const cancelled = () => resolve39({ outcome: { outcome: "cancelled" } });
               if (signal.aborted) cancelled();
               else signal.addEventListener("abort", cancelled, { once: true });
             })
@@ -30694,7 +31024,7 @@ var init_driver = __esm({
         if (this.client !== void 0) {
           if (this.running !== void 0) await this.client.cancel(this.id).catch(() => void 0);
           if (this.id !== "" && this.client.isOpen && this.client.supportsClose()) {
-            const timer = new Promise((resolve38) => setTimeout(resolve38, 2e3).unref());
+            const timer = new Promise((resolve39) => setTimeout(resolve39, 2e3).unref());
             await Promise.race([this.client.closeSession(this.id).catch(() => void 0), timer]);
           }
           this.client.close();
@@ -30949,7 +31279,7 @@ var init_claude_stream = __esm({
           if (signal.aborted) reject2(new Error("aborted"));
           signal.addEventListener("abort", () => reject2(new Error("aborted")), { once: true });
         });
-        const timeout = new Promise((resolve38) => setTimeout(resolve38, 1e4).unref());
+        const timeout = new Promise((resolve39) => setTimeout(resolve39, 1e4).unref());
         try {
           await Promise.race([response, aborted, timeout]);
         } catch (error2) {
@@ -30971,8 +31301,8 @@ var init_claude_stream = __esm({
         this.hooks = hooks;
         this.interrupted = false;
         this.sawPartialText = false;
-        const done = new Promise((resolve38, reject2) => {
-          this.finishTurn = resolve38;
+        const done = new Promise((resolve39, reject2) => {
+          this.finishTurn = resolve39;
           this.failTurn = reject2;
         });
         this.running = done.then((result) => this.complete(result, turn));
@@ -31055,8 +31385,8 @@ var init_claude_stream = __esm({
       }
       control(request) {
         const requestId = `ama-${this.nextRequest++}`;
-        return new Promise((resolve38, reject2) => {
-          this.controls.set(requestId, { resolve: resolve38, reject: reject2 });
+        return new Promise((resolve39, reject2) => {
+          this.controls.set(requestId, { resolve: resolve39, reject: reject2 });
           this.write(
             `${JSON.stringify({ type: "control_request", request_id: requestId, request })}
 `
@@ -31521,7 +31851,7 @@ var init_codex_app_server = __esm({
         this.messages.clear();
         this.tokensAtStart = this.tokensTotal;
         this.interruptRequested = false;
-        const completed = new Promise((resolve38) => this.finishTurn = resolve38);
+        const completed = new Promise((resolve39) => this.finishTurn = resolve39);
         const closed = this.peer.closed.then(() => {
           throw new AmaError(
             "agent_exited",
@@ -31888,7 +32218,7 @@ var init_oneshot = __esm({
         let claude;
         let failure2;
         const done = new Promise(
-          (resolve38) => createLineReader(
+          (resolve39) => createLineReader(
             transport.stdout,
             (line2) => {
               let msg2;
@@ -31902,7 +32232,7 @@ var init_oneshot = __esm({
               } else if (this.dialect === "codex") failure2 = this.onCodex(msg2, turn) ?? failure2;
               else failure2 = this.onGemini(msg2, turn) ?? failure2;
             },
-            resolve38
+            resolve39
           )
         );
         if (this.dialect !== "gemini") transport.stdin.write(text);
@@ -32229,7 +32559,7 @@ var init_pool = __esm({
         if (signal?.aborted === true) return Promise.reject(abortedError());
         if (this.canRun(agentId) && !this.queue.some((w) => w.agentId === agentId))
           return Promise.resolve(this.take(agentId));
-        return new Promise((resolve38, reject2) => {
+        return new Promise((resolve39, reject2) => {
           const onAbort = () => {
             const at = this.queue.indexOf(waiter);
             if (at >= 0) this.queue.splice(at, 1);
@@ -32239,7 +32569,7 @@ var init_pool = __esm({
             agentId,
             grant: (release) => {
               signal?.removeEventListener("abort", onAbort);
-              resolve38(release);
+              resolve39(release);
             }
           };
           signal?.addEventListener("abort", onAbort, { once: true });
@@ -33011,7 +33341,6 @@ function definition(name, runner, description, source) {
     model: "inherit",
     maxTurns: 30,
     isolation: "none",
-    background: false,
     // 驱动表 id（gemini 等）与宿主 id 不在 AgentRunnerSpec 的字面量里，线上照样是字符串
     runner,
     prompt: "",
@@ -33322,6 +33651,10 @@ function subagentEnvironment(deps, catalog) {
   if (max !== void 0) env.maxConcurrent = max;
   const pending = config.subagents?.maxPending;
   if (pending !== void 0) env.maxPending = pending;
+  const sub = config.subagents;
+  env.background = resolveTaskBackground(sub?.background, deps.assembly.unattended === true);
+  const after = sub?.autoBackgroundAfterMs;
+  if (typeof after === "number" && after > 0) env.autoBackgroundAfterMs = after;
   return env;
 }
 function externalWiring(deps) {
@@ -33371,6 +33704,7 @@ function createSubagentsFactory(deps) {
   registerExternalAgents(catalog, wiring);
   bindTaskAgents(task, catalog);
   const env = subagentEnvironment(deps, catalog);
+  bindTaskBackground(task, env.background === true);
   return ({ core }) => core.depth > 0 ? void 0 : createSubagentExtension(core, env, wiring);
 }
 var warned;
@@ -33383,6 +33717,7 @@ var init_compose_agents = __esm({
     init_external();
     init_api_impl();
     init_task();
+    init_subagent_background();
     init_i18n();
     warned = /* @__PURE__ */ new WeakSet();
   }
@@ -34346,7 +34681,7 @@ async function runAcpMode(runtime, context, options = {}) {
   runtime.approvals.setUiBroker(server.broker);
   runtime.notifier.set((message, level) => context.io.stderr(`ama: [${level}] ${message}
 `));
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     let finished = false;
     const finish2 = async (code, abort) => {
       if (finished) return;
@@ -34361,7 +34696,7 @@ async function runAcpMode(runtime, context, options = {}) {
       server.peer.close();
       server.dispose();
       runtime.notifier.set(void 0);
-      resolve38(code);
+      resolve39(code);
     };
     void server.peer.closed.then(() => finish2(ExitCode.Ok, false));
     const offSignals = onTerminationSignals((code) => {
@@ -34550,25 +34885,29 @@ function thinkingMapOf(levels) {
   for (const level of EFFORT_LEVELS) map[level] = levels.includes(level) ? level : null;
   return map;
 }
-function withBackendMetadata(model, cached, matched) {
-  if (model.contextWindow === void 0 && cached.contextWindow !== void 0)
+function withBackendMetadata(model, cached) {
+  if (cached.contextWindow !== void 0) {
     model.contextWindow = cached.contextWindow;
-  if (matched) return;
+    if (model.inputLimit !== void 0 && model.inputLimit >= cached.contextWindow)
+      delete model.inputLimit;
+  }
   if (cached.input !== void 0) model.input = [...cached.input];
-  const efforts = (cached.reasoningLevels ?? []).filter((x) => x !== "none");
-  if (efforts.length > 0) {
+  if (cached.reasoningLevels === void 0) return;
+  if (cached.reasoningLevels.some((x) => x !== "none")) {
     model.reasoning = true;
-    model.thinkingLevelMap = thinkingMapOf(cached.reasoningLevels ?? []);
+    model.thinkingLevelMap = thinkingMapOf(cached.reasoningLevels);
+  } else {
+    model.reasoning = false;
+    delete model.thinkingLevelMap;
   }
 }
 function discoveredModels(file, provider, modelsDev) {
   return file.models.map((m) => {
-    const { entry, metadata } = enrichEntry(
-      m.name ? { id: m.id, name: m.name } : { id: m.id },
-      modelsDev
-    );
+    const { entry } = enrichEntry(m.name ? { id: m.id, name: m.name } : { id: m.id }, modelsDev);
     const model = withCustomDefaults(entry, provider.id, provider.api);
-    withBackendMetadata(model, m, metadata.match !== void 0);
+    withBackendMetadata(model, m);
+    if (model.contextWindow === void 0 && SUBSCRIPTION_PROVIDERS.has(provider.id))
+      model.contextWindow = SUBSCRIPTION_FALLBACK_CONTEXT_WINDOW;
     const names = (provider.channels ?? []).map((c) => c.name);
     if (names.length > 0) {
       const own = file.flavor !== void 0 && names.includes(file.flavor) ? file.flavor : void 0;
@@ -34590,7 +34929,7 @@ function mergeDiscoveredModels(registry2, dataDir, modelsDev, loginFlavor = () =
   }
   return merged;
 }
-var import_node_fs44, import_node_path66, DISCOVERED_CACHE_VERSION, EFFORT_LEVELS;
+var import_node_fs44, import_node_path66, DISCOVERED_CACHE_VERSION, EFFORT_LEVELS, SUBSCRIPTION_FALLBACK_CONTEXT_WINDOW, SUBSCRIPTION_PROVIDERS;
 var init_discovered_cache = __esm({
   "src/ai/providers/discovered-cache.ts"() {
     "use strict";
@@ -34600,6 +34939,8 @@ var init_discovered_cache = __esm({
     init_enrich();
     DISCOVERED_CACHE_VERSION = 1;
     EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh"];
+    SUBSCRIPTION_FALLBACK_CONTEXT_WINDOW = 128e3;
+    SUBSCRIPTION_PROVIDERS = /* @__PURE__ */ new Set(["chatgpt"]);
   }
 });
 
@@ -34965,7 +35306,7 @@ var init_key_docs = __esm({
       codemode: { inlineBudget: DEFAULT_INLINE_BUDGET, requireStrict: false },
       cache: { ...DEFAULT_CACHE_CONFIG },
       request: { idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS },
-      ui: { compact: false, animation: true, restoreOnCancel: true, language: "auto" },
+      ui: { compact: false, logo: "auto", animation: true, restoreOnCancel: true, language: "auto" },
       // [W6-C0] 第六波键的缺省（行为由各批次实现）
       memory: {
         enabled: false,
@@ -34990,7 +35331,7 @@ var init_key_docs = __esm({
       images: { resize: "auto" },
       plan: { bash: "readonly", unattended: "stop" },
       agents: { maxConcurrent: 3, dirs: [] },
-      subagents: { maxConcurrent: 4, maxPending: 16 },
+      subagents: { maxConcurrent: 4, maxPending: 16, background: "auto", autoBackgroundAfterMs: 0 },
       reminders: { todo: true, fileChanges: true, contextPressure: true, budget: true },
       todo: { reminder: 10 }
     };
@@ -35244,7 +35585,13 @@ function w5Sections() {
         }
       }
     ),
-    subagents: object({ maxConcurrent: num2(1, 64), maxPending: num2(0, 1024), defaultModel: str3() }),
+    subagents: object({
+      maxConcurrent: num2(1, 64),
+      maxPending: num2(0, 1024),
+      defaultModel: str3(),
+      background: oneOf(SUBAGENT_BACKGROUND_MODES),
+      autoBackgroundAfterMs: num2(0)
+    }),
     models: object({ aliases: object({ fast: str3(), strong: str3() }), enabled: strings2 }),
     fallbackModel: str3(),
     limits: object({ maxTurns: num2(1), maxCostUsd: num2(0) }),
@@ -35359,6 +35706,7 @@ function buildBaseSchema() {
         quietStartup: oneOf(["normal", "header", "silent"]),
         ascii: bool(),
         compact: bool(),
+        logo: oneOf(["auto", "off"]),
         animation: bool(),
         restoreOnCancel: bool(),
         statusLine: oneOf(STATUS_LINE_MODES),
@@ -38404,7 +38752,7 @@ var init_auth2 = __esm({
         let pending = this.commandCache.get(key);
         if (!pending) {
           const timeout = this.options.commandTimeoutMs ?? 1e4;
-          pending = new Promise((resolve38) => {
+          pending = new Promise((resolve39) => {
             (0, import_node_child_process13.exec)(
               command3,
               { timeout, windowsHide: true, env: { ...this.env, ...extraEnv }, maxBuffer: 1 << 20 },
@@ -38412,8 +38760,8 @@ var init_auth2 = __esm({
                 const value = String(stdout).trim();
                 if (error2 || value.length === 0) {
                   this.warn(`api key command failed or printed nothing: ${command3.split(/\s+/)[0]}`);
-                  resolve38(void 0);
-                } else resolve38(value);
+                  resolve39(void 0);
+                } else resolve39(value);
               }
             );
           });
@@ -39371,6 +39719,7 @@ var init_settings_registry = __esm({
       row("ui.showThinking", "ui", "now", "any"),
       row("ui.compact", "ui", "now", "any"),
       row("ui.animation", "ui", "now", "any"),
+      row("ui.logo", "ui", "restart", "any"),
       row("ui.statusLine", "ui", "now", "any"),
       row("ui.restoreOnCancel", "ui", "nextSession", "any"),
       row("ui.quietStartup", "ui", "restart", "any"),
@@ -39432,6 +39781,9 @@ var init_settings_registry = __esm({
       row("agents.sessionBudgetUsd", "agents", "nextSession", "deny", { kind: "optionalNumber" }),
       row("subagents.maxConcurrent", "agents", "nextSession", "deny"),
       row("subagents.maxPending", "agents", "nextSession", "deny"),
+      // [W7-B2] 改 task 工具描述（缺省后台 / 前台两种文案），故 prefix
+      row("subagents.background", "agents", "restart", "any", { prefix: true }),
+      row("subagents.autoBackgroundAfterMs", "agents", "restart", "any"),
       // [W6-M]
       row("memory.enabled", "memory", "nextSession", "tighten", { envOverride: "AMA_MEMORY" }),
       row("memory.subagents", "memory", "nextSession", "deny")
@@ -41134,10 +41486,15 @@ var init_keybindings = __esm({
       /** [W5-U] 粘贴剪贴板图片（写进数据目录，输入框插入 `@路径`）。 */
       "app.paste.image": ["ctrl+v"],
       /**
-       * [W6-A] 进入 Agent 栏：只在输入为空时生效（有字时 `Ctrl+B` 仍是光标左移、`↓` 仍是下移 / 历史）；
-       * `↓` 另要求栏可见。tmux 缺省前缀吃掉 `Ctrl+B` 时用 `↓`。
+       * [W6-A / W7-A] 进入 Agent 栏：输入为空、补全未开、有子 Agent 任务即可（不要求栏可见）；有字时 `↓` 仍是
+       * 下移 / 历史，并给一次提示。`Ctrl+B` 不再进栏（tmux 缺省前缀会吃掉它），留给 `app.tasks.background`。
+       */
+      "app.agents.focus": ["down"],
+      /**
+       * [W7-C] 有阻塞中的前台子 Agent 任务（或 `task_ctl wait`）时全部转后台，不看输入框；没有时落回编辑器
+       * （`tui.editor.cursorLeft` 的 `ctrl+b`）。tmux 里按 `C-b C-b` 透传。
        */
-      "app.agents.focus": ["ctrl+b", "down"]
+      "app.tasks.background": ["ctrl+b"]
     };
     Keybindings = class {
       table;
@@ -42317,6 +42674,10 @@ var init_editor = __esm({
       get isCompletionOpen() {
         return this.completion !== null;
       }
+      /** 正在用 ↑↓ 浏览输入历史（编辑后即退出）。 */
+      get isBrowsingHistory() {
+        return this.historyIndex !== -1;
+      }
       getHistory() {
         return this.history;
       }
@@ -42819,6 +43180,9 @@ var init_spacer = __esm({
 });
 
 // src/tui/components/loader.ts
+function sameList(a, b) {
+  return a.length === b.length && a.every((e, i) => e === b[i]);
+}
 function formatElapsed(ms) {
   const total = Math.max(0, Math.floor(ms / 1e3));
   if (total < 60) return `${total}s`;
@@ -42848,6 +43212,7 @@ var init_loader = __esm({
       startedAt;
       verb;
       extras = [];
+      optional = [];
       verbElapsed;
       lastElapsed = "";
       listeners = /* @__PURE__ */ new Set();
@@ -42873,10 +43238,11 @@ var init_loader = __esm({
       }
       /** 换动词与附加项（附加项 dim，排在已用时之后）。 */
       setVerb(verb, extras = [], options = {}) {
-        const same2 = verb === this.verb && options.elapsed === this.verbElapsed && extras.length === this.extras.length && extras.every((e, i) => e === this.extras[i]);
+        const same2 = verb === this.verb && options.elapsed === this.verbElapsed && sameList(extras, this.extras) && sameList(options.optional ?? [], this.optional);
         if (same2) return;
         this.verb = verb;
         this.extras = [...extras];
+        this.optional = [...options.optional ?? []];
         this.verbElapsed = options.elapsed;
         this.requestRender();
       }
@@ -42936,7 +43302,13 @@ var init_loader = __esm({
         if (this.verbElapsed ?? this.options.showElapsed !== false) parts.push(dim(elapsed));
         for (const extra of this.extras) parts.push(dim(extra));
         const spinner = theme ? theme.fg("accent", this.frame) : this.frame;
-        return [truncateToWidth(`${spinner} ${parts.join(dim(" · "))}`, width2)];
+        const line2 = (items) => `${spinner} ${items.join(dim(" · "))}`;
+        for (const extra of this.optional) {
+          const next = [...parts, dim(extra)];
+          if (visibleWidth(line2(next)) > width2) break;
+          parts.push(dim(extra));
+        }
+        return [truncateToWidth(line2(parts), width2)];
       }
       invalidate() {
       }
@@ -43027,13 +43399,13 @@ var init_meter = __esm({
       render(width2) {
         const { theme, label: label2, cells = 10 } = this.options;
         const ratio = this.value === void 0 ? void 0 : Math.min(1, Math.max(0, this.value));
-        const percent2 = ratio === void 0 ? "—" : `${Math.round(ratio * 100)}%`;
+        const percent3 = ratio === void 0 ? "—" : `${Math.round(ratio * 100)}%`;
         const color = (c, text) => theme ? theme.fg(c, text) : text;
         const head = label2 === void 0 || label2 === "" ? "" : `${label2} `;
         const filled = ratio === void 0 ? 0 : Math.round(ratio * cells);
         const glyphs = theme?.glyphs ?? UNICODE_GLYPHS;
         const bar = color(this.level(), glyphs.meterFull.repeat(filled)) + color("dim", glyphs.meterEmpty.repeat(cells - filled));
-        const tail = color(ratio === void 0 ? "dim" : this.level(), percent2);
+        const tail = color(ratio === void 0 ? "dim" : this.level(), percent3);
         const full = `${head}${bar} ${tail}`;
         if (visibleWidth(full) <= width2) return [full];
         return [truncateToWidth(`${head}${tail}`, width2)];
@@ -43229,7 +43601,7 @@ function promptChoice(options) {
 `);
     drawn = lines2.length;
   };
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     const wasRaw = input2.isRaw === true;
     let done = false;
     const restore = () => {
@@ -43246,7 +43618,7 @@ function promptChoice(options) {
       draw([`${question} ${theme.fg("dim", answer)}`]);
       restore();
       input2.pause?.();
-      resolve38(index2);
+      resolve39(index2);
     };
     const onKey = (key) => {
       const letter = /^[a-z]$/i.test(key) ? key.toLowerCase() : "";
@@ -44303,12 +44675,12 @@ function cacheMissNotice(miss) {
 }
 function contextPressureNotice(event) {
   const m = msg().report.cache;
-  const percent2 = Math.round(event.percent);
+  const percent3 = Math.round(event.percent);
   if (event.estimatedTurnsLeft !== void 0)
-    return m.pressureTurns(percent2, event.estimatedTurnsLeft);
+    return m.pressureTurns(percent3, event.estimatedTurnsLeft);
   if (event.remainingTokens !== void 0)
-    return m.pressureTokens(percent2, formatTokenCount(event.remainingTokens));
-  return m.pressure(percent2);
+    return m.pressureTokens(percent3, formatTokenCount(event.remainingTokens));
+  return m.pressure(percent3);
 }
 function cacheEventNotice(event, enabled) {
   if (!enabled) return void 0;
@@ -44468,7 +44840,7 @@ function describeSession(session, now = Date.now()) {
   const stats = session.getStats();
   const model = state.model === void 0 ? "?" : `${state.model.provider}/${state.model.id}`;
   const t = stats.tokens;
-  const percent2 = stats.contextPercent === void 0 ? "?" : `${Math.round(stats.contextPercent)}`;
+  const percent3 = stats.contextPercent === void 0 ? "?" : `${Math.round(stats.contextPercent)}`;
   const m = msg().report.session;
   const rows = [
     { key: m.keySession, value: m.session(state.sessionId, state.sessionFile) },
@@ -44495,7 +44867,7 @@ function describeSession(session, now = Date.now()) {
       value: m.context(
         String(stats.contextTokens ?? "?"),
         String(stats.contextWindow ?? "?"),
-        percent2
+        percent3
       )
     }
   ];
@@ -44541,6 +44913,115 @@ var init_session_report = __esm({
   }
 });
 
+// src/modes/interactive/status-quota.ts
+function formatRemaining(ms, tight = false) {
+  const minutes = Math.max(0, Math.floor(ms / 6e4));
+  const days = Math.floor(minutes / 1440);
+  const hours = Math.floor(minutes % 1440 / 60);
+  const sep5 = tight ? "" : " ";
+  if (days > 0) return `${days}d${sep5}${hours}h`;
+  if (hours > 0) return `${hours}h${sep5}${minutes % 60}m`;
+  return `${minutes}m`;
+}
+function windowSpan(minutes) {
+  if (minutes % 1440 === 0) return `${minutes / 1440}d`;
+  if (minutes % 60 === 0) 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 === void 0 || 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 shortLabel(w, which) {
+  const m = msg().interactive.statusLine.quota;
+  const minutes = w.windowMinutes;
+  if (minutes === FIVE_HOURS || minutes === void 0 && which === "primary") return m.short5h;
+  if (minutes === WEEK || minutes === void 0 && which === "secondary") return m.shortWeek;
+  return windowSpan(minutes);
+}
+function percent2(theme, used, decimal) {
+  return theme.fg(levelColor(used / 100), decimal ? `${used.toFixed(1)}%` : `${Math.round(used)}%`);
+}
+function windows(quota) {
+  const out = [];
+  if (quota.primary !== void 0) out.push(["primary", quota.primary]);
+  if (quota.secondary !== void 0) out.push(["secondary", quota.secondary]);
+  return out;
+}
+function compactQuotaItem(quota, theme) {
+  const dim = (text) => theme.fg("dim", text);
+  const items = windows(quota).map(
+    ([which, w]) => `${dim(shortLabel(w, which))} ${percent2(theme, w.usedPercent, false)}`
+  );
+  return items.length === 0 ? void 0 : items.join(" ");
+}
+function quotaParts2(quota, width2, now, theme) {
+  const dim = (text) => theme.fg("dim", text);
+  const narrow = width2 < QUOTA_NARROW_WIDTH;
+  const parts = [];
+  windows(quota).forEach(([which, w], i) => {
+    const first = i === 0;
+    const group = narrow ? which : void 0;
+    const name = narrow ? `${shortLabel(w, which)} ` : labels(w, which).pct;
+    parts.push({
+      text: dim(name) + percent2(theme, w.usedPercent, !narrow),
+      priority: first ? void 0 : 2,
+      zone: "left",
+      ...group !== void 0 ? { group } : {}
+    });
+    if (w.resetsAt === void 0) return;
+    const left = formatRemaining(w.resetsAt - now, narrow);
+    parts.push({
+      text: narrow ? theme.fg("tool", `${theme.glyphs.retry}${left}`) : dim(labels(w, which).reset) + theme.fg("tool", left),
+      priority: first ? 3 : 1,
+      zone: "left",
+      // 宽格式按最宽形状占位（`23h 59m`），数值变化不让某项时有时无
+      reserve: narrow ? 0 : visibleWidth(labels(w, which).reset) + 7,
+      ...group !== void 0 ? { group } : {}
+    });
+  });
+  return parts;
+}
+var QUOTA_NARROW_WIDTH, FIVE_HOURS, WEEK, QuotaLine;
+var init_status_quota = __esm({
+  "src/modes/interactive/status-quota.ts"() {
+    "use strict";
+    init_i18n();
+    init_tui2();
+    init_status_bar();
+    QUOTA_NARROW_WIDTH = 80;
+    FIVE_HOURS = 300;
+    WEEK = 10080;
+    QuotaLine = class {
+      constructor(source, theme) {
+        this.source = source;
+        this.theme = theme;
+      }
+      source;
+      theme;
+      render(width2) {
+        if (this.source.layout() !== "full") return [];
+        const view = this.source.quota();
+        if (view === void 0) return [];
+        const theme = this.theme;
+        if (view === "pending") {
+          return [truncateToWidth(theme.fg("dim", msg().interactive.statusLine.quota.pending), width2)];
+        }
+        const parts = quotaParts2(view.quota, width2, this.source.now(), theme);
+        if (parts.length === 0) return [];
+        const sep5 = width2 < QUOTA_NARROW_WIDTH ? " · " : " | ";
+        return [layoutRow(parts, width2, theme, { sep: sep5 })];
+      }
+      invalidate() {
+      }
+    };
+  }
+});
+
 // src/modes/interactive/status-bar.ts
 function formatTokens3(count2) {
   if (count2 < 1e3) return String(count2);
@@ -44672,6 +45153,7 @@ var init_status_bar = __esm({
     init_i18n();
     init_modes();
     init_channels();
+    init_status_quota();
     init_tui2();
     MIN_GAP = 4;
     METER_WIDTH = 110;
@@ -44691,7 +45173,8 @@ var init_status_bar = __esm({
       rebill: 13,
       preset: 14,
       host: 15,
-      hint: 16
+      hint: 16,
+      quota: 17
     };
     FULL = { model: 0, ctx: 1, cost: 2, duration: 3, branch: 4, dir: 5, diff: 6, thinking: 7 };
     FULL_HINT = 12;
@@ -44751,7 +45234,8 @@ var init_status_bar = __esm({
         const modelText = fallback === void 0 ? theme.fg("accent", model) : theme.fg("accent", abbreviateModel(fallback.from, width2)) + dim(g.ascii ? " -> " : " → ") + theme.fg("warning", abbreviateModel(fallback.to, width2));
         right(modelText, p.model, full ? { group: "model" } : {});
         if (state.thinkingLevel !== "off") {
-          right(dim(state.thinkingLevel), p.thinking, full ? { group: "model" } : {});
+          const level = full ? theme.fg("user", state.thinkingLevel) : dim(state.thinkingLevel);
+          right(level, p.thinking, full ? { group: "model" } : {});
         }
         const usage = full ? {} : usageItems(stats, this.queue, this.source, theme);
         if (usage.tokens !== void 0) right(usage.tokens, COMPACT.tokens);
@@ -44764,50 +45248,71 @@ var init_status_bar = __esm({
           const cost2 = statusCost(stats);
           const used = stats.tokens.input + stats.tokens.output + stats.tokens.cacheRead > 0;
           if (cost2 === void 0 && used) right(dim("$?"), FULL.cost);
-          else if (cost2 !== void 0 && cost2 > 0) right(dim(formatCost(cost2)), FULL.cost);
+          else if (cost2 !== void 0 && cost2 > 0) {
+            right(theme.fg("warning", formatCost(cost2)), FULL.cost);
+          }
         }
         const started = this.source.sessionStartedAt?.() ?? stats.telemetry?.sessionStartedAt;
         if (started !== void 0) {
           const now = this.source.now?.() ?? Date.now();
-          right(dim(formatDuration4(now - started)), p.duration, { reserve: 6 });
+          const text = formatDuration4(now - started);
+          right(full ? theme.fg("tool", text) : dim(text), p.duration, { reserve: 6 });
         }
         if (usage.queue !== void 0) right(usage.queue, COMPACT.queue);
         if (usage.codemode !== void 0) right(usage.codemode, COMPACT.codemode);
         if (usage.sandbox !== void 0) right(usage.sandbox, COMPACT.codemode);
         if (usage.preset !== void 0) right(usage.preset, COMPACT.preset);
         if (usage.host !== void 0) right(usage.host, COMPACT.host);
+        const quota = full ? void 0 : this.source.quota?.();
+        const quotaItem = typeof quota === "object" ? compactQuotaItem(quota.quota, theme) : void 0;
+        if (quotaItem !== void 0) right(quotaItem, COMPACT.quota);
         return parts;
       }
-      /** `目录 ⎇ 分支 短提交 +a −b`：三项同组、各自按优先级丢弃。 */
+      /** `目录 ⎇ 分支 短提交 +a −b`：三项同组、各自按优先级丢弃；full 另带 `↑N ↓N` 并按参考配色。 */
       gitParts(p, full) {
         const git = this.source.git?.();
         if (git === void 0) return [];
         const theme = this.theme;
         const g = theme.glyphs;
         const dim = (text) => theme.fg("dim", text);
+        const ok = (text) => full ? theme.fg("success", text) : dim(text);
         const out = [];
-        const add3 = (text, priority) => void out.push({ text: dim(text), priority, zone: "right", group: "git" });
-        if (git.dir !== "") add3(git.dir, p.dir);
+        const add3 = (text, priority) => void out.push({ text, priority, zone: "right", group: "git" });
+        if (git.dir !== "") add3(ok(git.dir), p.dir);
         const info2 = git.info;
         if (info2 === void 0) return out;
-        const head = [info2.branch, info2.shortHead].filter((s2) => s2 !== void 0).join(" ");
-        if (head !== "") add3(`${g.branch} ${head}`, p.branch);
+        const head = [];
+        if (info2.branch !== void 0) head.push(ok(info2.branch));
+        if (info2.shortHead !== void 0) head.push(dim(info2.shortHead));
+        if (full && info2.ahead !== void 0 && info2.ahead > 0) {
+          head.push(theme.fg("code", `${g.arrowUp}${info2.ahead}`));
+        }
+        if (full && info2.behind !== void 0 && info2.behind > 0) {
+          head.push(theme.fg("error", `${g.arrowDown}${info2.behind}`));
+        }
+        if (!full) {
+          const text = [info2.branch, info2.shortHead].filter((s2) => s2 !== void 0).join(" ");
+          if (text !== "") add3(dim(`${g.branch} ${text}`), p.branch);
+        } else if (head.length > 0) add3(`${dim(g.branch)} ${head.join(" ")}`, p.branch);
         if (info2.insertions !== void 0 && info2.deletions !== void 0) {
           const { insertions: a, deletions: d } = info2;
-          add3(full ? `(+${a},-${d})` : `+${a} ${g.ascii ? "-" : "−"}${d}`, p.diff);
+          add3(
+            full ? `${dim("(")}${theme.fg("success", `+${a}`)}${dim(",")}${theme.fg("error", `-${d}`)}${dim(")")}` : dim(`+${a} ${g.ascii ? "-" : "−"}${d}`),
+            p.diff
+          );
         }
         return out;
       }
-      ctxText(percent2, width2, decimal) {
+      ctxText(percent3, width2, decimal) {
         const theme = this.theme;
-        if (percent2 === void 0) return theme.fg("dim", decimal ? "Ctx ?" : "ctx ?");
-        const color = levelColor(percent2 / 100);
+        if (percent3 === void 0) return theme.fg("dim", decimal ? "Ctx ?" : "ctx ?");
+        const color = levelColor(percent3 / 100);
         if (!decimal && width2 >= METER_WIDTH) {
-          const meter = new Meter(percent2 / 100, { label: theme.fg("dim", "ctx"), theme });
+          const meter = new Meter(percent3 / 100, { label: theme.fg("dim", "ctx"), theme });
           return meter.render(80)[0] ?? "";
         }
-        if (decimal) return theme.fg("dim", "Ctx ") + theme.fg(color, `${percent2.toFixed(1)}%`);
-        return theme.fg("dim", "ctx ") + theme.fg(color, `${Math.round(percent2)}%`);
+        if (decimal) return theme.fg("dim", "Ctx ") + theme.fg(color, `${percent3.toFixed(1)}%`);
+        return theme.fg("dim", "ctx ") + theme.fg(color, `${Math.round(percent3)}%`);
       }
       render(width2) {
         const style = this.layout() === "full" ? FULL_STYLE : {};
@@ -46358,7 +46863,7 @@ async function runSandbox(request) {
   let stderr = "";
   let settled = false;
   let finish2;
-  const finished = new Promise((resolve38) => finish2 = resolve38);
+  const finished = new Promise((resolve39) => finish2 = resolve39);
   const write2 = (message) => {
     if (child.stdin.destroyed || !child.stdin.writable) return;
     child.stdin.write(encodeLine(message));
@@ -47246,7 +47751,8 @@ __export(print_mode_exports, {
   joinPrompt: () => joinPrompt,
   readPromptStdin: () => readPromptStdin,
   runPrintMode: () => runPrintMode,
-  stdinWaitMs: () => stdinWaitMs
+  stdinWaitMs: () => stdinWaitMs,
+  waitBackgroundTasks: () => waitBackgroundTasks
 });
 function joinPrompt(argument, piped) {
   const parts = [argument ?? "", piped.replace(/\s+$/, "")].filter((p) => p.trim() !== "");
@@ -47260,12 +47766,12 @@ function stdinWaitMs(env) {
 }
 function readWithin(io, ms) {
   if (io.readStdinFirstByte !== void 0) return io.readStdinFirstByte(ms);
-  return new Promise((resolve38, reject2) => {
-    const timer = setTimeout(() => resolve38(void 0), ms);
+  return new Promise((resolve39, reject2) => {
+    const timer = setTimeout(() => resolve39(void 0), ms);
     io.readStdin().then(
       (text) => {
         clearTimeout(timer);
-        resolve38(text);
+        resolve39(text);
       },
       (error2) => {
         clearTimeout(timer);
@@ -47328,9 +47834,15 @@ async function runPrintMode(runtime, context) {
   const denied = [];
   let limit;
   let plan2;
+  let stopWaiting = () => void 0;
+  const stopped = new Promise((resolve39) => {
+    stopWaiting = resolve39;
+  });
   const unsubscribe = session.subscribe((event) => {
-    if (event.type === "limit_reached") limit ??= event;
-    else if (event.type === "plan_proposed") plan2 = event;
+    if (event.type === "limit_reached") {
+      limit ??= event;
+      stopWaiting();
+    } else if (event.type === "plan_proposed") plan2 = event;
     else if (event.type === "plan_resolved" && event.planId === plan2?.planId) plan2 = void 0;
     if (event.type === "tool_execution_end" && event.denied === true)
       denied.push({
@@ -47353,16 +47865,21 @@ async function runPrintMode(runtime, context) {
   let signalled;
   const offSignals = onTerminationSignals((code) => {
     signalled ??= code;
+    stopWaiting();
     void session.abort();
   });
   let stdoutClosed = false;
   const offEpipe = onStdoutClosed(() => {
     stdoutClosed = true;
+    stopWaiting();
     void session.abort();
   });
   let failure2;
   try {
     await session.prompt(prompt, images.length > 0 ? { images } : {});
+    const ended = lastAssistant(session)?.stopReason;
+    if (signalled === void 0 && !stdoutClosed && limit === void 0 && ended !== "error" && ended !== "aborted")
+      await waitBackgroundTasks(session, stopped, io);
   } catch (error2) {
     failure2 = errorText3(error2);
   } finally {
@@ -47393,6 +47910,7 @@ async function runPrintMode(runtime, context) {
         cost: stats.cost,
         cacheHitRate: stats.cacheHitRate,
         ...stats.cache !== void 0 ? { cache: stats.cache } : {},
+        ...stats.tasks !== void 0 ? { tasks: stats.tasks } : {},
         ...denied.length > 0 ? { deniedTools: denied } : {},
         ...plan2 !== void 0 ? {
           planPending: {
@@ -47439,6 +47957,13 @@ async function runPrintMode(runtime, context) {
   if (denied.length > 0) return ExitCode.ToolDenied;
   return ExitCode.Ok;
 }
+async function waitBackgroundTasks(session, stopped, io) {
+  const registry2 = registryOf(session.state.sessionId);
+  if (registry2 === void 0) return;
+  const running = registry2.list().filter((task) => task.status === "running").length;
+  if (running > 0) io.stderr(msg().print.print.waitingTasks(running));
+  await Promise.race([registry2.settled(), stopped]);
+}
 function describePlanPending(plan2) {
   const where = plan2.filePath ?? plan2.planId;
   return msg().print.print.planPending(plan2.version, where);
@@ -47467,6 +47992,7 @@ var init_print_mode = __esm({
     init_shared2();
     init_json_event();
     init_limits();
+    init_subagent_registry();
     init_image_input();
     init_i18n();
     STDIN_WAIT_HINT_MS = 3e3;
@@ -48266,6 +48792,59 @@ var init_tasks_report = __esm({
   }
 });
 
+// src/modes/interactive/task-background.ts
+function blockingTasks2(session) {
+  return registryOf(session.state.sessionId)?.blocking() ?? [];
+}
+function backgroundTasks(session, taskId) {
+  if (taskId === void 0 && blockingTasks2(session).length === 0) return [];
+  return session.backgroundTask(taskId, "user");
+}
+function runningBackground(session) {
+  const registry2 = registryOf(session.state.sessionId);
+  if (registry2 === void 0) return [];
+  return registry2.list().filter((task) => task.status === "running" && task.background).map((task) => task.taskId);
+}
+function backgroundedText2(ids) {
+  const m = msg().agents.background;
+  return ids.length === 0 ? m.none : m.done(ids.join(", "));
+}
+function keyLabel(keys, action) {
+  const id = keys.keys(action)[0];
+  if (id === void 0) return void 0;
+  return id.split("+").map(
+    (part) => part.length === 1 ? part.toUpperCase() : part[0].toUpperCase() + part.slice(1)
+  ).join("+");
+}
+var STOP_CONFIRM_MS, StopArm;
+var init_task_background = __esm({
+  "src/modes/interactive/task-background.ts"() {
+    "use strict";
+    init_subagent_registry();
+    init_i18n();
+    STOP_CONFIRM_MS = 1500;
+    StopArm = class {
+      constructor(windowMs = STOP_CONFIRM_MS) {
+        this.windowMs = windowMs;
+      }
+      windowMs;
+      armed;
+      press(taskId, now) {
+        const armed = this.armed;
+        if (armed !== void 0 && armed.taskId === taskId && now - armed.at < this.windowMs) {
+          this.armed = void 0;
+          return "stop";
+        }
+        this.armed = { taskId, at: now };
+        return "arm";
+      }
+      reset() {
+        this.armed = void 0;
+      }
+    };
+  }
+});
+
 // src/modes/commands-core.ts
 function command(name, key, args) {
   const info2 = {
@@ -48313,10 +48892,13 @@ function cacheCommand(session, args) {
   }
   throw new AmaError("invalid_arguments", msg().report.command.cacheUsage);
 }
-async function tasksCommand(sessionId, args) {
+async function tasksCommand(session, args) {
+  const sessionId = session.state.sessionId;
   const [first, second, extra] = args.split(/\s+/).filter((s2) => s2 !== "");
   const now = Date.now();
   if (first === void 0) return describeTasks(sessionId, now);
+  if (first === "bg" && extra === void 0)
+    return backgroundedText2(backgroundTasks(session, second));
   if (first === "stop" && second !== void 0 && extra === void 0) {
     await stopTask(sessionId, second);
     return msg().report.command.taskStopped(second);
@@ -48441,7 +49023,7 @@ async function runSlashCommand(line2, ctx) {
     case "plan":
       return planCommand(session, args, ctx);
     case "tasks":
-      return { kind: "handled", message: await tasksCommand(session.state.sessionId, args) };
+      return { kind: "handled", message: await tasksCommand(session, args) };
     case "agents":
       return { kind: "handled", message: describeAgents(session.state.sessionId) };
     case "paste": {
@@ -48475,6 +49057,7 @@ var init_commands_core = __esm({
     init_plan_command();
     init_rewind_command();
     init_tasks_report();
+    init_task_background();
     init_session_report();
     init_i18n();
     BUILTIN_COMMANDS = [
@@ -48493,7 +49076,7 @@ var init_commands_core = __esm({
       command("cache", "cache", "[warm off|streaming|idle | fingerprint]"),
       command("statusline", "statusline", "[full|compact]"),
       command("plan", "plan", { key: "planArgs" }),
-      command("tasks", "tasks", "[id] | stop <id>"),
+      command("tasks", "tasks", "[id] | stop <id> | bg [id]"),
       command("agents", "agents"),
       command("paste", "paste"),
       command("exit", "exit"),
@@ -48550,9 +49133,9 @@ async function startRun(ctx, run7) {
   const session = ctx.session();
   let settled = false;
   let off = () => void 0;
-  const started = new Promise((resolve38) => {
+  const started = new Promise((resolve39) => {
     off = session.subscribe((event) => {
-      if (event.type === "before_agent_start" || event.type === "agent_start") resolve38("started");
+      if (event.type === "before_agent_start" || event.type === "agent_start") resolve39("started");
     });
   });
   const running = run7().finally(() => {
@@ -48635,11 +49218,11 @@ var init_commands = __esm({
           this.early.delete(request.requestId);
           return Promise.resolve(ready);
         }
-        return new Promise((resolve38) => {
+        return new Promise((resolve39) => {
           const done = (decision) => {
             this.pending.delete(request.requestId);
             signal.removeEventListener("abort", onAbort);
-            resolve38(decision);
+            resolve39(decision);
           };
           const onAbort = () => done(void 0);
           if (signal.aborted) return done(void 0);
@@ -48649,9 +49232,9 @@ var init_commands = __esm({
       }
       /** 返回 false = 当前没有在等这个 requestId（已暂存，稍后被问到时生效）。 */
       respond(requestId, decision) {
-        const resolve38 = this.pending.get(requestId);
-        if (resolve38 !== void 0) {
-          resolve38(decision);
+        const resolve39 = this.pending.get(requestId);
+        if (resolve39 !== void 0) {
+          resolve39(decision);
           return true;
         }
         this.early.set(requestId, decision);
@@ -48659,7 +49242,7 @@ var init_commands = __esm({
       }
       /** 关 stdin / 撤下时：全部弃权（会话按无人作答 deny）。 */
       cancelAll() {
-        for (const resolve38 of [...this.pending.values()]) resolve38(void 0);
+        for (const resolve39 of [...this.pending.values()]) resolve39(void 0);
         this.early.clear();
       }
     };
@@ -48818,7 +49401,14 @@ var init_commands = __esm({
       get_tasks: async (_p, ctx) => ({ tasks: [...ctx.tasks?.()?.list() ?? []] }),
       get_agents: async (_p, ctx) => ({ agents: [...ctx.agents?.() ?? []] }),
       // [W6-T2] 轨迹（docs/wave6-plan.md §2.6；分页 / 增量 / 脱敏见 trace/query.ts）
-      get_trace: async (p, ctx) => sessionTrace(ctx.session(), p ?? {})
+      get_trace: async (p, ctx) => sessionTrace(ctx.session(), p ?? {}),
+      // [W7-B2] 前台任务转后台：工具调用立即返回、任务继续，完成后照常通知
+      background_task: async (p, ctx) => {
+        const taskId = p?.taskId;
+        if (taskId !== void 0 && typeof taskId !== "string")
+          throw new AmaError("invalid_arguments", msg().print.rpc.badTaskId);
+        return { backgrounded: ctx.session().backgroundTask(taskId) };
+      }
     };
     RPC_COMMAND_TYPES = Object.keys(handlers);
   }
@@ -48937,7 +49527,7 @@ async function runRpcMode(runtime, context, options = {}) {
     const task = respond(command3).finally(() => inflight2.delete(task));
     inflight2.add(task);
   };
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     let finished = false;
     const finish2 = async (code, abort) => {
       if (finished) return;
@@ -48953,7 +49543,7 @@ async function runRpcMode(runtime, context, options = {}) {
       unsubscribe();
       runtime.notifier.set(void 0);
       await writing;
-      resolve38(code);
+      resolve39(code);
     };
     const reader = createLineReader(stdin, onLine, () => void finish2(ExitCode.Ok, false));
     const offSignals = onTerminationSignals((code) => {
@@ -49023,8 +49613,8 @@ function startupScreenLevel(runtime) {
   return runtime.config.ui?.quietStartup ?? "normal";
 }
 function trustSourceLabel(source) {
-  const labels = msg().cli.startupScreen.trustSource;
-  return source === "trust-file" ? labels.trustFile : labels[source];
+  const labels2 = msg().cli.startupScreen.trustSource;
+  return source === "trust-file" ? labels2.trustFile : labels2[source];
 }
 function tildePath(path, home) {
   if (home === void 0 || home === "") return path;
@@ -49092,7 +49682,7 @@ function blockedReason(spec2, value, scope) {
 }
 function settingRows(snapshot2, scope, theme) {
   const s2 = msg().settings;
-  const labels = s2.labels;
+  const labels2 = s2.labels;
   const rows = settingsRegistry().map((spec2) => {
     const value = getConfigValue(snapshot2, spec2.key);
     const locked = overriddenFor(value, scope) !== void 0;
@@ -49107,7 +49697,7 @@ function settingRows(snapshot2, scope, theme) {
     const row3 = {
       id: spec2.key,
       group: s2.groups[spec2.group],
-      label: labels[spec2.key] ?? spec2.key,
+      label: labels2[spec2.key] ?? spec2.key,
       value: settingValueText(spec2, value, theme),
       tag,
       search: [...spec2.options ?? [], settingDoc(spec2.key) ?? ""].join(" ")
@@ -49342,14 +49932,14 @@ var init_config_panel = __esm({
 
 // src/modes/interactive/confirm-dialog.ts
 function openChoice(host, spec2) {
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     let handle;
     let settled = false;
     const dialog = new ChoiceDialog(spec2, host, (index2) => {
       if (settled) return;
       settled = true;
       handle?.hide();
-      resolve38(index2);
+      resolve39(index2);
     });
     handle = host.showOverlay(
       new Box(dialog, {
@@ -49541,6 +50131,12 @@ var init_subagent_view = __esm({
             }
             return state;
           }
+          case "subagent_background": {
+            const state = this.tasks.get(event.taskId);
+            if (state === void 0) return void 0;
+            state.background = true;
+            return state;
+          }
           case "subagent_end": {
             const state = this.tasks.get(event.taskId);
             if (state === void 0) return void 0;
@@ -49613,8 +50209,8 @@ function exitSummaryLines(stats, elapsedMs, theme) {
   return lines2;
 }
 function originLabel(origin) {
-  const labels = msg().interactive.view.message.origin;
-  return labels[origin] ?? origin;
+  const labels2 = msg().interactive.view.message.origin;
+  return labels2[origin] ?? origin;
 }
 function displayText(text) {
   return text.includes("proposed_plan>") ? text.replace(PLAN_TAG_LINE, "") : text;
@@ -50027,11 +50623,11 @@ function pickerFooter(arrows = "↑↓") {
   return msg().panels.picker.footer(arrows);
 }
 function openPicker(host, spec2) {
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     let handle;
     const close = (item) => {
       handle?.hide();
-      resolve38(item);
+      resolve39(item);
     };
     const list5 = new SelectList(spec2.items, {
       theme: host.theme,
@@ -51003,8 +51599,8 @@ var init_line_editor = __esm({
       ask(question, fallback) {
         this.hide();
         this.options.write(question);
-        return new Promise((resolve38) => {
-          this.question = { resolve: resolve38, fallback };
+        return new Promise((resolve39) => {
+          this.question = { resolve: resolve39, fallback };
         });
       }
       feed(data2) {
@@ -51323,6 +51919,12 @@ var init_tool_view = __esm({
           );
         }
         const result = this.result;
+        const moved = this.backgrounded();
+        if (moved !== void 0) {
+          const m = msg().agents.background;
+          const text2 = moved ? m.moved(formatElapsed(this.elapsedMs)) : m.started;
+          return truncateToWidth(lead + theme.fg("muted", text2), width2);
+        }
         const text = resultSummary(
           {
             name: this.toolName,
@@ -51337,6 +51939,17 @@ var init_tool_view = __esm({
         );
         return truncateToWidth(lead + text, width2);
       }
+      /**
+       * [W7-C] task 已返回、任务仍在后台跑：true = 前台转后台（固定英文结果文本），false = 直接后台；
+       * 其它情况 undefined。
+       */
+      backgrounded() {
+        const result = this.result;
+        if (this.toolName !== "task" || this.state !== "done" || result === void 0) return void 0;
+        const details = result.details;
+        if (details?.status !== "running") return void 0;
+        return /moved to the background/i.test(contentText3(result.content));
+      }
       /** 后台子 Agent：结果摘要下一行跟随状态 `    ↳ t2 explore · 完成 2m · 7 轮 …`。 */
       followLine(width2) {
         const sub = this.subagentState();
@@ -51429,6 +52042,7 @@ var init_tool_view = __esm({
           }
           return out;
         }
+        if (!this.expanded && this.backgrounded() !== void 0) return out;
         const custom = this.customResult(width2);
         if (custom !== void 0) return [...out, ...custom];
         const diff = this.state === "done" ? diffOf(this.result) : void 0;
@@ -51808,7 +52422,7 @@ var init_approval_dialog = __esm({
       }
       ask(request, signal) {
         if (signal.aborted) return Promise.resolve(void 0);
-        return new Promise((resolve38) => {
+        return new Promise((resolve39) => {
           let handle;
           let settled = false;
           const settle = (decision) => {
@@ -51819,7 +52433,7 @@ var init_approval_dialog = __esm({
             this.open--;
             this.host.onClose?.();
             this.host.report?.(request, decision ?? "cancelled");
-            resolve38(decision);
+            resolve39(decision);
           };
           const onAbort = () => settle(void 0);
           const dialog = new ApprovalDialog(request, this.host, settle);
@@ -51874,6 +52488,10 @@ function backgroundJobText(event) {
       return m.backgroundStopped(event.jobId, short2);
   }
 }
+function subagentBackgroundText(event, agent) {
+  const m = msg().agents.background;
+  return event.reason === "timeout" ? m.timeout(event.taskId, agent) : m.host(event.taskId, agent);
+}
 var ImageBudgetNotices, LIMIT_WARNING;
 var init_event_notices = __esm({
   "src/modes/interactive/event-notices.ts"() {
@@ -52249,9 +52867,9 @@ ${bypassRiskLines().map((l) => `  ${l}
     return ed.ask(bypassLineQuestion(), "n").then((answer) => answer === "y");
   }, session.state.permissionMode === BYPASS_MODE);
   runtime.approvals.setUiBroker({
-    ask: (request, signal) => new Promise((resolve38) => {
-      if (signal.aborted) return resolve38(void 0);
-      signal.addEventListener("abort", () => resolve38(void 0), { once: true });
+    ask: (request, signal) => new Promise((resolve39) => {
+      if (signal.aborted) return resolve39(void 0);
+      signal.addEventListener("abort", () => resolve39(void 0), { once: true });
       const preview = previewDisplayLines(request.preview).map((l) => `  ${l}
 `);
       const question = approvalQuestion(
@@ -52260,7 +52878,7 @@ ${bypassRiskLines().map((l) => `  ${l}
       );
       void ed.ask(`
 ${preview.join("")}${question}`, "n").then((answer) => {
-        resolve38(answer === "y" ? "allow" : answer === "a" ? "allow_session" : "deny");
+        resolve39(answer === "y" ? "allow" : answer === "a" ? "allow_session" : "deny");
         if (!busy) ed.render();
       });
     })
@@ -52269,7 +52887,7 @@ ${preview.join("")}${question}`, "n").then((answer) => {
 `));
   let busy = false;
   let lastInterrupt = 0;
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     let finished = false;
     const finish2 = (code) => {
       if (finished) return;
@@ -52283,7 +52901,7 @@ ${preview.join("")}${question}`, "n").then((answer) => {
       runtime.notifier.set(void 0);
       void session.abort().catch(() => void 0).finally(() => {
         unsubscribe();
-        resolve38(code);
+        resolve39(code);
       });
     };
     const run7 = (text) => {
@@ -52315,6 +52933,10 @@ ${msg().interactive.line.ctrlCAgain}
           continue;
         }
         if (busy) {
+          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(() => void 0);
             out(`${msg().interactive.line.steer(action.text)}
@@ -52342,7 +52964,7 @@ ${msg().interactive.line.ctrlCAgain}
   });
 }
 function runPiped(stdin, context, handle, session, unsubscribe, failed4) {
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     let chain = Promise.resolve(void 0);
     let finished = false;
     const finish2 = (code) => {
@@ -52352,7 +52974,7 @@ function runPiped(stdin, context, handle, session, unsubscribe, failed4) {
       offSignals();
       stdin.pause?.();
       unsubscribe();
-      resolve38(code);
+      resolve39(code);
     };
     const enqueue = (line2) => {
       chain = chain.then((state) => state === "exit" ? state : handle(line2));
@@ -52573,7 +53195,11 @@ var init_agent_bar = __esm({
         const hidden = rows.length - shown2.length;
         const tail = [];
         if (hidden > 0) tail.push(m.bar.more(hidden));
-        if (focused) tail.push(m.bar.keys(t.glyphs.arrowUp, t.glyphs.arrowDown));
+        if (focused) {
+          const [up, down] = [t.glyphs.arrowUp, t.glyphs.arrowDown];
+          const full = [...tail, m.bar.keysFull(up, down)].join(" · ");
+          tail.push(visibleWidth(full) <= width2 ? m.bar.keysFull(up, down) : m.bar.keys(up, down));
+        }
         if (tail.length > 0)
           out.push(truncateToWidth(t.fg("dim", tail.join(" · ")), width2, t.glyphs.ellipsis));
         return out;
@@ -52584,7 +53210,9 @@ var init_agent_bar = __esm({
         const agent = agentLabel(row3);
         const lead = focused ? (selected ? t.fg("accent", g.prompt) : " ") + " " : "";
         const marker = t.fg(statusColor(row3.status), g.tool);
-        const id = selected ? t.bold(row3.taskId) : row3.taskId;
+        const approval = row3.status === "approval";
+        const plainId = selected || approval ? t.bold(row3.taskId) : row3.taskId;
+        const id = approval ? t.fg("warning", plainId) : plainId;
         const description = row3.description.replace(/\s+/g, " ").trim();
         const text = `${lead}${marker} ${id} ${t.fg("tool", agent)}` + t.fg("dim", " · ") + t.fg(row3.status === "approval" ? "warning" : "muted", rowFacts(row3)) + (description === "" ? "" : `  ${t.fg("dim", description)}`);
         return truncateToWidth(text, width2, g.ellipsis);
@@ -52782,6 +53410,7 @@ var init_agent_view = __esm({
     init_session_report();
     init_agent_bar();
     init_agent_transcript();
+    init_task_background();
     AgentView = class {
       constructor(taskId, deps) {
         this.taskId = taskId;
@@ -52897,7 +53526,10 @@ var init_agent_view = __esm({
         const taskId = this.taskId;
         if (trimmed.startsWith("/")) {
           const stop = /^\/tasks\s+stop(?:\s+(\S+))?\s*$/.exec(trimmed);
-          if (stop === null) this.flash = m.commandsHere;
+          const bg = /^\/tasks\s+bg(?:\s+(\S+))?\s*$/.exec(trimmed);
+          if (bg !== null && this.deps.background !== void 0)
+            this.flash = backgroundedText2(this.deps.background(bg[1] ?? taskId));
+          else if (stop === null) this.flash = m.commandsHere;
           else {
             const target = stop[1] ?? taskId;
             try {
@@ -52926,6 +53558,13 @@ var init_agent_view = __esm({
         const empty = this.editor.isEmpty();
         const id = parseKey(data2)?.id;
         this.flash = void 0;
+        if (keys.matches(data2, "app.tasks.background") && this.deps.background !== void 0) {
+          const moved = this.deps.background(this.taskId);
+          if (moved.length > 0) {
+            this.flash = backgroundedText2(moved);
+            return;
+          }
+        }
         if (keys.matches(data2, "tui.select.cancel") && !this.editor.isCompletionOpen) {
           if (!empty) this.editor.clear();
           else this.deps.close();
@@ -53364,7 +54003,7 @@ function mainOptions(ellipsis) {
   return [m.optionApprove, m.optionApproveFresh, m.optionRevise(ellipsis), m.optionReject];
 }
 function openPlanDialog(host, input2) {
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     let handle;
     let settled = false;
     const dialog = new PlanDialog(input2, host, (choice3) => {
@@ -53372,7 +54011,7 @@ function openPlanDialog(host, input2) {
       settled = true;
       handle?.hide();
       host.onClose?.();
-      resolve38(choice3);
+      resolve39(choice3);
     });
     host.onOpen?.();
     handle = host.showOverlay(
@@ -53579,10 +54218,10 @@ var init_plan_dialog = __esm({
         if (hidden > 0) out.push(theme.fg("dim", m.moreSteps(theme.glyphs.ellipsis, hidden)));
         return out;
       }
-      optionLines(labels, selected, width2) {
+      optionLines(labels2, selected, width2) {
         const { theme } = this.host;
         const g = theme.glyphs;
-        return labels.map((label2, i) => {
+        return labels2.map((label2, i) => {
           const on = i === selected;
           const text = `${on ? g.prompt : " "} ${i + 1}. ${label2}`;
           const line2 = padToWidth(
@@ -53754,6 +54393,7 @@ var init_agent_ui = __esm({
     init_external_editor();
     init_plan_flow();
     init_subagent_view();
+    init_task_background();
     init_tasks_report();
     TASK_NOTICE = /^\[task (t\d+)\] ([\s\S]*)$/;
     AgentUi = class {
@@ -53796,7 +54436,7 @@ var init_agent_ui = __esm({
       /** [W6-A] key-dispatch.ts 的 Agent 栏入口。 */
       keys = {
         handleKey: (data2) => this.barKey(data2),
-        focus: (data2) => this.focusFromKey(data2)
+        focus: () => this.focusFromKey()
       };
       view;
       /** 等审批的请求 → 任务。 */
@@ -53804,6 +54444,10 @@ var init_agent_ui = __esm({
       restoreLog;
       /** 后台子 Agent 运行中：每秒重画跟随行的耗时（主会话空闲时 Loader 不转）。 */
       ticker;
+      /** [W7-C] 后台任务的审批停靠（approval-ui.ts 建好后接上）。 */
+      dock;
+      /** [W7-C] 栏内 `x` 的双击确认。 */
+      stopArm = new StopArm();
       keybindings() {
         return this.deps.dialog.keybindings ?? defaultKeybindings;
       }
@@ -53820,6 +54464,7 @@ var init_agent_ui = __esm({
         if (viewing !== void 0) this.deps.notice("info", msg().agents.view.removed(viewing));
         this.bar.reset();
         this.approvals.clear();
+        this.dock?.reset();
         this.deps.subagents.clear();
         this.stopTicker();
         this.plan.attach(session);
@@ -53875,9 +54520,12 @@ var init_agent_ui = __esm({
         switch (event.type) {
           case "subagent_start":
           case "subagent_update":
+          case "subagent_background":
           case "subagent_end": {
             const state = this.deps.subagents.onEvent(event);
             if (state === void 0) return true;
+            if (event.type === "subagent_background" && event.reason !== "user")
+              this.deps.notice("info", subagentBackgroundText(event, state.agent));
             this.deps.tools().get(state.parentToolCallId)?.refresh();
             if (event.type === "subagent_start" && this.view?.component.task === event.taskId)
               this.view.component.attach();
@@ -53898,11 +54546,18 @@ var init_agent_ui = __esm({
           case "permission_request": {
             const taskId = event.context?.taskId;
             if (taskId !== void 0) this.approvals.set(event.requestId, taskId);
+            this.dock?.observe(event);
             return false;
           }
           case "permission_resolved":
             this.approvals.delete(event.requestId);
+            this.dock?.observe(event);
+            return false;
+          case "agent_settled": {
+            const dock = this.dock;
+            if (dock !== void 0 && dock.size > 0) setTimeout(() => dock.poke(), 0);
             return false;
+          }
           default:
             return false;
         }
@@ -53947,19 +54602,31 @@ var init_agent_ui = __esm({
         }
         this.deps.render();
       }
-      /** `app.agents.focus`（输入为空）：`↓` 只在栏可见时进入，其它键（`Ctrl+B`）有任务即可。 */
-      focusFromKey(data2) {
-        if (this.view !== void 0 || !this.barEnabled()) return false;
-        if (parseKey(data2)?.id === "down" && !this.bar.visible) return false;
-        if (!this.bar.focus()) return false;
+      /**
+       * `app.agents.focus`：输入为空且有任务即进栏（与 `/tasks` 一致，不要求栏可见）[W7-A]；
+       * 否则返回落空原因——有字（有任务时）、栏关闭（有任务时）、没有任务（栏开着时）。
+       */
+      focusFromKey() {
+        if (this.view !== void 0) return false;
+        const hasTasks = this.bar.all().length > 0;
+        if (!this.barEnabled()) return hasTasks && this.deps.editor.isEmpty() ? "disabled" : false;
+        if (!this.deps.editor.isEmpty()) return hasTasks ? "busy-input" : false;
+        if (!this.bar.focus()) return "empty";
         this.deps.render();
         return true;
       }
+      /** [W7-A] 运行提示行要不要带「↓ Agent 栏」：栏开着、有该显示的任务、没在栏里或视图里。 */
+      get reachable() {
+        return this.view === void 0 && !this.bar.focused && this.bar.visible;
+      }
       /** 栏聚焦时的按键；不在栏里返回 false。 */
       barKey(data2) {
         if (!this.bar.focused) return false;
         const keys = this.keybindings();
-        if (keys.matches(data2, "tui.select.up")) {
+        if (data2 !== "x") this.stopArm.reset();
+        if (data2 === "b" || keys.matches(data2, "app.tasks.background")) this.backgroundSelected();
+        else if (data2 === "x") void this.stopSelected();
+        else if (keys.matches(data2, "tui.select.up")) {
           if (!this.bar.move(-1)) this.bar.blur();
         } else if (keys.matches(data2, "tui.select.down")) this.bar.move(1);
         else if (keys.matches(data2, "tui.editor.submit")) {
@@ -53975,6 +54642,33 @@ var init_agent_ui = __esm({
         this.deps.render();
         return true;
       }
+      /** [W7-C] 栏内 `b` / `Ctrl+B`：转后台选中的任务（只对前台运行中的有效）。 */
+      backgroundSelected() {
+        const taskId = this.bar.selected();
+        if (taskId === void 0) return;
+        const moved = this.deps.session().backgroundTask(taskId, "user");
+        this.deps.hint(
+          moved.length > 0 ? backgroundedText2(moved) : msg().agents.background.notForeground(taskId)
+        );
+      }
+      /** [W7-C] 栏内 `x`：第一次提示「再按 x 停止」，1.5 s 内再按停止。 */
+      async stopSelected() {
+        const taskId = this.bar.selected();
+        if (taskId === void 0) return;
+        const sessionId = this.deps.session().state.sessionId;
+        if (taskRegistryView(sessionId)?.get(taskId)?.status !== "running") {
+          this.stopArm.reset();
+          this.deps.hint(msg().agents.stop.ended(taskId));
+          return;
+        }
+        if (this.stopArm.press(taskId, this.deps.now()) === "arm") {
+          this.deps.hint(msg().agents.stop.confirm(taskId));
+          return;
+        }
+        this.deps.hint(msg().agents.view.stopped(taskId));
+        await stopTask(sessionId, taskId);
+        this.deps.render();
+      }
       /** `/tasks <id>` 与栏里 Enter：打开子 Agent 视图。 */
       openView(taskId) {
         const sessionId = this.deps.session().state.sessionId;
@@ -53996,6 +54690,7 @@ var init_agent_ui = __esm({
           siblings: () => this.bar.all().map((row3) => row3.taskId),
           close: () => this.closeView(),
           stop: (id) => stopTask(this.deps.session().state.sessionId, id),
+          background: (id) => this.deps.session().backgroundTask(id, "user"),
           messages: {
             ...ui.showThinking !== void 0 ? { showThinking: ui.showThinking } : {},
             ...ui.markdown !== void 0 ? { markdown: ui.markdown } : {},
@@ -54005,6 +54700,7 @@ var init_agent_ui = __esm({
         this.bar.blur();
         const handle = this.deps.tui.showOverlay(component, { anchor: "bottom" });
         this.view = { component, handle };
+        this.dock?.poke();
         this.deps.render();
       }
       get viewing() {
@@ -54080,6 +54776,169 @@ var init_agent_ui = __esm({
   }
 });
 
+// src/modes/interactive/approval-dock.ts
+var DOCK_POLL_MS, ApprovalDock;
+var init_approval_dock = __esm({
+  "src/modes/interactive/approval-dock.ts"() {
+    "use strict";
+    DOCK_POLL_MS = 250;
+    ApprovalDock = class {
+      constructor(inner, host) {
+        this.inner = inner;
+        this.host = host;
+      }
+      inner;
+      host;
+      docked = [];
+      /** 已发出、还没答复的不可停靠请求（主会话 / 前台任务）。 */
+      others = /* @__PURE__ */ new Set();
+      timer;
+      ask(request, signal) {
+        const taskId = request.context?.taskId;
+        if (taskId === void 0 || signal.aborted || !this.host.dockable(taskId) || this.others.size > 0 || this.host.ready(taskId))
+          return this.inner.ask(request, signal);
+        return new Promise((resolve39) => {
+          const entry = {
+            taskId,
+            request,
+            signal,
+            resolve: resolve39,
+            onAbort: () => {
+              this.remove(entry);
+              resolve39(void 0);
+            }
+          };
+          signal.addEventListener("abort", entry.onAbort, { once: true });
+          this.docked.push(entry);
+          this.startPolling();
+          this.host.changed();
+        });
+      }
+      /** 停靠中的任务。 */
+      tasks() {
+        return new Set(this.docked.map((entry) => entry.taskId));
+      }
+      get size() {
+        return this.docked.length;
+      }
+      /** 会话事件：记下不可停靠的请求；停靠期间来了这种请求就放出停靠的（见文件头）。 */
+      observe(event) {
+        if (event.type === "permission_request") {
+          const taskId = event.context?.taskId;
+          if (taskId !== void 0 && this.host.dockable(taskId)) return;
+          this.others.add(event.requestId);
+          this.poke();
+        } else if (event.type === "permission_resolved") this.others.delete(event.requestId);
+      }
+      /** 对一次弹出条件（定时器、视图打开、回合结束）。 */
+      poke() {
+        for (const entry of [...this.docked])
+          if (this.others.size > 0 || this.host.ready(entry.taskId)) this.release(entry);
+      }
+      /** 换会话：旧会话的未答复请求不再有 `permission_resolved` 到这里。 */
+      reset() {
+        this.others.clear();
+      }
+      /** 退出：停靠的请求按 undefined 交回链（链按拒绝处理）。 */
+      dispose() {
+        for (const entry of [...this.docked]) entry.onAbort();
+        this.others.clear();
+      }
+      release(entry) {
+        this.remove(entry);
+        entry.resolve(this.inner.ask(entry.request, entry.signal));
+      }
+      remove(entry) {
+        const at = this.docked.indexOf(entry);
+        if (at < 0) return;
+        this.docked.splice(at, 1);
+        entry.signal.removeEventListener("abort", entry.onAbort);
+        if (this.docked.length === 0) this.stopPolling();
+        this.host.changed();
+      }
+      startPolling() {
+        if (this.timer !== void 0) return;
+        this.timer = setInterval(() => this.poke(), this.host.pollMs ?? DOCK_POLL_MS);
+        this.timer.unref?.();
+      }
+      stopPolling() {
+        if (this.timer !== void 0) clearInterval(this.timer);
+        this.timer = void 0;
+      }
+    };
+  }
+});
+
+// src/modes/interactive/approval-ui.ts
+function approvalOverlayHooks(deps) {
+  const { tui, editor, indicator } = deps;
+  return {
+    showOverlay: (component) => tui.showOverlay(component, { anchor: "bottom" }),
+    onOpen: () => {
+      editor.disableSubmit = true;
+      deps.tools().setAwaiting(true);
+      indicator.setApproval(true);
+    },
+    onClose: () => {
+      editor.disableSubmit = false;
+      deps.tools().setAwaiting(false);
+      indicator.setApproval(false);
+    }
+  };
+}
+function createApprovalUi(deps) {
+  const { theme, keys, tui, editor, indicator, agentUi, hooks, notice } = deps;
+  const taskInfo = (taskId) => taskRegistryView(deps.session().state.sessionId)?.get(taskId);
+  const taskAgent = (taskId) => taskInfo(taskId)?.agent;
+  const dialog = new ApprovalDialogBroker({
+    theme,
+    keybindings: keys,
+    cwd: deps.session().state.cwd,
+    permissionMode: () => deps.session().state.permissionMode,
+    taskAgent,
+    externalRunner: (agent) => agentUi.merge.externalRunner(agent),
+    ...hooks,
+    report: (request, outcome) => {
+      if (outcome === "deny" || outcome === "cancelled") {
+        const text = approvalOutcomeText(request, outcome, taskAgent);
+        notice(outcome === "deny" ? "info" : "warn", text);
+      }
+    }
+  });
+  const dock = new ApprovalDock(dialog, {
+    dockable: (taskId) => {
+      const info2 = taskInfo(taskId);
+      return info2?.status === "running" && info2.background === true;
+    },
+    ready: (taskId) => agentUi.viewing === taskId || !tui.hasOverlay && !indicator.busy && editor.isEmpty(),
+    changed: () => {
+      indicator.sync();
+      deps.render();
+    }
+  });
+  agentUi.dock = dock;
+  indicator.docked = () => dock.size > 0;
+  const broker = mergingBroker(
+    dock,
+    agentUi.merge,
+    (request) => notice(
+      "info",
+      msg().interactive.app.followed(approvalOutcomeText(request, "allow", taskAgent))
+    )
+  );
+  return { broker, dock };
+}
+var init_approval_ui = __esm({
+  "src/modes/interactive/approval-ui.ts"() {
+    "use strict";
+    init_subagent_registry();
+    init_i18n();
+    init_approval_dialog();
+    init_approval_dock();
+    init_approval_merge();
+  }
+});
+
 // src/modes/interactive/commands.ts
 function command2(name, key) {
   return {
@@ -54355,7 +55214,7 @@ var init_commands2 = __esm({
           await ui.agentBar();
           return true;
         }
-        if (parts.length === 1 && parts[0] !== "stop" && ui.agentView !== void 0) {
+        if (parts.length === 1 && parts[0] !== "stop" && parts[0] !== "bg" && ui.agentView !== void 0) {
           await ui.agentView(parts[0]);
           return true;
         }
@@ -54552,6 +55411,28 @@ function parseNumstat(text) {
   }
   return { insertions, deletions };
 }
+function parseLeftRight(text) {
+  const match = /^\s*(\d+)\s+(\d+)\s*$/.exec(text);
+  return match === null ? void 0 : { behind: Number(match[1]), ahead: Number(match[2]) };
+}
+async function hasUpstream(cwd, branch) {
+  const gitDir = await findGitDir(cwd);
+  if (gitDir === void 0) return false;
+  const common = (await (0, import_promises24.readFile)((0, import_node_path94.join)(gitDir, "commondir"), "utf8").catch(() => void 0))?.trim();
+  const dir = common === void 0 ? gitDir : (0, import_node_path94.isAbsolute)(common) ? common : (0, import_node_path94.resolve)(gitDir, common);
+  const text = await (0, import_promises24.readFile)((0, import_node_path94.join)(dir, "config"), "utf8").catch(() => "");
+  let inBranch = false;
+  for (const raw of text.split("\n")) {
+    const line2 = raw.trim();
+    const section = /^\[\s*([^\]\s"]+)(?:\s+"((?:[^"\\]|\\.)*)")?\s*\]/.exec(line2);
+    if (section !== null) {
+      inBranch = section[1]?.toLowerCase() === "branch" && section[2] === branch;
+      continue;
+    }
+    if (inBranch && /^merge\s*=\s*\S/i.test(line2)) return true;
+  }
+  return false;
+}
 async function readHead2(cwd) {
   const head = await readGitHead(cwd);
   if (head !== void 0) {
@@ -54576,7 +55457,7 @@ var init_info = __esm({
     init_git_head();
     GIT_NUMSTAT_INTERVAL_MS = 1e4;
     GIT_NUMSTAT_TIMEOUT_MS = 2e3;
-    sameInfo = (a, b) => a?.branch === b?.branch && a?.shortHead === b?.shortHead && a?.insertions === b?.insertions && a?.deletions === b?.deletions && a === void 0 === (b === void 0);
+    sameInfo = (a, b) => a?.branch === b?.branch && a?.shortHead === b?.shortHead && a?.insertions === b?.insertions && a?.deletions === b?.deletions && a?.ahead === b?.ahead && a?.behind === b?.behind && a === void 0 === (b === void 0);
     GitInfoWatcher = class {
       constructor(cwd, deps = {}) {
         this.cwd = cwd;
@@ -54586,6 +55467,7 @@ var init_info = __esm({
         this.timeoutMs = deps.timeoutMs ?? GIT_NUMSTAT_TIMEOUT_MS;
         this.env = deps.env ?? process.env;
         this.numstatDisabled = this.env["AMA_STATUS_GIT"] === "0";
+        this.upstreamDisabled = this.numstatDisabled;
       }
       cwd;
       info;
@@ -54602,6 +55484,8 @@ var init_info = __esm({
       headAgain = false;
       disposed = false;
       diff;
+      upstream;
+      upstreamDisabled;
       current() {
         return this.info;
       }
@@ -54639,7 +55523,8 @@ var init_info = __esm({
       update(head) {
         const next = head === void 0 ? void 0 : {
           ...head,
-          ...this.diff !== void 0 && head.shortHead !== void 0 ? this.diff : {}
+          ...this.diff !== void 0 && head.shortHead !== void 0 ? this.diff : {},
+          ...this.upstream !== void 0 && head.branch !== void 0 ? this.upstream : {}
         };
         if (sameInfo(this.info, next)) return;
         this.info = next;
@@ -54652,42 +55537,60 @@ var init_info = __esm({
         if (at - this.lastNumstatAt < this.minIntervalMs) return Promise.resolve();
         this.lastNumstatAt = at;
         this.numstatRunning = true;
-        return this.numstat().then((diff) => {
-          this.numstatRunning = false;
+        return this.numstat().then(async (diff) => {
           if (this.disposed) return;
           if (diff === void 0) {
             this.numstatDisabled = true;
             this.diff = void 0;
           } else this.diff = diff;
+          await this.leftRight();
+          this.numstatRunning = false;
+          if (this.disposed) return;
           const info2 = this.info;
           if (info2 === void 0) return;
-          const { insertions: _i, deletions: _d, ...head } = info2;
+          const { insertions: _i, deletions: _d, ahead: _a, behind: _b, ...head } = info2;
           this.update(head);
         });
       }
-      numstat() {
-        return new Promise((resolve38) => {
+      /** 领先 / 落后上游：只在配置里有上游时起进程；超时本会话停用，非零退出只省略这一次。 */
+      async leftRight() {
+        const branch = this.info?.branch;
+        if (this.upstreamDisabled || branch === void 0 || !await hasUpstream(this.cwd, branch)) {
+          this.upstream = void 0;
+          return;
+        }
+        const result = await this.run(["rev-list", "--left-right", "--count", "@{upstream}...HEAD"]);
+        if (result === "timeout") this.upstreamDisabled = true;
+        this.upstream = typeof result === "object" && result.code === 0 ? parseLeftRight(result.out) : void 0;
+      }
+      async numstat() {
+        const result = await this.run(["diff", "--numstat", "HEAD"]);
+        return typeof result === "object" && result.code === 0 ? parseNumstat(result.out) : void 0;
+      }
+      /** 后台起一次 git；起不来为 undefined，超时杀掉并返回 `"timeout"`。 */
+      run(args) {
+        return new Promise((resolve39) => {
           let settled = false;
           let timer;
           const done = (value) => {
             if (settled) return;
             settled = true;
             clearTimeout(timer);
-            resolve38(value);
+            resolve39(value);
           };
           let child;
           try {
-            child = this.spawn("git", ["diff", "--numstat", "HEAD"], {
+            child = this.spawn("git", args, {
               cwd: this.cwd,
               env: { ...this.env, GIT_OPTIONAL_LOCKS: "0" }
             });
           } catch {
-            resolve38(void 0);
+            resolve39(void 0);
             return;
           }
           timer = setTimeout(() => {
             child.kill("SIGKILL");
-            done(void 0);
+            done("timeout");
           }, this.timeoutMs);
           timer.unref?.();
           let out = "";
@@ -54696,7 +55599,7 @@ var init_info = __esm({
             out += String(chunk);
           });
           child.on("error", () => done(void 0));
-          child.on("close", (code) => done(code === 0 ? parseNumstat(out) : void 0));
+          child.on("close", (code) => done({ code, out }));
         });
       }
     };
@@ -54755,32 +55658,40 @@ var init_status_line = __esm({
         const right = (text, priority) => {
           if (text !== void 0) parts.push({ text, priority, zone: "right" });
         };
+        const blue = (text) => theme.fg("accent", text);
+        const purple = (text) => theme.fg("tool", text);
+        const amountText = (tokens, ms) => `${blue(formatTokens3(tokens))}${dim(" tok / ")}${blue(formatSeconds2(ms))}`;
         let tps;
         let amount;
         if (live2 !== void 0) {
           tps = live2.tps;
-          amount = `${formatTokens3(live2.outputTokens)} tok / ${formatSeconds2(live2.elapsedMs)}`;
+          amount = amountText(live2.outputTokens, live2.elapsedMs);
         } else if (last?.doneAt !== void 0) {
           tps = last.tps;
           if (last.outputTokens !== void 0 && last.firstTokenAt !== void 0) {
-            amount = `${formatTokens3(last.outputTokens)} tok / ${formatSeconds2(last.doneAt - last.firstTokenAt)}`;
+            amount = amountText(last.outputTokens, last.doneAt - last.firstTokenAt);
           }
         }
         const label2 = live2 !== void 0 ? theme.fg("accent", "tps:") : dim("tps:");
         left(
-          `${label2} ${dim(tps === void 0 ? "—" : `${formatRate(tps)} tok/s`)}`,
+          `${label2} ${tps === void 0 ? dim("—") : `${purple(formatRate(tps))}${dim(" tok/s")}`}`,
           void 0,
           RESERVE.tps
         );
         if (amount !== void 0) {
-          left(dim(amount), PRIORITY.amount, RESERVE.amount, { lead: ` ${theme.glyphs.dot} ` });
+          left(amount, PRIORITY.amount, RESERVE.amount, { lead: ` ${theme.glyphs.dot} ` });
         }
         const stat16 = { group: "stats", lead: " " };
         if (telemetry?.avgTps !== void 0) {
-          left(dim(`avg ${formatRate(telemetry.avgTps)}`), PRIORITY.avg, RESERVE.avg, stat16);
+          left(`${dim("avg ")}${blue(formatRate(telemetry.avgTps))}`, PRIORITY.avg, RESERVE.avg, stat16);
         }
         if (last?.ttftMs !== void 0) {
-          left(dim(`ttft ${formatSeconds2(last.ttftMs)}`), PRIORITY.ttft, RESERVE.ttft, stat16);
+          left(
+            `${dim("ttft ")}${purple(formatSeconds2(last.ttftMs))}`,
+            PRIORITY.ttft,
+            RESERVE.ttft,
+            stat16
+          );
         }
         const usage = usageItems(stats, this.bar.queued(), this.source, theme);
         right(usage.tokens, PRIORITY.tokens);
@@ -54822,7 +55733,7 @@ function statusLineText(mode) {
   const m = msg().interactive.statusLine;
   return mode === "full" ? m.full : m.compact;
 }
-var import_node_path95, WRITE_TOOLS3, HintLine, StatusArea;
+var import_node_path95, WRITE_TOOLS3, QUOTA_TICK_MS, HintLine, StatusArea;
 var init_status_area = __esm({
   "src/modes/interactive/status-area.ts"() {
     "use strict";
@@ -54837,7 +55748,9 @@ var init_status_area = __esm({
     init_tui2();
     init_status_bar();
     init_status_line();
+    init_status_quota();
     WRITE_TOOLS3 = /* @__PURE__ */ new Set(["write", "edit", "bash", "task"]);
+    QUOTA_TICK_MS = 6e4;
     HintLine = class {
       text = "";
       setText(text) {
@@ -54874,16 +55787,26 @@ var init_status_area = __esm({
           // S2：bash 沙箱生效（配置 + 本机能力，与 compose 同一结论）且 bash 工具活动
           bashSandbox: () => (this.bashSandbox ??= resolveBashSandbox(runtime.config.sandbox, {
             status: osSandboxStatus()
-          }).active) && deps.session().getTools().some((tool) => tool.name === "bash")
+          }).active) && deps.session().getTools().some((tool) => tool.name === "bash"),
+          quota: () => this.quotaView()
         };
         this.bar = new StatusBar(source, deps.theme);
         this.rate = new StatusLine(this.bar, source, deps.theme);
+        this.quota = new QuotaLine(
+          { layout: () => this.mode, quota: () => this.quotaView(), now: () => deps.now() },
+          deps.theme
+        );
         this.watchGit();
+        this.syncTicker();
       }
       deps;
       hint = new HintLine();
       bar;
       rate;
+      /** [W6] 订阅配额行（full 第三行）。 */
+      quota;
+      lastQuota;
+      ticker;
       mode;
       startedAt;
       git;
@@ -54893,6 +55816,38 @@ var init_status_area = __esm({
       /** [W5-U] 模型回退中（`model_fallback` 到切回主模型）。 */
       fallback;
       bashSandbox;
+      /** [W6] 当前模型走 ChatGPT 订阅时的配额；codex 还没数据为 pending，SIWC 没数据或非订阅模型不显示。 */
+      quotaView() {
+        const model = this.deps.session().state.model;
+        if (model === void 0) return void 0;
+        const backend = this.backendOf(formatModelRef(model));
+        if (backend === void 0) return void 0;
+        const quota = this.lastQuota ?? this.deps.session().getStats().subscription?.quota;
+        if (quota !== void 0 && quota.provider === model.provider) return { quota };
+        return backend === "codex" ? "pending" : void 0;
+      }
+      backendMemo;
+      /** 模型的 ChatGPT 订阅后端（渠道 compat `chatgptBackend`）；按引用记住上次结果。 */
+      backendOf(ref) {
+        if (this.backendMemo?.ref === ref) return this.backendMemo.backend;
+        const found = this.deps.runtime.providers.findModel(ref);
+        const value = found.ok ? found.model.compat?.chatgptBackend : void 0;
+        const backend = value === "codex" || value === "siwc" ? value : void 0;
+        this.backendMemo = { ref, backend };
+        return backend;
+      }
+      /** 第三行显示且有重置时间时每分钟重画；否则不挂计时器。 */
+      syncTicker() {
+        const view = this.mode === "full" ? this.quotaView() : void 0;
+        const ticking = typeof view === "object" && (view.quota.primary?.resetsAt !== void 0 || view.quota.secondary?.resetsAt !== void 0);
+        if (ticking && this.ticker === void 0) {
+          this.ticker = setInterval(() => this.deps.render(), QUOTA_TICK_MS);
+          this.ticker.unref?.();
+        } else if (!ticking && this.ticker !== void 0) {
+          clearInterval(this.ticker);
+          this.ticker = void 0;
+        }
+      }
       layout() {
         return this.mode;
       }
@@ -54903,6 +55858,7 @@ var init_status_area = __esm({
       setLayout(mode) {
         if (mode === this.mode) return;
         this.mode = mode;
+        this.syncTicker();
         (this.deps.redraw ?? this.deps.render)();
       }
       toggle() {
@@ -54918,6 +55874,7 @@ var init_status_area = __esm({
         this.fallback = void 0;
         this.watchGit();
         this.bar.refresh();
+        this.syncTicker();
       }
       refreshGit() {
         void this.git?.refresh();
@@ -54928,6 +55885,10 @@ var init_status_area = __esm({
           case "telemetry_tick":
             this.bar.refresh();
             return true;
+          case "quota_update":
+            this.lastQuota = event;
+            this.syncTicker();
+            return true;
           case "agent_settled":
           case "session_rewound":
             this.refreshGit();
@@ -54947,6 +55908,7 @@ var init_status_area = __esm({
             if (this.fallback !== void 0 && model !== void 0) {
               if (formatModelRef(model) === this.fallback.from) this.fallback = void 0;
             }
+            this.syncTicker();
             return false;
           }
           default:
@@ -54954,6 +55916,11 @@ var init_status_area = __esm({
         }
       }
       dispose() {
+        this.disposeGit();
+        if (this.ticker !== void 0) clearInterval(this.ticker);
+        this.ticker = void 0;
+      }
+      disposeGit() {
         this.offGit();
         this.git?.dispose();
         this.git = void 0;
@@ -54966,7 +55933,7 @@ var init_status_area = __esm({
       watchGit() {
         const cwd = this.deps.session().state.cwd;
         if (cwd === this.gitCwd && this.git !== void 0) return;
-        this.dispose();
+        this.disposeGit();
         this.gitCwd = cwd;
         const git = new GitInfoWatcher(cwd, this.deps.env !== void 0 ? { env: this.deps.env } : {});
         this.git = git;
@@ -54982,6 +55949,8 @@ 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":
@@ -55039,8 +56008,32 @@ ${current3}`);
     if (typeof answer === "boolean") settle(answer);
     else void answer.then(settle);
   };
+  const atLastLine = () => editor.cursor.line >= editor.getText().split("\n").length - 1;
+  const focusAgents = (agents, data2) => {
+    if (editor.isCompletionOpen || editor.isBrowsingHistory) return false;
+    const result = agents.focus(data2);
+    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 !== void 0) {
+      deps.showHint(text, FOCUS_HINT_MS);
+      focusHintShown = true;
+    }
+    return false;
+  };
   return (data2) => {
     if (deps.inactive()) return false;
+    if (editor.isEmpty()) busyInputHinted = false;
     const is = (action) => keys.matches(data2, action);
     if (!is("app.rewind")) esc.reset();
     const agents = deps.agents?.();
@@ -55048,8 +56041,15 @@ ${current3}`);
       esc.reset();
       return true;
     }
-    if (agents !== void 0 && is("app.agents.focus") && editor.isEmpty() && !editor.isCompletionOpen && agents.focus(data2))
-      return true;
+    if (agents !== void 0 && is("app.agents.focus") && focusAgents(agents, data2)) return true;
+    if (is("app.tasks.background") && deps.backgroundTasks !== void 0) {
+      const moved = deps.backgroundTasks();
+      if (moved.length > 0) {
+        esc.reset();
+        deps.showHint(backgroundedText2(moved), FOCUS_HINT_MS);
+        return true;
+      }
+    }
     if (is("app.clear")) {
       if (!editor.isEmpty()) {
         editor.clear();
@@ -55067,7 +56067,10 @@ ${current3}`);
     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;
     }
@@ -55120,7 +56123,7 @@ ${current3}`);
     return false;
   };
 }
-var DOUBLE_CTRL_C_MS;
+var DOUBLE_CTRL_C_MS, FOCUS_HINT_MS;
 var init_key_dispatch = __esm({
   "src/modes/interactive/key-dispatch.ts"() {
     "use strict";
@@ -55128,19 +56131,21 @@ var init_key_dispatch = __esm({
     init_exit_codes();
     init_modes();
     init_double_esc();
+    init_task_background();
     init_status_area();
     DOUBLE_CTRL_C_MS = 1500;
+    FOCUS_HINT_MS = 3e3;
   }
 });
 
 // src/modes/interactive/model-picker.ts
 async function openModelPicker(host, options) {
   const catalog = await loadModelCatalog(options.providers);
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     let handle;
     const view = new ModelPickerView(host, catalog, options, (ref) => {
       handle?.hide();
-      resolve38(ref);
+      resolve39(ref);
     });
     const width2 = Math.max(20, Math.min(host.columns() - 2, 72));
     handle = host.showOverlay(new Box(view, { title: options.title, theme: host.theme }), {
@@ -55341,7 +56346,7 @@ function rewindListItems(points, cache3, highlighted, now, ascii = false) {
   });
 }
 function openRewindList(host, points, cache3) {
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     const ascii = host.theme.glyphs.ascii;
     let highlighted = points.at(-1)?.entryId;
     let refreshing = false;
@@ -55357,7 +56362,7 @@ function openRewindList(host, points, cache3) {
     const close = (point) => {
       closed = true;
       handle.hide();
-      resolve38(point);
+      resolve39(point);
     };
     const highlight2 = (entryId) => {
       highlighted = entryId;
@@ -55474,8 +56479,8 @@ function rewindOptions(model, ascii = false) {
 }
 function conflictOptions() {
   const m = msg().rewind.panel;
-  const labels = { skip: m.conflictSkip, overwrite: m.conflictOverwrite, back: m.conflictBack };
-  return CONFLICT_VALUES.map((value) => ({ value, label: labels[value] }));
+  const labels2 = { skip: m.conflictSkip, overwrite: m.conflictOverwrite, back: m.conflictBack };
+  return CONFLICT_VALUES.map((value) => ({ value, label: labels2[value] }));
 }
 var COMPACT_WIDTH4, MESSAGE_LINES, CONFLICT_VALUES, Lines4, RewindPanel;
 var init_rewind_panel = __esm({
@@ -55729,7 +56734,7 @@ var init_rewind_panel = __esm({
 
 // src/modes/interactive/rewind-flow.ts
 function openRewindPanel(host, model) {
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     let handle;
     const panel = new RewindPanel(
       model,
@@ -55740,7 +56745,7 @@ function openRewindPanel(host, model) {
       },
       (choice3) => {
         handle?.hide();
-        resolve38(choice3);
+        resolve39(choice3);
       }
     );
     handle = host.showOverlay(panel, { anchor: "bottom" });
@@ -55869,7 +56874,7 @@ var init_rewind_flow = __esm({
 
 // src/modes/interactive/trace-view.ts
 function openTraceView(host, taskId) {
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     let handle;
     let timer;
     let unsubscribe;
@@ -55879,12 +56884,12 @@ function openTraceView(host, taskId) {
       unsubscribe?.();
       handle?.hide();
       host.render?.();
-      resolve38();
+      resolve39();
     };
     const view = new TraceView(host, taskId, finish2);
     if (!view.found) {
       host.notice("warn", msg().trace.taskNotFound(taskId));
-      resolve38();
+      resolve39();
       return;
     }
     const throttle = host.refreshMs ?? TRACE_REFRESH_MS;
@@ -56149,6 +57154,153 @@ var init_trace_view = __esm({
   }
 });
 
+// src/modes/interactive/startup-logo.ts
+function logoRows(theme) {
+  return theme.glyphs.ascii ? LOGO_ASCII : LOGO_BLOCK;
+}
+function letterColor(col, ascii) {
+  const starts = LETTER_STARTS[ascii ? "ascii" : "block"];
+  let index2 = 0;
+  for (let i = 0; i < starts.length; i++) if (col >= starts[i]) index2 = i;
+  return GRADIENT[index2];
+}
+function logoWidth(rows) {
+  return Math.max(...rows.map((row3) => [...row3].length));
+}
+function sweepFrames(theme) {
+  return logoWidth(logoRows(theme)) + SWEEP_BAND;
+}
+function styleAt(col, ascii, sweep) {
+  const settled = { color: letterColor(col, ascii), bold: true };
+  if (sweep === void 0 || col <= sweep - SWEEP_BAND) return settled;
+  if (col <= sweep) return { color: "text", bold: true };
+  return { color: "dim", bold: false };
+}
+function paintLogo(theme, sweep) {
+  const rows = logoRows(theme);
+  const width2 = logoWidth(rows);
+  return rows.map((row3) => {
+    const chars = [...row3.padEnd(width2)];
+    let out = "";
+    let run7 = "";
+    let runStyle;
+    const flush = () => {
+      if (run7 === "") return;
+      if (runStyle === void 0) out += run7;
+      else {
+        const colored = theme.fg(runStyle.color, run7);
+        out += runStyle.bold ? theme.bold(colored) : colored;
+      }
+      run7 = "";
+    };
+    chars.forEach((ch2, col) => {
+      const style = ch2 === " " ? void 0 : styleAt(col, theme.glyphs.ascii, sweep);
+      if (style?.color !== runStyle?.color || style?.bold !== runStyle?.bold) {
+        flush();
+        runStyle = style;
+      }
+      run7 += ch2;
+    });
+    flush();
+    return out;
+  });
+}
+function shouldAnimate(gate) {
+  const ci = gate.env["CI"];
+  return gate.animation !== false && gate.hasLogo && gate.colors > 0 && gate.io.stdoutIsTTY && !gate.host && (gate.prompt ?? "").trim() === "" && (ci === void 0 || ci === "" || ci === "0" || ci === "false") && gate.rows >= MIN_ANIMATION_ROWS;
+}
+function playStartupAnimation(tui, header, theme, conditions) {
+  const term = tui.terminal;
+  const columns = term.columns;
+  if (header === void 0) return void 0;
+  const gate = {
+    ...conditions,
+    hasLogo: header.hasLogo(term.columns),
+    colors: theme.caps.colors,
+    rows: term.rows
+  };
+  const fits = () => tui.render(term.columns).length <= term.rows;
+  if (!shouldAnimate(gate) || !fits()) return void 0;
+  let offInput = () => void 0;
+  const animation = new LogoAnimation(header, {
+    frames: sweepFrames(theme),
+    render: () => tui.requestRender(),
+    // 改了尺寸（差分渲染要整屏重画）也立即定格
+    canContinue: () => term.columns === columns && fits(),
+    onDone: () => offInput()
+  });
+  offInput = tui.addInputListener(() => {
+    animation.finish();
+    return false;
+  });
+  animation.start();
+  return animation;
+}
+var LOGO_BLOCK, LOGO_ASCII, SWEEP_BAND, FRAME_MS, GRADIENT, LETTER_STARTS, LogoAnimation, MIN_ANIMATION_ROWS;
+var init_startup_logo = __esm({
+  "src/modes/interactive/startup-logo.ts"() {
+    "use strict";
+    LOGO_BLOCK = [
+      " ▄███▄  ██▄   ▄██  ▄███▄",
+      "██▀ ▀██ ███▄ ▄███ ██▀ ▀██",
+      "███████ ██ ▀█▀ ██ ███████",
+      "██   ██ ██     ██ ██   ██",
+      "▀▀   ▀▀ ▀▀     ▀▀ ▀▀   ▀▀"
+    ];
+    LOGO_ASCII = [
+      "    _    __  __    _",
+      "   / \\  |  \\/  |  / \\",
+      "  / _ \\ | |\\/| | / _ \\",
+      " / ___ \\| |  | |/ ___ \\",
+      "/_/   \\_\\_|  |_/_/   \\_\\"
+    ];
+    SWEEP_BAND = 3;
+    FRAME_MS = 32;
+    GRADIENT = ["accent", "user", "tool"];
+    LETTER_STARTS = { block: [0, 8, 18], ascii: [0, 8, 16] };
+    LogoAnimation = class {
+      constructor(target, options) {
+        this.target = target;
+        this.options = options;
+      }
+      target;
+      options;
+      frame = 0;
+      timer;
+      done = false;
+      get running() {
+        return !this.done && this.timer !== void 0;
+      }
+      start() {
+        if (this.done || this.timer !== void 0) return;
+        this.step();
+      }
+      step() {
+        this.timer = void 0;
+        if (this.frame >= this.options.frames || this.options.canContinue?.() === false) {
+          this.finish();
+          return;
+        }
+        this.target.setSweep(this.frame++);
+        this.options.render();
+        this.timer = setTimeout(() => this.step(), this.options.intervalMs ?? FRAME_MS);
+        this.timer.unref?.();
+      }
+      /** 立即定格（按键、退出、走完）；重复调用无副作用。 */
+      finish() {
+        if (this.done) return;
+        this.done = true;
+        if (this.timer !== void 0) clearTimeout(this.timer);
+        this.timer = void 0;
+        this.target.setSweep(void 0);
+        this.options.render();
+        this.options.onDone?.();
+      }
+    };
+    MIN_ANIMATION_ROWS = 16;
+  }
+});
+
 // src/modes/interactive/startup-header.ts
 function truncateLeft(text, width2, ellipsis = "…") {
   if (visibleWidth(text) <= width2) return text;
@@ -56165,19 +57317,26 @@ function truncateLeft(text, width2, ellipsis = "…") {
   }
   return ellipsis + out;
 }
+function fitSegments(text, width2) {
+  const parts = text.split(" · ");
+  while (parts.length > 1 && visibleWidth(parts.join(" · ")) > width2) parts.pop();
+  return parts.join(" · ");
+}
 function withoutChannel(model) {
   const at = model.indexOf("@");
   return at === -1 ? model : model.slice(0, at);
 }
-var HEADER_BOX_MIN_WIDTH, HEADER_BOX_MAX_WIDTH, StartupHeader;
+var HEADER_SIDE_MIN_WIDTH, HEADER_LOGO_MIN_WIDTH, GAP, StartupHeader;
 var init_startup_header = __esm({
   "src/modes/interactive/startup-header.ts"() {
     "use strict";
     init_i18n();
     init_modes();
     init_tui2();
-    HEADER_BOX_MIN_WIDTH = 56;
-    HEADER_BOX_MAX_WIDTH = 64;
+    init_startup_logo();
+    HEADER_SIDE_MIN_WIDTH = 72;
+    HEADER_LOGO_MIN_WIDTH = 48;
+    GAP = 3;
     StartupHeader = class {
       constructor(info2, options) {
         this.info = info2;
@@ -56186,9 +57345,19 @@ var init_startup_header = __esm({
       info;
       options;
       cache = null;
+      sweep;
       get theme() {
         return this.options.theme;
       }
+      /** 这个宽度下是否画字符画（动画只在画了时播放）。 */
+      hasLogo(width2) {
+        return this.options.level === "normal" && this.options.logo !== "off" && this.options.compact !== true && width2 >= HEADER_LOGO_MIN_WIDTH;
+      }
+      setSweep(sweep) {
+        if (sweep === this.sweep) return;
+        this.sweep = sweep;
+        this.cache = null;
+      }
       title() {
         const t = this.theme;
         return `${t.fg("accent", t.glyphs.thinking)} ${t.bold(`ama ${this.info.version}`)}`;
@@ -56217,7 +57386,11 @@ var init_startup_header = __esm({
       }
       render(width2) {
         if (this.cache?.width === width2) return this.cache.lines;
-        const lines2 = this.options.level === "header" ? [this.headerLine(width2)] : this.options.compact === true || width2 < HEADER_BOX_MIN_WIDTH ? this.plainLines(width2) : this.boxLines(width2);
+        let lines2;
+        if (this.options.level === "header") lines2 = [this.headerLine(width2)];
+        else if (width2 < HEADER_LOGO_MIN_WIDTH) lines2 = this.narrowLines(width2);
+        else if (!this.hasLogo(width2)) lines2 = this.infoLines(width2, this.title());
+        else lines2 = this.logoLines(width2);
         this.cache = { width: width2, lines: lines2 };
         return lines2;
       }
@@ -56232,64 +57405,63 @@ var init_startup_header = __esm({
         ];
         return truncateToWidth(parts.join(sep5), width2);
       }
-      plainLines(width2) {
+      /** < 48 列：两行（版本 · 模型 · 思考 / 模式 · 目录 · 信任），有警告再加一行。 */
+      narrowLines(width2) {
         const t = this.theme;
         const sep5 = t.fg("dim", " · ");
-        const ellipsis = t.glyphs.ellipsis;
         const { info: info2 } = this;
-        const lines2 = [this.title()];
-        lines2.push(t.fg("accent", withoutChannel(info2.model)) + sep5 + info2.thinking);
+        const lines2 = [
+          [this.title(), t.fg("accent", withoutChannel(info2.model)), info2.thinking].join(sep5)
+        ];
+        const mode = this.modeText();
         const trust = this.trustText(false);
-        const room = Math.max(4, width2 - visibleWidth(trust) - 3);
-        lines2.push(truncateLeft(info2.cwd, room, ellipsis) + sep5 + trust);
-        const mode = [this.modeText(), info2.preset, this.codemodeText()].filter(
-          (p) => p !== void 0
-        );
-        lines2.push(mode.join(sep5));
-        const loaded = this.loadedText();
-        if (loaded !== void 0) lines2.push(loaded);
-        const m = msg().interactive.startup.header;
-        if (info2.host !== void 0) lines2.push(m.host(info2.host));
-        if (info2.warnings > 0) lines2.push(t.fg("warning", m.warnings(info2.warnings)));
-        lines2.push(t.fg("dim", m.hintCompact));
+        const room = Math.max(4, width2 - visibleWidth(mode) - visibleWidth(trust) - 6);
+        lines2.push([mode, truncateLeft(info2.cwd, room, t.glyphs.ellipsis), trust].join(sep5));
+        if (info2.warnings > 0) {
+          lines2.push(t.fg("warning", msg().interactive.startup.header.warnings(info2.warnings)));
+        }
         return lines2.map((line2) => truncateToWidth(line2, width2));
       }
-      boxLines(width2) {
+      /** 信息列：首行 `title`，其后模型、目录、模式、可选行、按键提示；每行截到 `width`。 */
+      infoLines(width2, title) {
         const t = this.theme;
         const sep5 = t.fg("dim", " · ");
         const { info: info2 } = this;
         const m = msg().interactive.startup.header;
-        const boxWidth = Math.min(width2, HEADER_BOX_MAX_WIDTH);
-        const keyWidth = Math.max(
-          6,
-          ...[m.keyModel, m.keyDir, m.keyMode, m.keyLoaded, m.keyHost, m.keyWarnings].map(
-            (k) => visibleWidth(k)
-          )
-        );
-        const valueWidth = boxWidth - 4 - keyWidth - 1;
         const trust = this.trustText(true);
-        const cwdRoom = Math.max(4, valueWidth - visibleWidth(trust) - 3);
-        const rows = [
-          { key: m.keyModel, value: t.fg("accent", info2.model) + sep5 + m.thinking(info2.thinking) },
-          { key: m.keyDir, value: truncateLeft(info2.cwd, cwdRoom, t.glyphs.ellipsis) + sep5 + trust },
-          {
-            key: m.keyMode,
-            value: [this.modeText(), m.preset(info2.preset), this.codemodeText()].filter((p) => p !== void 0).join(sep5)
-          }
+        const cwdRoom = Math.max(4, width2 - visibleWidth(trust) - 3);
+        const lines2 = [
+          title,
+          t.fg("accent", info2.model) + sep5 + m.thinking(info2.thinking),
+          truncateLeft(info2.cwd, cwdRoom, t.glyphs.ellipsis) + sep5 + trust,
+          [this.modeText(), m.preset(info2.preset), this.codemodeText()].filter((p) => p !== void 0).join(sep5)
         ];
         const loaded = this.loadedText();
-        if (loaded !== void 0) rows.push({ key: m.keyLoaded, value: loaded });
-        if (info2.host !== void 0) rows.push({ key: m.keyHost, value: info2.host });
-        if (info2.warnings > 0) {
-          rows.push({ key: m.keyWarnings, value: t.fg("warning", m.warningsValue(info2.warnings)) });
+        if (loaded !== void 0) lines2.push(loaded);
+        if (info2.host !== void 0) lines2.push(m.host(info2.host));
+        if (info2.warnings > 0) lines2.push(t.fg("warning", m.warnings(info2.warnings)));
+        lines2.push(t.fg("dim", fitSegments(m.hint, width2)));
+        return lines2.map((line2) => truncateToWidth(line2, width2));
+      }
+      /** 字符画 + 信息列：够宽并排（顶端对齐），否则上下叠放。 */
+      logoLines(width2) {
+        const t = this.theme;
+        const logo = paintLogo(t, this.sweep);
+        const logoCols = logoWidth(logoRows(t));
+        const title = `${t.bold("ama")} ${t.fg("dim", this.info.version)}`;
+        if (width2 < HEADER_SIDE_MIN_WIDTH) {
+          return [...logo, "", ...this.infoLines(width2, title)];
+        }
+        const info2 = this.infoLines(width2 - logoCols - GAP, title);
+        const rows = Math.max(logo.length, info2.length);
+        const blank = " ".repeat(logoCols);
+        const gap = " ".repeat(GAP);
+        const lines2 = [];
+        for (let i = 0; i < rows; i++) {
+          const right = info2[i];
+          lines2.push(right === void 0 ? logo[i] ?? "" : (logo[i] ?? blank) + gap + right);
         }
-        const padded = rows.map((row3) => ({ ...row3, key: padToWidth(row3.key, keyWidth) }));
-        const kv = new KeyValue(padded, { theme: t, gap: 1, maxKeyRatio: 1 });
-        const body = {
-          render: (inner) => [this.title(), "", ...kv.render(inner), "", t.fg("dim", m.hint)],
-          invalidate: () => kv.invalidate()
-        };
-        return new Box(body, { theme: t }).render(boxWidth);
+        return lines2;
       }
       invalidate() {
         this.cache = null;
@@ -56328,6 +57500,10 @@ var init_run_indicator = __esm({
     RunIndicator = class {
       constructor(deps) {
         this.deps = deps;
+        deps.loader.onFrame(() => {
+          if (this.busy && !this.approval && this.optionalHints().join("\n") !== this.hintKey)
+            this.applyVerb();
+        });
       }
       deps;
       running = false;
@@ -56335,6 +57511,23 @@ var init_run_indicator = __esm({
       approval = false;
       retry;
       stream;
+      /** [W7-A] 有该显示的子 Agent 任务（interactive-mode 在 AgentUi 建好后接上）。 */
+      agents = () => false;
+      /** [W7-C] 有阻塞中的前台任务（Ctrl+B 可转后台）。 */
+      background = () => false;
+      /** [W7-C] 有停靠在 Agent 栏的审批。 */
+      docked = () => false;
+      hintKey = "";
+      /** 可丢弃的按键提示（按丢弃的逆序排列）。 */
+      optionalHints() {
+        const down = this.deps.theme.glyphs.arrowDown;
+        const key = this.deps.backgroundKey;
+        const out = [];
+        if (key !== void 0 && this.background()) out.push(msg().agents.background.runHint(key));
+        if (this.docked()) out.push(msg().agents.approval.runHint(down));
+        else if (this.agents()) out.push(msg().agents.bar.runHint(down));
+        return out;
+      }
       get busy() {
         return this.running || this.compacting;
       }
@@ -56413,17 +57606,21 @@ var init_run_indicator = __esm({
         const m = msg().interactive.view.run;
         const esc = [m.esc];
         if (this.approval) {
+          this.hintKey = "";
           loader.setVerb(m.awaitingApproval);
           return;
         }
+        const hints = this.optionalHints();
+        this.hintKey = hints.join("\n");
+        const optional = hints.length > 0 ? { optional: hints } : {};
         const running = tools.running();
         const top = running.filter((view) => !running.some((p) => p.children.includes(view)));
         if (top.length === 1) {
-          loader.setVerb(m.runningTool(top[0].toolName), esc);
+          loader.setVerb(m.runningTool(top[0].toolName), esc, optional);
           return;
         }
         if (top.length > 1) {
-          loader.setVerb(m.runningTools(top.length), esc);
+          loader.setVerb(m.runningTools(top.length), esc, optional);
           return;
         }
         if (this.retry !== void 0) {
@@ -56434,15 +57631,15 @@ var init_run_indicator = __esm({
           return;
         }
         if (this.compacting) {
-          loader.setVerb(m.compacting, esc);
+          loader.setVerb(m.compacting, esc, optional);
           return;
         }
         const stream5 = this.stream;
         if (stream5 !== void 0 && !stream5.thinking && stream5.tokens > 0) {
-          loader.setVerb(m.replying, [`↓≈${formatTokens3(stream5.tokens)}`, ...esc]);
+          loader.setVerb(m.replying, [`↓≈${formatTokens3(stream5.tokens)}`, ...esc], optional);
           return;
         }
-        loader.setVerb(m.thinking, esc);
+        loader.setVerb(m.thinking, esc, optional);
       }
     };
     QueueView = class extends Text {
@@ -56481,7 +57678,10 @@ function createSessionEventHandler(deps) {
   const { view, tools, status, area, agentUi, indicator, session, setQueue, notice, render } = deps;
   const images = new ImageBudgetNotices((text) => notice("info", text));
   return (event) => {
-    if (area.onEvent(event) || agentUi().onEvent(event)) return render();
+    if (area.onEvent(event) || agentUi().onEvent(event)) {
+      if (event.type === "subagent_start" || event.type === "subagent_end") indicator.sync();
+      return render();
+    }
     images.onEvent(event);
     switch (event.type) {
       case "agent_settled":
@@ -56677,6 +57877,7 @@ function runInteractiveMode(runtime, context, options = {}) {
   tui.addChild(hint);
   tui.addChild(area.rate);
   tui.addChild(status);
+  tui.addChild(area.quota);
   let finished = false;
   let hintTimer;
   let resolveExit = () => void 0;
@@ -56698,7 +57899,11 @@ 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 !== void 0 ? { backgroundKey } : {}
+  });
   const setQueue = (steering, followUp) => {
     status.setQueue(steering.length, followUp.length);
     queueView.setQueue(steering, followUp);
@@ -56720,7 +57925,7 @@ function runInteractiveMode(runtime, context, options = {}) {
   const startupLevel = startupScreenLevel(runtime);
   const home = env["HOME"] ?? env["USERPROFILE"];
   const info2 = startupInfo(runtime, home);
-  const header = (level) => new StartupHeader(info2, { theme, level, ...ui.compact === true ? { compact: true } : {} });
+  const header = (level) => new StartupHeader(info2, { theme, level, logo: ui.logo, compact: ui.compact });
   const resetView = () => {
     view.reset();
     if (startupLevel !== "silent") view.add(header("header"));
@@ -56893,22 +58098,13 @@ function runInteractiveMode(runtime, context, options = {}) {
       runCommand: (line2) => void runCommand2(line2),
       exit: (code) => exit(code),
       onInterrupted: (empty) => void rewind.afterInterrupt(empty),
-      agents: () => agentUi.keys
+      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,
@@ -56931,33 +58127,18 @@ function runInteractiveMode(runtime, context, options = {}) {
     ...options.clipboard !== void 0 ? { 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 = () => blockingTasks2(session).length > 0;
   let offSignals = () => void 0;
   function exit(code) {
     if (finished) return;
     finished = true;
+    logoAnimation?.finish();
     if (hintTimer !== void 0) clearTimeout(hintTimer);
     loader.stop();
     area.dispose();
@@ -56966,6 +58147,7 @@ function runInteractiveMode(runtime, context, options = {}) {
     tui.addChild(view);
     offSignals();
     agentUi.detach();
+    dock.dispose();
     runtime.approvals.setUiBroker(void 0);
     runtime.notifier.set(void 0);
     tui.stop();
@@ -56975,12 +58157,14 @@ function runInteractiveMode(runtime, context, options = {}) {
       resolveExit(code);
     });
   }
-  if (startupLevel !== "silent") view.add(header(startupLevel));
+  const startHeader = startupLevel === "silent" ? void 0 : header(startupLevel);
+  let logoAnimation;
+  if (startHeader !== void 0) view.add(startHeader);
   for (const warning of startupWarnings) view.addNotice("warn", warning);
   replay();
   status.refresh();
-  return new Promise((resolve38, reject2) => {
-    resolveExit = resolve38;
+  return new Promise((resolve39, reject2) => {
+    resolveExit = resolve39;
     try {
       tui.start();
     } catch (error2) {
@@ -57001,6 +58185,8 @@ function runInteractiveMode(runtime, context, options = {}) {
     agentUi.attach(session);
     offSignals = onTerminationSignals((code) => exit(code));
     tui.setFocus(editor);
+    const gate = { animation: ui.animation, host: info2.host !== void 0, env, ...context };
+    logoAnimation = playStartupAnimation(tui, startHeader, theme, gate);
     options.onReady?.({
       tui,
       editor,
@@ -57024,7 +58210,6 @@ var init_interactive_mode = __esm({
     init_image_input();
     import_node_path97 = require("node:path");
     init_session2();
-    init_subagent_registry();
     init_compose_session();
     init_startup_screen();
     init_errors();
@@ -57033,8 +58218,7 @@ var init_interactive_mode = __esm({
     init_bypass();
     init_shared2();
     init_agent_ui();
-    init_approval_dialog();
-    init_approval_merge();
+    init_approval_ui();
     init_commands2();
     init_memory_panel();
     init_completion();
@@ -57047,12 +58231,14 @@ var init_interactive_mode = __esm({
     init_rewind_flow();
     init_trace_view();
     init_startup_header();
+    init_startup_logo();
     init_run_indicator();
     init_status_area();
     init_session_events();
     init_subagent_view();
     init_terminal_setup();
     init_tool_view();
+    init_task_background();
     HINT_MS = 2500;
   }
 });
@@ -57106,7 +58292,7 @@ function createTextStartupUi(io) {
     io.write([...lines2, question].join("\n"));
     return readOneLine(io.stdin);
   };
-  const list5 = (values, labels) => values.map((_, i) => `  ${i + 1}. ${labels[i]}`);
+  const list5 = (values, labels2) => values.map((_, i) => `  ${i + 1}. ${labels2[i]}`);
   return {
     async promptTrust(cwd, resources) {
       const m = msg().report.startup;
@@ -57121,11 +58307,11 @@ function createTextStartupUi(io) {
       if (items.length === 0) return void 0;
       const sorted = [...items].sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
       const ids = sorted.map((item) => item.id);
-      const labels = sorted.map(
+      const labels2 = sorted.map(
         (item) => `${item.id.slice(0, 8)}  ${(item.name ?? item.firstPrompt ?? "").replace(/\s+/g, " ").slice(0, 60)}`
       );
       const m = msg().report.startup;
-      return choose(await ask([m.resumeQuestion, ...list5(ids, labels)], m.resumeAnswer), ids);
+      return choose(await ask([m.resumeQuestion, ...list5(ids, labels2)], m.resumeAnswer), ids);
     },
     async pickModel(providers, reason) {
       const refs = [];
@@ -58903,15 +60089,15 @@ function browserCommand(url, platform = process.platform) {
     return { command: "cmd", args: ["/c", "start", '""', url.replace(/&/g, "^&")] };
   return { command: "xdg-open", args: [url] };
 }
-var openBrowser = (url) => new Promise((resolve38) => {
+var openBrowser = (url) => new Promise((resolve39) => {
   const { command: command3, args } = browserCommand(url);
   try {
     const child = (0, import_node_child_process12.spawn)(command3, args, { stdio: "ignore", detached: true, windowsHide: true });
-    child.once("error", () => resolve38(false));
-    child.once("exit", (code) => resolve38(code === 0 || code === null));
+    child.once("error", () => resolve39(false));
+    child.once("exit", (code) => resolve39(code === 0 || code === null));
     child.unref();
   } catch {
-    resolve38(false);
+    resolve39(false);
   }
 });
 
@@ -58938,7 +60124,7 @@ function listed(item) {
   const visibility = item["visibility"];
   return visibility === void 0 || visibility === "list";
 }
-function codexMetadata(item) {
+function backendMetadata(item) {
   const out = {};
   const window2 = item["context_window"];
   if (typeof window2 === "number" && Number.isInteger(window2) && window2 > 0)
@@ -58978,7 +60164,7 @@ async function listChatGptModels(fetchFn, baseUrl, auth) {
     out.push({
       id,
       ...typeof name === "string" && name !== "" ? { name } : {},
-      ...auth.flavor === "codex" ? codexMetadata(item) : {}
+      ...backendMetadata(item)
     });
   }
   return out;
@@ -59080,7 +60266,7 @@ function parseCallbackUrl(input2, state) {
   return codeFromParams(params, state);
 }
 function listen(server, port) {
-  return new Promise((resolve38, reject2) => {
+  return new Promise((resolve39, reject2) => {
     const onError = (error2) => {
       server.off("listening", onListening);
       reject2(error2);
@@ -59088,7 +60274,7 @@ function listen(server, port) {
     const onListening = () => {
       server.off("error", onError);
       const address = server.address();
-      resolve38(typeof address === "object" && address !== null ? address.port : port);
+      resolve39(typeof address === "object" && address !== null ? address.port : port);
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -59099,8 +60285,8 @@ async function startCallbackServer(options) {
   const path = options.path ?? CALLBACK_PATH;
   const pages = options.pages ?? DEFAULT_PAGES;
   let settle;
-  const result = new Promise((resolve38, reject2) => {
-    settle = { resolve: resolve38, reject: reject2 };
+  const result = new Promise((resolve39, reject2) => {
+    settle = { resolve: resolve39, reject: reject2 };
   });
   result.catch(() => {
   });
@@ -59220,9 +60406,9 @@ async function loginPaste(preset, deps) {
 }
 var DEVICE_MAX_WAIT_MS = 15 * 6e4;
 function defaultSleep(ms, signal) {
-  return new Promise((resolve38, reject2) => {
+  return new Promise((resolve39, reject2) => {
     if (signal?.aborted) return reject2(new AmaError("aborted", "login aborted"));
-    const timer = setTimeout(resolve38, ms);
+    const timer = setTimeout(resolve39, ms);
     signal?.addEventListener(
       "abort",
       () => {
@@ -61053,12 +62239,12 @@ var RATE_LIMIT_RETRY_MS = 2e3;
 var RECOVER_AFTER = 4;
 var FATAL_STATUS = /^(?:HTTP )?(?:401|403|429)\b/;
 var RATE_LIMITED = /^(?:HTTP )?429\b/;
-var sleep5 = (ms, signal) => new Promise((resolve38) => {
+var sleep5 = (ms, signal) => new Promise((resolve39) => {
   const timer = setTimeout(done, ms);
   function done() {
     clearTimeout(timer);
     signal?.removeEventListener("abort", done);
-    resolve38();
+    resolve39();
   }
   signal?.addEventListener("abort", done, { once: true });
 });
@@ -61185,7 +62371,7 @@ var ProbeScheduler = class {
   async run(count2, task, onDone) {
     const results = new Array(count2).fill(void 0);
     let next = 0;
-    await new Promise((resolve38, reject2) => {
+    await new Promise((resolve39, reject2) => {
       const pump = () => {
         while (this.stopReason === void 0 && next < count2 && this.active < this.limit) {
           const index2 = next++;
@@ -61205,7 +62391,7 @@ var ProbeScheduler = class {
             }
           );
         }
-        if (this.active === 0 && (next >= count2 || this.stopReason !== void 0)) resolve38();
+        if (this.active === 0 && (next >= count2 || this.stopReason !== void 0)) resolve39();
       };
       pump();
     });
@@ -61443,10 +62629,15 @@ async function run6(ctx) {
     const fields = match !== void 0 ? modelsDevFields(match.model) : void 0;
     if (fields?.toolCall === false) noTools.add(model.id);
     if (match === void 0) unmatched.add(model.id);
-    const meta2 = fields === void 0 ? m.unmatched : `  ctx ${compactTokens(fields.contextWindow)} · out ${compactTokens(fields.maxTokens)}${fields.input?.includes("image") ? m.image : ""}${fields.reasoning ? m.reasoning : ""}${fields.toolCall === false ? m.noTools : ""} · ${matchLabel(match)}`;
+    const backendCtx = model.contextWindow !== void 0 ? `  ctx ${compactTokens(model.contextWindow)}${m.fromBackend}` : void 0;
+    const meta2 = fields === void 0 ? `${backendCtx ?? ""}${m.unmatched}` : `${backendCtx ?? `  ctx ${compactTokens(fields.contextWindow)}`} · out ${compactTokens(fields.maxTokens)}${fields.input?.includes("image") ? m.image : ""}${fields.reasoning ? m.reasoning : ""}${fields.toolCall === false ? m.noTools : ""} · ${matchLabel(match)}`;
     io.stdout(`  ${model.id}${known !== void 0 ? m.configured(known.api) : ""}${meta2}
 `);
   }
+  if (provider.id === CHATGPT_PROVIDER_ID) {
+    const missing = found.filter((x) => x.contextWindow === void 0).map((x) => x.id);
+    if (missing.length > 0) io.stdout(m.noBackendWindow(missing.join(", ")));
+  }
   const write2 = ctx.flags.has("write");
   if (!ctx.flags.has("probe") || provider.id === CHATGPT_PROVIDER_ID) {
     if (write2)
@@ -61602,13 +62793,13 @@ async function disable(ctx) {
 }
 async function listEnabled(ctx) {
   const m = msg().subcommands.modelsEnabled;
-  const labels = msg().panels.model;
+  const labels2 = msg().panels.model;
   const list5 = enabledList(ctx.level.merged.config.models?.enabled);
   const status = async (providerId) => {
     const provider = ctx.registry.get(providerId);
     if (provider === void 0) return "?";
     const access = await providerAccess(ctx.registry, provider);
-    return access === "none" ? labels.noKey : labels[access];
+    return access === "none" ? labels2.noKey : labels2[access];
   };
   if (list5 !== void 0) {
     ctx.io.stdout(m.listHeader(ctx.level.userConfigPath));
@@ -61630,7 +62821,7 @@ async function listEnabled(ctx) {
   for (const provider of ctx.registry.list()) {
     const access = await providerAccess(ctx.registry, provider);
     if (!accessReady(access)) continue;
-    const label2 = access === "none" ? labels.noKey : labels[access];
+    const label2 = access === "none" ? labels2.noKey : labels2[access];
     for (const model of provider.models) {
       ctx.io.stdout(`  ${provider.id}/${model.id}  ${label2}
 `);
@@ -63887,19 +65078,19 @@ function redactedLookup(lookup) {
 }
 function axisPoints(trace) {
   const t0 = trace.startedAt;
-  const windows = [];
+  const windows2 = [];
   for (const turn of trace.turns) {
     const span = turnSpan(turn);
-    if (span !== void 0) windows.push([span.start - t0, span.end - t0]);
+    if (span !== void 0) windows2.push([span.start - t0, span.end - t0]);
   }
   for (const aux of trace.aux)
     if (aux.startedAt !== void 0)
-      windows.push([aux.startedAt - t0, (aux.endedAt ?? aux.startedAt) - t0]);
-  windows.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+      windows2.push([aux.startedAt - t0, (aux.endedAt ?? aux.startedAt) - t0]);
+  windows2.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
   const points = [[0, 0]];
   let raw = 0;
   let mapped = 0;
-  for (const [start, end] of windows) {
+  for (const [start, end] of windows2) {
     if (end <= raw) continue;
     const from = Math.max(start, raw);
     if (from > raw) {
@@ -64384,14 +65575,14 @@ var registeredDeps;
 function readStdinDefault() {
   const stdin = process.stdin;
   if (!stdin.isTTY) {
-    return new Promise((resolve38, reject2) => {
+    return new Promise((resolve39, reject2) => {
       const chunks2 = [];
       stdin.on("data", (chunk) => chunks2.push(chunk));
-      stdin.once("end", () => resolve38(Buffer.concat(chunks2).toString("utf8")));
+      stdin.once("end", () => resolve39(Buffer.concat(chunks2).toString("utf8")));
       stdin.once("error", reject2);
     });
   }
-  return new Promise((resolve38) => {
+  return new Promise((resolve39) => {
     let line2 = "";
     stdin.setRawMode(true);
     stdin.resume();
@@ -64401,14 +65592,14 @@ function readStdinDefault() {
           stdin.off("data", onData);
           stdin.setRawMode(false);
           stdin.pause();
-          resolve38(line2);
+          resolve39(line2);
           return;
         }
         if (ch2 === "") {
           stdin.off("data", onData);
           stdin.setRawMode(false);
           stdin.pause();
-          resolve38("");
+          resolve39("");
           return;
         }
         if (ch2 === "" || ch2 === "\b") line2 = line2.slice(0, -1);
@@ -64432,7 +65623,7 @@ function stdinKindDefault() {
 }
 function readStdinFirstByteDefault(timeoutMs) {
   const stdin = process.stdin;
-  return new Promise((resolve38, reject2) => {
+  return new Promise((resolve39, reject2) => {
     const chunks2 = [];
     let timer;
     const cleanup = () => {
@@ -64448,7 +65639,7 @@ function readStdinFirstByteDefault(timeoutMs) {
     };
     const onEnd = () => {
       cleanup();
-      resolve38(Buffer.concat(chunks2).toString("utf8"));
+      resolve39(Buffer.concat(chunks2).toString("utf8"));
     };
     const onError = (error2) => {
       cleanup();
@@ -64458,7 +65649,7 @@ function readStdinFirstByteDefault(timeoutMs) {
       cleanup();
       stdin.pause();
       stdin.destroy();
-      resolve38(void 0);
+      resolve39(void 0);
     }, timeoutMs);
     stdin.on("data", onData);
     stdin.once("end", onEnd);