oh-pi 0.1.48 → 0.1.50

package/README.fr.md

@@ -45,13 +45,14 @@ Vous avez déjà une config ? oh-pi la détecte et propose une **sauvegarde avan
 ├── settings.json        Modèle, thème, niveau de réflexion
 ├── keybindings.json     Raccourcis Vim/Emacs (optionnel)
 ├── AGENTS.md            Directives IA par rôle
-├── extensions/          7 extensions (6 par défaut + colonie)
+├── extensions/          8 extensions (7 par défaut + colonie)
 │   ├── safe-guard       Confirmation des commandes dangereuses + protection des chemins
 │   ├── git-guard        Points de contrôle stash auto + alerte dépôt sale
 │   ├── auto-session     Nommage de session depuis le premier message
 │   ├── custom-footer    Barre d'état améliorée (token/coût/temps/git/cwd)
 │   ├── compact-header   Informations de démarrage simplifiées
 │   ├── auto-update      Vérification des mises à jour au lancement
+│   ├── bg-process       ⏳ **Bg Process** — Mise en arrière-plan automatique des commandes longues (serveurs dev, etc.)
 │   └── ant-colony/      🐜 Essaim multi-agents autonome (optionnel)
 ├── prompts/             10 modèles (/review /fix /commit /test ...)
 ├── skills/              11 compétences (outils + design UI + workflows)
@@ -68,14 +69,11 @@ Vous avez déjà une config ? oh-pi la détecte et propose une **sauvegarde avan
 
 ### Préréglages
 
-| | Thème | Réflexion | Inclut |
-|---|-------|-----------|--------|
-| 🟢 Débutant | oh-pi Dark | medium | Sécurité + bases git |
-| 🔵 Pro | Catppuccin | high | Chaîne d'outils complète |
-| 🟣 Chercheur en sécurité | Cyberpunk | high | Audit + pentest |
-| 🟠 Data & IA | Tokyo Night | medium | MLOps + pipelines |
-| 🔴 Minimal | Default | off | Noyau uniquement |
-| ⚫ Pleine puissance | oh-pi Dark | high | Tout + colonie de fourmis |
+| | Inclut |
+|---|--------|
+| 🟢 **Complet** | Toutes extensions + colonie + bg-process |
+| 🔵 **Propre** | Aucune extension |
+| 🟣 **Colonie** | Colonie uniquement |
 
 ### Fournisseurs
 
@@ -133,12 +131,23 @@ Les vraies colonies de fourmis résolvent des problèmes complexes sans contrôl
 
 En mode interactif, la colonie affiche la progression en direct :
 
-- **Widget** — fourmis actives et leur flux de sortie
-- **Barre de statut** — progression des tâches, nombre actif, coût
+- **Barre de statut** — footer compact avec métriques réelles : tâches terminées, fourmis actives, appels d'outils, tokens de sortie, coût, durée
+- **Ctrl+Shift+A** — panneau de détails en overlay avec liste des tâches, flux des fourmis actives et journal de la colonie
 - **Notification** — résumé à la fin
 
 Utilisez `/colony-stop` pour arrêter une colonie en cours.
 
+### Protocole de signaux
+
+La colonie communique avec la conversation principale via des signaux structurés, empêchant le LLM de vérifier ou deviner l'état :
+
+| Signal | Signification |
+|--------|---------------|
+| `COLONY_SIGNAL:LAUNCHED` | Colonie démarrée — ne pas vérifier |
+| `COLONY_SIGNAL:RUNNING` | Colonie active — injecté à chaque tour |
+| `COLONY_SIGNAL:COMPLETE` | Colonie terminée — consulter le rapport |
+| `COLONY_SIGNAL:FAILED` | Colonie crashée — signaler l'erreur |
+
 ### Contrôle des tours
 
 Chaque fourmi a un budget strict de tours pour éviter les exécutions incontrôlées :
@@ -174,7 +183,7 @@ Le LLM décide quand déployer la colonie. Vous n'avez pas à y penser :
 La colonie trouve automatiquement le parallélisme optimal pour votre machine :
 
 ```
-Démarrage à froid  →  1-2 fourmis (conservateur)
+Démarrage à froid  →  ceil(max/2) fourmis (démarrage rapide)
 Exploration        →  +1 par vague, surveillance du débit
 Débit ↓            →  verrouiller l'optimal, stabiliser
 CPU > 85%          →  réduire immédiatement

package/README.md

@@ -45,13 +45,14 @@ Already have a config? oh-pi detects it and offers **backup before overwriting**
 ├── settings.json        Model, theme, thinking level
 ├── keybindings.json     Vim/Emacs shortcuts (optional)
 ├── AGENTS.md            Role-specific AI guidelines
-├── extensions/          7 extensions (6 default + ant-colony)
+├── extensions/          8 extensions (7 default + ant-colony)
 │   ├── safe-guard       Dangerous command confirmation + path protection
 │   ├── git-guard        Auto stash checkpoints + dirty repo warning
 │   ├── auto-session     Session naming from first message
 │   ├── custom-footer    Enhanced status bar (token/cost/time/git/cwd)
 │   ├── compact-header   Streamlined startup info
 │   ├── auto-update      Check for updates on launch
+│   ├── bg-process       ⏳ **Bg Process** — Auto-background long-running commands (dev servers, etc.)
 │   └── ant-colony/      🐜 Autonomous multi-agent swarm (optional)
 ├── prompts/             10 templates (/review /fix /commit /test ...)
 ├── skills/              11 skills (tools + UI design + workflows)
@@ -70,12 +71,9 @@ Already have a config? oh-pi detects it and offers **backup before overwriting**
 
 | | Theme | Thinking | Includes |
 |---|-------|----------|----------|
-| 🟢 Starter | oh-pi Dark | medium | Safety + git basics |
-| 🔵 Pro Developer | Catppuccin | high | Full toolchain |
-| 🟣 Security Researcher | Cyberpunk | high | Audit + pentesting |
-| 🟠 Data & AI | Tokyo Night | medium | MLOps + pipelines |
-| 🔴 Minimal | Default | off | Core only |
-| ⚫ Full Power | oh-pi Dark | high | Everything + ant colony |
+| ⚫ Full Power | oh-pi Dark | high | All extensions + bg-process + ant-colony |
+| 🔴 Clean | Default | off | No extensions, just core |
+| 🐜 Colony Only | oh-pi Dark | medium | Ant-colony with minimal setup |
 
 ### Providers
 
@@ -133,12 +131,23 @@ Real ant colonies solve complex problems without central control. Each ant follo
 
 In interactive mode, the colony shows live progress:
 
-- **Widget** — active ants and their current output stream
-- **Status bar** — task progress, active count, cost
+- **Status bar** — compact footer with real metrics: tasks done, active ants, tool calls, output tokens, cost, elapsed time
+- **Ctrl+Shift+A** — overlay detail panel with task list, active ant streams, and colony log
 - **Notification** — completion summary when done
 
 Use `/colony-stop` to abort a running colony.
 
+### Signal Protocol
+
+The colony communicates with the main conversation via structured signals, preventing the LLM from polling or guessing colony status:
+
+| Signal | Meaning |
+|--------|---------|
+| `COLONY_SIGNAL:LAUNCHED` | Colony started — don't poll |
+| `COLONY_SIGNAL:RUNNING` | Colony active — injected each turn |
+| `COLONY_SIGNAL:COMPLETE` | Colony finished — review report |
+| `COLONY_SIGNAL:FAILED` | Colony crashed — report error |
+
 ### Turn Control
 
 Each ant has a strict turn budget to prevent runaway execution:
@@ -174,7 +183,7 @@ The LLM decides when to deploy the colony. You don't have to think about it:
 The colony automatically finds the optimal parallelism for your machine:
 
 ```
-Cold start     →  1-2 ants (conservative)
+Cold start     →  ceil(max/2) ants (fast ramp-up)
 Exploration    →  +1 each wave, monitoring throughput
 Throughput ↓   →  lock optimal, stabilize
 CPU > 85%      →  reduce immediately

package/README.zh.md

@@ -45,13 +45,14 @@ pi           # 开始编码
 ├── settings.json        模型、主题、思维级别
 ├── keybindings.json     Vim/Emacs 快捷键（可选）
 ├── AGENTS.md            角色专属 AI 指南
-├── extensions/          7 个扩展（6 个默认 + 蚁群）
+├── extensions/          8 个扩展（7 个默认 + 蚁群）
 │   ├── safe-guard       危险命令确认 + 路径保护
 │   ├── git-guard        自动 stash 检查点 + 脏仓库警告
 │   ├── auto-session     从首条消息自动命名会话
 │   ├── custom-footer    增强状态栏（token/成本/时间/git/cwd）
 │   ├── compact-header   精简启动信息
 │   ├── auto-update      启动时检查更新
+│   ├── bg-process       ⏳ **后台进程** — 自动后台化长时间运行的命令（开发服务器等）
 │   └── ant-colony/      🐜 自主多智能体蚁群系统（可选）
 ├── prompts/             10 个模板（/review /fix /commit /test ...）
 ├── skills/              11 个技能（工具 + UI 设计 + 工作流）
@@ -70,12 +71,9 @@ pi           # 开始编码
 
 | | 主题 | 思维 | 包含 |
 |---|------|------|------|
-| 🟢 入门 | oh-pi Dark | medium | 安全 + git 基础 |
-| 🔵 专业开发 | Catppuccin | high | 全工具链 |
-| 🟣 安全研究 | Cyberpunk | high | 审计 + 渗透测试 |
-| 🟠 数据 & AI | Tokyo Night | medium | MLOps + 管道 |
-| 🔴 极简 | Default | off | 仅核心 |
-| ⚫ 全功率 | oh-pi Dark | high | 全部 + 蚁群 |
+| 🟢 全功能 | oh-pi Dark | high | 全部扩展含蚁群 + 后台进程 |
+| 🔵 干净 | Default | off | 无扩展仅核心 |
+| 🟣 仅蚁群 | oh-pi Dark | medium | 蚁群 + 最小配置 |
 
 ### 提供商
 
@@ -133,12 +131,23 @@ pi（主进程）
 
 交互模式下，蚁群显示实时进度：
 
-- **Widget** — 活跃蚂蚁及其当前输出流
-- **状态栏** — 任务进度、活跃数量、成本
+- **状态栏** — 紧凑 footer 显示真实指标：完成任务数、活跃蚂蚁、工具调用次数、输出 token 数、成本、耗时
+- **Ctrl+Shift+A** — 弹出详情面板，显示任务列表、活跃蚂蚁流、蚁群日志
 - **通知** — 完成时显示汇总
 
 使用 `/colony-stop` 中止运行中的蚁群。
 
+### 信号协议
+
+蚁群通过结构化信号与主对话通信，防止 LLM 轮询或猜测蚁群状态：
+
+| 信号 | 含义 |
+|------|------|
+| `COLONY_SIGNAL:LAUNCHED` | 蚁群已启动 — 不要轮询 |
+| `COLONY_SIGNAL:RUNNING` | 蚁群运行中 — 每轮注入 |
+| `COLONY_SIGNAL:COMPLETE` | 蚁群完成 — 查看报告 |
+| `COLONY_SIGNAL:FAILED` | 蚁群崩溃 — 报告错误 |
+
 ### 轮次控制
 
 每只蚂蚁有严格的轮次预算，防止失控执行：
@@ -174,7 +183,7 @@ LLM 自行决定何时部署蚁群，你不需要操心：
 蚁群自动找到你机器的最优并行度：
 
 ```
-冷启动       →  1-2 只蚂蚁（保守）
+冷启动       →  ceil(max/2) 只蚂蚁（快速启动）
 探索阶段     →  每波 +1，监控吞吐量
 吞吐量下降   →  锁定最优值，稳定运行
 CPU > 85%   →  立即降低

package/dist/i18n.js

@@ -63,18 +63,12 @@ const messages = {
         "provider.detectedAddHint": "Configure additional providers",
         // preset
         "preset.select": "Choose a preset:",
-        "preset.starter": "🟢 Starter",
-        "preset.starterHint": "New to AI coding? Start here",
-        "preset.pro": "🔵 Pro Developer",
-        "preset.proHint": "Full-stack dev with all the bells and whistles",
-        "preset.security": "🟣 Security Researcher",
-        "preset.securityHint": "Pentesting, auditing, vulnerability research",
-        "preset.dataai": "🟠 Data & AI Engineer",
-        "preset.dataaiHint": "MLOps, data pipelines, AI applications",
-        "preset.minimal": "🔴 Minimal",
-        "preset.minimalHint": "Just the core, nothing extra",
         "preset.full": "⚫ Full Power",
-        "preset.fullHint": "Everything installed, ant colony included",
+        "preset.fullHint": "All features, extensions, and skills enabled",
+        "preset.clean": "✨ Clean",
+        "preset.cleanHint": "Minimal setup, just the essentials",
+        "preset.colony": "🐜 Colony",
+        "preset.colonyHint": "Ant swarm multi-agent system",
         // theme
         "theme.select": "Choose a theme:",
         // keybindings
@@ -199,18 +193,12 @@ const messages = {
         "provider.detectedAdd": "➕ 添加新 Provider",
         "provider.detectedAddHint": "配置额外的 Provider",
         "preset.select": "选择预设方案：",
-        "preset.starter": "🟢 入门",
-        "preset.starterHint": "AI 编程新手？从这里开始",
-        "preset.pro": "🔵 专业开发者",
-        "preset.proHint": "全栈开发，功能齐全",
-        "preset.security": "🟣 安全研究员",
-        "preset.securityHint": "渗透测试、审计、漏洞研究",
-        "preset.dataai": "🟠 数据与 AI 工程师",
-        "preset.dataaiHint": "MLOps、数据管道、AI 应用",
-        "preset.minimal": "🔴 极简",
-        "preset.minimalHint": "仅核心功能",
         "preset.full": "⚫ 全功能",
-        "preset.fullHint": "全部安装，含蚁群模式",
+        "preset.fullHint": "所有功能，包括蚁群系统",
+        "preset.clean": "🟢 简洁",
+        "preset.cleanHint": "核心功能，无蚁群",
+        "preset.colony": "🐜 蚁群",
+        "preset.colonyHint": "多 Agent 协同系统",
         "theme.select": "选择主题：",
         "kb.select": "快捷键方案：",
         "kb.default": "⌨️  默认",
@@ -328,18 +316,12 @@ const messages = {
         "provider.detectedAdd": "➕ Ajouter de nouveaux fournisseurs",
         "provider.detectedAddHint": "Configurer des fournisseurs supplémentaires",
         "preset.select": "Choisir un préréglage :",
-        "preset.starter": "🟢 Débutant",
-        "preset.starterHint": "Nouveau en codage IA ? Commencez ici",
-        "preset.pro": "🔵 Développeur Pro",
-        "preset.proHint": "Full-stack avec toutes les options",
-        "preset.security": "🟣 Chercheur en sécurité",
-        "preset.securityHint": "Pentest, audit, recherche de vulnérabilités",
-        "preset.dataai": "🟠 Ingénieur Data & IA",
-        "preset.dataaiHint": "MLOps, pipelines de données, applications IA",
-        "preset.minimal": "🔴 Minimal",
-        "preset.minimalHint": "Juste l'essentiel",
-        "preset.full": "⚫ Pleine puissance",
-        "preset.fullHint": "Tout installé, colonie de fourmis incluse",
+        "preset.full": "⚫ Complet",
+        "preset.fullHint": "Toutes les extensions et compétences",
+        "preset.clean": "🟢 Propre",
+        "preset.cleanHint": "Configuration minimale, aucune extension",
+        "preset.colony": "🐜 Colonie",
+        "preset.colonyHint": "Mode essaim multi-agent de fourmis",
         "theme.select": "Choisir un thème :",
         "kb.select": "Schéma de raccourcis :",
         "kb.default": "⌨️  Par défaut",

package/dist/tui/preset-select.js

@@ -1,55 +1,28 @@
 import * as p from "@clack/prompts";
 import { t } from "../i18n.js";
 const PRESETS = {
-    starter: {
-        labelKey: "preset.starter", hintKey: "preset.starterHint",
-        config: {
-            theme: "dark", keybindings: "default", thinking: "medium",
-            extensions: ["safe-guard", "git-guard", "auto-session-name", "custom-footer", "compact-header", "auto-update"],
-            prompts: ["review", "fix", "explain", "commit"],
-            agents: "general-developer",
-        },
-    },
-    pro: {
-        labelKey: "preset.pro", hintKey: "preset.proHint",
-        config: {
-            theme: "catppuccin-mocha", keybindings: "default", thinking: "high",
-            extensions: ["safe-guard", "git-guard", "auto-session-name", "custom-footer", "compact-header", "auto-update"],
-            prompts: ["review", "fix", "explain", "commit", "test", "refactor", "optimize", "document", "pr"],
-            agents: "fullstack-developer",
-        },
-    },
-    security: {
-        labelKey: "preset.security", hintKey: "preset.securityHint",
-        config: {
-            theme: "cyberpunk", keybindings: "default", thinking: "high",
-            extensions: ["safe-guard", "custom-footer", "compact-header", "auto-update"],
-            prompts: ["review", "security", "fix", "explain"],
-            agents: "security-researcher",
-        },
-    },
-    dataai: {
-        labelKey: "preset.dataai", hintKey: "preset.dataaiHint",
+    full: {
+        labelKey: "preset.full", hintKey: "preset.fullHint",
         config: {
-            theme: "tokyo-night", keybindings: "default", thinking: "medium",
-            extensions: ["safe-guard", "git-guard", "auto-session-name", "custom-footer", "compact-header", "auto-update"],
-            prompts: ["review", "fix", "explain", "optimize", "document", "test"],
-            agents: "data-ai-engineer",
+            theme: "dark", keybindings: "default", thinking: "high",
+            extensions: ["safe-guard", "git-guard", "auto-session-name", "custom-footer", "compact-header", "ant-colony", "auto-update", "bg-process"],
+            prompts: ["review", "fix", "explain", "commit", "test", "refactor", "optimize", "security", "document", "pr"],
+            agents: "colony-operator",
         },
     },
-    minimal: {
-        labelKey: "preset.minimal", hintKey: "preset.minimalHint",
+    clean: {
+        labelKey: "preset.clean", hintKey: "preset.cleanHint",
         config: {
             theme: "dark", keybindings: "default", thinking: "off",
             extensions: [], prompts: [], agents: "general-developer",
         },
     },
-    full: {
-        labelKey: "preset.full", hintKey: "preset.fullHint",
+    colony: {
+        labelKey: "preset.colony", hintKey: "preset.colonyHint",
         config: {
-            theme: "dark", keybindings: "default", thinking: "high",
-            extensions: ["safe-guard", "git-guard", "auto-session-name", "custom-footer", "compact-header", "ant-colony", "auto-update"],
-            prompts: ["review", "fix", "explain", "commit", "test", "refactor", "optimize", "security", "document", "pr"],
+            theme: "dark", keybindings: "default", thinking: "medium",
+            extensions: ["ant-colony", "auto-session-name", "compact-header"],
+            prompts: ["review", "fix", "explain", "commit"],
             agents: "colony-operator",
         },
     },

package/dist/types.js

@@ -49,6 +49,7 @@ export const EXTENSIONS = [
     { name: "compact-header", label: "⚡ Compact Header — Dense startup info replacing verbose output", default: true },
     { name: "ant-colony", label: "🐜 Ant Colony — Autonomous multi-agent swarm with adaptive concurrency", default: false },
     { name: "auto-update", label: "🔄 Auto Update — Check for oh-pi updates on startup and notify", default: true },
+    { name: "bg-process", label: "⏳ Bg Process — Auto-background long-running commands (dev servers, etc.)", default: false },
 ];
 /** 快捷键绑定方案（default / vim / emacs） */
 export const KEYBINDING_SCHEMES = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-pi",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "description": "One-click setup for pi-coding-agent. Like oh-my-zsh for pi.",
   "type": "module",
   "bin": {

package/pi-package/extensions/ant-colony/concurrency.ts

@@ -14,10 +14,10 @@ const CPU_CORES = os.cpus().length;
 
 export function defaultConcurrency(): ConcurrencyConfig {
   return {
-    current: 1,
+    current: 2,
     min: 1,
     max: Math.min(CPU_CORES, 8),
-    optimal: 2,
+    optimal: 3,
     history: [],
   };
 }
@@ -68,8 +68,8 @@ export function adapt(config: ConcurrencyConfig, pendingTasks: number): Concurre
   const taskCap = Math.min(pendingTasks, config.max);
 
   if (samples.length < 3) {
-    // 冷启动：保守起步
-    next.current = Math.min(2, taskCap);
+    // 冷启动：直接给一半 max，快速利用并发
+    next.current = Math.min(Math.ceil(config.max / 2), taskCap);
     return next;
   }
 

package/pi-package/extensions/ant-colony/index.ts

@@ -12,7 +12,7 @@
 import { readFileSync, appendFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Text, Container, Spacer } from "@mariozechner/pi-tui";
+import { Text, Container, Spacer, matchesKey } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { runColony, type QueenCallbacks } from "./queen.js";
 import type { ColonyState, ColonyMetrics, AntStreamEvent } from "./types.js";
@@ -46,30 +46,6 @@ function casteIcon(caste: string): string {
   return caste === "scout" ? "🔍" : caste === "soldier" ? "🛡️" : "⚒️";
 }
 
-function progressBar(done: number, total: number, width: number, theme: any): string {
-  if (total === 0) return "";
-  const pct = Math.min(done / total, 1);
-  const filled = Math.round(pct * width);
-  const empty = width - filled;
-  return theme.fg("success", "█".repeat(filled)) + theme.fg("muted", "░".repeat(empty)) + " " + theme.fg("accent", `${done}/${total}`);
-}
-
-function phasePipeline(status: string, theme: any): string {
-  const phases = [
-    { key: "scouting", icon: "🔍", label: "Scout" },
-    { key: "working", icon: "⚒️", label: "Work" },
-    { key: "reviewing", icon: "🛡️", label: "Review" },
-    { key: "done", icon: "✅", label: "Done" },
-  ];
-  const idx = phases.findIndex(p => p.key === status);
-  return phases.map((p, i) => {
-    const label = `${p.icon} ${p.label}`;
-    if (i < idx) return theme.fg("success", label);
-    if (i === idx) return theme.fg("accent", theme.bold(label));
-    return theme.fg("muted", label);
-  }).join(theme.fg("muted", " → "));
-}
-
 // ═══ Background colony state ═══
 
 interface AntStreamState {
@@ -94,64 +70,41 @@ export default function antColonyExtension(pi: ExtensionAPI) {
   // 当前运行中的后台蚁群（同时只允许一个）
   let activeColony: BackgroundColony | null = null;
 
-  // ─── Widget/Status 渲染 ───
+  // ─── Status 渲染 ───
 
   let lastRender = 0;
   const throttledRender = () => {
     const now = Date.now();
-    if (now - lastRender < 200) return;
+    if (now - lastRender < 500) return;
     lastRender = now;
-    renderWidget();
-    renderStatus();
+    pi.events.emit("ant-colony:render");
   };
 
-  const renderWidget = () => {
-    if (!activeColony) return;
-    const { state, phase, antStreams } = activeColony;
-    const streams = Array.from(antStreams.values());
-    const lines: string[] = [];
-
-    const elapsed = state ? formatDuration(Date.now() - state.createdAt) : "0s";
-    const cost = state ? formatCost(state.metrics.totalCost) : "$0";
-    lines.push(`🐜 Colony: ${phase} │ ${elapsed} │ ${cost}`);
-
-    if (state && state.metrics.tasksTotal > 0) {
-      const m = state.metrics;
-      const pct = Math.round((m.tasksDone / m.tasksTotal) * 100);
-      const filled = Math.round(pct / 5);
-      lines.push(`  ${"█".repeat(filled)}${"░".repeat(20 - filled)} ${m.tasksDone}/${m.tasksTotal} (${pct}%)`);
-    }
-
-    for (const s of streams.slice(-4)) {
-      const icon = casteIcon(s.caste);
-      const line = s.lastLine.length > 60 ? s.lastLine.slice(0, 57) + "..." : s.lastLine;
-      lines.push(`  ${icon} ${s.antId.slice(0, 15)} ▸ ${line || "..."}`);
-    }
-
-    pi.events.emit("ant-colony:widget", lines);
-  };
-
-  const renderStatus = () => {
-    if (!activeColony) return;
-    const { state, antStreams } = activeColony;
-    if (!state) return;
-    const m = state.metrics;
-    const active = antStreams.size;
-    pi.events.emit("ant-colony:status",
-      `🐜 ${statusIcon(state.status)} ${m.tasksDone}/${m.tasksTotal} tasks │ ${active} active │ ${formatCost(m.totalCost)}`
-    );
-  };
-
-  // 监听自己的事件来更新 UI（确保在有 ctx 的上下文中）
+  // 监听事件来更新 UI（确保在有 ctx 的上下文中）
   pi.on("session_start", async (_event, ctx) => {
-    pi.events.on("ant-colony:widget", (lines: string[]) => {
-      ctx.ui.setWidget("ant-colony", lines);
-    });
-    pi.events.on("ant-colony:status", (status: string) => {
-      ctx.ui.setStatus("ant-colony", status);
+    pi.events.on("ant-colony:render", () => {
+      if (!activeColony) return;
+      const { state, antStreams } = activeColony;
+      const active = antStreams.size;
+      const elapsed = state ? formatDuration(Date.now() - state.createdAt) : "0s";
+      const m = state?.metrics;
+      const colonyStatus = state?.status || "scouting";
+      const ants = state?.ants || [];
+      const turns = ants.reduce((s, a) => s + a.usage.turns, 0);
+      const outTok = ants.reduce((s, a) => s + a.usage.output, 0);
+
+      const parts = [`🐜 ${statusIcon(colonyStatus)}`];
+      if (m) parts.push(`${m.tasksDone}/${m.tasksTotal}`);
+      parts.push(`${active}⚡`);
+      parts.push(`${turns}↻`);
+      parts.push(formatTokens(outTok) + "↑");
+      if (m) parts.push(formatCost(m.totalCost));
+      parts.push(elapsed);
+
+      ctx.ui.setStatus("ant-colony", parts.join(" │ "));
     });
+
     pi.events.on("ant-colony:clear-ui", () => {
-      ctx.ui.setWidget("ant-colony", undefined);
       ctx.ui.setStatus("ant-colony", undefined);
     });
     pi.events.on("ant-colony:notify", (data: { msg: string; level: "info" | "success" | "warning" | "error" }) => {
@@ -361,7 +314,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       // 注入结果到对话
       pi.sendMessage({
         customType: "ant-colony-report",
-        content: report,
+        content: `[COLONY_SIGNAL:COMPLETE]\n${report}`,
         display: true,
       }, { triggerTurn: true, deliverAs: "followUp" });
 
@@ -373,6 +326,11 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       pi.events.emit("ant-colony:clear-ui");
       activeColony = null;
       pi.events.emit("ant-colony:notify", { msg: `🐜 Colony crashed: ${e}`, level: "error" });
+      pi.sendMessage({
+        customType: "ant-colony-report",
+        content: `[COLONY_SIGNAL:FAILED]\n## 🐜 Colony Crashed\n${e}`,
+        display: true,
+      }, { triggerTurn: true, deliverAs: "followUp" });
     });
   }
 
@@ -390,7 +348,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
     } catch { /* ignore */ }
 
     const colonyStatus = activeColony
-      ? `\n[COLONY RUNNING] A colony is already running in the background. Do NOT launch another. Use /colony-stop to cancel it first.`
+      ? `\n[COLONY_SIGNAL:RUNNING] A colony is currently running in the background for goal: "${activeColony.goal.slice(0, 100)}". Do NOT launch another colony. Do NOT check progress or assume failure. You will receive [COLONY_SIGNAL:COMPLETE] automatically when it finishes. If the user asks about colony status, tell them it's still running. Use /colony-stop to cancel.`
       : "";
 
     return {
@@ -405,8 +363,17 @@ You have the ant_colony tool. Use it automatically when:
 Do NOT ask for confirmation. Call ant_colony directly with a clear goal.
 For simple single-file tasks, work directly without the colony.
 
-The colony runs in the BACKGROUND — you can continue chatting while it works.
-Results are injected into the conversation when the colony finishes.
+[COLONY SIGNAL PROTOCOL]
+The colony communicates via signals. You MUST obey these:
+- [COLONY_SIGNAL:LAUNCHED] — Colony started. Do NOT poll, check, or assume failure. Wait for completion signal.
+- [COLONY_SIGNAL:RUNNING] — Colony is active. Do NOT launch another or check progress.
+- [COLONY_SIGNAL:COMPLETE] — Colony finished. Review the report and summarize results to the user.
+- [COLONY_SIGNAL:FAILED] — Colony crashed. Report the error to the user.
+
+After launching a colony, your ONLY correct behavior is:
+1. Tell the user the colony is running
+2. Continue chatting about OTHER topics if the user asks
+3. Wait for [COLONY_SIGNAL:COMPLETE] or [COLONY_SIGNAL:FAILED] — do NOT guess the outcome
 ${modelList ? `
 [COLONY MODEL SELECTION]
 Available models: ${modelList}
@@ -482,7 +449,7 @@ Strategy for choosing per-caste models:
       launchBackgroundColony(colonyParams);
 
       return {
-        content: [{ type: "text", text: `🐜 Colony launched in background!\n\n**Goal:** ${params.goal}\n\nThe colony is now running. You can continue chatting — results will be injected when it finishes.\n\nUse \`/colony-stop\` to cancel, \`/colony-status\` to check progress.` }],
+        content: [{ type: "text", text: `[COLONY_SIGNAL:LAUNCHED]\n🐜 Colony launched in background.\nGoal: ${params.goal}\n\n⚠️ IMPORTANT: The colony is now running autonomously. Do NOT check progress, do NOT ask about status, do NOT assume failure. You will receive a [COLONY_SIGNAL:COMPLETE] message automatically when it finishes. Continue chatting about other topics or wait silently.` }],
       };
     },
 
@@ -508,7 +475,7 @@ Strategy for choosing per-caste models:
       ));
       if (activeColony) {
         container.addChild(new Text(theme.fg("dim", `  Goal: ${activeColony.goal.slice(0, 70)}`), 0, 0));
-        container.addChild(new Text(theme.fg("muted", `  Use /colony-status or check the widget above`), 0, 0));
+        container.addChild(new Text(theme.fg("muted", `  Ctrl+Shift+A for details │ /colony-stop to cancel`), 0, 0));
       }
       return container;
     },
@@ -550,6 +517,99 @@ Strategy for choosing per-caste models:
     return container;
   });
 
+  // ═══ Shortcut: Ctrl+Shift+A 展开蚁群详情 ═══
+  pi.registerShortcut("ctrl+shift+a", {
+    description: "Show ant colony details",
+    async handler(ctx) {
+      if (!activeColony) {
+        ctx.ui.notify("No colony is currently running.", "info");
+        return;
+      }
+
+      await ctx.ui.custom<void>((tui, theme, _kb, done) => {
+        let cachedWidth: number | undefined;
+        let cachedLines: string[] | undefined;
+
+        const buildLines = (width: number): string[] => {
+          const c = activeColony;
+          if (!c) return [theme.fg("muted", "  No colony running.")];
+
+          const lines: string[] = [];
+          const w = width - 2; // padding
+
+          // ── Header ──
+          const elapsed = c.state ? formatDuration(Date.now() - c.state.createdAt) : "0s";
+          const cost = c.state ? formatCost(c.state.metrics.totalCost) : "$0";
+          lines.push(theme.fg("accent", theme.bold(`  🐜 Colony Details`)) + theme.fg("muted", ` │ ${elapsed} │ ${cost}`));
+          lines.push(theme.fg("dim", `  Goal: ${c.goal.slice(0, w - 8)}`));
+          lines.push("");
+
+          // ── Tasks ──
+          const tasks = c.state?.tasks || [];
+          if (tasks.length > 0) {
+            lines.push(theme.fg("accent", "  Tasks"));
+            for (const t of tasks.slice(0, 15)) {
+              const icon = t.status === "done" ? theme.fg("success", "✓")
+                : t.status === "failed" ? theme.fg("error", "✗")
+                : t.status === "active" ? theme.fg("warning", "●")
+                : theme.fg("dim", "○");
+              const dur = t.finishedAt && t.startedAt ? theme.fg("dim", ` ${formatDuration(t.finishedAt - t.startedAt)}`) : "";
+              lines.push(`  ${icon} ${casteIcon(t.caste)} ${theme.fg("text", t.title.slice(0, w - 12))}${dur}`);
+            }
+            if (tasks.length > 15) lines.push(theme.fg("muted", `  ⋯ +${tasks.length - 15} more`));
+            lines.push("");
+          }
+
+          // ── Active Ants ──
+          const streams = Array.from(c.antStreams.values());
+          if (streams.length > 0) {
+            lines.push(theme.fg("accent", "  Active Ants"));
+            for (const s of streams) {
+              const line = s.lastLine.length > w - 20 ? s.lastLine.slice(0, w - 23) + "..." : s.lastLine;
+              lines.push(`  ${casteIcon(s.caste)} ${theme.fg("accent", s.antId.slice(0, 14))} ${theme.fg("dim", `${s.tokens}tok`)} ${theme.fg("muted", "▸")} ${line}`);
+            }
+            lines.push("");
+          }
+
+          // ── Log (last 8) ──
+          if (c.log.length > 0) {
+            lines.push(theme.fg("accent", "  Log"));
+            for (const l of c.log.slice(-8)) {
+              lines.push(theme.fg("dim", `  ${l.slice(0, w - 2)}`));
+            }
+          }
+
+          lines.push("");
+          lines.push(theme.fg("muted", "  esc close"));
+          return lines;
+        };
+
+        // 定时刷新
+        const timer = setInterval(() => {
+          cachedWidth = undefined;
+          cachedLines = undefined;
+          tui.requestRender();
+        }, 1000);
+
+        return {
+          render(width: number): string[] {
+            if (cachedLines && cachedWidth === width) return cachedLines;
+            cachedLines = buildLines(width);
+            cachedWidth = width;
+            return cachedLines;
+          },
+          invalidate() { cachedWidth = undefined; cachedLines = undefined; },
+          handleInput(data: string) {
+            if (matchesKey(data, "escape")) {
+              clearInterval(timer);
+              done(undefined);
+            }
+          },
+        };
+      }, { overlay: true, overlayOptions: { anchor: "center", width: "80%", maxHeight: "80%" } });
+    },
+  });
+
   // ═══ Command: /colony-stop ═══
   pi.registerCommand("colony-stop", {
     description: "Stop the running background colony",

package/pi-package/extensions/ant-colony/nest.ts

@@ -21,6 +21,7 @@ export class Nest {
   private pheromoneCache: Pheromone[] = [];
   private pheromoneOffset: number = 0;
   private taskCache: Map<string, Task> = new Map();
+  private stateCache: ColonyState | null = null;
 
   constructor(private cwd: string, private colonyId: string) {
     this.dir = path.join(cwd, ".ant-colony", colonyId);
@@ -35,13 +36,16 @@ export class Nest {
 
   init(state: ColonyState): void {
     this.writeJson(this.stateFile, state);
+    this.stateCache = state;
     this.taskCache.clear();
     for (const t of state.tasks) this.writeTask(t);
   }
 
   getState(): ColonyState {
-    const base = this.readJson<ColonyState>(this.stateFile);
-    // 从 tasks/ 目录重建最新任务状态（原子性保证）
+    if (!this.stateCache) {
+      this.stateCache = this.readJson<ColonyState>(this.stateFile);
+    }
+    const base = { ...this.stateCache };
     base.tasks = this.getAllTasks();
     base.pheromones = this.getAllPheromones();
     return base;
@@ -49,9 +53,11 @@ export class Nest {
 
   updateState(patch: Partial<Pick<ColonyState, "status" | "concurrency" | "metrics" | "ants" | "finishedAt">>): void {
     this.withStateLock(() => {
-      const state = this.readJson<ColonyState>(this.stateFile);
-      Object.assign(state, patch);
-      this.writeJson(this.stateFile, state);
+      if (!this.stateCache) {
+        this.stateCache = this.readJson<ColonyState>(this.stateFile);
+      }
+      Object.assign(this.stateCache, patch);
+      this.writeJson(this.stateFile, this.stateCache);
     });
   }
 
@@ -186,11 +192,13 @@ export class Nest {
 
   updateAnt(ant: Ant): void {
     this.withStateLock(() => {
-      const state = this.readJson<ColonyState>(this.stateFile);
-      const idx = state.ants.findIndex(a => a.id === ant.id);
-      if (idx >= 0) state.ants[idx] = ant;
-      else state.ants.push(ant);
-      this.writeJson(this.stateFile, state);
+      if (!this.stateCache) {
+        this.stateCache = this.readJson<ColonyState>(this.stateFile);
+      }
+      const idx = this.stateCache.ants.findIndex(a => a.id === ant.id);
+      if (idx >= 0) this.stateCache.ants[idx] = ant;
+      else this.stateCache.ants.push(ant);
+      this.writeJson(this.stateFile, this.stateCache);
     });
   }
 
@@ -198,12 +206,14 @@ export class Nest {
 
   recordSample(sample: ConcurrencySample): void {
     this.withStateLock(() => {
-      const state = this.readJson<ColonyState>(this.stateFile);
-      state.concurrency.history.push(sample);
-      if (state.concurrency.history.length > 30) {
-        state.concurrency.history = state.concurrency.history.slice(-30);
+      if (!this.stateCache) {
+        this.stateCache = this.readJson<ColonyState>(this.stateFile);
+      }
+      this.stateCache.concurrency.history.push(sample);
+      if (this.stateCache.concurrency.history.length > 30) {
+        this.stateCache.concurrency.history = this.stateCache.concurrency.history.slice(-30);
       }
-      this.writeJson(this.stateFile, state);
+      this.writeJson(this.stateFile, this.stateCache);
     });
   }
 

package/pi-package/extensions/ant-colony/queen.ts

@@ -236,9 +236,9 @@ async function runAntWave(opts: WaveOptions): Promise<"ok"> {
       }
     }
 
-    // 自适应并发（每 5000ms 采样一次）
+    // 自适应并发（每 2000ms 采样一次）
     const now = Date.now();
-    if (now - lastSampleTime >= 5000) {
+    if (now - lastSampleTime >= 2000) {
       lastSampleTime = now;
       const completedRecently = state.tasks.filter(t =>
         t.status === "done" && t.finishedAt && t.finishedAt > now - 120000
@@ -260,7 +260,7 @@ async function runAntWave(opts: WaveOptions): Promise<"ok"> {
 
     if (slotsAvailable === 0) {
       // 等待一下再检查
-      await new Promise(r => setTimeout(r, 2000));
+      await new Promise(r => setTimeout(r, 500));
       continue;
     }
 
@@ -336,51 +336,39 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
   };
 
   try {
-    // ═══ Phase 1: 侦察（接力机制） ═══
-    let scoutAttempt = 0;
-    const MAX_SCOUT_RETRIES = 2;
-    let workerTasks: Task[] = [];
+    // ═══ Phase 1: 侦察（快速单次，不再多轮接力） ═══
+    callbacks.onPhase("scouting", "Dispatching scout ant to explore codebase...");
+    await runAntWave({ ...waveBase, caste: "scout" });
 
-    while (scoutAttempt <= MAX_SCOUT_RETRIES) {
-      callbacks.onPhase("scouting", scoutAttempt === 0
-        ? "Dispatching scout ants to explore codebase..."
-        : `Scout relay ${scoutAttempt}/${MAX_SCOUT_RETRIES} (building on previous discoveries)...`);
+    let workerTasks = nest.getAllTasks().filter(t => t.caste === "worker" && t.status === "pending");
 
+    // 只在完全没有 worker 任务时才重试一次
+    if (workerTasks.length === 0) {
+      const pheromones = nest.getAllPheromones();
+      const hasDiscoveries = pheromones.some(p => p.type === "discovery");
+      const relayTask: Task = {
+        id: makeTaskId(),
+        parentId: null,
+        title: "Scout relay: generate worker tasks",
+        description: hasDiscoveries
+          ? `Previous scout found information but didn't generate worker tasks. Generate concrete worker tasks based on discoveries.\n\nGoal:\n${opts.goal}`
+          : `Explore the codebase for this goal and generate worker tasks:\n\n${opts.goal}`,
+        caste: "scout",
+        status: "pending",
+        priority: 1,
+        files: [],
+        claimedBy: null,
+        result: null,
+        error: null,
+        spawnedTasks: [],
+        createdAt: Date.now(),
+        startedAt: null,
+        finishedAt: null,
+      };
+      nest.writeTask(relayTask);
+      callbacks.onPhase("scouting", "Scout relay: generating worker tasks...");
       await runAntWave({ ...waveBase, caste: "scout" });
-
       workerTasks = nest.getAllTasks().filter(t => t.caste === "worker" && t.status === "pending");
-      if (workerTasks.length > 0) break;
-
-      scoutAttempt++;
-      if (scoutAttempt <= MAX_SCOUT_RETRIES) {
-        // 接力：检查是否有信息素（前一只 scout 的部分发现）
-        const pheromones = nest.getAllPheromones();
-        const hasDiscoveries = pheromones.some(p => p.type === "discovery");
-
-        // 创建接力 scout 任务（而非重置旧任务）
-        const relayDescription = hasDiscoveries
-          ? `Continue exploring the codebase. Previous scouts made partial discoveries (see pheromone trail). Focus on areas NOT yet explored and generate worker tasks.\n\nOriginal goal:\n${opts.goal}`
-          : `Explore the codebase and identify all files, modules, and dependencies relevant to this goal:\n\n${opts.goal}\n\nBe thorough. The colony depends on your intelligence.`;
-
-        const relayTask: Task = {
-          id: makeTaskId(),
-          parentId: null,
-          title: hasDiscoveries ? "Scout relay: continue exploration" : "Scout: explore codebase for goal",
-          description: relayDescription,
-          caste: "scout",
-          status: "pending",
-          priority: 1,
-          files: [],
-          claimedBy: null,
-          result: null,
-          error: null,
-          spawnedTasks: [],
-          createdAt: Date.now(),
-          startedAt: null,
-          finishedAt: null,
-        };
-        nest.writeTask(relayTask);
-      }
     }
 
     if (workerTasks.length === 0) {

package/pi-package/extensions/bg-process.ts

@@ -0,0 +1,209 @@
+/**
+ * oh-pi Background Process Extension
+ *
+ * 任何 bash 命令超时未完成时，自动送到后台执行。
+ * 提供 bg_status 工具让 LLM 查看/停止后台进程。
+ */
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { StringEnum } from "@mariozechner/pi-ai";
+import { spawn, execSync } from "node:child_process";
+import { writeFileSync, readFileSync, existsSync } from "node:fs";
+
+/** 超时阈值（毫秒），超过此时间自动后台化 */
+const BG_TIMEOUT_MS = 10_000;
+
+interface BgProcess {
+  pid: number;
+  command: string;
+  logFile: string;
+  startedAt: number;
+}
+
+export default function (pi: ExtensionAPI) {
+  const bgProcesses = new Map<number, BgProcess>();
+
+  // 覆盖内置 bash 工具
+  pi.registerTool({
+    name: "bash",
+    label: "Bash",
+    description: `Execute a bash command. Output is truncated to 2000 lines or 50KB. If a command runs longer than ${BG_TIMEOUT_MS / 1000}s, it is automatically backgrounded and you get the PID + log file path. Use the bg_status tool to check on backgrounded processes.`,
+    parameters: Type.Object({
+      command: Type.String({ description: "Bash command to execute" }),
+      timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional)" })),
+    }),
+    async execute(toolCallId, params, signal) {
+      const { command } = params;
+      const userTimeout = params.timeout ? params.timeout * 1000 : undefined;
+      const effectiveTimeout = userTimeout ?? BG_TIMEOUT_MS;
+
+      return new Promise((resolve) => {
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+
+        const child = spawn("bash", ["-c", command], {
+          cwd: process.cwd(),
+          env: { ...process.env },
+          stdio: ["ignore", "pipe", "pipe"],
+        });
+
+        child.stdout?.on("data", (d: Buffer) => { stdout += d.toString(); });
+        child.stderr?.on("data", (d: Buffer) => { stderr += d.toString(); });
+
+        // 超时处理：分离进程，送到后台
+        const timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+
+          // 分离子进程，让它继续运行
+          child.stdout?.removeAllListeners();
+          child.stderr?.removeAllListeners();
+          child.removeAllListeners();
+          child.unref();
+
+          const logFile = `/tmp/oh-pi-bg-${Date.now()}.log`;
+          const pid = child.pid!;
+
+          // 启动一个 tail 进程把后续输出写入日志
+          try {
+            const tailCmd = `(echo ${JSON.stringify(stdout + stderr)}; tail --pid=${pid} -f /proc/${pid}/fd/1 2>/dev/null) > ${logFile} 2>&1 &`;
+            spawn("bash", ["-c", tailCmd], { detached: true, stdio: "ignore" }).unref();
+          } catch {
+            // fallback: 至少把已有输出写入日志
+            writeFileSync(logFile, stdout + stderr);
+          }
+
+          bgProcesses.set(pid, { pid, command, logFile, startedAt: Date.now() });
+
+          const preview = (stdout + stderr).slice(0, 500);
+          const text = `Command still running after ${effectiveTimeout / 1000}s, moved to background.\nPID: ${pid}\nLog: ${logFile}\nView output: tail -f ${logFile}\nStop: kill ${pid}\n\nOutput so far:\n${preview}`;
+
+          resolve({
+            content: [{ type: "text", text }],
+            details: {},
+          });
+        }, effectiveTimeout);
+
+        // 正常结束
+        child.on("close", (code) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+
+          const output = (stdout + stderr).trim();
+          const exitInfo = code !== 0 ? `\n[Exit code: ${code}]` : "";
+
+          resolve({
+            content: [{ type: "text", text: output + exitInfo }],
+            details: {},
+          });
+        });
+
+        child.on("error", (err) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+
+          resolve({
+            content: [{ type: "text", text: `Error: ${err.message}` }],
+            details: {},
+            isError: true,
+          });
+        });
+
+        // 处理 abort signal
+        if (signal) {
+          signal.addEventListener("abort", () => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            try { child.kill(); } catch {}
+            resolve({
+              content: [{ type: "text", text: "Command cancelled." }],
+              details: {},
+            });
+          }, { once: true });
+        }
+      });
+    },
+  });
+
+  // bg_status 工具：查看/管理后台进程
+  pi.registerTool({
+    name: "bg_status",
+    label: "Background Process Status",
+    description: "Check status, view output, or stop background processes that were auto-backgrounded.",
+    parameters: Type.Object({
+      action: StringEnum(["list", "log", "stop"] as const, { description: "list=show all, log=view output, stop=kill process" }),
+      pid: Type.Optional(Type.Number({ description: "PID of the process (required for log/stop)" })),
+    }),
+    async execute(toolCallId, params) {
+      const { action, pid } = params;
+
+      if (action === "list") {
+        if (bgProcesses.size === 0) {
+          return { content: [{ type: "text", text: "No background processes." }], details: {} };
+        }
+        const lines = [...bgProcesses.values()].map((p) => {
+          const alive = isAlive(p.pid);
+          const status = alive ? "🟢 running" : "⚪ stopped";
+          return `PID: ${p.pid} | ${status} | Log: ${p.logFile}\n  Cmd: ${p.command}`;
+        });
+        return { content: [{ type: "text", text: lines.join("\n\n") }], details: {} };
+      }
+
+      if (!pid) {
+        return { content: [{ type: "text", text: "Error: pid is required for log/stop" }], details: {}, isError: true };
+      }
+
+      const proc = bgProcesses.get(pid);
+
+      if (action === "log") {
+        const logFile = proc?.logFile;
+        if (logFile && existsSync(logFile)) {
+          try {
+            const content = readFileSync(logFile, "utf-8");
+            const tail = content.slice(-5000);
+            const truncated = content.length > 5000 ? `[...truncated, showing last 5000 chars]\n${tail}` : tail;
+            return { content: [{ type: "text", text: truncated || "(empty)" }], details: {} };
+          } catch (e: any) {
+            return { content: [{ type: "text", text: `Error reading log: ${e.message}` }], details: {}, isError: true };
+          }
+        }
+        // fallback: 直接读 /proc
+        try {
+          const out = execSync(`tail -20 /proc/${pid}/fd/1 2>/dev/null || echo "(cannot read output)"`, { timeout: 3000 }).toString();
+          return { content: [{ type: "text", text: out }], details: {} };
+        } catch {
+          return { content: [{ type: "text", text: "No log available for this PID." }], details: {} };
+        }
+      }
+
+      if (action === "stop") {
+        try {
+          process.kill(pid, "SIGTERM");
+          bgProcesses.delete(pid);
+          return { content: [{ type: "text", text: `Process ${pid} terminated.` }], details: {} };
+        } catch {
+          bgProcesses.delete(pid);
+          return { content: [{ type: "text", text: `Process ${pid} not found (already stopped?).` }], details: {} };
+        }
+      }
+
+      return { content: [{ type: "text", text: `Unknown action: ${action}` }], details: {}, isError: true };
+    },
+  });
+
+  // 清理：退出时杀掉所有后台进程
+  pi.on("session_shutdown", async () => {
+    for (const [pid] of bgProcesses) {
+      try { process.kill(pid, "SIGTERM"); } catch {}
+    }
+    bgProcesses.clear();
+  });
+}
+
+function isAlive(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}