gsd-pi 2.50.0-dev.d210a87 → 2.51.0-dev.7d435fe

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

@@ -75,25 +75,34 @@ function normalizeRows(rows) {
 }
 function createAdapter(rawDb) {
     const db = rawDb;
+    const stmtCache = new Map();
+    function wrapStmt(raw) {
+        return {
+            run(...params) {
+                return raw.run(...params);
+            },
+            get(...params) {
+                return normalizeRow(raw.get(...params));
+            },
+            all(...params) {
+                return normalizeRows(raw.all(...params));
+            },
+        };
+    }
     return {
         exec(sql) {
             db.exec(sql);
         },
         prepare(sql) {
-            const stmt = db.prepare(sql);
-            return {
-                run(...params) {
-                    return stmt.run(...params);
-                },
-                get(...params) {
-                    return normalizeRow(stmt.get(...params));
-                },
-                all(...params) {
-                    return normalizeRows(stmt.all(...params));
-                },
-            };
+            let cached = stmtCache.get(sql);
+            if (cached)
+                return cached;
+            cached = wrapStmt(db.prepare(sql));
+            stmtCache.set(sql, cached);
+            return cached;
         },
         close() {
+            stmtCache.clear();
             db.close();
         },
     };
@@ -109,12 +118,21 @@ function openRawDb(path) {
     const Database = providerModule;
     return new Database(path);
 }
-const SCHEMA_VERSION = 12;
+const SCHEMA_VERSION = 14;
 function initSchema(db, fileBacked) {
     if (fileBacked)
         db.exec("PRAGMA journal_mode=WAL");
     if (fileBacked)
         db.exec("PRAGMA busy_timeout = 5000");
+    if (fileBacked)
+        db.exec("PRAGMA synchronous = NORMAL");
+    if (fileBacked)
+        db.exec("PRAGMA auto_vacuum = INCREMENTAL");
+    if (fileBacked)
+        db.exec("PRAGMA cache_size = -8000"); // 8 MB page cache
+    if (fileBacked)
+        db.exec("PRAGMA mmap_size = 67108864"); // 64 MB mmap
+    db.exec("PRAGMA temp_store = MEMORY");
     db.exec("PRAGMA foreign_keys = ON");
     db.exec("BEGIN");
     try {
@@ -226,7 +244,7 @@ function initSchema(db, fileBacked) {
         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
+        sequence INTEGER DEFAULT 0, -- Ordering hint: tools may set this to control execution order
         replan_triggered_at TEXT DEFAULT NULL,
         PRIMARY KEY (milestone_id, id),
         FOREIGN KEY (milestone_id) REFERENCES milestones(id)
@@ -258,7 +276,7 @@ function initSchema(db, fileBacked) {
         expected_output TEXT NOT NULL DEFAULT '[]',
         observability_impact TEXT NOT NULL DEFAULT '',
         full_plan_md TEXT NOT NULL DEFAULT '',
-        sequence INTEGER DEFAULT 0, -- DEAD CODE: no tool exposes sequence — always 0
+        sequence INTEGER DEFAULT 0, -- Ordering hint: tools may set this to control execution order
         PRIMARY KEY (milestone_id, slice_id, id),
         FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
       )
@@ -318,9 +336,28 @@ function initSchema(db, fileBacked) {
         PRIMARY KEY (milestone_id, slice_id, gate_id, task_id),
         FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
       )
+    `);
+        // Slice dependency junction table (v14)
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS slice_dependencies (
+        milestone_id TEXT NOT NULL,
+        slice_id TEXT NOT NULL,
+        depends_on_slice_id TEXT NOT NULL,
+        PRIMARY KEY (milestone_id, slice_id, depends_on_slice_id),
+        FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id),
+        FOREIGN KEY (milestone_id, depends_on_slice_id) REFERENCES slices(milestone_id, 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)");
+        // v13 indexes — hot-path dispatch queries
+        db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_active ON tasks(milestone_id, slice_id, status)");
+        db.exec("CREATE INDEX IF NOT EXISTS idx_slices_active ON slices(milestone_id, status)");
+        db.exec("CREATE INDEX IF NOT EXISTS idx_milestones_status ON milestones(status)");
+        db.exec("CREATE INDEX IF NOT EXISTS idx_quality_gates_pending ON quality_gates(milestone_id, slice_id, status)");
+        db.exec("CREATE INDEX IF NOT EXISTS idx_verification_evidence_task ON verification_evidence(milestone_id, slice_id, task_id)");
+        // v14 index — slice dependency lookups
+        db.exec("CREATE INDEX IF NOT EXISTS idx_slice_deps_target ON slice_dependencies(milestone_id, depends_on_slice_id)");
         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`);
@@ -599,6 +636,35 @@ function migrateSchema(db) {
                 ":applied_at": new Date().toISOString(),
             });
         }
+        if (currentVersion < 13) {
+            // Hot-path indexes for auto-loop dispatch queries
+            db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_active ON tasks(milestone_id, slice_id, status)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_slices_active ON slices(milestone_id, status)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_milestones_status ON milestones(status)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_quality_gates_pending ON quality_gates(milestone_id, slice_id, status)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_verification_evidence_task ON verification_evidence(milestone_id, slice_id, task_id)");
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 13,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
+        if (currentVersion < 14) {
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS slice_dependencies (
+          milestone_id TEXT NOT NULL,
+          slice_id TEXT NOT NULL,
+          depends_on_slice_id TEXT NOT NULL,
+          PRIMARY KEY (milestone_id, slice_id, depends_on_slice_id),
+          FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id),
+          FOREIGN KEY (milestone_id, depends_on_slice_id) REFERENCES slices(milestone_id, id)
+        )
+      `);
+            db.exec("CREATE INDEX IF NOT EXISTS idx_slice_deps_target ON slice_dependencies(milestone_id, depends_on_slice_id)");
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 14,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
         db.exec("COMMIT");
     }
     catch (err) {
@@ -655,6 +721,11 @@ export function closeDatabase() {
             currentDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
         }
         catch { /* non-fatal — best effort before close */ }
+        try {
+            // Incremental vacuum to reclaim space without blocking
+            currentDb.exec('PRAGMA incremental_vacuum(64)');
+        }
+        catch { /* non-fatal */ }
         try {
             currentDb.close();
         }
@@ -666,9 +737,31 @@ export function closeDatabase() {
         currentPid = 0;
     }
 }
+/** Run a full VACUUM — call sparingly (e.g. after milestone completion). */
+export function vacuumDatabase() {
+    if (!currentDb)
+        return;
+    try {
+        currentDb.exec('VACUUM');
+    }
+    catch { /* non-fatal */ }
+}
+let _txDepth = 0;
 export function transaction(fn) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    // Re-entrant: if already inside a transaction, just run fn() without
+    // starting a new one. SQLite does not support nested BEGIN/COMMIT.
+    if (_txDepth > 0) {
+        _txDepth++;
+        try {
+            return fn();
+        }
+        finally {
+            _txDepth--;
+        }
+    }
+    _txDepth++;
     currentDb.exec("BEGIN");
     try {
         const result = fn();
@@ -679,6 +772,9 @@ export function transaction(fn) {
         currentDb.exec("ROLLBACK");
         throw err;
     }
+    finally {
+        _txDepth--;
+    }
 }
 export function insertDecision(d) {
     if (!currentDb)
@@ -1112,6 +1208,16 @@ export function updateSliceStatus(milestoneId, sliceId, status, completedAt) {
         ":id": sliceId,
     });
 }
+export function setTaskSummaryMd(milestoneId, sliceId, taskId, md) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`UPDATE tasks SET full_summary_md = :md WHERE milestone_id = :mid AND slice_id = :sid AND id = :tid`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId, ":md": md });
+}
+export function setSliceSummaryMd(milestoneId, sliceId, summaryMd, uatMd) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`UPDATE slices SET full_summary_md = :summary_md, full_uat_md = :uat_md WHERE milestone_id = :mid AND id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId, ":summary_md": summaryMd, ":uat_md": uatMd });
+}
 function rowToTask(row) {
     return {
         milestone_id: row["milestone_id"],
@@ -1216,6 +1322,16 @@ export function getMilestone(id) {
         return null;
     return rowToMilestone(row);
 }
+/**
+ * Update a milestone's status in the database.
+ * Used by park/unpark to keep the DB in sync with the filesystem marker.
+ * See: https://github.com/gsd-build/gsd-2/issues/2694
+ */
+export function updateMilestoneStatus(milestoneId, status, completedAt) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`UPDATE milestones SET status = :status, completed_at = :completed_at WHERE id = :id`).run({ ":status": status, ":completed_at": completedAt ?? null, ":id": milestoneId });
+}
 export function getActiveMilestoneFromDb() {
     if (!currentDb)
         return null;
@@ -1227,18 +1343,22 @@ export function getActiveMilestoneFromDb() {
 export function getActiveSliceFromDb(milestoneId) {
     if (!currentDb)
         return null;
-    const rows = currentDb.prepare("SELECT * FROM slices WHERE milestone_id = :mid AND status NOT IN ('complete', 'done') ORDER BY sequence, id").all({ ":mid": milestoneId });
-    if (rows.length === 0)
+    // Single query: find the first non-complete slice whose dependencies are all satisfied.
+    // Uses json_each() to expand the JSON depends array and checks each dep is complete.
+    const row = currentDb.prepare(`SELECT s.* FROM slices s
+     WHERE s.milestone_id = :mid
+       AND s.status NOT IN ('complete', 'done')
+       AND NOT EXISTS (
+         SELECT 1 FROM json_each(s.depends) AS dep
+         WHERE dep.value NOT IN (
+           SELECT id FROM slices WHERE milestone_id = :mid AND status IN ('complete', 'done')
+         )
+       )
+     ORDER BY s.sequence, s.id
+     LIMIT 1`).get({ ":mid": milestoneId });
+    if (!row)
         return null;
-    const completedRows = currentDb.prepare("SELECT id FROM slices WHERE milestone_id = :mid AND status IN ('complete', 'done')").all({ ":mid": milestoneId });
-    const completedIds = new Set(completedRows.map((r) => r["id"]));
-    for (const row of rows) {
-        const slice = rowToSlice(row);
-        if (slice.depends.length === 0 || slice.depends.every((d) => completedIds.has(d))) {
-            return slice;
-        }
-    }
-    return null;
+    return rowToSlice(row);
 }
 export function getActiveTaskFromDb(milestoneId, sliceId) {
     if (!currentDb)
@@ -1262,6 +1382,60 @@ export function getArtifact(path) {
         return null;
     return rowToArtifact(row);
 }
+// ─── Lightweight Query Variants (hot-path optimized) ─────────────────────
+/** Fast milestone status check — avoids deserializing JSON planning fields. */
+export function getActiveMilestoneIdFromDb() {
+    if (!currentDb)
+        return null;
+    const row = currentDb.prepare("SELECT id, status FROM milestones WHERE status NOT IN ('complete', 'parked') ORDER BY id LIMIT 1").get();
+    if (!row)
+        return null;
+    return { id: row["id"], status: row["status"] };
+}
+/** Fast slice status check — avoids deserializing JSON depends/planning fields. */
+export function getSliceStatusSummary(milestoneId) {
+    if (!currentDb)
+        return [];
+    return currentDb.prepare("SELECT id, status FROM slices WHERE milestone_id = :mid ORDER BY sequence, id").all({ ":mid": milestoneId }).map((r) => ({ id: r["id"], status: r["status"] }));
+}
+/** Fast task status check — avoids deserializing JSON arrays and large text fields. */
+export function getActiveTaskIdFromDb(milestoneId, sliceId) {
+    if (!currentDb)
+        return null;
+    const row = currentDb.prepare("SELECT id, status, title 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 { id: row["id"], status: row["status"], title: row["title"] };
+}
+/** Count tasks by status for a slice — useful for progress reporting without full row load. */
+export function getSliceTaskCounts(milestoneId, sliceId) {
+    if (!currentDb)
+        return { total: 0, done: 0, pending: 0 };
+    const row = currentDb.prepare(`SELECT
+       COUNT(*) as total,
+       SUM(CASE WHEN status IN ('complete', 'done') THEN 1 ELSE 0 END) as done,
+       SUM(CASE WHEN status NOT IN ('complete', 'done') THEN 1 ELSE 0 END) as pending
+     FROM tasks WHERE milestone_id = :mid AND slice_id = :sid`).get({ ":mid": milestoneId, ":sid": sliceId });
+    if (!row)
+        return { total: 0, done: 0, pending: 0 };
+    return { total: row["total"] ?? 0, done: row["done"] ?? 0, pending: row["pending"] ?? 0 };
+}
+// ─── Slice Dependencies (junction table) ─────────────────────────────────
+/** Sync the slice_dependencies junction table from a slice's JSON depends array. */
+export function syncSliceDependencies(milestoneId, sliceId, depends) {
+    if (!currentDb)
+        return;
+    currentDb.prepare("DELETE FROM slice_dependencies WHERE milestone_id = :mid AND slice_id = :sid").run({ ":mid": milestoneId, ":sid": sliceId });
+    for (const dep of depends) {
+        currentDb.prepare("INSERT OR IGNORE INTO slice_dependencies (milestone_id, slice_id, depends_on_slice_id) VALUES (:mid, :sid, :dep)").run({ ":mid": milestoneId, ":sid": sliceId, ":dep": dep });
+    }
+}
+/** Get all slices that depend on a given slice. */
+export function getDependentSlices(milestoneId, sliceId) {
+    if (!currentDb)
+        return [];
+    return currentDb.prepare("SELECT slice_id FROM slice_dependencies WHERE milestone_id = :mid AND depends_on_slice_id = :sid").all({ ":mid": milestoneId, ":sid": sliceId }).map((r) => r["slice_id"]);
+}
 // ─── Worktree DB Helpers ──────────────────────────────────────────────────
 export function copyWorktreeDb(srcDbPath, destDbPath) {
     try {
@@ -1278,10 +1452,13 @@ export function copyWorktreeDb(srcDbPath, destDbPath) {
     }
 }
 export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
-    const zero = { decisions: 0, requirements: 0, artifacts: 0, conflicts: [] };
+    const zero = { decisions: 0, requirements: 0, artifacts: 0, milestones: 0, slices: 0, tasks: 0, memories: 0, verification_evidence: 0, conflicts: [] };
     if (!existsSync(worktreeDbPath))
         return zero;
-    if (worktreeDbPath.includes("'")) {
+    // Sanitize path: reject any characters that could break ATTACH syntax.
+    // ATTACH DATABASE doesn't support parameterized paths in all providers,
+    // so we use strict allowlist validation instead.
+    if (/['";\x00]/.test(worktreeDbPath)) {
         process.stderr.write("gsd-db: worktree DB reconciliation failed: path contains unsafe characters\n");
         return zero;
     }
@@ -1305,17 +1482,19 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
             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 };
+            const merged = { decisions: 0, requirements: 0, artifacts: 0, milestones: 0, slices: 0, tasks: 0, memories: 0, verification_evidence: 0 };
+            function countChanges(result) {
+                return typeof result === "object" && result !== null ? (result.changes ?? 0) : 0;
+            }
             adapter.exec("BEGIN");
             try {
-                const dR = adapter.prepare(`
+                merged.decisions = countChanges(adapter.prepare(`
           INSERT OR REPLACE INTO decisions (
             id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by
           )
           SELECT id, when_context, scope, decision, choice, rationale, revisable, ${hasMadeBy ? "made_by" : "'agent'"}, superseded_by FROM wt.decisions
-        `).run();
-                merged.decisions = typeof dR === "object" && dR !== null ? (dR.changes ?? 0) : 0;
-                const rR = adapter.prepare(`
+        `).run());
+                merged.requirements = countChanges(adapter.prepare(`
           INSERT OR REPLACE INTO requirements (
             id, class, status, description, why, source, primary_owner,
             supporting_slices, validation, notes, full_content, superseded_by
@@ -1323,16 +1502,74 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
           SELECT id, class, status, description, why, source, primary_owner,
                  supporting_slices, validation, notes, full_content, superseded_by
           FROM wt.requirements
-        `).run();
-                merged.requirements = typeof rR === "object" && rR !== null ? (rR.changes ?? 0) : 0;
-                const aR = adapter.prepare(`
+        `).run());
+                merged.artifacts = countChanges(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;
+        `).run());
+                // Merge milestones — worktree may have updated status/planning fields
+                merged.milestones = countChanges(adapter.prepare(`
+          INSERT OR REPLACE INTO milestones (
+            id, title, status, depends_on, created_at, completed_at,
+            vision, success_criteria, key_risks, proof_strategy,
+            verification_contract, verification_integration, verification_operational, verification_uat,
+            definition_of_done, requirement_coverage, boundary_map_markdown
+          )
+          SELECT id, title, status, depends_on, created_at, completed_at,
+                 vision, success_criteria, key_risks, proof_strategy,
+                 verification_contract, verification_integration, verification_operational, verification_uat,
+                 definition_of_done, requirement_coverage, boundary_map_markdown
+          FROM wt.milestones
+        `).run());
+                // Merge slices — preserve worktree progress (status, summaries, planning)
+                merged.slices = countChanges(adapter.prepare(`
+          INSERT OR REPLACE INTO slices (
+            milestone_id, id, title, status, risk, depends, demo, created_at, completed_at,
+            full_summary_md, full_uat_md, goal, success_criteria, proof_level,
+            integration_closure, observability_impact, sequence, replan_triggered_at
+          )
+          SELECT milestone_id, id, title, status, risk, depends, demo, created_at, completed_at,
+                 full_summary_md, full_uat_md, goal, success_criteria, proof_level,
+                 integration_closure, observability_impact, sequence, replan_triggered_at
+          FROM wt.slices
+        `).run());
+                // Merge tasks — preserve execution results, status, summaries
+                merged.tasks = countChanges(adapter.prepare(`
+          INSERT OR REPLACE 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, full_plan_md, sequence
+          )
+          SELECT 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, full_plan_md, sequence
+          FROM wt.tasks
+        `).run());
+                // Merge memories — keep worktree-learned insights
+                merged.memories = countChanges(adapter.prepare(`
+          INSERT OR REPLACE INTO memories (
+            seq, id, category, content, confidence, source_unit_type, source_unit_id,
+            created_at, updated_at, superseded_by, hit_count
+          )
+          SELECT seq, id, category, content, confidence, source_unit_type, source_unit_id,
+                 created_at, updated_at, superseded_by, hit_count
+          FROM wt.memories
+        `).run());
+                // Merge verification evidence — append-only, use INSERT OR IGNORE to avoid duplicates
+                merged.verification_evidence = countChanges(adapter.prepare(`
+          INSERT OR IGNORE INTO verification_evidence (
+            task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at
+          )
+          SELECT task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at
+          FROM wt.verification_evidence
+        `).run());
                 adapter.exec("COMMIT");
             }
             catch (txErr) {
@@ -1388,20 +1625,36 @@ export function insertAssessment(entry) {
         ":created_at": new Date().toISOString(),
     });
 }
-export function deleteTask(milestoneId, sliceId, taskId) {
+export function deleteAssessmentByScope(milestoneId, scope) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`DELETE FROM assessments WHERE milestone_id = :mid AND scope = :scope`).run({ ":mid": milestoneId, ":scope": scope });
+}
+export function deleteVerificationEvidence(milestoneId, sliceId, taskId) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    // Must delete verification_evidence first (FK constraint)
     currentDb.prepare(`DELETE FROM verification_evidence WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
-    currentDb.prepare(`DELETE FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND id = :tid`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
+}
+export function deleteTask(milestoneId, sliceId, taskId) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    transaction(() => {
+        // Must delete verification_evidence first (FK constraint)
+        currentDb.prepare(`DELETE FROM verification_evidence WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
+        currentDb.prepare(`DELETE FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND id = :tid`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
+    });
 }
 export function deleteSlice(milestoneId, sliceId) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    // Cascade-style manual deletion: evidence → tasks → slice
-    currentDb.prepare(`DELETE FROM verification_evidence WHERE milestone_id = :mid AND slice_id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId });
-    currentDb.prepare(`DELETE FROM tasks WHERE milestone_id = :mid AND slice_id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId });
-    currentDb.prepare(`DELETE FROM slices WHERE milestone_id = :mid AND id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId });
+    transaction(() => {
+        // Cascade-style manual deletion: evidence → tasks → dependencies → 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 slice_dependencies WHERE milestone_id = :mid AND slice_id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId });
+        currentDb.prepare(`DELETE FROM slice_dependencies WHERE milestone_id = :mid AND depends_on_slice_id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId });
+        currentDb.prepare(`DELETE FROM slices WHERE milestone_id = :mid AND id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId });
+    });
 }
 export function updateSliceFields(milestoneId, sliceId, fields) {
     if (!currentDb)

package/dist/resources/extensions/gsd/init-wizard.js

@@ -336,9 +336,9 @@ function bootstrapGsdDirectory(basePath, prefs, signals) {
     assertSafeDirectory(basePath);
     const gsd = gsdRoot(basePath);
     mkdirSync(join(gsd, "milestones"), { recursive: true });
-    // Write preferences.md from wizard answers
+    // Write PREFERENCES.md from wizard answers
     const preferencesContent = buildPreferencesFile(prefs);
-    writeFileSync(join(gsd, "preferences.md"), preferencesContent, "utf-8");
+    writeFileSync(join(gsd, "PREFERENCES.md"), preferencesContent, "utf-8");
     // Seed CONTEXT.md with detected project signals
     const contextContent = buildContextSeed(signals);
     if (contextContent) {

package/dist/resources/extensions/gsd/key-manager.js

@@ -110,21 +110,12 @@ export function findProvider(idOrLabel) {
  */
 export function getAllKeyStatuses(auth) {
     return PROVIDER_REGISTRY.map((provider) => {
-        const creds = auth.getCredentialsForProvider(provider.id);
+        const rawCreds = auth.getCredentialsForProvider(provider.id);
+        // Filter out empty-key entries (left by legacy removeProviderToken or skipped onboarding)
+        const creds = rawCreds.filter((c) => !(c.type === "api_key" && !c.key));
         const envKey = provider.envVar ? process.env[provider.envVar] : undefined;
         if (creds.length > 0) {
             const firstCred = creds[0];
-            // Skip empty keys (from skipped onboarding)
-            if (firstCred.type === "api_key" && !firstCred.key) {
-                return {
-                    provider,
-                    configured: false,
-                    source: "none",
-                    credentialCount: 0,
-                    description: "empty key (skipped setup)",
-                    backedOff: false,
-                };
-            }
             const desc = creds.length > 1
                 ? `${creds.length} keys (round-robin)`
                 : describeCredential(firstCred);
@@ -222,7 +213,7 @@ export async function handleAddKey(providerArg, ctx, auth) {
     else {
         // Interactive provider picker
         const options = PROVIDER_REGISTRY.map((p) => {
-            const creds = auth.getCredentialsForProvider(p.id);
+            const creds = auth.getCredentialsForProvider(p.id).filter((c) => !(c.type === "api_key" && !c.key));
             const existing = creds.length > 0 ? " (configured)" : "";
             return `[${p.category}] ${p.label}${existing}`;
         });
@@ -285,7 +276,7 @@ export async function handleRemoveKey(providerArg, ctx, auth) {
     else {
         // Show only configured providers
         const configured = PROVIDER_REGISTRY.filter((p) => {
-            const creds = auth.getCredentialsForProvider(p.id);
+            const creds = auth.getCredentialsForProvider(p.id).filter((c) => !(c.type === "api_key" && !c.key));
             return creds.length > 0;
         });
         if (configured.length === 0) {
@@ -508,7 +499,7 @@ export async function handleRotateKey(providerArg, ctx, auth) {
         // Show only configured API key providers
         const configured = PROVIDER_REGISTRY.filter((p) => {
             const creds = auth.getCredentialsForProvider(p.id);
-            return creds.some((c) => c.type === "api_key");
+            return creds.some((c) => c.type === "api_key" && c.key);
         });
         if (configured.length === 0) {
             ctx.ui.notify("No API keys configured to rotate.", "info");
@@ -646,7 +637,7 @@ export function runKeyDoctor(auth) {
         if (!envValue)
             continue;
         const creds = auth.getCredentialsForProvider(provider.id);
-        const apiKey = creds.find((c) => c.type === "api_key");
+        const apiKey = creds.find((c) => c.type === "api_key" && c.key);
         if (apiKey?.key && apiKey.key !== envValue) {
             findings.push({
                 severity: "warning",

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

@@ -71,6 +71,9 @@ export function getActiveMemoriesRanked(limit = 30) {
 /**
  * Generate the next memory ID: MEM + zero-padded 3-digit from MAX(seq).
  * Returns MEM001 if no memories exist.
+ *
+ * NOTE: For race-safe creation, prefer createMemory() which inserts with a
+ * placeholder ID then updates to the seq-derived ID atomically.
  */
 export function nextMemoryId() {
     if (!isDbAvailable())
@@ -94,7 +97,9 @@ export function nextMemoryId() {
 }
 // ─── Mutation Functions ─────────────────────────────────────────────────────
 /**
- * Insert a new memory with auto-assigned ID.
+ * Insert a new memory with a race-safe auto-assigned ID.
+ * Uses AUTOINCREMENT seq to derive the ID after insert, avoiding
+ * the read-then-write race in concurrent scenarios (e.g. worktrees).
  * Returns the assigned ID, or null on failure.
  */
 export function createMemory(fields) {
@@ -104,11 +109,12 @@ export function createMemory(fields) {
     if (!adapter)
         return null;
     try {
-        const id = nextMemoryId();
         const now = new Date().toISOString();
+        // Insert with a temporary placeholder ID — seq is auto-assigned
+        const placeholder = `_TMP_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
         adapter.prepare(`INSERT INTO memories (id, category, content, confidence, source_unit_type, source_unit_id, created_at, updated_at)
        VALUES (:id, :category, :content, :confidence, :source_unit_type, :source_unit_id, :created_at, :updated_at)`).run({
-            ':id': id,
+            ':id': placeholder,
             ':category': fields.category,
             ':content': fields.content,
             ':confidence': fields.confidence ?? 0.8,
@@ -117,7 +123,17 @@ export function createMemory(fields) {
             ':created_at': now,
             ':updated_at': now,
         });
-        return id;
+        // Derive the real ID from the assigned seq
+        const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
+        if (!row)
+            return placeholder; // fallback — should not happen
+        const seq = row['seq'];
+        const realId = `MEM${String(seq).padStart(3, '0')}`;
+        adapter.prepare('UPDATE memories SET id = :real_id WHERE id = :placeholder').run({
+            ':real_id': realId,
+            ':placeholder': placeholder,
+        });
+        return realId;
     }
     catch {
         return null;
@@ -258,15 +274,14 @@ export function enforceMemoryCap(max = 50) {
         if (count <= max)
             return;
         const excess = count - max;
-        // Find the IDs of the lowest-ranked active memories
-        const rows = adapter.prepare(`SELECT id FROM memories
-       WHERE superseded_by IS NULL
-       ORDER BY (confidence * (1.0 + hit_count * 0.1)) ASC
-       LIMIT :limit`).all({ ':limit': excess });
-        const now = new Date().toISOString();
-        for (const row of rows) {
-            adapter.prepare('UPDATE memories SET superseded_by = :reason, updated_at = :now WHERE id = :id').run({ ':reason': 'CAP_EXCEEDED', ':now': now, ':id': row['id'] });
-        }
+        // Batch update: supersede lowest-ranked active memories in a single statement
+        adapter.prepare(`UPDATE memories SET superseded_by = 'CAP_EXCEEDED', updated_at = :now
+       WHERE id IN (
+         SELECT id FROM memories
+         WHERE superseded_by IS NULL
+         ORDER BY (confidence * (1.0 + hit_count * 0.1)) ASC
+         LIMIT :limit
+       )`).run({ ':now': new Date().toISOString(), ':limit': excess });
     }
     catch {
         // non-fatal