gsd-pi 2.63.0 → 2.64.0

package/dist/resources/extensions/gsd/safety/git-checkpoint.js

@@ -0,0 +1,91 @@
+/**
+ * Pre-unit git checkpoint and rollback for auto-mode safety harness.
+ * Uses the existing refs/gsd/ namespace (already pruned by doctor).
+ *
+ * Creates a lightweight ref at HEAD before unit execution. On failure,
+ * the ref can be used to rollback the branch to the pre-unit state.
+ *
+ * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+ */
+import { execFileSync } from "node:child_process";
+import { logWarning } from "../workflow-logger.js";
+// ─── Constants ──────────────────────────────────────────────────────────────
+const CHECKPOINT_PREFIX = "refs/gsd/checkpoints/";
+// ─── Public API ─────────────────────────────────────────────────────────────
+/**
+ * Create a checkpoint ref at the current HEAD for the given unit.
+ * Returns the SHA of HEAD, or null if the operation fails.
+ */
+export function createCheckpoint(basePath, unitId) {
+    try {
+        const sha = execFileSync("git", ["rev-parse", "HEAD"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        }).trim();
+        if (!sha || sha.length < 7)
+            return null;
+        // Sanitize unitId for use in ref path (replace / with -)
+        const safeUnitId = unitId.replace(/\//g, "-");
+        execFileSync("git", ["update-ref", `${CHECKPOINT_PREFIX}${safeUnitId}`, sha], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return sha;
+    }
+    catch (e) {
+        logWarning("safety", `checkpoint creation failed: ${e.message}`);
+        return null;
+    }
+}
+/**
+ * Rollback the current branch to a checkpoint SHA.
+ * Returns true on success, false on failure.
+ *
+ * WARNING: This is a destructive operation — it discards all changes
+ * since the checkpoint. Only call when the user has opted in via
+ * safety_harness.auto_rollback or an explicit manual trigger.
+ */
+export function rollbackToCheckpoint(basePath, unitId, sha) {
+    try {
+        // Get current branch name
+        const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        }).trim();
+        if (!branch || branch === "HEAD") {
+            logWarning("safety", "rollback: detached HEAD state, cannot rollback");
+            return false;
+        }
+        // Reset branch pointer and working tree to checkpoint SHA in one step.
+        // Using `git reset --hard <sha>` works on the currently checked-out branch
+        // (unlike `git branch -f` which is rejected for checked-out branches).
+        execFileSync("git", ["reset", "--hard", sha], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        // Cleanup checkpoint ref
+        cleanupCheckpoint(basePath, unitId);
+        return true;
+    }
+    catch (e) {
+        logWarning("safety", `rollback failed: ${e.message}`);
+        return false;
+    }
+}
+/**
+ * Remove a checkpoint ref after successful unit completion.
+ */
+export function cleanupCheckpoint(basePath, unitId) {
+    try {
+        const safeUnitId = unitId.replace(/\//g, "-");
+        execFileSync("git", ["update-ref", "-d", `${CHECKPOINT_PREFIX}${safeUnitId}`], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch {
+        // Non-fatal — ref may already have been cleaned up
+    }
+}

package/dist/resources/extensions/gsd/safety/safety-harness.js

@@ -0,0 +1,64 @@
+/**
+ * Safety Harness — central module for LLM damage control during auto-mode.
+ * Provides types, preference resolution, and orchestration for all safety components.
+ *
+ * Components:
+ * - evidence-collector.ts: Real-time tool call tracking
+ * - destructive-guard.ts: Bash command classification
+ * - file-change-validator.ts: Post-unit git diff vs plan
+ * - evidence-cross-ref.ts: Claimed vs actual verification evidence
+ * - git-checkpoint.ts: Pre-unit checkpoints + rollback
+ * - content-validator.ts: Output quality validation
+ *
+ * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+ */
+// ─── Defaults ───────────────────────────────────────────────────────────────
+const DEFAULTS = {
+    enabled: true,
+    evidence_collection: true,
+    file_change_validation: true,
+    evidence_cross_reference: true,
+    destructive_command_warnings: true,
+    content_validation: true,
+    checkpoints: true,
+    auto_rollback: false,
+    timeout_scale_cap: 6,
+};
+// ─── Public API ─────────────────────────────────────────────────────────────
+/**
+ * Resolve safety harness configuration from raw preferences.
+ * Missing fields fall back to defaults.
+ */
+export function resolveSafetyHarnessConfig(raw) {
+    if (!raw)
+        return { ...DEFAULTS };
+    return {
+        enabled: typeof raw.enabled === "boolean" ? raw.enabled : DEFAULTS.enabled,
+        evidence_collection: typeof raw.evidence_collection === "boolean" ? raw.evidence_collection : DEFAULTS.evidence_collection,
+        file_change_validation: typeof raw.file_change_validation === "boolean" ? raw.file_change_validation : DEFAULTS.file_change_validation,
+        evidence_cross_reference: typeof raw.evidence_cross_reference === "boolean" ? raw.evidence_cross_reference : DEFAULTS.evidence_cross_reference,
+        destructive_command_warnings: typeof raw.destructive_command_warnings === "boolean" ? raw.destructive_command_warnings : DEFAULTS.destructive_command_warnings,
+        content_validation: typeof raw.content_validation === "boolean" ? raw.content_validation : DEFAULTS.content_validation,
+        checkpoints: typeof raw.checkpoints === "boolean" ? raw.checkpoints : DEFAULTS.checkpoints,
+        auto_rollback: typeof raw.auto_rollback === "boolean" ? raw.auto_rollback : DEFAULTS.auto_rollback,
+        timeout_scale_cap: typeof raw.timeout_scale_cap === "number" ? raw.timeout_scale_cap : DEFAULTS.timeout_scale_cap,
+    };
+}
+/**
+ * Check if the safety harness is enabled.
+ * Used as a fast gate at hook registration and phase integration points.
+ */
+export function isHarnessEnabled(raw) {
+    if (!raw)
+        return DEFAULTS.enabled;
+    if (typeof raw.enabled === "boolean")
+        return raw.enabled;
+    return DEFAULTS.enabled;
+}
+// ─── Re-exports ─────────────────────────────────────────────────────────────
+export { resetEvidence, getEvidence, getBashEvidence, getFilePaths, recordToolCall, recordToolResult, } from "./evidence-collector.js";
+export { classifyCommand } from "./destructive-guard.js";
+export { validateFileChanges } from "./file-change-validator.js";
+export { crossReferenceEvidence } from "./evidence-cross-ref.js";
+export { createCheckpoint, rollbackToCheckpoint, cleanupCheckpoint } from "./git-checkpoint.js";
+export { validateContent } from "./content-validator.js";

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

@@ -0,0 +1,67 @@
+/**
+ * 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) {
+    const paths = new Set();
+    // 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, mid, sliceA, sliceB) {
+    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/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);
+}