gsd-pi 2.22.0 → 2.24.0

package/src/resources/extensions/gsd/captures.ts

@@ -26,6 +26,7 @@ export interface CaptureEntry {
   resolution?: string;
   rationale?: string;
   resolvedAt?: string;
+  executed?: boolean;
 }
 
 export interface TriageResult {
@@ -211,6 +212,52 @@ export function markCaptureResolved(
   writeFileSync(filePath, updated, "utf-8");
 }
 
+/**
+ * Mark a resolved capture as executed — its resolution action was carried out.
+ * Appends `**Executed:** <timestamp>` to the capture's section in CAPTURES.md.
+ */
+export function markCaptureExecuted(basePath: string, captureId: string): void {
+  const filePath = resolveCapturesPath(basePath);
+  if (!existsSync(filePath)) return;
+
+  const content = readFileSync(filePath, "utf-8");
+  const executedAt = new Date().toISOString();
+
+  const sectionRegex = new RegExp(
+    `(### ${escapeRegex(captureId)}\\n(?:(?!### ).)*?)(?=### |$)`,
+    "s",
+  );
+  const match = sectionRegex.exec(content);
+  if (!match) return;
+
+  let section = match[1];
+
+  // Remove any existing Executed field (in case of re-execution)
+  section = section.replace(/\*\*Executed:\*\*\s*.+\n?/g, "");
+
+  // Append Executed timestamp
+  section = section.trimEnd() + "\n" + `**Executed:** ${executedAt}` + "\n";
+
+  const updated = content.replace(sectionRegex, section);
+  writeFileSync(filePath, updated, "utf-8");
+}
+
+/**
+ * Load resolved captures that have actionable classifications (inject, replan,
+ * quick-task) but have NOT yet been executed.
+ * These are captures whose resolutions need to be carried out.
+ */
+export function loadActionableCaptures(basePath: string): CaptureEntry[] {
+  return loadAllCaptures(basePath).filter(
+    c =>
+      c.status === "resolved" &&
+      !c.executed &&
+      (c.classification === "inject" ||
+        c.classification === "replan" ||
+        c.classification === "quick-task"),
+  );
+}
+
 // ─── Parser ───────────────────────────────────────────────────────────────────
 
 /**
@@ -235,6 +282,7 @@ function parseCapturesContent(content: string): CaptureEntry[] {
     const resolution = extractBoldField(body, "Resolution");
     const rationale = extractBoldField(body, "Rationale");
     const resolvedAt = extractBoldField(body, "Resolved");
+    const executedAt = extractBoldField(body, "Executed");
 
     if (!text || !timestamp) continue;
 
@@ -251,6 +299,7 @@ function parseCapturesContent(content: string): CaptureEntry[] {
       ...(resolution ? { resolution } : {}),
       ...(rationale ? { rationale } : {}),
       ...(resolvedAt ? { resolvedAt } : {}),
+      ...(executedAt ? { executed: true } : {}),
     });
   }
 

package/src/resources/extensions/gsd/commands.ts

@@ -6,15 +6,15 @@
 
 import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
 import { AuthStorage } from "@gsd/pi-coding-agent";
-import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import { existsSync, readFileSync, mkdirSync, unlinkSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { enableDebug, isDebugEnabled } from "./debug-logger.js";
 import { fileURLToPath } from "node:url";
 import { deriveState } from "./state.js";
 import { GSDDashboardOverlay } from "./dashboard-overlay.js";
 import { GSDVisualizerOverlay } from "./visualizer-overlay.js";
-import { showQueue, showDiscuss } from "./guided-flow.js";
-import { startAuto, stopAuto, pauseAuto, isAutoActive, isAutoPaused, isStepMode, stopAutoRemote } from "./auto.js";
+import { showQueue, showDiscuss, showHeadlessMilestoneCreation } from "./guided-flow.js";
+import { startAuto, stopAuto, pauseAuto, isAutoActive, isAutoPaused, isStepMode, stopAutoRemote, dispatchDirectPhase } from "./auto.js";
 import { resolveProjectRoot } from "./worktree.js";
 import { appendCapture, hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import {
@@ -42,6 +42,14 @@ import { handleQuick } from "./quick.js";
 import { handleHistory } from "./history.js";
 import { handleUndo } from "./undo.js";
 import { handleExport } from "./export.js";
+import {
+  isParallelActive, getOrchestratorState, getWorkerStatuses,
+  prepareParallelStart, startParallel, stopParallel,
+  pauseWorker, resumeWorker,
+} from "./parallel-orchestrator.js";
+import { formatEligibilityReport } from "./parallel-eligibility.js";
+import { mergeAllCompleted, mergeCompletedMilestone, formatMergeResults } from "./parallel-merge.js";
+import { resolveParallelConfig } from "./preferences.js";
 import { nativeBranchList, nativeDetectMainBranch, nativeBranchListMerged, nativeBranchDelete, nativeForEachRef, nativeUpdateRef } from "./native-git-bridge.js";
 
 export function dispatchDoctorHeal(pi: ExtensionAPI, scope: string | undefined, reportText: string, structuredIssues: string): void {
@@ -69,20 +77,53 @@ function projectRoot(): string {
 
 export function registerGSDCommand(pi: ExtensionAPI): void {
   pi.registerCommand("gsd", {
-    description: "GSD — Get Shit Done: /gsd help|next|auto|stop|pause|status|visualize|queue|quick|capture|triage|history|undo|skip|export|cleanup|mode|prefs|config|hooks|run-hook|skill-health|doctor|forensics|migrate|remote|steer|knowledge",
+    description: "GSD — Get Shit Done: /gsd help|next|auto|stop|pause|status|visualize|queue|quick|capture|triage|dispatch|history|undo|skip|export|cleanup|mode|prefs|config|hooks|run-hook|skill-health|doctor|forensics|migrate|remote|steer|knowledge|new-milestone|parallel",
     getArgumentCompletions: (prefix: string) => {
       const subcommands = [
-        "help", "next", "auto", "stop", "pause", "status", "visualize", "queue", "quick", "discuss",
-        "capture", "triage",
-        "history", "undo", "skip", "export", "cleanup", "mode", "prefs",
-        "config", "hooks", "run-hook", "skill-health", "doctor", "forensics", "migrate", "remote", "steer", "inspect", "knowledge",
+        { cmd: "help", desc: "Categorized command reference with descriptions" },
+        { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
+        { cmd: "auto", desc: "Autonomous mode — research, plan, execute, commit, repeat" },
+        { 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: "visualize", desc: "Open workflow visualizer (progress, deps, metrics, timeline)" },
+        { cmd: "queue", desc: "Queue and reorder future milestones" },
+        { cmd: "quick", desc: "Execute a quick task without full planning overhead" },
+        { cmd: "discuss", desc: "Discuss architecture and decisions" },
+        { cmd: "capture", desc: "Fire-and-forget thought capture" },
+        { cmd: "triage", desc: "Manually trigger triage of pending captures" },
+        { cmd: "dispatch", desc: "Dispatch a specific phase directly" },
+        { cmd: "history", desc: "View execution history" },
+        { cmd: "undo", desc: "Revert last completed unit" },
+        { cmd: "skip", desc: "Prevent a unit from auto-mode dispatch" },
+        { cmd: "export", desc: "Export milestone/slice results" },
+        { cmd: "cleanup", desc: "Remove merged branches or snapshots" },
+        { cmd: "mode", desc: "Switch workflow mode (solo/team)" },
+        { cmd: "prefs", desc: "Manage preferences (model selection, timeouts, etc.)" },
+        { cmd: "config", desc: "Set API keys for external tools" },
+        { cmd: "hooks", desc: "Show configured post-unit and pre-dispatch hooks" },
+        { cmd: "run-hook", desc: "Manually trigger a specific hook" },
+        { cmd: "skill-health", desc: "Skill lifecycle dashboard" },
+        { cmd: "doctor", desc: "Runtime health checks with auto-fix" },
+        { cmd: "forensics", desc: "Examine execution logs" },
+        { cmd: "migrate", desc: "Migrate a v1 .planning directory to .gsd format" },
+        { cmd: "remote", desc: "Control remote auto-mode" },
+        { cmd: "steer", desc: "Hard-steer plan documents during execution" },
+        { cmd: "inspect", desc: "Show SQLite DB diagnostics" },
+        { 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)" },
       ];
       const parts = prefix.trim().split(/\s+/);
 
       if (parts.length <= 1) {
         return subcommands
-          .filter((cmd) => cmd.startsWith(parts[0] ?? ""))
-          .map((cmd) => ({ value: cmd, label: cmd }));
+          .filter((item) => item.cmd.startsWith(parts[0] ?? ""))
+          .map((item) => ({ 
+            value: item.cmd, 
+            label: item.cmd, 
+            description: item.desc 
+          }));
       }
 
       if (parts[0] === "auto" && parts.length <= 2) {
@@ -99,6 +140,13 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
           .map((cmd) => ({ value: `mode ${cmd}`, label: cmd }));
       }
 
+      if (parts[0] === "parallel" && parts.length <= 2) {
+        const subPrefix = parts[1] ?? "";
+        return ["start", "status", "stop", "pause", "resume", "merge"]
+          .filter((cmd) => cmd.startsWith(subPrefix))
+          .map((cmd) => ({ value: `parallel ${cmd}`, label: cmd }));
+      }
+
       if (parts[0] === "prefs" && parts.length <= 2) {
         const subPrefix = parts[1] ?? "";
         return ["global", "project", "status", "wizard", "setup", "import-claude"]
@@ -165,6 +213,13 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
         return [];
       }
 
+      if (parts[0] === "dispatch" && parts.length <= 2) {
+        const phasePrefix = parts[1] ?? "";
+        return ["research", "plan", "execute", "complete", "reassess", "uat", "replan"]
+          .filter((cmd) => cmd.startsWith(phasePrefix))
+          .map((cmd) => ({ value: `dispatch ${cmd}`, label: cmd }));
+      }
+
       return [];
     },
 
@@ -244,7 +299,7 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
           }
           return;
         }
-        await stopAuto(ctx, pi);
+        await stopAuto(ctx, pi, "User requested stop");
         return;
       }
 
@@ -281,6 +336,108 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
         return;
       }
 
+      // ─── Parallel Orchestration ────────────────────────────────────────
+      if (trimmed.startsWith("parallel")) {
+        const parallelArgs = trimmed.slice("parallel".length).trim();
+        const [subCmd = "", ...restParts] = parallelArgs.split(/\s+/);
+        const rest = restParts.join(" ");
+
+        if (subCmd === "start" || subCmd === "") {
+          const loaded = loadEffectiveGSDPreferences();
+          const config = resolveParallelConfig(loaded?.preferences);
+          if (!config.enabled) {
+            pi.sendMessage({
+              customType: "gsd-parallel",
+              content: "Parallel mode is not enabled. Set `parallel.enabled: true` in your preferences.",
+              display: false,
+            });
+            return;
+          }
+          const candidates = await prepareParallelStart(projectRoot(), loaded?.preferences);
+          const report = formatEligibilityReport(candidates);
+          if (candidates.eligible.length === 0) {
+            pi.sendMessage({ customType: "gsd-parallel", content: report + "\n\nNo milestones are eligible for parallel execution.", display: false });
+            return;
+          }
+          const result = await startParallel(
+            projectRoot(),
+            candidates.eligible.map(e => e.milestoneId),
+            loaded?.preferences,
+          );
+          const lines = [`Parallel orchestration started.`, `Workers: ${result.started.join(", ")}`];
+          if (result.errors.length > 0) {
+            lines.push(`Errors: ${result.errors.map(e => `${e.mid}: ${e.error}`).join("; ")}`);
+          }
+          pi.sendMessage({ customType: "gsd-parallel", content: report + "\n\n" + lines.join("\n"), display: false });
+          return;
+        }
+
+        if (subCmd === "status") {
+          if (!isParallelActive()) {
+            pi.sendMessage({ customType: "gsd-parallel", content: "No parallel orchestration is currently active.", display: false });
+            return;
+          }
+          const workers = getWorkerStatuses();
+          const lines = ["# Parallel Workers\n"];
+          for (const w of workers) {
+            lines.push(`- **${w.milestoneId}** (${w.title}) — ${w.state} — ${w.completedUnits} units — $${w.cost.toFixed(2)}`);
+          }
+          const orchState = getOrchestratorState();
+          if (orchState) {
+            lines.push(`\nTotal cost: $${orchState.totalCost.toFixed(2)}`);
+          }
+          pi.sendMessage({ customType: "gsd-parallel", content: lines.join("\n"), display: false });
+          return;
+        }
+
+        if (subCmd === "stop") {
+          const mid = rest.trim() || undefined;
+          await stopParallel(projectRoot(), mid);
+          pi.sendMessage({ customType: "gsd-parallel", content: mid ? `Stopped worker for ${mid}.` : "All parallel workers stopped.", display: false });
+          return;
+        }
+
+        if (subCmd === "pause") {
+          const mid = rest.trim() || undefined;
+          pauseWorker(projectRoot(), mid);
+          pi.sendMessage({ customType: "gsd-parallel", content: mid ? `Paused worker for ${mid}.` : "All parallel workers paused.", display: false });
+          return;
+        }
+
+        if (subCmd === "resume") {
+          const mid = rest.trim() || undefined;
+          resumeWorker(projectRoot(), mid);
+          pi.sendMessage({ customType: "gsd-parallel", content: mid ? `Resumed worker for ${mid}.` : "All parallel workers resumed.", display: false });
+          return;
+        }
+
+        if (subCmd === "merge") {
+          const mid = rest.trim() || undefined;
+          if (mid) {
+            // Merge a specific milestone
+            const result = await mergeCompletedMilestone(projectRoot(), mid);
+            pi.sendMessage({ customType: "gsd-parallel", content: formatMergeResults([result]), display: false });
+            return;
+          }
+          // Merge all completed milestones
+          const workers = getWorkerStatuses();
+          if (workers.length === 0) {
+            pi.sendMessage({ customType: "gsd-parallel", content: "No parallel workers to merge.", display: false });
+            return;
+          }
+          const results = await mergeAllCompleted(projectRoot(), workers);
+          pi.sendMessage({ customType: "gsd-parallel", content: formatMergeResults(results), display: false });
+          return;
+        }
+
+        pi.sendMessage({
+          customType: "gsd-parallel",
+          content: `Unknown parallel subcommand "${subCmd}". Usage: /gsd parallel [start|status|stop|pause|resume|merge]`,
+          display: false,
+        });
+        return;
+      }
+
       if (trimmed === "cleanup") {
         await handleCleanupBranches(ctx, projectRoot());
         await handleCleanupSnapshots(ctx, projectRoot());
@@ -307,6 +464,21 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
         return;
       }
 
+      if (trimmed === "new-milestone") {
+        const basePath = projectRoot();
+        const headlessContextPath = join(basePath, ".gsd", "runtime", "headless-context.md");
+        if (existsSync(headlessContextPath)) {
+          const seedContext = readFileSync(headlessContextPath, "utf-8");
+          try { unlinkSync(headlessContextPath); } catch { /* non-fatal */ }
+          await showHeadlessMilestoneCreation(ctx, pi, basePath, seedContext);
+        } else {
+          // No headless context — fall back to interactive smart entry
+          const { showSmartEntry } = await import("./guided-flow.js");
+          await showSmartEntry(ctx, pi, basePath);
+        }
+        return;
+      }
+
       if (trimmed.startsWith("capture ") || trimmed === "capture") {
         await handleCapture(trimmed.replace(/^capture\s*/, "").trim(), ctx);
         return;
@@ -388,6 +560,16 @@ Examples:
         return;
       }
 
+      if (trimmed === "dispatch" || trimmed.startsWith("dispatch ")) {
+        const phase = trimmed.replace(/^dispatch\s*/, "").trim();
+        if (!phase) {
+          ctx.ui.notify("Usage: /gsd dispatch <phase>  (research|plan|execute|complete|reassess|uat|replan)", "warning");
+          return;
+        }
+        await dispatchDirectPhase(ctx, pi, phase, projectRoot());
+        return;
+      }
+
       if (trimmed === "inspect") {
         await handleInspect(ctx);
         return;
@@ -417,6 +599,7 @@ function showHelp(ctx: ExtensionCommandContext): void {
     "  /gsd stop           Stop auto-mode gracefully",
     "  /gsd pause          Pause auto-mode (preserves state, /gsd auto to resume)",
     "  /gsd discuss        Start guided milestone/slice discussion",
+    "  /gsd new-milestone  Create milestone from headless context (used by gsd headless)",
     "",
     "VISIBILITY",
     "  /gsd status         Show progress dashboard  (Ctrl+Alt+G)",

package/src/resources/extensions/gsd/complexity.ts

@@ -87,6 +87,7 @@ const UNIT_TYPE_TIERS: Record<string, ComplexityTier> = {
   "execute-task": "standard",
   "replan-slice": "heavy",
   "reassess-roadmap": "heavy",
+  "validate-milestone": "heavy",
   "complete-milestone": "standard",
 };
 

package/src/resources/extensions/gsd/dashboard-overlay.ts

@@ -19,6 +19,7 @@ import {
 } from "./metrics.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { getActiveWorktreeName } from "./worktree-command.js";
+import { getWorkerBatches, hasActiveWorkers, type WorkerEntry } from "../subagent/worker-registry.js";
 
 function formatDuration(ms: number): string {
   const s = Math.floor(ms / 1000);
@@ -319,16 +320,23 @@ export class GSDDashboardOverlay {
     const centered = (content: string) => row(centerLine(content, contentWidth));
 
     const title = th.fg("accent", th.bold("GSD Dashboard"));
+    const isRemote = !!this.dashData.remoteSession;
     const status = this.dashData.active
       ? `${Date.now() % 2000 < 1000 ? th.fg("success", "●") : th.fg("dim", "○")} ${th.fg("success", "AUTO")}`
       : this.dashData.paused
         ? th.fg("warning", "⏸ PAUSED")
-        : th.fg("dim", "idle");
+        : isRemote
+          ? `${Date.now() % 2000 < 1000 ? th.fg("success", "●") : th.fg("dim", "○")} ${th.fg("success", "AUTO")} ${th.fg("dim", `(PID ${this.dashData.remoteSession!.pid})`)}`
+          : th.fg("dim", "idle");
     const worktreeName = getActiveWorktreeName();
     const worktreeTag = worktreeName
       ? `  ${th.fg("warning", `⎇ ${worktreeName}`)}`
       : "";
-    const elapsed = th.fg("dim", formatDuration(this.dashData.elapsed));
+    const elapsed = this.dashData.active || this.dashData.paused
+      ? th.fg("dim", formatDuration(this.dashData.elapsed))
+      : isRemote
+        ? th.fg("dim", `since ${this.dashData.remoteSession!.startedAt.replace("T", " ").slice(0, 19)}`)
+        : "";
     lines.push(row(joinColumns(`${title}  ${status}${worktreeTag}`, elapsed, contentWidth)));
     lines.push(blank());
 
@@ -344,11 +352,55 @@ export class GSDDashboardOverlay {
     } else if (this.dashData.paused) {
       lines.push(row(th.fg("dim", "/gsd auto to resume")));
       lines.push(blank());
+    } else if (isRemote) {
+      const rs = this.dashData.remoteSession!;
+      const unitDisplay = rs.unitType === "starting" || rs.unitType === "resuming"
+        ? rs.unitType
+        : `${unitLabel(rs.unitType)} ${rs.unitId}`;
+      lines.push(row(th.fg("text", `Remote session: ${unitDisplay}`)));
+      lines.push(blank());
     } else {
       lines.push(row(th.fg("dim", "No unit running · /gsd auto to start")));
       lines.push(blank());
     }
 
+    // Parallel workers section — shows active subagent sessions
+    if (hasActiveWorkers()) {
+      lines.push(hr());
+      lines.push(row(th.fg("text", th.bold("Parallel Workers"))));
+      lines.push(blank());
+
+      const batches = getWorkerBatches();
+      for (const [batchId, workers] of batches) {
+        const running = workers.filter(w => w.status === "running").length;
+        const done = workers.filter(w => w.status === "completed").length;
+        const failed = workers.filter(w => w.status === "failed").length;
+        const total = workers[0]?.batchSize ?? workers.length;
+
+        lines.push(row(joinColumns(
+          `  ${th.fg("accent", "⟐")} ${th.fg("text", `Batch ${batchId.slice(0, 8)}`)}`,
+          th.fg("dim", `${done + failed}/${total} done`),
+          contentWidth,
+        )));
+
+        for (const w of workers) {
+          const icon = w.status === "running"
+            ? th.fg("accent", "▸")
+            : w.status === "completed"
+              ? th.fg("success", "✓")
+              : th.fg("error", "✗");
+          const elapsed = th.fg("dim", formatDuration(Date.now() - w.startedAt));
+          const taskPreview = truncateToWidth(w.task, Math.max(20, contentWidth - 30));
+          lines.push(row(joinColumns(
+            `    ${icon} ${th.fg("text", w.agent)} ${th.fg("dim", taskPreview)}`,
+            elapsed,
+            contentWidth,
+          )));
+        }
+      }
+      lines.push(blank());
+    }
+
     // Pending captures badge — only shown when captures are waiting for triage
     if (this.dashData.pendingCaptureCount > 0) {
       const count = this.dashData.pendingCaptureCount;