gsd-pi 2.78.1-dev.0fdacd524 → 2.78.1-dev.2ff77b0ce

package/dist/resources/extensions/gsd/interrupted-session.js

@@ -1,16 +1,51 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { verifyExpectedArtifact } from "./auto-recovery.js";
 import { formatCrashInfo, isLockProcessAlive, readCrashLock, } from "./crash-recovery.js";
 import { gsdRoot } from "./paths.js";
+import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { synthesizeCrashRecovery, } from "./session-forensics.js";
 import { deriveState } from "./state.js";
+const LEGACY_DEEP_SETUP_UNITS = new Set([
+    "workflow-preferences:WORKFLOW-PREFS",
+    "discuss-project:PROJECT",
+    "discuss-requirements:REQUIREMENTS",
+    "research-decision:RESEARCH-DECISION",
+    "research-project:RESEARCH-PROJECT",
+]);
+function isStalePseudoMilestonePause(meta) {
+    if (meta.activeEngineId && meta.activeEngineId !== "dev")
+        return false;
+    if (meta.unitType === "discuss-milestone"
+        && typeof meta.unitId === "string"
+        && !MILESTONE_ID_RE.test(meta.unitId)) {
+        return true;
+    }
+    if (typeof meta.unitType === "string"
+        && typeof meta.unitId === "string"
+        && LEGACY_DEEP_SETUP_UNITS.has(`${meta.unitType}:${meta.unitId}`)) {
+        return true;
+    }
+    return typeof meta.milestoneId === "string"
+        && !MILESTONE_ID_RE.test(meta.milestoneId)
+        && typeof meta.unitType === "string"
+        && typeof meta.unitId === "string"
+        && LEGACY_DEEP_SETUP_UNITS.has(`${meta.unitType}:${meta.unitId}`);
+}
 export function readPausedSessionMetadata(basePath) {
     const pausedPath = join(gsdRoot(basePath), "runtime", "paused-session.json");
     if (!existsSync(pausedPath))
         return null;
     try {
-        return JSON.parse(readFileSync(pausedPath, "utf-8"));
+        const meta = JSON.parse(readFileSync(pausedPath, "utf-8"));
+        if (isStalePseudoMilestonePause(meta)) {
+            try {
+                unlinkSync(pausedPath);
+            }
+            catch { /* non-fatal */ }
+            return null;
+        }
+        return meta;
     }
     catch {
         return null;

package/dist/resources/extensions/gsd/key-manager.js

@@ -9,7 +9,7 @@ import { existsSync, statSync, chmodSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { mkdirSync } from "node:fs";
 import { getErrorMessage } from "./error-utils.js";
-import { getHomeDir } from "./home-dir.js";
+import { gsdHome } from "./gsd-home.js";
 export const PROVIDER_REGISTRY = [
     // LLM Providers
     { id: "anthropic", label: "Anthropic (Claude)", category: "llm", envVar: "ANTHROPIC_API_KEY", prefixes: ["sk-ant-"], hasOAuth: true, dashboardUrl: "console.anthropic.com" },
@@ -99,7 +99,7 @@ export function describeCredential(cred) {
  * Get the auth.json path.
  */
 export function getAuthPath() {
-    return join(getHomeDir(), ".gsd", "agent", "auth.json");
+    return join(gsdHome(), "agent", "auth.json");
 }
 /**
  * Create an AuthStorage instance for key management.

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -1,9 +1,8 @@
 // GSD Markdown Renderer — DB → Markdown file generation
 //
 // Transforms DB state into correct markdown files on disk.
-// Each render function reads from DB (with disk fallback),
-// patches content to match DB status, writes atomically to disk,
-// stores updated content in the artifacts table, and invalidates caches.
+// Each render function reads from DB, writes a markdown projection to disk,
+// stores generated content in the artifacts table, and invalidates caches.
 //
 // Critical invariant: rendered markdown must round-trip through
 // parseRoadmap(), parsePlan(), parseSummary() in files.ts.
@@ -36,46 +35,40 @@ function invalidateCaches() {
     clearPathCache();
     clearParseCache();
 }
+function meaningfulSection(value) {
+    const trimmed = (value ?? "").trim();
+    if (!trimmed)
+        return "";
+    if (/^(not provided\.?|none\.?|n\/a)$/i.test(trimmed))
+        return "";
+    if (/^\{\{[^}]+\}\}$/.test(trimmed))
+        return "";
+    return trimmed;
+}
+function pushIndented(lines, value, indent = "  ") {
+    for (const line of value.split("\n")) {
+        lines.push(`${indent}${line}`);
+    }
+}
+function taskSummaryForSlicePlan(description) {
+    const meaningful = meaningfulSection(description);
+    if (!meaningful)
+        return "";
+    const beforeHeading = meaningful.split(/\n#{1,6}\s+/)[0]?.trim() ?? "";
+    const firstBlock = beforeHeading.split(/\n\s*\n/)[0]?.trim() ?? "";
+    return firstBlock || beforeHeading;
+}
 /**
- * Load artifact content from DB first, falling back to reading from disk.
- * On disk fallback, stores the content in the artifacts table for future use.
- * Returns null if content is unavailable from both sources.
+ * Load artifact content from the DB. Markdown projections are not authoritative
+ * during runtime; when the artifact row is missing, callers regenerate from DB
+ * rows instead of patching disk fallback content and storing it back.
  */
-function loadArtifactContent(artifactPath, absPath, opts) {
-    // Try DB first
+function loadArtifactContent(artifactPath) {
     const artifact = getArtifact(artifactPath);
     if (artifact && artifact.full_content) {
         return artifact.full_content;
     }
-    // Fall back to disk
-    if (!absPath) {
-        process.stderr.write(`markdown-renderer: artifact not found in DB or on disk: ${artifactPath}\n`);
-        return null;
-    }
-    let content;
-    try {
-        content = readFileSync(absPath, "utf-8");
-    }
-    catch {
-        logWarning("renderer", `cannot read file from disk: ${absPath}`);
-        return null;
-    }
-    // Store in DB for future use (graceful degradation path)
-    try {
-        insertArtifact({
-            path: artifactPath,
-            artifact_type: opts.artifact_type,
-            milestone_id: opts.milestone_id,
-            slice_id: opts.slice_id ?? null,
-            task_id: opts.task_id ?? null,
-            full_content: content,
-        });
-    }
-    catch {
-        // Non-fatal: we have the content, DB storage is best-effort
-        logWarning("renderer", `failed to store disk fallback in DB: ${artifactPath}`);
-    }
-    return content;
+    return null;
 }
 /**
  * Write rendered content to disk and update the artifacts table.
@@ -130,7 +123,9 @@ function renderRoadmapMarkdown(milestone, slices) {
     return `${lines.join("\n").trimEnd()}\n`;
 }
 function renderTaskPlanMarkdown(task, taskGates = []) {
-    const estimatedSteps = Math.max(1, task.description.trim().split(/\n+/).filter(Boolean).length || 1);
+    const description = meaningfulSection(task.description);
+    const observabilityImpact = meaningfulSection(task.observability_impact);
+    const estimatedSteps = Math.max(1, description.split(/\n+/).filter(Boolean).length || 1);
     const estimatedFiles = task.files.length > 0
         ? task.files.length
         : task.expected_output.length > 0
@@ -147,8 +142,8 @@ function renderTaskPlanMarkdown(task, taskGates = []) {
     lines.push("");
     lines.push(`# ${task.id}: ${task.title || task.id}`);
     lines.push("");
-    if (task.description.trim()) {
-        lines.push(task.description.trim());
+    if (description) {
+        lines.push(description);
         lines.push("");
     }
     lines.push("## Inputs");
@@ -182,10 +177,10 @@ function renderTaskPlanMarkdown(task, taskGates = []) {
     lines.push("");
     lines.push(task.verify.trim() || "- Verify the task outcome with the slice-level checks.");
     lines.push("");
-    if (task.observability_impact.trim()) {
+    if (observabilityImpact) {
         lines.push("## Observability Impact");
         lines.push("");
-        lines.push(task.observability_impact.trim());
+        lines.push(observabilityImpact);
         lines.push("");
     }
     // ── Quality Gate Sections (Q5/Q6/Q7) ──────────────────────────────────
@@ -210,8 +205,9 @@ function renderSlicePlanMarkdown(slice, tasks, gates = []) {
     lines.push("");
     lines.push("## Must-Haves");
     lines.push("");
-    if (slice.success_criteria.trim()) {
-        for (const line of slice.success_criteria.split(/\n+/).map((entry) => entry.trim()).filter(Boolean)) {
+    const successCriteria = meaningfulSection(slice.success_criteria);
+    if (successCriteria) {
+        for (const line of successCriteria.split(/\n+/).map((entry) => entry.trim()).filter(Boolean)) {
             lines.push(line.startsWith("-") ? line : `- ${line}`);
         }
     }
@@ -234,22 +230,25 @@ function renderSlicePlanMarkdown(slice, tasks, gates = []) {
         lines.push(q4.findings.trim() || `- **Verdict:** ${q4.verdict}\n- **Rationale:** ${q4.rationale}`);
         lines.push("");
     }
-    if (slice.proof_level.trim()) {
+    const proofLevel = meaningfulSection(slice.proof_level);
+    if (proofLevel) {
         lines.push("## Proof Level");
         lines.push("");
-        lines.push(`- This slice proves: ${slice.proof_level.trim()}`);
+        lines.push(`- This slice proves: ${proofLevel}`);
         lines.push("");
     }
-    if (slice.integration_closure.trim()) {
+    const integrationClosure = meaningfulSection(slice.integration_closure);
+    if (integrationClosure) {
         lines.push("## Integration Closure");
         lines.push("");
-        lines.push(slice.integration_closure.trim());
+        lines.push(integrationClosure);
         lines.push("");
     }
     lines.push("## Verification");
     lines.push("");
-    if (slice.observability_impact.trim()) {
-        const verificationLines = slice.observability_impact
+    const verification = meaningfulSection(slice.observability_impact);
+    if (verification) {
+        const verificationLines = verification
             .split(/\n+/)
             .map((entry) => entry.trim())
             .filter(Boolean);
@@ -267,8 +266,9 @@ function renderSlicePlanMarkdown(slice, tasks, gates = []) {
         const done = isClosedStatus(task.status) ? "x" : " ";
         const estimate = task.estimate.trim() ? ` \`est:${task.estimate.trim()}\`` : "";
         lines.push(`- [${done}] **${task.id}: ${task.title || task.id}**${estimate}`);
-        if (task.description.trim()) {
-            lines.push(`  ${task.description.trim()}`);
+        const summary = taskSummaryForSlicePlan(task.description);
+        if (summary) {
+            pushIndented(lines, summary);
         }
         if (task.files.length > 0) {
             lines.push(`  - Files: ${task.files.map((file) => `\`${file}\``).join(", ")}`);
@@ -371,17 +371,14 @@ export async function renderRoadmapCheckboxes(basePath, milestoneId) {
     }
     const absPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
     const artifactPath = absPath ? toArtifactPath(absPath, basePath) : null;
-    // Load content from DB (with disk fallback)
+    // Load content from DB; regenerate from DB rows when the artifact is absent.
     let content = null;
     if (artifactPath) {
-        content = loadArtifactContent(artifactPath, absPath, {
-            artifact_type: "ROADMAP",
-            milestone_id: milestoneId,
-        });
+        content = loadArtifactContent(artifactPath);
     }
     if (!content) {
-        process.stderr.write(`markdown-renderer: no roadmap content available for ${milestoneId}\n`);
-        return false;
+        await renderRoadmapFromDb(basePath, milestoneId);
+        return true;
     }
     // Apply checkbox patches for each slice
     let updated = content;
@@ -424,15 +421,11 @@ export async function renderPlanCheckboxes(basePath, milestoneId, sliceId) {
     const artifactPath = absPath ? toArtifactPath(absPath, basePath) : null;
     let content = null;
     if (artifactPath) {
-        content = loadArtifactContent(artifactPath, absPath, {
-            artifact_type: "PLAN",
-            milestone_id: milestoneId,
-            slice_id: sliceId,
-        });
+        content = loadArtifactContent(artifactPath);
     }
     if (!content) {
-        process.stderr.write(`markdown-renderer: no plan content available for ${milestoneId}/${sliceId}\n`);
-        return false;
+        await renderPlanFromDb(basePath, milestoneId, sliceId);
+        return true;
     }
     // Apply checkbox patches for each task
     let updated = content;

package/dist/resources/extensions/gsd/migrate/command.js

@@ -13,8 +13,8 @@ import { resolve, join, dirname } from "node:path";
 import { gsdRoot } from "../paths.js";
 import { fileURLToPath } from "node:url";
 import { showNextAction } from "../../shared/tui.js";
-import { getHomeDir } from "../home-dir.js";
 import { validatePlanningDirectory, parsePlanningDirectory, transformToGSD, generatePreview, writeGSDDirectory, } from "./index.js";
+import { homedir } from "node:os";
 /** Format preview stats for embedding in the review prompt. */
 function formatPreviewStats(preview) {
     const lines = [
@@ -51,10 +51,10 @@ export async function handleMigrate(args, ctx, pi) {
     // Default to cwd when no args given; expand ~ to HOME
     let rawPath = args.trim() || ".";
     if (rawPath.startsWith("~/")) {
-        rawPath = join(getHomeDir(), rawPath.slice(2));
+        rawPath = join(homedir(), rawPath.slice(2));
     }
     else if (rawPath === "~") {
-        rawPath = getHomeDir();
+        rawPath = homedir();
     }
     let sourcePath = resolve(process.cwd(), rawPath);
     if (!sourcePath.endsWith(".planning")) {

package/dist/resources/extensions/gsd/milestone-scope-classifier.js

@@ -120,13 +120,14 @@ function mentionsWithoutNegation(text, term) {
         const start = m.index ?? 0;
         const windowStart = Math.max(0, start - 30);
         const window = lower.slice(windowStart, start);
-        // Negator anywhere in the 30-char lookback window counts as negation —
-        // covers "no backend", "without a server", "not using api", "zero
-        // dependencies on an api". If a sentence break intervenes between the
-        // negator and the term, treat as a different clause (positive mention).
-        const hasNegator = /(^|[^a-z0-9])(no|without|not|zero|skip(s|ping)?|drops?)\b/i.test(window);
-        const hasSentenceBreak = /[.;!?]/.test(window);
-        if (hasNegator && !hasSentenceBreak)
+        // Negator anywhere in the same clause counts as negation — covers "no
+        // backend", "without a server", "not using api", "zero dependencies on
+        // an api". Only inspect text after the most recent sentence break so
+        // "No backend. Add API" still treats API as a positive mention.
+        const lastBreak = Math.max(window.lastIndexOf("."), window.lastIndexOf(";"), window.lastIndexOf("!"), window.lastIndexOf("?"));
+        const clauseWindow = window.slice(lastBreak + 1);
+        const hasNegator = /(^|[^a-z0-9])(no|without|not|zero|skip(s|ping)?|drops?)\b/i.test(clauseWindow);
+        if (hasNegator)
             continue;
         return true;
     }
@@ -220,7 +221,8 @@ export function classifyMilestoneScope(input) {
         input.verificationOperational ?? "",
         input.verificationUat ?? "",
     ].join("\n");
-    const overrideHits = containsAnyKeyword(haystack, OVERRIDE_KEYWORDS);
+    const overrideHits = containsAnyKeyword(haystack, OVERRIDE_KEYWORDS)
+        .filter((kw) => mentionsWithoutNegation(haystack, kw));
     const complexHits = containsAnyKeyword(haystack, COMPLEX_KEYWORDS);
     const trivialHits = containsAnyKeyword(haystack, TRIVIAL_KEYWORDS);
     const fileCountHint = extractFileCountHint(haystack);

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -216,6 +216,20 @@ export function nativeIsRepo(basePath) {
         return false;
     }
 }
+/** Return true only when the repository has a reachable committed HEAD. */
+export function nativeHasCommittedHead(basePath) {
+    try {
+        execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
+            cwd: basePath,
+            stdio: ["ignore", "ignore", "ignore"],
+            env: GIT_NO_PROMPT_ENV,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Check if there are staged changes (index differs from HEAD).
  * Native: libgit2 tree-to-index diff.
@@ -746,56 +760,19 @@ export function nativeResetPaths(basePath, paths) {
         gitExec(basePath, ["reset", "HEAD", "--", p], true);
     }
 }
-/**
- * Read `commit.gpgsign` from the repo config. Returns true only if the value
- * is the literal string "true". Any other state (unset, false, error) → false.
- *
- * Used by nativeCommit to route signing-required commits through the git CLI,
- * because the libgit2 native path does not invoke configured signers.
- * (Issue #4980 CRIT-2)
- */
-function shouldSignCommits(basePath) {
-    try {
-        const result = execFileSync("git", ["config", "--get", "commit.gpgsign"], {
-            cwd: basePath,
-            stdio: ["ignore", "pipe", "pipe"],
-            encoding: "utf-8",
-            env: GIT_NO_PROMPT_ENV,
-        }).trim();
-        return result === "true";
-    }
-    catch {
-        return false;
-    }
-}
 /**
  * Create a commit from the current index.
  * Returns the commit SHA on success, or null if nothing to commit.
- * Native: libgit2 commit create.
- * Fallback: `git commit -F -` (runs hooks; honors commit.gpgsign).
+ * Uses `git commit -F -` so normal user hooks run and commit.gpgsign is honored.
  *
  * The fallback intentionally does NOT use --no-verify — user pre-commit /
  * commit-msg / prepare-commit-msg hooks must fire on every GSD-automated
  * commit. (Issue #4980 CRIT-1)
  */
 export function nativeCommit(basePath, message, options) {
-    const native = loadNative();
-    // libgit2's commit-create does not invoke configured GPG/SSH signers. When
-    // commit.gpgsign=true, route through the git CLI fallback so signing
-    // happens. (Issue #4980 CRIT-2)
-    if (native && !shouldSignCommits(basePath)) {
-        try {
-            return native.gitCommit(basePath, message, options?.allowEmpty);
-        }
-        catch (e) {
-            const msg = getErrorMessage(e);
-            if (msg.includes("nothing to commit"))
-                return null;
-            throw e;
-        }
-    }
-    // Fallback / signed-commit path: use git CLI with stdin pipe for safe
-    // multi-line messages. Hooks run; commit.gpgsign honored.
+    // Use git CLI with stdin pipe for safe multi-line messages. Hooks run;
+    // commit.gpgsign honored. libgit2 commit-create bypasses hooks, so automated
+    // GSD commits intentionally stay on the CLI path even when native git is on.
     try {
         const args = ["commit", "-F", "-"];
         if (options?.allowEmpty)
@@ -981,7 +958,7 @@ export function nativeBranchDelete(basePath, branch, force = true) {
         native.gitBranchDelete(basePath, branch, force);
         return;
     }
-    gitFileExec(basePath, ["branch", force ? "-D" : "-d", branch], true);
+    gitFileExec(basePath, ["branch", force ? "-D" : "-d", branch]);
 }
 /**
  * Force-reset a branch to point at a target ref.

package/dist/resources/extensions/gsd/onboarding-state.js

@@ -4,9 +4,9 @@
 // web boot probe all read the same source of truth. Replaces the implicit
 // "settings.defaultProvider exists" heuristic.
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { logWarning } from "./workflow-logger.js";
+import { gsdHome } from "./gsd-home.js";
 /**
  * Bump `FLOW_VERSION` whenever a new required step is added to ONBOARDING_STEPS.
  * Records with an older flowVersion are treated as "needs partial re-onboarding"
@@ -18,7 +18,7 @@ const RECORD_VERSION = 1;
 // rootDir-clean for the resources tsconfig; importing from src/ pulls files
 // outside src/resources and breaks the build.
 const AGENT_DIR = process.env.GSD_CODING_AGENT_DIR ||
-    join(process.env.GSD_HOME || join(homedir(), ".gsd"), "agent");
+    join(gsdHome(), "agent");
 const FILE = join(AGENT_DIR, "onboarding.json");
 const DEFAULT = {
     version: RECORD_VERSION,

package/dist/resources/extensions/gsd/parallel-merge.js

@@ -8,7 +8,7 @@ import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
 import { loadFile } from "./files.js";
-import { resolveMilestoneFile } from "./paths.js";
+import { resolveGsdPathContract, resolveMilestoneFile } from "./paths.js";
 import { mergeMilestoneToMain } from "./auto-worktree.js";
 import { MergeConflictError } from "./git-service.js";
 import { removeSessionStatus } from "./session-status-io.js";
@@ -16,12 +16,13 @@ import { getErrorMessage } from "./error-utils.js";
 import { logWarning } from "./workflow-logger.js";
 // ─── Merge Queue ───────────────────────────────────────────────────────────
 /**
- * Check whether a milestone is complete by querying its worktree SQLite DB.
+ * Check whether a milestone is complete by querying the canonical project DB.
  * Uses a subprocess to avoid disrupting the global DB singleton.
- * Returns true when milestones.status = 'complete' in the worktree's gsd.db.
+ * Returns true when milestones.status = 'complete' in project gsd.db.
  */
-export function isMilestoneCompleteInWorktreeDb(basePath, mid) {
-    const dbPath = join(basePath, ".gsd", "worktrees", mid, ".gsd", "gsd.db");
+export function isMilestoneCompleteInProjectDb(basePath, mid) {
+    const workRoot = join(basePath, ".gsd", "worktrees", mid);
+    const dbPath = resolveGsdPathContract(workRoot, basePath).projectDb;
     if (!existsSync(dbPath))
         return false;
     try {
@@ -34,15 +35,15 @@ export function isMilestoneCompleteInWorktreeDb(basePath, mid) {
     }
 }
 /**
- * Discover milestone IDs with status='complete' in their worktree DB,
- * scanning .gsd/worktrees/<MID>/.gsd/gsd.db for each worktree directory.
+ * Discover milestone IDs with status='complete' in the canonical DB,
+ * using worktree directories only to enumerate active parallel workers.
  */
 function discoverDbCompletedMilestones(basePath) {
     const completed = new Set();
     const worktreeDir = join(basePath, ".gsd", "worktrees");
     try {
         for (const entry of readdirSync(worktreeDir)) {
-            if (entry.startsWith("M") && isMilestoneCompleteInWorktreeDb(basePath, entry)) {
+            if (entry.startsWith("M") && isMilestoneCompleteInProjectDb(basePath, entry)) {
                 completed.add(entry);
             }
         }
@@ -57,15 +58,15 @@ function discoverDbCompletedMilestones(basePath) {
  * Sequential: merge in milestone ID order (M001 before M002).
  * By-completion: merge in the order milestones finished.
  *
- * When basePath is provided, also checks worktree SQLite DBs as the
- * source of truth — workers with stale orchestrator state (e.g. "error")
- * are included if their worktree DB shows status='complete'.
+ * When basePath is provided, also checks the canonical project DB as the
+ * source of truth. Workers with stale orchestrator state (e.g. "error")
+ * are included if their project DB row shows status='complete'.
  * See: https://github.com/gsd-build/gsd-2/issues/2812
  */
 export function determineMergeOrder(workers, order = "sequential", basePath) {
     // Start with workers the orchestrator already knows are stopped
     const stoppedIds = new Set(workers.filter(w => w.state === "stopped").map(w => w.milestoneId));
-    // When basePath is available, also check worktree DBs for milestones
+    // When basePath is available, also check the project DB for milestones
     // whose orchestrator state is stale but are actually complete (#2812)
     const dbCompleted = basePath ? discoverDbCompletedMilestones(basePath) : new Set();
     // Union: milestone is mergeable if stopped OR DB-complete
@@ -80,7 +81,7 @@ export function determineMergeOrder(workers, order = "sequential", basePath) {
             allMergeable.push(w);
         }
         else {
-            // Milestone discovered from worktree DB but not in workers list
+            // Milestone discovered from project DB but not in workers list
             allMergeable.push({
                 milestoneId: mid,
                 title: mid,

package/dist/resources/extensions/gsd/parallel-monitor-overlay.js

@@ -13,6 +13,7 @@ import { spawnSync } from "node:child_process";
 import { matchesKey, Key } from "@gsd/pi-tui";
 import { formatDuration } from "../shared/mod.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
+import { resolveGsdPathContract } from "./paths.js";
 // ─── Data Helpers ─────────────────────────────────────────────────────────
 function readJsonSafe(filePath) {
     try {
@@ -74,7 +75,8 @@ function discoverWorkers(basePath) {
     return [...mids].sort();
 }
 function querySliceProgress(basePath, mid) {
-    const dbPath = join(basePath, ".gsd", "worktrees", mid, ".gsd", "gsd.db");
+    const workRoot = join(basePath, ".gsd", "worktrees", mid);
+    const dbPath = resolveGsdPathContract(workRoot, basePath).projectDb;
     if (!existsSync(dbPath))
         return [];
     try {
@@ -119,7 +121,8 @@ function extractCostFromNdjson(basePath, mid) {
     }
 }
 function queryRecentCompletions(basePath, mid) {
-    const dbPath = join(basePath, ".gsd", "worktrees", mid, ".gsd", "gsd.db");
+    const workRoot = join(basePath, ".gsd", "worktrees", mid);
+    const dbPath = resolveGsdPathContract(workRoot, basePath).projectDb;
     if (!existsSync(dbPath))
         return [];
     try {