gsd-pi 2.37.1 → 2.38.0-dev.eeb3520

package/README.md

@@ -629,7 +629,7 @@ GSD isn't locked to one provider. It runs on the [Pi SDK](https://github.com/bad
 
 ### Built-in Providers
 
-Anthropic, OpenAI, Google (Gemini), OpenRouter, GitHub Copilot, Amazon Bedrock, Azure OpenAI, Google Vertex, Groq, Cerebras, Mistral, xAI, HuggingFace, Vercel AI Gateway, and more.
+Anthropic, Anthropic (Vertex AI), OpenAI, Google (Gemini), OpenRouter, GitHub Copilot, Amazon Bedrock, Azure OpenAI, Google Vertex, Groq, Cerebras, Mistral, xAI, HuggingFace, Vercel AI Gateway, and more.
 
 ### OAuth / Max Plans
 

package/dist/onboarding.js

@@ -38,6 +38,7 @@ const TOOL_KEYS = [
 /** Known LLM provider IDs that, if authed, mean the user doesn't need onboarding */
 const LLM_PROVIDER_IDS = [
     'anthropic',
+    'anthropic-vertex',
     'openai',
     'github-copilot',
     'openai-codex',

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -12,7 +12,7 @@ import { loadFile, loadActiveOverrides, parseRoadmap } from "./files.js";
 import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
+import { buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
 function missingSliceStop(mid, phase) {
     return {
         action: "stop",
@@ -223,6 +223,72 @@ const DISPATCH_RULES = [
             };
         },
     },
+    {
+        name: "executing → reactive-execute (parallel dispatch)",
+        match: async ({ state, mid, midTitle, basePath, prefs }) => {
+            if (state.phase !== "executing" || !state.activeTask)
+                return null;
+            if (!state.activeSlice)
+                return null; // fall through
+            // Only activate when reactive_execution is explicitly enabled
+            const reactiveConfig = prefs?.reactive_execution;
+            if (!reactiveConfig?.enabled)
+                return null;
+            const sid = state.activeSlice.id;
+            const sTitle = state.activeSlice.title;
+            const maxParallel = reactiveConfig.max_parallel ?? 2;
+            // Dry-run mode: max_parallel=1 means graph is derived and logged but
+            // execution remains sequential
+            if (maxParallel <= 1)
+                return null;
+            try {
+                const { loadSliceTaskIO, deriveTaskGraph, isGraphAmbiguous, getReadyTasks, chooseNonConflictingSubset, graphMetrics, } = await import("./reactive-graph.js");
+                const taskIO = await loadSliceTaskIO(basePath, mid, sid);
+                if (taskIO.length < 2)
+                    return null; // single task, no point
+                const graph = deriveTaskGraph(taskIO);
+                // Ambiguous graph → fall through to sequential
+                if (isGraphAmbiguous(graph))
+                    return null;
+                const completed = new Set(graph.filter((n) => n.done).map((n) => n.id));
+                const readyIds = getReadyTasks(graph, completed, new Set());
+                // Only activate reactive dispatch when >1 task is ready
+                if (readyIds.length <= 1)
+                    return null;
+                const selected = chooseNonConflictingSubset(readyIds, graph, maxParallel, new Set());
+                if (selected.length <= 1)
+                    return null;
+                // Log graph metrics for observability
+                const metrics = graphMetrics(graph);
+                process.stderr.write(`gsd-reactive: ${mid}/${sid} graph — tasks:${metrics.taskCount} edges:${metrics.edgeCount} ` +
+                    `ready:${metrics.readySetSize} dispatching:${selected.length} ambiguous:${metrics.ambiguous}\n`);
+                // Persist dispatched batch so verification and recovery can check
+                // exactly which tasks were sent.
+                const { saveReactiveState } = await import("./reactive-graph.js");
+                saveReactiveState(basePath, mid, sid, {
+                    sliceId: sid,
+                    completed: [...completed],
+                    dispatched: selected,
+                    graphSnapshot: metrics,
+                    updatedAt: new Date().toISOString(),
+                });
+                // Encode selected task IDs in unitId for artifact verification.
+                // Format: M001/S01/reactive+T02,T03
+                const batchSuffix = selected.join(",");
+                return {
+                    action: "dispatch",
+                    unitType: "reactive-execute",
+                    unitId: `${mid}/${sid}/reactive+${batchSuffix}`,
+                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath),
+                };
+            }
+            catch (err) {
+                // Non-fatal — fall through to sequential execution
+                process.stderr.write(`gsd-reactive: graph derivation failed: ${err.message}\n`);
+                return null;
+            }
+        },
+    },
     {
         name: "executing → execute-task (recover missing task plan → plan-slice)",
         match: async ({ state, mid, midTitle, basePath }) => {

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -171,6 +171,20 @@ export async function postUnitPreVerification(pctx) {
                 // Non-fatal
             }
         }
+        // Reactive state cleanup on slice completion
+        if (s.currentUnit.type === "complete-slice") {
+            try {
+                const parts = s.currentUnit.id.split("/");
+                const [mid, sid] = parts;
+                if (mid && sid) {
+                    const { clearReactiveState } = await import("./reactive-graph.js");
+                    clearReactiveState(s.basePath, mid, sid);
+                }
+            }
+            catch {
+                // Non-fatal
+            }
+        }
         // Post-triage: execute actionable resolutions
         if (s.currentUnit.type === "triage-captures") {
             try {

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -414,6 +414,35 @@ export async function getPriorTaskSummaryPaths(mid, sid, currentTid, base) {
     })
         .map(f => `${sRel}/tasks/${f}`);
 }
+/**
+ * Get carry-forward summary paths scoped to a task's derived dependencies.
+ *
+ * Instead of all prior tasks (order-based), returns only summaries for task
+ * IDs in `dependsOn`. Used by reactive-execute to give each subagent only
+ * the context it actually needs — not sibling tasks from a parallel batch.
+ *
+ * Falls back to order-based when dependsOn is empty (root tasks still get
+ * any available prior summaries for continuity).
+ */
+export async function getDependencyTaskSummaryPaths(mid, sid, currentTid, dependsOn, base) {
+    // If no dependencies, fall back to order-based for root tasks
+    if (dependsOn.length === 0) {
+        return getPriorTaskSummaryPaths(mid, sid, currentTid, base);
+    }
+    const tDir = resolveTasksDir(base, mid, sid);
+    if (!tDir)
+        return [];
+    const summaryFiles = resolveTaskFiles(tDir, "SUMMARY");
+    const sRel = relSlicePath(base, mid, sid);
+    const depSet = new Set(dependsOn.map((d) => d.toUpperCase()));
+    return summaryFiles
+        .filter((f) => {
+        // Extract task ID from filename: "T02-SUMMARY.md" → "T02"
+        const tid = f.replace(/-SUMMARY\.md$/i, "").toUpperCase();
+        return depSet.has(tid);
+    })
+        .map((f) => `${sRel}/tasks/${f}`);
+}
 // ─── Adaptive Replanning Checks ────────────────────────────────────────────
 /**
  * Check if the most recently completed slice needs reassessment.
@@ -688,8 +717,11 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
     });
 }
 export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, level) {
-    const inlineLevel = level ?? resolveInlineLevel();
-    const priorSummaries = await getPriorTaskSummaryPaths(mid, sid, tid, base);
+    const opts = typeof level === "object" && level !== null && !Array.isArray(level)
+        ? level
+        : { level: level };
+    const inlineLevel = opts.level ?? resolveInlineLevel();
+    const priorSummaries = opts.carryForwardPaths ?? await getPriorTaskSummaryPaths(mid, sid, tid, base);
     const priorLines = priorSummaries.length > 0
         ? priorSummaries.map(p => `- \`${p}\``).join("\n")
         : "- (no prior tasks)";
@@ -1090,6 +1122,63 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
         commitInstruction: reassessCommitInstruction,
     });
 }
+// ─── Reactive Execute Prompt ──────────────────────────────────────────────
+export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, readyTaskIds, base) {
+    const { loadSliceTaskIO, deriveTaskGraph, graphMetrics } = await import("./reactive-graph.js");
+    // Build graph for context
+    const taskIO = await loadSliceTaskIO(base, mid, sid);
+    const graph = deriveTaskGraph(taskIO);
+    const metrics = graphMetrics(graph);
+    // Build graph context section
+    const graphLines = [];
+    for (const node of graph) {
+        const status = node.done ? "✅ done" : readyTaskIds.includes(node.id) ? "🟢 ready" : "⏳ waiting";
+        const deps = node.dependsOn.length > 0 ? ` (depends on: ${node.dependsOn.join(", ")})` : "";
+        graphLines.push(`- **${node.id}: ${node.title}** — ${status}${deps}`);
+        if (node.outputFiles.length > 0) {
+            graphLines.push(`  - Outputs: ${node.outputFiles.map(f => `\`${f}\``).join(", ")}`);
+        }
+    }
+    const graphContext = [
+        `Tasks: ${metrics.taskCount}, Edges: ${metrics.edgeCount}, Ready: ${metrics.readySetSize}`,
+        "",
+        ...graphLines,
+    ].join("\n");
+    // Build individual subagent prompts for each ready task
+    const subagentSections = [];
+    const readyTaskListLines = [];
+    for (const tid of readyTaskIds) {
+        const node = graph.find((n) => n.id === tid);
+        const tTitle = node?.title ?? tid;
+        readyTaskListLines.push(`- **${tid}: ${tTitle}**`);
+        // Build dependency-scoped carry-forward paths for this task
+        const depPaths = await getDependencyTaskSummaryPaths(mid, sid, tid, node?.dependsOn ?? [], base);
+        // Build a full execute-task prompt with dependency-based carry-forward
+        const taskPrompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, { carryForwardPaths: depPaths });
+        subagentSections.push([
+            `### ${tid}: ${tTitle}`,
+            "",
+            "Use this as the prompt for a `subagent` call:",
+            "",
+            "```",
+            taskPrompt,
+            "```",
+        ].join("\n"));
+    }
+    const inlinedTemplates = inlineTemplate("task-summary", "Task Summary");
+    return loadPrompt("reactive-execute", {
+        workingDirectory: base,
+        milestoneId: mid,
+        milestoneTitle: midTitle,
+        sliceId: sid,
+        sliceTitle: sTitle,
+        graphContext,
+        readyTaskCount: String(readyTaskIds.length),
+        readyTaskList: readyTaskListLines.join("\n"),
+        subagentPrompts: subagentSections.join("\n\n---\n\n"),
+        inlinedTemplates,
+    });
+}
 export async function buildRewriteDocsPrompt(mid, midTitle, activeSlice, base, overrides) {
     const sid = activeSlice?.id;
     const sTitle = activeSlice?.title ?? "";

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -11,7 +11,7 @@ import { clearUnitRuntimeRecord } from "./unit-runtime.js";
 import { clearParseCache, parseRoadmap, parsePlan } from "./files.js";
 import { isValidationTerminal } from "./state.js";
 import { nativeConflictFiles, nativeCommit, nativeCheckoutTheirs, nativeAddPaths, nativeMergeAbort, nativeResetHard, } from "./native-git-bridge.js";
-import { resolveMilestonePath, resolveSlicePath, resolveSliceFile, resolveTasksDir, relMilestoneFile, relSliceFile, relSlicePath, relTaskFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
+import { resolveMilestonePath, resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, relSlicePath, relTaskFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
 import { markSliceDoneInRoadmap } from "./roadmap-mutations.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, } from "node:fs";
 import { dirname, join } from "node:path";
@@ -73,6 +73,9 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
         }
         case "rewrite-docs":
             return null;
+        case "reactive-execute":
+            // Reactive execute produces multiple task summaries — verified separately
+            return null;
         default:
             return null;
     }
@@ -105,6 +108,39 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         const content = readFileSync(overridesPath, "utf-8");
         return !content.includes("**Scope:** active");
     }
+    // Reactive-execute: verify that each dispatched task's summary exists.
+    // The unitId encodes the batch: "{mid}/{sid}/reactive+T02,T03"
+    if (unitType === "reactive-execute") {
+        const parts = unitId.split("/");
+        const mid = parts[0];
+        const sidAndBatch = parts[1];
+        const batchPart = parts[2]; // "reactive+T02,T03"
+        if (!mid || !sidAndBatch || !batchPart)
+            return false;
+        const sid = sidAndBatch;
+        const plusIdx = batchPart.indexOf("+");
+        if (plusIdx === -1) {
+            // Legacy format "reactive" without batch IDs — fall back to "any summary"
+            const tDir = resolveTasksDir(base, mid, sid);
+            if (!tDir)
+                return false;
+            const summaryFiles = resolveTaskFiles(tDir, "SUMMARY");
+            return summaryFiles.length > 0;
+        }
+        const batchIds = batchPart.slice(plusIdx + 1).split(",").filter(Boolean);
+        if (batchIds.length === 0)
+            return false;
+        const tDir = resolveTasksDir(base, mid, sid);
+        if (!tDir)
+            return false;
+        const existingSummaries = new Set(resolveTaskFiles(tDir, "SUMMARY").map((f) => f.replace(/-SUMMARY\.md$/i, "").toUpperCase()));
+        // Every dispatched task must have a summary file
+        for (const tid of batchIds) {
+            if (!existingSummaries.has(tid.toUpperCase()))
+                return false;
+        }
+        return true;
+    }
     const absPath = resolveExpectedArtifactPath(unitType, unitId, base);
     // For unit types with no verifiable artifact (null path), the parent directory
     // is missing on disk — treat as stale completion state so the key gets evicted (#313).

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/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}}