gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.710c06e97

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

@@ -0,0 +1,108 @@
+// Project/App: GSD-2
+// File Purpose: SQLite provider loading and fallback helpers for the GSD database facade.
+export const BETTER_SQLITE3_PACKAGE = ["better", "sqlite3"].join("-");
+export function suppressSqliteWarning() {
+    const origEmit = process.emit;
+    // Override via loose cast: Node's overloaded emit signature is not directly assignable.
+    process.emit = function (event, ...args) {
+        if (event === "warning" &&
+            args[0] &&
+            typeof args[0] === "object" &&
+            "name" in args[0] &&
+            args[0].name === "ExperimentalWarning" &&
+            "message" in args[0] &&
+            typeof args[0].message === "string" &&
+            args[0].message.includes("SQLite")) {
+            return false;
+        }
+        return origEmit.apply(process, [event, ...args]);
+    };
+}
+export class SqliteProviderLoader {
+    providerName = null;
+    providerModule = null;
+    loadAttempted = false;
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    load() {
+        if (this.loadAttempted)
+            return;
+        this.loadAttempted = true;
+        try {
+            this.deps.suppressSqliteWarning();
+            const mod = this.deps.requireModule("node:sqlite");
+            if (mod.DatabaseSync) {
+                this.providerModule = mod;
+                this.providerName = "node:sqlite";
+                return;
+            }
+        }
+        catch {
+            // unavailable
+        }
+        const betterSqlite = this.loadBetterSqliteModule();
+        if (betterSqlite) {
+            this.providerModule = betterSqlite;
+            this.providerName = "better-sqlite3";
+            return;
+        }
+        const nodeMajor = parseInt(this.deps.nodeVersion.split(".")[0], 10);
+        const versionHint = nodeMajor < 22
+            ? ` GSD requires Node >= 22.0.0 (current: v${this.deps.nodeVersion}). Upgrade Node to fix this.`
+            : "";
+        this.deps.writeStderr(`gsd-db: No SQLite provider available (tried node:sqlite, better-sqlite3).${versionHint}\n`);
+    }
+    getProviderName() {
+        return this.providerName;
+    }
+    openRaw(path) {
+        this.load();
+        if (!this.providerModule || !this.providerName)
+            return null;
+        if (this.providerName === "node:sqlite") {
+            const { DatabaseSync } = this.providerModule;
+            return new DatabaseSync(path);
+        }
+        const Database = this.providerModule;
+        return new Database(path);
+    }
+    tryOpenBetterSqliteFallback(path) {
+        if (this.providerName !== "node:sqlite")
+            return null;
+        const Database = this.loadBetterSqliteModule();
+        if (!Database)
+            return null;
+        return {
+            providerName: "better-sqlite3",
+            providerModule: Database,
+            rawDb: new Database(path),
+        };
+    }
+    commitFallback(fallback) {
+        this.providerName = fallback.providerName;
+        this.providerModule = fallback.providerModule;
+    }
+    reset() {
+        this.loadAttempted = false;
+        this.providerModule = null;
+        this.providerName = null;
+    }
+    loadBetterSqliteModule() {
+        try {
+            const mod = this.deps.requireModule(BETTER_SQLITE3_PACKAGE);
+            if (typeof mod === "function")
+                return mod;
+            if (mod && typeof mod.default === "function")
+                return mod.default;
+        }
+        catch {
+            // unavailable
+        }
+        return null;
+    }
+}
+export function createSqliteProviderLoader(deps) {
+    return new SqliteProviderLoader(deps);
+}

package/dist/resources/extensions/gsd/db-runtime-kv-schema.js

@@ -0,0 +1,27 @@
+// Project/App: GSD-2
+// File Purpose: Runtime key-value SQLite schema helper for the GSD database facade.
+/**
+ * Create the v25 runtime_kv table. Idempotent — uses IF NOT EXISTS.
+ *
+ * STRICT INVARIANT: runtime_kv is NON-CORRECTNESS-CRITICAL. UI cursors,
+ * dashboard caches, last-seen-version markers, resume cursors, and other
+ * "soft" state are OK. Anything that drives auto-mode control flow gets
+ * typed columns in unit_dispatches / workers / milestone_leases — never
+ * a bag of JSON in runtime_kv.
+ *
+ * Scope partitioning: ('global', '', key) for project-wide values;
+ * ('worker', worker_id, key) for per-worker state (resume cursors);
+ * ('milestone', milestone_id, key) for per-milestone soft state.
+ */
+export function createRuntimeKvTableV25(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS runtime_kv (
+      scope TEXT NOT NULL,
+      scope_id TEXT NOT NULL DEFAULT '',
+      key TEXT NOT NULL,
+      value_json TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (scope, scope_id, key)
+    )
+  `);
+}

package/dist/resources/extensions/gsd/db-schema-metadata.js

@@ -0,0 +1,23 @@
+// Project/App: GSD-2
+// File Purpose: SQLite schema metadata helpers for the GSD database facade and migrations.
+export function indexExists(db, name) {
+    return !!db.prepare("SELECT 1 as present FROM sqlite_master WHERE type = 'index' AND name = ?").get(name);
+}
+export function columnExists(db, table, column) {
+    const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+    return rows.some((row) => row["name"] === column);
+}
+export function ensureColumn(db, table, column, ddl) {
+    if (!columnExists(db, table, column))
+        db.exec(ddl);
+}
+export function getCurrentSchemaVersion(db) {
+    const row = db.prepare("SELECT MAX(version) as v FROM schema_version").get();
+    return row ? row["v"] : 0;
+}
+export function recordSchemaVersion(db, version) {
+    db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+        ":version": version,
+        ":applied_at": new Date().toISOString(),
+    });
+}

package/dist/resources/extensions/gsd/db-task-slice-rows.js

@@ -0,0 +1,86 @@
+// Project/App: GSD-2
+// File Purpose: Task and slice row mappers for the GSD database facade.
+export function parseTaskArrayColumn(raw) {
+    if (Array.isArray(raw)) {
+        return raw.filter((entry) => typeof entry === "string");
+    }
+    if (typeof raw !== "string")
+        return [];
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+            return parsed.filter((entry) => typeof entry === "string");
+        }
+        if (typeof parsed === "string" && parsed.trim()) {
+            return [parsed.trim()];
+        }
+        if (parsed === null || parsed === undefined || parsed === "") {
+            return [];
+        }
+        return [String(parsed)];
+    }
+    catch {
+        return trimmed.split(",").map((entry) => entry.trim()).filter(Boolean);
+    }
+}
+export function rowToSlice(row) {
+    return {
+        milestone_id: row["milestone_id"],
+        id: row["id"],
+        title: row["title"],
+        status: row["status"],
+        risk: row["risk"],
+        depends: JSON.parse(row["depends"] || "[]"),
+        demo: row["demo"] ?? "",
+        created_at: row["created_at"],
+        completed_at: row["completed_at"] ?? null,
+        full_summary_md: row["full_summary_md"] ?? "",
+        full_uat_md: row["full_uat_md"] ?? "",
+        goal: row["goal"] ?? "",
+        success_criteria: row["success_criteria"] ?? "",
+        proof_level: row["proof_level"] ?? "",
+        integration_closure: row["integration_closure"] ?? "",
+        observability_impact: row["observability_impact"] ?? "",
+        sequence: row["sequence"] ?? 0,
+        replan_triggered_at: row["replan_triggered_at"] ?? null,
+        is_sketch: row["is_sketch"] ?? 0,
+        sketch_scope: row["sketch_scope"] ?? "",
+    };
+}
+export function rowToTask(row) {
+    return {
+        milestone_id: row["milestone_id"],
+        slice_id: row["slice_id"],
+        id: row["id"],
+        title: row["title"],
+        status: row["status"],
+        one_liner: row["one_liner"],
+        narrative: row["narrative"],
+        verification_result: row["verification_result"],
+        duration: row["duration"],
+        completed_at: row["completed_at"] ?? null,
+        blocker_discovered: row["blocker_discovered"] === 1,
+        deviations: row["deviations"],
+        known_issues: row["known_issues"],
+        key_files: parseTaskArrayColumn(row["key_files"]),
+        key_decisions: parseTaskArrayColumn(row["key_decisions"]),
+        full_summary_md: row["full_summary_md"],
+        description: row["description"] ?? "",
+        estimate: row["estimate"] ?? "",
+        files: parseTaskArrayColumn(row["files"]),
+        verify: row["verify"] ?? "",
+        inputs: parseTaskArrayColumn(row["inputs"]),
+        expected_output: parseTaskArrayColumn(row["expected_output"]),
+        observability_impact: row["observability_impact"] ?? "",
+        full_plan_md: row["full_plan_md"] ?? "",
+        sequence: row["sequence"] ?? 0,
+        blocker_source: row["blocker_source"] ?? "",
+        escalation_pending: row["escalation_pending"] ?? 0,
+        escalation_awaiting_review: row["escalation_awaiting_review"] ?? 0,
+        escalation_artifact_path: row["escalation_artifact_path"] ?? null,
+        escalation_override_applied_at: row["escalation_override_applied_at"] ?? null,
+    };
+}

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

@@ -0,0 +1,63 @@
+// Project/App: GSD-2
+// File Purpose: Transaction depth helper for the GSD database facade.
+export class DbTransactionRunner {
+    depth = 0;
+    isInTransaction() {
+        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--;
+        }
+    }
+    readTransaction(controls, fn, logRollbackError) {
+        if (this.depth > 0) {
+            return this.runNested(fn);
+        }
+        controls.beginRead();
+        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)));
+            }
+            throw err;
+        }
+        finally {
+            this.depth--;
+        }
+    }
+    runNested(fn) {
+        this.depth++;
+        try {
+            return fn();
+        }
+        finally {
+            this.depth--;
+        }
+    }
+}
+export function createDbTransactionRunner() {
+    return new DbTransactionRunner();
+}

package/dist/resources/extensions/gsd/db-verification-evidence-rows.js

@@ -0,0 +1,3 @@
+// Project/App: GSD-2
+// File Purpose: Verification evidence row contract for GSD workflow database consumers.
+export {};

package/dist/resources/extensions/gsd/db-verification-evidence-schema.js

@@ -0,0 +1,19 @@
+// Project/App: GSD-2
+// File Purpose: Verification evidence SQLite schema helpers for the GSD database facade.
+import { indexExists } from "./db-schema-metadata.js";
+export function dedupeVerificationEvidenceRows(db) {
+    db.exec(`
+    DELETE FROM verification_evidence
+    WHERE rowid NOT IN (
+      SELECT MIN(rowid)
+      FROM verification_evidence
+      GROUP BY task_id, slice_id, milestone_id, command, verdict
+    )
+  `);
+}
+export function ensureVerificationEvidenceDedupIndex(db) {
+    if (indexExists(db, "idx_verification_evidence_dedup"))
+        return;
+    dedupeVerificationEvidenceRows(db);
+    db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_verification_evidence_dedup ON verification_evidence(task_id, slice_id, milestone_id, command, verdict)");
+}

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Mid-execution escalation artifact and state helpers for GSD tasks.
 // GSD Extension — ADR-011 Phase 2 Mid-Execution Escalation
 //
 // A single module that owns: escalation artifact I/O, detection, resolution,

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

@@ -89,10 +89,16 @@ export function writeGraph(runDir, graph) {
     renameSync(tmpPath, filePath);
 }
 /**
- * Get the next pending step whose dependencies are all complete.
+ * Return whether a graph step status satisfies dependency edges.
+ */
+export function isTerminalStepStatus(status) {
+    return status === "complete" || status === "expanded";
+}
+/**
+ * Get the next pending step whose dependencies are all terminal.
  *
  * Returns the first step (in array order) with status "pending" where
- * every step in its `dependsOn` list has status "complete".
+ * every step in its `dependsOn` list has status "complete" or "expanded".
  *
  * @param graph — the workflow graph to query
  * @returns The next dispatchable step, or null if none available
@@ -102,7 +108,7 @@ export function getNextPendingStep(graph) {
     for (const step of graph.steps) {
         if (step.status !== "pending")
             continue;
-        const depsComplete = step.dependsOn.every((depId) => statusMap.get(depId) === "complete");
+        const depsComplete = step.dependsOn.every((depId) => isTerminalStepStatus(statusMap.get(depId)));
         if (depsComplete)
             return step;
     }