gsd-pi 2.23.0 → 2.25.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-ui.ts

@@ -135,7 +135,7 @@ export async function showTriageConfirmation(
       recommended: cls === proposed,
     }));
 
-    const choice = await showNextAction(ctx as any, {
+    const choice = await showNextAction(ctx, {
       title: `Triage: ${result.captureId}`,
       summary,
       actions,

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-data.ts

@@ -1,25 +1,32 @@
 // Data loader for workflow visualizer overlay — aggregates state + metrics.
 
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import { deriveState } from './state.js';
 import { parseRoadmap, parsePlan, parseSummary, loadFile } from './files.js';
 import { findMilestoneIds } from './guided-flow.js';
-import { resolveMilestoneFile, resolveSliceFile } from './paths.js';
+import { resolveMilestoneFile, resolveSliceFile, resolveGsdRootFile } from './paths.js';
 import {
   getLedger,
   getProjectTotals,
   aggregateByPhase,
   aggregateBySlice,
   aggregateByModel,
+  aggregateByTier,
+  formatTierSavings,
   loadLedgerFromDisk,
   classifyUnitPhase,
 } from './metrics.js';
+import { loadAllCaptures, countPendingCaptures } from './captures.js';
+import { loadEffectiveGSDPreferences } from './preferences.js';
 
 import type { Phase } from './types.js';
+import type { CaptureEntry } from './captures.js';
 import type {
   ProjectTotals,
   PhaseAggregate,
   SliceAggregate,
   ModelAggregate,
+  TierAggregate,
   UnitMetrics,
 } from './metrics.js';
 
@@ -48,6 +55,7 @@ export interface VisualizerTask {
   title: string;
   done: boolean;
   active: boolean;
+  estimate?: string;
 }
 
 export interface CriticalPathInfo {
@@ -81,6 +89,71 @@ export interface ChangelogInfo {
   entries: ChangelogEntry[];
 }
 
+export interface VisualizerSliceRef {
+  milestoneId: string;
+  sliceId: string;
+  title: string;
+}
+
+export interface VisualizerSliceActivity extends VisualizerSliceRef {
+  completedAt: string;
+}
+
+export interface VisualizerStats {
+  missingCount: number;
+  missingSlices: VisualizerSliceRef[];
+  updatedCount: number;
+  updatedSlices: VisualizerSliceActivity[];
+  recentEntries: ChangelogEntry[];
+}
+
+export type DiscussionState = 'undiscussed' | 'draft' | 'discussed';
+
+export interface VisualizerDiscussionState {
+  milestoneId: string;
+  title: string;
+  state: DiscussionState;
+  hasContext: boolean;
+  hasDraft: boolean;
+  lastUpdated: string | null;
+}
+
+export interface SliceVerification {
+  milestoneId: string;
+  sliceId: string;
+  verificationResult: string;
+  blockerDiscovered: boolean;
+  keyDecisions: string[];
+  patternsEstablished: string[];
+  provides: string[];
+  requires: { slice: string; provides: string }[];
+}
+
+export interface KnowledgeInfo {
+  rules: { id: string; scope: string; content: string }[];
+  patterns: { id: string; content: string }[];
+  lessons: { id: string; content: string }[];
+  exists: boolean;
+}
+
+export interface CapturesInfo {
+  entries: CaptureEntry[];
+  pendingCount: number;
+  totalCount: number;
+}
+
+export interface HealthInfo {
+  budgetCeiling: number | undefined;
+  tokenProfile: string;
+  truncationRate: number;
+  continueHereRate: number;
+  tierBreakdown: TierAggregate[];
+  tierSavingsLine: string;
+  toolCalls: number;
+  assistantMessages: number;
+  userMessages: number;
+}
+
 export interface VisualizerData {
   milestones: VisualizerMilestone[];
   phase: Phase;
@@ -88,11 +161,19 @@ export interface VisualizerData {
   byPhase: PhaseAggregate[];
   bySlice: SliceAggregate[];
   byModel: ModelAggregate[];
+  byTier: TierAggregate[];
+  tierSavingsLine: string;
   units: UnitMetrics[];
   criticalPath: CriticalPathInfo;
   remainingSliceCount: number;
   agentActivity: AgentActivityInfo | null;
   changelog: ChangelogInfo;
+  sliceVerifications: SliceVerification[];
+  knowledge: KnowledgeInfo;
+  captures: CapturesInfo;
+  health: HealthInfo;
+  discussion: VisualizerDiscussionState[];
+  stats: VisualizerStats;
 }
 
 // ─── Critical Path ────────────────────────────────────────────────────────────
@@ -334,12 +415,18 @@ function loadAgentActivity(units: UnitMetrics[], milestones: VisualizerMilestone
   };
 }
 
-// ─── Changelog ───────────────────────────────────────────────────────────────
+// ─── Changelog & Verifications ────────────────────────────────────────────────
 
-const changelogCache = new Map<string, { mtime: number; entry: ChangelogEntry }>();
+const changelogCache = new Map<string, { mtime: number; entry: ChangelogEntry; verification: SliceVerification }>();
 
-async function loadChangelog(basePath: string, milestones: VisualizerMilestone[]): Promise<ChangelogInfo> {
+interface ChangelogAndVerifications {
+  changelog: ChangelogInfo;
+  verifications: SliceVerification[];
+}
+
+async function loadChangelogAndVerifications(basePath: string, milestones: VisualizerMilestone[]): Promise<ChangelogAndVerifications> {
   const entries: ChangelogEntry[] = [];
+  const verifications: SliceVerification[] = [];
 
   for (const ms of milestones) {
     for (const sl of ms.slices) {
@@ -348,11 +435,9 @@ async function loadChangelog(basePath: string, milestones: VisualizerMilestone[]
       const summaryFile = resolveSliceFile(basePath, ms.id, sl.id, 'SUMMARY');
       if (!summaryFile) continue;
 
-      // Check cache by file path
       const cacheKey = `${ms.id}/${sl.id}`;
       const cached = changelogCache.get(cacheKey);
 
-      // Check mtime for cache invalidation
       let mtime = 0;
       try {
         const { statSync } = await import('node:fs');
@@ -363,6 +448,7 @@ async function loadChangelog(basePath: string, milestones: VisualizerMilestone[]
 
       if (cached && cached.mtime === mtime) {
         entries.push(cached.entry);
+        verifications.push(cached.verification);
         continue;
       }
 
@@ -382,15 +468,184 @@ async function loadChangelog(basePath: string, milestones: VisualizerMilestone[]
         completedAt: String(summary.frontmatter.completed_at ?? ''),
       };
 
-      changelogCache.set(cacheKey, { mtime, entry });
+      const verification: SliceVerification = {
+        milestoneId: ms.id,
+        sliceId: sl.id,
+        verificationResult: summary.frontmatter.verification_result || '',
+        blockerDiscovered: summary.frontmatter.blocker_discovered,
+        keyDecisions: summary.frontmatter.key_decisions || [],
+        patternsEstablished: summary.frontmatter.patterns_established || [],
+        provides: summary.frontmatter.provides || [],
+        requires: (summary.frontmatter.requires || []).map(r => ({
+          slice: r.slice,
+          provides: r.provides,
+        })),
+      };
+
+      changelogCache.set(cacheKey, { mtime, entry, verification });
       entries.push(entry);
+      verifications.push(verification);
     }
   }
 
-  // Sort by completedAt descending
   entries.sort((a, b) => String(b.completedAt || '').localeCompare(String(a.completedAt || '')));
 
-  return { entries };
+  return { changelog: { entries }, verifications };
+}
+
+// ─── Knowledge Loader ─────────────────────────────────────────────────────────
+
+function loadKnowledge(basePath: string): KnowledgeInfo {
+  const knowledgePath = resolveGsdRootFile(basePath, 'KNOWLEDGE');
+  if (!existsSync(knowledgePath)) {
+    return { rules: [], patterns: [], lessons: [], exists: false };
+  }
+
+  let content: string;
+  try {
+    content = readFileSync(knowledgePath, 'utf-8');
+  } catch {
+    return { rules: [], patterns: [], lessons: [], exists: false };
+  }
+
+  const rules: { id: string; scope: string; content: string }[] = [];
+  const patterns: { id: string; content: string }[] = [];
+  const lessons: { id: string; content: string }[] = [];
+
+  const lines = content.split('\n');
+  let currentSection = '';
+
+  for (const line of lines) {
+    if (line.startsWith('## Rules')) { currentSection = 'rules'; continue; }
+    if (line.startsWith('## Patterns')) { currentSection = 'patterns'; continue; }
+    if (line.startsWith('## Lessons')) { currentSection = 'lessons'; continue; }
+    if (line.startsWith('## ')) { currentSection = ''; continue; }
+
+    if (!line.startsWith('| ') || line.startsWith('| ---') || line.startsWith('| ID')) continue;
+    const cols = line.split('|').map(c => c.trim()).filter(c => c.length > 0);
+    if (cols.length < 2) continue;
+
+    if (currentSection === 'rules' && cols.length >= 3) {
+      rules.push({ id: cols[0], scope: cols[1], content: cols[2] });
+    } else if (currentSection === 'patterns' && cols.length >= 2) {
+      patterns.push({ id: cols[0], content: cols[1] });
+    } else if (currentSection === 'lessons' && cols.length >= 2) {
+      lessons.push({ id: cols[0], content: cols[1] });
+    }
+  }
+
+  return { rules, patterns, lessons, exists: true };
+}
+
+// ─── Health Loader ────────────────────────────────────────────────────────────
+
+function loadHealth(units: UnitMetrics[], totals: ProjectTotals | null): HealthInfo {
+  const prefs = loadEffectiveGSDPreferences();
+  const budgetCeiling = prefs?.preferences?.budget_ceiling;
+  const tokenProfile = prefs?.preferences?.token_profile ?? 'standard';
+
+  let truncationRate = 0;
+  let continueHereRate = 0;
+  if (totals && totals.units > 0) {
+    truncationRate = (totals.totalTruncationSections / totals.units) * 100;
+    continueHereRate = (totals.continueHereFiredCount / totals.units) * 100;
+  }
+
+  const tierBreakdown = aggregateByTier(units);
+  const tierSavingsLine = formatTierSavings(units);
+
+  return {
+    budgetCeiling,
+    tokenProfile,
+    truncationRate,
+    continueHereRate,
+    tierBreakdown,
+    tierSavingsLine,
+    toolCalls: totals?.toolCalls ?? 0,
+    assistantMessages: totals?.assistantMessages ?? 0,
+    userMessages: totals?.userMessages ?? 0,
+  };
+}
+
+const RECENT_ENTRY_LIMIT = 3;
+const FEATURE_PREVIEW_LIMIT = 5;
+const UPDATED_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+
+function buildVisualizerStats(
+  milestones: VisualizerMilestone[],
+  entries: ChangelogEntry[],
+): VisualizerStats {
+  const missing: VisualizerSliceRef[] = [];
+  for (const ms of milestones) {
+    for (const sl of ms.slices) {
+      if (!sl.done) missing.push({ milestoneId: ms.id, sliceId: sl.id, title: sl.title });
+    }
+  }
+
+  const missingCount = missing.length;
+  const missingSlices = missing.slice(0, FEATURE_PREVIEW_LIMIT);
+
+  const now = Date.now();
+  const updatedEntries = entries.filter(entry => {
+    if (!entry.completedAt) return false;
+    const parsed = Date.parse(entry.completedAt);
+    return !Number.isNaN(parsed) && now - parsed <= UPDATED_WINDOW_MS;
+  });
+  const updatedCount = updatedEntries.length;
+  const updatedSlices = updatedEntries.slice(0, FEATURE_PREVIEW_LIMIT).map(entry => ({
+    milestoneId: entry.milestoneId,
+    sliceId: entry.sliceId,
+    title: entry.title,
+    completedAt: entry.completedAt,
+  }));
+
+  const recentEntries = entries.slice(0, RECENT_ENTRY_LIMIT);
+
+  return {
+    missingCount,
+    missingSlices,
+    updatedCount,
+    updatedSlices,
+    recentEntries,
+  };
+}
+
+function loadDiscussionState(
+  basePath: string,
+  milestones: VisualizerMilestone[],
+): VisualizerDiscussionState[] {
+  const states: VisualizerDiscussionState[] = [];
+
+  for (const ms of milestones) {
+    const contextPath = resolveMilestoneFile(basePath, ms.id, "CONTEXT");
+    const draftPath = resolveMilestoneFile(basePath, ms.id, "CONTEXT-DRAFT");
+    const state: DiscussionState = contextPath
+      ? "discussed"
+      : draftPath
+        ? "draft"
+        : "undiscussed";
+
+    let lastUpdated: string | null = null;
+    const target = contextPath ?? draftPath;
+    if (target) {
+      try {
+        lastUpdated = new Date(statSync(target).mtimeMs).toISOString();
+      } catch {
+        lastUpdated = null;
+      }
+    }
+
+    states.push({
+      milestoneId: ms.id,
+      title: ms.title,
+      state,
+      hasContext: !!contextPath,
+      hasDraft: !!draftPath,
+      lastUpdated,
+    });
+  }
+
+  return states;
 }
 
 // ─── Loader ───────────────────────────────────────────────────────────────────
@@ -433,6 +688,7 @@ export async function loadVisualizerData(basePath: string): Promise<VisualizerDa
                 title: t.title,
                 done: t.done,
                 active: state.activeTask?.id === t.id,
+                estimate: t.estimate || undefined,
               });
             }
           }
@@ -464,6 +720,8 @@ export async function loadVisualizerData(basePath: string): Promise<VisualizerDa
   let byPhase: PhaseAggregate[] = [];
   let bySlice: SliceAggregate[] = [];
   let byModel: ModelAggregate[] = [];
+  let byTier: TierAggregate[] = [];
+  let tierSavingsLine = '';
   let units: UnitMetrics[] = [];
 
   const ledger = getLedger() ?? loadLedgerFromDisk(basePath);
@@ -474,6 +732,8 @@ export async function loadVisualizerData(basePath: string): Promise<VisualizerDa
     byPhase = aggregateByPhase(units);
     bySlice = aggregateBySlice(units);
     byModel = aggregateByModel(units);
+    byTier = aggregateByTier(units);
+    tierSavingsLine = formatTierSavings(units);
   }
 
   // Compute new fields
@@ -487,7 +747,20 @@ export async function loadVisualizerData(basePath: string): Promise<VisualizerDa
   }
 
   const agentActivity = loadAgentActivity(units, milestones);
-  const changelog = await loadChangelog(basePath, milestones);
+  const { changelog, verifications: sliceVerifications } = await loadChangelogAndVerifications(basePath, milestones);
+
+  const knowledge = loadKnowledge(basePath);
+  const allCaptures = loadAllCaptures(basePath);
+  const pendingCount = countPendingCaptures(basePath);
+  const captures: CapturesInfo = {
+    entries: allCaptures,
+    pendingCount,
+    totalCount: allCaptures.length,
+  };
+
+  const health = loadHealth(units, totals);
+  const stats = buildVisualizerStats(milestones, changelog.entries);
+  const discussion = loadDiscussionState(basePath, milestones);
 
   return {
     milestones,
@@ -496,10 +769,18 @@ export async function loadVisualizerData(basePath: string): Promise<VisualizerDa
     byPhase,
     bySlice,
     byModel,
+    byTier,
+    tierSavingsLine,
     units,
     criticalPath,
     remainingSliceCount,
     agentActivity,
     changelog,
+    sliceVerifications,
+    knowledge,
+    captures,
+    health,
+    discussion,
+    stats,
   };
 }