gsd-pi 2.73.1-dev.47ed32a → 2.73.1-dev.49397e5

package/dist/resources/extensions/gsd/memory-store.js

@@ -2,7 +2,7 @@
 //
 // Storage layer for auto-learned project memories. Follows context-store.ts patterns.
 // All functions degrade gracefully: return empty results when DB unavailable, never throw.
-import { isDbAvailable, _getAdapter, transaction } from './gsd-db.js';
+import { isDbAvailable, _getAdapter, transaction, insertMemoryRow, rewriteMemoryId, updateMemoryContentRow, incrementMemoryHitCount, supersedeMemoryRow, markMemoryUnitProcessed, decayMemoriesBefore, supersedeLowestRankedMemories, } from './gsd-db.js';
 // ─── Category Display Order ─────────────────────────────────────────────────
 const CATEGORY_PRIORITY = {
     gotcha: 0,
@@ -112,27 +112,23 @@ export function createMemory(fields) {
         const now = new Date().toISOString();
         // Insert with a temporary placeholder ID — seq is auto-assigned
         const placeholder = `_TMP_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        adapter.prepare(`INSERT INTO memories (id, category, content, confidence, source_unit_type, source_unit_id, created_at, updated_at)
-       VALUES (:id, :category, :content, :confidence, :source_unit_type, :source_unit_id, :created_at, :updated_at)`).run({
-            ':id': placeholder,
-            ':category': fields.category,
-            ':content': fields.content,
-            ':confidence': fields.confidence ?? 0.8,
-            ':source_unit_type': fields.source_unit_type ?? null,
-            ':source_unit_id': fields.source_unit_id ?? null,
-            ':created_at': now,
-            ':updated_at': now,
+        insertMemoryRow({
+            id: placeholder,
+            category: fields.category,
+            content: fields.content,
+            confidence: fields.confidence ?? 0.8,
+            sourceUnitType: fields.source_unit_type ?? null,
+            sourceUnitId: fields.source_unit_id ?? null,
+            createdAt: now,
+            updatedAt: now,
         });
-        // Derive the real ID from the assigned seq
+        // Derive the real ID from the assigned seq (SELECT is still fine via adapter)
         const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
         if (!row)
             return placeholder; // fallback — should not happen
         const seq = row['seq'];
         const realId = `MEM${String(seq).padStart(3, '0')}`;
-        adapter.prepare('UPDATE memories SET id = :real_id WHERE id = :placeholder').run({
-            ':real_id': realId,
-            ':placeholder': placeholder,
-        });
+        rewriteMemoryId(placeholder, realId);
         return realId;
     }
     catch {
@@ -145,17 +141,8 @@ export function createMemory(fields) {
 export function updateMemoryContent(id, content, confidence) {
     if (!isDbAvailable())
         return false;
-    const adapter = _getAdapter();
-    if (!adapter)
-        return false;
     try {
-        const now = new Date().toISOString();
-        if (confidence != null) {
-            adapter.prepare('UPDATE memories SET content = :content, confidence = :confidence, updated_at = :updated_at WHERE id = :id').run({ ':content': content, ':confidence': confidence, ':updated_at': now, ':id': id });
-        }
-        else {
-            adapter.prepare('UPDATE memories SET content = :content, updated_at = :updated_at WHERE id = :id').run({ ':content': content, ':updated_at': now, ':id': id });
-        }
+        updateMemoryContentRow(id, content, confidence, new Date().toISOString());
         return true;
     }
     catch {
@@ -168,11 +155,8 @@ export function updateMemoryContent(id, content, confidence) {
 export function reinforceMemory(id) {
     if (!isDbAvailable())
         return false;
-    const adapter = _getAdapter();
-    if (!adapter)
-        return false;
     try {
-        adapter.prepare('UPDATE memories SET hit_count = hit_count + 1, updated_at = :updated_at WHERE id = :id').run({ ':updated_at': new Date().toISOString(), ':id': id });
+        incrementMemoryHitCount(id, new Date().toISOString());
         return true;
     }
     catch {
@@ -185,11 +169,8 @@ export function reinforceMemory(id) {
 export function supersedeMemory(oldId, newId) {
     if (!isDbAvailable())
         return false;
-    const adapter = _getAdapter();
-    if (!adapter)
-        return false;
     try {
-        adapter.prepare('UPDATE memories SET superseded_by = :new_id, updated_at = :updated_at WHERE id = :old_id').run({ ':new_id': newId, ':updated_at': new Date().toISOString(), ':old_id': oldId });
+        supersedeMemoryRow(oldId, newId, new Date().toISOString());
         return true;
     }
     catch {
@@ -220,12 +201,8 @@ export function isUnitProcessed(unitKey) {
 export function markUnitProcessed(unitKey, activityFile) {
     if (!isDbAvailable())
         return false;
-    const adapter = _getAdapter();
-    if (!adapter)
-        return false;
     try {
-        adapter.prepare(`INSERT OR IGNORE INTO memory_processed_units (unit_key, activity_file, processed_at)
-       VALUES (:key, :file, :at)`).run({ ':key': unitKey, ':file': activityFile, ':at': new Date().toISOString() });
+        markMemoryUnitProcessed(unitKey, activityFile, new Date().toISOString());
         return true;
     }
     catch {
@@ -244,16 +221,14 @@ export function decayStaleMemories(thresholdUnits = 20) {
     if (!adapter)
         return;
     try {
-        // Find the timestamp of the Nth most recent processed unit
+        // Find the timestamp of the Nth most recent processed unit (read-only SELECT)
         const row = adapter.prepare(`SELECT processed_at FROM memory_processed_units
        ORDER BY processed_at DESC
        LIMIT 1 OFFSET :offset`).get({ ':offset': thresholdUnits - 1 });
         if (!row)
             return; // not enough processed units yet
         const cutoff = row['processed_at'];
-        adapter.prepare(`UPDATE memories
-       SET confidence = MAX(0.1, confidence - 0.1), updated_at = :now
-       WHERE superseded_by IS NULL AND updated_at < :cutoff AND confidence > 0.1`).run({ ':now': new Date().toISOString(), ':cutoff': cutoff });
+        decayMemoriesBefore(cutoff, new Date().toISOString());
     }
     catch {
         // non-fatal
@@ -274,14 +249,7 @@ export function enforceMemoryCap(max = 50) {
         if (count <= max)
             return;
         const excess = count - max;
-        // Batch update: supersede lowest-ranked active memories in a single statement
-        adapter.prepare(`UPDATE memories SET superseded_by = 'CAP_EXCEEDED', updated_at = :now
-       WHERE id IN (
-         SELECT id FROM memories
-         WHERE superseded_by IS NULL
-         ORDER BY (confidence * (1.0 + hit_count * 0.1)) ASC
-         LIMIT :limit
-       )`).run({ ':now': new Date().toISOString(), ':limit': excess });
+        supersedeLowestRankedMemories(excess, new Date().toISOString());
     }
     catch {
         // non-fatal

package/dist/resources/extensions/gsd/milestone-validation-gates.js

@@ -10,7 +10,7 @@
  * gate registry so the definitions stay in lockstep with prompt builders,
  * dispatch rules, and state derivation. See gate-registry.ts.
  */
-import { _getAdapter } from "./gsd-db.js";
+import { isDbAvailable, upsertQualityGate } from "./gsd-db.js";
 import { getGatesForTurn } from "./gate-registry.js";
 /**
  * Insert milestone-level quality_gates records for a validation run.
@@ -24,21 +24,22 @@ import { getGatesForTurn } from "./gate-registry.js";
  * in gate-registry.ts automatically flows through here.
  */
 export function insertMilestoneValidationGates(milestoneId, sliceId, verdict, evaluatedAt) {
-    const db = _getAdapter();
-    if (!db)
+    if (!isDbAvailable())
         return;
     const gateVerdict = verdict === "pass" ? "pass" : "flag";
     const milestoneGates = getGatesForTurn("validate-milestone");
     for (const def of milestoneGates) {
-        db.prepare(`INSERT OR REPLACE INTO quality_gates
-       (milestone_id, slice_id, gate_id, scope, task_id, status, verdict, rationale, findings, evaluated_at)
-       VALUES (:mid, :sid, :gid, 'milestone', '', 'complete', :verdict, :rationale, '', :evaluated_at)`).run({
-            ":mid": milestoneId,
-            ":sid": sliceId,
-            ":gid": def.id,
-            ":verdict": gateVerdict,
-            ":rationale": `${def.promptSection} — milestone validation verdict: ${verdict}`,
-            ":evaluated_at": evaluatedAt,
+        upsertQualityGate({
+            milestoneId,
+            sliceId,
+            gateId: def.id,
+            scope: "milestone",
+            taskId: "",
+            status: "complete",
+            verdict: gateVerdict,
+            rationale: `${def.promptSection} — milestone validation verdict: ${verdict}`,
+            findings: "",
+            evaluatedAt,
         });
     }
 }

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -4,7 +4,7 @@
 //
 // Both READ and WRITE operations are native — push operations remain as
 // execSync calls because git2 credential handling is too complex.
-import { execSync, execFileSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { GSDError, GSD_GIT_ERROR } from "./errors.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { getErrorMessage } from "./error-utils.js";
@@ -206,7 +206,7 @@ export function nativeIsRepo(basePath) {
         return native.gitIsRepo(basePath);
     }
     try {
-        execSync("git rev-parse --git-dir", { cwd: basePath, stdio: "pipe" });
+        execFileSync("git", ["rev-parse", "--git-dir"], { cwd: basePath, stdio: "pipe" });
         return true;
     }
     catch {
@@ -629,7 +629,10 @@ export function nativeCommit(basePath, message, options) {
     }
     // Fallback: use git commit with stdin pipe for safe multi-line messages
     try {
-        const result = execSync(`git commit --no-verify -F -${options?.allowEmpty ? " --allow-empty" : ""}`, {
+        const args = ["commit", "--no-verify", "-F", "-"];
+        if (options?.allowEmpty)
+            args.push("--allow-empty");
+        const result = execFileSync("git", args, {
             cwd: basePath,
             stdio: ["pipe", "pipe", "pipe"],
             encoding: "utf-8",
@@ -767,7 +770,7 @@ export function nativeResetHard(basePath) {
         native.gitResetHard(basePath);
         return;
     }
-    execSync("git reset --hard HEAD", { cwd: basePath, stdio: "pipe" });
+    execFileSync("git", ["reset", "--hard", "HEAD"], { cwd: basePath, stdio: "pipe" });
 }
 /**
  * Soft reset to a target ref (git reset --soft <ref>).

package/dist/resources/extensions/gsd/notification-widget.js

@@ -1,6 +1,6 @@
 // GSD Extension — Notification Widget
 // Always-on ambient widget rendered belowEditor showing unread count and
-// the most recent notification message. Refreshes every 5 seconds.
+// the most recent notification message. Refreshes every 30 seconds.
 // Widget key: "gsd-notifications", placement: "belowEditor"
 import { getUnreadCount, onNotificationStoreChange } from "./notification-store.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
@@ -12,7 +12,7 @@ export function buildNotificationWidgetLines() {
     return [`  🔔 Notifications: ${unread} unread  (${formattedShortcutPair("notifications")})`];
 }
 // ─── Widget init ────────────────────────────────────────────────────────
-const REFRESH_INTERVAL_MS = 5_000;
+const REFRESH_INTERVAL_MS = 30_000;
 /**
  * Initialize the always-on notification widget (belowEditor).
  * Call once from session_start after the notification store is initialized.

package/dist/resources/extensions/gsd/prompts/add-tests.md

@@ -0,0 +1,35 @@
+You are generating tests for recently completed GSD work.
+
+## Slice: {{sliceId}} — {{sliceTitle}}
+
+### Summary
+
+{{sliceSummary}}
+
+### Existing Test Patterns
+
+{{existingTestPatterns}}
+
+## Working Directory
+
+`{{workingDirectory}}`
+
+## Instructions
+
+1. Read the slice summary above to understand what was built
+2. Identify the source files that were created or modified for this slice
+3. Read the implementation code to understand behavior, edge cases, and error paths
+4. Write comprehensive tests following the project's existing test patterns and framework
+5. Run the tests to verify they pass
+6. Fix any failures
+
+### Rules
+
+- Follow the project's existing test patterns (framework, assertions, file structure)
+- Test behavior, not implementation details
+- Cover: happy path, edge cases, error conditions, boundary values
+- Do NOT modify implementation files — only create or update test files
+- Name test files consistently with the project's conventions
+- Keep tests focused and readable
+
+{{skillActivation}}

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

@@ -271,7 +271,11 @@ function reconcileDiskToDb(basePath) {
         try {
             roadmapContent = readFileSync(roadmapPath, "utf-8");
         }
-        catch {
+        catch (err) {
+            logWarning("state", "reconcileDiskToDb: roadmap read failed, skipping milestone", {
+                mid,
+                error: err.message,
+            });
             continue;
         }
         const parsed = parseRoadmap(roadmapContent);
@@ -312,6 +316,10 @@ function reconcileDiskToDb(basePath) {
 function buildCompletenessSet(basePath, milestones) {
     const completeMilestoneIds = new Set();
     const parkedMilestoneIds = new Set();
+    // DB-authoritative: a milestone is only "complete" when its DB row says so.
+    // SUMMARY-file presence is NOT a completion signal here — an orphan SUMMARY
+    // (crashed complete-milestone turn, partial merge, manual edit) must not
+    // flip derived state to complete and cascade into a false auto-merge (#4179).
     for (const m of milestones) {
         const parkedFile = resolveMilestoneFile(basePath, m.id, "PARKED");
         if (parkedFile || m.status === 'parked') {
@@ -322,11 +330,6 @@ function buildCompletenessSet(basePath, milestones) {
             completeMilestoneIds.add(m.id);
             continue;
         }
-        const summaryFile = resolveMilestoneFile(basePath, m.id, "SUMMARY");
-        if (summaryFile) {
-            completeMilestoneIds.add(m.id);
-            continue;
-        }
     }
     return { completeMilestoneIds, parkedMilestoneIds };
 }
@@ -347,17 +350,22 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
             if (isGhostMilestone(basePath, m.id))
                 continue;
         }
-        const summaryFile = resolveMilestoneFile(basePath, m.id, "SUMMARY");
-        if (completeMilestoneIds.has(m.id) || (summaryFile !== null)) {
+        // DB-authoritative completeness (#4179): only trust completeMilestoneIds,
+        // which is itself derived from DB status. SUMMARY-file presence alone must
+        // not imply completion. The summary file may still be consulted below as a
+        // title source for legitimately-complete milestones whose DB row has no title.
+        if (completeMilestoneIds.has(m.id)) {
             let title = stripMilestonePrefix(m.title) || m.id;
-            if (summaryFile && !m.title) {
-                const summaryContent = await loadFile(summaryFile);
-                if (summaryContent) {
-                    title = parseSummary(summaryContent).title || m.id;
+            if (!m.title) {
+                const summaryFile = resolveMilestoneFile(basePath, m.id, "SUMMARY");
+                if (summaryFile) {
+                    const summaryContent = await loadFile(summaryFile);
+                    if (summaryContent) {
+                        title = parseSummary(summaryContent).title || m.id;
+                    }
                 }
             }
             registry.push({ id: m.id, title, status: 'complete' });
-            completeMilestoneIds.add(m.id);
             continue;
         }
         const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
@@ -391,7 +399,14 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
                 const validationFile = resolveMilestoneFile(basePath, m.id, "VALIDATION");
                 const validationContent = validationFile ? await loadFile(validationFile) : null;
                 const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
-                if (!validationTerminal || (validationTerminal && !summaryFile)) {
+                // DB-authoritative (#4179): completeness is already decided by
+                // completeMilestoneIds above. If we reached this branch, the DB says
+                // the milestone is NOT complete — so any SUMMARY file on disk is an
+                // orphan (crashed complete-milestone, partial merge, manual edit) and
+                // must not short-circuit this path. When validation is terminal, fall
+                // through to the default active-push below so `complete-milestone` can
+                // re-run idempotently.
+                if (!validationTerminal) {
                     activeMilestone = { id: m.id, title };
                     activeMilestoneSlices = slices;
                     activeMilestoneFound = true;
@@ -516,6 +531,9 @@ function resolveSliceDependencies(activeMilestoneSlices) {
             return { activeSlice: null, activeSliceRow: null };
         }
     }
+    // First pass: find a slice with ALL dependencies satisfied (strict)
+    let bestFallback = null;
+    let bestFallbackSatisfied = -1;
     for (const s of activeMilestoneSlices) {
         if (isStatusDone(s.status))
             continue;
@@ -524,6 +542,23 @@ function resolveSliceDependencies(activeMilestoneSlices) {
         if (s.depends.every(dep => doneSliceIds.has(dep))) {
             return { activeSlice: { id: s.id, title: s.title }, activeSliceRow: s };
         }
+        // Track the slice with the most satisfied dependencies as fallback
+        const satisfied = s.depends.filter(dep => doneSliceIds.has(dep)).length;
+        if (satisfied > bestFallbackSatisfied || (satisfied === bestFallbackSatisfied && !bestFallback)) {
+            bestFallback = s;
+            bestFallbackSatisfied = satisfied;
+        }
+    }
+    // Fallback: if no slice has all deps met but there ARE incomplete non-deferred
+    // slices, pick the one with the most deps satisfied. This prevents hard-blocking
+    // when dependency metadata is stale (e.g. after reassessment added/removed slices)
+    // or when deps reference slices from previous milestones.
+    if (bestFallback) {
+        const unmet = bestFallback.depends.filter(dep => !doneSliceIds.has(dep));
+        logWarning("state", `No slice has all deps satisfied — falling back to ${bestFallback.id} ` +
+            `(${bestFallbackSatisfied}/${bestFallback.depends.length} deps met, ` +
+            `unmet: ${unmet.join(", ")})`, { mid: activeMilestoneSlices[0]?.milestone_id, sid: bestFallback.id });
+        return { activeSlice: { id: bestFallback.id, title: bestFallback.title }, activeSliceRow: bestFallback };
     }
     return { activeSlice: null, activeSliceRow: null };
 }
@@ -567,7 +602,7 @@ async function reconcileSliceTasks(basePath, milestoneId, sliceId, planFile) {
         const summaryPath = resolveTaskFile(basePath, milestoneId, sliceId, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
             try {
-                updateTaskStatus(milestoneId, sliceId, t.id, "complete");
+                updateTaskStatus(milestoneId, sliceId, t.id, "complete", new Date().toISOString());
                 logWarning("reconcile", `task ${milestoneId}/${sliceId}/${t.id} status reconciled from "${t.status}" to "complete" (#2514)`, { mid: milestoneId, sid: sliceId, tid: t.id });
                 reconciled = true;
             }
@@ -1269,6 +1304,8 @@ export async function _deriveStateImpl(basePath) {
         }
     }
     else {
+        let bestFallbackLegacy = null;
+        let bestFallbackLegacySatisfied = -1;
         for (const s of activeRoadmap.slices) {
             if (s.done)
                 continue;
@@ -1276,6 +1313,20 @@ export async function _deriveStateImpl(basePath) {
                 activeSlice = { id: s.id, title: s.title };
                 break;
             }
+            // Track best fallback
+            const satisfied = s.depends.filter(dep => doneSliceIds.has(dep)).length;
+            if (satisfied > bestFallbackLegacySatisfied) {
+                bestFallbackLegacy = s;
+                bestFallbackLegacySatisfied = satisfied;
+            }
+        }
+        // Fallback: if no slice has all deps met, pick the one with the most deps satisfied
+        if (!activeSlice && bestFallbackLegacy) {
+            const unmet = bestFallbackLegacy.depends.filter(dep => !doneSliceIds.has(dep));
+            logWarning("state", `No slice has all deps satisfied — falling back to ${bestFallbackLegacy.id} ` +
+                `(${bestFallbackLegacySatisfied}/${bestFallbackLegacy.depends.length} deps met, ` +
+                `unmet: ${unmet.join(", ")})`);
+            activeSlice = { id: bestFallbackLegacy.id, title: bestFallbackLegacy.title };
         }
     }
     if (!activeSlice) {

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -1,7 +1,7 @@
 import { ensureDbOpen } from "../bootstrap/dynamic-tools.js";
 import { sanitizeCompleteMilestoneParams } from "../bootstrap/sanitize-complete-milestone.js";
 import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot } from "../bootstrap/write-gate.js";
-import { getMilestone, getSliceStatusSummary, getSliceTaskCounts, _getAdapter, saveGateResult, } from "../gsd-db.js";
+import { getMilestone, getSliceStatusSummary, getSliceTaskCounts, readTransaction, saveGateResult, } from "../gsd-db.js";
 import { GATE_REGISTRY } from "../gate-registry.js";
 import { saveArtifactToDb } from "../db-writer.js";
 import { handleCompleteMilestone } from "./complete-milestone.js";
@@ -493,12 +493,9 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
                 isError: true,
             };
         }
-        const adapter = _getAdapter();
-        adapter.exec("BEGIN");
-        try {
+        return readTransaction(() => {
             const milestone = getMilestone(params.milestoneId);
             if (!milestone) {
-                adapter.exec("COMMIT");
                 return {
                     content: [{ type: "text", text: `Milestone ${params.milestoneId} not found in database.` }],
                     details: { operation: "milestone_status", milestoneId: params.milestoneId, found: false },
@@ -510,7 +507,6 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
                 status: s.status,
                 taskCounts: getSliceTaskCounts(params.milestoneId, s.id),
             }));
-            adapter.exec("COMMIT");
             const result = {
                 milestoneId: milestone.id,
                 title: milestone.title,
@@ -524,14 +520,7 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
                 content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
                 details: { operation: "milestone_status", milestoneId: milestone.id, sliceCount: slices.length },
             };
-        }
-        catch (txErr) {
-            try {
-                adapter.exec("ROLLBACK");
-            }
-            catch { /* swallow */ }
-            throw txErr;
-        }
+        });
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);

package/dist/resources/extensions/gsd/triage-resolution.js

@@ -83,12 +83,9 @@ export function executeReplan(basePath, mid, sid, capture) {
         // Also write replan_triggered_at column for DB-backed detection
         try {
             const req = createRequire(import.meta.url);
-            const { isDbAvailable, _getAdapter } = req("./gsd-db.js");
+            const { isDbAvailable, setSliceReplanTriggeredAt } = req("./gsd-db.js");
             if (isDbAvailable()) {
-                const adapter = _getAdapter();
-                if (adapter) {
-                    adapter.prepare("UPDATE slices SET replan_triggered_at = :ts WHERE milestone_id = :mid AND id = :sid").run({ ":ts": ts, ":mid": mid, ":sid": sid });
-                }
+                setSliceReplanTriggeredAt(mid, sid, ts);
             }
         }
         catch {

package/dist/resources/extensions/gsd/workflow-manifest.js

@@ -1,4 +1,4 @@
-import { _getAdapter, transaction, } from "./gsd-db.js";
+import { _getAdapter, readTransaction, restoreManifest, } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -41,8 +41,7 @@ export function snapshotState() {
     const db = requireDb();
     // Wrap all reads in a deferred transaction so the snapshot is consistent
     // (all SELECTs see the same DB state even if a concurrent write lands between them).
-    db.exec("BEGIN DEFERRED");
-    try {
+    return readTransaction(() => {
         const rawMilestones = db.prepare("SELECT * FROM milestones ORDER BY id").all();
         const milestones = rawMilestones.map((r) => ({
             id: r["id"],
@@ -146,74 +145,14 @@ export function snapshotState() {
             decisions,
             verification_evidence,
         };
-        db.exec("COMMIT");
         return result;
-    }
-    catch (err) {
-        try {
-            db.exec("ROLLBACK");
-        }
-        catch { /* ignore rollback failure */ }
-        throw err;
-    }
-}
-// ─── restore ─────────────────────────────────────────────────────────────
-/**
- * Atomically replace all workflow state from a manifest.
- * Runs inside a transaction — if any insert fails, no tables are modified.
- * Only touches engine tables + decisions. Does NOT modify artifacts or memories.
- */
-function restore(manifest) {
-    const db = requireDb();
-    transaction(() => {
-        // Clear engine tables (order matters for foreign-key-like consistency)
-        db.exec("DELETE FROM verification_evidence");
-        db.exec("DELETE FROM tasks");
-        db.exec("DELETE FROM slices");
-        db.exec("DELETE FROM milestones");
-        db.exec("DELETE FROM decisions WHERE 1=1");
-        // Restore milestones
-        const msStmt = db.prepare(`INSERT INTO milestones (id, title, status, depends_on, created_at, completed_at,
-        vision, success_criteria, key_risks, proof_strategy,
-        verification_contract, verification_integration, verification_operational, verification_uat,
-        definition_of_done, requirement_coverage, boundary_map_markdown)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-        for (const m of manifest.milestones) {
-            msStmt.run(m.id, m.title, m.status, JSON.stringify(m.depends_on), m.created_at, m.completed_at, m.vision, JSON.stringify(m.success_criteria), JSON.stringify(m.key_risks), JSON.stringify(m.proof_strategy), m.verification_contract, m.verification_integration, m.verification_operational, m.verification_uat, JSON.stringify(m.definition_of_done), m.requirement_coverage, m.boundary_map_markdown);
-        }
-        // Restore slices
-        const slStmt = db.prepare(`INSERT INTO slices (milestone_id, id, title, status, risk, depends, demo,
-        created_at, completed_at, full_summary_md, full_uat_md,
-        goal, success_criteria, proof_level, integration_closure, observability_impact,
-        sequence, replan_triggered_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-        for (const s of manifest.slices) {
-            slStmt.run(s.milestone_id, s.id, s.title, s.status, s.risk, JSON.stringify(s.depends), s.demo, s.created_at, s.completed_at, s.full_summary_md, s.full_uat_md, s.goal, s.success_criteria, s.proof_level, s.integration_closure, s.observability_impact, s.sequence, s.replan_triggered_at);
-        }
-        // Restore tasks
-        const tkStmt = db.prepare(`INSERT INTO tasks (milestone_id, slice_id, id, title, status,
-        one_liner, narrative, verification_result, duration, completed_at,
-        blocker_discovered, deviations, known_issues, key_files, key_decisions,
-        full_summary_md, description, estimate, files, verify,
-        inputs, expected_output, observability_impact, sequence)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-        for (const t of manifest.tasks) {
-            tkStmt.run(t.milestone_id, t.slice_id, t.id, t.title, t.status, t.one_liner, t.narrative, t.verification_result, t.duration, t.completed_at, t.blocker_discovered ? 1 : 0, t.deviations, t.known_issues, JSON.stringify(t.key_files), JSON.stringify(t.key_decisions), t.full_summary_md, t.description, t.estimate, JSON.stringify(t.files), t.verify, JSON.stringify(t.inputs), JSON.stringify(t.expected_output), t.observability_impact, t.sequence);
-        }
-        // Restore decisions
-        const dcStmt = db.prepare(`INSERT INTO decisions (seq, id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-        for (const d of manifest.decisions) {
-            dcStmt.run(d.seq, d.id, d.when_context, d.scope, d.decision, d.choice, d.rationale, d.revisable, d.made_by, d.superseded_by);
-        }
-        // Restore verification evidence
-        const evStmt = db.prepare(`INSERT INTO verification_evidence (task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
-        for (const e of manifest.verification_evidence) {
-            evStmt.run(e.task_id, e.slice_id, e.milestone_id, e.command, e.exit_code, e.verdict, e.duration_ms, e.created_at);
-        }
     });
 }
+// ─── restore ─────────────────────────────────────────────────────────────
+//
+// The actual restore() implementation lives in gsd-db.ts (single-writer
+// invariant). This module only orchestrates reading the manifest file
+// and handing it to the writer.
 // ─── writeManifest ───────────────────────────────────────────────────────
 /**
  * Write current DB state to .gsd/state-manifest.json via atomicWriteSync.
@@ -258,6 +197,6 @@ export function bootstrapFromManifest(basePath) {
     if (!manifest) {
         return false;
     }
-    restore(manifest);
+    restoreManifest(manifest);
     return true;
 }