@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.8e6112e9

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

@@ -9,9 +9,10 @@
  * 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";
 // ── Constants ──────────────────────────────────────────────────────────────
 /** Default dev server ports to scan for conflicts. */
 const DEFAULT_DEV_PORTS = [3000, 3001, 4000, 5000, 5173, 8000, 8080, 8888];
@@ -20,26 +21,19 @@ const MIN_DISK_BYTES = 500 * 1024 * 1024;
 /** Timeout for external commands (ms). */
 const CMD_TIMEOUT = 5_000;
 // ── Helpers ────────────────────────────────────────────────────────────────
-/** Worktree sentinel — path segment that marks an auto-worktree directory. */
-const WORKTREE_PATH_SEGMENT = `${join(".gsd", "worktrees")}/`;
 /**
- * Resolve the project root when running inside a `.gsd/worktrees/<name>/`
- * auto-worktree. Returns `null` if not in a worktree.
+ * Resolve the project root when running inside a GSD auto-worktree.
+ * Returns `null` if not in a worktree.
  *
  * Detection order:
  *   1. `GSD_WORKTREE` env var (set by the worktree launcher)
- *   2. `.gsd/worktrees/` segment in basePath
+ *   2. worktree segment in basePath (via worktree-root's layout matching)
  */
 function resolveWorktreeProjectRoot(basePath) {
     const envRoot = process.env.GSD_WORKTREE;
     if (envRoot)
         return envRoot;
-    const normalised = basePath.replace(/\\/g, "/");
-    const idx = normalised.indexOf(WORKTREE_PATH_SEGMENT.replace(/\\/g, "/"));
-    if (idx === -1)
-        return null;
-    // Everything before `.gsd/worktrees/` is the project root
-    return basePath.slice(0, idx);
+    return projectRootFromWorktreePath(basePath);
 }
 function tryExec(cmd, cwd) {
     try {
@@ -62,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.
  */
@@ -190,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 ?? {};
@@ -217,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")
@@ -229,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 {
@@ -273,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` };
     }
@@ -285,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 {
@@ -314,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;
 }
@@ -467,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-format.js

@@ -1,3 +1,7 @@
+import { doctorFixHint } from "./guidance.js";
+function severityTag(severity) {
+    return severity === "error" ? "ERROR" : severity === "warning" ? "WARN" : "INFO";
+}
 function matchesScope(unitId, scope) {
     if (!scope)
         return true;
@@ -47,8 +51,10 @@ export function formatDoctorReport(report, options) {
     if (scopedIssues.length > 0) {
         lines.push("Priority issues:");
         for (const issue of scopedIssues.slice(0, maxIssues)) {
-            const prefix = issue.severity === "error" ? "ERROR" : issue.severity === "warning" ? "WARN" : "INFO";
-            lines.push(`- [${prefix}] ${issue.unitId}: ${issue.message}${issue.file ? ` (${issue.file})` : ""}`);
+            lines.push(`- [${severityTag(issue.severity)}] ${issue.unitId}: ${issue.message}${issue.file ? ` (${issue.file})` : ""}`);
+            const hint = doctorFixHint(issue.code);
+            if (hint && issue.severity !== "info")
+                lines.push(`  Fix: ${hint}`);
         }
         if (scopedIssues.length > maxIssues) {
             lines.push(`- ...and ${scopedIssues.length - maxIssues} more in scope`);
@@ -66,10 +72,7 @@ export function formatDoctorReport(report, options) {
 export function formatDoctorIssuesForPrompt(issues) {
     if (issues.length === 0)
         return "- No remaining issues in scope.";
-    return issues.map(issue => {
-        const prefix = issue.severity === "error" ? "ERROR" : issue.severity === "warning" ? "WARN" : "INFO";
-        return `- [${prefix}] ${issue.unitId} | ${issue.code} | ${issue.message}${issue.file ? ` | file: ${issue.file}` : ""} | fixable: ${issue.fixable ? "yes" : "no"}`;
-    }).join("\n");
+    return issues.map(issue => `- [${severityTag(issue.severity)}] ${issue.unitId} | ${issue.code} | ${issue.message}${issue.file ? ` | file: ${issue.file}` : ""} | fixable: ${issue.fixable ? "yes" : "no"}`).join("\n");
 }
 /**
  * Serialize a doctor report to JSON — suitable for CI/tooling integration.

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

@@ -3,11 +3,10 @@ import { spawnSync } from "node:child_process";
 import { cpSync, existsSync, mkdirSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { loadFile } from "./files.js";
-import { parseRoadmap as parseLegacyRoadmap } from "./parsers-legacy.js";
-import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { resolveMilestoneFile } from "./paths.js";
-import { deriveState, isMilestoneComplete } from "./state.js";
-import { createWorktree, listWorktrees, resolveGitDir, worktreesDir } from "./worktree-manager.js";
+import { isCompletedMilestoneTerminal } from "./milestone-closeout.js";
+import { deriveState } from "./state.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";
 import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddTracked, nativeCommit } from "./native-git-bridge.js";
@@ -141,21 +140,6 @@ function getSnapshotDiffCheckFailure(basePath) {
     }
     return failures.length > 0 ? failures.join("\n") : null;
 }
-async function isCompletedMilestoneTerminal(basePath, milestoneId) {
-    const summaryPath = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
-    if (!summaryPath)
-        return false;
-    if (isDbAvailable()) {
-        const milestone = getMilestone(milestoneId);
-        return !!milestone && milestone.status === "complete";
-    }
-    const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
-    const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
-    if (!roadmapContent)
-        return false;
-    const roadmap = parseLegacyRoadmap(roadmapContent);
-    return isMilestoneComplete(roadmap);
-}
 export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode = "none") {
     // Degrade gracefully if not a git repo
     if (!nativeIsRepo(basePath)) {
@@ -478,8 +462,9 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
     // that is no longer registered with git. These orphaned dirs cause
     // "already exists" errors when re-creating the same worktree name.
     try {
-        const wtDir = worktreesDir(basePath);
-        if (existsSync(wtDir)) {
+        for (const wtDir of allWorktreesDirs(basePath)) {
+            if (!existsSync(wtDir))
+                continue;
             // Resolve symlinks and normalize separators so that symlinked .gsd
             // paths (e.g. ~/.gsd/projects/<hash>/worktrees/…) match the paths
             // returned by `git worktree list`.

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

@@ -391,24 +391,29 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
                 ".gsd/completed-units*.json",
                 ".gsd/event-log.jsonl",
             ];
-            // If blanket .gsd/ or .gsd is present, all patterns are covered
+            // If blanket .gsd/ or .gsd is present, all .gsd/* patterns are covered —
+            // but NOT the .gsd-worktrees/ sibling, which always needs its own entry.
             const hasBlanketIgnore = existingLines.has(".gsd/") || existingLines.has(".gsd");
+            const missing = [];
+            if (!existingLines.has(".gsd-worktrees/") && !existingLines.has(".gsd-worktrees")) {
+                missing.push(".gsd-worktrees/");
+            }
             if (!hasBlanketIgnore) {
-                const missing = criticalPatterns.filter(p => !existingLines.has(p));
-                if (missing.length > 0) {
-                    issues.push({
-                        severity: "warning",
-                        code: "gitignore_missing_patterns",
-                        scope: "project",
-                        unitId: "project",
-                        message: `${missing.length} critical GSD runtime pattern(s) missing from .gitignore: ${missing.join(", ")}`,
-                        file: ".gitignore",
-                        fixable: true,
-                    });
-                    if (shouldFix("gitignore_missing_patterns")) {
-                        ensureGitignore(basePath, { manageGitignore });
-                        fixesApplied.push("added missing GSD runtime patterns to .gitignore");
-                    }
+                missing.push(...criticalPatterns.filter(p => !existingLines.has(p)));
+            }
+            if (missing.length > 0) {
+                issues.push({
+                    severity: "warning",
+                    code: "gitignore_missing_patterns",
+                    scope: "project",
+                    unitId: "project",
+                    message: `${missing.length} critical GSD runtime pattern(s) missing from .gitignore: ${missing.join(", ")}`,
+                    file: ".gitignore",
+                    fixable: true,
+                });
+                if (shouldFix("gitignore_missing_patterns")) {
+                    ensureGitignore(basePath, { manageGitignore });
+                    fixesApplied.push("added missing GSD runtime patterns to .gitignore");
                 }
             }
         }