@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.738160b9

package/dist/resources/extensions/gsd/exec-sandbox.js

@@ -11,7 +11,7 @@ import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { resolve } from "node:path";
-import { killProcessTree, SIGKILL_GRACE_MS, HARD_DEADLINE_MS } from "@gsd/pi-coding-agent";
+import { getShellConfig, killProcessTree, SIGKILL_GRACE_MS, HARD_DEADLINE_MS } from "@gsd/pi-coding-agent";
 const ALWAYS_FORWARD_ENV = ["PATH", "HOME"];
 // SIGKILL_GRACE_MS / HARD_DEADLINE_MS are imported from @gsd/pi-coding-agent
 // (shell.ts) — the single source of truth for the graceful-kill timing ladder —
@@ -60,7 +60,13 @@ function clampTimeout(request, opts) {
 function resolveCommand(runtime) {
     switch (runtime) {
         case "bash":
-            return { cmd: "bash", args: ["-c"] };
+            try {
+                const { shell, args } = getShellConfig();
+                return { cmd: shell, args };
+            }
+            catch {
+                return { cmd: "bash", args: ["-c"] };
+            }
         case "node":
             return { cmd: process.execPath, args: ["-e"] };
         case "python":
@@ -180,10 +186,22 @@ export function runExecSandbox(request, opts) {
         const effectiveGraceMs = opts.kill_grace_ms ?? SIGKILL_GRACE_MS;
         const effectiveForceResolveDelay = opts.force_resolve_delay_ms ?? (effectiveGraceMs + HARD_DEADLINE_MS);
         let timedOut = false;
+        let aborted = false;
         let settled = false;
+        let killInitiated = false;
+        let timer;
         let forceResolveTimer;
-        const timer = setTimeout(() => {
-            timedOut = true;
+        let abortListener;
+        const removeAbortListener = () => {
+            if (opts.signal && abortListener) {
+                opts.signal.removeEventListener("abort", abortListener);
+                abortListener = undefined;
+            }
+        };
+        const initiateKill = () => {
+            if (killInitiated)
+                return;
+            killInitiated = true;
             // killProcessTree handles both platforms and kills the whole tree: on Unix
             // it signals the process group (SIGTERM -> grace -> SIGKILL); on Windows it
             // force-kills the tree via taskkill /F /T. Using child.kill("SIGTERM") here
@@ -201,14 +219,14 @@ export function runExecSandbox(request, opts) {
                 finalize(null, "SIGKILL", true);
             }, effectiveForceResolveDelay);
             forceResolveTimer.unref?.();
-        }, timeoutMs);
-        timer.unref?.();
+        };
         const finalize = (exitCode, signal, forceResolved = false) => {
             if (settled)
                 return;
             settled = true;
             clearTimeout(timer);
             clearTimeout(forceResolveTimer);
+            removeAbortListener();
             const duration = Date.now() - started;
             const stdoutBuf = Buffer.concat(stdoutChunks);
             const stderrBuf = Buffer.concat(stderrChunks);
@@ -219,17 +237,20 @@ export function runExecSandbox(request, opts) {
             const digestBody = tail(stdoutBuf, opts.digest_chars);
             const digest = digestBody.length > 0
                 ? digestBody
-                : timedOut
-                    ? "[no stdout — timed out]"
-                    : stderrBuf.length > 0
-                        ? `[no stdout — tail of stderr]\n${tail(stderrBuf, opts.digest_chars)}`
-                        : "[no output]";
+                : aborted
+                    ? "[no stdout — aborted]"
+                    : timedOut
+                        ? "[no stdout — timed out]"
+                        : stderrBuf.length > 0
+                            ? `[no stdout — tail of stderr]\n${tail(stderrBuf, opts.digest_chars)}`
+                            : "[no output]";
             const result = {
                 id,
                 runtime: request.runtime,
                 exit_code: exitCode,
                 signal,
                 timed_out: timedOut,
+                aborted,
                 force_resolved: forceResolved,
                 duration_ms: duration,
                 stdout_bytes: stdoutBytes,
@@ -244,6 +265,26 @@ export function runExecSandbox(request, opts) {
             writeMeta(metaPath, result, request, now);
             resolveP(result);
         };
+        timer = setTimeout(() => {
+            timedOut = true;
+            initiateKill();
+        }, timeoutMs);
+        timer.unref?.();
+        if (opts.signal) {
+            abortListener = () => {
+                if (settled || timedOut)
+                    return;
+                aborted = true;
+                clearTimeout(timer);
+                initiateKill();
+            };
+            if (opts.signal.aborted) {
+                abortListener();
+            }
+            else {
+                opts.signal.addEventListener("abort", abortListener, { once: true });
+            }
+        }
         child.on("error", (err) => {
             const message = err instanceof Error ? err.message : String(err);
             const line = `child error: ${message}\n`;
@@ -274,6 +315,7 @@ function writeMeta(path, result, request, now) {
         exit_code: result.exit_code,
         signal: result.signal,
         timed_out: result.timed_out,
+        aborted: result.aborted === true,
         force_resolved: result.force_resolved,
         duration_ms: result.duration_ms,
         stdout_bytes: result.stdout_bytes,

package/dist/resources/extensions/gsd/flat-phase-migration.js

@@ -59,6 +59,51 @@ export function needsFlatPhaseMigration(basePath) {
     // Resume an interrupted migration where the legacy tree was renamed aside.
     return hasLegacyMilestoneSubdirs(legacyMigratingPath(basePath));
 }
+/** Retention window before flat-phase migration backups are auto-pruned. */
+export const FLAT_PHASE_BACKUP_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+/**
+ * Remove stale flat-phase migration backups after the retention window.
+ * Only runs when migration is complete (.gsd/phases/ exists, legacy layout gone).
+ * Returns the number of migrate-* directories removed.
+ */
+export function pruneStaleFlatPhaseBackups(basePath) {
+    if (needsFlatPhaseMigration(basePath))
+        return 0;
+    const phasesPath = join(basePath, ".gsd", LAYOUT_SEGMENTS.level1);
+    if (!existsSync(phasesPath))
+        return 0;
+    const backupRoot = join(basePath, ".gsd-backups");
+    if (!existsSync(backupRoot))
+        return 0;
+    const now = Date.now();
+    let removed = 0;
+    for (const entry of readdirSync(backupRoot)) {
+        if (!entry.startsWith("migrate-"))
+            continue;
+        const dirPath = join(backupRoot, entry);
+        try {
+            const st = statSync(dirPath);
+            if (!st.isDirectory())
+                continue;
+            if (now - st.mtimeMs < FLAT_PHASE_BACKUP_RETENTION_MS)
+                continue;
+            rmSync(dirPath, { recursive: true, force: true });
+            removed++;
+        }
+        catch {
+            // Non-fatal: leave backup for manual recovery.
+        }
+    }
+    try {
+        if (readdirSync(backupRoot).length === 0) {
+            rmSync(backupRoot, { recursive: true, force: true });
+        }
+    }
+    catch {
+        // Non-fatal.
+    }
+    return removed;
+}
 /**
  * Migrate from legacy nested .gsd/milestones/ to flat-phase .gsd/phases/.
  *

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

@@ -22,8 +22,7 @@ import { deriveState } from "./state.js";
 import { isAutoActive } from "./auto.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
-import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
-import { isClosedStatus } from "./status-guards.js";
+import { isDbAvailable, getHierarchyCompletionCounts } from "./gsd-db.js";
 import { formatDuration } from "../shared/format-utils.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 import { clearGSDPreferencesCache, loadEffectiveGSDPreferences, loadGlobalGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
@@ -593,36 +592,7 @@ function loadCompletedKeys(basePath) {
 function getDbCompletionCounts() {
     if (!isDbAvailable())
         return null;
-    const milestones = getAllMilestones();
-    let completedMilestones = 0;
-    let totalSlices = 0;
-    let completedSlices = 0;
-    let totalTasks = 0;
-    let completedTasks = 0;
-    for (const m of milestones) {
-        if (isClosedStatus(m.status))
-            completedMilestones++;
-        const slices = getMilestoneSlices(m.id);
-        for (const s of slices) {
-            totalSlices++;
-            if (isClosedStatus(s.status))
-                completedSlices++;
-            const tasks = getSliceTasks(m.id, s.id);
-            for (const t of tasks) {
-                totalTasks++;
-                if (isClosedStatus(t.status))
-                    completedTasks++;
-            }
-        }
-    }
-    return {
-        milestones: completedMilestones,
-        milestonesTotal: milestones.length,
-        slices: completedSlices,
-        slicesTotal: totalSlices,
-        tasks: completedTasks,
-        tasksTotal: totalTasks,
-    };
+    return getHierarchyCompletionCounts();
 }
 // ─── Anomaly Detectors ───────────────────────────────────────────────────────
 /**

package/dist/resources/extensions/gsd/git-service.js

@@ -208,6 +208,7 @@ export class MergeConflictError extends GSDError {
  */
 export const RUNTIME_EXCLUSION_PATHS = [
     ".gsd-worktrees/",
+    ".gsd-backups/**",
     ".gsd/activity/",
     ".gsd/audit/",
     ".gsd/forensics/",
@@ -225,6 +226,7 @@ export const RUNTIME_EXCLUSION_PATHS = [
     ".gsd/event-log.jsonl",
     ".gsd/DISCUSSION-MANIFEST.json",
 ];
+const runtimeFilesCleanedUpRepos = new Set();
 // ─── Integration Branch Metadata ───────────────────────────────────────────
 /**
  * Path to the milestone metadata file that stores the integration branch.
@@ -565,7 +567,8 @@ export class GitServiceImpl {
         // and the worktree is torn down. This prevents a mid-execution behavioral
         // discontinuity where the first half of a milestone has .gsd/ artifacts
         // committed but the second half doesn't (#1326).
-        if (!this._runtimeFilesCleanedUp) {
+        const cleanupRepoKey = resolve(this.basePath);
+        if (!runtimeFilesCleanedUpRepos.has(cleanupRepoKey)) {
             let cleaned = false;
             for (const exclusion of RUNTIME_EXCLUSION_PATHS) {
                 const removed = nativeRmCached(this.basePath, [exclusion]);
@@ -575,7 +578,7 @@ export class GitServiceImpl {
             if (cleaned) {
                 nativeCommit(this.basePath, "chore: untrack .gsd/ runtime files from git index", { allowEmpty: false });
             }
-            this._runtimeFilesCleanedUp = true;
+            runtimeFilesCleanedUpRepos.add(cleanupRepoKey);
         }
         // Stage everything using pathspec exclusions so excluded paths are never
         // hashed by git. The old approach of `git add -A` followed by unstaging
@@ -683,8 +686,6 @@ export class GitServiceImpl {
             return false;
         }
     }
-    /** Tracks whether runtime file cleanup has run this session. */
-    _runtimeFilesCleanedUp = false;
     /**
      * Stage files (smart staging) and commit.
      * Returns the commit message string on success, or null if nothing to commit.
@@ -1027,6 +1028,7 @@ function collectRepositoryDirtyStatus(basePath) {
     const preferences = loadEffectiveGSDPreferences(basePath)?.preferences;
     const registry = createRepositoryRegistryFromPreferences(basePath, preferences);
     const dirtyByRepository = {};
+    const registeredRoots = new Set(registry.repositories.map((repo) => resolve(repo.root)));
     for (const repo of registry.repositories) {
         try {
             dirtyByRepository[repo.id] = runGit(repo.root, ["status", "--porcelain"]).length > 0;
@@ -1036,8 +1038,63 @@ function collectRepositoryDirtyStatus(basePath) {
             dirtyByRepository[repo.id] = nativeHasChanges(repo.root);
         }
     }
+    for (const repoRoot of findUndeclaredNestedGitRepositories(registry.projectRoot, registeredRoots)) {
+        let dirty = false;
+        try {
+            dirty = runGit(repoRoot, ["status", "--porcelain"]).length > 0;
+        }
+        catch {
+            dirty = nativeHasChanges(repoRoot);
+        }
+        if (!dirty)
+            continue;
+        const relPath = relative(registry.projectRoot, repoRoot).split(sep).join("/") || repoRoot;
+        const label = `${relPath} (undeclared)`;
+        dirtyByRepository[label] = true;
+        logWarning("engine", `undeclared dirty nested git repo ${relPath}; declare it under workspace.repositories or commit manually`, { file: "git-service.ts" });
+    }
     return dirtyByRepository;
 }
+const UNDECLARED_NESTED_REPO_SCAN_MAX_DEPTH = 4;
+const UNDECLARED_NESTED_REPO_SKIP_DIRS = new Set([
+    ".git",
+    ".gsd",
+    ".gsd-worktrees",
+    "node_modules",
+    "dist",
+    "dist-test",
+]);
+function findUndeclaredNestedGitRepositories(projectRoot, registeredRoots) {
+    const found = [];
+    function visit(dir, depth) {
+        if (depth >= UNDECLARED_NESTED_REPO_SCAN_MAX_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (UNDECLARED_NESTED_REPO_SKIP_DIRS.has(entry.name))
+                continue;
+            const child = join(dir, entry.name);
+            const childRoot = resolve(child);
+            const hasGitDir = existsSync(join(child, ".git"));
+            const isRegistered = registeredRoots.has(childRoot);
+            if (hasGitDir && !isRegistered) {
+                found.push(childRoot);
+                continue;
+            }
+            visit(child, depth + 1);
+        }
+    }
+    visit(projectRoot, 0);
+    return found;
+}
 function runPerRepositoryCommitAction(args) {
     const preferences = loadEffectiveGSDPreferences(args.basePath)?.preferences;
     const registry = createRepositoryRegistryFromPreferences(args.basePath, preferences);

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

@@ -22,8 +22,9 @@ import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
  * With external state (symlink), these are a no-op in most cases,
  * but retained for backwards compatibility during migration.
  */
-const GSD_RUNTIME_PATTERNS = [
+export const GSD_RUNTIME_PATTERNS = [
     ".gsd-worktrees/",
+    ".gsd-backups/",
     ".gsd/activity/",
     ".gsd/audit/",
     ".gsd/forensics/",
@@ -48,6 +49,8 @@ const BASELINE_PATTERNS = [
     ".gsd",
     // Worktree container sibling — NOT covered by the ".gsd" pattern above.
     ".gsd-worktrees/",
+    // Flat-phase migration snapshots — NOT covered by the ".gsd" pattern above.
+    ".gsd-backups/",
     ".gsd-id",
     ".mcp.json",
     ".bg-shell/",

package/dist/resources/extensions/gsd/guided-flow-queue.js

@@ -12,7 +12,7 @@ import { loadFile } from "./files.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
-import { gsdRoot, resolveMilestoneFile, resolveGsdRootFile, relGsdRootFile, } from "./paths.js";
+import { gsdRoot, resolveMilestoneFile, resolveGsdRootFile, relGsdRootFile, relMilestoneFile, } from "./paths.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
 import { nativeAddPaths, nativeCommit } from "./native-git-bridge.js";
@@ -20,6 +20,9 @@ import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { saveQueueOrder } from "./queue-order.js";
 import { findMilestoneIds, nextMilestoneId } from "./milestone-ids.js";
 import { isFutureMilestoneStatus } from "./status-guards.js";
+const QUEUE_ARTIFACT_EXCERPT_MAX_CHARS = 20_000;
+const QUEUE_EXISTING_MILESTONES_CONTEXT_MAX_CHARS = 120_000;
+const QUEUE_CONTEXT_SECTION_SEPARATOR = "\n\n---\n\n";
 // ─── Queue Entry Point ──────────────────────────────────────────────────────
 /**
  * Queue future milestones via conversational intake.
@@ -215,7 +218,7 @@ export async function buildExistingMilestonesContext(basePath, milestoneIds, sta
         if (contextFile) {
             const content = await loadFile(contextFile);
             if (content) {
-                parts.push(`\n**Context:**\n${content.trim()}`);
+                parts.push(`\n**Context:**\n${summarizeArtifactForQueue(content, relMilestoneFile(basePath, mid, "CONTEXT"))}`);
             }
         }
         else {
@@ -224,7 +227,7 @@ export async function buildExistingMilestonesContext(basePath, milestoneIds, sta
             if (draftFile) {
                 const draftContent = await loadFile(draftFile);
                 if (draftContent) {
-                    parts.push(`\n**Draft context available:**\n${draftContent.trim()}`);
+                    parts.push(`\n**Draft context available:**\n${summarizeArtifactForQueue(draftContent, relMilestoneFile(basePath, mid, "CONTEXT-DRAFT"))}`);
                 }
             }
         }
@@ -235,7 +238,7 @@ export async function buildExistingMilestonesContext(basePath, milestoneIds, sta
             if (roadmapFile) {
                 const content = await loadFile(roadmapFile);
                 if (content) {
-                    parts.push(`\n**Roadmap:**\n${content.trim()}`);
+                    parts.push(`\n**Roadmap:**\n${summarizeArtifactForQueue(content, relMilestoneFile(basePath, mid, "ROADMAP"))}`);
                 }
             }
         }
@@ -249,7 +252,65 @@ export async function buildExistingMilestonesContext(basePath, milestoneIds, sta
             sections.push(`### Previous Queue Entries\nSource: \`${relGsdRootFile("QUEUE")}\`\n\n${queueContent.trim()}`);
         }
     }
-    return sections.join("\n\n---\n\n");
+    return capExistingMilestonesContext(sections);
+}
+function summarizeArtifactForQueue(content, sourcePath, cap = QUEUE_ARTIFACT_EXCERPT_MAX_CHARS) {
+    const trimmed = content.trim();
+    if (trimmed.length <= cap) {
+        return `Source: \`${sourcePath}\`\n\n${trimmed}`;
+    }
+    const excerpt = trimmed.slice(0, cap).trimEnd();
+    const omittedChars = trimmed.length - excerpt.length;
+    return [
+        `Source: \`${sourcePath}\``,
+        "",
+        excerpt,
+        "",
+        `[Truncated ${omittedChars} chars. Read \`${sourcePath}\` for full content.]`,
+    ].join("\n");
+}
+function capExistingMilestonesContext(sections, cap = QUEUE_EXISTING_MILESTONES_CONTEXT_MAX_CHARS) {
+    const fullContext = sections.join(QUEUE_CONTEXT_SECTION_SEPARATOR);
+    if (fullContext.length <= cap)
+        return fullContext;
+    const notice = `[Existing milestones context truncated to ${cap} chars. Read source paths in this prompt or the corresponding .gsd artifacts for full details.]`;
+    const noticeSuffix = `${QUEUE_CONTEXT_SECTION_SEPARATOR}${notice}`;
+    const selected = [];
+    for (const section of sections) {
+        const candidate = [...selected, section].join(QUEUE_CONTEXT_SECTION_SEPARATOR) + noticeSuffix;
+        if (candidate.length <= cap) {
+            selected.push(section);
+            continue;
+        }
+        break;
+    }
+    if (selected.length === sections.length) {
+        return selected.join(QUEUE_CONTEXT_SECTION_SEPARATOR) + noticeSuffix;
+    }
+    const compactTail = sections.slice(selected.length).map(compactSectionForQueueBudget);
+    const hybrid = [...selected, ...compactTail].join(QUEUE_CONTEXT_SECTION_SEPARATOR) + noticeSuffix;
+    if (hybrid.length <= cap)
+        return hybrid;
+    const compact = sections.map(compactSectionForQueueBudget);
+    const compactContext = compact.join(QUEUE_CONTEXT_SECTION_SEPARATOR) + noticeSuffix;
+    if (compactContext.length <= cap)
+        return compactContext;
+    return `${compactContext.slice(0, Math.max(0, cap - notice.length - 2)).trimEnd()}\n\n${notice}`;
+}
+function compactSectionForQueueBudget(section) {
+    const lines = section.split("\n");
+    const compact = [];
+    if (lines[0])
+        compact.push(lines[0]);
+    const statusLine = lines.find(line => line.startsWith("**Status:**"));
+    if (statusLine)
+        compact.push(statusLine);
+    const sourceLines = lines.filter(line => line.startsWith("Source: `"));
+    if (sourceLines.length > 0) {
+        compact.push("", "**Sources:**", ...sourceLines);
+        compact.push("", "[Artifact excerpts omitted due to total queue/rethink context budget.]");
+    }
+    return compact.join("\n");
 }
 // ─── Internal Helpers ───────────────────────────────────────────────────────
 /**

package/dist/resources/extensions/gsd/health-widget.js

@@ -1,29 +1,61 @@
 // Project/App: gsd-pi
 // File Purpose: Always-on ambient health signal rendered below the editor.
-import { runProviderChecks, summariseProviderIssues } from "./doctor-providers.js";
+import { execFile } from "node:child_process";
+import { runProviderChecks, runProviderChecksAsync, summariseProviderIssues } from "./doctor-providers.js";
 import { runEnvironmentChecks, runEnvironmentChecksAsync } from "./doctor-environment.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { nativeIsRepo, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeCommitSubject } from "./native-git-bridge.js";
+import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadLedgerFromDisk, getProjectTotals } from "./metrics.js";
 import { projectRoot } from "./commands/context.js";
 import { buildHealthLines, detectHealthWidgetProjectState, } from "./health-widget-core.js";
 export const HEALTH_WIDGET_ACTIVE_HINTS = "  /gsd auto to run  ·  /gsd status to inspect  ·  /gsd report for snapshots  ·  /gsd notifications for history  ·  /gsd help";
+const LAST_COMMIT_LOOKUP_TIMEOUT_MS = 3_000;
+const REFRESH_INTERVAL_MS = 60_000;
+const PROJECT_STATE_CACHE_TTL_MS = REFRESH_INTERVAL_MS;
 // ── Data loader ────────────────────────────────────────────────────────────────
-// Last-commit lookup is subprocess-backed (native-git-bridge → git spawns),
-// so it is treated like the other expensive checks: skipped on first paint,
-// run only by the background refresh.
-function loadLastCommitInfo(basePath) {
+const projectStateCache = new Map();
+export function getCachedProjectState(basePath, force) {
+    const now = Date.now();
+    const cached = projectStateCache.get(basePath);
+    if (!force && cached && now - cached.computedAt <= PROJECT_STATE_CACHE_TTL_MS) {
+        return cached.state;
+    }
+    const state = detectHealthWidgetProjectState(basePath);
+    projectStateCache.set(basePath, { state, computedAt: now });
+    return state;
+}
+function runHealthWidgetGit(basePath, args) {
+    return new Promise((resolve) => {
+        const child = execFile("git", args, {
+            cwd: basePath,
+            timeout: LAST_COMMIT_LOOKUP_TIMEOUT_MS,
+            encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
+        }, (err, stdout) => resolve(err ? null : String(stdout).trimEnd()));
+        child.on("error", () => resolve(null));
+    });
+}
+async function loadLastCommitInfoAsync(basePath) {
     try {
-        if (nativeIsRepo(basePath)) {
-            const branch = nativeGetCurrentBranch(basePath);
-            const epoch = nativeLastCommitEpoch(basePath, branch || "HEAD");
-            if (epoch > 0) {
-                return { epoch, message: nativeCommitSubject(basePath, branch || "HEAD") || null };
-            }
+        if ((await runHealthWidgetGit(basePath, ["rev-parse", "--git-dir"])) === null) {
+            return { epoch: null, message: null };
         }
+        const branch = await runHealthWidgetGit(basePath, ["branch", "--show-current"]);
+        const ref = branch || "HEAD";
+        const raw = await runHealthWidgetGit(basePath, ["log", "-1", "--format=%ct%x00%s", ref]);
+        if (!raw)
+            return { epoch: null, message: null };
+        const separator = raw.indexOf("\0");
+        const epochText = separator >= 0 ? raw.slice(0, separator) : raw;
+        const epoch = parseInt(epochText.trim(), 10) || 0;
+        if (epoch <= 0)
+            return { epoch: null, message: null };
+        const message = separator >= 0 ? raw.slice(separator + 1).trim() : "";
+        return { epoch, message: message || null };
+    }
+    catch {
+        return { epoch: null, message: null };
     }
-    catch { /* non-fatal */ }
-    return { epoch: null, message: null };
 }
 function loadHealthWidgetData(basePath, options) {
     // `includeChecks` gates the expensive subprocess-backed checks (provider +
@@ -38,7 +70,7 @@ function loadHealthWidgetData(basePath, options) {
     let environmentWarningCount = 0;
     let lastCommitEpoch = null;
     let lastCommitMessage = null;
-    const projectState = detectHealthWidgetProjectState(basePath);
+    const projectState = getCachedProjectState(basePath, options?.forceProjectState);
     try {
         const prefs = loadEffectiveGSDPreferences();
         budgetCeiling = prefs?.preferences?.budget_ceiling;
@@ -66,12 +98,6 @@ function loadHealthWidgetData(basePath, options) {
         }
         catch { /* non-fatal */ }
     }
-    // ── Last commit info ── (git spawns — gated like the other expensive checks)
-    if (includeChecks) {
-        const commit = loadLastCommitInfo(basePath);
-        lastCommitEpoch = commit.epoch;
-        lastCommitMessage = commit.message;
-    }
     return {
         projectState,
         budgetCeiling,
@@ -85,17 +111,15 @@ function loadHealthWidgetData(basePath, options) {
     };
 }
 // Non-blocking variant used by the widget's background refresh: the cheap fields
-// come from the synchronous snapshot, then provider + environment checks are
-// layered in off the event-loop critical path (env checks run concurrently via
-// runEnvironmentChecksAsync). Keeps the always-on widget from stalling the UI on
-// its initial enrichment or its 60s refresh.
+// come from the synchronous snapshot, then provider, environment, and last-commit
+// checks are layered in off the event-loop critical path.
 async function loadHealthWidgetDataAsync(basePath) {
     const data = loadHealthWidgetData(basePath, { includeChecks: false });
     let providerIssue = data.providerIssue;
     let environmentErrorCount = 0;
     let environmentWarningCount = 0;
     try {
-        providerIssue = summariseProviderIssues(runProviderChecks());
+        providerIssue = summariseProviderIssues(await runProviderChecksAsync());
     }
     catch { /* non-fatal */ }
     try {
@@ -108,7 +132,7 @@ async function loadHealthWidgetDataAsync(basePath) {
         }
     }
     catch { /* non-fatal */ }
-    const commit = loadLastCommitInfo(basePath);
+    const commit = await loadLastCommitInfoAsync(basePath);
     return {
         ...data,
         providerIssue,
@@ -120,7 +144,6 @@ async function loadHealthWidgetDataAsync(basePath) {
     };
 }
 // ── Widget init ────────────────────────────────────────────────────────────────
-const REFRESH_INTERVAL_MS = 60_000;
 /**
  * Initialize the always-on gsd-health widget (belowEditor).
  * Call once from the extension entry point after context is available.
@@ -129,13 +152,16 @@ export function initHealthWidget(ctx) {
     if (!ctx.hasUI)
         return;
     const basePath = projectRoot();
+    // Re-init must reflect filesystem changes immediately; the TTL cache is for
+    // interval refreshes, not this one-off synchronous paint.
+    projectStateCache.delete(basePath);
     // String-array fallback — used in RPC mode (factory is a no-op there).
     // Skip the expensive provider/environment doctor checks here: this runs
     // synchronously on the interactive-startup path, where running them would
     // block first paint by ~0.9s (lsof/docker probes, otherwise run again
     // immediately by the factory below). The factory's async refresh fills in
     // real health once the screen is up.
-    const initialData = loadHealthWidgetData(basePath, { includeChecks: false });
+    const initialData = loadHealthWidgetData(basePath, { includeChecks: false, forceProjectState: true });
     ctx.ui.setWidget("gsd-health", buildHealthLines(initialData), { placement: "belowEditor" });
     // Factory-based widget for TUI mode — replaces the string-array above
     ctx.ui.setWidget("gsd-health", (_tui, _theme) => {

package/dist/resources/extensions/gsd/json-persistence.js

@@ -56,6 +56,26 @@ export function saveJsonFile(filePath, data) {
         // Non-fatal — don't let persistence failures break operation
     }
 }
+/**
+ * Save a JSON file atomically using compact serialization.
+ *
+ * Intended for machine-only ledgers where pretty-printing has no consumer.
+ * Keeps the same write-tmp-rename safety and non-fatal error behavior as
+ * saveJsonFile.
+ */
+export function saveJsonFileCompact(filePath, data) {
+    try {
+        mkdirSync(dirname(filePath), { recursive: true });
+        // Use randomized tmp suffix to prevent concurrent-write data loss
+        const tmp = `${filePath}.tmp.${randomBytes(4).toString("hex")}`;
+        writeFileSync(tmp, JSON.stringify(data) + "\n", "utf-8");
+        renameSync(tmp, filePath);
+        // No cleanup needed — renameSync atomically removes tmp on success
+    }
+    catch {
+        // Non-fatal — don't let persistence failures break operation
+    }
+}
 /**
  * Write a JSON file atomically (write to .tmp, then rename).
  * Creates parent directories as needed. Non-fatal on error.