gsd-pi 2.22.0 → 2.24.0

package/dist/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/dist/resources/extensions/gsd/tests/validate-milestone.test.ts

@@ -0,0 +1,316 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { deriveState, isValidationTerminal } from "../state.ts";
+import { resolveExpectedArtifactPath, verifyExpectedArtifact, diagnoseExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.ts";
+import { resolveDispatch, type DispatchContext } from "../auto-dispatch.ts";
+import type { GSDState } from "../types.ts";
+import { clearPathCache } from "../paths.ts";
+import { clearParseCache } from "../files.ts";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-val-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  clearPathCache();
+  clearParseCache();
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function writeRoadmap(base: string, mid: string, content: string): void {
+  const dir = join(base, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-ROADMAP.md`), content);
+}
+
+function writeMilestoneSummary(base: string, mid: string, content: string): void {
+  const dir = join(base, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-SUMMARY.md`), content);
+}
+
+function writeValidation(base: string, mid: string, content: string): void {
+  const dir = join(base, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-VALIDATION.md`), content);
+}
+
+function writeSlicePlan(base: string, mid: string, sid: string, content: string): void {
+  const dir = join(base, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(join(dir, "tasks"), { recursive: true });
+  writeFileSync(join(dir, `${sid}-PLAN.md`), content);
+}
+
+function writeSliceSummary(base: string, mid: string, sid: string, content: string): void {
+  const dir = join(base, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${sid}-SUMMARY.md`), content);
+}
+
+const ALL_DONE_ROADMAP = `# M001: Test Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- It works
+
+## Slices
+
+- [x] **S01: First slice** \`risk:low\` \`depends:[]\`
+  > After this: it works
+
+## Boundary Map
+
+| From | To | Produces | Consumes |
+|------|-----|----------|----------|
+| S01  | terminal | output | nothing |
+`;
+
+const CONTEXT_FILE = `---
+id: M001
+title: Test Milestone
+---
+
+# Context
+Test context.
+`;
+
+// ─── isValidationTerminal ─────────────────────────────────────────────────
+
+test("isValidationTerminal returns true for verdict: pass", () => {
+  const content = "---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation";
+  assert.equal(isValidationTerminal(content), true);
+});
+
+test("isValidationTerminal returns true for verdict: needs-attention", () => {
+  const content = "---\nverdict: needs-attention\nremediation_round: 0\n---\n\n# Validation";
+  assert.equal(isValidationTerminal(content), true);
+});
+
+test("isValidationTerminal returns false for verdict: needs-remediation", () => {
+  const content = "---\nverdict: needs-remediation\nremediation_round: 0\n---\n\n# Validation";
+  assert.equal(isValidationTerminal(content), false);
+});
+
+test("isValidationTerminal returns false for missing frontmatter", () => {
+  const content = "# Validation\nNo frontmatter here.";
+  assert.equal(isValidationTerminal(content), false);
+});
+
+test("isValidationTerminal returns false for missing verdict field", () => {
+  const content = "---\nremediation_round: 0\n---\n\n# Validation";
+  assert.equal(isValidationTerminal(content), false);
+});
+
+// ─── deriveState: validating-milestone ────────────────────────────────────
+
+test("deriveState returns validating-milestone when all slices done and no VALIDATION file", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+    // Write CONTEXT so milestone has a title
+    const dir = join(base, ".gsd", "milestones", "M001");
+    writeFileSync(join(dir, "M001-CONTEXT.md"), CONTEXT_FILE);
+
+    const state = await deriveState(base);
+    assert.equal(state.phase, "validating-milestone");
+    assert.equal(state.activeMilestone?.id, "M001");
+    assert.equal(state.activeSlice, null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("deriveState returns completing-milestone when VALIDATION exists with terminal verdict", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+    writeValidation(base, "M001", "---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nAll good.");
+
+    const state = await deriveState(base);
+    assert.equal(state.phase, "completing-milestone");
+    assert.equal(state.activeMilestone?.id, "M001");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("deriveState returns validating-milestone when VALIDATION exists with needs-remediation verdict", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+    writeValidation(base, "M001", "---\nverdict: needs-remediation\nremediation_round: 0\n---\n\n# Validation\nNeeds fixes.");
+
+    const state = await deriveState(base);
+    assert.equal(state.phase, "validating-milestone");
+    assert.equal(state.activeMilestone?.id, "M001");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("deriveState returns complete when both VALIDATION and SUMMARY exist", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+    writeValidation(base, "M001", "---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nPassed.");
+    writeMilestoneSummary(base, "M001", "# Summary\nDone.");
+
+    const state = await deriveState(base);
+    assert.equal(state.phase, "complete");
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Dispatch rule ────────────────────────────────────────────────────────
+
+test("dispatch rule matches validating-milestone phase", async () => {
+  const state: GSDState = {
+    activeMilestone: { id: "M001", title: "Test" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "validating-milestone",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "Validate milestone M001.",
+    registry: [{ id: "M001", title: "Test", status: "active" }],
+    progress: { milestones: { done: 0, total: 1 } },
+  };
+
+  const base = makeTmpBase();
+  try {
+    // Set up minimal milestone structure for the prompt builder
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+
+    const ctx: DispatchContext = {
+      basePath: base,
+      mid: "M001",
+      midTitle: "Test",
+      state,
+      prefs: undefined,
+    };
+    const result = await resolveDispatch(ctx);
+    assert.equal(result.action, "dispatch");
+    if (result.action === "dispatch") {
+      assert.equal(result.unitType, "validate-milestone");
+      assert.equal(result.unitId, "M001");
+    }
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("dispatch rule skips when skip_milestone_validation preference is set", async () => {
+  const state: GSDState = {
+    activeMilestone: { id: "M001", title: "Test" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "validating-milestone",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "Validate milestone M001.",
+    registry: [{ id: "M001", title: "Test", status: "active" }],
+    progress: { milestones: { done: 0, total: 1 } },
+  };
+
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+
+    const ctx: DispatchContext = {
+      basePath: base,
+      mid: "M001",
+      midTitle: "Test",
+      state,
+      prefs: { phases: { skip_milestone_validation: true } },
+    };
+    const result = await resolveDispatch(ctx);
+    assert.equal(result.action, "skip");
+
+    // Verify the VALIDATION file was written
+    const validationPath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+    assert.ok(existsSync(validationPath), "VALIDATION file should be written on skip");
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Artifact resolution & verification ───────────────────────────────────
+
+test("resolveExpectedArtifactPath returns VALIDATION path for validate-milestone", () => {
+  const base = makeTmpBase();
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    const result = resolveExpectedArtifactPath("validate-milestone", "M001", base);
+    assert.ok(result);
+    assert.ok(result!.includes("VALIDATION"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact passes when VALIDATION.md exists", () => {
+  const base = makeTmpBase();
+  try {
+    writeValidation(base, "M001", "---\nverdict: pass\n---\n# Val");
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, true);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact fails when VALIDATION.md is missing", () => {
+  const base = makeTmpBase();
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── diagnoseExpectedArtifact ─────────────────────────────────────────────
+
+test("diagnoseExpectedArtifact returns validation path for validate-milestone", () => {
+  const base = makeTmpBase();
+  try {
+    const result = diagnoseExpectedArtifact("validate-milestone", "M001", base);
+    assert.ok(result);
+    assert.ok(result!.includes("VALIDATION"));
+    assert.ok(result!.includes("milestone validation report"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── buildLoopRemediationSteps ────────────────────────────────────────────
+
+test("buildLoopRemediationSteps returns steps for validate-milestone", () => {
+  const base = makeTmpBase();
+  try {
+    const result = buildLoopRemediationSteps("validate-milestone", "M001", base);
+    assert.ok(result);
+    assert.ok(result!.includes("VALIDATION"));
+    assert.ok(result!.includes("verdict: pass"));
+    assert.ok(result!.includes("gsd doctor"));
+  } finally {
+    cleanup(base);
+  }
+});

package/dist/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(