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

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -11,6 +11,7 @@ import { fileURLToPath } from "node:url";
 import { getGlobalGSDPreferencesPath, getLegacyGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, loadGlobalGSDPreferences, loadProjectGSDPreferences, loadEffectiveGSDPreferences, normalizePreferencesShape, resolveAllSkillReferences, } 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"];
 /** Extract body content after frontmatter closing delimiter, or null if none. */
@@ -1627,6 +1628,13 @@ export async function writePreferencesFile(path, prefs, ctx, opts) {
     const content = `---\n${frontmatter}---${body}`;
     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).length > 0) {
+            const sessionId = ctx.sessionManager?.getSessionId?.();
+            if (sessionId)
+                clearSessionModelOverride(sessionId);
+        }
         await ctx.waitForIdle();
         await ctx.reload();
         if (opts?.notifyOnSave !== false) {

package/dist/resources/extensions/gsd/commands-workflow-templates.js

@@ -59,6 +59,13 @@ function datePrefix() {
     const dd = String(d.getDate()).padStart(2, "0");
     return `${yy}${mm}${dd}`;
 }
+export function isWorkflowStateComplete(state) {
+    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.
  */
@@ -85,7 +92,7 @@ function writeWorkflowState(artifactDir, templateId, templateName, phases, descr
  * Scan all workflow artifact directories for in-progress STATE.json files.
  * Returns workflows that were started but not completed.
  */
-function findInProgressWorkflows(basePath) {
+export function findInProgressWorkflows(basePath) {
     const workflowsRoot = join(gsdRoot(basePath), "workflows");
     if (!existsSync(workflowsRoot))
         return [];
@@ -105,7 +112,7 @@ function findInProgressWorkflows(basePath) {
                 try {
                     const raw = readFileSync(statePath, "utf-8");
                     const state = JSON.parse(raw);
-                    if (!state.completedAt) {
+                    if (!isWorkflowStateComplete(state)) {
                         results.push(state);
                     }
                 }

package/dist/resources/extensions/gsd/config-overlay.js

@@ -10,11 +10,14 @@ import { matchesKey, Key, truncateToWidth } from "@gsd/pi-tui";
 import { renderDialogFrame, renderKeyHints } from "./tui/render-kit.js";
 import { loadEffectiveGSDPreferences, loadGlobalGSDPreferences, loadProjectGSDPreferences, getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, resolveDynamicRoutingConfig, resolveEffectiveProfile, resolveModelWithFallbacksForUnit, resolveAutoSupervisorConfig, } from "./preferences.js";
 const DEFAULT_WIDGET_MODE = "small";
-function collectConfigSections() {
+function collectConfigSections(options) {
     const sections = [];
     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 ─────────────────────────────────────────────────────────
     sections.push({
@@ -43,7 +46,7 @@ function collectConfigSections() {
     ];
     const modelRows = [];
     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) {
@@ -203,8 +206,8 @@ function collectConfigSections() {
     return sections;
 }
 // ─── Plain Text Formatter (headless/RPC fallback) ─────────────────────────
-export function formatConfigText() {
-    const sections = collectConfigSections();
+export function formatConfigText(options) {
+    const sections = collectConfigSections(options);
     const lines = ["GSD Configuration\n"];
     let maxLabel = 0;
     for (const section of sections) {
@@ -233,11 +236,11 @@ export class GSDConfigOverlay {
     cachedWidth;
     scrollOffset = 0;
     disposed = false;
-    constructor(tui, theme, onClose) {
+    constructor(tui, theme, onClose, options) {
         this.tui = tui;
         this.theme = theme;
         this.onClose = onClose;
-        this.sections = collectConfigSections();
+        this.sections = collectConfigSections(options);
     }
     invalidate() {
         this.cachedLines = undefined;

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

@@ -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";
@@ -15,7 +17,7 @@ import { createDbAdapter } from "../db-adapter.js";
 import { createBaseSchemaObjects } from "../db-base-schema.js";
 import { createCoordinationTablesV24 } from "../db-coordination-schema.js";
 import { createDbConnectionCache } from "../db-connection-cache.js";
-import { backupDatabaseBeforeMigration } from "../db-migration-backup.js";
+import { backupDatabaseBeforeMigration, isMigrationBackupError } from "../db-migration-backup.js";
 import { applyMigrationV2Artifacts, applyMigrationV3Memories, applyMigrationV4DecisionMadeBy, applyMigrationV5HierarchyTables, applyMigrationV6SliceSummaries, applyMigrationV7Dependencies, applyMigrationV8PlanningFields, applyMigrationV9Ordering, applyMigrationV10ReplanTrigger, applyMigrationV11TaskPlanning, applyMigrationV12QualityGates, applyMigrationV13HotPathIndexes, applyMigrationV14SliceDependencies, applyMigrationV15AuditTables, applyMigrationV16EscalationSource, applyMigrationV17TaskEscalation, applyMigrationV18MemorySources, applyMigrationV19MemoryFts, applyMigrationV20MemoryRelations, applyMigrationV21StructuredMemories, applyMigrationV22QualityGateRepair, applyMigrationV23MilestoneQueue, applyMigrationV26MilestoneCommitAttributions, applyMigrationV27ArtifactHash, applyMigrationV28MemoryLastHitAt, applyMigrationV29RepositoryTargets, } from "../db-migration-steps.js";
 import { isMemoriesFtsAvailableSchema, tryCreateMemoriesFtsSchema } from "../db-memory-fts-schema.js";
 import { createDbOpenState } from "../db-open-state.js";
@@ -526,8 +528,9 @@ export function openDatabase(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);
@@ -572,6 +575,10 @@ export function openDatabase(path) {
     }
     return true;
 }
+function shouldAttemptVacuumRecovery(fileBacked, err) {
+    return fileBacked && err instanceof Error && err.message.includes("malformed") && !isMigrationBackupError(err);
+}
+export const _shouldAttemptVacuumRecoveryForTest = shouldAttemptVacuumRecovery;
 export function closeDatabase() {
     if (currentDb) {
         try {
@@ -687,6 +694,7 @@ function createTransactionControls(db) {
     return {
         begin: () => db.exec("BEGIN"),
         beginRead: () => db.exec("BEGIN DEFERRED"),
+        beginImmediate: () => db.exec("BEGIN IMMEDIATE"),
         commit: () => db.exec("COMMIT"),
         rollback: () => db.exec("ROLLBACK"),
     };
@@ -705,6 +713,16 @@ export function transaction(fn) {
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     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(fn) {
+    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/dist/resources/extensions/gsd/db/queries.js

@@ -218,6 +218,36 @@ export function getMilestoneSlices(milestoneId) {
     const rows = getDbOrNull().prepare("SELECT * FROM slices WHERE milestone_id = :mid ORDER BY sequence, id").all({ ":mid": milestoneId });
     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) {
+    const db = getDbOrNull();
+    if (!db || milestoneIds.length === 0)
+        return new Map();
+    const idList = [...milestoneIds];
+    const placeholders = idList.map((_, i) => `:mid${i}`).join(",");
+    const params = {};
+    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);
+    const byMilestone = new Map();
+    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;
+}
 /**
  * Consolidated DB read for dispatch/gate/completion decisions (ADR-017).
  * `done` uses the canonical closed-status predicate (`isClosedStatus`) — the

package/dist/resources/extensions/gsd/db/writers/reconcile.js

@@ -10,6 +10,24 @@ import { createHash } from "node:crypto";
 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 = null;
+export function _setMainDbOpenerFnForTests(fn) {
+    const previous = _mainDbOpenerFn;
+    _mainDbOpenerFn = fn;
+    return () => { _mainDbOpenerFn = previous; };
+}
+function openMainDb(mainDbPath) {
+    return _mainDbOpenerFn ? _mainDbOpenerFn(mainDbPath) : openDatabase(mainDbPath);
+}
 export function copyWorktreeDb(srcDbPath, destDbPath) {
     try {
         if (!existsSync(srcDbPath))
@@ -61,7 +79,7 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
         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/dist/resources/extensions/gsd/db-migration-backup.js

@@ -1,5 +1,23 @@
 // Project/App: gsd-pi
 // File Purpose: Pre-migration backup helper for GSD database schema upgrades.
+/** Marks pre-migration backup failures so DB-open recovery cannot mask them. */
+export class MigrationBackupError extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+        this.name = "MigrationBackupError";
+    }
+}
+/** Returns true for errors raised while checkpointing or copying a migration backup. */
+export function isMigrationBackupError(err) {
+    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, dbPath, currentVersion, deps) {
     if (!dbPath || dbPath === ":memory:" || !deps.existsSync(dbPath))
         return;
@@ -7,16 +25,41 @@ export function backupDatabaseBeforeMigration(db, dbPath, currentVersion, deps)
         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) {
+    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) {
+    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, key) {
+    const value = row?.[key];
+    return value === undefined ? "unknown" : String(value);
+}
+function toMigrationBackupError(err) {
+    if (isMigrationBackupError(err))
+        return err;
+    const message = err instanceof Error ? err.message : String(err);
+    return new MigrationBackupError(message, err);
+}

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

@@ -6,29 +6,26 @@ export class DbTransactionRunner {
         return this.depth > 0;
     }
     transaction(controls, fn) {
-        if (this.depth > 0) {
-            return this.runNested(fn);
-        }
-        controls.begin();
-        this.depth++;
-        try {
-            const result = fn();
-            controls.commit();
-            return result;
-        }
-        catch (err) {
-            controls.rollback();
-            throw err;
-        }
-        finally {
-            this.depth--;
+        return this.runTransaction(controls, () => controls.begin(), fn);
+    }
+    /**
+     * Run a BEGIN IMMEDIATE transaction through the same depth counter as regular
+     * transactions so callers can compose it inside existing transaction scopes.
+     */
+    immediateTransaction(controls, fn) {
+        if (!controls.beginImmediate) {
+            throw new Error("db transaction controls do not support immediate transactions");
         }
+        return this.runTransaction(controls, () => controls.beginImmediate(), fn);
     }
     readTransaction(controls, fn, logRollbackError) {
+        return this.runTransaction(controls, () => controls.beginRead(), fn, logRollbackError);
+    }
+    runTransaction(controls, begin, fn, logRollbackError) {
         if (this.depth > 0) {
             return this.runNested(fn);
         }
-        controls.beginRead();
+        begin();
         this.depth++;
         try {
             const result = fn();
@@ -36,12 +33,7 @@ export class DbTransactionRunner {
             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 {
@@ -57,6 +49,18 @@ export class DbTransactionRunner {
             this.depth--;
         }
     }
+    rollback(controls, logRollbackError) {
+        if (!logRollbackError) {
+            controls.rollback();
+            return;
+        }
+        try {
+            controls.rollback();
+        }
+        catch (rollbackErr) {
+            logRollbackError(rollbackErr instanceof Error ? rollbackErr : new Error(String(rollbackErr)));
+        }
+    }
 }
 export function createDbTransactionRunner() {
     return new DbTransactionRunner();

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

@@ -620,27 +620,18 @@ async function mirrorDecisionToMemory(id, normalizedFields) {
 /**
  * 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) {
-    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;
 }