pi-messenger 0.10.0 → 0.11.0

package/crew/live-progress.ts

@@ -0,0 +1,57 @@
+import type { AgentProgress } from "./utils/progress.js";
+
+export interface LiveWorkerInfo {
+  cwd: string;
+  taskId: string;
+  agent: string;
+  progress: AgentProgress;
+  startedAt: number;
+}
+
+const liveWorkers = new Map<string, LiveWorkerInfo>();
+const listeners = new Set<() => void>();
+
+function getWorkerKey(cwd: string, taskId: string): string {
+  return `${cwd}::${taskId}`;
+}
+
+export function updateLiveWorker(cwd: string, taskId: string, info: Omit<LiveWorkerInfo, "cwd">): void {
+  liveWorkers.set(getWorkerKey(cwd, taskId), {
+    ...info,
+    cwd,
+  });
+  notifyListeners();
+}
+
+export function removeLiveWorker(cwd: string, taskId: string): void {
+  liveWorkers.delete(getWorkerKey(cwd, taskId));
+  notifyListeners();
+}
+
+export function getLiveWorkers(cwd?: string): ReadonlyMap<string, LiveWorkerInfo> {
+  if (!cwd) return new Map(liveWorkers);
+
+  const filtered = new Map<string, LiveWorkerInfo>();
+  for (const info of liveWorkers.values()) {
+    if (info.cwd !== cwd) continue;
+    filtered.set(info.taskId, info);
+  }
+  return filtered;
+}
+
+export function hasLiveWorkers(cwd?: string): boolean {
+  if (!cwd) return liveWorkers.size > 0;
+  for (const info of liveWorkers.values()) {
+    if (info.cwd === cwd) return true;
+  }
+  return false;
+}
+
+export function onLiveWorkersChanged(fn: () => void): () => void {
+  listeners.add(fn);
+  return () => listeners.delete(fn);
+}
+
+function notifyListeners(): void {
+  for (const fn of listeners) fn();
+}

package/crew/state.ts

@@ -17,7 +17,6 @@ export interface AutonomousState {
   active: boolean;
   cwd: string | null;
   waveNumber: number;
-  attemptsPerTask: Record<string, number>;
   waveHistory: WaveResult[];
   startedAt: string | null;
   stoppedAt: string | null;
@@ -33,52 +32,37 @@ export const autonomousState: AutonomousState = {
   active: false,
   cwd: null,
   waveNumber: 0,
-  attemptsPerTask: {},
   waveHistory: [],
   startedAt: null,
   stoppedAt: null,
   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;

package/crew/types.ts

@@ -36,6 +36,7 @@ export interface Task {
   id: string;                    // task-N format
   title: string;
   status: TaskStatus;
+  model?: string;
   depends_on: string[];          // Task IDs this depends on
   created_at: string;            // ISO timestamp
   updated_at: string;            // ISO timestamp
@@ -91,6 +92,7 @@ export interface CrewParams {
   // Work options
   autonomous?: boolean;
   concurrency?: number;
+  model?: string;
 
   // Task reset
   cascade?: boolean;
@@ -131,6 +133,8 @@ export interface ReviewResult {
 export interface AgentTask {
   agent: string;
   task: string;
+  taskId?: string;
+  modelOverride?: string;
   maxOutput?: MaxOutputConfig;
 }
 
@@ -141,6 +145,8 @@ export interface AgentResult {
   truncated: boolean;
   progress: AgentProgress;
   config?: CrewAgentConfig;
+  taskId?: string;
+  wasGracefullyShutdown?: boolean;
   error?: string;
   artifactPaths?: {
     input: string;

package/crew/utils/config.ts

@@ -13,6 +13,12 @@ const USER_CONFIG_PATH = path.join(os.homedir(), ".pi", "agent", "pi-messenger.j
 const PROJECT_CONFIG_FILE = "config.json";
 
 export interface CrewConfig {
+  models?: {
+    planner?: string;
+    worker?: string;
+    reviewer?: string;
+    analyst?: string;
+  };
   concurrency: {
     workers: number;
   };
@@ -30,7 +36,13 @@ export interface CrewConfig {
   planSync: { enabled: boolean };
   review: { enabled: boolean; maxIterations: number };
   planning: { maxPasses: number };
-  work: { maxAttemptsPerTask: number; maxWaves: number; stopOnBlock: boolean };
+  work: {
+    maxAttemptsPerTask: number;
+    maxWaves: number;
+    stopOnBlock: boolean;
+    env?: Record<string, string>;
+    shutdownGracePeriodMs?: number;
+  };
 }
 
 const DEFAULT_CONFIG: CrewConfig = {
@@ -48,7 +60,7 @@ const DEFAULT_CONFIG: CrewConfig = {
   planSync: { enabled: false },
   review: { enabled: true, maxIterations: 3 },
   planning: { maxPasses: 3 },
-  work: { maxAttemptsPerTask: 5, maxWaves: 50, stopOnBlock: false },
+  work: { maxAttemptsPerTask: 5, maxWaves: 50, stopOnBlock: false, shutdownGracePeriodMs: 30000 },
 };
 
 function loadJson(filePath: string): Record<string, unknown> {
@@ -60,19 +72,25 @@ function loadJson(filePath: string): Record<string, unknown> {
 }
 
 function deepMerge<T extends object>(target: T, ...sources: Partial<T>[]): T {
-  const result = { ...target };
+  const result: Record<string, unknown> = target && typeof target === "object"
+    ? { ...(target as Record<string, unknown>) }
+    : {};
   for (const source of sources) {
-    for (const key of Object.keys(source) as (keyof T)[]) {
+    const src = source as Record<string, unknown>;
+    for (const key of Object.keys(src)) {
       const targetVal = result[key];
-      const sourceVal = source[key];
+      const sourceVal = src[key];
       if (sourceVal && typeof sourceVal === "object" && !Array.isArray(sourceVal)) {
-        result[key] = deepMerge(targetVal as object, sourceVal as object) as T[keyof T];
+        const base = targetVal && typeof targetVal === "object" && !Array.isArray(targetVal)
+          ? targetVal as object
+          : {};
+        result[key] = deepMerge(base, sourceVal as object);
       } else if (sourceVal !== undefined) {
-        result[key] = sourceVal as T[keyof T];
+        result[key] = sourceVal;
       }
     }
   }
-  return result;
+  return result as T;
 }
 
 /**
@@ -90,9 +108,6 @@ export function loadCrewConfig(crewDir: string): CrewConfig {
   return deepMerge(DEFAULT_CONFIG, userCrewConfig, projectConfig);
 }
 
-/**
- * Get truncation config for a specific role.
- */
 export function getTruncationForRole(config: CrewConfig, role: string): MaxOutputConfig {
   switch (role) {
     case "planner": return config.truncation.planners;

package/crew/utils/progress.ts

@@ -10,13 +10,14 @@ export interface AgentProgress {
   currentTool?: string;
   currentToolArgs?: string;
   recentTools: Array<{ tool: string; args: string; endMs: number }>;
+  toolCallCount: number;
   tokens: number;
   durationMs: number;
   error?: string;
 }
 
 // Event types from pi's --mode json output
-interface PiEvent {
+export interface PiEvent {
   type: string;
   toolName?: string;
   args?: Record<string, unknown>;
@@ -34,6 +35,7 @@ export function createProgress(agent: string): AgentProgress {
     agent,
     status: "pending",
     recentTools: [],
+    toolCallCount: 0,
     tokens: 0,
     durationMs: 0,
   };
@@ -59,6 +61,7 @@ export function updateProgress(progress: AgentProgress, event: PiEvent, startTim
       break;
 
     case "tool_execution_end":
+      progress.toolCallCount++;
       if (progress.currentTool) {
         progress.recentTools.unshift({
           tool: progress.currentTool,

package/crew-overlay.ts

@@ -10,6 +10,7 @@ import type { Theme } from "@mariozechner/pi-coding-agent";
 import * as crewStore from "./crew/store.js";
 import { autonomousState } from "./crew/state.js";
 import type { Task } from "./crew/types.js";
+import { getLiveWorkers, type LiveWorkerInfo } from "./crew/live-progress.js";
 
 // Status icons
 const STATUS_ICONS: Record<string, string> = {
@@ -49,9 +50,9 @@ export function renderCrewContent(
   }
 
   const tasks = crewStore.getTasks(cwd);
+  const workers = getLiveWorkers(cwd);
   
   // Header: PRD with progress
-  const pct = plan.task_count > 0 ? Math.round((plan.completed_count / plan.task_count) * 100) : 0;
   const progressText = `[${plan.completed_count}/${plan.task_count}]`;
   const prdLine = `📋 ${plan.prd}`;
   const prdWidth = visibleWidth(prdLine);
@@ -61,13 +62,42 @@ export function renderCrewContent(
   lines.push(prdLine + " ".repeat(padding) + theme.fg("accent", progressText));
   lines.push("");
 
+  if (workers.size > 0) {
+    lines.push(theme.fg("dim", "─".repeat(Math.min(width, 40)) + " Active Workers"));
+
+    for (const [taskId, info] of workers) {
+      const activity = info.progress.currentTool
+        ? `${info.progress.currentTool}${info.progress.currentToolArgs ? ` ${info.progress.currentToolArgs}` : ""}`
+        : "thinking...";
+      const calls = `${info.progress.toolCallCount} calls`;
+      const tokens = info.progress.tokens > 1000
+        ? `${(info.progress.tokens / 1000).toFixed(0)}k tokens`
+        : `${info.progress.tokens} tokens`;
+      const elapsed = `${Math.floor((Date.now() - info.startedAt) / 1000)}s`;
+
+      const line = ` ⚡ ${taskId}: ${activity}`;
+      const stats = `${calls}  ${tokens}  ${elapsed}`;
+      lines.push(truncateToWidth(line + "  " + theme.fg("dim", stats), width));
+    }
+
+    lines.push(theme.fg("dim", "─".repeat(Math.min(width, 40))));
+    lines.push("");
+  }
+
   // Task list
+  const taskListStartLine = lines.length;
   if (tasks.length === 0) {
     lines.push(theme.fg("dim", "  (no tasks yet)"));
   } else {
     for (let i = 0; i < tasks.length; i++) {
       const task = tasks[i];
-      const taskLine = renderTaskLine(theme, task, i === viewState.selectedTaskIndex, width);
+      const taskLine = renderTaskLine(
+        theme,
+        task,
+        i === viewState.selectedTaskIndex,
+        width,
+        workers.get(task.id),
+      );
       lines.push(taskLine);
     }
   }
@@ -83,16 +113,22 @@ export function renderCrewContent(
 
   // Handle scrolling if content exceeds height
   if (lines.length > height) {
-    const startIdx = Math.min(viewState.scrollOffset, lines.length - height);
-    return lines.slice(startIdx, startIdx + height);
+    // Auto-scroll to keep the selected task visible
+    if (tasks.length > 0) {
+      const selectedLine = taskListStartLine + Math.min(viewState.selectedTaskIndex, tasks.length - 1);
+      if (selectedLine < viewState.scrollOffset) {
+        viewState.scrollOffset = selectedLine;
+      } else if (selectedLine >= viewState.scrollOffset + height) {
+        viewState.scrollOffset = selectedLine - height + 1;
+      }
+    }
+    viewState.scrollOffset = Math.max(0, Math.min(viewState.scrollOffset, lines.length - height));
+    return lines.slice(viewState.scrollOffset, viewState.scrollOffset + height);
   }
 
   return lines.slice(0, height);
 }
 
-/**
- * Render the status bar for autonomous mode.
- */
 export function renderCrewStatusBar(theme: Theme, cwd: string, width: number): string {
   const plan = crewStore.getPlan(cwd);
   
@@ -168,7 +204,8 @@ function renderTaskLine(
   theme: Theme,
   task: Task,
   isSelected: boolean,
-  width: number
+  width: number,
+  liveWorker?: LiveWorkerInfo
 ): string {
   const icon = STATUS_ICONS[task.status] ?? "?";
   const selectIndicator = isSelected ? theme.fg("accent", "▸ ") : "  ";
@@ -191,7 +228,12 @@ function renderTaskLine(
 
   // Build task suffix (assigned agent or dependencies)
   let suffix = "";
-  if (task.status === "in_progress" && task.assigned_to) {
+  if (task.status === "in_progress" && liveWorker) {
+    const activity = liveWorker.progress.currentTool
+      ? `${liveWorker.progress.currentTool}${liveWorker.progress.currentToolArgs ? ` ${liveWorker.progress.currentToolArgs}` : ""}`
+      : "thinking...";
+    suffix = ` (${activity})`;
+  } else if (task.status === "in_progress" && task.assigned_to) {
     suffix = ` (${task.assigned_to})`;
   } else if (task.status === "todo" && task.depends_on.length > 0) {
     suffix = ` → deps: ${task.depends_on.join(", ")}`;
@@ -219,9 +261,6 @@ function renderLegend(theme: Theme, width: number): string {
   return truncateToWidth(theme.fg("dim", legend), width);
 }
 
-/**
- * Navigate to next/prev task.
- */
 export function navigateTask(viewState: CrewViewState, direction: 1 | -1, taskCount: number): void {
   if (taskCount === 0) return;
   viewState.selectedTaskIndex = Math.max(
@@ -229,5 +268,3 @@ export function navigateTask(viewState: CrewViewState, direction: 1 | -1, taskCo
     Math.min(taskCount - 1, viewState.selectedTaskIndex + direction)
   );
 }
-
-

package/index.ts

@@ -36,6 +36,7 @@ import type { CrewParams } from "./crew/types.js";
 import { autonomousState, restoreAutonomousState, stopAutonomous } from "./crew/state.js";
 import { loadCrewConfig } from "./crew/utils/config.js";
 import * as crewStore from "./crew/store.js";
+import { getLiveWorkers, onLiveWorkersChanged } from "./crew/live-progress.js";
 
 let overlayTui: TUI | null = null;
 
@@ -225,13 +226,22 @@ export default function piMessengerExtension(pi: ExtensionAPI) {
       const cwd = ctx.cwd ?? process.cwd();
       const plan = crewStore.getPlan(cwd);
       if (plan) {
+        const workerCount = getLiveWorkers(cwd).size;
         crewStr = theme.fg("accent", ` ⚡${plan.completed_count}/${plan.task_count}`);
+        if (workerCount > 0) {
+          crewStr += theme.fg("dim", ` 🔨${workerCount}`);
+        }
       }
     }
 
     ctx.ui.setStatus("messenger", `msg: ${nameStr}${countStr}${unreadStr}${crewStr}`);
   }
 
+  let latestCtx: ExtensionContext | null = null;
+  onLiveWorkersChanged(() => {
+    if (latestCtx) updateStatus(latestCtx);
+  });
+
   // ===========================================================================
   // Tool Registration
   // ===========================================================================
@@ -303,6 +313,7 @@ Mode: action (if provided) > legacy key-based routing`,
       type: Type.Optional(StringEnum(["plan", "impl"], { description: "Review type (inferred from target if omitted)" })),
       autonomous: Type.Optional(Type.Boolean({ description: "Run work continuously until done/blocked" })),
       concurrency: Type.Optional(Type.Number({ description: "Override worker concurrency" })),
+      model: Type.Optional(Type.String({ description: "Override worker model for this work wave" })),
       cascade: Type.Optional(Type.Boolean({ description: "For task.reset - also reset dependent tasks" })),
       limit: Type.Optional(Type.Number({ description: "Number of events to return (for feed action, default 20)" })),
       paths: Type.Optional(Type.Array(Type.String(), { description: "Paths for reserve/release actions" })),
@@ -349,7 +360,8 @@ Mode: action (if provided) > legacy key-based routing`,
       autoRegisterPath?: "add" | "remove" | "list";
       list?: boolean;
       limit?: number;
-    }, _signal, _onUpdate, ctx) {
+    }, signal, _onUpdate, ctx) {
+      latestCtx = ctx;
       const {
         action,
         join,
@@ -384,7 +396,8 @@ Mode: action (if provided) > legacy key-based routing`,
           deliverMessage,
           updateStatus,
           (type, data) => pi.appendEntry(type, data),
-          { stuckThreshold: config.stuckThreshold, crewEventsInFeed: config.crewEventsInFeed, nameTheme, feedRetention: config.feedRetention }
+          { stuckThreshold: config.stuckThreshold, crewEventsInFeed: config.crewEventsInFeed, nameTheme, feedRetention: config.feedRetention },
+          signal
         );
       }
 
@@ -699,6 +712,7 @@ Mode: action (if provided) > legacy key-based routing`,
   // ===========================================================================
 
   pi.on("session_start", async (_event, ctx) => {
+    latestCtx = ctx;
     for (const entry of ctx.sessionManager.getEntries()) {
       if (entry.type === "custom" && entry.customType === "crew-state") {
         restoreAutonomousState(entry.data as Parameters<typeof restoreAutonomousState>[0]);
@@ -741,16 +755,22 @@ Mode: action (if provided) > legacy key-based routing`,
   }
 
   pi.on("session_switch", async (_event, ctx) => {
+    latestCtx = ctx;
     recoverWatcherIfNeeded();
     updateStatus(ctx);
   });
   pi.on("session_fork", async (_event, ctx) => {
+    latestCtx = ctx;
     recoverWatcherIfNeeded();
     updateStatus(ctx);
   });
-  pi.on("session_tree", async (_event, ctx) => updateStatus(ctx));
+  pi.on("session_tree", async (_event, ctx) => {
+    latestCtx = ctx;
+    updateStatus(ctx);
+  });
 
   pi.on("turn_end", async (event, ctx) => {
+    latestCtx = ctx;
     store.processAllPendingMessages(state, dirs, deliverMessage);
     recoverWatcherIfNeeded();
     updateStatus(ctx);

package/overlay.ts

@@ -34,6 +34,7 @@ import {
   navigateTask,
   type CrewViewState,
 } from "./crew-overlay.js";
+import { hasLiveWorkers, onLiveWorkersChanged } from "./crew/live-progress.js";
 import { loadConfig } from "./config.js";
 
 const AGENTS_TAB = "[agents]";
@@ -50,6 +51,8 @@ export class MessengerOverlay implements Component, Focusable {
   private crewViewState: CrewViewState = createCrewViewState();
   private cwd: string;
   private stuckThresholdMs: number;
+  private progressTimer: ReturnType<typeof setInterval> | null = null;
+  private progressUnsubscribe: (() => void) | null = null;
 
   constructor(
     private tui: TUI,
@@ -68,6 +71,18 @@ export class MessengerOverlay implements Component, Focusable {
     if (this.selectedAgent && this.selectedAgent !== AGENTS_TAB && this.selectedAgent !== CREW_TAB) {
       state.unreadCounts.set(this.selectedAgent, 0);
     }
+
+    this.progressUnsubscribe = onLiveWorkersChanged(() => {
+      if (this.selectedAgent === CREW_TAB) {
+        if (hasLiveWorkers(this.cwd)) this.startProgressRefresh();
+        else this.stopProgressRefresh();
+      }
+      this.tui.requestRender();
+    });
+
+    if (this.selectedAgent === CREW_TAB && hasLiveWorkers(this.cwd)) {
+      this.startProgressRefresh();
+    }
   }
 
   private getAgentsSorted(): AgentRegistration[] {
@@ -101,6 +116,30 @@ export class MessengerOverlay implements Component, Focusable {
       this.state.unreadCounts.set(agentName, 0);
     }
     this.scrollPosition = 0;
+
+    if (agentName === CREW_TAB && hasLiveWorkers(this.cwd)) {
+      this.startProgressRefresh();
+    } else {
+      this.stopProgressRefresh();
+    }
+  }
+
+  private startProgressRefresh(): void {
+    if (this.progressTimer) return;
+    this.progressTimer = setInterval(() => {
+      if (hasLiveWorkers(this.cwd)) {
+        this.tui.requestRender();
+      } else {
+        this.stopProgressRefresh();
+      }
+    }, 1000);
+  }
+
+  private stopProgressRefresh(): void {
+    if (this.progressTimer) {
+      clearInterval(this.progressTimer);
+      this.progressTimer = null;
+    }
   }
 
   private scroll(delta: number): void {
@@ -341,7 +380,9 @@ export class MessengerOverlay implements Component, Focusable {
       lines.push(row(this.renderTabBar(innerW - 2, agents)));
       lines.push(border("├" + "─".repeat(innerW) + "┤"));
 
-      const messageAreaHeight = 10; // Fixed height for message area
+      const chromeLines = 7; // top border, empty row, tab bar, separator, separator, input bar, bottom border
+      const termRows = process.stdout.rows ?? 24;
+      const messageAreaHeight = Math.min(25, Math.max(8, termRows - chromeLines - 2));
       const messageLines = this.renderMessages(innerW - 2, messageAreaHeight, agents);
       for (const line of messageLines) {
         lines.push(row(line));
@@ -709,5 +750,9 @@ export class MessengerOverlay implements Component, Focusable {
     // No cached state to invalidate
   }
 
-  dispose(): void {}
+  dispose(): void {
+    this.stopProgressRefresh();
+    this.progressUnsubscribe?.();
+    this.progressUnsubscribe = null;
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-messenger",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Inter-agent messaging and file reservation system for pi coding agent",
   "type": "module",
   "author": "Nico Bailon",
@@ -34,9 +34,15 @@
     "crew/**",
     "skills/**",
     "README.md",
-    "CHANGELOG.md",
-    "ARCHITECTURE.md"
+    "CHANGELOG.md"
   ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "vitest": "^2.1.8"
+  },
   "pi": {
     "extensions": ["./index.ts"]
   }

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    include: ["tests/**/*.test.ts"],
+    clearMocks: true,
+    restoreMocks: true,
+  },
+});