gsd-pi 2.51.0 → 2.52.0-dev.655ad8a

package/dist/resources/extensions/gsd/error-classifier.js

@@ -0,0 +1,105 @@
+/**
+ * Unified error classifier for provider/network/server errors.
+ *
+ * Consolidates patterns from:
+ *  - isTransientNetworkError()  in preferences-models.ts
+ *  - classifyProviderError()    in provider-error-pause.ts
+ *
+ * Single entry point: classifyError(errorMsg, retryAfterMs?)
+ *
+ * @see https://github.com/gsd-build/gsd/issues/2577
+ */
+export function createRetryState() {
+    return { networkRetryCount: 0, consecutiveTransientCount: 0, currentRetryModelId: undefined };
+}
+export function resetRetryState(state) {
+    state.networkRetryCount = 0;
+    state.consecutiveTransientCount = 0;
+    state.currentRetryModelId = undefined;
+}
+// ── Classification ──────────────────────────────────────────────────────────
+const PERMANENT_RE = /auth|unauthorized|forbidden|invalid.*key|invalid.*api|billing|quota exceeded|account/i;
+const RATE_LIMIT_RE = /rate.?limit|too many requests|429/i;
+const NETWORK_RE = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fetch failed|connection.*reset|dns/i;
+const SERVER_RE = /internal server error|500|502|503|overloaded|server_error|api_error|service.?unavailable/i;
+// ECONNRESET/ECONNREFUSED are in NETWORK_RE (same-model retry first).
+const CONNECTION_RE = /terminated|connection.?refused|other side closed|EPIPE|network.?(?:is\s+)?unavailable|stream_exhausted(?:_without_result)?/i;
+const STREAM_RE = /Unexpected end of JSON|Unexpected token.*JSON|Expected double-quoted property name|SyntaxError.*JSON/i;
+const RESET_DELAY_RE = /reset in (\d+)s/i;
+/**
+ * Classify an error message into one of the ErrorClass kinds.
+ *
+ * Classification order:
+ *  1. Permanent (auth/billing/quota) — unless also rate-limited
+ *  2. Rate limit (429, rate.?limit, too many requests)
+ *  3. Network (ECONNRESET, ETIMEDOUT, socket hang up, fetch failed, dns)
+ *  4. Server (500/502/503, overloaded, server_error)
+ *  5. Connection (terminated, ECONNREFUSED, EPIPE, other side closed)
+ *  6. Stream truncation (malformed JSON from mid-stream cut)
+ *  7. Unknown
+ */
+export function classifyError(errorMsg, retryAfterMs) {
+    const isPermanent = PERMANENT_RE.test(errorMsg);
+    const isRateLimit = RATE_LIMIT_RE.test(errorMsg);
+    // 1. Permanent — but rate limit takes precedence
+    if (isPermanent && !isRateLimit) {
+        return { kind: "permanent" };
+    }
+    // 2. Rate limit
+    if (isRateLimit) {
+        if (retryAfterMs != null && retryAfterMs > 0) {
+            return { kind: "rate-limit", retryAfterMs };
+        }
+        const resetMatch = errorMsg.match(RESET_DELAY_RE);
+        const delayMs = resetMatch ? Number(resetMatch[1]) * 1000 : 60_000;
+        return { kind: "rate-limit", retryAfterMs: delayMs };
+    }
+    // 3. Network errors — same-model retry candidate
+    if (NETWORK_RE.test(errorMsg)) {
+        // Exclude if also matches permanent signals (already handled above for
+        // rate-limit, but double-check for non-rate-limit permanent overlap like
+        // "billing" appearing alongside "network").
+        return { kind: "network", retryAfterMs: retryAfterMs ?? 3_000 };
+    }
+    // 4. Server errors — try fallback model
+    if (SERVER_RE.test(errorMsg)) {
+        return { kind: "server", retryAfterMs: retryAfterMs ?? 30_000 };
+    }
+    // 5. Connection errors — try fallback model
+    if (CONNECTION_RE.test(errorMsg)) {
+        return { kind: "connection", retryAfterMs: retryAfterMs ?? 15_000 };
+    }
+    // 6. Stream truncation — downstream symptom of connection drop
+    if (STREAM_RE.test(errorMsg)) {
+        return { kind: "stream", retryAfterMs: retryAfterMs ?? 15_000 };
+    }
+    // 7. Unknown
+    return { kind: "unknown" };
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+/** Returns true for all transient (auto-resumable) error kinds. */
+export function isTransient(cls) {
+    switch (cls.kind) {
+        case "network":
+        case "rate-limit":
+        case "server":
+        case "stream":
+        case "connection":
+            return true;
+        default:
+            return false;
+    }
+}
+/**
+ * Backward-compatible thin wrapper.
+ *
+ * Returns true when the error is a transient *network* error specifically
+ * (worth retrying the same model). Permanent signals (auth, billing, quota)
+ * cause this to return false even if a network keyword is present.
+ */
+export function isTransientNetworkError(errorMsg) {
+    if (!errorMsg)
+        return false;
+    const cls = classifyError(errorMsg);
+    return cls.kind === "network";
+}

package/dist/resources/extensions/gsd/git-service.js

@@ -446,11 +446,12 @@ export class GitServiceImpl {
     }
     /**
      * Create a snapshot ref for the given label (typically a slice branch name).
-     * Gated on prefs.snapshots === true. Ref path: refs/gsd/snapshots/<label>/<timestamp>
+     * Enabled by default; opt out with prefs.snapshots === false.
+     * Ref path: refs/gsd/snapshots/<label>/<timestamp>
      * The ref points at HEAD, capturing the current commit before destructive operations.
      */
     createSnapshot(label) {
-        if (this.prefs.snapshots !== true)
+        if (this.prefs.snapshots === false)
             return;
         const now = new Date();
         const ts = now.getFullYear().toString()
@@ -470,7 +471,7 @@ export class GitServiceImpl {
      * Stub: to be implemented in T03.
      */
     runPreMergeCheck() {
-        if (this.prefs.pre_merge_check === false || this.prefs.pre_merge_check === undefined) {
+        if (this.prefs.pre_merge_check === false) {
             return { passed: true, skipped: true };
         }
         // Determine command: explicit string or auto-detect from package.json

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

@@ -1,8 +1,8 @@
 /**
- * GSD bootstrappers for .gitignore and preferences.md
+ * GSD bootstrappers for .gitignore and PREFERENCES.md
  *
  * Ensures baseline .gitignore exists with universally-correct patterns.
- * Creates an empty preferences.md template if it doesn't exist.
+ * Creates an empty PREFERENCES.md template if it doesn't exist.
  * Both idempotent — non-destructive if already present.
  */
 import { join } from "node:path";
@@ -190,16 +190,16 @@ export function untrackRuntimeFiles(basePath) {
     }
 }
 /**
- * Ensure basePath/.gsd/preferences.md exists as an empty template.
+ * Ensure basePath/.gsd/PREFERENCES.md exists as an empty template.
  * Creates the file with frontmatter only if it doesn't exist.
  * Returns true if created, false if already exists.
  *
- * Checks both lowercase (canonical) and uppercase (legacy) to avoid
- * creating a duplicate when an uppercase file already exists.
+ * Checks both uppercase (canonical) and lowercase (legacy) to avoid
+ * creating a duplicate when a lowercase file already exists.
  */
 export function ensurePreferences(basePath) {
-    const preferencesPath = join(gsdRoot(basePath), "preferences.md");
-    const legacyPath = join(gsdRoot(basePath), "PREFERENCES.md");
+    const preferencesPath = join(gsdRoot(basePath), "PREFERENCES.md");
+    const legacyPath = join(gsdRoot(basePath), "preferences.md");
     if (existsSync(preferencesPath) || existsSync(legacyPath)) {
         return false;
     }

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)