gsd-pi 2.22.0 → 2.23.0

package/src/resources/extensions/gsd/tests/triage-dispatch.test.ts

@@ -222,3 +222,123 @@ test("dashboard: overlay labels triage-captures and quick-task unit types", () =
     "unitLabel should handle quick-task",
   );
 });
+
+// ─── Post-triage resolution execution ─────────────────────────────────────────
+
+test("dispatch: post-triage resolution executor fires after triage-captures unit", () => {
+  const triageCompletionBlock = autoSrc.slice(
+    autoSrc.indexOf("Post-triage: execute actionable resolutions"),
+    autoSrc.indexOf("Path A fix: verify artifact"),
+  );
+  assert.ok(
+    triageCompletionBlock.includes('currentUnit.type === "triage-captures"'),
+    "should check for triage-captures unit completion",
+  );
+  assert.ok(
+    triageCompletionBlock.includes("executeTriageResolutions"),
+    "should call executeTriageResolutions",
+  );
+});
+
+test("dispatch: post-triage executor handles inject results", () => {
+  const triageCompletionBlock = autoSrc.slice(
+    autoSrc.indexOf("Post-triage: execute actionable resolutions"),
+    autoSrc.indexOf("Path A fix: verify artifact"),
+  );
+  assert.ok(
+    triageCompletionBlock.includes("triageResult.injected"),
+    "should check injected count",
+  );
+});
+
+test("dispatch: post-triage executor handles replan results", () => {
+  const triageCompletionBlock = autoSrc.slice(
+    autoSrc.indexOf("Post-triage: execute actionable resolutions"),
+    autoSrc.indexOf("Path A fix: verify artifact"),
+  );
+  assert.ok(
+    triageCompletionBlock.includes("triageResult.replanned"),
+    "should check replanned count",
+  );
+});
+
+test("dispatch: post-triage executor queues quick-tasks", () => {
+  const triageCompletionBlock = autoSrc.slice(
+    autoSrc.indexOf("Post-triage: execute actionable resolutions"),
+    autoSrc.indexOf("Path A fix: verify artifact"),
+  );
+  assert.ok(
+    triageCompletionBlock.includes("pendingQuickTasks"),
+    "should push quick-tasks to pendingQuickTasks queue",
+  );
+});
+
+// ─── Quick-task dispatch ──────────────────────────────────────────────────────
+
+test("dispatch: quick-task dispatch block exists after triage check", () => {
+  const quickTaskBlock = autoSrc.indexOf("Quick-task dispatch: execute queued quick-tasks");
+  const triageBlock = autoSrc.indexOf("Triage check: dispatch triage unit");
+  const stepModeBlock = autoSrc.indexOf("In step mode, pause and show a wizard");
+
+  assert.ok(quickTaskBlock > 0, "quick-task dispatch block should exist");
+  assert.ok(
+    quickTaskBlock > triageBlock,
+    "quick-task dispatch should come after triage check",
+  );
+  assert.ok(
+    quickTaskBlock < stepModeBlock,
+    "quick-task dispatch should come before step mode check",
+  );
+});
+
+test("dispatch: quick-task dispatch uses buildQuickTaskPrompt", () => {
+  const quickTaskSection = autoSrc.slice(
+    autoSrc.indexOf("Quick-task dispatch: execute queued quick-tasks"),
+    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  );
+  assert.ok(
+    quickTaskSection.includes("buildQuickTaskPrompt"),
+    "should call buildQuickTaskPrompt for quick-task dispatch",
+  );
+});
+
+test("dispatch: quick-task dispatch marks capture as executed", () => {
+  const quickTaskSection = autoSrc.slice(
+    autoSrc.indexOf("Quick-task dispatch: execute queued quick-tasks"),
+    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  );
+  assert.ok(
+    quickTaskSection.includes("markCaptureExecuted"),
+    "should mark capture as executed after dispatch",
+  );
+});
+
+test("dispatch: quick-task dispatch uses early-return pattern", () => {
+  const quickTaskSection = autoSrc.slice(
+    autoSrc.indexOf("Quick-task dispatch: execute queued quick-tasks"),
+    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  );
+  assert.ok(
+    quickTaskSection.includes("return; // handleAgentEnd will fire again when quick-task session completes"),
+    "quick-task dispatch should return after sending message",
+  );
+});
+
+// ─── Post-unit hook exclusion for quick-task ──────────────────────────────────
+
+test("dispatch: quick-task excluded from post-unit hook triggering", () => {
+  assert.ok(
+    hooksSrc.includes('"quick-task"'),
+    "post-unit-hooks.ts should reference quick-task",
+  );
+});
+
+// ─── pendingQuickTasks queue lifecycle ────────────────────────────────────────
+
+test("dispatch: pendingQuickTasks queue is reset on auto-mode start/stop", () => {
+  const resetMatches = autoSrc.match(/pendingQuickTasks = \[\]/g);
+  assert.ok(
+    resetMatches && resetMatches.length >= 3,
+    "pendingQuickTasks should be reset in at least 3 places (start, stop, manual hook)",
+  );
+});

package/src/resources/extensions/gsd/tests/triage-resolution.test.ts

@@ -7,10 +7,10 @@ import assert from "node:assert/strict";
 import { mkdirSync, readFileSync, writeFileSync, rmSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { appendCapture, markCaptureResolved, loadAllCaptures } from "../captures.ts";
+import { appendCapture, markCaptureResolved, markCaptureExecuted, loadAllCaptures, loadActionableCaptures } from "../captures.ts";
 // Import only the functions that don't depend on @gsd/pi-coding-agent
 // (triage-ui.ts imports next-action-ui.ts which imports the unavailable package)
-import { executeInject, executeReplan, detectFileOverlap, loadDeferredCaptures, loadReplanCaptures, buildQuickTaskPrompt } from "../triage-resolution.ts";
+import { executeInject, executeReplan, detectFileOverlap, loadDeferredCaptures, loadReplanCaptures, buildQuickTaskPrompt, executeTriageResolutions } from "../triage-resolution.ts";
 
 function makeTempDir(prefix: string): string {
   const dir = join(
@@ -213,3 +213,204 @@ test("resolution: buildQuickTaskPrompt includes capture text and ID", () => {
   assert.ok(prompt.includes("Quick Task"), "should have Quick Task header");
   assert.ok(prompt.includes("Do NOT modify"), "should warn about plan files");
 });
+
+// ─── markCaptureExecuted ─────────────────────────────────────────────────────
+
+test("resolution: markCaptureExecuted adds Executed field to capture", () => {
+  const tmp = makeTempDir("res-executed");
+  try {
+    const id = appendCapture(tmp, "fix the button");
+    markCaptureResolved(tmp, id, "quick-task", "execute as quick-task", "small fix");
+
+    markCaptureExecuted(tmp, id);
+
+    const all = loadAllCaptures(tmp);
+    assert.strictEqual(all.length, 1);
+    assert.strictEqual(all[0].executed, true, "should be marked as executed");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("resolution: markCaptureExecuted is idempotent", () => {
+  const tmp = makeTempDir("res-executed-idem");
+  try {
+    const id = appendCapture(tmp, "fix something");
+    markCaptureResolved(tmp, id, "inject", "inject task", "needed");
+
+    markCaptureExecuted(tmp, id);
+    markCaptureExecuted(tmp, id); // call again — should not duplicate
+
+    const filePath = join(tmp, ".gsd", "CAPTURES.md");
+    const content = readFileSync(filePath, "utf-8");
+    const executedMatches = content.match(/\*\*Executed:\*\*/g);
+    assert.strictEqual(executedMatches?.length, 1, "should have exactly one Executed field");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── loadActionableCaptures ──────────────────────────────────────────────────
+
+test("resolution: loadActionableCaptures returns only unexecuted actionable captures", () => {
+  const tmp = makeTempDir("res-actionable");
+  try {
+    const id1 = appendCapture(tmp, "inject this task");
+    const id2 = appendCapture(tmp, "quick fix");
+    const id3 = appendCapture(tmp, "just a note");
+    const id4 = appendCapture(tmp, "replan needed");
+    const id5 = appendCapture(tmp, "already executed inject");
+
+    markCaptureResolved(tmp, id1, "inject", "add task", "needed");
+    markCaptureResolved(tmp, id2, "quick-task", "quick fix", "small");
+    markCaptureResolved(tmp, id3, "note", "acknowledged", "info");
+    markCaptureResolved(tmp, id4, "replan", "replan triggered", "approach changed");
+    markCaptureResolved(tmp, id5, "inject", "add task", "needed");
+    markCaptureExecuted(tmp, id5); // mark as executed
+
+    const actionable = loadActionableCaptures(tmp);
+    assert.strictEqual(actionable.length, 3, "should have 3 actionable captures");
+    assert.deepStrictEqual(
+      actionable.map(c => c.id),
+      [id1, id2, id4],
+      "should include inject, quick-task, replan but not note or executed inject",
+    );
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── executeTriageResolutions ────────────────────────────────────────────────
+
+test("resolution: executeTriageResolutions executes inject captures", () => {
+  const tmp = makeTempDir("res-exec-inject");
+  try {
+    setupPlanFile(tmp, "M001", "S01", SAMPLE_PLAN);
+    const id1 = appendCapture(tmp, "add error handling");
+    const id2 = appendCapture(tmp, "add retry logic");
+    markCaptureResolved(tmp, id1, "inject", "add task", "needed");
+    markCaptureResolved(tmp, id2, "inject", "add task", "also needed");
+
+    const result = executeTriageResolutions(tmp, "M001", "S01");
+
+    assert.strictEqual(result.injected, 2, "should inject 2 tasks");
+    assert.strictEqual(result.replanned, 0);
+    assert.strictEqual(result.quickTasks.length, 0);
+
+    // Verify tasks were added to plan
+    const planPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
+    const planContent = readFileSync(planPath, "utf-8");
+    assert.ok(planContent.includes("**T04:"), "should have T04");
+    assert.ok(planContent.includes("**T05:"), "should have T05");
+
+    // Verify captures marked as executed
+    const all = loadAllCaptures(tmp);
+    assert.strictEqual(all[0].executed, true, "first capture should be executed");
+    assert.strictEqual(all[1].executed, true, "second capture should be executed");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("resolution: executeTriageResolutions executes replan captures", () => {
+  const tmp = makeTempDir("res-exec-replan");
+  try {
+    setupPlanFile(tmp, "M001", "S01", SAMPLE_PLAN);
+    const id = appendCapture(tmp, "approach is wrong");
+    markCaptureResolved(tmp, id, "replan", "replan triggered", "wrong approach");
+
+    const result = executeTriageResolutions(tmp, "M001", "S01");
+
+    assert.strictEqual(result.injected, 0);
+    assert.strictEqual(result.replanned, 1, "should trigger 1 replan");
+    assert.strictEqual(result.quickTasks.length, 0);
+
+    // Verify trigger file was written
+    const triggerPath = join(
+      tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-REPLAN-TRIGGER.md",
+    );
+    assert.ok(existsSync(triggerPath), "replan trigger should exist");
+
+    // Verify capture marked as executed
+    const all = loadAllCaptures(tmp);
+    assert.strictEqual(all[0].executed, true, "capture should be executed");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("resolution: executeTriageResolutions queues quick-tasks without executing inline", () => {
+  const tmp = makeTempDir("res-exec-qt");
+  try {
+    const id = appendCapture(tmp, "fix typo in readme");
+    markCaptureResolved(tmp, id, "quick-task", "execute as quick-task", "small fix");
+
+    const result = executeTriageResolutions(tmp, "M001", "S01");
+
+    assert.strictEqual(result.injected, 0);
+    assert.strictEqual(result.replanned, 0);
+    assert.strictEqual(result.quickTasks.length, 1, "should queue 1 quick-task");
+    assert.strictEqual(result.quickTasks[0].id, id);
+
+    // Quick-tasks should NOT be marked as executed yet (caller marks after dispatch)
+    const all = loadAllCaptures(tmp);
+    assert.ok(!all[0].executed, "quick-task should not be executed yet");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("resolution: executeTriageResolutions handles mixed classifications", () => {
+  const tmp = makeTempDir("res-exec-mixed");
+  try {
+    setupPlanFile(tmp, "M001", "S01", SAMPLE_PLAN);
+    const id1 = appendCapture(tmp, "inject a task");
+    const id2 = appendCapture(tmp, "quick fix typo");
+    const id3 = appendCapture(tmp, "just a note");
+    const id4 = appendCapture(tmp, "defer to later");
+
+    markCaptureResolved(tmp, id1, "inject", "add task", "needed");
+    markCaptureResolved(tmp, id2, "quick-task", "quick fix", "small");
+    markCaptureResolved(tmp, id3, "note", "acknowledged", "info");
+    markCaptureResolved(tmp, id4, "defer", "deferred", "later");
+
+    const result = executeTriageResolutions(tmp, "M001", "S01");
+
+    assert.strictEqual(result.injected, 1, "should inject 1 task");
+    assert.strictEqual(result.replanned, 0);
+    assert.strictEqual(result.quickTasks.length, 1, "should queue 1 quick-task");
+    assert.strictEqual(result.actions.length, 2, "should have 2 action entries (note/defer excluded)");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("resolution: executeTriageResolutions skips already-executed captures", () => {
+  const tmp = makeTempDir("res-exec-skip");
+  try {
+    setupPlanFile(tmp, "M001", "S01", SAMPLE_PLAN);
+    const id = appendCapture(tmp, "already done");
+    markCaptureResolved(tmp, id, "inject", "add task", "needed");
+    markCaptureExecuted(tmp, id); // already executed
+
+    const result = executeTriageResolutions(tmp, "M001", "S01");
+
+    assert.strictEqual(result.injected, 0, "should not inject again");
+    assert.strictEqual(result.actions.length, 0, "should have no actions");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("resolution: executeTriageResolutions returns empty result when no actionable captures", () => {
+  const tmp = makeTempDir("res-exec-empty");
+  try {
+    const result = executeTriageResolutions(tmp, "M001", "S01");
+    assert.strictEqual(result.injected, 0);
+    assert.strictEqual(result.replanned, 0);
+    assert.strictEqual(result.quickTasks.length, 0);
+    assert.strictEqual(result.actions.length, 0);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/visualizer-overlay.test.ts

@@ -1,5 +1,5 @@
 // Tests for GSD visualizer overlay.
-// Verifies filter mode, tab switching, and export key handling.
+// Verifies filter mode, tab switching, including reverse tab navigation, and export key handling.
 
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
@@ -81,6 +81,11 @@ assertTrue(
   "tab key wraps around TAB_COUNT",
 );
 
+assertTrue(
+  overlaySrc.includes('Key.shift("tab")') || overlaySrc.includes("Key.shift('tab')"),
+  "supports Shift+Tab for reverse tab switching",
+);
+
 console.log("\n=== Overlay: Export Key Interception ===");
 
 assertTrue(
@@ -101,8 +106,8 @@ assertTrue(
 console.log("\n=== Overlay: Footer ===");
 
 assertTrue(
-  overlaySrc.includes("Tab/1-7"),
-  "footer hint shows 1-7 tab range",
+  overlaySrc.includes("Tab/Shift+Tab/1-7"),
+  "footer hint shows Tab, Shift+Tab, and 1-7 tab range",
 );
 
 assertTrue(

package/src/resources/extensions/gsd/triage-resolution.ts

@@ -16,7 +16,9 @@ import type { Classification, CaptureEntry } from "./captures.js";
 import {
   loadPendingCaptures,
   loadAllCaptures,
+  loadActionableCaptures,
   markCaptureResolved,
+  markCaptureExecuted,
 } from "./captures.js";
 
 // ─── Resolution Executors ─────────────────────────────────────────────────────
@@ -198,3 +200,84 @@ export function buildQuickTaskPrompt(capture: CaptureEntry): string {
     `5. When done, say: "Quick task complete."`,
   ].join("\n");
 }
+
+// ─── Post-Triage Resolution Executor ─────────────────────────────────────────
+
+/**
+ * Result of executing triage resolutions after a triage-captures unit completes.
+ */
+export interface TriageExecutionResult {
+  /** Number of inject resolutions executed (tasks added to plan) */
+  injected: number;
+  /** Number of replan triggers written */
+  replanned: number;
+  /** Captures classified as quick-task that need dispatch */
+  quickTasks: CaptureEntry[];
+  /** Details of each action taken, for logging */
+  actions: string[];
+}
+
+/**
+ * Execute pending triage resolutions.
+ *
+ * Called after a triage-captures unit completes. Reads CAPTURES.md for
+ * resolved captures that have actionable classifications (inject, replan,
+ * quick-task) but haven't been executed yet, then:
+ *
+ * - inject: calls executeInject() to add a task to the current slice plan
+ * - replan: calls executeReplan() to write the REPLAN-TRIGGER.md marker
+ * - quick-task: collects for dispatch (caller handles dispatching quick-task units)
+ *
+ * Each capture is marked as executed after its resolution action succeeds,
+ * preventing double-execution on retries or restarts.
+ */
+export function executeTriageResolutions(
+  basePath: string,
+  mid: string,
+  sid: string,
+): TriageExecutionResult {
+  const result: TriageExecutionResult = {
+    injected: 0,
+    replanned: 0,
+    quickTasks: [],
+    actions: [],
+  };
+
+  const actionable = loadActionableCaptures(basePath);
+  if (actionable.length === 0) return result;
+
+  for (const capture of actionable) {
+    switch (capture.classification) {
+      case "inject": {
+        const newTaskId = executeInject(basePath, mid, sid, capture);
+        if (newTaskId) {
+          markCaptureExecuted(basePath, capture.id);
+          result.injected++;
+          result.actions.push(`Injected ${newTaskId} from ${capture.id}: "${capture.text}"`);
+        } else {
+          result.actions.push(`Failed to inject ${capture.id}: "${capture.text}" (no plan file or parse error)`);
+        }
+        break;
+      }
+      case "replan": {
+        const success = executeReplan(basePath, mid, sid, capture);
+        if (success) {
+          markCaptureExecuted(basePath, capture.id);
+          result.replanned++;
+          result.actions.push(`Replan triggered from ${capture.id}: "${capture.text}"`);
+        } else {
+          result.actions.push(`Failed to trigger replan from ${capture.id}: "${capture.text}"`);
+        }
+        break;
+      }
+      case "quick-task": {
+        // Quick-tasks are collected for dispatch, not executed inline
+        result.quickTasks.push(capture);
+        result.actions.push(`Quick-task queued from ${capture.id}: "${capture.text}"`);
+        break;
+      }
+    }
+  }
+
+  return result;
+}

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

@@ -112,6 +112,13 @@ export class GSDVisualizerOverlay {
       return;
     }
 
+    if (matchesKey(data, Key.shift("tab"))) {
+      this.activeTab = (this.activeTab - 1 + TAB_COUNT) % TAB_COUNT;
+      this.invalidate();
+      this.tui.requestRender();
+      return;
+    }
+
     if (matchesKey(data, Key.tab)) {
       this.activeTab = (this.activeTab + 1) % TAB_COUNT;
       this.invalidate();
@@ -300,7 +307,7 @@ export class GSDVisualizerOverlay {
     const lines = this.wrapInBox(visibleContent, width);
 
     // Footer hint
-    const hint = th.fg("dim", "Tab/1-7 switch · / filter · ↑↓ scroll · g/G top/end · esc close");
+    const hint = th.fg("dim", "Tab/Shift+Tab/1-7 switch · / filter · ↑↓ scroll · g/G top/end · esc close");
     const hintVis = visibleWidth(hint);
     const hintPad = Math.max(0, Math.floor((width - hintVis) / 2));
     lines.push(" ".repeat(hintPad) + hint);

package/src/resources/extensions/gsd/workspace-index.ts

@@ -103,10 +103,21 @@ async function indexSlice(basePath: string, milestoneId: string, sliceId: string
   };
 }
 
-export async function indexWorkspace(basePath: string): Promise<GSDWorkspaceIndex> {
+export interface IndexWorkspaceOptions {
+  /**
+   * When true, run validatePlanBoundary and validateCompleteBoundary for each slice.
+   * Skipped by default — validation is expensive (content analysis) and only needed
+   * for explicit doctor/audit flows. The /gsd status dashboard and scope pickers
+   * don't need the full issue list.
+   */
+  validate?: boolean;
+}
+
+export async function indexWorkspace(basePath: string, opts: IndexWorkspaceOptions = {}): Promise<GSDWorkspaceIndex> {
   const milestoneIds = findMilestoneIds(basePath);
   const milestones: WorkspaceMilestoneTarget[] = [];
   const validationIssues: ValidationIssue[] = [];
+  const runValidation = opts.validate === true;
 
   for (const milestoneId of milestoneIds) {
     const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP") ?? undefined;
@@ -118,11 +129,27 @@ export async function indexWorkspace(basePath: string): Promise<GSDWorkspaceInde
       if (roadmapContent) {
         const roadmap = parseRoadmap(roadmapContent);
         title = titleFromRoadmapHeader(roadmapContent, milestoneId);
-        for (const slice of roadmap.slices) {
-          const indexedSlice = await indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done);
+
+        // Parallelise all per-slice I/O: indexSlice + (optional) validation calls run concurrently.
+        // Order is preserved via Promise.all on an array built from roadmap.slices.
+        const sliceResults = await Promise.all(
+          roadmap.slices.map(async (slice) => {
+            if (runValidation) {
+              const [indexedSlice, planIssues, completeIssues] = await Promise.all([
+                indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done),
+                validatePlanBoundary(basePath, milestoneId, slice.id),
+                validateCompleteBoundary(basePath, milestoneId, slice.id),
+              ]);
+              return { indexedSlice, issues: [...planIssues, ...completeIssues] };
+            }
+            const indexedSlice = await indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done);
+            return { indexedSlice, issues: [] as ValidationIssue[] };
+          }),
+        );
+
+        for (const { indexedSlice, issues } of sliceResults) {
           slices.push(indexedSlice);
-          validationIssues.push(...await validatePlanBoundary(basePath, milestoneId, slice.id));
-          validationIssues.push(...await validateCompleteBoundary(basePath, milestoneId, slice.id));
+          validationIssues.push(...issues);
         }
       }
     }
@@ -173,7 +200,8 @@ export async function listDoctorScopeSuggestions(basePath: string): Promise<Arra
 }
 
 export async function getSuggestedNextCommands(basePath: string): Promise<string[]> {
-  const index = await indexWorkspace(basePath);
+  // Run validation here since we surface a /gsd doctor audit hint when issues exist.
+  const index = await indexWorkspace(basePath, { validate: true });
   const scope = index.active.milestoneId && index.active.sliceId
     ? `${index.active.milestoneId}/${index.active.sliceId}`
     : index.active.milestoneId;