@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.72e3af2a

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -1671,19 +1671,25 @@ export function serializePreferencesToFrontmatter(prefs) {
                     const entries = Object.entries(item);
                     if (entries.length > 0) {
                         const [firstKey, firstVal] = entries[0];
-                        lines.push(`${prefix}  - ${firstKey}: ${yamlSafeString(firstVal)}`);
-                        for (let i = 1; i < entries.length; i++) {
-                            const [k, v] = entries[i];
-                            if (Array.isArray(v)) {
-                                lines.push(`${prefix}    ${k}:`);
-                                for (const arrItem of v) {
-                                    lines.push(`${prefix}      - ${yamlSafeString(arrItem)}`);
-                                }
+                        if (Array.isArray(firstVal)) {
+                            lines.push(`${prefix}  - ${firstKey}:`);
+                            for (const arrItem of firstVal) {
+                                lines.push(`${prefix}      - ${yamlSafeString(arrItem)}`);
                             }
-                            else {
-                                lines.push(`${prefix}    ${k}: ${yamlSafeString(v)}`);
+                        }
+                        else if (typeof firstVal === "object" && firstVal !== null) {
+                            lines.push(`${prefix}  - ${firstKey}:`);
+                            for (const [k, v] of Object.entries(firstVal)) {
+                                serializeValue(k, v, indent + 3);
                             }
                         }
+                        else {
+                            lines.push(`${prefix}  - ${firstKey}: ${yamlSafeString(firstVal)}`);
+                        }
+                        for (let i = 1; i < entries.length; i++) {
+                            const [k, v] = entries[i];
+                            serializeValue(k, v, indent + 2);
+                        }
                     }
                 }
                 else {

package/dist/resources/extensions/gsd/commands-worktree.js

@@ -12,9 +12,9 @@ import { inferCommitType } from "./git-service.js";
 import { autoCommitCurrentBranch } from "./worktree.js";
 import { GSDError, GSD_GIT_ERROR } from "./errors.js";
 // ─── Status helper ─────────────────────────────────────────────────────────
-function getStatus(basePath, name, wtPath) {
-    const diff = diffWorktreeAll(basePath, name);
-    const numstat = diffWorktreeNumstat(basePath, name);
+function getStatus(basePath, name, wtPath, mainBranch) {
+    const diff = diffWorktreeAll(basePath, name, undefined, mainBranch);
+    const numstat = diffWorktreeNumstat(basePath, name, undefined, mainBranch);
     const filesChanged = diff.added.length + diff.modified.length + diff.removed.length;
     let linesAdded = 0;
     let linesRemoved = 0;
@@ -31,8 +31,7 @@ function getStatus(basePath, name, wtPath) {
     }
     let commits = 0;
     try {
-        const main = nativeDetectMainBranch(basePath);
-        commits = nativeCommitCountBetween(basePath, main, worktreeBranchName(name));
+        commits = nativeCommitCountBetween(basePath, mainBranch, worktreeBranchName(name));
     }
     catch {
         // commit count unavailable → leave at 0
@@ -88,7 +87,8 @@ export function formatCleanKeepReason(status) {
 async function handleList(ctx) {
     const basePath = projectRoot();
     const worktrees = listWorktrees(basePath);
-    const statuses = worktrees.map((wt) => getStatus(basePath, wt.name, wt.path));
+    const mainBranch = worktrees.length > 0 ? nativeDetectMainBranch(basePath) : "";
+    const statuses = worktrees.map((wt) => getStatus(basePath, wt.name, wt.path, mainBranch));
     ctx.ui.notify(formatWorktreeList(statuses), "info");
 }
 // ─── Subcommand: merge ──────────────────────────────────────────────────────
@@ -117,7 +117,8 @@ async function handleMerge(args, ctx) {
         ctx.ui.notify(`Worktree "${target}" not found.\n\nAvailable: ${available}`, "error");
         return;
     }
-    const status = getStatus(basePath, target, wt.path);
+    const mainBranch = nativeDetectMainBranch(basePath);
+    const status = getStatus(basePath, target, wt.path, mainBranch);
     if (status.filesChanged === 0 && !status.uncommitted) {
         try {
             removeWorktree(basePath, target, { deleteBranch: true });
@@ -144,7 +145,6 @@ async function handleMerge(args, ctx) {
         }
     }
     const commitType = inferCommitType(target);
-    const mainBranch = nativeDetectMainBranch(basePath);
     const commitMessage = `${commitType}: merge worktree ${target}\n\nGSD-Worktree: ${target}`;
     try {
         mergeWorktreeToMain(basePath, target, commitMessage);
@@ -191,8 +191,9 @@ async function handleClean(ctx) {
     }
     const removed = [];
     const kept = [];
+    const mainBranch = nativeDetectMainBranch(basePath);
     for (const wt of worktrees) {
-        const status = getStatus(basePath, wt.name, wt.path);
+        const status = getStatus(basePath, wt.name, wt.path, mainBranch);
         if (status.filesChanged === 0 && !status.uncommitted) {
             try {
                 removeWorktree(basePath, wt.name, { deleteBranch: true });
@@ -238,7 +239,8 @@ async function handleRemove(args, ctx) {
         ctx.ui.notify(`Worktree "${name}" not found.\n\nAvailable: ${available}`, "error");
         return;
     }
-    const status = getStatus(basePath, name, wt.path);
+    const mainBranch = nativeDetectMainBranch(basePath);
+    const status = getStatus(basePath, name, wt.path, mainBranch);
     if ((status.filesChanged > 0 || status.uncommitted) && !force) {
         ctx.ui.notify([
             `Worktree "${name}" has pending changes (${formatCleanKeepReason(status)}).`,

package/dist/resources/extensions/gsd/dashboard-overlay.js

@@ -21,7 +21,7 @@ import { getWorkerBatches, hasActiveWorkers } from "../subagent/worker-registry.
 import { formatDuration, padRight, joinColumns, centerLine, fitColumns, STATUS_GLYPH, STATUS_COLOR } from "../shared/mod.js";
 import { estimateTimeRemaining } from "./auto-dashboard.js";
 import { computeProgressScore } from "./progress-score.js";
-import { runEnvironmentChecks } from "./doctor-environment.js";
+import { runEnvironmentChecksAsync } from "./doctor-environment.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { renderDialogFrame, renderKeyHints } from "./tui/render-kit.js";
 export function unitLabel(type) {
@@ -62,6 +62,9 @@ export class GSDDashboardOverlay {
     loading = true;
     loadedDashboardIdentity;
     refreshInFlight = null;
+    envRefreshInFlight = null;
+    cachedEnvBasePath;
+    cachedEnvIssues = [];
     disposed = false;
     resizeHandler = null;
     cachedMetrics = null;
@@ -155,11 +158,38 @@ export class GSDDashboardOverlay {
         if (initial) {
             this.loading = false;
         }
+        this.scheduleEnvironmentRefresh(this.dashData.basePath || process.cwd());
         if (identityChanged) {
             this.invalidate();
         }
         this.tui.requestRender();
     }
+    scheduleEnvironmentRefresh(basePath) {
+        if (this.cachedEnvBasePath !== basePath) {
+            this.cachedEnvBasePath = basePath;
+            this.cachedEnvIssues = [];
+            this.invalidate();
+        }
+        if (this.envRefreshInFlight || this.disposed)
+            return;
+        this.envRefreshInFlight = this.refreshEnvironmentHealth(basePath)
+            .finally(() => {
+            this.envRefreshInFlight = null;
+        });
+    }
+    async refreshEnvironmentHealth(basePath) {
+        try {
+            const envResults = await runEnvironmentChecksAsync(basePath);
+            if (this.disposed || this.cachedEnvBasePath !== basePath)
+                return;
+            this.cachedEnvIssues = envResults.filter(r => r.status !== "ok");
+            this.invalidate();
+            this.tui.requestRender();
+        }
+        catch {
+            // Non-fatal — keep last known environment issues
+        }
+    }
     async loadData() {
         const base = this.dashData.basePath || process.cwd();
         try {
@@ -540,8 +570,7 @@ export class GSDDashboardOverlay {
             }
         }
         // Environment health section (#1221) — only show issues
-        const envResults = runEnvironmentChecks(this.dashData.basePath || process.cwd());
-        const envIssues = envResults.filter(r => r.status !== "ok");
+        const envIssues = this.cachedEnvIssues;
         if (envIssues.length > 0) {
             lines.push(blank());
             lines.push(hr());

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

@@ -12,6 +12,7 @@ import { rowToActiveDecision, rowToActiveRequirement, rowToDecision, rowToRequir
 import { rowToGate } from "../db-gate-rows.js";
 import { rowToArtifact, rowToMilestone } from "../db-milestone-artifact-rows.js";
 import { rowToSlice, rowToTask } from "../db-task-slice-rows.js";
+import { TERMINAL_STATUS_SQL } from "./sql-constants.js";
 function parseStringArrayColumn(raw) {
     if (Array.isArray(raw))
         return raw.filter((entry) => typeof entry === "string");
@@ -35,6 +36,44 @@ function parseStringArrayColumn(raw) {
 function normalizeRepoPath(file) {
     return file.trim().replace(/\\/g, "/").replace(/^\.\/+/, "");
 }
+function numberColumn(row, column) {
+    const value = row?.[column];
+    if (typeof value === "number")
+        return value;
+    if (typeof value === "bigint")
+        return Number(value);
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+}
+function getCompletionCount(table) {
+    const row = getDbOrNull().prepare(`SELECT
+       COUNT(*) AS total,
+       COALESCE(SUM(CASE WHEN status IN (${TERMINAL_STATUS_SQL}) THEN 1 ELSE 0 END), 0) AS completed
+     FROM ${table}`).get();
+    return {
+        completed: numberColumn(row, "completed"),
+        total: numberColumn(row, "total"),
+    };
+}
+export function getHierarchyCompletionCounts() {
+    if (!getDbOrNull()) {
+        return { milestones: 0, milestonesTotal: 0, slices: 0, slicesTotal: 0, tasks: 0, tasksTotal: 0 };
+    }
+    const milestones = getCompletionCount("milestones");
+    const slices = getCompletionCount("slices");
+    const tasks = getCompletionCount("tasks");
+    return {
+        milestones: milestones.completed,
+        milestonesTotal: milestones.total,
+        slices: slices.completed,
+        slicesTotal: slices.total,
+        tasks: tasks.completed,
+        tasksTotal: tasks.total,
+    };
+}
 export function getDecisionById(id) {
     if (!getDbOrNull())
         return null;
@@ -391,6 +430,27 @@ export function getAssessment(path) {
     const row = getDbOrNull().prepare(`SELECT * FROM assessments WHERE path = :path`).get({ ":path": path });
     return row ?? null;
 }
+/**
+ * Look up a slice's `run-uat` assessment by (milestoneId, sliceId) identity,
+ * independent of the artifact `path`. Used as a DB fallback by the UAT
+ * closeout gate when a path migration orphans the ASSESSMENT markdown from its
+ * canonical expected path (ADR-017: DB-authoritative UAT sign-off).
+ *
+ * `status` holds the normalized verdict (`pass`/`fail`/…) written by
+ * `executeUatResultSave`; `fullContent` carries the ASSESSMENT body so callers
+ * can derive `uatType` without re-reading a file that may not exist.
+ */
+export function getSliceRunUatAssessment(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare(`SELECT status, full_content AS fullContent FROM assessments
+      WHERE milestone_id = :mid AND slice_id = :sid AND scope = 'run-uat'
+      ORDER BY created_at DESC, ROWID DESC
+      LIMIT 1`).get({ ":mid": milestoneId, ":sid": sliceId });
+    if (!row)
+        return null;
+    return { status: String(row["status"] ?? ""), fullContent: String(row["fullContent"] ?? "") };
+}
 export function getLatestAssessmentByScope(milestoneId, scope) {
     if (!getDbOrNull())
         return null;

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

@@ -1,10 +1,24 @@
 // Project/App: gsd-pi
 // File Purpose: Workspace-facing Interface for opening and maintaining the workflow database.
 import { existsSync } from "node:fs";
-import { dirname } from "node:path";
+import { dirname, join } from "node:path";
 import { backupDatabaseSnapshot, checkpointDatabase, closeAllDatabases, closeDatabase, closeDatabaseByWorkspace, getDbPath, getDbStatus, getDbProvider, isDbAvailable, openDatabase, openDatabaseByScope, openDatabaseByWorkspace, openIsolatedDatabase, refreshOpenDatabaseFromDisk, vacuumDatabase, wasDbOpenAttempted, } from "./gsd-db.js";
-import { resolveGsdPathContract } from "./paths.js";
-import { setLogBasePath } from "./workflow-logger.js";
+import { resolveGsdPathContract, gsdRoot } from "./paths.js";
+import { logWarning, setLogBasePath } from "./workflow-logger.js";
+/**
+ * Global SQLite handle invariants:
+ *
+ * - `openWorkflowDatabase` / `openDatabase` switch the process-global handle consumed by
+ *   deriveState, dispatch, reconciliation repairs, and domain writers. Only one active
+ *   project database should own the global handle at a time.
+ * - `openWorkflowDatabaseIsolated` opens a caller-owned connection that does not clobber
+ *   the global handle. Use for read-only observers (parallel monitor) and other background
+ *   probes that must not disturb the active workflow session.
+ * - Reconciliation repairs that write markdown/DB state must use `ensureWorkflowDbForBase`
+ *   so repairs target the correct project; those paths intentionally re-open the global handle.
+ * - Pair ad-hoc project switches with `closeWorkflowDatabase()` or restore via
+ *   `ensureWorkflowDbForBase(..., { refresh: true })` before returning to derive/dispatch.
+ */
 export function resolveWorkflowDatabaseLocation(basePath) {
     const contract = resolveGsdPathContract(basePath);
     return {
@@ -104,6 +118,44 @@ export function getWorkflowDatabasePath() {
 export function refreshWorkflowDatabaseFromDisk() {
     return refreshOpenDatabaseFromDisk();
 }
+export function expectedWorkflowDbPathForBase(basePath) {
+    return join(gsdRoot(basePath), "gsd.db");
+}
+export function ensureWorkflowDbAtPath(dbPath) {
+    if (!dbPath || dbPath === ":memory:")
+        return isDbAvailable();
+    if (isDbAvailable() && getWorkflowDatabasePath() === dbPath)
+        return true;
+    if (!existsSync(dbPath))
+        return false;
+    try {
+        return openWorkflowDatabasePath(dbPath);
+    }
+    catch (err) {
+        logWarning("reconcile", `ensureWorkflowDbAtPath could not reopen DB: ${err.message}`);
+        return false;
+    }
+}
+export function ensureWorkflowDbForBase(basePath, options = {}) {
+    const dbPath = expectedWorkflowDbPathForBase(basePath);
+    if (!existsSync(dbPath))
+        return false;
+    try {
+        if (options.refresh) {
+            if (isDbAvailable() && getWorkflowDatabasePath() === dbPath && refreshWorkflowDatabaseFromDisk()) {
+                return true;
+            }
+            return openWorkflowDatabasePath(dbPath);
+        }
+        if (isDbAvailable() && getWorkflowDatabasePath() === dbPath)
+            return true;
+        return openWorkflowDatabasePath(dbPath);
+    }
+    catch (err) {
+        logWarning("reconcile", `ensureWorkflowDbForBase could not reopen DB: ${err.message}`);
+        return false;
+    }
+}
 export function checkpointWorkflowDatabase() {
     checkpointDatabase();
 }

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

@@ -11,6 +11,7 @@
  *   - Optional search/tool integrations (Brave, Tavily, Jina, Context7)
  */
 import { existsSync, readFileSync } from "node:fs";
+import { access, readFile } from "node:fs/promises";
 import { delimiter, join } from "node:path";
 import { AuthStorage } from "@gsd/pi-coding-agent";
 import { getEnvApiKey } from "@gsd/pi-ai";
@@ -133,15 +134,11 @@ const CLI_AUTH_PATH_CHECK_PROVIDERS = new Set([
     "google-gemini-cli",
     "google-antigravity",
 ]);
-/**
- * Check if a CLI provider's binary exists anywhere in PATH.
- * Fast filesystem scan — no subprocess, no network, sub-1ms.
- */
-function isCliBinaryInPath(providerId) {
+let asyncCliBinaryPathCache = null;
+function cliExecutableNames(providerId) {
     const binaries = CLI_BINARY_MAP[providerId];
     if (!binaries)
-        return false;
-    const pathDirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+        return [];
     // On Windows, command shims are commonly installed as .cmd/.exe/.bat/.com.
     // Scan PATHEXT candidates in addition to the bare binary name.
     const executableNames = [...binaries];
@@ -160,8 +157,45 @@ function isCliBinaryInPath(providerId) {
             }
         }
     }
+    return executableNames;
+}
+/**
+ * Check if a CLI provider's binary exists anywhere in PATH.
+ * Fast filesystem scan — no subprocess, no network, sub-1ms.
+ */
+function isCliBinaryInPath(providerId) {
+    const cached = asyncCliBinaryPathCache?.get(providerId);
+    if (cached !== undefined)
+        return cached;
+    const executableNames = cliExecutableNames(providerId);
+    if (executableNames.length === 0)
+        return false;
+    const pathDirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
     return pathDirs.some(dir => executableNames.some(name => existsSync(join(dir, name))));
 }
+async function isCliBinaryInPathAsync(providerId) {
+    const executableNames = cliExecutableNames(providerId);
+    if (executableNames.length === 0)
+        return false;
+    const pathDirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+    const candidates = pathDirs.flatMap(dir => executableNames.map(name => join(dir, name)));
+    if (candidates.length === 0)
+        return false;
+    try {
+        await Promise.any(candidates.map(candidate => access(candidate)));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function loadCliBinaryPathCache() {
+    const entries = await Promise.all(Object.keys(CLI_BINARY_MAP).map(async (providerId) => [
+        providerId,
+        await isCliBinaryInPathAsync(providerId),
+    ]));
+    return new Map(entries);
+}
 function modelsJsonPaths() {
     const home = homedir();
     return [
@@ -170,7 +204,11 @@ function modelsJsonPaths() {
         join(home, ".pi", "agent", "models.json"),
     ];
 }
+let asyncModelsJsonApiKeyCache = null;
 function hasModelsJsonApiKey(providerId) {
+    if (asyncModelsJsonApiKeyCache) {
+        return asyncModelsJsonApiKeyCache.has(providerId);
+    }
     for (const path of modelsJsonPaths()) {
         if (!existsSync(path))
             continue;
@@ -187,7 +225,25 @@ function hasModelsJsonApiKey(providerId) {
     }
     return false;
 }
-function resolveKey(providerId) {
+async function loadModelsJsonApiKeyCache() {
+    const providersWithKeys = new Set();
+    for (const path of modelsJsonPaths()) {
+        try {
+            const parsed = JSON.parse(await readFile(path, "utf-8"));
+            for (const [providerId, provider] of Object.entries(parsed.providers ?? {})) {
+                const apiKey = provider.apiKey;
+                if (typeof apiKey === "string" && apiKey.trim().length > 0) {
+                    providersWithKeys.add(providerId);
+                }
+            }
+        }
+        catch {
+            // Missing or malformed models.json should not break dashboard health checks.
+        }
+    }
+    return providersWithKeys;
+}
+function resolveKeyFromAuthOrEnv(providerId) {
     const info = PROVIDER_REGISTRY.find(p => p.id === providerId);
     if (providerId === "anthropic-vertex" && process.env.ANTHROPIC_VERTEX_PROJECT_ID) {
         return { found: true, source: "env", backedOff: false };
@@ -234,6 +290,12 @@ function resolveKey(providerId) {
     if (info?.envVar && process.env[info.envVar]) {
         return { found: true, source: "env", backedOff: false };
     }
+    return null;
+}
+function resolveKey(providerId) {
+    const direct = resolveKeyFromAuthOrEnv(providerId);
+    if (direct)
+        return direct;
     if (hasModelsJsonApiKey(providerId)) {
         return { found: true, source: "models.json", backedOff: false };
     }
@@ -432,6 +494,28 @@ export function runProviderChecks() {
     results.push(...checkOptionalProviders());
     return results;
 }
+/**
+ * Non-blocking equivalent of `runProviderChecks` for the health-widget
+ * background refresh. PATH checks and custom models.json discovery use async
+ * filesystem APIs so periodic widget refreshes do not stall the input loop.
+ */
+export async function runProviderChecksAsync() {
+    const [cliCache, modelsJsonCache] = await Promise.all([
+        loadCliBinaryPathCache(),
+        loadModelsJsonApiKeyCache(),
+    ]);
+    const previousCliCache = asyncCliBinaryPathCache;
+    const previousModelsJsonCache = asyncModelsJsonApiKeyCache;
+    asyncCliBinaryPathCache = cliCache;
+    asyncModelsJsonApiKeyCache = modelsJsonCache;
+    try {
+        return runProviderChecks();
+    }
+    finally {
+        asyncCliBinaryPathCache = previousCliCache;
+        asyncModelsJsonApiKeyCache = previousModelsJsonCache;
+    }
+}
 /**
  * Format provider check results as a human-readable report string.
  */

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

@@ -180,10 +180,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 +213,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 +231,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 +259,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 +309,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/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

@@ -225,6 +225,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 +566,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 +577,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 +685,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.