gsd-pi 2.77.0 → 2.78.0

package/dist/resources/extensions/gsd/slice-cadence.js

@@ -0,0 +1,238 @@
+/**
+ * Slice-cadence collapse — #4765.
+ *
+ * When `git.collapse_cadence: "slice"` is set, each slice's commits are
+ * squash-merged from the milestone branch to main as soon as the slice
+ * passes validation. Shrinks the orphan window (#4761) from milestone-size
+ * to slice-size and surfaces merge conflicts per-slice rather than all at
+ * once at milestone end.
+ *
+ * This module is deliberately focused and narrower than mergeMilestoneToMain:
+ *   - No worktree teardown (worktree is reused for the next slice)
+ *   - No DB reconciliation (modern worktrees share the main DB via path resolver)
+ *   - No roadmap/summary/gate handling (that's still the milestone's job)
+ *   - Fails loudly on dirty main — caller is responsible for cleanliness
+ *
+ * Kernighan: the v1 surface handles the happy path + conflict. Edge cases
+ * that mergeMilestoneToMain covers (concurrent merges, shared DB paths,
+ * submodules) are explicit non-goals; users opt in via preference and early-
+ * adopter scenarios are scoped narrow.
+ */
+import { existsSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { GSDError, GSD_GIT_ERROR } from "./errors.js";
+import { MergeConflictError } from "./git-service.js";
+import { nativeBranchForceReset, nativeCheckoutBranch, nativeCommit, nativeCommitCountBetween, nativeConflictFiles, nativeDetectMainBranch, nativeMergeSquash, } from "./native-git-bridge.js";
+import { resolveGitDir } from "./worktree-manager.js";
+import { logWarning } from "./workflow-logger.js";
+import { emitSliceMerged, emitMilestoneResquash } from "./worktree-telemetry.js";
+/**
+ * Auto-worktree milestone branch name. Must match autoWorktreeBranch() in
+ * auto-worktree.ts; duplicated here to avoid a cyclic import.
+ */
+function milestoneBranchName(milestoneId) {
+    return `milestone/${milestoneId}`;
+}
+function cleanupMergeArtifacts(projectRoot) {
+    try {
+        const gitDir = resolveGitDir(projectRoot);
+        for (const f of ["SQUASH_MSG", "MERGE_MSG", "MERGE_HEAD"]) {
+            const p = join(gitDir, f);
+            if (existsSync(p))
+                unlinkSync(p);
+        }
+    }
+    catch (err) {
+        logWarning("worktree", `merge artifact cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Squash-merge one slice's commits from the milestone branch to main.
+ *
+ * Preconditions:
+ *   - Caller is on the milestone branch inside the worktree
+ *   - `projectRoot` points at the real project root (not the worktree)
+ *
+ * Post-conditions on success:
+ *   - Slice's commits are a single squash commit on main
+ *   - `milestone/<MID>` is fast-forwarded to main (so next slice's work
+ *     starts from a clean base)
+ *   - caller's process.cwd is restored
+ *
+ * Throws MergeConflictError on conflicts; caller should surface and stop.
+ * Throws GSDError on dirty main / detection failures.
+ */
+export function mergeSliceToMain(projectRoot, milestoneId, sliceId) {
+    const started = Date.now();
+    const worktreeCwd = process.cwd();
+    const milestoneBranch = milestoneBranchName(milestoneId);
+    const mainBranch = nativeDetectMainBranch(projectRoot);
+    // Fast path: if the milestone branch has no commits ahead of main, there
+    // is nothing to merge. Return a skip result instead of no-op'ing silently
+    // so the caller's telemetry shows the decision.
+    let commitsAhead = 0;
+    try {
+        commitsAhead = nativeCommitCountBetween(projectRoot, mainBranch, milestoneBranch);
+    }
+    catch {
+        // If we can't count, assume there's work and let the merge proceed —
+        // a failing merge is more informative than a silent skip.
+        commitsAhead = 1;
+    }
+    if (commitsAhead === 0) {
+        // Do NOT emit slice-merged here — this is a no-op, not a merge. Emitting
+        // would inflate slicesMerged in telemetry/forensics and distort the
+        // conflict rate denominator.
+        return {
+            commitSha: null,
+            mainBranch,
+            milestoneBranch,
+            durationMs: Date.now() - started,
+            skipped: true,
+            skippedReason: "no-commits-ahead",
+        };
+    }
+    process.chdir(projectRoot);
+    try {
+        // Dirty-main check — v1 fails loudly rather than auto-stashing. Users
+        // running slice-cadence opt in knowing main stays clean between merges.
+        const status = execFileSync("git", ["status", "--porcelain"], {
+            cwd: projectRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        }).trim();
+        if (status) {
+            throw new GSDError(GSD_GIT_ERROR, `slice-cadence merge requires a clean project root; uncommitted changes detected. ` +
+                `Commit or stash at ${projectRoot} before retrying. Status:\n${status}`);
+        }
+        nativeCheckoutBranch(projectRoot, mainBranch);
+        // Clean any stale merge artifacts before attempting the squash (#2912 pattern)
+        cleanupMergeArtifacts(projectRoot);
+        const mergeResult = nativeMergeSquash(projectRoot, milestoneBranch);
+        if (!mergeResult.success) {
+            const conflictedFiles = mergeResult.conflicts.length > 0
+                ? mergeResult.conflicts
+                : nativeConflictFiles(projectRoot);
+            cleanupMergeArtifacts(projectRoot);
+            try {
+                emitSliceMerged(projectRoot, milestoneId, sliceId, {
+                    durationMs: Date.now() - started,
+                    conflict: true,
+                });
+            }
+            catch { /* silent */ }
+            throw new MergeConflictError(conflictedFiles, "squash", milestoneBranch, mainBranch);
+        }
+        // Commit the squash with a slice-scoped message
+        const commitSha = nativeCommit(projectRoot, `gsd: merge ${sliceId} of ${milestoneId} (slice-cadence)`);
+        // Advance the milestone branch to main so the next slice's commits start
+        // from a clean base. Force-reset is safe because we just merged this
+        // branch's entire delta.
+        nativeBranchForceReset(projectRoot, milestoneBranch, mainBranch);
+        const durationMs = Date.now() - started;
+        try {
+            emitSliceMerged(projectRoot, milestoneId, sliceId, {
+                durationMs,
+                conflict: false,
+                commitSha: commitSha ?? undefined,
+            });
+        }
+        catch { /* silent */ }
+        return {
+            commitSha,
+            mainBranch,
+            milestoneBranch,
+            durationMs,
+            skipped: false,
+        };
+    }
+    finally {
+        // Always restore cwd even if anything above threw.
+        try {
+            process.chdir(worktreeCwd);
+        }
+        catch { /* best-effort */ }
+    }
+}
+/**
+ * Re-squash per-slice commits on main into a single milestone commit.
+ *
+ * Runs at milestone completion when `collapse_cadence: "slice"` AND
+ * `milestone_resquash: true`. The `startSha` is the SHA of main immediately
+ * before the milestone's first slice merge — the caller is responsible for
+ * recording this (AutoSession field, git ref, or DB row).
+ *
+ * Strategy: soft-reset main to startSha, then commit the net diff. The
+ * N slice commits between startSha and HEAD are collapsed into one.
+ *
+ * No-op (returns false) if startSha equals HEAD (nothing to re-squash).
+ */
+export function resquashMilestoneOnMain(projectRoot, milestoneId, startSha) {
+    const mainBranch = nativeDetectMainBranch(projectRoot);
+    const worktreeCwd = process.cwd();
+    process.chdir(projectRoot);
+    try {
+        nativeCheckoutBranch(projectRoot, mainBranch);
+        // Verify the startSha..HEAD range contains ONLY this milestone's slice-
+        // cadence commits. If any unrelated commits landed on main since the
+        // milestone started (e.g. concurrent work, cherry-picks, hotfixes), a
+        // blind `git reset --soft` would fold them into the re-squash and rewrite
+        // their attribution. Fail closed — the user can resolve manually.
+        const expectedSuffix = `(slice-cadence)`;
+        const expectedMilestoneToken = ` of ${milestoneId} `;
+        let subjectsRaw = "";
+        try {
+            subjectsRaw = execFileSync("git", ["log", "--format=%s", `${startSha}..HEAD`], { cwd: projectRoot, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
+        }
+        catch {
+            return { resquashed: false, newSha: null };
+        }
+        const subjects = subjectsRaw.split("\n").filter((s) => s.length > 0);
+        const sliceCount = subjects.length;
+        if (sliceCount === 0) {
+            return { resquashed: false, newSha: null };
+        }
+        const foreign = subjects.filter((s) => !(s.endsWith(expectedSuffix) && s.includes(expectedMilestoneToken)));
+        if (foreign.length > 0) {
+            logWarning("worktree", `slice-cadence: skipping milestone resquash for ${milestoneId} — ` +
+                `${foreign.length} non-slice-cadence commit(s) in ${startSha}..HEAD ` +
+                `would be folded in. First: "${foreign[0]}". Resolve history manually.`);
+            return { resquashed: false, newSha: null };
+        }
+        // Safe to collapse: all commits in the range are this milestone's slices.
+        execFileSync("git", ["reset", "--soft", startSha], {
+            cwd: projectRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        const newSha = nativeCommit(projectRoot, `gsd: complete milestone ${milestoneId} (${sliceCount} slices re-squashed)`, { allowEmpty: true });
+        try {
+            emitMilestoneResquash(projectRoot, milestoneId, {
+                sliceCount,
+                startSha,
+                endSha: newSha ?? undefined,
+            });
+        }
+        catch { /* silent */ }
+        return { resquashed: true, newSha };
+    }
+    finally {
+        try {
+            process.chdir(worktreeCwd);
+        }
+        catch { /* best-effort */ }
+    }
+}
+/**
+ * Read the effective collapse cadence from validated preferences. Accepts
+ * a raw preferences object (the shape loadEffectiveGSDPreferences returns).
+ */
+export function getCollapseCadence(prefs) {
+    return prefs?.git?.collapse_cadence ?? "milestone";
+}
+export function getMilestoneResquash(prefs) {
+    // Default true when cadence is slice — resquash preserves the milestone-
+    // level history shape users expect.
+    return prefs?.git?.milestone_resquash !== false;
+}

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

@@ -12,8 +12,9 @@
  * - 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 { execFileSync, spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { appendFileSync, existsSync, writeFileSync, readFileSync, mkdirSync, renameSync, unlinkSync, } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
@@ -24,12 +25,243 @@ import { getErrorMessage } from "./error-utils.js";
 import { selectConflictFreeBatch } from "./uok/execution-graph.js";
 // ─── Module State ──────────────────────────────────────────────────────────
 let sliceState = null;
+// ─── Persisted State (crash recovery) ──────────────────────────────────────
+//
+// Mirrors parallel-orchestrator.ts. Without persistence, a coordinator crash
+// leaves orphaned worktrees on disk with no way to detect or clean them up
+// on next session start. (Issue #4980 HIGH-8)
+const SLICE_ORCHESTRATOR_STATE_FILE = "slice-orchestrator.json";
+const TMP_SUFFIX = ".tmp";
+function sliceStateFilePath(basePath) {
+    return join(gsdRoot(basePath), SLICE_ORCHESTRATOR_STATE_FILE);
+}
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        if (err.code === "EPERM")
+            return true;
+        return false;
+    }
+}
+function readLinuxProcessStartFingerprint(pid) {
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, "utf-8");
+        const afterCommand = stat.slice(stat.lastIndexOf(")") + 2).trim();
+        const fields = afterCommand.split(/\s+/);
+        const startTimeTicks = fields[19];
+        return startTimeTicks ? `linux-stat:${startTimeTicks}` : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readPsProcessStartFingerprint(pid) {
+    try {
+        const raw = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+            stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf-8",
+        }).trim().replace(/\s+/g, " ");
+        return raw ? `ps-lstart:${raw}` : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readProcessStartFingerprint(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return null;
+    return readLinuxProcessStartFingerprint(pid) ?? readPsProcessStartFingerprint(pid);
+}
+function linuxProcessEnvContains(pid, key, value) {
+    if (process.platform !== "linux")
+        return null;
+    try {
+        const env = readFileSync(`/proc/${pid}/environ`, "utf-8");
+        return env.split("\0").includes(`${key}=${value}`);
+    }
+    catch {
+        return null;
+    }
+}
+function createWorkerToken(milestoneId, sliceId) {
+    return `slice:${milestoneId}:${sliceId}:${Date.now()}:${randomUUID()}`;
+}
+function isRecoveredSliceWorkerAlive(worker) {
+    if (!isPidAlive(worker.pid))
+        return false;
+    if (!worker.processStartFingerprint)
+        return false;
+    const currentFingerprint = readProcessStartFingerprint(worker.pid);
+    if (!currentFingerprint || currentFingerprint !== worker.processStartFingerprint) {
+        return false;
+    }
+    if (worker.workerToken) {
+        const envMatches = linuxProcessEnvContains(worker.pid, "GSD_SLICE_WORKER_TOKEN", worker.workerToken);
+        if (envMatches === false)
+            return false;
+    }
+    return true;
+}
+/**
+ * Persist current slice orchestrator state. Atomic write (tmp + rename) to
+ * prevent partial reads if the coordinator dies mid-write.
+ */
+function persistSliceState() {
+    if (!sliceState)
+        return;
+    try {
+        const dir = gsdRoot(sliceState.basePath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const persisted = {
+            active: sliceState.active,
+            workers: [...sliceState.workers.values()].map((w) => ({
+                milestoneId: w.milestoneId,
+                sliceId: w.sliceId,
+                pid: w.pid,
+                workerToken: w.workerToken,
+                processStartFingerprint: w.processStartFingerprint,
+                worktreePath: w.worktreePath,
+                startedAt: w.startedAt,
+                state: w.state,
+                completedUnits: w.completedUnits,
+                cost: w.cost,
+            })),
+            totalCost: sliceState.totalCost,
+            budgetCeiling: sliceState.budgetCeiling,
+            maxWorkers: sliceState.maxWorkers,
+            startedAt: sliceState.startedAt,
+            basePath: sliceState.basePath,
+        };
+        const dest = sliceStateFilePath(sliceState.basePath);
+        const tmp = dest + TMP_SUFFIX;
+        writeFileSync(tmp, JSON.stringify(persisted, null, 2), "utf-8");
+        renameSync(tmp, dest);
+        lastPersistTs = Date.now();
+    }
+    catch {
+        /* non-fatal: persistence is best-effort */
+    }
+}
+/**
+ * Throttled wrapper around `persistSliceState`. Skips if the last successful
+ * persist was less than `PERSIST_THROTTLE_MS` ago; otherwise persists
+ * immediately. Use this on hot paths (e.g. `message_end` events) where we
+ * receive many events per second per worker. Terminal events (worker exit,
+ * crash, stop) should call `persistSliceState()` directly to guarantee the
+ * final state hits disk regardless of timing.
+ */
+const PERSIST_THROTTLE_MS = 1000;
+let lastPersistTs = 0;
+function persistSliceStateThrottled() {
+    if (Date.now() - lastPersistTs < PERSIST_THROTTLE_MS)
+        return;
+    persistSliceState();
+}
+function removeSliceStateFile(basePath) {
+    try {
+        const p = sliceStateFilePath(basePath);
+        if (existsSync(p))
+            unlinkSync(p);
+    }
+    catch {
+        /* non-fatal */
+    }
+}
+/**
+ * Restore slice orchestrator state from disk. Filters dead-PID workers and
+ * removes their orphaned worktrees so a clean restart is possible.
+ *
+ * Returns null if no state file exists or no workers survive.
+ */
+export function restoreSliceState(basePath) {
+    try {
+        const p = sliceStateFilePath(basePath);
+        if (!existsSync(p))
+            return null;
+        const persisted = JSON.parse(readFileSync(p, "utf-8"));
+        const survivors = [];
+        const dead = [];
+        for (const w of persisted.workers) {
+            if (w.state === "running" && isRecoveredSliceWorkerAlive(w)) {
+                survivors.push(w);
+            }
+            else if (w.state === "running") {
+                dead.push(w);
+            }
+            else {
+                survivors.push(w);
+            }
+        }
+        // Best-effort cleanup of orphaned worktrees from dead workers.
+        for (const w of dead) {
+            const wtName = `${w.milestoneId}-${w.sliceId}`;
+            try {
+                removeWorktree(persisted.basePath, wtName, { deleteBranch: true, force: true });
+            }
+            catch {
+                /* worktree may already be gone */
+            }
+        }
+        persisted.workers = survivors;
+        if (survivors.length === 0) {
+            removeSliceStateFile(basePath);
+            return null;
+        }
+        return persisted;
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Public API ────────────────────────────────────────────────────────────
 /**
  * Check whether slice-level parallel is currently active.
+ *
+ * If in-memory state is unset but a persisted state file exists with at
+ * least one live-PID worker, treat as active and rehydrate so a coordinator
+ * crash followed by a fresh process is detectable. (Issue #4980 HIGH-8)
  */
-export function isSliceParallelActive() {
-    return sliceState?.active === true;
+export function isSliceParallelActive(basePath) {
+    if (sliceState?.active === true)
+        return true;
+    if (!basePath)
+        return false;
+    const restored = restoreSliceState(basePath);
+    if (!restored || restored.workers.length === 0)
+        return false;
+    // Rehydrate in-memory state from disk; processes are detached so we have
+    // no ChildProcess handles, only PIDs.
+    sliceState = {
+        active: restored.active,
+        workers: new Map(),
+        totalCost: restored.totalCost,
+        budgetCeiling: restored.budgetCeiling,
+        maxWorkers: restored.maxWorkers,
+        startedAt: restored.startedAt,
+        basePath: restored.basePath,
+    };
+    for (const w of restored.workers) {
+        sliceState.workers.set(w.sliceId, {
+            milestoneId: w.milestoneId,
+            sliceId: w.sliceId,
+            pid: w.pid,
+            process: null,
+            worktreePath: w.worktreePath,
+            workerToken: w.workerToken ?? "",
+            processStartFingerprint: w.processStartFingerprint ?? null,
+            startedAt: w.startedAt,
+            state: w.state,
+            completedUnits: w.completedUnits,
+            cost: w.cost,
+        });
+    }
+    return true;
 }
 /**
  * Get current slice orchestrator state (read-only snapshot).
@@ -80,6 +312,8 @@ export async function startSliceParallel(basePath, milestoneId, eligibleSlices,
                 milestoneId,
                 sliceId: slice.id,
                 pid: 0,
+                workerToken: createWorkerToken(milestoneId, slice.id),
+                processStartFingerprint: null,
                 process: null,
                 worktreePath: wtPath,
                 startedAt: Date.now(),
@@ -95,13 +329,18 @@ export async function startSliceParallel(basePath, milestoneId, eligibleSlices,
             }
             else {
                 errors.push({ sid: slice.id, error: "Failed to spawn worker process" });
-                worker.state = "error";
+                sliceState.workers.delete(slice.id);
+                try {
+                    removeWorktree(basePath, wtName, { deleteBranch: true, force: true });
+                }
+                catch { /* ignore cleanup failures */ }
             }
         }
         catch (err) {
             errors.push({ sid: slice.id, error: getErrorMessage(err) });
             // Best-effort cleanup of partially created worktree
             const wtName = `${milestoneId}-${slice.id}`;
+            sliceState.workers.delete(slice.id);
             try {
                 removeWorktree(basePath, wtName, { deleteBranch: true, force: true });
             }
@@ -111,6 +350,11 @@ export async function startSliceParallel(basePath, milestoneId, eligibleSlices,
     // If nothing started, deactivate
     if (started.length === 0) {
         sliceState.active = false;
+        removeSliceStateFile(basePath);
+    }
+    else {
+        // Persist state for crash recovery (Issue #4980 HIGH-8).
+        persistSliceState();
     }
     return { started, errors };
 }
@@ -120,13 +364,17 @@ export async function startSliceParallel(basePath, milestoneId, eligibleSlices,
 export function stopSliceParallel() {
     if (!sliceState)
         return;
+    const basePath = sliceState.basePath;
     for (const worker of sliceState.workers.values()) {
-        if (worker.process) {
-            try {
+        try {
+            if (worker.process) {
                 worker.process.kill("SIGTERM");
             }
-            catch { /* already dead */ }
+            else if (worker.state === "running" && isRecoveredSliceWorkerAlive(worker)) {
+                process.kill(worker.pid, "SIGTERM");
+            }
         }
+        catch { /* already dead */ }
         worker.cleanup?.();
         worker.cleanup = undefined;
         worker.process = null;
@@ -139,6 +387,9 @@ export function stopSliceParallel() {
         catch { /* best-effort cleanup */ }
     }
     sliceState.active = false;
+    // Clear persisted state — clean shutdown means no recovery on next start.
+    // (Issue #4980 HIGH-8)
+    removeSliceStateFile(basePath);
 }
 /**
  * Get aggregate cost across all slice workers.
@@ -170,6 +421,7 @@ export function resetSliceOrchestrator() {
         }
     }
     sliceState = null;
+    lastPersistTs = 0;
 }
 // ─── Internal: Conflict Filtering ──────────────────────────────────────────
 /**
@@ -254,6 +506,7 @@ function spawnSliceWorker(basePath, milestoneId, sliceId) {
                 GSD_MILESTONE_LOCK: milestoneId,
                 GSD_PROJECT_ROOT: basePath,
                 GSD_PARALLEL_WORKER: "1",
+                GSD_SLICE_WORKER_TOKEN: worker.workerToken,
             },
             stdio: ["ignore", "pipe", "pipe"],
             detached: false,
@@ -272,8 +525,17 @@ function spawnSliceWorker(basePath, milestoneId, sliceId) {
     });
     worker.process = child;
     worker.pid = child.pid ?? 0;
+    worker.processStartFingerprint = worker.pid > 0
+        ? readProcessStartFingerprint(worker.pid)
+        : null;
     if (!child.pid) {
         worker.process = null;
+        worker.pid = 0;
+        worker.processStartFingerprint = null;
+        try {
+            child.kill("SIGTERM");
+        }
+        catch { /* best-effort */ }
         return false;
     }
     // ── NDJSON stdout monitoring ────────────────────────────────────────
@@ -346,6 +608,9 @@ function spawnSliceWorker(basePath, milestoneId, sliceId) {
             startedAt: w.startedAt,
             worktreePath: w.worktreePath,
         });
+        // Persist worker terminal state for crash recovery.
+        // (Issue #4980 HIGH-8)
+        persistSliceState();
     });
     return true;
 }
@@ -374,6 +639,11 @@ function processSliceWorkerLine(_basePath, _milestoneId, sliceId, line) {
                 sliceState.totalCost += usage.cost;
             }
             worker.completedUnits++;
+            // Persist cost / progress updates so a crash mid-run preserves them.
+            // Throttled (~1/s per process) so high-frequency message_end traffic
+            // does not saturate disk I/O. Worker exit / start / stop paths persist
+            // unthrottled to guarantee the terminal state lands. (Issue #4980 HIGH-8)
+            persistSliceStateThrottled();
         }
     }
 }