gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/gsd-db.ts

@@ -11,15 +11,8 @@ import { dirname } from "node:path";
 import type { Decision, Requirement } from "./types.js";
 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);
 
-// ─── Provider Abstraction ──────────────────────────────────────────────────
-
-/**
- * Minimal interface over both node:sqlite DatabaseSync and better-sqlite3 Database.
- * Both expose prepare().run/get/all — the adapter normalizes row objects.
- */
 interface DbStatement {
   run(...params: unknown[]): unknown;
   get(...params: unknown[]): Record<string, unknown> | undefined;
@@ -38,13 +31,9 @@ let providerName: ProviderName | null = null;
 let providerModule: unknown = null;
 let loadAttempted = false;
 
-/**
- * Suppress the ExperimentalWarning for SQLite from node:sqlite.
- * Must be called before require('node:sqlite').
- */
 function suppressSqliteWarning(): void {
   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: string, ...args: unknown[]): boolean {
     if (
       event === "warning" &&
@@ -58,9 +47,7 @@ function suppressSqliteWarning(): void {
     ) {
       return false;
     }
-    return origEmit.apply(process, [event, ...args] as Parameters<
-      typeof process.emit
-    >) as unknown as boolean;
+    return origEmit.apply(process, [event, ...args] as Parameters<typeof process.emit>) as unknown as boolean;
   };
 }
 
@@ -68,7 +55,6 @@ function loadProvider(): void {
   if (loadAttempted) return;
   loadAttempted = true;
 
-  // Try node:sqlite first
   try {
     suppressSqliteWarning();
     const mod = _require("node:sqlite");
@@ -78,10 +64,9 @@ function loadProvider(): void {
       return;
     }
   } catch {
-    // node:sqlite not available
+    // unavailable
   }
 
-  // Try better-sqlite3
   try {
     const mod = _require("better-sqlite3");
     if (typeof mod === "function" || (mod && mod.default)) {
@@ -90,7 +75,7 @@ function loadProvider(): void {
       return;
     }
   } catch {
-    // better-sqlite3 not available
+    // unavailable
   }
 
   process.stderr.write(
@@ -98,11 +83,6 @@ function loadProvider(): void {
   );
 }
 
-// ─── Database Adapter ──────────────────────────────────────────────────────
-
-/**
- * Normalize a row from node:sqlite (null-prototype) to a plain object.
- */
 function normalizeRow(row: unknown): Record<string, unknown> | undefined {
   if (row == null) return undefined;
   if (Object.getPrototypeOf(row) === null) {
@@ -161,20 +141,16 @@ function openRawDb(path: string): unknown {
     return new DatabaseSync(path);
   }
 
-  // better-sqlite3
   const Database = providerModule as new (path: string) => unknown;
   return new Database(path);
 }
 
-// ─── Schema ────────────────────────────────────────────────────────────────
-
-const SCHEMA_VERSION = 4;
+const SCHEMA_VERSION = 10;
 
 function initSchema(db: DbAdapter, fileBacked: boolean): void {
-  // WAL mode for file-backed databases (must be outside transaction)
-  if (fileBacked) {
-    db.exec("PRAGMA journal_mode=WAL");
-  }
+  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 {
@@ -253,25 +229,135 @@ function initSchema(db: DbAdapter, fileBacked: boolean): void {
       )
     `);
 
-    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 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();
+    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)");
+    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`);
+
+    const existing = db.prepare("SELECT count(*) as cnt FROM schema_version").get();
     if (existing && (existing["cnt"] as number) === 0) {
       db.prepare(
         "INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)",
@@ -287,23 +373,25 @@ function initSchema(db: DbAdapter, fileBacked: boolean): void {
     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: DbAdapter, table: string, column: string): boolean {
+  const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+  return rows.some((row) => row["name"] === column);
+}
+
+function ensureColumn(db: DbAdapter, table: string, column: string, ddl: string): void {
+  if (!columnExists(db, table, column)) db.exec(ddl);
+}
+
 function migrateSchema(db: DbAdapter): void {
   const row = db.prepare("SELECT MAX(version) as v FROM schema_version").get();
   const currentVersion = row ? (row["v"] as number) : 0;
-
   if (currentVersion >= SCHEMA_VERSION) return;
 
   db.exec("BEGIN");
   try {
-    // v1 → v2: add artifacts table
     if (currentVersion < 2) {
       db.exec(`
         CREATE TABLE IF NOT EXISTS artifacts (
@@ -316,13 +404,12 @@ function migrateSchema(db: DbAdapter): void {
           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 (
@@ -339,7 +426,6 @@ function migrateSchema(db: DbAdapter): void {
           hit_count INTEGER NOT NULL DEFAULT 0
         )
       `);
-
       db.exec(`
         CREATE TABLE IF NOT EXISTS memory_processed_units (
           unit_key TEXT PRIMARY KEY,
@@ -347,34 +433,187 @@ function migrateSchema(db: DbAdapter): void {
           processed_at TEXT NOT NULL
         )
       `);
-
-      db.exec(
-        "CREATE INDEX IF NOT EXISTS idx_memories_active ON memories(superseded_by)",
-      );
+      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.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(),
+      });
     }
 
-    // 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.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");
@@ -384,72 +623,53 @@ function migrateSchema(db: DbAdapter): void {
   }
 }
 
-// ─── Module State ──────────────────────────────────────────────────────────
-
 let currentDb: DbAdapter | null = null;
 let currentPath: string | null = null;
-/** PID that opened the current connection — used for diagnostic logging. */
 let currentPid: number = 0;
+let _exitHandlerRegistered = false;
 
-// ─── Public API ────────────────────────────────────────────────────────────
-
-/**
- * Returns which SQLite provider is available, or null if none.
- */
 export function getDbProvider(): ProviderName | null {
   loadProvider();
   return providerName;
 }
 
-/**
- * Returns true if a database is currently open and usable.
- */
 export function isDbAvailable(): boolean {
   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: string): boolean {
-  // Close existing if different path
-  if (currentDb && currentPath !== path) {
-    closeDatabase();
-  }
-  if (currentDb && currentPath === path) {
-    return true; // already open
-  }
+  if (currentDb && currentPath !== path) closeDatabase();
+  if (currentDb && currentPath === path) return true;
 
   const rawDb = openRawDb(path);
   if (!rawDb) return false;
 
   const adapter = createAdapter(rawDb);
   const fileBacked = path !== ":memory:";
-
   try {
     initSchema(adapter, fileBacked);
   } catch (err) {
-    try {
-      adapter.close();
-    } catch {
-      /* swallow */
-    }
+    try { adapter.close(); } 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(): void {
   if (currentDb) {
+    try {
+      currentDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+    } catch { /* non-fatal — best effort before close */ }
     try {
       currentDb.close();
     } catch {
@@ -461,12 +681,8 @@ export function closeDatabase(): void {
   }
 }
 
-/**
- * Runs a function inside a transaction. Rolls back on error.
- */
 export function transaction<T>(fn: () => T): T {
-  if (!currentDb)
-    throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
   currentDb.exec("BEGIN");
   try {
     const result = fn();
@@ -478,35 +694,24 @@ export function transaction<T>(fn: () => T): T {
   }
 }
 
-// ─── Decision Wrappers ────────────────────────────────────────────────────
-
-/**
- * Insert a decision. The `seq` field is auto-generated.
- */
 export function insertDecision(d: Omit<Decision, "seq">): void {
-  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)
+  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({
-      ":id": d.id,
-      ":when_context": d.when_context,
-      ":scope": d.scope,
-      ":decision": d.decision,
-      ":choice": d.choice,
-      ":rationale": d.rationale,
-      ":revisable": d.revisable,
-      ":made_by": d.made_by ?? "agent",
-      ":superseded_by": d.superseded_by,
-    });
-}
-
-/**
- * Get a decision by its ID (e.g. "D001"). Returns null if not found.
- */
+  ).run({
+    ":id": d.id,
+    ":when_context": d.when_context,
+    ":scope": d.scope,
+    ":decision": d.decision,
+    ":choice": d.choice,
+    ":rationale": d.rationale,
+    ":revisable": d.revisable,
+    ":made_by": d.made_by ?? "agent",
+    ":superseded_by": d.superseded_by,
+  });
+}
+
 export function getDecisionById(id: string): Decision | null {
   if (!currentDb) return null;
   const row = currentDb.prepare("SELECT * FROM decisions WHERE id = ?").get(id);
@@ -525,9 +730,6 @@ export function getDecisionById(id: string): Decision | null {
   };
 }
 
-/**
- * Get all active (non-superseded) decisions.
- */
 export function getActiveDecisions(): Decision[] {
   if (!currentDb) return [];
   const rows = currentDb.prepare("SELECT * FROM active_decisions").all();
@@ -545,43 +747,30 @@ export function getActiveDecisions(): Decision[] {
   }));
 }
 
-// ─── Requirement Wrappers ─────────────────────────────────────────────────
-
-/**
- * Insert a requirement.
- */
 export function insertRequirement(r: Requirement): void {
-  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)
+  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({
-      ":id": r.id,
-      ":class": r.class,
-      ":status": r.status,
-      ":description": r.description,
-      ":why": r.why,
-      ":source": r.source,
-      ":primary_owner": r.primary_owner,
-      ":supporting_slices": r.supporting_slices,
-      ":validation": r.validation,
-      ":notes": r.notes,
-      ":full_content": r.full_content,
-      ":superseded_by": r.superseded_by,
-    });
-}
-
-/**
- * Get a requirement by its ID (e.g. "R001"). Returns null if not found.
- */
+  ).run({
+    ":id": r.id,
+    ":class": r.class,
+    ":status": r.status,
+    ":description": r.description,
+    ":why": r.why,
+    ":source": r.source,
+    ":primary_owner": r.primary_owner,
+    ":supporting_slices": r.supporting_slices,
+    ":validation": r.validation,
+    ":notes": r.notes,
+    ":full_content": r.full_content,
+    ":superseded_by": r.superseded_by,
+  });
+}
+
 export function getRequirementById(id: string): Requirement | null {
   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 {
     id: row["id"] as string,
@@ -599,9 +788,6 @@ export function getRequirementById(id: string): Requirement | null {
   };
 }
 
-/**
- * Get all active (non-superseded) requirements.
- */
 export function getActiveRequirements(): Requirement[] {
   if (!currentDb) return [];
   const rows = currentDb.prepare("SELECT * FROM active_requirements").all();
@@ -621,108 +807,66 @@ export function getActiveRequirements(): Requirement[] {
   }));
 }
 
-/**
- * Returns the PID of the process that opened the current DB connection.
- * Returns 0 if no connection is open.
- */
 export function getDbOwnerPid(): number {
   return currentPid;
 }
 
-/**
- * Returns the path of the currently open database, or null if none.
- */
 export function getDbPath(): string | null {
   return currentPath;
 }
 
-// ─── Internal Access (for testing) ─────────────────────────────────────────
-
-/**
- * Get the raw adapter for direct queries (testing only).
- */
 export function _getAdapter(): DbAdapter | null {
   return currentDb;
 }
 
-/**
- * Reset provider state (testing only — allows re-detection).
- */
 export function _resetProvider(): void {
   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: Omit<Decision, "seq">): void {
-  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)
+  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({
-      ":id": d.id,
-      ":when_context": d.when_context,
-      ":scope": d.scope,
-      ":decision": d.decision,
-      ":choice": d.choice,
-      ":rationale": d.rationale,
-      ":revisable": d.revisable,
-      ":made_by": d.made_by ?? "agent",
-      ":superseded_by": d.superseded_by ?? null,
-    });
-}
-
-/**
- * Insert or replace a requirement. Uses the `id` PK for idempotency.
- */
+  ).run({
+    ":id": d.id,
+    ":when_context": d.when_context,
+    ":scope": d.scope,
+    ":decision": d.decision,
+    ":choice": d.choice,
+    ":rationale": d.rationale,
+    ":revisable": d.revisable,
+    ":made_by": d.made_by ?? "agent",
+    ":superseded_by": d.superseded_by ?? null,
+  });
+}
+
 export function upsertRequirement(r: Requirement): void {
-  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)
+  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({
-      ":id": r.id,
-      ":class": r.class,
-      ":status": r.status,
-      ":description": r.description,
-      ":why": r.why,
-      ":source": r.source,
-      ":primary_owner": r.primary_owner,
-      ":supporting_slices": r.supporting_slices,
-      ":validation": r.validation,
-      ":notes": r.notes,
-      ":full_content": r.full_content,
-      ":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).
- */
+  ).run({
+    ":id": r.id,
+    ":class": r.class,
+    ":status": r.status,
+    ":description": r.description,
+    ":why": r.why,
+    ":source": r.source,
+    ":primary_owner": r.primary_owner,
+    ":supporting_slices": r.supporting_slices,
+    ":validation": r.validation,
+    ":notes": r.notes,
+    ":full_content": r.full_content,
+    ":superseded_by": r.superseded_by ?? null,
+  });
+}
+
 export function clearArtifacts(): void {
   if (!currentDb) return;
-  try {
-    currentDb.exec("DELETE FROM artifacts");
-  } catch {
-    // Clearing a cache should never be fatal
-  }
+  try { currentDb.exec("DELETE FROM artifacts"); } catch { /* cache clear is best effort */ }
 }
 
 export function insertArtifact(a: {
@@ -733,22 +877,598 @@ export function insertArtifact(a: {
   task_id: string | null;
   full_content: string;
 }): void {
-  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)
+  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({
+    ":path": a.path,
+    ":artifact_type": a.artifact_type,
+    ":milestone_id": a.milestone_id,
+    ":slice_id": a.slice_id,
+    ":task_id": a.task_id,
+    ":full_content": a.full_content,
+    ":imported_at": new Date().toISOString(),
+  });
+}
+
+export interface MilestonePlanningRecord {
+  vision: string;
+  successCriteria: string[];
+  keyRisks: Array<{ risk: string; whyItMatters: string }>;
+  proofStrategy: Array<{ riskOrUnknown: string; retireIn: string; whatWillBeProven: string }>;
+  verificationContract: string;
+  verificationIntegration: string;
+  verificationOperational: string;
+  verificationUat: string;
+  definitionOfDone: string[];
+  requirementCoverage: string;
+  boundaryMapMarkdown: string;
+}
+
+export interface SlicePlanningRecord {
+  goal: string;
+  successCriteria: string;
+  proofLevel: string;
+  integrationClosure: string;
+  observabilityImpact: string;
+}
+
+export interface TaskPlanningRecord {
+  title?: string;
+  description: string;
+  estimate: string;
+  files: string[];
+  verify: string;
+  inputs: string[];
+  expectedOutput: string[];
+  observabilityImpact: string;
+}
+
+export function insertMilestone(m: {
+  id: string;
+  title?: string;
+  status?: string;
+  depends_on?: string[];
+  planning?: Partial<MilestonePlanningRecord>;
+}): void {
+  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: string, planning: Partial<MilestonePlanningRecord>): void {
+  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: {
+  id: string;
+  milestoneId: string;
+  title?: string;
+  status?: string;
+  risk?: string;
+  depends?: string[];
+  demo?: string;
+  sequence?: number;
+  planning?: Partial<SlicePlanningRecord>;
+}): void {
+  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: string, sliceId: string, planning: Partial<SlicePlanningRecord>): void {
+  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: {
+  id: string;
+  sliceId: string;
+  milestoneId: string;
+  title?: string;
+  status?: string;
+  oneLiner?: string;
+  narrative?: string;
+  verificationResult?: string;
+  duration?: string;
+  blockerDiscovered?: boolean;
+  deviations?: string;
+  knownIssues?: string;
+  keyFiles?: string[];
+  keyDecisions?: string[];
+  fullSummaryMd?: string;
+  sequence?: number;
+  planning?: Partial<TaskPlanningRecord>;
+}): void {
+  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
     )
-    .run({
-      ":path": a.path,
-      ":artifact_type": a.artifact_type,
-      ":milestone_id": a.milestone_id,
-      ":slice_id": a.slice_id,
-      ":task_id": a.task_id,
-      ":full_content": a.full_content,
-      ":imported_at": new Date().toISOString(),
-    });
+    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: string, sliceId: string, taskId: string, status: string, completedAt?: string): void {
+  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: string, sliceId: string, taskId: string, planning: Partial<TaskPlanningRecord>): void {
+  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,
+  });
+}
+
+export interface SliceRow {
+  milestone_id: string;
+  id: string;
+  title: string;
+  status: string;
+  risk: string;
+  depends: string[];
+  demo: string;
+  created_at: string;
+  completed_at: string | null;
+  full_summary_md: string;
+  full_uat_md: string;
+  goal: string;
+  success_criteria: string;
+  proof_level: string;
+  integration_closure: string;
+  observability_impact: string;
+  sequence: number;
+  replan_triggered_at: string | null;
+}
+
+function rowToSlice(row: Record<string, unknown>): SliceRow {
+  return {
+    milestone_id: row["milestone_id"] as string,
+    id: row["id"] as string,
+    title: row["title"] as string,
+    status: row["status"] as string,
+    risk: row["risk"] as string,
+    depends: JSON.parse((row["depends"] as string) || "[]"),
+    demo: (row["demo"] as string) ?? "",
+    created_at: row["created_at"] as string,
+    completed_at: (row["completed_at"] as string) ?? null,
+    full_summary_md: (row["full_summary_md"] as string) ?? "",
+    full_uat_md: (row["full_uat_md"] as string) ?? "",
+    goal: (row["goal"] as string) ?? "",
+    success_criteria: (row["success_criteria"] as string) ?? "",
+    proof_level: (row["proof_level"] as string) ?? "",
+    integration_closure: (row["integration_closure"] as string) ?? "",
+    observability_impact: (row["observability_impact"] as string) ?? "",
+    sequence: (row["sequence"] as number) ?? 0,
+    replan_triggered_at: (row["replan_triggered_at"] as string) ?? null,
+  };
+}
+
+export function getSlice(milestoneId: string, sliceId: string): SliceRow | null {
+  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: string, sliceId: string, status: string, completedAt?: string): void {
+  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,
+  });
+}
+
+export interface TaskRow {
+  milestone_id: string;
+  slice_id: string;
+  id: string;
+  title: string;
+  status: string;
+  one_liner: string;
+  narrative: string;
+  verification_result: string;
+  duration: string;
+  completed_at: string | null;
+  blocker_discovered: boolean;
+  deviations: string;
+  known_issues: string;
+  key_files: string[];
+  key_decisions: string[];
+  full_summary_md: string;
+  description: string;
+  estimate: string;
+  files: string[];
+  verify: string;
+  inputs: string[];
+  expected_output: string[];
+  observability_impact: string;
+  sequence: number;
+}
+
+function rowToTask(row: Record<string, unknown>): TaskRow {
+  return {
+    milestone_id: row["milestone_id"] as string,
+    slice_id: row["slice_id"] as string,
+    id: row["id"] as string,
+    title: row["title"] as string,
+    status: row["status"] as string,
+    one_liner: row["one_liner"] as string,
+    narrative: row["narrative"] as string,
+    verification_result: row["verification_result"] as string,
+    duration: row["duration"] as string,
+    completed_at: (row["completed_at"] as string) ?? null,
+    blocker_discovered: (row["blocker_discovered"] as number) === 1,
+    deviations: row["deviations"] as string,
+    known_issues: row["known_issues"] as string,
+    key_files: JSON.parse((row["key_files"] as string) || "[]"),
+    key_decisions: JSON.parse((row["key_decisions"] as string) || "[]"),
+    full_summary_md: row["full_summary_md"] as string,
+    description: (row["description"] as string) ?? "",
+    estimate: (row["estimate"] as string) ?? "",
+    files: JSON.parse((row["files"] as string) || "[]"),
+    verify: (row["verify"] as string) ?? "",
+    inputs: JSON.parse((row["inputs"] as string) || "[]"),
+    expected_output: JSON.parse((row["expected_output"] as string) || "[]"),
+    observability_impact: (row["observability_impact"] as string) ?? "",
+    sequence: (row["sequence"] as number) ?? 0,
+  };
+}
+
+export function getTask(milestoneId: string, sliceId: string, taskId: string): TaskRow | null {
+  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: string, sliceId: string): TaskRow[] {
+  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: {
+  taskId: string;
+  sliceId: string;
+  milestoneId: string;
+  command: string;
+  exitCode: number;
+  verdict: string;
+  durationMs: number;
+}): void {
+  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(),
+  });
+}
+
+export interface MilestoneRow {
+  id: string;
+  title: string;
+  status: string;
+  depends_on: string[];
+  created_at: string;
+  completed_at: string | null;
+  vision: string;
+  success_criteria: string[];
+  key_risks: Array<{ risk: string; whyItMatters: string }>;
+  proof_strategy: Array<{ riskOrUnknown: string; retireIn: string; whatWillBeProven: string }>;
+  verification_contract: string;
+  verification_integration: string;
+  verification_operational: string;
+  verification_uat: string;
+  definition_of_done: string[];
+  requirement_coverage: string;
+  boundary_map_markdown: string;
+}
+
+function rowToMilestone(row: Record<string, unknown>): MilestoneRow {
+  return {
+    id: row["id"] as string,
+    title: row["title"] as string,
+    status: row["status"] as string,
+    depends_on: JSON.parse((row["depends_on"] as string) || "[]"),
+    created_at: row["created_at"] as string,
+    completed_at: (row["completed_at"] as string) ?? null,
+    vision: (row["vision"] as string) ?? "",
+    success_criteria: JSON.parse((row["success_criteria"] as string) || "[]"),
+    key_risks: JSON.parse((row["key_risks"] as string) || "[]"),
+    proof_strategy: JSON.parse((row["proof_strategy"] as string) || "[]"),
+    verification_contract: (row["verification_contract"] as string) ?? "",
+    verification_integration: (row["verification_integration"] as string) ?? "",
+    verification_operational: (row["verification_operational"] as string) ?? "",
+    verification_uat: (row["verification_uat"] as string) ?? "",
+    definition_of_done: JSON.parse((row["definition_of_done"] as string) || "[]"),
+    requirement_coverage: (row["requirement_coverage"] as string) ?? "",
+    boundary_map_markdown: (row["boundary_map_markdown"] as string) ?? "",
+  };
+}
+
+export interface ArtifactRow {
+  path: string;
+  artifact_type: string;
+  milestone_id: string | null;
+  slice_id: string | null;
+  task_id: string | null;
+  full_content: string;
+  imported_at: string;
+}
+
+function rowToArtifact(row: Record<string, unknown>): ArtifactRow {
+  return {
+    path: row["path"] as string,
+    artifact_type: row["artifact_type"] as string,
+    milestone_id: (row["milestone_id"] as string) ?? null,
+    slice_id: (row["slice_id"] as string) ?? null,
+    task_id: (row["task_id"] as string) ?? null,
+    full_content: row["full_content"] as string,
+    imported_at: row["imported_at"] as string,
+  };
+}
+
+export function getAllMilestones(): MilestoneRow[] {
+  if (!currentDb) return [];
+  const rows = currentDb.prepare("SELECT * FROM milestones ORDER BY id").all();
+  return rows.map(rowToMilestone);
+}
+
+export function getMilestone(id: string): MilestoneRow | null {
+  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(): MilestoneRow | null {
+  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: string): SliceRow | null {
+  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"] as string));
+
+  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: string, sliceId: string): TaskRow | null {
+  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: string): SliceRow[] {
+  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: string): ArtifactRow | null {
+  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 ──────────────────────────────────────────────────
@@ -761,9 +1481,7 @@ export function copyWorktreeDb(srcDbPath: string, destDbPath: string): boolean {
     copyFileSync(srcDbPath, destDbPath);
     return true;
   } catch (err) {
-    process.stderr.write(
-      `gsd-db: failed to copy DB to worktree: ${(err as Error).message}\n`,
-    );
+    process.stderr.write(`gsd-db: failed to copy DB to worktree: ${(err as Error).message}\n`);
     return false;
   }
 }
@@ -777,25 +1495,16 @@ export function reconcileWorktreeDb(
   artifacts: number;
   conflicts: string[];
 } {
-  const zero = {
-    decisions: 0,
-    requirements: 0,
-    artifacts: 0,
-    conflicts: [] as string[],
-  };
+  const zero = { decisions: 0, requirements: 0, artifacts: 0, conflicts: [] as string[] };
   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;
     }
   }
@@ -804,106 +1513,184 @@ export function reconcileWorktreeDb(
   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();
-      for (const row of decConf)
-        conflicts.push(
-          `decision ${(row as Record<string, unknown>)["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();
-      for (const row of reqConf)
-        conflicts.push(
-          `requirement ${(row as Record<string, unknown>)["id"]}: modified in both`,
-        );
+      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 as Record<string, unknown>)["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();
+      for (const row of reqConf) conflicts.push(`requirement ${(row as Record<string, unknown>)["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 as { changes?: number }).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 as { changes?: number }).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 as { changes?: number }).changes ?? 0)
-            : 0;
-        const aR = adapter
-          .prepare(
-            `
+        `).run();
+        merged.requirements = typeof rR === "object" && rR !== null ? ((rR as { changes?: number }).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 as { changes?: number }).changes ?? 0)
-            : 0;
+        `).run();
+        merged.artifacts = typeof aR === "object" && aR !== null ? ((aR as { changes?: number }).changes ?? 0) : 0;
+
         adapter.exec("COMMIT");
       } catch (txErr) {
-        try {
-          adapter.exec("ROLLBACK");
-        } catch {
-          /* best-effort */
-        }
+        try { adapter.exec("ROLLBACK"); } catch { /* best effort */ }
         throw txErr;
       }
       return { ...merged, conflicts };
     } finally {
-      try {
-        adapter.exec("DETACH DATABASE wt");
-      } catch {
-        /* best-effort */
-      }
+      try { adapter.exec("DETACH DATABASE wt"); } catch { /* best effort */ }
     }
   } catch (err) {
-    process.stderr.write(
-      `gsd-db: worktree DB reconciliation failed: ${(err as Error).message}\n`,
-    );
+    process.stderr.write(`gsd-db: worktree DB reconciliation failed: ${(err as Error).message}\n`);
     return { ...zero, conflicts };
   }
 }
+
+// ─── Replan & Assessment Helpers ──────────────────────────────────────────
+
+export function insertReplanHistory(entry: {
+  milestoneId: string;
+  sliceId?: string | null;
+  taskId?: string | null;
+  summary: string;
+  previousArtifactPath?: string | null;
+  replacementArtifactPath?: string | null;
+}): void {
+  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: {
+  path: string;
+  milestoneId: string;
+  sliceId?: string | null;
+  taskId?: string | null;
+  status: string;
+  scope: string;
+  fullContent: string;
+}): void {
+  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: string, sliceId: string, taskId: string): void {
+  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: string, sliceId: string): void {
+  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: string, sliceId: string, fields: {
+  title?: string;
+  risk?: string;
+  depends?: string[];
+  demo?: string;
+}): void {
+  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: string, sliceId?: string): Array<Record<string, unknown>> {
+  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: string): Record<string, unknown> | null {
+  if (!currentDb) return null;
+  const row = currentDb.prepare(
+    `SELECT * FROM assessments WHERE path = :path`,
+  ).get({ ":path": path });
+  return row ?? null;
+}