pi-messenger 0.7.3

package/crew/handlers/work.ts

@@ -0,0 +1,289 @@
+/**
+ * Crew - Work Handler
+ * 
+ * Spawns workers for ready tasks with concurrency control.
+ * Simplified: works on current plan's tasks
+ */
+
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { MessengerState, Dirs } from "../../lib.js";
+import type { CrewParams, AppendEntryFn, Task } from "../types.js";
+import { result } from "../utils/result.js";
+import { spawnAgents } from "../agents.js";
+import { loadCrewConfig } from "../utils/config.js";
+import { discoverCrewAgents } from "../utils/discover.js";
+import * as store from "../store.js";
+import { getCrewDir } from "../store.js";
+import { autonomousState, startAutonomous, stopAutonomous, addWaveResult } from "../state.js";
+
+export async function execute(
+  params: CrewParams,
+  _state: MessengerState,
+  _dirs: Dirs,
+  ctx: ExtensionContext,
+  appendEntry: AppendEntryFn
+) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const config = loadCrewConfig(getCrewDir(cwd));
+  const { autonomous, concurrency: concurrencyOverride } = params;
+
+  // Verify plan exists
+  const plan = store.getPlan(cwd);
+  if (!plan) {
+    return result("No plan found. Create one first:\n\n  pi_messenger({ action: \"plan\" })\n  pi_messenger({ action: \"plan\", prd: \"path/to/PRD.md\" })", {
+      mode: "work",
+      error: "no_plan"
+    });
+  }
+
+  // Check for worker agent
+  const availableAgents = discoverCrewAgents(cwd);
+  const hasWorker = availableAgents.some(a => a.name === "crew-worker");
+  if (!hasWorker) {
+    return result("Error: crew-worker agent not found. Required for task execution.", {
+      mode: "work",
+      error: "no_worker"
+    });
+  }
+
+  // Get ready tasks
+  const readyTasks = store.getReadyTasks(cwd);
+
+  if (readyTasks.length === 0) {
+    const tasks = store.getTasks(cwd);
+    const inProgress = tasks.filter(t => t.status === "in_progress");
+    const blocked = tasks.filter(t => t.status === "blocked");
+    const done = tasks.filter(t => t.status === "done");
+
+    let reason = "";
+    if (done.length === tasks.length) {
+      reason = "🎉 All tasks are done! Plan is complete.";
+    } else if (inProgress.length > 0) {
+      reason = `${inProgress.length} task(s) in progress: ${inProgress.map(t => t.id).join(", ")}`;
+    } else if (blocked.length > 0) {
+      reason = `${blocked.length} task(s) blocked: ${blocked.map(t => `${t.id} (${t.blocked_reason})`).join(", ")}`;
+    } else {
+      reason = "All remaining tasks have unmet dependencies.";
+    }
+
+    return result(`No ready tasks.\n\n${reason}`, {
+      mode: "work",
+      prd: plan.prd,
+      ready: [],
+      reason,
+      inProgress: inProgress.map(t => t.id),
+      blocked: blocked.map(t => t.id)
+    });
+  }
+
+  // Determine concurrency
+  const concurrency = concurrencyOverride ?? config.concurrency.workers;
+  const tasksToRun = readyTasks.slice(0, concurrency);
+
+  // If autonomous mode, set up state and persist (only on first wave or cwd change)
+  if (autonomous && (!autonomousState.active || autonomousState.cwd !== cwd)) {
+    startAutonomous(cwd);
+    appendEntry("crew-state", autonomousState);
+  }
+
+  // Spawn workers
+  const workerTasks = tasksToRun.map(task => ({
+    agent: "crew-worker",
+    task: buildWorkerPrompt(task, plan.prd, cwd)
+  }));
+
+  const workerResults = await spawnAgents(
+    workerTasks,
+    concurrency,
+    cwd
+  );
+
+  // Process results
+  const succeeded: string[] = [];
+  const failed: string[] = [];
+  const blocked: string[] = [];
+
+  for (let i = 0; i < workerResults.length; i++) {
+    const r = workerResults[i];
+    const taskId = tasksToRun[i].id;
+    const task = store.getTask(cwd, taskId);
+
+    if (r.exitCode === 0) {
+      // Check if task was completed (worker should call task.done)
+      if (task?.status === "done") {
+        succeeded.push(taskId);
+      } else if (task?.status === "blocked") {
+        blocked.push(taskId);
+      } else {
+        // Worker finished but didn't complete - treat as failure
+        failed.push(taskId);
+      }
+    } else {
+      // Auto-block on failure if in autonomous mode
+      if (autonomous && task?.status === "in_progress") {
+        store.blockTask(cwd, taskId, `Worker failed: ${r.error ?? "Unknown error"}`);
+        blocked.push(taskId);
+      } else {
+        failed.push(taskId);
+      }
+    }
+  }
+
+  // Save current wave number BEFORE addWaveResult increments it
+  const currentWave = autonomous ? autonomousState.waveNumber : 1;
+  
+  if (autonomous) {
+    addWaveResult({
+      waveNumber: currentWave,
+      tasksAttempted: tasksToRun.map(t => t.id),
+      succeeded,
+      failed,
+      blocked,
+      timestamp: new Date().toISOString()
+    });
+
+    // Check if we should continue
+    const nextReady = store.getReadyTasks(cwd);
+    const allTasks = store.getTasks(cwd);
+    const allDone = allTasks.every(t => t.status === "done");
+    const allBlockedOrDone = allTasks.every(t => t.status === "done" || t.status === "blocked");
+
+    if (allDone) {
+      stopAutonomous("completed");
+      appendEntry("crew-state", autonomousState);
+      appendEntry("crew_wave_complete", {
+        prd: plan.prd,
+        status: "completed",
+        totalWaves: currentWave,
+        totalTasks: allTasks.length
+      });
+    } else if (allBlockedOrDone || nextReady.length === 0) {
+      stopAutonomous("blocked");
+      appendEntry("crew-state", autonomousState);
+      appendEntry("crew_wave_blocked", {
+        prd: plan.prd,
+        status: "blocked",
+        blockedTasks: allTasks.filter(t => t.status === "blocked").map(t => t.id)
+      });
+    } else {
+      // Persist state for session recovery and signal continuation
+      appendEntry("crew-state", autonomousState);
+      appendEntry("crew_wave_continue", {
+        prd: plan.prd,
+        nextWave: autonomousState.waveNumber,
+        readyTasks: nextReady.map(t => t.id)
+      });
+    }
+  }
+
+  // Build result
+  const updatedPlan = store.getPlan(cwd);
+  const progress = updatedPlan 
+    ? `${updatedPlan.completed_count}/${updatedPlan.task_count}`
+    : "unknown";
+
+  let statusText = "";
+  if (succeeded.length > 0) statusText += `\n✅ Completed: ${succeeded.join(", ")}`;
+  if (failed.length > 0) statusText += `\n❌ Failed: ${failed.join(", ")}`;
+  if (blocked.length > 0) statusText += `\n🚫 Blocked: ${blocked.join(", ")}`;
+
+  const nextReady = store.getReadyTasks(cwd);
+  const nextText = nextReady.length > 0
+    ? `\n\n**Ready for next wave:** ${nextReady.map(t => t.id).join(", ")}`
+    : "";
+
+  const text = `# Work Wave ${currentWave}
+
+**PRD:** ${plan.prd}
+**Tasks attempted:** ${tasksToRun.length}
+**Progress:** ${progress}
+${statusText}${nextText}
+
+${autonomous && nextReady.length > 0 ? "Autonomous mode: Continuing to next wave..." : ""}`;
+
+  return result(text, {
+    mode: "work",
+    prd: plan.prd,
+    wave: currentWave,
+    attempted: tasksToRun.map(t => t.id),
+    succeeded,
+    failed,
+    blocked,
+    nextReady: nextReady.map(t => t.id),
+    autonomous: !!autonomous
+  });
+}
+
+// =============================================================================
+// Worker Prompt Builder
+// =============================================================================
+
+function buildWorkerPrompt(task: Task, prdPath: string, cwd: string): string {
+  const taskSpec = store.getTaskSpec(cwd, task.id);
+  const planSpec = store.getPlanSpec(cwd);
+
+  let prompt = `# Task Assignment
+
+**Task ID:** ${task.id}
+**Task Title:** ${task.title}
+**PRD:** ${prdPath}
+${task.attempt_count >= 1 ? `**Attempt:** ${task.attempt_count + 1} (retry after previous attempt)` : ""}
+
+## Your Mission
+
+Implement this task following the crew-worker protocol:
+1. Join the mesh
+2. Read task spec to understand requirements
+3. Start task and reserve files
+4. Implement the feature
+5. Commit your changes
+6. Release reservations and mark complete
+
+`;
+
+  // Include previous review feedback if this is a retry
+  if (task.last_review) {
+    prompt += `## ⚠️ Previous Review Feedback
+
+**Verdict:** ${task.last_review.verdict}
+
+${task.last_review.summary}
+
+${task.last_review.issues.length > 0 ? `**Issues to fix:**\n${task.last_review.issues.map(i => `- ${i}`).join("\n")}\n` : ""}
+${task.last_review.suggestions.length > 0 ? `**Suggestions:**\n${task.last_review.suggestions.map(s => `- ${s}`).join("\n")}\n` : ""}
+
+**You MUST address the issues above in this attempt.**
+
+`;
+  }
+
+  if (taskSpec && !taskSpec.includes("*Spec pending*")) {
+    prompt += `## Task Specification
+
+${taskSpec}
+
+`;
+  }
+
+  if (task.depends_on.length > 0) {
+    prompt += `## Dependencies
+
+This task depends on: ${task.depends_on.join(", ")}
+These tasks are already complete - you can reference their implementations.
+
+`;
+  }
+
+  if (planSpec && !planSpec.includes("*Spec pending*")) {
+    // Include truncated plan spec for context
+    const truncatedSpec = planSpec.length > 2000 
+      ? planSpec.slice(0, 2000) + `\n\n[Spec truncated - read full spec from .pi/messenger/crew/plan.md]`
+      : planSpec;
+    prompt += `## Plan Context
+
+${truncatedSpec}
+`;
+  }
+
+  return prompt;
+}

package/crew/id-allocator.ts

@@ -0,0 +1,44 @@
+/**
+ * Crew - ID Allocator
+ * 
+ * Simple task ID allocation: task-1, task-2, ...
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/**
+ * Scans existing tasks to determine the next sequence number.
+ * Returns task ID in format: task-N
+ */
+export function allocateTaskId(cwd: string): string {
+  const tasksDir = path.join(cwd, ".pi", "messenger", "crew", "tasks");
+
+  let maxN = 0;
+  if (fs.existsSync(tasksDir)) {
+    for (const file of fs.readdirSync(tasksDir)) {
+      const match = file.match(/^task-(\d+)\.json$/);
+      if (match) {
+        const n = parseInt(match[1], 10);
+        if (n > maxN) maxN = n;
+      }
+    }
+  }
+
+  return `task-${maxN + 1}`;
+}
+
+/**
+ * Validates that an ID is a well-formed task ID.
+ */
+export function isValidTaskId(id: string): boolean {
+  return /^task-\d+$/.test(id);
+}
+
+/**
+ * Extracts the task number from a task ID.
+ */
+export function getTaskNumber(taskId: string): number | null {
+  const match = taskId.match(/^task-(\d+)$/);
+  return match ? parseInt(match[1], 10) : null;
+}

package/crew/index.ts

@@ -0,0 +1,229 @@
+/**
+ * Crew - Action Router
+ * 
+ * Routes crew actions to their respective handlers.
+ * Simplified: PRD → plan → tasks → work → done
+ */
+
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { MessengerState, Dirs, AgentMailMessage } from "../lib.js";
+import * as handlers from "../handlers.js";
+import type { CrewParams, AppendEntryFn } from "./types.js";
+import { result } from "./utils/result.js";
+import { ensureAgentsInstalled, ensureSkillsInstalled } from "./utils/install.js";
+
+type DeliverFn = (msg: AgentMailMessage) => void;
+type UpdateStatusFn = (ctx: ExtensionContext) => void;
+
+/** Ensure both agents and skills are installed */
+function ensureCrewInstalled() {
+  ensureAgentsInstalled();
+  ensureSkillsInstalled();
+}
+
+/**
+ * Execute a crew action.
+ * 
+ * Routes action strings like "task.show" to the appropriate handler.
+ */
+export async function executeCrewAction(
+  action: string,
+  params: CrewParams,
+  state: MessengerState,
+  dirs: Dirs,
+  ctx: ExtensionContext,
+  deliverMessage: DeliverFn,
+  updateStatus: UpdateStatusFn,
+  appendEntry: AppendEntryFn
+) {
+  // Parse action: "task.show" → group="task", op="show"
+  const dotIndex = action.indexOf('.');
+  const group = dotIndex > 0 ? action.slice(0, dotIndex) : action;
+  const op = dotIndex > 0 ? action.slice(dotIndex + 1) : null;
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // Actions that DON'T require registration
+  // ═══════════════════════════════════════════════════════════════════════
+
+  // join - this is how you register
+  if (group === 'join') {
+    return handlers.executeJoin(state, dirs, ctx, deliverMessage, updateStatus, params.spec);
+  }
+
+  // autoRegisterPath - config management, not agent operation
+  if (group === 'autoRegisterPath') {
+    if (!params.autoRegisterPath) {
+      return result("Error: autoRegisterPath requires value ('add', 'remove', or 'list').",
+        { mode: "autoRegisterPath", error: "missing_value" });
+    }
+    return handlers.executeAutoRegisterPath(params.autoRegisterPath);
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // All other actions require registration
+  // ═══════════════════════════════════════════════════════════════════════
+  if (!state.registered) {
+    return handlers.notRegisteredError();
+  }
+
+  switch (group) {
+    // ═══════════════════════════════════════════════════════════════════════
+    // Coordination actions (delegate to existing handlers)
+    // ═══════════════════════════════════════════════════════════════════════
+    case 'status': {
+      // Check if this is a crew status request
+      try {
+        const statusHandler = await import("./handlers/status.js");
+        return statusHandler.execute(params, state, dirs, ctx);
+      } catch {
+        // Fall back to messenger status
+        return handlers.executeStatus(state, dirs);
+      }
+    }
+
+    case 'list':
+      return handlers.executeList(state, dirs);
+
+    case 'spec':
+      if (!params.spec) {
+        return result("Error: spec path required.", { mode: "spec", error: "missing_spec" });
+      }
+      return handlers.executeSetSpec(state, dirs, ctx, params.spec);
+
+    case 'send':
+      return handlers.executeSend(state, dirs, params.to, false, params.message, params.replyTo);
+
+    case 'broadcast':
+      return handlers.executeSend(state, dirs, undefined, true, params.message, params.replyTo);
+
+    case 'reserve':
+      if (!params.paths || params.paths.length === 0) {
+        return result("Error: paths required for reserve action.", { mode: "reserve", error: "missing_paths" });
+      }
+      return handlers.executeReserve(state, dirs, ctx, params.paths, params.reason);
+
+    case 'release':
+      return handlers.executeRelease(state, dirs, ctx, params.paths ?? true);
+
+    case 'rename':
+      if (!params.name) {
+        return result("Error: name required for rename action.", { mode: "rename", error: "missing_name" });
+      }
+      return handlers.executeRename(state, dirs, ctx, params.name, deliverMessage, updateStatus);
+
+    case 'swarm':
+      return handlers.executeSwarm(state, dirs, params.spec);
+
+    case 'claim':
+      if (!params.taskId) {
+        return result("Error: taskId required for claim action.", { mode: "claim", error: "missing_taskId" });
+      }
+      return handlers.executeClaim(state, dirs, ctx, params.taskId, params.spec, params.reason);
+
+    case 'unclaim':
+      if (!params.taskId) {
+        return result("Error: taskId required for unclaim action.", { mode: "unclaim", error: "missing_taskId" });
+      }
+      return handlers.executeUnclaim(state, dirs, params.taskId, params.spec);
+
+    case 'complete':
+      if (!params.taskId) {
+        return result("Error: taskId required for complete action.", { mode: "complete", error: "missing_taskId" });
+      }
+      return handlers.executeComplete(state, dirs, params.taskId, params.notes, params.spec);
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // Crew actions - Simplified PRD-based workflow
+    // ═══════════════════════════════════════════════════════════════════════
+    case 'task': {
+      if (!op) {
+        return result("Error: task action requires operation (e.g., 'task.show', 'task.list').",
+          { mode: "task", error: "missing_operation" });
+      }
+      try {
+        const taskHandlers = await import("./handlers/task.js");
+        return taskHandlers.execute(op, params, state, dirs, ctx);
+      } catch (e) {
+        return result(`Error: task.${op} handler failed: ${e instanceof Error ? e.message : 'unknown'}`,
+          { mode: "task", error: "handler_error", operation: op });
+      }
+    }
+
+    case 'plan': {
+      // Auto-install agents if missing
+      ensureCrewInstalled();
+      try {
+        const planHandler = await import("./handlers/plan.js");
+        return planHandler.execute(params, state, dirs, ctx);
+      } catch (e) {
+        return result(`Error: plan handler failed: ${e instanceof Error ? e.message : 'unknown'}`,
+          { mode: "plan", error: "handler_error" });
+      }
+    }
+
+    case 'work': {
+      // Auto-install agents if missing
+      ensureCrewInstalled();
+      try {
+        const workHandler = await import("./handlers/work.js");
+        return workHandler.execute(params, state, dirs, ctx, appendEntry);
+      } catch (e) {
+        return result(`Error: work handler failed: ${e instanceof Error ? e.message : 'unknown'}`,
+          { mode: "work", error: "handler_error" });
+      }
+    }
+
+    case 'review': {
+      // Auto-install agents if missing
+      ensureCrewInstalled();
+      try {
+        const reviewHandler = await import("./handlers/review.js");
+        return reviewHandler.execute(params, state, dirs, ctx);
+      } catch (e) {
+        return result(`Error: review handler failed: ${e instanceof Error ? e.message : 'unknown'}`,
+          { mode: "review", error: "handler_error" });
+      }
+    }
+
+    case 'interview': {
+      // Auto-install agents if missing
+      ensureCrewInstalled();
+      try {
+        const interviewHandler = await import("./handlers/interview.js");
+        return interviewHandler.execute(params, state, dirs, ctx);
+      } catch (e) {
+        return result(`Error: interview handler failed: ${e instanceof Error ? e.message : 'unknown'}`,
+          { mode: "interview", error: "handler_error" });
+      }
+    }
+
+    case 'sync': {
+      // Auto-install agents if missing
+      ensureCrewInstalled();
+      try {
+        const syncHandler = await import("./handlers/sync.js");
+        return syncHandler.execute(params, state, dirs, ctx);
+      } catch (e) {
+        return result(`Error: sync handler failed: ${e instanceof Error ? e.message : 'unknown'}`,
+          { mode: "sync", error: "handler_error" });
+      }
+    }
+
+    case 'crew': {
+      if (!op) {
+        return result("Error: crew action requires operation (e.g., 'crew.status', 'crew.agents').",
+          { mode: "crew", error: "missing_operation" });
+      }
+      try {
+        const statusHandlers = await import("./handlers/status.js");
+        return statusHandlers.executeCrew(op, params, state, dirs, ctx);
+      } catch (e) {
+        return result(`Error: crew.${op} handler failed: ${e instanceof Error ? e.message : 'unknown'}`,
+          { mode: "crew", error: "handler_error", operation: op });
+      }
+    }
+
+    default:
+      return result(`Unknown action: ${action}`, { mode: "error", error: "unknown_action", action });
+  }
+}

package/crew/state.ts

@@ -0,0 +1,116 @@
+/**
+ * Crew - Shared Autonomous State
+ * 
+ * Tracks autonomous mode execution across turns.
+ */
+
+export interface WaveResult {
+  waveNumber: number;
+  tasksAttempted: string[];
+  succeeded: string[];
+  failed: string[];
+  blocked: string[];
+  timestamp: string;
+}
+
+export interface AutonomousState {
+  active: boolean;
+  cwd: string | null;
+  waveNumber: number;
+  attemptsPerTask: Record<string, number>;
+  waveHistory: WaveResult[];
+  startedAt: string | null;
+  stoppedAt: string | null;
+  stopReason: "completed" | "blocked" | "manual" | null;
+}
+
+/**
+ * Shared state for autonomous mode.
+ * Persisted to session via appendEntry("crew-state", ...) and
+ * restored on session_start.
+ */
+export const autonomousState: AutonomousState = {
+  active: false,
+  cwd: null,
+  waveNumber: 0,
+  attemptsPerTask: {},
+  waveHistory: [],
+  startedAt: null,
+  stoppedAt: null,
+  stopReason: null,
+};
+
+/**
+ * Reset autonomous state.
+ */
+export function resetAutonomousState(): void {
+  autonomousState.active = false;
+  autonomousState.cwd = null;
+  autonomousState.waveNumber = 0;
+  autonomousState.attemptsPerTask = {};
+  autonomousState.waveHistory = [];
+  autonomousState.startedAt = null;
+  autonomousState.stoppedAt = null;
+  autonomousState.stopReason = null;
+}
+
+/**
+ * Start autonomous mode.
+ */
+export function startAutonomous(cwd: string): void {
+  autonomousState.active = true;
+  autonomousState.cwd = cwd;
+  autonomousState.waveNumber = 1;
+  autonomousState.attemptsPerTask = {};
+  autonomousState.waveHistory = [];
+  autonomousState.startedAt = new Date().toISOString();
+  autonomousState.stoppedAt = null;
+  autonomousState.stopReason = null;
+}
+
+/**
+ * Stop autonomous mode.
+ */
+export function stopAutonomous(reason: "completed" | "blocked" | "manual"): void {
+  autonomousState.active = false;
+  autonomousState.stoppedAt = new Date().toISOString();
+  autonomousState.stopReason = reason;
+}
+
+/**
+ * Add a wave result to history.
+ */
+export function addWaveResult(result: WaveResult): void {
+  autonomousState.waveHistory.push(result);
+  autonomousState.waveNumber++;
+}
+
+/**
+ * Restore autonomous state from session data.
+ */
+export function restoreAutonomousState(data: Partial<AutonomousState>): void {
+  if (data.active !== undefined) autonomousState.active = data.active;
+  if (data.cwd !== undefined) autonomousState.cwd = data.cwd;
+  if (data.waveNumber !== undefined) autonomousState.waveNumber = data.waveNumber;
+  if (data.attemptsPerTask !== undefined) autonomousState.attemptsPerTask = data.attemptsPerTask;
+  if (data.waveHistory !== undefined) autonomousState.waveHistory = data.waveHistory;
+  if (data.startedAt !== undefined) autonomousState.startedAt = data.startedAt;
+  if (data.stoppedAt !== undefined) autonomousState.stoppedAt = data.stoppedAt;
+  if (data.stopReason !== undefined) autonomousState.stopReason = data.stopReason;
+}
+
+/**
+ * Increment attempt count for a task.
+ */
+export function incrementTaskAttempt(taskId: string): number {
+  const current = autonomousState.attemptsPerTask[taskId] ?? 0;
+  autonomousState.attemptsPerTask[taskId] = current + 1;
+  return current + 1;
+}
+
+/**
+ * Get attempt count for a task.
+ */
+export function getTaskAttempts(taskId: string): number {
+  return autonomousState.attemptsPerTask[taskId] ?? 0;
+}