gsd-pi 2.35.0-dev.cd3b7ea → 2.36.0

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

@@ -15,7 +15,7 @@ import { isAutoActive } from "./auto.js";
 import { projectRoot } from "./commands.js";
 import { loadPrompt } from "./prompt-loader.js";
 export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
-    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");
     const prompt = loadPrompt("doctor-heal", {
         doctorSummary: reportText,
@@ -144,7 +144,7 @@ export async function handleTriage(ctx, pi, basePath) {
         currentPlan: currentPlan || "(no active slice plan)",
         roadmapContext: roadmapContext || "(no active roadmap)",
     });
-    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: "gsd-triage",

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

@@ -3,6 +3,9 @@
  *
  * Contains: InspectData type, formatInspectOutput, handleInspect
  */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { gsdRoot } from "./paths.js";
 import { getErrorMessage } from "./error-utils.js";
 export function formatInspectOutput(data) {
     const lines = [];
@@ -30,10 +33,14 @@ export function formatInspectOutput(data) {
 }
 export async function handleInspect(ctx) {
     try {
-        const { isDbAvailable, _getAdapter } = await import("./gsd-db.js");
+        const { isDbAvailable, _getAdapter, openDatabase } = await import("./gsd-db.js");
         if (!isDbAvailable()) {
-            ctx.ui.notify("No GSD database available. Run /gsd auto to create one.", "info");
-            return;
+            const gsdDir = gsdRoot(process.cwd());
+            const dbPath = join(gsdDir, "gsd.db");
+            if (!existsSync(gsdDir) || !existsSync(dbPath) || !openDatabase(dbPath)) {
+                ctx.ui.notify("No GSD database available. Run /gsd auto to create one.", "info");
+                return;
+            }
         }
         const adapter = _getAdapter();
         if (!adapter) {

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,7 @@ 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";
 /** Resolve the effective project root, accounting for worktree paths. */
 export function projectRoot() {
     const cwd = process.cwd();
@@ -54,6 +55,38 @@ 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",
@@ -74,6 +107,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" },
@@ -459,6 +493,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 +549,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 +850,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;
     }

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;
+}