gsd-pi 2.28.0 → 2.29.0-dev.2ccf3fb

package/dist/resources/extensions/gsd/tests/verification-gate.test.ts

@@ -20,7 +20,7 @@ import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { discoverCommands, runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit } from "../verification-gate.ts";
+import { discoverCommands, runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit, isLikelyCommand } from "../verification-gate.ts";
 import type { CaptureRuntimeErrorsOptions, DependencyAuditOptions } from "../verification-gate.ts";
 import { validatePreferences } from "../preferences.ts";
 
@@ -374,6 +374,120 @@ test("verification-gate: whitespace-only preference commands fall through", () =
   }
 });
 
+// ─── isLikelyCommand Tests (issue #1066) ────────────────────────────────────
+
+test("isLikelyCommand: known command prefixes are accepted", () => {
+  assert.equal(isLikelyCommand("npm run lint"), true);
+  assert.equal(isLikelyCommand("npx vitest"), true);
+  assert.equal(isLikelyCommand("yarn test"), true);
+  assert.equal(isLikelyCommand("pnpm run typecheck"), true);
+  assert.equal(isLikelyCommand("node script.js"), true);
+  assert.equal(isLikelyCommand("tsc --noEmit"), true);
+  assert.equal(isLikelyCommand("eslint ."), true);
+  assert.equal(isLikelyCommand("jest --ci"), true);
+  assert.equal(isLikelyCommand("python3 -m pytest"), true);
+  assert.equal(isLikelyCommand("cargo test"), true);
+  assert.equal(isLikelyCommand("go test ./..."), true);
+  assert.equal(isLikelyCommand("make test"), true);
+});
+
+test("isLikelyCommand: path-like first tokens are accepted", () => {
+  assert.equal(isLikelyCommand("./scripts/verify.sh"), true);
+  assert.equal(isLikelyCommand("/usr/local/bin/check"), true);
+  assert.equal(isLikelyCommand("../tools/lint.sh"), true);
+});
+
+test("isLikelyCommand: flag-like tokens indicate a command", () => {
+  assert.equal(isLikelyCommand("custom-tool --check"), true);
+  assert.equal(isLikelyCommand("mycheck -v"), true);
+});
+
+test("isLikelyCommand: prose descriptions are rejected", () => {
+  // The exact string from issue #1066
+  assert.equal(
+    isLikelyCommand("Document exists, contains all 5 scale names, all 14 semantic tokens, Inter assessment, philosophy and competitive citations present"),
+    false,
+  );
+  assert.equal(isLikelyCommand("Check that the file has been created with the correct content"), false);
+  assert.equal(isLikelyCommand("Verify the output matches expected format"), false);
+  assert.equal(isLikelyCommand("All tests pass and coverage is above 80%"), false);
+  assert.equal(isLikelyCommand("File should exist in the output directory"), false);
+  assert.equal(isLikelyCommand("Build succeeds without errors or warnings"), false);
+});
+
+test("isLikelyCommand: empty or whitespace-only strings are rejected", () => {
+  assert.equal(isLikelyCommand(""), false);
+  assert.equal(isLikelyCommand("   "), false);
+});
+
+test("isLikelyCommand: short lowercase tokens without flags are accepted (could be custom scripts)", () => {
+  assert.equal(isLikelyCommand("custom-verify"), true);
+  assert.equal(isLikelyCommand("mycheck"), true);
+});
+
+test("verification-gate: prose taskPlanVerify is rejected, falls through to package.json", () => {
+  const tmp = makeTempDir("vg-prose-reject");
+  try {
+    writeFileSync(
+      join(tmp, "package.json"),
+      JSON.stringify({ scripts: { test: "vitest" } }),
+    );
+    const result = discoverCommands({
+      taskPlanVerify: "Document exists, contains all 5 scale names, all 14 semantic tokens",
+      cwd: tmp,
+    });
+    // Prose should be rejected, so it falls through to package.json
+    assert.equal(result.source, "package-json");
+    assert.deepStrictEqual(result.commands, ["npm run test"]);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("verification-gate: prose taskPlanVerify with no package.json → source none", () => {
+  const tmp = makeTempDir("vg-prose-none");
+  try {
+    const result = discoverCommands({
+      taskPlanVerify: "Verify the output matches expected format and all fields are present",
+      cwd: tmp,
+    });
+    assert.equal(result.source, "none");
+    assert.deepStrictEqual(result.commands, []);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("verification-gate: valid command in taskPlanVerify still works", () => {
+  const tmp = makeTempDir("vg-valid-cmd");
+  try {
+    const result = discoverCommands({
+      taskPlanVerify: "npm run lint && npm run test",
+      cwd: tmp,
+    });
+    assert.equal(result.source, "task-plan");
+    assert.deepStrictEqual(result.commands, ["npm run lint", "npm run test"]);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("verification-gate: mixed prose and commands in taskPlanVerify — only commands kept", () => {
+  const tmp = makeTempDir("vg-mixed");
+  try {
+    const result = discoverCommands({
+      taskPlanVerify: "Check that everything works && npm run test",
+      cwd: tmp,
+    });
+    // "Check that everything works" is prose (starts with capital, 4+ words)
+    // "npm run test" is a valid command
+    assert.equal(result.source, "task-plan");
+    assert.deepStrictEqual(result.commands, ["npm run test"]);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
 // ─── Additional Execution Tests (T02) ───────────────────────────────────────
 
 test("verification-gate: one command fails — remaining commands still run (non-short-circuit)", () => {
@@ -467,7 +581,7 @@ test("formatFailureContext: formats a single failure with command, exit code, st
   const result: import("../types.ts").VerificationResult = {
     passed: false,
     checks: [
-      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "error: unused var", durationMs: 500 },
+      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "error: unused var", durationMs: 500, blocking: true },
     ],
     discoverySource: "preference",
     timestamp: Date.now(),
@@ -484,9 +598,9 @@ test("formatFailureContext: formats multiple failures", () => {
   const result: import("../types.ts").VerificationResult = {
     passed: false,
     checks: [
-      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "lint error", durationMs: 100 },
-      { command: "npm run test", exitCode: 2, stdout: "", stderr: "test failure", durationMs: 200 },
-      { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 50 },
+      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "lint error", durationMs: 100, blocking: true },
+      { command: "npm run test", exitCode: 2, stdout: "", stderr: "test failure", durationMs: 200, blocking: true },
+      { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 50, blocking: true },
     ],
     discoverySource: "preference",
     timestamp: Date.now(),
@@ -505,7 +619,7 @@ test("formatFailureContext: truncates stderr longer than 2000 chars", () => {
   const result: import("../types.ts").VerificationResult = {
     passed: false,
     checks: [
-      { command: "big-err", exitCode: 1, stdout: "", stderr: longStderr, durationMs: 100 },
+      { command: "big-err", exitCode: 1, stdout: "", stderr: longStderr, durationMs: 100, blocking: true },
     ],
     discoverySource: "preference",
     timestamp: Date.now(),
@@ -520,8 +634,8 @@ test("formatFailureContext: returns empty string when all checks pass", () => {
   const result: import("../types.ts").VerificationResult = {
     passed: true,
     checks: [
-      { command: "npm run lint", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100 },
-      { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 200 },
+      { command: "npm run lint", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100, blocking: true },
+      { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 200, blocking: true },
     ],
     discoverySource: "preference",
     timestamp: Date.now(),
@@ -549,6 +663,7 @@ test("formatFailureContext: caps total output at 10,000 chars", () => {
       stdout: "",
       stderr: "e".repeat(1000), // 1000 chars each, 20 * ~1050 (with formatting) > 10,000
       durationMs: 100,
+      blocking: true,
     });
   }
   const result: import("../types.ts").VerificationResult = {
@@ -963,3 +1078,131 @@ test("dependency-audit: subdirectory package.json does not trigger audit", () =>
   assert.equal(npmAuditCalled, false, "subdirectory dependency files should not trigger audit");
   assert.deepStrictEqual(result, []);
 });
+
+// ─── Non-Blocking Discovery Tests ────────────────────────────────────────────
+
+test("non-blocking: package-json discovered commands failing → result.passed is still true", () => {
+  const tmp = makeTempDir("vg-nb-pkg-fail");
+  try {
+    writeFileSync(
+      join(tmp, "package.json"),
+      JSON.stringify({ scripts: { lint: "eslint .", test: "vitest" } }),
+    );
+    // These commands will fail because eslint/vitest don't exist in the temp dir
+    const result = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+      // No preference commands — discovery falls through to package.json
+    });
+    assert.equal(result.discoverySource, "package-json");
+    assert.ok(result.checks.length > 0, "should have discovered package.json checks");
+    assert.equal(result.passed, true, "package-json failures should not block the gate");
+    for (const check of result.checks) {
+      assert.equal(check.blocking, false, "package-json checks should be non-blocking");
+    }
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("non-blocking: preference commands failing → result.passed is false", () => {
+  const tmp = makeTempDir("vg-nb-pref-fail");
+  try {
+    const result = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+      preferenceCommands: ["sh -c 'exit 1'"],
+    });
+    assert.equal(result.discoverySource, "preference");
+    assert.equal(result.passed, false, "preference failures should block the gate");
+    assert.equal(result.checks[0].blocking, true, "preference checks should be blocking");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("non-blocking: task-plan commands failing → result.passed is false", () => {
+  const tmp = makeTempDir("vg-nb-tp-fail");
+  try {
+    const result = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+      taskPlanVerify: "sh -c 'exit 1'",
+    });
+    assert.equal(result.discoverySource, "task-plan");
+    assert.equal(result.passed, false, "task-plan failures should block the gate");
+    assert.equal(result.checks[0].blocking, true, "task-plan checks should be blocking");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("non-blocking: blocking field is set correctly based on discovery source", () => {
+  const tmp = makeTempDir("vg-nb-field");
+  try {
+    // preference → blocking
+    const prefResult = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+      preferenceCommands: ["echo ok"],
+    });
+    assert.equal(prefResult.checks[0].blocking, true);
+
+    // task-plan → blocking
+    const tpResult = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+      taskPlanVerify: "echo ok",
+    });
+    assert.equal(tpResult.checks[0].blocking, true);
+
+    // package-json → non-blocking
+    writeFileSync(
+      join(tmp, "package.json"),
+      JSON.stringify({ scripts: { test: "echo ok" } }),
+    );
+    const pkgResult = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+    });
+    assert.equal(pkgResult.checks[0].blocking, false);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("non-blocking: formatFailureContext only includes blocking failures", () => {
+  const result: import("../types.ts").VerificationResult = {
+    passed: true,
+    checks: [
+      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "lint warning", durationMs: 100, blocking: false },
+      { command: "npm run test", exitCode: 1, stdout: "", stderr: "test error", durationMs: 200, blocking: true },
+      { command: "npm run typecheck", exitCode: 1, stdout: "", stderr: "type error", durationMs: 50, blocking: false },
+    ],
+    discoverySource: "preference",
+    timestamp: Date.now(),
+  };
+  const output = formatFailureContext(result);
+  assert.ok(output.includes("`npm run test`"), "should include blocking failure");
+  assert.ok(!output.includes("npm run lint"), "should not include non-blocking failure");
+  assert.ok(!output.includes("npm run typecheck"), "should not include non-blocking failure");
+});
+
+test("non-blocking: formatFailureContext returns empty when only non-blocking failures exist", () => {
+  const result: import("../types.ts").VerificationResult = {
+    passed: true,
+    checks: [
+      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "lint warning", durationMs: 100, blocking: false },
+      { command: "npm run test", exitCode: 1, stdout: "", stderr: "test warning", durationMs: 200, blocking: false },
+    ],
+    discoverySource: "package-json",
+    timestamp: Date.now(),
+  };
+  assert.equal(formatFailureContext(result), "", "should return empty when only non-blocking failures");
+});

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

@@ -230,8 +230,8 @@ assertTrue(
 console.log("\n=== Overlay: Shared Imports ===");
 
 assertTrue(
-  overlaySrc.includes('from "../shared/format-utils.js"'),
-  "imports from shared format-utils",
+  overlaySrc.includes('from "../shared/mod.js"'),
+  "imports from shared barrel",
 );
 
 report();

package/dist/resources/extensions/gsd/tests/visualizer-views.test.ts

@@ -387,6 +387,7 @@ console.log("\n=== renderMetricsView ===");
       userMessages: 5,
       totalTruncationSections: 0,
       continueHereFiredCount: 0,
+      apiRequests: 5,
     },
     byPhase: [
       {
@@ -653,7 +654,7 @@ console.log("\n=== renderHealthView ===");
       units: 10, tokens: { input: 5000, output: 2000, cacheRead: 1000, cacheWrite: 500, total: 8500 },
       cost: 5.00, duration: 120000, toolCalls: 50,
       assistantMessages: 30, userMessages: 15,
-      totalTruncationSections: 3, continueHereFiredCount: 1,
+      totalTruncationSections: 3, continueHereFiredCount: 1, apiRequests: 30,
     },
     health: {
       budgetCeiling: 20.00,

package/dist/resources/extensions/gsd/tests/workflow-templates.test.ts

@@ -0,0 +1,173 @@
+// GSD Workflow Templates — Unit Tests
+//
+// Tests registry loading, template resolution, auto-detection, and listing.
+
+import { createTestContext } from './test-helpers.ts';
+import {
+  loadRegistry,
+  resolveByName,
+  autoDetect,
+  listTemplates,
+  getTemplateInfo,
+  loadWorkflowTemplate,
+} from '../workflow-templates.ts';
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Registry Loading
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Registry Loading ──');
+
+{
+  const registry = loadRegistry();
+  assertTrue(registry !== null, 'Registry should load');
+  assertEq(registry.version, 1, 'Registry version should be 1');
+  assertTrue(Object.keys(registry.templates).length >= 8, 'Should have at least 8 templates');
+
+  // Verify required template keys exist
+  const expectedIds = ['full-project', 'bugfix', 'small-feature', 'refactor', 'spike', 'hotfix', 'security-audit', 'dep-upgrade'];
+  for (const id of expectedIds) {
+    assertTrue(id in registry.templates, `Template "${id}" should exist in registry`);
+  }
+
+  // Verify each template has required fields
+  for (const [id, entry] of Object.entries(registry.templates)) {
+    assertTrue(typeof entry.name === 'string' && entry.name.length > 0, `${id}: name should be non-empty string`);
+    assertTrue(typeof entry.description === 'string' && entry.description.length > 0, `${id}: description should be non-empty`);
+    assertTrue(typeof entry.file === 'string' && entry.file.endsWith('.md'), `${id}: file should be a .md path`);
+    assertTrue(Array.isArray(entry.phases) && entry.phases.length > 0, `${id}: phases should be non-empty array`);
+    assertTrue(Array.isArray(entry.triggers) && entry.triggers.length > 0, `${id}: triggers should be non-empty array`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Resolve by Name
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Resolve by Name ──');
+
+{
+  // Exact match
+  const bugfix = resolveByName('bugfix');
+  assertTrue(bugfix !== null, 'Should resolve "bugfix"');
+  assertEq(bugfix!.id, 'bugfix', 'ID should be "bugfix"');
+  assertEq(bugfix!.confidence, 'exact', 'Exact name should have exact confidence');
+
+  // Case-insensitive name match
+  const spike = resolveByName('Research Spike');
+  assertTrue(spike !== null, 'Should resolve "Research Spike" by name');
+  assertEq(spike!.id, 'spike', 'Should resolve to spike');
+
+  // Alias match
+  const bug = resolveByName('bug');
+  assertTrue(bug !== null, 'Should resolve "bug" alias');
+  assertEq(bug!.id, 'bugfix', 'Alias "bug" should map to bugfix');
+
+  const feat = resolveByName('feat');
+  assertTrue(feat !== null, 'Should resolve "feat" alias');
+  assertEq(feat!.id, 'small-feature', 'Alias "feat" should map to small-feature');
+
+  const deps = resolveByName('deps');
+  assertTrue(deps !== null, 'Should resolve "deps" alias');
+  assertEq(deps!.id, 'dep-upgrade', 'Alias "deps" should map to dep-upgrade');
+
+  // No match
+  const missing = resolveByName('nonexistent-template');
+  assertTrue(missing === null, 'Should return null for unknown template');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Auto-Detection
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Auto-Detection ──');
+
+{
+  // Should detect bugfix from "fix" keyword
+  const fixMatches = autoDetect('fix the login button');
+  assertTrue(fixMatches.length > 0, 'Should detect matches for "fix the login button"');
+  assertTrue(fixMatches.some(m => m.id === 'bugfix'), 'Should include bugfix in matches');
+
+  // Should detect spike from "research" keyword
+  const researchMatches = autoDetect('research authentication libraries');
+  assertTrue(researchMatches.length > 0, 'Should detect matches for "research"');
+  assertTrue(researchMatches.some(m => m.id === 'spike'), 'Should include spike in matches');
+
+  // Should detect hotfix from "urgent" keyword
+  const urgentMatches = autoDetect('urgent production is down');
+  assertTrue(urgentMatches.length > 0, 'Should detect matches for "urgent"');
+  assertTrue(urgentMatches.some(m => m.id === 'hotfix'), 'Should include hotfix in matches');
+
+  // Should detect dep-upgrade from "upgrade" keyword
+  const upgradeMatches = autoDetect('upgrade react to v19');
+  assertTrue(upgradeMatches.length > 0, 'Should detect matches for "upgrade"');
+  assertTrue(upgradeMatches.some(m => m.id === 'dep-upgrade'), 'Should include dep-upgrade in matches');
+
+  // Multi-word triggers should score higher
+  const projectMatches = autoDetect('create a new project from scratch');
+  const projectMatch = projectMatches.find(m => m.id === 'full-project');
+  assertTrue(projectMatch !== undefined, 'Should detect full-project for "from scratch"');
+
+  // Empty input should return no matches
+  const emptyMatches = autoDetect('');
+  assertEq(emptyMatches.length, 0, 'Empty input should return no matches');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// List Templates
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── List Templates ──');
+
+{
+  const output = listTemplates();
+  assertTrue(output.includes('Workflow Templates'), 'Should have header');
+  assertTrue(output.includes('bugfix'), 'Should list bugfix');
+  assertTrue(output.includes('spike'), 'Should list spike');
+  assertTrue(output.includes('hotfix'), 'Should list hotfix');
+  assertTrue(output.includes('/gsd start'), 'Should include usage hint');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Template Info
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Template Info ──');
+
+{
+  const info = getTemplateInfo('bugfix');
+  assertTrue(info !== null, 'Should return info for bugfix');
+  assertTrue(info!.includes('Bug Fix'), 'Should include template name');
+  assertTrue(info!.includes('triage'), 'Should include phase names');
+  assertTrue(info!.includes('Triggers'), 'Should include triggers section');
+
+  const missing = getTemplateInfo('nonexistent');
+  assertTrue(missing === null, 'Should return null for unknown template');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Load Workflow Template Content
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Load Workflow Template ──');
+
+{
+  const content = loadWorkflowTemplate('bugfix');
+  assertTrue(content !== null, 'Should load bugfix template');
+  assertTrue(content!.includes('Bugfix Workflow'), 'Should contain workflow title');
+  assertTrue(content!.includes('Phase 1: Triage'), 'Should contain triage phase');
+  assertTrue(content!.includes('Phase 4: Ship'), 'Should contain ship phase');
+
+  const hotfixContent = loadWorkflowTemplate('hotfix');
+  assertTrue(hotfixContent !== null, 'Should load hotfix template');
+  assertTrue(hotfixContent!.includes('Hotfix Workflow'), 'Should contain hotfix title');
+
+  const missingContent = loadWorkflowTemplate('nonexistent');
+  assertTrue(missingContent === null, 'Should return null for unknown template');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+
+report();

package/dist/resources/extensions/gsd/tests/workspace-index.test.ts

@@ -1,75 +1,38 @@
+import test from "node:test";
+import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-
 import { getSuggestedNextCommands, indexWorkspace, listDoctorScopeSuggestions } from "../workspace-index.ts";
-import { createTestContext } from './test-helpers.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
-const base = mkdtempSync(join(tmpdir(), "gsd-workspace-index-test-"));
-const gsd = join(base, ".gsd");
-const mDir = join(gsd, "milestones", "M001");
-const sDir = join(mDir, "slices", "S01");
-const tDir = join(sDir, "tasks");
-mkdirSync(tDir, { recursive: true });
-
-writeFileSync(join(mDir, "M001-ROADMAP.md"), `# M001: Demo Milestone
-
-## Slices
-- [ ] **S01: Demo Slice** \`risk:low\` \`depends:[]\`
-  > After this: demo works
-`);
-
-writeFileSync(join(sDir, "S01-PLAN.md"), `# S01: Demo Slice
-
-**Goal:** Demo
-**Demo:** Demo
 
-## Must-Haves
-- done
+test("workspace index: indexes active milestone/slice/task and suggests commands", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-workspace-index-test-"));
+  const gsd = join(base, ".gsd");
+  const mDir = join(gsd, "milestones", "M001");
+  const sDir = join(mDir, "slices", "S01");
+  mkdirSync(join(sDir, "tasks"), { recursive: true });
 
-## Tasks
-- [ ] **T01: Implement thing** \`est:10m\`
-  Task is in progress.
-`);
+  writeFileSync(join(mDir, "M001-ROADMAP.md"), `# M001: Demo Milestone\n\n## Slices\n- [ ] **S01: Demo Slice** \`risk:low\` \`depends:[]\`\n  > After this: demo works\n`);
+  writeFileSync(join(sDir, "S01-PLAN.md"), `# S01: Demo Slice\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Must-Haves\n- done\n\n## Tasks\n- [ ] **T01: Implement thing** \`est:10m\`\n  Task is in progress.\n`);
+  writeFileSync(join(sDir, "tasks", "T01-PLAN.md"), `# T01: Implement thing\n\n## Steps\n- do it\n`);
 
-writeFileSync(join(tDir, "T01-PLAN.md"), `# T01: Implement thing
-
-## Steps
-- do it
-`);
-
-async function main(): Promise<void> {
-  console.log("\n=== workspace index ===");
-  {
+  try {
     const index = await indexWorkspace(base);
-    assertEq(index.active.milestoneId, "M001", "active milestone indexed");
-    assertEq(index.active.sliceId, "S01", "active slice indexed");
-    assertEq(index.active.taskId, "T01", "active task indexed");
-    assertTrue(index.scopes.some(scope => scope.scope === "M001/S01"), "slice scope listed");
-    assertTrue(index.scopes.some(scope => scope.scope === "M001/S01/T01"), "task scope listed");
-  }
+    assert.equal(index.active.milestoneId, "M001");
+    assert.equal(index.active.sliceId, "S01");
+    assert.equal(index.active.taskId, "T01");
+    assert.ok(index.scopes.some(s => s.scope === "M001/S01"));
+    assert.ok(index.scopes.some(s => s.scope === "M001/S01/T01"));
 
-  console.log("\n=== doctor scope suggestions ===");
-  {
     const suggestions = await listDoctorScopeSuggestions(base);
-    assertEq(suggestions[0].value, "M001/S01", "active slice suggested first");
-    assertTrue(suggestions.some(item => item.value === "M001/S01/T01"), "task scope suggested");
-  }
+    assert.equal(suggestions[0].value, "M001/S01");
+    assert.ok(suggestions.some(item => item.value === "M001/S01/T01"));
 
-  console.log("\n=== next command suggestions ===");
-  {
     const commands = await getSuggestedNextCommands(base);
-    assertTrue(commands.includes("/gsd auto"), "suggests auto during execution");
-    assertTrue(commands.includes("/gsd doctor M001/S01"), "suggests scoped doctor");
-    assertTrue(commands.includes("/gsd status"), "suggests status");
+    assert.ok(commands.includes("/gsd auto"));
+    assert.ok(commands.includes("/gsd doctor M001/S01"));
+    assert.ok(commands.includes("/gsd status"));
+  } finally {
+    rmSync(base, { recursive: true, force: true });
   }
-
-  rmSync(base, { recursive: true, force: true });
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
 });

package/dist/resources/extensions/gsd/tests/worktree-e2e.test.ts

@@ -38,6 +38,9 @@ function createTempRepo(): string {
   run("git config user.email test@test.com", dir);
   run("git config user.name Test", dir);
   writeFileSync(join(dir, "README.md"), "# test\n");
+  // Mirror production: .gsd/worktrees/ is gitignored so autoCommitDirtyState
+  // doesn't pick up the worktrees directory as dirty state (#1127 fix).
+  writeFileSync(join(dir, ".gitignore"), ".gsd/worktrees/\n");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
   writeFileSync(join(dir, ".gsd", "STATE.md"), "# State\n");
   run("git add .", dir);
@@ -209,13 +212,13 @@ _None_
       run("git worktree add -b milestone/M001 .gsd/worktrees/M001", repo);
 
       // Detect
-      const detect = await runGSDDoctor(repo);
+      const detect = await runGSDDoctor(repo, { isolationMode: "worktree" });
       const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
       assertTrue(orphanIssues.length > 0, "doctor detects orphaned worktree");
       assertEq(orphanIssues[0]?.unitId, "M001", "orphaned worktree unitId is M001");
 
       // Fix
-      const fixed = await runGSDDoctor(repo, { fix: true });
+      const fixed = await runGSDDoctor(repo, { fix: true, isolationMode: "worktree" });
       assertTrue(
         fixed.fixesApplied.some(f => f.includes("removed orphaned worktree")),
         "doctor fix removes orphaned worktree",