gsd-pi 2.51.0 → 2.52.0-dev.585e355

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

package/dist/resources/extensions/gsd/milestone-actions.js

@@ -15,6 +15,7 @@ import { join } from "node:path";
 import { resolveMilestonePath, resolveMilestoneFile, buildMilestoneFileName, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
+import { isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
 // ─── Park ──────────────────────────────────────────────────────────────────
 /**
  * Park a milestone — creates a PARKED.md marker file with reason and timestamp.
@@ -44,6 +45,15 @@ export function parkMilestone(basePath, milestoneId, reason) {
         "",
     ].join("\n");
     writeFileSync(parkedPath, content, "utf-8");
+    // Sync DB status so deriveStateFromDb also skips this milestone (#2694)
+    if (isDbAvailable()) {
+        try {
+            updateMilestoneStatus(milestoneId, "parked");
+        }
+        catch (err) {
+            process.stderr.write(`gsd: parkMilestone DB sync failed for ${milestoneId}: ${err.message}\n`);
+        }
+    }
     invalidateAllCaches();
     return true;
 }
@@ -60,6 +70,15 @@ export function unparkMilestone(basePath, milestoneId) {
     if (!existsSync(parkedPath))
         return false; // not parked
     unlinkSync(parkedPath);
+    // Sync DB status so deriveStateFromDb picks up the unparked milestone (#2694)
+    if (isDbAvailable()) {
+        try {
+            updateMilestoneStatus(milestoneId, "active");
+        }
+        catch (err) {
+            process.stderr.write(`gsd: unparkMilestone DB sync failed for ${milestoneId}: ${err.message}\n`);
+        }
+    }
     invalidateAllCaches();
     return true;
 }

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

@@ -98,18 +98,6 @@ export function getNextFallbackModel(currentModelId, modelConfig) {
         return modelsToTry[0];
     }
 }
-/**
- * Detect whether an error message indicates a transient network error
- * (worth retrying the same model) vs a permanent provider error
- * (auth failure, quota exceeded, etc. -- should fall back immediately).
- */
-export function isTransientNetworkError(errorMsg) {
-    if (!errorMsg)
-        return false;
-    const hasNetworkSignal = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fetch failed|connection.*reset|dns/i.test(errorMsg);
-    const hasPermanentSignal = /auth|unauthorized|forbidden|invalid.*key|quota|billing/i.test(errorMsg);
-    return hasNetworkSignal && !hasPermanentSignal;
-}
 /**
  * Validate a model ID string.
  * Returns true if the ID looks like a valid model identifier.
@@ -273,7 +261,7 @@ export function resolveContextSelection() {
     return profile === "budget" ? "smart" : "full";
 }
 /**
- * Resolve the search provider preference from preferences.md.
+ * Resolve the search provider preference from PREFERENCES.md.
  * Returns undefined if not configured (caller falls back to existing behavior).
  */
 export function resolveSearchProviderFromPreferences() {

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

@@ -11,7 +11,7 @@ export const MODE_DEFAULTS = {
         git: {
             auto_push: true,
             push_branches: false,
-            pre_merge_check: false,
+            pre_merge_check: "auto",
             merge_strategy: "squash",
             isolation: "none",
         },

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

@@ -24,27 +24,27 @@ export { validatePreferences } from "./preferences-validation.js";
 // ─── Re-exports: skills ─────────────────────────────────────────────────────
 export { resolveAllSkillReferences, resolveSkillDiscoveryMode, resolveSkillStalenessDays, } from "./preferences-skills.js";
 // ─── Re-exports: models ─────────────────────────────────────────────────────
-export { resolveModelForUnit, resolveModelWithFallbacksForUnit, getNextFallbackModel, isTransientNetworkError, validateModelId, updatePreferencesModels, resolveDynamicRoutingConfig, resolveAutoSupervisorConfig, resolveProfileDefaults, resolveEffectiveProfile, resolveInlineLevel, resolveContextSelection, resolveSearchProviderFromPreferences, } from "./preferences-models.js";
+export { resolveModelForUnit, resolveModelWithFallbacksForUnit, getNextFallbackModel, validateModelId, updatePreferencesModels, resolveDynamicRoutingConfig, resolveAutoSupervisorConfig, resolveProfileDefaults, resolveEffectiveProfile, resolveInlineLevel, resolveContextSelection, resolveSearchProviderFromPreferences, } from "./preferences-models.js";
 // ─── Path Constants & Getters ───────────────────────────────────────────────
 function gsdHome() {
     return process.env.GSD_HOME || join(homedir(), ".gsd");
 }
 function globalPreferencesPath() {
-    return join(gsdHome(), "preferences.md");
+    return join(gsdHome(), "PREFERENCES.md");
 }
 function legacyGlobalPreferencesPath() {
     return join(homedir(), ".pi", "agent", "gsd-preferences.md");
 }
 function projectPreferencesPath() {
-    return join(gsdRoot(process.cwd()), "preferences.md");
+    return join(gsdRoot(process.cwd()), "PREFERENCES.md");
 }
-// Bootstrap in gitignore.ts historically created PREFERENCES.md (uppercase) by mistake.
-// Check uppercase as a fallback so those files aren't silently ignored.
-function globalPreferencesPathUppercase() {
-    return join(gsdHome(), "PREFERENCES.md");
+// Legacy: older versions used lowercase preferences.md.
+// Check lowercase as a fallback so those files aren't silently ignored.
+function globalPreferencesPathLegacy() {
+    return join(gsdHome(), "preferences.md");
 }
-function projectPreferencesPathUppercase() {
-    return join(gsdRoot(process.cwd()), "PREFERENCES.md");
+function projectPreferencesPathLegacy() {
+    return join(gsdRoot(process.cwd()), "preferences.md");
 }
 export function getGlobalGSDPreferencesPath() {
     return globalPreferencesPath();
@@ -58,12 +58,12 @@ export function getProjectGSDPreferencesPath() {
 // ─── Loading ────────────────────────────────────────────────────────────────
 export function loadGlobalGSDPreferences() {
     return loadPreferencesFile(globalPreferencesPath(), "global")
-        ?? loadPreferencesFile(globalPreferencesPathUppercase(), "global")
+        ?? loadPreferencesFile(globalPreferencesPathLegacy(), "global")
         ?? loadPreferencesFile(legacyGlobalPreferencesPath(), "global");
 }
 export function loadProjectGSDPreferences() {
     return loadPreferencesFile(projectPreferencesPath(), "project")
-        ?? loadPreferencesFile(projectPreferencesPathUppercase(), "project");
+        ?? loadPreferencesFile(projectPreferencesPathLegacy(), "project");
 }
 export function loadEffectiveGSDPreferences() {
     const globalPreferences = loadGlobalGSDPreferences();
@@ -149,7 +149,7 @@ export function parsePreferencesMarkdown(content) {
     }
     if (!_warnedUnrecognizedFormat) {
         _warnedUnrecognizedFormat = true;
-        console.warn("[parsePreferencesMarkdown] preferences.md exists but uses an unrecognized format — skipping.");
+        console.warn("[parsePreferencesMarkdown] PREFERENCES.md exists but uses an unrecognized format — skipping.");
     }
     return null;
 }
@@ -398,7 +398,7 @@ export function resolvePreDispatchHooks() {
  * Resolve the effective git isolation mode from preferences.
  * Returns "none" (default), "worktree", or "branch".
  *
- * Default is "none" so GSD works out of the box without preferences.md.
+ * Default is "none" so GSD works out of the box without PREFERENCES.md.
  * Worktree isolation requires explicit opt-in because it depends on git
  * branch infrastructure that must be set up before use.
  */

package/dist/resources/extensions/gsd/prompts/system.md

@@ -92,7 +92,7 @@ Titles live inside file content (headings, frontmatter), not in file or director
 
 ### Isolation Model
 
-Auto-mode supports three isolation modes (configured in `.gsd/preferences.md` under `taskIsolation.mode`):
+Auto-mode supports three isolation modes (configured in `.gsd/PREFERENCES.md` under `taskIsolation.mode`):
 
 - **worktree** (default): Work happens in `.gsd/worktrees/<MID>/`, a full git worktree on the `milestone/<MID>` branch. Each worktree has its own working copy and `.gsd/` directory. Squash-merged back to the integration branch on milestone completion.
 - **branch**: Work happens in the project root on a `milestone/<MID>` branch. No worktree directory — files are checked out in-place.

package/dist/resources/extensions/gsd/provider-error-pause.js

@@ -1,47 +1,3 @@
-/**
- * Classify a provider error as transient (auto-resume) or permanent (manual resume).
- *
- * Transient: rate limits, server errors (500/502/503), overloaded, internal errors.
- * These are expected to self-resolve and should auto-resume after a delay.
- *
- * Permanent: auth errors, invalid API key, billing issues.
- * These require user intervention and should pause indefinitely.
- */
-export function classifyProviderError(errorMsg) {
-    const isRateLimit = /rate.?limit|too many requests|429/i.test(errorMsg);
-    const isServerError = /internal server error|500|502|503|overloaded|server_error|api_error|service.?unavailable/i.test(errorMsg);
-    // Connection/process errors — transient, auto-resume after brief backoff (#2309).
-    // These indicate the process was killed, the connection was reset, or a network
-    // blip occurred. They are NOT permanent failures.
-    const isConnectionError = /terminated|connection.?reset|connection.?refused|other side closed|fetch failed|network.?(?:is\s+)?unavailable|ECONNREFUSED|ECONNRESET|EPIPE/i.test(errorMsg);
-    // Permanent errors — never auto-resume
-    const isPermanent = /auth|unauthorized|forbidden|invalid.*key|invalid.*api|billing|quota exceeded|account/i.test(errorMsg);
-    if (isPermanent && !isRateLimit) {
-        return { isTransient: false, isRateLimit: false, suggestedDelayMs: 0 };
-    }
-    if (isRateLimit) {
-        // Try to extract retry-after from the message
-        const resetMatch = errorMsg.match(/reset in (\d+)s/i);
-        const delayMs = resetMatch ? Number(resetMatch[1]) * 1000 : 60_000; // default 60s for rate limits
-        return { isTransient: true, isRateLimit: true, suggestedDelayMs: delayMs };
-    }
-    if (isServerError) {
-        return { isTransient: true, isRateLimit: false, suggestedDelayMs: 30_000 }; // 30s for server errors
-    }
-    if (isConnectionError) {
-        return { isTransient: true, isRateLimit: false, suggestedDelayMs: 15_000 }; // 15s for connection errors
-    }
-    // Stream-truncation JSON parse errors — transient (#2572).
-    // When the API stream is cut mid-chunk, pi tries to reassemble the partial
-    // tool-call JSON and gets a SyntaxError. This is the downstream symptom of
-    // a connection drop — same root cause as ECONNRESET, one layer up.
-    const isMalformedStream = /Unexpected end of JSON|Unexpected token.*JSON|Expected double-quoted property name|SyntaxError.*JSON/i.test(errorMsg);
-    if (isMalformedStream) {
-        return { isTransient: true, isRateLimit: false, suggestedDelayMs: 15_000 }; // 15s, same as connection errors
-    }
-    // Unknown error — treat as permanent (user reviews)
-    return { isTransient: false, isRateLimit: false, suggestedDelayMs: 0 };
-}
 /**
  * Pause auto-mode due to a provider error.
  *

package/dist/resources/extensions/gsd/rule-registry.js

@@ -426,7 +426,7 @@ export class RuleRegistry {
     formatHookStatus() {
         const entries = this.getHookStatus();
         if (entries.length === 0) {
-            return "No hooks configured. Add post_unit_hooks or pre_dispatch_hooks to .gsd/preferences.md";
+            return "No hooks configured. Add post_unit_hooks or pre_dispatch_hooks to .gsd/PREFERENCES.md";
         }
         const lines = ["Configured Hooks:", ""];
         const postHooks = entries.filter(e => e.type === "post");

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

@@ -13,16 +13,27 @@ import { getGlobalGSDPreferencesPath, loadEffectiveGSDPreferences, loadGlobalGSD
 import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
 const SERVICE_TIER_SCOPE_NOTE = "Only affects gpt-5.4 models, regardless of provider.";
 // ─── Gating ──────────────────────────────────────────────────────────────────
+/**
+ * Model ID prefixes (bare, without provider) that support OpenAI service tiers.
+ *
+ * This list is the fallback for callers that only have a model ID string.
+ * The authoritative source of truth is `model.capabilities.supportsServiceTier`
+ * (set via CAPABILITY_PATCHES in packages/pi-ai/src/models.ts). When callers
+ * have access to the full Model object, prefer reading capabilities directly.
+ *
+ * See: https://github.com/gsd-build/gsd-2/issues/2546
+ */
+const SERVICE_TIER_MODEL_PREFIXES = ["gpt-5.4"];
 /**
  * Returns true when the given model ID supports OpenAI service tiers.
- * Currently only gpt-5.4 variants qualify.
+ * Reads from SERVICE_TIER_MODEL_PREFIXES — update that list, not this function.
  */
 export function supportsServiceTier(modelId) {
     if (!modelId)
         return false;
     // Strip provider prefix if present (e.g. "openai/gpt-5.4" → "gpt-5.4")
     const bare = modelId.includes("/") ? modelId.split("/").pop() : modelId;
-    return bare.startsWith("gpt-5.4");
+    return SERVICE_TIER_MODEL_PREFIXES.some((prefix) => bare.startsWith(prefix));
 }
 // ─── Status Formatting ───────────────────────────────────────────────────────
 /**

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

@@ -6,6 +6,7 @@ import { parseSummary, loadFile, parseRequirementCounts, parseContextDependsOn,
 import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTasksDir, resolveGsdRootFile, gsdRoot, } from './paths.js';
 import { findMilestoneIds } from './milestone-ids.js';
 import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
+import { isClosedStatus } from './status-guards.js';
 import { nativeBatchParseGsdFiles } from './native-parser-bridge.js';
 import { join, resolve } from 'path';
 import { existsSync, readdirSync } from 'node:fs';
@@ -144,7 +145,23 @@ export async function deriveState(basePath) {
     let result;
     // Dual-path: try DB-backed derivation first when hierarchy tables are populated
     if (isDbAvailable()) {
-        const dbMilestones = getAllMilestones();
+        let dbMilestones = getAllMilestones();
+        // Disk→DB reconciliation (#2631): when the milestones table is empty
+        // (e.g. failed initial migration per #2529), the reconciliation code
+        // inside deriveStateFromDb is unreachable. Populate from disk here so
+        // the DB path activates correctly.
+        if (dbMilestones.length === 0) {
+            const diskIds = findMilestoneIds(basePath);
+            let synced = false;
+            for (const diskId of diskIds) {
+                if (!isGhostMilestone(basePath, diskId)) {
+                    insertMilestone({ id: diskId, status: 'active' });
+                    synced = true;
+                }
+            }
+            if (synced)
+                dbMilestones = getAllMilestones();
+        }
         if (dbMilestones.length > 0) {
             const stopDbTimer = debugTime("derive-state-db");
             result = await deriveStateFromDb(basePath);
@@ -187,12 +204,6 @@ function extractContextTitle(content, fallback) {
     return stripMilestonePrefix(h1.slice(2).trim()) || fallback;
 }
 // ─── DB-backed State Derivation ────────────────────────────────────────────
-/**
- * Helper: check if a DB status counts as "done" (handles K002 ambiguity).
- */
-function isStatusDone(status) {
-    return status === 'complete' || status === 'done';
-}
 /**
  * Derive GSD state from the milestones/slices/tasks DB tables.
  * Flag files (PARKED, VALIDATION, CONTINUE, REPLAN, REPLAN-TRIGGER, CONTEXT-DRAFT)
@@ -276,7 +287,7 @@ export async function deriveStateFromDb(basePath) {
             parkedMilestoneIds.add(m.id);
             continue;
         }
-        if (isStatusDone(m.status)) {
+        if (isClosedStatus(m.status)) {
             completeMilestoneIds.add(m.id);
             continue;
         }
@@ -288,7 +299,7 @@ export async function deriveStateFromDb(basePath) {
         }
         // Check roadmap: all slices done means milestone is complete
         const slices = getMilestoneSlices(m.id);
-        if (slices.length > 0 && slices.every(s => isStatusDone(s.status))) {
+        if (slices.length > 0 && slices.every(s => isClosedStatus(s.status))) {
             // All slices done but no summary — still counts as complete for dep resolution
             // if a summary file exists
             // Note: without summary file, the milestone is in validating/completing state, not complete
@@ -307,7 +318,7 @@ export async function deriveStateFromDb(basePath) {
         }
         // Ghost milestone check: no slices in DB AND no substantive files on disk
         const slices = getMilestoneSlices(m.id);
-        if (slices.length === 0 && !isStatusDone(m.status)) {
+        if (slices.length === 0 && !isClosedStatus(m.status)) {
             // Check disk for ghost detection
             if (isGhostMilestone(basePath, m.id))
                 continue;
@@ -328,7 +339,7 @@ export async function deriveStateFromDb(basePath) {
             continue;
         }
         // Not complete — determine if it should be active
-        const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
+        const allSlicesDone = slices.length > 0 && slices.every(s => isClosedStatus(s.status));
         // Get title — prefer DB, fall back to context file extraction
         let title = stripMilestonePrefix(m.title) || m.id;
         if (title === m.id) {
@@ -465,7 +476,10 @@ export async function deriveStateFromDb(basePath) {
         };
     }
     // ── All slices done → validating/completing ─────────────────────────
-    const allSlicesDone = activeMilestoneSlices.every(s => isStatusDone(s.status));
+    // Guard: [].every() === true (vacuous truth). Without the length check,
+    // an empty slice array causes a premature phase transition to
+    // validating-milestone. See: https://github.com/gsd-build/gsd-2/issues/2667
+    const allSlicesDone = activeMilestoneSlices.length > 0 && activeMilestoneSlices.every(s => isClosedStatus(s.status));
     if (allSlicesDone) {
         const validationFile = resolveMilestoneFile(basePath, activeMilestone.id, "VALIDATION");
         const validationContent = validationFile ? await loadFile(validationFile) : null;
@@ -495,14 +509,14 @@ export async function deriveStateFromDb(basePath) {
     }
     // ── Find active slice (first incomplete with deps satisfied) ─────────
     const sliceProgress = {
-        done: activeMilestoneSlices.filter(s => isStatusDone(s.status)).length,
+        done: activeMilestoneSlices.filter(s => isClosedStatus(s.status)).length,
         total: activeMilestoneSlices.length,
     };
-    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isStatusDone(s.status)).map(s => s.id));
+    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isClosedStatus(s.status)).map(s => s.id));
     let activeSlice = null;
     let activeSliceRow = null;
     for (const s of activeMilestoneSlices) {
-        if (isStatusDone(s.status))
+        if (isClosedStatus(s.status))
             continue;
         if (s.depends.every(dep => doneSliceIds.has(dep))) {
             activeSlice = { id: s.id, title: s.title };
@@ -542,7 +556,7 @@ export async function deriveStateFromDb(basePath) {
     // causing the dispatcher to re-dispatch the same completed task forever.
     let reconciled = false;
     for (const t of tasks) {
-        if (isStatusDone(t.status))
+        if (isClosedStatus(t.status))
             continue;
         const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
@@ -562,10 +576,10 @@ export async function deriveStateFromDb(basePath) {
         tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
     }
     const taskProgress = {
-        done: tasks.filter(t => isStatusDone(t.status)).length,
+        done: tasks.filter(t => isClosedStatus(t.status)).length,
         total: tasks.length,
     };
-    const activeTaskRow = tasks.find(t => !isStatusDone(t.status));
+    const activeTaskRow = tasks.find(t => !isClosedStatus(t.status));
     if (!activeTaskRow && tasks.length > 0) {
         // All tasks done but slice not marked complete → summarizing
         return {
@@ -620,7 +634,7 @@ export async function deriveStateFromDb(basePath) {
         };
     }
     // ── Blocker detection: check completed tasks for blocker_discovered ──
-    const completedTasks = tasks.filter(t => isStatusDone(t.status));
+    const completedTasks = tasks.filter(t => isClosedStatus(t.status));
     let blockerTaskId = null;
     for (const ct of completedTasks) {
         if (ct.blocker_discovered) {

package/dist/resources/extensions/gsd/status-guards.js

@@ -0,0 +1,12 @@
+/**
+ * Status predicates for GSD state-machine guards.
+ *
+ * The DB stores status as free-form strings. Two values indicate
+ * "closed": "complete" (canonical) and "done" (legacy / alias).
+ * Every inline `status === "complete" || status === "done"` should
+ * use isClosedStatus() instead.
+ */
+/** Returns true when a milestone, slice, or task status indicates closure. */
+export function isClosedStatus(status) {
+    return status === "complete" || status === "done";
+}

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

@@ -7,8 +7,9 @@
  */
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
-import { transaction, getMilestone, getMilestoneSlices, getSliceTasks, _getAdapter, } from "../gsd-db.js";
+import { transaction, getMilestone, getMilestoneSlices, getSliceTasks, updateMilestoneStatus, } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
+import { isClosedStatus } from "../status-guards.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -89,7 +90,7 @@ export async function handleCompleteMilestone(params, basePath) {
             guardError = `milestone not found: ${params.milestoneId}`;
             return;
         }
-        if (milestone.status === "complete" || milestone.status === "done") {
+        if (isClosedStatus(milestone.status)) {
             guardError = `milestone ${params.milestoneId} is already complete`;
             return;
         }
@@ -99,7 +100,7 @@ export async function handleCompleteMilestone(params, basePath) {
             guardError = `no slices found for milestone ${params.milestoneId}`;
             return;
         }
-        const incompleteSlices = slices.filter(s => s.status !== "complete" && s.status !== "done");
+        const incompleteSlices = slices.filter(s => !isClosedStatus(s.status));
         if (incompleteSlices.length > 0) {
             const incompleteIds = incompleteSlices.map(s => `${s.id} (status: ${s.status})`).join(", ");
             guardError = `incomplete slices: ${incompleteIds}`;
@@ -108,7 +109,7 @@ export async function handleCompleteMilestone(params, basePath) {
         // Deep check: verify all tasks in all slices are complete
         for (const slice of slices) {
             const tasks = getSliceTasks(params.milestoneId, slice.id);
-            const incompleteTasks = tasks.filter(t => t.status !== "complete" && t.status !== "done");
+            const incompleteTasks = tasks.filter(t => !isClosedStatus(t.status));
             if (incompleteTasks.length > 0) {
                 const ids = incompleteTasks.map(t => `${t.id} (status: ${t.status})`).join(", ");
                 guardError = `slice ${slice.id} has incomplete tasks: ${ids}`;
@@ -116,11 +117,7 @@ export async function handleCompleteMilestone(params, basePath) {
             }
         }
         // All guards passed — perform write
-        const adapter = _getAdapter();
-        adapter.prepare(`UPDATE milestones SET status = 'complete', completed_at = :completed_at WHERE id = :mid`).run({
-            ":completed_at": completedAt,
-            ":mid": params.milestoneId,
-        });
+        updateMilestoneStatus(params.milestoneId, 'complete', completedAt);
     });
     if (guardError) {
         return { error: guardError };
@@ -144,10 +141,7 @@ export async function handleCompleteMilestone(params, basePath) {
     catch (renderErr) {
         // Disk render failed — roll back DB status so state stays consistent
         process.stderr.write(`gsd-db: complete_milestone — disk render failed, rolling back DB status: ${renderErr.message}\n`);
-        const rollbackAdapter = _getAdapter();
-        if (rollbackAdapter) {
-            rollbackAdapter.prepare(`UPDATE milestones SET status = 'active', completed_at = NULL WHERE id = :mid`).run({ ":mid": params.milestoneId });
-        }
+        updateMilestoneStatus(params.milestoneId, 'active', null);
         invalidateStateCache();
         return { error: `disk render failed: ${renderErr.message}` };
     }

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

@@ -8,7 +8,8 @@
  */
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
-import { transaction, insertMilestone, insertSlice, getSlice, getSliceTasks, getMilestone, updateSliceStatus, _getAdapter, } from "../gsd-db.js";
+import { isClosedStatus } from "../status-guards.js";
+import { transaction, insertMilestone, insertSlice, getSlice, getSliceTasks, getMilestone, updateSliceStatus, setSliceSummaryMd, } from "../gsd-db.js";
 import { resolveSlicePath, clearPathCache } from "../paths.js";
 import { checkOwnership, sliceUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -179,12 +180,12 @@ export async function handleCompleteSlice(params, basePath) {
         // Milestone/slice not existing is OK — insertMilestone/insertSlice below will auto-create.
         // Only block if they exist and are closed.
         const milestone = getMilestone(params.milestoneId);
-        if (milestone && (milestone.status === "complete" || milestone.status === "done")) {
+        if (milestone && isClosedStatus(milestone.status)) {
             guardError = `cannot complete slice in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
             return;
         }
         const slice = getSlice(params.milestoneId, params.sliceId);
-        if (slice && (slice.status === "complete" || slice.status === "done")) {
+        if (slice && isClosedStatus(slice.status)) {
             guardError = `slice ${params.sliceId} is already complete — use gsd_slice_reopen first if you need to redo it`;
             return;
         }
@@ -194,7 +195,7 @@ export async function handleCompleteSlice(params, basePath) {
             guardError = `no tasks found for slice ${params.sliceId} in milestone ${params.milestoneId}`;
             return;
         }
-        const incompleteTasks = tasks.filter(t => t.status !== "complete" && t.status !== "done");
+        const incompleteTasks = tasks.filter(t => !isClosedStatus(t.status));
         if (incompleteTasks.length > 0) {
             const incompleteIds = incompleteTasks.map(t => `${t.id} (status: ${t.status})`).join(", ");
             guardError = `incomplete tasks: ${incompleteIds}`;
@@ -240,26 +241,12 @@ export async function handleCompleteSlice(params, basePath) {
     catch (renderErr) {
         // Disk render failed — roll back DB status so state stays consistent
         process.stderr.write(`gsd-db: complete_slice — disk render failed, rolling back DB status: ${renderErr.message}\n`);
-        const rollbackAdapter = _getAdapter();
-        if (rollbackAdapter) {
-            rollbackAdapter.prepare(`UPDATE slices SET status = 'pending' WHERE milestone_id = :mid AND id = :sid`).run({
-                ":mid": params.milestoneId,
-                ":sid": params.sliceId,
-            });
-        }
+        updateSliceStatus(params.milestoneId, params.sliceId, 'pending');
         invalidateStateCache();
         return { error: `disk render failed: ${renderErr.message}` };
     }
     // Store rendered markdown in DB for D004 recovery
-    const adapter = _getAdapter();
-    if (adapter) {
-        adapter.prepare(`UPDATE slices SET full_summary_md = :summary_md, full_uat_md = :uat_md WHERE milestone_id = :mid AND id = :sid`).run({
-            ":summary_md": summaryMd,
-            ":uat_md": uatMd,
-            ":mid": params.milestoneId,
-            ":sid": params.sliceId,
-        });
-    }
+    setSliceSummaryMd(params.milestoneId, params.sliceId, summaryMd, uatMd);
     // Invalidate all caches
     invalidateStateCache();
     clearPathCache();