gsd-pi 2.33.1-dev.ee47f1b → 2.34.0-dev.bbb5216

package/dist/resources/extensions/gsd/auto-stuck-detection.js

@@ -1,165 +0,0 @@
-/**
- * Stuck detection and loop recovery for auto-mode unit dispatch.
- *
- * Tracks dispatch counts per unit, enforces lifetime caps, and attempts
- * stub/artifact recovery before stopping.
- *
- * Extracted from dispatchNextUnit() in auto.ts. Returns action values
- * instead of calling stopAuto/dispatchNextUnit — the caller handles
- * control flow.
- */
-import { inspectExecuteTaskDurability, } from "./unit-runtime.js";
-import { verifyExpectedArtifact, diagnoseExpectedArtifact, skipExecuteTask, persistCompletedKey, buildLoopRemediationSteps, } from "./auto-recovery.js";
-import { closeoutUnit } from "./auto-unit-closeout.js";
-import { saveActivityLog } from "./activity-log.js";
-import { invalidateAllCaches } from "./cache.js";
-import { sendDesktopNotification } from "./notifications.js";
-import { debugLog } from "./debug-logger.js";
-import { resolveMilestonePath, resolveSlicePath, resolveTasksDir, buildTaskFileName, } from "./paths.js";
-import { MAX_UNIT_DISPATCHES, STUB_RECOVERY_THRESHOLD, MAX_LIFETIME_DISPATCHES, } from "./auto/session.js";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { parseUnitId } from "./unit-id.js";
-/**
- * Check dispatch counts, enforce lifetime cap and MAX_UNIT_DISPATCHES,
- * attempt stub/artifact recovery. Returns an action for the caller.
- */
-export async function checkStuckAndRecover(sctx) {
-    const { s, ctx, unitType, unitId, basePath, buildSnapshotOpts } = sctx;
-    const dispatchKey = `${unitType}/${unitId}`;
-    const prevCount = s.unitDispatchCount.get(dispatchKey) ?? 0;
-    // Real dispatch reached — clear the consecutive-skip counter for this unit.
-    s.unitConsecutiveSkips.delete(dispatchKey);
-    debugLog("dispatch-unit", {
-        type: unitType,
-        id: unitId,
-        cycle: prevCount + 1,
-        lifetime: (s.unitLifetimeDispatches.get(dispatchKey) ?? 0) + 1,
-    });
-    // Hard lifetime cap — survives counter resets from loop-recovery/self-repair.
-    const lifetimeCount = (s.unitLifetimeDispatches.get(dispatchKey) ?? 0) + 1;
-    s.unitLifetimeDispatches.set(dispatchKey, lifetimeCount);
-    if (lifetimeCount > MAX_LIFETIME_DISPATCHES) {
-        if (s.currentUnit) {
-            await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts());
-        }
-        else {
-            saveActivityLog(ctx, s.basePath, unitType, unitId);
-        }
-        const expected = diagnoseExpectedArtifact(unitType, unitId, basePath);
-        return {
-            action: "stop",
-            reason: `Hard loop: ${unitType} ${unitId}`,
-            notifyMessage: `Hard loop detected: ${unitType} ${unitId} dispatched ${lifetimeCount} times total (across reconciliation cycles).${expected ? `\n   Expected artifact: ${expected}` : ""}\n   This may indicate deriveState() keeps returning the same unit despite artifacts existing.\n   Check .gsd/completed-units.json and the slice plan checkbox state.`,
-        };
-    }
-    if (prevCount >= MAX_UNIT_DISPATCHES) {
-        if (s.currentUnit) {
-            await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts());
-        }
-        else {
-            saveActivityLog(ctx, s.basePath, unitType, unitId);
-        }
-        // Final reconciliation pass for execute-task
-        if (unitType === "execute-task") {
-            const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-            if (mid && sid && tid) {
-                const status = await inspectExecuteTaskDurability(basePath, unitId);
-                if (status) {
-                    const reconciled = skipExecuteTask(basePath, mid, sid, tid, status, "loop-recovery", prevCount);
-                    if (reconciled && verifyExpectedArtifact(unitType, unitId, basePath)) {
-                        ctx.ui.notify(`Loop recovery: ${unitId} reconciled after ${prevCount + 1} dispatches — blocker artifacts written, pipeline advancing.\n   Review ${status.summaryPath} and replace the placeholder with real work.`, "warning");
-                        const reconciledKey = `${unitType}/${unitId}`;
-                        persistCompletedKey(basePath, reconciledKey);
-                        s.completedKeySet.add(reconciledKey);
-                        s.unitDispatchCount.delete(dispatchKey);
-                        invalidateAllCaches();
-                        return { action: "recovered", dispatchAgain: true };
-                    }
-                }
-            }
-        }
-        // General reconciliation: artifact appeared on last attempt
-        if (verifyExpectedArtifact(unitType, unitId, basePath)) {
-            ctx.ui.notify(`Loop recovery: ${unitType} ${unitId} — artifact verified after ${prevCount + 1} dispatches. Advancing.`, "info");
-            persistCompletedKey(basePath, dispatchKey);
-            s.completedKeySet.add(dispatchKey);
-            s.unitDispatchCount.delete(dispatchKey);
-            invalidateAllCaches();
-            return { action: "recovered", dispatchAgain: true };
-        }
-        // Last resort for complete-milestone: generate stub summary
-        if (unitType === "complete-milestone") {
-            try {
-                const mPath = resolveMilestonePath(basePath, unitId);
-                if (mPath) {
-                    const stubPath = join(mPath, `${unitId}-SUMMARY.md`);
-                    if (!existsSync(stubPath)) {
-                        writeFileSync(stubPath, `# ${unitId} Summary\n\nAuto-generated stub — milestone tasks completed but summary generation failed after ${prevCount + 1} attempts.\nReview and replace this stub with a proper summary.\n`);
-                        ctx.ui.notify(`Generated stub summary for ${unitId} to unblock pipeline. Review later.`, "warning");
-                        persistCompletedKey(basePath, dispatchKey);
-                        s.completedKeySet.add(dispatchKey);
-                        s.unitDispatchCount.delete(dispatchKey);
-                        invalidateAllCaches();
-                        return { action: "recovered", dispatchAgain: true };
-                    }
-                }
-            }
-            catch { /* non-fatal — fall through to normal stop */ }
-        }
-        const expected = diagnoseExpectedArtifact(unitType, unitId, basePath);
-        const remediation = buildLoopRemediationSteps(unitType, unitId, basePath);
-        sendDesktopNotification("GSD", `Loop detected: ${unitType} ${unitId}`, "error", "error");
-        return {
-            action: "stop",
-            reason: `Loop: ${unitType} ${unitId}`,
-            notifyMessage: `Loop detected: ${unitType} ${unitId} dispatched ${prevCount + 1} times total. Expected artifact not found.${expected ? `\n   Expected: ${expected}` : ""}${remediation ? `\n\n   Remediation steps:\n${remediation}` : "\n   Check branch state and .gsd/ artifacts."}`,
-        };
-    }
-    s.unitDispatchCount.set(dispatchKey, prevCount + 1);
-    if (prevCount > 0) {
-        // Adaptive self-repair: each retry attempts a different remediation step.
-        if (unitType === "execute-task") {
-            const status = await inspectExecuteTaskDurability(basePath, unitId);
-            const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-            if (status && mid && sid && tid) {
-                if (status.summaryExists && !status.taskChecked) {
-                    const repaired = skipExecuteTask(basePath, mid, sid, tid, status, "self-repair", 0);
-                    if (repaired && verifyExpectedArtifact(unitType, unitId, basePath)) {
-                        ctx.ui.notify(`Self-repaired ${unitId}: summary existed but checkbox was unmarked. Marked [x] and advancing.`, "warning");
-                        const repairedKey = `${unitType}/${unitId}`;
-                        persistCompletedKey(basePath, repairedKey);
-                        s.completedKeySet.add(repairedKey);
-                        s.unitDispatchCount.delete(dispatchKey);
-                        invalidateAllCaches();
-                        return { action: "recovered", dispatchAgain: true };
-                    }
-                }
-                else if (prevCount >= STUB_RECOVERY_THRESHOLD && !status.summaryExists) {
-                    const tasksDir = resolveTasksDir(basePath, mid, sid);
-                    const sDir = resolveSlicePath(basePath, mid, sid);
-                    const targetDir = tasksDir ?? (sDir ? join(sDir, "tasks") : null);
-                    if (targetDir) {
-                        if (!existsSync(targetDir))
-                            mkdirSync(targetDir, { recursive: true });
-                        const summaryPath = join(targetDir, buildTaskFileName(tid, "SUMMARY"));
-                        if (!existsSync(summaryPath)) {
-                            const stubContent = [
-                                `# PARTIAL RECOVERY — attempt ${prevCount + 1} of ${MAX_UNIT_DISPATCHES}`,
-                                ``,
-                                `Task \`${tid}\` in slice \`${sid}\` (milestone \`${mid}\`) has not yet produced a real summary.`,
-                                `This placeholder was written by auto-mode after ${prevCount} dispatch attempts.`,
-                                ``,
-                                `The next agent session will retry this task. Replace this file with real work when done.`,
-                            ].join("\n");
-                            writeFileSync(summaryPath, stubContent, "utf-8");
-                            ctx.ui.notify(`Stub recovery (attempt ${prevCount + 1}/${MAX_UNIT_DISPATCHES}): ${unitId} stub summary placeholder written. Retrying with recovery context.`, "warning");
-                        }
-                    }
-                }
-            }
-        }
-        ctx.ui.notify(`${unitType} ${unitId} didn't produce expected artifact. Retrying (${prevCount + 1}/${MAX_UNIT_DISPATCHES}).`, "warning");
-    }
-    return { action: "proceed" };
-}

package/dist/resources/extensions/gsd/mechanical-completion.js

@@ -1,351 +0,0 @@
-/**
- * Mechanical Completion — deterministic post-verification artifact generation.
- *
- * Pure functions that aggregate task-level outputs into slice/milestone summaries,
- * UAT stubs, roadmap checkbox updates, and validation reports. Zero orchestration
- * dependencies — operates on filesystem paths and parsed structures only.
- *
- * ADR-003: replaces LLM-driven complete-slice and validate-milestone units with
- * mechanical aggregation when the data is sufficient.
- */
-import { readFileSync, existsSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { atomicWriteSync } from "./atomic-write.js";
-import { loadFile, parseSummary } from "./files.js";
-import { extractMarkdownSection } from "./auto-prompts.js";
-import { resolveTaskFiles, resolveTaskJsonFiles, resolveTasksDir, resolveSliceFile, resolveSlicePath, resolveMilestoneFile, resolveMilestonePath, resolveGsdRootFile, } from "./paths.js";
-// ─── Slice Completion ────────────────────────────────────────────────────────
-/**
- * Mechanically complete a slice by aggregating task summaries into:
- * - S##-SUMMARY.md (aggregated frontmatter + task one-liners)
- * - S##-UAT.md (extracted from plan Verification section)
- * - Roadmap checkbox [x] update
- *
- * Returns true if completion succeeded, false if data is insufficient
- * (serves as quality gate — caller falls back to LLM completion).
- */
-export async function mechanicalSliceCompletion(base, mid, sid) {
-    const tDir = resolveTasksDir(base, mid, sid);
-    if (!tDir)
-        return false;
-    // Read all task summaries
-    const summaryFiles = resolveTaskFiles(tDir, "SUMMARY");
-    if (summaryFiles.length === 0)
-        return false;
-    const taskSummaries = [];
-    for (const file of summaryFiles) {
-        const content = readFileSync(join(tDir, file), "utf-8");
-        if (!content.trim())
-            continue;
-        const summary = parseSummary(content);
-        const taskId = file.match(/^(T\d+)/)?.[1] ?? file;
-        taskSummaries.push({ taskId, summary });
-    }
-    if (taskSummaries.length === 0)
-        return false;
-    // Quality gate: multi-task slices need substantive summaries
-    if (taskSummaries.length > 1) {
-        const totalContent = taskSummaries
-            .map(ts => ts.summary.whatHappened || ts.summary.oneLiner || "")
-            .join("");
-        if (totalContent.length < 200)
-            return false;
-    }
-    // Aggregate frontmatter
-    const aggregated = aggregateFrontmatter(taskSummaries.map(ts => ts.summary.frontmatter));
-    // Build SUMMARY.md
-    const summaryLines = [
-        "---",
-        `id: ${sid}`,
-        `parent: ${mid}`,
-        `milestone: ${mid}`,
-    ];
-    if (aggregated.provides.length > 0)
-        summaryLines.push(`provides:\n${aggregated.provides.map(p => `  - ${p}`).join("\n")}`);
-    if (aggregated.key_files.length > 0)
-        summaryLines.push(`key_files:\n${aggregated.key_files.map(f => `  - ${f}`).join("\n")}`);
-    if (aggregated.key_decisions.length > 0)
-        summaryLines.push(`key_decisions:\n${aggregated.key_decisions.map(d => `  - ${d}`).join("\n")}`);
-    if (aggregated.patterns_established.length > 0)
-        summaryLines.push(`patterns_established:\n${aggregated.patterns_established.map(p => `  - ${p}`).join("\n")}`);
-    if (aggregated.affects.length > 0)
-        summaryLines.push(`affects:\n${aggregated.affects.map(a => `  - ${a}`).join("\n")}`);
-    if (aggregated.observability_surfaces.length > 0)
-        summaryLines.push(`observability_surfaces:\n${aggregated.observability_surfaces.map(o => `  - ${o}`).join("\n")}`);
-    const allPassed = taskSummaries.every(ts => ts.summary.frontmatter.verification_result === "passed");
-    summaryLines.push(`verification_result: ${allPassed ? "passed" : "mixed"}`);
-    summaryLines.push(`completed_at: ${new Date().toISOString()}`);
-    summaryLines.push("---");
-    summaryLines.push("");
-    summaryLines.push(`# ${sid}: Slice Summary`);
-    summaryLines.push("");
-    // Task one-liners
-    for (const { taskId, summary } of taskSummaries) {
-        const line = summary.oneLiner || summary.title || taskId;
-        summaryLines.push(`- **${taskId}**: ${line}`);
-    }
-    summaryLines.push("");
-    const sDir = resolveSlicePath(base, mid, sid);
-    if (!sDir)
-        return false;
-    const summaryPath = join(sDir, `${sid}-SUMMARY.md`);
-    atomicWriteSync(summaryPath, summaryLines.join("\n"));
-    process.stderr.write(`gsd-mechanical: wrote ${summaryPath}\n`);
-    // Build UAT.md from plan's Verification section
-    const planPath = resolveSliceFile(base, mid, sid, "PLAN");
-    if (planPath) {
-        const planContent = readFileSync(planPath, "utf-8");
-        const verification = extractMarkdownSection(planContent, "Verification");
-        if (verification) {
-            const uatContent = [
-                "---",
-                `id: ${sid}`,
-                `parent: ${mid}`,
-                "type: artifact-driven",
-                "---",
-                "",
-                `# ${sid}: UAT`,
-                "",
-                verification,
-                "",
-            ].join("\n");
-            const uatPath = join(sDir, `${sid}-UAT.md`);
-            atomicWriteSync(uatPath, uatContent);
-            process.stderr.write(`gsd-mechanical: wrote ${uatPath}\n`);
-        }
-    }
-    // Mark slice [x] in ROADMAP
-    await markSliceInRoadmap(base, mid, sid);
-    // Append new decisions if any
-    await appendNewDecisions(base, taskSummaries.map(ts => ts.summary));
-    // Update requirements if all passed
-    if (allPassed) {
-        await mechanicalRequirementsUpdate(base, mid, sid, taskSummaries.map(ts => ts.summary));
-    }
-    return true;
-}
-// ─── Requirements Update ─────────────────────────────────────────────────────
-/**
- * Conservative requirements update: mark requirements Validated only if
- * all tasks' verification passed.
- */
-export async function mechanicalRequirementsUpdate(_base, _mid, _sid, _taskSummaries) {
-    // Conservative: requirements validation requires human or LLM judgment
-    // about whether the requirement is truly met. Mechanical completion only
-    // marks the slice done — requirement status updates are left to the
-    // existing validation pipeline.
-}
-// ─── Decision Aggregation ────────────────────────────────────────────────────
-/**
- * Collect key_decisions from task summaries, deduplicate against existing
- * DECISIONS.md, and append new ones.
- */
-export async function appendNewDecisions(base, taskSummaries) {
-    const allDecisions = taskSummaries.flatMap(s => s.frontmatter.key_decisions);
-    if (allDecisions.length === 0)
-        return;
-    const decisionsPath = resolveGsdRootFile(base, "DECISIONS");
-    const existing = existsSync(decisionsPath)
-        ? readFileSync(decisionsPath, "utf-8")
-        : "";
-    // Deduplicate — skip decisions whose text already appears in the file
-    const newDecisions = allDecisions.filter(d => d.trim() && !existing.includes(d.trim()));
-    if (newDecisions.length === 0)
-        return;
-    const entries = newDecisions
-        .map(d => `- ${d} _(auto-aggregated from task summaries)_`)
-        .join("\n");
-    const updated = existing.trimEnd() + "\n\n### Auto-aggregated Decisions\n\n" + entries + "\n";
-    atomicWriteSync(decisionsPath, updated);
-    process.stderr.write(`gsd-mechanical: appended ${newDecisions.length} decision(s) to DECISIONS.md\n`);
-}
-/**
- * Aggregate T##-VERIFY.json files and S##-UAT-RESULT.md files across all
- * slices in a milestone to produce VALIDATION.md.
- */
-export async function aggregateMilestoneVerification(base, mid) {
-    const mDir = resolveMilestonePath(base, mid);
-    if (!mDir)
-        return { verdict: "failed", checks: [], uatResults: [], markdown: "" };
-    const allChecks = [];
-    const allUatResults = [];
-    // Scan all slices
-    const slicesDir = join(mDir, "slices");
-    if (!existsSync(slicesDir))
-        return { verdict: "failed", checks: [], uatResults: [], markdown: "" };
-    const sliceDirs = readdirSyncSafe(slicesDir).filter(name => /^S\d+/i.test(name)).sort();
-    for (const sliceName of sliceDirs) {
-        const sid = sliceName.match(/^(S\d+)/i)?.[1] ?? sliceName;
-        const tDir = resolveTasksDir(base, mid, sid);
-        if (tDir) {
-            const verifyFiles = resolveTaskJsonFiles(tDir, "VERIFY");
-            for (const vf of verifyFiles) {
-                try {
-                    const content = readFileSync(join(tDir, vf), "utf-8");
-                    const evidence = JSON.parse(content);
-                    allChecks.push(evidence);
-                }
-                catch {
-                    // Skip malformed JSON
-                }
-            }
-        }
-        // Check for UAT result
-        const uatResultPath = resolveSliceFile(base, mid, sid, "UAT-RESULT");
-        if (uatResultPath) {
-            try {
-                const uatContent = readFileSync(uatResultPath, "utf-8");
-                allUatResults.push(`### ${sid}\n\n${uatContent}`);
-            }
-            catch {
-                // Non-fatal
-            }
-        }
-    }
-    // Determine verdict
-    const allPassed = allChecks.length > 0 && allChecks.every(c => c.passed);
-    const anyFailed = allChecks.some(c => !c.passed);
-    const verdict = allPassed
-        ? "passed"
-        : anyFailed
-            ? (allChecks.some(c => c.passed) ? "mixed" : "failed")
-            : "passed"; // No checks = vacuously passed
-    // Build VALIDATION.md
-    const mdLines = [
-        "---",
-        `milestone: ${mid}`,
-        `verdict: ${verdict}`,
-        "remediation_round: 0",
-        `validated_at: ${new Date().toISOString()}`,
-        "---",
-        "",
-        `# ${mid}: Milestone Validation`,
-        "",
-        `**Verdict:** ${verdict}`,
-        "",
-        "## Verification Results",
-        "",
-    ];
-    if (allChecks.length === 0) {
-        mdLines.push("_No verification evidence found._");
-    }
-    else {
-        mdLines.push("| Task | Passed | Checks | Failed |");
-        mdLines.push("|------|--------|--------|--------|");
-        for (const check of allChecks) {
-            const failedCount = check.checks.filter(c => c.verdict === "fail").length;
-            mdLines.push(`| ${check.taskId} | ${check.passed ? "yes" : "no"} | ${check.checks.length} | ${failedCount} |`);
-        }
-    }
-    if (allUatResults.length > 0) {
-        mdLines.push("");
-        mdLines.push("## UAT Results");
-        mdLines.push("");
-        mdLines.push(...allUatResults);
-    }
-    mdLines.push("");
-    const markdown = mdLines.join("\n");
-    // Write VALIDATION.md
-    const validationPath = join(mDir, `${mid}-VALIDATION.md`);
-    atomicWriteSync(validationPath, markdown);
-    process.stderr.write(`gsd-mechanical: wrote ${validationPath}\n`);
-    return { verdict, checks: allChecks, uatResults: allUatResults, markdown };
-}
-// ─── Milestone Summary ──────────────────────────────────────────────────────
-/**
- * Read all S##-SUMMARY.md files and produce M##-SUMMARY.md.
- */
-export async function generateMilestoneSummary(base, mid) {
-    const mDir = resolveMilestonePath(base, mid);
-    if (!mDir)
-        return "";
-    const slicesDir = join(mDir, "slices");
-    if (!existsSync(slicesDir))
-        return "";
-    const sliceDirs = readdirSyncSafe(slicesDir).filter(name => /^S\d+/i.test(name)).sort();
-    const aggregatedProvides = [];
-    const aggregatedKeyFiles = [];
-    const aggregatedKeyDecisions = [];
-    const aggregatedPatterns = [];
-    const sliceOneLinerList = [];
-    for (const sliceName of sliceDirs) {
-        const sid = sliceName.match(/^(S\d+)/i)?.[1] ?? sliceName;
-        const summaryPath = resolveSliceFile(base, mid, sid, "SUMMARY");
-        if (!summaryPath)
-            continue;
-        try {
-            const content = readFileSync(summaryPath, "utf-8");
-            const summary = parseSummary(content);
-            aggregatedProvides.push(...summary.frontmatter.provides);
-            aggregatedKeyFiles.push(...summary.frontmatter.key_files);
-            aggregatedKeyDecisions.push(...summary.frontmatter.key_decisions);
-            aggregatedPatterns.push(...summary.frontmatter.patterns_established);
-            sliceOneLinerList.push(`- **${sid}**: ${summary.oneLiner || summary.title || sid}`);
-        }
-        catch {
-            sliceOneLinerList.push(`- **${sid}**: _(summary unavailable)_`);
-        }
-    }
-    const mdLines = [
-        "---",
-        `id: ${mid}`,
-    ];
-    if (dedup(aggregatedProvides).length > 0)
-        mdLines.push(`provides:\n${dedup(aggregatedProvides).map(p => `  - ${p}`).join("\n")}`);
-    if (dedup(aggregatedKeyFiles).length > 0)
-        mdLines.push(`key_files:\n${dedup(aggregatedKeyFiles).map(f => `  - ${f}`).join("\n")}`);
-    if (dedup(aggregatedKeyDecisions).length > 0)
-        mdLines.push(`key_decisions:\n${dedup(aggregatedKeyDecisions).map(d => `  - ${d}`).join("\n")}`);
-    if (dedup(aggregatedPatterns).length > 0)
-        mdLines.push(`patterns_established:\n${dedup(aggregatedPatterns).map(p => `  - ${p}`).join("\n")}`);
-    mdLines.push(`completed_at: ${new Date().toISOString()}`);
-    mdLines.push("---");
-    mdLines.push("");
-    mdLines.push(`# ${mid}: Milestone Summary`);
-    mdLines.push("");
-    mdLines.push("## Slices");
-    mdLines.push("");
-    mdLines.push(...sliceOneLinerList);
-    mdLines.push("");
-    const content = mdLines.join("\n");
-    // Write M##-SUMMARY.md
-    const summaryPath = join(mDir, `${mid}-SUMMARY.md`);
-    atomicWriteSync(summaryPath, content);
-    process.stderr.write(`gsd-mechanical: wrote ${summaryPath}\n`);
-    return content;
-}
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-function aggregateFrontmatter(fms) {
-    return {
-        provides: dedup(fms.flatMap(f => f.provides)),
-        key_files: dedup(fms.flatMap(f => f.key_files)),
-        key_decisions: dedup(fms.flatMap(f => f.key_decisions)),
-        patterns_established: dedup(fms.flatMap(f => f.patterns_established)),
-        affects: dedup(fms.flatMap(f => f.affects)),
-        observability_surfaces: dedup(fms.flatMap(f => f.observability_surfaces)),
-    };
-}
-function dedup(arr) {
-    return [...new Set(arr.filter(s => s.trim()))];
-}
-async function markSliceInRoadmap(base, mid, sid) {
-    const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
-    if (!roadmapPath)
-        return;
-    const content = await loadFile(roadmapPath);
-    if (!content)
-        return;
-    const updated = content.replace(new RegExp(`^(\\s*-\\s+)\\[ \\]\\s+\\*\\*${sid}:`, "m"), `$1[x] **${sid}:`);
-    if (updated !== content) {
-        atomicWriteSync(roadmapPath, updated);
-        process.stderr.write(`gsd-mechanical: marked ${sid} done in ROADMAP\n`);
-    }
-}
-function readdirSyncSafe(dir) {
-    try {
-        return readdirSync(dir);
-    }
-    catch {
-        return [];
-    }
-}

package/src/resources/extensions/gsd/auto-constants.ts

@@ -1,6 +0,0 @@
-/**
- * Shared constants for auto-mode modules (auto.ts, auto-post-unit.ts, etc.).
- */
-
-/** Throttle STATE.md rebuilds — at most once per 30 seconds. */
-export const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;

package/src/resources/extensions/gsd/auto-idempotency.ts

@@ -1,151 +0,0 @@
-/**
- * Idempotency checks for auto-mode unit dispatch.
- *
- * Handles completed-key membership, artifact cross-validation,
- * consecutive skip counting, phantom skip loop detection, key eviction,
- * and fallback persistence.
- *
- * Extracted from dispatchNextUnit() in auto.ts. Pure decision logic
- * with set mutations — does NOT call dispatchNextUnit or stopAuto.
- */
-
-import { invalidateAllCaches } from "./cache.js";
-import {
-  verifyExpectedArtifact,
-  persistCompletedKey,
-  removePersistedKey,
-} from "./auto-recovery.js";
-import { resolveMilestoneFile } from "./paths.js";
-import { MAX_CONSECUTIVE_SKIPS, MAX_LIFETIME_DISPATCHES } from "./auto/session.js";
-import type { AutoSession } from "./auto/session.js";
-import { parseUnitId } from "./unit-id.js";
-
-export interface IdempotencyContext {
-  s: AutoSession;
-  unitType: string;
-  unitId: string;
-  basePath: string;
-  /** Notification callback */
-  notify: (message: string, level: "info" | "warning" | "error") => void;
-}
-
-export type IdempotencyResult =
-  | { action: "skip"; reason: string }
-  | { action: "rerun"; reason: string }
-  | { action: "proceed" }
-  | { action: "stop"; reason: string };
-
-/**
- * Check whether a unit should be skipped (already completed), rerun
- * (stale completion record), or dispatched normally.
- *
- * Mutates s.completedKeySet, s.unitConsecutiveSkips, s.unitLifetimeDispatches,
- * and s.recentlyEvictedKeys as needed.
- */
-export function checkIdempotency(ictx: IdempotencyContext): IdempotencyResult {
-  const { s, unitType, unitId, basePath, notify } = ictx;
-  const idempotencyKey = `${unitType}/${unitId}`;
-
-  // ── Primary path: key exists in completed set ──
-  if (s.completedKeySet.has(idempotencyKey)) {
-    const artifactExists = verifyExpectedArtifact(unitType, unitId, basePath);
-    if (artifactExists) {
-      // Guard against infinite skip loops
-      const skipCount = (s.unitConsecutiveSkips.get(idempotencyKey) ?? 0) + 1;
-      s.unitConsecutiveSkips.set(idempotencyKey, skipCount);
-      if (skipCount > MAX_CONSECUTIVE_SKIPS) {
-        // Cross-check: verify the unit's milestone is still active (#790)
-        const skippedMid = parseUnitId(unitId).milestone;
-        const skippedMilestoneComplete = skippedMid
-          ? !!resolveMilestoneFile(basePath, skippedMid, "SUMMARY")
-          : false;
-        if (skippedMilestoneComplete) {
-          s.unitConsecutiveSkips.delete(idempotencyKey);
-          invalidateAllCaches();
-          notify(
-            `Phantom skip loop cleared: ${unitType} ${unitId} belongs to completed milestone ${skippedMid}. Re-dispatching from fresh state.`,
-            "info",
-          );
-          return { action: "skip", reason: "phantom-loop-cleared" };
-        }
-        s.unitConsecutiveSkips.delete(idempotencyKey);
-        s.completedKeySet.delete(idempotencyKey);
-        s.recentlyEvictedKeys.add(idempotencyKey);
-        removePersistedKey(basePath, idempotencyKey);
-        invalidateAllCaches();
-        notify(
-          `Skip loop detected: ${unitType} ${unitId} skipped ${skipCount} times without advancing. Evicting completion record and forcing reconciliation.`,
-          "warning",
-        );
-        return { action: "skip", reason: "evicted" };
-      }
-      // Count toward lifetime cap
-      const lifeSkip = (s.unitLifetimeDispatches.get(idempotencyKey) ?? 0) + 1;
-      s.unitLifetimeDispatches.set(idempotencyKey, lifeSkip);
-      if (lifeSkip > MAX_LIFETIME_DISPATCHES) {
-        return { action: "stop", reason: `Hard loop: ${unitType} ${unitId} (skip cycle)` };
-      }
-      notify(
-        `Skipping ${unitType} ${unitId} — already completed in a prior session. Advancing.`,
-        "info",
-      );
-      return { action: "skip", reason: "completed" };
-    } else {
-      // Stale completion record — artifact missing. Remove and re-run.
-      s.completedKeySet.delete(idempotencyKey);
-      removePersistedKey(basePath, idempotencyKey);
-      notify(
-        `Re-running ${unitType} ${unitId} — marked complete but expected artifact missing.`,
-        "warning",
-      );
-      return { action: "rerun", reason: "stale-key" };
-    }
-  }
-
-  // ── Fallback: key missing but artifact exists ──
-  if (verifyExpectedArtifact(unitType, unitId, basePath) && !s.recentlyEvictedKeys.has(idempotencyKey)) {
-    persistCompletedKey(basePath, idempotencyKey);
-    s.completedKeySet.add(idempotencyKey);
-    invalidateAllCaches();
-    // Same consecutive-skip guard as the primary path
-    const skipCount2 = (s.unitConsecutiveSkips.get(idempotencyKey) ?? 0) + 1;
-    s.unitConsecutiveSkips.set(idempotencyKey, skipCount2);
-    if (skipCount2 > MAX_CONSECUTIVE_SKIPS) {
-      const skippedMid2 = parseUnitId(unitId).milestone;
-      const skippedMilestoneComplete2 = skippedMid2
-        ? !!resolveMilestoneFile(basePath, skippedMid2, "SUMMARY")
-        : false;
-      if (skippedMilestoneComplete2) {
-        s.unitConsecutiveSkips.delete(idempotencyKey);
-        invalidateAllCaches();
-        notify(
-          `Phantom skip loop cleared: ${unitType} ${unitId} belongs to completed milestone ${skippedMid2}. Re-dispatching from fresh state.`,
-          "info",
-        );
-        return { action: "skip", reason: "phantom-loop-cleared" };
-      }
-      s.unitConsecutiveSkips.delete(idempotencyKey);
-      s.completedKeySet.delete(idempotencyKey);
-      removePersistedKey(basePath, idempotencyKey);
-      invalidateAllCaches();
-      notify(
-        `Skip loop detected: ${unitType} ${unitId} skipped ${skipCount2} times without advancing. Evicting completion record and forcing reconciliation.`,
-        "warning",
-      );
-      return { action: "skip", reason: "evicted" };
-    }
-    // Count toward lifetime cap
-    const lifeSkip2 = (s.unitLifetimeDispatches.get(idempotencyKey) ?? 0) + 1;
-    s.unitLifetimeDispatches.set(idempotencyKey, lifeSkip2);
-    if (lifeSkip2 > MAX_LIFETIME_DISPATCHES) {
-      return { action: "stop", reason: `Hard loop: ${unitType} ${unitId} (skip cycle)` };
-    }
-    notify(
-      `Skipping ${unitType} ${unitId} — artifact exists but completion key was missing. Repaired and advancing.`,
-      "info",
-    );
-    return { action: "skip", reason: "fallback-persisted" };
-  }
-
-  return { action: "proceed" };
-}