gsd-pi 2.63.0-dev.026d309 → 2.63.0-dev.351157b

package/src/resources/extensions/gsd/roadmap-slices.ts

@@ -82,7 +82,7 @@ function parseTableSlices(section: string): RoadmapSliceEntry[] {
     const fullRow = line.toLowerCase();
     const done =
       /\[x\]/i.test(line) ||
-      /[✅☑✓]/.test(line) ||
+      /[✅☑✓✔]/.test(line) ||
       /\bdone\b/.test(fullRow) ||
       /\bcomplete(?:d)?\b/.test(fullRow);
 
@@ -222,11 +222,11 @@ function parseProseSliceHeaders(content: string): RoadmapSliceEntry[] {
   // numeric prefixes (e.g., "1.", "(1)"), bracketed IDs (e.g., "[S01]"),
   // optional checkmark completion marker, and optional leading indentation.
   // Separator after the ID is flexible: colon, dash, em/en dash, dot, or just whitespace.
-  const headerPattern = /^\s*#{1,4}\s+\*{0,2}(?:\u2713\s+)?(?:\d+[.)]\s+)?(?:\(\d+\)\s+)?(?:Slice\s+)?\[?(S\d+)\]?\*{0,2}[:\s.\u2014\u2013-]*\s*(.+)/gm;
+  const headerPattern = /^\s*#{1,4}\s+\*{0,2}(?:[\u2713\u2705]\s+)?(?:\d+[.)]\s+)?(?:\(\d+\)\s+)?(?:Slice\s+)?\[?(S\d+)\]?\*{0,2}[:\s.\u2014\u2013-]*\s*(.+)/gm;
   let match: RegExpExecArray | null;
 
   // Check for checkmark before the slice ID (e.g., "## checkmark S01: Title")
-  const prefixCheckPattern = /^\s*#{1,4}\s+\*{0,2}\u2713\s+/;
+  const prefixCheckPattern = /^\s*#{1,4}\s+\*{0,2}[\u2713\u2705]\s+/;
 
   while ((match = headerPattern.exec(content)) !== null) {
     const id = match[1]!;
@@ -240,9 +240,14 @@ function parseProseSliceHeaders(content: string): RoadmapSliceEntry[] {
     const line = match[0];
     let done = prefixCheckPattern.test(line);
 
-    if (!done && title.startsWith("\u2713")) {
+    if (!done && /^[\u2713\u2705]/.test(title)) {
       done = true;
-      title = title.replace(/^\u2713\s*/, "");
+      title = title.replace(/^[\u2713\u2705]\s*/, "");
+    }
+
+    if (!done && /[\u2705]\s*$/.test(title)) {
+      done = true;
+      title = title.replace(/\s*[\u2705]\s*$/, "");
     }
 
     if (!done && /\(Complete\)\s*$/i.test(title)) {

package/src/resources/extensions/gsd/slice-parallel-conflict.ts

@@ -0,0 +1,86 @@
+/**
+ * GSD Slice Parallel Conflict Detection — File overlap analysis between slices.
+ *
+ * Reads PLAN.md for each slice and extracts file paths mentioned in task
+ * descriptions. If two slices share more than 5 file paths, they are considered
+ * conflicting and should not run in parallel.
+ *
+ * Conservative by default: missing PLAN = block parallel execution.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── File Path Extraction ─────────────────────────────────────────────────────
+
+/**
+ * Extract file paths from a PLAN.md content string.
+ * Matches common patterns like `src/...`, `lib/...`, paths with extensions.
+ */
+function extractFilePaths(content: string): Set<string> {
+  const paths = new Set<string>();
+
+  // Match file-like patterns: word/word paths with extensions, or src/lib/etc prefixed paths
+  const patterns = [
+    // Paths like src/foo/bar.ts, lib/utils.js, etc.
+    /(?:src|lib|test|tests|app|pkg|cmd|internal|components|pages|api|utils|config|scripts|dist|build)\/[\w./-]+\.\w+/g,
+    // Generic path with at least one slash and extension
+    /(?<!\w)[\w-]+\/[\w./-]+\.\w{1,5}(?!\w)/g,
+  ];
+
+  for (const pattern of patterns) {
+    const matches = content.matchAll(pattern);
+    for (const match of matches) {
+      paths.add(match[0]);
+    }
+  }
+
+  return paths;
+}
+
+// ─── Conflict Detection ──────────────────────────────────────────────────────
+
+/**
+ * Check if two slices have file conflicts that would block parallel execution.
+ *
+ * @param basePath  Project root path.
+ * @param mid       Milestone ID.
+ * @param sliceA    First slice ID.
+ * @param sliceB    Second slice ID.
+ * @returns         true if parallel is unsafe (>5 shared files or missing plan).
+ */
+export function hasFileConflict(
+  basePath: string,
+  mid: string,
+  sliceA: string,
+  sliceB: string,
+): boolean {
+  const planPathA = join(basePath, ".gsd", "milestones", mid, sliceA, "PLAN.md");
+  const planPathB = join(basePath, ".gsd", "milestones", mid, sliceB, "PLAN.md");
+
+  // Conservative: missing PLAN = block
+  if (!existsSync(planPathA) || !existsSync(planPathB)) {
+    return true;
+  }
+
+  const contentA = readFileSync(planPathA, "utf-8");
+  const contentB = readFileSync(planPathB, "utf-8");
+
+  const filesA = extractFilePaths(contentA);
+  const filesB = extractFilePaths(contentB);
+
+  // If either has no files extracted, no conflict detectable → allow
+  if (filesA.size === 0 || filesB.size === 0) {
+    return false;
+  }
+
+  // Count shared files
+  let sharedCount = 0;
+  for (const file of filesA) {
+    if (filesB.has(file)) {
+      sharedCount++;
+    }
+  }
+
+  return sharedCount > 5;
+}

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

@@ -0,0 +1,73 @@
+/**
+ * GSD Slice Parallel Eligibility — Pure function to determine which slices
+ * within a milestone can run in parallel based on dependency satisfaction.
+ *
+ * This is the slice-level equivalent of parallel-eligibility.ts (which operates
+ * at milestone scope). The key difference is the positional fallback: slices
+ * without explicit dependencies use sequential ordering as an implicit constraint.
+ */
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface SliceInput {
+  id: string;
+  done: boolean;
+  depends: string[];
+}
+
+export interface EligibleSlice {
+  id: string;
+}
+
+// ─── Core Logic ───────────────────────────────────────────────────────────────
+
+/**
+ * Determine which slices are eligible for parallel execution.
+ *
+ * Rules:
+ * 1. Done slices are never eligible (nothing to do).
+ * 2. A slice with explicit `depends` entries is eligible when ALL deps
+ *    appear in `completedSliceIds`.
+ * 3. A slice with NO `depends` entries uses positional fallback: it is
+ *    eligible only when every positionally-earlier slice is done.
+ *    This preserves backward compatibility with roadmaps that don't
+ *    declare inter-slice dependencies.
+ *
+ * @param slices      All slices in the milestone (ordered by position).
+ * @param completedSliceIds  Set of slice IDs that are already complete.
+ * @returns           Array of eligible slice descriptors.
+ */
+export function getEligibleSlices(
+  slices: SliceInput[],
+  completedSliceIds: Set<string>,
+): EligibleSlice[] {
+  const eligible: EligibleSlice[] = [];
+
+  for (let i = 0; i < slices.length; i++) {
+    const slice = slices[i];
+
+    // Rule 1: skip done slices
+    if (slice.done) continue;
+
+    const hasExplicitDeps = slice.depends.length > 0;
+
+    if (hasExplicitDeps) {
+      // Rule 2: explicit dependencies — all must be satisfied
+      const allDepsSatisfied = slice.depends.every(dep => completedSliceIds.has(dep));
+      if (allDepsSatisfied) {
+        eligible.push({ id: slice.id });
+      }
+    } else {
+      // Rule 3: no deps declared — positional fallback
+      // Eligible only if all positionally-earlier slices are done
+      const allEarlierDone = slices.slice(0, i).every(
+        earlier => earlier.done || completedSliceIds.has(earlier.id),
+      );
+      if (allEarlierDone) {
+        eligible.push({ id: slice.id });
+      }
+    }
+  }
+
+  return eligible;
+}

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

@@ -0,0 +1,477 @@
+/**
+ * GSD Slice Parallel Orchestrator — Engine for parallel slice execution
+ * within a single milestone.
+ *
+ * Mirrors the existing parallel-orchestrator.ts pattern at slice scope
+ * instead of milestone scope. Workers are separate processes spawned via
+ * child_process, each running in its own git worktree with GSD_SLICE_LOCK
+ * + GSD_MILESTONE_LOCK env vars set.
+ *
+ * Key differences from milestone-level parallelism:
+ * - Scope: slices within one milestone, not milestones within a project
+ * - Lock env: GSD_SLICE_LOCK (in addition to GSD_MILESTONE_LOCK)
+ * - Conflict check: file overlap between slice plans (slice-parallel-conflict.ts)
+ */
+
+import { spawn, type ChildProcess } from "node:child_process";
+import {
+  appendFileSync,
+  existsSync,
+  writeFileSync,
+  readFileSync,
+  mkdirSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { gsdRoot } from "./paths.js";
+import { createWorktree, worktreePath, removeWorktree } from "./worktree-manager.js";
+import { autoWorktreeBranch, runWorktreePostCreateHook } from "./auto-worktree.js";
+import {
+  writeSessionStatus,
+  removeSessionStatus,
+} from "./session-status-io.js";
+import { hasFileConflict } from "./slice-parallel-conflict.js";
+import { getErrorMessage } from "./error-utils.js";
+
+// ─── Types ─────────────────────────────────────────────────────────────────
+
+export interface SliceWorkerInfo {
+  milestoneId: string;
+  sliceId: string;
+  pid: number;
+  process: ChildProcess | null;
+  worktreePath: string;
+  startedAt: number;
+  state: "running" | "stopped" | "error";
+  completedUnits: number;
+  cost: number;
+  cleanup?: () => void;
+}
+
+export interface SliceOrchestratorState {
+  active: boolean;
+  workers: Map<string, SliceWorkerInfo>;
+  totalCost: number;
+  budgetCeiling?: number;
+  maxWorkers: number;
+  startedAt: number;
+  basePath: string;
+}
+
+export interface StartSliceParallelOpts {
+  maxWorkers?: number;
+  budgetCeiling?: number;
+}
+
+// ─── Module State ──────────────────────────────────────────────────────────
+
+let sliceState: SliceOrchestratorState | null = null;
+
+// ─── Public API ────────────────────────────────────────────────────────────
+
+/**
+ * Check whether slice-level parallel is currently active.
+ */
+export function isSliceParallelActive(): boolean {
+  return sliceState?.active === true;
+}
+
+/**
+ * Get current slice orchestrator state (read-only snapshot).
+ */
+export function getSliceOrchestratorState(): SliceOrchestratorState | null {
+  return sliceState;
+}
+
+/**
+ * Start parallel execution for eligible slices within a milestone.
+ *
+ * For each eligible slice: create a worktree, spawn `gsd --mode json --print "/gsd auto"`
+ * with env GSD_SLICE_LOCK=<SID> + GSD_MILESTONE_LOCK=<MID> + GSD_PARALLEL_WORKER=1.
+ */
+export async function startSliceParallel(
+  basePath: string,
+  milestoneId: string,
+  eligibleSlices: Array<{ id: string }>,
+  opts: StartSliceParallelOpts = {},
+): Promise<{ started: string[]; errors: Array<{ sid: string; error: string }> }> {
+  // Prevent nesting: if already a parallel worker, refuse
+  if (process.env.GSD_PARALLEL_WORKER) {
+    return { started: [], errors: [{ sid: "all", error: "Cannot start slice-parallel from within a parallel worker" }] };
+  }
+
+  const maxWorkers = opts.maxWorkers ?? 2;
+  const budgetCeiling = opts.budgetCeiling;
+
+  // Initialize orchestrator state
+  sliceState = {
+    active: true,
+    workers: new Map(),
+    totalCost: 0,
+    budgetCeiling,
+    maxWorkers,
+    startedAt: Date.now(),
+    basePath,
+  };
+
+  const started: string[] = [];
+  const errors: Array<{ sid: string; error: string }> = [];
+
+  // Filter out conflicting slices (conservative: check all pairs)
+  const safeSlices = filterConflictingSlices(basePath, milestoneId, eligibleSlices);
+
+  // Limit to maxWorkers
+  const toSpawn = safeSlices.slice(0, maxWorkers);
+
+  for (const slice of toSpawn) {
+    try {
+      // Create worktree for this slice
+      const wtBranch = `slice/${milestoneId}/${slice.id}`;
+      const wtName = `${milestoneId}-${slice.id}`;
+      const wtPath = worktreePath(basePath, wtName);
+
+      if (!existsSync(wtPath)) {
+        createWorktree(basePath, wtName, { branch: wtBranch });
+      }
+
+      // Create worker info
+      const worker: SliceWorkerInfo = {
+        milestoneId,
+        sliceId: slice.id,
+        pid: 0,
+        process: null,
+        worktreePath: wtPath,
+        startedAt: Date.now(),
+        state: "running",
+        completedUnits: 0,
+        cost: 0,
+      };
+
+      sliceState.workers.set(slice.id, worker);
+
+      // Spawn worker
+      const spawned = spawnSliceWorker(basePath, milestoneId, slice.id);
+      if (spawned) {
+        started.push(slice.id);
+      } else {
+        errors.push({ sid: slice.id, error: "Failed to spawn worker process" });
+        worker.state = "error";
+      }
+    } catch (err) {
+      errors.push({ sid: slice.id, error: getErrorMessage(err) });
+      // Best-effort cleanup of partially created worktree
+      const wtName = `${milestoneId}-${slice.id}`;
+      try {
+        removeWorktree(basePath, wtName, { deleteBranch: true, force: true });
+      } catch { /* ignore cleanup failures */ }
+    }
+  }
+
+  // If nothing started, deactivate
+  if (started.length === 0) {
+    sliceState.active = false;
+  }
+
+  return { started, errors };
+}
+
+/**
+ * Stop all slice-parallel workers and deactivate.
+ */
+export function stopSliceParallel(): void {
+  if (!sliceState) return;
+
+  for (const worker of sliceState.workers.values()) {
+    if (worker.process) {
+      try {
+        worker.process.kill("SIGTERM");
+      } catch { /* already dead */ }
+    }
+    worker.cleanup?.();
+    worker.cleanup = undefined;
+    worker.process = null;
+    worker.state = "stopped";
+
+    // Clean up worktree created for this worker
+    const wtName = `${worker.milestoneId}-${worker.sliceId}`;
+    try {
+      removeWorktree(sliceState.basePath, wtName, { deleteBranch: true, force: true });
+    } catch { /* best-effort cleanup */ }
+  }
+
+  sliceState.active = false;
+}
+
+/**
+ * Get aggregate cost across all slice workers.
+ */
+export function getSliceAggregateCost(): number {
+  if (!sliceState) return 0;
+  let total = 0;
+  for (const w of sliceState.workers.values()) {
+    total += w.cost;
+  }
+  return total;
+}
+
+/**
+ * Check if budget ceiling has been exceeded.
+ */
+export function isSliceBudgetExceeded(): boolean {
+  if (!sliceState?.budgetCeiling) return false;
+  return getSliceAggregateCost() >= sliceState.budgetCeiling;
+}
+
+/**
+ * Reset module state (for testing).
+ */
+export function resetSliceOrchestrator(): void {
+  if (sliceState) {
+    for (const w of sliceState.workers.values()) {
+      w.cleanup?.();
+    }
+  }
+  sliceState = null;
+}
+
+// ─── Internal: Conflict Filtering ──────────────────────────────────────────
+
+/**
+ * Remove slices that have file conflicts with each other.
+ * Greedy: add slices to the safe set in order; skip any that conflict
+ * with an already-included slice.
+ */
+function filterConflictingSlices(
+  basePath: string,
+  milestoneId: string,
+  slices: Array<{ id: string }>,
+): Array<{ id: string }> {
+  const safe: Array<{ id: string }> = [];
+
+  for (const candidate of slices) {
+    let conflictsWithSafe = false;
+    for (const existing of safe) {
+      if (hasFileConflict(basePath, milestoneId, candidate.id, existing.id)) {
+        conflictsWithSafe = true;
+        break;
+      }
+    }
+    if (!conflictsWithSafe) {
+      safe.push(candidate);
+    }
+  }
+
+  return safe;
+}
+
+// ─── Internal: Worker Spawning ─────────────────────────────────────────────
+
+/**
+ * Resolve the GSD CLI binary path.
+ * Same logic as parallel-orchestrator.ts resolveGsdBin().
+ */
+function resolveGsdBin(): string | null {
+  if (process.env.GSD_BIN_PATH && existsSync(process.env.GSD_BIN_PATH)) {
+    return process.env.GSD_BIN_PATH;
+  }
+
+  let thisDir: string;
+  try {
+    thisDir = dirname(fileURLToPath(import.meta.url));
+  } catch {
+    thisDir = process.cwd();
+  }
+  const candidates = [
+    join(thisDir, "..", "..", "..", "loader.js"),
+    join(thisDir, "..", "..", "..", "..", "dist", "loader.js"),
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+/**
+ * Spawn a worker process for a slice.
+ * The worker runs `gsd --mode json --print "/gsd auto"` in the slice's worktree
+ * with GSD_SLICE_LOCK, GSD_MILESTONE_LOCK, and GSD_PARALLEL_WORKER set.
+ */
+function spawnSliceWorker(
+  basePath: string,
+  milestoneId: string,
+  sliceId: string,
+): boolean {
+  if (!sliceState) return false;
+  const worker = sliceState.workers.get(sliceId);
+  if (!worker) return false;
+  if (worker.process) return true;
+
+  const binPath = resolveGsdBin();
+  if (!binPath) return false;
+
+  let child: ChildProcess;
+  try {
+    child = spawn(process.execPath, [binPath, "--mode", "json", "--print", "/gsd auto"], {
+      cwd: worker.worktreePath,
+      env: {
+        ...process.env,
+        GSD_SLICE_LOCK: sliceId,
+        GSD_MILESTONE_LOCK: milestoneId,
+        GSD_PROJECT_ROOT: basePath,
+        GSD_PARALLEL_WORKER: "1",
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false,
+    });
+  } catch {
+    return false;
+  }
+
+  child.on("error", () => {
+    if (!sliceState) return;
+    const w = sliceState.workers.get(sliceId);
+    if (w) {
+      w.process = null;
+    }
+  });
+
+  worker.process = child;
+  worker.pid = child.pid ?? 0;
+
+  if (!child.pid) {
+    worker.process = null;
+    return false;
+  }
+
+  // ── NDJSON stdout monitoring ────────────────────────────────────────
+  if (child.stdout) {
+    let stdoutBuffer = "";
+    child.stdout.on("data", (data: Buffer) => {
+      stdoutBuffer += data.toString();
+      const lines = stdoutBuffer.split("\n");
+      stdoutBuffer = lines.pop() || "";
+      for (const line of lines) {
+        processSliceWorkerLine(basePath, milestoneId, sliceId, line);
+      }
+    });
+    child.stdout.on("close", () => {
+      if (stdoutBuffer.trim()) {
+        processSliceWorkerLine(basePath, milestoneId, sliceId, stdoutBuffer);
+      }
+    });
+  }
+
+  if (child.stderr) {
+    child.stderr.on("data", (data: Buffer) => {
+      appendSliceWorkerLog(basePath, milestoneId, sliceId, data.toString());
+    });
+  }
+
+  // Update session status
+  writeSessionStatus(basePath, {
+    milestoneId: `${milestoneId}/${sliceId}`,
+    pid: worker.pid,
+    state: "running",
+    currentUnit: null,
+    completedUnits: worker.completedUnits,
+    cost: worker.cost,
+    lastHeartbeat: Date.now(),
+    startedAt: worker.startedAt,
+    worktreePath: worker.worktreePath,
+  });
+
+  // Store cleanup function
+  worker.cleanup = () => {
+    child.stdout?.removeAllListeners();
+    child.stderr?.removeAllListeners();
+    child.removeAllListeners();
+  };
+
+  // Handle worker exit
+  child.on("exit", (code) => {
+    if (!sliceState) return;
+    const w = sliceState.workers.get(sliceId);
+    if (!w) return;
+
+    w.cleanup?.();
+    w.cleanup = undefined;
+    w.process = null;
+
+    if (w.state === "stopped") return;
+
+    if (code === 0) {
+      w.state = "stopped";
+    } else {
+      w.state = "error";
+      appendSliceWorkerLog(basePath, milestoneId, sliceId,
+        `\n[slice-orchestrator] worker exited with code ${code ?? "null"}\n`);
+    }
+
+    writeSessionStatus(basePath, {
+      milestoneId: `${milestoneId}/${sliceId}`,
+      pid: w.pid,
+      state: w.state,
+      currentUnit: null,
+      completedUnits: w.completedUnits,
+      cost: w.cost,
+      lastHeartbeat: Date.now(),
+      startedAt: w.startedAt,
+      worktreePath: w.worktreePath,
+    });
+  });
+
+  return true;
+}
+
+// ─── NDJSON Processing ──────────────────────────────────────────────────────
+
+/**
+ * Process a single NDJSON line from a slice worker's stdout.
+ * Extracts cost from message_end events.
+ */
+function processSliceWorkerLine(
+  _basePath: string,
+  _milestoneId: string,
+  sliceId: string,
+  line: string,
+): void {
+  if (!line.trim() || !sliceState) return;
+
+  let event: Record<string, unknown>;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return;
+  }
+
+  const type = String(event.type ?? "");
+  if (type === "message_end") {
+    const worker = sliceState.workers.get(sliceId);
+    if (worker) {
+      const usage = event.usage as Record<string, unknown> | undefined;
+      if (usage?.cost && typeof usage.cost === "number") {
+        worker.cost += usage.cost;
+        sliceState.totalCost += usage.cost;
+      }
+      worker.completedUnits++;
+    }
+  }
+}
+
+// ─── Logging ────────────────────────────────────────────────────────────────
+
+function sliceLogDir(basePath: string): string {
+  return join(gsdRoot(basePath), "parallel", "slice-logs");
+}
+
+function appendSliceWorkerLog(
+  basePath: string,
+  milestoneId: string,
+  sliceId: string,
+  text: string,
+): void {
+  const dir = sliceLogDir(basePath);
+  mkdirSync(dir, { recursive: true });
+  appendFileSync(join(dir, `${milestoneId}-${sliceId}.log`), text);
+}