gsd-pi 2.43.0 → 2.44.0-dev.62b5d6c

package/src/resources/extensions/gsd/tests/token-cost-display.test.ts

@@ -0,0 +1,118 @@
+/**
+ * Tests for the show_token_cost preference (#1515).
+ *
+ * Covers:
+ *   - Preference recognition and validation
+ *   - Cost formatting accuracy (inline re-implementation for test isolation)
+ *   - Disabled-by-default behavior
+ *   - Preference parsing from markdown frontmatter
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  validatePreferences,
+  parsePreferencesMarkdown,
+} from "../preferences.ts";
+import { KNOWN_PREFERENCE_KEYS } from "../preferences-types.ts";
+
+// Re-implement formatPromptCost here for test isolation (avoids pi-coding-agent build dep).
+// The canonical implementation lives in footer.ts.
+function formatPromptCost(cost: number): string {
+  if (cost < 0.001) return `$${cost.toFixed(4)}`;
+  if (cost < 0.01) return `$${cost.toFixed(3)}`;
+  if (cost < 1) return `$${cost.toFixed(3)}`;
+  return `$${cost.toFixed(2)}`;
+}
+
+// ── Preference recognition ──────────────────────────────────────────────────
+
+test("show_token_cost is a known preference key", () => {
+  assert.ok(KNOWN_PREFERENCE_KEYS.has("show_token_cost"));
+});
+
+test("show_token_cost: true validates without errors", () => {
+  const { errors, preferences } = validatePreferences({ show_token_cost: true });
+  assert.equal(errors.length, 0);
+  assert.equal(preferences.show_token_cost, true);
+});
+
+test("show_token_cost: false validates without errors", () => {
+  const { errors, preferences } = validatePreferences({ show_token_cost: false });
+  assert.equal(errors.length, 0);
+  assert.equal(preferences.show_token_cost, false);
+});
+
+test("show_token_cost: non-boolean produces validation error", () => {
+  const { errors } = validatePreferences({ show_token_cost: "yes" as any });
+  assert.ok(errors.length > 0);
+  assert.ok(errors[0].includes("show_token_cost"));
+  assert.ok(errors[0].includes("boolean"));
+});
+
+test("show_token_cost does not produce unknown-key warning", () => {
+  const { warnings } = validatePreferences({ show_token_cost: true });
+  const unknownWarnings = warnings.filter(w => w.includes("show_token_cost"));
+  assert.equal(unknownWarnings.length, 0);
+});
+
+// ── Disabled by default ─────────────────────────────────────────────────────
+
+test("show_token_cost defaults to undefined (disabled) when not set", () => {
+  const { preferences } = validatePreferences({});
+  assert.equal(preferences.show_token_cost, undefined);
+});
+
+test("empty preferences.md does not enable show_token_cost", () => {
+  const prefs = parsePreferencesMarkdown("---\nversion: 1\n---\n");
+  assert.ok(prefs);
+  assert.equal(prefs.show_token_cost, undefined);
+});
+
+test("preferences.md with show_token_cost: true enables the preference", () => {
+  const prefs = parsePreferencesMarkdown("---\nshow_token_cost: true\n---\n");
+  assert.ok(prefs);
+  assert.equal(prefs.show_token_cost, true);
+});
+
+// ── Cost formatting ─────────────────────────────────────────────────────────
+
+test("formatPromptCost formats sub-cent amounts with 4 decimals", () => {
+  assert.equal(formatPromptCost(0.0003), "$0.0003");
+  assert.equal(formatPromptCost(0.0009), "$0.0009");
+});
+
+test("formatPromptCost formats cent-range amounts with 3 decimals", () => {
+  assert.equal(formatPromptCost(0.003), "$0.003");
+  assert.equal(formatPromptCost(0.012), "$0.012");
+  assert.equal(formatPromptCost(0.1), "$0.100");
+});
+
+test("formatPromptCost formats dollar-range amounts with 2 decimals", () => {
+  assert.equal(formatPromptCost(1.5), "$1.50");
+  assert.equal(formatPromptCost(12.345), "$12.35");
+});
+
+test("formatPromptCost handles zero", () => {
+  assert.equal(formatPromptCost(0), "$0.0000");
+});
+
+// ── Cost calculation correctness ────────────────────────────────────────────
+
+test("cost calculation formula matches Model cost structure", () => {
+  // Simulates: usage.input * model.cost.input / 1_000_000 + usage.output * model.cost.output / 1_000_000
+  // Model.cost fields are $/million tokens
+  const modelCost = { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 }; // claude-opus-4 pricing
+  const usage = { input: 2000, output: 500, cacheRead: 10000, cacheWrite: 1000 };
+
+  const cost =
+    (usage.input * modelCost.input / 1_000_000) +
+    (usage.output * modelCost.output / 1_000_000) +
+    (usage.cacheRead * modelCost.cacheRead / 1_000_000) +
+    (usage.cacheWrite * modelCost.cacheWrite / 1_000_000);
+
+  // 2000*15/1M + 500*75/1M + 10000*1.5/1M + 1000*18.75/1M
+  // = 0.03 + 0.0375 + 0.015 + 0.01875 = 0.10125
+  assert.ok(Math.abs(cost - 0.10125) < 0.0001, `Expected ~$0.10125 but got $${cost}`);
+  assert.equal(formatPromptCost(cost), "$0.101");
+});

package/src/resources/extensions/gsd/tests/tool-naming.test.ts

@@ -1,7 +1,7 @@
 // tool-naming — Verifies canonical + alias tool registration for GSD DB tools.
 //
-// Each of the 4 DB tools must register under its canonical gsd_concept_action name
-// AND under the old gsd_action_concept name as a backward-compatible alias.
+// Each DB tool must register under its canonical gsd_concept_action name
+// AND under a backward-compatible alias name.
 // The alias must share the exact same execute function reference as the canonical tool.
 
 import { createTestContext } from './test-helpers.ts';
@@ -26,6 +26,14 @@ const RENAME_MAP: Array<{ canonical: string; alias: string }> = [
   { canonical: "gsd_requirement_update", alias: "gsd_update_requirement" },
   { canonical: "gsd_summary_save", alias: "gsd_save_summary" },
   { canonical: "gsd_milestone_generate_id", alias: "gsd_generate_milestone_id" },
+  { canonical: "gsd_task_complete", alias: "gsd_complete_task" },
+  { canonical: "gsd_slice_complete", alias: "gsd_complete_slice" },
+  { canonical: "gsd_plan_milestone", alias: "gsd_milestone_plan" },
+  { canonical: "gsd_plan_slice", alias: "gsd_slice_plan" },
+  { canonical: "gsd_plan_task", alias: "gsd_task_plan" },
+  { canonical: "gsd_replan_slice", alias: "gsd_slice_replan" },
+  { canonical: "gsd_reassess_roadmap", alias: "gsd_roadmap_reassess" },
+  { canonical: "gsd_complete_milestone", alias: "gsd_milestone_complete" },
 ];
 
 // ─── Registration count ──────────────────────────────────────────────────────
@@ -35,7 +43,7 @@ console.log('\n── Tool naming: registration count ──');
 const pi = makeMockPi();
 registerDbTools(pi);
 
-assertEq(pi.tools.length, 8, 'Should register exactly 8 tools (4 canonical + 4 aliases)');
+assertEq(pi.tools.length, 24, 'Should register exactly 24 tools (12 canonical + 12 aliases)');
 
 // ─── Both names exist for each pair ──────────────────────────────────────────
 

package/src/resources/extensions/gsd/tests/undo.test.ts

@@ -8,8 +8,21 @@ import {
   extractCommitShas,
   findCommitsForUnit,
   handleUndo,
+  handleUndoTask,
+  handleResetSlice,
   uncheckTaskInPlan,
-} from "../undo.js";
+} from "../undo.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getTask,
+  getSlice,
+} from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { existsSync } from "node:fs";
 
 function makeTempDir(prefix: string): string {
   return mkdtempSync(join(tmpdir(), `${prefix}-`));
@@ -140,3 +153,310 @@ test("extractCommitShas ignores malformed commit tokens", () => {
 
   assert.deepEqual(extractCommitShas(content), ["1234567"]);
 });
+
+// ─── handleUndoTask tests ────────────────────────────────────────────────────
+
+function makeCtx(): { notifications: Array<{ message: string; level: string }>; ctx: any } {
+  const notifications: Array<{ message: string; level: string }> = [];
+  const ctx = {
+    ui: {
+      notify(message: string, level: string) {
+        notifications.push({ message, level });
+      },
+    },
+  };
+  return { notifications, ctx };
+}
+
+function setupTaskFixture(base: string): void {
+  // Create milestone/slice/task directory structure
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+
+  // Write plan file with checked task
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "- [x] **T01: First task** `est:30m`",
+      "- [ ] **T02: Second task** `est:30m`",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  // Write task summary file
+  writeFileSync(
+    join(tasksDir, "T01-SUMMARY.md"),
+    "# T01 Summary\nDone.",
+    "utf-8",
+  );
+
+  // Set up DB
+  openDatabase(":memory:");
+  insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Test Slice", status: "active", risk: "low", depends: [] });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "First task", status: "complete" });
+  insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", title: "Second task", status: "pending" });
+  invalidateAllCaches();
+}
+
+test("handleUndoTask without args shows usage", async () => {
+  const { notifications, ctx } = makeCtx();
+  const base = makeTempDir("gsd-undo-task-usage");
+  try {
+    await handleUndoTask("", ctx, {} as any, base);
+    assert.equal(notifications.length, 1);
+    assert.equal(notifications[0]?.level, "warning");
+    assert.match(notifications[0]?.message ?? "", /Usage:/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("handleUndoTask without --force shows confirmation", async () => {
+  const base = makeTempDir("gsd-undo-task-confirm");
+  try {
+    setupTaskFixture(base);
+    const { notifications, ctx } = makeCtx();
+    await handleUndoTask("M001/S01/T01", ctx, {} as any, base);
+    assert.equal(notifications.length, 1);
+    assert.equal(notifications[0]?.level, "warning");
+    assert.match(notifications[0]?.message ?? "", /--force to confirm/);
+    // Verify state was NOT modified
+    const task = getTask("M001", "S01", "T01");
+    assert.equal(task?.status, "complete");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("handleUndoTask with --force resets task and re-renders plan", async () => {
+  const base = makeTempDir("gsd-undo-task-force");
+  try {
+    setupTaskFixture(base);
+    const { notifications, ctx } = makeCtx();
+    await handleUndoTask("M001/S01/T01 --force", ctx, {} as any, base);
+
+    // DB status reset
+    const task = getTask("M001", "S01", "T01");
+    assert.equal(task?.status, "pending");
+
+    // Summary file deleted
+    const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md");
+    assert.equal(existsSync(summaryPath), false);
+
+    // Plan checkbox unchecked
+    const planContent = readFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+      "utf-8",
+    );
+    assert.match(planContent, /\[ \] \*\*T01:/);
+
+    // Success notification
+    assert.equal(notifications[0]?.level, "success");
+    assert.match(notifications[0]?.message ?? "", /Reset task M001\/S01\/T01/);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("handleUndoTask with non-existent task returns error", async () => {
+  const base = makeTempDir("gsd-undo-task-notfound");
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Test", status: "active", risk: "low", depends: [] });
+
+    const { notifications, ctx } = makeCtx();
+    await handleUndoTask("M001/S01/T99 --force", ctx, {} as any, base);
+    assert.equal(notifications[0]?.level, "error");
+    assert.match(notifications[0]?.message ?? "", /not found/);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("handleUndoTask accepts partial ID (T01) and resolves from state", async () => {
+  const base = makeTempDir("gsd-undo-task-partial");
+  try {
+    setupTaskFixture(base);
+
+    // Create STATE.md so deriveState can resolve the active milestone/slice
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "STATE.md"),
+      [
+        "# GSD State",
+        "",
+        "- Phase: executing",
+        "- Active Milestone: M001",
+        "- Active Slice: S01",
+        "- Active Task: T01",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const { notifications, ctx } = makeCtx();
+    await handleUndoTask("T01 --force", ctx, {} as any, base);
+
+    const task = getTask("M001", "S01", "T01");
+    assert.equal(task?.status, "pending");
+    assert.equal(notifications[0]?.level, "success");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// ─── handleResetSlice tests ──────────────────────────────────────────────────
+
+function setupSliceFixture(base: string): void {
+  const mDir = join(base, ".gsd", "milestones", "M001");
+  const sliceDir = join(mDir, "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+
+  // Write roadmap file
+  writeFileSync(
+    join(mDir, "M001-ROADMAP.md"),
+    [
+      "# Roadmap",
+      "",
+      "## Slices",
+      "",
+      "- [x] **S01: Test Slice** `risk:low` `depends:[]`",
+      "- [ ] **S02: Next Slice** `risk:low` `depends:[S01]`",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  // Write plan file
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "- [x] **T01: First task** `est:30m`",
+      "- [x] **T02: Second task** `est:30m`",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  // Write task summaries
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\nDone.", "utf-8");
+  writeFileSync(join(tasksDir, "T02-SUMMARY.md"), "# T02 Summary\nDone.", "utf-8");
+
+  // Write slice summary and UAT
+  writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# Slice Summary\nDone.", "utf-8");
+  writeFileSync(join(sliceDir, "S01-UAT.md"), "# UAT\nPassed.", "utf-8");
+
+  // Set up DB
+  openDatabase(":memory:");
+  insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Test Slice", status: "complete", risk: "low", depends: [] });
+  insertSlice({ id: "S02", milestoneId: "M001", title: "Next Slice", status: "pending", risk: "low", depends: ["S01"] });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "First task", status: "complete" });
+  insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", title: "Second task", status: "complete" });
+  invalidateAllCaches();
+}
+
+test("handleResetSlice without args shows usage", async () => {
+  const { notifications, ctx } = makeCtx();
+  const base = makeTempDir("gsd-reset-slice-usage");
+  try {
+    await handleResetSlice("", ctx, {} as any, base);
+    assert.equal(notifications.length, 1);
+    assert.equal(notifications[0]?.level, "warning");
+    assert.match(notifications[0]?.message ?? "", /Usage:/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("handleResetSlice without --force shows confirmation", async () => {
+  const base = makeTempDir("gsd-reset-slice-confirm");
+  try {
+    setupSliceFixture(base);
+    const { notifications, ctx } = makeCtx();
+    await handleResetSlice("M001/S01", ctx, {} as any, base);
+    assert.equal(notifications[0]?.level, "warning");
+    assert.match(notifications[0]?.message ?? "", /--force to confirm/);
+    // State not modified
+    const slice = getSlice("M001", "S01");
+    assert.equal(slice?.status, "complete");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("handleResetSlice with --force resets slice and all tasks", async () => {
+  const base = makeTempDir("gsd-reset-slice-force");
+  try {
+    setupSliceFixture(base);
+    const { notifications, ctx } = makeCtx();
+    await handleResetSlice("M001/S01 --force", ctx, {} as any, base);
+
+    // DB status reset
+    const slice = getSlice("M001", "S01");
+    assert.equal(slice?.status, "active");
+    const t1 = getTask("M001", "S01", "T01");
+    assert.equal(t1?.status, "pending");
+    const t2 = getTask("M001", "S01", "T02");
+    assert.equal(t2?.status, "pending");
+
+    // Task summaries deleted
+    const tasksDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
+    assert.equal(existsSync(join(tasksDir, "T01-SUMMARY.md")), false);
+    assert.equal(existsSync(join(tasksDir, "T02-SUMMARY.md")), false);
+
+    // Slice summary and UAT deleted
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    assert.equal(existsSync(join(sliceDir, "S01-SUMMARY.md")), false);
+    assert.equal(existsSync(join(sliceDir, "S01-UAT.md")), false);
+
+    // Plan checkboxes unchecked
+    const planContent = readFileSync(join(sliceDir, "S01-PLAN.md"), "utf-8");
+    assert.match(planContent, /\[ \] \*\*T01:/);
+    assert.match(planContent, /\[ \] \*\*T02:/);
+
+    // Roadmap checkbox unchecked
+    const roadmapContent = readFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "utf-8",
+    );
+    assert.match(roadmapContent, /\[ \] \*\*S01:/);
+
+    // Success notification
+    assert.equal(notifications[0]?.level, "success");
+    assert.match(notifications[0]?.message ?? "", /Reset slice M001\/S01/);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("handleResetSlice with non-existent slice returns error", async () => {
+  const base = makeTempDir("gsd-reset-slice-notfound");
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const { notifications, ctx } = makeCtx();
+    await handleResetSlice("M001/S99 --force", ctx, {} as any, base);
+    assert.equal(notifications[0]?.level, "error");
+    assert.match(notifications[0]?.message ?? "", /not found/);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/validate-milestone.test.ts

@@ -375,7 +375,7 @@ test("buildLoopRemediationSteps returns steps for validate-milestone", () => {
     assert.ok(result);
     assert.ok(result!.includes("VALIDATION"));
     assert.ok(result!.includes("verdict: pass"));
-    assert.ok(result!.includes("gsd doctor"));
+    assert.ok(result!.includes("gsd recover"));
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/verification-evidence.test.ts

@@ -240,148 +240,6 @@ test("verification-evidence: formatEvidenceTable uses ✅/❌ emoji for pass/fai
   assert.ok(table.includes("❌ fail"), "failing check should have ❌ fail");
 });
 
-// ─── Validator Rule Tests (T03) ──────────────────────────────────────────────
-
-import { validateTaskSummaryContent } from "../observability-validator.ts";
-
-const MINIMAL_SUMMARY_WITH_EVIDENCE = `---
-observability_surfaces:
-  - gate-output
----
-# T03 Summary
-
-## Diagnostics
-Run \`npm test\` to verify.
-
-## Verification Evidence
-| # | Command | Exit Code | Verdict | Duration |
-|---|---------|-----------|---------|----------|
-| 1 | npm run typecheck | 0 | ✅ pass | 2.3s |
-`;
-
-const MINIMAL_SUMMARY_NO_EVIDENCE = `---
-observability_surfaces:
-  - gate-output
----
-# T03 Summary
-
-## Diagnostics
-Run \`npm test\` to verify.
-`;
-
-const MINIMAL_SUMMARY_PLACEHOLDER_EVIDENCE = `---
-observability_surfaces:
-  - gate-output
----
-# T03 Summary
-
-## Diagnostics
-Run \`npm test\` to verify.
-
-## Verification Evidence
-{{evidence_table}}
-`;
-
-const MINIMAL_SUMMARY_NO_CHECKS_EVIDENCE = `---
-observability_surfaces:
-  - gate-output
----
-# T03 Summary
-
-## Diagnostics
-Run \`npm test\` to verify.
-
-## Verification Evidence
-_No verification checks discovered._
-`;
-
-test("verification-evidence: validator accepts summary with real evidence table", () => {
-  const issues = validateTaskSummaryContent("T03-SUMMARY.md", MINIMAL_SUMMARY_WITH_EVIDENCE);
-  const evidenceIssues = issues.filter(
-    (i) => i.ruleId === "evidence_block_missing" || i.ruleId === "evidence_block_placeholder",
-  );
-  assert.equal(evidenceIssues.length, 0, "no evidence warnings for real table");
-});
-
-test("verification-evidence: validator warns when evidence section is missing", () => {
-  const issues = validateTaskSummaryContent("T03-SUMMARY.md", MINIMAL_SUMMARY_NO_EVIDENCE);
-  const match = issues.find((i) => i.ruleId === "evidence_block_missing");
-  assert.ok(match, "should produce evidence_block_missing warning");
-  assert.equal(match!.severity, "warning");
-  assert.equal(match!.scope, "task-summary");
-});
-
-test("verification-evidence: validator warns when evidence section has only placeholder text", () => {
-  const issues = validateTaskSummaryContent("T03-SUMMARY.md", MINIMAL_SUMMARY_PLACEHOLDER_EVIDENCE);
-  const match = issues.find((i) => i.ruleId === "evidence_block_placeholder");
-  assert.ok(match, "should produce evidence_block_placeholder warning");
-  assert.equal(match!.severity, "warning");
-});
-
-test("verification-evidence: validator accepts 'no checks discovered' as valid content", () => {
-  const issues = validateTaskSummaryContent("T03-SUMMARY.md", MINIMAL_SUMMARY_NO_CHECKS_EVIDENCE);
-  const evidenceIssues = issues.filter(
-    (i) => i.ruleId === "evidence_block_missing" || i.ruleId === "evidence_block_placeholder",
-  );
-  assert.equal(evidenceIssues.length, 0, "no evidence warnings for 'no checks discovered'");
-});
-
-// ─── Integration Test: Full Chain (T03) ──────────────────────────────────────
-
-test("verification-evidence: integration — VerificationResult → JSON → table → validator accepts", () => {
-  const tmp = makeTempDir("ve-integration");
-  try {
-    // 1. Create a VerificationResult with 2 checks (1 pass, 1 fail)
-    const result = makeResult({
-      passed: false,
-      checks: [
-        { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 1500 },
-        { command: "npm run test:unit", exitCode: 1, stdout: "", stderr: "1 failed", durationMs: 3200 },
-      ],
-      discoverySource: "package-json",
-    });
-
-    // 2. Write JSON to temp dir and read it back
-    writeVerificationJSON(result, tmp, "T03");
-    const jsonPath = join(tmp, "T03-VERIFY.json");
-    assert.ok(existsSync(jsonPath), "JSON file should exist");
-
-    const json = JSON.parse(readFileSync(jsonPath, "utf-8"));
-    assert.equal(json.schemaVersion, 1, "schemaVersion should be 1");
-    assert.equal(json.passed, false, "passed should be false");
-    assert.equal(json.checks.length, 2, "should have 2 checks");
-    assert.equal(json.checks[0].verdict, "pass", "first check should pass");
-    assert.equal(json.checks[1].verdict, "fail", "second check should fail");
-
-    // 3. Generate evidence table and embed in a mock summary
-    const table = formatEvidenceTable(result);
-    assert.ok(table.includes("npm run typecheck"), "table should contain first command");
-    assert.ok(table.includes("npm run test:unit"), "table should contain second command");
-
-    const fullSummary = `---
-observability_surfaces:
-  - gate-output
----
-# T03 Summary
-
-## Diagnostics
-Run \`npm test\` to verify.
-
-## Verification Evidence
-${table}
-`;
-
-    // 4. Validate — no evidence warnings
-    const issues = validateTaskSummaryContent("T03-SUMMARY.md", fullSummary);
-    const evidenceIssues = issues.filter(
-      (i) => i.ruleId === "evidence_block_missing" || i.ruleId === "evidence_block_placeholder",
-    );
-    assert.equal(evidenceIssues.length, 0, "validator should accept real evidence from formatEvidenceTable");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
 // ─── Retry Evidence Field Tests (S03/T01) ─────────────────────────────────────
 
 test("verification-evidence: writeVerificationJSON with retryAttempt and maxRetries includes them in output", () => {

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

@@ -36,18 +36,24 @@ function createGitRepo(): string {
  * Returns true when the directory would PASS the health check (dispatch
  * proceeds), false when it would FAIL (dispatch blocked).
  *
- * This mirrors the fixed logic: .git must exist, AND at least one
- * PROJECT_FILES entry or a src/ directory must exist.
+ * The only hard gate is .git — project files are advisory (greenfield
+ * projects won't have them yet). Returns { pass, greenfield } to
+ * distinguish "pass with project files" from "pass as greenfield".
  */
 function wouldPassHealthCheck(basePath: string, existsSyncFn: (p: string) => boolean): boolean {
   const hasGit = existsSyncFn(join(basePath, ".git"));
   if (!hasGit) return false;
 
+  // .git is sufficient — greenfield projects proceed with a warning
+  return true;
+}
+
+/** Whether the directory has recognized project files (used for greenfield detection). */
+function hasRecognizedProjectFiles(basePath: string, existsSyncFn: (p: string) => boolean): boolean {
   for (const file of PROJECT_FILES) {
     if (existsSyncFn(join(basePath, file))) return true;
   }
   if (existsSyncFn(join(basePath, "src"))) return true;
-
   return false;
 }
 
@@ -118,8 +124,9 @@ describe("health check with git repo", () => {
     assert.ok(wouldPassHealthCheck(dir, existsSync), "src/-only project should pass health check");
   });
 
-  test("health check fails for empty git repo with no project files", () => {
-    assert.ok(!wouldPassHealthCheck(dir, existsSync), "empty git repo should fail health check");
+  test("health check passes for empty git repo (greenfield project)", () => {
+    assert.ok(wouldPassHealthCheck(dir, existsSync), "empty git repo should pass health check (greenfield)");
+    assert.ok(!hasRecognizedProjectFiles(dir, existsSync), "empty git repo has no recognized project files");
   });
 });