fusion/packages/engine/src/__tests__/executor-worktree-conflict.test.ts

import { beforeEach, describe, expect, it, vi } from "vitest";
import "./executor-test-helpers.js";
import { TaskExecutor } from "../executor.js";
import { activeSessionRegistry } from "../active-session-registry.js";
import { ActiveSessionWorktreeRemovalError } from "../worktree-backend.js";
import * as worktreePoolModule from "../worktree-pool.js";
import { createMockStore, resetExecutorMocks } from "./executor-test-helpers.js";

const CONFLICT_PATH = "/tmp/test/.worktrees/stale-self-owned";

describe("FN-4973: executor worktree conflict cleanup", () => {
  beforeEach(() => {
    resetExecutorMocks();
    activeSessionRegistry.clear();
  });

  it("clears stale self-owned registry entry before removal", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    store.listTasks.mockResolvedValue([]);
    activeSessionRegistry.registerPath(CONFLICT_PATH, { taskId: "FN-4973", kind: "executor", ownerKey: "FN-4973" });
    // FN-5256: backdate so the new min-idle window doesn't refuse the reconcile.
    (activeSessionRegistry.lookupByPath(CONFLICT_PATH) as any).registeredAt = 0;

    const removeSpy = vi.spyOn(worktreePoolModule, "removeWorktree").mockResolvedValue(undefined);
    const result = await (executor as any).cleanupConflictingWorktree(CONFLICT_PATH, "fusion/fn-4973", "FN-4973");

    expect(result).toBe(true);
    expect(removeSpy).toHaveBeenCalled();
    expect(activeSessionRegistry.lookupByPath(CONFLICT_PATH)).toBeNull();
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-4973",
      "Cleared stale self-owned active-session entry before remove",
      CONFLICT_PATH,
    );
  });

  it("does not reconcile when same-task in-memory binding is live and refuses removal", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    store.listTasks.mockResolvedValue([]);
    (executor as any).addActiveWorktree("FN-4973", CONFLICT_PATH);
    activeSessionRegistry.registerPath(CONFLICT_PATH, { taskId: "FN-4973", kind: "executor", ownerKey: "FN-4973" });

    vi.spyOn(worktreePoolModule, "removeWorktree").mockRejectedValue(
      new ActiveSessionWorktreeRemovalError({
        worktreePath: CONFLICT_PATH,
        taskId: "FN-4973",
        kind: "executor",
        ownerKey: "FN-4973",
        reason: worktreePoolModule.RemovalReason.ExecutorDispose,
      }),
    );

    const result = await (executor as any).cleanupConflictingWorktree(CONFLICT_PATH, "fusion/fn-4973", "FN-4973");
    expect(result).toBe(false);
    expect(activeSessionRegistry.lookupByPath(CONFLICT_PATH)?.taskId).toBe("FN-4973");
  });

  it("does not reconcile foreign-task registry entries and keeps refusal behavior", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    store.listTasks.mockResolvedValue([]);
    activeSessionRegistry.registerPath(CONFLICT_PATH, { taskId: "FN-OTHER", kind: "executor", ownerKey: "FN-OTHER" });

    vi.spyOn(worktreePoolModule, "removeWorktree").mockRejectedValue(
      new ActiveSessionWorktreeRemovalError({
        worktreePath: CONFLICT_PATH,
        taskId: "FN-OTHER",
        kind: "executor",
        ownerKey: "FN-OTHER",
        reason: worktreePoolModule.RemovalReason.ExecutorDispose,
      }),
    );

    const result = await (executor as any).cleanupConflictingWorktree(CONFLICT_PATH, "fusion/fn-4973", "FN-4973");
    expect(result).toBe(false);
    expect(activeSessionRegistry.lookupByPath(CONFLICT_PATH)?.taskId).toBe("FN-OTHER");
  });

  it("recovers a genuine orphan dir when git reports 'is not a working tree'", async () => {
    // FN-6782: a leaked orphan dir (dir on disk, admin entry gone) makes `git worktree remove`
    // fail with "is not a working tree". The stale-path recovery should prune, clean up, and
    // return true so fresh creation can proceed.
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    store.listTasks.mockResolvedValue([]);

    vi.spyOn(worktreePoolModule, "removeWorktree").mockRejectedValue(
      new Error("fatal: '/tmp/test/.worktrees/stale-self-owned' is not a working tree"),
    );

    const result = await (executor as any).cleanupConflictingWorktree(CONFLICT_PATH, "fusion/fn-4973", "FN-4973");

    expect(result).toBe(true);
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-4973",
      expect.stringContaining("Cleaned up stale conflicting worktree"),
      CONFLICT_PATH,
    );
  });

  it("refuses stale-path cleanup (no force-rm) for a conflict path outside .worktrees/", async () => {
    // Security regression: the recovery's rm must be bounded to .worktrees/. A git admin entry
    // can point anywhere; an out-of-bounds path must be refused, not force-removed.
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    store.listTasks.mockResolvedValue([]);
    const OUTSIDE_PATH = "/tmp/test/not-worktrees/escapee";

    vi.spyOn(worktreePoolModule, "removeWorktree").mockRejectedValue(
      new Error("fatal: '/tmp/test/not-worktrees/escapee' is not a working tree"),
    );

    const result = await (executor as any).cleanupConflictingWorktree(OUTSIDE_PATH, "fusion/fn-4973", "FN-4973");

    expect(result).toBe(false);
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-4973",
      expect.stringContaining("Refused stale-path cleanup"),
      OUTSIDE_PATH,
    );
  });

  it("reconciles once on race-window ActiveSessionWorktreeRemovalError then retries removal", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    store.listTasks.mockResolvedValue([]);

    const removeSpy = vi.spyOn(worktreePoolModule, "removeWorktree");
    removeSpy
      .mockImplementationOnce(async () => {
        activeSessionRegistry.registerPath(CONFLICT_PATH, { taskId: "FN-4973", kind: "executor", ownerKey: "FN-4973" });
        // FN-5256: backdate so the post-throw reconcile is not refused by min-idle.
        (activeSessionRegistry.lookupByPath(CONFLICT_PATH) as any).registeredAt = 0;
        throw new ActiveSessionWorktreeRemovalError({
          worktreePath: CONFLICT_PATH,
          taskId: "FN-4973",
          kind: "executor",
          ownerKey: "FN-4973",
          reason: worktreePoolModule.RemovalReason.ExecutorDispose,
        });
      })
      .mockResolvedValueOnce(undefined);

    const result = await (executor as any).cleanupConflictingWorktree(CONFLICT_PATH, "fusion/fn-4973", "FN-4973");

    expect(result).toBe(true);
    expect(removeSpy).toHaveBeenCalledTimes(2);
    expect(activeSessionRegistry.lookupByPath(CONFLICT_PATH)).toBeNull();
  });
});