gsd-pi 2.78.1-dev.d8826a445 → 2.78.1-dev.eccf86e27

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -9,7 +9,7 @@
  * without modifying orchestration code.
  */
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
-import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone, insertAssessment, transaction } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
 import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
@@ -32,6 +32,8 @@ import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { PROJECT_RESEARCH_INFLIGHT_MARKER, } from "./project-research-policy.js";
 import { isWorkflowPrefsCaptured, resolveDeepProjectSetupState, } from "./deep-project-setup-policy.js";
 import { annotateBackgroundable } from "./delegation-policy.js";
+import { invalidateAllCaches } from "./cache.js";
+import { insertMilestoneValidationGates } from "./milestone-validation-gates.js";
 let reassessmentChecker = checkNeedsReassessment;
 let researchProjectPromptBuilder = buildResearchProjectPrompt;
 function shouldBypassMilestoneDepthGateInAuto(prefs) {
@@ -996,9 +998,12 @@ export const DISPATCH_RULES = [
                     const skipSource = trivialVariant
                         ? "trivial-scope pipeline variant (#4781)"
                         : "`skip_milestone_validation` preference";
+                    const skipValidationReason = trivialVariant ? "trivial-scope" : "preference";
                     const content = [
                         "---",
                         "verdict: pass",
+                        "skip_validation: true",
+                        `skip_validation_reason: ${skipValidationReason}`,
                         "remediation_round: 0",
                         "---",
                         "",
@@ -1007,6 +1012,39 @@ export const DISPATCH_RULES = [
                         `Milestone validation was skipped via ${skipSource}.`,
                     ].join("\n");
                     writeFileSync(validationPath, content, "utf-8");
+                    try {
+                        // DB-backed state derivation keys off assessments, not only the file
+                        // projection. Persist the skipped validation there too so the next
+                        // loop iteration advances to completing-milestone instead of
+                        // re-entering validating-milestone.
+                        if (isDbAvailable()) {
+                            transaction(() => {
+                                insertAssessment({
+                                    path: validationPath,
+                                    milestoneId: mid,
+                                    sliceId: null,
+                                    taskId: null,
+                                    status: "pass",
+                                    scope: "milestone-validation",
+                                    fullContent: content,
+                                });
+                                const gateSliceId = getMilestoneSlices(mid)[0]?.id;
+                                if (gateSliceId) {
+                                    insertMilestoneValidationGates(mid, gateSliceId, "pass", new Date().toISOString());
+                                }
+                            });
+                        }
+                    }
+                    catch (err) {
+                        try {
+                            unlinkSync(validationPath);
+                        }
+                        catch (unlinkErr) {
+                            logWarning("dispatch", `failed to remove skipped validation file after DB write failure for ${mid}: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`);
+                        }
+                        throw err;
+                    }
+                    invalidateAllCaches();
                 }
                 return { action: "skip" };
             }
@@ -1087,13 +1125,19 @@ export const DISPATCH_RULES = [
                             if (validationContent) {
                                 // Allow completion when validation was intentionally skipped by
                                 // preference/budget profile (#3399, #3344).
+                                const skippedByMarker = /^skip_validation:\s*true$/im.test(validationContent);
                                 const skippedByPreference = /skip(?:ped)?[\s\-]+(?:by|per|due to)\s+(?:preference|budget|profile)/i.test(validationContent);
+                                const skippedByTrivialVariant = /trivial-scope pipeline variant/i.test(validationContent);
                                 // Accept either the structured template format (table with MET/N/A/SATISFIED)
                                 // or prose evidence patterns the validation agent may emit.
                                 const structuredMatch = validationContent.includes("Operational") &&
                                     (validationContent.includes("MET") || validationContent.includes("N/A") || validationContent.includes("SATISFIED"));
                                 const proseMatch = /[Oo]perational[\s\S]{0,500}?(?:✅|pass|verified|confirmed|met|complete|true|yes|addressed|covered|satisfied|partially|n\/a|not[\s-]+applicable)/i.test(validationContent);
-                                const hasOperationalCheck = skippedByPreference || structuredMatch || proseMatch;
+                                const hasOperationalCheck = skippedByMarker ||
+                                    skippedByPreference ||
+                                    skippedByTrivialVariant ||
+                                    structuredMatch ||
+                                    proseMatch;
                                 if (!hasOperationalCheck) {
                                     return {
                                         action: "stop",

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -656,13 +656,15 @@ export async function postUnitPreVerification(pctx, opts) {
         if (s.currentUnit.type === "triage-captures") {
             try {
                 const { executeTriageResolutions } = await import("./triage-resolution.js");
-                const state = await deriveState(s.basePath);
+                const state = await deriveState(s.canonicalProjectRoot);
                 const mid = state.activeMilestone?.id ?? "";
                 const sid = state.activeSlice?.id ?? "";
                 // executeTriageResolutions handles defer milestone creation even
                 // without an active milestone/slice (the "all milestones complete"
                 // scenario from #1562). inject/replan/quick-task still require mid+sid.
-                const triageResult = executeTriageResolutions(s.basePath, mid, sid);
+                // Phase C: write to canonical project root. copyPlanningArtifacts
+                // has been deleted, so triage writes land where readers consult.
+                const triageResult = executeTriageResolutions(s.canonicalProjectRoot, mid, sid);
                 if (triageResult.injected > 0) {
                     ctx.ui.notify(`Triage: injected ${triageResult.injected} task${triageResult.injected === 1 ? "" : "s"} into ${sid} plan.`, "info");
                 }
@@ -805,10 +807,14 @@ export async function postUnitPreVerification(pctx, opts) {
                 try {
                     const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
                     if (mid && sid) {
-                        const regenerated = await regenerateIfMissing(s.basePath, mid, sid, "PLAN");
+                        // Phase C: write to the canonical project root (#5236 scope)
+                        // so non-symlinked worktrees no longer maintain a separate
+                        // local .gsd/ projection. copyPlanningArtifacts has been
+                        // deleted; reads + writes converge at projectRoot.
+                        const regenerated = await regenerateIfMissing(s.canonicalProjectRoot, mid, sid, "PLAN");
                         if (regenerated) {
                             // Re-check after regeneration
-                            triggerArtifactVerified = verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
+                            triggerArtifactVerified = verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.canonicalProjectRoot);
                             if (triggerArtifactVerified) {
                                 invalidateAllCaches();
                             }
@@ -999,7 +1005,7 @@ export async function postUnitPostVerification(pctx) {
                     if (mid && sid && tid) {
                         try {
                             updateTaskStatus(mid, sid, tid, "pending");
-                            await renderPlanCheckboxes(s.basePath, mid, sid);
+                            await renderPlanCheckboxes(s.canonicalProjectRoot, mid, sid);
                         }
                         catch (dbErr) {
                             // DB unavailable — fail explicitly rather than silently reverting to markdown mutation.
@@ -1009,7 +1015,8 @@ export async function postUnitPostVerification(pctx) {
                     }
                     // 2. Delete SUMMARY.md for the task
                     if (mid && sid && tid) {
-                        const tasksDir = resolveTasksDir(s.basePath, mid, sid);
+                        // Phase C: read+delete via canonical project root.
+                        const tasksDir = resolveTasksDir(s.canonicalProjectRoot, mid, sid);
                         if (tasksDir) {
                             const summaryFile = join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
                             if (existsSync(summaryFile)) {
@@ -1019,7 +1026,7 @@ export async function postUnitPostVerification(pctx) {
                     }
                     // 3. Delete the retry_on artifact (e.g. NEEDS-REWORK.md)
                     if (trigger.retryArtifact) {
-                        const retryArtifactPath = resolveHookArtifactPath(s.basePath, trigger.unitId, trigger.retryArtifact);
+                        const retryArtifactPath = resolveHookArtifactPath(s.canonicalProjectRoot, trigger.unitId, trigger.retryArtifact);
                         if (existsSync(retryArtifactPath)) {
                             unlinkSync(retryArtifactPath);
                         }
@@ -1255,16 +1262,17 @@ export async function postUnitPostVerification(pctx) {
             if (hasPendingCaptures(s.basePath)) {
                 const pending = loadPendingCaptures(s.basePath);
                 if (pending.length > 0) {
-                    const state = await deriveState(s.basePath);
+                    const readRoot = s.canonicalProjectRoot;
+                    const state = await deriveState(readRoot);
                     const mid = state.activeMilestone?.id;
                     const sid = state.activeSlice?.id;
                     if (mid && sid) {
                         let currentPlan = "";
                         let roadmapContext = "";
-                        const planFile = resolveSliceFile(s.basePath, mid, sid, "PLAN");
+                        const planFile = resolveSliceFile(readRoot, mid, sid, "PLAN");
                         if (planFile)
                             currentPlan = (await loadFile(planFile)) ?? "";
-                        const roadmapFile = resolveMilestoneFile(s.basePath, mid, "ROADMAP");
+                        const roadmapFile = resolveMilestoneFile(readRoot, mid, "ROADMAP");
                         if (roadmapFile)
                             roadmapContext = (await loadFile(roadmapFile)) ?? "";
                         const capturesList = pending.map(c => `- **${c.id}**: "${c.text}" (captured: ${c.timestamp})`).join("\n");
@@ -1312,7 +1320,7 @@ export async function postUnitPostVerification(pctx) {
     // exits the loop, leaving the user with no hint to /clear and /gsd again.
     if (s.stepMode) {
         try {
-            const nextState = await deriveState(s.basePath);
+            const nextState = await deriveState(s.canonicalProjectRoot);
             ctx.ui.notify(buildStepCompleteMessage(nextState), "info");
         }
         catch (e) {

package/dist/resources/extensions/gsd/auto-worktree.js

@@ -9,7 +9,6 @@ import { existsSync, cpSync, readFileSync, readdirSync, mkdirSync, realpathSync,
 import { isAbsolute, join, sep as pathSep } from "node:path";
 import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
 import { reconcileWorktreeDb, isDbAvailable, getMilestone, getMilestoneSlices, closeDatabase, openDatabase, getDbPath, } from "./gsd-db.js";
-import { atomicWriteSync } from "./atomic-write.js";
 import { execFileSync } from "node:child_process";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import { gsdRoot, resolveGsdPathContract } from "./paths.js";
@@ -206,9 +205,12 @@ function getActiveWorkspace() {
 }
 function clearProjectRootStateFiles(basePath, milestoneId) {
     const gsdDir = gsdRoot(basePath);
+    // Phase C pt 2: auto.lock removed from this list — the file is gone
+    // (migrated to the workers + unit_dispatches + runtime_kv tables). The
+    // remaining transient files (STATE.md, {MID}-META.json) are still
+    // worth removing on teardown.
     const transientFiles = [
         join(gsdDir, "STATE.md"),
-        join(gsdDir, "auto.lock"),
         join(gsdDir, "milestones", milestoneId, `${milestoneId}-META.json`),
     ];
     for (const file of transientFiles) {
@@ -968,120 +970,13 @@ export function enterBranchModeForMilestone(basePath, milestoneId) {
  * Forward-merge plan checkbox state from the project root into a freshly
  * re-attached worktree (#778).
  *
- * When auto-mode stops via crash (not graceful stop), the milestone branch
- * HEAD may be behind the filesystem state at the project root because
- * syncStateToProjectRoot() runs after every task completion but the final
- * git commit may not have happened before the crash. On restart the worktree
- * is re-attached to the branch HEAD, which has [ ] for the crashed task,
- * causing verifyExpectedArtifact() to fail and triggering an infinite
- * dispatch/skip loop.
- *
- * Fix: after re-attaching, read every *.md plan file in the milestone
- * directory at the project root and apply any [x] checkbox states that are
- * ahead of the worktree version (forward-only: never downgrade [x] → [ ]).
- *
- * This is forward-only compatibility for legacy projection copies. The DB
- * remains authoritative; this never downgrades checked boxes in a local
- * worktree projection.
+ * Phase C: deleted. Writers in workflow-projections.ts, triage-resolution.ts,
+ * rule-registry.ts, and auto-post-unit.ts now route through
+ * s.canonicalProjectRoot, so non-symlinked worktrees no longer need a local
+ * .gsd/ projection — the project-root .gsd/ is the only authoritative source
+ * for both reads and writes. copyPlanningArtifacts and reconcilePlanCheckboxes
+ * (both formerly here) became dead.
  */
-/**
- * Scope-typed variant of reconcilePlanCheckboxes.
- *
- * Takes an explicit (rootScope, worktreeScope) pair. milestoneId is taken
- * from rootScope. Asserts both scopes belong to the same workspace identity
- * to prevent silent mismatch bugs.
- */
-export function reconcilePlanCheckboxesByScope(rootScope, worktreeScope) {
-    if (rootScope.workspace.identityKey !== worktreeScope.workspace.identityKey) {
-        throw new Error(`reconcilePlanCheckboxesByScope: scope identity mismatch — ` +
-            `rootScope.identityKey="${rootScope.workspace.identityKey}" ` +
-            `worktreeScope.identityKey="${worktreeScope.workspace.identityKey}"`);
-    }
-    if (rootScope.milestoneId !== worktreeScope.milestoneId) {
-        throw new Error(`reconcilePlanCheckboxesByScope: milestoneId mismatch — ` +
-            `rootScope.milestoneId="${rootScope.milestoneId}" worktreeScope.milestoneId="${worktreeScope.milestoneId}"`);
-    }
-    const projectRoot = rootScope.workspace.projectRoot;
-    const wtPath = worktreeScope.workspace.worktreeRoot ?? worktreeScope.workspace.projectRoot;
-    const milestoneId = rootScope.milestoneId;
-    reconcilePlanCheckboxes(projectRoot, wtPath, milestoneId);
-}
-/**
- * @deprecated Use reconcilePlanCheckboxesByScope instead.
- * TODO(C-future): remove once all callers migrated.
- */
-function reconcilePlanCheckboxes(projectRoot, wtPath, milestoneId) {
-    const srcMilestone = join(projectRoot, ".gsd", "milestones", milestoneId);
-    const dstMilestone = join(wtPath, ".gsd", "milestones", milestoneId);
-    if (!existsSync(srcMilestone) || !existsSync(dstMilestone))
-        return;
-    // Walk all markdown files in the milestone directory (plans, summaries, etc.)
-    function walkMd(dir) {
-        const results = [];
-        try {
-            for (const entry of readdirSync(dir, { withFileTypes: true })) {
-                const full = join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    results.push(...walkMd(full));
-                }
-                else if (entry.isFile() && entry.name.endsWith(".md")) {
-                    results.push(full);
-                }
-            }
-        }
-        catch (err) {
-            /* non-fatal */
-            logWarning("worktree", `walkMd directory read failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        return results;
-    }
-    for (const srcFile of walkMd(srcMilestone)) {
-        const rel = srcFile.slice(srcMilestone.length);
-        const dstFile = dstMilestone + rel;
-        if (!existsSync(dstFile))
-            continue; // only reconcile existing files
-        let srcContent;
-        let dstContent;
-        try {
-            srcContent = readFileSync(srcFile, "utf-8");
-            dstContent = readFileSync(dstFile, "utf-8");
-        }
-        catch (e) {
-            logWarning("worktree", `reconcilePlanCheckboxes read failed: ${e.message}`);
-            continue;
-        }
-        if (srcContent === dstContent)
-            continue;
-        // Extract all checked task IDs from the source (project root)
-        // Pattern: - [x] **T<id>: or - [x] **S<id>: (case-insensitive x)
-        const checkedRe = /^- \[[xX]\] \*\*([TS]\d+):/gm;
-        const srcChecked = new Set();
-        for (const m of srcContent.matchAll(checkedRe))
-            srcChecked.add(m[1]);
-        if (srcChecked.size === 0)
-            continue;
-        // Forward-apply: replace [ ] → [x] for any IDs that are checked in src
-        let updated = dstContent;
-        let changed = false;
-        for (const id of srcChecked) {
-            const escapedId = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-            const uncheckedRe = new RegExp(`^(- )\\[ \\]( \\*\\*${escapedId}:)`, "gm");
-            if (uncheckedRe.test(updated)) {
-                updated = updated.replace(new RegExp(`^(- )\\[ \\]( \\*\\*${escapedId}:)`, "gm"), "$1[x]$2");
-                changed = true;
-            }
-        }
-        if (changed) {
-            try {
-                atomicWriteSync(dstFile, updated, "utf-8");
-            }
-            catch (err) {
-                /* non-fatal */
-                logWarning("worktree", `plan checkbox reconcile write failed: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-    }
-}
 export function createAutoWorktree(basePath, milestoneId) {
     basePath = resolveWorktreeProjectRoot(basePath);
     // Check if repo has commits — git worktree requires a valid HEAD
@@ -1127,33 +1022,15 @@ export function createAutoWorktree(basePath, milestoneId) {
             startPoint,
         });
     }
-    // Copy .gsd/ planning artifacts from the source repo into the new worktree.
-    // Worktrees are fresh git checkouts — untracked files don't carry over.
-    // Planning artifacts may be untracked if the project's .gitignore had a
-    // blanket .gsd/ rule (pre-v2.14.0). Without this copy, auto-mode loops
-    // on plan-slice because the plan file doesn't exist in the worktree.
-    //
-    // IMPORTANT: Skip when re-attaching to an existing branch (#759).
-    // The branch checkout already has committed artifacts with correct state
-    // (e.g. [x] for completed slices). Copying from the project root would
-    // overwrite them with stale data ([ ] checkboxes) because the root is
-    // not always fully synced.
-    if (!branchExists) {
-        copyPlanningArtifacts(basePath, info.path);
-    }
-    else {
-        // Re-attaching to an existing branch: forward-merge any plan checkpoint
-        // state from the project root into the worktree (#778).
-        //
-        // If auto-mode stopped via crash, the milestone branch HEAD may lag behind
-        // the project root filesystem because syncStateToProjectRoot() ran after
-        // task completion but the auto-commit never fired. On restart the worktree
-        // is re-created from the branch HEAD (which has [ ] for the crashed task),
-        // causing verifyExpectedArtifact() to return false → stale-key eviction →
-        // infinite dispatch/skip loop. Reconciling here ensures the worktree sees
-        // the same [x] state that syncStateToProjectRoot() wrote to the root.
-        reconcilePlanCheckboxes(basePath, info.path, milestoneId);
-    }
+    // Phase C: copyPlanningArtifacts and reconcilePlanCheckboxes were
+    // deleted. Both addressed the same problem (worktree-local .gsd/
+    // projection lagging behind project-root state) by maintaining a stale
+    // copy. Now that auto-mode writers in workflow-projections.ts,
+    // triage-resolution.ts, rule-registry.ts, and auto-post-unit.ts route
+    // through s.canonicalProjectRoot, the worktree never needs a local
+    // .gsd/ — both reads and writes converge on the project-root .gsd/.
+    // The original concerns (#759, #778) no longer apply because there is
+    // no second copy to drift.
     // Run user-configured post-create hook (#597) — e.g. copy .env, symlink assets
     const hookError = runWorktreePostCreateHook(basePath, info.path);
     if (hookError) {
@@ -1173,51 +1050,13 @@ export function createAutoWorktree(basePath, milestoneId) {
     nudgeGitBranchCache(previousCwd);
     return info.path;
 }
-/**
- * Copy .gsd/ planning artifacts from source repo to a new worktree.
- * Copies milestones/, DECISIONS.md, REQUIREMENTS.md, PROJECT.md, QUEUE.md,
- * STATE.md, KNOWLEDGE.md, and OVERRIDES.md.
- * Skips runtime files (auto.lock, metrics.json, etc.) and the worktrees/ dir.
- * Best-effort — failures are non-fatal since auto-mode can recreate artifacts.
- */
-function copyPlanningArtifacts(srcBase, wtPath) {
-    const srcGsd = join(srcBase, ".gsd");
-    const dstGsd = join(wtPath, ".gsd");
-    if (!existsSync(srcGsd))
-        return;
-    if (isSamePath(srcGsd, dstGsd))
-        return;
-    // Copy milestones/ directory (planning files, roadmaps, plans, research)
-    safeCopyRecursive(join(srcGsd, "milestones"), join(dstGsd, "milestones"), {
-        force: true,
-        filter: (src) => !src.endsWith("-META.json"),
-    });
-    // Copy top-level planning files
-    for (const file of [
-        "DECISIONS.md",
-        "REQUIREMENTS.md",
-        "PROJECT.md",
-        "QUEUE.md",
-        "STATE.md",
-        "KNOWLEDGE.md",
-        "OVERRIDES.md",
-        "mcp.json",
-    ]) {
-        safeCopy(join(srcGsd, file), join(dstGsd, file), { force: true });
-    }
-    // Seed canonical PREFERENCES.md when available; fall back to legacy lowercase.
-    if (existsSync(join(srcGsd, PROJECT_PREFERENCES_FILE))) {
-        safeCopy(join(srcGsd, PROJECT_PREFERENCES_FILE), join(dstGsd, PROJECT_PREFERENCES_FILE), { force: true });
-    }
-    else if (existsSync(join(srcGsd, LEGACY_PROJECT_PREFERENCES_FILE))) {
-        safeCopy(join(srcGsd, LEGACY_PROJECT_PREFERENCES_FILE), join(dstGsd, LEGACY_PROJECT_PREFERENCES_FILE), { force: true });
-    }
-    // Shared WAL (R012): worktrees use the project root's DB directly.
-    // No longer copy gsd.db into the worktree — the DB path resolver in
-    // ensureDbOpen() detects the worktree location and opens the root DB.
-    // Compat note: reconcileWorktreeDb() in mergeMilestoneToMain handles
-    // worktrees that already have a local gsd.db from before this change.
-}
+// Phase C: copyPlanningArtifacts removed. Planning artifacts now live
+// only at the project root .gsd/; auto-mode writers (workflow-projections,
+// triage-resolution, rule-registry, regenerateIfMissing,
+// resolveHookArtifactPath) all route through s.canonicalProjectRoot.
+// Worktrees are pure git checkouts — they no longer maintain a parallel
+// .gsd/ projection. The gsd.db has always lived at the project root via
+// the shared-WAL R012 contract; that is unchanged.
 /**
  * Teardown an auto-worktree: chdir back to original base, then remove
  * the worktree and its branch.