gsd-pi 2.57.0 → 2.58.0-dev.778d6ac

package/src/resources/extensions/gsd/tests/guided-flow-dynamic-routing.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Guided-flow dynamic routing — regression test for #2958.
+ *
+ * Verifies that dispatchWorkflow() routes through the dynamic routing pipeline
+ * (selectAndApplyModel from auto-model-selection.ts) instead of bypassing it
+ * with a direct call to resolveModelWithFallbacksForUnit.
+ *
+ * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+ */
+
+import 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 gsdDir = join(__dirname, "..");
+
+function readSrc(file: string): string {
+  return readFileSync(join(gsdDir, file), "utf-8");
+}
+
+const guidedFlowSrc = readSrc("guided-flow.ts");
+
+// ═══════════════════════════════════════════════════════════════════════════
+// #2958: dispatchWorkflow must route through dynamic routing pipeline
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("#2958: guided-flow imports selectAndApplyModel from auto-model-selection", () => {
+  assert.ok(
+    guidedFlowSrc.includes("selectAndApplyModel"),
+    "guided-flow.ts must import and use selectAndApplyModel from auto-model-selection.ts",
+  );
+});
+
+test("#2958: dispatchWorkflow does not call resolveModelWithFallbacksForUnit directly", () => {
+  // Extract the dispatchWorkflow function body
+  const fnStart = guidedFlowSrc.indexOf("async function dispatchWorkflow(");
+  assert.ok(fnStart !== -1, "dispatchWorkflow function not found");
+
+  // Find the function body by tracking brace depth
+  const openBrace = guidedFlowSrc.indexOf("{", fnStart);
+  let depth = 1;
+  let pos = openBrace + 1;
+  while (depth > 0 && pos < guidedFlowSrc.length) {
+    if (guidedFlowSrc[pos] === "{") depth++;
+    else if (guidedFlowSrc[pos] === "}") depth--;
+    pos++;
+  }
+  const fnBody = guidedFlowSrc.slice(openBrace, pos);
+
+  assert.ok(
+    !fnBody.includes("resolveModelWithFallbacksForUnit"),
+    "dispatchWorkflow must NOT call resolveModelWithFallbacksForUnit directly — " +
+    "it must route through selectAndApplyModel for dynamic routing support (#2958)",
+  );
+});
+
+test("#2958: dispatchWorkflow calls selectAndApplyModel for model selection", () => {
+  // Extract the dispatchWorkflow function body
+  const fnStart = guidedFlowSrc.indexOf("async function dispatchWorkflow(");
+  assert.ok(fnStart !== -1, "dispatchWorkflow function not found");
+
+  const openBrace = guidedFlowSrc.indexOf("{", fnStart);
+  let depth = 1;
+  let pos = openBrace + 1;
+  while (depth > 0 && pos < guidedFlowSrc.length) {
+    if (guidedFlowSrc[pos] === "{") depth++;
+    else if (guidedFlowSrc[pos] === "}") depth--;
+    pos++;
+  }
+  const fnBody = guidedFlowSrc.slice(openBrace, pos);
+
+  assert.ok(
+    fnBody.includes("selectAndApplyModel"),
+    "dispatchWorkflow must call selectAndApplyModel to route through the dynamic routing pipeline (#2958)",
+  );
+});
+
+test("#2958: dispatchWorkflow does not use resolveAvailableModel inline", () => {
+  const fnStart = guidedFlowSrc.indexOf("async function dispatchWorkflow(");
+  assert.ok(fnStart !== -1, "dispatchWorkflow function not found");
+
+  const openBrace = guidedFlowSrc.indexOf("{", fnStart);
+  let depth = 1;
+  let pos = openBrace + 1;
+  while (depth > 0 && pos < guidedFlowSrc.length) {
+    if (guidedFlowSrc[pos] === "{") depth++;
+    else if (guidedFlowSrc[pos] === "}") depth--;
+    pos++;
+  }
+  const fnBody = guidedFlowSrc.slice(openBrace, pos);
+
+  assert.ok(
+    !fnBody.includes("resolveAvailableModel"),
+    "dispatchWorkflow must NOT use resolveAvailableModel inline — " +
+    "model resolution is handled by selectAndApplyModel (#2958)",
+  );
+});
+
+test("#2958: guided-flow does not import resolveModelWithFallbacksForUnit", () => {
+  // The import should be removed since dispatchWorkflow was the only consumer
+  // Check if resolveModelWithFallbacksForUnit is still used elsewhere in the file
+  const fnStart = guidedFlowSrc.indexOf("async function dispatchWorkflow(");
+  const beforeDispatch = guidedFlowSrc.slice(0, fnStart);
+  const afterFnEnd = (() => {
+    const openBrace = guidedFlowSrc.indexOf("{", fnStart);
+    let depth = 1;
+    let p = openBrace + 1;
+    while (depth > 0 && p < guidedFlowSrc.length) {
+      if (guidedFlowSrc[p] === "{") depth++;
+      else if (guidedFlowSrc[p] === "}") depth--;
+      p++;
+    }
+    return guidedFlowSrc.slice(p);
+  })();
+
+  // If resolveModelWithFallbacksForUnit is not used outside dispatchWorkflow,
+  // the import should be removed
+  const usedOutside = beforeDispatch.includes("resolveModelWithFallbacksForUnit(")
+    || afterFnEnd.includes("resolveModelWithFallbacksForUnit(");
+
+  if (!usedOutside) {
+    // Verify the import line was cleaned up
+    const importLines = guidedFlowSrc.split("\n").filter(l =>
+      l.includes("import") && l.includes("resolveModelWithFallbacksForUnit"),
+    );
+    assert.equal(
+      importLines.length,
+      0,
+      "resolveModelWithFallbacksForUnit import should be removed when no longer used outside dispatchWorkflow",
+    );
+  }
+});

package/src/resources/extensions/gsd/tests/guided-flow-session-isolation.test.ts

@@ -0,0 +1,97 @@
+/**
+ * Regression test for #2985 Bugs 3 & 4:
+ *   Bug 3 — module-level pendingAutoStart singleton clobbers concurrent sessions.
+ *   Bug 4 — getDiscussionMilestoneId() returns wrong project's milestone under concurrency.
+ *
+ * pendingAutoStart must be keyed by basePath so concurrent discuss sessions
+ * in different projects are independent.  getDiscussionMilestoneId() must accept
+ * a basePath parameter to perform a keyed lookup.
+ */
+
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  getDiscussionMilestoneId,
+  setPendingAutoStart,
+  clearPendingAutoStart,
+} from "../guided-flow.ts";
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+describe("#2985 Bug 3 — concurrent discuss sessions must be independent", () => {
+  beforeEach(() => {
+    clearPendingAutoStart();
+  });
+
+  test("second session does not clobber first session's pending auto-start", () => {
+    // Simulate two concurrent discuss sessions for different projects
+    const projectA = "/projects/alpha";
+    const projectB = "/projects/beta";
+
+    setPendingAutoStart(projectA, {
+      basePath: projectA,
+      milestoneId: "M001-aaa111",
+    });
+
+    setPendingAutoStart(projectB, {
+      basePath: projectB,
+      milestoneId: "M002-bbb222",
+    });
+
+    // Both sessions should be retrievable
+    const milestoneA = getDiscussionMilestoneId(projectA);
+    const milestoneB = getDiscussionMilestoneId(projectB);
+
+    assert.equal(milestoneA, "M001-aaa111", "projectA's milestone should be preserved");
+    assert.equal(milestoneB, "M002-bbb222", "projectB's milestone should be preserved");
+  });
+
+  test("clearing one session does not affect the other", () => {
+    const projectA = "/projects/alpha";
+    const projectB = "/projects/beta";
+
+    setPendingAutoStart(projectA, { basePath: projectA, milestoneId: "M001-aaa111" });
+    setPendingAutoStart(projectB, { basePath: projectB, milestoneId: "M002-bbb222" });
+
+    // Clear only projectA
+    clearPendingAutoStart(projectA);
+
+    assert.equal(getDiscussionMilestoneId(projectA), null, "projectA should be cleared");
+    assert.equal(getDiscussionMilestoneId(projectB), "M002-bbb222", "projectB should survive");
+  });
+});
+
+describe("#2985 Bug 4 — getDiscussionMilestoneId must be keyed by basePath", () => {
+  beforeEach(() => {
+    clearPendingAutoStart();
+  });
+
+  test("getDiscussionMilestoneId(basePath) returns correct milestone for each project", () => {
+    setPendingAutoStart("/proj/a", { basePath: "/proj/a", milestoneId: "M001" });
+    setPendingAutoStart("/proj/b", { basePath: "/proj/b", milestoneId: "M002" });
+
+    assert.equal(getDiscussionMilestoneId("/proj/a"), "M001");
+    assert.equal(getDiscussionMilestoneId("/proj/b"), "M002");
+    assert.equal(getDiscussionMilestoneId("/proj/unknown"), null);
+  });
+
+  test("getDiscussionMilestoneId() without basePath returns null when multiple sessions exist", () => {
+    setPendingAutoStart("/proj/a", { basePath: "/proj/a", milestoneId: "M001" });
+    setPendingAutoStart("/proj/b", { basePath: "/proj/b", milestoneId: "M002" });
+
+    // Without a key, the function should not blindly return the first entry
+    const result = getDiscussionMilestoneId();
+    // When there's ambiguity (multiple sessions), it should return null
+    // to force callers to be explicit
+    assert.equal(result, null, "should not return arbitrary milestone when multiple sessions exist");
+  });
+
+  test("getDiscussionMilestoneId() without basePath returns the milestone when only one session", () => {
+    setPendingAutoStart("/proj/a", { basePath: "/proj/a", milestoneId: "M001" });
+
+    // With only one session, backward compat — return it
+    const result = getDiscussionMilestoneId();
+    assert.equal(result, "M001", "should return the only active milestone for backward compat");
+  });
+});

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

@@ -6,6 +6,7 @@ import { tmpdir } from "node:os";
 import {
   buildHealthLines,
   detectHealthWidgetProjectState,
+  formatRelativeTime,
   type HealthWidgetData,
 } from "../health-widget-core.ts";
 
@@ -34,6 +35,8 @@ function activeData(overrides: Partial<HealthWidgetData> = {}): HealthWidgetData
     providerIssue: null,
     environmentErrorCount: 0,
     environmentWarningCount: 0,
+    lastCommitEpoch: null,
+    lastCommitMessage: null,
     lastRefreshed: Date.now(),
     ...overrides,
   };
@@ -98,6 +101,70 @@ test("buildHealthLines: active state with issues reports issue summary", (t) =>
   assert.match(lines[0]!, /Env: 1 error/);
 });
 
+// ── Last commit display ──────────────────────────────────────────────────
+
+test("buildHealthLines: shows last commit with relative time and message", (t) => {
+  const epoch = Math.floor(Date.now() / 1000) - 300; // 5 minutes ago
+  const lines = buildHealthLines(activeData({
+    lastCommitEpoch: epoch,
+    lastCommitMessage: "feat(widget): add health display",
+  }));
+  assert.equal(lines.length, 1);
+  assert.match(lines[0]!, /Last commit: 5m ago/);
+  assert.match(lines[0]!, /feat\(widget\): add health display/);
+});
+
+test("buildHealthLines: truncates long commit messages", (t) => {
+  const epoch = Math.floor(Date.now() / 1000) - 60;
+  const longMsg = "a".repeat(80);
+  const lines = buildHealthLines(activeData({
+    lastCommitEpoch: epoch,
+    lastCommitMessage: longMsg,
+  }));
+  assert.equal(lines.length, 1);
+  assert.match(lines[0]!, /a{49}…/);
+  assert.ok(!lines[0]!.includes("a".repeat(51)), "message is truncated");
+});
+
+test("buildHealthLines: no last commit section when epoch is null", (t) => {
+  const lines = buildHealthLines(activeData({ lastCommitEpoch: null }));
+  assert.equal(lines.length, 1);
+  assert.ok(!lines[0]!.includes("Last commit"), "no last commit when null");
+});
+
+test("buildHealthLines: last commit without message shows only time", (t) => {
+  const epoch = Math.floor(Date.now() / 1000) - 3600; // 1 hour ago
+  const lines = buildHealthLines(activeData({
+    lastCommitEpoch: epoch,
+    lastCommitMessage: null,
+  }));
+  assert.equal(lines.length, 1);
+  assert.match(lines[0]!, /Last commit: 1h ago/);
+  assert.ok(!lines[0]!.includes(" — "), "no dash separator when no message");
+});
+
+// ── formatRelativeTime ───────────────────────────────────────────────────
+
+test("formatRelativeTime: just now for <60s", () => {
+  const epoch = Math.floor(Date.now() / 1000) - 30;
+  assert.equal(formatRelativeTime(epoch), "just now");
+});
+
+test("formatRelativeTime: minutes", () => {
+  const epoch = Math.floor(Date.now() / 1000) - 300;
+  assert.equal(formatRelativeTime(epoch), "5m ago");
+});
+
+test("formatRelativeTime: hours", () => {
+  const epoch = Math.floor(Date.now() / 1000) - 7200;
+  assert.equal(formatRelativeTime(epoch), "2h ago");
+});
+
+test("formatRelativeTime: days", () => {
+  const epoch = Math.floor(Date.now() / 1000) - 172800;
+  assert.equal(formatRelativeTime(epoch), "2d ago");
+});
+
 test("detectHealthWidgetProjectState: metrics file alone does not imply project", (t) => {
   const dir = makeTempDir("metrics-only");
   t.after(() => { cleanup(dir); });

package/src/resources/extensions/gsd/tests/hook-key-parsing.test.ts

@@ -0,0 +1,107 @@
+import { describe, it } 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 gsdDir = join(__dirname, "..");
+
+/**
+ * Regression tests for #2826: hook/* completed-unit keys were parsed
+ * incorrectly by forensics + doctor, causing false-positive missing-artifact
+ * errors for all hook units.
+ *
+ * The root cause: `key.indexOf("/")` splits "hook/telegram-progress/M007/S01"
+ * into unitType="hook" + unitId="telegram-progress/M007/S01" instead of
+ * unitType="hook/telegram-progress" + unitId="M007/S01".
+ */
+
+describe("splitCompletedKey (#2826)", () => {
+  it("is exported from forensics.ts", () => {
+    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
+    assert.ok(
+      source.includes("export function splitCompletedKey"),
+      "forensics.ts must export splitCompletedKey helper",
+    );
+  });
+
+  it("splits simple unit types correctly", async () => {
+    const { splitCompletedKey } = await import("../forensics.ts");
+    const result = splitCompletedKey("execute-task/M007/S01/T01");
+    assert.deepStrictEqual(result, {
+      unitType: "execute-task",
+      unitId: "M007/S01/T01",
+    });
+  });
+
+  it("splits hook unit types preserving the compound hook/<hookName> prefix", async () => {
+    const { splitCompletedKey } = await import("../forensics.ts");
+    const result = splitCompletedKey("hook/telegram-progress/M007/S01");
+    assert.deepStrictEqual(result, {
+      unitType: "hook/telegram-progress",
+      unitId: "M007/S01",
+    });
+  });
+
+  it("splits hook unit types with task-level unitId", async () => {
+    const { splitCompletedKey } = await import("../forensics.ts");
+    const result = splitCompletedKey("hook/telegram-progress/M007/S02/T01");
+    assert.deepStrictEqual(result, {
+      unitType: "hook/telegram-progress",
+      unitId: "M007/S02/T01",
+    });
+  });
+
+  it("returns null for malformed keys without a slash", async () => {
+    const { splitCompletedKey } = await import("../forensics.ts");
+    assert.strictEqual(splitCompletedKey("noslash"), null);
+  });
+
+  it("returns null for malformed hook keys with only 'hook/' and no more segments", async () => {
+    const { splitCompletedKey } = await import("../forensics.ts");
+    // "hook/someName" has no unitId segment after the hook name
+    assert.strictEqual(splitCompletedKey("hook/someName"), null);
+  });
+});
+
+describe("forensics detectMissingArtifacts uses splitCompletedKey (#2826)", () => {
+  it("does not use indexOf for key splitting", () => {
+    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
+    // Extract only the detectMissingArtifacts function body
+    const fnStart = source.indexOf("function detectMissingArtifacts");
+    assert.ok(fnStart !== -1, "detectMissingArtifacts must exist");
+    const fnBody = source.slice(fnStart, source.indexOf("\n}\n", fnStart) + 3);
+
+    assert.ok(
+      !fnBody.includes('key.indexOf("/")'),
+      "detectMissingArtifacts must not use key.indexOf('/') — use splitCompletedKey instead",
+    );
+    assert.ok(
+      fnBody.includes("splitCompletedKey"),
+      "detectMissingArtifacts must use splitCompletedKey helper",
+    );
+  });
+});
+
+describe("doctor-runtime-checks uses splitCompletedKey (#2826)", () => {
+  it("does not use indexOf for key splitting in orphaned-key check", () => {
+    const source = readFileSync(
+      join(gsdDir, "doctor-runtime-checks.ts"),
+      "utf-8",
+    );
+    // Find the orphaned completed-units section
+    const sectionStart = source.indexOf("Orphaned completed-units");
+    assert.ok(sectionStart !== -1, "orphaned completed-units section must exist");
+    const sectionBody = source.slice(sectionStart, source.indexOf("} catch", sectionStart));
+
+    assert.ok(
+      !sectionBody.includes('key.indexOf("/")'),
+      "doctor orphaned-key check must not use key.indexOf('/') — use splitCompletedKey instead",
+    );
+    assert.ok(
+      sectionBody.includes("splitCompletedKey"),
+      "doctor orphaned-key check must use splitCompletedKey helper",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/integration/auto-recovery.test.ts

@@ -111,7 +111,51 @@ test("resolveExpectedArtifactPath returns correct path for all slice-level types
 
   const uatResult = resolveExpectedArtifactPath("run-uat", "M001/S01", base);
   assert.ok(uatResult);
-  assert.ok(uatResult!.includes("UAT"));
+  assert.ok(uatResult!.includes("ASSESSMENT"));
+});
+
+// ─── run-uat artifact path contract (#2873) ──────────────────────────────
+
+test("resolveExpectedArtifactPath for run-uat returns ASSESSMENT path, not UAT (#2873)", (t) => {
+  // The run-uat prompt instructs the agent to call gsd_summary_save with
+  // artifact_type: "ASSESSMENT", which writes S##-ASSESSMENT.md. The artifact
+  // verification path must match — otherwise verification fails and auto-mode
+  // retries the unit in an infinite loop.
+  const base = makeTmpBase();
+  t.after(() => cleanup(base));
+
+  const result = resolveExpectedArtifactPath("run-uat", "M001/S01", base);
+  assert.ok(result, "run-uat should resolve to a non-null artifact path");
+  assert.ok(
+    result!.endsWith("S01-ASSESSMENT.md"),
+    `run-uat artifact path should end with S01-ASSESSMENT.md, got: ${result}`,
+  );
+});
+
+test("diagnoseExpectedArtifact for run-uat references ASSESSMENT (#2873)", (t) => {
+  const base = makeTmpBase();
+  t.after(() => cleanup(base));
+
+  const diag = diagnoseExpectedArtifact("run-uat", "M001/S01", base);
+  assert.ok(diag, "run-uat should have a diagnostic message");
+  assert.ok(
+    diag!.includes("ASSESSMENT"),
+    `run-uat diagnostic should reference ASSESSMENT, got: ${diag}`,
+  );
+});
+
+test("verifyExpectedArtifact passes for run-uat when ASSESSMENT file exists (#2873)", (t) => {
+  // Regression test: run-uat writes S##-ASSESSMENT.md via gsd_summary_save,
+  // but verification looked for S##-UAT.md, causing false stuck retries.
+  const base = makeTmpBase();
+  t.after(() => cleanup(base));
+
+  // Write the ASSESSMENT file (what gsd_summary_save actually produces)
+  const assessPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-ASSESSMENT.md");
+  writeFileSync(assessPath, "---\nverdict: PASS\n---\n# UAT Assessment\n");
+
+  const verified = verifyExpectedArtifact("run-uat", "M001/S01", base);
+  assert.ok(verified, "verifyExpectedArtifact should pass when ASSESSMENT file exists");
 });
 
 // ─── diagnoseExpectedArtifact ─────────────────────────────────────────────
@@ -697,6 +741,72 @@ test("verifyExpectedArtifact complete-milestone fails with only .gsd/ files (#17
   assert.equal(result, false, "complete-milestone should fail verification when only .gsd/ files present");
 });
 
+// ─── reconcileMergeState: silent nativeCommit failure (#2542) ─────────────
+
+import { reconcileMergeState } from "../../auto-recovery.ts";
+import { chmodSync } from "node:fs";
+
+function makeMockCtx(): { ctx: any; notifications: Array<{ msg: string; level: string }> } {
+  const notifications: Array<{ msg: string; level: string }> = [];
+  const ctx = {
+    ui: {
+      notify(msg: string, level: string) {
+        notifications.push({ msg, level });
+      },
+    },
+  };
+  return { ctx, notifications };
+}
+
+test("reconcileMergeState returns false and notifies error when nativeCommit fails (#2542)", (t) => {
+  const base = makeGitBase();
+  t.after(() => cleanup(base));
+
+  // Create a second branch with a commit, then start a merge on main
+  execFileSync("git", ["checkout", "-b", "feature"], { cwd: base, stdio: "ignore" });
+  writeFileSync(join(base, "feature.txt"), "feature content");
+  execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "add feature"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["checkout", "main"], { cwd: base, stdio: "ignore" });
+
+  // Start merge (no conflicts — fast path with MERGE_HEAD)
+  execFileSync("git", ["merge", "--no-ff", "--no-commit", "feature"], { cwd: base, stdio: "ignore" });
+
+  // Verify MERGE_HEAD exists
+  assert.ok(existsSync(join(base, ".git", "MERGE_HEAD")), "MERGE_HEAD should exist");
+
+  // Make .git/objects read-only so git cannot write the commit object,
+  // causing nativeCommit to throw a non-"nothing to commit" error.
+  const objectsDir = join(base, ".git", "objects");
+  chmodSync(objectsDir, 0o444);
+  t.after(() => { try { chmodSync(objectsDir, 0o755); } catch { /* cleanup */ } });
+
+  const { ctx, notifications } = makeMockCtx();
+  const result = reconcileMergeState(base, ctx);
+
+  // The function should return false to signal reconciliation failure
+  // (Currently it silently swallows the error and returns true — this test should FAIL before the fix)
+  assert.equal(result, false, "reconcileMergeState should return false when nativeCommit fails");
+  const errorNotifications = notifications.filter(n => n.level === "error");
+  assert.ok(errorNotifications.length > 0, "should notify an error when nativeCommit fails");
+  assert.ok(
+    errorNotifications[0].msg.includes("Failed to finalize"),
+    "error notification should describe the commit failure",
+  );
+});
+
+test("reconcileMergeState returns true when no merge state present", (t) => {
+  // When there's no MERGE_HEAD or SQUASH_MSG, reconcileMergeState returns false (no dirty state)
+  const base = makeGitBase();
+  t.after(() => cleanup(base));
+
+  const { ctx, notifications } = makeMockCtx();
+  const result = reconcileMergeState(base, ctx);
+
+  assert.equal(result, false, "should return false when no merge state exists");
+  assert.equal(notifications.length, 0, "should not notify when no merge state present");
+});
+
 test("verifyExpectedArtifact complete-milestone passes with impl files (#1703)", (t) => {
   const base = makeGitBase();
   t.after(() => cleanup(base));

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

@@ -638,6 +638,107 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
       "#1906: codeFilesChanged must be false when only .gsd/ files were merged");
   });
 
+  test("#2912: MERGE_HEAD cleaned up after squash-merge conflict", () => {
+    const repo = freshRepo();
+    const wtPath = createAutoWorktree(repo, "M291");
+
+    // Create a file on main that will conflict with the milestone branch
+    run("git checkout main", repo);
+    writeFileSync(join(repo, "conflict.ts"), "// main version\nexport const x = 1;\n");
+    run("git add .", repo);
+    run("git commit -m 'add conflict.ts on main'", repo);
+
+    // Switch back to milestone branch and create conflicting content
+    run("git checkout milestone/M291", wtPath);
+    writeFileSync(join(wtPath, "conflict.ts"), "// milestone version\nexport const x = 2;\n");
+    run("git add .", wtPath);
+    run("git commit -m 'add conflict.ts on milestone'", wtPath);
+
+    const roadmap = makeRoadmap("M291", "Conflict milestone", [
+      { id: "S01", title: "Conflict test" },
+    ]);
+
+    // The merge should throw MergeConflictError due to conflict.ts
+    let threw = false;
+    try {
+      mergeMilestoneToMain(repo, "M291", roadmap);
+    } catch (err: unknown) {
+      threw = true;
+      // Verify it's a merge conflict error
+      assert.ok(
+        err instanceof Error && err.message.includes("conflict"),
+        "should throw a conflict-related error",
+      );
+    }
+    assert.ok(threw, "mergeMilestoneToMain must throw on code conflict");
+
+    // BUG #2912: MERGE_HEAD must NOT be left on disk after the error
+    const mergeHeadPath = join(repo, ".git", "MERGE_HEAD");
+    assert.ok(
+      !existsSync(mergeHeadPath),
+      "#2912: MERGE_HEAD must be cleaned up after merge conflict error",
+    );
+  });
+
+  test("#2912: stale MERGE_HEAD from native merge is cleaned after successful commit", () => {
+    const repo = freshRepo();
+    const wtPath = createAutoWorktree(repo, "M292");
+
+    addSliceToMilestone(repo, wtPath, "M292", "S01", "Feature A", [
+      { file: "feature-a.ts", content: "export const a = true;\n", message: "add feature a" },
+    ]);
+
+    const roadmap = makeRoadmap("M292", "Clean merge", [
+      { id: "S01", title: "Feature A" },
+    ]);
+
+    // Simulate what libgit2's merge implementation does: it creates MERGE_HEAD
+    // even for squash merges (unlike CLI git). We plant MERGE_HEAD before calling
+    // mergeMilestoneToMain to verify the success path cleans it up.
+    // We cannot plant it before the call because the function manages checkout
+    // internally, so instead we verify after the call.
+    mergeMilestoneToMain(repo, "M292", roadmap);
+
+    // After successful merge+commit, MERGE_HEAD must not linger
+    const mergeHeadPath = join(repo, ".git", "MERGE_HEAD");
+    assert.ok(
+      !existsSync(mergeHeadPath),
+      "#2912: MERGE_HEAD must be cleaned up after successful merge",
+    );
+  });
+
+  test("#2912: planted MERGE_HEAD is cleaned up in success path", () => {
+    // This test directly verifies the cleanup code handles a MERGE_HEAD file
+    // left by the native (libgit2) merge path. We hook into the merge by
+    // planting MERGE_HEAD right after nativeMergeSquash would create it.
+    const repo = freshRepo();
+    const wtPath = createAutoWorktree(repo, "M293");
+
+    addSliceToMilestone(repo, wtPath, "M293", "S01", "Feature B", [
+      { file: "feature-b.ts", content: "export const b = true;\n", message: "add feature b" },
+    ]);
+
+    const roadmap = makeRoadmap("M293", "Planted MERGE_HEAD", [
+      { id: "S01", title: "Feature B" },
+    ]);
+
+    // Plant a fake MERGE_HEAD in the git dir to simulate libgit2 behavior.
+    // We need to do this after the function checks out main but before it
+    // commits. Since we can't intercept mid-function, we plant it before
+    // the call. If the function cleans it up, the test passes.
+    const gitDir = join(repo, ".git");
+    const fakeHead = run("git rev-parse HEAD", repo);
+    writeFileSync(join(gitDir, "MERGE_HEAD"), fakeHead + "\n");
+
+    mergeMilestoneToMain(repo, "M293", roadmap);
+
+    // The planted MERGE_HEAD must be cleaned up
+    assert.ok(
+      !existsSync(join(gitDir, "MERGE_HEAD")),
+      "#2912: planted MERGE_HEAD must be removed by success-path cleanup",
+    );
+  });
+
   test("#1906: codeFilesChanged=true when real code is merged", () => {
     const repo = freshRepo();
     const wtPath = createAutoWorktree(repo, "M190");