oh-pi 0.1.75 → 0.1.77

package/README.fr.md

@@ -22,20 +22,28 @@ npx oh-pi
 
 ---
 
-## Pourquoi
-
-pi-coding-agent est puissant dès l'installation. Mais configurer manuellement les fournisseurs, thèmes, extensions, compétences et modèles de prompts est fastidieux. oh-pi offre une TUI moderne qui fait tout en moins d'une minute — et embarque un **essaim de fourmis** qui transforme pi en système multi-agents.
-
-## Démarrage rapide
+## Démarrage en 30 secondes
 
 ```bash
 npx oh-pi    # tout configurer
 pi           # commencer à coder
 ```
 
-C'est tout. oh-pi détecte votre environnement, vous guide dans la configuration et écrit `~/.pi/agent/` pour vous.
+oh-pi détecte automatiquement votre environnement, vous guide dans une TUI moderne, puis écrit `~/.pi/agent/`.
+
+Déjà configuré ? oh-pi détecte les fichiers existants et propose une **sauvegarde avant écrasement**.
+
+## Valeur en 2 minutes
+
+pi-coding-agent est puissant par défaut, mais la configuration manuelle (fournisseurs, thèmes, extensions, skills, prompts) prend du temps. oh-pi compresse cette phase en moins d'une minute — puis ajoute la colonie pour les tâches complexes.
+
+- [`docs/DEMO-SCRIPT.md`](./docs/DEMO-SCRIPT.md) — démo rapide en 2 minutes
+- [`ROADMAP.md`](./ROADMAP.md) — positionnement, jalons, métriques
+- [`DECISIONS.md`](./DECISIONS.md) — décisions produit et compromis techniques
+
+## Quand ne pas utiliser la colonie
 
-Vous avez déjà une config ? oh-pi la détecte et propose une **sauvegarde avant écrasement**.
+Utilisez le flux pi classique (sans colonie) si la tâche est petite, très exploratoire, ou nécessite un pilotage humain continu.
 
 ## Ce que vous obtenez
 
@@ -139,14 +147,19 @@ 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 :
+La colonie communique via des signaux structurés, pour éviter toute supposition côté modèle :
 
 | 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 |
+| `COLONY_SIGNAL:LAUNCHED` | Colonie démarrée en arrière-plan |
+| `COLONY_SIGNAL:SCOUTING` | Vague d'éclaireuses en exploration/planification |
+| `COLONY_SIGNAL:PLANNING_RECOVERY` | Boucle de récupération du plan en cours |
+| `COLONY_SIGNAL:WORKING` | Exécution des tâches par les ouvrières |
+| `COLONY_SIGNAL:REVIEWING` | Revue qualité par les soldats |
+| `COLONY_SIGNAL:TASK_DONE` | Tâche terminée (jalon de progression) |
+| `COLONY_SIGNAL:COMPLETE` | Mission terminée, rapport injecté |
+| `COLONY_SIGNAL:FAILED` | Mission échouée avec diagnostic |
+| `COLONY_SIGNAL:BUDGET_EXCEEDED` | Budget maximal atteint |
 
 ### Contrôle des tours
 

package/README.md

@@ -22,20 +22,28 @@ npx oh-pi
 
 ---
 
-## Why
-
-pi-coding-agent is powerful out of the box. But configuring providers, themes, extensions, skills, and prompts by hand is tedious. oh-pi gives you a modern TUI that does it all in under a minute — and ships an **ant colony swarm** that turns pi into a multi-agent system.
-
-## Quick Start
+## 30-Second Start
 
 ```bash
 npx oh-pi    # configure everything
 pi           # start coding
 ```
 
-That's it. oh-pi detects your environment, walks you through setup, and writes `~/.pi/agent/` for you.
+oh-pi auto-detects your environment, guides setup in a modern TUI, and writes `~/.pi/agent/` for you.
+
+Already configured? It detects existing files and offers **backup before overwriting**.
+
+## 2-Minute Value
+
+pi-coding-agent is powerful by default, but manual setup across providers, themes, extensions, skills, and prompts is slow. oh-pi compresses that setup into under a minute — then adds an **ant colony swarm** for multi-agent execution.
+
+Want the fast walkthrough? See [`docs/DEMO-SCRIPT.md`](./docs/DEMO-SCRIPT.md).
 
-Already have a config? oh-pi detects it and offers **backup before overwriting**.
+## When Not to Use Ant Colony
+
+Use plain pi workflows (without colony) when your task is tiny, highly exploratory, or needs constant human steering.
+
+For positioning, scope, and milestones, see [`ROADMAP.md`](./ROADMAP.md). For rationale behind key trade-offs, see [`DECISIONS.md`](./DECISIONS.md).
 
 ## What You Get
 
@@ -96,6 +104,16 @@ oh-pi:
   ✅ Done — report auto-injected into conversation
 ```
 
+### What's new in v0.1.75
+
+- **Planning Recovery Loop**: if scouts return unstructured intel, colony enters `planning_recovery` instead of failing immediately.
+- **Plan Validation Gate**: before workers start, tasks are validated (title/description/caste/priority).
+- **Scout Quorum for complex goals**: multi-step goals default to at least 2 scouts for better planning reliability.
+
+### Colony lifecycle (simple)
+
+`SCOUTING → (if needed) PLANNING_RECOVERY → WORKING → REVIEWING → DONE`
+
 ### Architecture
 
 Each ant is an in-process `AgentSession` (pi SDK), not a child process:
@@ -139,14 +157,19 @@ 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:
+The colony communicates with the main conversation via structured signals, so the model never has to guess background state. Updates are passively pushed (non-blocking), so polling is optional:
 
 | 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 |
+| `COLONY_SIGNAL:LAUNCHED` | Colony started in background |
+| `COLONY_SIGNAL:SCOUTING` | Scout wave is exploring / planning |
+| `COLONY_SIGNAL:PLANNING_RECOVERY` | Plan recovery loop is restructuring tasks |
+| `COLONY_SIGNAL:WORKING` | Worker phase is executing tasks |
+| `COLONY_SIGNAL:REVIEWING` | Soldier review phase is active |
+| `COLONY_SIGNAL:TASK_DONE` | A task finished (progress checkpoint) |
+| `COLONY_SIGNAL:COMPLETE` | Colony finished and report injected |
+| `COLONY_SIGNAL:FAILED` | Colony failed with diagnostics |
+| `COLONY_SIGNAL:BUDGET_EXCEEDED` | Budget limit reached |
 
 ### Turn Control
 

package/README.zh.md

@@ -22,20 +22,34 @@ npx oh-pi
 
 ---
 
-## 为什么
-
-pi-coding-agent 开箱即用很强大，但手动配置提供商、主题、扩展、技能和提示词模板很繁琐。oh-pi 提供现代化 TUI，一分钟内搞定一切 —— 还附带一个**蚁群系统**，把 pi 变成多智能体平台。
-
-## 快速开始
+## 30 秒上手
 
 ```bash
 npx oh-pi    # 配置一切
 pi           # 开始编码
 ```
 
-就这样。oh-pi 检测你的环境，引导你完成设置，自动写入 `~/.pi/agent/`。
+就这样。oh-pi 会自动检测环境、引导配置，并写入 `~/.pi/agent/`。
+
+已有配置？会先备份，再覆盖。
+
+## 2 分钟看懂价值
+
+oh-pi 把原本分散且手工的配置流程（提供商、主题、扩展、技能、提示词模板）整合成一次引导，通常 1 分钟内完成。
+
+当任务涉及多文件或可并行流程时，可启用蚁群系统，把 pi 升级为可协作的多智能体执行流。
+
+- [`docs/DEMO-SCRIPT.zh.md`](./docs/DEMO-SCRIPT.zh.md) — 2 分钟演示脚本（价值与节奏）
+- [`ROADMAP.md`](./ROADMAP.md) — 定位、里程碑与衡量指标
+- [`DECISIONS.md`](./DECISIONS.md) — 阶段性关键决策与取舍依据
 
-已有配置？oh-pi 会检测到并提供**覆盖前备份**。
+## 何时不该用蚁群
+
+以下场景建议**不要**启用蚁群，直接单代理更快：
+
+- 只改 1 个文件、改动范围明确
+- 快速问答、解释代码、一次性小修复
+- 你需要严格串行控制每一步修改
 
 ## 你会得到
 
@@ -96,6 +110,16 @@ oh-pi:
   ✅ 完成 — 报告自动注入对话
 ```
 
+### v0.1.75 更新亮点
+
+- **Planning Recovery 回路**：当 scout 产出非结构化情报时，进入 `planning_recovery`，而不是直接失败。
+- **执行前计划校验**：worker 启动前会校验任务字段完整性（title/description/caste/priority）。
+- **复杂目标 Scout Quorum**：多步骤目标默认至少 2 个 scout，提升规划可靠性。
+
+### 生命周期（简化）
+
+`SCOUTING →（必要时）PLANNING_RECOVERY → WORKING → REVIEWING → DONE`
+
 ### 架构
 
 每只蚂蚁是进程内的 `AgentSession`（pi SDK），而非子进程：
@@ -139,14 +163,19 @@ pi（主进程）
 
 ### 信号协议
 
-蚁群通过结构化信号与主对话通信，防止 LLM 轮询或猜测蚁群状态：
+蚁群通过结构化信号与主对话通信，让模型无需猜测后台状态。更新采用被动推送（非阻塞），轮询仅在手动排障时需要：
 
 | 信号 | 含义 |
 |------|------|
-| `COLONY_SIGNAL:LAUNCHED` | 蚁群已启动 — 不要轮询 |
-| `COLONY_SIGNAL:RUNNING` | 蚁群运行中 — 每轮注入 |
-| `COLONY_SIGNAL:COMPLETE` | 蚁群完成 — 查看报告 |
-| `COLONY_SIGNAL:FAILED` | 蚁群崩溃 — 报告错误 |
+| `COLONY_SIGNAL:LAUNCHED` | 蚁群已在后台启动 |
+| `COLONY_SIGNAL:SCOUTING` | 侦察波次正在探索/规划 |
+| `COLONY_SIGNAL:PLANNING_RECOVERY` | 计划恢复回路正在重组任务 |
+| `COLONY_SIGNAL:WORKING` | 工蚁执行阶段进行中 |
+| `COLONY_SIGNAL:REVIEWING` | 兵蚁审查阶段进行中 |
+| `COLONY_SIGNAL:TASK_DONE` | 单个任务完成（进度检查点） |
+| `COLONY_SIGNAL:COMPLETE` | 蚁群完成并注入报告 |
+| `COLONY_SIGNAL:FAILED` | 蚁群失败并附带诊断信息 |
+| `COLONY_SIGNAL:BUDGET_EXCEEDED` | 达到预算上限 |
 
 ### 轮次控制
 

package/dist/index.js

@@ -43,7 +43,7 @@ async function quickFlow(env) {
         providers,
         theme: "dark",
         keybindings: "default",
-        extensions: ["safe-guard", "git-guard", "auto-session-name", "custom-footer", "compact-header", "auto-update", "smart-compact"],
+        extensions: ["safe-guard", "git-guard", "auto-session-name", "custom-footer", "compact-header", "auto-update"],
         prompts: ["review", "fix", "explain", "commit", "test"],
         agents: "general-developer",
         thinking: "medium",

package/dist/registry.js

@@ -49,7 +49,6 @@ 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: "smart-compact", label: "🗜️  Smart Compact — Trim large tool outputs and old messages in-flight", default: true },
     { name: "bg-process", label: "⏳ Bg Process — Auto-background long-running commands (dev servers, etc.)", default: false },
 ];
 /** 快捷键绑定方案（default / vim / emacs） */

package/package.json

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

package/pi-package/agents/colony-operator.md

@@ -17,8 +17,9 @@ You command an autonomous ant colony. Complex tasks are delegated to the swarm,
 ## Workflow
 1. Assess task scope
 2. If colony-worthy → use `ant_colony` tool with clear goal
-3. If simple → do it directly
-4. Review colony output, fix gaps manually if needed
+3. After launch, use passive mode: wait for `COLONY_SIGNAL:*` updates; do not poll `bg_colony_status` unless user explicitly asks
+4. If simple → do it directly
+5. Review colony output, fix gaps manually if needed
 
 ## Code Standards
 - Follow existing conventions

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

@@ -18,7 +18,7 @@ import { runColony, resumeColony, type QueenCallbacks } from "./queen.js";
 import { Nest } from "./nest.js";
 import type { ColonyState, ColonyMetrics, AntStreamEvent } from "./types.js";
 
-import { formatDuration, formatCost, formatTokens, statusIcon, casteIcon, buildReport } from "./ui.js";
+import { formatDuration, formatCost, formatTokens, statusIcon, statusLabel, progressBar, casteIcon, buildReport } from "./ui.js";
 
 // ═══ Background colony state ═══
 
@@ -38,12 +38,19 @@ interface AntStreamState {
   tokens: number;
 }
 
+interface ColonyLogEntry {
+  timestamp: number;
+  level: "info" | "warning" | "error";
+  text: string;
+}
+
 interface BackgroundColony {
   goal: string;
   abortController: AbortController;
   state: ColonyState | null;
   phase: string;
   antStreams: Map<string, AntStreamState>;
+  logs: ColonyLogEntry[];
   promise: Promise<ColonyState>;
 }
 
@@ -52,6 +59,56 @@ export default function antColonyExtension(pi: ExtensionAPI) {
   // 当前运行中的后台蚁群（同时只允许一个）
   let activeColony: BackgroundColony | null = null;
 
+  // 防止主进程主动轮询导致阻塞：仅允许显式请求的手动快照，并加冷却
+  let lastBgStatusSnapshotAt = 0;
+  const STATUS_SNAPSHOT_COOLDOWN_MS = 15_000;
+
+  const extractMessageText = (message: any): string => {
+    const c = message?.content;
+    if (typeof c === "string") return c;
+    if (Array.isArray(c)) {
+      return c.map((p: any) => {
+        if (typeof p === "string") return p;
+        if (typeof p?.text === "string") return p.text;
+        if (typeof p?.content === "string") return p.content;
+        return "";
+      }).join("\n");
+    }
+    return "";
+  };
+
+  const lastUserMessageText = (ctx: any): string => {
+    try {
+      const branch = ctx?.sessionManager?.getBranch?.() ?? [];
+      for (let i = branch.length - 1; i >= 0; i--) {
+        const e = branch[i];
+        if (e?.type === "message" && e.message?.role === "user") {
+          return extractMessageText(e.message).trim();
+        }
+      }
+    } catch {
+      // ignore
+    }
+    return "";
+  };
+
+  const isExplicitStatusRequest = (ctx: any): boolean => {
+    const text = lastUserMessageText(ctx);
+    return /(?:\/colony-status|bg_colony_status)|(?:(?:蚁群|colony).{0,20}(?:状态|进度|进展|汇报|快照|status|progress|snapshot|update|check))|(?:(?:状态|进度|进展|汇报|快照|status|progress|snapshot|update|check).{0,20}(?:蚁群|colony))/i.test(text);
+  };
+
+  const calcProgress = (m?: ColonyMetrics | null) => {
+    if (!m || m.tasksTotal <= 0) return 0;
+    return Math.max(0, Math.min(1, m.tasksDone / m.tasksTotal));
+  };
+
+  const trim = (text: string, max: number) => text.length > max ? `${text.slice(0, Math.max(0, max - 1))}…` : text;
+
+  const pushLog = (colony: BackgroundColony, entry: Omit<ColonyLogEntry, "timestamp">) => {
+    colony.logs.push({ timestamp: Date.now(), ...entry });
+    if (colony.logs.length > 40) colony.logs.splice(0, colony.logs.length - 40);
+  };
+
   // ─── Status 渲染 ───
 
   let lastRender = 0;
@@ -78,10 +135,14 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       const { state } = activeColony;
       const elapsed = state ? formatDuration(Date.now() - state.createdAt) : "0s";
       const m = state?.metrics;
-      const colonyStatus = state?.status || "scouting";
-
-      const parts = [`🐜 ${statusIcon(colonyStatus)}`];
-      if (m) parts.push(`${m.tasksDone}/${m.tasksTotal}`);
+      const phase = state?.status || "scouting";
+      const progress = calcProgress(m);
+      const pct = `${Math.round(progress * 100)}%`;
+      const active = activeColony.antStreams.size;
+
+      const parts = [`🐜 ${statusIcon(phase)} ${statusLabel(phase)}`];
+      parts.push(m ? `${m.tasksDone}/${m.tasksTotal} (${pct})` : `0/0 (${pct})`);
+      parts.push(`⚡${active}`);
       if (m) parts.push(formatCost(m.totalCost));
       parts.push(elapsed);
 
@@ -162,9 +223,12 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       state: null,
       phase: "initializing",
       antStreams: new Map(),
+      logs: [],
       promise: null as any, // set below
     };
 
+    pushLog(colony, { level: "info", text: "INITIALIZING · Colony launched in background" });
+
     let lastPhase = "";
 
     const callbacks: QueenCallbacks = {
@@ -174,6 +238,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
         if (signal.phase !== lastPhase) {
           lastPhase = signal.phase;
           const pct = Math.round(signal.progress * 100);
+          pushLog(colony, { level: "info", text: `${statusLabel(signal.phase)} ${pct}% · ${signal.message}` });
           pi.sendMessage({
             customType: "ant-colony-progress",
             content: `[COLONY_SIGNAL:${signal.phase.toUpperCase()}] 🐜 ${signal.message} (${pct}%, ${formatCost(signal.cost)})`,
@@ -184,6 +249,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       },
       onPhase(phase, detail) {
         colony.phase = detail;
+        pushLog(colony, { level: "info", text: `${statusLabel(phase)} · ${detail}` });
         throttledRender();
       },
       onAntSpawn(ant, task) {
@@ -199,6 +265,10 @@ export default function antColonyExtension(pi: ExtensionAPI) {
         const icon = ant.status === "done" ? "✓" : "✗";
         const progress = m ? `${m.tasksDone}/${m.tasksTotal}` : "";
         const cost = m ? formatCost(m.totalCost) : "";
+        pushLog(colony, {
+          level: ant.status === "done" ? "info" : "warning",
+          text: `${icon} ${task.title.slice(0, 80)} (${progress}${cost ? `, ${cost}` : ""})`,
+        });
         pi.sendMessage({
           customType: "ant-colony-progress",
           content: `[COLONY_SIGNAL:TASK_DONE] 🐜 ${icon} ${task.title.slice(0, 60)} (${progress}, ${cost})`,
@@ -221,6 +291,10 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       onComplete(state) {
         colony.state = state;
         colony.phase = state.status === "done" ? "Colony mission complete" : "Colony failed";
+        pushLog(colony, {
+          level: state.status === "done" ? "info" : "error",
+          text: `${statusLabel(state.status)} · ${state.metrics.tasksDone}/${state.metrics.tasksTotal} · ${formatCost(state.metrics.totalCost)}`,
+        });
         colony.antStreams.clear();
         throttledRender();
       },
@@ -244,6 +318,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
     colony.promise = resume ? resumeColony(colonyOpts) : runColony(colonyOpts);
 
     activeColony = colony;
+    lastBgStatusSnapshotAt = 0;
     throttledRender();
 
     // 后台等待完成，注入结果
@@ -251,6 +326,10 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       const ok = state.status === "done";
       const report = buildReport(state);
       const m = state.metrics;
+      pushLog(colony, {
+        level: ok ? "info" : "error",
+        text: `${ok ? "COMPLETE" : "FAILED"} · ${m.tasksDone}/${m.tasksTotal} · ${formatCost(m.totalCost)}`,
+      });
 
       // 清理 UI
       pi.events.emit("ant-colony:clear-ui");
@@ -268,6 +347,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
         level: ok ? "success" : "error",
       });
     }).catch((e) => {
+      pushLog(colony, { level: "error", text: `CRASHED · ${String(e).slice(0, 120)}` });
       pi.events.emit("ant-colony:clear-ui");
       activeColony = null;
       pi.events.emit("ant-colony:notify", { msg: `🐜 Colony crashed: ${e}`, level: "error" });
@@ -283,6 +363,29 @@ export default function antColonyExtension(pi: ExtensionAPI) {
 
 
 
+  // ═══ Custom message renderer for colony progress signals ═══
+  pi.registerMessageRenderer("ant-colony-progress", (message, theme) => {
+    const content = typeof message.content === "string" ? message.content : "";
+    const line = content.split("\n")[0] || content;
+    const phaseMatch = line.match(/\[COLONY_SIGNAL:([A-Z_]+)\]/);
+    const text = line.replace(/\[COLONY_SIGNAL:[A-Z_]+\]\s*/, "").trim();
+
+    const phase = phaseMatch?.[1]?.toLowerCase() || "working";
+    const icon = statusIcon(phase);
+    const label = statusLabel(phase);
+
+    const body = trim(text, 120);
+    const coloredBody = phase === "failed"
+      ? theme.fg("error", body)
+      : phase === "budget_exceeded"
+        ? theme.fg("warning", body)
+        : phase === "done" || phase === "complete"
+          ? theme.fg("success", body)
+          : theme.fg("muted", body);
+
+    return new Text(`${icon} ${theme.fg("toolTitle", theme.bold(label))} ${coloredBody}`, 0, 0);
+  });
+
   // ═══ Custom message renderer for colony reports ═══
   pi.registerMessageRenderer("ant-colony-report", (message, theme) => {
     const content = typeof message.content === "string" ? message.content : "";
@@ -304,7 +407,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
     const taskLines = content.split("\n").filter(l => l.startsWith("- ✓") || l.startsWith("- ✗"));
     for (const l of taskLines.slice(0, 8)) {
       const icon = l.startsWith("- ✓") ? theme.fg("success", "✓") : theme.fg("error", "✗");
-      container.addChild(new Text(`  ${icon} ${theme.fg("dim", l.slice(4).trim().slice(0, 70))}`, 0, 0));
+      container.addChild(new Text(`  ${icon} ${theme.fg("muted", l.slice(4).trim().slice(0, 70))}`, 0, 0));
     }
     if (taskLines.length > 8) {
       container.addChild(new Text(theme.fg("muted", `  ⋯ +${taskLines.length - 8} more`), 0, 0));
@@ -331,6 +434,8 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       await ctx.ui.custom<void>((tui, theme, _kb, done) => {
         let cachedWidth: number | undefined;
         let cachedLines: string[] | undefined;
+        let currentTab: "tasks" | "streams" | "log" = "tasks";
+        let taskFilter: "all" | "active" | "done" | "failed" = "all";
 
         const buildLines = (width: number): string[] => {
           const c = activeColony;
@@ -341,36 +446,121 @@ export default function antColonyExtension(pi: ExtensionAPI) {
 
           // ── Header ──
           const elapsed = c.state ? formatDuration(Date.now() - c.state.createdAt) : "0s";
-          const cost = c.state ? formatCost(c.state.metrics.totalCost) : "$0";
+          const m = c.state?.metrics;
+          const phase = c.state?.status || "scouting";
+          const progress = calcProgress(m);
+          const pct = Math.round(progress * 100);
+          const cost = m ? formatCost(m.totalCost) : "$0";
+          const activeAnts = c.antStreams.size;
+          const barWidth = Math.max(10, Math.min(24, w - 28));
+
           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(theme.fg("muted", `  Goal: ${trim(c.goal, w - 8)}`));
+          lines.push(`  ${statusIcon(phase)} ${theme.bold(statusLabel(phase))} │ ${m ? `${m.tasksDone}/${m.tasksTotal}` : "0/0"} │ ${pct}% │ ⚡${activeAnts}`);
+          lines.push(theme.fg("muted", `  ${progressBar(progress, barWidth)} ${pct}%`));
+          if (c.phase && c.phase !== "initializing") {
+            lines.push(theme.fg("muted", `  Phase: ${trim(c.phase, w - 10)}`));
+          }
+          lines.push("");
+
+          // ── Tabs ──
+          const tabs: Array<{ key: "tasks" | "streams" | "log"; hotkey: string; label: string }> = [
+            { key: "tasks", hotkey: "1", label: "Tasks" },
+            { key: "streams", hotkey: "2", label: "Streams" },
+            { key: "log", hotkey: "3", label: "Log" },
+          ];
+          const tabLine = tabs.map((t) => {
+            const label = `[${t.hotkey}] ${t.label}`;
+            return currentTab === t.key ? theme.fg("accent", theme.bold(label)) : theme.fg("muted", label);
+          }).join("  ");
+          lines.push(`  ${tabLine}`);
           lines.push("");
 
-          // ── Tasks ──
           const tasks = c.state?.tasks || [];
-          if (tasks.length > 0) {
+          const streams = Array.from(c.antStreams.values());
+
+          // ── Tab: Tasks ──
+          if (currentTab === "tasks") {
+            const counts = {
+              done: tasks.filter(t => t.status === "done").length,
+              active: tasks.filter(t => t.status === "active").length,
+              failed: tasks.filter(t => t.status === "failed").length,
+              pending: tasks.filter(t => t.status === "pending" || t.status === "claimed" || t.status === "blocked").length,
+            };
             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}`);
+            lines.push(theme.fg("muted", `  done:${counts.done} │ active:${counts.active} │ pending:${counts.pending} │ failed:${counts.failed}`));
+            lines.push(theme.fg("muted", "  Filter: [0] all  [a] active  [d] done  [f] failed"));
+            lines.push(theme.fg("muted", `  Current filter: ${taskFilter.toUpperCase()}`));
+            lines.push("");
+
+            const filtered = tasks.filter(t =>
+              taskFilter === "all" ? true :
+                taskFilter === "active" ? t.status === "active" :
+                  taskFilter === "done" ? t.status === "done" :
+                    t.status === "failed"
+            );
+
+            if (filtered.length === 0) {
+              lines.push(theme.fg("muted", "  (no tasks match current filter)"));
+            } else {
+              for (const t of filtered.slice(0, 16)) {
+                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", trim(t.title, w - 12))}${dur}`);
+              }
+              if (filtered.length > 16) lines.push(theme.fg("muted", `  ⋯ +${filtered.length - 16} more`));
             }
-            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: ${streams.length} ants working`));
+          // ── Tab: Streams ──
+          if (currentTab === "streams") {
+            lines.push(theme.fg("accent", `  Active Ant Streams (${streams.length})`));
+            lines.push(theme.fg("muted", "  Shows latest line + token count for active ants"));
+            lines.push("");
+            if (streams.length === 0) {
+              lines.push(theme.fg("muted", "  (no active streams right now)"));
+            } else {
+              for (const s of streams.slice(0, 10)) {
+                const excerpt = trim((s.lastLine || "...").replace(/\s+/g, " "), Math.max(20, w - 24));
+                lines.push(`  ${casteIcon(s.caste)} ${theme.fg("muted", s.antId.slice(0, 12))} ${theme.fg("muted", `${formatTokens(s.tokens)}t`)} ${theme.fg("text", excerpt)}`);
+              }
+              if (streams.length > 10) lines.push(theme.fg("muted", `  ⋯ +${streams.length - 10} more streams`));
+            }
             lines.push("");
           }
 
-          lines.push("");
-          lines.push(theme.fg("muted", "  esc close"));
+          // ── Tab: Log ──
+          if (currentTab === "log") {
+            const failedTasks = tasks.filter(t => t.status === "failed");
+            if (failedTasks.length > 0) {
+              lines.push(theme.fg("warning", `  Warnings (${failedTasks.length})`));
+              for (const t of failedTasks.slice(0, 4)) {
+                lines.push(`  ${theme.fg("error", "✗")} ${theme.fg("text", trim(t.title, w - 8))}`);
+              }
+              if (failedTasks.length > 4) lines.push(theme.fg("muted", `  ⋯ +${failedTasks.length - 4} more failed tasks`));
+              lines.push("");
+            }
+
+            const recentLogs = c.logs.slice(-12);
+            lines.push(theme.fg("accent", "  Recent Signals"));
+            if (recentLogs.length === 0) {
+              lines.push(theme.fg("muted", "  (no signal logs yet)"));
+            } else {
+              const now = Date.now();
+              for (const log of recentLogs) {
+                const age = formatDuration(Math.max(0, now - log.timestamp));
+                const levelIcon = log.level === "error" ? theme.fg("error", "✗") : log.level === "warning" ? theme.fg("warning", "!") : theme.fg("muted", "•");
+                lines.push(`  ${levelIcon} ${theme.fg("muted", age)} ${theme.fg("text", trim(log.text, w - 12))}`);
+              }
+            }
+            lines.push("");
+          }
+
+          lines.push(theme.fg("muted", "  [1/2/3] switch tabs │ [0/a/d/f] task filter │ esc close"));
           return lines;
         };
 
@@ -395,7 +585,21 @@ export default function antColonyExtension(pi: ExtensionAPI) {
             if (matchesKey(data, "escape")) {
               cleanup();
               done(undefined);
+              return;
             }
+
+            if (data === "1") currentTab = "tasks";
+            else if (data === "2") currentTab = "streams";
+            else if (data === "3") currentTab = "log";
+            else if (data === "0") taskFilter = "all";
+            else if (data.toLowerCase() === "a") taskFilter = "active";
+            else if (data.toLowerCase() === "d") taskFilter = "done";
+            else if (data.toLowerCase() === "f") taskFilter = "failed";
+            else return;
+
+            cachedWidth = undefined;
+            cachedLines = undefined;
+            tui.requestRender();
           },
         };
       }, { overlay: true, overlayOptions: { anchor: "center", width: "80%", maxHeight: "80%" } });
@@ -462,7 +666,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       launchBackgroundColony(colonyParams);
 
       return {
-        content: [{ type: "text", text: `[COLONY_SIGNAL:LAUNCHED]\n🐜 Colony launched in background.\nGoal: ${params.goal}\n\nThe colony is now running autonomously. Results will be injected when it finishes.` }],
+        content: [{ type: "text", text: `[COLONY_SIGNAL:LAUNCHED]\n🐜 Colony launched in background.\nGoal: ${params.goal}\n\nThe colony runs autonomously in passive mode. Progress is pushed via [COLONY_SIGNAL:*] follow-up messages. Do not poll bg_colony_status unless the user explicitly asks for a manual snapshot.` }],
       };
     },
 
@@ -471,7 +675,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       let text = theme.fg("toolTitle", theme.bold("🐜 ant_colony"));
       if (args.maxAnts) text += theme.fg("muted", ` ×${args.maxAnts}`);
       if (args.maxCost) text += theme.fg("warning", ` $${args.maxCost}`);
-      text += "\n" + theme.fg("dim", `  ${goal || "..."}`);
+      text += "\n" + theme.fg("muted", `  ${goal || "..."}`);
       return new Text(text, 0, 0);
     },
 
@@ -486,7 +690,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
         0, 0,
       ));
       if (activeColony) {
-        container.addChild(new Text(theme.fg("dim", `  Goal: ${activeColony.goal.slice(0, 70)}`), 0, 0));
+        container.addChild(new Text(theme.fg("muted", `  Goal: ${activeColony.goal.slice(0, 70)}`), 0, 0));
         container.addChild(new Text(theme.fg("muted", `  Ctrl+Shift+A for details │ /colony-stop to cancel`), 0, 0));
       }
       return container;
@@ -502,12 +706,19 @@ export default function antColonyExtension(pi: ExtensionAPI) {
     const elapsed = state ? formatDuration(Date.now() - state.createdAt) : "0s";
     const m = state?.metrics;
     const phase = state?.status || "scouting";
+    const progress = calcProgress(m);
+    const pct = Math.round(progress * 100);
+    const activeAnts = c.antStreams.size;
 
     const lines: string[] = [
-      `🐜 ${statusIcon(phase)} ${c.goal.slice(0, 80)}`,
-      `${phase} │ ${m ? `${m.tasksDone}/${m.tasksTotal} tasks` : "starting"} │ ${m ? formatCost(m.totalCost) : "$0"} │ ${elapsed}`,
+      `🐜 ${statusIcon(phase)} ${trim(c.goal, 80)}`,
+      `${statusLabel(phase)} │ ${m ? `${m.tasksDone}/${m.tasksTotal} tasks` : "starting"} │ ${pct}% │ ⚡${activeAnts} │ ${m ? formatCost(m.totalCost) : "$0"} │ ${elapsed}`,
+      `${progressBar(progress, 18)} ${pct}%`,
     ];
 
+    if (c.phase && c.phase !== "initializing") lines.push(`Phase: ${trim(c.phase, 100)}`);
+    const lastLog = c.logs[c.logs.length - 1];
+    if (lastLog) lines.push(`Last: ${trim(lastLog.text, 100)}`);
     if (m && m.tasksFailed > 0) lines.push(`⚠ ${m.tasksFailed} failed`);
 
     return lines.join("\n");
@@ -517,9 +728,40 @@ export default function antColonyExtension(pi: ExtensionAPI) {
   pi.registerTool({
     name: "bg_colony_status",
     label: "Colony Status",
-    description: "Check the status of a running background ant colony. Use this instead of bg_status to monitor colony progress.",
+    description: "Optional manual snapshot for a running colony. Progress is pushed passively via COLONY_SIGNAL follow-up messages; call this only when the user explicitly asks.",
     parameters: Type.Object({}),
-    async execute() {
+    async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+      if (!activeColony) {
+        return {
+          content: [{ type: "text" as const, text: "No colony is currently running." }],
+        };
+      }
+
+      const explicit = isExplicitStatusRequest(ctx);
+      if (!explicit) {
+        return {
+          content: [{
+            type: "text" as const,
+            text: "Passive mode is active. Colony progress is already pushed via [COLONY_SIGNAL:*] follow-up messages. Skipping bg_colony_status polling to avoid blocking the main process. Ask explicitly for a manual snapshot if needed.",
+          }],
+          isError: true,
+        };
+      }
+
+      const now = Date.now();
+      const delta = now - lastBgStatusSnapshotAt;
+      if (delta < STATUS_SNAPSHOT_COOLDOWN_MS) {
+        const waitSec = Math.ceil((STATUS_SNAPSHOT_COOLDOWN_MS - delta) / 1000);
+        return {
+          content: [{
+            type: "text" as const,
+            text: `Manual status snapshot is rate-limited. Please wait ${waitSec}s to avoid active polling loops.`,
+          }],
+          isError: true,
+        };
+      }
+
+      lastBgStatusSnapshotAt = now;
       return {
         content: [{ type: "text" as const, text: buildStatusText() }],
       };

package/pi-package/extensions/ant-colony/ui.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { formatDuration, formatCost, formatTokens, statusIcon, casteIcon, buildReport } from "./ui.js";
+import { formatDuration, formatCost, formatTokens, statusIcon, statusLabel, progressBar, casteIcon, buildReport } from "./ui.js";
 import type { ColonyState } from "./types.js";
 
 describe("formatDuration", () => {
@@ -25,16 +25,33 @@ describe("formatTokens", () => {
 });
 
 describe("statusIcon", () => {
+  it("launched", () => expect(statusIcon("launched")).toBe("🚀"));
   it("scouting", () => expect(statusIcon("scouting")).toBe("🔍"));
   it("working", () => expect(statusIcon("working")).toBe("⚒️"));
   it("planning_recovery", () => expect(statusIcon("planning_recovery")).toBe("♻️"));
   it("reviewing", () => expect(statusIcon("reviewing")).toBe("🛡️"));
+  it("task_done", () => expect(statusIcon("task_done")).toBe("✅"));
   it("done", () => expect(statusIcon("done")).toBe("✅"));
   it("failed", () => expect(statusIcon("failed")).toBe("❌"));
   it("budget_exceeded", () => expect(statusIcon("budget_exceeded")).toBe("💰"));
   it("unknown", () => expect(statusIcon("xyz")).toBe("🐜"));
 });
 
+describe("statusLabel", () => {
+  it("launched", () => expect(statusLabel("launched")).toBe("LAUNCHED"));
+  it("scouting", () => expect(statusLabel("scouting")).toBe("SCOUTING"));
+  it("planning_recovery", () => expect(statusLabel("planning_recovery")).toBe("PLANNING_RECOVERY"));
+  it("task_done", () => expect(statusLabel("task_done")).toBe("TASK_DONE"));
+  it("budget_exceeded", () => expect(statusLabel("budget_exceeded")).toBe("BUDGET_EXCEEDED"));
+  it("unknown", () => expect(statusLabel("custom")).toBe("CUSTOM"));
+});
+
+describe("progressBar", () => {
+  it("0%", () => expect(progressBar(0, 10)).toBe("[----------]"));
+  it("50%", () => expect(progressBar(0.5, 10)).toBe("[#####-----]"));
+  it("100%", () => expect(progressBar(1, 10)).toBe("[##########]"));
+});
+
 describe("casteIcon", () => {
   it("scout", () => expect(casteIcon("scout")).toBe("🔍"));
   it("soldier", () => expect(casteIcon("soldier")).toBe("🛡️"));

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

@@ -17,12 +17,42 @@ export function formatTokens(n: number): string {
 
 export function statusIcon(status: string): string {
   const icons: Record<string, string> = {
-    scouting: "🔍", planning_recovery: "♻️", working: "⚒️", reviewing: "🛡️",
-    done: "✅", failed: "❌", budget_exceeded: "💰",
+    launched: "🚀",
+    scouting: "🔍",
+    planning_recovery: "♻️",
+    working: "⚒️",
+    reviewing: "🛡️",
+    task_done: "✅",
+    done: "✅",
+    complete: "✅",
+    failed: "❌",
+    budget_exceeded: "💰",
   };
   return icons[status] || "🐜";
 }
 
+export function statusLabel(status: string): string {
+  const labels: Record<string, string> = {
+    launched: "LAUNCHED",
+    scouting: "SCOUTING",
+    planning_recovery: "PLANNING_RECOVERY",
+    working: "WORKING",
+    reviewing: "REVIEWING",
+    task_done: "TASK_DONE",
+    done: "DONE",
+    complete: "COMPLETE",
+    failed: "FAILED",
+    budget_exceeded: "BUDGET_EXCEEDED",
+  };
+  return labels[status] || status.toUpperCase();
+}
+
+export function progressBar(progress: number, width = 14): string {
+  const p = Math.max(0, Math.min(1, Number.isFinite(progress) ? progress : 0));
+  const filled = Math.round(width * p);
+  return `[${"#".repeat(filled)}${"-".repeat(Math.max(0, width - filled))}]`;
+}
+
 export function casteIcon(caste: string): string {
   return caste === "scout" ? "🔍" : caste === "soldier" ? "🛡️" : caste === "drone" ? "⚙️" : "⚒️";
 }

package/pi-package/extensions/smart-compact.test.ts

@@ -1,64 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { truncateText, compactContent } from "./smart-compact";
-
-const longMultiline = (lines: number, lineLen = 100) =>
-  Array.from({ length: lines }, (_, i) => "x".repeat(lineLen) + i).join("\n");
-
-describe("truncateText", () => {
-  it("short text returns unchanged", () => {
-    expect(truncateText("hello", 8000)).toBe("hello");
-  });
-
-  it("few lines but long chars returns unchanged", () => {
-    const text = "x".repeat(9000) + "\n" + "y".repeat(9000);
-    expect(truncateText(text, 8000)).toBe(text);
-  });
-
-  it("long text with many lines gets truncated", () => {
-    const text = longMultiline(200);
-    const result = truncateText(text, 8000);
-    expect(result).toContain("[...truncated");
-  });
-
-  it("preserves head and tail", () => {
-    const text = longMultiline(200);
-    const result = truncateText(text, 8000);
-    expect(result.startsWith(text.slice(0, 1500))).toBe(true);
-    expect(result.endsWith(text.slice(-2500))).toBe(true);
-  });
-
-  it("custom head/tail params work", () => {
-    const text = longMultiline(200);
-    const result = truncateText(text, 100, 50, 50);
-    expect(result).toContain("[...truncated");
-    expect(result.startsWith(text.slice(0, 50))).toBe(true);
-    expect(result.endsWith(text.slice(-50))).toBe(true);
-  });
-});
-
-describe("compactContent", () => {
-  it("short string returns unchanged", () => {
-    expect(compactContent("short")).toBe("short");
-  });
-
-  it("long string gets truncated", () => {
-    const text = longMultiline(200);
-    expect(compactContent(text)).toContain("[...truncated");
-  });
-
-  it("array text block gets truncated", () => {
-    const text = longMultiline(200);
-    const result = compactContent([{ type: "text", text }]);
-    expect(result[0].text).toContain("[...truncated");
-  });
-
-  it("array non-text block returned unchanged", () => {
-    const block = { type: "image", url: "x" };
-    expect(compactContent([block])).toEqual([block]);
-  });
-
-  it("non-array non-string returned as-is", () => {
-    expect(compactContent(42)).toBe(42);
-    expect(compactContent({ a: 1 })).toEqual({ a: 1 });
-  });
-});

package/pi-package/extensions/smart-compact.ts

@@ -1,89 +0,0 @@
-/**
- * 智能压缩扩展 — 在发送给 LLM 前裁剪大块内容
- *
- * 策略：
- * 1. 工具输出超过阈值 → 保留首尾，中间替换为 "[...truncated N lines]"
- * 2. 用户粘贴的大块文本 → 同上
- * 3. 越旧的消息裁剪越激进
- */
-
-const MAX_TOOL_OUTPUT_CHARS = 8000;
-const MAX_USER_BLOCK_CHARS = 12000;
-const KEEP_HEAD = 1500;
-const KEEP_TAIL = 2500;
-
-export function truncateText(text: string, max: number, head = KEEP_HEAD, tail = KEEP_TAIL): string {
-  if (text.length <= max) return text;
-  const lines = text.split("\n");
-  if (lines.length <= 10) return text; // 短文本不裁
-  const headText = text.slice(0, head);
-  const tailText = text.slice(-tail);
-  const removedLines = text.slice(head, -tail).split("\n").length;
-  return `${headText}\n\n[...truncated ${removedLines} lines...]\n\n${tailText}`;
-}
-
-export function compactContent(content: any): any {
-  if (typeof content === "string") {
-    return truncateText(content, MAX_TOOL_OUTPUT_CHARS);
-  }
-  if (!Array.isArray(content)) return content;
-  return content.map((block: any) => {
-    if (block.type === "text" && typeof block.text === "string") {
-      return { ...block, text: truncateText(block.text, MAX_TOOL_OUTPUT_CHARS) };
-    }
-    return block;
-  });
-}
-
-export default function smartCompact(pi: any) {
-  pi.on("context", async (event: any) => {
-    const messages = event.messages;
-    if (!messages || messages.length < 4) return; // 太短不处理
-
-    // 只处理非最近 3 条消息（保留最近上下文完整）
-    const cutoff = messages.length - 3;
-
-    for (let i = 0; i < cutoff; i++) {
-      const msg = messages[i];
-      if (!msg) continue;
-
-      if (msg.role === "toolResult") {
-        msg.content = compactContent(msg.content);
-      } else if (msg.role === "user") {
-        // 用户消息用更宽松的阈值
-        if (typeof msg.content === "string" && msg.content.length > MAX_USER_BLOCK_CHARS) {
-          msg.content = truncateText(msg.content, MAX_USER_BLOCK_CHARS);
-        } else if (Array.isArray(msg.content)) {
-          msg.content = msg.content.map((block: any) => {
-            if (block.type === "text" && typeof block.text === "string" && block.text.length > MAX_USER_BLOCK_CHARS) {
-              return { ...block, text: truncateText(block.text, MAX_USER_BLOCK_CHARS) };
-            }
-            return block;
-          });
-        }
-      } else if (msg.role === "assistant" && Array.isArray(msg.content)) {
-        // 裁剪 assistant 的大块工具调用参数
-        msg.content = msg.content.map((block: any) => {
-          if (block.type === "toolCall" && block.arguments) {
-            const args = JSON.stringify(block.arguments);
-            if (args.length > MAX_TOOL_OUTPUT_CHARS) {
-              try {
-                const parsed = typeof block.arguments === "string" ? JSON.parse(block.arguments) : block.arguments;
-                // 裁剪大字符串参数
-                for (const key of Object.keys(parsed)) {
-                  if (typeof parsed[key] === "string" && parsed[key].length > MAX_TOOL_OUTPUT_CHARS) {
-                    parsed[key] = truncateText(parsed[key], MAX_TOOL_OUTPUT_CHARS);
-                  }
-                }
-                return { ...block, arguments: parsed };
-              } catch { return block; }
-            }
-          }
-          return block;
-        });
-      }
-    }
-
-    return { messages };
-  });
-}