gsd-pi 2.22.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/triage-resolution.ts

@@ -16,7 +16,9 @@ import type { Classification, CaptureEntry } from "./captures.js";
 import {
   loadPendingCaptures,
   loadAllCaptures,
+  loadActionableCaptures,
   markCaptureResolved,
+  markCaptureExecuted,
 } from "./captures.js";
 
 // ─── Resolution Executors ─────────────────────────────────────────────────────
@@ -198,3 +200,84 @@ export function buildQuickTaskPrompt(capture: CaptureEntry): string {
     `5. When done, say: "Quick task complete."`,
   ].join("\n");
 }
+
+// ─── Post-Triage Resolution Executor ─────────────────────────────────────────
+
+/**
+ * Result of executing triage resolutions after a triage-captures unit completes.
+ */
+export interface TriageExecutionResult {
+  /** Number of inject resolutions executed (tasks added to plan) */
+  injected: number;
+  /** Number of replan triggers written */
+  replanned: number;
+  /** Captures classified as quick-task that need dispatch */
+  quickTasks: CaptureEntry[];
+  /** Details of each action taken, for logging */
+  actions: string[];
+}
+
+/**
+ * Execute pending triage resolutions.
+ *
+ * Called after a triage-captures unit completes. Reads CAPTURES.md for
+ * resolved captures that have actionable classifications (inject, replan,
+ * quick-task) but haven't been executed yet, then:
+ *
+ * - inject: calls executeInject() to add a task to the current slice plan
+ * - replan: calls executeReplan() to write the REPLAN-TRIGGER.md marker
+ * - quick-task: collects for dispatch (caller handles dispatching quick-task units)
+ *
+ * Each capture is marked as executed after its resolution action succeeds,
+ * preventing double-execution on retries or restarts.
+ */
+export function executeTriageResolutions(
+  basePath: string,
+  mid: string,
+  sid: string,
+): TriageExecutionResult {
+  const result: TriageExecutionResult = {
+    injected: 0,
+    replanned: 0,
+    quickTasks: [],
+    actions: [],
+  };
+
+  const actionable = loadActionableCaptures(basePath);
+  if (actionable.length === 0) return result;
+
+  for (const capture of actionable) {
+    switch (capture.classification) {
+      case "inject": {
+        const newTaskId = executeInject(basePath, mid, sid, capture);
+        if (newTaskId) {
+          markCaptureExecuted(basePath, capture.id);
+          result.injected++;
+          result.actions.push(`Injected ${newTaskId} from ${capture.id}: "${capture.text}"`);
+        } else {
+          result.actions.push(`Failed to inject ${capture.id}: "${capture.text}" (no plan file or parse error)`);
+        }
+        break;
+      }
+      case "replan": {
+        const success = executeReplan(basePath, mid, sid, capture);
+        if (success) {
+          markCaptureExecuted(basePath, capture.id);
+          result.replanned++;
+          result.actions.push(`Replan triggered from ${capture.id}: "${capture.text}"`);
+        } else {
+          result.actions.push(`Failed to trigger replan from ${capture.id}: "${capture.text}"`);
+        }
+        break;
+      }
+      case "quick-task": {
+        // Quick-tasks are collected for dispatch, not executed inline
+        result.quickTasks.push(capture);
+        result.actions.push(`Quick-task queued from ${capture.id}: "${capture.text}"`);
+        break;
+      }
+    }
+  }
+
+  return result;
+}

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/gsd/visualizer-overlay.ts

@@ -112,6 +112,13 @@ export class GSDVisualizerOverlay {
       return;
     }
 
+    if (matchesKey(data, Key.shift("tab"))) {
+      this.activeTab = (this.activeTab - 1 + TAB_COUNT) % TAB_COUNT;
+      this.invalidate();
+      this.tui.requestRender();
+      return;
+    }
+
     if (matchesKey(data, Key.tab)) {
       this.activeTab = (this.activeTab + 1) % TAB_COUNT;
       this.invalidate();
@@ -300,7 +307,7 @@ export class GSDVisualizerOverlay {
     const lines = this.wrapInBox(visibleContent, width);
 
     // Footer hint
-    const hint = th.fg("dim", "Tab/1-7 switch · / filter · ↑↓ scroll · g/G top/end · esc close");
+    const hint = th.fg("dim", "Tab/Shift+Tab/1-7 switch · / filter · ↑↓ scroll · g/G top/end · esc close");
     const hintVis = visibleWidth(hint);
     const hintPad = Math.max(0, Math.floor((width - hintVis) / 2));
     lines.push(" ".repeat(hintPad) + hint);

package/src/resources/extensions/gsd/workspace-index.ts

@@ -103,10 +103,21 @@ async function indexSlice(basePath: string, milestoneId: string, sliceId: string
   };
 }
 
-export async function indexWorkspace(basePath: string): Promise<GSDWorkspaceIndex> {
+export interface IndexWorkspaceOptions {
+  /**
+   * When true, run validatePlanBoundary and validateCompleteBoundary for each slice.
+   * Skipped by default — validation is expensive (content analysis) and only needed
+   * for explicit doctor/audit flows. The /gsd status dashboard and scope pickers
+   * don't need the full issue list.
+   */
+  validate?: boolean;
+}
+
+export async function indexWorkspace(basePath: string, opts: IndexWorkspaceOptions = {}): Promise<GSDWorkspaceIndex> {
   const milestoneIds = findMilestoneIds(basePath);
   const milestones: WorkspaceMilestoneTarget[] = [];
   const validationIssues: ValidationIssue[] = [];
+  const runValidation = opts.validate === true;
 
   for (const milestoneId of milestoneIds) {
     const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP") ?? undefined;
@@ -118,11 +129,27 @@ export async function indexWorkspace(basePath: string): Promise<GSDWorkspaceInde
       if (roadmapContent) {
         const roadmap = parseRoadmap(roadmapContent);
         title = titleFromRoadmapHeader(roadmapContent, milestoneId);
-        for (const slice of roadmap.slices) {
-          const indexedSlice = await indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done);
+
+        // Parallelise all per-slice I/O: indexSlice + (optional) validation calls run concurrently.
+        // Order is preserved via Promise.all on an array built from roadmap.slices.
+        const sliceResults = await Promise.all(
+          roadmap.slices.map(async (slice) => {
+            if (runValidation) {
+              const [indexedSlice, planIssues, completeIssues] = await Promise.all([
+                indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done),
+                validatePlanBoundary(basePath, milestoneId, slice.id),
+                validateCompleteBoundary(basePath, milestoneId, slice.id),
+              ]);
+              return { indexedSlice, issues: [...planIssues, ...completeIssues] };
+            }
+            const indexedSlice = await indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done);
+            return { indexedSlice, issues: [] as ValidationIssue[] };
+          }),
+        );
+
+        for (const { indexedSlice, issues } of sliceResults) {
           slices.push(indexedSlice);
-          validationIssues.push(...await validatePlanBoundary(basePath, milestoneId, slice.id));
-          validationIssues.push(...await validateCompleteBoundary(basePath, milestoneId, slice.id));
+          validationIssues.push(...issues);
         }
       }
     }
@@ -173,7 +200,8 @@ export async function listDoctorScopeSuggestions(basePath: string): Promise<Arra
 }
 
 export async function getSuggestedNextCommands(basePath: string): Promise<string[]> {
-  const index = await indexWorkspace(basePath);
+  // Run validation here since we surface a /gsd doctor audit hint when issues exist.
+  const index = await indexWorkspace(basePath, { validate: true });
   const scope = index.active.milestoneId && index.active.sliceId
     ? `${index.active.milestoneId}/${index.active.sliceId}`
     : index.active.milestoneId;

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;
+}