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

package/dist/resources/extensions/gsd/doctor-environment.js

@@ -9,7 +9,7 @@
  * integrate into the doctor pipeline via checkEnvironmentHealth().
  */
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { execSync } from "node:child_process";
+import { execFile, execSync } from "node:child_process";
 import { join } from "node:path";
 import { detectPythonExecutable } from "./python-resolver.js";
 import { projectRootFromWorktreePath } from "./worktree-root.js";
@@ -56,44 +56,49 @@ function commandExists(name, cwd) {
 /**
  * Check that Node.js version meets the project's engines requirement.
  */
-function checkNodeVersion(basePath) {
+function readPackageEngineNode(basePath) {
     const pkgPath = join(basePath, "package.json");
     if (!existsSync(pkgPath))
         return null;
     try {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        const required = pkg.engines?.node;
-        if (!required)
-            return null;
-        const currentVersion = tryExec("node --version", basePath);
-        if (!currentVersion) {
-            return { name: "node_version", status: "error", message: "Node.js not found in PATH" };
-        }
-        // Parse semver requirement (handles >=X.Y.Z format)
-        const reqMatch = required.match(/>=?\s*(\d+)(?:\.(\d+))?/);
-        if (!reqMatch)
-            return null;
-        const reqMajor = parseInt(reqMatch[1], 10);
-        const reqMinor = parseInt(reqMatch[2] ?? "0", 10);
-        const curMatch = currentVersion.match(/v?(\d+)\.(\d+)/);
-        if (!curMatch)
-            return null;
-        const curMajor = parseInt(curMatch[1], 10);
-        const curMinor = parseInt(curMatch[2], 10);
-        if (curMajor < reqMajor || (curMajor === reqMajor && curMinor < reqMinor)) {
-            return {
-                name: "node_version",
-                status: "warning",
-                message: `Node.js ${currentVersion} does not meet requirement "${required}"`,
-                detail: `Current: ${currentVersion}, Required: ${required}`,
-            };
-        }
-        return { name: "node_version", status: "ok", message: `Node.js ${currentVersion}` };
+        return pkg.engines?.node ?? null;
     }
     catch {
         return null;
     }
 }
+function buildNodeVersionResult(required, currentVersion) {
+    if (!currentVersion) {
+        return { name: "node_version", status: "error", message: "Node.js not found in PATH" };
+    }
+    // Parse semver requirement (handles >=X.Y.Z format)
+    const reqMatch = required.match(/>=?\s*(\d+)(?:\.(\d+))?/);
+    if (!reqMatch)
+        return null;
+    const reqMajor = parseInt(reqMatch[1], 10);
+    const reqMinor = parseInt(reqMatch[2] ?? "0", 10);
+    const curMatch = currentVersion.match(/v?(\d+)\.(\d+)/);
+    if (!curMatch)
+        return null;
+    const curMajor = parseInt(curMatch[1], 10);
+    const curMinor = parseInt(curMatch[2], 10);
+    if (curMajor < reqMajor || (curMajor === reqMajor && curMinor < reqMinor)) {
+        return {
+            name: "node_version",
+            status: "warning",
+            message: `Node.js ${currentVersion} does not meet requirement "${required}"`,
+            detail: `Current: ${currentVersion}, Required: ${required}`,
+        };
+    }
+    return { name: "node_version", status: "ok", message: `Node.js ${currentVersion}` };
+}
+function checkNodeVersion(basePath) {
+    const required = readPackageEngineNode(basePath);
+    if (!required)
+        return null;
+    return buildNodeVersionResult(required, tryExec("node --version", basePath));
+}
 /**
  * Check if node_modules exists and is not stale vs the lockfile.
  */
@@ -184,20 +189,15 @@ function checkEnvFiles(basePath) {
  * Check for port conflicts on common dev server ports.
  * Only checks ports that appear in package.json scripts.
  */
-function checkPortConflicts(basePath) {
-    // Only run on macOS/Linux — lsof is not available on Windows
-    if (process.platform === "win32")
-        return [];
-    const results = [];
-    // Try to detect ports from package.json scripts
+// Detect the dev ports worth checking from package.json scripts, falling back to
+// common defaults. Returns an empty set when there's no Node project (no
+// package.json) or a parse failure — the caller then skips port checks entirely,
+// avoiding false positives from system services (e.g. macOS AirPlay on 5000, #1381).
+function collectPortsToCheck(basePath) {
     const portsToCheck = new Set();
     const pkgPath = join(basePath, "package.json");
-    if (!existsSync(pkgPath)) {
-        // No package.json — this isn't a Node.js project. Skip port checks
-        // entirely to avoid false positives from system services (e.g., macOS
-        // AirPlay Receiver on port 5000). (#1381)
-        return [];
-    }
+    if (!existsSync(pkgPath))
+        return portsToCheck;
     try {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
         const scripts = pkg.scripts ?? {};
@@ -211,11 +211,8 @@ function checkPortConflicts(basePath) {
         }
     }
     catch {
-        // parse failed — skip port checks rather than using defaults
-        return [];
+        return new Set();
     }
-    // If no ports found in scripts, check common defaults.
-    // Filter out port 5000 on macOS — AirPlay Receiver uses it by default (#1381).
     if (portsToCheck.size === 0) {
         for (const p of DEFAULT_DEV_PORTS) {
             if (p === 5000 && process.platform === "darwin")
@@ -223,30 +220,54 @@ function checkPortConflicts(basePath) {
             portsToCheck.add(p);
         }
     }
+    return portsToCheck;
+}
+// Parse a single `lsof -nP -iTCP -sTCP:LISTEN` scan and report which of the
+// requested ports are in use. Replaces the old per-port lsof loop (up to ~14
+// system-wide socket scans, ~350ms) with one scan + an in-memory lookup.
+function buildPortConflictResults(lsofOut, portsToCheck) {
+    const results = [];
+    const listening = new Map();
+    if (lsofOut) {
+        for (const line of lsofOut.split("\n")) {
+            // COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
+            // e.g. `node 12345 user 23u IPv4 0x.. 0t0 TCP *:3000 (LISTEN)`
+            const portMatch = line.match(/:(\d+)(?:\s+\(LISTEN\))?\s*$/);
+            if (!portMatch)
+                continue;
+            const port = parseInt(portMatch[1], 10);
+            if (!Number.isFinite(port) || listening.has(port))
+                continue;
+            const cols = line.split(/\s+/);
+            listening.set(port, { command: cols[0] ?? "unknown", pid: cols[1] ?? "?" });
+        }
+    }
     for (const port of portsToCheck) {
-        const result = tryExec(`lsof -i :${port} -sTCP:LISTEN -t`, basePath);
-        if (result && result.length > 0) {
-            // Get process name
-            const nameResult = tryExec(`lsof -i :${port} -sTCP:LISTEN -Fp | head -2`, basePath);
-            const processName = nameResult?.match(/p(\d+)\n?c?(.+)?/)?.[2] ?? "unknown";
+        const hit = listening.get(port);
+        if (hit) {
             results.push({
                 name: "port_conflict",
                 status: "warning",
-                message: `Port ${port} is already in use by ${processName} (PID ${result.split("\n")[0]})`,
+                message: `Port ${port} is already in use by ${hit.command} (PID ${hit.pid})`,
                 detail: `Kill the process or use a different port`,
             });
         }
     }
     return results;
 }
+function checkPortConflicts(basePath) {
+    // Only run on macOS/Linux — lsof is not available on Windows
+    if (process.platform === "win32")
+        return [];
+    const portsToCheck = collectPortsToCheck(basePath);
+    if (portsToCheck.size === 0)
+        return [];
+    return buildPortConflictResults(tryExec("lsof -nP -iTCP -sTCP:LISTEN", basePath), portsToCheck);
+}
 /**
  * Check available disk space on the working directory partition.
  */
-function checkDiskSpace(basePath) {
-    // Only run on macOS/Linux
-    if (process.platform === "win32")
-        return null;
-    const dfOutput = tryExec(`df -k "${basePath}" | tail -1`, basePath);
+function buildDiskSpaceResult(dfOutput) {
     if (!dfOutput)
         return null;
     try {
@@ -267,11 +288,7 @@ function checkDiskSpace(basePath) {
             };
         }
         if (availBytes < MIN_DISK_BYTES * 4) {
-            return {
-                name: "disk_space",
-                status: "warning",
-                message: `Disk space getting low: ${availGB}GB free`,
-            };
+            return { name: "disk_space", status: "warning", message: `Disk space getting low: ${availGB}GB free` };
         }
         return { name: "disk_space", status: "ok", message: `${availGB}GB free` };
     }
@@ -279,16 +296,24 @@ function checkDiskSpace(basePath) {
         return null;
     }
 }
+function checkDiskSpace(basePath) {
+    // Only run on macOS/Linux
+    if (process.platform === "win32")
+        return null;
+    return buildDiskSpaceResult(tryExec(`df -k "${basePath}" | tail -1`, basePath));
+}
 /**
  * Check if Docker is available when project has a Dockerfile.
  */
-function checkDocker(basePath) {
-    const hasDockerfile = existsSync(join(basePath, "Dockerfile")) ||
+function hasDockerConfig(basePath) {
+    return existsSync(join(basePath, "Dockerfile")) ||
         existsSync(join(basePath, "docker-compose.yml")) ||
         existsSync(join(basePath, "docker-compose.yaml")) ||
         existsSync(join(basePath, "compose.yml")) ||
         existsSync(join(basePath, "compose.yaml"));
-    if (!hasDockerfile)
+}
+function checkDocker(basePath) {
+    if (!hasDockerConfig(basePath))
         return null;
     if (!commandExists("docker", basePath)) {
         return {
@@ -308,74 +333,62 @@ function checkDocker(basePath) {
     }
     return { name: "docker", status: "ok", message: `Docker ${info}` };
 }
-/**
- * Check for common project tools that should be available.
- */
-function checkProjectTools(basePath) {
-    const results = [];
+// Decide which project tools to verify from package.json + marker files (pure fs).
+// The actual `command -v` probes are left to the sync/async checkers so both share
+// this logic.
+function readProjectToolSpec(basePath) {
     const pkgPath = join(basePath, "package.json");
     if (!existsSync(pkgPath))
-        return results;
+        return null;
     try {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        const allDeps = {
-            ...(pkg.dependencies ?? {}),
-            ...(pkg.devDependencies ?? {}),
-        };
-        // Check for package manager
-        const packageManager = pkg.packageManager;
-        if (packageManager) {
-            const managerName = packageManager.split("@")[0];
-            if (managerName && managerName !== "npm" && !commandExists(managerName, basePath)) {
-                results.push({
-                    name: "package_manager",
-                    status: "warning",
-                    message: `Project requires ${managerName} but it's not installed`,
-                    detail: `Install with: npm install -g ${managerName}`,
-                });
-            }
-        }
-        // Check for TypeScript if it's a dependency
-        if (allDeps["typescript"] && !existsSync(join(basePath, "node_modules", ".bin", "tsc"))) {
-            results.push({
-                name: "typescript",
-                status: "warning",
-                message: "TypeScript is a dependency but tsc is not available (run npm install)",
-            });
-        }
-        // Check for Python if pyproject.toml or requirements.txt exists
-        if (existsSync(join(basePath, "pyproject.toml")) || existsSync(join(basePath, "requirements.txt"))) {
-            if (detectPythonExecutable() === null) {
-                results.push({
-                    name: "python",
-                    status: "warning",
-                    message: "Project has Python config but python is not installed",
-                });
-            }
-        }
-        // Check for Rust if Cargo.toml exists
-        if (existsSync(join(basePath, "Cargo.toml"))) {
-            if (!commandExists("cargo", basePath)) {
-                results.push({
-                    name: "cargo",
-                    status: "warning",
-                    message: "Project has Cargo.toml but cargo is not installed",
-                });
-            }
-        }
-        // Check for Go if go.mod exists
-        if (existsSync(join(basePath, "go.mod"))) {
-            if (!commandExists("go", basePath)) {
-                results.push({
-                    name: "go",
-                    status: "warning",
-                    message: "Project has go.mod but go is not installed",
-                });
-            }
+        const allDeps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+        let packageManager = null;
+        if (pkg.packageManager) {
+            const managerName = String(pkg.packageManager).split("@")[0];
+            if (managerName && managerName !== "npm")
+                packageManager = managerName;
         }
+        return {
+            packageManager,
+            needsTsc: Boolean(allDeps["typescript"]) && !existsSync(join(basePath, "node_modules", ".bin", "tsc")),
+            needsPython: existsSync(join(basePath, "pyproject.toml")) || existsSync(join(basePath, "requirements.txt")),
+            needsCargo: existsSync(join(basePath, "Cargo.toml")),
+            needsGo: existsSync(join(basePath, "go.mod")),
+        };
     }
     catch {
-        // parse failed — skip
+        return null;
+    }
+}
+function checkProjectTools(basePath) {
+    const spec = readProjectToolSpec(basePath);
+    if (!spec)
+        return [];
+    const results = [];
+    if (spec.packageManager && !commandExists(spec.packageManager, basePath)) {
+        results.push({
+            name: "package_manager",
+            status: "warning",
+            message: `Project requires ${spec.packageManager} but it's not installed`,
+            detail: `Install with: npm install -g ${spec.packageManager}`,
+        });
+    }
+    if (spec.needsTsc) {
+        results.push({
+            name: "typescript",
+            status: "warning",
+            message: "TypeScript is a dependency but tsc is not available (run npm install)",
+        });
+    }
+    if (spec.needsPython && detectPythonExecutable() === null) {
+        results.push({ name: "python", status: "warning", message: "Project has Python config but python is not installed" });
+    }
+    if (spec.needsCargo && !commandExists("cargo", basePath)) {
+        results.push({ name: "cargo", status: "warning", message: "Project has Cargo.toml but cargo is not installed" });
+    }
+    if (spec.needsGo && !commandExists("go", basePath)) {
+        results.push({ name: "go", status: "warning", message: "Project has go.mod but go is not installed" });
     }
     return results;
 }
@@ -461,6 +474,124 @@ function checkTestHealth(basePath) {
  * Run all environment health checks. Returns structured results for
  * integration with the doctor pipeline.
  */
+// ── Async variants ─────────────────────────────────────────────────────────
+// The always-on health widget refreshes off the first-paint path, but the sync
+// `runEnvironmentChecks` blocks the event loop on its subprocess checks (~300ms,
+// and again every 60s). These async siblings run the same checks via non-blocking
+// `execFile` and fan the independent ones out concurrently, so the UI thread never
+// stalls. The sync API above is unchanged for /gsd doctor and the dashboards.
+function tryExecAsync(cmd, cwd) {
+    return new Promise((resolve) => {
+        const isWin = process.platform === "win32";
+        const child = execFile(isWin ? "cmd" : "sh", isWin ? ["/c", cmd] : ["-c", cmd], { cwd, timeout: CMD_TIMEOUT, encoding: "utf-8" }, (err, stdout) => resolve(err ? null : String(stdout).trim()));
+        child.on("error", () => resolve(null));
+    });
+}
+async function commandExistsAsync(name, cwd) {
+    const whichCmd = process.platform === "win32" ? `where ${name}` : `command -v ${name}`;
+    return (await tryExecAsync(whichCmd, cwd)) !== null;
+}
+async function checkNodeVersionAsync(basePath) {
+    const required = readPackageEngineNode(basePath);
+    if (!required)
+        return null;
+    const currentVersion = await tryExecAsync("node --version", basePath);
+    return buildNodeVersionResult(required, currentVersion);
+}
+async function checkPortConflictsAsync(basePath) {
+    if (process.platform === "win32")
+        return [];
+    const portsToCheck = collectPortsToCheck(basePath);
+    if (portsToCheck.size === 0)
+        return [];
+    const lsofOut = await tryExecAsync("lsof -nP -iTCP -sTCP:LISTEN", basePath);
+    return buildPortConflictResults(lsofOut, portsToCheck);
+}
+async function checkDiskSpaceAsync(basePath) {
+    if (process.platform === "win32")
+        return null;
+    return buildDiskSpaceResult(await tryExecAsync(`df -k "${basePath}" | tail -1`, basePath));
+}
+async function checkDockerAsync(basePath) {
+    if (!hasDockerConfig(basePath))
+        return null;
+    if (!(await commandExistsAsync("docker", basePath))) {
+        return { name: "docker", status: "warning", message: "Project has Docker files but docker is not installed" };
+    }
+    const info = await tryExecAsync("docker info --format '{{.ServerVersion}}'", basePath);
+    if (!info) {
+        return {
+            name: "docker",
+            status: "warning",
+            message: "Docker is installed but daemon is not running",
+            detail: "Start Docker Desktop or the docker daemon",
+        };
+    }
+    return { name: "docker", status: "ok", message: `Docker ${info}` };
+}
+async function checkProjectToolsAsync(basePath) {
+    const spec = readProjectToolSpec(basePath);
+    if (!spec)
+        return [];
+    const results = [];
+    if (spec.packageManager && !(await commandExistsAsync(spec.packageManager, basePath))) {
+        results.push({
+            name: "package_manager",
+            status: "warning",
+            message: `Project requires ${spec.packageManager} but it's not installed`,
+            detail: `Install with: npm install -g ${spec.packageManager}`,
+        });
+    }
+    if (spec.needsTsc) {
+        results.push({
+            name: "typescript",
+            status: "warning",
+            message: "TypeScript is a dependency but tsc is not available (run npm install)",
+        });
+    }
+    if (spec.needsPython && detectPythonExecutable() === null) {
+        results.push({ name: "python", status: "warning", message: "Project has Python config but python is not installed" });
+    }
+    if (spec.needsCargo && !(await commandExistsAsync("cargo", basePath))) {
+        results.push({ name: "cargo", status: "warning", message: "Project has Cargo.toml but cargo is not installed" });
+    }
+    if (spec.needsGo && !(await commandExistsAsync("go", basePath))) {
+        results.push({ name: "go", status: "warning", message: "Project has go.mod but go is not installed" });
+    }
+    return results;
+}
+/**
+ * Non-blocking equivalent of `runEnvironmentChecks` for the health-widget
+ * background refresh. Cheap fs checks run inline; the subprocess-backed checks
+ * fan out concurrently so the whole suite costs ~max(check), not the sum.
+ */
+export async function runEnvironmentChecksAsync(basePath) {
+    const results = [];
+    // fs-only checks — already cheap and synchronous.
+    const depsCheck = checkDependenciesInstalled(basePath);
+    if (depsCheck)
+        results.push(depsCheck);
+    const envCheck = checkEnvFiles(basePath);
+    if (envCheck)
+        results.push(envCheck);
+    // subprocess-backed checks — run concurrently, off the event-loop critical path.
+    const [nodeCheck, portChecks, diskCheck, dockerCheck, toolChecks] = await Promise.all([
+        checkNodeVersionAsync(basePath),
+        checkPortConflictsAsync(basePath),
+        checkDiskSpaceAsync(basePath),
+        checkDockerAsync(basePath),
+        checkProjectToolsAsync(basePath),
+    ]);
+    if (nodeCheck)
+        results.push(nodeCheck);
+    results.push(...portChecks);
+    if (diskCheck)
+        results.push(diskCheck);
+    if (dockerCheck)
+        results.push(dockerCheck);
+    results.push(...toolChecks);
+    return results;
+}
 export function runEnvironmentChecks(basePath) {
     const results = [];
     const nodeCheck = checkNodeVersion(basePath);

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

@@ -6,6 +6,7 @@ import { loadFile } from "./files.js";
 import { resolveMilestoneFile } from "./paths.js";
 import { isCompletedMilestoneTerminal } from "./milestone-closeout.js";
 import { deriveState } from "./state.js";
+import { isClosedStatus } from "./status-guards.js";
 import { allWorktreesDirs, createWorktree, listWorktrees, resolveGitDir } from "./worktree-manager.js";
 import { abortAndReset } from "./git-self-heal.js";
 import { RUNTIME_EXCLUSION_PATHS, resolveMilestoneIntegrationBranch, writeIntegrationBranch } from "./git-service.js";
@@ -174,7 +175,7 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                 const milestoneId = wt.branch.replace(/^milestone\//, "");
                 const milestoneEntry = state.registry.find(m => m.id === milestoneId);
                 const isComplete = milestoneEntry
-                    ? await isCompletedMilestoneTerminal(basePath, milestoneId)
+                    ? isClosedStatus(milestoneEntry.status)
                     : false;
                 if (!isComplete && !hasProjectContentOnDisk(wt.path) && hasProjectContentOnDisk(basePath)) {
                     issues.push({
@@ -269,6 +270,9 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                         const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
                         if (!roadmapContent)
                             continue;
+                        const milestoneEntry = state.registry.find(m => m.id === milestoneId);
+                        if (!milestoneEntry || !isClosedStatus(milestoneEntry.status))
+                            continue;
                         branchMilestoneComplete = await isCompletedMilestoneTerminal(basePath, milestoneId);
                         if (branchMilestoneComplete) {
                             issues.push({

package/dist/resources/extensions/gsd/doctor-providers.js

@@ -35,7 +35,7 @@ const CLI_AUTH_PROVIDERS = new Set([
 const PROVIDER_ROUTES = {
     anthropic: ["github-copilot", "claude-code"],
     openai: ["github-copilot", "openai-codex"],
-    google: ["google-gemini-cli"],
+    google: ["google-antigravity", "google-gemini-cli"],
 };
 // ── Model → Provider ID mapping ───────────────────────────────────────────────
 /**

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

@@ -53,19 +53,21 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
         if (lock) {
             const alive = isLockProcessAlive(lock);
             if (!alive) {
-                issues.push({
-                    severity: "error",
-                    code: "stale_crash_lock",
-                    scope: "project",
-                    unitId: "project",
-                    message: `Stale auto-mode worker (PID ${lock.pid}, started ${lock.startedAt}, was executing ${lock.unitType} ${lock.unitId}) — process is no longer running`,
-                    file: "<workers table>",
-                    fixable: true,
-                });
                 if (shouldFix("stale_crash_lock")) {
                     clearStaleWorkerLock(basePath);
                     fixesApplied.push("cleared stale auto-mode worker state");
                 }
+                else {
+                    issues.push({
+                        severity: "error",
+                        code: "stale_crash_lock",
+                        scope: "project",
+                        unitId: "project",
+                        message: `Stale auto-mode worker (PID ${lock.pid}, started ${lock.startedAt}, was executing ${lock.unitType} ${lock.unitId}) — process is no longer running`,
+                        file: "<workers table>",
+                        fixable: true,
+                    });
+                }
             }
         }
     }

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

@@ -3,13 +3,15 @@
 //
 // ─── Single-writer invariant ─────────────────────────────────────────────
 // Every write-SQL statement against `.gsd/gsd.db` lives behind a typed
-// wrapper in the single-writer layer (this file plus db/writers/*). Connection
-// ownership, lifecycle, schema/migrations and transaction primitives live in
-// db/engine.ts and are re-exported here for backward compatibility, so callers
-// keep importing from "./gsd-db.js".
+// wrapper in the explicit writer allowlist: this compatibility barrel,
+// db/writers/*, typed coordination/runtime writers, schema/migration helpers,
+// and ADR backfill helpers. Connection ownership, lifecycle, schema/migrations,
+// and transaction primitives live in db/engine.ts and are re-exported here for
+// backward compatibility, so callers keep importing from "./gsd-db.js".
 //
 // `_getAdapter()` (re-exported from the engine) is retained for read-only
-// SELECTs in query modules. Do NOT use it for writes — add a wrapper here.
+// SELECTs in query modules. Do NOT use it for writes — add or call a typed
+// wrapper in the explicit writer layer.
 //
 // The separate `.gsd/unit-claims.db` (unit-ownership.ts) is an intentionally
 // independent store and is excluded from this invariant.
@@ -22,10 +24,10 @@ import { isClosedStatus } from "./status-guards.js";
 // primitives now live in the engine; re-export the full public surface so
 // existing `from "./gsd-db.js"` imports keep working.
 export * from "./db/engine.js";
-import { transaction, getDbOrNull } from "./db/engine.js";
+import { immediateTransaction, transaction, getDb, getDbOrNull } from "./db/engine.js";
 // ─── Single Writer Layer re-exports ──────────────────────────────────────
-// Write subsystems live in db/writers/*; re-exported here so callers keep
-// importing from "./gsd-db.js".
+// Domain write subsystems live in db/writers/*; re-exported here so callers
+// keep importing from "./gsd-db.js".
 export * from "./db/writers/memory.js";
 export * from "./db/writers/reconcile.js";
 export * from "./db/writers/import-restore.js";
@@ -529,21 +531,14 @@ export function insertVerificationEvidence(e) {
     });
 }
 export function setMilestoneQueueOrder(order) {
-    if (!getDbOrNull())
-        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    getDbOrNull().exec("BEGIN IMMEDIATE");
-    try {
-        getDbOrNull().prepare("UPDATE milestones SET sequence = 0").run();
-        const stmt = getDbOrNull().prepare("UPDATE milestones SET sequence = :sequence WHERE id = :id");
+    const db = getDb();
+    immediateTransaction(() => {
+        db.prepare("UPDATE milestones SET sequence = 0").run();
+        const stmt = db.prepare("UPDATE milestones SET sequence = :sequence WHERE id = :id");
         order.forEach((id, index) => {
             stmt.run({ ":id": id, ":sequence": index + 1 });
         });
-        getDbOrNull().exec("COMMIT");
-    }
-    catch (err) {
-        getDbOrNull().exec("ROLLBACK");
-        throw err;
-    }
+    });
 }
 function getMilestoneStatusForUpdate(milestoneId) {
     if (!getDbOrNull())