gsd-pi 2.80.0-dev.3065f7bfa → 2.80.0-dev.488219eb6

package/src/resources/extensions/gsd/tests/dispatcher-stuck-planning.test.ts

@@ -6,32 +6,50 @@
  * planning/import APIs.
  */
 
-import { describe, test } from "node:test";
+import { afterEach, beforeEach, describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "state.ts");
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
+import { deriveStateFromDb, invalidateStateCache } from "../state.ts";
 
 describe("dispatcher DB-authoritative planning boundary", () => {
-  const source = readFileSync(sourceFile, "utf-8");
+  let base: string;
 
-  test("does not import insertTask into state derivation", () => {
-    assert.doesNotMatch(source, /import\s*\{[^}]*insertTask[^}]*\}\s*from/);
+  beforeEach(() => {
+    base = mkdtempSync(join(tmpdir(), "gsd-dispatcher-planning-"));
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "S01"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "CONTEXT.md"), "# M001\n");
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "ROADMAP.md"), [
+      "## Slices",
+      "- [ ] **S01: Build** `risk:low` `depends:[]`",
+    ].join("\n"));
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "S01", "PLAN.md"), [
+      "## Tasks",
+      "- [ ] **T01: Projection-only task**",
+    ].join("\n"));
+    openDatabase(join(base, ".gsd", "gsd.db"));
   });
 
-  test("does not contain plan-file task reconciliation block", () => {
-    assert.doesNotMatch(source, /dbTaskIds\.has\(t\.id\)/);
-    assert.match(source, /Slice \$\{activeSlice\.id\} has no DB tasks/);
+  afterEach(() => {
+    closeDatabase();
+    invalidateStateCache();
+    rmSync(base, { recursive: true, force: true });
   });
 
-  test("does not call insertTask from state derivation", () => {
-    assert.doesNotMatch(source, /insertTask\(\{/);
-  });
+  test("PLAN.md projection tasks are not imported into runtime DB state", async () => {
+    insertMilestone({ id: "M001", title: "Milestone 1", status: "active", depends_on: [] });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Build", status: "active", depends: [] });
+
+    const state = await deriveStateFromDb(base);
 
-  test("documents markdown projections as non-authoritative", () => {
-    assert.match(source, /Markdown files are projections only/);
+    assert.equal(state.phase, "planning");
+    assert.equal(state.activeTask, null);
+    assert.match(
+      state.nextAction ?? "",
+      /Slice S01 has no DB tasks\. Plan slice tasks before execution\./,
+    );
   });
 });

package/src/resources/extensions/gsd/tests/error-success-mask.test.ts

@@ -8,30 +8,25 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "bootstrap", "agent-end-recovery.ts");
+import { resolveAgentEndErrorDisplay } from "../bootstrap/agent-end-recovery.ts";
 
 describe("error-success mask detection (#3664)", () => {
-  const source = readFileSync(sourceFile, "utf-8");
-
-  test("detects useless errorMessage values with regex", () => {
-    assert.match(source, /success\|ok\|true\|error\|unknown/i);
-  });
-
-  test("extracts display message from content text block", () => {
-    assert.match(source, /textBlock/);
-    assert.match(source, /\.text\.slice\(0,\s*300\)/);
-  });
-
-  test("classifies using rawErrorMsg, not displayMsg", () => {
-    assert.match(source, /classifyError\(rawErrorMsg/);
+  test("falls back to assistant text when errorMessage is uninformative", () => {
+    assert.equal(
+      resolveAgentEndErrorDisplay("success", [
+        { type: "tool_use", name: "noop" },
+        { type: "text", text: "provider failed with a useful message" },
+      ]),
+      "provider failed with a useful message",
+    );
   });
 
-  test("references issue #3588 in comments", () => {
-    assert.match(source, /#3588/);
+  test("keeps informative raw error messages", () => {
+    assert.equal(
+      resolveAgentEndErrorDisplay("rate limit exceeded", [
+        { type: "text", text: "prose should not replace useful raw error" },
+      ]),
+      "rate limit exceeded",
+    );
   });
 });

package/src/resources/extensions/gsd/tests/est-annotation-timeout.test.ts

@@ -8,46 +8,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-const timersSrcPath = join(import.meta.dirname, "..", "auto-timers.ts");
-const timersSrc = readFileSync(timersSrcPath, "utf-8");
-
-// ─── Source analysis: parseEstimateMinutes exists and is exported ────────────
-
-test("#2243: auto-timers.ts should export parseEstimateMinutes", () => {
-  assert.ok(
-    timersSrc.includes("export function parseEstimateMinutes"),
-    "parseEstimateMinutes should be exported from auto-timers.ts",
-  );
-});
-
-// ─── Inline unit test of parseEstimateMinutes logic ─────────────────────────
-// Since importing the module pulls in heavy deps, test the parsing logic inline.
-
-function parseEstimateMinutes(estimate: string): number | null {
-  if (!estimate || typeof estimate !== "string") return null;
-  const trimmed = estimate.trim();
-  if (!trimmed) return null;
-
-  let totalMinutes = 0;
-  let matched = false;
-
-  const hoursMatch = trimmed.match(/(\d+)\s*h/i);
-  if (hoursMatch) {
-    totalMinutes += Number(hoursMatch[1]) * 60;
-    matched = true;
-  }
-
-  const minutesMatch = trimmed.match(/(\d+)\s*m/i);
-  if (minutesMatch) {
-    totalMinutes += Number(minutesMatch[1]);
-    matched = true;
-  }
-
-  return matched ? totalMinutes : null;
-}
+import { parseEstimateMinutes, resolveUnitSupervisionTimeouts } from "../auto-timers.ts";
 
 test("#2243: parseEstimateMinutes parses '30m' correctly", () => {
   assert.equal(parseEstimateMinutes("30m"), 30);
@@ -73,48 +34,20 @@ test("#2243: parseEstimateMinutes returns null for invalid string", () => {
   assert.equal(parseEstimateMinutes("not a time"), null);
 });
 
-// ─── Source analysis: startUnitSupervision uses task estimates ───────────────
-
-test("#2243: startUnitSupervision should reference task estimates for timeout scaling", () => {
-  const usesEstimate =
-    timersSrc.includes("parseEstimateMinutes") &&
-    timersSrc.includes("estimateMinutes") &&
-    timersSrc.includes("taskEstimate");
-
-  assert.ok(
-    usesEstimate,
-    "startUnitSupervision should use task estimate annotations for timeout scaling",
+test("#2243: estimate scale affects soft and hard timeouts but not idle timeout", () => {
+  const result = resolveUnitSupervisionTimeouts(
+    "execute-task",
+    {
+      soft_timeout_minutes: 10,
+      idle_timeout_minutes: 5,
+      hard_timeout_minutes: 20,
+    },
+    3,
   );
-});
-
-test("#2243: SupervisionContext should accept an optional taskEstimate field", () => {
-  const ctxIdx = timersSrc.indexOf("SupervisionContext");
-  assert.ok(ctxIdx !== -1, "SupervisionContext interface exists");
 
-  const ctxEnd = timersSrc.indexOf("}", ctxIdx);
-  const ctxBlock = timersSrc.slice(ctxIdx, ctxEnd);
-
-  assert.ok(
-    ctxBlock.includes("taskEstimate"),
-    "SupervisionContext should include a taskEstimate field",
-  );
-});
-
-test("#2243: timeouts should be scaled by estimate (timeoutScale in source)", () => {
-  assert.ok(
-    timersSrc.includes("timeoutScale"),
-    "auto-timers.ts should use a timeoutScale factor derived from est: annotations",
-  );
-});
-
-test("#2243: idle timeout should NOT be scaled (idle is idle regardless of estimate)", () => {
-  // Find the idleTimeoutMs line
-  const idleIdx = timersSrc.indexOf("const idleTimeoutMs");
-  assert.ok(idleIdx !== -1, "idleTimeoutMs variable exists");
-  
-  const idleLine = timersSrc.slice(idleIdx, timersSrc.indexOf("\n", idleIdx));
-  assert.ok(
-    !idleLine.includes("timeoutScale"),
-    "idleTimeoutMs should NOT be scaled — idle is idle",
-  );
+  assert.deepEqual(result, {
+    softTimeoutMs: 30 * 60 * 1000,
+    idleTimeoutMs: 5 * 60 * 1000,
+    hardTimeoutMs: 60 * 60 * 1000,
+  });
 });

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/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', () => {

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",
-  );
-});