// -nocheck
/* eslint-disable -eslint/no-unused-vars */
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import "./executor-test-helpers.js";
import { AgentSemaphore } from "../concurrency.js";
import { detectReviewHandoffIntent, determineRevisionResetStart } from "../executor.js";
import { TaskExecutor, buildExecutionPrompt } from "../executor.js";
import { createFnAgent } from "../pi.js";
import { reviewStep as mockedReviewStepFn } from "../reviewer.js";
import { execSync } from "node:child_process";
import { findWorktreeUser, aiMergeTask } from "../merger.js";
import { WorktreePool } from "../worktree-pool.js";
import * as worktreePoolModule from "../worktree-pool.js";
import { BranchConflictError } from "../branch-conflicts.js";
import * as branchConflictModule from "../branch-conflicts.js";
import { generateWorktreeName, slugify } from "../worktree-names.js";
import type { Task, TaskDetail } from "@fusion/core";
import { SessionManager } from "@earendil-works/pi-coding-agent";
import { StepSessionExecutor } from "../step-session-executor.js";
import { executorLog } from "../logger.js";
import { withRateLimitRetry } from "../rate-limit-retry.js";
import { runVerificationCommand as mockedRunVerificationCommand } from "../verification-utils.js";
import {
  createMockStore,
  mockedCreateFnAgent,
  mockedSessionManager,
  mockedGenerateWorktreeName,
  mockedFindWorktreeUser,
  mockedStepSessionExecutor,
  mockedWithRateLimitRetry,
  mockedExec,
  mockedExecSync,
  mockedExistsSync,
  mockedHydrateWorktreeDb,
  mockedClassifyTaskWorktree,
  mockedIsUsableTaskWorktree,
  mockedClassifyStaleLock,
  mockedTryRemoveStaleLock,
  mockedRecoverStaleRegistration,
  mockedInstallTaskWorktreeIdentityGuard,
  mockExecuteAll,
  mockTerminateAllSessions,
  mockCleanup,
  resetExecutorMocks,
} from "./executor-test-helpers.js";

const mockedReviewStep = vi.mocked(mockedReviewStepFn);

describe("TaskExecutor with semaphore", () => {
  beforeEach(() => {
    resetExecutorMocks();
  });

  it("acquires semaphore before creating agent and releases after", async () => {
    const sem = new AgentSemaphore(2);
    const store = createMockStore();
    const acquireSpy = vi.spyOn(sem, "acquire");
    const releaseSpy = vi.spyOn(sem, "release");

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

    const executor = new TaskExecutor(store, "/tmp/test", { semaphore: sem });

    await executor.execute({
      id: "FN-001",
      title: "Test",
      description: "Test",
      column: "in-progress",
      dependencies: [],
      steps: [],
      currentStep: 0,
      log: [],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    expect(acquireSpy).toHaveBeenCalledOnce();
    expect(releaseSpy).toHaveBeenCalledOnce();
    expect(sem.activeCount).toBe(0);
  });

  it("releases semaphore on agent error", async () => {
    const sem = new AgentSemaphore(1);
    const store = createMockStore();

    mockedCreateFnAgent.mockRejectedValue(new Error("agent failed"));

    const onError = vi.fn();
    const executor = new TaskExecutor(store, "/tmp/test", {
      semaphore: sem,
      onError,
    });

    await executor.execute({
      id: "FN-001",
      title: "Test",
      description: "Test",
      column: "in-progress",
      dependencies: [],
      steps: [],
      currentStep: 0,
      log: [],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    expect(sem.activeCount).toBe(0);
    expect(onError).toHaveBeenCalled();
  });

  it("sets task status to 'failed' with error message when execution throws", async () => {
    const store = createMockStore();

    mockedCreateFnAgent.mockRejectedValue(new Error("agent crashed"));

    const onError = vi.fn();
    const executor = new TaskExecutor(store, "/tmp/test", { onError });

    await executor.execute({
      id: "FN-001",
      title: "Test",
      description: "Test",
      column: "in-progress",
      dependencies: [],
      steps: [],
      currentStep: 0,
      log: [],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    expect(store.updateTask).toHaveBeenCalledWith("FN-001", { status: "failed", error: expect.any(String) });
    expect(store.moveTask).toHaveBeenCalledWith("FN-001", "in-review");
    expect(onError).toHaveBeenCalled();
  });

  it("concurrent executions respect semaphore limit", async () => {
    const sem = new AgentSemaphore(1);
    const store = createMockStore();
    let concurrent = 0;
    let maxConcurrent = 0;

    mockedCreateFnAgent.mockImplementation(async () => {
      concurrent++;
      maxConcurrent = Math.max(maxConcurrent, concurrent);
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            await new Promise((r) => setTimeout(r, 10));
            concurrent--;
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const executor = new TaskExecutor(store, "/tmp/test", { semaphore: sem });

    const task = (id: string) => ({
      id,
      title: "Test",
      description: "Test",
      column: "in-progress" as const,
      dependencies: [],
      steps: [],
      currentStep: 0,
      log: [],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    await Promise.all([
      executor.execute(task("FN-001")),
      executor.execute(task("FN-002")),
      executor.execute(task("FN-003")),
    ]);

    expect(maxConcurrent).toBe(1);
    expect(sem.activeCount).toBe(0);
  });
});

describe("TaskExecutor worktreeInitCommand", () => {
  const makeTask = (id = "FN-010") => ({
    id,
    title: "Test",
    description: "Test",
    column: "in-progress" as const,
    dependencies: [],
    steps: [],
    currentStep: 0,
    log: [],
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
  });

  beforeEach(() => {
    resetExecutorMocks();
    // Default: worktree does NOT exist (new worktree)
    mockedExistsSync.mockReturnValue(false);
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  it("runs worktreeInitCommand in new worktree when configured", async () => {
    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      worktreeInitCommand: "pnpm install --frozen-lockfile",
    });

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    // execSync is called for worktree creation + init command
    const initCall = mockedExecSync.mock.calls.find(
      (call) => call[0] === "pnpm install --frozen-lockfile",
    );
    expect(initCall).toBeDefined();
    expect(initCall![1]).toMatchObject({
      cwd: expect.stringContaining(".worktrees/"),
      timeout: 300_000,
    });

    // Should log success
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-010",
      expect.stringMatching(/^\[timing\] Worktree init command completed in \d+ms$/),
      "pnpm install --frozen-lockfile",
      expect.objectContaining({ agentId: "executor" }),
    );
  });

  it("does NOT run init command when worktreeInitCommand is not set", async () => {
    const store = createMockStore();
    // getSettings returns default (no worktreeInitCommand)

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    // Only worktree creation calls to execSync, no "pnpm install --frozen-lockfile" etc.
    const initCall = mockedExecSync.mock.calls.find(
      (call) => typeof call[0] === "string" && !call[0].startsWith("git"),
    );
    expect(initCall).toBeUndefined();
  });

  it("catches init command failure and logs without aborting", async () => {
    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      worktreeInitCommand: "npm run setup",
    });

    // Make the init command fail (but not git worktree commands)
    mockedExecSync.mockImplementation((cmd: any) => {
      if (cmd === "npm run setup") {
        const err: any = new Error("command failed");
        err.stderr = Buffer.from("setup script error");
        throw err;
      }
      return Buffer.from("");
    });

    const onError = vi.fn();
    const executor = new TaskExecutor(store, "/tmp/test", { onError });
    await executor.execute(makeTask());

    // Should log the failure
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-010",
      expect.stringContaining("Worktree init command failed"),
      undefined,
      expect.objectContaining({ agentId: "executor" }),
    );

    // The init command failure itself does not abort execution, but the mocked
    // agent still exits without fn_task_done. After 3 retries it requeues to todo
    // and reports an error.
    expect(onError).toHaveBeenCalledWith(
      expect.objectContaining({ id: "FN-010" }),
      expect.objectContaining({ message: "Agent finished without calling fn_task_done (after 3 retries)" }),
    );

    // Agent should still have been created
    expect(mockedCreateFnAgent).toHaveBeenCalled();
  });

  it("does NOT run init command on worktree resume", async () => {
    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      worktreeInitCommand: "pnpm install --frozen-lockfile",
    });

    // Worktree already exists (resume)
    mockedExistsSync.mockReturnValue(true);

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    // getSettings is called (for project commands in execution prompt) but init command should not run
    expect(store.getSettings).toHaveBeenCalled();
  });
});

describe("TaskExecutor worktree naming", () => {
  const makeTask = (id = "FN-030", worktree?: string) => ({
    id,
    title: "Test Task Title",
    description: "Test description for task",
    column: "in-progress" as const,
    dependencies: [],
    steps: [],
    currentStep: 0,
    log: [],
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
    ...(worktree ? { worktree } : {}),
  });

  beforeEach(() => {
    resetExecutorMocks();
    mockedExistsSync.mockReturnValue(false);
    mockedGenerateWorktreeName.mockReturnValue("swift-falcon");
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  it("uses generateWorktreeName for fresh worktree directories", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");

    await executor.execute(makeTask());

    // The worktree path stored should use the generated name, not the task ID
    expect(store.updateTask).toHaveBeenCalledWith("FN-030", {
      worktree: "/tmp/test/.worktrees/swift-falcon",
      branch: "fusion/fn-030",
    });
    expect(mockedGenerateWorktreeName).toHaveBeenCalledWith("/tmp/test", expect.any(Object));
  });

  it("does NOT use task ID as worktree directory name for fresh worktrees", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");

    await executor.execute(makeTask("FN-099"));

    // Verify the worktree path does NOT contain the task ID
    const updateCalls = store.updateTask.mock.calls;
    const worktreeUpdate = updateCalls.find(
      (call: any[]) => call[1]?.worktree !== undefined,
    );
    expect(worktreeUpdate).toBeDefined();
    expect(worktreeUpdate![1].worktree).not.toContain("FN-099");
    expect(worktreeUpdate![1].worktree).toContain("swift-falcon");
  });

  it("reuses stored worktree path for resumed tasks", async () => {
    const existingPath = "/tmp/test/.worktrees/calm-river";
    mockedExistsSync.mockReturnValue(true);
    mockedExecSync.mockImplementation((cmd: any) => {
      if (String(cmd) === "git worktree list --porcelain") {
        return [
          "worktree /tmp/test",
          "HEAD abc123",
          "branch refs/heads/main",
          "",
          `worktree ${existingPath}`,
          "HEAD def456",
          "branch refs/heads/fusion/fn-031",
          "",
        ].join("\n") as any;
      }
      return Buffer.from("");
    });

    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");

    await executor.execute(makeTask("FN-031", existingPath));

    // Should NOT generate a new name — reuse the stored path
    expect(mockedGenerateWorktreeName).not.toHaveBeenCalled();
  });

  it("does not reuse a stored worktree path that is not registered", async () => {
    const stalePath = "/tmp/test/.worktrees/broken-wt";
    mockedIsUsableTaskWorktree.mockResolvedValueOnce(false);
    mockedClassifyTaskWorktree.mockResolvedValueOnce({ ok: false, classification: "incomplete", reason: "missing or invalid .git metadata" } as any);
    mockedExistsSync.mockImplementation((path) => String(path).startsWith(stalePath));
    mockedExecSync.mockImplementation((cmd: any) => {
      if (String(cmd) === "git worktree list --porcelain") {
        return "worktree /tmp/test\nHEAD abc123\nbranch refs/heads/main\n" as any;
      }
      return Buffer.from("");
    });

    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");

    await executor.execute(makeTask("FN-032", stalePath));

    expect(store.updateTask).toHaveBeenCalledWith("FN-032", expect.objectContaining({ worktree: null, branch: null }));
    expect(mockedGenerateWorktreeName).toHaveBeenCalledWith("/tmp/test", expect.any(Object));
    const worktreeAddCalls = mockedExecSync.mock.calls.filter(
      (call) => typeof call[0] === "string" && call[0].includes("git worktree add"),
    );
    expect(worktreeAddCalls.length).toBeGreaterThan(0);
  });

  describe("worktreeNaming setting", () => {
    it("uses task ID as worktree name when worktreeNaming is 'task-id'", async () => {
      const store = createMockStore();
      store.getSettings.mockResolvedValue({
        maxConcurrent: 2,
        maxWorktrees: 4,
        pollIntervalMs: 15000,
        groupOverlappingFiles: false,
        autoMerge: false,
        worktreeNaming: "task-id",
      });

      const executor = new TaskExecutor(store, "/tmp/test");
      await executor.execute(makeTask("FN-042"));

      // Should use task ID (lowercase) as worktree name
      expect(store.updateTask).toHaveBeenCalledWith("FN-042", {
        worktree: "/tmp/test/.worktrees/fn-042",
        branch: "fusion/fn-042",
      });
      // Should NOT call generateWorktreeName when using task-id
      expect(mockedGenerateWorktreeName).not.toHaveBeenCalled();
    });

    it("uses slugified task title as worktree name when worktreeNaming is 'task-title'", async () => {
      const store = createMockStore();
      store.getSettings.mockResolvedValue({
        maxConcurrent: 2,
        maxWorktrees: 4,
        pollIntervalMs: 15000,
        groupOverlappingFiles: false,
        autoMerge: false,
        worktreeNaming: "task-title",
      });

      const executor = new TaskExecutor(store, "/tmp/test");
      await executor.execute({
        ...makeTask("FN-043"),
        title: "Fix login bug with OAuth",
      });

      // Should use slugified title as worktree name
      const expectedSlug = slugify("Fix login bug with OAuth");
      expect(store.updateTask).toHaveBeenCalledWith("FN-043", {
        worktree: `/tmp/test/.worktrees/${expectedSlug}`,
        branch: "fusion/fn-043",
      });
      expect(mockedGenerateWorktreeName).not.toHaveBeenCalled();
    });

    it("falls back to description when title is empty for 'task-title' mode", async () => {
      const store = createMockStore();
      store.getSettings.mockResolvedValue({
        maxConcurrent: 2,
        maxWorktrees: 4,
        pollIntervalMs: 15000,
        groupOverlappingFiles: false,
        autoMerge: false,
        worktreeNaming: "task-title",
      });

      const executor = new TaskExecutor(store, "/tmp/test");
      const taskDescription = "Implement user authentication flow";
      await executor.execute({
        ...makeTask("FN-044"),
        title: "",
        description: taskDescription,
      });

      // Should slugify the first 60 chars of description when title is empty
      const expectedSlug = slugify(taskDescription.slice(0, 60));
      expect(store.updateTask).toHaveBeenCalledWith("FN-044", {
        worktree: `/tmp/test/.worktrees/${expectedSlug}`,
        branch: "fusion/fn-044",
      });
    });

    it("uses generateWorktreeName when worktreeNaming is 'random'", async () => {
      const store = createMockStore();
      store.getSettings.mockResolvedValue({
        maxConcurrent: 2,
        maxWorktrees: 4,
        pollIntervalMs: 15000,
        groupOverlappingFiles: false,
        autoMerge: false,
        worktreeNaming: "random",
      });

      const executor = new TaskExecutor(store, "/tmp/test");
      await executor.execute(makeTask("FN-045"));

      // Should use generateWorktreeName for random mode
      expect(store.updateTask).toHaveBeenCalledWith("FN-045", {
        worktree: "/tmp/test/.worktrees/swift-falcon",
        branch: "fusion/fn-045",
      });
      expect(mockedGenerateWorktreeName).toHaveBeenCalledWith("/tmp/test", expect.any(Object));
    });

    it("defaults to random naming when worktreeNaming is undefined", async () => {
      const store = createMockStore();
      store.getSettings.mockResolvedValue({
        maxConcurrent: 2,
        maxWorktrees: 4,
        pollIntervalMs: 15000,
        groupOverlappingFiles: false,
        autoMerge: false,
        // worktreeNaming is not set (undefined)
      });

      const executor = new TaskExecutor(store, "/tmp/test");
      await executor.execute(makeTask("FN-046"));

      // Should default to random naming
      expect(store.updateTask).toHaveBeenCalledWith("FN-046", {
        worktree: "/tmp/test/.worktrees/swift-falcon",
        branch: "fusion/fn-046",
      });
      expect(mockedGenerateWorktreeName).toHaveBeenCalledWith("/tmp/test", expect.any(Object));
    });

    it("ignores worktreeNaming setting when using pooled worktree (recycle mode)", async () => {
      const pool = new WorktreePool();
      pool.release("/tmp/test/.worktrees/pooled-warm-wt");
      mockedIsUsableTaskWorktree.mockResolvedValue(true);
      // Pool path exists on disk, task worktree path does not (not a resume)
      mockedExistsSync.mockReturnValue(true);

      const store = createMockStore();
      store.getSettings.mockResolvedValue({
        maxConcurrent: 2,
        maxWorktrees: 4,
        pollIntervalMs: 15000,
        groupOverlappingFiles: false,
        autoMerge: false,
        recycleWorktrees: true,
        worktreeNaming: "task-id", // This should be ignored for pooled worktrees
      });

      vi.spyOn(pool, "acquire").mockReturnValue("/tmp/test/.worktrees/pooled-warm-wt");
      vi.spyOn(pool, "prepareForTask").mockResolvedValue({
        branch: "fusion/fn-047",
        worktreePath: "/tmp/test/.worktrees/pooled-warm-wt",
        reclaimed: false,
      });

      const executor = new TaskExecutor(store, "/tmp/test", { pool });
      await executor.execute(makeTask("FN-047"));

      // Worktree naming preference should not break task startup in recycle mode.
      expect(store.updateTask).toHaveBeenCalledWith("FN-047", {
        worktree: "/tmp/test/.worktrees/swift-falcon",
        branch: "fusion/fn-047",
      });
      expect(mockedGenerateWorktreeName).toHaveBeenCalledWith("/tmp/test", expect.any(Object));
    });
  });
});

describe("TaskExecutor worktree recovery", () => {
  const makeTask = (id = "FN-050") => ({
    id,
    title: "Test Task",
    description: "Test description",
    column: "in-progress" as const,
    dependencies: [],
    steps: [],
    currentStep: 0,
    log: [],
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
  });

  beforeEach(() => {
    vi.useFakeTimers();
    resetExecutorMocks();
    mockedExistsSync.mockReturnValue(false);
    mockedGenerateWorktreeName.mockReturnValue("swift-falcon");
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  afterEach(() => {
    vi.useRealTimers();
  });

  it("creates worktree successfully on first attempt", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");

    await executor.execute(makeTask());

    // Should have logged worktree creation
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Worktree created at"),
      undefined,
      expect.objectContaining({ agentId: "executor" }),
    );
    // execSync should be called for worktree creation
    expect(mockedExecSync).toHaveBeenCalledWith(
      expect.stringContaining("git worktree add"),
      expect.any(Object),
    );
  });

  it("fails fast with a clear error when rootDir is not a git repository", async () => {
    const store = createMockStore();
    const onError = vi.fn();

    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command === "git rev-parse --git-dir") {
        const error: any = new Error("fatal: not a git repository (or any of the parent directories): .git");
        error.stderr = Buffer.from("fatal: not a git repository (or any of the parent directories): .git");
        throw error;
      }
      return Buffer.from("");
    });

    const executor = new TaskExecutor(store, "/tmp/test", { onError });
    await executor.execute(makeTask());

    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Cannot execute task: project directory is not a Git repository"),
    );
    expect(store.updateTask).toHaveBeenCalledWith(
      "FN-050",
      expect.objectContaining({
        status: "failed",
        error: expect.stringContaining("not a Git repository"),
      }),
    );
    expect(onError).toHaveBeenCalledWith(
      expect.objectContaining({ id: "FN-050" }),
      expect.objectContaining({ message: expect.stringContaining("not a Git repository") }),
    );
  });

  it("does not attempt git worktree add when rootDir is not a git repository", async () => {
    const store = createMockStore();

    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command === "git rev-parse --git-dir") {
        const error: any = new Error("fatal: not a git repository");
        error.stderr = Buffer.from("fatal: not a git repository");
        throw error;
      }
      return Buffer.from("");
    });

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    const worktreeAddCalls = mockedExecSync.mock.calls.filter(
      (call) => typeof call[0] === "string" && call[0].includes("git worktree add"),
    );
    expect(worktreeAddCalls).toHaveLength(0);
  });

  it("extractWorktreeConflictInfo classifies not-a-git-repository errors", () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");

    const error: any = new Error("fatal: not a git repository");
    error.stderr = Buffer.from("fatal: not a git repository");

    const conflictInfo = (executor as any).extractWorktreeConflictInfo(error);
    expect(conflictInfo.type).toBe("not-git-repo");
    expect(conflictInfo.message).toContain("not a git repository");
  });

  it("treats not-a-git-repository as non-retryable in tryCreateWorktree flow", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");

    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command === "git worktree list --porcelain") {
        return Buffer.from(["worktree /tmp/test", "HEAD abc123", "branch refs/heads/main", ""].join("\n"));
      }
      if (command.includes("git worktree add -b")) {
        const error: any = new Error("fatal: not a git repository (or any of the parent directories): .git");
        error.stderr = Buffer.from("fatal: not a git repository (or any of the parent directories): .git");
        throw error;
      }
      return Buffer.from("");
    });

    await expect(
      (executor as any).createWorktree("fusion/fn-050", "/tmp/test/.worktrees/swift-falcon", "FN-050"),
    ).rejects.toThrow("not a Git repository");

    const worktreeAddCalls = mockedExecSync.mock.calls.filter(
      (call) => typeof call[0] === "string" && call[0].includes("git worktree add -b"),
    );
    expect(worktreeAddCalls).toHaveLength(1);
  });

  it("extractWorktreeConflictInfo classifies already checked out errors as already-used", () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");

    const error: any = new Error(
      "fatal: 'fusion/fn-050' is already checked out at '/tmp/test/.worktrees/green-sage'",
    );
    error.stderr = Buffer.from(
      "fatal: 'fusion/fn-050' is already checked out at '/tmp/test/.worktrees/green-sage'",
    );

    const conflictInfo = (executor as any).extractWorktreeConflictInfo(error);
    expect(conflictInfo).toMatchObject({
      type: "already-used",
      path: "/tmp/test/.worktrees/green-sage",
    });
  });

  it("recovers from already checked out worktree conflict and retries", async () => {
    const store = createMockStore();
    let callCount = 0;

    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree add") && callCount++ === 0) {
        const error: any = new Error(
          "fatal: 'fusion/fn-050' is already checked out at '/tmp/test/.worktrees/green-sage'",
        );
        error.stderr = Buffer.from(
          "fatal: 'fusion/fn-050' is already checked out at '/tmp/test/.worktrees/green-sage'",
        );
        throw error;
      }
      return Buffer.from("");
    });

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Cleaned up conflicting worktree, retrying"),
      "/tmp/test/.worktrees/swift-falcon",
    );
    expect(store.updateTask).toHaveBeenCalledWith(
      "FN-050",
      expect.objectContaining({ worktree: expect.any(String) }),
    );
  });

  it("records recovery context when handling a branch conflict (FN-4847: now discards + requeues instead of pausing)", async () => {
    // FN-4847: branch-conflict-unrecoverable previously paused the task with
    // status=failed + pausedReason="branch-conflict-unrecoverable". The user has
    // opted into discard-and-recreate, so the executor's handleBranchConflict now
    // delegates to the auto-recovery dispatcher which in 'deterministic-only' mode
    // returns action='retry'. The handler discards the foreign branch and requeues
    // the task to todo. status='failed' is no longer set; moveTask IS called.
    const store = createMockStore();
    const onError = vi.fn();
    const executor = new TaskExecutor(store, "/tmp/test", { onError });

    const result = await (executor as any).handleBranchConflict(
      makeTask(),
      new BranchConflictError({
        branchName: "fusion/fn-050",
        conflictingWorktreePath: "/tmp/test/.worktrees/green-sage",
        existingTipSha: "abc123def456",
        strandedCommits: [
          { sha: "aaa111", subject: "Preserve prior fix" },
          { sha: "bbb222", subject: "Add regression coverage" },
        ],
        startPoint: "HEAD",
        recommendedAction: "Reclaim the existing task branch/worktree or explicitly discard prior work before retrying.",
      }),
    );

    // New contract: handleBranchConflict returns 'retry' (not 'sticky') and does
    // NOT mark the task failed. The branch-conflict context still gets logged and
    // surfaced for observability, but the task continues via requeue.
    expect(result).toBe("retry");
    expect(store.updateTask).not.toHaveBeenCalledWith(
      "FN-050",
      expect.objectContaining({ status: "failed" }),
    );
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Existing tip: abc123def456"),
      undefined,
      undefined,
    );
    expect(store.appendAgentLog).toHaveBeenCalledWith(
      "FN-050",
      "Branch conflict recovery required",
      "tool_error",
      expect.stringContaining("stranded=aaa111 Preserve prior fix"),
      "executor",
    );
    // onError no longer fires for the recoverable branch-conflict-unrecoverable path.
    expect(onError).not.toHaveBeenCalled();
  });

  it("FN-4397 reproduces repeated branch-conflict recovery-required emissions for the same task", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    const conflictError = new BranchConflictError({
      branchName: "fusion/fn-050",
      conflictingWorktreePath: "/tmp/test/.worktrees/green-sage",
      existingTipSha: "abc123def456",
      strandedCommits: [],
      startPoint: "HEAD",
      recommendedAction: "Reclaim the existing task branch/worktree or explicitly discard prior work before retrying.",
    });

    vi.spyOn(branchConflictModule, "inspectBranchConflict").mockResolvedValue({
      kind: "live-foreign",
      livePath: "/tmp/test/.worktrees/green-sage",
      error: conflictError,
    });
    vi.spyOn(executor as any, "cleanupConflictingWorktree").mockResolvedValue(false);

    await (executor as any).handleBranchConflict(makeTask(), conflictError);
    await (executor as any).handleBranchConflict(makeTask(), conflictError);
    await (executor as any).handleBranchConflict(makeTask(), conflictError);

    expect(store.appendAgentLog).toHaveBeenCalledTimes(3);
    expect(store.appendAgentLog).toHaveBeenNthCalledWith(
      1,
      "FN-050",
      "Branch conflict recovery required",
      "tool_error",
      expect.any(String),
      "executor",
    );
  });

  it("FN-4397 tripwire pauses on 6th branch conflict and suppresses additional recovery-required agent logs", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    const conflictError = new BranchConflictError({
      branchName: "fusion/fn-050",
      conflictingWorktreePath: "/tmp/test/.worktrees/green-sage",
      existingTipSha: "abc123def456",
      strandedCommits: [],
      startPoint: "HEAD",
      recommendedAction: "Reclaim the existing task branch/worktree or explicitly discard prior work before retrying.",
    });

    const handleSpy = vi.spyOn(executor as any, "handleBranchConflict").mockImplementation(async () => {
      await store.appendAgentLog("FN-050", "Branch conflict recovery required", "tool_error", "mock", "executor");
      return "sticky";
    });
    vi.spyOn(executor as any, "createWorktree").mockRejectedValue(conflictError);

    for (let i = 0; i < 6; i += 1) {
      await executor.execute(makeTask());
    }

    expect(handleSpy).toHaveBeenCalledTimes(5);
    const tripwireLogCall = vi.mocked(store.logEntry).mock.calls.find((call: unknown[]) =>
      call[0] === "FN-050" && String(call[1]).includes("Branch conflict tripwire fired after 6 events"),
    );
    expect(tripwireLogCall).toBeDefined();
    expect(store.updateTask).toHaveBeenCalledWith(
      "FN-050",
      expect.objectContaining({
        status: "failed",
        paused: true,
        pausedReason: "branch-conflict-tripwire",
      }),
    );
    expect(store.appendAgentLog).toHaveBeenCalledTimes(5);
  });

  it("falls back to default base and clears task.executionStartBranch when the configured base ref is missing (FN-2165)", async () => {
    const store = createMockStore();

    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git rev-parse --verify")) {
        // The stored baseBranch no longer exists — simulates a dep's branch
        // being deleted while this task sat queued/stuck.
        const error: any = new Error("fatal: Needed a single revision");
        error.stderr = Buffer.from("fatal: Needed a single revision");
        throw error;
      }
      return Buffer.from("");
    });

    const onError = vi.fn();
    const executor = new TaskExecutor(store, "/tmp/test", { onError });
    await executor.execute({ ...makeTask(), executionStartBranch: "fusion/missing-base" });

    // Should log the soft fallback, not a terminal failure
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining('Worktree base ref "fusion/missing-base" is missing'),
      expect.any(String),
    );
    // Should clear baseBranch on the task so retries use the default
    expect(store.updateTask).toHaveBeenCalledWith(
      "FN-050",
      expect.objectContaining({ executionStartBranch: null }),
    );
    // Should proceed to create a worktree from HEAD (no startPoint)
    const worktreeAddCalls = mockedExecSync.mock.calls.filter(
      (c) => typeof c[0] === "string" && c[0].includes("git worktree add"),
    );
    expect(worktreeAddCalls.length).toBeGreaterThan(0);
    // None of the worktree add calls should include the stale base ref
    for (const call of worktreeAddCalls) {
      expect(String(call[0])).not.toContain("fusion/missing-base");
    }
    // The task should NOT have been marked failed because of the stale baseBranch
    // (downstream errors unrelated to worktree creation may still occur in this
    // integration-style test — we only assert that baseBranch-missing is no
    // longer a terminal failure).
    const worktreeFailureCalls = (store.logEntry as ReturnType<typeof vi.fn>).mock.calls.filter(
      (c) => typeof c[1] === "string" && c[1].includes("Worktree creation failed"),
    );
    expect(worktreeFailureCalls).toHaveLength(0);
    // onError may still fire from downstream step execution in this test harness;
    // what matters is that the failure reason is NOT "base ref missing".
    void onError;
  });

  it("refuses to create a worktree nested inside another worktree (FN-2165 guard)", async () => {
    const store = createMockStore();

    // Simulate `git worktree list --porcelain` returning a non-root worktree
    // that would be an ancestor of the target path.
    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command === "git worktree list --porcelain") {
        return Buffer.from(
          [
            "worktree /tmp/test",
            "HEAD abc123",
            "branch refs/heads/main",
            "",
            "worktree /tmp/test/.worktrees/green-finch",
            "HEAD def456",
            "branch refs/heads/fusion/fn-007",
            "",
          ].join("\n"),
        );
      }
      return Buffer.from("");
    });

    const onError = vi.fn();
    const executor = new TaskExecutor(store, "/tmp/test", { onError });
    // Task has a worktree path nested inside green-finch — must be refused
    await executor.execute({
      ...makeTask(),
      worktree: "/tmp/test/.worktrees/green-finch/.worktrees/amber-panda",
    });

    // Should NEVER attempt a git worktree add for the nested path
    const worktreeAddCalls = mockedExecSync.mock.calls.filter(
      (c) =>
        typeof c[0] === "string" &&
        c[0].includes("git worktree add") &&
        c[0].includes("green-finch/.worktrees/amber-panda"),
    );
    expect(worktreeAddCalls).toHaveLength(0);

    // Should log the refusal with both the target and ancestor paths
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      "Refusing to create nested worktree",
      expect.stringContaining("green-finch"),
    );
  });

  it("fails after 3 unsuccessful attempts with detailed error", async () => {
    vi.useRealTimers();
    const store = createMockStore();

    // All worktree add calls fail
    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree add")) {
        const error: any = new Error(
          "fatal: 'fusion/fn-050' is already used by worktree at '/tmp/test/.worktrees/green-sage'",
        );
        error.stderr = Buffer.from(
          "fatal: 'fusion/fn-050' is already used by worktree at '/tmp/test/.worktrees/green-sage'",
        );
        throw error;
      }
      // Cleanup also fails
      if (command.includes("git worktree remove")) {
        throw new Error("cleanup failed");
      }
      return Buffer.from("");
    });

    const onError = vi.fn();
    const executor = new TaskExecutor(store, "/tmp/test", { onError });

    await executor.execute(makeTask());

    // Should log final failure
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Worktree creation failed after 3 attempts"),
      expect.any(String),
    );
    // Should update task as failed
    expect(store.updateTask).toHaveBeenCalledWith(
      "FN-050",
      expect.objectContaining({ status: "failed" }),
    );
    expect(onError).toHaveBeenCalled();
  });

  it("recovers from 'already used by worktree' error in createFromExistingBranch fallback", async () => {
    const store = createMockStore();
    let callCount = 0;

    // First createWithBranch fails with "branch already exists" (not "already used")
    // Then createFromExistingBranch fails with "already used by worktree"
    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree add")) {
        callCount++;
        if (command.includes("-b")) {
          // First attempt: createWithBranch fails with branch already exists
          const error: any = new Error(
            "fatal: A branch named 'fusion/fn-050' already exists.",
          );
          error.stderr = Buffer.from(
            "fatal: A branch named 'fusion/fn-050' already exists.",
          );
          throw error;
        } else {
          // Fallback createFromExistingBranch fails with already used
          const error: any = new Error(
            "fatal: 'fusion/fn-050' is already used by worktree at '/tmp/test/.worktrees/green-sage'",
          );
          error.stderr = Buffer.from(
            "fatal: 'fusion/fn-050' is already used by worktree at '/tmp/test/.worktrees/green-sage'",
          );
          throw error;
        }
      }
      if (command.includes("git worktree remove")) {
        return Buffer.from("");
      }
      if (command.includes("git branch -D")) {
        return Buffer.from("");
      }
      return Buffer.from("");
    });

    const executor = new TaskExecutor(store, "/tmp/test");

    // Mock the second call to tryCreateWorktree to succeed
    // by making subsequent calls succeed after cleanup
    let secondAttempt = false;
    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree add")) {
        if (secondAttempt) {
          return Buffer.from(""); // Second attempt succeeds
        }
        if (command.includes("-b")) {
          const error: any = new Error(
            "fatal: A branch named 'fusion/fn-050' already exists.",
          );
          error.stderr = Buffer.from(
            "fatal: A branch named 'fusion/fn-050' already exists.",
          );
          throw error;
        } else {
          const error: any = new Error(
            "fatal: 'fusion/fn-050' is already used by worktree at '/tmp/test/.worktrees/green-sage'",
          );
          error.stderr = Buffer.from(
            "fatal: 'fusion/fn-050' is already used by worktree at '/tmp/test/.worktrees/green-sage'",
          );
          throw error;
        }
      }
      if (command.includes("git worktree remove")) {
        secondAttempt = true; // After cleanup, next add will succeed
        return Buffer.from("");
      }
      if (command.includes("git branch -D")) {
        return Buffer.from("");
      }
      return Buffer.from("");
    });

    await executor.execute(makeTask());

    // Should have cleaned up the conflicting worktree
    expect(mockedExecSync).toHaveBeenCalledWith(
      expect.stringContaining('git worktree remove --force "/tmp/test/.worktrees/green-sage"'),
      expect.any(Object),
    );

    // Should have logged the cleanup
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Cleaned up conflicting worktree, retrying"),
      expect.any(String),
    );

    // Task should eventually succeed
    expect(store.updateTask).toHaveBeenCalledWith(
      "FN-050",
      expect.objectContaining({ worktree: expect.any(String) }),
    );
  });

  it("generates new worktree name when conflicting worktree belongs to active task in legacy rename mode (FN-4811: refuses force-removal of active worktree)", async () => {
    // FN-4811: When the conflicting worktree is bound to a live in-progress task, the
    // executor MUST NOT force-remove it (doing so yanks the active session's filesystem
    // and produces FN-4781/FN-4804-style cascade failures). Instead, with sibling-rename
    // enabled, it falls through to the suffix-rename path so the requesting task gets a
    // fresh worktree name without disturbing the live owner.
    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      executorAllowSiblingBranchRename: true,
    });
    store.listTasks.mockResolvedValue([
      {
        id: "FN-049",
        title: "Other Task",
        description: "Other task",
        column: "in-progress",
        worktree: "/tmp/test/.worktrees/green-sage",
        paused: false,
        dependencies: [],
        steps: [],
        currentStep: 0,
        log: [],
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      },
    ]);

    mockedFindWorktreeUser.mockResolvedValue("FN-049");
    mockedExistsSync.mockImplementation((path) => path === "/tmp/test/.worktrees/green-sage");

    let callCount = 0;
    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      // First attempt fails with conflict, subsequent attempts (suffix-rename path) succeed.
      if (command.includes("git worktree add") && callCount++ === 0) {
        const error: any = new Error(
          "fatal: 'fusion/fn-050' is already used by worktree at '/tmp/test/.worktrees/green-sage'",
        );
        error.stderr = Buffer.from(
          "fatal: 'fusion/fn-050' is already used by worktree at '/tmp/test/.worktrees/green-sage'",
        );
        throw error;
      }
      return Buffer.from("");
    });

    // Second generated name for the suffix-rename path.
    mockedGenerateWorktreeName.mockReturnValueOnce("jade-finch");

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute({ ...makeTask(), executionStartBranch: "fusion/fn-049" });

    // FN-4811 contract: the active worktree must NOT have been force-removed.
    const removeCalls = mockedExecSync.mock.calls
      .map((call) => String(call[0]))
      .filter((command) => command.includes("git worktree remove"));
    expect(
      removeCalls.some((command) => command.includes("/tmp/test/.worktrees/green-sage")),
    ).toBe(false);

    // The legacy "Removed foreign conflicting worktree and retrying" log must NOT fire
    // for the actively-owned worktree (that path is the bug FN-4811 fixes).
    const removalLogCalls = store.logEntry.mock.calls.map((c: any[]) => String(c[1] ?? ""));
    expect(
      removalLogCalls.some((m: string) => m.includes("Removed foreign conflicting worktree")),
    ).toBe(false);

    // The suffix-rename path was taken instead.
    expect(mockedGenerateWorktreeName).toHaveBeenCalled();
    const worktreeAddCalls = mockedExecSync.mock.calls
      .map((call) => String(call[0]))
      .filter((command) => command.includes("git worktree add -b"));
    expect(
      worktreeAddCalls.some(
        (command) =>
          command.includes('git worktree add -b "fusion/fn-050"') &&
          command.endsWith('"fusion/fn-049"'),
      ),
    ).toBe(true);
    expect(worktreeAddCalls.length).toBeGreaterThan(0);
  });

  describe("index.lock stale recovery", () => {
    it("recovers stale lock and succeeds", async () => {
      const store = createMockStore();
      let addCalls = 0;
      mockedClassifyStaleLock.mockResolvedValue({ kind: "stale", reason: "old-lock", ageMs: 60000 } as any);
      mockedTryRemoveStaleLock.mockResolvedValue({ removed: true });

      mockedExecSync.mockImplementation((cmd: string | string[]) => {
        const command = typeof cmd === "string" ? cmd : cmd[0];
        if (command.includes("git worktree add") && addCalls++ === 0) {
          const error: any = new Error("fatal: unable to create '/tmp/test/.git/worktrees/swift-falcon/index.lock': File exists");
          error.stderr = Buffer.from("fatal: unable to create '/tmp/test/.git/worktrees/swift-falcon/index.lock': File exists");
          throw error;
        }
        return Buffer.from("");
      });

      const executor = new TaskExecutor(store, "/tmp/test");
      await executor.execute(makeTask());

      expect(mockedClassifyStaleLock).toHaveBeenCalled();
      expect(mockedTryRemoveStaleLock).toHaveBeenCalled();
      expect(store.logEntry).toHaveBeenCalledWith(
        "FN-050",
        expect.stringContaining("Recovered stale worktree index.lock and retrying"),
        expect.any(String),
        expect.anything(),
      );
    });

    it("refuses fresh lock and fails with actionable error", async () => {
      const store = createMockStore();
      mockedClassifyStaleLock.mockResolvedValue({ kind: "active-session", reason: "active-session-owns-worktree", owningWorktreePath: "/tmp/test/.worktrees/swift-falcon" } as any);

      mockedExecSync.mockImplementation((cmd: string | string[]) => {
        const command = typeof cmd === "string" ? cmd : cmd[0];
        if (command.includes("git worktree add")) {
          const error: any = new Error("fatal: unable to create '/tmp/test/.git/worktrees/swift-falcon/index.lock': File exists");
          error.stderr = Buffer.from("fatal: unable to create '/tmp/test/.git/worktrees/swift-falcon/index.lock': File exists");
          throw error;
        }
        return Buffer.from("");
      });

      const executor = new TaskExecutor(store, "/tmp/test");
      await executor.execute(makeTask());

      expect(store.updateTask).toHaveBeenCalledWith(
        "FN-050",
        expect.objectContaining({ status: "failed", error: expect.stringContaining("index.lock") }),
      );
      expect(mockedTryRemoveStaleLock).not.toHaveBeenCalled();
    });
  });

  describe("stale registration recovery", () => {
    it("recovers stale registration and retries git worktree add", async () => {
      const store = createMockStore();
      let addCalls = 0;
      mockedRecoverStaleRegistration.mockResolvedValue({ recovered: true, actions: ["prune", "remove-force"] });

      mockedExecSync.mockImplementation((cmd: string | string[]) => {
        const command = typeof cmd === "string" ? cmd : cmd[0];
        if (command.includes("git worktree add") && addCalls++ === 0) {
          const error: any = new Error("fatal: '/tmp/test/.worktrees/swift-falcon' is a missing but already registered worktree");
          error.stderr = Buffer.from("fatal: '/tmp/test/.worktrees/swift-falcon' is a missing but already registered worktree");
          throw error;
        }
        return Buffer.from("");
      });

      const executor = new TaskExecutor(store, "/tmp/test");
      await executor.execute(makeTask());

      expect(mockedRecoverStaleRegistration).toHaveBeenCalled();
      expect(store.logEntry).toHaveBeenCalledWith(
        "FN-050",
        "Recovered stale worktree registration and retrying",
        "/tmp/test/.worktrees/swift-falcon",
        expect.anything(),
      );
      const worktreeAddCalls = mockedExecSync.mock.calls
        .map((call) => String(call[0]))
        .filter((command) => command.includes("git worktree add -b"));
      expect(worktreeAddCalls.length).toBeGreaterThanOrEqual(2);
    });

    it("preserves existing failure path when stale registration persists", async () => {
      const store = createMockStore();
      mockedRecoverStaleRegistration.mockResolvedValue({ recovered: false, actions: ["prune"], reason: "still registered" });

      mockedExecSync.mockImplementation((cmd: string | string[]) => {
        const command = typeof cmd === "string" ? cmd : cmd[0];
        if (command.includes("git worktree add")) {
          const error: any = new Error("fatal: '/tmp/test/.worktrees/swift-falcon' is a missing but already registered worktree");
          error.stderr = Buffer.from("fatal: '/tmp/test/.worktrees/swift-falcon' is a missing but already registered worktree");
          throw error;
        }
        return Buffer.from("");
      });

      const executor = new TaskExecutor(store, "/tmp/test");
      (executor as any).MAX_WORKTREE_RETRIES = 1;

      await expect(
        (executor as any).createWorktree("fusion/fn-050", "/tmp/test/.worktrees/swift-falcon", "FN-050"),
      ).rejects.toThrow("Failed to create worktree after 1 attempts");

      expect(mockedRecoverStaleRegistration).toHaveBeenCalled();
    }, 20000);
  });

  it("removes stale branch and retries when branch exists without worktree", async () => {
    const store = createMockStore();
    let callCount = 0;

    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree add")) {
        if (callCount++ === 0) {
          const error: any = new Error("fatal: invalid reference: 'fusion/fn-050'");
          error.stderr = Buffer.from("fatal: invalid reference: 'fusion/fn-050'");
          throw error;
        }
      }
      return Buffer.from("");
    });

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    // Should have removed the stale branch
    expect(mockedExecSync).toHaveBeenCalledWith(
      expect.stringContaining("git branch -D"),
      expect.any(Object),
    );
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Removed stale branch reference, retrying"),
    );
  });

  it("runs git worktree prune before branch deletion for stale references", async () => {
    const store = createMockStore();
    let callCount = 0;

    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree add")) {
        if (callCount++ === 0) {
          const error: any = new Error("fatal: invalid reference: 'fusion/fn-050'");
          error.stderr = Buffer.from("fatal: invalid reference: 'fusion/fn-050'");
          throw error;
        }
      }
      return Buffer.from("");
    });

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    // Should have called git worktree prune as the first recovery step
    expect(mockedExecSync).toHaveBeenCalledWith(
      "git worktree prune",
      expect.any(Object),
    );
    // Should log the prune
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Pruned stale worktree metadata"),
      "fusion/fn-050",
    );
    // Should also call branch -D after prune
    expect(mockedExecSync).toHaveBeenCalledWith(
      expect.stringContaining("git branch -D"),
      expect.any(Object),
    );
    // Task should eventually succeed
    expect(store.updateTask).toHaveBeenCalledWith(
      "FN-050",
      expect.objectContaining({ worktree: expect.any(String) }),
    );
  });

  it("falls back to git update-ref -d when git branch -D fails on stale reference", async () => {
    const store = createMockStore();
    let worktreeAddCallCount = 0;

    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree add")) {
        if (worktreeAddCallCount++ === 0) {
          const error: any = new Error("fatal: invalid reference: 'fusion/fn-050'");
          error.stderr = Buffer.from("fatal: invalid reference: 'fusion/fn-050'");
          throw error;
        }
        return Buffer.from("");
      }
      // Prune succeeds
      if (command.includes("git worktree prune")) {
        return Buffer.from("");
      }
      // branch -D fails (corrupted reference)
      if (command.includes("git branch -D")) {
        const error: any = new Error("error: unable to delete ref 'refs/heads/fusion/fn-050'");
        throw error;
      }
      // update-ref -d succeeds
      if (command.includes("git update-ref -d")) {
        return Buffer.from("");
      }
      return Buffer.from("");
    });

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    // Should have tried branch -D first
    expect(mockedExecSync).toHaveBeenCalledWith(
      expect.stringContaining("git branch -D"),
      expect.any(Object),
    );
    // Should have fallen back to update-ref -d
    expect(mockedExecSync).toHaveBeenCalledWith(
      expect.stringContaining("git update-ref -d"),
      expect.any(Object),
    );
    // Should log the fallback
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("git branch -D failed for stale branch, trying update-ref"),
      expect.any(String),
    );
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Force-removed stale branch reference via update-ref"),
      expect.any(String),
    );
    // Task should eventually succeed after cleanup + retry
    expect(store.updateTask).toHaveBeenCalledWith(
      "FN-050",
      expect.objectContaining({ worktree: expect.any(String) }),
    );
  });

  it("bounds stale-reference cleanup retries when update-ref succeeds but the ref remains invalid", async () => {
    const store = createMockStore();
    let worktreeAddCallCount = 0;

    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree add")) {
        worktreeAddCallCount++;
        const error: any = new Error("fatal: invalid reference: 'fusion/fn-050'");
        error.stderr = Buffer.from("fatal: invalid reference: 'fusion/fn-050'");
        throw error;
      }
      if (command.includes("git branch -D")) {
        const error: any = new Error("error: branch 'fusion/fn-050' not found");
        error.stderr = Buffer.from("error: branch 'fusion/fn-050' not found");
        throw error;
      }
      return Buffer.from("");
    });

    const onError = vi.fn();
    const executor = new TaskExecutor(store, "/tmp/test", { onError });
    const executePromise = executor.execute(makeTask());
    await vi.advanceTimersByTimeAsync(5000);
    await executePromise;

    expect(worktreeAddCallCount).toBe(3);
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Worktree creation failed after 3 attempts"),
      expect.any(String),
    );
    expect(store.updateTask).toHaveBeenCalledWith(
      "FN-050",
      expect.objectContaining({ status: "failed" }),
    );
    expect(onError).toHaveBeenCalled();
  });

  it("fails task when all stale reference cleanup steps fail", async () => {
    vi.useRealTimers();
    const store = createMockStore();

    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree add")) {
        const error: any = new Error("fatal: invalid reference: 'fusion/fn-050'");
        error.stderr = Buffer.from("fatal: invalid reference: 'fusion/fn-050'");
        throw error;
      }
      // Prune fails
      if (command.includes("git worktree prune")) {
        throw new Error("prune failed");
      }
      // branch -D fails
      if (command.includes("git branch -D")) {
        throw new Error("branch delete failed");
      }
      // update-ref -d also fails
      if (command.includes("git update-ref -d")) {
        throw new Error("update-ref failed");
      }
      return Buffer.from("");
    });

    const onError = vi.fn();
    const executor = new TaskExecutor(store, "/tmp/test", { onError });
    await executor.execute(makeTask());

    // Should have logged terminal failure for the stale reference
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Failed to remove stale branch reference"),
      expect.any(String),
    );
    // Task should be marked as failed
    expect(store.updateTask).toHaveBeenCalledWith(
      "FN-050",
      expect.objectContaining({ status: "failed" }),
    );
    expect(onError).toHaveBeenCalled();
  });

  it("recovers from stale reference in createFromExistingBranch fallback path", async () => {
    const store = createMockStore();
    let worktreeAddCallCount = 0;

    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree add")) {
        worktreeAddCallCount++;
        if (command.includes("-b")) {
          // createWithBranch: fails with "already exists" (not invalid-reference)
          const error: any = new Error("fatal: A branch named 'fusion/fn-050' already exists.");
          error.stderr = Buffer.from("fatal: A branch named 'fusion/fn-050' already exists.");
          throw error;
        } else {
          // createFromExistingBranch: fails with invalid reference
          if (worktreeAddCallCount <= 2) {
            const error: any = new Error("fatal: invalid reference: 'fusion/fn-050'");
            error.stderr = Buffer.from("fatal: invalid reference: 'fusion/fn-050'");
            throw error;
          }
        }
      }
      // All cleanup commands succeed
      return Buffer.from("");
    });

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    // Should have logged cleanup in fallback path
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Cleaned up stale reference in fallback, retrying"),
    );
    // Task should eventually succeed
    expect(store.updateTask).toHaveBeenCalledWith(
      "FN-050",
      expect.objectContaining({ worktree: expect.any(String) }),
    );
  });

  it("recognizes 'unable to resolve reference' as invalid-reference pattern", async () => {
    const store = createMockStore();
    let callCount = 0;

    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree add")) {
        if (callCount++ === 0) {
          const error: any = new Error("fatal: unable to resolve reference 'fusion/fn-050'");
          error.stderr = Buffer.from("fatal: unable to resolve reference 'fusion/fn-050'");
          throw error;
        }
      }
      return Buffer.from("");
    });

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    // Should have triggered cleanup (stale branch reclaim)
    expect(mockedExecSync).toHaveBeenCalledWith(
      expect.stringContaining("git worktree prune"),
      expect.any(Object),
    );
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Removed stale branch reference, retrying"),
    );
  });

  it("recognizes 'stale file handle' as invalid-reference pattern", async () => {
    const store = createMockStore();
    let callCount = 0;

    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree add")) {
        if (callCount++ === 0) {
          const error: any = new Error("fatal: stale file handle");
          error.stderr = Buffer.from("fatal: stale file handle");
          throw error;
        }
      }
      return Buffer.from("");
    });

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Removed stale branch reference, retrying"),
    );
  });

  it("recognizes 'not a valid ref' as invalid-reference pattern", async () => {
    const store = createMockStore();
    let callCount = 0;

    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree add")) {
        if (callCount++ === 0) {
          const error: any = new Error("fatal: not a valid ref: 'refs/heads/fusion/fn-050'");
          error.stderr = Buffer.from("fatal: not a valid ref: 'refs/heads/fusion/fn-050'");
          throw error;
        }
      }
      return Buffer.from("");
    });

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Removed stale branch reference, retrying"),
    );
  });

  it("removes existing directory that is not a registered worktree", async () => {
    const store = createMockStore();
    const fs = await import("node:fs/promises");
    const staleWorktreePath = "/tmp/test/.worktrees/swift-falcon";

    // Directory exists but is not registered
    mockedExistsSync.mockReturnValue(true);

    await fs.mkdir(staleWorktreePath, { recursive: true });
    await fs.writeFile(`${staleWorktreePath}/marker.txt`, "stale");

    // Mock git worktree list to not include our path
    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree list")) {
        return Buffer.from("/other/path/.git/worktrees/other\n");
      }
      return Buffer.from("");
    });

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    expect(
      mockedExecSync.mock.calls.some((call) =>
        typeof call[0] === "string" && call[0].includes("rm -rf"),
      ),
    ).toBe(false);
    await expect(fs.access(staleWorktreePath)).rejects.toThrow();
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-050",
      expect.stringContaining("Removing existing directory (not a registered worktree)"),
    );
  });

  it("handles locked worktree by unlocking before removal", async () => {
    const store = createMockStore();

    let callCount = 0;
    mockedExecSync.mockImplementation((cmd: string | string[]) => {
      const command = typeof cmd === "string" ? cmd : cmd[0];
      if (command.includes("git worktree add") && callCount++ === 0) {
        const error: any = new Error(
          "fatal: 'fusion/fn-050' is already used by worktree at '/tmp/test/.worktrees/green-sage'",
        );
        error.stderr = Buffer.from(
          "fatal: 'fusion/fn-050' is already used by worktree at '/tmp/test/.worktrees/green-sage'",
        );
        throw error;
      }
      return Buffer.from("");
    });

    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    // Should attempt to unlock the worktree before removing
    const unlockCalls = mockedExecSync.mock.calls.filter((call) =>
      String(call[0]).includes("git worktree unlock"),
    );
    expect(unlockCalls.length).toBeGreaterThanOrEqual(0); // Unlock is attempted but may fail silently
  });
});

describe("TaskExecutor dependency-based worktree creation", () => {
  const makeTask = (overrides: Partial<Task> = {}) => ({
    id: "FN-060",
    title: "Test",
    description: "Test",
    column: "in-progress" as const,
    dependencies: [],
    steps: [],
    currentStep: 0,
    log: [],
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
    ...overrides,
  });

  beforeEach(() => {
    vi.useRealTimers();
    resetExecutorMocks();
    mockedExistsSync.mockReturnValue(false);
    mockedFindWorktreeUser.mockResolvedValue(null);
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  it("creates worktree from baseBranch when set on task", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");

    await executor.execute(makeTask({
      id: "FN-060",
      executionStartBranch: "fusion/fn-059",
    }));

    // The git worktree add command should include the startPoint
    const worktreeAddCalls = mockedExecSync.mock.calls.filter(
      (c) => typeof c[0] === "string" && (c[0] as string).includes("worktree add"),
    );
    expect(worktreeAddCalls.length).toBeGreaterThan(0);
    expect(worktreeAddCalls[0][0]).toContain("fusion/fn-059");
  });

  it("creates worktree from HEAD when baseBranch is not set", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");

    await executor.execute(makeTask({
      id: "FN-061",
      // no baseBranch
    }));

    // The git worktree add command should NOT include a startPoint
    const worktreeAddCalls = mockedExecSync.mock.calls.filter(
      (c) => typeof c[0] === "string" && (c[0] as string).includes("worktree add -b"),
    );
    expect(worktreeAddCalls.length).toBeGreaterThan(0);
    // Command format: git worktree add -b "branch" "path" (no extra ref after path)
    const cmd = worktreeAddCalls[0][0] as string;
    // Count quoted segments: branch + path = 2 quoted args
    const quoted = cmd.match(/"[^"]+"/g) || [];
    expect(quoted).toHaveLength(2);
  });

  it("logs base branch in worktree creation log entry", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");

    await executor.execute(makeTask({
      id: "FN-062",
      executionStartBranch: "fusion/fn-061",
    }));

    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-062",
      expect.stringContaining("based on fusion/fn-061"),
      undefined,
      expect.objectContaining({ agentId: "executor" }),
    );
  });

  it("does not mention base branch in log when baseBranch is not set", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");

    await executor.execute(makeTask({
      id: "FN-063",
    }));

    // Check that log entry does NOT mention "based on"
    const logCalls = store.logEntry.mock.calls.filter(
      (call: any[]) => typeof call[1] === "string" && call[1].includes("Worktree created"),
    );
    expect(logCalls.length).toBeGreaterThan(0);
    expect(logCalls[0][1]).not.toContain("based on");
  });

  it("retries worktree creation after cleaning up conflicting worktree", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    const conflictingPath = "/tmp/test/.worktrees/sharp-stone";
    const removeWorktreeSpy = vi.spyOn(worktreePoolModule, "removeWorktree");

    let firstAttempt = true;
    mockedExecSync.mockImplementation((cmd: any) => {
      if (typeof cmd === "string" && cmd.includes("git worktree add") && cmd.includes("-b") && firstAttempt) {
        firstAttempt = false;
        const err: any = new Error(
          `fatal: 'fusion/fn-064' is already used by worktree at '${conflictingPath}'`,
        );
        err.stderr = Buffer.from(
          `fatal: 'fusion/fn-064' is already used by worktree at '${conflictingPath}'`,
        );
        throw err;
      }
      return Buffer.from("");
    });

    await executor.execute(makeTask({ id: "FN-064" }));

    expect(removeWorktreeSpy).toHaveBeenCalledWith(
      expect.objectContaining({
        worktreePath: conflictingPath,
        rootDir: "/tmp/test",
        taskId: "FN-064",
        settings: expect.any(Object),
      }),
    );
    expect(mockedExecSync).toHaveBeenCalledWith(
      'git branch -D "fusion/fn-064"',
      expect.objectContaining({ cwd: "/tmp/test" }),
    );

    const worktreeCreateCalls = mockedExecSync.mock.calls.filter(
      (call) => typeof call[0] === "string" && call[0].includes('git worktree add') && call[0].includes("-b"),
    );
    expect(worktreeCreateCalls).toHaveLength(2);
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-064",
      expect.stringContaining("Worktree created at /tmp/test/.worktrees/swift-falcon"),
      undefined,
      expect.objectContaining({ agentId: "executor" }),
    );
  });

  it("throws original error if cleanup also fails", async () => {
    vi.useRealTimers();
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    const conflictingPath = "/tmp/test/.worktrees/sharp-stone";

    mockedExecSync.mockImplementation((cmd: any) => {
      if (typeof cmd === "string" && cmd.includes("git worktree add") && cmd.includes("-b")) {
        const err: any = new Error(
          `fatal: 'fusion/fn-065' is already used by worktree at '${conflictingPath}'`,
        );
        err.stderr = Buffer.from(
          `fatal: 'fusion/fn-065' is already used by worktree at '${conflictingPath}'`,
        );
        throw err;
      }
      if (cmd === `git worktree remove --force "${conflictingPath}"`) {
        throw new Error("remove failed");
      }
      return Buffer.from("");
    });

    await executor.execute(makeTask({ id: "FN-065" }));

    expect(store.updateTask).toHaveBeenCalledWith("FN-065", {
      status: "failed",
      error: expect.stringContaining("automatic cleanup failed"),
    });
  });

  it("passes baseBranch to pool prepareForTask when using pooled worktree", async () => {
    const pool = new WorktreePool();
    pool.release("/tmp/test/.worktrees/idle-wt");
    mockedExistsSync.mockImplementation(
      (p) => p === "/tmp/test/.worktrees/idle-wt",
    );

    const prepareSpy = vi.spyOn(pool, "prepareForTask").mockResolvedValue({ branch: "fusion/fn-064", worktreePath: "/tmp/test/.worktrees/idle-wt", reclaimed: false });

    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      recycleWorktrees: true,
    });

    const executor = new TaskExecutor(store, "/tmp/test", { pool });

    await executor.execute(makeTask({
      id: "FN-064",
      executionStartBranch: "fusion/fn-063",
    }));

    expect(prepareSpy).toHaveBeenCalledWith(
      "/tmp/test/.worktrees/idle-wt",
      "fusion/fn-064",
      "fusion/fn-063",
      { allowSiblingBranchRename: false, repoDir: "/tmp/test", requestingTaskId: "FN-064" },
    );
  });

  it("passes undefined to pool prepareForTask when no baseBranch", async () => {
    const pool = new WorktreePool();
    pool.release("/tmp/test/.worktrees/idle-wt");
    mockedExistsSync.mockImplementation(
      (p) => p === "/tmp/test/.worktrees/idle-wt",
    );

    const prepareSpy = vi.spyOn(pool, "prepareForTask").mockResolvedValue({ branch: "fusion/fn-065", worktreePath: "/tmp/test/.worktrees/idle-wt", reclaimed: false });

    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      recycleWorktrees: true,
    });

    const executor = new TaskExecutor(store, "/tmp/test", { pool });

    await executor.execute(makeTask({
      id: "FN-065",
    }));

    expect(prepareSpy).toHaveBeenCalledWith(
      "/tmp/test/.worktrees/idle-wt",
      "fusion/fn-065",
      undefined,
      { allowSiblingBranchRename: false, repoDir: "/tmp/test", requestingTaskId: "FN-065" },
    );
  });

  it("records branch:auto-reclaim run-audit event when pooled prepare returns reclaimed worktree", async () => {
    const pool = new WorktreePool();
    pool.release("/tmp/test/.worktrees/idle-wt");
    mockedExistsSync.mockImplementation((p) => p === "/tmp/test/.worktrees/idle-wt" || p === "/tmp/test/.worktrees/live-wt");

    vi.spyOn(pool, "prepareForTask").mockResolvedValue({
      branch: "fusion/fn-066",
      worktreePath: "/tmp/test/.worktrees/live-wt",
      reclaimed: true,
      existingTipSha: "abc123def456",
      strandedCommitCount: 2,
    });

    const store = createMockStore();
    store.recordRunAuditEvent = vi.fn().mockResolvedValue(undefined);
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      recycleWorktrees: true,
    });

    const executor = new TaskExecutor(store, "/tmp/test", { pool });
    await executor.execute(makeTask({ id: "FN-066" }));

    expect(store.recordRunAuditEvent).toHaveBeenCalledWith(expect.objectContaining({
      mutationType: "branch:auto-reclaim",
      target: "fusion/fn-066",
      metadata: expect.objectContaining({
        taskId: "FN-066",
        trigger: "dispatch-preflight",
        worktreePath: "/tmp/test/.worktrees/live-wt",
        existingTipSha: "abc123def456",
        strandedCommitCount: 2,
      }),
    }));
  });

  it("stores suffixed branch name when pool returns a different name", async () => {
    const pool = new WorktreePool();
    pool.release("/tmp/test/.worktrees/idle-wt");
    mockedExistsSync.mockImplementation(
      (p) => p === "/tmp/test/.worktrees/idle-wt",
    );

    // Pool returns a suffixed branch name due to conflict
    vi.spyOn(pool, "prepareForTask").mockResolvedValue({ branch: "fusion/fn-066-2", worktreePath: "/tmp/test/.worktrees/idle-wt", reclaimed: false });

    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      recycleWorktrees: true,
    });

    const executor = new TaskExecutor(store, "/tmp/test", { pool });

    await executor.execute(makeTask({
      id: "FN-066",
    }));

    // Should store the suffixed branch name
    expect(store.updateTask).toHaveBeenCalledWith("FN-066", {
      worktree: "/tmp/test/.worktrees/idle-wt",
      branch: "fusion/fn-066-2",
    });
  });
});

describe("TaskExecutor worktree pool integration", () => {
  const makeTask = (id = "FN-020") => ({
    id,
    title: "Test",
    description: "Test",
    column: "in-progress" as const,
    dependencies: [],
    steps: [],
    currentStep: 0,
    log: [],
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
  });

  beforeEach(() => {
    resetExecutorMocks();
    // Default: worktree does NOT exist (new worktree)
    mockedExistsSync.mockReturnValue(false);
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
      },
    } as any);
  });

  it("acquires from pool when recycleWorktrees is true and pool has idle worktrees", async () => {
    const pool = new WorktreePool();
    pool.release("/tmp/test/.worktrees/idle-wt");
    // Pool path exists on disk, task worktree path does not (not a resume)
    mockedExistsSync.mockImplementation(
      (p) => p === "/tmp/test/.worktrees/idle-wt",
    );

    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      recycleWorktrees: true,
    });

    const executor = new TaskExecutor(store, "/tmp/test", { pool });
    await executor.execute(makeTask());

    // Should NOT call git worktree add (no fresh worktree)
    const worktreeAddCalls = mockedExecSync.mock.calls.filter(
      (c) => typeof c[0] === "string" && (c[0] as string).includes("worktree add"),
    );
    expect(worktreeAddCalls).toHaveLength(0);

    // Should log pool acquisition
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-020",
      expect.stringContaining("Acquired worktree from pool"),
      undefined,
      expect.objectContaining({ agentId: "executor" }),
    );

    // Pool should be empty after acquire
    expect(pool.size).toBe(0);
  });

  it("overwrites baseCommitSha when starting from a pooled worktree", async () => {
    const pool = new WorktreePool();
    pool.release("/tmp/test/.worktrees/idle-wt");
    mockedExistsSync.mockImplementation((p) => p === "/tmp/test/.worktrees/idle-wt");

    mockedExecSync.mockImplementation((cmd: any) => {
      if (String(cmd).includes("git merge-base --is-ancestor")) {
        throw new Error("not ancestor");
      }
      return "" as any;
    });
    mockedExec.mockImplementation(((cmd: any, _opts: any, cb: any) => {
      if (String(cmd).includes("git merge-base HEAD origin/main")) {
        cb(null, "newbase123\n", "");
        return {} as any;
      }
      cb(null, "", "");
      return {} as any;
    }) as any);

    const store = createMockStore();
    store.getTask.mockResolvedValue({
      id: "FN-020",
      title: "Test",
      description: "Test",
      column: "in-progress",
      dependencies: [],
      steps: [],
      currentStep: 0,
      log: [],
      prompt: "# test\n## Steps\n### Step 0: Preflight\n- [ ] check",
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
      baseCommitSha: "stale-base",
    });
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      recycleWorktrees: true,
    });

    const executor = new TaskExecutor(store, "/tmp/test", { pool });
    await executor.execute(makeTask());

    expect(store.updateTask).toHaveBeenCalledWith("FN-020", { baseCommitSha: "newbase123" });
  });

  it("creates fresh worktree when pool is empty", async () => {
    const pool = new WorktreePool();
    // Pool is empty

    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      recycleWorktrees: true,
    });

    const executor = new TaskExecutor(store, "/tmp/test", { pool });
    await executor.execute(makeTask());

    // Should call git worktree add (fresh worktree)
    const worktreeAddCalls = mockedExecSync.mock.calls.filter(
      (c) => typeof c[0] === "string" && (c[0] as string).includes("worktree add"),
    );
    expect(worktreeAddCalls.length).toBeGreaterThan(0);
    expect(mockedInstallTaskWorktreeIdentityGuard).toHaveBeenCalledWith(
      expect.objectContaining({ taskId: "FN-020" }),
    );

    // Should log worktree creation, NOT pool acquisition
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-020",
      expect.stringContaining("Worktree created at"),
      undefined,
      expect.objectContaining({ agentId: "executor" }),
    );
  });

  it("skips worktree init command for pooled worktrees", async () => {
    const pool = new WorktreePool();
    pool.release("/tmp/test/.worktrees/warm-wt");
    // Pool path exists on disk, task worktree path does not
    mockedExistsSync.mockImplementation(
      (p) => p === "/tmp/test/.worktrees/warm-wt",
    );

    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      recycleWorktrees: true,
      worktreeInitCommand: "pnpm install --frozen-lockfile",
    });

    const executor = new TaskExecutor(store, "/tmp/test", { pool });
    await executor.execute(makeTask());

    // "pnpm install --frozen-lockfile" should NOT have been called (pooled worktree has warm cache)
    const initCalls = mockedExecSync.mock.calls.filter(
      (c) => c[0] === "pnpm install --frozen-lockfile",
    );
    expect(initCalls).toHaveLength(0);
  });

  it("does not use pool when recycleWorktrees is false", async () => {
    const pool = new WorktreePool();
    pool.release("/tmp/test/.worktrees/idle-wt");

    const store = createMockStore();
    // recycleWorktrees defaults to false

    const executor = new TaskExecutor(store, "/tmp/test", { pool });
    await executor.execute(makeTask());

    // Should create a fresh worktree, NOT acquire from pool
    const worktreeAddCalls = mockedExecSync.mock.calls.filter(
      (c) => typeof c[0] === "string" && (c[0] as string).includes("worktree add"),
    );
    expect(worktreeAddCalls.length).toBeGreaterThan(0);

    // Pool should still have the entry (not acquired)
    expect(pool.size).toBe(1);
  });

  it("falls through to fresh worktree when pool prepareForTask throws", async () => {
    const pool = new WorktreePool();
    pool.release("/tmp/test/.worktrees/bad-wt");
    mockedExistsSync.mockImplementation(
      (p) => p === "/tmp/test/.worktrees/bad-wt",
    );
    vi.spyOn(pool, "prepareForTask").mockImplementation(() => {
      throw new Error("branch conflict unrecoverable");
    });
    const releaseSpy = vi.spyOn(pool, "release");

    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      recycleWorktrees: true,
    });

    const executor = new TaskExecutor(store, "/tmp/test", { pool });
    await executor.execute(makeTask());

    expect(releaseSpy).toHaveBeenCalledWith("/tmp/test/.worktrees/bad-wt", "FN-020");

    const worktreeAddCalls = mockedExecSync.mock.calls.filter(
      (c) => typeof c[0] === "string" && (c[0] as string).includes("worktree add"),
    );
    expect(worktreeAddCalls.length).toBeGreaterThan(0);

    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-020",
      expect.stringContaining("Pool worktree preparation failed"),
      undefined,
      expect.objectContaining({ agentId: "executor" }),
    );
  });

  it("does not fall through to a fresh worktree when pooled preparation hits a typed branch conflict", async () => {
    const pool = new WorktreePool();
    pool.release("/tmp/test/.worktrees/warm-wt");
    mockedExistsSync.mockImplementation((p) => p === "/tmp/test/.worktrees/warm-wt");
    vi.spyOn(pool, "prepareForTask").mockRejectedValue(
      new BranchConflictError({
        branchName: "fusion/fn-020",
        conflictingWorktreePath: "/tmp/test/.worktrees/existing-fn-020",
        existingTipSha: "abc123def456",
        strandedCommits: [{ sha: "aaa111", subject: "Preserve prior fix" }],
        startPoint: "main",
        recommendedAction: "Reclaim the existing task branch/worktree or explicitly discard prior work before retrying.",
      }),
    );

    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      recycleWorktrees: true,
    });

    const executor = new TaskExecutor(store, "/tmp/test", { pool });
    await executor.execute(makeTask("FN-020"));

    const worktreeAddCalls = mockedExecSync.mock.calls.filter(
      (c) => typeof c[0] === "string" && (c[0] as string).includes("worktree add"),
    );
    expect(worktreeAddCalls).toHaveLength(0);
    expect(store.updateTask).toHaveBeenCalledWith(
      "FN-020",
      expect.objectContaining({
        status: "failed",
        paused: true,
      }),
    );
    expect(store.moveTask).not.toHaveBeenCalled();
  });
});

describe("WorktreePool capacity", () => {
  it("pool does not enforce maxWorktrees — scheduler is the capacity gatekeeper", () => {
    const pool = new WorktreePool();
    pool.release("/tmp/a");
    pool.release("/tmp/b");
    pool.release("/tmp/c");
    pool.release("/tmp/d");
    pool.release("/tmp/e");
    expect(pool.size).toBe(5);
  });
});

describe("Merger worktree pool integration", () => {
  beforeEach(() => {
    resetExecutorMocks();
  });

  it("passes pool option through to aiMergeTask", async () => {
    const pool = new WorktreePool();
    const mockedAiMergeTask = vi.mocked(aiMergeTask);
    mockedAiMergeTask.mockResolvedValue({
      task: { id: "FN-050" } as any,
      branch: "fusion/fn-050",
      merged: true,
      worktreeRemoved: false,
      branchDeleted: true,
    });

    await aiMergeTask({} as any, "/tmp/test", "FN-050", { pool });

    expect(mockedAiMergeTask).toHaveBeenCalledWith(
      expect.anything(),
      "/tmp/test",
      "FN-050",
      expect.objectContaining({ pool }),
    );
  });

  // Full merger worktree pool integration tests are split across merger-merge-lifecycle.test.ts and related merger-*.test.ts files
  // which tests aiMergeTask with real implementation
});

function createMockTaskDetail(overrides: Partial<TaskDetail> = {}): TaskDetail {
  return {
    id: "FN-001",
    title: "Test Task",
    description: "A test task",
    column: "in-progress",
    dependencies: [],
    steps: [],
    currentStep: 0,
    log: [],
    prompt: "# test\n## Steps\n### Step 0: Preflight\n- [ ] check",
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
    ...overrides,
  };
}


describe("worktree DB hydration", () => {
  const makeTask = (overrides: Partial<Task> = {}): Task => ({
    id: "FN-HYD",
    title: "Hydrate",
    description: "Hydrate",
    column: "in-progress",
    dependencies: [],
    steps: [],
    currentStep: 0,
    log: [],
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
    ...overrides,
  });

  beforeEach(() => {
    resetExecutorMocks();
    mockedHydrateWorktreeDb.mockReset();
    mockedHydrateWorktreeDb.mockResolvedValue({
      tasksCopied: 1,
      documentsCopied: 2,
      degraded: false,
    });
    mockedCreateFnAgent.mockResolvedValue({
      session: { prompt: vi.fn().mockResolvedValue(undefined), dispose: vi.fn() },
    } as any);
  });

  it("runs once for fresh worktree", async () => {
    mockedExistsSync.mockReturnValue(false);
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());
    expect(mockedHydrateWorktreeDb).toHaveBeenCalledTimes(1);
  });

  it("runs once for pool acquire", async () => {
    mockedExistsSync.mockReturnValue(false);
    const store = createMockStore();
    const pool = {
      acquire: vi.fn(() => "/tmp/test/.worktrees/pooled"),
      prepareForTask: vi.fn(async () => "fusion/fn-hyd"),
      release: vi.fn(),
    } as any;
    store.getSettings.mockResolvedValue({ ...(await store.getSettings()), recycleWorktrees: true });
    const executor = new TaskExecutor(store, "/tmp/test", { pool });
    await executor.execute(makeTask());
    expect(mockedHydrateWorktreeDb).toHaveBeenCalledTimes(1);
  });

  it("runs hydration path when executor reassigns unusable root worktree", async () => {
    mockedIsUsableTaskWorktree.mockResolvedValueOnce(false);
    mockedClassifyTaskWorktree.mockResolvedValueOnce({ ok: false, classification: "incomplete", reason: "missing or invalid .git metadata" } as any);
    mockedExistsSync.mockReturnValue(true);
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask({ worktree: "/tmp/test" }));
    expect(mockedHydrateWorktreeDb).toHaveBeenCalledTimes(1);
  });

  it("logs degraded hydration reason and continues execution", async () => {
    mockedHydrateWorktreeDb.mockResolvedValueOnce({
      tasksCopied: 0,
      documentsCopied: 0,
      degraded: true,
      reason: "unable to open database file",
    });
    mockedExistsSync.mockReturnValue(false);
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());

    expect((store.logEntry as ReturnType<typeof vi.fn>).mock.calls).toEqual(
      expect.arrayContaining([
        [
          "FN-HYD",
          "Worktree DB hydration degraded: unable to open database file",
          undefined,
          expect.objectContaining({ agentId: "executor" }),
        ],
      ]),
    );
    expect(mockedCreateFnAgent).toHaveBeenCalled();
  });

  it("hydration failure does not abort execute", async () => {
    mockedHydrateWorktreeDb.mockRejectedValueOnce(new Error("boom"));
    mockedExistsSync.mockReturnValue(false);
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    await executor.execute(makeTask());
    expect(mockedCreateFnAgent).toHaveBeenCalled();
  });
});