@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.844675c9

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -21,6 +21,14 @@ function runGit(args: string[], cwd: string): void {
   });
 }
 
+function renderOutcomeWidget(widget: unknown): string {
+  const component = (widget as any)(
+    { requestRender() {} },
+    { fg: (_color: string, text: string) => text, bold: (text: string) => text },
+  );
+  return component.render(100).join("\n");
+}
+
 test("cleanupAfterLoopExit preserves paused auto badge after provider pause", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-paused-cleanup-"));
   const previousCwd = process.cwd();
@@ -167,13 +175,17 @@ test("cleanupAfterLoopExit preserves completion closeout surface after stopAuto
       false,
       "completion cleanup must not replace the closeout surface with a generic outcome card",
     );
-    assert.equal(autoSession.completionStopInProgress, false);
+    assert.equal(
+      autoSession.completionStopInProgress,
+      true,
+      "completion closeout preservation must survive post-loop cleanup until the next agent turn",
+    );
   } finally {
     autoSession.reset();
   }
 });
 
-test("cleanupAfterLoopExit clears completionStopInProgress even when preserveStepSurfaceAfterLoopExit is also set", async () => {
+test("cleanupAfterLoopExit preserves completionStopInProgress even when preserveStepSurfaceAfterLoopExit is also set", async () => {
   const statusCalls: unknown[] = [];
   const widgetCalls: unknown[] = [];
 
@@ -196,8 +208,8 @@ test("cleanupAfterLoopExit clears completionStopInProgress even when preserveSte
 
     assert.equal(
       autoSession.completionStopInProgress,
-      false,
-      "completionStopInProgress must be cleared even when preserveStepSurfaceAfterLoopExit was also set",
+      true,
+      "completionStopInProgress must survive cleanup even when preserveStepSurfaceAfterLoopExit was also set",
     );
     assert.equal(autoSession.preserveStepSurfaceAfterLoopExit, false);
   } finally {
@@ -641,6 +653,10 @@ test("stopAuto foreground completion closeout reroots session and preserves the
       false,
       "foreground completion stop must not install a replacement roll-up widget over the transcript",
     );
+    assert.ok(
+      widgetCalls.some(([key, value]) => key === "gsd-progress" && value === undefined),
+      "foreground completion stop must clear stale progress controls in the rerooted session",
+    );
     assert.ok(
       notifications.every(message => !message.includes("/gsd auto to resume")),
       "completion stop notification must not tell users to resume a finished auto run",
@@ -649,10 +665,15 @@ test("stopAuto foreground completion closeout reroots session and preserves the
       notifications.every(message => !message.includes("Auto-mode stopped") && !message.includes("Session:") && !message.includes("Debug log written")),
       "completion stop must not append generic stop/session/debug notifications after the report",
     );
-    assert.ok(
-      widgetCalls.every(([key, value]) => key !== "gsd-outcome" || value === undefined),
-      "foreground completion stop must not replace the transcript with a generic outcome card",
+    const outcome = widgetCalls.find(([key, value]) => key === "gsd-outcome" && typeof value === "function")?.[1];
+    assert.equal(
+      typeof outcome,
+      "function",
+      "foreground completion stop must install a durable closeout outcome in the rerooted session",
     );
+    const rendered = renderOutcomeWidget(outcome);
+    assert.match(rendered, /Milestone M003 complete/);
+    assert.match(rendered, /Review the closeout/);
 
     const widgetCallCountBeforePostLoopCleanup = widgetCalls.length;
     await cleanupAfterLoopExit(ctx);
@@ -822,7 +843,7 @@ test("stopAuto closeout-transcript preservation suppresses generic stop widgets"
   }
 });
 
-test("stopAuto foreground all-complete closeout preserves the transcript surface", async () => {
+test("stopAuto foreground all-complete closeout installs a durable terminal outcome", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-all-complete-closeout-"));
   const previousCwd = process.cwd();
   const widgetCalls: Array<[string, unknown]> = [];
@@ -875,8 +896,15 @@ test("stopAuto foreground all-complete closeout preserves the transcript surface
       false,
       "foreground all-complete closeout must not replace the visible transcript with a roll-up widget",
     );
-    const finalOutcome = widgetCalls.filter(([key]) => key === "gsd-outcome").at(-1);
-    assert.equal(finalOutcome?.[1], undefined, "foreground all-complete closeout must not add an outcome replacement");
+    const finalOutcome = widgetCalls.filter(([key]) => key === "gsd-outcome").at(-1)?.[1];
+    assert.equal(
+      typeof finalOutcome,
+      "function",
+      "foreground all-complete closeout must install a durable terminal outcome",
+    );
+    const rendered = renderOutcomeWidget(finalOutcome);
+    assert.match(rendered, /All milestones complete/);
+    assert.match(rendered, /start new work/);
   } finally {
     try { closeDatabase(); } catch { /* noop */ }
     autoSession.reset();

package/src/resources/extensions/gsd/tests/debug-logger.test.ts

@@ -115,6 +115,21 @@ test('debugCount increments counters', () => {
   assert.strictEqual(summary.dispatches, 5);
 });
 
+test('debugCount tracks gitInvocations and writeDebugSummary reports it', () => {
+  const tmp = createTempGsdDir();
+  enableDebug(tmp);
+
+  debugCount('gitInvocations');
+  debugCount('gitInvocations', 13);
+
+  const logPath = writeDebugSummary()!;
+  const lines = readLogLines(logPath);
+
+  const summary = lines.find(l => l.event === 'debug-summary') as any;
+  assert.ok(summary, 'should have debug-summary event');
+  assert.strictEqual(summary.gitInvocations, 14);
+});
+
 test('debugPeak tracks max values', () => {
   const tmp = createTempGsdDir();
   enableDebug(tmp);

package/src/resources/extensions/gsd/tests/execute-summary-save-empty-project.test.ts

@@ -6,7 +6,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { openDatabase, closeDatabase, getAllMilestones } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, getAllMilestones, getArtifact } from "../gsd-db.ts";
+import { parseProject } from "../schemas/parsers.ts";
 import { markApprovalGateVerified, clearDiscussionFlowState } from "../bootstrap/write-gate.ts";
 import { executeSummarySave } from "../tools/workflow-tool-executors.ts";
 
@@ -107,3 +108,65 @@ test("executeSummarySave registers milestones when PROJECT.md uses canonical em-
   assert.deepEqual(result.details.registeredMilestones, ["M001", "M002"]);
   assert.equal(getAllMilestones().length, 2);
 });
+
+test("executeSummarySave self-heals the Milestone Sequence when DB already has milestones but content parses zero", async (t) => {
+  const base = setupBase(t);
+
+  // 1) First save registers M001 as complete; DB now holds the milestone with
+  //    authoritative status.
+  const canonical = [
+    "# Project",
+    "",
+    "## Milestone Sequence",
+    "",
+    "<!-- Check off milestones as they complete. -->",
+    "",
+    "- [x] M001: Foo — bar",
+    "",
+  ].join("\n");
+  await inProjectDir(base, () => executeSummarySave({ artifact_type: "PROJECT", content: canonical }, base));
+  assert.equal(getAllMilestones().length, 1);
+
+  // 2) A completion re-save reflows the sequence with an en-dash separator the
+  //    canonical parser rejects → zero parseable lines, but the DB is intact.
+  //    (A trailing non-bullet section prevents MILESTONE_LINE_RE from bridging
+  //    onto a later bullet.) The checkbox here is deliberately WRONG (unchecked)
+  //    to prove the rebuild takes status from the DB, not the malformed content.
+  const malformed = [
+    "# Project",
+    "",
+    "## Milestone Sequence",
+    "",
+    "<!-- Check off milestones as they complete. -->",
+    "",
+    "- [ ] M001: Foo – shipped bar", // en-dash U+2013, not accepted by MILESTONE_LINE_RE
+    "",
+    "## Notes",
+    "",
+    "Trailing prose with no list bullets.",
+    "",
+  ].join("\n");
+
+  const result = await inProjectDir(base, () => executeSummarySave({ artifact_type: "PROJECT", content: malformed }, base));
+
+  // Non-fatal: the save succeeds and reports the self-heal.
+  assert.notEqual(result.isError, true);
+  assert.equal(result.details.milestoneSequenceSelfHealed, true);
+  assert.deepEqual(result.details.registeredMilestones, ["M001"]);
+  assert.equal(getAllMilestones().length, 1);
+
+  // The persisted PROJECT.md now parses canonically and preserves status + prose.
+  const persisted = getArtifact("PROJECT.md");
+  assert.ok(persisted);
+  const parsed = parseProject(persisted!.full_content);
+  assert.equal(parsed.milestones.length, 1);
+  const m001 = parsed.milestones.find(m => m.id === "M001");
+  assert.ok(m001);
+  // Status comes from the DB (M001 complete), not the unchecked box in the
+  // malformed content.
+  assert.equal(m001!.done, true);
+  assert.equal(m001!.title, "Foo");
+  assert.match(m001!.oneLiner, /shipped bar/);
+  // The HTML comment hint survives the rebuild.
+  assert.match(persisted!.full_content, /Check off milestones as they complete/);
+});

package/src/resources/extensions/gsd/tests/integration/merge-strategy-regular.test.ts

@@ -0,0 +1,157 @@
+// Integration regression for #549: merge_strategy: merge is not respected.
+//
+// mergeMilestoneToMain always called nativeMergeSquash regardless of the
+// git.merge_strategy preference. When a user set `merge_strategy: merge`
+// (to respect a global `merge.ff = false`), the squash path still ran.
+//
+// Fix (#549): an `effectiveStrategy` variable selects nativeMergeRegular
+// (--no-ff --no-commit) when merge_strategy === "merge", leaving MERGE_HEAD
+// so nativeCommit produces a real merge commit with two parents.
+//
+// These tests verify:
+//   1. merge_strategy: merge → merge commit topology (two parents on main).
+//   2. No merge_strategy set → squash commit topology (one parent on main).
+//   3. Error messages reference the correct strategy label ("Merge" vs
+//      "Squash merge") so users are not misled when a conflict or dirty-tree
+//      error occurs under the merge strategy.
+
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { createAutoWorktree, mergeMilestoneToMain } from "../../auto-worktree.ts";
+import { closeDatabase } from "../../gsd-db.ts";
+import { getSliceBranchName } from "../../worktree.ts";
+
+function run(cmd: string, cwd: string): string {
+  // Safe: all inputs are hardcoded test strings, not user input
+  return execSync(cmd, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "merge-strategy-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  run("git config core.autocrlf false", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  writeFileSync(join(dir, ".gsd", "STATE.md"), "# State\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+  return dir;
+}
+
+function makeRoadmap(milestoneId: string, title: string): string {
+  return `# ${milestoneId}: ${title}\n\n## Slices\n- [x] **S01: Feature**\n`;
+}
+
+function addSliceToMilestone(
+  repo: string,
+  wtPath: string,
+  milestoneId: string,
+  sliceId: string,
+  sliceTitle: string,
+  fileName: string,
+): void {
+  const normalizedPath = wtPath.replaceAll("\\", "/");
+  const marker = "/.gsd/worktrees/";
+  const idx = normalizedPath.indexOf(marker);
+  const worktreeName =
+    idx !== -1 ? normalizedPath.slice(idx + marker.length).split("/")[0] : null;
+
+  const sliceBranch = getSliceBranchName(milestoneId, sliceId, worktreeName);
+
+  run(`git checkout -b ${sliceBranch}`, wtPath);
+  writeFileSync(join(wtPath, fileName), `export const feature = true;\n`);
+  run("git add .", wtPath);
+  run(`git commit -m "feat: ${sliceTitle}"`, wtPath);
+  run(`git checkout milestone/${milestoneId}`, wtPath);
+  run(
+    `git merge --no-ff ${sliceBranch} -m "feat(${milestoneId}/${sliceId}): ${sliceTitle}"`,
+    wtPath,
+  );
+  run(`git branch -d ${sliceBranch}`, wtPath);
+}
+
+/** Number of parents of the most recent commit on a branch. */
+function parentCount(repo: string, branch: string): number {
+  const parents = run(`git log -1 --format=%P ${branch}`, repo);
+  return parents.trim() === "" ? 0 : parents.trim().split(/\s+/).length;
+}
+
+describe("mergeMilestoneToMain merge_strategy dispatch (#549)", { timeout: 300_000 }, () => {
+  const savedCwd = process.cwd();
+  const tempDirs: string[] = [];
+
+  function freshRepo(): string {
+    const d = createTempRepo();
+    tempDirs.push(d);
+    return d;
+  }
+
+  afterEach(() => {
+    process.chdir(savedCwd);
+    closeDatabase();
+    for (const d of tempDirs) {
+      if (existsSync(d)) rmSync(d, { recursive: true, force: true });
+    }
+    tempDirs.length = 0;
+  });
+
+  test("#549: merge_strategy: merge produces a true merge commit with two parents", () => {
+    const repo = freshRepo();
+
+    // Write project preferences with merge_strategy: merge
+    writeFileSync(
+      join(repo, ".gsd", "PREFERENCES.md"),
+      "---\nversion: 1\ngit:\n  merge_strategy: merge\n---\n",
+    );
+
+    const wtPath = createAutoWorktree(repo, "M549");
+    addSliceToMilestone(repo, wtPath, "M549", "S01", "Feature A", "feature-a.ts");
+
+    const roadmap = makeRoadmap("M549", "Merge strategy milestone");
+    mergeMilestoneToMain(repo, "M549", roadmap);
+
+    assert.equal(
+      parentCount(repo, "main"),
+      2,
+      "merge_strategy: merge must produce a true merge commit with 2 parents on main",
+    );
+    assert.ok(existsSync(join(repo, "feature-a.ts")), "feature-a.ts present on main");
+  });
+
+  test("default (no merge_strategy): squash commit has one parent on main", () => {
+    const repo = freshRepo();
+    // No PREFERENCES.md — default squash path
+
+    const wtPath = createAutoWorktree(repo, "M550");
+    addSliceToMilestone(repo, wtPath, "M550", "S01", "Feature B", "feature-b.ts");
+
+    const roadmap = makeRoadmap("M550", "Squash strategy milestone");
+    mergeMilestoneToMain(repo, "M550", roadmap);
+
+    assert.equal(
+      parentCount(repo, "main"),
+      1,
+      "default (squash) must produce a single-parent commit on main",
+    );
+    assert.ok(existsSync(join(repo, "feature-b.ts")), "feature-b.ts present on main");
+  });
+});

package/src/resources/extensions/gsd/tests/markdown-renderer-parse-cache.test.ts

@@ -0,0 +1,75 @@
+// Project/App: gsd-pi
+// File Purpose: Performance-contract test for the detectStaleRenders file-identity
+// parse cache (#442 Phase 1.5). Asserts the observable contract: an unchanged
+// projection is NOT re-parsed on the next dispatch (cache hit), while a changed
+// projection IS re-parsed (cache miss on path+mtime+size). Modeled on the
+// prepared-statement caching contract test in db-adapter.test.ts — it asserts
+// external behavior (parse happened / did not), never internal wiring.
+
+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 { openDatabase, closeDatabase, insertMilestone, insertSlice } from "../gsd-db.ts";
+import { clearParseCache } from "../files.ts";
+import { clearPathCache } from "../paths.ts";
+import { invalidateStateCache } from "../state.ts";
+import { detectStaleRenders } from "../markdown-renderer.ts";
+import { enableDebug, disableDebug, getDebugCounters } from "../debug-logger.ts";
+
+function roadmapMd(slices: Array<{ id: string; title: string; done: boolean }>): string {
+  const lines = ["# M001 Roadmap", "", "**Vision:** cache contract", "", "## Slices", ""];
+  for (const s of slices) lines.push(`- ${s.done ? "[x]" : "[ ]"} **${s.id}: ${s.title}** \`risk:medium\` \`depends:[]\``);
+  lines.push("");
+  return lines.join("\n");
+}
+
+test("#442: detectStaleRenders re-parses ROADMAP only when it changes on disk", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-parse-cache-"));
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  const roadmapPath = join(milestoneDir, "M001-ROADMAP.md");
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    disableDebug();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Cache", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "active", risk: "medium", depends: [], sequence: 1 });
+
+  // Start from a cold cache so counts are attributable to this test.
+  clearParseCache();
+  clearPathCache();
+  invalidateStateCache();
+
+  writeFileSync(roadmapPath, roadmapMd([{ id: "S01", title: "Slice", done: false }]));
+
+  enableDebug(base); // resets counters
+
+  // First dispatch: cold cache → the roadmap is read + parsed.
+  detectStaleRenders(base);
+  const afterCold = getDebugCounters().parseRoadmapCalls;
+  assert.ok(afterCold > 0, "cold dispatch must parse the roadmap");
+
+  // Second dispatch, file unchanged: cache hit → NO new parse.
+  detectStaleRenders(base);
+  const afterWarm = getDebugCounters().parseRoadmapCalls;
+  assert.equal(afterWarm, afterCold, "unchanged projection must not be re-parsed");
+
+  // Change the file (different content AND size) WITHOUT clearing caches:
+  // the path+mtime+size identity changes, forcing a re-parse.
+  writeFileSync(
+    roadmapPath,
+    roadmapMd([
+      { id: "S01", title: "Slice", done: true },
+      { id: "S02", title: "Added Slice", done: false },
+    ]),
+  );
+  detectStaleRenders(base);
+  const afterChange = getDebugCounters().parseRoadmapCalls;
+  assert.ok(afterChange > afterWarm, "a changed projection must be re-parsed");
+});

package/src/resources/extensions/gsd/tests/native-merge-regular.test.ts

@@ -0,0 +1,139 @@
+// Regression tests for nativeMergeRegular (#549 — merge_strategy: merge).
+//
+// nativeMergeRegular is the new `git merge --no-ff --no-commit` path called
+// when `git.merge_strategy: merge` is configured. These tests verify:
+//   1. Success path: returns { success: true, conflicts: [] } and leaves MERGE_HEAD
+//      so nativeCommit can supply the commit message and git records two parents.
+//   2. Dirty-tree path: returns __dirty_working_tree__ sentinel (matching
+//      nativeMergeSquash behaviour) when uncommitted changes would be overwritten.
+//   3. Content-conflict path: returns the conflicted file names (not the dirty-tree
+//      sentinel) when both branches modified the same region of a file.
+
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  existsSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { nativeMergeRegular } from "../native-git-bridge.ts";
+
+function git(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function makeRepo(prefix: string): string {
+  const dir = mkdtempSync(join(tmpdir(), prefix));
+  git(dir, "init");
+  git(dir, "config", "user.email", "test@test.com");
+  git(dir, "config", "user.name", "Test");
+  git(dir, "config", "core.autocrlf", "false");
+  writeFileSync(join(dir, "README.md"), "# init\n");
+  git(dir, "add", "-A");
+  git(dir, "commit", "-m", "init");
+  git(dir, "branch", "-M", "main");
+  return dir;
+}
+
+describe("nativeMergeRegular (#549)", () => {
+  const tempDirs: string[] = [];
+
+  function freshRepo(prefix: string = "nmr-"): string {
+    const d = makeRepo(prefix);
+    tempDirs.push(d);
+    return d;
+  }
+
+  afterEach(() => {
+    for (const d of tempDirs) {
+      try {
+        git(d, "merge", "--abort");
+      } catch {
+        // no merge in progress — that is fine
+      }
+      if (existsSync(d)) rmSync(d, { recursive: true, force: true });
+    }
+    tempDirs.length = 0;
+  });
+
+  test("success: returns { success: true, conflicts: [] } and sets MERGE_HEAD", () => {
+    const repo = freshRepo("nmr-success-");
+    git(repo, "checkout", "-b", "feature");
+    writeFileSync(join(repo, "feature.ts"), "export const a = 1;\n");
+    git(repo, "add", "feature.ts");
+    git(repo, "commit", "-m", "add feature");
+    git(repo, "checkout", "main");
+
+    const result = nativeMergeRegular(repo, "feature");
+
+    assert.equal(result.success, true);
+    assert.deepEqual(result.conflicts, []);
+    // --no-commit leaves MERGE_HEAD; nativeCommit sees it and creates two parents.
+    assert.ok(
+      existsSync(join(repo, ".git", "MERGE_HEAD")),
+      "MERGE_HEAD must exist after --no-ff --no-commit so the caller commits a true merge",
+    );
+  });
+
+  test("dirty working tree: returns __dirty_working_tree__ sentinel", () => {
+    const repo = freshRepo("nmr-dirty-");
+
+    // feature branch introduces feature.ts
+    git(repo, "checkout", "-b", "feature");
+    writeFileSync(join(repo, "feature.ts"), "export const x = 1;\n");
+    git(repo, "add", "feature.ts");
+    git(repo, "commit", "-m", "add feature");
+    git(repo, "checkout", "main");
+
+    // dirty uncommitted local file that the merge would overwrite
+    writeFileSync(join(repo, "feature.ts"), "// local dirty version\n");
+
+    const result = nativeMergeRegular(repo, "feature");
+
+    assert.equal(result.success, false);
+    assert.ok(
+      result.conflicts.includes("__dirty_working_tree__"),
+      `expected __dirty_working_tree__ sentinel, got: ${JSON.stringify(result.conflicts)}`,
+    );
+  });
+
+  test("content conflict: returns conflicted file names, not dirty-tree sentinel", () => {
+    const repo = freshRepo("nmr-conflict-");
+
+    // Diverging history: both main and feature modify the same file region.
+    writeFileSync(join(repo, "shared.ts"), "// base\nexport const v = 0;\n");
+    git(repo, "add", "shared.ts");
+    git(repo, "commit", "-m", "base version");
+
+    git(repo, "checkout", "-b", "feature");
+    writeFileSync(join(repo, "shared.ts"), "// feature version\nexport const v = 2;\n");
+    git(repo, "add", "shared.ts");
+    git(repo, "commit", "-m", "feature changes shared");
+
+    git(repo, "checkout", "main");
+    writeFileSync(join(repo, "shared.ts"), "// main version\nexport const v = 1;\n");
+    git(repo, "add", "shared.ts");
+    git(repo, "commit", "-m", "main changes shared");
+
+    const result = nativeMergeRegular(repo, "feature");
+
+    assert.equal(result.success, false);
+    assert.ok(
+      result.conflicts.includes("shared.ts"),
+      `expected shared.ts in conflicts, got: ${JSON.stringify(result.conflicts)}`,
+    );
+    assert.ok(
+      !result.conflicts.includes("__dirty_working_tree__"),
+      "content conflict must not be misclassified as dirty-tree",
+    );
+  });
+});