gsd-pi 2.33.1-dev.ee47f1b → 2.34.0-dev.bbb5216

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

@@ -4,8 +4,10 @@
 //
 // Exposes a unified sync API for decisions and requirements storage.
 // Schema is initialized on first open with WAL mode for file-backed DBs.
-import { createRequire } from 'node:module';
-import { GSDError, GSD_STALE_STATE } from './errors.js';
+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;
@@ -19,14 +21,14 @@ function suppressSqliteWarning() {
     const origEmit = process.emit;
     // @ts-expect-error — overriding process.emit with filtered version
     process.emit = function (event, ...args) {
-        if (event === 'warning' &&
+        if (event === "warning" &&
             args[0] &&
-            typeof args[0] === 'object' &&
-            'name' in args[0] &&
-            args[0].name === 'ExperimentalWarning' &&
-            'message' in args[0] &&
-            typeof args[0].message === 'string' &&
-            args[0].message.includes('SQLite')) {
+            typeof args[0] === "object" &&
+            "name" in args[0] &&
+            args[0].name === "ExperimentalWarning" &&
+            "message" in args[0] &&
+            typeof args[0].message === "string" &&
+            args[0].message.includes("SQLite")) {
             return false;
         }
         return origEmit.apply(process, [event, ...args]);
@@ -39,10 +41,10 @@ function loadProvider() {
     // Try node:sqlite first
     try {
         suppressSqliteWarning();
-        const mod = _require('node:sqlite');
+        const mod = _require("node:sqlite");
         if (mod.DatabaseSync) {
             providerModule = mod;
-            providerName = 'node:sqlite';
+            providerName = "node:sqlite";
             return;
         }
     }
@@ -51,17 +53,17 @@ function loadProvider() {
     }
     // Try better-sqlite3
     try {
-        const mod = _require('better-sqlite3');
-        if (typeof mod === 'function' || (mod && mod.default)) {
+        const mod = _require("better-sqlite3");
+        if (typeof mod === "function" || (mod && mod.default)) {
             providerModule = mod.default || mod;
-            providerName = 'better-sqlite3';
+            providerName = "better-sqlite3";
             return;
         }
     }
     catch {
         // better-sqlite3 not available
     }
-    process.stderr.write('gsd-db: No SQLite provider available (tried node:sqlite, better-sqlite3)\n');
+    process.stderr.write("gsd-db: No SQLite provider available (tried node:sqlite, better-sqlite3)\n");
 }
 // ─── Database Adapter ──────────────────────────────────────────────────────
 /**
@@ -76,7 +78,7 @@ function normalizeRow(row) {
     return row;
 }
 function normalizeRows(rows) {
-    return rows.map(r => normalizeRow(r));
+    return rows.map((r) => normalizeRow(r));
 }
 function createAdapter(rawDb) {
     const db = rawDb;
@@ -88,7 +90,7 @@ function createAdapter(rawDb) {
             const stmt = db.prepare(sql);
             return {
                 run(...params) {
-                    stmt.run(...params);
+                    return stmt.run(...params);
                 },
                 get(...params) {
                     return normalizeRow(stmt.get(...params));
@@ -107,7 +109,7 @@ function openRawDb(path) {
     loadProvider();
     if (!providerModule || !providerName)
         return null;
-    if (providerName === 'node:sqlite') {
+    if (providerName === "node:sqlite") {
         const { DatabaseSync } = providerModule;
         return new DatabaseSync(path);
     }
@@ -120,9 +122,9 @@ const SCHEMA_VERSION = 3;
 function initSchema(db, fileBacked) {
     // WAL mode for file-backed databases (must be outside transaction)
     if (fileBacked) {
-        db.exec('PRAGMA journal_mode=WAL');
+        db.exec("PRAGMA journal_mode=WAL");
     }
-    db.exec('BEGIN');
+    db.exec("BEGIN");
     try {
         db.exec(`
       CREATE TABLE IF NOT EXISTS schema_version (
@@ -192,20 +194,25 @@ function initSchema(db, fileBacked) {
         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)");
         // 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();
-        if (existing && existing['cnt'] === 0) {
-            db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)').run({ ':version': SCHEMA_VERSION, ':applied_at': new Date().toISOString() });
+        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,
+                ":applied_at": new Date().toISOString(),
+            });
         }
-        db.exec('COMMIT');
+        db.exec("COMMIT");
     }
     catch (err) {
-        db.exec('ROLLBACK');
+        db.exec("ROLLBACK");
         throw err;
     }
     // Run incremental migrations for existing databases
@@ -216,11 +223,11 @@ function initSchema(db, fileBacked) {
  * and applies DDL for each version step up to SCHEMA_VERSION.
  */
 function migrateSchema(db) {
-    const row = db.prepare('SELECT MAX(version) as v FROM schema_version').get();
-    const currentVersion = row ? row['v'] : 0;
+    const row = db.prepare("SELECT MAX(version) as v FROM schema_version").get();
+    const currentVersion = row ? row["v"] : 0;
     if (currentVersion >= SCHEMA_VERSION)
         return;
-    db.exec('BEGIN');
+    db.exec("BEGIN");
     try {
         // v1 → v2: add artifacts table
         if (currentVersion < 2) {
@@ -235,7 +242,7 @@ 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) {
@@ -261,15 +268,15 @@ function migrateSchema(db) {
           processed_at TEXT NOT NULL
         )
       `);
-            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 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('COMMIT');
+        db.exec("COMMIT");
     }
     catch (err) {
-        db.exec('ROLLBACK');
+        db.exec("ROLLBACK");
         throw err;
     }
 }
@@ -309,7 +316,7 @@ export function openDatabase(path) {
     if (!rawDb)
         return false;
     const adapter = createAdapter(rawDb);
-    const fileBacked = path !== ':memory:';
+    const fileBacked = path !== ":memory:";
     try {
         initSchema(adapter, fileBacked);
     }
@@ -317,7 +324,9 @@ export function openDatabase(path) {
         try {
             adapter.close();
         }
-        catch { /* swallow */ }
+        catch {
+            /* swallow */
+        }
         throw err;
     }
     currentDb = adapter;
@@ -346,15 +355,15 @@ export function closeDatabase() {
  */
 export function transaction(fn) {
     if (!currentDb)
-        throw new GSDError(GSD_STALE_STATE, 'gsd-db: No database open');
-    currentDb.exec('BEGIN');
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.exec("BEGIN");
     try {
         const result = fn();
-        currentDb.exec('COMMIT');
+        currentDb.exec("COMMIT");
         return result;
     }
     catch (err) {
-        currentDb.exec('ROLLBACK');
+        currentDb.exec("ROLLBACK");
         throw err;
     }
 }
@@ -364,17 +373,19 @@ export function transaction(fn) {
  */
 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, superseded_by)
-     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :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,
-        ':superseded_by': d.superseded_by,
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb
+        .prepare(`INSERT INTO decisions (id, when_context, scope, decision, choice, rationale, revisable, superseded_by)
+     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :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,
+        ":superseded_by": d.superseded_by,
     });
 }
 /**
@@ -383,19 +394,19 @@ export function insertDecision(d) {
 export function getDecisionById(id) {
     if (!currentDb)
         return null;
-    const row = currentDb.prepare('SELECT * FROM decisions WHERE id = ?').get(id);
+    const row = currentDb.prepare("SELECT * FROM decisions WHERE id = ?").get(id);
     if (!row)
         return null;
     return {
-        seq: row['seq'],
-        id: row['id'],
-        when_context: row['when_context'],
-        scope: row['scope'],
-        decision: row['decision'],
-        choice: row['choice'],
-        rationale: row['rationale'],
-        revisable: row['revisable'],
-        superseded_by: row['superseded_by'] ?? null,
+        seq: row["seq"],
+        id: row["id"],
+        when_context: row["when_context"],
+        scope: row["scope"],
+        decision: row["decision"],
+        choice: row["choice"],
+        rationale: row["rationale"],
+        revisable: row["revisable"],
+        superseded_by: row["superseded_by"] ?? null,
     };
 }
 /**
@@ -404,16 +415,16 @@ export function getDecisionById(id) {
 export function getActiveDecisions() {
     if (!currentDb)
         return [];
-    const rows = currentDb.prepare('SELECT * FROM active_decisions').all();
-    return rows.map(row => ({
-        seq: row['seq'],
-        id: row['id'],
-        when_context: row['when_context'],
-        scope: row['scope'],
-        decision: row['decision'],
-        choice: row['choice'],
-        rationale: row['rationale'],
-        revisable: row['revisable'],
+    const rows = currentDb.prepare("SELECT * FROM active_decisions").all();
+    return rows.map((row) => ({
+        seq: row["seq"],
+        id: row["id"],
+        when_context: row["when_context"],
+        scope: row["scope"],
+        decision: row["decision"],
+        choice: row["choice"],
+        rationale: row["rationale"],
+        revisable: row["revisable"],
         superseded_by: null,
     }));
 }
@@ -423,21 +434,23 @@ export function getActiveDecisions() {
  */
 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({
-        ':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,
+        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,
     });
 }
 /**
@@ -446,22 +459,24 @@ export function insertRequirement(r) {
 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 {
-        id: row['id'],
-        class: row['class'],
-        status: row['status'],
-        description: row['description'],
-        why: row['why'],
-        source: row['source'],
-        primary_owner: row['primary_owner'],
-        supporting_slices: row['supporting_slices'],
-        validation: row['validation'],
-        notes: row['notes'],
-        full_content: row['full_content'],
-        superseded_by: row['superseded_by'] ?? null,
+        id: row["id"],
+        class: row["class"],
+        status: row["status"],
+        description: row["description"],
+        why: row["why"],
+        source: row["source"],
+        primary_owner: row["primary_owner"],
+        supporting_slices: row["supporting_slices"],
+        validation: row["validation"],
+        notes: row["notes"],
+        full_content: row["full_content"],
+        superseded_by: row["superseded_by"] ?? null,
     };
 }
 /**
@@ -470,19 +485,19 @@ export function getRequirementById(id) {
 export function getActiveRequirements() {
     if (!currentDb)
         return [];
-    const rows = currentDb.prepare('SELECT * FROM active_requirements').all();
-    return rows.map(row => ({
-        id: row['id'],
-        class: row['class'],
-        status: row['status'],
-        description: row['description'],
-        why: row['why'],
-        source: row['source'],
-        primary_owner: row['primary_owner'],
-        supporting_slices: row['supporting_slices'],
-        validation: row['validation'],
-        notes: row['notes'],
-        full_content: row['full_content'],
+    const rows = currentDb.prepare("SELECT * FROM active_requirements").all();
+    return rows.map((row) => ({
+        id: row["id"],
+        class: row["class"],
+        status: row["status"],
+        description: row["description"],
+        why: row["why"],
+        source: row["source"],
+        primary_owner: row["primary_owner"],
+        supporting_slices: row["supporting_slices"],
+        validation: row["validation"],
+        notes: row["notes"],
+        full_content: row["full_content"],
         superseded_by: null,
     }));
 }
@@ -520,17 +535,19 @@ export function _resetProvider() {
  */
 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, superseded_by)
-     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :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,
-        ':superseded_by': d.superseded_by ?? null,
+        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, superseded_by)
+     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :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,
+        ":superseded_by": d.superseded_by ?? null,
     });
 }
 /**
@@ -538,21 +555,23 @@ export function upsertDecision(d) {
  */
 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({
-        ':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,
+        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,
     });
 }
 /**
@@ -568,7 +587,7 @@ export function clearArtifacts() {
     if (!currentDb)
         return;
     try {
-        currentDb.exec('DELETE FROM artifacts');
+        currentDb.exec("DELETE FROM artifacts");
     }
     catch {
         // Clearing a cache should never be fatal
@@ -576,15 +595,141 @@ export function clearArtifacts() {
 }
 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({
-        ':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(),
+        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(),
     });
 }
+// ─── Worktree DB Helpers ──────────────────────────────────────────────────
+export function copyWorktreeDb(srcDbPath, destDbPath) {
+    try {
+        if (!existsSync(srcDbPath))
+            return false;
+        const destDir = dirname(destDbPath);
+        mkdirSync(destDir, { recursive: true });
+        copyFileSync(srcDbPath, destDbPath);
+        return true;
+    }
+    catch (err) {
+        process.stderr.write(`gsd-db: failed to copy DB to worktree: ${err.message}\n`);
+        return false;
+    }
+}
+export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
+    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`);
+        return zero;
+    }
+    if (!currentDb) {
+        const opened = openDatabase(mainDbPath);
+        if (!opened) {
+            process.stderr.write(`gsd-db: worktree DB reconciliation failed: cannot open main DB\n`);
+            return zero;
+        }
+    }
+    const adapter = currentDb;
+    const conflicts = [];
+    try {
+        adapter.exec(`ATTACH DATABASE '${worktreeDbPath}' AS wt`);
+        try {
+            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 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();
+            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(`
+          INSERT OR REPLACE INTO decisions (
+            id, when_context, scope, decision, choice, rationale, revisable, superseded_by
+          )
+          SELECT
+            id, when_context, scope, decision, choice, rationale, revisable, 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
+          FROM wt.requirements
+        `)
+                    .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
+          FROM wt.artifacts
+        `)
+                    .run();
+                merged.artifacts =
+                    typeof aR === "object" && aR !== null
+                        ? (aR.changes ?? 0)
+                        : 0;
+                adapter.exec("COMMIT");
+            }
+            catch (txErr) {
+                try {
+                    adapter.exec("ROLLBACK");
+                }
+                catch {
+                    /* best-effort */
+                }
+                throw txErr;
+            }
+            return { ...merged, conflicts };
+        }
+        finally {
+            try {
+                adapter.exec("DETACH DATABASE wt");
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+    }
+    catch (err) {
+        process.stderr.write(`gsd-db: worktree DB reconciliation failed: ${err.message}\n`);
+        return { ...zero, conflicts };
+    }
+}