gsd-pi 2.35.0 → 2.36.0-dev.d612764

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

@@ -0,0 +1,31 @@
+/**
+ * /gsd rate — Submit feedback on the last unit's model tier assignment.
+ * Feeds into the adaptive routing history so future dispatches improve.
+ */
+import { loadLedgerFromDisk } from "./metrics.js";
+import { recordFeedback, initRoutingHistory } from "./routing-history.js";
+const VALID_RATINGS = new Set(["over", "under", "ok"]);
+export async function handleRate(args, ctx, basePath) {
+    const rating = args.trim().toLowerCase();
+    if (!rating || !VALID_RATINGS.has(rating)) {
+        ctx.ui.notify("Usage: /gsd rate <over|ok|under>\n" +
+            "  over  — model was overpowered for that task (encourage cheaper)\n" +
+            "  ok    — model was appropriate\n" +
+            "  under — model was too weak (encourage stronger)", "info");
+        return;
+    }
+    const ledger = loadLedgerFromDisk(basePath);
+    if (!ledger || ledger.units.length === 0) {
+        ctx.ui.notify("No completed units found — nothing to rate.", "warning");
+        return;
+    }
+    const lastUnit = ledger.units[ledger.units.length - 1];
+    const tier = lastUnit.tier;
+    if (!tier) {
+        ctx.ui.notify("Last unit has no tier data (dynamic routing was not active). Rating skipped.", "warning");
+        return;
+    }
+    initRoutingHistory(basePath);
+    recordFeedback(lastUnit.type, lastUnit.id, tier, rating);
+    ctx.ui.notify(`Recorded "${rating}" for ${lastUnit.type}/${lastUnit.id} at tier ${tier}.`, "info");
+}

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

@@ -36,6 +36,8 @@ import { computeProgressScore, formatProgressLine } from "./progress-score.js";
 import { runEnvironmentChecks } from "./doctor-environment.js";
 import { handleLogs } from "./commands-logs.js";
 import { handleStart, handleTemplates, getTemplateCompletions } from "./commands-workflow-templates.js";
+import { readSessionLockData, isSessionLockProcessAlive } from "./session-lock.js";
+import { handleCmux } from "./commands-cmux.js";
 /** Resolve the effective project root, accounting for worktree paths. */
 export function projectRoot() {
     const cwd = process.cwd();
@@ -54,9 +56,41 @@ export function projectRoot() {
     }
     return root;
 }
+/**
+ * Check if another process holds the auto-mode session lock.
+ * Returns the lock data if a remote session is alive, null otherwise.
+ */
+function getRemoteAutoSession(basePath) {
+    const lockData = readSessionLockData(basePath);
+    if (!lockData)
+        return null;
+    if (lockData.pid === process.pid)
+        return null;
+    if (!isSessionLockProcessAlive(lockData))
+        return null;
+    return { pid: lockData.pid };
+}
+/**
+ * Show a steering menu when auto-mode is running in another process.
+ * Returns true if a remote session was detected (caller should return early).
+ */
+function notifyRemoteAutoActive(ctx, basePath) {
+    const remote = getRemoteAutoSession(basePath);
+    if (!remote)
+        return false;
+    ctx.ui.notify(`Auto-mode is running in another process (PID ${remote.pid}).\n` +
+        `Use these commands to interact with it:\n` +
+        `  /gsd status   — check progress\n` +
+        `  /gsd discuss  — discuss architecture decisions\n` +
+        `  /gsd queue    — queue the next milestone\n` +
+        `  /gsd steer    — apply an override to active work\n` +
+        `  /gsd capture  — fire-and-forget thought\n` +
+        `  /gsd stop     — stop auto-mode`, "warning");
+    return true;
+}
 export function registerGSDCommand(pi) {
     pi.registerCommand("gsd", {
-        description: "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|visualize|queue|quick|capture|triage|dispatch|history|undo|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|update",
+        description: "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|visualize|queue|quick|capture|triage|dispatch|history|undo|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|update",
         getArgumentCompletions: (prefix) => {
             const subcommands = [
                 { cmd: "help", desc: "Categorized command reference with descriptions" },
@@ -65,6 +99,7 @@ export function registerGSDCommand(pi) {
                 { cmd: "stop", desc: "Stop auto mode gracefully" },
                 { cmd: "pause", desc: "Pause auto-mode (preserves state, /gsd auto to resume)" },
                 { cmd: "status", desc: "Progress dashboard" },
+                { cmd: "widget", desc: "Cycle widget: full → small → min → off" },
                 { cmd: "visualize", desc: "Open 10-tab workflow visualizer (progress, timeline, deps, metrics, health, agent, changes, knowledge, captures, export)" },
                 { cmd: "queue", desc: "Queue and reorder future milestones" },
                 { cmd: "quick", desc: "Execute a quick task without full planning overhead" },
@@ -74,6 +109,7 @@ export function registerGSDCommand(pi) {
                 { cmd: "triage", desc: "Manually trigger triage of pending captures" },
                 { cmd: "dispatch", desc: "Dispatch a specific phase directly" },
                 { cmd: "history", desc: "View execution history" },
+                { cmd: "rate", desc: "Rate last unit's model tier (over/ok/under) — improves adaptive routing" },
                 { cmd: "undo", desc: "Revert last completed unit" },
                 { cmd: "skip", desc: "Prevent a unit from auto-mode dispatch" },
                 { cmd: "export", desc: "Export milestone/slice results" },
@@ -97,6 +133,7 @@ export function registerGSDCommand(pi) {
                 { cmd: "knowledge", desc: "Add persistent project knowledge (rule, pattern, or lesson)" },
                 { cmd: "new-milestone", desc: "Create a milestone from a specification document (headless)" },
                 { cmd: "parallel", desc: "Parallel milestone orchestration (start, status, stop, merge)" },
+                { cmd: "cmux", desc: "Manage cmux integration (status, sidebar, notifications, splits)" },
                 { cmd: "park", desc: "Park a milestone — skip without deleting" },
                 { cmd: "unpark", desc: "Reactivate a parked milestone" },
                 { cmd: "update", desc: "Update GSD to the latest version" },
@@ -148,6 +185,36 @@ export function registerGSDCommand(pi) {
                     .filter((s) => s.cmd.startsWith(subPrefix))
                     .map((s) => ({ value: `parallel ${s.cmd}`, label: s.cmd, description: s.desc }));
             }
+            if (parts[0] === "cmux") {
+                if (parts.length <= 2) {
+                    const subPrefix = parts[1] ?? "";
+                    const subs = [
+                        { cmd: "status", desc: "Show cmux detection, prefs, and capabilities" },
+                        { cmd: "on", desc: "Enable cmux integration" },
+                        { cmd: "off", desc: "Disable cmux integration" },
+                        { cmd: "notifications", desc: "Toggle cmux desktop notifications" },
+                        { cmd: "sidebar", desc: "Toggle cmux sidebar metadata" },
+                        { cmd: "splits", desc: "Toggle cmux visual subagent splits" },
+                        { cmd: "browser", desc: "Toggle future browser integration flag" },
+                    ];
+                    return subs
+                        .filter((s) => s.cmd.startsWith(subPrefix))
+                        .map((s) => ({ value: `cmux ${s.cmd}`, label: s.cmd, description: s.desc }));
+                }
+                if (parts.length <= 3 && ["notifications", "sidebar", "splits", "browser"].includes(parts[1])) {
+                    const togglePrefix = parts[2] ?? "";
+                    return [
+                        { cmd: "on", desc: "Enable this cmux area" },
+                        { cmd: "off", desc: "Disable this cmux area" },
+                    ]
+                        .filter((item) => item.cmd.startsWith(togglePrefix))
+                        .map((item) => ({
+                        value: `cmux ${parts[1]} ${item.cmd}`,
+                        label: item.cmd,
+                        description: item.desc,
+                    }));
+                }
+            }
             if (parts[0] === "setup" && parts.length <= 2) {
                 const subPrefix = parts[1] ?? "";
                 const subs = [
@@ -396,6 +463,18 @@ export async function handleGSDCommand(args, ctx, pi) {
         await handleStatus(ctx);
         return;
     }
+    if (trimmed === "widget" || trimmed.startsWith("widget ")) {
+        const { cycleWidgetMode, setWidgetMode, getWidgetMode } = await import("./auto-dashboard.js");
+        const arg = trimmed.replace(/^widget\s*/, "").trim();
+        if (arg === "full" || arg === "small" || arg === "min" || arg === "off") {
+            setWidgetMode(arg);
+        }
+        else {
+            cycleWidgetMode();
+        }
+        ctx.ui.notify(`Widget: ${getWidgetMode()}`, "info");
+        return;
+    }
     if (trimmed === "visualize") {
         await handleVisualize(ctx);
         return;
@@ -412,6 +491,10 @@ export async function handleGSDCommand(args, ctx, pi) {
         await handlePrefs(trimmed.replace(/^prefs\s*/, "").trim(), ctx);
         return;
     }
+    if (trimmed === "cmux" || trimmed.startsWith("cmux ")) {
+        await handleCmux(trimmed.replace(/^cmux\s*/, "").trim(), ctx);
+        return;
+    }
     if (trimmed === "init") {
         const { detectProjectState } = await import("./detection.js");
         const { showProjectInit, handleReinit } = await import("./init-wizard.js");
@@ -459,6 +542,8 @@ export async function handleGSDCommand(args, ctx, pi) {
             await handleDryRun(ctx, projectRoot());
             return;
         }
+        if (notifyRemoteAutoActive(ctx, projectRoot()))
+            return;
         const verboseMode = trimmed.includes("--verbose");
         const debugMode = trimmed.includes("--debug");
         if (debugMode)
@@ -513,6 +598,11 @@ export async function handleGSDCommand(args, ctx, pi) {
         await handleUndo(trimmed.replace(/^undo\s*/, "").trim(), ctx, pi, projectRoot());
         return;
     }
+    if (trimmed === "rate" || trimmed.startsWith("rate ")) {
+        const { handleRate } = await import("./commands-rate.js");
+        await handleRate(trimmed.replace(/^rate\s*/, "").trim(), ctx, projectRoot());
+        return;
+    }
     if (trimmed.startsWith("skip ")) {
         await handleSkip(trimmed.replace(/^skip\s*/, "").trim(), ctx, projectRoot());
         return;
@@ -809,7 +899,8 @@ Examples:
         return;
     }
     if (trimmed === "") {
-        // Bare /gsd defaults to step mode
+        if (notifyRemoteAutoActive(ctx, projectRoot()))
+            return;
         await startAuto(ctx, pi, projectRoot(), false, { step: true });
         return;
     }
@@ -858,6 +949,7 @@ function showHelp(ctx) {
         "  /gsd setup          Global setup status  [llm|search|remote|keys|prefs]",
         "  /gsd mode           Set workflow mode (solo/team)  [global|project]",
         "  /gsd prefs          Manage preferences  [global|project|status|wizard|setup|import-claude]",
+        "  /gsd cmux           Manage cmux integration  [status|on|off|notifications|sidebar|splits|browser]",
         "  /gsd config         Set API keys for external tools",
         "  /gsd keys           API key manager  [list|add|remove|test|rotate|doctor]",
         "  /gsd hooks          Show post-unit hook configuration",

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -173,6 +173,13 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
   - `on_milestone`: boolean — notify when a milestone finishes. Default: `true`.
   - `on_attention`: boolean — notify when manual attention is needed. Default: `true`.
 
+- `cmux`: configures cmux terminal integration when GSD is running inside a cmux workspace. Keys:
+  - `enabled`: boolean — master toggle for cmux integration. Default: `false`.
+  - `notifications`: boolean — route desktop notifications through cmux. Default: `true` when enabled.
+  - `sidebar`: boolean — publish status, progress, and log metadata to the cmux sidebar. Default: `true` when enabled.
+  - `splits`: boolean — run supported subagent work in visible cmux splits. Default: `false`.
+  - `browser`: boolean — reserve the future browser integration flag. Default: `false`.
+
 - `dynamic_routing`: configures the dynamic model router that adjusts model selection based on task complexity. Keys:
   - `enabled`: boolean — enable dynamic routing. Default: `false`.
   - `tier_models`: object — model overrides per complexity tier. Keys: `light`, `standard`, `heavy`. Values are model ID strings.
@@ -477,6 +484,24 @@ Disables per-unit completion notifications (noisy in long runs) while keeping er
 
 ---
 
+## cmux Example
+
+```yaml
+---
+version: 1
+cmux:
+  enabled: true
+  notifications: true
+  sidebar: true
+  splits: true
+  browser: false
+---
+```
+
+Enables cmux-aware notifications, sidebar metadata, and visible subagent splits when GSD is running inside a cmux terminal.
+
+---
+
 ## Post-Unit Hooks Example
 
 ```yaml

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

@@ -148,27 +148,36 @@ function checkPortConflicts(basePath) {
     // Try to detect ports from package.json scripts
     const portsToCheck = new Set();
     const pkgPath = join(basePath, "package.json");
-    if (existsSync(pkgPath)) {
-        try {
-            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-            const scripts = pkg.scripts ?? {};
-            const scriptText = Object.values(scripts).join(" ");
-            // Look for --port NNNN, -p NNNN, PORT=NNNN, :NNNN patterns
-            const portMatches = scriptText.matchAll(/(?:--port\s+|(?:^|[^a-z])PORT[=:]\s*|-p\s+|:)(\d{4,5})\b/gi);
-            for (const m of portMatches) {
-                const port = parseInt(m[1], 10);
-                if (port >= 1024 && port <= 65535)
-                    portsToCheck.add(port);
-            }
-        }
-        catch {
-            // parse failed — use defaults
+    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 [];
+    }
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        const scripts = pkg.scripts ?? {};
+        const scriptText = Object.values(scripts).join(" ");
+        // Look for --port NNNN, -p NNNN, PORT=NNNN, :NNNN patterns
+        const portMatches = scriptText.matchAll(/(?:--port\s+|(?:^|[^a-z])PORT[=:]\s*|-p\s+|:)(\d{4,5})\b/gi);
+        for (const m of portMatches) {
+            const port = parseInt(m[1], 10);
+            if (port >= 1024 && port <= 65535)
+                portsToCheck.add(port);
         }
     }
-    // If no ports found in scripts, check common defaults
+    catch {
+        // parse failed — skip port checks rather than using defaults
+        return [];
+    }
+    // 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)
+        for (const p of DEFAULT_DEV_PORTS) {
+            if (p === 5000 && process.platform === "darwin")
+                continue;
             portsToCheck.add(p);
+        }
     }
     for (const port of portsToCheck) {
         const result = tryExec(`lsof -i :${port} -sTCP:LISTEN -t`, basePath);

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

@@ -509,7 +509,8 @@ export async function loadFile(path) {
         return await fs.readFile(path, 'utf-8');
     }
     catch (err) {
-        if (err.code === 'ENOENT')
+        const code = err.code;
+        if (code === 'ENOENT' || code === 'EISDIR')
             return null;
         throw err;
     }
@@ -704,7 +705,7 @@ export async function inlinePriorMilestoneSummary(mid, base) {
  * Returns `null` when no manifest file exists (path resolution failure or
  * file not on disk) - callers can distinguish "no manifest" from "empty manifest".
  */
-export async function getManifestStatus(base, milestoneId) {
+export async function getManifestStatus(base, milestoneId, projectRoot) {
     const resolvedPath = resolveMilestoneFile(base, milestoneId, 'SECRETS');
     if (!resolvedPath)
         return null;
@@ -713,8 +714,16 @@ export async function getManifestStatus(base, milestoneId) {
         return null;
     const manifest = parseSecretsManifest(content);
     const keys = manifest.entries.map(e => e.key);
+    // Check both the base path .env AND the project root .env (#1387).
+    // In worktree mode, base is the worktree path which may not have .env.
+    // The project root's .env is where the user actually defined their keys.
     const existingKeys = await checkExistingEnvKeys(keys, resolve(base, '.env'));
     const existingSet = new Set(existingKeys);
+    if (projectRoot && projectRoot !== base) {
+        const rootKeys = await checkExistingEnvKeys(keys, resolve(projectRoot, '.env'));
+        for (const k of rootKeys)
+            existingSet.add(k);
+    }
     const result = {
         pending: [],
         collected: [],

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

@@ -6,8 +6,8 @@
  * Both idempotent — non-destructive if already present.
  */
 import { join } from "node:path";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { nativeRmCached } from "./native-git-bridge.js";
+import { existsSync, lstatSync, readFileSync, writeFileSync } from "node:fs";
+import { nativeRmCached, nativeLsFiles } from "./native-git-bridge.js";
 import { gsdRoot } from "./paths.js";
 /**
  * GSD runtime patterns for git index cleanup.
@@ -67,12 +67,48 @@ const BASELINE_PATTERNS = [
     "tmp/",
 ];
 /**
- * Ensure basePath/.gitignore contains a blanket `.gsd/` ignore.
- * Creates the file if missing; appends `.gsd/` if not present.
+ * Check whether `.gsd/` contains files tracked by git.
+ * If so, the project intentionally keeps `.gsd/` in version control
+ * and we must NOT add `.gsd` to `.gitignore` or attempt migration.
+ *
+ * Returns true if git tracks at least one file under `.gsd/`.
+ * Returns false (safe to ignore) if:
+ *   - Not a git repo
+ *   - `.gsd/` is a symlink (external state, should be ignored)
+ *   - `.gsd/` doesn't exist
+ *   - No tracked files found under `.gsd/`
+ */
+export function hasGitTrackedGsdFiles(basePath) {
+    const localGsd = join(basePath, ".gsd");
+    // If .gsd doesn't exist or is already a symlink, no tracked files concern
+    if (!existsSync(localGsd))
+        return false;
+    try {
+        if (lstatSync(localGsd).isSymbolicLink())
+            return false;
+    }
+    catch {
+        return false;
+    }
+    // Check if git tracks any files under .gsd/
+    try {
+        const tracked = nativeLsFiles(basePath, ".gsd");
+        return tracked.length > 0;
+    }
+    catch {
+        // Not a git repo or git not available — safe to proceed
+        return false;
+    }
+}
+/**
+ * Ensure basePath/.gitignore contains baseline ignore patterns.
+ * Creates the file if missing; appends missing patterns.
  * Returns true if the file was created or modified, false if already complete.
  *
- * `.gsd/` state is managed externally (symlinked to `~/.gsd/projects/<hash>/`),
- * so the entire directory is always gitignored.
+ * **Safety check:** If `.gsd/` contains git-tracked files (i.e., the project
+ * intentionally keeps `.gsd/` in version control), the `.gsd` ignore pattern
+ * is excluded to prevent data loss. Only the `.gsd` pattern is affected —
+ * all other baseline patterns are still applied normally.
  */
 export function ensureGitignore(basePath, options) {
     // If manage_gitignore is explicitly false, do not touch .gitignore at all
@@ -88,8 +124,14 @@ export function ensureGitignore(basePath, options) {
         .split("\n")
         .map((l) => l.trim())
         .filter((l) => l && !l.startsWith("#")));
+    // Determine which patterns to apply. If .gsd/ has tracked files,
+    // exclude the ".gsd" pattern to prevent deleting tracked state.
+    const gsdIsTracked = hasGitTrackedGsdFiles(basePath);
+    const patternsToApply = gsdIsTracked
+        ? BASELINE_PATTERNS.filter((p) => p !== ".gsd")
+        : BASELINE_PATTERNS;
     // Find patterns not yet present
-    const missing = BASELINE_PATTERNS.filter((p) => !existingLines.has(p));
+    const missing = patternsToApply.filter((p) => !existingLines.has(p));
     if (missing.length === 0)
         return false;
     // Build the block to append
@@ -111,6 +153,11 @@ export function ensureGitignore(basePath, options) {
  * already in the index even after .gitignore is updated.
  *
  * Only removes from the index (`--cached`), never from disk. Idempotent.
+ *
+ * Note: These are strictly runtime/ephemeral paths (activity logs, lock files,
+ * metrics, STATE.md). They are always safe to untrack, even when the project
+ * intentionally keeps other `.gsd/` files (like PROJECT.md, milestones/) in
+ * version control.
  */
 export function untrackRuntimeFiles(basePath) {
     const runtimePaths = GSD_RUNTIME_PATTERNS;

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

@@ -17,6 +17,7 @@ import { resolveExpectedArtifactPath } from "./auto.js";
 import { gsdRoot, milestonesDir, resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveGsdRootFile, relGsdRootFile, relMilestoneFile, relSliceFile, } from "./paths.js";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from "node:fs";
+import { readSessionLockData, isSessionLockProcessAlive } from "./session-lock.js";
 import { nativeIsRepo, nativeInit } from "./native-git-bridge.js";
 import { ensureGitignore, ensurePreferences, untrackRuntimeFiles } from "./gitignore.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
@@ -154,7 +155,7 @@ function parseMilestoneSequenceFromProject(content) {
  * This is the only way the wizard triggers work — everything else is the LLM's job.
  */
 function dispatchWorkflow(pi, note, customType = "gsd-run") {
-    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".pi", "GSD-WORKFLOW.md");
+    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
     pi.sendMessage({
         customType,
@@ -426,7 +427,12 @@ export async function showDiscuss(ctx, pi, basePath) {
         // If all pending slices are discussed, notify and exit instead of looping
         const allDiscussed = pendingSlices.every(s => discussedMap.get(s.id));
         if (allDiscussed) {
-            ctx.ui.notify(`All ${pendingSlices.length} slices discussed. Run /gsd to start planning.`, "info");
+            const lockData = readSessionLockData(basePath);
+            const remoteAutoRunning = lockData && lockData.pid !== process.pid && isSessionLockProcessAlive(lockData);
+            const nextStep = remoteAutoRunning
+                ? "Auto-mode is already running — use /gsd status to check progress."
+                : "Run /gsd to start planning.";
+            ctx.ui.notify(`All ${pendingSlices.length} slices discussed. ${nextStep}`, "info");
             return;
         }
         // Find the first undiscussed slice to recommend

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

@@ -0,0 +1,96 @@
+/**
+ * Pure GSD health widget logic.
+ *
+ * Separates project-state detection and line rendering from the widget's
+ * runtime integrations so the regressions can be tested directly.
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { gsdRoot } from "./paths.js";
+import { join } from "node:path";
+export function detectHealthWidgetProjectState(basePath) {
+    const root = gsdRoot(basePath);
+    if (!existsSync(root))
+        return "none";
+    // Lightweight milestone count — avoids the full detectProjectState() scan
+    // (CI markers, Makefile targets, etc.) that is unnecessary on the 60s refresh.
+    try {
+        const milestonesDir = join(root, "milestones");
+        if (existsSync(milestonesDir)) {
+            const entries = readdirSync(milestonesDir, { withFileTypes: true });
+            if (entries.some(e => e.isDirectory()))
+                return "active";
+        }
+    }
+    catch { /* non-fatal */ }
+    return "initialized";
+}
+function formatCost(n) {
+    return n >= 1 ? `$${n.toFixed(2)}` : `${(n * 100).toFixed(1)}¢`;
+}
+function formatProgress(progress) {
+    if (!progress)
+        return null;
+    const parts = [];
+    parts.push(`M ${progress.milestones.done}/${progress.milestones.total}`);
+    if (progress.slices)
+        parts.push(`S ${progress.slices.done}/${progress.slices.total}`);
+    if (progress.tasks)
+        parts.push(`T ${progress.tasks.done}/${progress.tasks.total}`);
+    return parts.length > 0 ? `Progress: ${parts.join(" · ")}` : null;
+}
+function formatEnvironmentSummary(errorCount, warningCount) {
+    if (errorCount <= 0 && warningCount <= 0)
+        return null;
+    const parts = [];
+    if (errorCount > 0)
+        parts.push(`${errorCount} error${errorCount > 1 ? "s" : ""}`);
+    if (warningCount > 0)
+        parts.push(`${warningCount} warning${warningCount > 1 ? "s" : ""}`);
+    return `Env: ${parts.join(", ")}`;
+}
+function formatBudgetSummary(data) {
+    if (data.budgetCeiling !== undefined && data.budgetCeiling > 0) {
+        const pct = Math.min(100, (data.budgetSpent / data.budgetCeiling) * 100);
+        return `Budget: ${formatCost(data.budgetSpent)}/${formatCost(data.budgetCeiling)} (${pct.toFixed(0)}%)`;
+    }
+    if (data.budgetSpent > 0) {
+        return `Spent: ${formatCost(data.budgetSpent)}`;
+    }
+    return null;
+}
+function buildExecutionHeadline(data) {
+    const status = data.executionStatus ?? "Active project";
+    const target = data.executionTarget ?? data.blocker ?? "loading status…";
+    return `  GSD  ${status}${target ? ` - ${target}` : ""}`;
+}
+/**
+ * Build compact health lines for the widget.
+ * Returns a string array suitable for setWidget().
+ */
+export function buildHealthLines(data) {
+    if (data.projectState === "none") {
+        return ["  GSD  No project loaded — run /gsd to start"];
+    }
+    if (data.projectState === "initialized") {
+        return ["  GSD  Project initialized — run /gsd to continue setup"];
+    }
+    const lines = [buildExecutionHeadline(data)];
+    const details = [];
+    const progress = formatProgress(data.progress);
+    if (progress)
+        details.push(progress);
+    if (data.providerIssue)
+        details.push(data.providerIssue);
+    const environment = formatEnvironmentSummary(data.environmentErrorCount, data.environmentWarningCount);
+    if (environment)
+        details.push(environment);
+    const budget = formatBudgetSummary(data);
+    if (budget)
+        details.push(budget);
+    if (data.eta)
+        details.push(data.eta);
+    if (details.length > 0) {
+        lines.push(`  ${details.join("  │  ")}`);
+    }
+    return lines;
+}