// -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 { generateWorktreeName, slugify } from "../worktree-names.js";
import type { Task, TaskDetail } from "@fusion/core";
import { SessionManager } from "@mariozechner/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,
  mockedExecSync,
  mockedExistsSync,
  mockExecuteAll,
  mockTerminateAllSessions,
  mockCleanup,
  resetExecutorMocks,
} from "./executor-test-helpers.js";

const mockedReviewStep = vi.mocked(mockedReviewStepFn);

describe("TaskExecutor context limit error recovery", () => {
  beforeEach(() => {
    resetExecutorMocks();
  });

  function createMockSessionForContextRecovery() {
    return {
      prompt: vi.fn(async () => {}),
      dispose: vi.fn(),
      subscribe: vi.fn(),
      setThinkingLevel: vi.fn(),
      steer: vi.fn(async () => {}),
      sessionFile: "/tmp/test-session.json",
      model: { provider: "mock", id: "mock-model", name: "Mock" },
      sessionManager: { getLeafId: vi.fn().mockReturnValue("leaf-1") },
      state: {},
    };
  }

  it("does NOT mark task as failed when context limit error is detected and recovery succeeds", async () => {
    const mockSession = createMockSessionForContextRecovery();
    
    // Mock compactSessionContext to succeed
    const { compactSessionContext } = await import("../pi.js");
    vi.mocked(compactSessionContext).mockResolvedValueOnce({
      summary: "Compacted conversation",
      tokensBefore: 150000,
    });

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

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

    // Directly inject an active session
    (executor as any).activeSessions.set("FN-001", {
      session: mockSession,
      seenSteeringIds: new Set(),
    });

    // Simulate the catch block being invoked with a context limit error
    // This would normally happen when prompt() throws
    const contextError = new Error("invalid params, context window exceeds limit (2013)");

    // The executor should catch this error and attempt recovery
    // We can't directly test the catch block, but we can test that isContextLimitError
    // now correctly identifies this error
    const { isContextLimitError } = await import("../context-limit-detector.js");
    expect(isContextLimitError(contextError.message)).toBe(true);
  });

  it("recognizes 'context window exceeds limit' as context limit error", async () => {
    const { isContextLimitError } = await import("../context-limit-detector.js");

    // These are the specific error formats that should be recognized
    expect(isContextLimitError("invalid params, context window exceeds limit (2013)")).toBe(true);
    expect(isContextLimitError("context window exceeds limit")).toBe(true);
    expect(isContextLimitError("context window exceeds limit (2003)")).toBe(true);
    expect(isContextLimitError("Context Window Exceeds limit")).toBe(true);
  });

  it("does NOT recognize generic 'limit exceeded' without context keywords", async () => {
    const { isContextLimitError } = await import("../context-limit-detector.js");

    // These should NOT be recognized as context limit errors
    expect(isContextLimitError("limit exceeded")).toBe(false);
    expect(isContextLimitError("quota exceeded")).toBe(false);
    expect(isContextLimitError("rate limit exceeded")).toBe(false);
  });

  it("reduced-prompt retry is attempted when compact returns null", async () => {
    // This test verifies the recovery flow when compactSessionContext returns null
    // (no history to compact) - the code should fall through to reduced-prompt retry
    const { isContextLimitError } = await import("../context-limit-detector.js");

    // These error formats should trigger reduced-prompt recovery
    const contextError = "context window exceeds limit (2013)";
    expect(isContextLimitError(contextError)).toBe(true);
    // The test passes if isContextLimitError returns true, which means
    // the reduced-prompt retry path would be triggered
  });

  it("reduced-prompt retry prompt focuses on completing efficiently", async () => {
    // Verify the reduced prompt template includes key instructions
    const reducedPrompt = [
      "Your previous attempt hit the context window limit.",
      "Focus on completing the task efficiently with minimal context:",
      "1. Review git status and git log to see what's been done",
      "2. Identify the most critical remaining work",
      "3. Complete it with a simpler, more focused approach",
      "",
      "Do not repeat what's already been done. Just complete the task and call fn_task_done.",
    ].join("\n");

    expect(reducedPrompt).toContain("context window limit");
    expect(reducedPrompt).toContain("git status");
    expect(reducedPrompt).toContain("fn_task_done");
    expect(reducedPrompt).toContain("Do not repeat what's already been done");
  });
});

// ── Agent Spawning Tests ─────────────────────────────────────────────────

function createMockAgentStore() {
  let nextId = 1;
  const agents = new Map<string, any>();

  return {
    createAgent: vi.fn(async (input: any) => {
      const agentId = `agent-${String(nextId++).padStart(8, "0")}`;
      const agent = {
        id: agentId,
        name: input.name,
        role: input.role,
        state: "idle" as string,
        reportsTo: input.reportsTo,
        metadata: input.metadata ?? {},
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      };
      agents.set(agentId, agent);
      return agent;
    }),
    updateAgentState: vi.fn(async (agentId: string, newState: string) => {
      const agent = agents.get(agentId);
      if (agent) {
        agent.state = newState;
        agent.updatedAt = new Date().toISOString();
      }
      return agent;
    }),
    _agents: agents,
  };
}

async function captureToolsWithAgentStore(agentStore?: any, settingsOverride?: any): Promise<{
  tools: Record<string, (id: string, params: any) => Promise<any>>;
  store: ReturnType<typeof createMockStore>;
  executor: TaskExecutor;
}> {
  const store = createMockStore();
  store.updateStep.mockResolvedValue({
    steps: [
      { name: "Preflight", status: "done" },
      { name: "Implement", status: "in-progress" },
      { name: "Testing", status: "pending" },
    ],
  });
  const mergedSettings = {
    maxConcurrent: 2,
    maxWorktrees: 4,
    pollIntervalMs: 15000,
    groupOverlappingFiles: false,
    autoMerge: false,
    worktreeInitCommand: undefined,
    ...settingsOverride,
  };
  store.getSettings.mockResolvedValue(mergedSettings);

  let capturedTools: any[] = [];
  mockedCreateFnAgent.mockImplementation(async (opts: any) => {
    capturedTools = opts.customTools || [];
    // Child agent sessions get a never-resolving prompt so runSpawnedChild
    // doesn't complete and decrement totalSpawnedCount before limit checks.
    const isChildAgent = opts.systemPrompt?.includes("child agent spawned");
    return {
      session: {
        prompt: isChildAgent ? vi.fn(() => new Promise(() => {})) : vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
        sessionManager: {
          getLeafId: vi.fn().mockReturnValue("leaf-id"),
          branchWithSummary: vi.fn(),
        },
        navigateTree: vi.fn().mockResolvedValue({ cancelled: false }),
      },
    } as any;
  });

  mockedExistsSync.mockReturnValue(true);
  // Mock execSync for worktree operations
  vi.mocked(execSync).mockReturnValue("");

  const options: any = {};
  if (agentStore) {
    options.agentStore = agentStore;
  }

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

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

  const tools: Record<string, any> = {};
  for (const t of capturedTools) {
    tools[t.name] = t.execute;
  }
  return { tools, store, executor };
}

describe("Agent Spawning", () => {
  beforeEach(() => {
    resetExecutorMocks();
    mockedExistsSync.mockReturnValue(true);
    vi.mocked(execSync).mockReturnValue("");
  });

  it("fn_spawn_agent tool is registered in customTools", async () => {
    const { tools } = await captureToolsWithAgentStore();
    expect(tools.fn_spawn_agent).toBeDefined();
    expect(typeof tools.fn_spawn_agent).toBe("function");
  });

  it("returns error when AgentStore is not configured", async () => {
    const { tools } = await captureToolsWithAgentStore(undefined);
    const result = await tools.fn_spawn_agent("call1", {
      name: "researcher",
      role: "engineer",
      task: "Research something",
    });

    expect(result.content[0].text).toContain("not available");
    expect(result.content[0].text).toContain("no AgentStore configured");
    expect(result.details.state).toBe("error");
  });

  it("creates agent in AgentStore with correct reportsTo", async () => {
    const agentStore = createMockAgentStore();
    const { tools } = await captureToolsWithAgentStore(agentStore);

    const result = await tools.fn_spawn_agent("call1", {
      name: "researcher",
      role: "engineer",
      task: "Research authentication patterns",
    });

    expect(agentStore.createAgent).toHaveBeenCalledOnce();
    const createInput = agentStore.createAgent.mock.calls[0][0];
    expect(createInput.name).toBe("researcher");
    expect(createInput.role).toBe("engineer");
    expect(createInput.reportsTo).toBe("FN-SPAWN");
    expect(createInput.metadata.type).toBe("spawned");
    expect(createInput.metadata.parentTaskId).toBe("FN-SPAWN");
  });

  it("returns correct SpawnAgentResult structure with state", async () => {
    const agentStore = createMockAgentStore();
    const { tools } = await captureToolsWithAgentStore(agentStore);

    const result = await tools.fn_spawn_agent("call1", {
      name: "researcher",
      role: "engineer",
      task: "Research authentication patterns",
    });

    // Parse the JSON from the text content
    const parsed = JSON.parse(result.content[0].text);
    expect(parsed).toHaveProperty("agentId");
    expect(parsed).toHaveProperty("name", "researcher");
    expect(parsed).toHaveProperty("state", "running");
    expect(parsed).toHaveProperty("role", "engineer");
    expect(parsed).toHaveProperty("message");
    expect(parsed.message).toContain("researcher");
    expect(parsed.message).toContain("Research authentication patterns");

    // Also check details object
    expect(result.details.agentId).toBe(parsed.agentId);
    expect(result.details.state).toBe("running");
  });

  it("transitions agent to active state after creation", async () => {
    const agentStore = createMockAgentStore();
    const { tools } = await captureToolsWithAgentStore(agentStore);

    await tools.fn_spawn_agent("call1", {
      name: "worker",
      role: "custom",
      task: "Do some work",
    });

    // Agent is created in idle, then transitioned to active
    const agentId = agentStore.createAgent.mock.calls[0][0];
    expect(agentStore.updateAgentState).toHaveBeenCalledWith(
      expect.any(String),
      "active"
    );
  });

  it("creates child agent session via createFnAgent", async () => {
    const agentStore = createMockAgentStore();
    const { tools } = await captureToolsWithAgentStore(agentStore);

    await tools.fn_spawn_agent("call1", {
      name: "worker",
      role: "engineer",
      task: "Do some work",
    });

    // createFnAgent is called at least twice: once for parent, once for child
    expect(mockedCreateFnAgent.mock.calls.length).toBeGreaterThanOrEqual(2);
    
    // Find the child session call
    const childCall = mockedCreateFnAgent.mock.calls.find(
      (call: any) => call[0].systemPrompt?.includes("child agent spawned")
    );
    expect(childCall).toBeDefined();
    expect(childCall![0].tools).toBe("coding");
    expect(childCall![0].systemPrompt).toContain("FN-SPAWN");
  });

  it("respects per-parent maxSpawnedAgentsPerParent limit", async () => {
    const agentStore = createMockAgentStore();
    const { tools } = await captureToolsWithAgentStore(agentStore, {
      maxSpawnedAgentsPerParent: 2,
    });

    // Spawn 2 agents (limit)
    await tools.fn_spawn_agent("call1", { name: "a1", role: "engineer", task: "task 1" });
    await tools.fn_spawn_agent("call2", { name: "a2", role: "engineer", task: "task 2" });

    // 3rd should be rejected
    const result = await tools.fn_spawn_agent("call3", { name: "a3", role: "engineer", task: "task 3" });
    expect(result.content[0].text).toContain("Per-parent spawn limit reached");
    expect(result.content[0].text).toContain("2/2");
    expect(result.details.state).toBe("error");
  });

  it("respects global maxSpawnedAgentsGlobal limit", async () => {
    const agentStore = createMockAgentStore();
    const { tools } = await captureToolsWithAgentStore(agentStore, {
      maxSpawnedAgentsGlobal: 3,
    });

    // Spawn 3 agents (global limit)
    await tools.fn_spawn_agent("call1", { name: "a1", role: "engineer", task: "task 1" });
    await tools.fn_spawn_agent("call2", { name: "a2", role: "engineer", task: "task 2" });
    await tools.fn_spawn_agent("call3", { name: "a3", role: "engineer", task: "task 3" });

    // 4th should hit global limit
    const result = await tools.fn_spawn_agent("call4", { name: "a4", role: "engineer", task: "task 4" });
    expect(result.content[0].text).toContain("Global spawn limit reached");
    expect(result.content[0].text).toContain("3/3");
    expect(result.details.state).toBe("error");
  });

  it("uses default limits when settings are not specified", async () => {
    const agentStore = createMockAgentStore();
    // No spawn settings in the store — defaults should apply
    const { tools } = await captureToolsWithAgentStore(agentStore);

    // Should be able to spawn (defaults: 5 per parent, 20 global)
    const result = await tools.fn_spawn_agent("call1", {
      name: "worker",
      role: "engineer",
      task: "task 1",
    });
    const parsed = JSON.parse(result.content[0].text);
    expect(parsed.state).toBe("running");
  });

  it("handles errors during agent creation gracefully", async () => {
    const agentStore = createMockAgentStore();
    agentStore.createAgent.mockRejectedValue(new Error("DB connection failed"));

    const { tools } = await captureToolsWithAgentStore(agentStore);

    const result = await tools.fn_spawn_agent("call1", {
      name: "worker",
      role: "engineer",
      task: "task 1",
    });

    expect(result.content[0].text).toContain("Failed to spawn agent");
    expect(result.content[0].text).toContain("DB connection failed");
    expect(result.details.state).toBe("error");
  });

  it("trims whitespace from agent name", async () => {
    const agentStore = createMockAgentStore();
    const { tools } = await captureToolsWithAgentStore(agentStore);

    await tools.fn_spawn_agent("call1", {
      name: "  researcher  ",
      role: "engineer",
      task: "task 1",
    });

    const createInput = agentStore.createAgent.mock.calls[0][0];
    expect(createInput.name).toBe("researcher");
  });

  it("truncates long task descriptions in result message", async () => {
    const agentStore = createMockAgentStore();
    const { tools } = await captureToolsWithAgentStore(agentStore);

    const longTask = "A".repeat(200);
    const result = await tools.fn_spawn_agent("call1", {
      name: "worker",
      role: "engineer",
      task: longTask,
    });

    const parsed = JSON.parse(result.content[0].text);
    expect(parsed.message).toContain("...");
    // The message should contain the first 100 chars
    expect(parsed.message.length).toBeLessThan(longTask.length + 50);
  });
});

describe("Agent Spawning - Child Termination", () => {
  beforeEach(() => {
    resetExecutorMocks();
    mockedExistsSync.mockReturnValue(true);
    vi.mocked(execSync).mockReturnValue("");
  });

  it("parent termination triggers all child terminations", async () => {
    const agentStore = createMockAgentStore();
    const mockDispose = vi.fn();

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      return {
        session: {
          prompt: vi.fn().mockResolvedValue(undefined),
          dispose: mockDispose,
          sessionManager: {
            getLeafId: vi.fn().mockReturnValue("leaf-id"),
            branchWithSummary: vi.fn(),
          },
          navigateTree: vi.fn().mockResolvedValue({ cancelled: false }),
        },
      } as any;
    });

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

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

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

    // execute() should have completed, disposing the parent session
    // and any child sessions that were spawned
    expect(mockDispose).toHaveBeenCalled();
  });

  it("terminateChildAgent cleans up maps and decrements count", async () => {
    const agentStore = createMockAgentStore();
    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
    });

    const mockDispose = vi.fn();
    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: mockDispose,
        sessionManager: {
          getLeafId: vi.fn().mockReturnValue("leaf-id"),
          branchWithSummary: vi.fn(),
        },
        navigateTree: vi.fn().mockResolvedValue({ cancelled: false }),
      },
    } as any);

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

    // Access internal state via any for testing
    const internals = executor as any;
    
    // Simulate spawned agent tracking state
    const childId = "agent-test-child";
    const mockSession = { dispose: vi.fn() };
    internals.childSessions.set(childId, mockSession);
    internals.spawnedAgents.set("FN-PARENT", new Set([childId]));
    internals.totalSpawnedCount = 1;

    // Terminate the child
    await internals.terminateChildAgent(childId);

    expect(mockSession.dispose).toHaveBeenCalled();
    expect(internals.childSessions.has(childId)).toBe(false);
    // Note: spawnedAgents cleanup is done by terminateAllChildren, not terminateChildAgent
    expect(internals.totalSpawnedCount).toBe(0);
    expect(agentStore.updateAgentState).toHaveBeenCalledWith(childId, "paused");
  });

  it("terminateChildAgent handles missing session gracefully", async () => {
    const agentStore = createMockAgentStore();
    const store = createMockStore();

    const executor = new TaskExecutor(store, "/tmp/test", { agentStore } as any);
    const internals = executor as any;

    internals.totalSpawnedCount = 1;

    // Terminate a child that doesn't have a session in the map
    await internals.terminateChildAgent("nonexistent-agent");

    // Should still decrement counter and attempt state update
    expect(internals.totalSpawnedCount).toBe(0);
    expect(agentStore.updateAgentState).toHaveBeenCalledWith("nonexistent-agent", "paused");
  });

  it("terminateAllChildren handles no children gracefully", async () => {
    const agentStore = createMockAgentStore();
    const store = createMockStore();

    const executor = new TaskExecutor(store, "/tmp/test", { agentStore } as any);
    const internals = executor as any;

    // Should not throw when there are no children
    await internals.terminateAllChildren("FN-NONE");
    expect(agentStore.updateAgentState).not.toHaveBeenCalled();
  });

  it("terminateAllChildren terminates all children and cleans up", async () => {
    const agentStore = createMockAgentStore();
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test", { agentStore } as any);
    const internals = executor as any;

    // Set up multiple children
    const child1 = { dispose: vi.fn() };
    const child2 = { dispose: vi.fn() };
    internals.childSessions.set("c1", child1);
    internals.childSessions.set("c2", child2);
    internals.spawnedAgents.set("FN-PARENT", new Set(["c1", "c2"]));
    internals.totalSpawnedCount = 2;

    await internals.terminateAllChildren("FN-PARENT");

    expect(child1.dispose).toHaveBeenCalled();
    expect(child2.dispose).toHaveBeenCalled();
    expect(internals.spawnedAgents.has("FN-PARENT")).toBe(false);
    expect(internals.totalSpawnedCount).toBe(0);
    expect(agentStore.updateAgentState).toHaveBeenCalledWith("c1", "paused");
    expect(agentStore.updateAgentState).toHaveBeenCalledWith("c2", "paused");
  });

  it("terminateChildAgent handles AgentStore errors gracefully", async () => {
    const agentStore = createMockAgentStore();
    agentStore.updateAgentState.mockRejectedValue(new Error("DB error"));
    const store = createMockStore();

    const executor = new TaskExecutor(store, "/tmp/test", { agentStore } as any);
    const internals = executor as any;

    const mockSession = { dispose: vi.fn() };
    internals.childSessions.set("c1", mockSession);
    internals.totalSpawnedCount = 1;

    // Should not throw even when AgentStore fails
    await internals.terminateChildAgent("c1");
    expect(mockSession.dispose).toHaveBeenCalled();
    expect(internals.totalSpawnedCount).toBe(0);
  });

  it("terminateChildAgent auto-deletes agent immediately", async () => {
    const agentStore = createMockAgentStore() as any;
    agentStore.deleteAgent = vi.fn().mockResolvedValue(undefined);
    const store = createMockStore();

    const executor = new TaskExecutor(store, "/tmp/test", { agentStore } as any);
    const internals = executor as any;

    const mockSession = { dispose: vi.fn() };
    const childId = "agent-auto-delete-test";
    internals.childSessions.set(childId, mockSession);
    internals.totalSpawnedCount = 1;

    await internals.terminateChildAgent(childId);

    expect(mockSession.dispose).toHaveBeenCalled();
    expect(agentStore.deleteAgent).toHaveBeenCalledTimes(1);
    expect(agentStore.deleteAgent).toHaveBeenCalledWith(childId);
    expect(internals.pendingEphemeralDeletions.has(childId)).toBe(false);
  });

  it("disposeEphemeralTimers clears pending deletion bookkeeping", async () => {
    const agentStore = createMockAgentStore() as any;
    agentStore.deleteAgent = vi.fn().mockResolvedValue(undefined);
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test", { agentStore } as any);
    const internals = executor as any;

    internals.pendingEphemeralDeletions.add("agent-dispose-test");
    executor.disposeEphemeralTimers();

    expect(internals.pendingEphemeralDeletions.size).toBe(0);
  });
});

describe("Agent Spawning - runSpawnedChild", () => {
  beforeEach(() => {
    resetExecutorMocks();
    mockedExistsSync.mockReturnValue(true);
  });

  it("updates agent state to running then active on success", async () => {
    const agentStore = createMockAgentStore();
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test", { agentStore } as any);
    const internals = executor as any;

    const mockSession = { dispose: vi.fn(), prompt: vi.fn().mockResolvedValue(undefined) };
    internals.childSessions.set("agent-test", mockSession);
    internals.totalSpawnedCount = 1;

    await internals.runSpawnedChild("agent-test", mockSession, "Do the research");

    // Should transition: running → active
    expect(agentStore.updateAgentState).toHaveBeenCalledWith("agent-test", "running");
    expect(agentStore.updateAgentState).toHaveBeenCalledWith("agent-test", "active");
    // Should clean up
    expect(internals.childSessions.has("agent-test")).toBe(false);
    expect(internals.totalSpawnedCount).toBe(0);
  });

  it("updates agent state to error on failure", async () => {
    const agentStore = createMockAgentStore();
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test", { agentStore } as any);
    const internals = executor as any;

    const mockSession = { dispose: vi.fn() };
    internals.childSessions.set("agent-test", mockSession);
    internals.totalSpawnedCount = 1;

    // Make promptWithFallback throw
    const { promptWithFallback } = await import("../pi.js");
    vi.mocked(promptWithFallback).mockRejectedValueOnce(new Error("API error"));

    await internals.runSpawnedChild("agent-test", mockSession, "Do the research");

    expect(agentStore.updateAgentState).toHaveBeenCalledWith("agent-test", "running");
    expect(agentStore.updateAgentState).toHaveBeenCalledWith("agent-test", "error");
    // Should still clean up
    expect(internals.childSessions.has("agent-test")).toBe(false);
    expect(internals.totalSpawnedCount).toBe(0);
  });

  it("cleans up even when state update fails", async () => {
    const agentStore = createMockAgentStore();
    agentStore.updateAgentState.mockRejectedValue(new Error("DB down"));
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test", { agentStore } as any);
    const internals = executor as any;

    const mockSession = { dispose: vi.fn() };
    internals.childSessions.set("agent-test", mockSession);
    internals.totalSpawnedCount = 1;

    // Should not throw even when state updates fail
    await internals.runSpawnedChild("agent-test", mockSession, "Do the research");

    expect(internals.childSessions.has("agent-test")).toBe(false);
    expect(internals.totalSpawnedCount).toBe(0);
  });
});

// ─── Agent Execution Flow Integration Tests (FN-978) ────────────────────────────
//
// These tests verify the complete execution flow: event listener registration,
// session creation, stuck detector tracking, and heartbeat recording.
describe("TaskExecutor agent execution flow (FN-978)", () => {
  beforeEach(() => {
    resetExecutorMocks();
    mockedExistsSync.mockReturnValue(true);
  });

  it("registers task:moved event listener in constructor", () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");
    // Verify the store.on was called with "task:moved"
    expect(store.on).toHaveBeenCalledWith("task:moved", expect.any(Function));
  });

  it("executes task when task:moved event fires with to='in-progress'", async () => {
    const store = createMockStore();
    const session = {
      prompt: vi.fn().mockResolvedValue(undefined),
      dispose: vi.fn(),
    };

    mockedCreateFnAgent.mockResolvedValue({ session } as any);

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

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

    // Trigger the task:moved event manually
    store._trigger("task:moved", { task, from: "todo", to: "in-progress" });

    // Wait for async execution to complete
    await new Promise((resolve) => setTimeout(resolve, 50));

    // Verify the agent was created and prompt was called
    expect(mockedCreateFnAgent).toHaveBeenCalledWith(
      expect.objectContaining({
        cwd: expect.any(String),
        systemPrompt: expect.any(String),
        tools: "coding",
      }),
    );
    expect(session.prompt).toHaveBeenCalled();
  });

  it("does not execute task when task:moved event fires with to!='in-progress'", async () => {
    const store = createMockStore();

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

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

    const task = {
      id: "FN-978",
      title: "Test Task",
      description: "Test",
      column: "todo",
      dependencies: [],
      steps: [],
      currentStep: 0,
      log: [],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };

    // Trigger the task:moved event with to='done' (should not execute)
    store._trigger("task:moved", { task, from: "in-progress", to: "done" });

    // Wait for async
    await new Promise((resolve) => setTimeout(resolve, 50));

    // Verify no agent was created
    expect(mockedCreateFnAgent).not.toHaveBeenCalled();
  });

  describe("merge-state reset when returning to in-progress (FN-2883)", () => {
    it("resets merge state on in-review → in-progress move", async () => {
      const store = createMockStore();
      const executor = new TaskExecutor(store, "/tmp/test");
      const executeSpy = vi.spyOn(executor, "execute").mockResolvedValue(undefined);

      const movedTask = {
        id: "FN-2883-A",
        title: "Merge retry",
        description: "desc",
        column: "in-progress" as const,
        dependencies: [],
        steps: [
          { name: "Step 0: Preflight", status: "done" },
          { name: "Step 1: Implementation", status: "done" },
          { name: "Step 2: Testing & Verification", status: "done" },
          { name: "Step 3: Documentation & Delivery", status: "done" },
        ],
        currentStep: 3,
        log: [],
        mergeDetails: { strategy: "manual" } as any,
        mergeRetries: 2,
        verificationFailureCount: 0,
        workflowStepResults: [{ id: "wf-1", status: "passed" }],
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      };

      store.getTask.mockResolvedValue(movedTask);
      store._trigger("task:moved", { task: movedTask, from: "in-review", to: "in-progress" });
      await new Promise((resolve) => setTimeout(resolve, 20));

      expect(store.updateTask).toHaveBeenCalledWith("FN-2883-A", expect.objectContaining({
        mergeDetails: null,
        mergeRetries: 0,
        verificationFailureCount: 0,
        workflowStepResults: [],
      }));
      expect(store.updateStep).toHaveBeenCalledWith("FN-2883-A", 3, "pending");
      expect(store.logEntry).toHaveBeenCalledWith(
        "FN-2883-A",
        expect.stringContaining("Task returned to in-progress from in-review column"),
        undefined,
        undefined,
      );
      expect(executeSpy).toHaveBeenCalled();
    });

    it("resets merge state on done → in-progress move", async () => {
      const store = createMockStore();
      const executor = new TaskExecutor(store, "/tmp/test");
      vi.spyOn(executor, "execute").mockResolvedValue(undefined);

      const movedTask = {
        id: "FN-2883-B",
        title: "Done rollback",
        description: "desc",
        column: "in-progress" as const,
        dependencies: [],
        steps: [
          { name: "Step 0: Preflight", status: "done" },
          { name: "Step 1: Testing & Verification", status: "done" },
          { name: "Step 2: Documentation & Delivery", status: "done" },
        ],
        currentStep: 2,
        log: [],
        mergeDetails: { strategy: "ours" } as any,
        mergeRetries: 1,
        verificationFailureCount: 0,
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      };

      store.getTask.mockResolvedValue(movedTask);
      store._trigger("task:moved", { task: movedTask, from: "done", to: "in-progress" });
      await new Promise((resolve) => setTimeout(resolve, 20));

      expect(store.updateTask).toHaveBeenCalledWith("FN-2883-B", expect.objectContaining({
        mergeDetails: null,
        mergeRetries: 0,
        verificationFailureCount: 0,
        workflowStepResults: [],
      }));
      expect(store.updateStep).toHaveBeenCalledWith("FN-2883-B", 2, "pending");
      expect(store.logEntry).toHaveBeenCalledWith(
        "FN-2883-B",
        expect.stringContaining("Task returned to in-progress from done column"),
        undefined,
        undefined,
      );
    });

    it("preserves verificationFailureCount for merge remediation cycles even if status was cleared", async () => {
      const store = createMockStore();
      const executor = new TaskExecutor(store, "/tmp/test");
      vi.spyOn(executor, "execute").mockResolvedValue(undefined);

      const movedTask = {
        id: "FN-2883-D",
        title: "Verification remediation",
        description: "desc",
        column: "in-progress" as const,
        dependencies: [],
        steps: [{ name: "Step 2: Testing & Verification", status: "done" }],
        currentStep: 0,
        log: [],
        mergeDetails: { strategy: "manual" } as any,
        mergeRetries: 0,
        status: null,
        verificationFailureCount: 2,
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      };

      store.getTask.mockResolvedValue(movedTask);
      store._trigger("task:moved", { task: movedTask, from: "in-review", to: "in-progress" });
      await new Promise((resolve) => setTimeout(resolve, 20));

      expect(store.updateTask).toHaveBeenCalledWith("FN-2883-D", expect.objectContaining({
        mergeDetails: null,
        mergeRetries: 0,
        verificationFailureCount: 2,
        workflowStepResults: [],
      }));
    });

    it("does not reset merge state on todo → in-progress move", async () => {
      const store = createMockStore();
      const executor = new TaskExecutor(store, "/tmp/test");
      vi.spyOn(executor, "execute").mockResolvedValue(undefined);

      const movedTask = {
        id: "FN-2883-C",
        title: "Fresh start",
        description: "desc",
        column: "in-progress" as const,
        dependencies: [],
        steps: [{ name: "Step 0: Preflight", status: "pending" }],
        currentStep: 0,
        log: [],
        mergeDetails: null,
        mergeRetries: 0,
        verificationFailureCount: 0,
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      };

      store._trigger("task:moved", { task: movedTask, from: "todo", to: "in-progress" });
      await new Promise((resolve) => setTimeout(resolve, 20));

      expect(store.updateTask).not.toHaveBeenCalledWith("FN-2883-C", expect.objectContaining({ mergeDetails: null }));
      expect(store.updateStep).not.toHaveBeenCalled();
    });
  });

  describe("when task is moved away from in-progress", () => {
    it("terminates active session and removes from activeSessions map", async () => {
      const store = createMockStore();
      const executor = new TaskExecutor(store, "/tmp/test");

      const disposeSpy = vi.fn();
      const mockSession = {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: disposeSpy,
        steer: vi.fn(),
      };

      // Simulate an active session
      (executor as any).activeSessions.set("FN-001", {
        session: mockSession,
        seenSteeringIds: new Set(),
      });

      const task = {
        id: "FN-001",
        title: "Test Task",
        description: "Test",
        column: "todo" as const,
        dependencies: [],
        steps: [],
        currentStep: 0,
        log: [],
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      };

      // Trigger task:moved away from in-progress
      store._trigger("task:moved", { task, from: "in-progress", to: "todo" });

      // Allow async handlers to complete
      await new Promise((resolve) => setTimeout(resolve, 50));

      // Verify session was disposed and removed from map
      expect(disposeSpy).toHaveBeenCalled();
      expect((executor as any).activeSessions.has("FN-001")).toBe(false);
      // Verify task was added to pausedAborted set
      expect((executor as any).pausedAborted.has("FN-001")).toBe(true);
    });

    it("terminates active step executor when task is moved away", async () => {
      const store = createMockStore();
      const executor = new TaskExecutor(store, "/tmp/test");

      const mockTerminateAllSessions = vi.fn().mockResolvedValue(undefined);
      const mockStepExecutor = {
        executeAll: vi.fn().mockResolvedValue([]),
        terminateAllSessions: mockTerminateAllSessions,
        cleanup: vi.fn().mockResolvedValue(undefined),
      };

      // Simulate an active step executor
      (executor as any).activeStepExecutors.set("FN-002", mockStepExecutor as any);

      const task = {
        id: "FN-002",
        title: "Test Task",
        description: "Test",
        column: "todo" as const,
        dependencies: [],
        steps: [],
        currentStep: 0,
        log: [],
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      };

      // Trigger task:moved away from in-progress
      store._trigger("task:moved", { task, from: "in-progress", to: "triage" });

      // Allow async handlers to complete
      await new Promise((resolve) => setTimeout(resolve, 50));

      // Verify terminateAllSessions was called
      expect(mockTerminateAllSessions).toHaveBeenCalled();
      // Verify removed from map
      expect((executor as any).activeStepExecutors.has("FN-002")).toBe(false);
    });

    it("handles graceful no-op when no active session exists", async () => {
      const store = createMockStore();
      const executor = new TaskExecutor(store, "/tmp/test");

      // No active session set

      const task = {
        id: "FN-003",
        title: "Test Task",
        description: "Test",
        column: "todo" as const,
        dependencies: [],
        steps: [],
        currentStep: 0,
        log: [],
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      };

      // Should not throw
      expect(() => {
        store._trigger("task:moved", { task, from: "in-progress", to: "triage" });
      }).not.toThrow();
    });

    it("untracks task from stuck detector when moved away", async () => {
      const store = createMockStore();
      const untrackSpy = vi.fn();
      const stuckDetector = {
        trackTask: vi.fn(),
        recordActivity: vi.fn(),
        recordProgress: vi.fn(),
        untrackTask: untrackSpy,
      };

      const executor = new TaskExecutor(store, "/tmp/test", {
        stuckTaskDetector: stuckDetector as any,
      });

      const disposeSpy = vi.fn();
      const mockSession = {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: disposeSpy,
        steer: vi.fn(),
      };

      (executor as any).activeSessions.set("FN-004", {
        session: mockSession,
        seenSteeringIds: new Set(),
      });

      const task = {
        id: "FN-004",
        title: "Test Task",
        description: "Test",
        column: "todo" as const,
        dependencies: [],
        steps: [],
        currentStep: 0,
        log: [],
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      };

      store._trigger("task:moved", { task, from: "in-progress", to: "todo" });

      await new Promise((resolve) => setTimeout(resolve, 50));

      expect(untrackSpy).toHaveBeenCalledWith("FN-004");
    });

    it("adds task to pausedAborted set to prevent re-execution", async () => {
      const store = createMockStore();
      const executor = new TaskExecutor(store, "/tmp/test");

      const disposeSpy = vi.fn();
      const mockSession = {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: disposeSpy,
        steer: vi.fn(),
      };

      (executor as any).activeSessions.set("FN-005", {
        session: mockSession,
        seenSteeringIds: new Set(),
      });

      const task = {
        id: "FN-005",
        title: "Test Task",
        description: "Test",
        column: "triage" as const,
        dependencies: [],
        steps: [],
        currentStep: 0,
        log: [],
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      };

      store._trigger("task:moved", { task, from: "in-progress", to: "triage" });

      await new Promise((resolve) => setTimeout(resolve, 50));

      expect((executor as any).pausedAborted.has("FN-005")).toBe(true);
    });
  });

  it("tracks task with stuck detector after session creation", async () => {
    const store = createMockStore();
    const stuckDetector = {
      trackTask: vi.fn(),
      recordActivity: vi.fn(),
      recordProgress: vi.fn(),
      untrackTask: vi.fn(),
    };

    const session = {
      prompt: vi.fn().mockResolvedValue(undefined),
      dispose: vi.fn(),
    };

    mockedCreateFnAgent.mockResolvedValue({ session } as any);

    const executor = new TaskExecutor(store, "/tmp/test", {
      stuckTaskDetector: stuckDetector as any,
    });

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

    await executor.execute(task);

    // Verify trackTask was called with task ID
    expect(stuckDetector.trackTask).toHaveBeenCalledWith("FN-978", expect.anything());
    // Verify recordActivity was called (heartbeat on prompt start)
    expect(stuckDetector.recordActivity).toHaveBeenCalledWith("FN-978");
    // Verify untrackTask was called in the finally block
    expect(stuckDetector.untrackTask).toHaveBeenCalledWith("FN-978");
  });

  it("records activity via AgentLogger onText callbacks", async () => {
    const store = createMockStore();
    const stuckDetector = {
      trackTask: vi.fn(),
      recordActivity: vi.fn(),
      recordProgress: vi.fn(),
      untrackTask: vi.fn(),
    };

    let capturedOnText: ((delta: string) => void) | undefined;

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      // Capture the onText callback that's passed to createFnAgent
      capturedOnText = opts.onText;
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            // Simulate the agent producing text output
            if (capturedOnText) {
              capturedOnText("Hello world");
            }
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const onAgentText = vi.fn();
    const executor = new TaskExecutor(store, "/tmp/test", {
      stuckTaskDetector: stuckDetector as any,
      onAgentText,
    });

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

    await executor.execute(task);

    // Verify that recordActivity was called (at least once for the initial heartbeat
    // and possibly more for the simulated text output)
    expect(stuckDetector.recordActivity).toHaveBeenCalledWith("FN-978");
    // The initial recordActivity + text callback should result in multiple calls
    expect(stuckDetector.recordActivity.mock.calls.length).toBeGreaterThanOrEqual(2);
    // Verify onAgentText callback was called with the delta
    expect(onAgentText).toHaveBeenCalledWith("FN-978", "Hello world");
  });

  it("records activity via AgentLogger onToolStart callbacks", async () => {
    const store = createMockStore();
    const stuckDetector = {
      trackTask: vi.fn(),
      recordActivity: vi.fn(),
      recordProgress: vi.fn(),
      untrackTask: vi.fn(),
    };

    let capturedOnToolStart: ((name: string, args?: Record<string, unknown>) => void) | undefined;

    mockedCreateFnAgent.mockImplementation(async (opts: any) => {
      capturedOnToolStart = opts.onToolStart;
      return {
        session: {
          prompt: vi.fn().mockImplementation(async () => {
            // Simulate the agent calling a tool
            if (capturedOnToolStart) {
              capturedOnToolStart("bash", { command: "echo test" });
            }
          }),
          dispose: vi.fn(),
        },
      } as any;
    });

    const onAgentTool = vi.fn();
    const executor = new TaskExecutor(store, "/tmp/test", {
      stuckTaskDetector: stuckDetector as any,
      onAgentTool,
    });

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

    await executor.execute(task);

    // Verify that recordActivity was called for the tool usage
    expect(stuckDetector.recordActivity).toHaveBeenCalledWith("FN-978");
    // Verify onAgentTool callback was called with the tool name
    expect(onAgentTool).toHaveBeenCalledWith("FN-978", "bash");
  });

  it("prevents duplicate execution when task:moved fires twice for same task", async () => {
    const store = createMockStore();
    const session = {
      prompt: vi.fn().mockResolvedValue(undefined),
      dispose: vi.fn(),
    };

    mockedCreateFnAgent.mockResolvedValue({ session } as any);

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

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

    // Trigger the event twice quickly
    store._trigger("task:moved", { task, from: "todo", to: "in-progress" });
    store._trigger("task:moved", { task, from: "todo", to: "in-progress" });

    // Wait for completion
    await new Promise((resolve) => setTimeout(resolve, 200));

    // The executing guard prevents duplicate execution from the event handler.
    // Note: createFnAgent may be called a second time if the agent finishes
    // without calling fn_task_done (retry path), but the initial trigger should
    // only cause one execution, not two.
    // Verify that store.on was called with task:moved (listener registered)
    expect(store.on).toHaveBeenCalledWith("task:moved", expect.any(Function));
    // Verify the event handler initiated execute() (not twice from events)
    // The executing set guard works — both triggers don't cause double execution
  });

  it("logs error when execute() fails in task:moved handler", async () => {
    const store = createMockStore();
    mockedCreateFnAgent.mockRejectedValue(new Error("model not found"));

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

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

    // Trigger the event
    store._trigger("task:moved", { task, from: "todo", to: "in-progress" });

    // Wait for async
    await new Promise((resolve) => setTimeout(resolve, 50));

    // Verify the error handler was called
    expect(onError).toHaveBeenCalledWith(
      expect.objectContaining({ id: "FN-978" }),
      expect.any(Error),
    );
  });
});

describe("FN-2883 fast-path guards", () => {
  beforeEach(() => {
    resetExecutorMocks();
    mockedExistsSync.mockReturnValue(true);
  });

  it("execute() defensively clears stale mergeDetails for in-progress tasks", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");

    const cleanupSpy = vi.spyOn(executor as any, "cleanupMergeStateForReverification")
      .mockResolvedValue({
        id: "FN-2883-D",
        title: "stale merge",
        description: "desc",
        column: "in-progress",
        dependencies: [],
        steps: [{ name: "Step 0", status: "pending" }],
        currentStep: 0,
        log: [],
        mergeDetails: null,
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      });

    const task = {
      id: "FN-2883-D",
      title: "stale merge",
      description: "desc",
      column: "in-progress" as const,
      dependencies: [],
      steps: [{ name: "Step 0", status: "pending" }],
      currentStep: 0,
      log: [],
      mergeDetails: { strategy: "theirs" } as any,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };

    await executor.execute(task as any);

    expect(cleanupSpy).toHaveBeenCalledWith(
      expect.objectContaining({ id: "FN-2883-D" }),
      expect.stringContaining("stale merge state"),
    );
  });

  it("resumeOrphaned does not fast-path completed tasks that still have mergeDetails", async () => {
    const store = createMockStore();
    const executor = new TaskExecutor(store, "/tmp/test");

    store.listTasks.mockResolvedValue([
      {
        id: "FN-2883-E",
        title: "orphan",
        description: "desc",
        column: "in-progress",
        paused: false,
        dependencies: [],
        steps: [
          { name: "Step 0", status: "done" },
          { name: "Step 1", status: "done" },
        ],
        currentStep: 1,
        log: [],
        mergeDetails: { strategy: "manual" },
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      },
    ]);

    const executeSpy = vi.spyOn(executor, "execute").mockResolvedValue(undefined);
    const recoverSpy = vi.spyOn(executor, "recoverCompletedTask").mockResolvedValue(false);

    await executor.resumeOrphaned();

    expect(recoverSpy).not.toHaveBeenCalled();
    expect(executeSpy).toHaveBeenCalledWith(expect.objectContaining({ id: "FN-2883-E" }));
  });
});

describe("TaskExecutor watchdogs", () => {
  beforeEach(() => {
    resetExecutorMocks();
    mockedExistsSync.mockReturnValue(true);
    vi.useFakeTimers();
  });

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

  it("recovers a completed task still stuck in-progress after the completion watchdog delay", async () => {
    const store = createMockStore();
    const stuckTask = {
      id: "FN-WD-1",
      title: "Watchdog test",
      description: "desc",
      column: "in-progress" as const,
      paused: false,
      dependencies: [],
      steps: [{ name: "Step 0", status: "done" as const }],
      currentStep: 0,
      log: [],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };
    store.getTask.mockImplementation(async () => stuckTask);

    const executor = new TaskExecutor(store, "/tmp/test");
    const recoverSpy = vi.spyOn(executor, "recoverCompletedTask").mockResolvedValue(true);

    (executor as any).scheduleCompletedTaskWatchdog("FN-WD-1", "fn_task_done");
    await vi.advanceTimersByTimeAsync(60_000);

    expect(recoverSpy).toHaveBeenCalledWith(expect.objectContaining({ id: "FN-WD-1" }));
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-WD-1",
      expect.stringContaining("Watchdog: task remained in-progress 60s after fn_task_done"),
    );
  });

  it("clears the completion watchdog once the task leaves in-progress", async () => {
    const store = createMockStore();
    const stuckTask = {
      id: "FN-WD-2",
      title: "Watchdog clear test",
      description: "desc",
      column: "in-progress" as const,
      paused: false,
      dependencies: [],
      steps: [{ name: "Step 0", status: "done" as const }],
      currentStep: 0,
      log: [],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };
    store.getTask.mockImplementation(async () => stuckTask);

    const executor = new TaskExecutor(store, "/tmp/test");
    const recoverSpy = vi.spyOn(executor, "recoverCompletedTask").mockResolvedValue(true);

    (executor as any).scheduleCompletedTaskWatchdog("FN-WD-2", "fn_task_done");
    store._trigger("task:moved", { task: { id: "FN-WD-2" }, from: "in-progress", to: "in-review" });
    await vi.advanceTimersByTimeAsync(60_000);

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

  it("retries a stalled workflow rerun handoff once after the watchdog delay", async () => {
    const store = createMockStore();
    const mutableTask: {
      id: string;
      title: string;
      description: string;
      column: "in-progress" | "todo";
      paused: boolean;
      worktree: string;
      dependencies: string[];
      steps: { name: string; status: "done" }[];
      currentStep: number;
      log: unknown[];
      createdAt: string;
      updatedAt: string;
    } = {
      id: "FN-WD-3",
      title: "Workflow watchdog test",
      description: "desc",
      column: "in-progress",
      paused: false,
      worktree: "/tmp/fn-wd-3",
      dependencies: [],
      steps: [{ name: "Step 0", status: "done" as const }],
      currentStep: 0,
      log: [],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };
    let inProgressAttempts = 0;

    store.getTask.mockImplementation(async () => mutableTask as any);
    store.updateTask.mockImplementation(async (_taskId: string, patch: any) => {
      if (patch.worktree !== undefined) {
        mutableTask.worktree = patch.worktree;
      }
      return {};
    });
    store.moveTask.mockImplementation(async (_taskId: string, column: string) => {
      if (column === "todo") {
        mutableTask.column = "todo";
        return {};
      }
      if (column === "in-progress") {
        inProgressAttempts += 1;
        if (inProgressAttempts === 1) {
          throw new Error("guard still unwinding");
        }
        mutableTask.column = "in-progress";
      }
      return {};
    });

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

    (executor as any).scheduleWorkflowRerun(
      "FN-WD-3",
      "/tmp/fn-wd-3",
      "FN-WD-3: workflow step retry scheduled — moved to todo then in-progress",
    );

    await vi.advanceTimersByTimeAsync(0);
    expect(mutableTask.column).toBe("todo");

    await vi.advanceTimersByTimeAsync(15_000);

    expect(inProgressAttempts).toBe(2);
    expect(mutableTask.column).toBe("in-progress");
    expect(store.logEntry).toHaveBeenCalledWith(
      "FN-WD-3",
      expect.stringContaining("Watchdog: workflow rerun handoff stalled for 15s"),
    );
  });

  it("defers workflow rerun bounce while global pause is active", async () => {
    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      autoMerge: false,
      globalPause: true,
      enginePaused: false,
    });

    const executor = new TaskExecutor(store, "/tmp/test");
    const outcome = await (executor as any).performWorkflowRerunBounce("FN-WD-PAUSE", "/tmp/fn-wd-pause");

    expect(outcome).toBe("deferred-paused");
    expect(store.getTask).not.toHaveBeenCalled();
    expect(store.moveTask).not.toHaveBeenCalled();
  });

  it("preserves the original executionStartedAt during a workflow rerun bounce", async () => {
    const store = createMockStore();
    const originalExecutionStartedAt = "2026-04-30T05:06:43.781Z";
    const mutableTask: {
      id: string;
      title: string;
      description: string;
      column: "in-progress" | "todo";
      paused: boolean;
      worktree: string;
      executionStartedAt: string;
      dependencies: string[];
      steps: { name: string; status: string }[];
      currentStep: number;
      log: unknown[];
      createdAt: string;
      updatedAt: string;
    } = {
      id: "FN-WD-4",
      title: "Workflow rerun timing",
      description: "desc",
      column: "in-progress",
      paused: false,
      worktree: "/tmp/fn-wd-4",
      executionStartedAt: originalExecutionStartedAt,
      dependencies: [],
      steps: [{ name: "Step 0", status: "done" as const }],
      currentStep: 0,
      log: [],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };

    store.getTask.mockResolvedValue(mutableTask as any);
    store.moveTask.mockImplementation(async (_taskId: string, column: string) => {
      mutableTask.column = column as "in-progress" | "todo";
      return { ...mutableTask };
    });

    const executor = new TaskExecutor(store, "/tmp/test");
    const outcome = await (executor as any).performWorkflowRerunBounce("FN-WD-4", "/tmp/fn-wd-4");

    expect(outcome).toBe("bounced");
    expect(store.updateTask).toHaveBeenCalledWith("FN-WD-4", {
      worktree: "/tmp/fn-wd-4",
      executionStartedAt: originalExecutionStartedAt,
    });
    expect(store.moveTask.mock.calls).toEqual([
      ["FN-WD-4", "todo", { preserveResumeState: true, preserveWorktree: true }],
      ["FN-WD-4", "in-progress"],
    ]);
  });
});

// ── StepSessionExecutor integration tests ──────────────────────────────────

describe("StepSessionExecutor integration", () => {
  beforeEach(() => {
    resetExecutorMocks();
    mockExecuteAll.mockResolvedValue([]);
    mockTerminateAllSessions.mockResolvedValue(undefined);
    mockCleanup.mockResolvedValue(undefined);
  });

  /** Helper to create a task with steps for step-session mode testing */
  function createTaskWithSteps(overrides: Partial<Task> = {}): Task {
    return {
      id: "FN-200",
      title: "Step-session test task",
      description: "Test task with steps for step-session execution",
      column: "in-progress",
      dependencies: [],
      steps: [
        { name: "Step 0", status: "pending" },
        { name: "Step 1", status: "pending" },
      ],
      currentStep: 0,
      log: [],
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
      ...overrides,
    };
  }

  /** Helper to create a store configured for step-session mode */
  function createStepSessionStore() {
    const store = createMockStore();
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      runStepsInNewSessions: true,
      maxParallelSteps: 2,
    });
    store.getTask.mockResolvedValue({
      id: "FN-200",
      title: "Step-session test task",
      description: "Test task with steps for step-session execution",
      column: "in-progress",
      dependencies: [],
      steps: [
        { name: "Step 0", status: "pending" },
        { name: "Step 1", status: "pending" },
      ],
      currentStep: 0,
      log: [],
      prompt: "# test\n## Steps\n### Step 0: Preflight\n- [ ] check\n### Step 1: Implement\n- [ ] code",
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
      baseCommitSha: "abc123",
      enabledWorkflowSteps: [],
    });
    return store;
  }

  function createTokenUsageStepSessionStore(overrides: Partial<Task> = {}) {
    const store = createStepSessionStore();
    const taskState: Task = {
      ...createTaskWithSteps({
        assignedAgentId: "agent-001",
        baseCommitSha: "abc123",
        enabledWorkflowSteps: [],
      }),
      ...overrides,
    };

    store.getTask.mockImplementation(async () => ({ ...taskState }));
    store.updateTask.mockImplementation(async (_taskId: string, updates: Record<string, unknown>) => {
      if (updates.tokenUsage !== undefined) {
        (taskState as Task).tokenUsage = updates.tokenUsage as Task["tokenUsage"];
      }
      if (updates.status !== undefined) {
        (taskState as Task).status = updates.status as Task["status"];
      }
      if (updates.error !== undefined) {
        (taskState as Task).error = updates.error as Task["error"];
      }
      return {};
    });

    return { store, taskState };
  }

  it("uses step-session path when runStepsInNewSessions is true", async () => {
    const store = createStepSessionStore();

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

    await executor.execute(createTaskWithSteps());

    // StepSessionExecutor constructor should have been called
    expect(mockedStepSessionExecutor).toHaveBeenCalled();
    // executeAll should have been called
    expect(mockExecuteAll).toHaveBeenCalledOnce();
    // createFnAgent should NOT have been called for step-session path
    expect(mockedCreateFnAgent).not.toHaveBeenCalled();
  });

  it("uses single-session path when runStepsInNewSessions is false (default)", async () => {
    const store = createMockStore();
    // Default settings: no runStepsInNewSessions
    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
    });
    store.getTask.mockResolvedValue({
      id: "FN-200",
      title: "Test",
      description: "Test",
      column: "in-progress",
      dependencies: [],
      steps: [{ name: "Step 0", status: "pending" }],
      currentStep: 0,
      log: [],
      prompt: "# test\n## Steps\n### Step 0: Preflight\n- [ ] check",
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    mockedCreateFnAgent.mockResolvedValue({
      session: {
        prompt: vi.fn().mockResolvedValue(undefined),
        dispose: vi.fn(),
        subscribe: vi.fn(),
        on: vi.fn(),
        sessionManager: { getLeafId: vi.fn().mockReturnValue("leaf-1") },
        state: {},
      },
    } as any);

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

    // Should NOT use step-session executor
    expect(mockedStepSessionExecutor).not.toHaveBeenCalled();
    // Should use the traditional single-session agent
    expect(mockedCreateFnAgent).toHaveBeenCalled();
  });

  it("success path moves task to in-review and calls onComplete", async () => {
    const store = createStepSessionStore();

    mockExecuteAll.mockResolvedValue([
      { stepIndex: 0, success: true, retries: 0 },
      { stepIndex: 1, success: true, retries: 0 },
    ]);

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

    await executor.execute(createTaskWithSteps());

    expect(mockExecuteAll).toHaveBeenCalledOnce();
    expect(store.moveTask).toHaveBeenCalledWith("FN-200", "in-review");
    expect(onComplete).toHaveBeenCalledWith(expect.objectContaining({ id: "FN-200" }));
    expect(onError).not.toHaveBeenCalled();
  });

  it("failure path marks task as failed with step error summary", async () => {
    const store = createStepSessionStore();

    mockExecuteAll.mockResolvedValue([
      { stepIndex: 0, success: true, retries: 0 },
      { stepIndex: 1, success: false, error: "compilation error", retries: 3 },
    ]);

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

    await executor.execute(createTaskWithSteps());

    expect(store.updateTask).toHaveBeenCalledWith("FN-200", {
      status: "failed",
      error: "Step 1: compilation error",
    });
    expect(store.moveTask).toHaveBeenCalledWith("FN-200", "in-review");
    expect(onError).toHaveBeenCalledWith(
      expect.objectContaining({ id: "FN-200" }),
      expect.objectContaining({ message: "Step 1: compilation error" }),
    );
    expect(onComplete).not.toHaveBeenCalled();
  });

  it("persists aggregated tokenUsage from step-session results", async () => {
    const { store } = createTokenUsageStepSessionStore();
    mockExecuteAll.mockResolvedValue([
      {
        stepIndex: 0,
        success: true,
        retries: 0,
        tokenUsage: { inputTokens: 22, outputTokens: 8, cachedTokens: 3, totalTokens: 33 },
      },
      {
        stepIndex: 1,
        success: true,
        retries: 0,
        tokenUsage: { inputTokens: 28, outputTokens: 13, cachedTokens: 1, totalTokens: 42 },
      },
    ]);

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

    const tokenUsageUpdates = store.updateTask.mock.calls
      .filter(([, updates]: [string, Record<string, unknown>]) => updates.tokenUsage)
      .map(([, updates]: [string, Record<string, unknown>]) => updates.tokenUsage as Record<string, unknown>);

    expect(tokenUsageUpdates.length).toBeGreaterThan(0);
    expect(tokenUsageUpdates[tokenUsageUpdates.length - 1]).toEqual(
      expect.objectContaining({
        inputTokens: 50,
        outputTokens: 21,
        cachedTokens: 4,
        totalTokens: 75,
        firstUsedAt: expect.any(String),
        lastUsedAt: expect.any(String),
      }),
    );
  });

  it("persists tokenUsage incrementally during step execution before in-review transition", async () => {
    const { store } = createTokenUsageStepSessionStore();

    mockedStepSessionExecutor.mockImplementationOnce(((options: any) => ({
      executeAll: vi.fn(async () => {
        options.onStepComplete(0, {
          stepIndex: 0,
          success: true,
          retries: 0,
          tokenUsage: { inputTokens: 20, outputTokens: 10, cachedTokens: 2, totalTokens: 32 },
        });
        await new Promise((resolve) => setTimeout(resolve, 0));

        options.onStepComplete(1, {
          stepIndex: 1,
          success: true,
          retries: 0,
          tokenUsage: { inputTokens: 30, outputTokens: 5, cachedTokens: 1, totalTokens: 36 },
        });
        await new Promise((resolve) => setTimeout(resolve, 0));

        return [
          {
            stepIndex: 0,
            success: true,
            retries: 0,
            tokenUsage: { inputTokens: 20, outputTokens: 10, cachedTokens: 2, totalTokens: 32 },
          },
          {
            stepIndex: 1,
            success: true,
            retries: 0,
            tokenUsage: { inputTokens: 30, outputTokens: 5, cachedTokens: 1, totalTokens: 36 },
          },
        ];
      }),
      terminateAllSessions: mockTerminateAllSessions,
      cleanup: mockCleanup,
    })) as any);

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

    const tokenUsageUpdates = store.updateTask.mock.calls
      .filter(([, updates]: [string, Record<string, unknown>]) => updates.tokenUsage)
      .map(([, updates]: [string, Record<string, unknown>]) => updates.tokenUsage as Record<string, unknown>);

    expect(tokenUsageUpdates).toEqual(
      expect.arrayContaining([
        expect.objectContaining({
          inputTokens: 20,
          outputTokens: 10,
          cachedTokens: 2,
          totalTokens: 32,
        }),
        expect.objectContaining({
          inputTokens: 50,
          outputTokens: 15,
          cachedTokens: 3,
          totalTokens: 68,
        }),
      ]),
    );
    expect(store.moveTask).toHaveBeenCalledWith("FN-200", "in-review");
  });

  it("persists task tokenUsage on step-session failure paths so partial usage is visible", async () => {
    const { store } = createTokenUsageStepSessionStore();
    mockExecuteAll.mockResolvedValue([
      {
        stepIndex: 0,
        success: true,
        retries: 0,
        tokenUsage: { inputTokens: 14, outputTokens: 6, cachedTokens: 2, totalTokens: 22 },
      },
      {
        stepIndex: 1,
        success: false,
        error: "lint failed",
        retries: 1,
        tokenUsage: { inputTokens: 7, outputTokens: 3, cachedTokens: 1, totalTokens: 11 },
      },
    ]);

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

    const tokenUsageUpdates = store.updateTask.mock.calls
      .filter(([, updates]: [string, Record<string, unknown>]) => updates.tokenUsage)
      .map(([, updates]: [string, Record<string, unknown>]) => updates.tokenUsage as Record<string, unknown>);

    expect(tokenUsageUpdates[tokenUsageUpdates.length - 1]).toEqual(
      expect.objectContaining({
        inputTokens: 21,
        outputTokens: 9,
        cachedTokens: 3,
        totalTokens: 33,
      }),
    );
  });

  it("persists tokenUsage from session.getSessionStats in single-session mode", async () => {
    const store = createMockStore();
    const taskState = createTaskWithSteps({
      description: "# test\n## Steps\n### Step 0: Preflight\n- [ ] check",
      steps: [{ name: "Step 0", status: "done" }],
      currentStep: 0,
    });

    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      runStepsInNewSessions: false,
    });
    store.getTask.mockImplementation(async () => ({ ...taskState }));
    store.updateTask.mockImplementation(async (_taskId: string, updates: Record<string, unknown>) => {
      if (updates.tokenUsage !== undefined) {
        (taskState as Task).tokenUsage = updates.tokenUsage as Task["tokenUsage"];
      }
      if (updates.status !== undefined) {
        (taskState as Task).status = updates.status as Task["status"];
      }
      return {};
    });

    const session = {
      prompt: vi.fn().mockResolvedValue(undefined),
      dispose: vi.fn(),
      subscribe: vi.fn(),
      on: vi.fn(),
      abortBash: vi.fn(),
      state: {},
      sessionManager: { getLeafId: vi.fn().mockReturnValue("leaf-1") },
      getSessionStats: vi.fn().mockReturnValue({
        tokens: {
          input: 31,
          output: 17,
          cacheRead: 5,
          cacheWrite: 2,
          total: 55,
        },
      }),
    };

    mockedCreateFnAgent.mockResolvedValue({ session } as any);

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

    expect(store.updateTask).toHaveBeenCalledWith(
      "FN-200",
      expect.objectContaining({
        tokenUsage: expect.objectContaining({
          inputTokens: 31,
          outputTokens: 17,
          cachedTokens: 7,
          totalTokens: 55,
        }),
      }),
    );
    expect(session.getSessionStats).toHaveBeenCalled();
  });

  it("persists single-session tokenUsage on failure so partial usage is visible", async () => {
    const store = createMockStore();
    const taskState = createTaskWithSteps({
      description: "# test\n## Steps\n### Step 0: Preflight\n- [ ] check",
      steps: [{ name: "Step 0", status: "pending" }],
      currentStep: 0,
    });

    store.getSettings.mockResolvedValue({
      maxConcurrent: 2,
      maxWorktrees: 4,
      pollIntervalMs: 15000,
      groupOverlappingFiles: false,
      autoMerge: false,
      runStepsInNewSessions: false,
    });
    store.getTask.mockImplementation(async () => ({ ...taskState }));
    store.updateTask.mockImplementation(async (_taskId: string, updates: Record<string, unknown>) => {
      if (updates.tokenUsage !== undefined) {
        (taskState as Task).tokenUsage = updates.tokenUsage as Task["tokenUsage"];
      }
      if (updates.status !== undefined) {
        (taskState as Task).status = updates.status as Task["status"];
      }
      if (updates.error !== undefined) {
        (taskState as Task).error = updates.error as Task["error"];
      }
      return {};
    });

    const session = {
      prompt: vi.fn().mockRejectedValue(new Error("session failed")),
      dispose: vi.fn(),
      subscribe: vi.fn(),
      on: vi.fn(),
      abortBash: vi.fn(),
      state: {},
      sessionManager: { getLeafId: vi.fn().mockReturnValue("leaf-1") },
      getSessionStats: vi.fn().mockReturnValue({
        tokens: {
          input: 12,
          output: 4,
          cacheRead: 1,
          cacheWrite: 0,
          total: 17,
        },
      }),
    };

    mockedCreateFnAgent.mockResolvedValue({ session } as any);

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

    const tokenUsageUpdates = store.updateTask.mock.calls
      .filter(([, updates]: [string, Record<string, unknown>]) => updates.tokenUsage)
      .map(([, updates]: [string, Record<string, unknown>]) => updates.tokenUsage as Record<string, unknown>);

    expect(tokenUsageUpdates[tokenUsageUpdates.length - 1]).toEqual(
      expect.objectContaining({
        inputTokens: 12,
        outputTokens: 4,
        cachedTokens: 1,
        totalTokens: 17,
      }),
    );
    expect(session.getSessionStats).toHaveBeenCalled();
  });

  it("moves task to in-review when step-session execution fails", async () => {
    const store = createStepSessionStore();

    mockExecuteAll.mockRejectedValue(new Error("Infrastructure failure"));

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

    await executor.execute(createTaskWithSteps());

    expect(store.updateTask).toHaveBeenCalledWith("FN-200", expect.objectContaining({
      status: "failed",
      error: "Infrastructure failure",
    }));
    expect(store.moveTask).toHaveBeenCalledWith("FN-200", "in-review");
    expect(onError).toHaveBeenCalled();
  });

  it("moves task to in-review when transient retries are exhausted (step-session)", async () => {
    const store = createStepSessionStore();

    mockExecuteAll.mockRejectedValue(new Error("socket hang up"));

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

    await executor.execute(createTaskWithSteps({ recoveryRetryCount: 3 }));

    expect(store.updateTask).toHaveBeenCalledWith("FN-200", {
      status: "failed",
      error: "socket hang up",
      recoveryRetryCount: null,
      nextRecoveryAt: null,
    });
    expect(store.moveTask).toHaveBeenCalledWith("FN-200", "in-review");
    expect(store.moveTask).not.toHaveBeenCalledWith("FN-200", "todo");
    expect(onError).toHaveBeenCalled();
  });

  it("pause terminates step sessions", async () => {
    const store = createStepSessionStore();
    const stuckDetector = {
      trackTask: vi.fn(),
      untrackTask: vi.fn(),
      recordProgress: vi.fn(),
    } as any;

    // Make executeAll hang until we trigger pause
    let resolveExecuteAll: () => void;
    mockExecuteAll.mockReturnValue(new Promise<void>((resolve) => {
      resolveExecuteAll = resolve;
    }));

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

    const task = createTaskWithSteps();

    // Start execution (don't await — it will hang)
    const executePromise = executor.execute(task);

    // Give it time to set up the step executor
    await new Promise((r) => setTimeout(r, 50));

    // Trigger pause
    store._trigger("task:updated", { ...task, paused: true });

    // Resolve executeAll so the execution can complete
    resolveExecuteAll!();
    await executePromise;

    expect(mockTerminateAllSessions).toHaveBeenCalled();
    expect(stuckDetector.untrackTask).toHaveBeenCalledWith("FN-200");
  });

  it("stuck-kill terminates step sessions", async () => {
    const store = createStepSessionStore();

    // Make executeAll hang
    let resolveExecuteAll: () => void;
    mockExecuteAll.mockReturnValue(new Promise<void>((resolve) => {
      resolveExecuteAll = resolve;
    }));

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

    const task = createTaskWithSteps();
    const executePromise = executor.execute(task);

    // Give it time to set up the step executor
    await new Promise((r) => setTimeout(r, 50));

    // Trigger stuck kill
    executor.markStuckAborted("FN-200");

    // Resolve executeAll so the execution can complete
    resolveExecuteAll!();
    await executePromise;

    expect(mockTerminateAllSessions).toHaveBeenCalled();
  });

  // ── FN-1461: Step-session stuck retry regression tests ─────────────────────────────────────

  it("REGRESSION: stuck-kill with bare task ID properly requeues step-session task to todo", async () => {
    const store = createStepSessionStore();

    // Make executeAll hang initially
    let resolveExecuteAll: (() => void) | null = null;
    mockExecuteAll.mockReturnValue(new Promise<void>((resolve) => {
      resolveExecuteAll = resolve;
    }));

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

    const task = createTaskWithSteps();
    const executePromise = executor.execute(task);

    // Give it time to set up the step executor
    await new Promise((r) => setTimeout(r, 50));

    // Verify step executor is registered
    expect((executor as any).activeStepExecutors.has("FN-200")).toBe(true);

    // Trigger stuck kill with bare task ID (as StuckTaskDetector.onStuck would call)
    executor.markStuckAborted("FN-200", true);

    // Resolve executeAll to complete the execution
    resolveExecuteAll!();
    await executePromise;

    // Verify: task should be marked stuck-killed and moved to todo for retry
    expect(store.updateTask).toHaveBeenCalledWith("FN-200", expect.objectContaining({
      status: "stuck-killed",
      worktree: null,
      branch: null,
    }));
    expect(store.moveTask).toHaveBeenCalledWith("FN-200", "todo", { preserveProgress: true });
  });

  it("REGRESSION: stuck-kill with exhausted budget does not requeue step-session task", async () => {
    const store = createStepSessionStore();

    let resolveExecuteAll: (() => void) | null = null;
    mockExecuteAll.mockReturnValue(new Promise<void>((resolve) => {
      resolveExecuteAll = resolve;
    }));

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

    const task = createTaskWithSteps();
    const executePromise = executor.execute(task);

    await new Promise((r) => setTimeout(r, 50));

    // Budget exhausted — should NOT requeue
    executor.markStuckAborted("FN-200", false);

    resolveExecuteAll!();
    await executePromise;

    // Should NOT move to todo or mark as stuck-killed
    expect(store.moveTask).not.toHaveBeenCalledWith("FN-200", "todo");
    expect(store.moveTask).not.toHaveBeenCalledWith("FN-200", "todo", expect.anything());
    expect(store.updateTask).not.toHaveBeenCalledWith("FN-200", expect.objectContaining({
      status: "stuck-killed",
    }));
  });

  it("REGRESSION: untrackTask called with bare task ID during pause in step-session mode", async () => {
    const store = createStepSessionStore();

    const stuckDetector = {
      trackTask: vi.fn(),
      untrackTask: vi.fn(),
      recordProgress: vi.fn(),
    } as any;

    let resolveExecuteAll: (() => void) | null = null;
    mockExecuteAll.mockReturnValue(new Promise<void>((resolve) => {
      resolveExecuteAll = resolve;
    }));

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

    const task = createTaskWithSteps();
    const executePromise = executor.execute(task);

    await new Promise((r) => setTimeout(r, 50));

    // Trigger pause
    store._trigger("task:updated", { ...task, paused: true });

    resolveExecuteAll!();
    await executePromise;

    // In step-session mode, untrackTask is called with bare task ID "FN-200"
    // But tracking was done with step-scoped keys like "FN-200-step-0"
    // BUG: This test captures that the current implementation passes bare ID,
    // which won't match the step-scoped tracking keys
    expect(stuckDetector.untrackTask).toHaveBeenCalledWith("FN-200");
    // After fix: untrackTask should also clean up any step-scoped entries
  });

  it("REGRESSION: StepSessionExecutor should pass bare task ID for recordProgress in onStepStart", async () => {
    // Note: This test verifies the expected contract between StepSessionExecutor and StuckTaskDetector.
    // In step-session mode:
    // - StepSessionExecutor tracks with step-scoped keys (e.g., "FN-200-step-0")
    // - But recordProgress should be called with the bare task ID for consistency
    // - StuckTaskDetector.recordProgress should handle this by finding the canonical task ID
    //
    // Currently, StepSessionExecutor calls recordProgress(task.id) where task.id is "FN-200"
    // But the entry was tracked with key "FN-200-step-0", so the lookup fails.
    //
    // After fix: recordProgress should handle both bare task IDs and step-scoped keys
    // by extracting the canonical task ID from step-scoped keys.
    //
    // This test is informational - the actual fix will be in StuckTaskDetector.recordProgress()
    // which should find entries by canonicalTaskId when looking up by bare task ID.
    expect(true).toBe(true); // Placeholder - real test verifies StuckTaskDetector behavior
  });

  it("cleanup called in finally block even on error", async () => {
    const store = createStepSessionStore();

    mockExecuteAll.mockRejectedValue(new Error("Fatal error"));
    mockCleanup.mockResolvedValue(undefined);

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

    await executor.execute(createTaskWithSteps());

    // cleanup should still have been called despite the error
    expect(mockCleanup).toHaveBeenCalledOnce();
  });

  it("respects semaphore for concurrency control", async () => {
    const store = createStepSessionStore();
    const sem = new AgentSemaphore(2);
    const runSpy = vi.spyOn(sem, "run");

    mockExecuteAll.mockResolvedValue([
      { stepIndex: 0, success: true, retries: 0 },
    ]);

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

    expect(runSpy).toHaveBeenCalledOnce();
    expect(sem.activeCount).toBe(0);
  });

  it("runs without semaphore when not provided", async () => {
    const store = createStepSessionStore();

    mockExecuteAll.mockResolvedValue([
      { stepIndex: 0, success: true, retries: 0 },
    ]);

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

    // Should still work fine without a semaphore
    expect(mockExecuteAll).toHaveBeenCalledOnce();
    expect(store.moveTask).toHaveBeenCalledWith("FN-200", "in-review");
  });

  it("dep-abort during step-session execution triggers cleanup", async () => {
    const store = createStepSessionStore();

    // Make executeAll hang so we can trigger dep-abort mid-execution
    let resolveExecuteAll: () => void;
    mockExecuteAll.mockReturnValue(new Promise<void>((resolve) => {
      resolveExecuteAll = resolve;
    }));

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

    const task = createTaskWithSteps();
    const executePromise = executor.execute(task);

    // Give it time to set up the step executor
    await new Promise((r) => setTimeout(r, 50));

    // Simulate dep-abort by directly triggering the fn_task_add_dep cleanup logic
    // The dep-abort flag should cause the step-session path to handle cleanup
    // We can test this by checking that when depAborted is set, cleanup is called
    // For now, just resolve and verify cleanup runs
    resolveExecuteAll!();
    await executePromise;

    // Verify cleanup was called in finally
    expect(mockCleanup).toHaveBeenCalled();
  });

  it("workflow steps run on success and block on failure", async () => {
    const store = createStepSessionStore();

    // Enable a workflow step
    store.getTask.mockResolvedValue({
      id: "FN-200",
      title: "Step-session test task",
      description: "Test task",
      column: "in-progress",
      dependencies: [],
      steps: [
        { name: "Step 0", status: "pending" },
      ],
      currentStep: 0,
      log: [],
      prompt: "# test\n## Steps\n### Step 0: Preflight\n- [ ] check",
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
      baseCommitSha: "abc123",
      enabledWorkflowSteps: ["WS-001"],
    });

    store.getWorkflowStep.mockResolvedValue({
      id: "WS-001",
      name: "Test Workflow",
      description: "Test",
      mode: "script",
      phase: "pre-merge",
      scriptName: "test-script",
      prompt: undefined,
      enabled: true,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    });

    // Steps succeed, but workflow step will fail
    mockExecuteAll.mockResolvedValue([
      { stepIndex: 0, success: true, retries: 0 },
    ]);

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

    // Use fake timers to control the setTimeout in sendTaskBackForFix
    vi.useFakeTimers();

    // Exhaust retries so workflow step failure is immediate
    await executor.execute(createTaskWithSteps({ steps: [{ name: "Step 0", status: "pending" }], workflowStepRetries: 3, enabledWorkflowSteps: ["WS-001"] }));

    // Should have called getWorkflowStep to look up the workflow step
    expect(store.getWorkflowStep).toHaveBeenCalledWith("WS-001");
    // With script mode and no scripts configured, the step should fail (script not found)
    // Task should be sent back to in-progress for remediation, NOT call onError
    expect(store.addTaskComment).toHaveBeenCalledWith(
      "FN-200",
      expect.stringContaining("Workflow step failed"),
      "agent",
    );
    // onError should NOT be called (task is being retried, not permanently failed)
    expect(onError).not.toHaveBeenCalled();

    // Advance timers to trigger the setTimeout that moves task to todo then in-progress
    vi.advanceTimersByTime(0);
    // Run any pending microtasks (the async code in setTimeout)
    await vi.runAllTimersAsync();

    // Task should move to todo then in-progress (not in-review). The
    // workflow-rerun bounce flags preserveResumeState so the worktree and
    // accumulated step progress survive the transient todo state.
    expect(store.moveTask).toHaveBeenCalledWith("FN-200", "todo", { preserveResumeState: true, preserveWorktree: true });
    expect(store.moveTask).toHaveBeenCalledWith("FN-200", "in-progress");

    vi.useRealTimers();
  });

  it("onStepStart callback updates step status to in-progress", async () => {
    const store = createStepSessionStore();
    store.updateStep.mockResolvedValue({} as any);

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

    // Capture the StepSessionExecutor constructor options
    expect(mockedStepSessionExecutor).toHaveBeenCalled();
    const ctorOptions = mockedStepSessionExecutor.mock.calls[mockedStepSessionExecutor.mock.calls.length - 1][0];

    // Invoke the onStepStart callback
    ctorOptions.onStepStart!(0);

    // Should update step status in store
    expect(store.updateStep).toHaveBeenCalledWith("FN-200", 0, "in-progress");
  });

  it("onStepComplete callback updates step status to done on success", async () => {
    const store = createStepSessionStore();
    store.updateStep.mockResolvedValue({} as any);

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

    const ctorOptions = mockedStepSessionExecutor.mock.calls[mockedStepSessionExecutor.mock.calls.length - 1][0];

    ctorOptions.onStepComplete!(0, { stepIndex: 0, success: true, retries: 0 });

    expect(store.updateStep).toHaveBeenCalledWith("FN-200", 0, "done");
  });

  it("onStepComplete callback updates step status to skipped on failure", async () => {
    const store = createStepSessionStore();
    store.updateStep.mockResolvedValue({} as any);

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

    const ctorOptions = mockedStepSessionExecutor.mock.calls[mockedStepSessionExecutor.mock.calls.length - 1][0];

    ctorOptions.onStepComplete!(1, { stepIndex: 1, success: false, retries: 3 });

    expect(store.updateStep).toHaveBeenCalledWith("FN-200", 1, "skipped");
  });

  it("step status update errors do not block execution", async () => {
    const store = createStepSessionStore();
    store.updateStep.mockRejectedValue(new Error("DB error"));

    const executor = new TaskExecutor(store, "/tmp/test", {});
    // Should not throw even when updateStep rejects
    await executor.execute(createTaskWithSteps());

    const ctorOptions = mockedStepSessionExecutor.mock.calls[mockedStepSessionExecutor.mock.calls.length - 1][0];

    // Invoking callbacks should not throw
    expect(() => ctorOptions.onStepStart!(0)).not.toThrow();
    expect(() => ctorOptions.onStepComplete!(0, { stepIndex: 0, success: true, retries: 0 })).not.toThrow();
  });
});