diff --git a/README.md b/README.md
index 8ab44455..2b42753d 100644
--- a/README.md
+++ b/README.md
@@ -351,9 +351,13 @@ Baselines across these dimensions include **Claude Code**, **OpenAI CodeX**, and
 
 ## 📅 Roadmap & News
 
+- **2026-05-23** — 🆕 **TUI v3 released** (`frontends/tui_v3.py`). Block-based scrollback with proper resize reflow, per-terminal color profile for cross-terminal parity, and feature parity with v2.
+- **2026-05-18** — 🆕 **Morphling mode**. Project-level skill absorption — extract goal + tests from any external repo, then decide per component: call, rewrite, or discard. See `memory/morphling_sop.md`.
+- **2026-05-17** — 🆕 **Goal Hive mode**. Multi-worker cooperative Goal mode — BBS-coordinated master/workers running long-horizon objectives in parallel. See `memory/goal_hive_sop.md`.
 - **2026-05-15** — 🖥️ **Desktop GUI released**. One-line installs ship a ready-to-run desktop app (`frontends/GenericAgent.exe`). Developers launch via `python launch.pyw`.
 - **2026-05-14** — 🆕 **Conductor sub-agent orchestration**. Spawn, supervise, and auto-clean parallel sub-agents; first-class delegation primitives complementing `/btw` side-questions.
 - **2026-05-12** — 🆕 **TUI v2 released** (`frontends/tuiapp_v2.py`). Refined Textual frontend with image-paste folding, file paste, block-delete, Ctrl+C copy, history navigation, and `/llm` / `/export` / `/continue` pickers.
+- **2026-05-08** — 🆕 **Goal mode** (`reflect/goal_mode.py`). Time-budget-driven self-driven loop — "keep optimizing X for N hours" with no premature delivery.
 - **2026-04-21** — 📄 [**Technical Report on arXiv**](https://arxiv.org/abs/2604.17091) — *GenericAgent: A Token-Efficient Self-Evolving LLM Agent via Contextual Information Density Maximization*.
 - **2026-04-11** — Introduced **L4 session archive memory** and scheduler cron integration.
 - **2026-03-23** — Personal WeChat supported as a bot frontend.
@@ -388,6 +392,7 @@ Thanks to the **LinuxDo** community for the support!
 
 - [chilishark27/ga-manager](https://github.com/chilishark27/ga-manager)
 - [wangjc683/galley](https://github.com/wangjc683/galley)
+- [FroStorM/A3Agent](https://github.com/FroStorM/A3Agent/tree/workbench)
 
 ---
 
@@ -720,9 +725,13 @@ GenericAgent 通过 **分层记忆 × 最小工具集 × 自主执行循环** 
 
 ## 📅 路线图与最新动态
 
+- **2026-05-23** — 🆕 **TUI v3 正式发布**（`frontends/tui_v3.py`）。基于块的滚屏回看 + 正确的 resize 重排，每终端独立配色保证跨终端一致，并与 v2 达成功能对齐。
+- **2026-05-18** — 🆕 **Morphling 模式**。项目级能力吞噬 —— 从任意外部仓库抽取目标与测例后，对每个核心组件分别决定调用、重写或舍弃。详见 `memory/morphling_sop.md`。
+- **2026-05-17** — 🆕 **Goal Hive 模式**。多 worker 协作版 Goal —— Master/Worker 通过 BBS 协同推进长程目标。详见 `memory/goal_hive_sop.md`。
 - **2026-05-15** — 🖥️ **桌面 GUI 发布**。一键安装会自带可直接运行的桌面端（`frontends/GenericAgent.exe`），开发者也可用 `python launch.pyw` 启动。
 - **2026-05-14** — 🆕 **Conductor 子 Agent 编排**。派发、监督、自动清理并行子 Agent；与 `/btw` 旁路子 Agent 互补，提供一等公民级的任务委派原语。
 - **2026-05-12** — 🆕 **TUI v2 正式发布**（`frontends/tuiapp_v2.py`）。重做视觉风格的 Textual 前端，支持图片粘贴折叠、文件粘贴、块删除、Ctrl+C 复制、历史导航，以及 `/llm` / `/export` / `/continue` 选择器。
+- **2026-05-08** — 🆕 **Goal 模式**（`reflect/goal_mode.py`）。时间预算驱动的自驱循环 —— "持续优化 X N 小时"，预算没到不准提前交付。
 - **2026-04-21** — 📄 [**技术报告已发布至 arXiv**](https://arxiv.org/abs/2604.17091) — *GenericAgent: A Token-Efficient Self-Evolving LLM Agent via Contextual Information Density Maximization*。
 - **2026-04-11** — 引入 **L4 会话归档记忆**，并接入 scheduler cron 调度。
 - **2026-03-23** — 支持个人微信接入作为 Bot 前端。
@@ -757,7 +766,7 @@ GenericAgent 通过 **分层记忆 × 最小工具集 × 自主执行循环** 
 
 - [chilishark27/ga-manager](https://github.com/chilishark27/ga-manager)
 - [wangjc683/galley](https://github.com/wangjc683/galley)
-- https://github.com/FroStorM/A3Agent/tree/workbench
+- [FroStorM/A3Agent](https://github.com/FroStorM/A3Agent/tree/workbench)
 
 ---
 
diff --git a/docs/GETTING_STARTED.md b/docs/GETTING_STARTED.md
index 8d4525f1..eec10a58 100644
--- a/docs/GETTING_STARTED.md
+++ b/docs/GETTING_STARTED.md
@@ -48,9 +48,36 @@ python3 --version
 
 ### 下载项目
 
-1. 打开 [GitHub 仓库页面](https://github.com/lsdefine/GenericAgent)
-2. 点绿色 **Code** 按钮 → **Download ZIP**
-3. 解压到你喜欢的位置
+最方便的方式是 **一键安装**（自带隔离 Python 环境 + Git + 桌面端）：
+
+**Windows PowerShell**
+
+```powershell
+powershell -ExecutionPolicy Bypass -c "irm http://fudankw.cn:9000/files/ga_install.ps1 | iex"
+```
+
+**Linux / macOS**
+
+```bash
+curl -fsSL http://fudankw.cn:9000/files/ga_install.sh | bash
+```
+
+或者手动 clone（开发者）：
+
+```bash
+git clone https://github.com/lsdefine/GenericAgent.git
+cd GenericAgent
+uv venv && uv pip install -e ".[ui]"
+```
+
+也可以走最朴素的 ZIP：[GitHub 仓库页面](https://github.com/lsdefine/GenericAgent) → 点绿色 **Code** → **Download ZIP** → 解压到喜欢的位置。
+
+> 💡 **让 Claude / Codex 等 Agent 帮你装**：把下面这条 curl 丢给它，它会按官方指南替你完成安装：
+> ```bash
+> curl -fsSL https://raw.githubusercontent.com/lsdefine/GenericAgent/refs/heads/main/docs/installation_zh.md
+> ```
+>
+> 📖 平台差异、排障、升级流程见 [`docs/installation_zh.md`](installation_zh.md)。
 
 ### 创建配置文件
 
@@ -62,62 +89,55 @@ python3 --version
 
 ### 配置示例
 
-**最常见的用法：**
+**推荐首选：Claude 原生协议**：
 
 ```python
-# 变量名含 'oai' → 走 OpenAI 兼容格式 (/chat/completions)
-oai_config = {
-    'apikey': 'sk-你的密钥',
-    'apibase': 'http://你的API地址:端口',
-    'model': '模型名称',
+# 变量名同时含 'native' 和 'claude' → NativeClaudeSession（API 原生工具字段）
+native_claude_config = {
+    'name': 'claude',                        # /llms 显示名 & mixin 引用名
+    'apikey': 'sk-xxx',                      # sk-ant- 走 x-api-key；其它走 Bearer
+    'apibase': 'https://api.anthropic.com',  # 官方直连；反代渠道填对应地址
+    'model': 'claude-opus-4-7',              # [1m] 后缀触发 1M 上下文 beta
+    # 'fake_cc_system_prompt': True,         # CC switch / 反代渠道必须置 True
 }
 ```
 
-```python
-# 变量名含 'claude'（不含 'native'）→ 走 Claude 兼容格式 (/messages)
-claude_config = {
-    'apikey': 'sk-你的密钥',
-    'apibase': 'http://你的API地址:端口',
-    'model': 'claude-sonnet-4-20250514',
-}
-```
+**也支持：OpenAI 原生协议**：
 
 ```python
-# MiniMax 使用 OpenAI 兼容格式，变量名含 'oai' 即可
-# 温度自动修正为 (0, 1]，支持 M2.7 / M2.5 全系列，204K 上下文
-oai_minimax_config = {
-    'apikey': 'eyJh...',
-    'apibase': 'https://api.minimax.io/v1',
-    'model': 'MiniMax-M2.7',
+# 变量名同时含 'native' 和 'oai' → NativeOAISession
+native_oai_config = {
+    'name': 'gpt',                           # /llms 显示名 & mixin 引用名
+    'apikey': 'sk-xxx',
+    'apibase': 'https://api.openai.com/v1',  # 自动补 /v1/chat/completions
+    'model': 'gpt-5.5',
 }
 ```
 
-**使用标准工具调用格式（适合较弱模型）：**
+**进阶：Mixin 故障转移**（多 session 自动切换，最稳的玩法）：
 
 ```python
-# 变量名同时含 'native' 和 'claude' → Claude 标准工具调用格式
-native_claude_config = {
-    'apikey': 'sk-ant-你的密钥',
-    'apibase': 'https://api.anthropic.com',
-    'model': 'claude-sonnet-4-20250514',
+# llm_nos 按优先级排列；首项失败按指数退避切下一项
+mixin_config = {
+    'llm_nos': ['claude', 'gpt'],   # 与上面 native_* 的 name 字段对应
+    'max_retries': 10,
+    'base_delay': 0.5,
 }
 ```
 
-> 💡 还支持 `native_oai_config`（OpenAI 标准工具调用）、`sider_cookie`（Sider）等，详见 `mykey_template.py` 中的注释。
+> 💡 完整字段说明（`thinking_type` / `reasoning_effort` / `context_win` / `proxy` / Zhipu / MiniMax / Kimi / OpenRouter 等渠道示例）见 `mykey_template.py` 顶部注释。
 
 ### 关键规则
 
-**变量命名决定接口格式**（不是模型名决定的）：
+**变量命名决定 Session 类型**（不是模型名决定的）：
 
-| 变量名包含 | 触发的 Session | 适用场景 |
-|-----------|---------------|---------|
-| `oai` | OpenAI 兼容 | 大多数 API 服务、OpenAI 官方 |
-| `claude`（不含 `native`） | Claude 兼容 | Claude API 服务 |
-| `native` + `claude` | Claude 标准工具调用 | 较弱模型推荐，工具调用更规范 |
-| `native` + `oai` | OpenAI 标准工具调用 | 较弱模型推荐，工具调用更规范 |
-
-> 例：用 Claude 模型，但 API 服务提供的是 OpenAI 兼容接口 → 变量名用 `oai_xxx`。
-> 例：用 MiniMax 模型 → 变量名用 `oai_minimax_config`，MiniMax 走 OpenAI 兼容接口。
+| 变量名包含 | 触发的 Session | 工具协议 | 适用场景 |
+|-----------|---------------|---------|---------|
+| `native` + `claude` | NativeClaudeSession | API 原生 tool 字段 | **推荐首选** — Claude 原生协议 |
+| `native` + `oai` | NativeOAISession | API 原生 tool 字段 | GPT/o 系列、OAI 兼容渠道 |
+| `mixin` | MixinSession | 多 session 故障转移 | 最稳；要求被引用 session 全为 native |
+| `claude`（不含 `native`） | ClaudeSession | 文本协议工具 | **deprecated**，后续版本可能移除 |
+| `oai`（不含 `native`） | LLMSession | 文本协议工具 | **deprecated**，后续版本可能移除 |
 
 **`apibase` 填写规则**（会自动拼接端点路径）：
 
@@ -167,13 +187,16 @@ Agent 会自己读代码、找出需要的包、全部装好。
 
 ### 升级到图形界面
 
-依赖装完后，就可以用 GUI 模式了：
+依赖装完后，可以选择适合你的前端：
 
-```bash
-python3 launch.pyw
-```
+| 前端 | 启动命令 | 说明 |
+|------|---------|------|
+| **桌面端** | 双击 `frontends/GenericAgent.exe`（Windows 一键安装自带） | 真原生窗口，零终端依赖 |
+| **TUI v3** | `python frontends/tui_v3.py` | 基于块的滚屏回看、resize 重排、每终端独立配色，跨终端体验一致 |
+| **TUI v2** | `python frontends/tuiapp_v2.py` | Textual 键盘驱动界面，图片粘贴折叠、`/llm`/`/export`/`/continue` 选择器 |
+| **Streamlit / 悬浮窗** | `python launch.pyw` | 浏览器中打开的 Streamlit UI，附带桌面悬浮窗 |
 
-启动后会出现一个桌面悬浮窗，直接在里面输入任务指令。
+> 💡 Windows 下推荐用 **Git Bash** 跑 TUI；PowerShell / cmd 对 Unicode 和键位支持较弱。仍异常时请直接告诉 Agent：「参考 Claude Code 在 Windows 终端的最佳配置帮我把 TUI 修一遍」。
 
 ### 可选：让 Agent 帮你做的事
 
@@ -244,6 +267,10 @@ Agent 会自动配好。如果你电脑上没有 Git，它也会帮你下载 por
 | **Plan（规划）** | `查看你的代码，告诉我你的 plan 模式怎么启用` |
 | **SubAgent（子代理）** | `查看你的代码，告诉我你的 subagent 模式怎么启用` |
 | **自主探索** | `查看你的代码，告诉我你的自主探索模式怎么启用` |
+| **Goal** | `查看你的代码，告诉我 goal 模式怎么启用` |
+| **Goal Hive（多 worker 协作）** | `查看你的代码，告诉我 goal hive 模式怎么启用` |
+| **Conductor（多 subagent 编排）** | `查看你的代码，告诉我 conductor 模式怎么启用` |
+| **Morphling（吞噬外部项目）** | `查看你的代码，告诉我 morphling 模式怎么启用` |
 
 > 💡 这就是 GenericAgent 的核心设计理念：**代码即文档**。Agent 能读懂自己的源码，所以任何功能你都可以直接问它。
 
@@ -268,4 +295,4 @@ GenericAgent 不预设技能，而是**靠使用进化**。每完成一个新任
 
 > Agent 会自动 pull 最新代码并解读 commit log，告诉你新增了什么能力。
 
-> 更多细节请参阅 [README.md](../README.md) 或 [详细版图文教程](https://my.feishu.cn/wiki/CGrDw0T76iNFuskmwxdcWrpinPb)。
\ No newline at end of file
+> 更多细节请参阅 [README.md](../README.md) 或 [详细版图文教程](https://my.feishu.cn/wiki/CGrDw0T76iNFuskmwxdcWrpinPb)。
diff --git a/frontends/slash_cmds.py b/frontends/slash_cmds.py
index 46415073..f6298562 100644
--- a/frontends/slash_cmds.py
+++ b/frontends/slash_cmds.py
@@ -343,18 +343,20 @@ def start_service(name: str) -> tuple[bool, str]:
 def _match_service(cmdline: list[str], svc: dict) -> bool:
     """Does this OS process belong to `svc`?  Match on the trailing script
     arg (`reflect/foo.py` for reflect tasks, `frontends/bar.py` for apps),
-    which is invariant across `python` vs `pythonw` vs venv shims."""
+    which is invariant across `python` vs `pythonw` vs venv shims.
+
+    Reflect detection used to require BOTH `agentmain.py` AND the reflect
+    path in cmdline.  That rejected tasks launched directly (`python
+    reflect/scheduler.py`) by launch.pyw, dev scripts, or by an earlier
+    TUI run that used a different launcher — they showed unticked in
+    /scheduler even when alive.  Path-only match handles both styles; the
+    Python-process pre-filter in `running_services` keeps false positives
+    (greps, editors with the file open) from sneaking in."""
     if not cmdline:
         return False
     rel = svc["name"]  # 'reflect/foo.py' | 'frontends/bar.py'
-    if svc["kind"] == "reflect":
-        # agentmain.py --reflect reflect/foo.py
-        has_main = any("agentmain.py" in (a or "") for a in cmdline)
-        has_rel = any(rel.replace("/", os.sep) in (a or "") or rel in (a or "")
-                      for a in cmdline)
-        return has_main and has_rel
-    # frontend: either `python frontends/foo.py` or `python -m streamlit run frontends/stapp.py …`
-    return any(rel.replace("/", os.sep) in (a or "") or rel in (a or "")
+    rel_norm = rel.replace("/", os.sep)
+    return any(rel_norm in (a or "") or rel in (a or "")
                for a in cmdline)
 
 
@@ -503,7 +505,8 @@ def start_reflect_task(name: str) -> tuple[bool, str]:
     ("/goal",      "[goal]",    "进入 Goal 模式（需 condition 约束）"),
     ("/hive",      "[target]",  "进入 Hive 多 worker 协作模式"),
     ("/conductor", "[task]",    "调用 frontends/conductor.py 多 subagent 编排"),
-    ("/scheduler", "",          "多选启动 reflect 任务 / 查看 cron"),
+    ("/scheduler", "",          "多选启动/停止 reflect 任务（cron 由 reflect/scheduler.py 驱动）"),
+    ("/resume",    "",           "列出最近会话并恢复其中一个（GA 端展开 prompt）"),
 ]
 
 
diff --git a/frontends/tui_v3.py b/frontends/tui_v3.py
index 3ef2f2b6..d63e2abe 100644
--- a/frontends/tui_v3.py
+++ b/frontends/tui_v3.py
@@ -102,6 +102,8 @@
         "Tip: /scheduler is live — untick a running row to stop it; tick again to relaunch.",
         "Tip: Ctrl+S stashes your draft input — it's waiting for you next time you open a picker.",
         "Tip: /scheduler lists reflect tasks and starts them via `/scheduler start a,b,c`.",
+        "Tip: prefix `!` runs the rest as a host shell command — output is folded into LLM history.",
+        "Tip: /resume lists recent sessions you can pick from to restore prior context.",
     ],
     'zh': [
         "Tip: 按 / 唤起命令面板 —— 方向键选择，Enter 落入输入框。",
@@ -119,6 +121,8 @@
         "Tip: /update 是双分支 upstream 同步 —— 先 diff 预演，再分别快进。",
         "Tip: /scheduler 里再点一下已勾选的任务可以 stop —— 取消勾选 = 停止。",
         "Tip: Ctrl+S 把当前输入 stash 起来，下次 / 打开 picker 时还在。",
+        "Tip: 以 `!` 开头直接跑 shell —— 命令与输出都会进入 LLM 历史，agent 可以引用。",
+        "Tip: /resume 列出最近会话，可挑选一个恢复之前的上下文。",
     ],
 }
 
@@ -146,6 +150,14 @@
         'help.export':          '  /export [sub]        Export last reply: clip / file [name] / all',
         'help.stop':            '  /stop                Abort current task',
         'help.language':        '  /language [code]     View / switch interface language',
+        'help.update':          '  /update [note]       Preview upstream commits & diff, then pull (no commit)',
+        'help.autorun':         '  /autorun [seed]      Enter autonomous-operation mode',
+        'help.morphling':       '  /morphling [target]  Distill / absorb an external skill',
+        'help.goal':            '  /goal [goal]         Enter Goal mode (asks for budget / worker cap)',
+        'help.hive':            '  /hive [target]       Enter Hive multi-worker mode',
+        'help.conductor':       '  /conductor [task]    Hand task to conductor.py for multi-subagent run',
+        'help.scheduler':       '  /scheduler           Multi-pick reflect tasks / view cron',
+        'help.emoji':           '  /emoji [style]       Pick the spinner pet face (picker / direct switch)',
         'help.quit':            '  /quit                Quit',
         'help.esc':             '  Esc                  Cancel ask · clear draft · stop task (no exit)',
         'help.cc':              '  Ctrl+C × 2           Quit (when idle; only aborts the task while running)',
@@ -193,7 +205,9 @@
         'cmd.hive.desc':        'enter Hive multi-worker mode',
         'cmd.conductor.arg':    '[task]',
         'cmd.conductor.desc':   'hand task to frontends/conductor.py for multi-subagent orchestration',
-        'cmd.scheduler.desc':   'multi-pick reflect tasks / show cron',
+        'cmd.scheduler.desc':   'multi-pick start/stop reflect tasks (cron is driven by reflect/scheduler.py)',
+        'cmd.emoji.arg':        '[style]',
+        'cmd.emoji.desc':       'pick the spinner pet face — opens picker; arg switches directly',
 
         # status line (one-liner above input box)
         'status.asking':        '◉ waiting · Esc cancel',
@@ -296,9 +310,19 @@
         # llm picker
         'llm.title':            'Switch LLM',
 
+        # emoji picker (pet style)
+        'emoji.title':          'Pick spinner pet style',
+        'emoji.switched':       'pet style → `{style}`',
+        'emoji.unknown':        'unknown style `{choice}` — valid: {valid}',
+        'emoji.row.current':    '● {name:<8} {sample}',
+        'emoji.row.other':      '  {name:<8} {sample}',
+        'emoji.row.off':        '(hide pet)',
+
         # /scheduler picker (multi-pick reflect tasks / frontends)
         'scheduler.pick.title':   'Pick services — checked = running (untick to stop)',
         'scheduler.pick.hint':    'Space toggle · ↑↓ move · Enter next · Esc cancel · or /scheduler start a,b,c',
+        'scheduler.cron.active':  'cron: {n} task(s) in sche_tasks/*.json · active (reflect/scheduler.py running)',
+        'scheduler.cron.inactive': 'cron: {n} task(s) in sche_tasks/*.json · inactive (start reflect/scheduler.py to schedule)',
         'scheduler.empty':        '(no startable services: both reflect/*.py and frontends/*app*.py are empty)',
         'scheduler.no_pick':      '(no service picked)',
         'scheduler.no_change':    '(no change vs running set)',
@@ -333,6 +357,23 @@
 
         # answer prefix when committing user reply to ask_user
         'msg.answer_prefix':    '[ans] {text}',
+
+        # pending input preview (queued while agent is busy)
+        'pending.head_running':  'queued {n} (agent busy) · ↑ amend · Esc clear',
+        'pending.head_cooldown': 'queued {n} · sending in {sec:.1f}s · ↑ amend · Esc cancel',
+        'pending.cleared':       'cleared {n} pending message(s)',
+        'pending.queued_marker': '[queued] {text}',
+
+        # shell-mode magic (`!` prefix)
+        'shell.hint':           '! for shell mode',
+        'shell.timeout':        '[shell: timeout {sec}s]',
+        'shell.error':          '[shell error: {err}]',
+        'shell.empty':          '(no output)',
+        'shell.history':        '[!shell] {cmd}\n```\n{out}\n```\n(exit {rc})',
+
+        # /resume
+        'cmd.resume.desc':      'list recent sessions and pick one to recover',
+        'help.resume':          '  /resume              List recent sessions and recover one',
     },
 
     'zh': {
@@ -354,6 +395,14 @@
         'help.export':          '  /export [sub]        导出最后回复：clip / file [name] / all',
         'help.stop':            '  /stop                中止当前任务',
         'help.language':        '  /language [code]     查看 / 切换界面语言',
+        'help.update':          '  /update [备注]       预览 upstream 提交与 diff，再 git pull（不 commit）',
+        'help.autorun':         '  /autorun [seed]      进入 autonomous_operation 自主模式',
+        'help.morphling':       '  /morphling [target]  启用 Morphling 蒸馏 / 吞噬外部技能',
+        'help.goal':            '  /goal [goal]         进入 Goal 模式（需 condition 约束）',
+        'help.hive':            '  /hive [target]       进入 Hive 多 worker 协作模式',
+        'help.conductor':       '  /conductor [task]    交给 conductor.py 做多 subagent 编排',
+        'help.scheduler':       '  /scheduler           多选启动 reflect 任务 / 查看 cron',
+        'help.emoji':           '  /emoji [style]       切换 spinner 宠物样式（picker / 直接传参）',
         'help.quit':            '  /quit                退出',
         'help.esc':             '  Esc                  撤回提问 · 清草稿 · 停任务（不退出）',
         'help.cc':              '  Ctrl+C × 2           退出（空闲时；运行中只 abort 任务）',
@@ -401,7 +450,9 @@
         'cmd.hive.desc':        '进入 Hive 多 worker 协作模式',
         'cmd.conductor.arg':    '[任务]',
         'cmd.conductor.desc':   '调用 frontends/conductor.py 做多 subagent 编排',
-        'cmd.scheduler.desc':   '多选启动 reflect 任务 / 查看 cron',
+        'cmd.scheduler.desc':   '多选启动/停止 reflect 任务（cron 由 reflect/scheduler.py 驱动）',
+        'cmd.emoji.arg':        '[样式]',
+        'cmd.emoji.desc':       '切换 spinner 宠物表情 — 打开 picker；带参数则直接切换',
 
         # status line
         'status.asking':        '◉ 待答 · Esc 撤回提问',
@@ -504,9 +555,19 @@
         # llm picker
         'llm.title':            '切换 LLM',
 
+        # emoji picker
+        'emoji.title':          '选择 spinner 宠物样式',
+        'emoji.switched':       '宠物样式 → `{style}`',
+        'emoji.unknown':        '未知样式 `{choice}` — 可选：{valid}',
+        'emoji.row.current':    '● {name:<8} {sample}',
+        'emoji.row.other':      '  {name:<8} {sample}',
+        'emoji.row.off':        '（隐藏 pet）',
+
         # /scheduler picker (multi-pick reflect tasks / frontends)
         'scheduler.pick.title':   '挑选要启动的服务（已勾选 = 运行中，取消勾选即停止）',
         'scheduler.pick.hint':    'Space 勾选 · ↑↓ 移动 · Enter 下一步 · Esc 取消 · 或 /scheduler start a,b,c',
+        'scheduler.cron.active':  'cron：sche_tasks/*.json 共 {n} 个任务 · 已激活（reflect/scheduler.py 在运行）',
+        'scheduler.cron.inactive': 'cron：sche_tasks/*.json 共 {n} 个任务 · 未激活（启动 reflect/scheduler.py 才会调度）',
         'scheduler.empty':        '（没有可启动的服务：reflect/*.py 与 frontends/*app*.py 均为空）',
         'scheduler.no_pick':      '（未选择任何服务）',
         'scheduler.no_change':    '（与当前运行集合相比无变化）',
@@ -541,6 +602,23 @@
 
         # answer prefix
         'msg.answer_prefix':    '[答] {text}',
+
+        # pending input preview
+        'pending.head_running':  '已排队 {n} 条（agent 忙）· ↑ 回看修改 · Esc 清空',
+        'pending.head_cooldown': '已排队 {n} 条 · {sec:.1f}s 后发送 · ↑ 回看修改 · Esc 取消',
+        'pending.cleared':       '已清空 {n} 条待发送消息',
+        'pending.queued_marker': '[排队] {text}',
+
+        # shell-mode magic (`!` prefix)
+        'shell.hint':           '! 进入 shell 模式',
+        'shell.timeout':        '[shell：{sec}s 超时]',
+        'shell.error':          '[shell 错误：{err}]',
+        'shell.empty':          '（无输出）',
+        'shell.history':        '[!shell] {cmd}\n```\n{out}\n```\n（退出码 {rc}）',
+
+        # /resume
+        'cmd.resume.desc':      '列出最近会话并恢复其中一个',
+        'help.resume':          '  /resume              列出最近会话并恢复其中一个',
     },
 }
 
@@ -1004,7 +1082,11 @@ def _cleanup():
 # Keep SGR (color) codes, strip everything else
 _ANSI_SGR_RE = re.compile(r'\x1b\[[0-9;]*m')
 
-_TURN_MARKER_RE = re.compile(r'\*\*LLM Running \(Turn (\d+)\).*?\*\*')
+# agent_loop.py emits `**LLM Running (Turn N) ...**` by default but switches
+# to the short `**Turn N ...**` when `handler.parent.task_dir` is set
+# (agent_loop.py:52).  TUI v3 sets task_dir to enable the _intervene
+# injection hook, which silently activates the short form — match both.
+_TURN_MARKER_RE = re.compile(r'\*\*(?:LLM Running \()?Turn (\d+)\)?[^\n]*?\*\*')
 _META_TAG_RE = re.compile(r'<(?:thinking|summary|tool_use|file_content)>.*?</(?:thinking|summary|tool_use|file_content)>', re.DOTALL)
 _TOOL_USE_BLOCK_RE = re.compile(r'```json\s*\{[^}]*"tool_name"[^}]*\}\s*```', re.DOTALL)
 _TOOL_USE_TAG_RE = re.compile(r'<tool_use>\s*\{.*?"tool_name"\s*:\s*"([^"]+)".*?\}\s*</tool_use>', re.DOTALL)
@@ -1017,7 +1099,9 @@ def _cleanup():
 # `<summary>` regex uses a negative lookahead so two adjacent summaries don't
 # merge; the title cleaner strips fenced code + thinking before extraction.
 _FENCE4_STASH_RE = re.compile(r'^`{4,}.*?^`{4,}\n?', re.DOTALL | re.MULTILINE)
-_TURN_SPLIT_FOLD_RE = re.compile(r'(\*\*LLM Running \(Turn \d+\) \.\.\.\*\*)')
+# Same as _TURN_MARKER_RE but capturing the WHOLE match for str.split() to
+# keep the marker as a separator token in the result list.
+_TURN_SPLIT_FOLD_RE = re.compile(r'(\*\*(?:LLM Running \()?Turn \d+\)? \.\.\.\*\*)')
 _SUMMARY_PERTURN_RE = re.compile(r'<summary>\s*((?:(?!<summary>).)*?)\s*</summary>', re.DOTALL)
 _TITLE_CLEAN_RE = re.compile(r'`{3,}.*?`{3,}|<thinking>.*?</thinking>', re.DOTALL)
 _TITLE_ARGS_TAIL_RE = re.compile(r',?\s*args:.*$')
@@ -1229,6 +1313,14 @@ def __init__(self, llm_no: int = 0):
             self.agent.llmclient = self.agent.llmclients[llm_no % len(self.agent.llmclients)]
         self.agent.inc_out = True
         self.agent.verbose = True
+        # Give the agent a `task_dir` so the per-turn `_intervene` file hook
+        # in ga.turn_end_callback (ga.py:576) can fire — that's how we
+        # smuggle pending user messages into the next LLM call while a
+        # turn is still in flight.  Dedicated PID-scoped dir so concurrent
+        # TUI v3 processes don't step on each other's intervene files.
+        self.agent.task_dir = os.path.join(_ROOT, 'temp', f'_tui_v3_{os.getpid()}')
+        try: os.makedirs(self.agent.task_dir, exist_ok=True)
+        except Exception: pass
         self.ask_user_queue: queue.Queue[AskUserEvent] = queue.Queue()
         self._install_hook()
         self._healthy = True
@@ -1239,6 +1331,43 @@ def __init__(self, llm_no: int = 0):
         self._runner = threading.Thread(target=self._run_safe, daemon=True, name=f'ga-tui-agent')
         self._runner.start()
 
+    def inject_intervene(self, text: str) -> bool:
+        """Write `text` to `<task_dir>/_intervene`.  ga.turn_end_callback
+        consumes the file at the next turn boundary and APPENDS the content
+        to next_prompt as `[MASTER] ...`, so the agent sees it as part of
+        the upcoming user message without breaking the current turn.
+
+        Returns False if the agent isn't actually mid-turn (idle) — caller
+        should fall back to put_task in that case.
+
+        Append-mode write so that if the agent's `consume_file` reads and
+        deletes the file between our existence check and write, our text
+        lands in a freshly-created file (and fires the NEXT turn) instead
+        of duplicating already-consumed content from a read-modify-write
+        TOCTOU window.  The `\\n\\n` separator only goes in when the file
+        already has content right before we open it — race-narrow but
+        idempotent because the worst case is a leading blank line."""
+        td = getattr(self.agent, 'task_dir', None)
+        if not td or not getattr(self.agent, 'is_running', False):
+            return False
+        try:
+            os.makedirs(td, exist_ok=True)
+        except Exception:
+            return False
+        fp = os.path.join(td, '_intervene')
+        try:
+            sep = ''
+            try:
+                if os.path.getsize(fp) > 0:
+                    sep = '\n\n'
+            except OSError:
+                pass   # file gone — fresh create on append, sep stays empty
+            with open(fp, 'a', encoding='utf-8') as f:
+                f.write(sep + text)
+            return True
+        except Exception:
+            return False
+
     def _run_safe(self):
         try:
             self.agent.run()
@@ -1353,16 +1482,36 @@ def drain_display_queue(self, dq: queue.Queue, timeout: float = 0.25):
 # 256 inverse (which renders muddy on Win Terminal dark themes) to truecolor.
 _TILE_U = '\x1b[48;2;55;55;55m\x1b[38;2;230;230;230m'
 _MARK = _ACCENT + '❯' + _RST             # prompt mark — the single accent
+# Shell-mode (`!` magic prefix) accents — vivid pink so it stands out from
+# the normal accent purple without clashing with the heat-counter reds.
+_SHELL_ACCENT = '\x1b[38;5;205m'         # hot pink for border / prompt mark
+_SHELL_BG = '\x1b[48;2;65;60;65m'        # 65,60,65 charcoal-magenta (per spec)
+_SHELL_MARK = _SHELL_ACCENT + '!' + _RST
+# Full-row tile for committed shell rows (echo + each output line), so the
+# pair reads as one block in scrollback, matching cc-style.  Slightly
+# warmer than _TILE_U (55,55,55) so the two row kinds are distinguishable
+# when interleaved.  Black-terminal only — light themes get the bare band.
+_TILE_SHELL = '\x1b[48;2;65;60;65m\x1b[38;2;230;230;230m'
 _BG_TOK = {str(n) for n in list(range(40, 48)) + [49] + list(range(100, 108))}
 _SGR_RE = re.compile(r'\x1b\[([0-9;]*)m')
 _CSI_ERASE_RE = re.compile(r'\x1b\[[0-9;?]*[JK]')
 _SGR_TOKEN_RE = re.compile(r'\x1b\[[0-9;]*m')
 
 
-def _tile(s: str, style: str) -> str:
-    # re-assert style after every reset so muted-markdown \x1b[0m can't punch
-    # a hole in the block; \x1b[K fills to the edge (CJK-safe full-width tile).
-    return style + s.replace(_RST, _RST + style) + '\x1b[K' + _RST
+def _tile(s: str, style: str, width: int | None = None) -> str:
+    # Re-assert style after every reset so muted-markdown \x1b[0m can't punch
+    # a hole in the block.  When `width` is provided we pad with explicit
+    # bg-active spaces — prompt-toolkit's cell renderer doesn't honour
+    # \x1b[K (erase-to-EOL) inside its own buffer, so PTK-bound scrollback
+    # would otherwise leave the row gap exposed.  Fall back to \x1b[K for
+    # legacy callers writing straight to the terminal (no PTK), where the
+    # erase command still fills correctly.
+    body = style + s.replace(_RST, _RST + style)
+    if width is None:
+        return body + '\x1b[K' + _RST
+    visible = _SGR_TOKEN_RE.sub('', s)
+    pad = max(0, width - cell_len(visible))
+    return body + ' ' * pad + _RST
 
 
 def _border(left: str, right: str, width: int, style: str = _BORDER) -> str:
@@ -1399,8 +1548,8 @@ def repl(m: re.Match) -> str:
 _PLACEHOLDER_RES = (_PASTE_PH_RE, _IMG_PH_RE, _FILE_PH_RE)
 _IMAGE_EXTS = {'.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp', '.tiff', '.tif', '.ico'}
 _TURN_MK_RE = re.compile(
-    r'\*\*LLM Running \(Turn \d+\)[^\n]*\*\*'   # native live-format marker
-    r'|^[ \t]*Turn \d+\s*\.{3,}[ \t]*$',         # plain subagent form on its own line
+    r'\*\*(?:LLM Running \()?Turn \d+\)?[^\n]*\*\*'  # native + task-mode short form
+    r'|^[ \t]*Turn \d+\s*\.{3,}[ \t]*$',             # plain subagent form on its own line
     re.M)
 _TOOL_RE = re.compile(
     r'🛠️ Tool: `([^`]+)`[^\n]*\n'                    # 1 = name
@@ -1408,7 +1557,9 @@ def repl(m: re.Match) -> str:
     r'(?:'
     r'(`{5,})[^\n]*\n(.*?)\n\4[ \t]*\n*'              # 4 = result fence (5-bt), 5 = body
     r'|'                                              # ─ OR ─
-    r'(.*?)(?=^🛠️ Tool: `|^\*\*LLM Running|^<summary>|\Z)'  # 6 = live exec trace
+    # Trail-end sentinel: either form of the `**Turn N ...**` marker, or a
+    # bare `Turn N ...` on its own line, or the next tool / summary tag.
+    r'(.*?)(?=^🛠️ Tool: `|^\*\*(?:LLM Running \()?Turn \d+|^Turn \d+ \.\.\.$|^<summary>|\Z)'  # 6 = live exec trace
     r')',
     re.DOTALL | re.MULTILINE)
 # Prompted-style tool wrappers GA models emit AS TEXT in saved logs (no
@@ -1449,6 +1600,15 @@ def _tool_status(result: str, trailing: str) -> str:
         return 'error'
     if re.match(r'^(?:Error[:\s]|Exception[:\s]|Traceback|❌|⛔)', s.lstrip(), re.I):
         return 'error'
+    # ga.do_ask_user yields a 'Waiting for your answer ...' marker BEFORE the
+    # user has actually answered (it's the "I'm blocking on input" signal).
+    # The plain s.strip() truthy check below would otherwise light the chip
+    # ✓ ok the instant that marker appears — making the user think the tool
+    # has finished while the input prompt is, in reality, still waiting.
+    # Mark it pending (· …) until something else (the answer, a real status
+    # line) lands in the result.
+    if 'Waiting for your answer' in s and '✅' not in s and '成功' not in s:
+        return '?'
     if '✅' in s or '成功' in s or s.strip():
         return 'ok'
     return '?'
@@ -1640,6 +1800,8 @@ def _cmds() -> list[tuple[str, str, str]]:
         ('/export',   _t('cmd.export.arg'),     _t('cmd.export.desc')),
         ('/stop',     '',                       _t('cmd.stop.desc')),
         ('/language', _t('cmd.language.arg'),   _t('cmd.language.desc')),
+        ('/emoji',    _t('cmd.emoji.arg'),      _t('cmd.emoji.desc')),
+        ('/resume',   '',                       _t('cmd.resume.desc')),
         ('/quit',     '',                       _t('cmd.quit.desc')),
     ]
 
@@ -1675,18 +1837,50 @@ def _gerund(el: float) -> str:
 # width, making `(>_<)` look "fat" and shoving the heat counter sideways.
 # `/emoji ascii` switches to bracketed glyphs that stay single-width on
 # every terminal.  `/emoji off` hides the pet entirely.
-_PETS_ASCII = (
-    ('[:)] ', '[:)] ', '[:)] ', '[:|] '),
-    ('[:|] ', '[;|] ', '[:|] ', '[|:] '),
-    ('[-_-]', '[-_-]', '[---]', '[-_-]'),
-    ('[>_<]', '[@_@]', '[>_<]', '[T_T]'),
+# Cat head — calm tier uses • (sleepy/cute look), `o` reserved for the
+# focused tier, `-` for the sleepy tier so each row's mood reads
+# distinctly.  Each tier's 4 frames share a width within the tier.
+_PETS_CAT = (
+    ('=^•.•^=', '=^•.•^=', '=^-.-^=', '=^•.•^='),
+    ('=^o.o^=', '=^o.-^=', '=^o.o^=', '=^-.o^='),
+    ('=^-.-^=', '=^-.-^=', '=^v.v^=', '=^-.-^='),
+    ('=^>.<^=', '=^@.@^=', '=^>.<^=', '=^T.T^='),
+)
+# Bracketed dot-eye — same mood arc; `•` for calm, `o` for focused.
+_PETS_DOT = (
+    ('[•.•]', '[•.•]', '[-.-]', '[•.•]'),
+    ('[o.o]', '[o.-]', '[o.o]', '[-.o]'),
+    ('[-.-]', '[-.-]', '[v.v]', '[-.-]'),
+    ('[>.<]', '[@.@]', '[>.<]', '[T.T]'),
 )
-_PET_STYLES = {'unicode': _PETS_UNICODE, 'ascii': _PETS_ASCII}
-_pet_style = 'unicode'   # mutated by /emoji <style>; module global (single-process TUI)
+# Bear face — restored to the classic ʕ•ᴥ•ʔ for the calm tier (user
+# preference; see screenshot 025734).  Mood escalates the same way as the
+# other styles: calm → focused → sleepy → stressed.  Bullets are kept to
+# the calm/focused tier where mixing them with `-` would jitter; tier 2
+# and 3 stay dash-/bracket-internal so the heat counter never shifts.
+_PETS_BEAR = (
+    ('ʕ•ᴥ•ʔ', 'ʕ-ᴥ-ʔ', 'ʕ•ᴥ•ʔ', 'ʕ•ᴥ-ʔ'),
+    ('ʕoᴥoʔ', 'ʕoᴥ-ʔ', 'ʕoᴥoʔ', 'ʕ-ᴥoʔ'),
+    ('ʕ-ᴥ-ʔ', 'ʕ-ᴥ-ʔ', 'ʕ~ᴥ~ʔ', 'ʕ-ᴥ-ʔ'),
+    ('ʕ>ᴥ<ʔ', 'ʕ@ᴥ@ʔ', 'ʕ>ᴥ<ʔ', 'ʕTᴥTʔ'),
+)
+_PET_STYLES = {
+    'bear':    _PETS_BEAR,
+    'cat':     _PETS_CAT,
+    'dot':     _PETS_DOT,
+    'unicode': _PETS_UNICODE,
+}
+# `off` is rendered specially (empty string) — kept out of _PET_STYLES so the
+# picker can iterate real styles, then surface the hide-pet row separately.
+_PET_HIDDEN = 'off'
+_pet_style = 'bear'   # default per user request; mutated by /emoji <style>
 
 
 def _pet(el: float, frame: int) -> str:
-    if _pet_style == 'off':
+    # `frame` ticks at the spinner rate (0.1s).  Pet emotes feel frantic if
+    # they swap every tick, so callers divide the spin counter (currently /5)
+    # to land a ~0.5s pet-frame cadence while the spinner glyph stays snappy.
+    if _pet_style == _PET_HIDDEN:
         return ''
     tier = 0 if el < 20 else 1 if el < 60 else 2 if el < 180 else 3
     pool = _PET_STYLES.get(_pet_style, _PETS_UNICODE)[tier]
@@ -1705,12 +1899,17 @@ def _pet(el: float, frame: int) -> str:
 
 
 def _set_term_title(text: str) -> None:
+    # PTK app run redirects sys.stdout to sb_agent.log (see
+    # _run_prompt_toolkit), so sys.stdout.write here would write OSC 0
+    # into the log file instead of the terminal — title silently
+    # frozen at the very first pre-PTK call.  Write straight to fd 1
+    # via os.write, same approach as _w().
     global _last_term_title
     if text == _last_term_title:
         return
     _last_term_title = text
     try:
-        sys.stdout.write('\x1b]0;' + text + '\x07'); sys.stdout.flush()
+        os.write(1, ('\x1b]0;' + text + '\x07').encode('utf-8', 'replace'))
     except OSError:
         pass   # detached stdout / non-tty — let-it-crash § 14 (best-effort)
 
@@ -2056,6 +2255,17 @@ def __init__(self) -> None:
         self._asking: AskUserEvent | None = None
         self._quit = False
         self._cc_t = 0.0                # last bare-Ctrl+C time (arm-to-quit window)
+        self._last_esc_t = 0.0          # last bare-Esc time (Esc Esc → /clear)
+        # Pending user inputs queued while the agent was busy (codex-style).
+        # Drained as ONE combined prompt 5 s after the LAST pending arrived
+        # (cooldown resets on each new queue entry).  During the cooldown
+        # the user can Esc-cancel or Up-amend.  When the timer lapses we
+        # try mid-turn injection via `_intervene` first (agent picks it up
+        # at the next turn boundary); fall back to put_task if the agent
+        # is idle.
+        self._pending: list[str] = []
+        self._pending_drain_t: float = 0.0
+        self._pending_cooldown: float = 5.0
         self._epend = b''               # held trailing ESC (split-read disambiguation)
         self._undo: list[tuple[str, int]] = []   # buffer-edit history for Ctrl+Z
         self._redo: list[tuple[str, int]] = []   # cleared on any new edit
@@ -2297,32 +2507,39 @@ def _plan_placeholder(self, w: int, ag) -> list[str]:
         return out
 
     @staticmethod
-    def _boxln(plain: str, colored: str, w: int) -> str:
+    def _boxln(plain: str, colored: str, w: int, border: str = _BORDER) -> str:
         if w < 4:
             return _clip_cells(plain, max(1, w))
         inner = max(0, w - 4)
         plain_fit = _clip_cells(plain, inner)
         colored_fit = _clip_ansi_cells(colored, inner)
         pad = max(0, inner - cell_len(plain_fit))   # cell_len → CJK-safe alignment
-        return _BORDER + '│ ' + _RST + colored_fit + ' ' * pad + _BORDER + ' │' + _RST
-
-    def _segs(self, iw: int) -> list[tuple[int, str]]:
-        """Flatten buf into visual rows: (abs char start in buf, chunk text).
-        One source of truth for both caret math and ←→↑↓ navigation."""
+        return border + '│ ' + _RST + colored_fit + ' ' * pad + border + ' │' + _RST
+
+    def _segs(self, iw: int, text: str | None = None) -> list[tuple[int, str]]:
+        """Flatten `text` (defaults to self.buf) into visual rows: (abs char
+        start, chunk text).  One source of truth for both caret math and
+        ←→↑↓ navigation.  Pass `text` explicitly when rendering a virtual
+        body (e.g. shell-mode hides the leading `!`); pair it with the
+        matching `pos` in `_seg_at`."""
+        src = self.buf if text is None else text
         segs, p = [], 0
-        for line in self.buf.split('\n'):
+        for line in src.split('\n'):
             for ch in _wrap_cells(line, iw) or ['']:
                 segs.append((p, ch)); p += len(ch)
             p += 1                              # the '\n' separator
         return segs
 
-    def _seg_at(self, segs: list[tuple[int, str]]) -> tuple[int, int]:
-        """(visual row index, char offset within its chunk) for self.pos."""
+    def _seg_at(self, segs: list[tuple[int, str]], pos: int | None = None) -> tuple[int, int]:
+        """(visual row index, char offset within its chunk) for `pos`
+        (defaults to self.pos).  Caller passes a virtual `pos` when segs
+        were built from a virtual `text`."""
+        p = self.pos if pos is None else pos
         for i, (st, ch) in enumerate(segs):
             end = st + len(ch)
             eol = i + 1 == len(segs) or segs[i + 1][0] != end   # \n gap ⇒ row ends here
-            if st <= self.pos and (self.pos < end or (self.pos == end and eol)):
-                return i, self.pos - st
+            if st <= p and (p < end or (p == end and eol)):
+                return i, p - st
         return len(segs) - 1, len(segs[-1][1])
 
     def _cur_v(self, d: int) -> None:
@@ -2365,7 +2582,8 @@ def _picker_reset(self) -> None:
 
     def _show_menu(self, title: str, options: list[str], on_submit,
                    hint: str | None = None, on_cancel=None,
-                   multi_select: bool = False) -> None:
+                   multi_select: bool = False,
+                   pre_checked: set[int] | None = None) -> None:
         """Open a modal arrow-key menu in place of the input box.
 
         The menu takes over the live region; ↑↓ move the highlight, Enter
@@ -2376,7 +2594,14 @@ def _show_menu(self, title: str, options: list[str], on_submit,
         `multi_select=True` switches to checkbox mode: Space toggles the
         highlighted row, the per-row prefix becomes `[x]/[ ]`, and Enter
         delivers a sorted `list[int]` of all checked indices (may be empty
-        if the user submits with nothing ticked)."""
+        if the user submits with nothing ticked).
+
+        `pre_checked` seeds the multi-select tick state atomically.  Callers
+        used to set `self._menu_checked` AFTER `_show_menu` returned, which
+        worked logically but left a one-frame window where PTK could render
+        the menu with the wrong state — observed as /scheduler picker
+        rendering all unchecked even though `reflect/scheduler.py` was alive.
+        Passing the set up-front makes the open atomic."""
         if not options:
             return
         self._menu_active = True
@@ -2395,7 +2620,7 @@ def _show_menu(self, title: str, options: list[str], on_submit,
         self._menu_on_submit = on_submit
         self._menu_on_cancel = on_cancel
         self._menu_multi = bool(multi_select)
-        self._menu_checked = set()
+        self._menu_checked = set(pre_checked) if pre_checked else set()
         self._render_live()
 
     def _close_menu(self) -> None:
@@ -2505,7 +2730,10 @@ def _hint_lines(self, w: int) -> list[str]:
         out: list[str] = []
         for i in range(start, end):
             n, a, d = ms[i]
-            row = f'  {n:<10}{a:<7} {d}'
+            # `<11` + literal space guarantees a visible gap between the
+            # 10-char names (/conductor, /morphling, /scheduler) and their
+            # `[arg]` placeholder — without it they render as `/conductor[task]`.
+            row = f'  {n:<11} {a:<8} {d}' if a else f'  {n:<11}          {d}'
             if i == self._palette_sel:
                 out.append(_ACCENT + _BOLD + _clip_cells(row, w) + _RST)
             else:
@@ -2564,6 +2792,16 @@ def _esc_back(self) -> None:
         if self.buf:
             self._snap()                              # let Ctrl+Z restore the draft
             self.buf = ''; self.pos = 0; self._sel = None; return
+        if self._pending:                             # cancel queued user messages
+            # Esc on an empty input drops the whole pending queue — gives
+            # the user a single-key abort if they no-longer want what they
+            # typed during the run.  Echoed as a system line so the
+            # disappearance of the preview block isn't silent.
+            n = len(self._pending)
+            self._pending = []
+            self._pending_drain_t = 0.0
+            self.commit([_DIM + _t('pending.cleared', n=n) + _RST])
+            return
         if self._running and self._bridge:
             self._bridge.abort()
             self.commit([_DIM + _t('msg.abort_requested') + _RST]); return
@@ -2799,44 +3037,196 @@ def row(text: str, style: str = '') -> list[str]:
             out = [' ' * indent + ln for ln in out]
         return out
 
+    def _pending_card(self, w: int) -> list[str]:
+        """Compact preview of user inputs queued while the agent was busy.
+        Renders as a dim accent strip above the input box, no border —
+        keeps the visual weight light because the messages already echoed
+        as `[queued] ...` lines into scrollback when they were submitted.
+
+        Header tells the user what's happening (busy / cooling-down) and
+        the bindings (Up amends last entry, Esc clears the lot)."""
+        if not self._pending:
+            return []
+        n = len(self._pending)
+        cd = max(0.0, self._pending_drain_t - time.time())
+        if self._running:
+            head = _t('pending.head_running', n=n)
+        elif cd > 0:
+            head = _t('pending.head_cooldown', n=n, sec=cd)
+        else:
+            head = _t('pending.head_running', n=n)
+        rows = [_ACCENT + _BOLD + _clip_cells('  ↑ ' + head, w) + _RST]
+        # Inline preview — capped at three entries so the strip never eats
+        # more rows than the input box itself.
+        body_w = max(20, w - 8)
+        for i, msg in enumerate(self._pending[-3:], 1):
+            preview = msg.replace('\n', ' ').strip()
+            if cell_len(preview) > body_w:
+                preview = _clip_cells(preview, body_w - 1) + '…'
+            rows.append(_DIM + _clip_cells(f'    {i}. {preview}', w) + _RST)
+        if n > 3:
+            rows.append(_DIM + _clip_cells(f'    … +{n - 3} more', w) + _RST)
+        rows.append('')
+        return rows
+
+    def _run_shell(self, cmd: str) -> None:
+        """Execute `cmd` in the host shell and echo command + output into
+        scrollback as the `! cmd` / `└ output` pair seen in screenshot
+        034257.  Both halves get appended to the agent's LLM history
+        (single user-role entry with a `[!shell]` tag) so a follow-up
+        question like "what did I just run?" finds the context.
+
+        Output capture is utf-8 / replace so binary spew never crashes
+        the decoder.  30 s timeout — anything longer wants `/conductor`
+        territory, not a magic prompt."""
+        if not cmd:
+            return
+        w = _term()[0]
+        # Echo the command line as a full-width charcoal tile (cc-style):
+        # pink `!` prompt embedded; `_tile` re-asserts the bg around every
+        # internal _RST so the pink fg coexists with the band.
+        head = _SHELL_ACCENT + '! ' + _RST + cmd
+        self.commit([_tile(' ' + head, _TILE_SHELL, w)])
+        import subprocess
+        out = ''
+        rc = 0
+        try:
+            r = subprocess.run(
+                cmd, shell=True, capture_output=True,
+                timeout=30, encoding='utf-8', errors='replace',
+            )
+            out = (r.stdout or '') + (r.stderr or '')
+            rc = r.returncode
+        except subprocess.TimeoutExpired:
+            out = _t('shell.timeout', sec=30); rc = -1
+        except Exception as e:
+            out = _t('shell.error', err=f'{type(e).__name__}: {e}'); rc = -1
+        body = (out.rstrip('\n') or _t('shell.empty')).split('\n')
+        rows: list[str] = []
+        for i, ln in enumerate(body):
+            # Output rows stay on bare terminal bg — only the `! cmd` echo
+            # carries the charcoal band so the eye reads it as "this is
+            # the command, that's its output" (cc-style).  `└ ` only on
+            # the first line so multi-line output reads as a continuation.
+            prefix = _DIM + '  └ ' + _RST if i == 0 else _DIM + '    ' + _RST
+            rows.append(prefix + ln)
+        rows.append('')   # blank gap separates the shell pair from the next chat block
+        self.commit(rows)
+        # Persist the exchange so the agent sees it on its next turn.
+        # Splitting on `is_running` avoids racing the agent thread:
+        #   running → use the `_intervene` file hook (safe because the
+        #             agent only reads it at turn boundaries, never
+        #             while iterating `backend.history`).
+        #   idle    → direct append to backend.history is safe — there's
+        #             no concurrent reader.
+        try:
+            txt = _t('shell.history', cmd=cmd, out=out.rstrip(), rc=rc)
+            if (self._bridge is not None
+                    and getattr(self._bridge.agent, 'is_running', False)):
+                self._bridge.inject_intervene(txt)
+            else:
+                be = getattr(self._bridge.agent, 'llmclient', None) if self._bridge else None
+                be = getattr(be, 'backend', None) if be is not None else None
+                if be is not None and hasattr(be, 'history'):
+                    be.history.append({"role": "user",
+                                       "content": [{"type": "text", "text": txt}]})
+        except Exception:
+            pass
+
+    def _drain_pending(self) -> None:
+        """Flush queued user messages.  Two paths:
+
+        - Agent still mid-turn → write to `<task_dir>/_intervene`.  GA's
+          `turn_end_callback` (ga.py:576) consumes the file at the next
+          turn boundary and prepends `[MASTER] …` to the upcoming user
+          prompt, which means the new message lands inside the SAME run
+          (no new task started) — exactly what the user asked for.
+        - Agent idle → no intervene hook available; submit as a fresh task
+          so it just becomes the next turn.
+
+        Combined into one payload (not per-message) because users queue
+        clarifying lines for one logical follow-up; N separate turns would
+        force the agent into pointless handoffs.  Caller must hold
+        `self._lk`."""
+        if not self._pending or not self._bridge:
+            return
+        combined = '\n\n'.join(self._pending)
+        self._pending = []
+        self._pending_drain_t = 0.0
+        # Mid-turn injection first; falls back to a new task if the agent
+        # is no longer running (e.g., turn ended between arming the timer
+        # and the timer firing).
+        if not self._bridge.inject_intervene(combined):
+            self._submit(combined, [])
+
     def _input_box(self, w: int) -> list[str]:
         """A full-width bordered, padded input box (cc-style). Lives in the
         redraw region only — border glyphs never reach scrollback/copy. The
         caret (row/col) is derived from self.pos so ←→↑↓ edit in place. In
         ask-mode the answer is typed INSIDE the question card itself (one
         unified component) — short-circuit to _ask_card.  When a modal
-        menu (e.g. /llm picker) is active, _menu_card replaces the input box."""
+        menu (e.g. /llm picker) is active, _menu_card replaces the input box.
+
+        Shell mode: when the buffer starts with `!`, that `!` IS the
+        prompt mark — pink, same column as `❯`, followed by one space and
+        then the body.  The leading `!` is stripped from the rendered body
+        so it shows once (the duplicate-`!` bug fixed in screenshot
+        040031).  Selection / cursor math uses a virtual buf=buf[1:],
+        pos=max(0, pos-1) so ←→ navigation still tracks the user's
+        intuition (caret never goes before the prompt)."""
         if self._menu_active:
             return self._menu_card(w)
         if self._asking is not None:
             return self._ask_card(w)
+        shell_mode = self.buf.startswith('!')
+        if shell_mode:
+            border = _SHELL_ACCENT
+            accent = _SHELL_ACCENT
+            mark = '!'
+            body = self.buf[1:]
+            body_pos = max(0, self.pos - 1)
+        else:
+            border = _BORDER
+            accent = _ACCENT
+            mark = '❯'
+            body = self.buf
+            body_pos = self.pos
         if w < 8:
             iw = max(1, w - 2)
-            segs = self._segs(iw)
-            ci, coff = self._seg_at(segs)
+            segs = self._segs(iw, body)
+            ci, coff = self._seg_at(segs, body_pos)
             rows = []
             for i, (_st, ch) in enumerate(segs):
-                pre = '❯ ' if i == 0 and w >= 3 else '❯' if i == 0 else ''
+                pre = f'{mark} ' if i == 0 and w >= 3 else mark if i == 0 else ''
                 rows.append(_clip_cells(pre + ch, w))
-            ccol = min(max(1, w), cell_len(('❯ ' if ci == 0 and w >= 3 else '❯' if ci == 0 else '') + segs[ci][1][:coff]) + 1)
+            ccol = min(max(1, w), cell_len((f'{mark} ' if ci == 0 and w >= 3 else mark if ci == 0 else '') + segs[ci][1][:coff]) + 1)
             return rows or [''], ci, ccol
-        top = _border('╭', '╮', w)
-        bot = _border('╰', '╯', w)
-        segs = self._segs(max(1, w - 6))
-        ci, coff = self._seg_at(segs)
-        sel = self._sel_range()
+        top = _border('╭', '╮', w, border)
+        bot = _border('╰', '╯', w, border)
+        segs = self._segs(max(1, w - 6), body)
+        ci, coff = self._seg_at(segs, body_pos)
+        # Selection range is computed against the original buf; offset by
+        # 1 for shell mode so the highlight aligns with the displayed
+        # body slice rather than the underlying buf indices.
+        sel_raw = self._sel_range()
+        sel = None
+        if sel_raw is not None:
+            shift = 1 if shell_mode else 0
+            lo, hi = max(0, sel_raw[0] - shift), max(0, sel_raw[1] - shift)
+            if lo < hi:
+                sel = (lo, hi)
         rows = []
         for i, (st, ch) in enumerate(segs):
             first = i == 0
-            pre_p = '❯ ' if first else '  '
-            pre_c = (_ACCENT + '❯' + _RST + ' ') if first else '  '
+            pre_p = f'{mark} ' if first else '  '
+            pre_c = (accent + mark + _RST + ' ') if first else '  '
             disp = ch
             if sel:                              # reverse-video the selected slice
                 lo = max(sel[0] - st, 0); hi = min(sel[1] - st, len(ch))
                 if lo < hi:
                     disp = ch[:lo] + '\x1b[7m' + ch[lo:hi] + '\x1b[27m' + ch[hi:]
-            rows.append(self._boxln(pre_p + ch, pre_c + disp, w))
-        pre = '❯ ' if ci == 0 else '  '
+            rows.append(self._boxln(pre_p + ch, pre_c + disp, w, border))
+        pre = f'{mark} ' if ci == 0 else '  '
         crow, ccol = ci, cell_len(pre + segs[ci][1][:coff]) + 3
         box = [top] + rows + [bot]
         caret_row = crow + 1                      # +1 for the top border row
@@ -2854,7 +3244,9 @@ def _live_lines(self) -> list[str]:
         after: list[str] = []
         if self._running and self._asking is None:
             el = time.time() - self._t0_anchor
-            after.append(' ' + _heat(el) + _pet(el, self._spin) + _RST +
+            # `_spin // 5` slows the pet-frame swap to ~0.5s (the spinner
+            # glyph itself still cycles at 0.1s for the snappy "alive" feel).
+            after.append(' ' + _heat(el) + _pet(el, self._spin // 5) + _RST +
                          '  ' + _DIM + _gerund(el) + '…' + _RST)
         # Plan card sits above the btw card — it's longer-lived context and
         # belongs further from the input area than transient side-questions.
@@ -2867,6 +3259,12 @@ def _live_lines(self) -> list[str]:
         # modal menu owns the live region).
         if self._btws and not self._menu_active:
             after += self._btw_card(w)
+        # Pending-input preview sits just above the input box too — appears
+        # whenever there's a queued message (during run OR during the
+        # short post-turn cooldown).  Hidden when a modal menu is active
+        # so the picker keeps the whole live region for itself.
+        if self._pending and not self._menu_active:
+            after += self._pending_card(w)
         box_start = len(after)
         box, caret_row, caret_col = self._input_box(w)
         after += box
@@ -2880,6 +3278,10 @@ def _live_lines(self) -> list[str]:
                 # prompt so it stands out (v2 parity).  Uses the input box's
                 # accent color so the prompt reads as part of that component.
                 after.append(_BOLD + _ACCENT + _clip_cells('  ' + _t('status.cc_confirm'), w) + _RST)
+            elif self.buf.startswith('!') and self._asking is None and not self._menu_active:
+                # Shell-mode hint replaces the status line — same hot pink
+                # so the user reads input box + hint as one component.
+                after.append(_BOLD + _SHELL_ACCENT + _clip_cells('  ' + _t('shell.hint'), w) + _RST)
             elif self._running and self._asking is None:
                 lead = _heat(time.time() - self._t0_anchor) + _SPIN[self._spin % len(_SPIN)] + ' ' + _RST
                 after.append(lead + _DIM + _clip_cells(self._status_line(w), max(2, w - 2)) + _RST)
@@ -3176,7 +3578,7 @@ def _render_block(self, b: Block, w: int) -> list[str]:
         if b.kind == 'user':
             parts = b.source.split('\n')
             raw = [_MARK + ' ' + parts[0]] + [CONT + p for p in parts[1:]]
-            lines = [_tile(' ' + x, _TILE_U) for x in raw]
+            lines = [_tile(' ' + x, _TILE_U, w) for x in raw]
             lines.append('')
             return lines
         if b.kind == 'assistant':
@@ -3536,6 +3938,13 @@ def _on_enter(self) -> None:
             self.hist = self.hist[-250:]
         if not self.hist or self.hist[-1] != raw:   # v2: skip consecutive dupes
             self.hist.append(raw)
+        if raw.startswith('!'):
+            # Shell-mode magic: run the rest as a host shell command, echo
+            # the command + output into scrollback, and append the pair to
+            # the agent's LLM history so the next real turn can reference
+            # it (per screenshot 034257 — agent recalls `echo hi`).
+            self._run_shell(raw[1:].strip())
+            return
         if raw.startswith('/'):
             # /btw owns its own live-region panel — keep the command itself
             # out of the main scrollback.
@@ -3543,13 +3952,25 @@ def _on_enter(self) -> None:
             if cmd0 != 'btw':
                 self._commit_user(raw)
             self._cmd(raw); return
-        if self._running:
-            return
-        # Collect images whose `[Image #N]` placeholder is still in the draft,
-        # in placeholder order — a block-deleted placeholder drops its image.
+        # Expand placeholders FIRST so the agent receives the resolved text,
+        # not the [Image #N] / [Pasted #N] markers.  This matches the idle
+        # submit path below — keeping the form identical means a queued
+        # message and an immediate one feed the LLM the same bytes.
         imgs = [self._imgs[i] for i in
                 (int(m.group(1)) for m in _IMG_PH_RE.finditer(raw)) if i in self._imgs]
-        expanded = self._expand(raw)               # expand paste/file refs FIRST so
+        expanded = self._expand(raw)
+        if self._running:
+            # Queue rather than reject — frees the user from /stop just to
+            # tack on a follow-up.  The pending preview block above the
+            # input shows what's waiting; Up amends the last entry, Esc
+            # clears.  Each new entry resets the 5 s cooldown so a burst
+            # of quick edits coalesces into one inject.
+            self._pending.append(expanded)
+            self._pending_drain_t = time.time() + self._pending_cooldown
+            self._commit_user(_t('pending.queued_marker', text=expanded))
+            self._pstore.clear(); self._fstore.clear(); self._imgs.clear()
+            self._render_live()
+            return
         self._commit_user(expanded)                # scrollback shows exactly what
         self._submit(expanded, imgs)               # the agent receives, not the
         self._pstore.clear(); self._fstore.clear(); self._imgs.clear()   # drop placeholders
@@ -3789,6 +4210,11 @@ def _pick_rewind(idx: int) -> None:
                     self.commit(Block('assistant', text))   # markdown re-renders on resize
                 except queue.Empty:
                     self.commit([_t('msg.review_empty')])
+        elif name == 'resume':
+            # GA's _handle_slash_cmd (agentmain.py:124) replaces `/resume`
+            # with a session-recovery prompt before the LLM sees it.  We
+            # just forward the literal string — the agent expands it.
+            self._submit('/resume', [])
         elif name in ('update', 'autorun', 'morphling', 'goal', 'hive', 'conductor'):
             # slash_cmds bundle — build a long prompt and feed it back through
             # _submit so the agent sees an ordinary user turn.  Keeps the
@@ -3833,9 +4259,16 @@ def _pick_rewind(idx: int) -> None:
                                 if s['name'] in running}
                 options = []
                 for s in ordered:
+                    is_running = s['name'] in running
                     doc = f"  — {s['doc']}" if s['doc'] else ''
-                    tag = _t('scheduler.running_tag') if s['name'] in running else ''
-                    options.append(f"{s['name']}{tag}{doc}")
+                    tag = _t('scheduler.running_tag') if is_running else ''
+                    label = f"{s['name']}{tag}{doc}"
+                    if is_running:
+                        # Functional green so already-running rows pop out
+                        # of the picker grid even without the checkbox tick;
+                        # cell_len ignores ANSI so column math stays sane.
+                        label = _OK + label + _RST
+                    options.append(label)
 
                 # Two-step ask_user-style flow:
                 #   picker (pre-checked = running) → diff vs running
@@ -3898,18 +4331,27 @@ def _confirm_cancel() -> None:
                             multi_select=False,
                         )
 
+                    hint_text = _t('scheduler.pick.hint')
+                    try:
+                        cron_n = len(slash_cmds.list_scheduler_tasks())
+                    except Exception:
+                        cron_n = 0
+                    if cron_n:
+                        sch_running = 'reflect/scheduler.py' in running
+                        key = 'scheduler.cron.active' if sch_running else 'scheduler.cron.inactive'
+                        hint_text += '\n' + _t(key, n=cron_n)
+                    # Pre-check the running set (first open) or the in-progress
+                    # selection (re-open via "Edit selection" / Esc) — passed
+                    # to _show_menu so it lands atomically with the rest of
+                    # the menu state, not as a post-open override.
                     self._show_menu(
                         _t('scheduler.pick.title'),
                         options,
                         _pick_services,
-                        hint=_t('scheduler.pick.hint'),
+                        hint=hint_text,
                         multi_select=True,
+                        pre_checked=initial if initial else None,
                     )
-                    # Pre-check the running set (first open) or the in-progress
-                    # selection (re-open via "Edit selection" / Esc).
-                    if initial:
-                        self._menu_checked = set(initial)
-                        self._render_live()
 
                 _open_picker()
         elif name == 'llm':
@@ -4029,6 +4471,7 @@ def _prefill_file() -> None:
                          _t('help.btw'),
                          _t('help.review'),
                          _t('help.rewind'),
+                         _t('help.resume'),
                          _t('help.continue'),
                          _t('help.new'),
                          _t('help.rename'),
@@ -4038,6 +4481,14 @@ def _prefill_file() -> None:
                          _t('help.export'),
                          _t('help.stop'),
                          _t('help.language'),
+                         _t('help.emoji'),
+                         _t('help.update'),
+                         _t('help.autorun'),
+                         _t('help.morphling'),
+                         _t('help.goal'),
+                         _t('help.hive'),
+                         _t('help.conductor'),
+                         _t('help.scheduler'),
                          _t('help.quit'),
                          _t('help.esc'),
                          _t('help.cc'),
@@ -4064,23 +4515,53 @@ def _btw(self, entry: list) -> None:
             self._render_live()
 
     def _cmd_emoji(self, arg: str) -> None:
-        """`/emoji [unicode|ascii|off]` — switch the running-spinner pet face.
-
-        Win consoles render some CJK punctuation as double-width, making
-        glyphs like `(>_<)` look "fat" and shoving the heat counter
-        sideways.  `/emoji ascii` swaps in bracketed faces that stay
-        single-width everywhere; `/emoji off` hides the pet entirely.
-        Bare `/emoji` reports the current style and the valid choices.
+        """`/emoji` opens an arrow-key picker (parity with /llm); `/emoji
+        <style>` switches directly.  Styles are sourced from `_PET_STYLES`
+        so adding a new face dict automatically surfaces a new row.  `off`
+        is rendered as a separate trailing row that hides the pet entirely.
         """
         global _pet_style
         choice = (arg or '').strip().lower()
-        valid = ('unicode', 'ascii', 'off')
-        if choice not in valid:
-            self.commit([f'{_DIM}emoji style is `{_pet_style}` · '
-                         f'available: {", ".join(valid)}{_RST}'])
+        valid_keys = list(_PET_STYLES.keys()) + [_PET_HIDDEN]
+        if choice:
+            if choice not in valid_keys:
+                self.commit([f'{_DIM}'
+                             + _t('emoji.unknown', choice=choice,
+                                  valid=', '.join(valid_keys))
+                             + _RST])
+                return
+            _pet_style = choice
+            self.commit([f'{_DIM}' + _t('emoji.switched', style=choice) + _RST])
             return
-        _pet_style = choice
-        self.commit([f'{_DIM}emoji style → `{choice}`{_RST}'])
+        # No arg → /llm-style picker.  Sample = the first frame of tier 0
+        # so each row shows what the calm face looks like.
+        keys = list(_PET_STYLES.keys())
+        options: list[str] = []
+        current_idx = 0
+        for i, k in enumerate(keys):
+            sample = _PET_STYLES[k][0][0]
+            if k == _pet_style:
+                current_idx = i
+                options.append(_t('emoji.row.current', name=k, sample=sample))
+            else:
+                options.append(_t('emoji.row.other', name=k, sample=sample))
+        # Trailing "off" row hides the pet — appended last so the regular
+        # face styles cluster at the top of the menu.
+        off_label = (_t('emoji.row.current', name=_PET_HIDDEN, sample=_t('emoji.row.off'))
+                     if _pet_style == _PET_HIDDEN
+                     else _t('emoji.row.other', name=_PET_HIDDEN, sample=_t('emoji.row.off')))
+        options.append(off_label)
+        if _pet_style == _PET_HIDDEN:
+            current_idx = len(keys)
+        picks = keys + [_PET_HIDDEN]
+
+        def _pick(idx: int) -> None:
+            global _pet_style
+            _pet_style = picks[idx]
+            self.commit([f'{_DIM}' + _t('emoji.switched', style=picks[idx]) + _RST])
+
+        self._show_menu(_t('emoji.title'), options, _pick)
+        self._menu_sel = current_idx
 
     def _cmd_language(self, arg: str) -> None:
         """`/language` — arrow-key picker (like /llm); `/language <code>` — direct switch."""
@@ -4245,11 +4726,12 @@ def _ticker(self) -> None:
 
     def _term_title(self) -> str:
         """Compose terminal-window title — `⠇ <session> · GenericAgent`.
-        Spinner glyph appears only while an agent run is in flight."""
-        name = (self._session_name or '').strip()
+        Spinner glyph appears only while an agent run is in flight; an
+        unnamed session falls back to literal 'session' so the title
+        always carries the session segment (parity with tuiapp_v2)."""
+        name = (self._session_name or '').strip() or 'session'
         head = (_SPIN[self._spin % len(_SPIN)] + ' ') if self._running else ''
-        mid = (name + ' · ') if name else ''
-        return head + mid + 'GenericAgent'
+        return f'{head}{name} · GenericAgent'
 
     def _poll_ask(self, grace: float = 0.0) -> AskUserEvent | None:
         """Only pull a queued ask when none is currently being shown.
@@ -4285,11 +4767,18 @@ def _drain(self, dq) -> None:
                 # to the stream *just before* it pushes the AskUserEvent onto
                 # ask_user_queue.  When the agent then short-circuits with
                 # should_exit=True a DoneEvent can land here before the
-                # AskUserEvent.put() returns — so we wait generously when the
-                # marker is in the stream.  Plain replies keep the snappy
-                # 0.4s grace so cleanup stays tight.
-                grace = 2.0 if 'Waiting for your answer' in self._stream else 0.4
-                ae = self._poll_ask(grace=grace)  # ask hook may land around turn end
+                # AskUserEvent.put() returns.  The previous 2s grace was the
+                # right idea but too short under load (long sessions backed
+                # up the put), so the ae would be missed and the question
+                # silently dropped into scrollback — observed as 'input box
+                # never re-appears'.  When the marker is present, treat the
+                # ae as REQUIRED and wait longer; the hook is synchronous
+                # with agent thread exit so 10s is comfortably above the
+                # real arrival time.  Plain replies keep the snappy 0.4s.
+                if 'Waiting for your answer' in self._stream:
+                    ae = self._poll_ask(grace=10.0)
+                else:
+                    ae = self._poll_ask(grace=0.4)
                 with self._lk:
                     self._enter_ask(ae) if ae else self._finalize(ev.text)
                 break
@@ -4302,6 +4791,15 @@ def _drain(self, dq) -> None:
                 elif isinstance(ev, (SystemEvent, ErrorEvent)):
                     self._finalize(getattr(ev, 'text', None) or getattr(ev, 'message', '')); break
         self._running = False
+        # Note: pending-drain timer is armed on each user submit (resets
+        # every time they add another), not on turn end — that matches
+        # the "5 s cooldown since LAST keystroke" intent.  Maintenance
+        # loop fires _drain_pending when the deadline lapses regardless
+        # of running state.
+        # _ticker stops as soon as _running goes False so the title would
+        # freeze on the last spinner frame.  Repaint it now to drop the
+        # glyph and reveal a clean idle title.
+        _set_term_title(self._term_title())
         with self._lk:
             self._flow(final=True) if self._stream else self._render_live()
 
@@ -4387,9 +4885,13 @@ def _safe_pos(self, stream: str) -> int:
         (no closing tag). Falls back to last `\\n\\n` paragraph boundary."""
         unsafe = []
         for m in re.finditer(r'🛠️ Tool:', stream):
-            if not re.search(r'(?:^|\n)(?:\*\*LLM Running|🛠️ Tool:)', stream[m.end():]):
+            # Closing sentinel for an in-flight tool block: next tool, next
+            # turn marker (either form), or next assistant frame.  Matches
+            # both `**LLM Running (Turn N) ...**` and the task-mode short
+            # `**Turn N ...**` so task_dir-enabled runs aren't mis-classified.
+            if not re.search(r'(?:^|\n)(?:\*\*(?:LLM Running \()?Turn \d+|🛠️ Tool:)', stream[m.end():]):
                 unsafe.append(m.start())
-        for m in re.finditer(r'\*\*LLM Running', stream):
+        for m in re.finditer(r'\*\*(?:LLM Running \()?Turn \d+', stream):
             if '**' not in stream[m.end():]:
                 unsafe.append(m.start())
         for tag in ('summary', 'thinking'):
@@ -4582,6 +5084,12 @@ def _keys(self, data: bytes) -> None:
                     self._menu_submit(); continue
                 if o == 0x1b:                                # Esc
                     self._menu_cancel(); continue
+                if o == 0x02:                                # ← cancel (directional Esc)
+                    # The /scheduler confirm card spawns a menu with an
+                    # on_cancel that re-opens the picker — ← gives users
+                    # a one-handed rollback without reaching for Esc.
+                    # Menus with no on_cancel just dismiss.
+                    self._menu_cancel(); continue
                 # swallow everything else while the menu is up
                 continue
             # ── ask_user picker key intercept ───────────────────────────────
@@ -4638,6 +5146,16 @@ def _keys(self, data: bytes) -> None:
             elif o == 0x10:                       # ↑ visual-row up (history at top)
                 if self._palette_visible():
                     self._palette_sel = max(0, self._palette_sel - 1)
+                elif self._pending and not self.buf:
+                    # Empty input + pending → pop the most-recent queued
+                    # message back into the composer for amendment.  Re-
+                    # submitting it appends at the tail again; Esc clears
+                    # the whole queue.  Order preserved (LIFO recall).
+                    self.buf = self._pending.pop()
+                    self.pos = len(self.buf)
+                    if not self._pending:
+                        self._pending_drain_t = 0.0
+                    self._render_live()
                 else:
                     self._sel = None; self._cur_v(-1)
             elif o == 0x13:                       # Ctrl+S stash/restore draft
@@ -4671,7 +5189,7 @@ def _keys(self, data: bytes) -> None:
                 r = self._sel_range()
                 if r:
                     clip.copy(self.buf[r[0]:r[1]]); self._kill_sel()
-            elif o == 0x1b:                       # Esc — universal back
+            elif o == 0x1b:                       # Esc — universal back (Esc Esc handled in _handle_key)
                 self._esc_back()
             elif o == 0x09:                       # Tab — slash-command completion
                 self._tab()
@@ -4823,10 +5341,23 @@ def _handle_key(event) -> None:
                 # b'\x1b' here is unambiguously Esc.  Handle it directly instead
                 # of routing through _keys, whose raw-terminal escape-delay
                 # hold (~30ms) would otherwise lag every menu/ask cancel.
+                #
+                # Esc Esc within 800 ms → /rewind (user-requested binding).
+                # The first Esc still runs _esc_back (cancel ask / clear
+                # draft / abort task), so this only fires when the user
+                # presses twice quickly — never surprises a single press.
                 if data == b'\x1b':
-                    with self._lk:
-                        self._esc_back()
-                        self._render_live()
+                    now = time.time()
+                    if now - self._last_esc_t < 0.8:
+                        self._last_esc_t = 0.0
+                        with self._lk:
+                            self._cmd('/rewind')
+                            self._render_live()
+                    else:
+                        self._last_esc_t = now
+                        with self._lk:
+                            self._esc_back()
+                            self._render_live()
                     event.app.invalidate()
                     continue
                 if data and not self._feed(data):
@@ -4888,6 +5419,18 @@ async def _maintenance_loop() -> None:
                     # restores itself once the 1s window lapses (the extra
                     # 0.1s margin guarantees one render past expiry).
                     dirty = True
+                if (self._pending and self._pending_drain_t > 0
+                        and self._asking is None):
+                    # Cooldown countdown — repaint so the "{sec:.1f}s" tick
+                    # is visible.  When the deadline lapses, drain:
+                    # if the agent is still mid-turn, _drain_pending writes
+                    # to _intervene and ga.turn_end_callback picks it up
+                    # at the next boundary; if idle, drain submits as a
+                    # new task.
+                    if time.time() >= self._pending_drain_t:
+                        with self._lk:
+                            self._drain_pending()
+                    dirty = True
                 if self._epend or (self._rb and not self._bp):
                     with self._lk:
                         self._flush_esc()
diff --git a/frontends/tuiapp_v2.py b/frontends/tuiapp_v2.py
index 515c368c..47892b17 100644
--- a/frontends/tuiapp_v2.py
+++ b/frontends/tuiapp_v2.py
@@ -21,6 +21,10 @@
 import tempfile
 import threading
 import time
+
+# Local: cross-platform shortcut-label formatter (Win/Linux "Ctrl+B" vs mac "⌃B").
+# Imported early because _TIPS at module load time uses fmt_key().
+from keysym import fmt_key, fmt_keys  # noqa: E402
 from dataclasses import dataclass, field
 from itertools import count
 from typing import Any, Callable, Optional
@@ -55,6 +59,7 @@ def _ensure_tui_deps() -> None:
     from textual.containers import Horizontal, Vertical, VerticalScroll
     from textual.message import Message
     from textual.screen import ModalScreen
+    from textual.widget import Widget
     from textual.widgets import Input, OptionList, SelectionList, Static, TextArea
     from textual.widgets.option_list import Option
     from textual.widgets.selection_list import Selection
@@ -96,10 +101,13 @@ def _hint_terminal_capabilities() -> None:
 # (e.g. mapping narrow rendered output to source positions for selection).
 _ANSI_SGR_RE = re.compile(r"\x1b\[[0-9;]*m")
 
-# Strip the leading `**LLM Running (Turn N) ...**` marker that agent_loop yields per turn.
+# Strip the leading turn marker that agent_loop yields per turn — covers
+# both the default `**LLM Running (Turn N) ...**` and the task-mode short
+# `**Turn N ...**` (agent_loop.py:52 switches when handler.parent.task_dir
+# is set; v2 now sets task_dir for the _intervene injection hook).
 # fold_turns still needs the marker in source content to split turns, so we only strip at
 # render time. Applies to the live (last) text segment, since folded turns don't include it.
-_TURN_MARKER_RE = re.compile(r"^\s*\**LLM Running \(Turn \d+\) \.\.\.\**\s*", re.MULTILINE)
+_TURN_MARKER_RE = re.compile(r"^\s*\**(?:LLM Running \()?Turn \d+\)?[^\n]*\**\s*", re.MULTILINE)
 
 # Commonmark task-list patterns: `- [ ] foo` / `* [x] foo` / `+ [X] foo`.
 # Group 1 keeps the bullet + leading space so we can substitute the [ ] / [x]
@@ -134,10 +142,10 @@ def _hint_terminal_capabilities() -> None:
     "Tip: /cost 查看 token 用量；/cost all 列出所有会话的累计。",
     "Tip: /continue 列出最近 20 个历史会话，按 Enter 进入。",
     "Tip: /btw <问题> 让 side-agent 回答而不打断主任务。",
-    "Tip: Ctrl+B 折叠侧栏；Ctrl+O 切换长输出折叠；Ctrl+/ 查看快捷键。",
-    "Tip: Ctrl+N 新建会话；Ctrl+↑/↓ 在多个会话间切换。",
+    f"Tip: {fmt_key('ctrl+b')} 折叠侧栏；{fmt_key('ctrl+o')} 切换长输出折叠；{fmt_key('ctrl+/')} 查看快捷键。",
+    f"Tip: {fmt_key('ctrl+n')} 新建会话；{fmt_keys('ctrl+up','ctrl+down')} 在多个会话间切换。",
     "Tip: 粘贴图片 / 文件后会自动折叠成 [Image #N] / [File #N] 占位符。",
-    "Tip: 多行输入用 Ctrl+J 换行；Enter 直接发送。",
+    f"Tip: 多行输入用 {fmt_key('ctrl+j')} 换行；Enter 直接发送。",
     "Tip: /rewind <n> 回退最近 n 轮对话；/stop 中止当前任务。",
     "Tip: /export clip 把上一条回复复制到剪贴板；/export all 给出完整日志路径。",
     "Tip: /branch [name] 从当前历史分裂出新会话，互不污染。",
@@ -150,7 +158,7 @@ def _hint_terminal_capabilities() -> None:
     "Tip: /conductor <任务> 直接交给 frontends/conductor.py 做多 subagent 编排。",
     "Tip: /update 是双分支 upstream 同步 —— 先 diff 预演，再分别快进。",
     "Tip: /scheduler 里再点一下已勾选的任务可以 stop —— 取消勾选 = 停止。",
-    "Tip: Ctrl+S 把当前输入 stash 起来，下次 / 打开 picker 时还在。",
+    f"Tip: {fmt_key('ctrl+s')} 把当前输入 stash 起来，下次 / 打开 picker 时还在。",
 )
 
 
@@ -253,7 +261,7 @@ def stash(m):
     # Line-anchored so backticks embedded in tool output (e.g. `N|\`\`\`\``
     # gutter from file_read) don't pair with later real fences.
     safe = re.sub(r"^`{4,}.*?^`{4,}\n?", stash, text, flags=re.DOTALL | re.MULTILINE)
-    parts = re.split(r"(\**LLM Running \(Turn \d+\) \.\.\.\**)", safe)
+    parts = re.split(r"(\**(?:LLM Running \()?Turn \d+\)? \.\.\.\**)", safe)
     parts = [re.sub(r"\x00PH(\d+)\x00", lambda m: placeholders[int(m.group(1))], p) for p in parts]
     if len(parts) < 4:
         return [{"type": "text", "content": text}]
@@ -1182,6 +1190,12 @@ class AgentSession:
     # Boundary between restored history (≤ idx) and this run (> idx);
     # `/continue` bumps to `len(messages)` so old plan cards don't resurrect.
     plan_scan_baseline: int = 0
+    # Pending user inputs queued while this session was running (codex-style).
+    # Drained 300 ms after the current turn ends (`_pending_cooldown`).  The
+    # cooldown gives the user a chance to Esc-cancel or amend the most recent
+    # entry via the Up arrow (popped back into the input box).
+    pending: list[str] = field(default_factory=list)
+    pending_drain_at: float = 0.0   # epoch deadline; 0 = no drain pending
 
 
 def default_agent_factory() -> Any:
@@ -1215,8 +1229,9 @@ def default_agent_factory() -> Any:
     ("/goal",      "[goal]",           "进入 Goal 模式（需 condition 约束）"),
     ("/hive",      "[target]",         "进入 Hive 多 worker 协作模式"),
     ("/conductor", "[task]",           "调用 frontends/conductor.py 多 subagent 编排"),
-    ("/scheduler", "",                 "多选启动 reflect 任务 / 查看 cron"),
+    ("/scheduler", "",                 "多选启动/停止 reflect 任务（cron 由 reflect/scheduler.py 驱动）"),
     ("/continue", "[n|name]",         "列出 / 恢复历史会话"),
+    ("/resume",   "",                 "列出最近会话并恢复其中一个"),
     ("/cost",     "[all]",            "显示当前会话 token 用量（all = 所有会话）"),
     ("/export",   "clip|<file>|all",  "导出最后回复"),
     ("/restore",  "",                 "恢复上次模型响应日志"),
@@ -1238,6 +1253,12 @@ def default_agent_factory() -> Any:
 class ChoiceList(OptionList):
     BINDINGS = [*OptionList.BINDINGS,
                 Binding("right", "select", "Select", show=False),
+                # `left` mirrors Esc — pickers spawned with an on_cancel
+                # (e.g. /scheduler's submit-confirm card → rollback to
+                # picker) get a directional way to back out without
+                # reaching for Esc.  Choices without an on_cancel just
+                # dismiss, same as Esc.
+                Binding("left",  "cancel", "Back",   show=False),
                 Binding("escape", "cancel", "Cancel", show=False)]
 
     def __init__(self, msg: "ChatMessage", *options, **kwargs):
@@ -1634,6 +1655,14 @@ def action_cancel(self) -> None:
 
 
 class SelectableStatic(Static):
+    # PR #461: a SelectableStatic that gets removed from the DOM but whose
+    # reference still lingers (e.g. cached in a closure) was firing mouse
+    # selection on stale screen coordinates.  has_valid_selection_parent
+    # is the cheap "am I still in the tree?" probe used by the screen-
+    # level mouse-event filter (`_is_stale_selectable_mouse_event`).
+    def has_valid_selection_parent(self) -> bool:
+        return isinstance(self.parent, Widget)
+
     # Widget.get_selection returns None for non-Text/Content visuals; fall back to render_line.
     def get_selection(self, selection):
         render = getattr(self, "_ga_render", None)
@@ -1795,42 +1824,66 @@ def action_noop(self) -> None:
     def action_stash(self) -> None:
         """Stash/restore the input draft.
 
-        - Non-empty input → save into `_draft_stash`, then `reset()` the
-          TextArea. `reset()` is O(1)-ish vs the multi-second relayout
-          that `self.text = ""` triggers on large drafts.
-        - Empty input + a previous stash → put the saved text back so the
-          user can keep typing where they left off.
-        - Empty input + no stash → no-op (accidental presses harmless).
+        Long-session note (2026-05-28, 2nd pass): the previous fix tried to
+        keep `reset()` synchronous and only deferred the palette/resize
+        cleanup, but `reset()` itself still queues a Changed event behind
+        the streaming reactive cycle.  When the queue is saturated with
+        per-chunk repaints the visible clear never lands and the user sees
+        a frozen input.  Now we defer the reset itself: only the buffer
+        snapshot happens on the keystroke; the visible clear and layout
+        work both happen on the next event-loop tick via
+        `call_after_refresh`.  Trades a 1-frame delay for guaranteed
+        keystroke responsiveness.
         """
         current = self.text
         if current:
             self._draft_stash = current
-            self.reset()
             self._history_index = -1
             self._history_stash = ""
-            try: self.app._hide_palette()
-            except Exception: pass
-            try: self.app._resize_input(self)
-            except Exception: pass
+            try:
+                self.app.call_after_refresh(self._stash_cleanup_clear)
+            except Exception:
+                # Last-resort synchronous fallback (re-introduces the freeze
+                # window but at least keeps the function correct).
+                self._stash_cleanup_clear()
         elif self._draft_stash:
             stashed = self._draft_stash
             self._draft_stash = ""
             self._history_index = -1
             self._history_stash = ""
-            # Suppress palette popup during the bulk insert — restoring
-            # a slash-command draft should not re-trigger the command picker.
-            try: self._suppress_palette_next_change()
-            except Exception: pass
-            self.text = stashed
             try:
-                # `cursor_location = document.end` is multi-line safe;
-                # `move_cursor((0, len(stashed)))` clamps to row 0 and
-                # would mis-position the caret on multi-line drafts.
-                self.cursor_location = self.document.end
+                self.app.call_after_refresh(self._stash_cleanup_restore, stashed)
             except Exception:
-                pass
-            try: self.app._resize_input(self)
-            except Exception: pass
+                self._stash_cleanup_restore(stashed)
+
+    def _stash_cleanup_clear(self) -> None:
+        """Deferred companion to action_stash (clear path).
+
+        Runs OUTSIDE the keystroke event so the Textual layout cascade
+        triggered by reset() doesn't block the user from typing more.
+        `_skip_change_next` still short-circuits on_input_area_changed
+        so the cascade hits once (from `reset()` itself), not twice."""
+        self._skip_change_next = True
+        try:
+            self.reset()
+        finally:
+            self._skip_change_next = False
+        try: self.app._hide_palette()
+        except Exception: pass
+        try: self.app._resize_input(self)
+        except Exception: pass
+
+    def _stash_cleanup_restore(self, stashed: str) -> None:
+        """Deferred companion to action_stash (restore path)."""
+        try: self._suppress_palette_next_change()
+        except Exception: pass
+        self.text = stashed
+        try:
+            self.cursor_location = self.document.end
+        except Exception:
+            pass
+        try: self.app._resize_input(self)
+        except Exception: pass
 
     def action_clear_input(self) -> None:
         self.reset()
@@ -1946,6 +1999,12 @@ def __init__(self, *args, **kwargs) -> None:
         # Ctrl+S scratch draft (PR#479 semantics). Distinct from
         # `_history_stash`, which is the Up/Down-arrow working buffer.
         self._draft_stash: str = ""
+        # Set by `action_stash` to make on_input_area_changed bail out on
+        # the synchronous Changed event from `reset()` — the layout work
+        # is rescheduled via `call_after_refresh` so the keystroke handler
+        # returns immediately even when streaming has the reactive queue
+        # saturated.  Cleared by `_stash_cleanup_clear`.
+        self._skip_change_next: bool = False
         self._HISTORY_MAX = 200
 
     def expand_placeholders(self, text: str) -> str:
@@ -2067,6 +2126,29 @@ async def _on_key(self, event: events.Key) -> None:
         # 3) history browse: only at (0,0) for up / end-of-text for down, so in-line
         #    cursor movement is preserved.
         if event.key == "up" and self.cursor_location == (0, 0):
+            # Pending-queue recall: Up on an empty input pops the most-
+            # recent queued message back into the composer for amendment
+            # (LIFO).  Re-submitting it appends at the tail again; Esc
+            # clears the whole queue.  Takes priority over history when
+            # there's nothing typed AND something is queued.
+            if not self.text:
+                try:
+                    sess = self.app.current
+                except Exception:
+                    sess = None
+                if sess is not None and sess.pending:
+                    self._suppress_palette_next_change()
+                    self.text = sess.pending.pop()
+                    if not sess.pending:
+                        sess.pending_drain_at = 0.0
+                    if sess.agent_id == self.app.current_id:
+                        try: self.app._refresh_bottombar()
+                        except Exception: pass
+                    try:
+                        self.cursor_location = self.document.end
+                    except Exception:
+                        pass
+                    event.stop(); event.prevent_default(); return
             if self._history_up():
                 event.stop(); event.prevent_default(); return
         if event.key == "down":
@@ -2226,16 +2308,17 @@ def render_bottombar(quit_armed: bool = False, rewind_armed: bool = False) -> Ta
     t.add_column(justify="left")
     left = Text()
     if quit_armed:
-        left.append("再按 Ctrl+C 退出", style=f"bold {C_GREEN}")
+        left.append(f"再按 {fmt_key('ctrl+c')} 退出", style=f"bold {C_GREEN}")
     elif rewind_armed:
         left.append("再按 Esc 回退", style=f"bold {C_GREEN}")
     else:
-        pairs = [("Enter", "发送"), ("Ctrl+N", "新会话"),
-                 ("Ctrl+B", "侧栏"), ("Ctrl+C", "停止/退出"),
-                 ("/", "命令面板"), ("Ctrl+/", "快捷键帮助")]
-        for i, (k, d) in enumerate(pairs):
+        pairs = [("enter", "发送"), ("ctrl+n", "新会话"),
+                 ("ctrl+b", "侧栏"), ("ctrl+c", "停止/退出"),
+                 ("/", "命令面板"), ("ctrl+/", "快捷键帮助")]
+        for i, (combo, d) in enumerate(pairs):
             if i: left.append("    ")
-            left.append(k, style=C_GREEN if k in ("/", "Ctrl+/") else C_FG)
+            k = "/" if combo == "/" else fmt_key(combo)
+            left.append(k, style=C_GREEN if combo in ("/", "ctrl+/") else C_FG)
             left.append(" ")
             left.append(d, style=C_MUTED)
     t.add_row(left)
@@ -2540,6 +2623,38 @@ def __init__(self, agent_factory: Optional[AgentFactory] = None) -> None:
         except Exception:
             pass
 
+    # PR #461 (upstream 08f21e8): suppress mouse events that target a
+    # SelectableStatic whose parent is no longer in the widget tree.
+    # Such widgets persist as cached references (e.g. the ChatMessage
+    # picker collapse path stashes the previous body widget) but they're
+    # no longer mounted, so any MouseDown/MouseMove on their old screen
+    # rect would fire selection callbacks on detached objects → crash.
+    def _is_stale_selectable_mouse_event(self, event) -> bool:
+        if not isinstance(event, (events.MouseDown, events.MouseMove)):
+            return False
+        try:
+            select_widget, select_offset = self.screen.get_widget_and_offset_at(
+                event.x, event.y
+            )
+        except Exception:
+            return False
+        return (
+            select_offset is not None
+            and isinstance(select_widget, SelectableStatic)
+            and not select_widget.has_valid_selection_parent()
+        )
+
+    async def on_event(self, event) -> None:
+        if self._is_stale_selectable_mouse_event(event):
+            if isinstance(event, events.MouseDown):
+                try:
+                    self.screen.clear_selection()
+                except Exception:
+                    pass
+            event.stop()
+            return
+        await super().on_event(event)
+
     def compose(self) -> ComposeResult:
         yield Static("", id="topbar")
         with Horizontal(id="body"):
@@ -2555,7 +2670,7 @@ def compose(self) -> ComposeResult:
                     show_line_numbers=False,
                     compact=True,
                     highlight_cursor_line=False,
-                    placeholder="输入指令或问题... (Enter 发送, Ctrl+J 换行, / 唤起命令面板)",
+                    placeholder=f"输入指令或问题... (Enter 发送, {fmt_key('ctrl+j')} 换行, / 唤起命令面板)",
                 )
                 # Tip line sits inside #main so it doesn't compete for height
                 # with #body's 1fr. Content set at compose so the first frame
@@ -2565,13 +2680,15 @@ def compose(self) -> ComposeResult:
 
     def on_mount(self) -> None:
         self.add_session("main")
-        self._system("Welcome to GenericAgent TUI. 按 / 唤起命令面板，Ctrl+N 新建会话。")
+        self._system(f"Welcome to GenericAgent TUI. 按 / 唤起命令面板，{fmt_key('ctrl+n')} 新建会话。")
+
         # CSS `#planbar { display: none }` keeps it hidden by default —
         # the renderer flips it on once items materialize.
         self.query_one("#input", InputArea).focus()
         self.set_interval(0.5, self._tick)
         self._patch_auto_scroll_for_selection()
         self._start_plan_watcher()
+        self._start_pending_watcher()
         self._start_tip_rotator()
         self._apply_responsive_layout()
         # Disable alternate scroll mode (?1007). Textual enables ?1006 SGR mouse but doesn't
@@ -2664,6 +2781,17 @@ def add_session(self, name: Optional[str] = None) -> AgentSession:
         agent = self.agent_factory()
         try: agent.inc_out = True
         except Exception: pass
+        # Give the agent a per-session task_dir so ga.turn_end_callback's
+        # `_intervene` file hook (ga.py:576) can fire — that's how pending
+        # user messages slip into the current turn's next LLM call instead
+        # of waiting for the whole run to end.  Dedicated PID+session dir
+        # so concurrent sessions don't share an intervene file.
+        try:
+            agent.task_dir = os.path.join(FRONTENDS_DIR, '..', 'temp',
+                                          f'_tui_v2_{os.getpid()}_{agent_id}')
+            os.makedirs(agent.task_dir, exist_ok=True)
+        except Exception:
+            pass
         sess = AgentSession(agent_id=agent_id, name=name or f"agent-{agent_id}", agent=agent)
         thread = threading.Thread(target=agent.run, name=f"ga-tui-agent-{agent_id}", daemon=True)
         thread.start()
@@ -2861,6 +2989,25 @@ def action_escape(self) -> None:
             self.query_one("#input", InputArea).focus()
             self._disarm_rewind()
             return
+        # Pending-queue cancel: Esc with the input empty and entries queued
+        # drops the lot.  Runs before quit-arm so a single Esc clears the
+        # queue (no second-press needed).
+        try:
+            sess = self.current
+        except Exception:
+            sess = None
+        if sess is not None and sess.pending:
+            try:
+                inp_empty = not (self.query_one("#input", InputArea).text or "")
+            except Exception:
+                inp_empty = True
+            if inp_empty:
+                n = len(sess.pending)
+                sess.pending = []
+                sess.pending_drain_at = 0.0
+                self._system(f"已清空 {n} 条待发送消息")
+                self._disarm_rewind()
+                return
         if self._quit_armed:
             self._disarm_quit()
             return
@@ -2960,30 +3107,30 @@ def watch_theme(self, _old_theme, _new_theme) -> None:
 
     def _render_help(self) -> Text:
         rows = [
-            ("Enter",                   "发送"),
-            ("Ctrl+J / Ctrl+Enter",     "换行（Shift+Enter 同义）"),
-            ("Ctrl+C",                  "停止任务 / 空闲时连按两次退出"),
-            ("Ctrl+N",                  "新建会话"),
-            ("Ctrl+B",                  "切换侧栏"),
-            ("Ctrl+↑ / Ctrl+↓",         "切换会话"),
-            ("Ctrl+D",                  "侧栏移除会话"),
-            ("Ctrl+O",                  "折叠 / 展开已完成的轮次"),
-            ("Ctrl+U",                  "清空输入框"),
-            ("Ctrl+V",                  "粘贴（图片优先）"),
-            ("↑ / ↓",                   "输入框：浏览发送历史 / 面板内：移动"),
-            ("/",                       "唤起命令面板"),
-            ("Tab",                     "命令面板可见时补全"),
-            ("Esc",                     "取消选择 / 关闭面板 / 关闭帮助"),
-            ("Esc Esc",                 "打开回退选择"),
-            ("Ctrl+T",                  "切换主题"),
-            ("Ctrl+/",                  "显示 / 隐藏本帮助"),
+            ("Enter",                            "发送"),
+            (fmt_keys("ctrl+j", "ctrl+enter"),   "换行（Shift+Enter 同义）"),
+            (fmt_key("ctrl+c"),                  "停止任务 / 空闲时连按两次退出"),
+            (fmt_key("ctrl+n"),                  "新建会话"),
+            (fmt_key("ctrl+b"),                  "切换侧栏"),
+            (fmt_keys("ctrl+up", "ctrl+down"),   "切换会话"),
+            (fmt_key("ctrl+d"),                  "侧栏移除会话"),
+            (fmt_key("ctrl+o"),                  "折叠 / 展开已完成的轮次"),
+            (fmt_key("ctrl+u"),                  "清空输入框"),
+            (fmt_key("ctrl+v"),                  "粘贴（图片优先）"),
+            ("↑ / ↓",                            "输入框：浏览发送历史 / 面板内：移动"),
+            ("/",                                "唤起命令面板"),
+            ("Tab",                              "命令面板可见时补全"),
+            ("Esc",                              "取消选择 / 关闭面板 / 关闭帮助"),
+            ("Esc Esc",                          "打开回退选择"),
+            (fmt_key("ctrl+t"),                  "切换主题"),
+            (fmt_key("ctrl+/"),                  "显示 / 隐藏本帮助"),
         ]
         t = Text()
         t.append("快捷键帮助\n\n", style=f"bold {C_GREEN}")
         for k, d in rows:
             t.append(f"  {k:<22}", style=C_FG)
             t.append(f"{d}\n", style=C_MUTED)
-        t.append("\n按 Esc 或 Ctrl+/ 关闭", style=C_DIM)
+        t.append(f"\n按 Esc 或 {fmt_key('ctrl+/')} 关闭", style=C_DIM)
         return t
 
     def action_complete_command(self) -> None:
@@ -3118,6 +3265,14 @@ def on_text_area_changed(self, event: TextArea.Changed) -> None:
         if event.text_area.id != "input":
             return
         inp = event.text_area
+        # action_stash flips this flag right before `reset()`/text assign
+        # so the synchronous Changed event won't trigger the heavy
+        # _resize_input + palette-query on the keystroke hot path.  The
+        # deferred `_stash_cleanup_*` callbacks (call_after_refresh) own
+        # all the layout work for that path.
+        if getattr(inp, "_skip_change_next", False):
+            inp._skip_change_next = False
+            return
         self._resize_input(inp)
         val = (inp.text or "").lstrip()
         if self._suppress_palette_open:
@@ -3174,6 +3329,17 @@ def on_input_area_submitted(self, event: "InputArea.Submitted") -> None:
                 sess.agent.load_llm_sessions()
         except Exception:
             pass
+        if text.startswith("!"):
+            # Shell-mode magic: run the rest as a host shell command, echo
+            # the command + output into scrollback, and append the pair to
+            # the agent's LLM history so a follow-up question can reference
+            # it (parity with v3 _run_shell).
+            self._run_shell(text[1:].strip())
+            try:
+                self.query_one("#messages", VerticalScroll).scroll_end(animate=False)
+            except Exception:
+                pass
+            return
         if text.startswith("/"):
             parts = text.split(maxsplit=1)
             cmd = parts[0][1:].lower()
@@ -3185,6 +3351,11 @@ def on_input_area_submitted(self, event: "InputArea.Submitted") -> None:
                 except Exception:
                     pass
                 return
+            if cmd == "resume":
+                # GA's _handle_slash_cmd expands `/resume` at agent side —
+                # forward the literal so the agent recovers context.
+                self.submit_user_message(text)
+                return
         self.submit_user_message(text, images=images)
 
     def _show_palette(self) -> None:
@@ -3353,6 +3524,16 @@ def _collapse_choice(self, msg: ChatMessage, idx: int) -> None:
                 result_text = msg.on_select(value)
             except Exception as e:
                 result_text = f"❌ 失败: {type(e).__name__}: {e}"
+        # PR #466 (upstream 8ae3645): if on_select rebuilt the message
+        # container (e.g. /rewind picker → _do_rewind → _remount_current_session
+        # detaches every widget under #messages), the captured anchors are
+        # now stale.  Bail out early so we don't try to mount(after=...)
+        # against a detached widget — that'd raise NoWidget and crash.
+        anchor_guard = msg._hint_widget or msg._body_widget
+        if (anchor_guard is not None
+                and hasattr(anchor_guard, 'is_mounted')
+                and not anchor_guard.is_mounted):
+            return
         display = (result_text or label).strip() or label
         msg.selected_label = display
         msg.content = display
@@ -4121,15 +4302,33 @@ def _cmd_scheduler(self, args, raw):
         for kind in ("reflect", "frontend"):
             for s in (svc for svc in services if svc["kind"] == kind):
                 doc = f"  — {s['doc']}" if s["doc"] else ""
-                tag = "  ● running" if s["name"] in running else ""
-                if s["name"] in running:
+                is_running = s["name"] in running
+                tag = "  · running" if is_running else ""
+                if is_running:
                     preselected.append(len(choices))
-                choices.append((f"{s['name']}{doc}{tag}", s["name"]))
+                label = f"{s['name']}{doc}{tag}"
+                # Functional green for already-running rows so they're
+                # distinguishable even when the [x] tick is small or the
+                # row scrolls off the visible window.
+                if is_running:
+                    from rich.text import Text as _T
+                    rich_label = _T(label, style="green")
+                    choices.append((rich_label, s["name"]))
+                else:
+                    choices.append((label, s["name"]))
         sess = self.current
-        hint = ("📋 选择要启动的服务（与 hub.pyw 一致：reflect 任务 + frontend 应用）"
+        hint = ("选择要启动的服务（与 hub.pyw 一致：reflect 任务 + frontend 应用）"
                 "    Space 勾选 · Enter 提交 · Esc 取消 — 提交后还需二次确认")
         if running:
-            hint += f"\n   ● = 正在运行（已勾选）；取消勾选即停止该服务（共 {len(running)} 个在运行）"
+            hint += f"\n   绿色 = 正在运行（已勾选）；取消勾选即停止该服务（共 {len(running)} 个在运行）"
+        try:
+            cron_n = len(slash_cmds.list_scheduler_tasks())
+        except Exception:
+            cron_n = 0
+        if cron_n:
+            sch_running = 'reflect/scheduler.py' in running
+            cron_state = "已激活" if sch_running else "未激活（启动 reflect/scheduler.py 来调度）"
+            hint += f"\n   cron：sche_tasks/*.json 共 {cron_n} 个任务 · {cron_state}"
         msg = ChatMessage(
             role="system",
             content=hint,
@@ -4236,7 +4435,7 @@ def _launch_service_batch(self, names: list[str]) -> None:
         from frontends import slash_cmds
         if not names:
             self._system("（未选择任何服务）"); return
-        lines = [f"🚀 批量启动 {len(names)} 个服务："]
+        lines = [f"批量启动 {len(names)} 个服务："]
         for n in names:
             ok, msg = slash_cmds.start_service(n)
             lines.append(("  ✅ " if ok else "  ❌ ") + msg)
@@ -4254,14 +4453,111 @@ def _reset_terminal_title(self) -> None:
     def on_unmount(self) -> None:
         self._reset_terminal_title()
 
+    def _run_shell(self, cmd: str) -> None:
+        """`!cmd` magic: run `cmd` in the host shell, echo command + output
+        into the current session's scrollback, and append a `[!shell]` pair
+        to backend.history so the agent can reference it on the next turn.
+
+        Output capture is utf-8 / replace; 30 s timeout — anything longer
+        belongs in /conductor or a proper tool call, not a one-liner."""
+        if not cmd:
+            return
+        sess = self.current
+        sess.messages.append(ChatMessage("system",
+                                         f"! {cmd}",
+                                         kind="system"))
+        import subprocess
+        out = ''; rc = 0
+        try:
+            r = subprocess.run(
+                cmd, shell=True, capture_output=True,
+                timeout=30, encoding='utf-8', errors='replace',
+            )
+            out = (r.stdout or '') + (r.stderr or '')
+            rc = r.returncode
+        except subprocess.TimeoutExpired:
+            out = '[shell: timeout 30s]'; rc = -1
+        except Exception as e:
+            out = f'[shell error: {type(e).__name__}: {e}]'; rc = -1
+        body = (out.rstrip('\n') or '(no output)').split('\n')
+        formatted = '\n'.join(('  └ ' + ln if i == 0 else '    ' + ln)
+                              for i, ln in enumerate(body))
+        sess.messages.append(ChatMessage("system", formatted, kind="system"))
+        if sess.agent_id == self.current_id:
+            self._refresh_messages()
+        # Splice the exchange into LLM history.
+        try:
+            be = getattr(sess.agent, 'llmclient', None)
+            be = getattr(be, 'backend', None) if be is not None else None
+            if be is not None and hasattr(be, 'history'):
+                txt = f"[!shell] {cmd}\n```\n{out.rstrip()}\n```\n(exit {rc})"
+                be.history.append({"role": "user",
+                                   "content": [{"type": "text", "text": txt}]})
+        except Exception:
+            pass
+
     # ---------------- agent task + stream ----------------
+    # 5 s cooldown after the LAST user submit (cooldown resets per entry).
+    # Drain path:
+    #   running → write to <task_dir>/_intervene; ga.turn_end_callback
+    #             (ga.py:576) prepends it to next_prompt at the next
+    #             turn boundary — message lands mid-run.
+    #   idle    → fall back to put_task for a fresh turn.
+    _PENDING_COOLDOWN_SEC = 5.0
+
+    def _session_intervene_path(self, sess: AgentSession) -> Optional[str]:
+        td = getattr(sess.agent, 'task_dir', None)
+        if not td:
+            return None
+        try:
+            os.makedirs(td, exist_ok=True)
+        except Exception:
+            return None
+        return os.path.join(td, '_intervene')
+
+    def _inject_intervene(self, sess: AgentSession, text: str) -> bool:
+        """Append `text` to `<task_dir>/_intervene` (append-mode so a
+        TOCTOU between our read-then-write and the agent's
+        `consume_file` (read+delete) can't duplicate already-consumed
+        content into the NEXT turn)."""
+        if sess.status != "running":
+            return False
+        fp = self._session_intervene_path(sess)
+        if not fp:
+            return False
+        try:
+            sep = ''
+            try:
+                if os.path.getsize(fp) > 0:
+                    sep = '\n\n'
+            except OSError:
+                pass   # file consumed mid-call → write into a fresh one
+            with open(fp, 'a', encoding='utf-8') as f:
+                f.write(sep + text)
+            return True
+        except Exception:
+            return False
+
     def submit_user_message(self, text: str, images: Optional[list[str]] = None, display_text: Optional[str] = None) -> int:
         sess = self.current
         # Free-text ask_user answers go through a 2-step submit-confirm card.
         if self._maybe_intercept_free_text(sess, text):
             return -1
         if sess.status == "running":
-            self._system(f"#{sess.agent_id} 正在跑，/stop 后再发。")
+            # Codex-style: don't reject, queue.  Cooldown resets per entry
+            # so a burst of edits coalesces into one inject.  Drain fires
+            # `_inject_intervene` (mid-turn) or `put_task` (idle).
+            visible = text if display_text is None else display_text
+            sess.pending.append(text)
+            sess.pending_drain_at = time.time() + self._PENDING_COOLDOWN_SEC
+            sess.messages.append(ChatMessage(
+                "system",
+                f"[queued #{len(sess.pending)}] {visible}",
+                kind="system",
+            ))
+            if sess.agent_id == self.current_id:
+                self._refresh_messages()
+                self._refresh_bottombar()
             return -1
         sess.task_seq += 1
         tid = sess.task_seq
@@ -4313,12 +4609,38 @@ def _on_stream(self, agent_id, task_id, text, done):
         if done:
             s.status = "idle"
             s.current_display_queue = None
+            # NOTE: cooldown timer is armed on each user submit (see
+            # submit_user_message), NOT here on turn end.  This matches
+            # "5 s since LAST keystroke" semantics: if turn ends within
+            # the cooldown the timer keeps counting, drain fires whenever
+            # the deadline lapses (mid-turn → intervene; idle → put_task).
         self._update_assistant(agent_id, text, task_id=task_id, done=done, refresh_chrome=True)
         # End-of-turn re-parse only; mid-stream `[...]` fragments would flash.
         if done:
             self._update_plan_state(s, text)
             self._drain_ask_user_events(s)
 
+    def _drain_pending(self, sess: AgentSession) -> None:
+        """Flush queued user messages.  Two paths:
+        - sess.status == 'running' → write to <task_dir>/_intervene; the
+          agent's turn_end_callback (ga.py:576) consumes it and prepends
+          to next_prompt, so the message lands inside the current run.
+        - idle → fall back to put_task for a fresh turn.
+        Combined into one payload because users usually queue clarifying
+        lines for a single logical follow-up; N separate turns would
+        force pointless handoffs."""
+        if not sess.pending:
+            return
+        combined = "\n\n".join(sess.pending)
+        sess.pending = []
+        sess.pending_drain_at = 0.0
+        if self._inject_intervene(sess, combined):
+            return
+        # Echo nothing — the [queued #N] system lines already landed when
+        # each entry was submitted; this just hands the combined text to
+        # the agent without an extra visual.
+        self.submit_user_message(combined, display_text=combined)
+
     # Phrasing-based opt-in for multi-select picker (no core schema change).
     _MULTI_RE = re.compile(r"\[?(?:多选|multi(?:[-_ ]?select)?|select all)\]?", re.IGNORECASE)
 
@@ -4635,6 +4957,31 @@ def _start_plan_watcher(self) -> None:
         try: self._plan_timer = self.set_interval(1.0, self._poll_plan_files)
         except Exception: pass
 
+    def _start_pending_watcher(self) -> None:
+        """Pending-input drain poller — fires every 100 ms.  Walks all
+        sessions, fires `_drain_pending(sess)` when the post-turn cooldown
+        deadline lapses.  Idle on sessions with nothing queued."""
+        if getattr(self, "_pending_timer", None) is not None: return
+        try: self._pending_timer = self.set_interval(0.1, self._poll_pending)
+        except Exception: pass
+
+    def _poll_pending(self) -> None:
+        now = time.time()
+        for sess in list(self.sessions.values()):
+            # Drain regardless of running state — _drain_pending picks the
+            # right transport (intervene for mid-turn, put_task for idle).
+            if (sess.pending and sess.pending_drain_at > 0
+                    and now >= sess.pending_drain_at):
+                try:
+                    self._drain_pending(sess)
+                except Exception:
+                    # Swallow so a bad pending entry can't kill the timer.
+                    sess.pending = []
+                    sess.pending_drain_at = 0.0
+        # Repaint bottombar so the cooldown countdown ticks visibly.
+        if any(s.pending for s in self.sessions.values()):
+            self._refresh_bottombar()
+
     def _poll_plan_files(self) -> None:
         # Poll only the visible session — background sessions don't paint planbar.
         import plan_state