@opengsd/gsd-pi 1.2.0-dev.e8563f58 → 1.2.0-dev.fbdca60b

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/crash-recovery.js

@@ -186,6 +186,7 @@ export function writeLock(basePath, unitType, unitId, sessionFile) {
  * stale session-file pointer.
  */
 export function clearLock(basePath) {
+    const legacyLock = readLegacyLock(basePath);
     clearLegacyLockFile(basePath);
     if (!isDbAvailable())
         return;
@@ -198,9 +199,13 @@ export function clearLock(basePath) {
             deleteRuntimeKv("worker", staleWorker.worker_id, SESSION_FILE_KV_KEY);
             return;
         }
-        const lock = readLegacyLock(basePath);
-        if (lock?.pid)
-            markWorkerStoppingByPid(projectRoot, lock.pid);
+        if (legacyLock?.pid) {
+            markWorkerStoppingByPid(projectRoot, legacyLock.pid);
+            const workerByLegacyPid = getAllAutoWorkers().find((w) => w.pid === legacyLock.pid
+                && normalizeRealPath(w.project_root_realpath) === projectRoot);
+            if (workerByLegacyPid)
+                forceReleaseLeasesForWorker(workerByLegacyPid.worker_id);
+        }
         const worker = findActiveWorkerForCurrentProcess(projectRoot);
         if (worker)
             deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);

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-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;
 }

package/dist/resources/extensions/gsd/doctor-engine-checks.js

@@ -1,11 +1,11 @@
 import { existsSync, statSync } from "node:fs";
-import { join } from "node:path";
 import { isDbAvailable, _getAdapter } from "./gsd-db.js";
 import { isAfter, latestExplicitReopenAt } from "./milestone-reopen-events.js";
 import { resolveGsdPathContract, resolveMilestoneFile } from "./paths.js";
 import { deriveState } from "./state.js";
+import { workflowEventLogPath } from "./workflow-event-ledger.js";
 import { readEvents } from "./workflow-events.js";
-import { renderAllProjections } from "./workflow-projections.js";
+import { flushWorkflowProjections } from "./projection-flush.js";
 export async function checkEngineHealth(basePath, issues, fixesApplied) {
     const dbPath = resolveGsdPathContract(basePath).projectDb;
     if (!isDbAvailable() && existsSync(dbPath)) {
@@ -228,7 +228,7 @@ export async function checkEngineHealth(basePath, issues, fixesApplied) {
     // relative to the event log and re-render them.
     try {
         if (isDbAvailable()) {
-            const eventLogPath = join(basePath, ".gsd", "event-log.jsonl");
+            const eventLogPath = workflowEventLogPath(basePath);
             const events = readEvents(eventLogPath);
             if (events.length > 0) {
                 const lastEventTs = new Date(events[events.length - 1].ts).getTime();
@@ -239,7 +239,7 @@ export async function checkEngineHealth(basePath, issues, fixesApplied) {
                     const roadmapPath = resolveMilestoneFile(basePath, milestone.id, "ROADMAP");
                     if (!roadmapPath || !existsSync(roadmapPath)) {
                         try {
-                            await renderAllProjections(basePath, milestone.id);
+                            await flushWorkflowProjections(basePath, { milestoneId: milestone.id });
                             fixesApplied.push(`re-rendered missing projections for ${milestone.id}`);
                         }
                         catch {
@@ -250,7 +250,7 @@ export async function checkEngineHealth(basePath, issues, fixesApplied) {
                     const projectionMtime = statSync(roadmapPath).mtimeMs;
                     if (lastEventTs > projectionMtime) {
                         try {
-                            await renderAllProjections(basePath, milestone.id);
+                            await flushWorkflowProjections(basePath, { milestoneId: milestone.id });
                             fixesApplied.push(`re-rendered stale projections for ${milestone.id}`);
                         }
                         catch {