gsd-pi 2.42.0-dev.97e9e30 → 2.43.0-next.1

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

@@ -13,7 +13,7 @@
 import { deriveState } from "./state.js";
 import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
-import { resolveSliceFile, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, gsdRoot, } from "./paths.js";
+import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, gsdRoot, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { autoCommitCurrentBranch, } from "./worktree.js";
@@ -22,16 +22,56 @@ import { writeUnitRuntimeRecord, clearUnitRuntimeRecord } from "./unit-runtime.j
 import { runGSDDoctor, rebuildState, summarizeDoctorIssues } from "./doctor.js";
 import { recordHealthSnapshot, checkHealEscalation } from "./doctor-proactive.js";
 import { syncStateToProjectRoot } from "./auto-worktree-sync.js";
-import { isDbAvailable } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, updateTaskStatus } from "./gsd-db.js";
+import { renderPlanCheckboxes } from "./markdown-renderer.js";
 import { consumeSignal } from "./session-status-io.js";
 import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
 import { hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
-import { existsSync, unlinkSync } from "node:fs";
+import { existsSync, unlinkSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { uncheckTaskInPlan } from "./undo.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { _resetHasChangesCache } from "./native-git-bridge.js";
+/**
+ * Detect summary files written directly to disk without the LLM calling
+ * the completion tool. A "rogue" file is one that exists on disk but has
+ * no corresponding DB row with status "complete".
+ *
+ * This is a safety-net diagnostic (D003). The existing migrateFromMarkdown()
+ * in postUnitPostVerification() eventually ingests rogue files, but explicit
+ * detection provides immediate diagnostics so operators know the prompt failed.
+ */
+export function detectRogueFileWrites(unitType, unitId, basePath) {
+    if (!isDbAvailable())
+        return [];
+    const parts = unitId.split("/");
+    const rogues = [];
+    if (unitType === "execute-task") {
+        const [mid, sid, tid] = parts;
+        if (!mid || !sid || !tid)
+            return [];
+        const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+        if (!summaryPath || !existsSync(summaryPath))
+            return [];
+        const dbRow = getTask(mid, sid, tid);
+        if (!dbRow || dbRow.status !== "complete") {
+            rogues.push({ path: summaryPath, unitType, unitId });
+        }
+    }
+    else if (unitType === "complete-slice") {
+        const [mid, sid] = parts;
+        if (!mid || !sid)
+            return [];
+        const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
+        if (!summaryPath || !existsSync(summaryPath))
+            return [];
+        const dbRow = getSlice(mid, sid);
+        if (!dbRow || dbRow.status !== "complete") {
+            rogues.push({ path: summaryPath, unitType, unitId });
+        }
+    }
+    return rogues;
+}
 /** Throttle STATE.md rebuilds — at most once per 30 seconds */
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
 /**
@@ -283,6 +323,17 @@ export async function postUnitPreVerification(pctx, opts) {
                 process.stderr.write(`gsd-triage: resolution execution failed: ${err.message}\n`);
             }
         }
+        // Rogue file detection — safety net for LLM bypassing completion tools (D003)
+        try {
+            const rogueFiles = detectRogueFileWrites(s.currentUnit.type, s.currentUnit.id, s.basePath);
+            for (const rogue of rogueFiles) {
+                process.stderr.write(`gsd-rogue: detected rogue file write: ${rogue.path} (unit: ${rogue.unitId})\n`);
+                ctx.ui.notify(`Rogue file write detected: ${rogue.path}`, "warning");
+            }
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "rogue-detection", error: String(e) });
+        }
         // Artifact verification
         let triggerArtifactVerified = false;
         if (!s.currentUnit.type.startsWith("hook/")) {
@@ -389,9 +440,33 @@ export async function postUnitPostVerification(pctx) {
                 try {
                     const parts = trigger.unitId.split("/");
                     const [mid, sid, tid] = parts;
-                    // 1. Uncheck [x] → [ ] in PLAN.md
+                    // 1. Reset task status in DB and re-render plan checkboxes
                     if (mid && sid && tid) {
-                        uncheckTaskInPlan(s.basePath, mid, sid, tid);
+                        try {
+                            updateTaskStatus(mid, sid, tid, "pending");
+                            await renderPlanCheckboxes(s.basePath, mid, sid);
+                        }
+                        catch {
+                            // DB may be unavailable — fall back to direct file-based uncheck
+                            try {
+                                const slicePath = resolveSlicePath(s.basePath, mid, sid);
+                                if (slicePath) {
+                                    const { readdirSync } = await import("node:fs");
+                                    const planCandidates = readdirSync(slicePath)
+                                        .filter((f) => f.includes("PLAN") && (f.startsWith(sid) || f.startsWith(`${sid}-`)));
+                                    if (planCandidates.length > 0) {
+                                        const planFile = join(slicePath, planCandidates[0]);
+                                        let content = readFileSync(planFile, "utf-8");
+                                        const regex = new RegExp(`^(\\s*-\\s*)\\[x\\](\\s*\\**${tid}\\**[:\\s])`, "mi");
+                                        if (regex.test(content)) {
+                                            content = content.replace(regex, "$1[ ]$2");
+                                            writeFileSync(planFile, content, "utf-8");
+                                        }
+                                    }
+                                }
+                            }
+                            catch { /* non-fatal: file-based fallback failure */ }
+                        }
                     }
                     // 2. Delete SUMMARY.md for the task
                     if (mid && sid && tid) {

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

@@ -6,13 +6,12 @@
  * Pure functions that receive all needed state as parameters — no module-level
  * globals or AutoContext dependency.
  */
-import { parseUnitId } from "./unit-id.js";
 import { clearUnitRuntimeRecord } from "./unit-runtime.js";
 import { clearParseCache, parseRoadmap, parsePlan } from "./files.js";
+import { isDbAvailable, getTask, getSlice } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { nativeConflictFiles, nativeCommit, nativeCheckoutTheirs, nativeAddPaths, nativeMergeAbort, nativeResetHard, } from "./native-git-bridge.js";
-import { resolveMilestonePath, resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, relSlicePath, relTaskFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
-import { markSliceDoneInRoadmap } from "./roadmap-mutations.js";
+import { resolveMilestonePath, resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { dirname, join } from "node:path";
@@ -269,26 +268,37 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         if (!hasCheckboxTask && !hasHeadingTask)
             return false;
     }
-    // execute-task must also have its checkbox marked [x] in the slice plan.
-    // Heading-style plans (### T01 -- Title) have no checkbox — the task summary
-    // file existence (checked above via resolveExpectedArtifactPath) is sufficient.
+    // execute-task: DB status is authoritative. Fall back to heading-style plan
+    // detection when the DB is unavailable (unmigrated projects).
     if (unitType === "execute-task") {
         const parts = unitId.split("/");
         const mid = parts[0];
         const sid = parts[1];
         const tid = parts[2];
         if (mid && sid && tid) {
-            const planAbs = resolveSliceFile(base, mid, sid, "PLAN");
-            if (planAbs && existsSync(planAbs)) {
-                const planContent = readFileSync(planAbs, "utf-8");
-                const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-                const cbRe = new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m");
-                const hdRe = new RegExp(`^#{2,4}\\s+${escapedTid}\\s*(?:--|—|:)`, "m");
-                // Heading-style entries count as verified (no checkbox to toggle);
-                // checkbox-style entries require [x].
-                if (!cbRe.test(planContent) && !hdRe.test(planContent))
+            const dbTask = getTask(mid, sid, tid);
+            if (dbTask) {
+                // DB available — trust it
+                if (dbTask.status !== "complete" && dbTask.status !== "done")
                     return false;
             }
+            else if (!isDbAvailable()) {
+                // DB unavailable — fall back to plan heading check (format detection,
+                // not reconciliation). Heading-style entries (### T01 --) count as
+                // verified because the summary file existence (checked above) is the
+                // real signal.
+                const planAbs = resolveSliceFile(base, mid, sid, "PLAN");
+                if (planAbs && existsSync(planAbs)) {
+                    const planContent = readFileSync(planAbs, "utf-8");
+                    const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                    const hdRe = new RegExp(`^#{2,4}\\s+${escapedTid}\\s*(?:--|—|:)`, "m");
+                    const cbRe = new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m");
+                    if (!hdRe.test(planContent) && !cbRe.test(planContent))
+                        return false;
+                }
+            }
+            // else: DB available but task not found — summary file exists (checked above),
+            // so treat as verified (task may not be imported yet)
         }
     }
     // plan-slice must also produce individual task plan files for every task listed
@@ -317,11 +327,8 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             }
         }
     }
-    // complete-slice must also produce a UAT file AND mark the slice [x] in the roadmap.
-    // Without the roadmap check, a crash after writing SUMMARY+UAT but before updating
-    // the roadmap causes an infinite skip loop: the idempotency key says "done" but the
-    // state machine keeps returning the same complete-slice unit (roadmap still shows
-    // the slice incomplete), so dispatchNextUnit recurses forever.
+    // complete-slice: DB status is authoritative for whether the slice is done.
+    // Fall back to file-based check (roadmap [x]) when DB is unavailable.
     if (unitType === "complete-slice") {
         const parts = unitId.split("/");
         const mid = parts[0];
@@ -333,24 +340,30 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
                 if (!existsSync(uatPath))
                     return false;
             }
-            // Verify the roadmap has the slice marked [x]. If not, the completion
-            // record is stale — the unit must re-run to update the roadmap.
-            const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-            if (roadmapFile && existsSync(roadmapFile)) {
-                try {
-                    const roadmapContent = readFileSync(roadmapFile, "utf-8");
-                    const roadmap = parseRoadmap(roadmapContent);
-                    const slice = roadmap.slices.find((s) => s.id === sid);
-                    if (slice && !slice.done)
-                        return false;
-                }
-                catch {
-                    // Corrupt/unparseable roadmap — fail verification so the unit
-                    // re-runs and has a chance to fix the roadmap. Silently passing
-                    // here could advance past an incomplete slice.
+            const dbSlice = getSlice(mid, sid);
+            if (dbSlice) {
+                // DB available — trust it
+                if (dbSlice.status !== "complete")
                     return false;
+            }
+            else if (!isDbAvailable()) {
+                // DB unavailable — fall back to roadmap checkbox check
+                const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
+                if (roadmapFile && existsSync(roadmapFile)) {
+                    try {
+                        const roadmapContent = readFileSync(roadmapFile, "utf-8");
+                        const roadmap = parseRoadmap(roadmapContent);
+                        const slice = roadmap.slices.find((s) => s.id === sid);
+                        if (slice && !slice.done)
+                            return false;
+                    }
+                    catch {
+                        return false;
+                    }
                 }
             }
+            // else: DB available but slice not found — summary + UAT exist,
+            // treat as verified (slice may not be imported yet)
         }
     }
     // complete-milestone must have produced implementation artifacts (#1703).
@@ -423,52 +436,6 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
             return null;
     }
 }
-// ─── Skip / Blocker Artifact Generation ───────────────────────────────────────
-/**
- * Write skip artifacts for a stuck execute-task: a blocker task summary and
- * the [x] checkbox in the slice plan. Returns true if artifacts were written.
- */
-export function skipExecuteTask(base, mid, sid, tid, status, reason, maxAttempts) {
-    // Write a blocker task summary if missing.
-    if (!status.summaryExists) {
-        const tasksDir = resolveTasksDir(base, mid, sid);
-        const sDir = resolveSlicePath(base, mid, sid);
-        const targetDir = tasksDir ?? (sDir ? join(sDir, "tasks") : null);
-        if (!targetDir)
-            return false;
-        if (!existsSync(targetDir))
-            mkdirSync(targetDir, { recursive: true });
-        const summaryPath = join(targetDir, buildTaskFileName(tid, "SUMMARY"));
-        const content = [
-            `# BLOCKER — task skipped by auto-mode recovery`,
-            ``,
-            `Task \`${tid}\` in slice \`${sid}\` (milestone \`${mid}\`) failed to complete after ${reason} recovery exhausted ${maxAttempts} attempts.`,
-            ``,
-            `This placeholder was written by auto-mode so the pipeline can advance.`,
-            `Review this task manually and replace this file with a real summary.`,
-        ].join("\n");
-        writeFileSync(summaryPath, content, "utf-8");
-    }
-    // Mark [x] in the slice plan if not already checked.
-    if (!status.taskChecked) {
-        const planAbs = resolveSliceFile(base, mid, sid, "PLAN");
-        if (planAbs && existsSync(planAbs)) {
-            const planContent = readFileSync(planAbs, "utf-8");
-            const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-            const re = new RegExp(`^(- \\[) \\] (\\*\\*${escapedTid}:)`, "m");
-            if (re.test(planContent)) {
-                writeFileSync(planAbs, planContent.replace(re, "$1x] $2"), "utf-8");
-            }
-            else {
-                // Regex didn't match — checkbox format differs from expected pattern.
-                // Return false so callers know the plan was NOT updated and can
-                // fall through to other recovery strategies instead of assuming success.
-                return false;
-            }
-        }
-    }
-    return true;
-}
 // ─── Merge State Reconciliation ───────────────────────────────────────────────
 /**
  * Detect leftover merge state from a prior session and reconcile it.
@@ -590,39 +557,8 @@ export async function selfHealRuntimeRecords(base, ctx) {
         const now = Date.now();
         for (const record of records) {
             const { unitType, unitId } = record;
-            // Case 0: complete-slice with SUMMARY + UAT but unchecked roadmap (#1350).
-            // If a complete-slice was interrupted after writing artifacts but before
-            // flipping the roadmap checkbox, the verification fails and the dispatch
-            // loop relaunches the same unit forever. Auto-fix the checkbox.
-            if (unitType === "complete-slice") {
-                const { milestone: mid, slice: sid } = parseUnitId(unitId);
-                if (mid && sid) {
-                    const dir = resolveSlicePath(base, mid, sid);
-                    if (dir) {
-                        const summaryPath = join(dir, buildSliceFileName(sid, "SUMMARY"));
-                        const uatPath = join(dir, buildSliceFileName(sid, "UAT"));
-                        if (existsSync(summaryPath) && existsSync(uatPath)) {
-                            const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-                            if (roadmapFile && existsSync(roadmapFile)) {
-                                try {
-                                    const roadmapContent = readFileSync(roadmapFile, "utf-8");
-                                    const roadmap = parseRoadmap(roadmapContent);
-                                    const slice = (roadmap.slices ?? []).find(s => s.id === sid);
-                                    if (slice && !slice.done) {
-                                        // Auto-fix: flip the checkbox using shared utility
-                                        if (markSliceDoneInRoadmap(base, mid, sid)) {
-                                            ctx.ui.notify(`Self-heal: marked ${sid} done in roadmap (SUMMARY + UAT exist but checkbox was stale).`, "info");
-                                        }
-                                    }
-                                }
-                                catch {
-                                    // Roadmap parse failure — don't block self-heal
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+            // Case 0 removed — roadmap checkbox auto-fix is no longer needed.
+            // With DB-as-truth, stale checkboxes are fixed by repairStaleRenders().
             // Clear stale dispatched records (dispatched > 1h ago, process crashed)
             const age = now - (record.startedAt ?? 0);
             if (record.phase === "dispatched" && age > STALE_THRESHOLD_MS) {
@@ -654,13 +590,10 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
         case "execute-task": {
             if (!mid || !sid || !tid)
                 break;
-            const planRel = relSliceFile(base, mid, sid, "PLAN");
-            const summaryRel = relTaskFile(base, mid, sid, tid, "SUMMARY");
             return [
-                `   1. Write ${summaryRel} (even a partial summary is sufficient to unblock the pipeline)`,
-                `   2. Mark ${tid} [x] in ${planRel}: change "- [ ] **${tid}:" → "- [x] **${tid}:"`,
-                `   3. Run \`gsd doctor\` to reconcile .gsd/ state`,
-                `   4. Resume auto-mode — it will pick up from the next task`,
+                `   1. Run \`gsd undo-task ${tid}\` to reset the task state`,
+                `   2. Resume auto-mode — it will re-execute the task`,
+                `   3. If the task keeps failing, run \`gsd recover\` to rebuild DB state from disk`,
             ].join("\n");
         }
         case "plan-slice":
@@ -672,7 +605,7 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
                 : relSliceFile(base, mid, sid, "RESEARCH");
             return [
                 `   1. Write ${artifactRel} manually (or with the LLM in interactive mode)`,
-                `   2. Run \`gsd doctor\` to reconcile .gsd/ state`,
+                `   2. Run \`gsd recover\` to rebuild DB state from disk`,
                 `   3. Resume auto-mode`,
             ].join("\n");
         }
@@ -680,10 +613,9 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
             if (!mid || !sid)
                 break;
             return [
-                `   1. Write the slice summary and UAT file for ${sid} in ${relSlicePath(base, mid, sid)}`,
-                `   2. Mark ${sid} [x] in ${relMilestoneFile(base, mid, "ROADMAP")}`,
-                `   3. Run \`gsd doctor\` to reconcile .gsd/ state`,
-                `   4. Resume auto-mode`,
+                `   1. Run \`gsd reset-slice ${sid}\` to reset the slice and all its tasks`,
+                `   2. Resume auto-mode — it will re-execute incomplete tasks and re-complete the slice`,
+                `   3. If the slice keeps failing, run \`gsd recover\` to rebuild DB state from disk`,
             ].join("\n");
         }
         case "validate-milestone": {
@@ -692,7 +624,7 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
             const artifactRel = relMilestoneFile(base, mid, "VALIDATION");
             return [
                 `   1. Write ${artifactRel} with verdict: pass`,
-                `   2. Run \`gsd doctor\``,
+                `   2. Run \`gsd recover\` to rebuild DB state from disk`,
                 `   3. Resume auto-mode`,
             ].join("\n");
         }

package/dist/resources/extensions/gsd/auto-timeout-recovery.js

@@ -4,7 +4,7 @@
  * and blocker placeholder generation.
  */
 import { readUnitRuntimeRecord, writeUnitRuntimeRecord, formatExecuteTaskRecoveryStatus, inspectExecuteTaskDurability, } from "./unit-runtime.js";
-import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, skipExecuteTask, writeBlockerPlaceholder, } from "./auto-recovery.js";
+import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, writeBlockerPlaceholder, } from "./auto-recovery.js";
 import { existsSync } from "node:fs";
 import { resolveAgentEnd } from "./auto-loop.js";
 export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rctx) {
@@ -78,13 +78,10 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
             ctx.ui.notify(`${reason === "idle" ? "Idle" : "Timeout"} recovery: steering ${unitType} ${unitId} to finish durable output (attempt ${attemptNumber}, session ${recoveryAttempts + 1}/${maxRecoveryAttempts}).`, "warning");
             return "recovered";
         }
-        // Retries exhausted — write missing durable artifacts and advance.
+        // Retries exhausted — write a blocker placeholder and advance.
         const diagnostic = formatExecuteTaskRecoveryStatus(status);
-        const [mid, sid, tid] = unitId.split("/");
-        const skipped = mid && sid && tid
-            ? skipExecuteTask(basePath, mid, sid, tid, status, reason, maxRecoveryAttempts)
-            : false;
-        if (skipped) {
+        const placeholder = writeBlockerPlaceholder(unitType, unitId, basePath, `${reason} recovery exhausted ${maxRecoveryAttempts} attempts. Status: ${diagnostic}`);
+        if (placeholder) {
             writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
                 phase: "skipped",
                 recovery: status,

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

@@ -8,7 +8,7 @@
 import { existsSync, cpSync, readFileSync, readdirSync, mkdirSync, realpathSync, rmSync, unlinkSync, lstatSync as lstatSyncFn, } from "node:fs";
 import { isAbsolute, join } from "node:path";
 import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
-import { copyWorktreeDb, reconcileWorktreeDb, isDbAvailable, } from "./gsd-db.js";
+import { reconcileWorktreeDb, isDbAvailable, } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { execFileSync } from "node:child_process";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
@@ -251,6 +251,22 @@ export function syncWorktreeStateBack(mainBasePath, worktreePath, milestoneId) {
     }
     if (!existsSync(wtGsd) || !existsSync(mainGsd))
         return { synced };
+    // ── 0. Pre-upgrade worktree DB reconciliation ────────────────────────
+    // If the worktree has its own gsd.db (copied before the WAL transition),
+    // reconcile its hierarchy data into the project root DB before syncing
+    // files. This handles in-flight worktrees that were created before the
+    // upgrade to shared WAL mode.
+    const wtLocalDb = join(wtGsd, "gsd.db");
+    const mainDb = join(mainGsd, "gsd.db");
+    if (existsSync(wtLocalDb) && existsSync(mainDb)) {
+        try {
+            reconcileWorktreeDb(mainDb, wtLocalDb);
+            synced.push("gsd.db (pre-upgrade reconcile)");
+        }
+        catch {
+            // Non-fatal — file sync below is the fallback
+        }
+    }
     // ── 1. Sync root-level .gsd/ files back ──────────────────────────────
     // The worktree is authoritative — complete-milestone updates REQUIREMENTS,
     // PROJECT, etc. These must overwrite main's copies so they survive teardown.
@@ -641,17 +657,11 @@ function copyPlanningArtifacts(srcBase, wtPath) {
     ]) {
         safeCopy(join(srcGsd, file), join(dstGsd, file), { force: true });
     }
-    // Copy gsd.db if present in source
-    const srcDb = join(srcGsd, "gsd.db");
-    const destDb = join(dstGsd, "gsd.db");
-    if (existsSync(srcDb)) {
-        try {
-            copyWorktreeDb(srcDb, destDb);
-        }
-        catch {
-            /* non-fatal */
-        }
-    }
+    // 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.
 }
 /**
  * Teardown an auto-worktree: chdir back to original base, then remove

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

@@ -1063,4 +1063,4 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
 // Direct phase dispatch → auto-direct-dispatch.ts
 export { dispatchDirectPhase } from "./auto-direct-dispatch.js";
 // Re-export recovery functions for external consumers
-export { resolveExpectedArtifactPath, verifyExpectedArtifact, writeBlockerPlaceholder, skipExecuteTask, buildLoopRemediationSteps, } from "./auto-recovery.js";
+export { resolveExpectedArtifactPath, verifyExpectedArtifact, writeBlockerPlaceholder, buildLoopRemediationSteps, } from "./auto-recovery.js";