import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";

// Mock external dependencies
vi.mock("../pi.js", () => ({
  createFnAgent: vi.fn(),
  describeModel: vi.fn(() => "mock-provider/mock-model"),
  promptWithFallback: vi.fn(async (session, prompt, options) => {
    if (options === undefined) {
      await session.prompt(prompt);
    } else {
      await session.prompt(prompt, options);
    }
  }),
  compactSessionContext: vi.fn(),
}));

// Route async `exec` through the `execSync` mock so existing tests that set up
// mockedExecSync.mockImplementation for verification commands (vitest run,
// pnpm build, etc.) keep working unchanged. `promisify(exec)` in merger.ts
// resolves/rejects based on the callback wired here.
vi.mock("node:child_process", async () => {
  const { promisify } = await import("node:util");
  const { EventEmitter } = await import("node:events");
  const execSyncFn = vi.fn();
  const spawnFn = vi.fn((cmd: string, opts?: any) => {
    const child = new EventEmitter() as any;
    child.stdout = new EventEmitter();
    child.stderr = new EventEmitter();
    child.pid = 12345;
    child.exitCode = null;
    child.signalCode = null;
    child.kill = vi.fn();
    queueMicrotask(() => {
      try {
        const out = execSyncFn(cmd, opts);
        const stdout = out === undefined ? "" : out.toString();
        if (stdout) child.stdout.emit("data", Buffer.from(stdout));
        child.exitCode = 0;
        child.emit("close", 0, null);
      } catch (err) {
        const error = err as { stdout?: string; stderr?: string; status?: number; code?: number };
        const stdout = error?.stdout?.toString?.() ?? "";
        const stderr = error?.stderr?.toString?.() ?? "";
        if (stdout) child.stdout.emit("data", Buffer.from(stdout));
        if (stderr) child.stderr.emit("data", Buffer.from(stderr));
        child.exitCode = error.status ?? error.code ?? 1;
        child.emit("close", child.exitCode, null);
      }
    });
    return child;
  });
  const execFn: any = vi.fn((cmd: any, opts: any, cb: any) => {
    const callback = typeof opts === "function" ? opts : cb;
    try {
      const out = execSyncFn(cmd, { stdio: ["pipe", "pipe", "pipe"] });
      const stdout = out === undefined ? "" : out.toString();
      if (typeof callback === "function") callback(null, stdout, "");
    } catch (err: any) {
      if (typeof callback === "function") {
        callback(err, err?.stdout?.toString?.() ?? "", err?.stderr?.toString?.() ?? "");
      }
    }
  });
  // Mirror real child_process.exec: promisify resolves to { stdout, stderr }.
  execFn[promisify.custom] = (cmd: any, opts?: any) =>
    new Promise((resolve, reject) => {
      execFn(cmd, opts, (err: any, stdout: any, stderr: any) => {
        if (err) {
          err.stdout = stdout;
          err.stderr = stderr;
          reject(err);
        } else {
          resolve({ stdout, stderr });
        }
      });
    });

  // execFile(file, args, opts, cb) — reassemble a shell-equivalent command and
  // delegate to execSyncFn so the same mock infrastructure handles both exec and execFile.
  const execFileFn: any = vi.fn((file: any, args: any, opts: any, cb: any) => {
    // Normalize overloads: (file, args, cb) or (file, args, opts, cb)
    const callback = typeof opts === "function" ? opts : cb;
    const options = typeof opts === "function" ? {} : opts;
    const cmd = [file, ...(Array.isArray(args) ? args : [])].join(" ");
    try {
      const out = execSyncFn(cmd, { stdio: ["pipe", "pipe", "pipe"], ...options });
      const stdout = out === undefined ? "" : out.toString();
      if (typeof callback === "function") callback(null, stdout, "");
    } catch (err: any) {
      if (typeof callback === "function") {
        callback(err, err?.stdout?.toString?.() ?? "", err?.stderr?.toString?.() ?? "");
      }
    }
  });
  execFileFn[promisify.custom] = (file: any, args?: any, opts?: any) =>
    new Promise((resolve, reject) => {
      execFileFn(file, args, opts, (err: any, stdout: any, stderr: any) => {
        if (err) {
          err.stdout = stdout;
          err.stderr = stderr;
          reject(err);
        } else {
          resolve({ stdout, stderr });
        }
      });
    });

  return { execSync: execSyncFn, exec: execFn, execFile: execFileFn, spawn: spawnFn };
});

vi.mock("node:fs", () => ({
  existsSync: vi.fn().mockReturnValue(true),
  readFileSync: vi.fn(),
}));

vi.mock("../rate-limit-retry.js", () => ({
  withRateLimitRetry: (fn: () => Promise<any>) => fn(),
}));

vi.mock("../context-limit-detector.js", () => ({
  isContextLimitError: vi.fn(),
}));

import {
  aiMergeTask,
  pushToRemoteAfterMerge,
  findWorktreeUser,
  detectResolvableConflicts,
  autoResolveFile,
  resolveConflicts,
  classifyConflict,
  getConflictedFiles,
  isTrivialWhitespaceConflict,
  resolveWithOurs,
  resolveWithTheirs,
  resolveTrivialWhitespace,
  LOCKFILE_PATTERNS,
  GENERATED_PATTERNS,
  parseDiffStat,
  extractFileScope,
  validateDiffScope,
  shouldSyncDependenciesForMerge,
  summarizeVerificationOutput,
  inferDefaultTestCommand,
  resolveTaskDiffBaseRef,
  MergeAbortedError,
  type ConflictCategory,
} from "../merger.js";
import { mergerLog } from "../logger.js";
import { createFnAgent } from "../pi.js";
import { execSync, exec } from "node:child_process";
import * as core from "@fusion/core";
import { type TaskStore, type Task, type MergeResult, DEFAULT_SETTINGS } from "@fusion/core";

const mockedCreateFnAgent = vi.mocked(createFnAgent);
const mockedExecSync = vi.mocked(execSync);
const mockedExec = vi.mocked(exec);
const { existsSync: mockedExistsSyncRaw, readFileSync: mockedReadFileSyncRaw } = await import("node:fs");
const mockedExistsSync = vi.mocked(mockedExistsSyncRaw);
const mockedReadFileSync = vi.mocked(mockedReadFileSyncRaw);

function createMockStore(taskOverrides: Partial<Task> = {}, allTasks: Task[] = []) {
  const baseTask: Task = {
    id: "FN-050",
    title: "Test task",
    description: "Test",
    column: "in-review",
    dependencies: [],
    worktree: "/tmp/root/.worktrees/KB-050",
    steps: [],
    currentStep: 0,
    log: [],
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
    ...taskOverrides,
  };

  return {
    getTask: vi.fn().mockResolvedValue({ ...baseTask, prompt: "# test" }),
    listTasks: vi.fn().mockResolvedValue(allTasks),
    updateTask: vi.fn().mockResolvedValue(baseTask),
    moveTask: vi.fn().mockResolvedValue(baseTask),
    logEntry: vi.fn().mockResolvedValue(undefined),
    appendAgentLog: vi.fn().mockResolvedValue(undefined),
    updateSettings: vi.fn().mockResolvedValue({}),
    getSettings: vi.fn().mockResolvedValue({ ...DEFAULT_SETTINGS }),
    getActiveMergingTask: vi.fn().mockReturnValue(null),
    emit: vi.fn(),
    on: vi.fn(),
    clearStaleExecutionStartBranchReferences: vi.fn().mockReturnValue([]),
    getVerificationCacheHit: vi.fn().mockReturnValue(null),
    recordVerificationCachePass: vi.fn(),
  } as unknown as TaskStore;
}

/**
 * Set up execSync to handle the standard merge flow:
 * rev-parse, log, diff, merge --squash, diff --cached --quiet (squash check),
 * diff --cached (post-agent verify), branch -d
 *
 * Both `-X ours` and `-X theirs` final-fallback merges return success — the
 * default settings strategy is "smart-prefer-main" (-X ours), but a few tests
 * still exercise -X theirs explicitly via `mergeConflictStrategy: "smart-prefer-branch"`.
 *
 * For tests that want the merge to fail after 3 attempts, call
 * setupFailingFallbackStrategy() instead.
 */
function setupHappyPathExecSync() {
  mockedExecSync.mockImplementation((cmd: any) => {
    const cmdStr = String(cmd);
    if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
    if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
    if (cmdStr.includes("git log")) return "- feat: something" as any;
    if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
    if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
    if (cmdStr.includes("merge --squash")) return Buffer.from("");
    if (cmdStr.includes("merge -X theirs --squash") || cmdStr.includes("merge -X ours --squash")) {
      return Buffer.from("");
    }
    // Post-squash check: --quiet means "did squash stage anything?" → "1" = yes
    if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
    // Post-agent check: "did agent commit?" → "0" = yes
    if (cmdStr.includes("diff --cached")) return "0" as any;
    if (cmdStr.includes("show --shortstat")) return "3 files changed, 10 insertions(+), 2 deletions(-)" as any;
    if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
    if (cmdStr.includes("worktree remove")) return Buffer.from("");
    return Buffer.from("");
  });
}

/**
 * Same as setupHappyPathExecSync but makes the final fallback merge fail
 * (both `-X theirs` and `-X ours`). Use this for tests that expect the merge
 * to throw after 3 attempts fail.
 */
function setupFailingFallbackStrategy() {
  mockedExecSync.mockImplementation((cmd: any) => {
    const cmdStr = String(cmd);
    if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
    if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
    if (cmdStr.includes("git log")) return "- feat: something" as any;
    if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
    if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
    if (cmdStr.includes("merge --squash")) return Buffer.from("");
    // -X theirs / -X ours should fail for these tests (they expect merge to throw)
    if (cmdStr.includes("merge -X theirs --squash") || cmdStr.includes("merge -X ours --squash")) {
      const err = new Error("fatal: git merge -X fallback failed with unresolved conflicts");
      err.name = "ExecSyncError";
      throw err;
    }
    // Post-squash check: --quiet means "did squash stage anything?" → "1" = yes
    if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
    // Post-agent check: "did agent commit?" → "0" = yes
    if (cmdStr.includes("diff --cached")) return "0" as any;
    if (cmdStr.includes("show --shortstat")) return "3 files changed, 10 insertions(+), 2 deletions(-)" as any;
    if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
    if (cmdStr.includes("worktree remove")) return Buffer.from("");
    return Buffer.from("");
  });
}

/** @deprecated Renamed to setupFailingFallbackStrategy. */
const setupFailingTheirsStrategy = setupFailingFallbackStrategy;

describe("findWorktreeUser", () => {
  it("returns null when no other task uses the worktree", async () => {
    const store = createMockStore({}, [
      { id: "FN-050", worktree: "/tmp/wt", column: "done" } as Task,
    ]);
    const result = await findWorktreeUser(store, "/tmp/wt", "FN-050");
    expect(result).toBeNull();
  });

  it("returns task ID when another non-done task uses the worktree", async () => {
    const store = createMockStore({}, [
      { id: "FN-050", worktree: "/tmp/wt", column: "done" } as Task,
      { id: "FN-051", worktree: "/tmp/wt", column: "in-progress" } as Task,
    ]);
    const result = await findWorktreeUser(store, "/tmp/wt", "FN-050");
    expect(result).toBe("FN-051");
  });

  it("ignores done tasks", async () => {
    const store = createMockStore({}, [
      { id: "FN-050", worktree: "/tmp/wt", column: "done" } as Task,
      { id: "FN-051", worktree: "/tmp/wt", column: "done" } as Task,
    ]);
    const result = await findWorktreeUser(store, "/tmp/wt", "FN-050");
    expect(result).toBeNull();
  });
});

describe("aiMergeTask pre-merge fetch + fast-forward (smart strategies)", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  function setupSyncMock({
    behind,
    ahead,
    fetchFails = false,
  }: {
    behind: number;
    ahead: number;
    fetchFails?: boolean;
  }) {
    let fetchCalled = false;
    let ffCalled = false;
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --abbrev-ref HEAD")) return "main" as any;
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      if (cmdStr.includes("rev-list --left-right --count")) {
        return `${behind}\t${ahead}` as any;
      }
      if (cmdStr.includes("git fetch origin")) {
        fetchCalled = true;
        if (fetchFails) throw new Error("fatal: unable to access remote");
        return Buffer.from("");
      }
      if (cmdStr.includes("merge --ff-only")) {
        ffCalled = true;
        return Buffer.from("");
      }
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("merge -X theirs --squash") || cmdStr.includes("merge -X ours --squash")) {
        return Buffer.from("");
      }
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "0" as any;
      if (cmdStr.includes("show --shortstat")) return "3 files changed, 10 insertions(+), 2 deletions(-)" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });
    return {
      get fetchCalled() { return fetchCalled; },
      get ffCalled() { return ffCalled; },
    };
  }

  it("fast-forwards local main when origin is strictly ahead (default smart-prefer-main)", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    const probe = setupSyncMock({ behind: 2, ahead: 0 });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(probe.fetchCalled).toBe(true);
    expect(probe.ffCalled).toBe(true);
  });

  it("skips fast-forward when local main has unpushed commits (divergent)", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    const probe = setupSyncMock({ behind: 1, ahead: 1 });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(probe.fetchCalled).toBe(true);
    expect(probe.ffCalled).toBe(false);
  });

  it("continues merge when fetch fails (graceful degrade)", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    const probe = setupSyncMock({ behind: 0, ahead: 0, fetchFails: true });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(probe.fetchCalled).toBe(true);
    expect(probe.ffCalled).toBe(false);
    expect(result.merged).toBe(true);
  });

  it("does not fetch for ai-only strategy", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      mergeConflictStrategy: "ai-only",
    });
    const probe = setupSyncMock({ behind: 5, ahead: 0 });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(probe.fetchCalled).toBe(false);
  });

  it("normalizes legacy 'smart' setting and still fetches", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      mergeConflictStrategy: "smart" as any,
    });
    const probe = setupSyncMock({ behind: 1, ahead: 0 });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(probe.fetchCalled).toBe(true);
    expect(probe.ffCalled).toBe(true);
  });
});

describe("aiMergeTask abort handling", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    setupHappyPathExecSync();
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  it("throws immediately when signal is already aborted", async () => {
    const store = createMockStore();
    const controller = new AbortController();
    controller.abort();

    await expect(
      aiMergeTask(store, "/tmp/root", "FN-050", { signal: controller.signal }),
    ).rejects.toBeInstanceOf(MergeAbortedError);

    expect(store.getTask).not.toHaveBeenCalled();
    expect(mockedCreateFnAgent).not.toHaveBeenCalled();
  });

  it("throws MergeAbortedError when aborted during deterministic verification", async () => {
    const controller = new AbortController();
    const store = createMockStore();
    store.getSettings = vi.fn().mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "pnpm test",
    });

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr === "pnpm test") {
        controller.abort();
        return "" as any;
      }
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("merge -X theirs --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "0" as any;
      if (cmdStr.includes("show --shortstat")) return "3 files changed, 10 insertions(+), 2 deletions(-)" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    await expect(
      aiMergeTask(store, "/tmp/root", "FN-050", { signal: controller.signal }),
    ).rejects.toBeInstanceOf(MergeAbortedError);
  });
});

describe("aiMergeTask — conditional worktree cleanup", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    setupHappyPathExecSync();
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  it("does NOT remove worktree when another task references the same path", async () => {
    const worktreePath = "/tmp/root/.worktrees/KB-050";
    const store = createMockStore(
      { id: "FN-050", worktree: worktreePath },
      [
        { id: "FN-050", worktree: worktreePath, column: "in-review" } as Task,
        { id: "FN-051", worktree: worktreePath, column: "in-progress" } as Task,
      ],
    );

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    // Worktree should NOT be removed
    const removeCall = mockedExecSync.mock.calls.find(
      (call) => String(call[0]).includes("worktree remove"),
    );
    expect(removeCall).toBeUndefined();
    expect(result.worktreeRemoved).toBe(false);
  });

  it("removes worktree when no other task references it", async () => {
    const worktreePath = "/tmp/root/.worktrees/KB-050";
    const store = createMockStore(
      { id: "FN-050", worktree: worktreePath },
      [
        { id: "FN-050", worktree: worktreePath, column: "in-review" } as Task,
      ],
    );

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    const removeCall = mockedExecSync.mock.calls.find(
      (call) => String(call[0]).includes("worktree remove"),
    );
    expect(removeCall).toBeDefined();
    expect(result.worktreeRemoved).toBe(true);
  });

  it("clears task.worktree/branch after the worktree is removed", async () => {
    const worktreePath = "/tmp/root/.worktrees/KB-050";
    const store = createMockStore(
      { id: "FN-050", worktree: worktreePath },
      [
        { id: "FN-050", worktree: worktreePath, column: "in-review" } as Task,
      ],
    );

    await aiMergeTask(store, "/tmp/root", "FN-050");

    // The dashboard's diff endpoint reads task.worktree to decide whether to
    // run a live git diff; leaving it set after removal would point at a
    // foreign branch (when the path is recycled) and surface other tasks'
    // commits as if they belonged to FN-050.
    const updateCalls = (store.updateTask as any).mock.calls;
    const cleared = updateCalls.find(
      ([id, patch]: [string, any]) =>
        id === "FN-050" && patch && patch.worktree === null && patch.branch === null,
    );
    expect(cleared).toBeDefined();
  });

  it("always deletes the branch regardless of worktree sharing", async () => {
    const worktreePath = "/tmp/root/.worktrees/KB-050";
    const store = createMockStore(
      { id: "FN-050", worktree: worktreePath },
      [
        { id: "FN-050", worktree: worktreePath, column: "in-review" } as Task,
        { id: "FN-051", worktree: worktreePath, column: "in-progress" } as Task,
      ],
    );

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    // Branch should be deleted even though worktree is shared
    const branchDeleteCall = mockedExecSync.mock.calls.find(
      (call) => String(call[0]).includes("branch -d") || String(call[0]).includes("branch -D"),
    );
    expect(branchDeleteCall).toBeDefined();
    expect(result.branchDeleted).toBe(true);
  });

  it("result.worktreeRemoved is false when worktree is retained", async () => {
    const worktreePath = "/tmp/root/.worktrees/KB-050";
    const store = createMockStore(
      { id: "FN-050", worktree: worktreePath },
      [
        { id: "FN-050", worktree: worktreePath, column: "in-review" } as Task,
        { id: "FN-051", worktree: worktreePath, column: "todo" } as Task,
      ],
    );

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");
    expect(result.worktreeRemoved).toBe(false);
    expect(result.merged).toBe(true);
  });
});

describe("aiMergeTask — pre-merge rebase abort observability", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  it("attempts rebase abort in the task worktree and continues merge when abort succeeds", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    // Fall-through is only allowed for prefer-branch; prefer-main hard-fails (see test below).
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      mergeConflictStrategy: "smart-prefer-branch",
    });

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git symbolic-ref --short HEAD")) return "main" as any;
      if (cmdStr.includes("git rev-parse --abbrev-ref origin/HEAD")) return "origin/main" as any;
      if (cmdStr === "git rev-parse --abbrev-ref HEAD") return "main" as any;
      if (cmdStr.includes("git config --get branch.main.remote")) return "origin" as any;
      if (cmdStr === 'git fetch "origin"') return Buffer.from("");
      if (cmdStr === 'git rebase "origin/main"') {
        throw new Error("pre-merge rebase conflict");
      }
      if (cmdStr === "git rebase --abort") return Buffer.from("");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "" as any;
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "0" as any;
      if (cmdStr.includes("show --shortstat")) return "1 file changed, 1 insertion(+), 0 deletions(-)" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(
      mockedExec.mock.calls.some(
        ([command, options]) => command === "git rebase --abort"
          && typeof options === "object"
          && options !== null
          && "cwd" in options
          && (options as { cwd?: string }).cwd === "/tmp/root/.worktrees/KB-050",
      ),
    ).toBe(true);
    expect(mockedExecSync.mock.calls.some(([command]) => String(command).includes("merge --squash"))).toBe(true);
  });

  it("logs abort cleanup failure details but still falls through to merge", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      mergeConflictStrategy: "smart-prefer-branch",
    });

    const warnSpy = vi.spyOn(mergerLog, "warn");
    const abortFailureMessage = "fatal: no rebase in progress";

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git symbolic-ref --short HEAD")) return "main" as any;
      if (cmdStr.includes("git rev-parse --abbrev-ref origin/HEAD")) return "origin/main" as any;
      if (cmdStr === "git rev-parse --abbrev-ref HEAD") return "main" as any;
      if (cmdStr.includes("git config --get branch.main.remote")) return "origin" as any;
      if (cmdStr === 'git fetch "origin"') return Buffer.from("");
      if (cmdStr === 'git rebase "origin/main"') {
        throw new Error("pre-merge rebase conflict");
      }
      if (cmdStr === "git rebase --abort") {
        const error = new Error("rebase abort failed") as Error & { stderr?: string };
        error.stderr = abortFailureMessage;
        throw error;
      }
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "" as any;
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "0" as any;
      if (cmdStr.includes("show --shortstat")) return "1 file changed, 1 insertion(+), 0 deletions(-)" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(
      warnSpy.mock.calls.some(([message]) => String(message).includes(`FN-050: failed to abort pre-merge rebase: ${abortFailureMessage}`)),
    ).toBe(true);
    expect(mockedExecSync.mock.calls.some(([command]) => String(command).includes("merge --squash"))).toBe(true);

    warnSpy.mockRestore();
  });

  it("hard-fails when prefer-main is paired with both rebase stages disabled", async () => {
    // After the rebase block was split into two independent stages
    // (remote + local-base), prefer-main is satisfied by either stage running
    // successfully. Only when BOTH are explicitly disabled is the
    // configuration incoherent.
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      mergeConflictStrategy: "smart-prefer-main",
      worktreeRebaseBeforeMerge: false,
      worktreeRebaseLocalBase: false,
    });

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git rev-parse --abbrev-ref")) return "main" as any;
      return Buffer.from("");
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toThrow(
      /Incompatible settings.*smart-prefer-main.*worktreeRebase/i,
    );
  });

  it("local-base rebase still runs when remote is unresolvable (independent stages)", async () => {
    // Regression: previously the local-base rebase was nested inside the
    // remote-rebase success path, so a missing remote would skip BOTH. Now
    // the stages are independent — local-base runs even when remote can't
    // resolve, providing prefer-main with a usable safety net.
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      mergeConflictStrategy: "smart-prefer-main",
    });

    let localBaseRebaseRan = false;
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git symbolic-ref --short HEAD")) return "main" as any;
      if (cmdStr === "git rev-parse --abbrev-ref HEAD") return "main" as any;
      // No remote configured: empty config + empty remote list
      if (cmdStr.includes("git config --get branch.")) return "" as any;
      if (cmdStr === "git remote") return "" as any;
      // Local HEAD lookup for Stage 2
      if (cmdStr === "git rev-parse HEAD") return "localhead123";
      // Stage 2 ancestor check fails (not contained), so rebase runs
      if (cmdStr.includes("merge-base --is-ancestor")) {
        const err: any = new Error("not an ancestor");
        err.status = 1;
        throw err;
      }
      // Stage 2 rebase command
      if (cmdStr.includes('git rebase "localhead123"')) {
        localBaseRebaseRan = true;
        return Buffer.from("");
      }
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "";
      if (cmdStr.includes("diff --cached --quiet")) return "1";
      if (cmdStr.includes("show --shortstat")) return "1 file changed, 1 insertion(+), 0 deletions(-)";
      return Buffer.from("");
    });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(localBaseRebaseRan).toBe(true);
  });

  it("does not silently fall through to -X ours when smart-prefer-main rebase aborts and recovery layers 1+2 fail", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      mergeConflictStrategy: "smart-prefer-main",
    });

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git symbolic-ref --short HEAD")) return "main" as any;
      if (cmdStr.includes("git rev-parse --abbrev-ref origin/HEAD")) return "origin/main" as any;
      if (cmdStr === "git rev-parse --abbrev-ref HEAD") return "main" as any;
      if (cmdStr.includes("git config --get branch.main.remote")) return "origin" as any;
      if (cmdStr === 'git fetch "origin"') return Buffer.from("");
      if (cmdStr === 'git rebase "origin/main"') {
        throw new Error("pre-merge rebase conflict");
      }
      if (cmdStr === "git rebase --abort") return Buffer.from("");
      return Buffer.from("");
    });

    // Layers 1+2 require successful exec calls we don't stub here, so they
    // fail-soft. After fall-through, AI attempts 1+2 fail (no AI mock) and
    // the merge cascade exhausts. The contract under test: -X ours must
    // NEVER run, even after fall-through, because that would silently
    // re-introduce content main has deleted.
    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toThrow();
    expect(
      mockedExec.mock.calls.some(([command]) => String(command).includes("merge -X ours")),
    ).toBe(false);
    // The fall-through must be visible in the task log so the user can see
    // the recovery attempt and why we declined to silently merge.
    const logCalls = (store.logEntry as ReturnType<typeof vi.fn>).mock.calls.map(
      (args: unknown[]) => String(args[1] ?? ""),
    );
    expect(
      logCalls.some((msg: string) => msg.includes("Pre-merge recovery (Layer 3)")),
    ).toBe(true);
    expect(
      logCalls.some((msg: string) => msg.includes("Attempt 3 (-X ours fallback) suppressed")),
    ).toBe(true);
  });

  it("Layer 1 recovery: surgically drops dep commits via rebase --onto when executionStartBranch is set and primary rebase aborted", async () => {
    // Scenario: FN-2849 declared baseBranch=fusion/fn-2729 (a dep). The
    // worktree was forked off FN-2729's tip and inherited its raw commits.
    // FN-2729 was later squash-merged to main. Now the primary rebase onto
    // main aborts because FN-2729's raw commits conflict with their own
    // squashed equivalent + later main commits. Layer 1 detects baseBranch
    // and runs `git rebase --onto <main> <dep-tip> <branch>` to peel off
    // the dep's commits cleanly so the merge can proceed.
    const store = createMockStore(
      {
        id: "FN-2849",
        executionStartBranch: "fusion/fn-2729",
        branch: "fusion/fn-2849",
        worktree: "/tmp/root/.worktrees/coral-stone",
      },
      [{ id: "FN-2849", worktree: "/tmp/root/.worktrees/coral-stone", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      mergeConflictStrategy: "smart-prefer-main",
    });

    // Layer happy-path mocks first, then override only what this test needs.
    setupHappyPathExecSync();
    const happyPath = mockedExecSync.getMockImplementation()!;
    const DEP_TIP = "8f54a0e66b419a43703f996df5206d82bb4832e1";
    let primaryRebaseAttempted = false;
    let layer1OntoRebaseRan = false;

    mockedExecSync.mockImplementation((cmd: any, opts?: any) => {
      const cmdStr = String(cmd);
      // Set up a resolvable origin remote so Stage 1 actually runs.
      if (cmdStr === "git remote") return "origin\n" as any;
      if (cmdStr.includes("git config --get branch.main.remote")) return "origin" as any;
      if (cmdStr.includes("git rev-parse --abbrev-ref origin/HEAD")) return "origin/main" as any;
      if (cmdStr === "git rev-parse --abbrev-ref HEAD") return "main" as any;
      if (cmdStr.includes("git symbolic-ref --short HEAD")) return "main" as any;
      if (cmdStr === 'git fetch "origin"') return Buffer.from("");
      // Resolve dep tip when Layer 1 looks it up via baseBranch.
      if (cmdStr.includes('rev-parse --verify "fusion/fn-2729^{commit}"')) {
        return Buffer.from(DEP_TIP);
      }
      // Stage 1 rebase aborts — this is what triggers Layer 1 recovery.
      if (cmdStr === 'git rebase "origin/main"') {
        primaryRebaseAttempted = true;
        const err: any = new Error(
          'could not apply ca5674d43... feat(FN-2729): Step 2 — adopt NodeHealthDot in InlineCreateCard\nadvice.mergeConflict false\nrebase conflict manually',
        );
        throw err;
      }
      if (cmdStr === "git rebase --abort") return Buffer.from("");
      // Layer 1's surgical rebase succeeds.
      if (
        cmdStr.startsWith("git rebase --onto") &&
        cmdStr.includes(DEP_TIP) &&
        cmdStr.includes("fusion/fn-2849")
      ) {
        layer1OntoRebaseRan = true;
        return Buffer.from("");
      }
      return happyPath(cmd, opts);
    });

    await aiMergeTask(store, "/tmp/root", "FN-2849");

    expect(primaryRebaseAttempted).toBe(true);
    expect(layer1OntoRebaseRan).toBe(true);
    const logCalls = (store.logEntry as ReturnType<typeof vi.fn>).mock.calls.map(
      (args: unknown[]) => String(args[1] ?? ""),
    );
    expect(
      logCalls.some((msg: string) => msg.includes("Pre-merge recovery (Layer 1)")),
    ).toBe(true);
    // Layer 3 fall-through must NOT have triggered — Layer 1 unblocked.
    expect(
      logCalls.some((msg: string) => msg.includes("Pre-merge recovery (Layer 3)")),
    ).toBe(false);
  });
});

describe("aiMergeTask — task.branch field", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    setupHappyPathExecSync();
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  it("uses task.branch when set instead of deriving from task ID", async () => {
    const store = createMockStore(
      { id: "FN-050", branch: "fusion/fn-050-2", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    // Should use fusion/fn-050-2, not fusion/fn-050
    expect(result.branch).toBe("fusion/fn-050-2");

    // Verify the suffixed branch was verified and deleted
    const revParseCall = mockedExecSync.mock.calls.find(
      (call) => String(call[0]).includes("rev-parse --verify") && String(call[0]).includes("fusion/fn-050-2"),
    );
    expect(revParseCall).toBeDefined();

    const branchDeleteCall = mockedExecSync.mock.calls.find(
      (call) => String(call[0]).includes("branch -d") && String(call[0]).includes("fusion/fn-050-2"),
    );
    expect(branchDeleteCall).toBeDefined();
  });

  it("falls back to conventional branch name when task.branch is not set", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.branch).toBe("fusion/fn-050");
  });
});

describe("aiMergeTask — empty squash merge (branch already merged via dep)", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
  });

  it("skips agent and still completes when squash stages nothing", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      // Squash staged nothing → "0"
      if (cmdStr.includes("diff --cached --quiet")) return "0" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const store = createMockStore();
    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    // Agent should NOT have been spawned
    expect(mockedCreateFnAgent).not.toHaveBeenCalled();
    // Task should still be moved to done
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
  });

  it("does not record commitSha when squash is empty (would be pre-merge HEAD)", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "premergehead999";
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "0" as any;
      if (cmdStr.includes("show --shortstat")) return " 5 files changed, 12 insertions(+), 3 deletions(-)\n" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const store = createMockStore();
    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);

    // mergeDetails should be stored without commitSha (which would be the
    // pre-merge HEAD, unrelated to this task).
    const updateCalls = (store.updateTask as ReturnType<typeof vi.fn>).mock.calls;
    const mergeDetailsCall = updateCalls.find((call: any[]) => call[1]?.mergeDetails !== undefined);
    expect(mergeDetailsCall).toBeDefined();
    expect(mergeDetailsCall![1].mergeDetails.commitSha).toBeUndefined();
  });

  it("still cleans up branch and worktree when squash is empty", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "0" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const store = createMockStore();
    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    // Branch should be deleted
    const branchDeleteCall = mockedExecSync.mock.calls.find(
      (call) => String(call[0]).includes("branch -d"),
    );
    expect(branchDeleteCall).toBeDefined();
    expect(result.branchDeleted).toBe(true);

    // Worktree should be removed
    const worktreeRemoveCall = mockedExecSync.mock.calls.find(
      (call) => String(call[0]).includes("worktree remove"),
    );
    expect(worktreeRemoveCall).toBeDefined();
    expect(result.worktreeRemoved).toBe(true);
  });
});

describe("push-after-merge", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  function setupAiMergeExecSyncWithPush(pushBehavior?: (attempt: number) => void) {
    let pushAttempts = 0;

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);

      if (cmdStr.includes("rev-parse --verify REBASE_HEAD")) {
        const err = new Error("fatal: Needed a single revision") as Error & { status?: number };
        err.status = 128;
        throw err;
      }
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git symbolic-ref --short HEAD")) return "main" as any;
      if (cmdStr.includes("git rev-parse --abbrev-ref origin/HEAD")) return "origin/main" as any;
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123" as any;
      if (cmdStr.includes("git log HEAD..")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("git merge --squash")) return Buffer.from("");
      if (cmdStr.includes("git diff --name-only --diff-filter=U")) return "" as any;
      if (cmdStr.includes("git diff --cached --quiet")) {
        // First call: squash-empty check, second call: post-agent commit verification.
        return "1" as any;
      }
      if (cmdStr.startsWith("git commit ")) return Buffer.from("");
      if (cmdStr.includes("git show --shortstat")) return "3 files changed, 10 insertions(+), 2 deletions(-)" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr.startsWith("git pull --rebase")) return Buffer.from("");
      if (cmdStr.startsWith("git push ")) {
        pushAttempts += 1;
        pushBehavior?.(pushAttempts);
        return Buffer.from("");
      }

      return Buffer.from("");
    });

  }

  it("pushes merged result when pushAfterMerge is enabled", async () => {
    setupAiMergeExecSyncWithPush();

    const store = createMockStore();
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      pushAfterMerge: true,
      pushRemote: "origin",
      mergeStrategy: "direct",
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.pushedToRemote).toBe(true);
    expect(
      mockedExecSync.mock.calls.some((call) => String(call[0]).includes('git pull --rebase "origin" "main"')),
    ).toBe(true);
    expect(
      mockedExecSync.mock.calls.some((call) => String(call[0]).includes('git push "origin" "main"')),
    ).toBe(true);
  });

  it("does not push when pushAfterMerge is disabled (default)", async () => {
    setupAiMergeExecSyncWithPush();

    const store = createMockStore();
    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.pushedToRemote).toBeUndefined();
    expect(
      mockedExecSync.mock.calls.some((call) => String(call[0]).startsWith("git pull --rebase")),
    ).toBe(false);
    expect(
      mockedExecSync.mock.calls.some((call) => String(call[0]).startsWith("git push ")),
    ).toBe(false);
  });

  it("does not push for pull-request merge strategy", async () => {
    setupAiMergeExecSyncWithPush();

    const store = createMockStore();
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      mergeStrategy: "pull-request",
      pushAfterMerge: true,
      pushRemote: "origin",
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.pushedToRemote).toBeUndefined();
    expect(
      mockedExecSync.mock.calls.some((call) => String(call[0]).startsWith("git pull --rebase")),
    ).toBe(false);
    expect(
      mockedExecSync.mock.calls.some((call) => String(call[0]).startsWith("git push ")),
    ).toBe(false);
  });

  it("records push error but still completes merge when push fails", async () => {
    setupAiMergeExecSyncWithPush((attempt) => {
      if (attempt === 1) {
        const err = new Error("failed to push some refs");
        (err as Error & { stderr?: string }).stderr = "remote: permission denied";
        throw err;
      }
    });

    const store = createMockStore();
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      pushAfterMerge: true,
      pushRemote: "origin",
      mergeStrategy: "direct",
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(result.pushedToRemote).toBe(false);
    expect(result.pushError).toContain("permission denied");
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
  });

  it("uses custom remote and branch when configured", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.startsWith("git pull --rebase \"upstream\" \"main\"")) return Buffer.from("");
      if (cmdStr.startsWith("git push \"upstream\" \"main\"")) return Buffer.from("");
      if (cmdStr.includes("rev-parse --verify REBASE_HEAD")) {
        const err = new Error("fatal: Needed a single revision");
        throw err;
      }
      return Buffer.from("");
    });

    const store = createMockStore();
    const result = await pushToRemoteAfterMerge(store, "/tmp/root", "FN-050", {
      ...DEFAULT_SETTINGS,
      pushAfterMerge: true,
      pushRemote: "upstream main",
    });

    expect(result.pushed).toBe(true);
    expect(
      mockedExecSync.mock.calls.some((call) => String(call[0]).startsWith('git pull --rebase "upstream" "main"')),
    ).toBe(true);
    expect(
      mockedExecSync.mock.calls.some((call) => String(call[0]).startsWith('git push "upstream" "main"')),
    ).toBe(true);
  });

  it("auto-resolves lock-file rebase conflicts and continues", async () => {
    let rebaseInProgress = false;
    let hasConflicts = false;

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);

      if (cmdStr.startsWith('git pull --rebase "origin" "main"')) {
        hasConflicts = true;
        rebaseInProgress = true;
        const err = new Error("rebase conflict") as Error & { stderr?: string };
        err.stderr = "CONFLICT (content): Merge conflict in pnpm-lock.yaml";
        throw err;
      }
      if (cmdStr.includes("git diff --name-only --diff-filter=U")) {
        return hasConflicts ? "pnpm-lock.yaml" as any : "" as any;
      }
      if (cmdStr.includes("checkout --ours") && cmdStr.includes("pnpm-lock.yaml")) return Buffer.from("");
      if (cmdStr.includes("git add") && cmdStr.includes("pnpm-lock.yaml")) {
        hasConflicts = false;
        return Buffer.from("");
      }
      if (cmdStr.includes("git rev-parse --verify REBASE_HEAD")) {
        if (rebaseInProgress) return "rebasehead" as any;
        const err = new Error("fatal: Needed a single revision") as Error & { status?: number };
        err.status = 128;
        throw err;
      }
      if (cmdStr.startsWith("GIT_EDITOR=true git rebase --continue")) {
        rebaseInProgress = false;
        return Buffer.from("");
      }
      if (cmdStr.startsWith('git push "origin" "main"')) return Buffer.from("");
      if (cmdStr.includes("git symbolic-ref --short HEAD")) return "main" as any;

      return Buffer.from("");
    });

    const store = createMockStore();
    const result = await pushToRemoteAfterMerge(store, "/tmp/root", "FN-050", {
      ...DEFAULT_SETTINGS,
      pushAfterMerge: true,
      pushRemote: "origin",
    });

    expect(result.pushed).toBe(true);
    expect(
      mockedExecSync.mock.calls.some((call) => String(call[0]).includes("checkout --ours") && String(call[0]).includes("pnpm-lock.yaml")),
    ).toBe(true);
    expect(
      mockedExecSync.mock.calls.some((call) => String(call[0]).startsWith("GIT_EDITOR=true git rebase --continue")),
    ).toBe(true);
  });

  it("uses AI to resolve complex rebase conflicts", async () => {
    let rebaseInProgress = false;
    let hasConflicts = false;

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn(async () => {
          hasConflicts = false;
        }),
        dispose: vi.fn(),
      },
    } as any);

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);

      if (cmdStr.startsWith('git pull --rebase "origin" "main"')) {
        hasConflicts = true;
        rebaseInProgress = true;
        const err = new Error("rebase conflict") as Error & { stderr?: string };
        err.stderr = "CONFLICT (content): Merge conflict in src/app.ts";
        throw err;
      }
      if (cmdStr.includes("git diff --name-only --diff-filter=U")) {
        return hasConflicts ? "src/app.ts" as any : "" as any;
      }
      if (cmdStr.startsWith("git diff-tree -p -w")) return "@@\n-foo\n+bar" as any;
      if (cmdStr.includes("git rev-parse --verify REBASE_HEAD")) {
        if (rebaseInProgress) return "rebasehead" as any;
        const err = new Error("fatal: Needed a single revision") as Error & { status?: number };
        err.status = 128;
        throw err;
      }
      if (cmdStr.startsWith("GIT_EDITOR=true git rebase --continue")) {
        rebaseInProgress = false;
        return Buffer.from("");
      }
      if (cmdStr.startsWith('git push "origin" "main"')) return Buffer.from("");
      if (cmdStr.includes("git symbolic-ref --short HEAD")) return "main" as any;

      return Buffer.from("");
    });

    const store = createMockStore();
    const result = await pushToRemoteAfterMerge(store, "/tmp/root", "FN-050", {
      ...DEFAULT_SETTINGS,
      pushAfterMerge: true,
      pushRemote: "origin",
    });

    expect(result.pushed).toBe(true);
    expect(mockedCreateFnAgent).toHaveBeenCalled();
  });

  it("retries push once after non-fast-forward rejection", async () => {
    let pushAttempts = 0;
    let pullAttempts = 0;

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.startsWith('git pull --rebase "origin" "main"')) {
        pullAttempts += 1;
        return Buffer.from("");
      }
      if (cmdStr.startsWith('git push "origin" "main"')) {
        pushAttempts += 1;
        if (pushAttempts === 1) {
          const err = new Error("non-fast-forward") as Error & { stderr?: string };
          err.stderr = "[rejected] main -> main (non-fast-forward)";
          throw err;
        }
        return Buffer.from("");
      }
      if (cmdStr.includes("git symbolic-ref --short HEAD")) return "main" as any;
      if (cmdStr.includes("git rev-parse --verify REBASE_HEAD")) {
        const err = new Error("fatal: Needed a single revision") as Error & { status?: number };
        err.status = 128;
        throw err;
      }
      return Buffer.from("");
    });

    const store = createMockStore();
    const result = await pushToRemoteAfterMerge(store, "/tmp/root", "FN-050", {
      ...DEFAULT_SETTINGS,
      pushAfterMerge: true,
      pushRemote: "origin",
    });

    expect(result.pushed).toBe(true);
    expect(pullAttempts).toBe(2);
    expect(pushAttempts).toBe(2);
  });

  it("aborts rebase when conflicts remain unresolved", async () => {
    let rebaseInProgress = false;

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);

      if (cmdStr.startsWith('git pull --rebase "origin" "main"')) {
        rebaseInProgress = true;
        const err = new Error("rebase conflict") as Error & { stderr?: string };
        err.stderr = "CONFLICT (content): Merge conflict in src/app.ts";
        throw err;
      }
      if (cmdStr.includes("git diff --name-only --diff-filter=U")) return "src/app.ts" as any;
      if (cmdStr.startsWith("git diff-tree -p -w")) return "@@\n-foo\n+bar" as any;
      if (cmdStr.includes("git rev-parse --verify REBASE_HEAD")) {
        if (rebaseInProgress) return "rebasehead" as any;
        const err = new Error("fatal: Needed a single revision") as Error & { status?: number };
        err.status = 128;
        throw err;
      }
      if (cmdStr.startsWith("git rebase --abort")) {
        rebaseInProgress = false;
        return Buffer.from("");
      }
      if (cmdStr.includes("git symbolic-ref --short HEAD")) return "main" as any;

      return Buffer.from("");
    });

    const store = createMockStore();
    const result = await pushToRemoteAfterMerge(store, "/tmp/root", "FN-050", {
      ...DEFAULT_SETTINGS,
      pushAfterMerge: true,
      pushRemote: "origin",
    });

    expect(result.pushed).toBe(false);
    expect(result.error).toContain("unable to resolve rebase conflicts");
    expect(
      mockedExecSync.mock.calls.some((call) => String(call[0]).startsWith("git rebase --abort")),
    ).toBe(true);
  });
});

describe("aiMergeTask — includeTaskIdInCommit setting", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    setupHappyPathExecSync();
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  it("includes task ID in system prompt by default (includeTaskIdInCommit: true)", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    await aiMergeTask(store, "/tmp/root", "FN-050");

    const agentCall = mockedCreateFnAgent.mock.calls[0][0] as any;
    expect(agentCall.systemPrompt).toContain("<type>(<scope>): <summary>");
    expect(agentCall.systemPrompt).toContain("the task ID");
  });

  it("omits task ID scope in system prompt when includeTaskIdInCommit is false", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      includeTaskIdInCommit: false,
    });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    const agentCall = mockedCreateFnAgent.mock.calls[0][0] as any;
    expect(agentCall.systemPrompt).toContain("<type>: <summary>");
    expect(agentCall.systemPrompt).not.toContain("<type>(<scope>): <summary>");
    expect(agentCall.systemPrompt).toContain("Do NOT include a scope");
  });

  it("fallback commit includes task ID when includeTaskIdInCommit is true", async () => {
    // Make staged check return "1" so fallback is triggered
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached")) return "1" as any;
      if (cmdStr.includes("git commit")) return Buffer.from("");
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    await aiMergeTask(store, "/tmp/root", "FN-050");

    const commitCall = mockedExecSync.mock.calls.find(
      (call) => String(call[0]).includes("git commit"),
    );
    expect(commitCall).toBeDefined();
    expect(String(commitCall![0])).toContain("feat(FN-050):");
  });

  it("fallback commit omits task ID when includeTaskIdInCommit is false", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached")) return "1" as any;
      if (cmdStr.includes("git commit")) return Buffer.from("");
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      includeTaskIdInCommit: false,
    });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    const commitCall = mockedExecSync.mock.calls.find(
      (call) => String(call[0]).includes("git commit"),
    );
    expect(commitCall).toBeDefined();
    // Subject must use bare `feat:` prefix (no task-id scope) when
    // includeTaskIdInCommit=false. The summary portion is derived from the
    // step commit log or AI subject, so we don't pin its exact text — just
    // assert the prefix shape.
    expect(String(commitCall![0])).toMatch(/git commit -m "feat: \S/);
    expect(String(commitCall![0])).not.toContain("feat(KB-050)");
    expect(String(commitCall![0])).not.toContain("feat(FN-050)");
  });
});

describe("aiMergeTask — model settings threading", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    setupHappyPathExecSync();
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  it("passes defaultProvider and defaultModelId from settings to createFnAgent", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      defaultProvider: "openai",
      defaultModelId: "gpt-4o",
    });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(mockedCreateFnAgent).toHaveBeenCalledTimes(1);
    const opts = mockedCreateFnAgent.mock.calls[0][0] as any;
    expect(opts.defaultProvider).toBe("openai");
    expect(opts.defaultModelId).toBe("gpt-4o");
  });

  it("does not set model fields when settings omit them", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    await aiMergeTask(store, "/tmp/root", "FN-050");

    const opts = mockedCreateFnAgent.mock.calls[0][0] as any;
    expect(opts.defaultProvider).toBeUndefined();
    expect(opts.defaultModelId).toBeUndefined();
  });
});

describe("aiMergeTask — agent log persistence", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    setupHappyPathExecSync();
  });

  it("logs text deltas to store.appendAgentLog", async () => {
    let capturedOnText: ((delta: string) => void) | undefined;

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      capturedOnText = opts.onText;
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            capturedOnText?.("Hello ");
            capturedOnText?.("merge");
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const worktreePath = "/tmp/root/.worktrees/KB-050";
    const store = createMockStore(
      { id: "FN-050", worktree: worktreePath },
      [{ id: "FN-050", worktree: worktreePath, column: "in-review" } as Task],
    );

    await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(store.appendAgentLog).toHaveBeenCalledWith("FN-050", "Hello merge", "text", undefined, "merger");
  });

  it("logs tool invocations to store.appendAgentLog", async () => {
    let capturedOnToolStart: ((name: string, args: any) => void) | undefined;

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      capturedOnToolStart = opts.onToolStart;
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            capturedOnToolStart?.("Bash", { command: "git status" });
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const worktreePath = "/tmp/root/.worktrees/KB-050";
    const store = createMockStore(
      { id: "FN-050", worktree: worktreePath },
      [{ id: "FN-050", worktree: worktreePath, column: "in-review" } as Task],
    );

    await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(store.appendAgentLog).toHaveBeenCalledWith("FN-050", "Bash", "tool", "git status", "merger");
  });

  it("still fires onAgentText callback alongside logging", async () => {
    const onAgentText = vi.fn();
    let capturedOnText: ((delta: string) => void) | undefined;

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      capturedOnText = opts.onText;
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            capturedOnText?.("hi");
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const worktreePath = "/tmp/root/.worktrees/KB-050";
    const store = createMockStore(
      { id: "FN-050", worktree: worktreePath },
      [{ id: "FN-050", worktree: worktreePath, column: "in-review" } as Task],
    );

    await aiMergeTask(store, "/tmp/root", "FN-050", { onAgentText });

    expect(onAgentText).toHaveBeenCalledWith("hi");
    expect(store.appendAgentLog).toHaveBeenCalledWith("FN-050", "hi", "text", undefined, "merger");
  });
});

// ── Usage limit detection in merger ──────────────────────────────────

import { UsageLimitPauser } from "../usage-limit-detector.js";

describe("aiMergeTask — usage limit detection", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    // Use setupFailingTheirsStrategy so -X theirs merge fails,
    // allowing tests that expect throws to pass
    setupFailingTheirsStrategy();
  });

  it("triggers global pause when merger catches a usage-limit error", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    const pauser = new UsageLimitPauser(store);
    const onUsageLimitHitSpy = vi.spyOn(pauser, "onUsageLimitHit");

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockRejectedValue(new Error("rate_limit_error: Rate limit exceeded")),
        dispose: vi.fn(),
      },
    } as any);

    await expect(
      aiMergeTask(store, "/tmp/root", "FN-050", { usageLimitPauser: pauser }),
    ).rejects.toThrow("AI merge failed");

    expect(onUsageLimitHitSpy).toHaveBeenCalledWith(
      "merger",
      "FN-050",
      "rate_limit_error: Rate limit exceeded",
    );
    expect(store.updateSettings).toHaveBeenCalledWith({
      globalPause: true,
      globalPauseReason: "rate-limit",
    });
  });

  it("triggers global pause when session.prompt() resolves with exhausted-retry error on state.error", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    const pauser = new UsageLimitPauser(store);
    const onUsageLimitHitSpy = vi.spyOn(pauser, "onUsageLimitHit");

    // session.prompt() resolves normally, but session.state.error is set
    const mockSession = {
      prompt: vi.fn().mockResolvedValue(undefined),
      dispose: vi.fn(),
      state: { error: "429 Too Many Requests" },
    };
    mockedCreateFnAgent.mockResolvedValue({ session: mockSession } as any);

    await expect(
      aiMergeTask(store, "/tmp/root", "FN-050", { usageLimitPauser: pauser }),
    ).rejects.toThrow("AI merge failed");

    // UsageLimitPauser should be called with "merger" agent type
    expect(onUsageLimitHitSpy).toHaveBeenCalledWith(
      "merger",
      "FN-050",
      "429 Too Many Requests",
    );
    // git reset --merge should be called to abort the merge
    const resetCalls = mockedExecSync.mock.calls.filter(
      (c) => String(c[0]).includes("reset --merge"),
    );
    expect(resetCalls.length).toBeGreaterThan(0);
  });

  it("does NOT trigger global pause for non-usage-limit errors", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    const pauser = new UsageLimitPauser(store);
    const onUsageLimitHitSpy = vi.spyOn(pauser, "onUsageLimitHit");

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockRejectedValue(new Error("connection refused")),
        dispose: vi.fn(),
      },
    } as any);

    await expect(
      aiMergeTask(store, "/tmp/root", "FN-050", { usageLimitPauser: pauser }),
    ).rejects.toThrow("AI merge failed");

    expect(onUsageLimitHitSpy).not.toHaveBeenCalled();
  });

  it("works without usageLimitPauser (backward compatible)", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockRejectedValue(new Error("rate_limit_error: Rate limit exceeded")),
        dispose: vi.fn(),
      },
    } as any);

    // Should not crash — just re-throw
    await expect(
      aiMergeTask(store, "/tmp/root", "FN-050"),
    ).rejects.toThrow("AI merge failed");
  });

  it("triggers global pause for overloaded error", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    const pauser = new UsageLimitPauser(store);
    const onUsageLimitHitSpy = vi.spyOn(pauser, "onUsageLimitHit");

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockRejectedValue(new Error("overloaded_error: Overloaded")),
        dispose: vi.fn(),
      },
    } as any);

    await expect(
      aiMergeTask(store, "/tmp/root", "FN-050", { usageLimitPauser: pauser }),
    ).rejects.toThrow("AI merge failed");

    expect(onUsageLimitHitSpy).toHaveBeenCalledWith(
      "merger",
      "FN-050",
      "overloaded_error: Overloaded",
    );
  });
});

describe("aiMergeTask — onSession callback", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    setupHappyPathExecSync();
  });

  it("calls onSession with the session object after creation", async () => {
    const mockSession = {
      prompt: vi.fn().mockResolvedValue(undefined),
      dispose: vi.fn(),
    };

    mockedCreateFnAgent.mockResolvedValue({
      session: mockSession,
    } as any);

    const onSession = vi.fn();
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    await aiMergeTask(store, "/tmp/root", "FN-050", { onSession });

    expect(onSession).toHaveBeenCalledTimes(1);
    expect(onSession).toHaveBeenCalledWith(mockSession);
  });

  it("works without onSession callback (backward compatible)", async () => {
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    // Should not crash without onSession
    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).resolves.toBeDefined();
  });
});

// ── Conflict Detection & Auto-Resolution ─────────────────────────────────

describe("detectResolvableConflicts", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it("returns empty array when no conflicts exist", async () => {
    mockedExecSync.mockReturnValue(""); // Empty output = no conflicts

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result).toEqual([]);
  });

  it("detects package-lock.json as auto-resolvable with 'theirs' strategy", async () => {
    mockedExecSync.mockReturnValue("package-lock.json\n");

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result).toHaveLength(1);
    expect(result[0]).toMatchObject({
      filePath: "package-lock.json",
      autoResolvable: true,
      strategy: "ours",
      reason: "lock-file",
    });
  });

  it("detects pnpm-lock.yaml as lock file with 'ours' strategy", async () => {
    mockedExecSync.mockReturnValue("pnpm-lock.yaml\n");

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result).toHaveLength(1);
    expect(result[0]).toMatchObject({
      filePath: "pnpm-lock.yaml",
      autoResolvable: true,
      strategy: "ours",
      reason: "lock-file",
    });
  });

  it("detects yarn.lock as lock file with 'ours' strategy", async () => {
    mockedExecSync.mockReturnValue("yarn.lock\n");

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result[0]).toMatchObject({
      autoResolvable: true,
      strategy: "ours",
      reason: "lock-file",
    });
  });

  it("detects Gemfile.lock as lock file with 'ours' strategy", async () => {
    mockedExecSync.mockReturnValue("Gemfile.lock\n");

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result[0]).toMatchObject({
      autoResolvable: true,
      strategy: "ours",
      reason: "lock-file",
    });
  });

  it("detects .gen.ts files as generated files with 'theirs' strategy", async () => {
    mockedExecSync.mockReturnValue("src/types.gen.ts\n");

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result[0]).toMatchObject({
      autoResolvable: true,
      strategy: "theirs",
      reason: "generated-file",
    });
  });

  it("detects dist/ paths as generated files with 'theirs' strategy", async () => {
    mockedExecSync.mockReturnValue("dist/index.js\n");

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result[0]).toMatchObject({
      autoResolvable: true,
      strategy: "theirs",
      reason: "generated-file",
    });
  });

  it("detects coverage/ paths as generated files with 'theirs' strategy", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("git diff --name-only")) return "coverage/lcov.info\n";
      return Buffer.from("");
    });

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result[0]).toMatchObject({
      autoResolvable: true,
      strategy: "theirs",
      reason: "generated-file",
    });
  });

  it("marks regular source files as complex conflicts", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("git diff --name-only")) return "src/components/App.tsx\n";
      // git diff-tree for trivial detection — return real diff content to indicate non-trivial
      if (cmdStr.includes("diff-tree")) return "+real change\n-old line\n";
      return Buffer.from("");
    });

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result[0]).toMatchObject({
      filePath: "src/components/App.tsx",
      autoResolvable: false,
      reason: "complex",
    });
  });

  it("handles multiple conflicted files with mixed categories", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("git diff --name-only"))
        return "package-lock.json\nsrc/components/App.tsx\ndist/bundle.js\n";
      // git diff-tree for trivial detection — return real diff for source files
      if (cmdStr.includes("diff-tree")) return "+real change\n-old line\n";
      return Buffer.from("");
    });

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result).toHaveLength(3);

    const lockFile = result.find((r) => r.filePath === "package-lock.json");
    const sourceFile = result.find((r) => r.filePath === "src/components/App.tsx");
    const distFile = result.find((r) => r.filePath === "dist/bundle.js");

    expect(lockFile).toMatchObject({ autoResolvable: true, reason: "lock-file" });
    expect(sourceFile).toMatchObject({ autoResolvable: false, reason: "complex" });
    expect(distFile).toMatchObject({ autoResolvable: true, reason: "generated-file" });
  });

  it("returns empty array on git command failure", async () => {
    mockedExecSync.mockImplementation(() => {
      throw new Error("git command failed");
    });

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result).toEqual([]);
  });
});

describe("autoResolveFile", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    // Default mock returns empty buffer for all git commands
    mockedExecSync.mockReturnValue(Buffer.from(""));
  });

  it("calls git checkout --theirs for 'theirs' resolution", async () => {
    await autoResolveFile("package-lock.json", "theirs", "/tmp/root");

    const checkoutCall = mockedExecSync.mock.calls.find((call) =>
      String(call[0]).includes("git checkout --theirs"),
    );
    expect(checkoutCall).toBeDefined();
    expect(String(checkoutCall![0])).toContain("package-lock.json");
  });

  it("calls git checkout --ours for 'ours' resolution", async () => {
    await autoResolveFile("config.json", "ours", "/tmp/root");

    const checkoutCall = mockedExecSync.mock.calls.find((call) =>
      String(call[0]).includes("git checkout --ours"),
    );
    expect(checkoutCall).toBeDefined();
    expect(String(checkoutCall![0])).toContain("config.json");
  });

  it("stages the resolved file with git add", async () => {
    await autoResolveFile("package-lock.json", "theirs", "/tmp/root");

    const addCall = mockedExecSync.mock.calls.find((call) =>
      String(call[0]).includes("git add"),
    );
    expect(addCall).toBeDefined();
    expect(String(addCall![0])).toContain("package-lock.json");
  });

  it("throws error when git checkout fails", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      if (String(cmd).includes("checkout")) {
        throw new Error("checkout failed");
      }
      return Buffer.from("");
    });

    await expect(autoResolveFile("file.ts", "theirs", "/tmp/root")).rejects.toThrow(
      "Failed to auto-resolve",
    );
  });
});

describe("resolveConflicts", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    // Default mock - success
    mockedExecSync.mockReturnValue(Buffer.from(""));
  });

  it("resolves lock files and returns remaining complex conflicts", async () => {
    const categories: ConflictCategory[] = [
      { filePath: "package-lock.json", autoResolvable: true, strategy: "ours", reason: "lock-file" },
      { filePath: "src/App.tsx", autoResolvable: false, reason: "complex" },
      { filePath: "dist/bundle.js", autoResolvable: true, strategy: "ours", reason: "generated-file" },
    ];

    const remaining = await resolveConflicts(categories, "/tmp/root");

    // Should have resolved package-lock.json and dist/bundle.js
    expect(remaining).toEqual(["src/App.tsx"]);

    // Should have called checkout and add for resolved files
    const checkoutCalls = mockedExecSync.mock.calls.filter((call) =>
      String(call[0]).includes("checkout"),
    );
    expect(checkoutCalls).toHaveLength(2);
  });

  it("returns all files when none are auto-resolvable", async () => {
    const categories: ConflictCategory[] = [
      { filePath: "src/App.tsx", autoResolvable: false, reason: "complex" },
      { filePath: "src/utils.ts", autoResolvable: false, reason: "complex" },
    ];

    const remaining = await resolveConflicts(categories, "/tmp/root");

    expect(remaining).toEqual(["src/App.tsx", "src/utils.ts"]);
    // No checkout calls should be made
    const checkoutCalls = mockedExecSync.mock.calls.filter((call) =>
      String(call[0]).includes("checkout"),
    );
    expect(checkoutCalls).toHaveLength(0);
  });

  it("returns empty array when all conflicts are resolved", async () => {
    const categories: ConflictCategory[] = [
      { filePath: "package-lock.json", autoResolvable: true, strategy: "ours", reason: "lock-file" },
      { filePath: "yarn.lock", autoResolvable: true, strategy: "ours", reason: "lock-file" },
    ];

    const remaining = await resolveConflicts(categories, "/tmp/root");

    expect(remaining).toEqual([]);
  });
});

// ── Trivial Conflict Detection Tests ──────────────────────────────────────

describe("trivial conflict detection (isTrivialWhitespaceConflict via detectResolvableConflicts)", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it("detects whitespace-only conflicts as trivial", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("git diff --name-only")) return "src/utils.ts\n";
      // git diff-tree with -w returns empty = trivial whitespace
      if (cmdStr.includes("diff-tree")) return "";
      return Buffer.from("");
    });

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result).toHaveLength(1);
    expect(result[0]).toMatchObject({
      filePath: "src/utils.ts",
      autoResolvable: true,
      strategy: "ours",
      reason: "trivial",
    });
  });

  it("marks conflicts with actual content differences as complex", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("git diff --name-only")) return "src/utils.ts\n";
      // git diff-tree returns real content changes = non-trivial
      if (cmdStr.includes("diff-tree")) return "+return 2;\n-return 1;\n";
      return Buffer.from("");
    });

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result).toHaveLength(1);
    expect(result[0]).toMatchObject({
      filePath: "src/utils.ts",
      autoResolvable: false,
      reason: "complex",
    });
  });

  it("handles multiple conflict sections - one non-trivial makes complex", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("git diff --name-only")) return "src/utils.ts\n";
      // Real diff content = non-trivial
      if (cmdStr.includes("diff-tree")) return "+const x = 999;\n-const x = 2;\n";
      return Buffer.from("");
    });

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result).toHaveLength(1);
    expect(result[0]).toMatchObject({
      autoResolvable: false,
      reason: "complex",
    });
  });

  it("handles git command errors as complex conflicts", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("git diff --name-only")) return "src/utils.ts\n";
      if (cmdStr.includes("diff-tree")) throw new Error("git error");
      return Buffer.from("");
    });

    const result = await detectResolvableConflicts("/tmp/root");
    expect(result).toHaveLength(1);
    expect(result[0]).toMatchObject({
      autoResolvable: false,
      reason: "complex",
    });
  });
});

// ── Retry Logic Tests ───────────────────────────────────────────────────

describe("aiMergeTask — retry logic with escalating strategies", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);

    // Default mock: successful happy path
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash") || cmdStr.includes("merge -X")) return Buffer.from("");
      // Post-squash check: "1" = has staged changes
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      // Post-agent check: "0" = committed
      if (cmdStr.includes("diff --cached") && !cmdStr.includes("--quiet")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr.includes("reset --merge")) return Buffer.from("");
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  it("attempt 1 success: sets resolutionStrategy to 'ai' and attemptsMade to 1", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    // Clean merge with no conflicts - simulate empty diff for conflicts
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      // No conflicts
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "";
      // Has staged changes that need committing
      if (cmdStr.includes("diff --cached --quiet")) return "1";
      if (cmdStr.includes("git commit")) return Buffer.from("");
      if (cmdStr.includes("branch -d")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(result.resolutionStrategy).toBe("ai");
    expect(result.attemptsMade).toBe(1);
  });

  it("with autoResolveConflicts disabled: only makes 1 attempt on conflict", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      autoResolveConflicts: false, // Disabled
    });

    let agentCallCount = 0;

    // Simulate: merge succeeds but leaves conflicts, agent is called but fails
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";

      if (cmdStr.includes("merge --squash")) {
        // Merge command succeeds but leaves conflict markers
        return Buffer.from("");
      }

      // Conflict detection returns conflicts
      if (cmdStr.includes("diff --name-only --diff-filter=U")) {
        return "src/file.ts\n";
      }

      // git diff-tree for trivial whitespace detection - return real changes (non-trivial)
      if (cmdStr.includes("diff-tree")) {
        const error = new Error("exit code 1") as any;
        error.stdout = "+const x = 2;\n-const x = 1;";
        throw error;
      }

      // Staged changes check after merge (conflicts present but not staged)
      if (cmdStr.includes("diff --cached --quiet")) {
        return "1"; // Has staged changes from the merge
      }

      if (cmdStr.includes("reset --merge")) return Buffer.from("");
      return Buffer.from("");
    });

    // Agent will be called and will fail
    mockedCreateFnAgent.mockImplementation(() => {
      agentCallCount++;
      return Promise.resolve({
        session: {
          prompt: vi.fn().mockRejectedValue(new Error("Agent failed")),
          dispose: vi.fn(),
        },
      } as any);
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toThrow();

    // Should have called agent exactly once (no retries since autoResolve is disabled)
    expect(agentCallCount).toBe(1);
  });

  it("attempt 2 throws when squash fails for a non-conflict reason (no U files)", async () => {
    // Regression: previously any squash error was treated as conflicts. If
    // the failure was non-conflict (hook, IO, lock) and no U files existed,
    // the cascade fell into "all conflicts auto-resolved" and returned true,
    // recording merge metadata for a merge that never happened.
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    let mergeCallCount = 0;
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("merge --squash")) {
        mergeCallCount++;
        // Simulate a non-conflict failure on every squash attempt
        // (e.g. pre-commit hook rejected, repo locked).
        throw new Error("fatal: pre-commit hook returned non-zero status");
      }
      // Critical: no conflicted files surface
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "";
      if (cmdStr.includes("diff --cached --quiet")) return "1";
      if (cmdStr.includes("reset --merge")) return Buffer.from("");
      return Buffer.from("");
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toThrow(
      /failed without producing conflicts/i,
    );
    expect(mergeCallCount).toBeGreaterThanOrEqual(1);
  });

  it("attempt 1 fails, attempt 2 auto-resolves lock files: sets resolutionStrategy to 'auto-resolve'", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    let mergeCallCount = 0;
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";

      if (cmdStr.includes("merge --squash")) {
        mergeCallCount++;
        if (mergeCallCount === 1) {
          // First attempt: conflict
          throw new Error("Merge conflict");
        }
        // Second attempt succeeds after auto-resolution
      }

      if (cmdStr.includes("diff --name-only --diff-filter=U")) {
        // First time: return lock file, second time: empty
        if (mergeCallCount === 1) return "package-lock.json\n";
        return "";
      }

      if (cmdStr.includes("checkout --ours")) return Buffer.from("");
      if (cmdStr.includes("git add")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "0"; // All resolved
      if (cmdStr.includes("branch -d")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr.includes("reset --merge")) return Buffer.from("");

      return Buffer.from("");
    });

    // Agent should not be called since all conflicts are auto-resolved
    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(result.resolutionStrategy).toBe("auto-resolve");
    expect(result.attemptsMade).toBe(2);
  });

  it("attempt 3 uses -X theirs strategy: sets resolutionStrategy to 'theirs'", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    // Pin the strategy: default is now "smart-prefer-main" (-X ours), but
    // this test specifically exercises the -X theirs fallback path.
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      mergeConflictStrategy: "smart-prefer-branch",
    });

    let squashCallCount = 0;
    let theirsCallCount = 0;
    let hasConflicts = true;
    let agentCallCount = 0;

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";

      // First two regular squash merges fail with conflicts
      if (cmdStr.includes("merge --squash") && !cmdStr.includes("-X")) {
        squashCallCount++;
        throw new Error("Merge conflict");
      }

      // Third attempt with -X theirs succeeds (no conflicts)
      if (cmdStr.includes("merge -X theirs --squash")) {
        theirsCallCount++;
        hasConflicts = false;
        return Buffer.from("");
      }

      // After -X theirs, no conflicts
      if (cmdStr.includes("diff --name-only --diff-filter=U")) {
        return hasConflicts ? "src/complex.ts\n" : "";
      }

      // git diff-tree for trivial whitespace detection - return real changes (non-trivial)
      if (cmdStr.includes("diff-tree")) {
        const error = new Error("exit code 1") as any;
        error.stdout = "+const x = 2;\n-const x = 1;";
        throw error;
      }

      if (cmdStr.includes("diff --cached --quiet")) return hasConflicts ? "1" : "0";
      if (cmdStr.includes("git commit")) return Buffer.from("");
      if (cmdStr.includes("branch -d")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr.includes("reset --merge")) return Buffer.from("");

      return Buffer.from("");
    });

    // Agent fails on attempt 2 (when called to resolve complex conflicts)
    mockedCreateFnAgent.mockImplementation(() => {
      agentCallCount++;
      if (agentCallCount === 1) {
        // First agent call (attempt 2) fails
        return Promise.resolve({
          session: {
            prompt: vi.fn().mockRejectedValue(new Error("Agent failed")),
            dispose: vi.fn(),
          },
        } as any);
      }
      // Should not reach here
      return Promise.resolve({
        session: {
          prompt: vi.fn().mockResolvedValue(undefined),
          dispose: vi.fn(),
        },
      } as any);
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(result.resolutionStrategy).toBe("theirs");
    expect(result.attemptsMade).toBe(3);
    expect(theirsCallCount).toBe(1); // -X theirs was used once
    expect(agentCallCount).toBe(1); // Agent was called once (on attempt 2, which failed)
  });

  it("final cleanup reset succeeds after all 3 attempts fail", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    const resetCalls: string[] = [];
    const warnSpy = vi.spyOn(mergerLog, "warn");

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";

      if (cmdStr.includes("merge --squash")) {
        // AI merge attempts fail with conflicts
        throw new Error("Merge conflict");
      }

      if (cmdStr.includes("merge -X theirs")) {
        // -X theirs also fails (some conflicts can't be auto-resolved)
        const err = new Error("Merge conflict");
        err.name = "ExecSyncError";
        throw err;
      }

      if (cmdStr.includes("diff --name-only --diff-filter=U")) {
        return "src/always-conflicts.ts\n"; // Always has conflicts
      }

      // Make auto-resolution fail by making git add fail
      if (cmdStr.includes("git add")) {
        const err = new Error("git add failed");
        err.name = "ExecSyncError";
        throw err;
      }

      if (cmdStr.includes("reset --merge")) {
        resetCalls.push(cmdStr);
        return Buffer.from("");
      }

      return Buffer.from("");
    });

    // Agent will also fail
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockRejectedValue(new Error("Agent failed")),
        dispose: vi.fn(),
      },
    } as any);

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toThrow(
      "all 3 attempts exhausted",
    );

    // Should have cleanup calls after each failed attempt plus final cleanup
    expect(resetCalls.length).toBeGreaterThanOrEqual(3);
    expect(
      warnSpy.mock.calls.some(([message]) => String(message).includes("git reset --merge cleanup failed")),
    ).toBe(false);

    warnSpy.mockRestore();
  });

  it("final cleanup reset failure is logged but does not change thrown error", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    const resetFailureMessage = "reset failed: dirty worktree";
    const warnSpy = vi.spyOn(mergerLog, "warn");

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";

      if (cmdStr.includes("merge --squash")) {
        throw new Error("Merge conflict");
      }

      if (cmdStr.includes("merge -X theirs")) {
        const err = new Error("Merge conflict");
        err.name = "ExecSyncError";
        throw err;
      }

      if (cmdStr.includes("diff --name-only --diff-filter=U")) {
        return "src/always-conflicts.ts\n";
      }

      if (cmdStr.includes("git add")) {
        const err = new Error("git add failed");
        err.name = "ExecSyncError";
        throw err;
      }

      if (cmdStr.includes("reset --merge")) {
        throw new Error(resetFailureMessage);
      }

      return Buffer.from("");
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockRejectedValue(new Error("Agent failed")),
        dispose: vi.fn(),
      },
    } as any);

    let thrown: unknown;
    try {
      await aiMergeTask(store, "/tmp/root", "FN-050");
    } catch (error) {
      thrown = error;
    }

    expect(thrown).toBeInstanceOf(Error);
    expect((thrown as Error).message).toContain("all 3 attempts exhausted");
    expect((thrown as Error).message).not.toContain(resetFailureMessage);

    const cleanupWarnMessages = warnSpy.mock.calls
      .map(([message]) => String(message))
      .filter((message) => message.includes("git reset --merge cleanup failed"));

    expect(cleanupWarnMessages.length).toBeGreaterThan(0);
    expect(cleanupWarnMessages.some((message) => message.includes(resetFailureMessage))).toBe(true);

    warnSpy.mockRestore();
  });

  it("retry-cleanup reset failure after attempt 1 is logged and merge continues to attempt 2", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    const warnSpy = vi.spyOn(mergerLog, "warn");
    const resetFailureMessage = "attempt-1 cleanup reset failed";
    let mergeSquashCalls = 0;
    let resetCalls = 0;

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("show --shortstat")) return "1 file changed, 1 insertion(+), 0 deletions(-)";

      if (cmdStr.includes("merge --squash") && !cmdStr.includes("-X")) {
        mergeSquashCalls++;
        if (mergeSquashCalls === 1) {
          throw new Error("Merge conflict");
        }
        return Buffer.from("");
      }

      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "";
      if (cmdStr.includes("diff --cached --quiet")) return "0";

      if (cmdStr.includes("reset --merge")) {
        resetCalls++;
        if (resetCalls === 1) {
          throw new Error(resetFailureMessage);
        }
        return Buffer.from("");
      }

      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(result.attemptsMade).toBe(2);
    expect(mergeSquashCalls).toBe(2);

    const cleanupWarnMessages = warnSpy.mock.calls
      .map(([message]) => String(message))
      .filter((message) => message.includes("git reset --merge cleanup failed"));

    expect(cleanupWarnMessages.some((message) => message.includes("merge-cleanup, attempt 1"))).toBe(true);
    expect(cleanupWarnMessages.some((message) => message.includes(resetFailureMessage))).toBe(true);

    warnSpy.mockRestore();
  });

  it("build-retry reset failure is logged when build verification fails", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      buildRetryCount: 1,
      verificationFixRetries: 0,
    });

    const warnSpy = vi.spyOn(mergerLog, "warn");
    const buildFailureMessage = "Build verification failed: tsc error";
    const resetFailureMessage = "build-retry reset failed";
    let resetCalls = 0;

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("merge --squash") && !cmdStr.includes("-X")) return Buffer.from("");
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "";
      if (cmdStr.includes("diff --cached --quiet")) return "1";

      if (cmdStr.includes("reset --merge")) {
        resetCalls++;
        if (resetCalls === 1) {
          throw new Error(resetFailureMessage);
        }
        return Buffer.from("");
      }

      return Buffer.from("");
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockRejectedValue(new Error(buildFailureMessage)),
        dispose: vi.fn(),
      },
    } as any);

    let thrown: unknown;
    try {
      await aiMergeTask(store, "/tmp/root", "FN-050");
    } catch (error) {
      thrown = error;
    }

    expect(thrown).toBeInstanceOf(Error);
    expect((thrown as Error).message).toContain(buildFailureMessage);
    expect((thrown as Error).message).not.toContain(resetFailureMessage);

    const cleanupWarnMessages = warnSpy.mock.calls
      .map(([message]) => String(message))
      .filter((message) => message.includes("git reset --merge cleanup failed"));

    expect(cleanupWarnMessages.some((message) => message.includes("build-retry"))).toBe(true);
    expect(cleanupWarnMessages.some((message) => message.includes(resetFailureMessage))).toBe(true);

    warnSpy.mockRestore();
  });

  it("error-path retry cleanup reset failure is logged and merge still retries", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    const warnSpy = vi.spyOn(mergerLog, "warn");
    const resetFailureMessage = "retry cleanup reset failed";
    let mergeSquashCalls = 0;
    let resetCalls = 0;
    let usedFallbackStrategy = false;

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("show --shortstat")) return "3 files changed, 10 insertions(+), 2 deletions(-)";

      if (cmdStr.includes("merge --squash") && !cmdStr.includes("-X")) {
        mergeSquashCalls++;
        if (mergeSquashCalls === 1) {
          throw new Error("Merge conflict");
        }
        return Buffer.from("");
      }

      if (cmdStr.includes("merge -X theirs --squash") || cmdStr.includes("merge -X ours --squash")) {
        usedFallbackStrategy = true;
        return Buffer.from("");
      }

      if (cmdStr.includes("diff --name-only --diff-filter=U")) {
        if (!usedFallbackStrategy && mergeSquashCalls === 2) {
          return "src/complex.ts\n";
        }
        return "";
      }

      if (cmdStr.includes("diff-tree")) {
        const error = new Error("exit code 1") as any;
        error.stdout = "+const value = 2;\n-const value = 1;";
        throw error;
      }

      if (cmdStr.includes("diff --cached --quiet")) return "1";

      if (cmdStr.includes("git commit")) return Buffer.from("");

      if (cmdStr.includes("reset --merge")) {
        resetCalls++;
        if (resetCalls === 2) {
          throw new Error(resetFailureMessage);
        }
        return Buffer.from("");
      }

      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockRejectedValue(new Error("Agent failed on attempt 2")),
        dispose: vi.fn(),
      },
    } as any);

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(result.attemptsMade).toBe(3);
    expect(mergeSquashCalls).toBe(2);

    const cleanupWarnMessages = warnSpy.mock.calls
      .map(([message]) => String(message))
      .filter((message) => message.includes("git reset --merge cleanup failed"));

    expect(cleanupWarnMessages.some((message) => message.includes("merge-retry, attempt 2"))).toBe(true);
    expect(cleanupWarnMessages.some((message) => message.includes(resetFailureMessage))).toBe(true);

    warnSpy.mockRestore();
  });

  it("tracks resolutionStrategy as 'ai' when attempt 1 succeeds even with autoResolve enabled", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    // Clean merge with no conflicts
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return ""; // No conflicts
      if (cmdStr.includes("diff --cached --quiet")) return "1"; // Has staged changes
      if (cmdStr.includes("git commit")) return Buffer.from("");
      if (cmdStr.includes("branch -d")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(result.resolutionStrategy).toBe("ai");
    expect(result.attemptsMade).toBe(1);
  });
});

describe("aiMergeTask — reset cleanup failure diagnostics", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
  });

  it("retry-cleanup reset failure after failed attempt is logged", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    const warnSpy = vi.spyOn(mergerLog, "warn");
    const resetFailureMessage = "dirty worktree";
    let resetCalls = 0;

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("show --shortstat")) return "1 file changed, 1 insertion(+), 0 deletions(-)";

      if (cmdStr.includes("merge --squash") && !cmdStr.includes("-X")) {
        throw new Error("Merge conflict");
      }

      if (cmdStr.includes("merge -X theirs --squash")) {
        throw new Error("Merge conflict");
      }

      if (cmdStr.includes("diff --name-only --diff-filter=U")) {
        return "src/always-conflicts.ts\n";
      }

      if (cmdStr.includes("diff-tree")) {
        const error = new Error("exit code 1") as any;
        error.stdout = "+const x = 2;\n-const x = 1;";
        throw error;
      }

      if (cmdStr.includes("git add")) {
        const err = new Error("git add failed");
        err.name = "ExecSyncError";
        throw err;
      }

      if (cmdStr.includes("reset --merge")) {
        resetCalls++;
        if (resetCalls === 1) {
          throw new Error(resetFailureMessage);
        }
        return Buffer.from("");
      }

      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockRejectedValue(new Error("Agent failed")),
        dispose: vi.fn(),
      },
    } as any);

    let thrown: unknown;
    try {
      await aiMergeTask(store, "/tmp/root", "FN-050");
    } catch (error) {
      thrown = error;
    }

    expect(thrown).toBeInstanceOf(Error);
    expect((thrown as Error).message).toContain("all 3 attempts exhausted");
    expect((thrown as Error).message).not.toContain(resetFailureMessage);

    const cleanupWarnMessages = warnSpy.mock.calls
      .map(([message]) => String(message))
      .filter((message) => message.includes("git reset --merge cleanup failed"));

    expect(cleanupWarnMessages.some((message) => message.includes("merge-cleanup"))).toBe(true);
    expect(cleanupWarnMessages.some((message) => message.includes(resetFailureMessage))).toBe(true);

    warnSpy.mockRestore();
  });

  it("error-path retry cleanup reset failure is logged", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    const warnSpy = vi.spyOn(mergerLog, "warn");
    const resetFailureMessage = "retry cleanup reset failed";
    let mergeSquashCalls = 0;
    let resetCalls = 0;

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed";

      if (cmdStr.includes("merge --squash") && !cmdStr.includes("-X")) {
        mergeSquashCalls++;
        if (mergeSquashCalls === 1) {
          throw new Error("git merge failed: exit code 128");
        }
        return Buffer.from("");
      }

      if (cmdStr.includes("merge -X theirs --squash") || cmdStr.includes("merge -X ours --squash")) {
        throw new Error("Merge conflict");
      }

      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "";
      if (cmdStr.includes("diff --cached --quiet")) return "1";

      if (cmdStr.includes("reset --merge")) {
        resetCalls++;
        if (resetCalls === 2) {
          throw new Error(resetFailureMessage);
        }
        return Buffer.from("");
      }

      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockRejectedValue(new Error("git merge failed: exit code 128")),
        dispose: vi.fn(),
      },
    } as any);

    let thrown: unknown;
    try {
      await aiMergeTask(store, "/tmp/root", "FN-050");
    } catch (error) {
      thrown = error;
    }

    expect(thrown).toBeInstanceOf(Error);
    expect((thrown as Error).message).toContain("all 3 attempts exhausted");
    expect((thrown as Error).message).not.toContain(resetFailureMessage);

    const cleanupWarnMessages = warnSpy.mock.calls
      .map(([message]) => String(message))
      .filter((message) => message.includes("git reset --merge cleanup failed"));

    expect(cleanupWarnMessages.some((message) => message.includes("merge-retry"))).toBe(true);
    expect(cleanupWarnMessages.some((message) => message.includes(resetFailureMessage))).toBe(true);

    warnSpy.mockRestore();
  });

  it("build-verification reset failure is logged in executeMergeAttempt", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      buildCommand: "pnpm build",
      buildRetryCount: 0,
      verificationFixRetries: 0,
    });

    const warnSpy = vi.spyOn(mergerLog, "warn");
    const resetFailureMessage = "lock file busy";

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      const reportTool = opts.customTools?.find((t: any) => t.name === "fn_report_build_failure");
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            if (reportTool) {
              await reportTool.execute("tool-call-1", { message: "build failed" });
            }
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("merge --squash") && !cmdStr.includes("-X")) return Buffer.from("");
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "";
      if (cmdStr.includes("diff --cached --quiet")) return "1";

      if (cmdStr.includes("reset --merge")) {
        throw new Error(resetFailureMessage);
      }

      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    let thrown: unknown;
    try {
      await aiMergeTask(store, "/tmp/root", "FN-050");
    } catch (error) {
      thrown = error;
    }

    expect(thrown).toBeInstanceOf(Error);
    expect((thrown as Error).message).toContain("Build verification failed");
    expect((thrown as Error).message).not.toContain(resetFailureMessage);

    const cleanupWarnMessages = warnSpy.mock.calls
      .map(([message]) => String(message))
      .filter((message) => message.includes("git reset --merge cleanup failed"));

    // Reset cleanup now runs from mergeAttempt's catch handler (after the
    // squash state is preserved across the build-failure throw site for the
    // in-merge fix path). With both verificationFixRetries=0 and
    // buildRetryCount=0 the rollback fires from the "no retries left" branch.
    expect(cleanupWarnMessages.some((message) => message.includes("build-verification rollback"))).toBe(true);
    expect(cleanupWarnMessages.some((message) => message.includes(resetFailureMessage))).toBe(true);

    warnSpy.mockRestore();
  });
});

// ── New Smart Conflict Resolution API Tests ────────────────────────────

describe("classifyConflict", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it("classifies package-lock.json as 'lockfile-ours'", async () => {
    const result = await classifyConflict("package-lock.json", "/tmp/root");
    expect(result).toBe("lockfile-ours");
  });

  it("classifies pnpm-lock.yaml as 'lockfile-ours'", async () => {
    const result = await classifyConflict("pnpm-lock.yaml", "/tmp/root");
    expect(result).toBe("lockfile-ours");
  });

  it("classifies yarn.lock as 'lockfile-ours'", async () => {
    const result = await classifyConflict("yarn.lock", "/tmp/root");
    expect(result).toBe("lockfile-ours");
  });

  it("classifies Gemfile.lock as 'lockfile-ours'", async () => {
    const result = await classifyConflict("Gemfile.lock", "/tmp/root");
    expect(result).toBe("lockfile-ours");
  });

  it("classifies bun.lockb as 'lockfile-ours'", async () => {
    const result = await classifyConflict("bun.lockb", "/tmp/root");
    expect(result).toBe("lockfile-ours");
  });

  it("classifies go.sum as 'lockfile-ours'", async () => {
    const result = await classifyConflict("go.sum", "/tmp/root");
    expect(result).toBe("lockfile-ours");
  });

  it("classifies *.gen.ts files as 'generated-theirs'", async () => {
    const result = await classifyConflict("src/types.gen.ts", "/tmp/root");
    expect(result).toBe("generated-theirs");
  });

  it("classifies dist/* files as 'generated-theirs'", async () => {
    const result = await classifyConflict("dist/bundle.js", "/tmp/root");
    expect(result).toBe("generated-theirs");
  });

  it("classifies build/* files as 'generated-theirs'", async () => {
    const result = await classifyConflict("build/index.html", "/tmp/root");
    expect(result).toBe("generated-theirs");
  });

  it("classifies *.min.js files as 'generated-theirs'", async () => {
    const result = await classifyConflict("app.min.js", "/tmp/root");
    expect(result).toBe("generated-theirs");
  });

  it("classifies regular source files as 'complex'", async () => {
    // Mock git diff-tree to return actual content changes (non-trivial)
    mockedExecSync.mockImplementation(() => {
      const error = new Error("exit code 1") as any;
      error.stdout = `diff --git a/src/components/App.tsx b/src/components/App.tsx
--- a/src/components/App.tsx
+++ b/src/components/App.tsx
@@ -1 +1 @@
-const x = 1;
+const x = 2;`;
      throw error;
    });
    mockedReadFileSync.mockReturnValue("const x = 1;");
    const result = await classifyConflict("src/components/App.tsx", "/tmp/root");
    expect(result).toBe("complex");
  });
});

describe("getConflictedFiles", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it("returns array of conflicted file paths", async () => {
    mockedExecSync.mockReturnValue("package-lock.json\nsrc/index.ts\n");

    const result = await getConflictedFiles("/tmp/root");
    expect(result).toEqual(["package-lock.json", "src/index.ts"]);
  });

  it("returns empty array when no conflicts", async () => {
    mockedExecSync.mockReturnValue("");

    const result = await getConflictedFiles("/tmp/root");
    expect(result).toEqual([]);
  });

  it("returns empty array on git error", async () => {
    mockedExecSync.mockImplementation(() => {
      throw new Error("git error");
    });

    const result = await getConflictedFiles("/tmp/root");
    expect(result).toEqual([]);
  });
});

describe("resolveWithOurs", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExecSync.mockReturnValue(Buffer.from(""));
  });

  it("calls git checkout --ours and git add", async () => {
    await resolveWithOurs("package-lock.json", "/tmp/root");

    const checkoutCall = mockedExecSync.mock.calls.find((call) =>
      String(call[0]).includes("checkout --ours"),
    );
    const addCall = mockedExecSync.mock.calls.find((call) =>
      String(call[0]).includes("git add"),
    );

    expect(checkoutCall).toBeDefined();
    expect(addCall).toBeDefined();
    expect(String(checkoutCall![0])).toContain("package-lock.json");
  });

  it("throws on git error", async () => {
    mockedExecSync.mockImplementation(() => {
      throw new Error("checkout failed");
    });

    await expect(resolveWithOurs("file.ts", "/tmp/root")).rejects.toThrow(
      "Failed to auto-resolve",
    );
  });
});

describe("resolveWithTheirs", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExecSync.mockReturnValue(Buffer.from(""));
  });

  it("calls git checkout --theirs and git add", async () => {
    await resolveWithTheirs("dist/bundle.js", "/tmp/root");

    const checkoutCall = mockedExecSync.mock.calls.find((call) =>
      String(call[0]).includes("checkout --theirs"),
    );
    const addCall = mockedExecSync.mock.calls.find((call) =>
      String(call[0]).includes("git add"),
    );

    expect(checkoutCall).toBeDefined();
    expect(addCall).toBeDefined();
    expect(String(checkoutCall![0])).toContain("dist/bundle.js");
  });

  it("throws on git error", async () => {
    mockedExecSync.mockImplementation(() => {
      throw new Error("checkout failed");
    });

    await expect(resolveWithTheirs("file.ts", "/tmp/root")).rejects.toThrow(
      "Failed to auto-resolve",
    );
  });
});

describe("resolveTrivialWhitespace", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExecSync.mockReturnValue(Buffer.from(""));
  });

  it("calls git add to resolve trivial whitespace conflict", async () => {
    await resolveTrivialWhitespace("src/utils.ts", "/tmp/root");

    const addCall = mockedExecSync.mock.calls.find((call) =>
      String(call[0]).includes("git add"),
    );

    expect(addCall).toBeDefined();
    expect(String(addCall![0])).toContain("src/utils.ts");
  });

  it("throws on git error", async () => {
    mockedExecSync.mockImplementation(() => {
      throw new Error("add failed");
    });

    await expect(resolveTrivialWhitespace("file.ts", "/tmp/root")).rejects.toThrow(
      "Failed to auto-resolve",
    );
  });
});

describe("LOCKFILE_PATTERNS and GENERATED_PATTERNS", () => {
  it("LOCKFILE_PATTERNS contains expected lock file patterns", () => {
    expect(LOCKFILE_PATTERNS).toContain("package-lock.json");
    expect(LOCKFILE_PATTERNS).toContain("pnpm-lock.yaml");
    expect(LOCKFILE_PATTERNS).toContain("yarn.lock");
    expect(LOCKFILE_PATTERNS).toContain("Gemfile.lock");
    expect(LOCKFILE_PATTERNS).toContain("bun.lockb");
    expect(LOCKFILE_PATTERNS).toContain("go.sum");
    expect(LOCKFILE_PATTERNS).toContain("composer.lock");
    expect(LOCKFILE_PATTERNS).toContain("poetry.lock");
    expect(LOCKFILE_PATTERNS).not.toContain("Cargo.lock"); // Not in task spec
  });

  it("GENERATED_PATTERNS contains expected generated file patterns", () => {
    expect(GENERATED_PATTERNS).toContain("*.gen.ts");
    expect(GENERATED_PATTERNS).toContain("*.gen.js");
    expect(GENERATED_PATTERNS).toContain("*.min.js");
    expect(GENERATED_PATTERNS).toContain("*.min.css");
    expect(GENERATED_PATTERNS).toContain("dist/*");
    expect(GENERATED_PATTERNS).toContain("build/*");
    expect(GENERATED_PATTERNS).toContain("coverage/*");
    expect(GENERATED_PATTERNS).toContain("out/*");
  });
});

describe("isTrivialWhitespaceConflict", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it("returns true when diff contains only whitespace changes", async () => {
    // Mock git diff-tree to return empty diff (no content changes)
    mockedExecSync.mockReturnValue(
      "diff --git a/file.ts b/file.ts\nindex 123..456 100644\n--- a/file.ts\n+++ b/file.ts\n"
    );

    const result = await isTrivialWhitespaceConflict("src/file.ts", "/tmp/root");
    expect(result).toBe(true);
  });

  it("returns false when diff contains content changes", async () => {
    // Mock git diff-tree to return diff with actual content changes
    mockedExecSync.mockImplementation(() => {
      const error = new Error("exit code 1") as any;
      error.stdout = `diff --git a/file.ts b/file.ts
--- a/file.ts
+++ b/file.ts
@@ -1 +1 @@
-const x = 1;
+const x = 2;`;
      throw error;
    });

    const result = await isTrivialWhitespaceConflict("src/file.ts", "/tmp/root");
    expect(result).toBe(false);
  });

  it("returns true when only line endings differ (CRLF vs LF)", async () => {
    // Mock git diff-tree -w to show no content changes (whitespace ignored)
    mockedExecSync.mockReturnValue(
      "diff --git a/file.ts b/file.ts\nindex 123..456 100644\n--- a/file.ts\n+++ b/file.ts\n"
    );

    const result = await isTrivialWhitespaceConflict("src/file.ts", "/tmp/root");
    expect(result).toBe(true);
  });

  it("returns false when git diff-tree fails unexpectedly", async () => {
    mockedExecSync.mockImplementation(() => {
      throw new Error("fatal: not a git repository");
    });
    // Mock readFileSync for the fallback
    mockedReadFileSync.mockReturnValue("content without conflict markers");

    const result = await isTrivialWhitespaceConflict("src/file.ts", "/tmp/root");
    expect(result).toBe(false);
  });

  it("calls git diff-tree with correct index references (:2: and :3:)", async () => {
    mockedExecSync.mockReturnValue("");

    await isTrivialWhitespaceConflict("src/utils.ts", "/tmp/root");

    const call = mockedExecSync.mock.calls.find((call) =>
      String(call[0]).includes("git diff-tree")
    );
    expect(call).toBeDefined();
    const cmdStr = String(call![0]);
    expect(cmdStr).toContain("-w"); // whitespace ignored
    expect(cmdStr).toContain(':2:"src/utils.ts"');
    expect(cmdStr).toContain(':3:"src/utils.ts"');
  });
});

// ── Build Verification Tests ─────────────────────────────────────────

describe("aiMergeTask — build verification", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    // Default happy path exec mock
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached") && !cmdStr.includes("--quiet")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr.includes("reset --merge")) return Buffer.from("");
      return Buffer.from("");
    });
  });

  it("system prompt contains build verification section", async () => {
    let capturedSystemPrompt: string | undefined;
    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      capturedSystemPrompt = opts.systemPrompt;
      return {
        session: {
          prompt: vi.fn().mockResolvedValue(undefined),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore();
    await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(capturedSystemPrompt).toContain("## Build verification");
    expect(capturedSystemPrompt).toContain("build verification is a hard gate");
    expect(capturedSystemPrompt).toContain("Do not assume the build passes");
    expect(capturedSystemPrompt).toContain("fn_report_build_failure");
  });

  it("includes build command in merge prompt when configured", async () => {
    let capturedArgs: any;
    let capturedPrompt: string | undefined;
    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      capturedArgs = opts;
      // Simulate agent committing by returning session that results in clean state
      return {
        session: {
          prompt: vi.fn().mockImplementation(async (prompt: string) => {
            capturedPrompt = prompt;
            // Simulate commit happening by making staged check return "0" (clean)
            mockedExecSync.mockImplementation((cmd: any) => {
              const cmdStr = String(cmd);
              if (cmdStr.includes("rev-parse")) return Buffer.from("abc123");
              if (cmdStr.includes("git log")) return "- feat: something" as any;
              if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
              if (cmdStr.includes("--stat")) return "1 file changed" as any;
              if (cmdStr.includes("merge --squash")) return Buffer.from("");
              // After commit, diff shows clean
              if (cmdStr.includes("diff --cached --quiet")) return "0" as any;
              if (cmdStr.includes("branch -d")) return Buffer.from("");
              if (cmdStr.includes("worktree remove")) return Buffer.from("");
              return Buffer.from("");
            });
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      buildCommand: "pnpm build",
    });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    // Verify custom tool was passed
    expect(capturedArgs.customTools).toBeDefined();
    expect(capturedArgs.customTools.some((t: any) => t.name === "fn_report_build_failure")).toBe(true);
    expect(capturedPrompt).toContain("Build command: `pnpm build`");
    expect(capturedPrompt).toContain("This command is mandatory before commit.");
    expect(capturedPrompt).toContain("Only commit if it exits 0.");
    expect(capturedPrompt).toContain("call `fn_report_build_failure`");
  });

  it("merge succeeds when build passes (agent reports success)", async () => {
    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            // Simulate commit happening by making staged check return "0" (clean)
            mockedExecSync.mockImplementation((cmd: any) => {
              const cmdStr = String(cmd);
              if (cmdStr.includes("rev-parse")) return Buffer.from("abc123");
              if (cmdStr.includes("git log")) return "- feat: something" as any;
              if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
              if (cmdStr.includes("--stat")) return "1 file changed" as any;
              if (cmdStr.includes("merge --squash")) return Buffer.from("");
              // After commit, diff shows clean
              if (cmdStr.includes("diff --cached --quiet")) return "0" as any;
              if (cmdStr.includes("branch -d")) return Buffer.from("");
              if (cmdStr.includes("worktree remove")) return Buffer.from("");
              return Buffer.from("");
            });
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      buildCommand: "pnpm build",
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
  });

  it("merge aborts when build fails via fn_report_build_failure tool", async () => {
    // Mock agent that calls the fn_report_build_failure tool execute method
    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      const reportTool = opts.customTools?.find((t: any) => t.name === "fn_report_build_failure");
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            // Simulate the agent calling the tool when session.prompt() is called
            if (reportTool) {
              await reportTool.execute("tool-call-123", { message: "Type error in src/utils.ts" });
            }
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const resetCalls: string[] = [];
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("reset --merge")) {
        resetCalls.push(cmdStr);
        return Buffer.from("");
      }
      // Default happy path for other commands
      if (cmdStr.includes("rev-parse")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      // Staged changes present (agent didn't commit due to build failure)
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("branch -d")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      buildCommand: "pnpm build",
      verificationFixRetries: 0, // Disable in-merge fix for this test
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toThrow(
      "Build verification failed for FN-050: Type error in src/utils.ts",
    );

    // Verify git reset --merge was called
    expect(resetCalls.length).toBeGreaterThan(0);
    // Verify task was NOT moved to done
    expect(store.moveTask).not.toHaveBeenCalled();
    // Verify log entry was made
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      "Build verification failed during merge",
      "Type error in src/utils.ts",
    );
  });

  it("logs warning when git reset --merge fails during build-verification rollback", async () => {
    const store = createMockStore(
      { id: "FN-099", worktree: "/tmp/root/.worktrees/KB-099" },
      [{ id: "FN-099", worktree: "/tmp/root/.worktrees/KB-099", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      buildCommand: "pnpm build",
      verificationFixRetries: 0,
    });

    const warnSpy = vi.spyOn(mergerLog, "warn");
    const resetFailureMessage = "reset failed: dirty working tree";

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      const reportTool = opts.customTools?.find((t: any) => t.name === "fn_report_build_failure");
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            await reportTool?.execute("tool-call-1", {
              message: "Type error in src/utils.ts",
            });
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1";
      if (cmdStr.includes("git reset --merge")) throw new Error(resetFailureMessage);
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-099")).rejects.toThrow(
      "Build verification failed for FN-099: Type error in src/utils.ts",
    );

    expect(warnSpy).toHaveBeenCalledWith(
      expect.stringContaining("FN-099: git reset --merge cleanup failed during build-verification rollback"),
    );
    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining(resetFailureMessage));

    warnSpy.mockRestore();
  });

  it("merge proceeds normally when no build command is configured", async () => {
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    // buildCommand is undefined by default in DEFAULT_SETTINGS

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
  });

  it("merge proceeds when buildCommand is empty string (treated as undefined)", async () => {
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      buildCommand: "   ", // whitespace-only, should be treated as undefined
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
  });

  it("syncs dependencies before build verification when install state is missing", async () => {
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);

    mockedExistsSync.mockImplementation((path: any) => {
      const pathStr = String(path);
      if (pathStr.includes("node_modules") || pathStr.endsWith(".pnp.cjs")) return false;
      return true;
    });

    let cachedQuietChecks = 0;
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "2 files changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "" as any;
      if (cmdStr.includes("git diff --cached --name-only")) {
        return "package.json\npackages/desktop/package.json" as any;
      }
      if (cmdStr.includes("pnpm install --frozen-lockfile")) return "Lockfile is up to date" as any;
      if (cmdStr.includes("diff --cached --quiet")) {
        cachedQuietChecks += 1;
        return cachedQuietChecks === 1 ? "1" as any : "0" as any;
      }
      if (cmdStr.includes("show --shortstat")) return "3 files changed, 10 insertions(+), 2 deletions(-)" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      buildCommand: "pnpm build",
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    const installCall = mockedExecSync.mock.calls.find(
      (call) => String(call[0]).includes("pnpm install --frozen-lockfile"),
    );
    expect(installCall).toBeDefined();
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      "Syncing dependencies before merge build verification: pnpm install --frozen-lockfile",
    );
  });
});

// ── Deterministic Merge Verification Tests ──────────────────────────────

describe("aiMergeTask — deterministic merge verification", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    // Default happy path exec mock
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached") && !cmdStr.includes("--quiet")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr.includes("reset --merge")) return Buffer.from("");
      return Buffer.from("");
    });
  });

  it("runs testCommand before buildCommand when both are configured", async () => {
    const verificationOrder: string[] = [];
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      // Record verification command calls
      if (cmdStr.includes("vitest run")) {
        verificationOrder.push("test");
        return Buffer.from("");
      }
      if (cmdStr.includes("pnpm build")) {
        verificationOrder.push("build");
        return Buffer.from("");
      }
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached") && !cmdStr.includes("--quiet")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr.includes("reset --merge")) return Buffer.from("");
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            // Simulate commit
            mockedExecSync.mockImplementation((cmd: any) => {
              const cmdStr = String(cmd);
              if (cmdStr.includes("rev-parse")) return Buffer.from("abc123");
              if (cmdStr.includes("git log")) return "- feat: something" as any;
              if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
              if (cmdStr.includes("--stat")) return "1 file changed" as any;
              if (cmdStr.includes("merge --squash")) return Buffer.from("");
              if (cmdStr.includes("vitest run")) {
                verificationOrder.push("test");
                return Buffer.from("");
              }
              if (cmdStr.includes("pnpm build")) {
                verificationOrder.push("build");
                return Buffer.from("");
              }
              if (cmdStr.includes("diff --cached --quiet")) return "0" as any;
              if (cmdStr.includes("branch -d")) return Buffer.from("");
              if (cmdStr.includes("worktree remove")) return Buffer.from("");
              return Buffer.from("");
            });
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
      buildCommand: "pnpm build",
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(verificationOrder).toEqual(["test", "build"]);
  });

  it("writes verification start/success entries to agent log", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("vitest run")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached") && !cmdStr.includes("--quiet")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      if (cmdStr.includes("show --shortstat")) return "1 file changed, 1 insertion(+)" as any;
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(store.appendAgentLog).toHaveBeenCalledWith(
      "FN-050",
      "Running deterministic merge verification (test: vitest run)",
      "text",
      undefined,
      "merger",
    );
    expect(store.appendAgentLog).toHaveBeenCalledWith(
      "FN-050",
      "Running test command",
      "tool",
      "vitest run",
      "merger",
    );

    const appendAgentLogCalls = (store.appendAgentLog as ReturnType<typeof vi.fn>).mock.calls;
    const successCall = appendAgentLogCalls.find(
      ([task, message, type]) => task === "FN-050"
        && message === "test command succeeded (exit 0)"
        && type === "tool_result",
    );
    expect(successCall).toBeTruthy();
    expect(successCall?.[3]).toMatch(/^\d+ms$/);
    expect(successCall?.[4]).toBe("merger");

    expect(store.appendAgentLog).toHaveBeenCalledWith(
      "FN-050",
      "Deterministic merge verification passed",
      "text",
      undefined,
      "merger",
    );
  });

  it("writes verification failure output summaries to agent log", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("vitest run")) {
        const error = new Error("Test failed") as any;
        error.status = 1;
        error.stdout = "FAIL: some test failed";
        error.stderr = "";
        throw error;
      }
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
      verificationFixRetries: 0,
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toThrow(
      "Deterministic test verification failed",
    );

    const appendAgentLogCalls = (store.appendAgentLog as ReturnType<typeof vi.fn>).mock.calls;
    const failureCall = appendAgentLogCalls.find(
      ([task, message, type]) => task === "FN-050"
        && message === "test command failed (exit 1)"
        && type === "tool_error",
    );
    expect(failureCall).toBeTruthy();
    expect(failureCall?.[3]).toContain("full output available in engine logs");
    expect(failureCall?.[4]).toBe("merger");
  });

  it("fails merge when testCommand fails and does not move task to done", async () => {
    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      // Fail the test command
      if (cmdStr.includes("vitest run")) {
        const error = new Error("Test failed") as any;
        error.status = 1;
        error.stdout = "FAIL: some test failed";
        error.stderr = "";
        throw error;
      }
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      return {
        session: {
          prompt: vi.fn().mockResolvedValue(undefined),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
    });

    try {
      await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toThrow(
        "Deterministic test verification failed",
      );
      const consoleErrors = errorSpy.mock.calls.flat().join("\n");
      expect(consoleErrors).not.toContain("FAIL: some test failed");
    } finally {
      errorSpy.mockRestore();
    }

    // Verify task was NOT moved to done
    expect(store.moveTask).not.toHaveBeenCalled();
    // Verify log entry was made
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Deterministic test verification failed"),
      "VerificationError",
    );

    // Verify log entry contains summary (not raw output) with engine logs reference
    const logCalls = (store.logEntry as ReturnType<typeof vi.fn>).mock.calls;
    const verificationFailCall = logCalls.find((call: any[]) =>
      typeof call[1] === "string" && call[1].includes("[verification] test command failed"),
    );
    expect(verificationFailCall).toBeTruthy();
    expect(verificationFailCall![1]).toContain("full output available in engine logs");
  });

  it("does not fail verification when verbose test output exceeds buffer after exit 0", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("vitest run")) {
        const error = new Error("stdout maxBuffer length exceeded") as any;
        error.code = "ENOBUFS";
        error.status = 0;
        error.stdout = "tests passed but output was verbose";
        error.stderr = "";
        throw error;
      }
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached") && !cmdStr.includes("--quiet")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      if (cmdStr.includes("show --shortstat")) return "1 file changed, 1 insertion(+)" as any;
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockImplementation(async () => ({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    }) as any);

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringMatching(/^\[timing\] \[verification\] test command succeeded \(exit 0(?:, output exceeded buffer)?\) in \d+ms$/),
    );
  });

  it("fails merge when buildCommand fails and does not move task to done", async () => {
    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
    // Setup exec mock that will be updated after agent commits
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      // Initial diff check - staged changes exist
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            // After agent "commits", update mock to handle verification commands
            mockedExecSync.mockImplementation((cmd: any) => {
              const cmdStr = String(cmd);
              if (cmdStr.includes("rev-parse")) return Buffer.from("abc123");
              if (cmdStr.includes("git log")) return "- feat: something" as any;
              if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
              if (cmdStr.includes("--stat")) return "1 file changed" as any;
              if (cmdStr.includes("merge --squash")) return Buffer.from("");
              // test passes
              if (cmdStr.includes("vitest run")) return Buffer.from("");
              // Fail the build command
              if (cmdStr.includes("pnpm build")) {
                const error = new Error("Build failed") as any;
                error.status = 1;
                error.stdout = "";
                error.stderr = "Type error in src/utils.ts";
                throw error;
              }
              if (cmdStr.includes("diff --cached --quiet")) return "0" as any;
              if (cmdStr.includes("branch -d")) return Buffer.from("");
              if (cmdStr.includes("worktree remove")) return Buffer.from("");
              return Buffer.from("");
            });
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
      buildCommand: "pnpm build",
    });

    try {
      await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toThrow(
        "Deterministic build verification failed",
      );
      const consoleErrors = errorSpy.mock.calls.flat().join("\n");
      expect(consoleErrors).not.toContain("Type error in src/utils.ts");
    } finally {
      errorSpy.mockRestore();
    }

    // Verify task was NOT moved to done
    expect(store.moveTask).not.toHaveBeenCalled();
  });

  it("enforces verification when merge uses fallback commit", async () => {
    const verificationCalls: string[] = [];

    // Initial exec mock - will be updated after agent commits
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            // After agent "commits", update mock for verification
            mockedExecSync.mockImplementation((cmd: any) => {
              const cmdStr = String(cmd);
              if (cmdStr.includes("rev-parse")) return Buffer.from("abc123");
              if (cmdStr.includes("git log")) return "- feat: something" as any;
              if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
              if (cmdStr.includes("--stat")) return "1 file changed" as any;
              if (cmdStr.includes("merge --squash")) return Buffer.from("");
              // Track verification commands
              if (cmdStr.includes("vitest run")) {
                verificationCalls.push("test");
                return Buffer.from("");
              }
              if (cmdStr.includes("diff --cached --quiet")) return "0" as any;
              if (cmdStr.includes("branch -d")) return Buffer.from("");
              if (cmdStr.includes("worktree remove")) return Buffer.from("");
              return Buffer.from("");
            });
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    // Verification should have run
    expect(verificationCalls).toContain("test");
  });

  it("skips verification when neither testCommand nor buildCommand is configured", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached") && !cmdStr.includes("--quiet")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            // Simulate commit
            mockedExecSync.mockImplementation((cmd: any) => {
              const cmdStr = String(cmd);
              if (cmdStr.includes("rev-parse")) return Buffer.from("abc123");
              if (cmdStr.includes("git log")) return "- feat: something" as any;
              if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
              if (cmdStr.includes("--stat")) return "1 file changed" as any;
              if (cmdStr.includes("merge --squash")) return Buffer.from("");
              if (cmdStr.includes("diff --cached --quiet")) return "0" as any;
              if (cmdStr.includes("branch -d")) return Buffer.from("");
              if (cmdStr.includes("worktree remove")) return Buffer.from("");
              return Buffer.from("");
            });
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    // Neither testCommand nor buildCommand configured
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);
    // Verify no verification commands were called
    const verificationCalls = mockedExecSync.mock.calls.filter(
      (call) => String(call[0]).includes("vitest") || String(call[0]).includes("pnpm build"),
    );
    expect(verificationCalls).toHaveLength(0);
  });

  it("skips test and build commands when a cache hit is found for the current tree sha", async () => {
    const treeSha = "cachedtreeshaabc1234567890";
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "0" as any;
      if (cmdStr.includes("show --shortstat")) return "3 files changed, 10 insertions(+), 2 deletions(-)" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      // Return the fake tree sha when rev-parse HEAD^{tree} is called
      if (cmdStr.includes("HEAD^{tree}")) return Buffer.from(treeSha + "\n");
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    // Simulate a cache hit for this tree sha
    const cacheHit = { recordedAt: "2026-05-01T00:00:00.000Z", taskId: "FN-049" };
    (store.getVerificationCacheHit as ReturnType<typeof vi.fn>).mockReturnValue(cacheHit);
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
      buildCommand: "pnpm build",
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);

    // No actual test/build commands should have run
    const runCalls = mockedExecSync.mock.calls.filter(
      (call) => String(call[0]).includes("vitest run") || String(call[0]).includes("pnpm build"),
    );
    expect(runCalls).toHaveLength(0);

    // The cache skip message should appear in the task log
    const logCalls = (store.logEntry as ReturnType<typeof vi.fn>).mock.calls;
    const cacheMsg = logCalls.find((call: any[]) =>
      typeof call[1] === "string" && call[1].includes("Skipping deterministic verification — cached pass"),
    );
    expect(cacheMsg).toBeTruthy();
    expect(cacheMsg![1]).toContain(treeSha.slice(0, 7));
    expect(cacheMsg![1]).toContain("FN-049");

    // getVerificationCacheHit should have been called with the tree sha and commands
    expect(store.getVerificationCacheHit).toHaveBeenCalledWith(treeSha, "vitest run", "pnpm build");
  });

  it("runs commands and records a cache pass when no cache hit exists", async () => {
    const treeSha = "freshtreedead0000beef";
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("vitest run")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "0" as any;
      if (cmdStr.includes("show --shortstat")) return "3 files changed, 10 insertions(+), 2 deletions(-)" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr.includes("HEAD^{tree}")) return Buffer.from(treeSha + "\n");
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    // No cache hit — returns null (default mock)
    (store.getVerificationCacheHit as ReturnType<typeof vi.fn>).mockReturnValue(null);
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);

    // The test command should have been executed
    const testRuns = mockedExecSync.mock.calls.filter(
      (call) => String(call[0]).includes("vitest run"),
    );
    expect(testRuns.length).toBeGreaterThan(0);

    // recordVerificationCachePass should have been called with the tree sha
    expect(store.recordVerificationCachePass).toHaveBeenCalledWith(
      treeSha, "vitest run", "", "FN-050",
    );
  });

  it("gracefully skips cache lookup when git rev-parse HEAD^{tree} fails", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("vitest run")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "0" as any;
      if (cmdStr.includes("show --shortstat")) return "3 files changed, 10 insertions(+), 2 deletions(-)" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      // Simulate git failure for tree sha resolution
      if (cmdStr.includes("HEAD^{tree}")) {
        const err = new Error("not a git repository") as any;
        err.status = 128;
        throw err;
      }
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
    });

    // Should not throw — merge should complete normally
    const result = await aiMergeTask(store, "/tmp/root", "FN-050");
    expect(result.merged).toBe(true);

    // Cache methods should never have been called
    expect(store.getVerificationCacheHit).not.toHaveBeenCalled();
    expect(store.recordVerificationCachePass).not.toHaveBeenCalled();

    // The test command should still have run
    const testRuns = mockedExecSync.mock.calls.filter(
      (call) => String(call[0]).includes("vitest run"),
    );
    expect(testRuns.length).toBeGreaterThan(0);
  });
});

describe("shouldSyncDependenciesForMerge", () => {
  it("returns true when install state is missing", () => {
    expect(shouldSyncDependenciesForMerge([], false)).toBe(true);
  });

  it("returns true when staged files change package manifests or lockfiles", () => {
    expect(shouldSyncDependenciesForMerge(["packages/desktop/package.json"], true)).toBe(true);
    expect(shouldSyncDependenciesForMerge(["pnpm-lock.yaml"], true)).toBe(true);
  });

  it("returns false for regular source-only changes when install state exists", () => {
    expect(shouldSyncDependenciesForMerge(["packages/engine/src/merger.ts"], true)).toBe(false);
  });
});

// ── Pre-merge diffstat scope validation tests ────────────────────────

describe("parseDiffStat", () => {
  it("parses standard diffstat output", () => {
    const stat = [
      " packages/core/src/types.ts         | 9 ++--",
      " packages/engine/src/notifier.ts     | 46 +-----",
      " 2 files changed, 10 insertions(+), 45 deletions(-)",
    ].join("\n");

    const entries = parseDiffStat(stat);
    expect(entries).toHaveLength(2);
    expect(entries[0].file).toBe("packages/core/src/types.ts");
    // Rounding may shift total by ±1, so check approximate range
    expect(entries[0].insertions + entries[0].deletions).toBeGreaterThanOrEqual(9);
    expect(entries[0].insertions + entries[0].deletions).toBeLessThanOrEqual(10);
    expect(entries[1].file).toBe("packages/engine/src/notifier.ts");
    expect(entries[1].deletions).toBeGreaterThan(entries[1].insertions);
  });

  it("handles pure-deletion lines", () => {
    const stat = " packages/engine/src/usage.ts | 527 ---";
    const entries = parseDiffStat(stat);
    expect(entries).toHaveLength(1);
    expect(entries[0].insertions).toBe(0);
    expect(entries[0].deletions).toBe(527);
  });

  it("handles pure-insertion lines", () => {
    const stat = " packages/engine/src/new.ts | 100 +++";
    const entries = parseDiffStat(stat);
    expect(entries).toHaveLength(1);
    expect(entries[0].insertions).toBe(100);
    expect(entries[0].deletions).toBe(0);
  });

  it("returns empty for unreadable stat", () => {
    expect(parseDiffStat("(unable to read diff)")).toEqual([]);
    expect(parseDiffStat("")).toEqual([]);
  });

  it("skips summary line", () => {
    const stat = " 1 file changed, 5 insertions(+)";
    expect(parseDiffStat(stat)).toEqual([]);
  });
});

describe("extractFileScope", () => {
  it("extracts file patterns from PROMPT.md", () => {
    const prompt = [
      "# Task: FN-100 - Add feature",
      "",
      "## File Scope",
      "",
      "- `packages/core/src/types.ts`",
      "- `packages/engine/src/notifier.ts`",
      "- `packages/dashboard/app/components/*`",
      "",
      "## Steps",
      "",
      "### Step 1: Do things",
    ].join("\n");

    const scope = extractFileScope(prompt);
    expect(scope).toEqual([
      "packages/core/src/types.ts",
      "packages/engine/src/notifier.ts",
      "packages/dashboard/app/components/*",
    ]);
  });

  it("handles patterns with artifact annotations", () => {
    const prompt = [
      "## File Scope",
      "",
      "- `src/foo.ts` (new)",
      "- `src/bar.ts` (modified)",
      "",
      "## Steps",
    ].join("\n");

    const scope = extractFileScope(prompt);
    expect(scope).toEqual(["src/foo.ts", "src/bar.ts"]);
  });

  it("returns empty for missing File Scope section", () => {
    const prompt = "# Task\n\n## Steps\n### Step 1\n";
    expect(extractFileScope(prompt)).toEqual([]);
  });
});

describe("validateDiffScope", () => {
  it("returns warnings for large deletions outside scope", async () => {
    const store = {
      getTask: vi.fn().mockResolvedValue({
        prompt: [
          "## File Scope",
          "",
          "- `packages/dashboard/app/components/Header.tsx`",
          "",
          "## Steps",
        ].join("\n"),
      }),
      logEntry: vi.fn(),
    } as unknown as TaskStore;

    const diffStat = [
      " packages/dashboard/app/components/Header.tsx | 20 ++--",
      " packages/engine/src/usage.ts                 | 527 ---",
      " packages/engine/src/usage.test.ts            | 524 ---",
      " 3 files changed, 5 insertions(+), 1066 deletions(-)",
    ].join("\n");

    const result = await validateDiffScope(store, "FN-100", diffStat);
    expect(result.outOfScopeFiles).toContain("packages/engine/src/usage.ts");
    expect(result.outOfScopeFiles).toContain("packages/engine/src/usage.test.ts");
    expect(result.largeOutOfScopeDeletions).toHaveLength(2);
    expect(result.warnings.length).toBeGreaterThan(0);
    expect(result.warnings[0]).toContain("SCOPE WARNING");
  });

  it("allows changeset files outside scope", async () => {
    const store = {
      getTask: vi.fn().mockResolvedValue({
        prompt: "## File Scope\n\n- `src/foo.ts`\n\n## Steps",
      }),
    } as unknown as TaskStore;

    const diffStat = [
      " src/foo.ts                          | 10 +++",
      " .changeset/my-change.md             | 5 +++",
      " 2 files changed, 15 insertions(+)",
    ].join("\n");

    const result = await validateDiffScope(store, "FN-100", diffStat);
    expect(result.outOfScopeFiles).not.toContain(".changeset/my-change.md");
    expect(result.warnings).toHaveLength(0);
  });

  it("returns empty result when no scope is declared", async () => {
    const store = {
      getTask: vi.fn().mockResolvedValue({
        prompt: "# Task\n\n## Steps\n",
      }),
    } as unknown as TaskStore;

    const result = await validateDiffScope(store, "FN-100", " foo.ts | 500 ---");
    expect(result.warnings).toHaveLength(0);
  });

  it("does not warn for in-scope changes", async () => {
    const store = {
      getTask: vi.fn().mockResolvedValue({
        prompt: "## File Scope\n\n- `packages/engine/src/*`\n\n## Steps",
      }),
    } as unknown as TaskStore;

    const diffStat = [
      " packages/engine/src/executor.ts | 50 +++---",
      " packages/engine/src/triage.ts   | 30 +++---",
      " 2 files changed, 40 insertions(+), 40 deletions(-)",
    ].join("\n");

    const result = await validateDiffScope(store, "FN-100", diffStat);
    expect(result.outOfScopeFiles).toHaveLength(0);
    expect(result.warnings).toHaveLength(0);
  });
});

describe("resolveTaskDiffBaseRef", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it("prefers merge-base when it differs from head", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr === 'git merge-base "HEAD" "main"') return "merge-base-123" as any;
      if (cmdStr === 'git rev-parse "HEAD"') return "head-456" as any;
      throw new Error(`Unexpected command: ${cmdStr}`);
    });

    const diffBase = await resolveTaskDiffBaseRef({
      cwd: "/tmp/root",
      headRef: "HEAD",
      baseBranch: "main",
      baseCommitSha: "task-base-789",
    });

    expect(diffBase).toBe("merge-base-123");
    expect(
      mockedExecSync.mock.calls.some(([cmd]) =>
        String(cmd).includes("merge-base --is-ancestor"),
      ),
    ).toBe(false);
  });

  it("uses baseCommitSha when merge-base equals head", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr === 'git merge-base "HEAD" "main"') return "head-456" as any;
      if (cmdStr === 'git rev-parse "HEAD"') return "head-456" as any;
      if (cmdStr === 'git merge-base --is-ancestor "task-base-789" "HEAD"') return "" as any;
      throw new Error(`Unexpected command: ${cmdStr}`);
    });

    const diffBase = await resolveTaskDiffBaseRef({
      cwd: "/tmp/root",
      headRef: "HEAD",
      baseBranch: "main",
      baseCommitSha: "task-base-789",
    });

    expect(diffBase).toBe("task-base-789");
  });

  it("falls back to HEAD~1 when merge-base is unavailable and baseCommitSha is stale", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr === 'git merge-base "HEAD" "main"') {
        throw new Error("missing local main");
      }
      if (cmdStr === 'git merge-base "HEAD" "origin/main"') {
        throw new Error("missing remote main");
      }
      if (cmdStr === 'git merge-base --is-ancestor "stale-base" "HEAD"') {
        throw new Error("stale base sha");
      }
      if (cmdStr === 'git rev-parse "HEAD~1"') return "parent-123" as any;
      throw new Error(`Unexpected command: ${cmdStr}`);
    });

    const diffBase = await resolveTaskDiffBaseRef({
      cwd: "/tmp/root",
      headRef: "HEAD",
      baseBranch: "main",
      baseCommitSha: "stale-base",
    });

    expect(diffBase).toBe("parent-123");
  });

  it("returns undefined when no merge base, no valid baseCommitSha, and no parent commit are available", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr === 'git merge-base "HEAD" "main"') {
        throw new Error("missing local main");
      }
      if (cmdStr === 'git merge-base "HEAD" "origin/main"') {
        throw new Error("missing remote main");
      }
      if (cmdStr === 'git merge-base --is-ancestor "stale-base" "HEAD"') {
        throw new Error("stale base sha");
      }
      if (cmdStr === 'git rev-parse "HEAD~1"') {
        throw new Error("single commit repo");
      }
      throw new Error(`Unexpected command: ${cmdStr}`);
    });

    const diffBase = await resolveTaskDiffBaseRef({
      cwd: "/tmp/root",
      headRef: "HEAD",
      baseBranch: "main",
      baseCommitSha: "stale-base",
    });

    expect(diffBase).toBeUndefined();
  });
});

describe("aiMergeTask — post-merge workflow steps", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    setupHappyPathExecSync();
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
        subscribe: vi.fn(),
        on: vi.fn(),
        state: {},
        sessionManager: { getLeafId: vi.fn().mockReturnValue("leaf-1") },
      },
    } as any);
  });

  it("runs post-merge workflow steps after successful merge", async () => {
    const store = createMockStore();
    // Add getWorkflowStep to mock
    (store as any).getWorkflowStep = vi.fn().mockResolvedValue({
      id: "WS-001",
      name: "Post-merge Notify",
      description: "Send notifications after merge",
      prompt: "Check the merged code and confirm all is well.",
      phase: "post-merge",
      mode: "prompt",
      enabled: true,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    // Override getTask to include enabledWorkflowSteps
    const baseTask = {
      id: "FN-050",
      title: "Test task",
      description: "Test",
      column: "in-review",
      dependencies: [],
      worktree: "/tmp/root/.worktrees/KB-050",
      steps: [],
      currentStep: 0,
      log: [],
      enabledWorkflowSteps: ["WS-001"],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };
    store.getTask = vi.fn().mockResolvedValue({ ...baseTask, prompt: "# test" });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);

    // getWorkflowStep should have been called for the post-merge step
    expect((store as any).getWorkflowStep).toHaveBeenCalledWith("WS-001");

    const postMergeAgentCall = mockedCreateFnAgent.mock.calls.find(
      (c: any) => c[0]?.systemPrompt?.includes("post-merge workflow step agent"),
    );
    expect(postMergeAgentCall).toBeDefined();
    expect(postMergeAgentCall?.[0]?.cwd).toMatch(/\.worktrees\/post-merge-FN-050-[a-z0-9]+/);
    expect(postMergeAgentCall?.[0]?.cwd).not.toBe("/tmp/root");

    // Task should still move to done even though post-merge step ran
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
  });

  it("does not run pre-merge workflow steps in merger", async () => {
    const store = createMockStore();
    (store as any).getWorkflowStep = vi.fn().mockResolvedValue({
      id: "WS-001",
      name: "Pre-merge Check",
      description: "Check before merge",
      prompt: "Run pre-merge checks.",
      phase: "pre-merge",
      mode: "prompt",
      enabled: true,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    const baseTask = {
      id: "FN-050",
      title: "Test task",
      description: "Test",
      column: "in-review",
      dependencies: [],
      worktree: "/tmp/root/.worktrees/KB-050",
      steps: [],
      currentStep: 0,
      log: [],
      enabledWorkflowSteps: ["WS-001"],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };
    store.getTask = vi.fn().mockResolvedValue({ ...baseTask, prompt: "# test" });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    // getWorkflowStep may be called but pre-merge steps should not trigger agent creation
    // beyond the merge agent itself. We verify createFnAgent was called only once (merge agent)
    // since pre-merge steps are skipped in the merger
    const mergeAgentCalls = mockedCreateFnAgent.mock.calls.filter(
      (c: any) => c[0]?.systemPrompt?.includes("You are a merge agent")
    );
    const postMergeCalls = mockedCreateFnAgent.mock.calls.filter(
      (c: any) => c[0]?.systemPrompt?.includes("post-merge")
    );

    // No post-merge agent should be created for a pre-merge step
    expect(postMergeCalls).toHaveLength(0);
  });

  it("appends post-merge results to existing pre-merge results", async () => {
    const existingPreMergeResults = [{
      workflowStepId: "WS-001",
      workflowStepName: "Pre-merge Check",
      phase: "pre-merge",
      status: "passed",
      output: "All good",
    }];

    const store = createMockStore();
    (store as any).getWorkflowStep = vi.fn().mockResolvedValue({
      id: "WS-002",
      name: "Post-merge Verify",
      description: "Verify after merge",
      prompt: "Check merged state.",
      phase: "post-merge",
      mode: "prompt",
      enabled: true,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    const baseTask = {
      id: "FN-050",
      title: "Test task",
      description: "Test",
      column: "in-review",
      dependencies: [],
      worktree: "/tmp/root/.worktrees/KB-050",
      steps: [],
      currentStep: 0,
      log: [],
      enabledWorkflowSteps: ["WS-001", "WS-002"],
      workflowStepResults: existingPreMergeResults,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };
    store.getTask = vi.fn().mockResolvedValue({ ...baseTask, prompt: "# test" });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    // Should have called updateTask with workflow results containing both pre and post
    const updateCalls = (store.updateTask as ReturnType<typeof vi.fn>).mock.calls;
    const resultsCall = updateCalls.find((c: any) =>
      Array.isArray(c[1]?.workflowStepResults) && c[1].workflowStepResults.length > 1
    );

    if (resultsCall) {
      const results = resultsCall[1].workflowStepResults;
      // Should contain both pre-merge and post-merge results
      expect(results.some((r: any) => r.phase === "pre-merge")).toBe(true);
      expect(results.some((r: any) => r.phase === "post-merge")).toBe(true);
    }
  });

  it("moves task to done even when post-merge step fails", async () => {
    const store = createMockStore();
    (store as any).getWorkflowStep = vi.fn().mockResolvedValue({
      id: "WS-001",
      name: "Post-merge Fail",
      description: "Will fail",
      prompt: "Fail this check.",
      phase: "post-merge",
      mode: "prompt",
      enabled: true,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    const baseTask = {
      id: "FN-050",
      title: "Test task",
      description: "Test",
      column: "in-review",
      dependencies: [],
      worktree: "/tmp/root/.worktrees/KB-050",
      steps: [],
      currentStep: 0,
      log: [],
      enabledWorkflowSteps: ["WS-001"],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };
    store.getTask = vi.fn().mockResolvedValue({ ...baseTask, prompt: "# test" });

    // Make the post-merge agent throw
    mockedCreateFnAgent.mockImplementation((async (opts: any) => {
      if (opts.systemPrompt?.includes("post-merge")) {
        return {
          session: {
            prompt: vi.fn().mockRejectedValue(new Error("Post-merge agent failed")),
            dispose: vi.fn(),
            subscribe: vi.fn(),
            on: vi.fn(),
            state: {},
            sessionManager: { getLeafId: vi.fn().mockReturnValue("leaf-1") },
          },
        };
      }
      return {
        session: {
          prompt: vi.fn().mockResolvedValue(undefined),
          dispose: vi.fn(),
          subscribe: vi.fn(),
          on: vi.fn(),
          state: {},
          sessionManager: { getLeafId: vi.fn().mockReturnValue("leaf-1") },
        },
      };
    }) as any);

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    // Merge should succeed regardless of post-merge step failure
    expect(result.merged).toBe(true);
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
  });

  it("runs script-mode post-merge steps", async () => {
    const store = createMockStore();
    (store as any).getWorkflowStep = vi.fn().mockResolvedValue({
      id: "WS-001",
      name: "Post-merge Build",
      description: "Verify build passes",
      phase: "post-merge",
      mode: "script",
      scriptName: "build",
      enabled: true,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    const baseTask = {
      id: "FN-050",
      title: "Test task",
      description: "Test",
      column: "in-review",
      dependencies: [],
      worktree: "/tmp/root/.worktrees/KB-050",
      steps: [],
      currentStep: 0,
      log: [],
      enabledWorkflowSteps: ["WS-001"],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };
    store.getTask = vi.fn().mockResolvedValue({ ...baseTask, prompt: "# test" });

    // Override settings to include scripts
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      scripts: { build: "pnpm build" },
    });

    // Mock execSync to handle the script execution
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "0" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr === "pnpm build") return "Build successful" as any;
      return Buffer.from("");
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    const scriptExecCall = mockedExec.mock.calls.find((call: any) => String(call[0]) === "pnpm build");
    expect(scriptExecCall).toBeDefined();
    expect(scriptExecCall?.[1]?.cwd).toMatch(/\.worktrees\/post-merge-FN-050-[a-z0-9]+/);

    expect(result.merged).toBe(true);
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
  });

  it("creates temporary worktree for post-merge steps", async () => {
    const store = createMockStore();
    (store as any).getWorkflowStep = vi.fn().mockResolvedValue({
      id: "WS-001",
      name: "Post-merge Notify",
      description: "Send notifications after merge",
      prompt: "Check the merged code and confirm all is well.",
      phase: "post-merge",
      mode: "prompt",
      enabled: true,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    const baseTask = {
      id: "FN-050",
      title: "Test task",
      description: "Test",
      column: "in-review",
      dependencies: [],
      worktree: "/tmp/root/.worktrees/KB-050",
      steps: [],
      currentStep: 0,
      log: [],
      enabledWorkflowSteps: ["WS-001"],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };
    store.getTask = vi.fn().mockResolvedValue({ ...baseTask, prompt: "# test" });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    const worktreeAddCall = mockedExec.mock.calls.find((call: any) =>
      String(call[0]).includes("git worktree add") && String(call[0]).includes("post-merge-FN-050-"),
    );
    const worktreeRemoveCall = mockedExec.mock.calls.find((call: any) =>
      String(call[0]).includes("git worktree remove --force") && String(call[0]).includes("post-merge-FN-050-"),
    );

    expect(worktreeAddCall).toBeDefined();
    expect(worktreeRemoveCall).toBeDefined();
  });

  it("falls back to rootDir when worktree creation fails", async () => {
    const store = createMockStore();
    (store as any).getWorkflowStep = vi.fn().mockResolvedValue({
      id: "WS-001",
      name: "Post-merge Notify",
      description: "Send notifications after merge",
      prompt: "Check the merged code and confirm all is well.",
      phase: "post-merge",
      mode: "prompt",
      enabled: true,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    const baseTask = {
      id: "FN-050",
      title: "Test task",
      description: "Test",
      column: "in-review",
      dependencies: [],
      worktree: "/tmp/root/.worktrees/KB-050",
      steps: [],
      currentStep: 0,
      log: [],
      enabledWorkflowSteps: ["WS-001"],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };
    store.getTask = vi.fn().mockResolvedValue({ ...baseTask, prompt: "# test" });

    const baseExecImpl = mockedExecSync.getMockImplementation();
    mockedExecSync.mockImplementation((cmd: any, opts: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("git worktree add") && cmdStr.includes("post-merge-FN-050-")) {
        const error: any = new Error("cannot create worktree");
        error.stderr = "cannot create worktree";
        throw error;
      }
      return baseExecImpl ? baseExecImpl(cmd, opts) : Buffer.from("");
    });

    const warnSpy = vi.spyOn(mergerLog, "warn");
    await aiMergeTask(store, "/tmp/root", "FN-050");

    const postMergeAgentCall = mockedCreateFnAgent.mock.calls.find(
      (c: any) => c[0]?.systemPrompt?.includes("post-merge workflow step agent"),
    );
    expect(postMergeAgentCall?.[0]?.cwd).toBe("/tmp/root");
    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("could not create post-merge worktree — falling back to rootDir"));
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
  });

  it("cleans up temporary worktree even when post-merge step fails", async () => {
    const store = createMockStore();
    (store as any).getWorkflowStep = vi.fn().mockResolvedValue({
      id: "WS-001",
      name: "Post-merge Fail",
      description: "Will fail",
      prompt: "Fail this check.",
      phase: "post-merge",
      mode: "prompt",
      enabled: true,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    const baseTask = {
      id: "FN-050",
      title: "Test task",
      description: "Test",
      column: "in-review",
      dependencies: [],
      worktree: "/tmp/root/.worktrees/KB-050",
      steps: [],
      currentStep: 0,
      log: [],
      enabledWorkflowSteps: ["WS-001"],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };
    store.getTask = vi.fn().mockResolvedValue({ ...baseTask, prompt: "# test" });

    mockedCreateFnAgent.mockImplementation((async (opts: any) => {
      if (opts.systemPrompt?.includes("post-merge")) {
        throw new Error("Post-merge agent creation failed");
      }
      return {
        session: {
          prompt: vi.fn().mockResolvedValue(undefined),
          dispose: vi.fn(),
          subscribe: vi.fn(),
          on: vi.fn(),
          state: {},
          sessionManager: { getLeafId: vi.fn().mockReturnValue("leaf-1") },
        },
      };
    }) as any);

    await aiMergeTask(store, "/tmp/root", "FN-050");

    const worktreeRemoveCall = mockedExec.mock.calls.find((call: any) =>
      String(call[0]).includes("git worktree remove --force") && String(call[0]).includes("post-merge-FN-050-"),
    );
    expect(worktreeRemoveCall).toBeDefined();
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
  });

  it("does not create post-merge worktree when no post-merge steps exist", async () => {
    const store = createMockStore();
    (store as any).getWorkflowStep = vi.fn().mockResolvedValue({
      id: "WS-001",
      name: "Pre-merge Check",
      description: "Check before merge",
      prompt: "Run pre-merge checks.",
      phase: "pre-merge",
      mode: "prompt",
      enabled: true,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    const baseTask = {
      id: "FN-050",
      title: "Test task",
      description: "Test",
      column: "in-review",
      dependencies: [],
      worktree: "/tmp/root/.worktrees/KB-050",
      steps: [],
      currentStep: 0,
      log: [],
      enabledWorkflowSteps: ["WS-001"],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };
    store.getTask = vi.fn().mockResolvedValue({ ...baseTask, prompt: "# test" });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    const worktreeAddCall = mockedExec.mock.calls.find((call: any) =>
      String(call[0]).includes("git worktree add") && String(call[0]).includes("post-merge-FN-050-"),
    );
    expect(worktreeAddCall).toBeUndefined();
  });
});

// ── Merge Details Collection Tests ─────────────────────────────────────

describe("aiMergeTask — merge details collection", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  it("stores mergeDetails with commitSha and stats after successful merge", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD "))
        return "mergedcommit123456789"; // encoding: utf-8 → string
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "";
      if (cmdStr.includes("diff --cached --quiet")) return "1";
      if (cmdStr.includes("git commit")) return Buffer.from("");
      if (cmdStr.includes("show --shortstat"))
        return "3 files changed, 10 insertions(+), 2 deletions(-)";
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);

    // Find the updateTask call that set mergeDetails
    const updateCalls = (store.updateTask as ReturnType<typeof vi.fn>).mock.calls;
    const mergeDetailsCall = updateCalls.find(
      (call: any[]) => call[1]?.mergeDetails !== undefined,
    );
    expect(mergeDetailsCall).toBeDefined();

    const mergeDetails = mergeDetailsCall![1].mergeDetails;
    expect(mergeDetails.commitSha).toBe("mergedcommit123456789");
    expect(mergeDetails.filesChanged).toBe(3);
    expect(mergeDetails.insertions).toBe(10);
    expect(mergeDetails.deletions).toBe(2);
    expect(mergeDetails.mergeCommitMessage).toBe("- feat: something");
    expect(mergeDetails.mergedAt).toBeDefined();
    expect(mergeDetails.mergeConfirmed).toBe(true);
    expect(mergeDetails.resolutionStrategy).toBe("ai");
    expect(mergeDetails.resolutionMethod).toBe("ai");
    expect(mergeDetails.attemptsMade).toBe(1);
  });

  it("stores AI summary in mergeDetails when useAiMergeCommitSummary is enabled", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      useAiMergeCommitSummary: true,
    });

    vi.spyOn(core, "summarizeMergeCommit").mockResolvedValue("AI summary of merged work.");

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123456789";
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "";
      if (cmdStr.includes("diff --cached --quiet")) return "1";
      if (cmdStr.includes("git commit")) return Buffer.from("");
      if (cmdStr.includes("show --shortstat")) return "1 file changed, 1 insertion(+)";
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");
    expect(result.merged).toBe(true);

    const updateCalls = (store.updateTask as ReturnType<typeof vi.fn>).mock.calls;
    const mergeDetailsCall = updateCalls.find((call: any[]) => call[1]?.mergeDetails !== undefined);
    expect(mergeDetailsCall?.[1].mergeDetails.mergeCommitMessage).toBe("AI summary of merged work.");
  });

  it("falls back to raw commit log when AI merge summary returns null", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      useAiMergeCommitSummary: true,
    });

    vi.spyOn(core, "summarizeMergeCommit").mockResolvedValue(null);

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123456789";
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "";
      if (cmdStr.includes("diff --cached --quiet")) return "1";
      if (cmdStr.includes("git commit")) return Buffer.from("");
      if (cmdStr.includes("show --shortstat")) return "1 file changed, 1 insertion(+)";
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");
    expect(result.merged).toBe(true);

    const updateCalls = (store.updateTask as ReturnType<typeof vi.fn>).mock.calls;
    const mergeDetailsCall = updateCalls.find((call: any[]) => call[1]?.mergeDetails !== undefined);
    expect(mergeDetailsCall?.[1].mergeDetails.mergeCommitMessage).toBe("- feat: something");
  });

  it("recovers owned landed commit when branch is not found", async () => {
    const store = createMockStore(
      {
        id: "FN-3469",
        worktree: "/tmp/root/.worktrees/FN-3469",
        baseCommitSha: "base3469",
        mergeDetails: { commitSha: "a47b1e5d78d626f8b480f1e90d3d64be2625ff6a" } as any,
      },
      [{ id: "FN-3469", worktree: "/tmp/root/.worktrees/FN-3469", column: "in-review" } as Task],
    );

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) throw new Error("not found");
      if (cmdStr.includes("merge-base --is-ancestor a47b1e5d78d626f8b480f1e90d3d64be2625ff6a HEAD")) return Buffer.from("");
      if (cmdStr.includes("log -1 --format=%H%x1f%s%x1f%b a47b1e5d78d626f8b480f1e90d3d64be2625ff6a")) {
        return "a47b1e5d78d626f8b480f1e90d3d64be2625ff6a\u001ffix(FN-3469): title\u001fFusion-Task-Id: FN-3469" as any;
      }
      if (cmdStr.includes("show --shortstat --format= a47b1e5d78d626f8b480f1e90d3d64be2625ff6a")) {
        return "2 files changed, 84 insertions(+), 2 deletions(-)" as any;
      }
      return Buffer.from("");
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-3469");
    expect(result.merged).toBe(false);

    const mergeDetailsCall = (store.updateTask as ReturnType<typeof vi.fn>).mock.calls.find(
      (call: any[]) => call[1]?.mergeDetails !== undefined,
    );
    expect(mergeDetailsCall?.[1].mergeDetails).toEqual(expect.objectContaining({
      commitSha: "a47b1e5d78d626f8b480f1e90d3d64be2625ff6a",
      mergeCommitMessage: "fix(FN-3469): title",
      mergeConfirmed: true,
    }));
  });

  it("does not persist misleading mergeDetails when branch is not found and no owned commit exists", async () => {
    const store = createMockStore(
      { id: "FN-3373", worktree: "/tmp/root/.worktrees/FN-3373" },
      [{ id: "FN-3373", worktree: "/tmp/root/.worktrees/FN-3373", column: "in-review" } as Task],
    );

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) throw new Error("not found");
      return Buffer.from("");
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-3373");
    expect(result.merged).toBe(false);

    const mergeDetailsCall = (store.updateTask as ReturnType<typeof vi.fn>).mock.calls.find(
      (call: any[]) => call[1]?.mergeDetails !== undefined,
    );
    expect(mergeDetailsCall).toBeUndefined();
  });

  it("completes merge even when git commands fail during merge details collection", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    // Use prefer-branch: this test simulates `git rev-parse HEAD` failing to
    // exercise merge-details fallback. The local-base rebase stage hits the
    // same command first; under prefer-main its failure would hard-fail. This
    // test isn't about prefer-main semantics, so opt out.
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      mergeConflictStrategy: "smart-prefer-branch",
    });

    let revParseHeadCalled = false;
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) {
        revParseHeadCalled = true;
        throw new Error("git rev-parse HEAD failed");
      }
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "";
      if (cmdStr.includes("diff --cached --quiet")) return "1";
      if (cmdStr.includes("git commit")) return Buffer.from("");
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    // Merge should still succeed even though merge details collection failed
    expect(result.merged).toBe(true);
    expect(revParseHeadCalled).toBe(true);

    // No mergeDetails should have been stored
    const updateCalls = (store.updateTask as ReturnType<typeof vi.fn>).mock.calls;
    const mergeDetailsCall = updateCalls.find(
      (call: any[]) => call[1]?.mergeDetails !== undefined,
    );
    expect(mergeDetailsCall).toBeUndefined();

    // Task should still be moved to done
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
  });

  it("handles missing shortstat gracefully when show --shortstat fails", async () => {
    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD "))
        return "mergedcommit123"; // encoding: utf-8 → string
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "";
      if (cmdStr.includes("diff --cached --quiet")) return "1";
      if (cmdStr.includes("git commit")) return Buffer.from("");
      // show --shortstat fails
      if (cmdStr.includes("show --shortstat")) throw new Error("show failed");
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(result.merged).toBe(true);

    // mergeDetails should still be stored with commitSha but without stats
    const updateCalls = (store.updateTask as ReturnType<typeof vi.fn>).mock.calls;
    const mergeDetailsCall = updateCalls.find(
      (call: any[]) => call[1]?.mergeDetails !== undefined,
    );
    expect(mergeDetailsCall).toBeDefined();

    const mergeDetails = mergeDetailsCall![1].mergeDetails;
    expect(mergeDetails.commitSha).toBe("mergedcommit123");
    // Stats should be undefined since show --shortstat failed (inner catch sets them as undefined)
    expect(mergeDetails.filesChanged).toBeUndefined();
    expect(mergeDetails.insertions).toBeUndefined();
    expect(mergeDetails.deletions).toBeUndefined();
  });
});

describe("aiMergeTask — fresh session and compaction recovery", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
  });

  function setupFreshSessionExecSync() {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1";
      if (cmdStr.includes("git commit")) return Buffer.from("");
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });
  }

  it("creates a fresh session for merge agent via createFnAgent", async () => {
    setupFreshSessionExecSync();

    const sessionInstances: any[] = [];
    mockedCreateFnAgent.mockImplementation(async () => {
      const session = {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      };
      sessionInstances.push(session);
      // Use type assertion to match expected return type
      return { session } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    await aiMergeTask(store, "/tmp/root", "FN-050");

    // Session should be created once for the merge agent
    expect(mockedCreateFnAgent).toHaveBeenCalledTimes(1);
    expect(sessionInstances.length).toBe(1);
  });

  it("disposes session after merge agent completes (finally block)", async () => {
    setupFreshSessionExecSync();

    const mockDispose = vi.fn();
    const mockSession = {
      prompt: vi.fn().mockResolvedValue(undefined),
      dispose: mockDispose,
    };
    mockedCreateFnAgent.mockResolvedValue({ session: mockSession } as any);

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    await aiMergeTask(store, "/tmp/root", "FN-050");

    // Session should be disposed via finally block
    expect(mockDispose).toHaveBeenCalledTimes(1);
  });

  it("imports compactSessionContext and isContextLimitError from respective modules", async () => {
    // This test verifies the imports are present in merger.ts
    // The actual functionality is tested via behavior verification
    const mergerModule = await import("../merger.js");
    expect(mergerModule).toBeDefined();
  });
});

// ── Merge Prompt Truncation Tests ─────────────────────────────────────

describe("buildSourceIssueRef", () => {
  it("returns owner/repo#number for GitHub source issues", async () => {
    const { buildSourceIssueRef } = await import("../merger.js");
    expect(buildSourceIssueRef({
      provider: "github",
      repository: "runfusion/fusion",
      externalIssueId: "123",
      issueNumber: 123,
    })).toBe("runfusion/fusion#123");
  });

  it("falls back to externalIssueId when issueNumber is missing", async () => {
    const { buildSourceIssueRef } = await import("../merger.js");
    expect(buildSourceIssueRef({
      provider: "github",
      repository: "runfusion/fusion",
      externalIssueId: "321",
    } as any)).toBe("runfusion/fusion#321");
  });

  it("returns empty string for non-GitHub providers", async () => {
    const { buildSourceIssueRef } = await import("../merger.js");
    expect(buildSourceIssueRef({
      provider: "gitlab",
      repository: "group/project",
      externalIssueId: "123",
      issueNumber: 123,
    })).toBe("");
  });

  it("returns empty string for nullish source issue", async () => {
    const { buildSourceIssueRef } = await import("../merger.js");
    expect(buildSourceIssueRef(undefined)).toBe("");
    expect(buildSourceIssueRef(null)).toBe("");
    expect(buildSourceIssueRef({
      provider: "github",
      repository: "runfusion/fusion",
      externalIssueId: "not-a-number",
    } as any)).toBe("");
  });
});

describe("buildMergePrompt — truncation behavior", () => {
  it("truncates commit log when exceeding MERGE_COMMIT_LOG_MAX_CHARS", async () => {
    const { buildMergePrompt } = await import("../merger.js");

    // Create a commit log that exceeds 5000 characters
    const longCommitLog = "- " + "a".repeat(6000);
    const prompt = buildMergePrompt({
      taskId: "FN-001",
      branch: "fusion/fn-001",
      commitLog: longCommitLog,
      diffStat: "1 file changed",
      hasConflicts: false,
    });

    // The prompt should contain truncation indicator
    expect(prompt).toContain("... (truncated)");
    // The truncated version should be shorter than original
    expect(prompt.indexOf("- " + "a".repeat(5000))).toBe(-1);
  });

  it("truncates diff stat when exceeding MERGE_DIFF_STAT_MAX_CHARS", async () => {
    const { buildMergePrompt } = await import("../merger.js");

    // Create a diff stat that exceeds 3000 characters
    const longDiffStat = "file.ts | " + " ".repeat(10) + "x".repeat(4000);
    const prompt = buildMergePrompt({
      taskId: "FN-001",
      branch: "fusion/fn-001",
      commitLog: "- feat: something",
      diffStat: longDiffStat,
      hasConflicts: false,
    });

    // The prompt should contain truncation indicator
    expect(prompt).toContain("... (truncated)");
    // The diff stat section should not contain the full long content
    expect(prompt.indexOf("x".repeat(3000))).toBe(-1);
  });

  it("preserves short content unchanged (under limits)", async () => {
    const { buildMergePrompt } = await import("../merger.js");

    const shortCommitLog = "- feat: add login\n- fix: correct typo";
    const shortDiffStat = "src/login.ts | 5 +++\n1 file changed";
    const prompt = buildMergePrompt({
      taskId: "FN-001",
      branch: "fusion/fn-001",
      commitLog: shortCommitLog,
      diffStat: shortDiffStat,
      hasConflicts: false,
    });

    // Should not contain truncation markers
    expect(prompt).not.toContain("... (truncated)");
    // Should contain original content
    expect(prompt).toContain(shortCommitLog);
    expect(prompt).toContain(shortDiffStat);
  });

  it("truncates commit log but not diff stat when only commit log is over limit", async () => {
    const { buildMergePrompt } = await import("../merger.js");

    const longCommitLog = "- " + "b".repeat(6000);
    const shortDiffStat = "1 file changed";
    const prompt = buildMergePrompt({
      taskId: "FN-001",
      branch: "fusion/fn-001",
      commitLog: longCommitLog,
      diffStat: shortDiffStat,
      hasConflicts: false,
    });

    // Should contain truncation for commit log
    expect(prompt).toContain("... (truncated)");
    // Diff stat should be unchanged
    expect(prompt).toContain(shortDiffStat);
  });

  it("includes author arg in no-conflicts commit instruction", async () => {
    const { buildMergePrompt } = await import("../merger.js");

    const prompt = buildMergePrompt({
      taskId: "FN-001",
      branch: "fusion/fn-001",
      commitLog: "- feat: something",
      diffStat: "1 file changed",
      hasConflicts: false,
      authorArg: ' --author="Fusion <noreply@runfusion.ai>"',
    });

    expect(prompt).toContain('Be sure to include `--author="Fusion <noreply@runfusion.ai>"` in the commit command');
  });

  it("includes author arg in conflicts commit instruction", async () => {
    const { buildMergePrompt } = await import("../merger.js");

    const prompt = buildMergePrompt({
      taskId: "FN-001",
      branch: "fusion/fn-001",
      commitLog: "- feat: something",
      diffStat: "1 file changed",
      hasConflicts: true,
      authorArg: ' --author="CustomBot <bot@example.com>"',
    });

    expect(prompt).toContain('Be sure to include `--author="CustomBot <bot@example.com>"` in the commit command');
  });

  it("omits author instruction when authorArg is not provided", async () => {
    const { buildMergePrompt } = await import("../merger.js");

    const prompt = buildMergePrompt({
      taskId: "FN-001",
      branch: "fusion/fn-001",
      commitLog: "- feat: something",
      diffStat: "1 file changed",
      hasConflicts: false,
    });

    expect(prompt).not.toContain("Be sure to include");
    expect(prompt).toContain("Write and run the `git commit` command with a good message summarizing the work");
  });

  it("handles empty authorArg gracefully", async () => {
    const { buildMergePrompt } = await import("../merger.js");

    const prompt = buildMergePrompt({
      taskId: "FN-001",
      branch: "fusion/fn-001",
      commitLog: "- feat: something",
      diffStat: "1 file changed",
      hasConflicts: false,
      authorArg: "",
    });

    expect(prompt).not.toContain("Be sure to include");
  });

  it("includes source issue reference guidance when provided", async () => {
    const { buildMergePrompt } = await import("../merger.js");

    const prompt = buildMergePrompt({
      taskId: "FN-001",
      branch: "fusion/fn-001",
      commitLog: "- feat: something",
      diffStat: "1 file changed",
      hasConflicts: false,
      sourceIssueRef: "runfusion/fusion#2915",
    });

    expect(prompt).toContain("Include this in the commit message body:");
    expect(prompt).toContain("Ref: runfusion/fusion#2915");
  });

  it("omits source issue reference guidance when not provided", async () => {
    const { buildMergePrompt } = await import("../merger.js");

    const prompt = buildMergePrompt({
      taskId: "FN-001",
      branch: "fusion/fn-001",
      commitLog: "- feat: something",
      diffStat: "1 file changed",
      hasConflicts: false,
    });

    expect(prompt).not.toContain("Include this in the commit message body:");
    expect(prompt).not.toContain("Ref: runfusion/fusion#2915");
  });
});

// ── Context Limit Recovery Tests ─────────────────────────────────────

describe("aiMergeTask — context limit recovery with truncation", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
  });

  function setupContextLimitExecSync() {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1";
      if (cmdStr.includes("git commit")) return Buffer.from("");
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });
  }

  it("retries with minimal prompt when context limit hit after auto-compaction", async () => {
    const { isContextLimitError } = await import("../context-limit-detector.js");

    vi.mocked(isContextLimitError).mockReturnValue(true);

    // Track prompt calls
    const promptCalls: string[] = [];
    let firstCall = true;
    mockedCreateFnAgent.mockImplementation(async () => {
      const session = {
        prompt: vi.fn().mockImplementation(async (prompt: string) => {
          promptCalls.push(prompt);
          if (firstCall) {
            firstCall = false;
            throw new Error("context window exceeds limit (2013)");
          }
          // Second call succeeds
        }),
        dispose: vi.fn(),
      };
      return { session } as any;
    });

    setupContextLimitExecSync();

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    // Merge should succeed after truncated retry
    expect(result.merged).toBe(true);

    // Should have made 2 prompt calls
    expect(promptCalls).toHaveLength(2);

    // First call had original prompt, second call should have simplified prompt
    expect(promptCalls[0]).toContain("## Branch commits");
    // Second call uses simplifiedContext=true, so it should NOT contain "## Files changed"
    expect(promptCalls[1]).not.toContain("## Files changed");
    // Second call should have the minimal placeholder
    expect(promptCalls[1]).toContain("(see git log)");

    // Note: Compaction is now handled by promptWithFallback, not by the merger directly
  });

  it("throws when truncated retry also fails with context limit", async () => {
    const { isContextLimitError } = await import("../context-limit-detector.js");

    vi.mocked(isContextLimitError).mockReturnValue(true);

    // Track prompt calls to verify both original and truncated prompts were tried
    const promptCalls: string[] = [];

    mockedCreateFnAgent.mockImplementation(async () => {
      const session = {
        prompt: vi.fn().mockImplementation(async (prompt: string) => {
          promptCalls.push(prompt);
          // Both calls fail with context limit error
          throw new Error("context window exceeds limit (2013)");
        }),
        dispose: vi.fn(),
      };
      return { session } as any;
    });

    // Setup that simulates both attempts failing (first fails, attempts 2 and 3 also fail)
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";
      // All merge attempts fail
      if (cmdStr.includes("merge --squash") || cmdStr.includes("merge -X")) {
        throw new Error("merge conflict");
      }
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "src/file.ts";
      // git diff-tree for trivial whitespace detection - return real changes (non-trivial)
      if (cmdStr.includes("diff-tree")) {
        const error = new Error("exit code 1") as any;
        error.stdout = "+const x = 2;\n-const x = 1;";
        throw error;
      }
      if (cmdStr.includes("reset --merge")) return Buffer.from("");
      return Buffer.from("");
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      smartConflictResolution: true, // Enable all 3 attempts
    });

    // Should throw after all attempts exhausted
    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toThrow("all 3 attempts exhausted");

    // Verify both original and truncated prompts were attempted (2 attempts for attempt 1)
    // Each merge attempt calls promptWithFallback twice (original + truncated when compaction fails)
    // With 3 merge attempts, this means we should have at least 6 prompt calls total
    expect(promptCalls.length).toBeGreaterThan(0);

    // Note: Compaction is now handled by promptWithFallback, not by the merger directly
  });

  it("succeeds when prompt succeeds on retry after context error", async () => {
    const { isContextLimitError } = await import("../context-limit-detector.js");

    vi.mocked(isContextLimitError).mockReturnValue(true);

    // Track prompt calls
    const promptCalls: string[] = [];
    let firstCall = true;
    mockedCreateFnAgent.mockImplementation(async () => {
      const session = {
        prompt: vi.fn().mockImplementation(async (prompt: string) => {
          promptCalls.push(prompt);
          if (firstCall) {
            firstCall = false;
            throw new Error("context window exceeds limit (2013)");
          }
          // Second call succeeds
        }),
        dispose: vi.fn(),
      };
      return { session } as any;
    });

    setupContextLimitExecSync();

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    // Merge should succeed after retry
    expect(result.merged).toBe(true);

    // Should have made 2 prompt calls
    expect(promptCalls).toHaveLength(2);

    // Note: Compaction is now handled by promptWithFallback, not by the merger directly
  });

  it("does not attempt truncation retry for non-context errors", async () => {
    const { compactSessionContext } = await import("../pi.js");
    const { isContextLimitError } = await import("../context-limit-detector.js");

    // Non-context error should not trigger recovery path
    vi.mocked(compactSessionContext).mockResolvedValue(null);
    vi.mocked(isContextLimitError).mockReturnValue(false);

    // Mock non-context error
    mockedCreateFnAgent.mockImplementation(async () => {
      const session = {
        prompt: vi.fn().mockRejectedValue(new Error("connection refused")),
        dispose: vi.fn(),
      };
      return { session } as any;
    });

    // Setup that simulates merge failing - make merge --squash throw so auto-resolution isn't triggered
    // Also make commit fail so all attempts exhaust
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something";
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("--stat")) return "1 file changed";
      // All merge attempts fail - make merge --squash throw with conflicts
      if (cmdStr.includes("merge --squash") || cmdStr.includes("merge -X")) {
        const err = new Error("merge conflict");
        err.name = "ExecSyncError";
        throw err;
      }
      if (cmdStr.includes("diff --name-only --diff-filter=U")) return "src/file.ts";
      if (cmdStr.includes("reset --merge")) return Buffer.from("");
      // Make commit fail so attempt 2's auto-resolution also fails
      if (cmdStr.includes("git commit")) {
        const err = new Error("commit failed");
        err.name = "ExecSyncError";
        throw err;
      }
      return Buffer.from("");
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      smartConflictResolution: true,
    });

    // Should throw without attempting compaction or truncation
    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toThrow("all 3 attempts exhausted");

    // Compaction should NOT have been called for non-context errors
    expect(vi.mocked(compactSessionContext)).not.toHaveBeenCalled();
  });
});

describe("summarizeVerificationOutput", () => {
  it("extracts vitest-style test summary with failure names", () => {
    const output = [
      "some setup output...",
      "FAIL src/utils.test.ts",
      "  ✗ should validate input",
      "  ✗ should handle edge case",
      "Tests: 2 failed, 48 passed, 50 total",
    ].join("\n");
    const result = summarizeVerificationOutput(output, "test");
    expect(result).toContain("Tests: 2 failed, 48 passed, 50 total");
    expect(result).toContain("should validate input");
    expect(result).toContain("full output available in engine logs");
  });

  it("limits failure names to 5 with overflow indicator", () => {
    // Build output with 7 FAIL lines
    const output = [
      "FAIL test1",
      "FAIL test2",
      "FAIL test3",
      "FAIL test4",
      "FAIL test5",
      "FAIL test6",
      "FAIL test7",
      "Tests: 7 failed, 0 passed, 7 total",
    ].join("\n");
    const result = summarizeVerificationOutput(output, "test");
    expect(result).toContain("test5");
    expect(result).toContain("... and 2 more failures");
    expect(result).not.toContain("test6");
  });

  it("falls back to first 500 chars for unstructured output", () => {
    const output = "A".repeat(1000);
    const result = summarizeVerificationOutput(output, "build");
    expect(result.length).toBeLessThan(600);
    expect(result).toContain("full output available in engine logs");
  });

  it("returns generic message for empty output", () => {
    const result = summarizeVerificationOutput("", "test");
    expect(result).toContain("no output");
    expect(result).toContain("full output available in engine logs");
  });

  it("deduplicates identical failure names", () => {
    const output = [
      "FAIL src/a.test.ts",
      "FAIL src/a.test.ts",  // duplicate
      "FAIL src/b.test.ts",
      "Tests: 3 failed, 0 passed",
    ].join("\n");
    const result = summarizeVerificationOutput(output, "test");
    // Should contain only unique names (src/a.test.ts once, src/b.test.ts)
    const bulletMatches = result.match(/• /g);
    expect(bulletMatches?.length).toBe(2);
  });
});

// ── Default Test Command Inference Tests ──────────────────────────────────

describe("inferDefaultTestCommand", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    // Default: no lock files present
    mockedExistsSync.mockReturnValue(false);
  });

  it("returns null when no package manager lock files exist", () => {
    mockedExistsSync.mockReturnValue(false);
    const result = inferDefaultTestCommand("/tmp/root");
    expect(result).toBeNull();
  });

  it("returns pnpm test for pnpm-lock.yaml", () => {
    mockedExistsSync.mockImplementation((path: any) => {
      return String(path).includes("pnpm-lock.yaml");
    });
    const result = inferDefaultTestCommand("/tmp/root");
    expect(result).toEqual({
      command: "pnpm test",
      testSource: "inferred",
    });
  });

  it("returns npm test for package-lock.json", () => {
    mockedExistsSync.mockImplementation((path: any) => {
      return String(path).includes("package-lock.json");
    });
    const result = inferDefaultTestCommand("/tmp/root");
    expect(result).toEqual({
      command: "npm test",
      testSource: "inferred",
    });
  });

  it("returns yarn test for yarn.lock", () => {
    mockedExistsSync.mockImplementation((path: any) => {
      return String(path).includes("yarn.lock");
    });
    const result = inferDefaultTestCommand("/tmp/root");
    expect(result).toEqual({
      command: "yarn test",
      testSource: "inferred",
    });
  });

  it("returns bun test for bun.lock", () => {
    mockedExistsSync.mockImplementation((path: any) => {
      return String(path).includes("bun.lock");
    });
    const result = inferDefaultTestCommand("/tmp/root");
    expect(result).toEqual({
      command: "bun test",
      testSource: "inferred",
    });
  });

  it("returns bun test for bun.lockb", () => {
    mockedExistsSync.mockImplementation((path: any) => {
      return String(path).includes("bun.lockb");
    });
    const result = inferDefaultTestCommand("/tmp/root");
    expect(result).toEqual({
      command: "bun test",
      testSource: "inferred",
    });
  });

  it("prefers pnpm over npm when both exist", () => {
    mockedExistsSync.mockImplementation((path: any) => {
      const pathStr = String(path);
      return pathStr.includes("pnpm-lock.yaml") || pathStr.includes("package-lock.json");
    });
    const result = inferDefaultTestCommand("/tmp/root");
    expect(result?.command).toBe("pnpm test");
  });

  it("uses explicit testCommand when provided", () => {
    mockedExistsSync.mockImplementation((path: any) => {
      return String(path).includes("pnpm-lock.yaml");
    });
    const result = inferDefaultTestCommand("/tmp/root", "vitest run", "pnpm build");
    expect(result).toEqual({
      command: "vitest run",
      testSource: "explicit",
      buildSource: "explicit",
    });
  });

  it("ignores empty string explicit testCommand", () => {
    mockedExistsSync.mockImplementation((path: any) => {
      return String(path).includes("pnpm-lock.yaml");
    });
    const result = inferDefaultTestCommand("/tmp/root", "", "pnpm build");
    expect(result?.command).toBe("pnpm test");
    expect(result?.testSource).toBe("inferred");
    expect(result?.buildSource).toBe("explicit");
  });

  it("ignores whitespace-only explicit testCommand", () => {
    mockedExistsSync.mockImplementation((path: any) => {
      return String(path).includes("pnpm-lock.yaml");
    });
    const result = inferDefaultTestCommand("/tmp/root", "   ", "pnpm build");
    expect(result?.command).toBe("pnpm test");
    expect(result?.testSource).toBe("inferred");
  });

  it("returns build source even when test is inferred", () => {
    mockedExistsSync.mockImplementation((path: any) => {
      return String(path).includes("pnpm-lock.yaml");
    });
    const result = inferDefaultTestCommand("/tmp/root", undefined, "pnpm build");
    expect(result).toEqual({
      command: "pnpm test",
      testSource: "inferred",
      buildSource: "explicit",
    });
  });
});

// ── Inferred Test Command Merge Behavior ─────────────────────────────────

describe("aiMergeTask — inferred test command execution", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mockedExistsSync.mockReturnValue(true);
    setupHappyPathExecSync();
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  it("runs inferred test command when settings.testCommand is not configured", async () => {
    // pnpm-lock.yaml exists, testCommand is not set
    mockedExistsSync.mockImplementation((path: any) => {
      const pathStr = String(path);
      if (pathStr.includes("pnpm-lock.yaml")) return true;
      return true; // other files exist for worktree check
    });

    const verificationCalls: string[] = [];
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("pnpm test")) {
        verificationCalls.push("pnpm test");
        return Buffer.from("");
      }
      // Handle all other git commands - matching setupHappyPathExecSync
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached") && !cmdStr.includes("--quiet")) return "0" as any;
      if (cmdStr.includes("show --shortstat")) return "3 files changed, 10 insertions(+), 2 deletions(-)" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    // testCommand is not set (undefined in DEFAULT_SETTINGS)
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
    });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(verificationCalls).toContain("pnpm test");
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
  });

  it("logs that test command was inferred from project files", async () => {
    mockedExistsSync.mockImplementation((path: any) => {
      return String(path).includes("pnpm-lock.yaml");
    });

    // Setup happy path
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("pnpm test")) return Buffer.from("");
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached") && !cmdStr.includes("--quiet")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
    });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    // Verify log entries include verification with test command mentioned
    const logCalls = (store.logEntry as ReturnType<typeof vi.fn>).mock.calls;
    const verificationLogCall = logCalls.find((call: any[]) =>
      typeof call[1] === "string" && call[1].includes("pnpm test")
    );
    expect(verificationLogCall).toBeTruthy();
  });

  it("failing inferred test command blocks merge and keeps task out of done", async () => {
    mockedExistsSync.mockImplementation((path: any) => {
      return String(path).includes("pnpm-lock.yaml");
    });

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("pnpm test")) {
        // Simulate test failure
        const error = new Error("Test failed") as any;
        error.status = 1;
        error.stdout = "FAIL: test failed";
        error.stderr = "";
        throw error;
      }
      // Handle other commands normally
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached") && !cmdStr.includes("--quiet")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toThrow(
      "Deterministic test verification failed",
    );

    // Task should NOT be moved to done
    expect(store.moveTask).not.toHaveBeenCalledWith("FN-050", "done");
    // Log entry should indicate failure
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("test verification failed"),
      "VerificationError",
    );
  });

  it("explicit settings.testCommand takes precedence over inferred command", async () => {
    mockedExistsSync.mockImplementation((path: any) => {
      return String(path).includes("pnpm-lock.yaml");
    });

    const verificationCalls: string[] = [];
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("vitest run")) {
        verificationCalls.push("vitest run");
        return Buffer.from("");
      }
      if (cmdStr.includes("pnpm test")) {
        verificationCalls.push("pnpm test - SHOULD NOT BE CALLED");
        return Buffer.from("");
      }
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached") && !cmdStr.includes("--quiet")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    // Explicit testCommand is set
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
    });

    await aiMergeTask(store, "/tmp/root", "FN-050");

    // Explicit command should be used, not inferred
    expect(verificationCalls).toContain("vitest run");
    expect(verificationCalls).not.toContain("pnpm test - SHOULD NOT BE CALLED");
  });

  it("skips verification when no lock files exist and no explicit testCommand is set", async () => {
    // No lock files exist
    mockedExistsSync.mockReturnValue(false);

    const verificationCalls: string[] = [];
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("pnpm test") || cmdStr.includes("npm test") || cmdStr.includes("yarn test") || cmdStr.includes("bun test")) {
        verificationCalls.push(cmdStr);
      }
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached") && !cmdStr.includes("--quiet")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      return Buffer.from("");
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
    });

    const result = await aiMergeTask(store, "/tmp/root", "FN-050");

    // No test verification should have run
    expect(verificationCalls).toHaveLength(0);
    // Merge should still succeed
    expect(result.merged).toBe(true);
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
  });
});

describe("aiMergeTask — skill selection resolver contract (FN-1510/FN-1511)", () => {
  // Mock session-skill-context to control skill selection behavior
  vi.mock("../session-skill-context.js", () => ({
    buildSessionSkillContext: vi.fn(),
  }));

  beforeEach(() => {
    vi.clearAllMocks();
  });

  it("passes skillSelection to createFnAgent when agentStore is provided", async () => {
    const { buildSessionSkillContext } = await import("../session-skill-context.js");
    vi.mocked(buildSessionSkillContext).mockResolvedValue({
      skillSelectionContext: {
        projectRootDir: "/tmp/root",
        requestedSkillNames: ["fusion"],
        sessionPurpose: "merger",
      },
      resolvedSkillNames: ["fusion"],
      skillSource: "role-fallback",
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn(),
        dispose: vi.fn(),
      },
    } as any);

    setupHappyPathExecSync();

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
    });

    const mockAgentStore = {
      listAgents: vi.fn().mockResolvedValue([]),
    };

    await aiMergeTask(store, "/tmp/root", "FN-050", {
      agentStore: mockAgentStore as any,
    });

    expect(mockedCreateFnAgent).toHaveBeenCalled();
    // Find the first createFnAgent call (main merger agent)
    const firstCall = mockedCreateFnAgent.mock.calls[0];
    const opts = firstCall[0];
    expect(opts.skillSelection).toBeDefined();
    expect(opts.skillSelection!.projectRootDir).toBe("/tmp/root");
    expect(opts.skillSelection!.requestedSkillNames).toEqual(["fusion"]);
    expect(opts.skillSelection!.sessionPurpose).toBe("merger");
  });

  it("uses assigned agent skills when available", async () => {
    const { buildSessionSkillContext } = await import("../session-skill-context.js");
    vi.mocked(buildSessionSkillContext).mockResolvedValue({
      skillSelectionContext: {
        projectRootDir: "/tmp/root",
        requestedSkillNames: ["custom-skill", "another-skill"],
        sessionPurpose: "merger",
      },
      resolvedSkillNames: ["custom-skill", "another-skill"],
      skillSource: "assigned-agent",
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn(),
        dispose: vi.fn(),
      },
    } as any);

    setupHappyPathExecSync();

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", assignedAgentId: "agent-001" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
    });

    const mockAgentStore = {
      listAgents: vi.fn().mockResolvedValue([]),
    };

    await aiMergeTask(store, "/tmp/root", "FN-050", {
      agentStore: mockAgentStore as any,
    });

    expect(mockedCreateFnAgent).toHaveBeenCalled();
    const firstCall = mockedCreateFnAgent.mock.calls[0];
    const opts = firstCall[0];
    expect(opts.skillSelection).toBeDefined();
    expect(opts.skillSelection!.requestedSkillNames).toEqual(["custom-skill", "another-skill"]);
  });

  it("does not pass skillSelection when buildSessionSkillContext returns undefined context", async () => {
    const { buildSessionSkillContext } = await import("../session-skill-context.js");
    vi.mocked(buildSessionSkillContext).mockResolvedValue({
      skillSelectionContext: undefined,
      resolvedSkillNames: [],
      skillSource: "none",
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn(),
        dispose: vi.fn(),
      },
    } as any);

    setupHappyPathExecSync();

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
    });

    const mockAgentStore = {
      listAgents: vi.fn().mockResolvedValue([]),
    };

    await aiMergeTask(store, "/tmp/root", "FN-050", {
      agentStore: mockAgentStore as any,
    });

    expect(mockedCreateFnAgent).toHaveBeenCalled();
    const firstCall = mockedCreateFnAgent.mock.calls[0];
    const opts = firstCall[0];
    // skillSelection should not be present when context is undefined
    expect("skillSelection" in opts).toBe(false);
  });

  it("does not pass skillSelection when agentStore is not provided", async () => {
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn(),
        dispose: vi.fn(),
      },
    } as any);

    setupHappyPathExecSync();

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
    });

    // No agentStore provided
    await aiMergeTask(store, "/tmp/root", "FN-050");

    expect(mockedCreateFnAgent).toHaveBeenCalled();
    const firstCall = mockedCreateFnAgent.mock.calls[0];
    const opts = firstCall[0];
    expect("skillSelection" in opts).toBe(false);
  });

  it("gracefully handles buildSessionSkillContext throwing", async () => {
    const { buildSessionSkillContext } = await import("../session-skill-context.js");
    vi.mocked(buildSessionSkillContext).mockRejectedValue(new Error("Agent not found"));

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn(),
        dispose: vi.fn(),
      },
    } as any);

    setupHappyPathExecSync();

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
    });

    const mockAgentStore = {
      listAgents: vi.fn().mockResolvedValue([]),
    };

    // Should not throw - graceful fallback
    const result = await aiMergeTask(store, "/tmp/root", "FN-050", {
      agentStore: mockAgentStore as any,
    });

    expect(result.merged).toBe(true);
    expect(mockedCreateFnAgent).toHaveBeenCalled();
    const firstCall = mockedCreateFnAgent.mock.calls[0];
    const opts = firstCall[0];
    expect("skillSelection" in opts).toBe(false);
  });

  it("records resolved skill names in skill context result", async () => {
    const { buildSessionSkillContext } = await import("../session-skill-context.js");
    const resolvedNames = ["skill-a", "skill-b"];
    vi.mocked(buildSessionSkillContext).mockResolvedValue({
      skillSelectionContext: {
        projectRootDir: "/tmp/root",
        requestedSkillNames: resolvedNames,
        sessionPurpose: "merger",
      },
      resolvedSkillNames: resolvedNames,
      skillSource: "assigned-agent",
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn(),
        dispose: vi.fn(),
      },
    } as any);

    setupHappyPathExecSync();

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", assignedAgentId: "agent-001" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
    });

    const mockAgentStore = {
      listAgents: vi.fn().mockResolvedValue([]),
    };

    await aiMergeTask(store, "/tmp/root", "FN-050", {
      agentStore: mockAgentStore as any,
    });

    expect(mockedCreateFnAgent).toHaveBeenCalled();
    const firstCall = mockedCreateFnAgent.mock.calls[0];
    const opts = firstCall[0];
    expect(opts.skillSelection?.requestedSkillNames).toEqual(resolvedNames);
  });

  it("uses sessionPurpose='merger' in skill selection context", async () => {
    const { buildSessionSkillContext } = await import("../session-skill-context.js");
    vi.mocked(buildSessionSkillContext).mockResolvedValue({
      skillSelectionContext: {
        projectRootDir: "/tmp/root",
        requestedSkillNames: ["fusion"],
        sessionPurpose: "merger",
      },
      resolvedSkillNames: ["fusion"],
      skillSource: "role-fallback",
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn(),
        dispose: vi.fn(),
      },
    } as any);

    setupHappyPathExecSync();

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
    });

    const mockAgentStore = {
      listAgents: vi.fn().mockResolvedValue([]),
    };

    await aiMergeTask(store, "/tmp/root", "FN-050", {
      agentStore: mockAgentStore as any,
    });

    expect(mockedCreateFnAgent).toHaveBeenCalled();
    const firstCall = mockedCreateFnAgent.mock.calls[0];
    const opts = firstCall[0];
    expect(opts.skillSelection?.sessionPurpose).toBe("merger");
  });
});

describe("aiMergeTask — skill selection non-fatal diagnostics (FN-1510/FN-1511)", () => {
  // Mock session-skill-context to control skill selection behavior
  vi.mock("../session-skill-context.js", () => ({
    buildSessionSkillContext: vi.fn(),
  }));

  beforeEach(() => {
    vi.clearAllMocks();
    vi.spyOn(console, "error").mockImplementation(() => {});
  });

  afterEach(() => {
    vi.restoreAllMocks();
  });

  it("merge continues when skill selection produces diagnostics", async () => {
    const { buildSessionSkillContext } = await import("../session-skill-context.js");
    // Simulate diagnostics being logged - the resolver would produce these
    // when requested skills are not found or filtered
    vi.mocked(buildSessionSkillContext).mockResolvedValue({
      skillSelectionContext: {
        projectRootDir: "/tmp/root",
        requestedSkillNames: ["nonexistent-skill"],
        sessionPurpose: "merger",
      },
      resolvedSkillNames: [],
      skillSource: "none",
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn(),
        dispose: vi.fn(),
      },
    } as any);

    setupHappyPathExecSync();

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
    });

    const mockAgentStore = {
      listAgents: vi.fn().mockResolvedValue([]),
    };

    // Merge should succeed even when skill diagnostics are present
    const result = await aiMergeTask(store, "/tmp/root", "FN-050", {
      agentStore: mockAgentStore as any,
    });

    expect(result.merged).toBe(true);
    expect(store.moveTask).toHaveBeenCalledWith("FN-050", "done");
  });

  it("records skill source in context result for debugging", async () => {
    const { buildSessionSkillContext } = await import("../session-skill-context.js");
    vi.mocked(buildSessionSkillContext).mockResolvedValue({
      skillSelectionContext: {
        projectRootDir: "/tmp/root",
        requestedSkillNames: ["custom-skill"],
        sessionPurpose: "merger",
      },
      resolvedSkillNames: ["custom-skill"],
      skillSource: "assigned-agent",
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn(),
        dispose: vi.fn(),
      },
    } as any);

    setupHappyPathExecSync();

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", assignedAgentId: "agent-001" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
    });

    const mockAgentStore = {
      listAgents: vi.fn().mockResolvedValue([]),
    };

    const result = await aiMergeTask(store, "/tmp/root", "FN-050", {
      agentStore: mockAgentStore as any,
    });

    // Result should be successful regardless of skill source
    expect(result.merged).toBe(true);

    // Verify skillSelection was passed with the custom skill
    expect(mockedCreateFnAgent).toHaveBeenCalled();
    const firstCall = mockedCreateFnAgent.mock.calls[0];
    const opts = firstCall[0];
    expect(opts.skillSelection?.requestedSkillNames).toEqual(["custom-skill"]);
  });
});

describe("aiMergeTask — in-merge verification fix", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    vi.spyOn(console, "error").mockImplementation(() => {});
    mockedExistsSync.mockReturnValue(true);
  });

  it("verification fix is attempted when verification fails", async () => {
    // Simple mock: always fail verification
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("vitest run")) {
        const err = new Error("Test failed") as any;
        err.status = 1;
        err.stdout = "";
        err.stderr = "";
        throw err;
      }
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      const isFixAgent = opts.systemPrompt?.includes("verification fix agent");
      return {
        session: {
          prompt: vi.fn().mockResolvedValue(undefined),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
      verificationFixRetries: 1,
    });

    // With verificationFixRetries: 1, the merge should fail with VerificationError
    // because the fix agent can't fix the verification (it's mocked to not actually fix anything)
    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toMatchObject({
      name: "VerificationError",
    });

    // Verify that fix agent was spawned (3 calls: summarizer + merger + fix)
    expect(mockedCreateFnAgent).toHaveBeenCalledTimes(3);

    // Verify the fix agent was called with correct options
    const fixAgentCall = mockedCreateFnAgent.mock.calls[1];
    expect(fixAgentCall[0].tools).toBe("coding");
    expect(fixAgentCall[0].cwd).toBe("/tmp/root");
  });

  it("logs fix-agent startup metadata, streams callbacks, and logs rerun lifecycle", async () => {
    let capturedFixOptions: any;

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("vitest run")) {
        const err = new Error("Test failed") as any;
        err.status = 1;
        err.stdout = "";
        err.stderr = "";
        throw err;
      }
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      const isFixAgent = opts.systemPrompt?.includes("verification fix agent");
      if (!isFixAgent) {
        return {
          session: {
            prompt: vi.fn().mockResolvedValue(undefined),
            dispose: vi.fn(),
          },
        } as any;
      }

      capturedFixOptions = opts;
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            opts.onText?.("working on fix");
            opts.onThinking?.("diagnosing");
            opts.onToolStart?.("Bash", { command: "vitest run" });
            opts.onToolEnd?.("Bash", false, "still failing");
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
      verificationFixRetries: 1,
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toMatchObject({
      name: "VerificationError",
    });

    expect(capturedFixOptions).toBeDefined();
    expect(capturedFixOptions.onText).toBeTypeOf("function");
    expect(capturedFixOptions.onThinking).toBeTypeOf("function");
    expect(capturedFixOptions.onToolStart).toBeTypeOf("function");
    expect(capturedFixOptions.onToolEnd).toBeTypeOf("function");

    expect(store.appendAgentLog).toHaveBeenCalledWith("FN-050", "Bash", "tool", "vitest run", "merger");

    const logMessages = (store.logEntry as ReturnType<typeof vi.fn>).mock.calls
      .map((call: any[]) => call[1])
      .filter((message: unknown): message is string => typeof message === "string");

    const startupLog = logMessages.find((message) =>
      message.includes("In-merge verification fix agent started"),
    );
    expect(startupLog).toBeDefined();
    expect(startupLog).toContain("model: mock-provider/mock-model");
    expect(startupLog).toContain("agentId: merger");
    expect(startupLog).toMatch(/runId: merge-FN-050-/);

    const rerunIdx = logMessages.findIndex((message) =>
      message.includes("Re-running deterministic merge verification (attempt 1)"),
    );
    expect(rerunIdx).toBeGreaterThan(-1);

    const verificationAfterRerunIdx = logMessages.findIndex(
      (message, index) =>
        index > rerunIdx && message.includes("[verification] Running test command: vitest run"),
    );
    expect(verificationAfterRerunIdx).toBeGreaterThan(rerunIdx);
  });

  it("logs rerun lifecycle before verification in build-failure fix path", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("pnpm build")) {
        const err = new Error("Build failed") as any;
        err.status = 1;
        err.stdout = "";
        err.stderr = "";
        throw err;
      }
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      const isFixAgent = opts.systemPrompt?.includes("verification fix agent");
      if (isFixAgent) {
        return {
          session: {
            prompt: vi.fn().mockResolvedValue(undefined),
            dispose: vi.fn(),
          },
        } as any;
      }

      const reportTool = opts.customTools?.find((t: any) => t.name === "fn_report_build_failure");
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            await reportTool?.execute("tool-call-build", { message: "Type error in src/build.ts" });
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      buildCommand: "pnpm build",
      verificationFixRetries: 1,
      buildRetryCount: 0,
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toThrow(
      "Build verification failed for FN-050: Type error in src/build.ts",
    );

    const logMessages = (store.logEntry as ReturnType<typeof vi.fn>).mock.calls
      .map((call: any[]) => call[1])
      .filter((message: unknown): message is string => typeof message === "string");

    const rerunIdx = logMessages.findIndex((message) =>
      message.includes("Re-running deterministic merge verification (attempt 1)"),
    );
    expect(rerunIdx).toBeGreaterThan(-1);

    const verificationAfterRerunIdx = logMessages.findIndex(
      (message, index) =>
        index > rerunIdx && message.includes("[verification] Running build command: pnpm build"),
    );
    expect(verificationAfterRerunIdx).toBeGreaterThan(rerunIdx);
  });

  it("verification fix is skipped when verificationFixRetries is 0", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("vitest run")) {
        const err = new Error("Test failed") as any;
        err.status = 1;
        err.stdout = "";
        err.stderr = "";
        throw err;
      }
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
      verificationFixRetries: 0,
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toMatchObject({
      name: "VerificationError",
    });

    // Verify fix agent was NOT spawned (summarizer + merger only)
    expect(mockedCreateFnAgent).toHaveBeenCalledTimes(2);

    // Verify no fix attempt was logged
    const logCalls = (store.logEntry as ReturnType<typeof vi.fn>).mock.calls;
    const fixAttempts = logCalls.filter((call: any[]) =>
      typeof call[1] === "string" && call[1].includes("in-merge verification fix"),
    );
    expect(fixAttempts).toHaveLength(0);
  });

  it("fix agent uses same model settings as merger", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("vitest run")) {
        const err = new Error("Test failed") as any;
        err.status = 1;
        err.stdout = "";
        err.stderr = "";
        throw err;
      }
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockImplementation(async (_opts: any) => {
      return {
        session: {
          prompt: vi.fn().mockResolvedValue(undefined),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
      verificationFixRetries: 1,
      defaultProvider: "anthropic",
      defaultModelId: "claude-sonnet-4-5",
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toMatchObject({
      name: "VerificationError",
    });

    // Verify fix agent uses same model settings
    const fixAgentCall = mockedCreateFnAgent.mock.calls[1];
    expect(fixAgentCall[0].defaultProvider).toBe("anthropic");
    expect(fixAgentCall[0].defaultModelId).toBe("claude-sonnet-4-5");
  });

  it("uses project default override for merge agent model", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("vitest run")) {
        const err = new Error("Test failed") as any;
        err.status = 1;
        err.stdout = "";
        err.stderr = "";
        throw err;
      }
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockImplementation(async (_opts: any) => {
      return {
        session: {
          prompt: vi.fn().mockResolvedValue(undefined),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
      verificationFixRetries: 0,
      defaultProvider: "anthropic",
      defaultModelId: "claude-sonnet-4-5",
      defaultProviderOverride: "openai",
      defaultModelIdOverride: "gpt-4o",
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toMatchObject({
      name: "VerificationError",
    });

    const mergeAgentCall = mockedCreateFnAgent.mock.calls[0];
    expect(mergeAgentCall[0].defaultProvider).toBe("openai");
    expect(mergeAgentCall[0].defaultModelId).toBe("gpt-4o");
  });

  it("fix agent session is disposed", async () => {
    const disposeMock = vi.fn();

    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("vitest run")) {
        const err = new Error("Test failed") as any;
        err.status = 1;
        err.stdout = "";
        err.stderr = "";
        throw err;
      }
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      const isFixAgent = opts.systemPrompt?.includes("verification fix agent");
      if (isFixAgent) {
        return {
          session: {
            prompt: vi.fn().mockResolvedValue(undefined),
            dispose: disposeMock,
          },
        } as any;
      }
      return {
        session: {
          prompt: vi.fn().mockResolvedValue(undefined),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
      verificationFixRetries: 1,
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toMatchObject({
      name: "VerificationError",
    });

    expect(disposeMock).toHaveBeenCalled();
  });

  it("max fix retries capped at 3", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("vitest run")) {
        const err = new Error("Test failed") as any;
        err.status = 1;
        err.stdout = "";
        err.stderr = "";
        throw err;
      }
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      return {
        session: {
          prompt: vi.fn().mockResolvedValue(undefined),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
      verificationFixRetries: 10, // Exceeds max
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toMatchObject({
      name: "VerificationError",
    });

    // Should have 3 fix attempts (capped at 3) + summarizer + merger = 5 calls
    expect(mockedCreateFnAgent).toHaveBeenCalledTimes(5);
  });

  it("default verificationFixRetries (omitted) results in 3 fix attempts", async () => {
    mockedExecSync.mockImplementation((cmd: any) => {
      const cmdStr = String(cmd);
      if (cmdStr.includes("rev-parse --verify")) return Buffer.from("abc123");
      if (cmdStr.includes("git log")) return "- feat: something" as any;
      if (cmdStr.includes("merge-base")) return Buffer.from("abc123");
      if (cmdStr.includes("git diff") && cmdStr.includes("--stat")) return "1 file changed" as any;
      if (cmdStr.includes("merge --squash")) return Buffer.from("");
      if (cmdStr.includes("vitest run")) {
        const err = new Error("Test failed") as any;
        err.status = 1;
        err.stdout = "";
        err.stderr = "";
        throw err;
      }
      if (cmdStr.includes("diff --cached --quiet")) return "1" as any;
      if (cmdStr.includes("diff --cached")) return "" as any;
      if (cmdStr.includes("branch -d") || cmdStr.includes("branch -D")) return Buffer.from("");
      if (cmdStr.includes("worktree remove")) return Buffer.from("");
      if (cmdStr === "git rev-parse HEAD" || cmdStr.startsWith("git rev-parse HEAD ")) return "mergedcommit123";
      return Buffer.from("");
    });

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      return {
        session: {
          prompt: vi.fn().mockResolvedValue(undefined),
          dispose: vi.fn(),
        },
      } as any;
    });

    const store = createMockStore(
      { id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050" },
      [{ id: "FN-050", worktree: "/tmp/root/.worktrees/KB-050", column: "in-review" } as Task],
    );
    // Explicitly omit verificationFixRetries to test default behavior
    (store.getSettings as ReturnType<typeof vi.fn>).mockResolvedValue({
      ...DEFAULT_SETTINGS,
      testCommand: "vitest run",
      // verificationFixRetries is NOT set — should default to 3
    });

    await expect(aiMergeTask(store, "/tmp/root", "FN-050")).rejects.toMatchObject({
      name: "VerificationError",
    });

    // Should have 3 fix attempts (default) + summarizer + merger = 5 calls
    expect(mockedCreateFnAgent).toHaveBeenCalledTimes(5);

    // Verify the log shows 3 fix attempts (2 log entries per attempt: start + failure)
    const logCalls = (store.logEntry as ReturnType<typeof vi.fn>).mock.calls;
    const fixAttempts = logCalls.filter((call: any[]) =>
      typeof call[1] === "string" && call[1].includes("In-merge verification fix attempt"),
    );
    // Each attempt produces 2 log entries: "attempt X/3" and "attempt X — verification still fails"
    expect(fixAttempts).toHaveLength(6);
    expect(fixAttempts[0][1]).toContain("attempt 1/3");
    expect(fixAttempts[2][1]).toContain("attempt 2/3");
    expect(fixAttempts[4][1]).toContain("attempt 3/3");
  });
});