gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/dist/resources/extensions/gsd/gsd-db.js

@@ -8,18 +8,13 @@ import { createRequire } from "node:module";
 import { existsSync, copyFileSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import { GSDError, GSD_STALE_STATE } from "./errors.js";
-// Create a require function for loading native modules in ESM context
 const _require = createRequire(import.meta.url);
 let providerName = null;
 let providerModule = null;
 let loadAttempted = false;
-/**
- * Suppress the ExperimentalWarning for SQLite from node:sqlite.
- * Must be called before require('node:sqlite').
- */
 function suppressSqliteWarning() {
     const origEmit = process.emit;
-    // @ts-expect-error — overriding process.emit with filtered version
+    // @ts-expect-error overriding process.emit for warning filter
     process.emit = function (event, ...args) {
         if (event === "warning" &&
             args[0] &&
@@ -38,7 +33,6 @@ function loadProvider() {
     if (loadAttempted)
         return;
     loadAttempted = true;
-    // Try node:sqlite first
     try {
         suppressSqliteWarning();
         const mod = _require("node:sqlite");
@@ -49,9 +43,8 @@ function loadProvider() {
         }
     }
     catch {
-        // node:sqlite not available
+        // unavailable
     }
-    // Try better-sqlite3
     try {
         const mod = _require("better-sqlite3");
         if (typeof mod === "function" || (mod && mod.default)) {
@@ -61,14 +54,10 @@ function loadProvider() {
         }
     }
     catch {
-        // better-sqlite3 not available
+        // unavailable
     }
     process.stderr.write("gsd-db: No SQLite provider available (tried node:sqlite, better-sqlite3)\n");
 }
-// ─── Database Adapter ──────────────────────────────────────────────────────
-/**
- * Normalize a row from node:sqlite (null-prototype) to a plain object.
- */
 function normalizeRow(row) {
     if (row == null)
         return undefined;
@@ -113,17 +102,16 @@ function openRawDb(path) {
         const { DatabaseSync } = providerModule;
         return new DatabaseSync(path);
     }
-    // better-sqlite3
     const Database = providerModule;
     return new Database(path);
 }
-// ─── Schema ────────────────────────────────────────────────────────────────
-const SCHEMA_VERSION = 4;
+const SCHEMA_VERSION = 10;
 function initSchema(db, fileBacked) {
-    // WAL mode for file-backed databases (must be outside transaction)
-    if (fileBacked) {
+    if (fileBacked)
         db.exec("PRAGMA journal_mode=WAL");
-    }
+    if (fileBacked)
+        db.exec("PRAGMA busy_timeout = 5000");
+    db.exec("PRAGMA foreign_keys = ON");
     db.exec("BEGIN");
     try {
         db.exec(`
@@ -194,16 +182,128 @@ function initSchema(db, fileBacked) {
         activity_file TEXT,
         processed_at TEXT NOT NULL
       )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS milestones (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'active',
+        depends_on TEXT NOT NULL DEFAULT '[]',
+        created_at TEXT NOT NULL DEFAULT '',
+        completed_at TEXT DEFAULT NULL,
+        vision TEXT NOT NULL DEFAULT '',
+        success_criteria TEXT NOT NULL DEFAULT '[]',
+        key_risks TEXT NOT NULL DEFAULT '[]',
+        proof_strategy TEXT NOT NULL DEFAULT '[]',
+        verification_contract TEXT NOT NULL DEFAULT '',
+        verification_integration TEXT NOT NULL DEFAULT '',
+        verification_operational TEXT NOT NULL DEFAULT '',
+        verification_uat TEXT NOT NULL DEFAULT '',
+        definition_of_done TEXT NOT NULL DEFAULT '[]',
+        requirement_coverage TEXT NOT NULL DEFAULT '',
+        boundary_map_markdown TEXT NOT NULL DEFAULT ''
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS slices (
+        milestone_id TEXT NOT NULL,
+        id TEXT NOT NULL,
+        title TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'pending',
+        risk TEXT NOT NULL DEFAULT 'medium',
+        depends TEXT NOT NULL DEFAULT '[]',
+        demo TEXT NOT NULL DEFAULT '',
+        created_at TEXT NOT NULL DEFAULT '',
+        completed_at TEXT DEFAULT NULL,
+        full_summary_md TEXT NOT NULL DEFAULT '',
+        full_uat_md TEXT NOT NULL DEFAULT '',
+        goal TEXT NOT NULL DEFAULT '',
+        success_criteria TEXT NOT NULL DEFAULT '',
+        proof_level TEXT NOT NULL DEFAULT '',
+        integration_closure TEXT NOT NULL DEFAULT '',
+        observability_impact TEXT NOT NULL DEFAULT '',
+        sequence INTEGER DEFAULT 0, -- DEAD CODE: no tool exposes sequence — always 0
+        replan_triggered_at TEXT DEFAULT NULL,
+        PRIMARY KEY (milestone_id, id),
+        FOREIGN KEY (milestone_id) REFERENCES milestones(id)
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        milestone_id TEXT NOT NULL,
+        slice_id TEXT NOT NULL,
+        id TEXT NOT NULL,
+        title TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'pending',
+        one_liner TEXT NOT NULL DEFAULT '',
+        narrative TEXT NOT NULL DEFAULT '',
+        verification_result TEXT NOT NULL DEFAULT '',
+        duration TEXT NOT NULL DEFAULT '',
+        completed_at TEXT DEFAULT NULL,
+        blocker_discovered INTEGER DEFAULT 0,
+        deviations TEXT NOT NULL DEFAULT '',
+        known_issues TEXT NOT NULL DEFAULT '',
+        key_files TEXT NOT NULL DEFAULT '[]',
+        key_decisions TEXT NOT NULL DEFAULT '[]',
+        full_summary_md TEXT NOT NULL DEFAULT '',
+        description TEXT NOT NULL DEFAULT '',
+        estimate TEXT NOT NULL DEFAULT '',
+        files TEXT NOT NULL DEFAULT '[]',
+        verify TEXT NOT NULL DEFAULT '',
+        inputs TEXT NOT NULL DEFAULT '[]',
+        expected_output TEXT NOT NULL DEFAULT '[]',
+        observability_impact TEXT NOT NULL DEFAULT '',
+        sequence INTEGER DEFAULT 0, -- DEAD CODE: no tool exposes sequence — always 0
+        PRIMARY KEY (milestone_id, slice_id, id),
+        FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS verification_evidence (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL DEFAULT '',
+        slice_id TEXT NOT NULL DEFAULT '',
+        milestone_id TEXT NOT NULL DEFAULT '',
+        command TEXT NOT NULL DEFAULT '',
+        exit_code INTEGER DEFAULT 0,
+        verdict TEXT NOT NULL DEFAULT '',
+        duration_ms INTEGER DEFAULT 0,
+        created_at TEXT NOT NULL DEFAULT '',
+        FOREIGN KEY (milestone_id, slice_id, task_id) REFERENCES tasks(milestone_id, slice_id, id)
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS replan_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        milestone_id TEXT NOT NULL DEFAULT '',
+        slice_id TEXT DEFAULT NULL,
+        task_id TEXT DEFAULT NULL,
+        summary TEXT NOT NULL DEFAULT '',
+        previous_artifact_path TEXT DEFAULT NULL,
+        replacement_artifact_path TEXT DEFAULT NULL,
+        created_at TEXT NOT NULL DEFAULT '',
+        FOREIGN KEY (milestone_id) REFERENCES milestones(id)
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS assessments (
+        path TEXT PRIMARY KEY,
+        milestone_id TEXT NOT NULL DEFAULT '',
+        slice_id TEXT DEFAULT NULL,
+        task_id TEXT DEFAULT NULL,
+        status TEXT NOT NULL DEFAULT '',
+        scope TEXT NOT NULL DEFAULT '',
+        full_content TEXT NOT NULL DEFAULT '',
+        created_at TEXT NOT NULL DEFAULT '',
+        FOREIGN KEY (milestone_id) REFERENCES milestones(id)
+      )
     `);
         db.exec("CREATE INDEX IF NOT EXISTS idx_memories_active ON memories(superseded_by)");
-        // Views — DROP + CREATE since CREATE VIEW IF NOT EXISTS doesn't update definitions
+        db.exec("CREATE INDEX IF NOT EXISTS idx_replan_history_milestone ON replan_history(milestone_id, created_at)");
         db.exec(`CREATE VIEW IF NOT EXISTS active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL`);
         db.exec(`CREATE VIEW IF NOT EXISTS active_requirements AS SELECT * FROM requirements WHERE superseded_by IS NULL`);
         db.exec(`CREATE VIEW IF NOT EXISTS active_memories AS SELECT * FROM memories WHERE superseded_by IS NULL`);
-        // Insert schema version if not already present
-        const existing = db
-            .prepare("SELECT count(*) as cnt FROM schema_version")
-            .get();
+        const existing = db.prepare("SELECT count(*) as cnt FROM schema_version").get();
         if (existing && existing["cnt"] === 0) {
             db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
                 ":version": SCHEMA_VERSION,
@@ -216,13 +316,16 @@ function initSchema(db, fileBacked) {
         db.exec("ROLLBACK");
         throw err;
     }
-    // Run incremental migrations for existing databases
     migrateSchema(db);
 }
-/**
- * Incremental schema migration. Reads current version from schema_version table
- * and applies DDL for each version step up to SCHEMA_VERSION.
- */
+function columnExists(db, table, column) {
+    const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+    return rows.some((row) => row["name"] === column);
+}
+function ensureColumn(db, table, column, ddl) {
+    if (!columnExists(db, table, column))
+        db.exec(ddl);
+}
 function migrateSchema(db) {
     const row = db.prepare("SELECT MAX(version) as v FROM schema_version").get();
     const currentVersion = row ? row["v"] : 0;
@@ -230,7 +333,6 @@ function migrateSchema(db) {
         return;
     db.exec("BEGIN");
     try {
-        // v1 → v2: add artifacts table
         if (currentVersion < 2) {
             db.exec(`
         CREATE TABLE IF NOT EXISTS artifacts (
@@ -243,9 +345,11 @@ function migrateSchema(db) {
           imported_at TEXT NOT NULL DEFAULT ''
         )
       `);
-            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({ ":version": 2, ":applied_at": new Date().toISOString() });
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 2,
+                ":applied_at": new Date().toISOString(),
+            });
         }
-        // v2 → v3: add memories + memory_processed_units tables
         if (currentVersion < 3) {
             db.exec(`
         CREATE TABLE IF NOT EXISTS memories (
@@ -272,16 +376,171 @@ function migrateSchema(db) {
             db.exec("CREATE INDEX IF NOT EXISTS idx_memories_active ON memories(superseded_by)");
             db.exec("DROP VIEW IF EXISTS active_memories");
             db.exec("CREATE VIEW active_memories AS SELECT * FROM memories WHERE superseded_by IS NULL");
-            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({ ":version": 3, ":applied_at": new Date().toISOString() });
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 3,
+                ":applied_at": new Date().toISOString(),
+            });
         }
-        // v3 → v4: add made_by column to decisions table
         if (currentVersion < 4) {
-            // Add made_by column — default 'agent' for existing rows (pre-attribution decisions)
-            db.exec(`ALTER TABLE decisions ADD COLUMN made_by TEXT NOT NULL DEFAULT 'agent'`);
-            // Recreate views to pick up new columns (SQLite expands SELECT * at view creation time)
+            ensureColumn(db, "decisions", "made_by", `ALTER TABLE decisions ADD COLUMN made_by TEXT NOT NULL DEFAULT 'agent'`);
             db.exec("DROP VIEW IF EXISTS active_decisions");
             db.exec("CREATE VIEW active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL");
-            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({ ":version": 4, ":applied_at": new Date().toISOString() });
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 4,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
+        if (currentVersion < 5) {
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS milestones (
+          id TEXT PRIMARY KEY,
+          title TEXT NOT NULL DEFAULT '',
+          status TEXT NOT NULL DEFAULT 'active',
+          created_at TEXT NOT NULL,
+          completed_at TEXT DEFAULT NULL
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS slices (
+          milestone_id TEXT NOT NULL,
+          id TEXT NOT NULL,
+          title TEXT NOT NULL DEFAULT '',
+          status TEXT NOT NULL DEFAULT 'pending',
+          risk TEXT NOT NULL DEFAULT 'medium',
+          created_at TEXT NOT NULL DEFAULT '',
+          completed_at TEXT DEFAULT NULL,
+          PRIMARY KEY (milestone_id, id),
+          FOREIGN KEY (milestone_id) REFERENCES milestones(id)
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS tasks (
+          milestone_id TEXT NOT NULL,
+          slice_id TEXT NOT NULL,
+          id TEXT NOT NULL,
+          title TEXT NOT NULL DEFAULT '',
+          status TEXT NOT NULL DEFAULT 'pending',
+          one_liner TEXT NOT NULL DEFAULT '',
+          narrative TEXT NOT NULL DEFAULT '',
+          verification_result TEXT NOT NULL DEFAULT '',
+          duration TEXT NOT NULL DEFAULT '',
+          completed_at TEXT DEFAULT NULL,
+          blocker_discovered INTEGER DEFAULT 0,
+          deviations TEXT NOT NULL DEFAULT '',
+          known_issues TEXT NOT NULL DEFAULT '',
+          key_files TEXT NOT NULL DEFAULT '[]',
+          key_decisions TEXT NOT NULL DEFAULT '[]',
+          full_summary_md TEXT NOT NULL DEFAULT '',
+          PRIMARY KEY (milestone_id, slice_id, id),
+          FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS verification_evidence (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          task_id TEXT NOT NULL DEFAULT '',
+          slice_id TEXT NOT NULL DEFAULT '',
+          milestone_id TEXT NOT NULL DEFAULT '',
+          command TEXT NOT NULL DEFAULT '',
+          exit_code INTEGER DEFAULT 0,
+          verdict TEXT NOT NULL DEFAULT '',
+          duration_ms INTEGER DEFAULT 0,
+          created_at TEXT NOT NULL DEFAULT '',
+          FOREIGN KEY (milestone_id, slice_id, task_id) REFERENCES tasks(milestone_id, slice_id, id)
+        )
+      `);
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 5,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
+        if (currentVersion < 6) {
+            ensureColumn(db, "slices", "full_summary_md", `ALTER TABLE slices ADD COLUMN full_summary_md TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "slices", "full_uat_md", `ALTER TABLE slices ADD COLUMN full_uat_md TEXT NOT NULL DEFAULT ''`);
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 6,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
+        if (currentVersion < 7) {
+            ensureColumn(db, "slices", "depends", `ALTER TABLE slices ADD COLUMN depends TEXT NOT NULL DEFAULT '[]'`);
+            ensureColumn(db, "slices", "demo", `ALTER TABLE slices ADD COLUMN demo TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "milestones", "depends_on", `ALTER TABLE milestones ADD COLUMN depends_on TEXT NOT NULL DEFAULT '[]'`);
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 7,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
+        if (currentVersion < 8) {
+            ensureColumn(db, "milestones", "vision", `ALTER TABLE milestones ADD COLUMN vision TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "milestones", "success_criteria", `ALTER TABLE milestones ADD COLUMN success_criteria TEXT NOT NULL DEFAULT '[]'`);
+            ensureColumn(db, "milestones", "key_risks", `ALTER TABLE milestones ADD COLUMN key_risks TEXT NOT NULL DEFAULT '[]'`);
+            ensureColumn(db, "milestones", "proof_strategy", `ALTER TABLE milestones ADD COLUMN proof_strategy TEXT NOT NULL DEFAULT '[]'`);
+            ensureColumn(db, "milestones", "verification_contract", `ALTER TABLE milestones ADD COLUMN verification_contract TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "milestones", "verification_integration", `ALTER TABLE milestones ADD COLUMN verification_integration TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "milestones", "verification_operational", `ALTER TABLE milestones ADD COLUMN verification_operational TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "milestones", "verification_uat", `ALTER TABLE milestones ADD COLUMN verification_uat TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "milestones", "definition_of_done", `ALTER TABLE milestones ADD COLUMN definition_of_done TEXT NOT NULL DEFAULT '[]'`);
+            ensureColumn(db, "milestones", "requirement_coverage", `ALTER TABLE milestones ADD COLUMN requirement_coverage TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "milestones", "boundary_map_markdown", `ALTER TABLE milestones ADD COLUMN boundary_map_markdown TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "slices", "goal", `ALTER TABLE slices ADD COLUMN goal TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "slices", "success_criteria", `ALTER TABLE slices ADD COLUMN success_criteria TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "slices", "proof_level", `ALTER TABLE slices ADD COLUMN proof_level TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "slices", "integration_closure", `ALTER TABLE slices ADD COLUMN integration_closure TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "slices", "observability_impact", `ALTER TABLE slices ADD COLUMN observability_impact TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "tasks", "description", `ALTER TABLE tasks ADD COLUMN description TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "tasks", "estimate", `ALTER TABLE tasks ADD COLUMN estimate TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "tasks", "files", `ALTER TABLE tasks ADD COLUMN files TEXT NOT NULL DEFAULT '[]'`);
+            ensureColumn(db, "tasks", "verify", `ALTER TABLE tasks ADD COLUMN verify TEXT NOT NULL DEFAULT ''`);
+            ensureColumn(db, "tasks", "inputs", `ALTER TABLE tasks ADD COLUMN inputs TEXT NOT NULL DEFAULT '[]'`);
+            ensureColumn(db, "tasks", "expected_output", `ALTER TABLE tasks ADD COLUMN expected_output TEXT NOT NULL DEFAULT '[]'`);
+            ensureColumn(db, "tasks", "observability_impact", `ALTER TABLE tasks ADD COLUMN observability_impact TEXT NOT NULL DEFAULT ''`);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS replan_history (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          milestone_id TEXT NOT NULL DEFAULT '',
+          slice_id TEXT DEFAULT NULL,
+          task_id TEXT DEFAULT NULL,
+          summary TEXT NOT NULL DEFAULT '',
+          previous_artifact_path TEXT DEFAULT NULL,
+          replacement_artifact_path TEXT DEFAULT NULL,
+          created_at TEXT NOT NULL DEFAULT '',
+          FOREIGN KEY (milestone_id) REFERENCES milestones(id)
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS assessments (
+          path TEXT PRIMARY KEY,
+          milestone_id TEXT NOT NULL DEFAULT '',
+          slice_id TEXT DEFAULT NULL,
+          task_id TEXT DEFAULT NULL,
+          status TEXT NOT NULL DEFAULT '',
+          scope TEXT NOT NULL DEFAULT '',
+          full_content TEXT NOT NULL DEFAULT '',
+          created_at TEXT NOT NULL DEFAULT '',
+          FOREIGN KEY (milestone_id) REFERENCES milestones(id)
+        )
+      `);
+            db.exec("CREATE INDEX IF NOT EXISTS idx_replan_history_milestone ON replan_history(milestone_id, created_at)");
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 8,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
+        if (currentVersion < 9) {
+            ensureColumn(db, "slices", "sequence", `ALTER TABLE slices ADD COLUMN sequence INTEGER DEFAULT 0`);
+            ensureColumn(db, "tasks", "sequence", `ALTER TABLE tasks ADD COLUMN sequence INTEGER DEFAULT 0`);
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 9,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
+        if (currentVersion < 10) {
+            ensureColumn(db, "slices", "replan_triggered_at", `ALTER TABLE slices ADD COLUMN replan_triggered_at TEXT DEFAULT NULL`);
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 10,
+                ":applied_at": new Date().toISOString(),
+            });
         }
         db.exec("COMMIT");
     }
@@ -290,38 +549,22 @@ function migrateSchema(db) {
         throw err;
     }
 }
-// ─── Module State ──────────────────────────────────────────────────────────
 let currentDb = null;
 let currentPath = null;
-/** PID that opened the current connection — used for diagnostic logging. */
 let currentPid = 0;
-// ─── Public API ────────────────────────────────────────────────────────────
-/**
- * Returns which SQLite provider is available, or null if none.
- */
+let _exitHandlerRegistered = false;
 export function getDbProvider() {
     loadProvider();
     return providerName;
 }
-/**
- * Returns true if a database is currently open and usable.
- */
 export function isDbAvailable() {
     return currentDb !== null;
 }
-/**
- * Opens (or creates) a SQLite database at the given path.
- * Initializes schema if needed. Sets WAL mode for file-backed DBs.
- * Returns true on success, false if no provider is available.
- */
 export function openDatabase(path) {
-    // Close existing if different path
-    if (currentDb && currentPath !== path) {
+    if (currentDb && currentPath !== path)
         closeDatabase();
-    }
-    if (currentDb && currentPath === path) {
-        return true; // already open
-    }
+    if (currentDb && currentPath === path)
+        return true;
     const rawDb = openRawDb(path);
     if (!rawDb)
         return false;
@@ -334,21 +577,27 @@ export function openDatabase(path) {
         try {
             adapter.close();
         }
-        catch {
-            /* swallow */
-        }
+        catch { /* swallow */ }
         throw err;
     }
     currentDb = adapter;
     currentPath = path;
     currentPid = process.pid;
+    if (!_exitHandlerRegistered) {
+        _exitHandlerRegistered = true;
+        process.on("exit", () => { try {
+            closeDatabase();
+        }
+        catch { } });
+    }
     return true;
 }
-/**
- * Closes the current database connection.
- */
 export function closeDatabase() {
     if (currentDb) {
+        try {
+            currentDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+        }
+        catch { /* non-fatal — best effort before close */ }
         try {
             currentDb.close();
         }
@@ -360,9 +609,6 @@ export function closeDatabase() {
         currentPid = 0;
     }
 }
-/**
- * Runs a function inside a transaction. Rolls back on error.
- */
 export function transaction(fn) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
@@ -377,17 +623,11 @@ export function transaction(fn) {
         throw err;
     }
 }
-// ─── Decision Wrappers ────────────────────────────────────────────────────
-/**
- * Insert a decision. The `seq` field is auto-generated.
- */
 export function insertDecision(d) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    currentDb
-        .prepare(`INSERT INTO decisions (id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by)
-     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :made_by, :superseded_by)`)
-        .run({
+    currentDb.prepare(`INSERT INTO decisions (id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by)
+     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :made_by, :superseded_by)`).run({
         ":id": d.id,
         ":when_context": d.when_context,
         ":scope": d.scope,
@@ -399,9 +639,6 @@ export function insertDecision(d) {
         ":superseded_by": d.superseded_by,
     });
 }
-/**
- * Get a decision by its ID (e.g. "D001"). Returns null if not found.
- */
 export function getDecisionById(id) {
     if (!currentDb)
         return null;
@@ -421,9 +658,6 @@ export function getDecisionById(id) {
         superseded_by: row["superseded_by"] ?? null,
     };
 }
-/**
- * Get all active (non-superseded) decisions.
- */
 export function getActiveDecisions() {
     if (!currentDb)
         return [];
@@ -441,17 +675,11 @@ export function getActiveDecisions() {
         superseded_by: null,
     }));
 }
-// ─── Requirement Wrappers ─────────────────────────────────────────────────
-/**
- * Insert a requirement.
- */
 export function insertRequirement(r) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    currentDb
-        .prepare(`INSERT INTO requirements (id, class, status, description, why, source, primary_owner, supporting_slices, validation, notes, full_content, superseded_by)
-     VALUES (:id, :class, :status, :description, :why, :source, :primary_owner, :supporting_slices, :validation, :notes, :full_content, :superseded_by)`)
-        .run({
+    currentDb.prepare(`INSERT INTO requirements (id, class, status, description, why, source, primary_owner, supporting_slices, validation, notes, full_content, superseded_by)
+     VALUES (:id, :class, :status, :description, :why, :source, :primary_owner, :supporting_slices, :validation, :notes, :full_content, :superseded_by)`).run({
         ":id": r.id,
         ":class": r.class,
         ":status": r.status,
@@ -466,15 +694,10 @@ export function insertRequirement(r) {
         ":superseded_by": r.superseded_by,
     });
 }
-/**
- * Get a requirement by its ID (e.g. "R001"). Returns null if not found.
- */
 export function getRequirementById(id) {
     if (!currentDb)
         return null;
-    const row = currentDb
-        .prepare("SELECT * FROM requirements WHERE id = ?")
-        .get(id);
+    const row = currentDb.prepare("SELECT * FROM requirements WHERE id = ?").get(id);
     if (!row)
         return null;
     return {
@@ -492,9 +715,6 @@ export function getRequirementById(id) {
         superseded_by: row["superseded_by"] ?? null,
     };
 }
-/**
- * Get all active (non-superseded) requirements.
- */
 export function getActiveRequirements() {
     if (!currentDb)
         return [];
@@ -514,45 +734,25 @@ export function getActiveRequirements() {
         superseded_by: null,
     }));
 }
-/**
- * Returns the PID of the process that opened the current DB connection.
- * Returns 0 if no connection is open.
- */
 export function getDbOwnerPid() {
     return currentPid;
 }
-/**
- * Returns the path of the currently open database, or null if none.
- */
 export function getDbPath() {
     return currentPath;
 }
-// ─── Internal Access (for testing) ─────────────────────────────────────────
-/**
- * Get the raw adapter for direct queries (testing only).
- */
 export function _getAdapter() {
     return currentDb;
 }
-/**
- * Reset provider state (testing only — allows re-detection).
- */
 export function _resetProvider() {
     loadAttempted = false;
     providerModule = null;
     providerName = null;
 }
-// ─── Upsert Wrappers (for idempotent import) ─────────────────────────────
-/**
- * Insert or replace a decision. Uses the `id` UNIQUE constraint for idempotency.
- */
 export function upsertDecision(d) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    currentDb
-        .prepare(`INSERT OR REPLACE INTO decisions (id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by)
-     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :made_by, :superseded_by)`)
-        .run({
+    currentDb.prepare(`INSERT OR REPLACE INTO decisions (id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by)
+     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :made_by, :superseded_by)`).run({
         ":id": d.id,
         ":when_context": d.when_context,
         ":scope": d.scope,
@@ -564,16 +764,11 @@ export function upsertDecision(d) {
         ":superseded_by": d.superseded_by ?? null,
     });
 }
-/**
- * Insert or replace a requirement. Uses the `id` PK for idempotency.
- */
 export function upsertRequirement(r) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    currentDb
-        .prepare(`INSERT OR REPLACE INTO requirements (id, class, status, description, why, source, primary_owner, supporting_slices, validation, notes, full_content, superseded_by)
-     VALUES (:id, :class, :status, :description, :why, :source, :primary_owner, :supporting_slices, :validation, :notes, :full_content, :superseded_by)`)
-        .run({
+    currentDb.prepare(`INSERT OR REPLACE INTO requirements (id, class, status, description, why, source, primary_owner, supporting_slices, validation, notes, full_content, superseded_by)
+     VALUES (:id, :class, :status, :description, :why, :source, :primary_owner, :supporting_slices, :validation, :notes, :full_content, :superseded_by)`).run({
         ":id": r.id,
         ":class": r.class,
         ":status": r.status,
@@ -588,32 +783,19 @@ export function upsertRequirement(r) {
         ":superseded_by": r.superseded_by ?? null,
     });
 }
-/**
- * Insert or replace an artifact. Uses the `path` PK for idempotency.
- */
-/**
- * Delete all rows from the artifacts table.
- * The artifacts table is a read cache — clearing it forces the next
- * deriveState() to fall through to disk reads (native Rust batch parse).
- * Safe to call when no database is open (no-op).
- */
 export function clearArtifacts() {
     if (!currentDb)
         return;
     try {
         currentDb.exec("DELETE FROM artifacts");
     }
-    catch {
-        // Clearing a cache should never be fatal
-    }
+    catch { /* cache clear is best effort */ }
 }
 export function insertArtifact(a) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    currentDb
-        .prepare(`INSERT OR REPLACE INTO artifacts (path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at)
-     VALUES (:path, :artifact_type, :milestone_id, :slice_id, :task_id, :full_content, :imported_at)`)
-        .run({
+    currentDb.prepare(`INSERT OR REPLACE INTO artifacts (path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at)
+     VALUES (:path, :artifact_type, :milestone_id, :slice_id, :task_id, :full_content, :imported_at)`).run({
         ":path": a.path,
         ":artifact_type": a.artifact_type,
         ":milestone_id": a.milestone_id,
@@ -623,6 +805,403 @@ export function insertArtifact(a) {
         ":imported_at": new Date().toISOString(),
     });
 }
+export function insertMilestone(m) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`INSERT OR IGNORE INTO milestones (
+      id, title, status, depends_on, created_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 (
+      :id, :title, :status, :depends_on, :created_at,
+      :vision, :success_criteria, :key_risks, :proof_strategy,
+      :verification_contract, :verification_integration, :verification_operational, :verification_uat,
+      :definition_of_done, :requirement_coverage, :boundary_map_markdown
+    )`).run({
+        ":id": m.id,
+        ":title": m.title ?? "",
+        ":status": m.status ?? "active",
+        ":depends_on": JSON.stringify(m.depends_on ?? []),
+        ":created_at": new Date().toISOString(),
+        ":vision": m.planning?.vision ?? "",
+        ":success_criteria": JSON.stringify(m.planning?.successCriteria ?? []),
+        ":key_risks": JSON.stringify(m.planning?.keyRisks ?? []),
+        ":proof_strategy": JSON.stringify(m.planning?.proofStrategy ?? []),
+        ":verification_contract": m.planning?.verificationContract ?? "",
+        ":verification_integration": m.planning?.verificationIntegration ?? "",
+        ":verification_operational": m.planning?.verificationOperational ?? "",
+        ":verification_uat": m.planning?.verificationUat ?? "",
+        ":definition_of_done": JSON.stringify(m.planning?.definitionOfDone ?? []),
+        ":requirement_coverage": m.planning?.requirementCoverage ?? "",
+        ":boundary_map_markdown": m.planning?.boundaryMapMarkdown ?? "",
+    });
+}
+export function upsertMilestonePlanning(milestoneId, planning) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`UPDATE milestones SET
+      vision = COALESCE(:vision, vision),
+      success_criteria = COALESCE(:success_criteria, success_criteria),
+      key_risks = COALESCE(:key_risks, key_risks),
+      proof_strategy = COALESCE(:proof_strategy, proof_strategy),
+      verification_contract = COALESCE(:verification_contract, verification_contract),
+      verification_integration = COALESCE(:verification_integration, verification_integration),
+      verification_operational = COALESCE(:verification_operational, verification_operational),
+      verification_uat = COALESCE(:verification_uat, verification_uat),
+      definition_of_done = COALESCE(:definition_of_done, definition_of_done),
+      requirement_coverage = COALESCE(:requirement_coverage, requirement_coverage),
+      boundary_map_markdown = COALESCE(:boundary_map_markdown, boundary_map_markdown)
+     WHERE id = :id`).run({
+        ":id": milestoneId,
+        ":vision": planning.vision ?? null,
+        ":success_criteria": planning.successCriteria ? JSON.stringify(planning.successCriteria) : null,
+        ":key_risks": planning.keyRisks ? JSON.stringify(planning.keyRisks) : null,
+        ":proof_strategy": planning.proofStrategy ? JSON.stringify(planning.proofStrategy) : null,
+        ":verification_contract": planning.verificationContract ?? null,
+        ":verification_integration": planning.verificationIntegration ?? null,
+        ":verification_operational": planning.verificationOperational ?? null,
+        ":verification_uat": planning.verificationUat ?? null,
+        ":definition_of_done": planning.definitionOfDone ? JSON.stringify(planning.definitionOfDone) : null,
+        ":requirement_coverage": planning.requirementCoverage ?? null,
+        ":boundary_map_markdown": planning.boundaryMapMarkdown ?? null,
+    });
+}
+export function insertSlice(s) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`INSERT OR IGNORE INTO slices (
+      milestone_id, id, title, status, risk, depends, demo, created_at,
+      goal, success_criteria, proof_level, integration_closure, observability_impact, sequence
+    ) VALUES (
+      :milestone_id, :id, :title, :status, :risk, :depends, :demo, :created_at,
+      :goal, :success_criteria, :proof_level, :integration_closure, :observability_impact, :sequence
+    )`).run({
+        ":milestone_id": s.milestoneId,
+        ":id": s.id,
+        ":title": s.title ?? "",
+        ":status": s.status ?? "pending",
+        ":risk": s.risk ?? "medium",
+        ":depends": JSON.stringify(s.depends ?? []),
+        ":demo": s.demo ?? "",
+        ":created_at": new Date().toISOString(),
+        ":goal": s.planning?.goal ?? "",
+        ":success_criteria": s.planning?.successCriteria ?? "",
+        ":proof_level": s.planning?.proofLevel ?? "",
+        ":integration_closure": s.planning?.integrationClosure ?? "",
+        ":observability_impact": s.planning?.observabilityImpact ?? "",
+        ":sequence": s.sequence ?? 0,
+    });
+}
+export function upsertSlicePlanning(milestoneId, sliceId, planning) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`UPDATE slices SET
+      goal = COALESCE(:goal, goal),
+      success_criteria = COALESCE(:success_criteria, success_criteria),
+      proof_level = COALESCE(:proof_level, proof_level),
+      integration_closure = COALESCE(:integration_closure, integration_closure),
+      observability_impact = COALESCE(:observability_impact, observability_impact)
+     WHERE milestone_id = :milestone_id AND id = :id`).run({
+        ":milestone_id": milestoneId,
+        ":id": sliceId,
+        ":goal": planning.goal ?? null,
+        ":success_criteria": planning.successCriteria ?? null,
+        ":proof_level": planning.proofLevel ?? null,
+        ":integration_closure": planning.integrationClosure ?? null,
+        ":observability_impact": planning.observabilityImpact ?? null,
+    });
+}
+export function insertTask(t) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.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 (
+      :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
+    )
+    ON CONFLICT(milestone_id, slice_id, id) DO UPDATE SET
+      title = CASE WHEN NULLIF(:title, '') IS NOT NULL THEN :title ELSE tasks.title END,
+      status = :status,
+      one_liner = :one_liner,
+      narrative = :narrative,
+      verification_result = :verification_result,
+      duration = :duration,
+      completed_at = :completed_at,
+      blocker_discovered = :blocker_discovered,
+      deviations = :deviations,
+      known_issues = :known_issues,
+      key_files = :key_files,
+      key_decisions = :key_decisions,
+      full_summary_md = :full_summary_md,
+      description = CASE WHEN NULLIF(:description, '') IS NOT NULL THEN :description ELSE tasks.description END,
+      estimate = CASE WHEN NULLIF(:estimate, '') IS NOT NULL THEN :estimate ELSE tasks.estimate END,
+      files = CASE WHEN NULLIF(:files, '[]') IS NOT NULL THEN :files ELSE tasks.files END,
+      verify = CASE WHEN NULLIF(:verify, '') IS NOT NULL THEN :verify ELSE tasks.verify END,
+      inputs = CASE WHEN NULLIF(:inputs, '[]') IS NOT NULL THEN :inputs ELSE tasks.inputs END,
+      expected_output = CASE WHEN NULLIF(:expected_output, '[]') IS NOT NULL THEN :expected_output ELSE tasks.expected_output END,
+      observability_impact = CASE WHEN NULLIF(:observability_impact, '') IS NOT NULL THEN :observability_impact ELSE tasks.observability_impact END,
+      sequence = :sequence`).run({
+        ":milestone_id": t.milestoneId,
+        ":slice_id": t.sliceId,
+        ":id": t.id,
+        ":title": t.title ?? "",
+        ":status": t.status ?? "pending",
+        ":one_liner": t.oneLiner ?? "",
+        ":narrative": t.narrative ?? "",
+        ":verification_result": t.verificationResult ?? "",
+        ":duration": t.duration ?? "",
+        ":completed_at": t.status === "done" || t.status === "complete" ? new Date().toISOString() : null,
+        ":blocker_discovered": t.blockerDiscovered ? 1 : 0,
+        ":deviations": t.deviations ?? "",
+        ":known_issues": t.knownIssues ?? "",
+        ":key_files": JSON.stringify(t.keyFiles ?? []),
+        ":key_decisions": JSON.stringify(t.keyDecisions ?? []),
+        ":full_summary_md": t.fullSummaryMd ?? "",
+        ":description": t.planning?.description ?? "",
+        ":estimate": t.planning?.estimate ?? "",
+        ":files": JSON.stringify(t.planning?.files ?? []),
+        ":verify": t.planning?.verify ?? "",
+        ":inputs": JSON.stringify(t.planning?.inputs ?? []),
+        ":expected_output": JSON.stringify(t.planning?.expectedOutput ?? []),
+        ":observability_impact": t.planning?.observabilityImpact ?? "",
+        ":sequence": t.sequence ?? 0,
+    });
+}
+export function updateTaskStatus(milestoneId, sliceId, taskId, status, completedAt) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`UPDATE tasks SET status = :status, completed_at = :completed_at
+     WHERE milestone_id = :milestone_id AND slice_id = :slice_id AND id = :id`).run({
+        ":status": status,
+        ":completed_at": completedAt ?? null,
+        ":milestone_id": milestoneId,
+        ":slice_id": sliceId,
+        ":id": taskId,
+    });
+}
+export function upsertTaskPlanning(milestoneId, sliceId, taskId, planning) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`UPDATE tasks SET
+      title = COALESCE(:title, title),
+      description = COALESCE(:description, description),
+      estimate = COALESCE(:estimate, estimate),
+      files = COALESCE(:files, files),
+      verify = COALESCE(:verify, verify),
+      inputs = COALESCE(:inputs, inputs),
+      expected_output = COALESCE(:expected_output, expected_output),
+      observability_impact = COALESCE(:observability_impact, observability_impact)
+     WHERE milestone_id = :milestone_id AND slice_id = :slice_id AND id = :id`).run({
+        ":milestone_id": milestoneId,
+        ":slice_id": sliceId,
+        ":id": taskId,
+        ":title": planning.title ?? null,
+        ":description": planning.description ?? null,
+        ":estimate": planning.estimate ?? null,
+        ":files": planning.files ? JSON.stringify(planning.files) : null,
+        ":verify": planning.verify ?? null,
+        ":inputs": planning.inputs ? JSON.stringify(planning.inputs) : null,
+        ":expected_output": planning.expectedOutput ? JSON.stringify(planning.expectedOutput) : null,
+        ":observability_impact": planning.observabilityImpact ?? null,
+    });
+}
+function rowToSlice(row) {
+    return {
+        milestone_id: row["milestone_id"],
+        id: row["id"],
+        title: row["title"],
+        status: row["status"],
+        risk: row["risk"],
+        depends: JSON.parse(row["depends"] || "[]"),
+        demo: row["demo"] ?? "",
+        created_at: row["created_at"],
+        completed_at: row["completed_at"] ?? null,
+        full_summary_md: row["full_summary_md"] ?? "",
+        full_uat_md: row["full_uat_md"] ?? "",
+        goal: row["goal"] ?? "",
+        success_criteria: row["success_criteria"] ?? "",
+        proof_level: row["proof_level"] ?? "",
+        integration_closure: row["integration_closure"] ?? "",
+        observability_impact: row["observability_impact"] ?? "",
+        sequence: row["sequence"] ?? 0,
+        replan_triggered_at: row["replan_triggered_at"] ?? null,
+    };
+}
+export function getSlice(milestoneId, sliceId) {
+    if (!currentDb)
+        return null;
+    const row = currentDb.prepare("SELECT * FROM slices WHERE milestone_id = :mid AND id = :sid").get({ ":mid": milestoneId, ":sid": sliceId });
+    if (!row)
+        return null;
+    return rowToSlice(row);
+}
+export function updateSliceStatus(milestoneId, sliceId, status, completedAt) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`UPDATE slices SET status = :status, completed_at = :completed_at
+     WHERE milestone_id = :milestone_id AND id = :id`).run({
+        ":status": status,
+        ":completed_at": completedAt ?? null,
+        ":milestone_id": milestoneId,
+        ":id": sliceId,
+    });
+}
+function rowToTask(row) {
+    return {
+        milestone_id: row["milestone_id"],
+        slice_id: row["slice_id"],
+        id: row["id"],
+        title: row["title"],
+        status: row["status"],
+        one_liner: row["one_liner"],
+        narrative: row["narrative"],
+        verification_result: row["verification_result"],
+        duration: row["duration"],
+        completed_at: row["completed_at"] ?? null,
+        blocker_discovered: row["blocker_discovered"] === 1,
+        deviations: row["deviations"],
+        known_issues: row["known_issues"],
+        key_files: JSON.parse(row["key_files"] || "[]"),
+        key_decisions: JSON.parse(row["key_decisions"] || "[]"),
+        full_summary_md: row["full_summary_md"],
+        description: row["description"] ?? "",
+        estimate: row["estimate"] ?? "",
+        files: JSON.parse(row["files"] || "[]"),
+        verify: row["verify"] ?? "",
+        inputs: JSON.parse(row["inputs"] || "[]"),
+        expected_output: JSON.parse(row["expected_output"] || "[]"),
+        observability_impact: row["observability_impact"] ?? "",
+        sequence: row["sequence"] ?? 0,
+    };
+}
+export function getTask(milestoneId, sliceId, taskId) {
+    if (!currentDb)
+        return null;
+    const row = currentDb.prepare("SELECT * FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND id = :tid").get({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
+    if (!row)
+        return null;
+    return rowToTask(row);
+}
+export function getSliceTasks(milestoneId, sliceId) {
+    if (!currentDb)
+        return [];
+    const rows = currentDb.prepare("SELECT * FROM tasks WHERE milestone_id = :mid AND slice_id = :sid ORDER BY sequence, id").all({ ":mid": milestoneId, ":sid": sliceId });
+    return rows.map(rowToTask);
+}
+export function insertVerificationEvidence(e) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`INSERT INTO verification_evidence (task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at)
+     VALUES (:task_id, :slice_id, :milestone_id, :command, :exit_code, :verdict, :duration_ms, :created_at)`).run({
+        ":task_id": e.taskId,
+        ":slice_id": e.sliceId,
+        ":milestone_id": e.milestoneId,
+        ":command": e.command,
+        ":exit_code": e.exitCode,
+        ":verdict": e.verdict,
+        ":duration_ms": e.durationMs,
+        ":created_at": new Date().toISOString(),
+    });
+}
+function rowToMilestone(row) {
+    return {
+        id: row["id"],
+        title: row["title"],
+        status: row["status"],
+        depends_on: JSON.parse(row["depends_on"] || "[]"),
+        created_at: row["created_at"],
+        completed_at: row["completed_at"] ?? null,
+        vision: row["vision"] ?? "",
+        success_criteria: JSON.parse(row["success_criteria"] || "[]"),
+        key_risks: JSON.parse(row["key_risks"] || "[]"),
+        proof_strategy: JSON.parse(row["proof_strategy"] || "[]"),
+        verification_contract: row["verification_contract"] ?? "",
+        verification_integration: row["verification_integration"] ?? "",
+        verification_operational: row["verification_operational"] ?? "",
+        verification_uat: row["verification_uat"] ?? "",
+        definition_of_done: JSON.parse(row["definition_of_done"] || "[]"),
+        requirement_coverage: row["requirement_coverage"] ?? "",
+        boundary_map_markdown: row["boundary_map_markdown"] ?? "",
+    };
+}
+function rowToArtifact(row) {
+    return {
+        path: row["path"],
+        artifact_type: row["artifact_type"],
+        milestone_id: row["milestone_id"] ?? null,
+        slice_id: row["slice_id"] ?? null,
+        task_id: row["task_id"] ?? null,
+        full_content: row["full_content"],
+        imported_at: row["imported_at"],
+    };
+}
+export function getAllMilestones() {
+    if (!currentDb)
+        return [];
+    const rows = currentDb.prepare("SELECT * FROM milestones ORDER BY id").all();
+    return rows.map(rowToMilestone);
+}
+export function getMilestone(id) {
+    if (!currentDb)
+        return null;
+    const row = currentDb.prepare("SELECT * FROM milestones WHERE id = :id").get({ ":id": id });
+    if (!row)
+        return null;
+    return rowToMilestone(row);
+}
+export function getActiveMilestoneFromDb() {
+    if (!currentDb)
+        return null;
+    const row = currentDb.prepare("SELECT * FROM milestones WHERE status NOT IN ('complete', 'parked') ORDER BY id LIMIT 1").get();
+    if (!row)
+        return null;
+    return rowToMilestone(row);
+}
+export function getActiveSliceFromDb(milestoneId) {
+    if (!currentDb)
+        return null;
+    const rows = currentDb.prepare("SELECT * FROM slices WHERE milestone_id = :mid AND status NOT IN ('complete', 'done') ORDER BY sequence, id").all({ ":mid": milestoneId });
+    if (rows.length === 0)
+        return null;
+    const completedRows = currentDb.prepare("SELECT id FROM slices WHERE milestone_id = :mid AND status IN ('complete', 'done')").all({ ":mid": milestoneId });
+    const completedIds = new Set(completedRows.map((r) => r["id"]));
+    for (const row of rows) {
+        const slice = rowToSlice(row);
+        if (slice.depends.length === 0 || slice.depends.every((d) => completedIds.has(d))) {
+            return slice;
+        }
+    }
+    return null;
+}
+export function getActiveTaskFromDb(milestoneId, sliceId) {
+    if (!currentDb)
+        return null;
+    const row = currentDb.prepare("SELECT * FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND status NOT IN ('complete', 'done') ORDER BY sequence, id LIMIT 1").get({ ":mid": milestoneId, ":sid": sliceId });
+    if (!row)
+        return null;
+    return rowToTask(row);
+}
+export function getMilestoneSlices(milestoneId) {
+    if (!currentDb)
+        return [];
+    const rows = currentDb.prepare("SELECT * FROM slices WHERE milestone_id = :mid ORDER BY sequence, id").all({ ":mid": milestoneId });
+    return rows.map(rowToSlice);
+}
+export function getArtifact(path) {
+    if (!currentDb)
+        return null;
+    const row = currentDb.prepare("SELECT * FROM artifacts WHERE path = :path").get({ ":path": path });
+    if (!row)
+        return null;
+    return rowToArtifact(row);
+}
 // ─── Worktree DB Helpers ──────────────────────────────────────────────────
 export function copyWorktreeDb(srcDbPath, destDbPath) {
     try {
@@ -639,22 +1218,17 @@ export function copyWorktreeDb(srcDbPath, destDbPath) {
     }
 }
 export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
-    const zero = {
-        decisions: 0,
-        requirements: 0,
-        artifacts: 0,
-        conflicts: [],
-    };
+    const zero = { decisions: 0, requirements: 0, artifacts: 0, conflicts: [] };
     if (!existsSync(worktreeDbPath))
         return zero;
     if (worktreeDbPath.includes("'")) {
-        process.stderr.write(`gsd-db: worktree DB reconciliation failed: path contains unsafe characters\n`);
+        process.stderr.write("gsd-db: worktree DB reconciliation failed: path contains unsafe characters\n");
         return zero;
     }
     if (!currentDb) {
         const opened = openDatabase(mainDbPath);
         if (!opened) {
-            process.stderr.write(`gsd-db: worktree DB reconciliation failed: cannot open main DB\n`);
+            process.stderr.write("gsd-db: worktree DB reconciliation failed: cannot open main DB\n");
             return zero;
         }
     }
@@ -663,75 +1237,49 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
     try {
         adapter.exec(`ATTACH DATABASE '${worktreeDbPath}' AS wt`);
         try {
-            // Check if attached wt database has the made_by column (legacy v3 worktrees won't)
             const wtInfo = adapter.prepare("PRAGMA wt.table_info('decisions')").all();
             const hasMadeBy = wtInfo.some((col) => col["name"] === "made_by");
-            const decConf = adapter
-                .prepare(`SELECT m.id FROM decisions m INNER JOIN wt.decisions w ON m.id = w.id WHERE m.decision != w.decision OR m.choice != w.choice OR m.rationale != w.rationale OR ${hasMadeBy ? "m.made_by != w.made_by" : "'agent' != 'agent'"} OR m.superseded_by IS NOT w.superseded_by`)
-                .all();
+            const decConf = adapter.prepare(`SELECT m.id FROM decisions m INNER JOIN wt.decisions w ON m.id = w.id WHERE m.decision != w.decision OR m.choice != w.choice OR m.rationale != w.rationale OR ${hasMadeBy ? "m.made_by != w.made_by" : "'agent' != 'agent'"} OR m.superseded_by IS NOT w.superseded_by`).all();
             for (const row of decConf)
                 conflicts.push(`decision ${row["id"]}: modified in both`);
-            const reqConf = adapter
-                .prepare(`SELECT m.id FROM requirements m INNER JOIN wt.requirements w ON m.id = w.id WHERE m.description != w.description OR m.status != w.status OR m.notes != w.notes OR m.superseded_by IS NOT w.superseded_by`)
-                .all();
+            const reqConf = adapter.prepare(`SELECT m.id FROM requirements m INNER JOIN wt.requirements w ON m.id = w.id WHERE m.description != w.description OR m.status != w.status OR m.notes != w.notes OR m.superseded_by IS NOT w.superseded_by`).all();
             for (const row of reqConf)
                 conflicts.push(`requirement ${row["id"]}: modified in both`);
             const merged = { decisions: 0, requirements: 0, artifacts: 0 };
             adapter.exec("BEGIN");
             try {
-                const dR = adapter
-                    .prepare(`
+                const dR = adapter.prepare(`
           INSERT OR REPLACE INTO decisions (
             id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by
           )
-          SELECT
-            id, when_context, scope, decision, choice, rationale, revisable, ${hasMadeBy ? "made_by" : "'agent'"}, superseded_by
-          FROM wt.decisions
-        `)
-                    .run();
-                merged.decisions =
-                    typeof dR === "object" && dR !== null
-                        ? (dR.changes ?? 0)
-                        : 0;
-                const rR = adapter
-                    .prepare(`
+          SELECT id, when_context, scope, decision, choice, rationale, revisable, ${hasMadeBy ? "made_by" : "'agent'"}, superseded_by FROM wt.decisions
+        `).run();
+                merged.decisions = typeof dR === "object" && dR !== null ? (dR.changes ?? 0) : 0;
+                const rR = adapter.prepare(`
           INSERT OR REPLACE INTO requirements (
             id, class, status, description, why, source, primary_owner,
             supporting_slices, validation, notes, full_content, superseded_by
           )
-          SELECT
-            id, class, status, description, why, source, primary_owner,
-            supporting_slices, validation, notes, full_content, superseded_by
+          SELECT id, class, status, description, why, source, primary_owner,
+                 supporting_slices, validation, notes, full_content, superseded_by
           FROM wt.requirements
-        `)
-                    .run();
-                merged.requirements =
-                    typeof rR === "object" && rR !== null
-                        ? (rR.changes ?? 0)
-                        : 0;
-                const aR = adapter
-                    .prepare(`
+        `).run();
+                merged.requirements = typeof rR === "object" && rR !== null ? (rR.changes ?? 0) : 0;
+                const aR = adapter.prepare(`
           INSERT OR REPLACE INTO artifacts (
             path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at
           )
-          SELECT
-            path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at
+          SELECT path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at
           FROM wt.artifacts
-        `)
-                    .run();
-                merged.artifacts =
-                    typeof aR === "object" && aR !== null
-                        ? (aR.changes ?? 0)
-                        : 0;
+        `).run();
+                merged.artifacts = typeof aR === "object" && aR !== null ? (aR.changes ?? 0) : 0;
                 adapter.exec("COMMIT");
             }
             catch (txErr) {
                 try {
                     adapter.exec("ROLLBACK");
                 }
-                catch {
-                    /* best-effort */
-                }
+                catch { /* best effort */ }
                 throw txErr;
             }
             return { ...merged, conflicts };
@@ -740,9 +1288,7 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
             try {
                 adapter.exec("DETACH DATABASE wt");
             }
-            catch {
-                /* best-effort */
-            }
+            catch { /* best effort */ }
         }
     }
     catch (err) {
@@ -750,3 +1296,79 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
         return { ...zero, conflicts };
     }
 }
+// ─── Replan & Assessment Helpers ──────────────────────────────────────────
+export function insertReplanHistory(entry) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`INSERT INTO replan_history (milestone_id, slice_id, task_id, summary, previous_artifact_path, replacement_artifact_path, created_at)
+     VALUES (:milestone_id, :slice_id, :task_id, :summary, :previous_artifact_path, :replacement_artifact_path, :created_at)`).run({
+        ":milestone_id": entry.milestoneId,
+        ":slice_id": entry.sliceId ?? null,
+        ":task_id": entry.taskId ?? null,
+        ":summary": entry.summary,
+        ":previous_artifact_path": entry.previousArtifactPath ?? null,
+        ":replacement_artifact_path": entry.replacementArtifactPath ?? null,
+        ":created_at": new Date().toISOString(),
+    });
+}
+export function insertAssessment(entry) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`INSERT OR REPLACE INTO assessments (path, milestone_id, slice_id, task_id, status, scope, full_content, created_at)
+     VALUES (:path, :milestone_id, :slice_id, :task_id, :status, :scope, :full_content, :created_at)`).run({
+        ":path": entry.path,
+        ":milestone_id": entry.milestoneId,
+        ":slice_id": entry.sliceId ?? null,
+        ":task_id": entry.taskId ?? null,
+        ":status": entry.status,
+        ":scope": entry.scope,
+        ":full_content": entry.fullContent,
+        ":created_at": new Date().toISOString(),
+    });
+}
+export function deleteTask(milestoneId, sliceId, taskId) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    // Must delete verification_evidence first (FK constraint)
+    currentDb.prepare(`DELETE FROM verification_evidence WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
+    currentDb.prepare(`DELETE FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND id = :tid`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
+}
+export function deleteSlice(milestoneId, sliceId) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    // Cascade-style manual deletion: evidence → tasks → slice
+    currentDb.prepare(`DELETE FROM verification_evidence WHERE milestone_id = :mid AND slice_id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId });
+    currentDb.prepare(`DELETE FROM tasks WHERE milestone_id = :mid AND slice_id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId });
+    currentDb.prepare(`DELETE FROM slices WHERE milestone_id = :mid AND id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId });
+}
+export function updateSliceFields(milestoneId, sliceId, fields) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`UPDATE slices SET
+      title = COALESCE(:title, title),
+      risk = COALESCE(:risk, risk),
+      depends = COALESCE(:depends, depends),
+      demo = COALESCE(:demo, demo)
+     WHERE milestone_id = :milestone_id AND id = :id`).run({
+        ":milestone_id": milestoneId,
+        ":id": sliceId,
+        ":title": fields.title ?? null,
+        ":risk": fields.risk ?? null,
+        ":depends": fields.depends ? JSON.stringify(fields.depends) : null,
+        ":demo": fields.demo ?? null,
+    });
+}
+export function getReplanHistory(milestoneId, sliceId) {
+    if (!currentDb)
+        return [];
+    if (sliceId) {
+        return currentDb.prepare(`SELECT * FROM replan_history WHERE milestone_id = :mid AND slice_id = :sid ORDER BY created_at DESC`).all({ ":mid": milestoneId, ":sid": sliceId });
+    }
+    return currentDb.prepare(`SELECT * FROM replan_history WHERE milestone_id = :mid ORDER BY created_at DESC`).all({ ":mid": milestoneId });
+}
+export function getAssessment(path) {
+    if (!currentDb)
+        return null;
+    const row = currentDb.prepare(`SELECT * FROM assessments WHERE path = :path`).get({ ":path": path });
+    return row ?? null;
+}