gsd-pi 2.37.1 → 2.38.0-dev.29edcdc

package/src/resources/extensions/gsd/tests/doctor-enhancements.test.ts

@@ -0,0 +1,266 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { runGSDDoctor } from "../doctor.js";
+import { formatDoctorReportJson } from "../doctor-format.js";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeBase(): { base: string; gsd: string; mDir: string } {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-enh-"));
+  const gsd = join(base, ".gsd");
+  const mDir = join(gsd, "milestones", "M001");
+  mkdirSync(join(mDir, "slices"), { recursive: true });
+  return { base, gsd, mDir };
+}
+
+function writeRoadmap(mDir: string, content: string): void {
+  writeFileSync(join(mDir, "M001-ROADMAP.md"), content);
+}
+
+function writeSlice(mDir: string, sliceId: string, planContent: string): string {
+  const sDir = join(mDir, "slices", sliceId);
+  const tDir = join(sDir, "tasks");
+  mkdirSync(tDir, { recursive: true });
+  writeFileSync(join(sDir, `${sliceId}-PLAN.md`), planContent);
+  return sDir;
+}
+
+async function main(): Promise<void> {
+  // ── 1. Circular dependency detection ──────────────────────────────────────
+  console.log("\n=== circular dependency detection ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Circular Test\n\n## Slices\n- [ ] **S01: Slice A** \`risk:low\` \`depends:[S02]\`\n  > After this: done\n- [ ] **S02: Slice B** \`risk:low\` \`depends:[S01]\`\n  > After this: done\n`);
+    writeSlice(mDir, "S01", "# S01: Slice A\n\n**Goal:** A\n**Demo:** A\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+    writeSlice(mDir, "S02", "# S02: Slice B\n\n**Goal:** B\n**Demo:** B\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "circular_slice_dependency"),
+      "detects circular dependency S01 → S02 → S01",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 2. Duplicate task IDs ──────────────────────────────────────────────────
+  console.log("\n=== duplicate task IDs ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Dup Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: First** `est:10m`\n  Task one.\n- [ ] **T01: Duplicate** `est:10m`\n  Task dup.\n");
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "duplicate_task_id"),
+      "detects duplicate task ID T01",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 3. Orphaned slice directory ──────────────────────────────────────────
+  console.log("\n=== orphaned slice directory ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Orphan Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+    // Create an extra slice directory not in roadmap
+    mkdirSync(join(mDir, "slices", "S99"), { recursive: true });
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "orphaned_slice_directory" && i.message.includes("S99")),
+      "detects orphaned slice directory S99",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 4. Task file not in plan ───────────────────────────────────────────────
+  console.log("\n=== task file not in plan ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Extra Task Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [x] **T01: Task** `est:10m`\n  Done.\n");
+    // T01 summary (matches plan)
+    writeFileSync(join(sDir, "tasks", "T01-SUMMARY.md"), "---\nstatus: done\n---\n# T01\nDone.\n");
+    // T99 summary (NOT in plan)
+    writeFileSync(join(sDir, "tasks", "T99-SUMMARY.md"), "---\nstatus: done\n---\n# T99\nExtra.\n");
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "task_file_not_in_plan" && i.message.includes("T99")),
+      "detects task summary T99 not in plan",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 5. Stale REPLAN file ────────────────────────────────────────────────────
+  console.log("\n=== stale REPLAN detection ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Replan Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [x] **T01: Task** `est:10m`\n  Done.\n");
+    writeFileSync(join(sDir, "tasks", "T01-SUMMARY.md"), "---\nstatus: done\ncompleted_at: 2026-01-01T00:00:00Z\n---\n# T01\nDone.\n");
+    // Add a REPLAN file even though all tasks are done
+    writeFileSync(join(sDir, "S01-REPLAN.md"), "# S01 REPLAN\nSomething changed.\n");
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "stale_replan_file"),
+      "detects stale REPLAN when all tasks are done",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 6. Metrics ledger corrupt ───────────────────────────────────────────────
+  console.log("\n=== metrics ledger corrupt ===");
+  {
+    const { base, gsd, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Metrics Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+    // Write invalid metrics.json
+    writeFileSync(join(gsd, "metrics.json"), '{"version":2,"data":[]}');
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "metrics_ledger_corrupt"),
+      "detects corrupt metrics ledger (version != 1)",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 7. Large planning file ──────────────────────────────────────────────────
+  console.log("\n=== large planning file ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Large File Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+    // Write a 101KB .md file
+    const bigContent = "# Big File\n" + "x".repeat(101 * 1024);
+    writeFileSync(join(sDir, "BIGFILE.md"), bigContent);
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "large_planning_file"),
+      "detects large planning file over 100KB",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 8. Future timestamp ─────────────────────────────────────────────────────
+  console.log("\n=== future timestamp ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Timestamp Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [x] **T01: Task** `est:10m`\n  Done.\n");
+    // completed_at is 2 days in the future
+    const futureDate = new Date(Date.now() + 2 * 24 * 60 * 60 * 1000).toISOString();
+    writeFileSync(
+      join(sDir, "tasks", "T01-SUMMARY.md"),
+      `---\nstatus: done\ncompleted_at: ${futureDate}\n---\n# T01\nDone.\n`,
+    );
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "future_timestamp"),
+      "detects future completed_at timestamp",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 9. JSON output format ───────────────────────────────────────────────────
+  console.log("\n=== JSON output format ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: JSON Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+
+    const result = await runGSDDoctor(base, { fix: false });
+    const json = formatDoctorReportJson(result);
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(json);
+    } catch {
+      parsed = null;
+    }
+
+    assertTrue(parsed !== null, "formatDoctorReportJson produces valid JSON");
+    assertTrue(typeof (parsed as Record<string, unknown>)?.ok === "boolean", "JSON has ok field");
+    assertTrue(Array.isArray((parsed as Record<string, unknown>)?.issues), "JSON has issues array");
+    assertTrue(Array.isArray((parsed as Record<string, unknown>)?.fixesApplied), "JSON has fixesApplied array");
+    assertTrue(typeof (parsed as Record<string, unknown>)?.generatedAt === "string", "JSON has generatedAt field");
+    assertTrue(typeof (parsed as Record<string, unknown>)?.summary === "object", "JSON has summary object");
+
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 10. Dry-run mode ────────────────────────────────────────────────────────
+  console.log("\n=== dry-run mode ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Dry Run Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [x] **T01: Task** `est:10m`\n  Done.\n");
+
+    const result = await runGSDDoctor(base, { fix: true, dryRun: true });
+    // In dry-run mode, no actual files should be created
+    assertTrue(!existsSync(join(sDir, "S01-SUMMARY.md")), "dry-run does not create slice summary");
+    assertTrue(
+      result.fixesApplied.some(f => f.startsWith("[dry-run]")),
+      "dry-run mode reports would-fix entries",
+    );
+
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 11. Per-check timing ─────────────────────────────────────────────────────
+  console.log("\n=== per-check timing ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Timing Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(result.timing !== undefined, "report includes timing");
+    assertTrue(typeof result.timing?.git === "number", "timing.git is a number");
+    assertTrue(typeof result.timing?.runtime === "number", "timing.runtime is a number");
+    assertTrue(typeof result.timing?.environment === "number", "timing.environment is a number");
+    assertTrue(typeof result.timing?.gsdState === "number", "timing.gsdState is a number");
+
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 12. Doctor history ───────────────────────────────────────────────────────
+  console.log("\n=== doctor history ===");
+  {
+    const { base, gsd, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: History Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+
+    await runGSDDoctor(base, { fix: false });
+
+    const historyPath = join(gsd, "doctor-history.jsonl");
+    assertTrue(existsSync(historyPath), "doctor-history.jsonl is created after run");
+
+    const { readDoctorHistory } = await import("../doctor.js");
+    const history = await readDoctorHistory(base);
+    assertTrue(history.length >= 1, "history has at least one entry");
+    assertTrue(typeof history[0]?.ts === "string", "history entry has ts field");
+    assertTrue(typeof history[0]?.ok === "boolean", "history entry has ok field");
+    assertTrue(typeof history[0]?.errors === "number", "history entry has errors count");
+    assertTrue(Array.isArray(history[0]?.codes), "history entry has codes array");
+
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  report();
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/src/resources/extensions/gsd/tests/doctor-providers.test.ts

@@ -47,6 +47,18 @@ function withEnv(vars: Record<string, string | undefined>, fn: () => void): void
   }
 }
 
+function withCwd(nextCwd: string, fn: () => void): void {
+  const saved = process.cwd();
+  process.chdir(nextCwd);
+  try {
+    fn();
+  } finally {
+    process.chdir(saved);
+  }
+}
+
+const PRESENT_TEST_VALUE = "configured";
+
 // ─── formatProviderReport ─────────────────────────────────────────────────────
 
 test("formatProviderReport returns fallback for empty results", () => {
@@ -184,7 +196,7 @@ test("runProviderChecks detects Anthropic key from ANTHROPIC_API_KEY env var", (
   // Isolate from real HOME so loadEffectiveGSDPreferences returns null (default → anthropic)
   // and auth.json lookups hit an empty directory.
   const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-env-test-")));
-  withEnv({ ANTHROPIC_API_KEY: "sk-ant-test-key", HOME: tmpHome }, () => {
+  withEnv({ ANTHROPIC_API_KEY: "sk-ant-test-key", ANTHROPIC_OAUTH_TOKEN: undefined, HOME: tmpHome }, () => {
     try {
       const results = runProviderChecks();
       const anthropic = results.find(r => r.name === "anthropic");
@@ -199,7 +211,15 @@ test("runProviderChecks detects Anthropic key from ANTHROPIC_API_KEY env var", (
 
 test("runProviderChecks returns error for Anthropic when no key present", () => {
   const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-test-")));
-  withEnv({ ANTHROPIC_API_KEY: undefined, HOME: tmpHome }, () => {
+  withEnv({
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    // Clear cross-provider routing env vars (GitHub Copilot can serve Claude models)
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+    HOME: tmpHome,
+  }, () => {
     try {
       const results = runProviderChecks();
       const anthropic = results.find(r => r.name === "anthropic");
@@ -275,7 +295,7 @@ test("runProviderChecks detects key from auth.json", () => {
 });
 
 test("runProviderChecks ignores empty placeholder keys in auth.json", () => {
-  withEnv({ ANTHROPIC_API_KEY: undefined }, () => {
+  withEnv({ ANTHROPIC_API_KEY: undefined, ANTHROPIC_OAUTH_TOKEN: undefined, COPILOT_GITHUB_TOKEN: undefined, GH_TOKEN: undefined, GITHUB_TOKEN: undefined }, () => {
     const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-test-")));
     const agentDir = join(tmpHome, ".gsd", "agent");
     mkdirSync(agentDir, { recursive: true });
@@ -296,3 +316,171 @@ test("runProviderChecks ignores empty placeholder keys in auth.json", () => {
     rmSync(tmpHome, { recursive: true, force: true });
   });
 });
+
+// ─── runProviderChecks — cross-provider routing ──────────────────────────────
+
+test("runProviderChecks reports ok for Anthropic when GitHub Copilot env var is set", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-copilot-test-")));
+  withEnv({
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    COPILOT_GITHUB_TOKEN: PRESENT_TEST_VALUE,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+    HOME: tmpHome,
+  }, () => {
+    try {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic result should exist");
+      assert.equal(anthropic!.status, "ok", "should be ok when Copilot auth is available");
+      assert.ok(anthropic!.message.includes("GitHub Copilot"), "should mention cross-provider source");
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
+test("runProviderChecks reports ok for Anthropic via GITHUB_TOKEN cross-provider routing", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-ghtoken-test-")));
+  withEnv({
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: PRESENT_TEST_VALUE,
+    HOME: tmpHome,
+  }, () => {
+    try {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic result should exist");
+      assert.equal(anthropic!.status, "ok", "should be ok when GITHUB_TOKEN provides Copilot access");
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
+test("runProviderChecks detects ANTHROPIC_OAUTH_TOKEN as valid Anthropic auth", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-oauth-test-")));
+  withEnv({
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: PRESENT_TEST_VALUE,
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+    HOME: tmpHome,
+  }, () => {
+    try {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic result should exist");
+      assert.equal(anthropic!.status, "ok", "should be ok when ANTHROPIC_OAUTH_TOKEN is set");
+      assert.ok(anthropic!.message.includes("env"), "should report env source");
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
+test("runProviderChecks reports ok via Copilot auth.json for Anthropic", () => {
+  withEnv({
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+  }, () => {
+    const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-copilot-auth-test-")));
+    const agentDir = join(tmpHome, ".gsd", "agent");
+    mkdirSync(agentDir, { recursive: true });
+
+    // GitHub Copilot OAuth in auth.json
+    const authData = {
+      "github-copilot": { type: "oauth", apiKey: "ghu_copilot-key", expires: Date.now() + 3_600_000 },
+    };
+    writeFileSync(join(agentDir, "auth.json"), JSON.stringify(authData));
+
+    withEnv({ HOME: tmpHome }, () => {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic result should exist");
+      assert.equal(anthropic!.status, "ok", "should be ok when Copilot is authenticated in auth.json");
+      assert.ok(anthropic!.message.includes("GitHub Copilot"), "should mention Copilot as source");
+    });
+
+    rmSync(tmpHome, { recursive: true, force: true });
+  });
+});
+
+test("runProviderChecks uses provider-qualified anthropic-vertex model IDs", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-vertex-prefix-home-")));
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-vertex-prefix-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "preferences.md"),
+    [
+      "---",
+      "models:",
+      "  execution: anthropic-vertex/claude-sonnet-4-6",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  withEnv({
+    HOME: tmpHome,
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    ANTHROPIC_VERTEX_PROJECT_ID: "vertex-project",
+  }, () => {
+    withCwd(repo, () => {
+      const results = runProviderChecks();
+      const vertex = results.find(r => r.name === "anthropic-vertex");
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(vertex, "anthropic-vertex result should exist");
+      assert.equal(vertex!.status, "ok", "should accept ANTHROPIC_VERTEX_PROJECT_ID as configured");
+      assert.ok(!anthropic || !anthropic.required, "plain anthropic should not be required for anthropic-vertex config");
+    });
+  });
+
+  rmSync(repo, { recursive: true, force: true });
+  rmSync(tmpHome, { recursive: true, force: true });
+});
+
+test("runProviderChecks uses object provider field for anthropic-vertex models", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-vertex-provider-home-")));
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-vertex-provider-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "preferences.md"),
+    [
+      "---",
+      "models:",
+      "  execution:",
+      "    model: claude-sonnet-4-6",
+      "    provider: anthropic-vertex",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  withEnv({
+    HOME: tmpHome,
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    ANTHROPIC_VERTEX_PROJECT_ID: undefined,
+  }, () => {
+    withCwd(repo, () => {
+      const results = runProviderChecks();
+      const vertex = results.find(r => r.name === "anthropic-vertex");
+      assert.ok(vertex, "anthropic-vertex result should exist");
+      assert.equal(vertex!.status, "error", "missing vertex config should be reported against anthropic-vertex");
+      assert.ok(vertex!.detail?.includes("ANTHROPIC_VERTEX_PROJECT_ID"), "should point to vertex setup");
+    });
+  });
+
+  rmSync(repo, { recursive: true, force: true });
+  rmSync(tmpHome, { recursive: true, force: true });
+});

package/src/resources/extensions/gsd/tests/plan-quality-validator.test.ts

@@ -360,4 +360,115 @@ console.log('\n=== Clean slice plan: no plan-quality issues ===');
   assertEq(planQualityIssues.length, 0, 'clean slice plan produces no empty_task_entry issues');
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// validateTaskPlanContent — missing output file paths
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== validateTaskPlanContent: missing output file paths ===');
+{
+  const content = `# T01: Some Task
+
+## Description
+
+Do something.
+
+## Steps
+
+1. Do the thing
+
+## Verification
+
+- Check it works
+
+## Expected Output
+
+This task produces the main output.
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const outputIssues = issues.filter(i => i.ruleId === 'missing_output_file_paths');
+  assertTrue(outputIssues.length >= 1, 'Expected Output without file paths triggers missing_output_file_paths');
+}
+
+console.log('\n=== validateTaskPlanContent: valid output file paths ===');
+{
+  const content = `# T01: Some Task
+
+## Description
+
+Do something.
+
+## Steps
+
+1. Do the thing
+
+## Verification
+
+- Check it works
+
+## Expected Output
+
+- \`src/types.ts\` — New type definitions
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const outputIssues = issues.filter(i => i.ruleId === 'missing_output_file_paths');
+  assertEq(outputIssues.length, 0, 'Expected Output with file paths does not trigger warning');
+}
+
+console.log('\n=== validateTaskPlanContent: missing input file paths (info severity) ===');
+{
+  const content = `# T01: Some Task
+
+## Description
+
+Do something.
+
+## Steps
+
+1. Do the thing
+
+## Verification
+
+- Check it works
+
+## Inputs
+
+Prior task summary insights about the architecture.
+
+## Expected Output
+
+- \`src/output.ts\` — Output file
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const inputIssues = issues.filter(i => i.ruleId === 'missing_input_file_paths');
+  assertTrue(inputIssues.length >= 1, 'Inputs without file paths triggers missing_input_file_paths');
+  if (inputIssues.length > 0) {
+    assertEq(inputIssues[0].severity, 'info', 'missing_input_file_paths is info severity (not warning)');
+  }
+}
+
+console.log('\n=== validateTaskPlanContent: no Expected Output section at all ===');
+{
+  const content = `# T01: Some Task
+
+## Description
+
+Do something.
+
+## Steps
+
+1. Do the thing
+
+## Verification
+
+- Check it works
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const outputIssues = issues.filter(i => i.ruleId === 'missing_output_file_paths');
+  assertTrue(outputIssues.length >= 1, 'Missing Expected Output section triggers missing_output_file_paths');
+}
+
 report();

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

@@ -208,30 +208,25 @@ test("git fields comprehensive validation", () => {
   assert.equal(preferences.git?.isolation, "branch");
 });
 
-test("auto_visualize, auto_report, compression_strategy, context_selection validate correctly", () => {
+test("auto_visualize, auto_report, context_selection validate correctly", () => {
   const { preferences, errors } = validatePreferences({
     auto_visualize: true,
     auto_report: false,
-    compression_strategy: "compress",
     context_selection: "smart",
   });
   assert.equal(errors.length, 0);
   assert.equal(preferences.auto_visualize, true);
   assert.equal(preferences.auto_report, false);
-  assert.equal(preferences.compression_strategy, "compress");
   assert.equal(preferences.context_selection, "smart");
 });
 
-test("auto_visualize, auto_report, compression_strategy, context_selection reject invalid values", () => {
+test("auto_visualize, auto_report, context_selection reject invalid values", () => {
   const { errors: e1 } = validatePreferences({ auto_visualize: "yes" as never });
   assert.ok(e1.some(e => e.includes("auto_visualize")));
 
   const { errors: e2 } = validatePreferences({ auto_report: 1 as never });
   assert.ok(e2.some(e => e.includes("auto_report")));
 
-  const { errors: e3 } = validatePreferences({ compression_strategy: "shrink" as never });
-  assert.ok(e3.some(e => e.includes("compression_strategy")));
-
   const { errors: e4 } = validatePreferences({ context_selection: "partial" as never });
   assert.ok(e4.some(e => e.includes("context_selection")));
 });