gsd-pi 2.73.1 → 2.74.0-dev.b741afb

package/dist/resources/extensions/gsd/preferences-models.js

@@ -6,6 +6,8 @@
  * and dynamic routing configuration.
  */
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import { defaultRoutingConfig } from "./model-router.js";
 import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
 /**
@@ -161,6 +163,47 @@ export function resolveDefaultSessionModel(sessionProvider) {
     }
     return undefined;
 }
+/**
+ * Returns true if `provider` is defined as a custom provider in the user's
+ * `~/.gsd/agent/models.json` (Ollama, vLLM, LM Studio, OpenAI-compatible
+ * proxies, etc.).
+ *
+ * Used by auto-mode bootstrap to decide whether the session model
+ * (set via `/gsd model`) should override `PREFERENCES.md`.  Custom providers
+ * are never reachable from `PREFERENCES.md` (which only knows built-in
+ * providers), so when the user has explicitly selected one, it must take
+ * priority — otherwise auto-mode tries to start the built-in provider from
+ * PREFERENCES.md and fails with "Not logged in · Please run /login" (#4122).
+ *
+ * Reads models.json directly with a lightweight JSON parse to avoid
+ * pulling in the full model-registry at this call site.  Falls back to
+ * `~/.pi/agent/models.json` for parity with `resolveModelsJsonPath()`.
+ * Any read or parse error yields `false` (treat as not-custom) so a
+ * malformed models.json never breaks the session bootstrap.
+ */
+export function isCustomProvider(provider) {
+    if (!provider)
+        return false;
+    const candidates = [
+        join(homedir(), ".gsd", "agent", "models.json"),
+        join(homedir(), ".pi", "agent", "models.json"),
+    ];
+    for (const path of candidates) {
+        if (!existsSync(path))
+            continue;
+        try {
+            const raw = readFileSync(path, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed?.providers && Object.prototype.hasOwnProperty.call(parsed.providers, provider)) {
+                return true;
+            }
+        }
+        catch {
+            // Ignore — malformed models.json must not break bootstrap.
+        }
+    }
+    return false;
+}
 /**
  * Determines the next fallback model to try when the current model fails.
  * If the current model is not in the configured list, returns the primary model.

package/dist/resources/extensions/gsd/preferences-types.js

@@ -83,6 +83,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "discuss_preparation",
     "discuss_web_research",
     "discuss_depth",
+    "flat_rate_providers",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -155,6 +155,28 @@ export function validatePreferences(preferences) {
             errors.push(`search_provider must be one of: brave, tavily, ollama, native, auto`);
         }
     }
+    // ─── Flat-rate Providers ────────────────────────────────────────────
+    // User-declared flat-rate providers for dynamic routing suppression.
+    // Built-in providers (github-copilot, copilot, claude-code) and any
+    // externalCli provider are already auto-detected; this list layers on
+    // top for private subscription proxies and custom CLI wrappers.
+    if (preferences.flat_rate_providers !== undefined) {
+        if (Array.isArray(preferences.flat_rate_providers)) {
+            const allStrings = preferences.flat_rate_providers.every((item) => typeof item === "string");
+            if (allStrings) {
+                // Strip empty/whitespace-only entries to avoid false matches.
+                validated.flat_rate_providers = preferences.flat_rate_providers
+                    .map((s) => s.trim())
+                    .filter((s) => s.length > 0);
+            }
+            else {
+                errors.push("flat_rate_providers must be an array of strings");
+            }
+        }
+        else {
+            errors.push("flat_rate_providers must be an array of strings");
+        }
+    }
     // ─── Phase Skip Preferences ─────────────────────────────────────────
     if (preferences.phases !== undefined) {
         if (typeof preferences.phases === "object" && preferences.phases !== null) {

package/dist/resources/extensions/gsd/prompts/add-tests.md

@@ -0,0 +1,35 @@
+You are generating tests for recently completed GSD work.
+
+## Slice: {{sliceId}} — {{sliceTitle}}
+
+### Summary
+
+{{sliceSummary}}
+
+### Existing Test Patterns
+
+{{existingTestPatterns}}
+
+## Working Directory
+
+`{{workingDirectory}}`
+
+## Instructions
+
+1. Read the slice summary above to understand what was built
+2. Identify the source files that were created or modified for this slice
+3. Read the implementation code to understand behavior, edge cases, and error paths
+4. Write comprehensive tests following the project's existing test patterns and framework
+5. Run the tests to verify they pass
+6. Fix any failures
+
+### Rules
+
+- Follow the project's existing test patterns (framework, assertions, file structure)
+- Test behavior, not implementation details
+- Cover: happy path, edge cases, error conditions, boundary values
+- Do NOT modify implementation files — only create or update test files
+- Name test files consistently with the project's conventions
+- Keep tests focused and readable
+
+{{skillActivation}}

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

@@ -271,7 +271,11 @@ function reconcileDiskToDb(basePath) {
         try {
             roadmapContent = readFileSync(roadmapPath, "utf-8");
         }
-        catch {
+        catch (err) {
+            logWarning("state", "reconcileDiskToDb: roadmap read failed, skipping milestone", {
+                mid,
+                error: err.message,
+            });
             continue;
         }
         const parsed = parseRoadmap(roadmapContent);
@@ -312,6 +316,10 @@ function reconcileDiskToDb(basePath) {
 function buildCompletenessSet(basePath, milestones) {
     const completeMilestoneIds = new Set();
     const parkedMilestoneIds = new Set();
+    // DB-authoritative: a milestone is only "complete" when its DB row says so.
+    // SUMMARY-file presence is NOT a completion signal here — an orphan SUMMARY
+    // (crashed complete-milestone turn, partial merge, manual edit) must not
+    // flip derived state to complete and cascade into a false auto-merge (#4179).
     for (const m of milestones) {
         const parkedFile = resolveMilestoneFile(basePath, m.id, "PARKED");
         if (parkedFile || m.status === 'parked') {
@@ -322,11 +330,6 @@ function buildCompletenessSet(basePath, milestones) {
             completeMilestoneIds.add(m.id);
             continue;
         }
-        const summaryFile = resolveMilestoneFile(basePath, m.id, "SUMMARY");
-        if (summaryFile) {
-            completeMilestoneIds.add(m.id);
-            continue;
-        }
     }
     return { completeMilestoneIds, parkedMilestoneIds };
 }
@@ -347,17 +350,22 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
             if (isGhostMilestone(basePath, m.id))
                 continue;
         }
-        const summaryFile = resolveMilestoneFile(basePath, m.id, "SUMMARY");
-        if (completeMilestoneIds.has(m.id) || (summaryFile !== null)) {
+        // DB-authoritative completeness (#4179): only trust completeMilestoneIds,
+        // which is itself derived from DB status. SUMMARY-file presence alone must
+        // not imply completion. The summary file may still be consulted below as a
+        // title source for legitimately-complete milestones whose DB row has no title.
+        if (completeMilestoneIds.has(m.id)) {
             let title = stripMilestonePrefix(m.title) || m.id;
-            if (summaryFile && !m.title) {
-                const summaryContent = await loadFile(summaryFile);
-                if (summaryContent) {
-                    title = parseSummary(summaryContent).title || m.id;
+            if (!m.title) {
+                const summaryFile = resolveMilestoneFile(basePath, m.id, "SUMMARY");
+                if (summaryFile) {
+                    const summaryContent = await loadFile(summaryFile);
+                    if (summaryContent) {
+                        title = parseSummary(summaryContent).title || m.id;
+                    }
                 }
             }
             registry.push({ id: m.id, title, status: 'complete' });
-            completeMilestoneIds.add(m.id);
             continue;
         }
         const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
@@ -391,7 +399,14 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
                 const validationFile = resolveMilestoneFile(basePath, m.id, "VALIDATION");
                 const validationContent = validationFile ? await loadFile(validationFile) : null;
                 const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
-                if (!validationTerminal || (validationTerminal && !summaryFile)) {
+                // DB-authoritative (#4179): completeness is already decided by
+                // completeMilestoneIds above. If we reached this branch, the DB says
+                // the milestone is NOT complete — so any SUMMARY file on disk is an
+                // orphan (crashed complete-milestone, partial merge, manual edit) and
+                // must not short-circuit this path. When validation is terminal, fall
+                // through to the default active-push below so `complete-milestone` can
+                // re-run idempotently.
+                if (!validationTerminal) {
                     activeMilestone = { id: m.id, title };
                     activeMilestoneSlices = slices;
                     activeMilestoneFound = true;
@@ -516,6 +531,9 @@ function resolveSliceDependencies(activeMilestoneSlices) {
             return { activeSlice: null, activeSliceRow: null };
         }
     }
+    // First pass: find a slice with ALL dependencies satisfied (strict)
+    let bestFallback = null;
+    let bestFallbackSatisfied = -1;
     for (const s of activeMilestoneSlices) {
         if (isStatusDone(s.status))
             continue;
@@ -524,6 +542,23 @@ function resolveSliceDependencies(activeMilestoneSlices) {
         if (s.depends.every(dep => doneSliceIds.has(dep))) {
             return { activeSlice: { id: s.id, title: s.title }, activeSliceRow: s };
         }
+        // Track the slice with the most satisfied dependencies as fallback
+        const satisfied = s.depends.filter(dep => doneSliceIds.has(dep)).length;
+        if (satisfied > bestFallbackSatisfied || (satisfied === bestFallbackSatisfied && !bestFallback)) {
+            bestFallback = s;
+            bestFallbackSatisfied = satisfied;
+        }
+    }
+    // Fallback: if no slice has all deps met but there ARE incomplete non-deferred
+    // slices, pick the one with the most deps satisfied. This prevents hard-blocking
+    // when dependency metadata is stale (e.g. after reassessment added/removed slices)
+    // or when deps reference slices from previous milestones.
+    if (bestFallback) {
+        const unmet = bestFallback.depends.filter(dep => !doneSliceIds.has(dep));
+        logWarning("state", `No slice has all deps satisfied — falling back to ${bestFallback.id} ` +
+            `(${bestFallbackSatisfied}/${bestFallback.depends.length} deps met, ` +
+            `unmet: ${unmet.join(", ")})`, { mid: activeMilestoneSlices[0]?.milestone_id, sid: bestFallback.id });
+        return { activeSlice: { id: bestFallback.id, title: bestFallback.title }, activeSliceRow: bestFallback };
     }
     return { activeSlice: null, activeSliceRow: null };
 }
@@ -567,7 +602,7 @@ async function reconcileSliceTasks(basePath, milestoneId, sliceId, planFile) {
         const summaryPath = resolveTaskFile(basePath, milestoneId, sliceId, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
             try {
-                updateTaskStatus(milestoneId, sliceId, t.id, "complete");
+                updateTaskStatus(milestoneId, sliceId, t.id, "complete", new Date().toISOString());
                 logWarning("reconcile", `task ${milestoneId}/${sliceId}/${t.id} status reconciled from "${t.status}" to "complete" (#2514)`, { mid: milestoneId, sid: sliceId, tid: t.id });
                 reconciled = true;
             }
@@ -1269,6 +1304,8 @@ export async function _deriveStateImpl(basePath) {
         }
     }
     else {
+        let bestFallbackLegacy = null;
+        let bestFallbackLegacySatisfied = -1;
         for (const s of activeRoadmap.slices) {
             if (s.done)
                 continue;
@@ -1276,6 +1313,20 @@ export async function _deriveStateImpl(basePath) {
                 activeSlice = { id: s.id, title: s.title };
                 break;
             }
+            // Track best fallback
+            const satisfied = s.depends.filter(dep => doneSliceIds.has(dep)).length;
+            if (satisfied > bestFallbackLegacySatisfied) {
+                bestFallbackLegacy = s;
+                bestFallbackLegacySatisfied = satisfied;
+            }
+        }
+        // Fallback: if no slice has all deps met, pick the one with the most deps satisfied
+        if (!activeSlice && bestFallbackLegacy) {
+            const unmet = bestFallbackLegacy.depends.filter(dep => !doneSliceIds.has(dep));
+            logWarning("state", `No slice has all deps satisfied — falling back to ${bestFallbackLegacy.id} ` +
+                `(${bestFallbackLegacySatisfied}/${bestFallbackLegacy.depends.length} deps met, ` +
+                `unmet: ${unmet.join(", ")})`);
+            activeSlice = { id: bestFallbackLegacy.id, title: bestFallbackLegacy.title };
         }
     }
     if (!activeSlice) {

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -354,6 +354,21 @@ export async function handleCompleteSlice(params, basePath) {
     catch (eventErr) {
         logError("tool", `complete-slice event log FAILED — completion invisible to reconciliation`, { error: eventErr.message });
     }
+    // Fire-and-forget graph rebuild — must NOT await, must NOT crash slice completion.
+    // Dynamic import of the package name (not a relative path) so it resolves
+    // correctly via package.json#exports in both development and production.
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    (async () => {
+        try {
+            const graphMod = await import("@gsd-build/mcp-server");
+            const g = await graphMod.buildGraph(basePath);
+            await graphMod.writeGraph(graphMod.resolveGsdRoot(basePath), g);
+        }
+        catch (graphErr) {
+            // Graph rebuild is best-effort — log at warning level but never propagate
+            logWarning("tool", `complete-slice graph rebuild failed (non-fatal): ${graphErr.message ?? String(graphErr)}`);
+        }
+    })();
     return {
         sliceId: params.sliceId,
         milestoneId: params.milestoneId,

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -1,7 +1,7 @@
 import { ensureDbOpen } from "../bootstrap/dynamic-tools.js";
 import { sanitizeCompleteMilestoneParams } from "../bootstrap/sanitize-complete-milestone.js";
 import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot } from "../bootstrap/write-gate.js";
-import { getMilestone, getSliceStatusSummary, getSliceTaskCounts, _getAdapter, saveGateResult, } from "../gsd-db.js";
+import { getMilestone, getSliceStatusSummary, getSliceTaskCounts, readTransaction, saveGateResult, } from "../gsd-db.js";
 import { GATE_REGISTRY } from "../gate-registry.js";
 import { saveArtifactToDb } from "../db-writer.js";
 import { handleCompleteMilestone } from "./complete-milestone.js";
@@ -493,12 +493,9 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
                 isError: true,
             };
         }
-        const adapter = _getAdapter();
-        adapter.exec("BEGIN");
-        try {
+        return readTransaction(() => {
             const milestone = getMilestone(params.milestoneId);
             if (!milestone) {
-                adapter.exec("COMMIT");
                 return {
                     content: [{ type: "text", text: `Milestone ${params.milestoneId} not found in database.` }],
                     details: { operation: "milestone_status", milestoneId: params.milestoneId, found: false },
@@ -510,7 +507,6 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
                 status: s.status,
                 taskCounts: getSliceTaskCounts(params.milestoneId, s.id),
             }));
-            adapter.exec("COMMIT");
             const result = {
                 milestoneId: milestone.id,
                 title: milestone.title,
@@ -524,14 +520,7 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
                 content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
                 details: { operation: "milestone_status", milestoneId: milestone.id, sliceCount: slices.length },
             };
-        }
-        catch (txErr) {
-            try {
-                adapter.exec("ROLLBACK");
-            }
-            catch { /* swallow */ }
-            throw txErr;
-        }
+        });
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);

package/dist/resources/extensions/gsd/triage-resolution.js

@@ -83,12 +83,9 @@ export function executeReplan(basePath, mid, sid, capture) {
         // Also write replan_triggered_at column for DB-backed detection
         try {
             const req = createRequire(import.meta.url);
-            const { isDbAvailable, _getAdapter } = req("./gsd-db.js");
+            const { isDbAvailable, setSliceReplanTriggeredAt } = req("./gsd-db.js");
             if (isDbAvailable()) {
-                const adapter = _getAdapter();
-                if (adapter) {
-                    adapter.prepare("UPDATE slices SET replan_triggered_at = :ts WHERE milestone_id = :mid AND id = :sid").run({ ":ts": ts, ":mid": mid, ":sid": sid });
-                }
+                setSliceReplanTriggeredAt(mid, sid, ts);
             }
         }
         catch {

package/dist/resources/extensions/gsd/workflow-manifest.js

@@ -1,4 +1,4 @@
-import { _getAdapter, transaction, } from "./gsd-db.js";
+import { _getAdapter, readTransaction, restoreManifest, } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -41,8 +41,7 @@ export function snapshotState() {
     const db = requireDb();
     // Wrap all reads in a deferred transaction so the snapshot is consistent
     // (all SELECTs see the same DB state even if a concurrent write lands between them).
-    db.exec("BEGIN DEFERRED");
-    try {
+    return readTransaction(() => {
         const rawMilestones = db.prepare("SELECT * FROM milestones ORDER BY id").all();
         const milestones = rawMilestones.map((r) => ({
             id: r["id"],
@@ -146,74 +145,14 @@ export function snapshotState() {
             decisions,
             verification_evidence,
         };
-        db.exec("COMMIT");
         return result;
-    }
-    catch (err) {
-        try {
-            db.exec("ROLLBACK");
-        }
-        catch { /* ignore rollback failure */ }
-        throw err;
-    }
-}
-// ─── restore ─────────────────────────────────────────────────────────────
-/**
- * Atomically replace all workflow state from a manifest.
- * Runs inside a transaction — if any insert fails, no tables are modified.
- * Only touches engine tables + decisions. Does NOT modify artifacts or memories.
- */
-function restore(manifest) {
-    const db = requireDb();
-    transaction(() => {
-        // Clear engine tables (order matters for foreign-key-like consistency)
-        db.exec("DELETE FROM verification_evidence");
-        db.exec("DELETE FROM tasks");
-        db.exec("DELETE FROM slices");
-        db.exec("DELETE FROM milestones");
-        db.exec("DELETE FROM decisions WHERE 1=1");
-        // Restore milestones
-        const msStmt = db.prepare(`INSERT 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)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-        for (const m of manifest.milestones) {
-            msStmt.run(m.id, m.title, m.status, JSON.stringify(m.depends_on), m.created_at, m.completed_at, m.vision, JSON.stringify(m.success_criteria), JSON.stringify(m.key_risks), JSON.stringify(m.proof_strategy), m.verification_contract, m.verification_integration, m.verification_operational, m.verification_uat, JSON.stringify(m.definition_of_done), m.requirement_coverage, m.boundary_map_markdown);
-        }
-        // Restore slices
-        const slStmt = db.prepare(`INSERT 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)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-        for (const s of manifest.slices) {
-            slStmt.run(s.milestone_id, s.id, s.title, s.status, s.risk, JSON.stringify(s.depends), s.demo, s.created_at, s.completed_at, s.full_summary_md, s.full_uat_md, s.goal, s.success_criteria, s.proof_level, s.integration_closure, s.observability_impact, s.sequence, s.replan_triggered_at);
-        }
-        // Restore tasks
-        const tkStmt = db.prepare(`INSERT INTO tasks (milestone_id, slice_id, id, title, status,
-        one_liner, narrative, verification_result, duration, completed_at,
-        blocker_discovered, deviations, known_issues, key_files, key_decisions,
-        full_summary_md, description, estimate, files, verify,
-        inputs, expected_output, observability_impact, sequence)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-        for (const t of manifest.tasks) {
-            tkStmt.run(t.milestone_id, t.slice_id, t.id, t.title, t.status, t.one_liner, t.narrative, t.verification_result, t.duration, t.completed_at, t.blocker_discovered ? 1 : 0, t.deviations, t.known_issues, JSON.stringify(t.key_files), JSON.stringify(t.key_decisions), t.full_summary_md, t.description, t.estimate, JSON.stringify(t.files), t.verify, JSON.stringify(t.inputs), JSON.stringify(t.expected_output), t.observability_impact, t.sequence);
-        }
-        // Restore decisions
-        const dcStmt = db.prepare(`INSERT INTO decisions (seq, id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-        for (const d of manifest.decisions) {
-            dcStmt.run(d.seq, d.id, d.when_context, d.scope, d.decision, d.choice, d.rationale, d.revisable, d.made_by, d.superseded_by);
-        }
-        // Restore verification evidence
-        const evStmt = db.prepare(`INSERT INTO verification_evidence (task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
-        for (const e of manifest.verification_evidence) {
-            evStmt.run(e.task_id, e.slice_id, e.milestone_id, e.command, e.exit_code, e.verdict, e.duration_ms, e.created_at);
-        }
     });
 }
+// ─── restore ─────────────────────────────────────────────────────────────
+//
+// The actual restore() implementation lives in gsd-db.ts (single-writer
+// invariant). This module only orchestrates reading the manifest file
+// and handing it to the writer.
 // ─── writeManifest ───────────────────────────────────────────────────────
 /**
  * Write current DB state to .gsd/state-manifest.json via atomicWriteSync.
@@ -258,6 +197,6 @@ export function bootstrapFromManifest(basePath) {
     if (!manifest) {
         return false;
     }
-    restore(manifest);
+    restoreManifest(manifest);
     return true;
 }

package/dist/resources/extensions/gsd/workflow-migration.js

@@ -4,7 +4,7 @@
 // Populates data into the already-existing v10 schema tables.
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { _getAdapter, transaction } from "./gsd-db.js";
+import { _getAdapter, bulkInsertLegacyHierarchy } from "./gsd-db.js";
 import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
 import { logWarning } from "./workflow-logger.js";
 // ─── needsAutoMigration ───────────────────────────────────────────────────
@@ -174,27 +174,26 @@ export function migrateFromMarkdown(basePath) {
         process.stderr.write("workflow-migration: no milestones collected, nothing to insert\n");
         return;
     }
-    const placeholders = migratedMilestoneIds.map(() => "?").join(",");
-    transaction(() => {
-        // Clear existing data to handle stale DB shape (DELETE ... IN (...))
-        db.prepare(`DELETE FROM tasks WHERE milestone_id IN (${placeholders})`).run(...migratedMilestoneIds);
-        db.prepare(`DELETE FROM slices WHERE milestone_id IN (${placeholders})`).run(...migratedMilestoneIds);
-        db.prepare(`DELETE FROM milestones WHERE id IN (${placeholders})`).run(...migratedMilestoneIds);
-        // Insert milestones
-        const insertMilestone = db.prepare("INSERT INTO milestones (id, title, status, created_at) VALUES (?, ?, ?, ?)");
-        for (const m of milestoneInserts) {
-            insertMilestone.run(m.id, m.title, m.status, now);
-        }
-        // Insert slices (using v10 column names: depends, sequence)
-        const insertSlice = db.prepare("INSERT INTO slices (id, milestone_id, title, status, risk, depends, sequence, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
-        for (const s of sliceInserts) {
-            insertSlice.run(s.id, s.milestoneId, s.title, s.status, s.risk, "[]", s.sequence, now);
-        }
-        // Insert tasks (using v10 column names: sequence, blocker_discovered, full_summary_md)
-        const insertTask = db.prepare("INSERT INTO tasks (id, slice_id, milestone_id, title, description, status, estimate, files, sequence) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
-        for (const t of taskInserts) {
-            insertTask.run(t.id, t.sliceId, t.milestoneId, t.title, "", t.status, "", "[]", t.sequence);
-        }
+    bulkInsertLegacyHierarchy({
+        milestones: milestoneInserts,
+        slices: sliceInserts.map(s => ({
+            id: s.id,
+            milestoneId: s.milestoneId,
+            title: s.title,
+            status: s.status,
+            risk: s.risk,
+            sequence: s.sequence,
+        })),
+        tasks: taskInserts.map(t => ({
+            id: t.id,
+            sliceId: t.sliceId,
+            milestoneId: t.milestoneId,
+            title: t.title,
+            status: t.status,
+            sequence: t.sequence,
+        })),
+        clearMilestoneIds: migratedMilestoneIds,
+        createdAt: now,
     });
 }
 // ─── validateMigration ────────────────────────────────────────────────────

package/dist/resources/extensions/gsd/workflow-projections.js

@@ -303,7 +303,10 @@ export async function renderStateProjection(basePath) {
         try {
             adapter.prepare("SELECT 1").get();
         }
-        catch {
+        catch (err) {
+            logWarning("projection", "renderStateProjection: DB handle probe failed, skipping render", {
+                error: err.message,
+            });
             return;
         }
         const state = await deriveState(basePath);

package/dist/resources/extensions/gsd/workflow-reconcile.js

@@ -2,7 +2,7 @@ import { join } from "node:path";
 import { mkdirSync, existsSync, readFileSync, unlinkSync } from "node:fs";
 import { logWarning, logError } from "./workflow-logger.js";
 import { readEvents, findForkPoint, getSessionId } from "./workflow-events.js";
-import { transaction, updateTaskStatus, updateSliceStatus, updateMilestoneStatus, getSliceTasks, insertMilestone, _getAdapter, getMilestoneSlices, insertVerificationEvidence, upsertDecision, openDatabase, setTaskBlockerDiscovered, } from "./gsd-db.js";
+import { transaction, updateTaskStatus, updateSliceStatus, updateMilestoneStatus, getSliceTasks, insertMilestone, getMilestoneSlices, insertVerificationEvidence, upsertDecision, openDatabase, setTaskBlockerDiscovered, insertOrIgnoreSlice, insertOrIgnoreTask, } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { invalidateStateCache } from "./state.js";
 import { clearPathCache } from "./paths.js";
@@ -132,11 +132,12 @@ function replayEvents(events) {
                     const milestoneId = p["milestoneId"];
                     const sliceId = p["sliceId"];
                     if (milestoneId && sliceId) {
-                        const adapter = _getAdapter();
-                        if (adapter) {
-                            adapter.prepare(`INSERT OR IGNORE INTO slices (milestone_id, id, title, status, created_at)
-               VALUES (:mid, :sid, :title, 'pending', :ts)`).run({ ":mid": milestoneId, ":sid": sliceId, ":title": p["title"] ?? sliceId, ":ts": event.ts });
-                        }
+                        insertOrIgnoreSlice({
+                            milestoneId,
+                            sliceId,
+                            title: p["title"] ?? sliceId,
+                            createdAt: event.ts,
+                        });
                     }
                     break;
                 }
@@ -148,11 +149,13 @@ function replayEvents(events) {
                     const sliceId = p["sliceId"];
                     const taskId = p["taskId"];
                     if (milestoneId && sliceId && taskId) {
-                        const adapter = _getAdapter();
-                        if (adapter) {
-                            adapter.prepare(`INSERT OR IGNORE INTO tasks (milestone_id, slice_id, id, title, status, created_at)
-               VALUES (:mid, :sid, :tid, :title, 'pending', :ts)`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId, ":title": p["title"] ?? taskId, ":ts": event.ts });
-                        }
+                        insertOrIgnoreTask({
+                            milestoneId,
+                            sliceId,
+                            taskId,
+                            title: p["title"] ?? taskId,
+                            createdAt: event.ts,
+                        });
                     }
                     break;
                 }