@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

package/src/resources/extensions/gsd/commands/handlers/core.ts

@@ -4,7 +4,7 @@ import type { GSDState } from "../../types.js";
 import { createRequire } from "node:module";
 
 import { computeProgressScore, formatProgressLine } from "../../progress-score.js";
-import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath } from "../../preferences.js";
+import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, availableModelIdsFromRegistry, modelIdsForProfileResolution, resolveProfileAnchorProvider, resolveDisabledModelProvidersFromPreferences } from "../../preferences.js";
 import { ensurePreferencesFile, handlePrefs, handlePrefsMode, handlePrefsWizard, handleLanguage } from "../../commands-prefs-wizard.js";
 import { runEnvironmentChecks } from "../../doctor-environment.js";
 import { deriveState } from "../../state.js";
@@ -282,7 +282,10 @@ export async function handleSetup(args: string, ctx: ExtensionCommandContext, pi
     return;
   }
   if (args === "model") {
-    await handleModel("", ctx, pi);
+    // Default model picker: persist settings.json default only — do not pin the
+    // session override that /gsd model uses, or PREFERENCES.md per-phase models
+    // are ignored for the rest of this session (#model-prefs-precedence).
+    await handleModel("", ctx, pi, { pinSession: false });
     return;
   }
   if (args === "keys") {
@@ -412,7 +415,12 @@ async function resolveRequestedModel(
   return selectModelByProvider(`Multiple models match "${query}"`, partialMatches, ctx, ctx.model);
 }
 
-async function handleModel(trimmedArgs: string, ctx: ExtensionCommandContext, pi: ExtensionAPI | undefined): Promise<void> {
+async function handleModel(
+  trimmedArgs: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI | undefined,
+  options?: { pinSession?: boolean },
+): Promise<void> {
   const availableModels = ctx.modelRegistry.getAvailable();
   if (availableModels.length === 0) {
     ctx.ui.notify("No available models found. Check provider auth and model discovery.", "warning");
@@ -451,16 +459,19 @@ async function handleModel(trimmedArgs: string, ctx: ExtensionCommandContext, pi
 
   // /gsd model is an explicit per-session pin for GSD dispatches.
   // This is captured at auto bootstrap so it survives internal session
-  // switches during /gsd auto and /gsd next runs.
+  // switches during /gsd auto and /gsd next runs. /gsd setup model skips
+  // this pin so PREFERENCES.md per-phase models keep precedence.
+  const pinSession = options?.pinSession !== false;
   const sessionId = ctx.sessionManager?.getSessionId?.();
-  if (sessionId) {
+  if (pinSession && sessionId) {
     setSessionModelOverride(sessionId, {
       provider: targetModel.provider,
       id: targetModel.id,
     });
   }
 
-  ctx.ui.notify(`Model: ${targetModel.provider}/${targetModel.id}`, "info");
+  const pinNote = pinSession ? "" : " (default updated; per-phase prefs still apply in auto)";
+  ctx.ui.notify(`Model: ${targetModel.provider}/${targetModel.id}${pinNote}`, "info");
 }
 
 export async function handleCoreCommand(
@@ -531,8 +542,16 @@ export async function handleCoreCommand(
   }
   if (trimmed === "show-config") {
     const { GSDConfigOverlay, formatConfigText } = await import("../../config-overlay.js");
+    const basePath = projectRoot();
+    const anchorProvider = resolveProfileAnchorProvider(ctx.model?.provider);
+    const disabledProviders = resolveDisabledModelProvidersFromPreferences();
+    const availableModelIds = modelIdsForProfileResolution(ctx.modelRegistry, anchorProvider, disabledProviders);
+    const configOptions = {
+      basePath,
+      ...(availableModelIds && availableModelIds.length > 0 ? { availableModelIds } : {}),
+    };
     const result = await ctx.ui.custom<boolean>(
-      (tui, theme, _kb, done) => new GSDConfigOverlay(tui, theme, () => done(true)),
+      (tui, theme, _kb, done) => new GSDConfigOverlay(tui, theme, () => done(true), configOptions),
       {
         overlay: true,
         overlayOptions: {
@@ -544,7 +563,7 @@ export async function handleCoreCommand(
       },
     );
     if (result === undefined) {
-      ctx.ui.notify(formatConfigText(), "info");
+      ctx.ui.notify(formatConfigText(configOptions), "info");
     }
     return true;
   }

package/src/resources/extensions/gsd/commands/handlers/ops.ts

@@ -58,7 +58,7 @@ export async function handleOpsCommand(trimmed: string, ctx: ExtensionCommandCon
     ["execute-task", "execute"],
     ["complete-slice", "complete"],
     ["validate-milestone", "validate-milestone"],
-    ["complete-milestone", "complete"],
+    ["complete-milestone", "complete-milestone"],
   ]);
   const aliasPhase = directDispatchAlias.get(trimmed);
   if (aliasPhase) {
@@ -238,7 +238,10 @@ Examples:
   if (trimmed === "dispatch" || trimmed.startsWith("dispatch ")) {
     const phase = trimmed.replace(/^dispatch\s*/, "").trim();
     if (!phase) {
-      ctx.ui.notify("Usage: /gsd dispatch <phase>  (research|plan|execute|complete|validate|reassess|uat|replan)", "warning");
+      ctx.ui.notify(
+        "Usage: /gsd dispatch <phase>  (research|plan|execute|complete|complete-milestone|validate|reassess|uat|replan)",
+        "warning",
+      );
       return true;
     }
     const basePath = projectRoot();

package/src/resources/extensions/gsd/commands-mcp-status.ts

@@ -102,7 +102,7 @@ export function formatMcpStatusReport(servers: McpServerStatus[]): string {
       : s.connected
         ? `connected — ${s.toolCount} tools`
         : s.available
-          ? `available — ${s.toolCount} tools`
+          ? `probe available — ${s.toolCount} tools`
         : "disconnected";
     const warningText = s.envWarnings?.length ? ` — ${s.envWarnings.length} warning(s)` : "";
     lines.push(`  ${icon} ${s.name} (${s.transport}) — ${status}${warningText}`);
@@ -128,7 +128,7 @@ export function formatMcpServerDetail(server: McpServerDetail): string {
     lines.push(`  Status:    error`);
     lines.push(`  Error:     ${server.error}`);
   } else if (server.connected || server.available) {
-    lines.push(`  Status:    ${server.connected ? "connected" : "available"}`);
+    lines.push(`  Status:    ${server.connected ? "connected" : "probe available"}`);
     lines.push(`  Tools:     ${server.toolCount}`);
     if (server.tools.length > 0) {
       lines.push("");

package/src/resources/extensions/gsd/commands-prefs-wizard.ts

@@ -22,6 +22,7 @@ import {
 } from "./preferences.js";
 import { loadFile, saveFile, splitFrontmatter, parseFrontmatterMap } from "./files.js";
 import { runClaudeImportFlow } from "./claude-import.js";
+import { clearSessionModelOverride } from "./session-model-override.js";
 
 const DEFAULT_WIDGET_MODE = "small";
 const WIDGET_MODE_OPTIONS = [DEFAULT_WIDGET_MODE, "full", "min", "off"] as const;
@@ -1678,6 +1679,12 @@ export async function writePreferencesFile(
   await saveFile(path, content);
 
   if (ctx) {
+    // Per-phase model prefs must beat an earlier /gsd model session pin.
+    const models = prefs.models;
+    if (models && typeof models === "object" && Object.keys(models as object).length > 0) {
+      const sessionId = ctx.sessionManager?.getSessionId?.();
+      if (sessionId) clearSessionModelOverride(sessionId);
+    }
     await ctx.waitForIdle();
     await ctx.reload();
     if (opts?.notifyOnSave !== false) {

package/src/resources/extensions/gsd/commands-workflow-templates.ts

@@ -80,13 +80,13 @@ function datePrefix(): string {
 
 // ─── State Types ─────────────────────────────────────────────────────────────
 
-interface WorkflowPhaseState {
+export interface WorkflowPhaseState {
   name: string;
   index: number;
   status: "pending" | "active" | "completed";
 }
 
-interface WorkflowState {
+export interface WorkflowState {
   template: string;
   templateName: string;
   description: string;
@@ -99,6 +99,13 @@ interface WorkflowState {
   artifactDir: string;
 }
 
+export function isWorkflowStateComplete(state: WorkflowState): boolean {
+  if (state.completedAt) return true;
+  return Array.isArray(state.phases) &&
+    state.phases.length > 0 &&
+    state.phases.every((phase) => phase.status === "completed");
+}
+
 /**
  * Write a STATE.json file to track workflow execution state.
  */
@@ -133,7 +140,7 @@ function writeWorkflowState(
  * Scan all workflow artifact directories for in-progress STATE.json files.
  * Returns workflows that were started but not completed.
  */
-function findInProgressWorkflows(basePath: string): WorkflowState[] {
+export function findInProgressWorkflows(basePath: string): WorkflowState[] {
   const workflowsRoot = join(gsdRoot(basePath), "workflows");
   if (!existsSync(workflowsRoot)) return [];
 
@@ -152,7 +159,7 @@ function findInProgressWorkflows(basePath: string): WorkflowState[] {
         try {
           const raw = readFileSync(statePath, "utf-8");
           const state = JSON.parse(raw) as WorkflowState;
-          if (!state.completedAt) {
+          if (!isWorkflowStateComplete(state)) {
             results.push(state);
           }
         } catch { /* corrupted state file — skip */ }

package/src/resources/extensions/gsd/config-overlay.ts

@@ -25,19 +25,27 @@ import {
 
 const DEFAULT_WIDGET_MODE = "small";
 
-// ─── Data Collection ──────────────────────────────────────────────────────
-
 interface ConfigSection {
   title: string;
   rows: Array<{ label: string; value: string; accent?: boolean }>;
 }
 
-function collectConfigSections(): ConfigSection[] {
+// ─── Data Collection ──────────────────────────────────────────────────────
+
+export interface CollectConfigOptions {
+  basePath?: string;
+  availableModelIds?: string[];
+}
+
+function collectConfigSections(options?: CollectConfigOptions): ConfigSection[] {
   const sections: ConfigSection[] = [];
 
   const globalPrefs = loadGlobalGSDPreferences();
-  const projectPrefs = loadProjectGSDPreferences();
-  const effective = loadEffectiveGSDPreferences();
+  const projectPrefs = loadProjectGSDPreferences(options?.basePath);
+  const loadOpts = options?.availableModelIds
+    ? { availableModelIds: options.availableModelIds }
+    : undefined;
+  const effective = loadEffectiveGSDPreferences(options?.basePath, loadOpts);
   const prefs = effective?.preferences;
 
   // ─── Sources ─────────────────────────────────────────────────────────
@@ -69,7 +77,11 @@ function collectConfigSections(): ConfigSection[] {
 
   const modelRows: ConfigSection["rows"] = [];
   for (const [label, unitType] of unitTypes) {
-    const resolved = resolveModelWithFallbacksForUnit(unitType);
+    const resolved = resolveModelWithFallbacksForUnit(
+      unitType,
+      options?.basePath,
+      options?.availableModelIds,
+    );
     if (resolved) {
       let val = resolved.primary;
       if (resolved.fallbacks.length > 0) {
@@ -204,8 +216,8 @@ function collectConfigSections(): ConfigSection[] {
 
 // ─── Plain Text Formatter (headless/RPC fallback) ─────────────────────────
 
-export function formatConfigText(): string {
-  const sections = collectConfigSections();
+export function formatConfigText(options?: CollectConfigOptions): string {
+  const sections = collectConfigSections(options);
   const lines: string[] = ["GSD Configuration\n"];
 
   let maxLabel = 0;
@@ -243,11 +255,12 @@ export class GSDConfigOverlay {
     tui: { requestRender: () => void },
     theme: Theme,
     onClose: () => void,
+    options?: CollectConfigOptions,
   ) {
     this.tui = tui;
     this.theme = theme;
     this.onClose = onClose;
-    this.sections = collectConfigSections();
+    this.sections = collectConfigSections(options);
   }
 
   invalidate(): void {

package/src/resources/extensions/gsd/db/engine.ts

@@ -1,11 +1,13 @@
 // Project/App: gsd-pi
 // File Purpose: GSD engine — connection ownership, lifecycle, schema/migrations,
 // and transaction primitives for the single-writer layer. The shared handle
-// (currentDb) lives here; writers (db/writers/*) and the Query Module
-// (db/queries.ts) read it through getDb()/getDbOrNull().
+// (currentDb) lives here; domain writers, allowlisted coordination/runtime
+// writers, schema/migration helpers, and the Query Module (db/queries.ts) read
+// it through getDb()/getDbOrNull().
 //
 // This file legitimately holds DDL and BEGIN/COMMIT control, so it is
-// allowlisted in tests/single-writer-invariant.test.ts alongside db/writers/.
+// allowlisted in tests/single-writer-invariant.test.ts alongside the explicit
+// writer layer.
 import { createRequire } from "node:module";
 import { existsSync, copyFileSync, mkdirSync, realpathSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -16,7 +18,7 @@ import { createDbAdapter, type DbAdapter } from "../db-adapter.js";
 import { createBaseSchemaObjects } from "../db-base-schema.js";
 import { createCoordinationTablesV24 } from "../db-coordination-schema.js";
 import { createDbConnectionCache, type DbConnectionCacheEntry } from "../db-connection-cache.js";
-import { backupDatabaseBeforeMigration } from "../db-migration-backup.js";
+import { backupDatabaseBeforeMigration, isMigrationBackupError } from "../db-migration-backup.js";
 import {
   applyMigrationV2Artifacts,
   applyMigrationV3Memories,
@@ -601,8 +603,9 @@ export function openDatabase(path: string): boolean {
     initSchema(adapter, fileBacked, path);
   } catch (err) {
     // Corrupt freelist: DDL fails with "malformed" but VACUUM can rebuild.
-    // Attempt VACUUM recovery before giving up (see #2519).
-    if (fileBacked && err instanceof Error && err.message?.includes("malformed")) {
+    // Pre-migration backup failures are already pre-DDL and must propagate
+    // instead of being masked by VACUUM recovery (see #2519).
+    if (shouldAttemptVacuumRecovery(fileBacked, err)) {
       try {
         adapter.exec("VACUUM");
         initSchema(adapter, fileBacked, path);
@@ -634,6 +637,12 @@ export function openDatabase(path: string): boolean {
   return true;
 }
 
+function shouldAttemptVacuumRecovery(fileBacked: boolean, err: unknown): boolean {
+  return fileBacked && err instanceof Error && err.message.includes("malformed") && !isMigrationBackupError(err);
+}
+
+export const _shouldAttemptVacuumRecoveryForTest = shouldAttemptVacuumRecovery;
+
 export function closeDatabase(): void {
   if (currentDb) {
     try {
@@ -735,6 +744,7 @@ function createTransactionControls(db: DbAdapter) {
   return {
     begin: () => db.exec("BEGIN"),
     beginRead: () => db.exec("BEGIN DEFERRED"),
+    beginImmediate: () => db.exec("BEGIN IMMEDIATE"),
     commit: () => db.exec("COMMIT"),
     rollback: () => db.exec("ROLLBACK"),
   };
@@ -755,6 +765,16 @@ export function transaction<T>(fn: () => T): T {
   return _transactionRunner.transaction(createTransactionControls(currentDb), fn);
 }
 
+/**
+ * Run a BEGIN IMMEDIATE write transaction for operations that need SQLite's
+ * reserved writer lock before issuing updates. Re-entrant like transaction():
+ * nested calls run inside the outer transaction without a nested BEGIN.
+ */
+export function immediateTransaction<T>(fn: () => T): T {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  return _transactionRunner.immediateTransaction(createTransactionControls(currentDb), fn);
+}
+
 /**
  * Wrap a block of reads in a DEFERRED transaction so that all SELECTs observe
  * a consistent snapshot of the DB even if a concurrent writer commits between

package/src/resources/extensions/gsd/db/queries.ts

@@ -270,6 +270,35 @@ export function getMilestoneSlices(milestoneId: string): SliceRow[] {
   return rows.map(rowToSlice);
 }
 
+/**
+ * Load slices for many milestones in a single query. Returns a Map keyed by
+ * milestone_id, preserving `ORDER BY sequence, id` within each bucket.
+ */
+export function getSlicesByMilestoneIds(milestoneIds: readonly string[]): Map<string, SliceRow[]> {
+  const db = getDbOrNull();
+  if (!db || milestoneIds.length === 0) return new Map();
+  const idList = [...milestoneIds];
+  const placeholders = idList.map((_, i) => `:mid${i}`).join(",");
+  const params: Record<string, unknown> = {};
+  idList.forEach((id, i) => {
+    params[`:mid${i}`] = id;
+  });
+  const rows = db
+    .prepare(`SELECT * FROM slices WHERE milestone_id IN (${placeholders}) ORDER BY milestone_id, sequence, id`)
+    .all(params) as Record<string, unknown>[];
+  const byMilestone = new Map<string, SliceRow[]>();
+  for (const row of rows) {
+    const slice = rowToSlice(row);
+    const bucket = byMilestone.get(slice.milestone_id);
+    if (bucket) {
+      bucket.push(slice);
+    } else {
+      byMilestone.set(slice.milestone_id, [slice]);
+    }
+  }
+  return byMilestone;
+}
+
 /** Dispatch-eligibility shape consumed by decision-path callers (ADR-017). */
 export interface MilestoneSliceSummary {
   id: string;

package/src/resources/extensions/gsd/db/writers/reconcile.ts

@@ -11,6 +11,29 @@ import { logError, logWarning } from "../../workflow-logger.js";
 import { getDbOrNull, openDatabase } from "../engine.js";
 import { TERMINAL_STATUS_SQL } from "../sql-constants.js";
 
+/**
+ * Optional override for the project-root DB open inside reconcileWorktreeDb.
+ * Production leaves this null so the real engine.openDatabase runs; tests
+ * inject a function returning false to deterministically exercise the
+ * cannot-open-main-DB branch (reconcile.ts:82), which is otherwise unreachable
+ * without a contrived provider/OS fault (openDatabase rethrows on real failures
+ * rather than returning false across providers).
+ * @internal
+ */
+let _mainDbOpenerFn: ((mainDbPath: string) => boolean) | null = null;
+
+export function _setMainDbOpenerFnForTests(
+  fn: ((mainDbPath: string) => boolean) | null,
+): () => void {
+  const previous = _mainDbOpenerFn;
+  _mainDbOpenerFn = fn;
+  return () => { _mainDbOpenerFn = previous; };
+}
+
+function openMainDb(mainDbPath: string): boolean {
+  return _mainDbOpenerFn ? _mainDbOpenerFn(mainDbPath) : openDatabase(mainDbPath);
+}
+
 export function copyWorktreeDb(srcDbPath: string, destDbPath: string): boolean {
   try {
     if (!existsSync(srcDbPath)) return false;
@@ -77,7 +100,7 @@ export function reconcileWorktreeDb(
     return zero;
   }
   if (!getDbOrNull()!) {
-    const opened = openDatabase(mainDbPath);
+    const opened = openMainDb(mainDbPath);
     if (!opened) {
       logError("db", "worktree DB reconciliation failed: cannot open main DB");
       return zero;

package/src/resources/extensions/gsd/db-migration-backup.ts

@@ -9,6 +9,26 @@ export interface MigrationBackupDeps {
   logWarning(scope: string, message: string): void;
 }
 
+/** Marks pre-migration backup failures so DB-open recovery cannot mask them. */
+export class MigrationBackupError extends Error {
+  constructor(message: string, cause?: unknown) {
+    super(message, { cause });
+    this.name = "MigrationBackupError";
+  }
+}
+
+/** Returns true for errors raised while checkpointing or copying a migration backup. */
+export function isMigrationBackupError(err: unknown): err is MigrationBackupError {
+  return err instanceof MigrationBackupError;
+}
+
+/**
+ * Creates a same-version backup before file-backed schema migrations.
+ *
+ * Existing same-version backups are reused. New backups fail closed: WAL
+ * checkpoint failures, incomplete checkpoints, and copy failures are logged
+ * and then rethrown before migration DDL runs.
+ */
 export function backupDatabaseBeforeMigration(
   db: DbAdapter,
   dbPath: string | null,
@@ -21,14 +41,43 @@ export function backupDatabaseBeforeMigration(
     const backupPath = `${dbPath}.backup-v${currentVersion}`;
     if (deps.existsSync(backupPath)) return;
 
-    try {
-      db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
-    } catch {
-      // Checkpoint is best effort; copying the base file is still better than no backup.
-    }
+    checkpointWal(db);
     deps.copyFileSync(dbPath, backupPath);
   } catch (backupErr) {
-    const message = backupErr instanceof Error ? backupErr.message : String(backupErr);
-    deps.logWarning("db", `Pre-migration backup failed: ${message}`);
+    const error = toMigrationBackupError(backupErr);
+    deps.logWarning("db", `Pre-migration backup failed: ${error.message}`);
+    throw error;
+  }
+}
+
+function checkpointWal(db: DbAdapter): void {
+  const row = db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+  if (!isCheckpointComplete(row)) {
+    const busy = formatCheckpointValue(row, "busy");
+    const log = formatCheckpointValue(row, "log");
+    const checkpointed = formatCheckpointValue(row, "checkpointed");
+    throw new MigrationBackupError(
+      `WAL checkpoint incomplete: busy=${busy} log=${log} checkpointed=${checkpointed}`,
+    );
   }
 }
+
+function isCheckpointComplete(row: Record<string, unknown> | undefined): boolean {
+  if (!row) return false;
+  const busy = Number(row["busy"]);
+  const log = Number(row["log"]);
+  const checkpointed = Number(row["checkpointed"]);
+  if (!Number.isFinite(busy) || !Number.isFinite(log) || !Number.isFinite(checkpointed)) return false;
+  return busy === 0 && log === checkpointed;
+}
+
+function formatCheckpointValue(row: Record<string, unknown> | undefined, key: string): string {
+  const value = row?.[key];
+  return value === undefined ? "unknown" : String(value);
+}
+
+function toMigrationBackupError(err: unknown): MigrationBackupError {
+  if (isMigrationBackupError(err)) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  return new MigrationBackupError(message, err);
+}

package/src/resources/extensions/gsd/db-transaction.ts

@@ -4,6 +4,8 @@
 export interface DbTransactionControls {
   begin(): void;
   beginRead(): void;
+  /** Starts a write transaction that obtains SQLite's reserved lock up front. */
+  beginImmediate?(): void;
   commit(): void;
   rollback(): void;
 }
@@ -16,45 +18,47 @@ export class DbTransactionRunner {
   }
 
   transaction<T>(controls: DbTransactionControls, fn: () => T): T {
-    if (this.depth > 0) {
-      return this.runNested(fn);
-    }
+    return this.runTransaction(controls, () => controls.begin(), fn);
+  }
 
-    controls.begin();
-    this.depth++;
-    try {
-      const result = fn();
-      controls.commit();
-      return result;
-    } catch (err) {
-      controls.rollback();
-      throw err;
-    } finally {
-      this.depth--;
+  /**
+   * Run a BEGIN IMMEDIATE transaction through the same depth counter as regular
+   * transactions so callers can compose it inside existing transaction scopes.
+   */
+  immediateTransaction<T>(controls: DbTransactionControls, fn: () => T): T {
+    if (!controls.beginImmediate) {
+      throw new Error("db transaction controls do not support immediate transactions");
     }
+
+    return this.runTransaction(controls, () => controls.beginImmediate!(), fn);
   }
 
   readTransaction<T>(
     controls: DbTransactionControls,
     fn: () => T,
     logRollbackError: (error: Error) => void,
+  ): T {
+    return this.runTransaction(controls, () => controls.beginRead(), fn, logRollbackError);
+  }
+
+  private runTransaction<T>(
+    controls: DbTransactionControls,
+    begin: () => void,
+    fn: () => T,
+    logRollbackError?: (error: Error) => void,
   ): T {
     if (this.depth > 0) {
       return this.runNested(fn);
     }
 
-    controls.beginRead();
+    begin();
     this.depth++;
     try {
       const result = fn();
       controls.commit();
       return result;
     } catch (err) {
-      try {
-        controls.rollback();
-      } catch (rollbackErr) {
-        logRollbackError(rollbackErr instanceof Error ? rollbackErr : new Error(String(rollbackErr)));
-      }
+      this.rollback(controls, logRollbackError);
       throw err;
     } finally {
       this.depth--;
@@ -69,6 +73,19 @@ export class DbTransactionRunner {
       this.depth--;
     }
   }
+
+  private rollback(controls: DbTransactionControls, logRollbackError?: (error: Error) => void): void {
+    if (!logRollbackError) {
+      controls.rollback();
+      return;
+    }
+
+    try {
+      controls.rollback();
+    } catch (rollbackErr) {
+      logRollbackError(rollbackErr instanceof Error ? rollbackErr : new Error(String(rollbackErr)));
+    }
+  }
 }
 
 export function createDbTransactionRunner(): DbTransactionRunner {

package/src/resources/extensions/gsd/db-writer.ts

@@ -714,31 +714,23 @@ async function mirrorDecisionToMemory(
 /**
  * Extract a milestone/slice reference from a deferral decision.
  *
- * Detects deferrals by checking:
- *   - scope contains "defer" (e.g., "deferral", "defer")
- *   - choice or decision contains "defer" + an M###/S## pattern
+ * Detects deferrals when the slice reference is part of the deferral phrase.
  *
  * Returns { milestoneId, sliceId } if found, null otherwise.
  */
 export function extractDeferredSliceRef(
   fields: Pick<SaveDecisionFields, 'scope' | 'decision' | 'choice'>,
 ): { milestoneId: string; sliceId: string } | null {
-  const isDeferral =
-    /\bdefer(?:ral|red|ring|s)?\b/i.test(fields.scope) ||
-    /\bdefer(?:ral|red|ring|s)?\b/i.test(fields.choice) ||
-    /\bdefer(?:ral|red|ring|s)?\b/i.test(fields.decision);
-
-  if (!isDeferral) return null;
-
-  // Look for M###/S## pattern in choice first, then decision
-  const slicePattern = /\b(M\d{3,4})\/(S\d{2,3})\b/;
-  const choiceMatch = fields.choice.match(slicePattern);
-  if (choiceMatch) {
-    return { milestoneId: choiceMatch[1], sliceId: choiceMatch[2] };
-  }
-  const decisionMatch = fields.decision.match(slicePattern);
-  if (decisionMatch) {
-    return { milestoneId: decisionMatch[1], sliceId: decisionMatch[2] };
+  const defersSlicePattern =
+    /\bdefer(?:ral|red|ring|s)?\b\s+(?:(?:of|the)\s+)*(?:slice\s+)?\b(M\d{3,4})\/(S\d{2,3})\b/i;
+  const sliceIsDeferredPattern =
+    /\b(M\d{3,4})\/(S\d{2,3})\b\s+(?:is|was|will be|should be|can be)\s+defer(?:red|ring)?\b/i;
+
+  for (const text of [fields.choice, fields.decision, fields.scope]) {
+    const match = text.match(defersSlicePattern) ?? text.match(sliceIsDeferredPattern);
+    if (match) {
+      return { milestoneId: match[1], sliceId: match[2] };
+    }
   }
 
   return null;