gsd-pi 2.31.2 → 2.32.0-dev.d792ba5

package/src/resources/extensions/gsd/preferences-validation.ts

@@ -14,6 +14,7 @@ import { normalizeStringArray } from "../shared/mod.js";
 
 import {
   KNOWN_PREFERENCE_KEYS,
+  KNOWN_UNIT_TYPES,
   SKILL_ACTIONS,
   type WorkflowMode,
   type GSDPreferences,
@@ -239,11 +240,7 @@ export function validatePreferences(preferences: GSDPreferences): {
   if (preferences.post_unit_hooks && Array.isArray(preferences.post_unit_hooks)) {
     const validHooks: PostUnitHookConfig[] = [];
     const seenNames = new Set<string>();
-    const knownUnitTypes = new Set([
-      "research-milestone", "plan-milestone", "research-slice", "plan-slice",
-      "execute-task", "complete-slice", "replan-slice", "reassess-roadmap",
-      "run-uat", "complete-milestone",
-    ]);
+    const knownUnitTypes = new Set<string>(KNOWN_UNIT_TYPES);
     for (const hook of preferences.post_unit_hooks) {
       if (!hook || typeof hook !== "object") {
         errors.push("post_unit_hooks entry must be an object");
@@ -305,11 +302,7 @@ export function validatePreferences(preferences: GSDPreferences): {
   if (preferences.pre_dispatch_hooks && Array.isArray(preferences.pre_dispatch_hooks)) {
     const validPreHooks: PreDispatchHookConfig[] = [];
     const seenPreNames = new Set<string>();
-    const knownUnitTypes = new Set([
-      "research-milestone", "plan-milestone", "research-slice", "plan-slice",
-      "execute-task", "complete-slice", "replan-slice", "reassess-roadmap",
-      "run-uat", "complete-milestone",
-    ]);
+    const knownUnitTypes = new Set<string>(KNOWN_UNIT_TYPES);
     const validActions = new Set(["modify", "skip", "replace"]);
     for (const hook of preferences.pre_dispatch_hooks) {
       if (!hook || typeof hook !== "object") {

package/src/resources/extensions/gsd/progress-score.ts

@@ -0,0 +1,273 @@
+/**
+ * GSD Progress Score — Traffic Light Status Indicator (#1221)
+ *
+ * Combines existing health signals into a single at-a-glance status:
+ *   - Green: progressing well
+ *   - Yellow: struggling (retries, warnings)
+ *   - Red: stuck (loops, persistent errors, no activity)
+ *
+ * Purely derived — no stored state. Reads from doctor-proactive health
+ * tracking, stuck detection counters, and working-tree activity.
+ */
+
+import {
+  getHealthTrend,
+  getConsecutiveErrorUnits,
+  getHealthHistory,
+  type HealthSnapshot,
+} from "./doctor-proactive.js";
+
+// ── Types ──────────────────────────────────────────────────────────────────
+
+export type ProgressLevel = "green" | "yellow" | "red";
+
+export interface ProgressScore {
+  level: ProgressLevel;
+  summary: string;
+  signals: ProgressSignal[];
+}
+
+export interface ProgressSignal {
+  name: string;
+  level: ProgressLevel;
+  detail: string;
+}
+
+// ── Signal Evaluators ──────────────────────────────────────────────────────
+
+function evaluateHealthTrend(): ProgressSignal {
+  const trend = getHealthTrend();
+
+  switch (trend) {
+    case "improving":
+      return { name: "health_trend", level: "green", detail: "Health improving" };
+    case "stable":
+      return { name: "health_trend", level: "green", detail: "Health stable" };
+    case "degrading":
+      return { name: "health_trend", level: "red", detail: "Health degrading" };
+    case "unknown":
+      return { name: "health_trend", level: "green", detail: "Insufficient data" };
+  }
+}
+
+function evaluateErrorStreak(): ProgressSignal {
+  const streak = getConsecutiveErrorUnits();
+
+  if (streak === 0) {
+    return { name: "error_streak", level: "green", detail: "No consecutive errors" };
+  }
+  if (streak <= 2) {
+    return { name: "error_streak", level: "yellow", detail: `${streak} consecutive error unit(s)` };
+  }
+  return { name: "error_streak", level: "red", detail: `${streak} consecutive error units` };
+}
+
+function evaluateRecentErrors(): ProgressSignal {
+  const history = getHealthHistory();
+  if (history.length === 0) {
+    return { name: "recent_errors", level: "green", detail: "No health data yet" };
+  }
+
+  const latest = history[history.length - 1]!;
+
+  if (latest.errors === 0 && latest.warnings <= 1) {
+    return { name: "recent_errors", level: "green", detail: `${latest.errors}E/${latest.warnings}W` };
+  }
+  if (latest.errors === 0) {
+    return { name: "recent_errors", level: "yellow", detail: `${latest.warnings} warning(s)` };
+  }
+  if (latest.errors <= 2) {
+    return { name: "recent_errors", level: "yellow", detail: `${latest.errors} error(s), ${latest.warnings} warning(s)` };
+  }
+  return { name: "recent_errors", level: "red", detail: `${latest.errors} error(s), ${latest.warnings} warning(s)` };
+}
+
+function evaluateArtifactProduction(): ProgressSignal {
+  const history = getHealthHistory();
+  if (history.length < 2) {
+    return { name: "artifact_production", level: "green", detail: "Insufficient data" };
+  }
+
+  const totalFixes = history.reduce((sum, s) => sum + s.fixesApplied, 0);
+  const recent = history.slice(-3);
+  const recentFixes = recent.reduce((sum, s) => sum + s.fixesApplied, 0);
+
+  // If recent units are all producing fixes but errors aren't decreasing,
+  // doctor is fighting fires but not making headway
+  if (recentFixes > 3 && recent.every(s => s.errors > 0)) {
+    return { name: "artifact_production", level: "yellow", detail: "Doctor applying fixes but errors persist" };
+  }
+
+  return { name: "artifact_production", level: "green", detail: `${totalFixes} total fixes applied` };
+}
+
+function evaluateDispatchVelocity(): ProgressSignal {
+  const history = getHealthHistory();
+  if (history.length < 3) {
+    return { name: "dispatch_velocity", level: "green", detail: "Insufficient data" };
+  }
+
+  // Check time between recent snapshots — are units completing at a reasonable rate?
+  const recent = history.slice(-5);
+  if (recent.length < 2) {
+    return { name: "dispatch_velocity", level: "green", detail: "Insufficient data" };
+  }
+
+  const timeDiffs: number[] = [];
+  for (let i = 1; i < recent.length; i++) {
+    timeDiffs.push(recent[i]!.timestamp - recent[i - 1]!.timestamp);
+  }
+
+  const avgTimeMs = timeDiffs.reduce((a, b) => a + b, 0) / timeDiffs.length;
+  const avgTimeMins = Math.round(avgTimeMs / 60_000);
+
+  // If average unit time is > 15 minutes, something might be wrong
+  if (avgTimeMins > 15) {
+    return { name: "dispatch_velocity", level: "yellow", detail: `Units averaging ${avgTimeMins}min each` };
+  }
+
+  return { name: "dispatch_velocity", level: "green", detail: `Units averaging ${avgTimeMins || "<1"}min each` };
+}
+
+// ── Main API ───────────────────────────────────────────────────────────────
+
+/**
+ * Compute the current progress score by evaluating all available signals.
+ * Returns a composite score with individual signal details.
+ */
+export function computeProgressScore(): ProgressScore {
+  const signals: ProgressSignal[] = [
+    evaluateHealthTrend(),
+    evaluateErrorStreak(),
+    evaluateRecentErrors(),
+    evaluateArtifactProduction(),
+    evaluateDispatchVelocity(),
+  ];
+
+  // Overall level: worst of all signals
+  const level = signals.some(s => s.level === "red")
+    ? "red"
+    : signals.some(s => s.level === "yellow")
+      ? "yellow"
+      : "green";
+
+  // Build summary from the most important signals
+  const summary = buildSummary(level, signals);
+
+  return { level, summary, signals };
+}
+
+/**
+ * Compute progress score with additional context from the current unit.
+ */
+export function computeProgressScoreWithContext(context: {
+  currentUnitType?: string;
+  currentUnitId?: string;
+  completedUnits?: number;
+  totalUnits?: number;
+  retryCount?: number;
+  maxRetries?: number;
+}): ProgressScore {
+  const base = computeProgressScore();
+
+  // Add retry signal if available
+  if (context.retryCount !== undefined && context.maxRetries !== undefined) {
+    const retrySignal: ProgressSignal = context.retryCount === 0
+      ? { name: "retry_count", level: "green", detail: "No retries" }
+      : context.retryCount <= 2
+        ? { name: "retry_count", level: "yellow", detail: `Retry ${context.retryCount}/${context.maxRetries}` }
+        : { name: "retry_count", level: "red", detail: `Retry ${context.retryCount}/${context.maxRetries} — looping` };
+
+    base.signals.push(retrySignal);
+
+    // Re-evaluate level
+    if (retrySignal.level === "red") base.level = "red";
+    else if (retrySignal.level === "yellow" && base.level === "green") base.level = "yellow";
+  }
+
+  // Build richer summary with context
+  base.summary = buildSummaryWithContext(base.level, base.signals, context);
+
+  return base;
+}
+
+// ── Formatting ─────────────────────────────────────────────────────────────
+
+function buildSummary(level: ProgressLevel, signals: ProgressSignal[]): string {
+  switch (level) {
+    case "green":
+      return "Progressing well";
+    case "yellow": {
+      const issues = signals.filter(s => s.level === "yellow").map(s => s.detail);
+      return `Struggling — ${issues[0] ?? "minor issues detected"}`;
+    }
+    case "red": {
+      const issues = signals.filter(s => s.level === "red").map(s => s.detail);
+      return `Stuck — ${issues[0] ?? "critical issues detected"}`;
+    }
+  }
+}
+
+function buildSummaryWithContext(
+  level: ProgressLevel,
+  signals: ProgressSignal[],
+  context: {
+    currentUnitType?: string;
+    currentUnitId?: string;
+    completedUnits?: number;
+    totalUnits?: number;
+    retryCount?: number;
+    maxRetries?: number;
+  },
+): string {
+  const unitLabel = context.currentUnitId
+    ? ` ${context.currentUnitId}`
+    : "";
+  const progressLabel = context.completedUnits !== undefined && context.totalUnits !== undefined
+    ? ` (${context.completedUnits} of ${context.totalUnits} done)`
+    : "";
+
+  switch (level) {
+    case "green":
+      return `Progressing well —${unitLabel}${progressLabel}`;
+    case "yellow": {
+      const issues = signals.filter(s => s.level === "yellow").map(s => s.detail);
+      const retryInfo = context.retryCount ? `, attempt ${context.retryCount}/${context.maxRetries}` : "";
+      return `Struggling —${unitLabel}${retryInfo}${progressLabel ? ` ${progressLabel}` : ""}, ${issues[0] ?? "issues detected"}`;
+    }
+    case "red": {
+      const issues = signals.filter(s => s.level === "red").map(s => s.detail);
+      return `Stuck —${unitLabel}${progressLabel ? ` ${progressLabel}` : ""}, ${issues[0] ?? "critical issues"}`;
+    }
+  }
+}
+
+/**
+ * Format progress score as a single-line traffic light for TUI display.
+ */
+export function formatProgressLine(score: ProgressScore): string {
+  const icon = score.level === "green" ? "\uD83D\uDFE2"
+    : score.level === "yellow" ? "\uD83D\uDFE1"
+      : "\uD83D\uDD34";
+  return `${icon} ${score.summary}`;
+}
+
+/**
+ * Format a detailed progress report showing all signals.
+ */
+export function formatProgressReport(score: ProgressScore): string {
+  const lines: string[] = [];
+
+  lines.push(formatProgressLine(score));
+  lines.push("");
+  lines.push("Signals:");
+
+  for (const signal of score.signals) {
+    const icon = signal.level === "green" ? "\u2705"
+      : signal.level === "yellow" ? "\u26A0\uFE0F"
+        : "\uD83D\uDED1";
+    lines.push(`  ${icon} ${signal.name}: ${signal.detail}`);
+  }
+
+  return lines.join("\n");
+}

package/src/resources/extensions/gsd/prompts/run-uat.md

@@ -17,11 +17,8 @@ If a `GSD Skill Preferences` block is present in system context, use it to decid
 ## UAT Instructions
 
 **UAT file:** `{{uatPath}}`
-**UAT type:** `{{uatType}}`
 **Result file to write:** `{{uatResultPath}}`
 
-### If UAT type is `artifact-driven`
-
 You are the test runner. Execute every check defined in `{{uatPath}}` directly:
 
 - Run shell commands with `bash`
@@ -46,7 +43,7 @@ Write `{{uatResultPath}}` with:
 ```markdown
 ---
 sliceId: {{sliceId}}
-uatType: {{uatType}}
+uatType: artifact-driven
 verdict: PASS | FAIL | PARTIAL
 date: <ISO 8601 timestamp>
 ---
@@ -68,44 +65,6 @@ date: <ISO 8601 timestamp>
 <any additional context, errors encountered, or follow-up items>
 ```
 
-### If UAT type is NOT `artifact-driven` (type is `{{uatType}}`)
-
-This UAT type requires human execution or live-runtime observation that you cannot perform mechanically. Your role is to surface it clearly for review.
-
-Write `{{uatResultPath}}` with:
-
-```markdown
----
-sliceId: {{sliceId}}
-uatType: {{uatType}}
-verdict: surfaced-for-human-review
-date: <ISO 8601 timestamp>
----
-
-# UAT Result — {{sliceId}}
-
-## UAT Type
-
-`{{uatType}}` — requires human execution or live-runtime verification.
-
-## Status
-
-Surfaced for human review. Auto-mode will pause after this unit so the UAT can be performed manually.
-
-## UAT File
-
-See `{{uatPath}}` for the full UAT specification and acceptance criteria.
-
-## Instructions for Human Reviewer
-
-Review `{{uatPath}}`, perform the described UAT steps, then update this file with:
-- The actual verdict (PASS / FAIL / PARTIAL)
-- Results for each check
-- Date completed
-
-Once updated, run `/gsd auto` to resume auto-mode.
-```
-
 ---
 
 **You MUST write `{{uatResultPath}}` before finishing.**

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

@@ -14,8 +14,7 @@ import { existsSync, mkdirSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
-import { GitServiceImpl, runGit } from "./git-service.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { createGitService, runGit } from "./git-service.js";
 
 // ─── Quick Task Helpers ───────────────────────────────────────────────────────
 
@@ -103,16 +102,16 @@ export async function handleQuick(
   const date = new Date().toISOString().split("T")[0];
 
   // Create git branch for the quick task (unless isolation: none)
-  const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git ?? {};
-  const git = new GitServiceImpl(basePath, gitPrefs);
+  const git = createGitService(basePath);
   const branchName = `gsd/quick/${taskNum}-${slug}`;
-  const skipBranch = gitPrefs.isolation === "none";
+  const skipBranch = git.prefs.isolation === "none";
 
   let branchCreated = false;
+  let originalBranch: string | undefined;
   if (!skipBranch) {
     try {
-      const current = git.getCurrentBranch();
-      if (current !== branchName) {
+      originalBranch = git.getCurrentBranch();
+      if (originalBranch !== branchName) {
         // Auto-commit any dirty state before switching
         try {
           git.autoCommit("quick-task", `Q${taskNum}`, []);
@@ -156,4 +155,57 @@ export async function handleQuick(
     },
     { triggerTurn: true },
   );
+
+  // Schedule branch merge-back after the quick task agent session ends.
+  // Without this, auto-mode resumes on the quick-task branch (#1269).
+  if (branchCreated && originalBranch) {
+    _pendingQuickBranchReturn = {
+      basePath,
+      originalBranch,
+      quickBranch: branchName,
+      taskNum,
+      slug,
+      description,
+    };
+  }
+}
+
+/** Pending quick-task branch return — consumed by cleanupQuickBranch(). */
+let _pendingQuickBranchReturn: {
+  basePath: string;
+  originalBranch: string;
+  quickBranch: string;
+  taskNum: number;
+  slug: string;
+  description: string;
+} | null = null;
+
+/**
+ * Merge the quick-task branch back to the original branch and switch.
+ * Called from the agent_end handler after a quick task completes.
+ * Returns true if a branch return was performed.
+ */
+export function cleanupQuickBranch(): boolean {
+  if (!_pendingQuickBranchReturn) return false;
+  const { basePath, originalBranch, quickBranch, taskNum, slug, description } = _pendingQuickBranchReturn;
+  _pendingQuickBranchReturn = null;
+
+  try {
+    // Auto-commit any remaining work
+    try { runGit(basePath, ["add", "-A"]); } catch {}
+    try { runGit(basePath, ["commit", "-m", `quick(Q${taskNum}): ${slug}`]); } catch {}
+
+    // Switch back and merge
+    runGit(basePath, ["checkout", originalBranch]);
+    try {
+      runGit(basePath, ["merge", "--squash", quickBranch]);
+      runGit(basePath, ["commit", "-m", `quick(Q${taskNum}): ${description.slice(0, 72)}`]);
+    } catch { /* merge conflict or nothing — non-fatal */ }
+
+    // Clean up quick branch
+    try { runGit(basePath, ["branch", "-D", quickBranch]); } catch {}
+    return true;
+  } catch {
+    return false;
+  }
 }

package/src/resources/extensions/gsd/repo-identity.ts

@@ -10,7 +10,7 @@ import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
 import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, symlinkSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { join, resolve, sep } from "node:path";
 
 // ─── Repo Identity ──────────────────────────────────────────────────────────
 
@@ -37,6 +37,27 @@ function getRemoteUrl(basePath: string): string {
  */
 function resolveGitRoot(basePath: string): string {
   try {
+    // In a worktree, --show-toplevel returns the worktree path, not the main
+    // repo root. Use --git-common-dir to find the shared .git directory,
+    // then derive the main repo root from it (#1288).
+    const commonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
+      cwd: basePath,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5_000,
+    }).trim();
+
+    // If commonDir ends with .git/worktrees/<name>, the main repo is two
+    // levels up from the worktrees dir. If it's just .git, resolve normally.
+    if (commonDir.includes(`${sep}worktrees${sep}`) || commonDir.includes("/worktrees/")) {
+      // e.g., /path/to/project/.gsd/worktrees/M001/.git → /path/to/project
+      // or /path/to/project/.git/worktrees/M001 → /path/to/project
+      const gitDir = commonDir.replace(/[/\\]worktrees[/\\][^/\\]+$/, "");
+      const mainRoot = resolve(gitDir, "..");
+      return mainRoot;
+    }
+
+    // Not in a worktree — use --show-toplevel as usual
     return execFileSync("git", ["rev-parse", "--show-toplevel"], {
       cwd: basePath,
       encoding: "utf-8",

package/src/resources/extensions/gsd/tests/auto-reentrancy-guard.test.ts

@@ -0,0 +1,127 @@
+/**
+ * auto-reentrancy-guard.test.ts — Tests for the unconditional reentrancy guard.
+ *
+ * Regression for #1272: auto-mode stuck-loop where gap watchdog or
+ * pendingAgentEndRetry could enter dispatchNextUnit concurrently during
+ * recursive skip chains because the reentrancy guard was bypassed when
+ * skipDepth > 0.
+ *
+ * The fix makes the guard unconditional (`if (s.dispatching)` without
+ * `&& s.skipDepth === 0`), and defers recursive re-dispatch via
+ * setImmediate/setTimeout so s.dispatching is released first.
+ */
+
+import {
+  _getDispatching,
+  _setDispatching,
+  _getSkipDepth,
+  _setSkipDepth,
+} from "../auto.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+async function main(): Promise<void> {
+  // ─── Test-only accessors work ───────────────────────────────────────────
+  console.log("\n=== reentrancy guard: test accessors round-trip ===");
+  {
+    _setDispatching(false);
+    assertEq(_getDispatching(), false, "dispatching starts false");
+
+    _setDispatching(true);
+    assertEq(_getDispatching(), true, "dispatching set to true");
+
+    _setDispatching(false);
+    assertEq(_getDispatching(), false, "dispatching reset to false");
+  }
+
+  // ─── skipDepth accessors ────────────────────────────────────────────────
+  console.log("\n=== reentrancy guard: skipDepth accessors round-trip ===");
+  {
+    _setSkipDepth(0);
+    assertEq(_getSkipDepth(), 0, "skipDepth starts at 0");
+
+    _setSkipDepth(3);
+    assertEq(_getSkipDepth(), 3, "skipDepth set to 3");
+
+    _setSkipDepth(0);
+    assertEq(_getSkipDepth(), 0, "skipDepth reset to 0");
+  }
+
+  // ─── Guard blocks even when skipDepth > 0 (#1272 regression) ───────────
+  console.log("\n=== reentrancy guard: blocks when dispatching=true regardless of skipDepth ===");
+  {
+    // Simulate the scenario from #1272: dispatching=true + skipDepth>0
+    // The old guard (`if (s.dispatching && s.skipDepth === 0)`) would allow
+    // concurrent entry when skipDepth > 0. The fix makes the check
+    // unconditional on skipDepth.
+    _setDispatching(true);
+    _setSkipDepth(2);
+
+    // Verify dispatching is true — guard should block regardless of skipDepth
+    assertTrue(
+      _getDispatching() === true,
+      "dispatching flag is true during skip chain"
+    );
+
+    // The actual reentrancy guard in dispatchNextUnit checks:
+    //   if (s.dispatching) { return; }
+    // We verify the state that would trigger the guard:
+    const wouldBlock = _getDispatching(); // unconditional check
+    const wouldBlockOld = _getDispatching() && _getSkipDepth() === 0; // old check
+
+    assertTrue(wouldBlock === true, "new guard blocks when dispatching=true, skipDepth=2");
+    assertTrue(wouldBlockOld === false, "old guard WOULD NOT block when dispatching=true, skipDepth=2 (the bug)");
+
+    // Clean up
+    _setDispatching(false);
+    _setSkipDepth(0);
+  }
+
+  // ─── Guard allows entry when dispatching=false ──────────────────────────
+  console.log("\n=== reentrancy guard: allows entry when dispatching=false ===");
+  {
+    _setDispatching(false);
+    _setSkipDepth(0);
+    assertTrue(!_getDispatching(), "guard allows entry when dispatching=false, skipDepth=0");
+
+    _setDispatching(false);
+    _setSkipDepth(3);
+    assertTrue(!_getDispatching(), "guard allows entry when dispatching=false, skipDepth=3");
+
+    _setSkipDepth(0);
+  }
+
+  // ─── skipDepth does not affect guard decision (the fix) ─────────────────
+  console.log("\n=== reentrancy guard: skipDepth is irrelevant to guard decision ===");
+  {
+    for (const depth of [0, 1, 2, 5]) {
+      _setDispatching(true);
+      _setSkipDepth(depth);
+      assertTrue(
+        _getDispatching() === true,
+        `guard blocks at skipDepth=${depth} when dispatching=true`
+      );
+    }
+
+    for (const depth of [0, 1, 2, 5]) {
+      _setDispatching(false);
+      _setSkipDepth(depth);
+      assertTrue(
+        _getDispatching() === false,
+        `guard allows at skipDepth=${depth} when dispatching=false`
+      );
+    }
+
+    // Clean up
+    _setDispatching(false);
+    _setSkipDepth(0);
+  }
+
+  report();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});