gsd-pi 2.80.0-dev.96f4d89d5 → 2.80.0-dev.a947d025c

package/src/resources/extensions/gsd/tests/flat-rate-routing-guard.test.ts

@@ -6,14 +6,11 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import { buildFlatRateContext, isFlatRateProvider, resolvePreferredModelConfig } from "../auto-model-selection.ts";
 
-const __dirname_4386 = dirname(fileURLToPath(import.meta.url));
-
 describe("flat-rate provider routing guard (#3453)", () => {
 
   test("isFlatRateProvider returns true for github-copilot", () => {
@@ -306,18 +303,3 @@ describe("flat-rate routing opt-in (#4386)", () => {
     );
   });
 });
-
-// ─── Banner transparency: auto-start respects the opt-in (#4386) ────────────
-
-describe("auto-start banner respects allow_flat_rate_providers (#4386)", () => {
-  test("banner expression gates flat-rate disable on allow_flat_rate_providers", () => {
-    const src = readFileSync(
-      join(__dirname_4386, "..", "auto-start.ts"),
-      "utf-8",
-    );
-    assert.ok(
-      src.includes("routingConfig.allow_flat_rate_providers"),
-      "auto-start banner must read allow_flat_rate_providers so the banner reflects the opt-in",
-    );
-  });
-});

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/gsd-db.test.ts

@@ -30,6 +30,10 @@ import {
   insertTask,
   getTask,
   getSliceTasks,
+  deleteMilestone,
+  clearEngineHierarchy,
+  recordMilestoneCommitAttribution,
+  getMilestoneCommitAttributionShas,
   checkpointDatabase,
   refreshOpenDatabaseFromDisk,
   tryCreateMemoriesFts,
@@ -1047,6 +1051,46 @@ describe('gsd-db', () => {
     });
   });
 
+  // ─── milestone_commit_attributions teardown ───────────────────────────────
+
+  describe('milestone commit attribution teardown', () => {
+    test('deleteMilestone removes persisted milestone commit attributions', () => {
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+      recordMilestoneCommitAttribution({
+        commitSha: '0123456789abcdef0123456789abcdef01234567',
+        milestoneId: 'M001',
+        source: 'backfill',
+        confidence: 0.8,
+        files: ['app.js'],
+        createdAt: '2026-05-05T00:00:00.000Z',
+      });
+
+      assert.deepEqual(getMilestoneCommitAttributionShas('M001'), ['0123456789abcdef0123456789abcdef01234567']);
+      deleteMilestone('M001');
+      assert.deepEqual(getMilestoneCommitAttributionShas('M001'), []);
+      closeDatabase();
+    });
+
+    test('clearEngineHierarchy removes persisted milestone commit attributions', () => {
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+      recordMilestoneCommitAttribution({
+        commitSha: 'fedcba9876543210fedcba9876543210fedcba98',
+        milestoneId: 'M001',
+        source: 'backfill',
+        confidence: 0.8,
+        files: ['app.js'],
+        createdAt: '2026-05-05T00:00:00.000Z',
+      });
+
+      assert.deepEqual(getMilestoneCommitAttributionShas('M001'), ['fedcba9876543210fedcba9876543210fedcba98']);
+      clearEngineHierarchy();
+      assert.deepEqual(getMilestoneCommitAttributionShas('M001'), []);
+      closeDatabase();
+    });
+  });
+
   // ─── getDbStatus ───────────────────────────────────────────────────────────
 
   describe('getDbStatus', () => {

package/src/resources/extensions/gsd/tests/has-pending-deep-stage.test.ts

@@ -15,7 +15,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 
-import { hasPendingDeepStage } from "../auto-dispatch.ts";
+import { hasPendingDeepStage, shouldRunDeepProjectSetup } from "../auto-dispatch.ts";
 import type { GSDPreferences } from "../preferences.ts";
 import { loadEffectiveGSDPreferences } from "../preferences.ts";
 
@@ -57,6 +57,38 @@ test("hasPendingDeepStage: returns true in deep mode when nothing has been captu
   }
 });
 
+test("shouldRunDeepProjectSetup: complete state wins over pending deep setup", async () => {
+  const base = makeBase();
+  try {
+    assert.equal(hasPendingDeepStage(deepPrefs, base), true);
+    assert.equal(
+      shouldRunDeepProjectSetup({ phase: "complete" }, deepPrefs, base),
+      false,
+      "completed projects must not restart deep setup and loop through auto-mode",
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("shouldRunDeepProjectSetup: only setup phases can trigger pending deep setup", () => {
+  const base = makeBase();
+  try {
+    assert.equal(hasPendingDeepStage(deepPrefs, base), true);
+    assert.equal(shouldRunDeepProjectSetup({ phase: "pre-planning" }, deepPrefs, base), true);
+    assert.equal(shouldRunDeepProjectSetup({ phase: "needs-discussion" }, deepPrefs, base), true);
+    assert.equal(shouldRunDeepProjectSetup({ phase: "planning" }, deepPrefs, base), true);
+    assert.equal(shouldRunDeepProjectSetup({ phase: "executing" }, deepPrefs, base), false);
+    assert.equal(shouldRunDeepProjectSetup({ phase: "blocked" }, deepPrefs, base), false);
+    assert.equal(
+      shouldRunDeepProjectSetup({ phase: "pre-planning" }, deepPrefs, base, { hasSurvivorBranch: true }),
+      false,
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("hasPendingDeepStage: returns true in deep mode when only some gates pass", () => {
   // workflow-preferences captured but PROJECT.md still missing.
   const base = makeBase();

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,60 @@ 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 });
+  });
+
   // ─── 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",
-  );
-});