gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/frontmatter-parse-noise.test.ts

@@ -7,36 +7,28 @@
 
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const prefsSrc = readFileSync(
-  join(__dirname, '..', 'preferences.ts'),
-  'utf-8',
-);
+import { _resetParseWarningFlag, parsePreferencesMarkdown } from "../preferences.ts";
+import { drainLogs } from "../workflow-logger.ts";
 
 describe('frontmatter parse noise suppression (#3693)', () => {
-  test('_warnedFrontmatterParse flag is defined', () => {
-    assert.match(prefsSrc, /_warnedFrontmatterParse/,
-      '_warnedFrontmatterParse flag should exist in preferences.ts');
-  });
+  test('invalid frontmatter emits one warning per reset', () => {
+    _resetParseWarningFlag();
+    drainLogs();
 
-  test('parseFrontmatterBlock function exists', () => {
-    assert.match(prefsSrc, /function parseFrontmatterBlock\(/,
-      'parseFrontmatterBlock function should be defined');
-  });
+    const invalidPrefs = [
+      "---",
+      "models: [unterminated",
+      "---",
+    ].join("\n");
 
-  test('flag is checked before warning', () => {
-    assert.match(prefsSrc, /if\s*\(\s*!_warnedFrontmatterParse\s*\)/,
-      'should check !_warnedFrontmatterParse before logging');
-  });
+    assert.deepEqual(parsePreferencesMarkdown(invalidPrefs), {});
+    assert.deepEqual(parsePreferencesMarkdown(invalidPrefs), {});
 
-  test('flag is set to true after first warning', () => {
-    assert.match(prefsSrc, /_warnedFrontmatterParse\s*=\s*true/,
-      'should set _warnedFrontmatterParse = true after warning');
+    const warnings = drainLogs().filter((entry) =>
+      entry.severity === "warn" &&
+      entry.component === "guided" &&
+      entry.message.includes("YAML parse error in preferences frontmatter")
+    );
+    assert.equal(warnings.length, 1);
   });
 });

package/src/resources/extensions/gsd/tests/header-renderer.test.ts

@@ -0,0 +1,40 @@
+// Project/App: GSD-2
+// File Purpose: Visual contract tests for the GSD watch header renderer.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { stripVTControlCharacters } from "node:util";
+import { renderHeaderLines } from "../watch/header-renderer.ts";
+import { splashPalette } from "../watch/splash-palette.ts";
+
+function rgbPattern(hex: string): RegExp {
+  const cleaned = hex.replace("#", "");
+  const r = Number.parseInt(cleaned.slice(0, 2), 16);
+  const g = Number.parseInt(cleaned.slice(2, 4), 16);
+  const b = Number.parseInt(cleaned.slice(4, 6), 16);
+  return new RegExp(`\\x1b\\[38;2;${r};${g};${b}m`);
+}
+
+test("renderHeaderLines uses the command-center splash layout", () => {
+  const lines = renderHeaderLines(
+    {
+      model: "claude-sonnet-4-6",
+      provider: "anthropic",
+      directory: "~/Github/gsd-2",
+      branch: "feat/tui-refresh",
+      mcpServers: ["context7"],
+    },
+    120,
+  );
+
+  const raw = lines.join("\n");
+  const plain = stripVTControlCharacters(raw);
+
+  assert.match(raw, rgbPattern(splashPalette.border), "logo and divider should use the recommended olive border");
+  assert.match(raw, rgbPattern(splashPalette.accent), "header accents should use the recommended blue");
+  assert.match(plain, /Project Console/);
+  assert.match(plain, /\/gsd start/);
+  assert.match(plain, /\/gsd templates/);
+  assert.match(plain, /claude-sonnet-4-6/);
+  assert.match(plain, /Context7 ✓/);
+});

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

@@ -85,6 +85,11 @@ describe("headless milestone bootstrap — parity with interactive flow", () =>
       /Do not announce the ready phrase as something you are "about to" do/.test(section),
       "single-milestone pre-condition must include the 'do not announce intent' guard",
     );
+    assert.ok(/Next steps:/.test(section), "single-milestone handoff must include next steps");
+    assert.ok(/\/gsd auto/.test(section), "single-milestone handoff must mention /gsd auto");
+    assert.ok(/\/gsd status/.test(section), "single-milestone handoff must mention /gsd status");
+    assert.ok(/\/gsd visualize/.test(section), "single-milestone handoff must mention /gsd visualize");
+    assert.ok(/\/gsd notifications/.test(section), "single-milestone handoff must mention /gsd notifications");
   });
 
   test("discuss-headless multi-milestone pre-condition uses the non-bypassable checkbox format", () => {
@@ -113,5 +118,10 @@ describe("headless milestone bootstrap — parity with interactive flow", () =>
       /gates_completed === total/.test(multiSection),
       "multi-milestone pre-condition must still enforce gates_completed === total",
     );
+    assert.ok(/Next steps:/.test(multiSection), "multi-milestone handoff must include next steps");
+    assert.ok(/\/gsd auto/.test(multiSection), "multi-milestone handoff must mention /gsd auto");
+    assert.ok(/\/gsd status/.test(multiSection), "multi-milestone handoff must mention /gsd status");
+    assert.ok(/\/gsd visualize/.test(multiSection), "multi-milestone handoff must mention /gsd visualize");
+    assert.ok(/\/gsd notifications/.test(multiSection), "multi-milestone handoff must mention /gsd notifications");
   });
 });

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

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Tests for the GSD health widget state and footer hint rendering.
+
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
@@ -9,6 +12,7 @@ import {
   formatRelativeTime,
   type HealthWidgetData,
 } from "../health-widget-core.ts";
+import { HEALTH_WIDGET_ACTIVE_HINTS } from "../health-widget.ts";
 import { registerHooks } from "../bootstrap/register-hooks.ts";
 
 function makeTempDir(prefix: string): string {
@@ -75,13 +79,11 @@ test("buildHealthLines: none state shows single onboarding line pointing at /gsd
   assert.match(lines[0]!, /\/gsd/);
 });
 
-test("buildHealthLines: initialized state shows single setup line pointing at /gsd", (t) => {
+test("buildHealthLines: initialized state shows concise initialized line", (t) => {
   const lines = buildHealthLines(activeData({ projectState: "initialized" }));
   assert.equal(lines.length, 1, "renders exactly one line");
   assert.ok(!/System OK|Budget|Last commit/.test(lines[0]!), "no active-project chrome");
-  // Distinct from "none" — must mention initialized/setup language and /gsd.
-  assert.match(lines[0]!, /\/gsd/);
-  assert.match(lines[0]!, /initiali[sz]ed|setup/i);
+  assert.equal(lines[0], "  GSD  Project Initialized");
 });
 
 test("buildHealthLines: active state with ledger-driven spend shows spent summary", (t) => {
@@ -91,6 +93,14 @@ test("buildHealthLines: active state with ledger-driven spend shows spent summar
   assert.match(lines[0]!, /Spent: 42\.0¢/);
 });
 
+test("health widget active hints include visualization and notifications", () => {
+  assert.match(HEALTH_WIDGET_ACTIVE_HINTS, /\/gsd auto to run/);
+  assert.match(HEALTH_WIDGET_ACTIVE_HINTS, /\/gsd status for overview/);
+  assert.match(HEALTH_WIDGET_ACTIVE_HINTS, /\/gsd visualize to inspect/);
+  assert.match(HEALTH_WIDGET_ACTIVE_HINTS, /\/gsd notifications for history/);
+  assert.match(HEALTH_WIDGET_ACTIVE_HINTS, /\/gsd help/);
+});
+
 test("buildHealthLines: active state with budget ceiling shows percent summary", (t) => {
   const lines = buildHealthLines(activeData({ budgetSpent: 2.5, budgetCeiling: 10 }));
   assert.equal(lines.length, 1);

package/src/resources/extensions/gsd/tests/init-skip-git.test.ts

@@ -1,19 +1,16 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 
-const initWizardSource = readFileSync(join(import.meta.dirname, "..", "init-wizard.ts"), "utf8");
-const guidedFlowSource = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf8");
+import { shouldWriteGitFiles } from "../init-wizard.ts";
+import { shouldSkipGitBootstrapAfterInit } from "../guided-flow.ts";
 
-test("init wizard returns gitEnabled false when git setup is skipped", () => {
-	assert.match(initWizardSource, /gitEnabled = signals\.isGitRepo/);
-	assert.match(initWizardSource, /return \{ completed: true, bootstrapped: true, gitEnabled \}/);
-	assert.match(initWizardSource, /if \(gitEnabled\) \{\s*ensureGitignore\(basePath\);/);
+test("init wizard does not write git files when git setup is skipped", () => {
+	assert.equal(shouldWriteGitFiles(false), false);
+	assert.equal(shouldWriteGitFiles(true), true);
 });
 
-test("guided flow does not initialize git after the init wizard skip-git choice", () => {
-	assert.match(guidedFlowSource, /skipGitBootstrap = result\.gitEnabled === false/);
-	assert.match(guidedFlowSource, /if \(!skipGitBootstrap && \(!nativeIsRepo\(basePath\) \|\| isInheritedRepo\(basePath\)\)\)/);
-	assert.match(guidedFlowSource, /if \(!skipGitBootstrap && nativeIsRepo\(basePath\)\) \{\s*ensureGitignore\(basePath\);/);
+test("guided flow skips git bootstrap after the init wizard skip-git choice", () => {
+	assert.equal(shouldSkipGitBootstrapAfterInit({ gitEnabled: false }), true);
+	assert.equal(shouldSkipGitBootstrapAfterInit({ gitEnabled: true }), false);
+	assert.equal(shouldSkipGitBootstrapAfterInit({}), false);
 });

package/src/resources/extensions/gsd/tests/integration/auto-worktree-milestone-merge.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Auto-worktree milestone squash-merge integration tests.
 /**
  * auto-worktree-milestone-merge.test.ts — Integration tests for mergeMilestoneToMain.
  *
@@ -25,6 +27,13 @@ import {
 import { getSliceBranchName } from "../../worktree.ts";
 import { nativeMergeSquash } from "../../native-git-bridge.ts";
 import { drainLogs, setStderrLoggingEnabled } from "../../workflow-logger.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../../gsd-db.ts";
 
 function run(cmd: string, cwd: string): string {
   // Safe: all inputs are hardcoded test strings, not user input
@@ -117,6 +126,7 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
 
   afterEach(() => {
     process.chdir(savedCwd);
+    closeDatabase();
     for (const d of tempDirs) {
       if (existsSync(d)) rmSync(d, { recursive: true, force: true });
     }
@@ -179,6 +189,24 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
     addSliceToMilestone(repo, wtPath, "M020", "S03", "Logging infra", [
       { file: "logger.ts", content: "export const log = () => {};\n", message: "add logger" },
     ]);
+    openDatabase(":memory:");
+    insertMilestone({ id: "M020", title: "M020: Backend foundation", status: "complete" });
+    for (const slice of [
+      { id: "S01", title: "Core API", tasks: [{ id: "T01", title: "Create API router" }] },
+      { id: "S02", title: "Error handling", tasks: [{ id: "T02", title: "Handle API errors" }] },
+      { id: "S03", title: "Logging infra", tasks: [{ id: "T03", title: "Wire request logging" }] },
+    ]) {
+      insertSlice({ id: slice.id, milestoneId: "M020", title: slice.title, status: "complete" });
+      for (const task of slice.tasks) {
+        insertTask({
+          id: task.id,
+          sliceId: slice.id,
+          milestoneId: "M020",
+          title: task.title,
+          status: "complete",
+        });
+      }
+    }
 
     const roadmap = makeRoadmap("M020", "Backend foundation", [
       { id: "S01", title: "Core API" },
@@ -193,13 +221,20 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
     assert.ok(result.commitMessage.includes("- S01: Core API"), "body lists S01");
     assert.ok(result.commitMessage.includes("- S02: Error handling"), "body lists S02");
     assert.ok(result.commitMessage.includes("- S03: Logging infra"), "body lists S03");
+    assert.ok(result.commitMessage.includes("Completed tasks:"), "body lists completed tasks");
+    assert.ok(result.commitMessage.includes("- S01/T01: Create API router"), "body lists S01 task");
+    assert.ok(result.commitMessage.includes("- S02/T02: Handle API errors"), "body lists S02 task");
+    assert.ok(result.commitMessage.includes("Milestone: M020 - Backend foundation"), "body has human milestone context");
     assert.ok(result.commitMessage.includes("GSD-Milestone: M020"), "body has GSD-Milestone trailer");
     assert.ok(result.commitMessage.includes("Branch: milestone/M020"), "body has branch metadata");
+    assert.ok(!result.commitMessage.includes("auto-commit after complete-milestone"), "body avoids generic complete-milestone fallback");
+    assert.ok(!result.commitMessage.includes("GSD-Unit:"), "body avoids generic unit trailer");
 
     const gitMsg = run("git log -1 --format=%B main", repo).trim();
     assert.match(gitMsg, /^feat:/, "git commit message starts with feat:");
     assert.ok(gitMsg.includes("GSD-Milestone: M020"), "git commit has GSD-Milestone trailer");
     assert.ok(gitMsg.includes("- S01: Core API"), "git commit body has S01");
+    assert.ok(gitMsg.includes("- S03/T03: Wire request logging"), "git commit body has task names");
   });
 
   test("nothing to commit — safe when no code changes (#1738, #1792)", () => {
@@ -780,6 +815,11 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
       !existsSync(mergeHeadPath),
       "#2912: MERGE_HEAD must be cleaned up after merge conflict error",
     );
+    assert.equal(
+      run("git diff --name-only --diff-filter=U", repo),
+      "",
+      "squash conflict cleanup must clear unmerged index entries",
+    );
   });
 
   test("#2912: stale MERGE_HEAD from native merge is cleaned after successful commit", () => {

package/src/resources/extensions/gsd/tests/integration/commands-eval-review.integration.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Integration tests for the /gsd eval-review helper chain.
 /**
  * Integration test for `/gsd eval-review` .
  *
@@ -10,7 +12,7 @@
 
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -119,7 +121,7 @@ describe("integration: /gsd eval-review helper chain on a real on-disk slice", (
     );
     assert.equal(ctx.truncated, false);
     assert.equal(ctx.sliceId, "S07");
-    assert.equal(ctx.outputPath, evalReviewWritePath(layout.sliceDir, "S07"));
+    assert.equal(ctx.outputPath, evalReviewWritePath(realpathSync(layout.sliceDir), "S07"));
 
     const prompt = buildEvalReviewPrompt(ctx);
 

package/src/resources/extensions/gsd/tests/integration/git-locale.test.ts

@@ -7,13 +7,13 @@ import assert from 'node:assert/strict';
  * English output, and that nativeMergeSquash passes the env to execFileSync.
  */
 
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
 import { GIT_NO_PROMPT_ENV } from "../../git-constants.ts";
-import { nativeAddAllWithExclusions } from "../../native-git-bridge.ts";
+import { nativeAddAllWithExclusions, nativeMergeSquash } from "../../native-git-bridge.ts";
 import { RUNTIME_EXCLUSION_PATHS } from "../../git-service.ts";
 function git(cwd: string, ...args: string[]): string {
   return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
@@ -97,23 +97,34 @@ describe('git-locale', async () => {
 
   // ─── nativeMergeSquash: env is passed (merge-squash stderr is English) ─
 
-  test('nativeMergeSquash fallback uses GIT_NO_PROMPT_ENV', () => {
-    // We verify indirectly: the source code must pass env: GIT_NO_PROMPT_ENV.
-    // Read the source and check for the pattern. This is a static check.
-    const src = readFileSync(
-      join(import.meta.dirname, "../..", "native-git-bridge.ts"),
-      "utf-8"
-    );
-
-    // Find the nativeMergeSquash function and check it uses GIT_NO_PROMPT_ENV
-    const fnStart = src.indexOf("export function nativeMergeSquash");
-    assert.ok(fnStart !== -1, "nativeMergeSquash function exists in source");
-
-    const fnBody = src.slice(fnStart, src.indexOf("\nexport function", fnStart + 1));
-    const hasEnv = fnBody.includes("env: GIT_NO_PROMPT_ENV");
-    assert.ok(
-      hasEnv,
-      "nativeMergeSquash fallback must pass env: GIT_NO_PROMPT_ENV to execFileSync (#1997)"
-    );
+  test('nativeMergeSquash succeeds under non-English locale env', () => {
+    const repo = initTempRepo();
+    try {
+      const mainBranch = git(repo, "branch", "--show-current");
+      git(repo, "checkout", "-b", "feature");
+      createFile(repo, "src/feature.ts", "export const feature = true;");
+      git(repo, "add", "-A");
+      git(repo, "commit", "-m", "feat: add feature");
+      git(repo, "checkout", mainBranch);
+
+      const origLcAll = process.env.LC_ALL;
+      const origLang = process.env.LANG;
+      process.env.LANG = "de_DE.UTF-8";
+      delete process.env.LC_ALL;
+      try {
+        const result = nativeMergeSquash(repo, "feature");
+        assert.equal(result.success, true);
+      } finally {
+        if (origLcAll !== undefined) process.env.LC_ALL = origLcAll;
+        else delete process.env.LC_ALL;
+        if (origLang !== undefined) process.env.LANG = origLang;
+        else delete process.env.LANG;
+      }
+
+      const staged = git(repo, "diff", "--cached", "--name-only");
+      assert.ok(staged.includes("src/feature.ts"));
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+    }
   });
 });

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Git service integration and commit-message tests.
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, symlinkSync, readFileSync } from "node:fs";
@@ -211,7 +213,12 @@ describe('git-service', async () => {
   test('buildTaskCommitMessage', () => {
     const msg = buildTaskCommitMessage({
       taskId: "S01/T02",
+      taskDisplayId: "T02",
       taskTitle: "implement user authentication",
+      milestoneId: "M001",
+      milestoneTitle: "User management",
+      sliceId: "S01",
+      sliceTitle: "Authentication",
       oneLiner: "Added JWT-based auth with refresh token rotation",
       keyFiles: ["src/auth.ts", "src/middleware/jwt.ts"],
     });
@@ -220,7 +227,12 @@ describe('git-service', async () => {
     assert.ok(msg.includes("JWT-based auth"), "message includes one-liner content");
     assert.ok(msg.includes("- src/auth.ts"), "message body includes key files");
     assert.ok(msg.includes("- src/middleware/jwt.ts"), "message body includes second key file");
+    assert.ok(msg.includes("GSD context:"), "message includes human GSD context block");
+    assert.ok(msg.includes("- Milestone: M001 - User management"), "message includes milestone name");
+    assert.ok(msg.includes("- Slice: S01 - Authentication"), "message includes slice name");
+    assert.ok(msg.includes("- Task: T02 - implement user authentication"), "message includes task name");
     assert.ok(msg.includes("GSD-Task: S01/T02"), "GSD-Task trailer in body");
+    assert.ok(!msg.includes("chore: auto-commit after execute-task"), "message does not use generic fallback");
   });
 
   test('buildTaskCommitMessage sanitizes subject text', () => {
@@ -542,6 +554,86 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  // Regression: #5500. The LLM occasionally hallucinates files in
+  // task.keyFiles that were never written. Pre-existing scoped-stage code
+  // ran `git add -- <every keyFile>` and failed the entire commit on the
+  // first missing path. Verify that valid paths still commit and missing
+  // ones are dropped silently.
+  test('GitServiceImpl: scoped staging drops missing keyFiles and commits the rest', () => {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    createFile(repo, "src/index.ts", "export const ok = true;");
+    // Note: src/commands/list.ts is intentionally NOT created — the LLM
+    // claimed it wrote this file but didn't.
+
+    const msg = svc.autoCommit("execute-task", "M001/S01/T02", [], {
+      taskId: "S01/T02",
+      taskTitle: "wire up command list",
+      oneLiner: "Added list command stub",
+      keyFiles: ["src/index.ts", "src/commands/list.ts"],
+    });
+    assert.ok(msg !== null, "autoCommit succeeds when at least one keyFile exists");
+
+    const committed = run("git show --name-only --format= HEAD", repo);
+    assert.ok(committed.includes("src/index.ts"), "existing key file is committed");
+    assert.ok(!committed.includes("src/commands/list.ts"), "missing key file is silently dropped");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  // Regression: #5500. When ALL keyFiles are bogus, scopedStageTaskFiles
+  // must return false so autoCommit falls back to smartStage. The commit
+  // still goes out (using `git add -A` semantics) instead of failing.
+  test('GitServiceImpl: all missing keyFiles falls back to smartStage', () => {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    createFile(repo, "src/actually-changed.ts", "export const real = true;");
+
+    const msg = svc.autoCommit("execute-task", "M001/S01/T03", [], {
+      taskId: "S01/T03",
+      taskTitle: "fix path handling",
+      oneLiner: "Hardened path resolution",
+      keyFiles: ["src/wrong/path-1.ts", "src/wrong/path-2.ts"],
+    });
+    assert.ok(msg !== null, "autoCommit falls back to smartStage when all keyFiles are missing");
+
+    const committed = run("git show --name-only --format= HEAD", repo);
+    assert.ok(
+      committed.includes("src/actually-changed.ts"),
+      "smartStage fallback stages real dirty files when scoped staging finds nothing",
+    );
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test('GitServiceImpl: task context keyFiles ignores gitignored build outputs', () => {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    createFile(repo, ".gitignore", "dist/\n");
+    runGit(repo, ["add", ".gitignore"]);
+    runGit(repo, ["commit", "-F", "-"], { input: "ignore dist" });
+
+    createFile(repo, "src/task.ts", "export const task = true;");
+    createFile(repo, "dist/task.js", "export const task = true;");
+
+    const msg = svc.autoCommit("execute-task", "M001/S01/T01", [], {
+      taskId: "S01/T01",
+      taskTitle: "implement scoped task",
+      oneLiner: "Added scoped task implementation",
+      keyFiles: ["src/task.ts", "dist/task.js"],
+    });
+    assert.ok(msg !== null, "autoCommit should commit non-ignored key files");
+
+    const committed = run("git show --name-only --format= HEAD", repo);
+    assert.ok(committed.includes("src/task.ts"), "non-ignored key file is committed");
+    assert.ok(!committed.includes("dist/task.js"), "ignored build output is not committed");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   // ─── GitServiceImpl: empty-after-staging guard ─────────────────────────
 
   test('GitServiceImpl: empty-after-staging guard', () => {

package/src/resources/extensions/gsd/tests/integration/milestone-transition-worktree.test.ts

@@ -4,8 +4,6 @@
  * Verifies that when auto-mode transitions between milestones, the
  * worktree lifecycle is handled: old worktree merged, new worktree created.
  *
- * Uses source-level checks since the full auto-mode dispatch loop
- * requires the @gsd/pi-coding-agent runtime.
  */
 
 import test from "node:test";
@@ -119,48 +117,3 @@ test("worktree swap on milestone transition: merge old, create new", () => {
     }
   }
 });
-
-// ─── Verify the transition code path exists in auto.ts ──────────────────────
-
-test("auto/phases.ts milestone transition block contains worktree lifecycle", () => {
-  const phasesSrc = readFileSync(
-    join(__dirname, "../..", "auto", "phases.ts"),
-    "utf-8",
-  );
-
-  // The resolver handles worktree merge + enter inside the milestone transition block
-  assert.ok(
-    phasesSrc.includes("Worktree lifecycle on milestone transition"),
-    "auto/phases.ts should contain the worktree lifecycle comment marker",
-  );
-  assert.ok(
-    phasesSrc.includes("resolver.mergeAndExit") && phasesSrc.includes("mid !== s.currentMilestoneId"),
-    "auto/phases.ts should call resolver.mergeAndExit during milestone transition",
-  );
-  assert.ok(
-    phasesSrc.includes("resolver.enterMilestone"),
-    "auto/phases.ts should call resolver.enterMilestone for incoming milestone",
-  );
-});
-
-// ─── Verify worktree-resolver mergeAndExit preserves branch on missing roadmap (#1573) ──
-
-test("worktree-resolver mergeAndExit preserves branch when roadmap is missing (#1573)", () => {
-  const resolverSrc = readFileSync(
-    join(__dirname, "../..", "worktree-resolver.ts"),
-    "utf-8",
-  );
-
-  // The fallback teardown must pass preserveBranch: true to prevent orphaning commits
-  assert.ok(
-    resolverSrc.includes("preserveBranch: true"),
-    "worktree-resolver.ts should pass preserveBranch: true in the no-roadmap fallback",
-  );
-
-  // The worktree path should be tried as a fallback for roadmap resolution
-  assert.ok(
-    resolverSrc.includes("this.s.basePath !== originalBase") ||
-      resolverSrc.includes("roadmap-fallback"),
-    "worktree-resolver.ts should try resolving roadmap from worktree path as fallback",
-  );
-});