gsd-pi 2.63.0 → 2.64.0-dev.05b8a94

package/dist/resources/extensions/gsd/slice-parallel-eligibility.js

@@ -0,0 +1,51 @@
+/**
+ * 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.
+ */
+// ─── 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, completedSliceIds) {
+    const eligible = [];
+    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/dist/resources/extensions/gsd/slice-parallel-orchestrator.js

@@ -0,0 +1,378 @@
+/**
+ * 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 } from "node:child_process";
+import { appendFileSync, existsSync, 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 { writeSessionStatus, } from "./session-status-io.js";
+import { hasFileConflict } from "./slice-parallel-conflict.js";
+import { getErrorMessage } from "./error-utils.js";
+// ─── Module State ──────────────────────────────────────────────────────────
+let sliceState = null;
+// ─── Public API ────────────────────────────────────────────────────────────
+/**
+ * Check whether slice-level parallel is currently active.
+ */
+export function isSliceParallelActive() {
+    return sliceState?.active === true;
+}
+/**
+ * Get current slice orchestrator state (read-only snapshot).
+ */
+export function getSliceOrchestratorState() {
+    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, milestoneId, eligibleSlices, opts = {}) {
+    // 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 = [];
+    const errors = [];
+    // 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 = {
+                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() {
+    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() {
+    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() {
+    if (!sliceState?.budgetCeiling)
+        return false;
+    return getSliceAggregateCost() >= sliceState.budgetCeiling;
+}
+/**
+ * Reset module state (for testing).
+ */
+export function resetSliceOrchestrator() {
+    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, milestoneId, slices) {
+    const safe = [];
+    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() {
+    if (process.env.GSD_BIN_PATH && existsSync(process.env.GSD_BIN_PATH)) {
+        return process.env.GSD_BIN_PATH;
+    }
+    let thisDir;
+    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, milestoneId, sliceId) {
+    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;
+    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) => {
+            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) => {
+            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, _milestoneId, sliceId, line) {
+    if (!line.trim() || !sliceState)
+        return;
+    let event;
+    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;
+            if (usage?.cost && typeof usage.cost === "number") {
+                worker.cost += usage.cost;
+                sliceState.totalCost += usage.cost;
+            }
+            worker.completedUnits++;
+        }
+    }
+}
+// ─── Logging ────────────────────────────────────────────────────────────────
+function sliceLogDir(basePath) {
+    return join(gsdRoot(basePath), "parallel", "slice-logs");
+}
+function appendSliceWorkerLog(basePath, milestoneId, sliceId, text) {
+    const dir = sliceLogDir(basePath);
+    mkdirSync(dir, { recursive: true });
+    appendFileSync(join(dir, `${milestoneId}-${sliceId}.log`), text);
+}

package/dist/resources/extensions/gsd/state.js

@@ -6,12 +6,13 @@ import { parseSummary, loadFile, parseRequirementCounts, parseContextDependsOn,
 import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTasksDir, resolveGsdRootFile, gsdRoot, } from './paths.js';
 import { findMilestoneIds } from './milestone-ids.js';
 import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
+import { isDeferredStatus } from './status-guards.js';
 import { nativeBatchParseGsdFiles } from './native-parser-bridge.js';
 import { join, resolve } from 'path';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
-import { extractVerdict } from './verdict-parser.js';
 import { logWarning, logError } from './workflow-logger.js';
+import { extractVerdict } from './verdict-parser.js';
 import { isDbAvailable, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
@@ -568,13 +569,43 @@ export async function deriveStateFromDb(basePath) {
     const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isStatusDone(s.status)).map(s => s.id));
     let activeSlice = null;
     let activeSliceRow = null;
-    for (const s of activeMilestoneSlices) {
-        if (isStatusDone(s.status))
-            continue;
-        if (s.depends.every(dep => doneSliceIds.has(dep))) {
-            activeSlice = { id: s.id, title: s.title };
-            activeSliceRow = s;
-            break;
+    // ── Slice-level parallel worker isolation ─────────────────────────────
+    // When GSD_SLICE_LOCK is set, this process is a parallel worker scoped
+    // to a single slice. Override activeSlice to only the locked slice ID.
+    const sliceLock = process.env.GSD_SLICE_LOCK;
+    if (sliceLock) {
+        const lockedSlice = activeMilestoneSlices.find(s => s.id === sliceLock);
+        if (lockedSlice) {
+            activeSlice = { id: lockedSlice.id, title: lockedSlice.title };
+            activeSliceRow = lockedSlice;
+        }
+        else {
+            logWarning("state", `GSD_SLICE_LOCK=${sliceLock} not found in active slices — worker has no assigned work`);
+            // Don't silently continue — this is a dispatch error
+            return {
+                activeMilestone, activeSlice: null, activeTask: null,
+                phase: 'blocked',
+                recentDecisions: [], blockers: [`GSD_SLICE_LOCK=${sliceLock} not found in active milestone slices`],
+                nextAction: 'Slice lock references a non-existent slice — check orchestrator dispatch.',
+                registry, requirements,
+                progress: { milestones: milestoneProgress, slices: sliceProgress },
+            };
+        }
+    }
+    else {
+        for (const s of activeMilestoneSlices) {
+            if (isStatusDone(s.status))
+                continue;
+            // #2661: Skip deferred slices — a decision explicitly deferred this work.
+            // Without this guard the dispatcher would keep dispatching deferred slices
+            // because DECISIONS.md is only contextual, not authoritative for dispatch.
+            if (isDeferredStatus(s.status))
+                continue;
+            if (s.depends.every(dep => doneSliceIds.has(dep))) {
+                activeSlice = { id: s.id, title: s.title };
+                activeSliceRow = s;
+                break;
+            }
         }
     }
     if (!activeSlice) {
@@ -1188,12 +1219,41 @@ export async function _deriveStateImpl(basePath) {
     // Find the active slice (first incomplete with deps satisfied)
     const doneSliceIds = new Set(activeRoadmap.slices.filter(s => s.done).map(s => s.id));
     let activeSlice = null;
-    for (const s of activeRoadmap.slices) {
-        if (s.done)
-            continue;
-        if (s.depends.every(dep => doneSliceIds.has(dep))) {
-            activeSlice = { id: s.id, title: s.title };
-            break;
+    // ── Slice-level parallel worker isolation ─────────────────────────────
+    // When GSD_SLICE_LOCK is set, override activeSlice to only the locked slice.
+    const sliceLockLegacy = process.env.GSD_SLICE_LOCK;
+    if (sliceLockLegacy) {
+        const lockedSlice = activeRoadmap.slices.find(s => s.id === sliceLockLegacy);
+        if (lockedSlice) {
+            activeSlice = { id: lockedSlice.id, title: lockedSlice.title };
+        }
+        else {
+            logWarning("state", `GSD_SLICE_LOCK=${sliceLockLegacy} not found in active slices — worker has no assigned work`);
+            return {
+                activeMilestone,
+                activeSlice: null,
+                activeTask: null,
+                phase: 'blocked',
+                recentDecisions: [],
+                blockers: [`GSD_SLICE_LOCK=${sliceLockLegacy} not found in active milestone slices`],
+                nextAction: 'Slice lock references a non-existent slice — check orchestrator dispatch.',
+                registry,
+                requirements,
+                progress: {
+                    milestones: milestoneProgress,
+                    slices: sliceProgress,
+                },
+            };
+        }
+    }
+    else {
+        for (const s of activeRoadmap.slices) {
+            if (s.done)
+                continue;
+            if (s.depends.every(dep => doneSliceIds.has(dep))) {
+                activeSlice = { id: s.id, title: s.title };
+                break;
+            }
         }
     }
     if (!activeSlice) {

package/dist/resources/extensions/gsd/status-guards.js

@@ -11,3 +11,14 @@
 export function isClosedStatus(status) {
     return status === "complete" || status === "done" || status === "skipped";
 }
+/** Returns true when a slice status indicates it was deferred by a decision. */
+export function isDeferredStatus(status) {
+    return status === "deferred";
+}
+/**
+ * Returns true when a slice should be skipped during active-slice selection.
+ * This includes both closed (complete/done) and deferred slices.
+ */
+export function isInactiveStatus(status) {
+    return isClosedStatus(status) || isDeferredStatus(status);
+}

package/dist/resources/extensions/gsd/tools/complete-milestone.js

@@ -12,24 +12,29 @@ import { resolveMilestonePath, clearPathCache } from "../paths.js";
 import { isClosedStatus } from "../status-guards.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { renderAllProjections, stripIdPrefix } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 function renderMilestoneSummaryMarkdown(params) {
     const now = new Date().toISOString();
-    const keyDecisionsYaml = params.keyDecisions.length > 0
-        ? params.keyDecisions.map(d => `  - ${d}`).join("\n")
+    const displayTitle = stripIdPrefix(params.title, params.milestoneId);
+    // Apply defaults for optional enrichment fields (#2771)
+    const keyDecisions = params.keyDecisions ?? [];
+    const keyFiles = params.keyFiles ?? [];
+    const lessonsLearned = params.lessonsLearned ?? [];
+    const keyDecisionsYaml = keyDecisions.length > 0
+        ? keyDecisions.map(d => `  - ${d}`).join("\n")
         : "  - (none)";
-    const keyFilesYaml = params.keyFiles.length > 0
-        ? params.keyFiles.map(f => `  - ${f}`).join("\n")
+    const keyFilesYaml = keyFiles.length > 0
+        ? keyFiles.map(f => `  - ${f}`).join("\n")
         : "  - (none)";
-    const lessonsYaml = params.lessonsLearned.length > 0
-        ? params.lessonsLearned.map(l => `  - ${l}`).join("\n")
+    const lessonsYaml = lessonsLearned.length > 0
+        ? lessonsLearned.map(l => `  - ${l}`).join("\n")
         : "  - (none)";
     return `---
 id: ${params.milestoneId}
-title: "${params.title}"
+title: "${displayTitle}"
 status: complete
 completed_at: ${now}
 key_decisions:
@@ -40,7 +45,7 @@ lessons_learned:
 ${lessonsYaml}
 ---
 
-# ${params.milestoneId}: ${params.title}
+# ${params.milestoneId}: ${displayTitle}
 
 **${params.oneLiner}**
 
@@ -50,15 +55,15 @@ ${params.narrative}
 
 ## Success Criteria Results
 
-${params.successCriteriaResults}
+${params.successCriteriaResults ?? "Not provided."}
 
 ## Definition of Done Results
 
-${params.definitionOfDoneResults}
+${params.definitionOfDoneResults ?? "Not provided."}
 
 ## Requirement Outcomes
 
-${params.requirementOutcomes}
+${params.requirementOutcomes ?? "Not provided."}
 
 ## Deviations