gsd-pi 2.23.0 → 2.24.0

package/src/resources/extensions/gsd/tests/worker-registry.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Tests for the parallel worker registry used by the dashboard overlay.
+ *
+ * Verifies worker lifecycle (register → update → cleanup), batch grouping,
+ * and the hasActiveWorkers() status check.
+ */
+
+import { createTestContext } from './test-helpers.ts';
+import {
+  registerWorker,
+  updateWorker,
+  getActiveWorkers,
+  getWorkerBatches,
+  hasActiveWorkers,
+  resetWorkerRegistry,
+} from '../../subagent/worker-registry.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── Setup ────────────────────────────────────────────────────────────────────
+
+resetWorkerRegistry();
+
+// ─── Registration ─────────────────────────────────────────────────────────────
+
+console.log("\n=== Worker Registration ===");
+
+{
+  resetWorkerRegistry();
+  const id = registerWorker("scout", "Explore codebase", 0, 3, "batch-1");
+  assertTrue(id.startsWith("worker-"), "worker ID has correct prefix");
+  const workers = getActiveWorkers();
+  assertEq(workers.length, 1, "one worker registered");
+  assertEq(workers[0].agent, "scout", "worker agent name correct");
+  assertEq(workers[0].task, "Explore codebase", "worker task correct");
+  assertEq(workers[0].status, "running", "worker starts as running");
+  assertEq(workers[0].index, 0, "worker index correct");
+  assertEq(workers[0].batchSize, 3, "worker batch size correct");
+  assertEq(workers[0].batchId, "batch-1", "worker batch ID correct");
+}
+
+// ─── Multiple workers in a batch ──────────────────────────────────────────────
+
+console.log("\n=== Multiple Workers in a Batch ===");
+
+{
+  resetWorkerRegistry();
+  const id1 = registerWorker("scout", "Task A", 0, 3, "batch-2");
+  const id2 = registerWorker("researcher", "Task B", 1, 3, "batch-2");
+  const id3 = registerWorker("worker", "Task C", 2, 3, "batch-2");
+
+  const workers = getActiveWorkers();
+  assertEq(workers.length, 3, "three workers registered");
+  assertTrue(hasActiveWorkers(), "has active workers");
+
+  const batches = getWorkerBatches();
+  assertEq(batches.size, 1, "one batch");
+  const batch = batches.get("batch-2");
+  assertTrue(batch !== undefined, "batch-2 exists");
+  assertEq(batch!.length, 3, "batch has 3 workers");
+}
+
+// ─── Worker status updates ────────────────────────────────────────────────────
+
+console.log("\n=== Worker Status Updates ===");
+
+{
+  resetWorkerRegistry();
+  const id1 = registerWorker("scout", "Task A", 0, 2, "batch-3");
+  const id2 = registerWorker("worker", "Task B", 1, 2, "batch-3");
+
+  updateWorker(id1, "completed");
+  const workers = getActiveWorkers();
+  const w1 = workers.find(w => w.id === id1);
+  assertEq(w1?.status, "completed", "worker 1 marked completed");
+
+  const w2 = workers.find(w => w.id === id2);
+  assertEq(w2?.status, "running", "worker 2 still running");
+  assertTrue(hasActiveWorkers(), "still has active workers (worker 2 running)");
+}
+
+// ─── Failed worker ────────────────────────────────────────────────────────────
+
+console.log("\n=== Failed Worker ===");
+
+{
+  resetWorkerRegistry();
+  const id = registerWorker("scout", "Task A", 0, 1, "batch-4");
+  updateWorker(id, "failed");
+  const workers = getActiveWorkers();
+  assertEq(workers[0].status, "failed", "worker marked failed");
+}
+
+// ─── Multiple batches ─────────────────────────────────────────────────────────
+
+console.log("\n=== Multiple Batches ===");
+
+{
+  resetWorkerRegistry();
+  registerWorker("scout", "Task A", 0, 2, "batch-5");
+  registerWorker("worker", "Task B", 1, 2, "batch-5");
+  registerWorker("researcher", "Task C", 0, 1, "batch-6");
+
+  const batches = getWorkerBatches();
+  assertEq(batches.size, 2, "two batches");
+  assertEq(batches.get("batch-5")!.length, 2, "batch-5 has 2 workers");
+  assertEq(batches.get("batch-6")!.length, 1, "batch-6 has 1 worker");
+}
+
+// ─── hasActiveWorkers with all completed ──────────────────────────────────────
+
+console.log("\n=== hasActiveWorkers — all completed ===");
+
+{
+  resetWorkerRegistry();
+  const id1 = registerWorker("scout", "Task A", 0, 2, "batch-7");
+  const id2 = registerWorker("worker", "Task B", 1, 2, "batch-7");
+  updateWorker(id1, "completed");
+  updateWorker(id2, "completed");
+  assertTrue(!hasActiveWorkers(), "no active workers when all completed");
+}
+
+// ─── Reset clears everything ─────────────────────────────────────────────────
+
+console.log("\n=== Reset ===");
+
+{
+  registerWorker("scout", "Task", 0, 1, "batch-8");
+  assertTrue(getActiveWorkers().length > 0, "workers exist before reset");
+  resetWorkerRegistry();
+  assertEq(getActiveWorkers().length, 0, "no workers after reset");
+  assertTrue(!hasActiveWorkers(), "hasActiveWorkers false after reset");
+}
+
+// ─── Update non-existent worker is no-op ──────────────────────────────────────
+
+console.log("\n=== Update non-existent worker ===");
+
+{
+  resetWorkerRegistry();
+  // Should not throw
+  updateWorker("nonexistent-id", "completed");
+  assertEq(getActiveWorkers().length, 0, "no workers created by updating nonexistent");
+}
+
+// ─── Summary ──────────────────────────────────────────────────────────────────
+
+report();

package/src/resources/extensions/gsd/types.ts

@@ -5,7 +5,7 @@
 // ─── Enums & Literal Unions ────────────────────────────────────────────────
 
 export type RiskLevel = 'low' | 'medium' | 'high';
-export type Phase = 'pre-planning' | 'needs-discussion' | 'discussing' | 'researching' | 'planning' | 'executing' | 'verifying' | 'summarizing' | 'advancing' | 'completing-milestone' | 'replanning-slice' | 'complete' | 'paused' | 'blocked';
+export type Phase = 'pre-planning' | 'needs-discussion' | 'discussing' | 'researching' | 'planning' | 'executing' | 'verifying' | 'summarizing' | 'advancing' | 'validating-milestone' | 'completing-milestone' | 'replanning-slice' | 'complete' | 'paused' | 'blocked';
 export type ContinueStatus = 'in_progress' | 'interrupted' | 'compacted';
 
 // ─── Roadmap (Milestone-level) ─────────────────────────────────────────────
@@ -264,6 +264,7 @@ export interface PhaseSkipPreferences {
   skip_research?: boolean;
   skip_reassess?: boolean;
   skip_slice_research?: boolean;
+  skip_milestone_validation?: boolean;
 }
 
 export interface NotificationPreferences {
@@ -363,3 +364,16 @@ export interface Requirement {
   full_content: string;     // full requirement text
   superseded_by: string | null;  // ID of superseding requirement, or null
 }
+
+// ─── Parallel Orchestration Types ────────────────────────────────────────
+
+export type MergeStrategy = "per-slice" | "per-milestone";
+export type AutoMergeMode = "auto" | "confirm" | "manual";
+
+export interface ParallelConfig {
+  enabled: boolean;
+  max_workers: number;
+  budget_ceiling?: number;
+  merge_strategy: MergeStrategy;
+  auto_merge: AutoMergeMode;
+}

package/src/resources/extensions/subagent/index.ts

@@ -33,6 +33,7 @@ import {
 	mergeDeltaPatches,
 	readIsolationMode,
 } from "./isolation.js";
+import { registerWorker, updateWorker } from "./worker-registry.js";
 
 const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
@@ -626,7 +627,10 @@ export default function (pi: ExtensionAPI) {
 				};
 
 				const MAX_RETRIES = 1; // Retry failed tasks once
+				const batchId = crypto.randomUUID();
+				const batchSize = params.tasks.length;
 				const results = await mapWithConcurrencyLimit(params.tasks, MAX_CONCURRENCY, async (t, index) => {
+					const workerId = registerWorker(t.agent, t.task, index, batchSize, batchId);
 					let result = await runSingleAgent(
 						ctx.cwd,
 						agents,
@@ -666,6 +670,7 @@ export default function (pi: ExtensionAPI) {
 						);
 					}
 
+					updateWorker(workerId, result.exitCode === 0 ? "completed" : "failed");
 					allResults[index] = result;
 					emitParallelUpdate();
 					return result;

package/src/resources/extensions/subagent/worker-registry.ts

@@ -0,0 +1,99 @@
+/**
+ * Worker Registry — Tracks active subagent sessions for dashboard visibility.
+ *
+ * Provides a global registry of currently-running parallel workers so the
+ * GSD dashboard overlay can display real-time worker status.
+ */
+
+export interface WorkerEntry {
+  id: string;
+  agent: string;
+  task: string;
+  startedAt: number;
+  status: "running" | "completed" | "failed";
+  /** Index within a parallel batch (0-based) */
+  index: number;
+  /** Total workers in the parallel batch */
+  batchSize: number;
+  /** Unique batch identifier for grouping parallel runs */
+  batchId: string;
+}
+
+const activeWorkers = new Map<string, WorkerEntry>();
+let workerIdCounter = 0;
+
+/**
+ * Register a new worker. Returns the worker ID for later updates.
+ */
+export function registerWorker(
+  agent: string,
+  task: string,
+  index: number,
+  batchSize: number,
+  batchId: string,
+): string {
+  const id = `worker-${++workerIdCounter}`;
+  activeWorkers.set(id, {
+    id,
+    agent,
+    task,
+    startedAt: Date.now(),
+    status: "running",
+    index,
+    batchSize,
+    batchId,
+  });
+  return id;
+}
+
+/**
+ * Update worker status when it completes or fails.
+ */
+export function updateWorker(id: string, status: "completed" | "failed"): void {
+  const entry = activeWorkers.get(id);
+  if (entry) {
+    entry.status = status;
+    // Remove after a brief display window (5 seconds)
+    setTimeout(() => {
+      activeWorkers.delete(id);
+    }, 5000);
+  }
+}
+
+/**
+ * Get all currently-tracked workers (running + recently completed).
+ */
+export function getActiveWorkers(): WorkerEntry[] {
+  return Array.from(activeWorkers.values());
+}
+
+/**
+ * Get workers grouped by batch.
+ */
+export function getWorkerBatches(): Map<string, WorkerEntry[]> {
+  const batches = new Map<string, WorkerEntry[]>();
+  for (const worker of activeWorkers.values()) {
+    const batch = batches.get(worker.batchId) ?? [];
+    batch.push(worker);
+    batches.set(worker.batchId, batch);
+  }
+  return batches;
+}
+
+/**
+ * Check if any parallel workers are currently running.
+ */
+export function hasActiveWorkers(): boolean {
+  for (const worker of activeWorkers.values()) {
+    if (worker.status === "running") return true;
+  }
+  return false;
+}
+
+/**
+ * Reset registry state. Used for testing.
+ */
+export function resetWorkerRegistry(): void {
+  activeWorkers.clear();
+  workerIdCounter = 0;
+}