gsd-pi 2.37.0 → 2.37.1-dev.3bbb0a9

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

@@ -12,7 +12,7 @@ import { deriveState } from "./state.js";
 import { GSDDashboardOverlay } from "./dashboard-overlay.js";
 import { GSDVisualizerOverlay } from "./visualizer-overlay.js";
 import { showQueue, showDiscuss, showHeadlessMilestoneCreation } from "./guided-flow.js";
-import { startAuto, stopAuto, pauseAuto, isAutoActive, isAutoPaused, stopAutoRemote } from "./auto.js";
+import { startAuto, stopAuto, pauseAuto, isAutoActive, isAutoPaused, stopAutoRemote, checkRemoteAutoSession } from "./auto.js";
 import { dispatchDirectPhase } from "./auto-direct-dispatch.js";
 import { resolveProjectRoot } from "./worktree.js";
 import { assertSafeDirectory } from "./validate-directory.js";
@@ -36,8 +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";
+import { showNextAction } from "../shared/mod.js";
 /** Resolve the effective project root, accounting for worktree paths. */
 export function projectRoot() {
     const cwd = process.cwd();
@@ -57,36 +57,81 @@ 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.
+ * Guard against starting auto-mode when a remote session is already running.
+ * Returns true if the caller should proceed with startAuto, false if handled.
  */
-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)
+async function guardRemoteSession(ctx, pi) {
+    // Local session already active — proceed (startAuto handles re-entrant calls)
+    if (isAutoActive() || isAutoPaused())
+        return true;
+    const remote = checkRemoteAutoSession(projectRoot());
+    if (!remote.running || !remote.pid)
+        return true;
+    const unitLabel = remote.unitType && remote.unitId
+        ? `${remote.unitType} (${remote.unitId})`
+        : "unknown unit";
+    const unitsMsg = remote.completedUnits != null
+        ? `${remote.completedUnits} units completed`
+        : "";
+    const choice = await showNextAction(ctx, {
+        title: `Auto-mode is running in another terminal (PID ${remote.pid})`,
+        summary: [
+            `Currently executing: ${unitLabel}`,
+            ...(unitsMsg ? [unitsMsg] : []),
+            ...(remote.startedAt ? [`Started: ${remote.startedAt}`] : []),
+        ],
+        actions: [
+            {
+                id: "status",
+                label: "View status",
+                description: "Show the current GSD progress dashboard.",
+                recommended: true,
+            },
+            {
+                id: "steer",
+                label: "Steer the session",
+                description: "Use /gsd steer <instruction> to redirect the running session.",
+            },
+            {
+                id: "stop",
+                label: "Stop remote session",
+                description: `Send SIGTERM to PID ${remote.pid} to stop it gracefully.`,
+            },
+            {
+                id: "force",
+                label: "Force start (steal lock)",
+                description: "Start a new session, terminating the existing one.",
+            },
+        ],
+        notYetMessage: "Run /gsd when ready.",
+    });
+    if (choice === "status") {
+        await handleStatus(ctx);
+        return false;
+    }
+    if (choice === "steer") {
+        ctx.ui.notify("Use /gsd steer <instruction> to redirect the running auto-mode session.\n" +
+            "Example: /gsd steer Use Postgres instead of SQLite", "info");
+        return false;
+    }
+    if (choice === "stop") {
+        const result = stopAutoRemote(projectRoot());
+        if (result.found) {
+            ctx.ui.notify(`Sent stop signal to auto-mode session (PID ${result.pid}). It will shut down gracefully.`, "info");
+        }
+        else if (result.error) {
+            ctx.ui.notify(`Failed to stop remote auto-mode: ${result.error}`, "error");
+        }
+        else {
+            ctx.ui.notify("Remote session is no longer running.", "info");
+        }
         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;
+    }
+    if (choice === "force") {
+        return true; // Proceed — startAuto will steal the lock
+    }
+    // "not_yet" or escape
+    return false;
 }
 export function registerGSDCommand(pi) {
     pi.registerCommand("gsd", {
@@ -542,12 +587,12 @@ 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)
             enableDebug(projectRoot());
+        if (!(await guardRemoteSession(ctx, pi)))
+            return;
         await startAuto(ctx, pi, projectRoot(), verboseMode, { step: true });
         return;
     }
@@ -556,6 +601,8 @@ export async function handleGSDCommand(args, ctx, pi) {
         const debugMode = trimmed.includes("--debug");
         if (debugMode)
             enableDebug(projectRoot());
+        if (!(await guardRemoteSession(ctx, pi)))
+            return;
         await startAuto(ctx, pi, projectRoot(), verboseMode);
         return;
     }
@@ -899,7 +946,7 @@ Examples:
         return;
     }
     if (trimmed === "") {
-        if (notifyRemoteAutoActive(ctx, projectRoot()))
+        if (!(await guardRemoteSession(ctx, pi)))
             return;
         await startAuto(ctx, pi, projectRoot(), false, { step: true });
         return;

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

@@ -12,6 +12,7 @@
  */
 import { existsSync } from "node:fs";
 import { AuthStorage } from "@gsd/pi-coding-agent";
+import { getEnvApiKey } from "@gsd/pi-ai";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { getAuthPath, PROVIDER_REGISTRY } from "./key-manager.js";
 // ── Model → Provider ID mapping ───────────────────────────────────────────────
@@ -33,6 +34,7 @@ function modelToProviderId(model) {
             google: "google",
             anthropic: "anthropic",
             openai: "openai",
+            "github-copilot": "github-copilot",
         };
         if (prefixMap[prefix])
             return prefixMap[prefix];
@@ -108,13 +110,29 @@ function resolveKey(providerId) {
             // auth.json malformed — fall through to env check
         }
     }
-    // Check environment variable
+    // Check environment variable using the authoritative env var resolution
+    // (handles multi-var lookups like ANTHROPIC_OAUTH_TOKEN || ANTHROPIC_API_KEY,
+    //  COPILOT_GITHUB_TOKEN || GH_TOKEN || GITHUB_TOKEN, Vertex ADC, Bedrock, etc.)
+    if (getEnvApiKey(providerId)) {
+        return { found: true, source: "env", backedOff: false };
+    }
+    // Fall back to PROVIDER_REGISTRY env var for providers not covered by getEnvApiKey
+    // (e.g., search providers like Brave, Tavily; tool providers like Jina, Context7)
     if (info?.envVar && process.env[info.envVar]) {
         return { found: true, source: "env", backedOff: false };
     }
     return { found: false, source: "none", backedOff: false };
 }
 // ── Individual check groups ────────────────────────────────────────────────────
+/**
+ * Providers that can serve models normally associated with another provider.
+ * Key = the provider whose models can be served, Value = alternative providers to check.
+ * e.g. GitHub Copilot subscriptions can access Claude and GPT models.
+ */
+const PROVIDER_ROUTES = {
+    anthropic: ["github-copilot"],
+    openai: ["github-copilot"],
+};
 function checkLlmProviders() {
     const required = collectConfiguredModelProviders();
     const results = [];
@@ -123,6 +141,22 @@ function checkLlmProviders() {
         const label = info?.label ?? providerId;
         const lookup = resolveKey(providerId);
         if (!lookup.found) {
+            // Check if a cross-provider can serve this provider's models
+            const routes = PROVIDER_ROUTES[providerId];
+            const routeProvider = routes?.find(routeId => resolveKey(routeId).found);
+            if (routeProvider) {
+                const routeInfo = PROVIDER_REGISTRY.find(p => p.id === routeProvider);
+                const routeLabel = routeInfo?.label ?? routeProvider;
+                results.push({
+                    name: providerId,
+                    label,
+                    category: "llm",
+                    status: "ok",
+                    message: `${label} — available via ${routeLabel}`,
+                    required: true,
+                });
+                continue;
+            }
             const envVar = info?.envVar ?? `${providerId.toUpperCase()}_API_KEY`;
             results.push({
                 name: providerId,

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

@@ -629,6 +629,47 @@ export function countMustHavesMentionedInSummary(mustHaves, summaryContent) {
     }
     return count;
 }
+// ─── Task Plan IO Extractor ────────────────────────────────────────────────
+/**
+ * Extract input and output file paths from a task plan's `## Inputs` and
+ * `## Expected Output` sections. Looks for backtick-wrapped file paths on
+ * each line (e.g. `` `src/foo.ts` ``).
+ *
+ * Returns empty arrays for missing/empty sections — callers should treat
+ * tasks with no IO as ambiguous (sequential fallback trigger).
+ */
+export function parseTaskPlanIO(content) {
+    const backtickPathRegex = /`([^`]+)`/g;
+    function extractPaths(sectionText) {
+        if (!sectionText)
+            return [];
+        const paths = [];
+        for (const line of sectionText.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            let match;
+            backtickPathRegex.lastIndex = 0;
+            while ((match = backtickPathRegex.exec(trimmed)) !== null) {
+                const candidate = match[1];
+                // Filter out things that look like code tokens rather than file paths
+                // (e.g. `true`, `false`, `npm run test`). A file path has at least one
+                // dot or slash.
+                if (candidate.includes("/") || candidate.includes(".")) {
+                    paths.push(candidate);
+                }
+            }
+        }
+        return paths;
+    }
+    const [, body] = splitFrontmatter(content);
+    const inputSection = extractSection(body, "Inputs");
+    const outputSection = extractSection(body, "Expected Output");
+    return {
+        inputFiles: extractPaths(inputSection),
+        outputFiles: extractPaths(outputSection),
+    };
+}
 /**
  * Extract the UAT type from a UAT file's raw content.
  *

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

@@ -349,10 +349,18 @@ export class GitServiceImpl {
         }
         const wtName = detectWorktreeName(this.basePath);
         if (wtName) {
+            // Auto-mode worktrees use milestone/<MID> branches (wtName = milestone ID)
+            const milestoneBranch = `milestone/${wtName}`;
+            const currentBranch = nativeGetCurrentBranch(this.basePath);
+            // If we're on a milestone/<MID> branch, use it (auto-mode case)
+            if (currentBranch.startsWith("milestone/")) {
+                return currentBranch;
+            }
+            // Otherwise check for manual worktree branch (worktree/<name>)
             const wtBranch = `worktree/${wtName}`;
             if (nativeBranchExists(this.basePath, wtBranch))
                 return wtBranch;
-            return nativeGetCurrentBranch(this.basePath);
+            return currentBranch;
         }
         // Repo-level default detection: origin/HEAD → main → master → current branch.
         // Native path uses libgit2 (single call), fallback spawns multiple git processes.

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

@@ -1,6 +1,7 @@
 // GSD Extension — Session History View
 // Human-readable display of past auto-mode unit executions.
-import { formatDuration, padRight, truncateWithEllipsis } from "../shared/format-utils.js";
+import { formatDuration, truncateWithEllipsis } from "../shared/format-utils.js";
+import { padRight } from "../shared/layout-utils.js";
 import { getLedger, getProjectTotals, formatCost, formatTokenCount, aggregateBySlice, aggregateByPhase, aggregateByModel, loadLedgerFromDisk, } from "./metrics.js";
 /**
  * Show recent unit execution history with cost, tokens, and duration.

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

@@ -17,8 +17,10 @@ import { gsdRoot } from "./paths.js";
 import { getAndClearSkills } from "./skill-telemetry.js";
 import { loadJsonFile, loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
 import { parseUnitId } from "./unit-id.js";
-// Re-export from shared — canonical implementation lives in format-utils.
-export { formatTokenCount } from "../shared/mod.js";
+// Re-export from shared — import directly from format-utils to avoid pulling
+// in the full barrel (mod.js → ui.js → @gsd/pi-tui) which breaks when loaded
+// outside jiti's alias resolution (e.g. dynamic import in auto-loop reports).
+export { formatTokenCount } from "../shared/format-utils.js";
 export function classifyUnitPhase(unitType) {
     switch (unitType) {
         case "research-milestone":

package/dist/resources/extensions/gsd/observability-validator.js

@@ -209,6 +209,30 @@ export function validateTaskPlanContent(file, content) {
             }
         }
     }
+    // Rule: Inputs and Expected Output should contain backtick-wrapped file paths
+    const inputsSection = getSection(content, "Inputs", 2);
+    const outputSection = getSection(content, "Expected Output", 2);
+    const backtickPathPattern = /`[^`]*[./][^`]*`/;
+    if (outputSection === null || !backtickPathPattern.test(outputSection)) {
+        issues.push({
+            severity: "warning",
+            scope: "task-plan",
+            file,
+            ruleId: "missing_output_file_paths",
+            message: "Task plan `## Expected Output` is missing or has no backtick-wrapped file paths.",
+            suggestion: "List concrete output file paths in backticks (e.g. `src/types.ts`). These are machine-parsed to derive task dependencies.",
+        });
+    }
+    if (inputsSection !== null && inputsSection.trim().length > 0 && !backtickPathPattern.test(inputsSection)) {
+        issues.push({
+            severity: "info",
+            scope: "task-plan",
+            file,
+            ruleId: "missing_input_file_paths",
+            message: "Task plan `## Inputs` has content but no backtick-wrapped file paths.",
+            suggestion: "List input file paths in backticks (e.g. `src/config.json`). These are machine-parsed to derive task dependencies.",
+        });
+    }
     // ── Observability rules (gated by runtime relevance) ──
     const relevant = textSuggestsObservabilityRelevant(content);
     if (!relevant)

package/dist/resources/extensions/gsd/preferences-types.js

@@ -65,11 +65,12 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "compression_strategy",
     "context_selection",
     "widget_mode",
+    "reactive_execution",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [
     "research-milestone", "plan-milestone", "research-slice", "plan-slice",
-    "execute-task", "complete-slice", "replan-slice", "reassess-roadmap",
+    "execute-task", "reactive-execute", "complete-slice", "replan-slice", "reassess-roadmap",
     "run-uat", "complete-milestone",
 ];
 export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -500,6 +500,48 @@ export function validatePreferences(preferences) {
             validated.parallel = parallel;
         }
     }
+    // ─── Reactive Execution ─────────────────────────────────────────────────
+    if (preferences.reactive_execution !== undefined) {
+        if (typeof preferences.reactive_execution === "object" && preferences.reactive_execution !== null) {
+            const re = preferences.reactive_execution;
+            const validRe = {};
+            if (re.enabled !== undefined) {
+                if (typeof re.enabled === "boolean")
+                    validRe.enabled = re.enabled;
+                else
+                    errors.push("reactive_execution.enabled must be a boolean");
+            }
+            if (re.max_parallel !== undefined) {
+                const mp = typeof re.max_parallel === "number" ? re.max_parallel : Number(re.max_parallel);
+                if (Number.isFinite(mp) && mp >= 1 && mp <= 8) {
+                    validRe.max_parallel = Math.floor(mp);
+                }
+                else {
+                    errors.push("reactive_execution.max_parallel must be a number between 1 and 8");
+                }
+            }
+            if (re.isolation_mode !== undefined) {
+                if (re.isolation_mode === "same-tree") {
+                    validRe.isolation_mode = "same-tree";
+                }
+                else {
+                    errors.push('reactive_execution.isolation_mode must be "same-tree"');
+                }
+            }
+            const knownReKeys = new Set(["enabled", "max_parallel", "isolation_mode"]);
+            for (const key of Object.keys(re)) {
+                if (!knownReKeys.has(key)) {
+                    warnings.push(`unknown reactive_execution key "${key}" — ignored`);
+                }
+            }
+            if (Object.keys(validRe).length > 0) {
+                validated.reactive_execution = validRe;
+            }
+        }
+        else {
+            errors.push("reactive_execution must be an object");
+        }
+    }
     // ─── Verification Preferences ───────────────────────────────────────────
     if (preferences.verification_commands !== undefined) {
         if (Array.isArray(preferences.verification_commands)) {

package/dist/resources/extensions/gsd/prompts/plan-slice.md

@@ -61,13 +61,14 @@ Then:
    - a concrete, action-oriented title
    - the inline task entry fields defined in the plan.md template (Why / Files / Do / Verify / Done when)
    - a matching task plan file with description, steps, must-haves, verification, inputs, and expected output
+   - **Inputs and Expected Output must list concrete backtick-wrapped file paths** (e.g. `` `src/types.ts` ``). These are machine-parsed to derive task dependencies — vague prose without paths breaks parallel execution. Every task must have at least one output file path.
    - Observability Impact section **only if the task touches runtime boundaries, async flows, or error paths** — omit it otherwise
 6. Write `{{outputPath}}`
 7. Write individual task plans in `{{slicePath}}/tasks/`: `T01-PLAN.md`, `T02-PLAN.md`, etc.
 8. **Self-audit the plan.** Walk through each check — if any fail, fix the plan files before moving on:
     - **Completion semantics:** If every task were completed exactly as written, the slice goal/demo should actually be true.
     - **Requirement coverage:** Every must-have in the slice maps to at least one task. No must-have is orphaned. If `REQUIREMENTS.md` exists, every Active requirement this slice owns maps to at least one task.
-    - **Task completeness:** Every task has steps, must-haves, verification, inputs, and expected output — none are blank or vague.
+    - **Task completeness:** Every task has steps, must-haves, verification, inputs, and expected output — none are blank or vague. Inputs and Expected Output list backtick-wrapped file paths, not prose descriptions.
     - **Dependency correctness:** Task ordering is consistent. No task references work from a later task.
     - **Key links planned:** For every pair of artifacts that must connect, there is an explicit step that wires them.
     - **Scope sanity:** Target 2–5 steps and 3–8 files per task. 10+ steps or 12+ files — must split. Each task must be completable in a single fresh context window.

package/dist/resources/extensions/gsd/prompts/reactive-execute.md

@@ -0,0 +1,41 @@
+# Reactive Task Execution — Parallel Dispatch
+
+**Working directory:** `{{workingDirectory}}`
+**Milestone:** {{milestoneId}} — {{milestoneTitle}}
+**Slice:** {{sliceId}} — {{sliceTitle}}
+
+## Mission
+
+You are executing **multiple tasks in parallel** for this slice. The task graph below shows which tasks are ready for simultaneous execution based on their input/output dependencies.
+
+**Critical rule:** Use the `subagent` tool in **parallel mode** to dispatch all ready tasks simultaneously. Each subagent gets a self-contained execute-task prompt. After all subagents return, verify each task's outputs and write summaries.
+
+## Task Dependency Graph
+
+{{graphContext}}
+
+## Ready Tasks for Parallel Dispatch
+
+{{readyTaskCount}} tasks are ready for parallel execution:
+
+{{readyTaskList}}
+
+## Execution Protocol
+
+1. **Dispatch all ready tasks** using `subagent` in parallel mode. Each subagent prompt is provided below.
+2. **Wait for all subagents** to complete.
+3. **Verify each task's outputs** — check that expected files were created/modified and that verification commands pass.
+4. **Write task summaries** for each completed task using the task-summary template.
+5. **Mark completed tasks** as done in the slice plan (checkbox `[x]`).
+6. **Commit** all changes with a clear message covering the parallel batch.
+
+If any subagent fails:
+- Write a summary for the failed task with `blocker_discovered: true`
+- Continue marking the successful tasks as done
+- The orchestrator will handle re-dispatch on the next iteration
+
+## Subagent Prompts
+
+{{subagentPrompts}}
+
+{{inlinedTemplates}}