oh-pi 0.1.74 → 0.1.75

package/package.json

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

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

@@ -81,6 +81,39 @@ describe("parseSubTasks", () => {
     const tasks = parseSubTasks(output);
     expect(tasks[0].context).toBeTruthy();
   });
+
+  it("parses chinese task format with full-width colon", () => {
+    const output = `### 任务：生成重启检查报告
+- 描述：创建重启检查文档
+- 文件：docs/ant-colony-restart-check.md
+- 角色：worker
+- 优先级：1`;
+    const tasks = parseSubTasks(output);
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].title).toContain("重启检查报告");
+    expect(tasks[0].files).toEqual(["docs/ant-colony-restart-check.md"]);
+    expect(tasks[0].caste).toBe("worker");
+    expect(tasks[0].priority).toBe(1);
+  });
+
+  it("does not infer tasks from plain next-step narrative", () => {
+    const output = `目前发现如下\n\n下一步我会继续定位：
+- 写入 docs/ant-colony-restart-check.md
+- 校验 src/index.ts 的入口流程`;
+    const tasks = parseSubTasks(output);
+    expect(tasks).toEqual([]);
+  });
+
+  it("parses bold markdown field keys", () => {
+    const output = `### TASK: Harden parser
+- **description**: support bold fields
+- **files**: pi-package/extensions/ant-colony/parser.ts
+- **caste**: worker
+- **priority**: 2`;
+    const tasks = parseSubTasks(output);
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].files).toEqual(["pi-package/extensions/ant-colony/parser.ts"]);
+  });
 });
 
 describe("extractPheromones", () => {

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

@@ -2,6 +2,7 @@ import type { AntCaste, Pheromone, PheromoneType } from "./types.js";
 import { makePheromoneId } from "./spawner.js";
 
 const VALID_CASTES = new Set(["scout", "worker", "soldier", "drone"]);
+const TASK_HEADER_RE = /^\s*#{2,6}\s*(?:task|任务)\s*[：:]\s*(.+?)\s*$/i;
 
 export interface ParsedSubTask {
   title: string;
@@ -12,44 +13,138 @@ export interface ParsedSubTask {
   context?: string;
 }
 
+function normalizePriority(v: unknown): 1 | 2 | 3 | 4 | 5 {
+  const n = parseInt(String(v ?? "3"), 10);
+  return Math.min(5, Math.max(1, Number.isNaN(n) ? 3 : n)) as 1 | 2 | 3 | 4 | 5;
+}
+
+function normalizeCaste(v: unknown): AntCaste {
+  const raw = String(v ?? "worker").trim().toLowerCase();
+  if (VALID_CASTES.has(raw)) return raw as AntCaste;
+  if (raw.includes("侦察") || raw.includes("scout")) return "scout";
+  if (raw.includes("工") || raw.includes("worker")) return "worker";
+  if (raw.includes("兵") || raw.includes("review") || raw.includes("soldier")) return "soldier";
+  if (raw.includes("drone") || raw.includes("bash") || raw.includes("shell")) return "drone";
+  return "worker";
+}
+
+function extractFileLike(value: string): string[] {
+  const normalized = value.replace(/[，、；;]/g, ",").replace(/["']/g, "").replace(/`/g, "");
+  const tokens = normalized.split(",").map(s => s.trim()).filter(Boolean);
+  const fileish = tokens
+    .map(t => t.replace(/^\.?\//, ""))
+    .filter(t => /[./\\]/.test(t) || /\.[a-z0-9]+$/i.test(t));
+  return [...new Set(fileish)];
+}
+
+function normalizeJsonTasks(parsed: unknown): ParsedSubTask[] {
+  const arr = (Array.isArray(parsed) ? parsed : [parsed]) as Array<Record<string, unknown>>;
+  return arr.map((t) => ({
+    title: String(t.title || "Untitled"),
+    description: String(t.description || t.title || ""),
+    files: Array.isArray(t.files)
+      ? t.files.map(String).map(f => f.trim()).filter(Boolean)
+      : extractFileLike(String(t.files || "")),
+    caste: normalizeCaste(t.caste),
+    priority: normalizePriority(t.priority),
+    context: t.context ? String(t.context) : undefined,
+  }));
+}
+
+function parseTasksFromStructuredLines(output: string): ParsedSubTask[] {
+  const lines = output.split(/\r?\n/);
+  const tasks: ParsedSubTask[] = [];
+
+  let current: ParsedSubTask | null = null;
+
+  const flushCurrent = () => {
+    if (!current) return;
+    current.title = current.title.trim() || "Untitled";
+    current.description = current.description.trim() || current.title;
+    current.files = [...new Set(current.files.map(f => f.trim()).filter(Boolean))];
+    current.priority = normalizePriority(current.priority);
+    current.caste = normalizeCaste(current.caste);
+    if (current.context) current.context = current.context.trim();
+    tasks.push(current);
+    current = null;
+  };
+
+  const fieldMatch = (line: string) => {
+    return line.match(/^\s*(?:[-*]|\d+\.)?\s*(?:\*\*|__)?\s*(description|desc|描述|说明|files?|文件|路径|caste|role|角色|priority|prio|优先级|context|上下文)\s*(?:\*\*|__)?\s*[：:]\s*(.*)$/i);
+  };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    const header = line.match(TASK_HEADER_RE);
+    if (header) {
+      flushCurrent();
+      current = {
+        title: header[1]?.trim() || "Untitled",
+        description: "",
+        files: [],
+        caste: "worker",
+        priority: 3,
+      };
+      continue;
+    }
+
+    if (!current) continue;
+
+    const m = fieldMatch(line);
+    if (!m) continue;
+
+    const key = m[1].toLowerCase();
+    const value = (m[2] || "").trim();
+
+    if (["description", "desc", "描述", "说明"].includes(key)) {
+      current.description = value;
+      continue;
+    }
+
+    if (["files", "file", "文件", "路径"].includes(key)) {
+      current.files.push(...extractFileLike(value));
+      continue;
+    }
+
+    if (["caste", "role", "角色"].includes(key)) {
+      current.caste = normalizeCaste(value);
+      continue;
+    }
+
+    if (["priority", "prio", "优先级"].includes(key)) {
+      current.priority = normalizePriority(value);
+      continue;
+    }
+
+    if (["context", "上下文"].includes(key)) {
+      const contextLines = [value];
+      while (i + 1 < lines.length) {
+        const next = lines[i + 1];
+        if (TASK_HEADER_RE.test(next) || fieldMatch(next)) break;
+        if (/^\s*#{1,6}\s+/.test(next)) break;
+        contextLines.push(next);
+        i++;
+      }
+      current.context = contextLines.join("\n").trim();
+    }
+  }
+
+  flushCurrent();
+  return tasks;
+}
+
 export function parseSubTasks(output: string): ParsedSubTask[] {
-  // Try JSON block first
-  const jsonMatch = output.match(/```json\s*([\s\S]*?)```/);
+  // 1) JSON fenced block
+  const jsonMatch = output.match(/```json\s*([\s\S]*?)```/i);
   if (jsonMatch?.[1]) {
     try {
-      const parsed = JSON.parse(jsonMatch[1].trim());
-      const arr = Array.isArray(parsed) ? parsed : [parsed];
-      return arr.map((t: Record<string, unknown>) => ({
-        title: String(t.title || "Untitled"),
-        description: String(t.description || t.title || ""),
-        files: Array.isArray(t.files) ? t.files.map(String) : String(t.files || "").split(",").map((f: string) => f.trim()).filter(Boolean),
-        caste: (VALID_CASTES.has(String(t.caste)) ? String(t.caste) : "worker") as AntCaste,
-        priority: (Math.min(5, Math.max(1, parseInt(String(t.priority || "3")))) as 1 | 2 | 3 | 4 | 5),
-        context: t.context ? String(t.context) : undefined,
-      }));
-    } catch { /* fallback to regex */ }
+      return normalizeJsonTasks(JSON.parse(jsonMatch[1].trim()));
+    } catch { /* fallback */ }
   }
 
-  // Fallback: regex parsing with per-task try-catch
-  const tasks: ParsedSubTask[] = [];
-  const regex = /### TASK:\s*(.+)\n(?:- description:\s*(.+)\n)?(?:- files:\s*(.+)\n)?(?:- caste:\s*(\w+)\n)?(?:- priority:\s*(\d))?/g;
-  const taskBlocks = output.split(/(?=### TASK:)/);
-  for (const m of output.matchAll(regex)) {
-    try {
-      const block = taskBlocks.find(b => b.includes(`### TASK: ${m[1]?.trim()}`)) || "";
-      const ctxMatch = block.match(/- context:\s*([\s\S]*?)(?=### TASK:|## |\n\n|$)/);
-      const context = ctxMatch?.[1]?.trim() || undefined;
-      tasks.push({
-        title: m[1]?.trim() || "Untitled",
-        description: m[2]?.trim() || m[1]?.trim() || "",
-        files: (m[3]?.trim() || "").split(",").map((f: string) => f.trim()).filter(Boolean),
-        caste: (VALID_CASTES.has(m[4]?.trim() ?? "") ? m[4]!.trim() : "worker") as AntCaste,
-        priority: (parseInt(m[5] || "3") as 1 | 2 | 3 | 4 | 5) || 3,
-        context,
-      });
-    } catch { /* skip malformed task, continue */ }
-  }
-  return tasks;
+  // 2) Structured markdown task blocks (English/Chinese)
+  return parseTasksFromStructuredLines(output);
 }
 
 export function extractPheromones(antId: string, caste: AntCaste, taskId: string, output: string, files: string[], failed = false): Pheromone[] {

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

@@ -13,7 +13,7 @@ vi.mock("@mariozechner/pi-coding-agent", () => ({
 }));
 vi.mock("@mariozechner/pi-ai", () => ({ getModel: vi.fn() }));
 
-import { classifyError, quorumMergeTasks } from "./queen.js";
+import { classifyError, quorumMergeTasks, shouldUseScoutQuorum, validateExecutionPlan } from "./queen.js";
 import { Nest } from "./nest.js";
 import type { ColonyState, Task } from "./types.js";
 
@@ -69,6 +69,40 @@ describe("classifyError", () => {
   });
 });
 
+describe("shouldUseScoutQuorum", () => {
+  it("returns true for multi-step goals", () => {
+    expect(shouldUseScoutQuorum("1) scan repo; 2) write report; 3) review output")).toBe(true);
+  });
+
+  it("returns false for simple single-step goals", () => {
+    expect(shouldUseScoutQuorum("List top-level files")).toBe(false);
+  });
+});
+
+describe("validateExecutionPlan", () => {
+  it("accepts well-formed worker tasks", () => {
+    const plan = validateExecutionPlan([
+      mkTask({ id: "t-plan-1", caste: "worker", title: "Do x", description: "desc", priority: 1, files: ["a.ts"] }),
+    ]);
+    expect(plan.ok).toBe(true);
+    expect(plan.issues).toEqual([]);
+  });
+
+  it("rejects empty plans", () => {
+    const plan = validateExecutionPlan([]);
+    expect(plan.ok).toBe(false);
+    expect(plan.issues).toContain("no_pending_worker_tasks");
+  });
+
+  it("flags non-worker cates as invalid for execution phase", () => {
+    const plan = validateExecutionPlan([
+      mkTask({ id: "t-plan-2", caste: "scout" as any }),
+    ]);
+    expect(plan.ok).toBe(false);
+    expect(plan.issues.some(i => i.includes("invalid_caste"))).toBe(true);
+  });
+});
+
 // ═══ quorumMergeTasks ═══
 
 const mkState = (overrides: Partial<ColonyState> = {}): ColonyState => ({

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

@@ -136,6 +136,88 @@ export function quorumMergeTasks(nest: Nest): void {
   }
 }
 
+export interface PlanValidation {
+  ok: boolean;
+  issues: string[];
+  warnings: string[];
+}
+
+export function shouldUseScoutQuorum(goal: string): boolean {
+  // 多步骤/复合目标更适合至少 2 个 Scout 投票
+  return /(\n\s*\d+[\.)]|[;；]| and |以及|并且|同时|步骤|phase|then|之后)/i.test(goal);
+}
+
+export function validateExecutionPlan(tasks: Task[]): PlanValidation {
+  const issues: string[] = [];
+  const warnings: string[] = [];
+
+  if (tasks.length === 0) {
+    issues.push("no_pending_worker_tasks");
+    return { ok: false, issues, warnings };
+  }
+
+  for (const t of tasks) {
+    if (!t.title?.trim()) issues.push(`task:${t.id}:missing_title`);
+    if (!t.description?.trim()) issues.push(`task:${t.id}:missing_description`);
+    if (t.caste !== "worker" && t.caste !== "drone") issues.push(`task:${t.id}:invalid_caste:${t.caste}`);
+    if (t.priority < 1 || t.priority > 5) issues.push(`task:${t.id}:invalid_priority:${t.priority}`);
+    if (t.files.length === 0) warnings.push(`task:${t.id}:broad_scope`);
+  }
+
+  return { ok: issues.length === 0, issues, warnings };
+}
+
+function collectScoutIntelligence(nest: Nest, maxChars = 6000): string {
+  const scoutResults = nest.getAllTasks()
+    .filter(t => t.caste === "scout" && t.status === "done" && t.result)
+    .map(t => `## ${t.title}\n${t.result}`)
+    .join("\n\n");
+  return scoutResults.slice(0, maxChars);
+}
+
+function makeRecoveryScoutTask(goal: string, attempt: number, planIssues: string[], intel: string): Task {
+  const issueText = planIssues.length > 0 ? planIssues.map(i => `- ${i}`).join("\n") : "- no parseable worker/drone tasks generated";
+  return {
+    id: makeTaskId(),
+    parentId: null,
+    title: `Scout recovery ${attempt}: structure executable plan`,
+    description: [
+      "Previous scout output could not pass plan validation.",
+      "Transform existing intelligence into a VALID structured execution plan.",
+      "",
+      "Goal:",
+      goal,
+      "",
+      "Validation issues:",
+      issueText,
+      "",
+      "Intelligence from prior scouts:",
+      intel || "(none)",
+      "",
+      "Output requirements (STRICT):",
+      "- Return at least ONE task block",
+      "### TASK: <title>",
+      "- description: <what to do>",
+      "- files: <comma-separated file paths>",
+      "- caste: worker",
+      "- priority: <1-5>",
+      "",
+      "Do NOT execute changes. Only planning.",
+    ].join("\n"),
+    caste: "scout",
+    status: "pending",
+    priority: 1,
+    files: [],
+    claimedBy: null,
+    result: null,
+    error: null,
+    spawnedTasks: [],
+    createdAt: Date.now(),
+    startedAt: null,
+    finishedAt: null,
+  };
+}
+
 function makeReviewTask(completedTasks: Task[]): Task {
   const files = [...new Set(completedTasks.flatMap(t => t.files))];
   return {
@@ -530,7 +612,8 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
 
   try {
     // ═══ Phase 1: 侦察（Bio 5: 蚁群投票 — 复杂目标派多 Scout） ═══
-    const scoutCount = opts.goal.length > 500 ? 3 : opts.goal.length > 200 ? 2 : 1;
+    const scoutCountBase = opts.goal.length > 500 ? 3 : opts.goal.length > 200 ? 2 : 1;
+    const scoutCount = shouldUseScoutQuorum(opts.goal) ? Math.max(2, scoutCountBase) : scoutCountBase;
     if (scoutCount > 1) {
       // 多 Scout 并行：为每只 Scout 创建独立任务
       for (let i = 1; i < scoutCount; i++) {
@@ -561,43 +644,36 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
     // Bio 5: 合并多 Scout 产生的重复任务
     if (scoutCount > 1) quorumMergeTasks(nest);
 
-    let workerTasks = nest.getAllTasks().filter(t => (t.caste === "worker" || t.caste === "drone") && 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...");
-      emitSignal("scouting", "Retrying scout...");
+    const getPendingExecutionTasks = () => nest.getAllTasks().filter(t => (t.caste === "worker" || t.caste === "drone") && t.status === "pending");
+
+    let workerTasks = getPendingExecutionTasks();
+    let plan = validateExecutionPlan(workerTasks);
+
+    // 计划恢复回路：Scout 输出不可执行时，不直接造 Worker，先让 Scout 结构化重组
+    const MAX_PLAN_RECOVERY_ROUNDS = 2;
+    let recoveryRound = 0;
+    while (!plan.ok && recoveryRound < MAX_PLAN_RECOVERY_ROUNDS) {
+      recoveryRound++;
+      nest.updateState({ status: "planning_recovery" });
+
+      const intel = collectScoutIntelligence(nest);
+      const recoveryTask = makeRecoveryScoutTask(opts.goal, recoveryRound, plan.issues, intel);
+      nest.writeTask(recoveryTask);
+
+      callbacks.onPhase?.("planning_recovery", `Plan recovery ${recoveryRound}/${MAX_PLAN_RECOVERY_ROUNDS}: restructuring scout intelligence...`);
+      emitSignal("planning_recovery", `Recovering plan (${recoveryRound}/${MAX_PLAN_RECOVERY_ROUNDS})`);
       await runAntWave({ ...waveBase, caste: "scout" });
-      workerTasks = nest.getAllTasks().filter(t => (t.caste === "worker" || t.caste === "drone") && t.status === "pending");
+      quorumMergeTasks(nest);
+
+      workerTasks = getPendingExecutionTasks();
+      plan = validateExecutionPlan(workerTasks);
     }
 
-    if (workerTasks.length === 0) {
+    if (!plan.ok) {
       nest.updateState({ status: "failed", finishedAt: Date.now() });
       const finalState = nest.getState();
       callbacks.onComplete?.(finalState);
-      emitSignal("failed", "No tasks generated");
+      emitSignal("failed", `No valid execution plan: ${plan.issues.slice(0, 3).join(", ")}`);
       return finalState;
     }
 

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

@@ -95,7 +95,7 @@ export interface AntStreamEvent {
 export interface ColonyState {
   id: string;
   goal: string;
-  status: "scouting" | "working" | "reviewing" | "done" | "failed" | "budget_exceeded";
+  status: "scouting" | "planning_recovery" | "working" | "reviewing" | "done" | "failed" | "budget_exceeded";
   tasks: Task[];
   ants: Ant[];
   pheromones: Pheromone[];

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

@@ -27,6 +27,7 @@ describe("formatTokens", () => {
 describe("statusIcon", () => {
   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("done", () => expect(statusIcon("done")).toBe("✅"));
   it("failed", () => expect(statusIcon("failed")).toBe("❌"));

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

@@ -17,7 +17,7 @@ export function formatTokens(n: number): string {
 
 export function statusIcon(status: string): string {
   const icons: Record<string, string> = {
-    scouting: "🔍", working: "⚒️", reviewing: "🛡️",
+    scouting: "🔍", planning_recovery: "♻️", working: "⚒️", reviewing: "🛡️",
     done: "✅", failed: "❌", budget_exceeded: "💰",
   };
   return icons[status] || "🐜";