gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/md-importer.ts

@@ -11,17 +11,26 @@ import {
   upsertDecision,
   upsertRequirement,
   insertArtifact,
+  insertMilestone,
+  insertSlice,
+  insertTask,
   openDatabase,
   transaction,
   _getAdapter,
 } from './gsd-db.js';
 import {
   resolveGsdRootFile,
+  resolveMilestoneFile,
+  resolveSliceFile,
+  resolveSlicePath,
+  resolveTasksDir,
   milestonesDir,
   gsdRoot,
   resolveTaskFiles,
 } from './paths.js';
 import { findMilestoneIds } from './guided-flow.js';
+import { parseRoadmap, parsePlan } from './parsers-legacy.js';
+import { parseContextDependsOn } from './files.js';
 
 // ─── DECISIONS.md Parser ───────────────────────────────────────────────────
 
@@ -480,6 +489,198 @@ function findFileByPrefixAndSuffix(dir: string, idPrefix: string, suffix: string
   }
 }
 
+// ─── Hierarchy Migration (milestones/slices/tasks from roadmaps+plans) ────
+
+/**
+ * Walk .gsd/milestones/ dirs, parse roadmaps and plans, and populate
+ * the milestones/slices/tasks DB tables.
+ *
+ * - Milestone title: from roadmap H1 (e.g. "# M001: Title") or CONTEXT.md
+ * - Milestone status: 'complete' if SUMMARY exists, 'parked' if PARKED exists, else 'active'
+ * - Milestone depends_on: from CONTEXT.md frontmatter
+ * - Slice metadata: from parseRoadmap() — id, title, risk, depends, done, demo
+ * - Task metadata: from parsePlan() — id, title, done, estimate
+ *
+ * Uses INSERT OR IGNORE for idempotency. Insert order: milestones → slices → tasks.
+ * Ghost milestones (dirs with no CONTEXT, ROADMAP, or SUMMARY) are skipped.
+ *
+ * Returns count of inserted hierarchy items.
+ */
+export function migrateHierarchyToDb(basePath: string): {
+  milestones: number;
+  slices: number;
+  tasks: number;
+} {
+  const counts = { milestones: 0, slices: 0, tasks: 0 };
+  const milestoneIds = findMilestoneIds(basePath);
+
+  for (const milestoneId of milestoneIds) {
+    // Check for ghost milestones — skip dirs with no meaningful content
+    const roadmapPath = resolveMilestoneFile(basePath, milestoneId, 'ROADMAP');
+    const contextPath = resolveMilestoneFile(basePath, milestoneId, 'CONTEXT');
+    const summaryPath = resolveMilestoneFile(basePath, milestoneId, 'SUMMARY');
+    const parkedPath = resolveMilestoneFile(basePath, milestoneId, 'PARKED');
+
+    const hasRoadmap = roadmapPath !== null && existsSync(roadmapPath);
+    const hasContext = contextPath !== null && existsSync(contextPath);
+    const hasSummary = summaryPath !== null && existsSync(summaryPath);
+    const hasParked = parkedPath !== null && existsSync(parkedPath);
+
+    // Ghost milestone: no CONTEXT, ROADMAP, or SUMMARY → skip
+    if (!hasRoadmap && !hasContext && !hasSummary) continue;
+
+    // Determine milestone status
+    let milestoneStatus = 'active';
+    if (hasSummary) milestoneStatus = 'complete';
+    else if (hasParked) milestoneStatus = 'parked';
+
+    // Determine milestone title from roadmap H1 or CONTEXT heading
+    let milestoneTitle = '';
+    let roadmapContent: string | null = null;
+    let roadmap: ReturnType<typeof parseRoadmap> | null = null;
+    if (hasRoadmap) {
+      roadmapContent = readFileSync(roadmapPath!, 'utf-8');
+      roadmap = parseRoadmap(roadmapContent);
+      milestoneTitle = roadmap.title;
+    }
+    if (!milestoneTitle && hasContext) {
+      const contextContent = readFileSync(contextPath!, 'utf-8');
+      const h1Match = contextContent.match(/^#\s+(.+)/m);
+      if (h1Match) milestoneTitle = h1Match[1].trim();
+    }
+
+    // Determine depends_on from CONTEXT frontmatter
+    let dependsOn: string[] = [];
+    if (hasContext) {
+      const contextContent = readFileSync(contextPath!, 'utf-8');
+      dependsOn = parseContextDependsOn(contextContent);
+    }
+
+    // Extract raw "## Boundary Map" section from roadmap markdown for planning column
+    let boundaryMapSection = '';
+    if (roadmapContent) {
+      const bmIdx = roadmapContent.indexOf('## Boundary Map');
+      if (bmIdx >= 0) {
+        const afterBm = roadmapContent.slice(bmIdx);
+        // Take content until next ## heading or EOF
+        const nextHeading = afterBm.indexOf('\n## ', 1);
+        boundaryMapSection = nextHeading >= 0 ? afterBm.slice(0, nextHeading).trim() : afterBm.trim();
+      }
+    }
+
+    // Insert milestone (FK parent — must come first)
+    insertMilestone({
+      id: milestoneId,
+      title: milestoneTitle,
+      status: milestoneStatus,
+      depends_on: dependsOn,
+      planning: {
+        vision: roadmap?.vision ?? '',
+        successCriteria: roadmap?.successCriteria ?? [],
+        boundaryMapMarkdown: boundaryMapSection,
+      },
+    });
+    counts.milestones++;
+
+    // Parse roadmap for slices
+    if (!roadmap) continue;
+
+    for (const sliceEntry of roadmap.slices) {
+      // Per K002: use 'complete' not 'done'
+      const sliceStatus = sliceEntry.done ? 'complete' : 'pending';
+
+      // Parse slice plan early so goal is available for insertSlice planning column
+      const planPath = resolveSliceFile(basePath, milestoneId, sliceEntry.id, 'PLAN');
+      let plan: ReturnType<typeof parsePlan> | null = null;
+      if (planPath && existsSync(planPath)) {
+        const planContent = readFileSync(planPath, 'utf-8');
+        plan = parsePlan(planContent);
+      }
+
+      insertSlice({
+        id: sliceEntry.id,
+        milestoneId: milestoneId,
+        title: sliceEntry.title,
+        status: sliceStatus,
+        risk: sliceEntry.risk,
+        depends: sliceEntry.depends,
+        demo: sliceEntry.demo,
+        planning: {
+          goal: plan?.goal ?? '',
+        },
+      });
+      counts.slices++;
+
+      // Insert tasks from parsed plan
+      if (!plan) continue;
+
+      for (const taskEntry of plan.tasks) {
+        // Per K002: use 'complete' not 'done'
+        let taskStatus: string = taskEntry.done ? 'complete' : 'pending';
+
+        // Pre-migration consistency: if task is marked done in the plan but has
+        // no summary file on disk, import as 'pending' so it gets re-executed
+        // rather than silently importing bad state as the new DB authority.
+        if (taskStatus === 'complete') {
+          const tDir = resolveTasksDir(basePath, milestoneId, sliceEntry.id);
+          if (tDir) {
+            const summaryFile = join(tDir, `${taskEntry.id}-SUMMARY.md`);
+            if (!existsSync(summaryFile)) {
+              taskStatus = 'pending';
+              process.stderr.write(
+                `gsd-migrate: ${milestoneId}/${sliceEntry.id}/${taskEntry.id} marked done but missing summary — importing as pending\n`,
+              );
+            }
+          }
+        }
+
+        insertTask({
+          id: taskEntry.id,
+          sliceId: sliceEntry.id,
+          milestoneId: milestoneId,
+          title: taskEntry.title,
+          status: taskStatus,
+          planning: {
+            files: taskEntry.files ?? [],
+            verify: taskEntry.verify ?? '',
+          },
+        });
+        counts.tasks++;
+      }
+
+      // Pre-migration consistency: if all tasks are done and the slice
+      // summary exists but the roadmap checkbox is unchecked, upgrade the
+      // slice to complete. This handles the common
+      // "all_tasks_done_roadmap_not_checked" inconsistency that the old
+      // doctor would have auto-fixed. Without a slice summary, the slice
+      // is in the "summarizing" phase, not complete.
+      if (!sliceEntry.done) {
+        const sliceSummaryPath = resolveSliceFile(basePath, milestoneId, sliceEntry.id, 'SUMMARY');
+        const hasSliceSummary = sliceSummaryPath !== null && existsSync(sliceSummaryPath);
+        const allTasksDone = plan.tasks.length > 0 && plan.tasks.every(t => {
+          const tDir = resolveTasksDir(basePath, milestoneId, sliceEntry.id);
+          if (!tDir) return t.done;
+          const summaryFile = join(tDir, `${t.id}-SUMMARY.md`);
+          return t.done && existsSync(summaryFile);
+        });
+        if (allTasksDone && hasSliceSummary) {
+          const adapter = _getAdapter();
+          if (adapter) {
+            adapter.prepare(
+              `UPDATE slices SET status = 'complete' WHERE id = :sid AND milestone_id = :mid`,
+            ).run({ ':sid': sliceEntry.id, ':mid': milestoneId });
+            process.stderr.write(
+              `gsd-migrate: ${milestoneId}/${sliceEntry.id} all tasks + slice summary complete — upgrading slice to complete\n`,
+            );
+          }
+        }
+      }
+    }
+  }
+
+  return counts;
+}
+
 // ─── Orchestrator ──────────────────────────────────────────────────────────
 
 /**
@@ -493,6 +694,7 @@ export function migrateFromMarkdown(gsdDir: string): {
   decisions: number;
   requirements: number;
   artifacts: number;
+  hierarchy: { milestones: number; slices: number; tasks: number };
 } {
   const dbPath = join(gsdRoot(gsdDir), 'gsd.db');
 
@@ -504,6 +706,7 @@ export function migrateFromMarkdown(gsdDir: string): {
   let decisions = 0;
   let requirements = 0;
   let artifacts = 0;
+  let hierarchy = { milestones: 0, slices: 0, tasks: 0 };
 
   transaction(() => {
     try {
@@ -523,11 +726,17 @@ export function migrateFromMarkdown(gsdDir: string): {
     } catch (err) {
       process.stderr.write(`gsd-migrate: skipping artifacts import: ${(err as Error).message}\n`);
     }
+
+    try {
+      hierarchy = migrateHierarchyToDb(gsdDir);
+    } catch (err) {
+      process.stderr.write(`gsd-migrate: skipping hierarchy migration: ${(err as Error).message}\n`);
+    }
   });
 
   process.stderr.write(
-    `gsd-migrate: imported ${decisions} decisions, ${requirements} requirements, ${artifacts} artifacts\n`,
+    `gsd-migrate: imported ${decisions} decisions, ${requirements} requirements, ${artifacts} artifacts, ${hierarchy.milestones}M/${hierarchy.slices}S/${hierarchy.tasks}T hierarchy\n`,
   );
 
-  return { decisions, requirements, artifacts };
+  return { decisions, requirements, artifacts, hierarchy };
 }

package/src/resources/extensions/gsd/native-git-bridge.ts

@@ -58,6 +58,8 @@ interface GitBatchInfo {
 interface GitMergeResult {
   success: boolean;
   conflicts: string[];
+  /** Filenames extracted from git stderr when a dirty working tree blocks the merge (#2151). */
+  dirtyFiles?: string[];
 }
 
 // ─── Native Module Loading ──────────────────────────────────────────────────
@@ -863,7 +865,16 @@ export function nativeMergeSquash(basePath: string, branch: string): GitMergeRes
       stderr.includes("not possible because you have unmerged files") ||
       stderr.includes("overwritten by merge")
     ) {
-      return { success: false, conflicts: ["__dirty_working_tree__"] };
+      // Extract filenames from git stderr so callers can report which files
+      // are dirty instead of generically blaming .gsd/ (#2151).
+      // Git lists them as tab-indented lines between the "would be overwritten"
+      // header and the "Please commit" footer.
+      const dirtyFiles = stderr
+        .split("\n")
+        .filter((line) => line.startsWith("\t"))
+        .map((line) => line.trim())
+        .filter(Boolean);
+      return { success: false, conflicts: ["__dirty_working_tree__"], dirtyFiles };
     }
 
     // Check for real content conflicts

package/src/resources/extensions/gsd/parallel-eligibility.ts

@@ -6,9 +6,9 @@
  */
 
 import { deriveState } from "./state.js";
-import { parseRoadmap, parsePlan, loadFile } from "./files.js";
 import { resolveMilestoneFile, resolveSliceFile } from "./paths.js";
 import { findMilestoneIds } from "./guided-flow.js";
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import type { MilestoneRegistryEntry } from "./types.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
@@ -36,27 +36,23 @@ async function collectTouchedFiles(
   basePath: string,
   milestoneId: string,
 ): Promise<string[]> {
-  const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
-  if (!roadmapPath) return [];
-
-  const roadmapContent = await loadFile(roadmapPath);
-  if (!roadmapContent) return [];
-
-  const roadmap = parseRoadmap(roadmapContent);
   const files = new Set<string>();
 
-  for (const slice of roadmap.slices) {
-    const planPath = resolveSliceFile(basePath, milestoneId, slice.id, "PLAN");
-    if (!planPath) continue;
-
-    const planContent = await loadFile(planPath);
-    if (!planContent) continue;
-
-    const plan = parsePlan(planContent);
-    for (const f of plan.filesLikelyTouched) {
-      files.add(f);
+  if (isDbAvailable()) {
+    // DB path: query slices and their tasks for file lists
+    const slices = getMilestoneSlices(milestoneId);
+    for (const slice of slices) {
+      const tasks = getSliceTasks(milestoneId, slice.id);
+      for (const task of tasks) {
+        if (Array.isArray(task.files)) {
+          for (const f of task.files) {
+            files.add(f);
+          }
+        }
+      }
     }
   }
+  // When DB unavailable, return empty file set — parallel eligibility cannot be determined
 
   return [...files];
 }

package/src/resources/extensions/gsd/parallel-orchestrator.ts

@@ -54,6 +54,7 @@ export interface WorkerInfo {
   state: "running" | "paused" | "stopped" | "error";
   completedUnits: number;
   cost: number;
+  cleanup?: () => void;
 }
 
 export interface OrchestratorState {
@@ -357,6 +358,16 @@ export async function startParallel(
 
   const config = resolveParallelConfig(prefs);
 
+  // Release any leftover state from a previous session before reassigning
+  if (state) {
+    for (const w of state.workers.values()) {
+      w.cleanup?.();
+      w.cleanup = undefined;
+      w.process = null;
+    }
+    state.workers.clear();
+  }
+
   // Try to restore from a previous crash
   const restored = restoreState(basePath);
   if (restored && restored.workers.length > 0) {
@@ -598,12 +609,26 @@ export function spawnWorker(
     worktreePath: worker.worktreePath,
   });
 
+  // Store cleanup function to remove all listeners from the child process.
+  // This prevents listener accumulation when workers are respawned, since
+  // handler closures capture milestoneId and other data that would otherwise
+  // be retained indefinitely.
+  worker.cleanup = () => {
+    child.stdout?.removeAllListeners();
+    child.stderr?.removeAllListeners();
+    child.removeAllListeners();
+  };
+
   // Handle worker exit
   child.on("exit", (code) => {
     if (!state) return;
     const w = state.workers.get(milestoneId);
     if (!w) return;
 
+    // Remove all stream listeners to release closure references
+    w.cleanup?.();
+    w.cleanup = undefined;
+
     w.process = null;
     if (w.state === "stopped") return; // graceful stop, already handled
 
@@ -795,6 +820,10 @@ export async function stopParallel(
       await waitForWorkerExit(worker, 250);
     }
 
+    // Remove stream listeners before releasing the process handle
+    worker.cleanup?.();
+    worker.cleanup = undefined;
+
     // Update in-memory state
     worker.state = "stopped";
     worker.process = null;
@@ -880,6 +909,8 @@ export function refreshWorkerStatuses(
   for (const mid of staleIds) {
     const worker = state.workers.get(mid);
     if (worker) {
+      worker.cleanup?.();
+      worker.cleanup = undefined;
       worker.state = "error";
       worker.process = null;
     }
@@ -897,6 +928,8 @@ export function refreshWorkerStatuses(
     const diskStatus = statusMap.get(mid);
     if (!diskStatus) {
       if (!isPidAlive(worker.pid)) {
+        worker.cleanup?.();
+        worker.cleanup = undefined;
         worker.state = worker.completedUnits > 0 ? "stopped" : "error";
         worker.process = null;
       }
@@ -938,5 +971,15 @@ export function isBudgetExceeded(): boolean {
 
 /** Reset orchestrator state. Called on clean shutdown. */
 export function resetOrchestrator(): void {
+  if (state) {
+    // Explicitly release all WorkerInfo references and run any pending
+    // cleanup callbacks so child process stream closures are freed.
+    for (const w of state.workers.values()) {
+      w.cleanup?.();
+      w.cleanup = undefined;
+      w.process = null;
+    }
+    state.workers.clear();
+  }
   state = null;
 }