/**
 * End-to-end integration tests for the autonomous operation chain.
 * Tests all 8 steps from IMPLEMENTATION_PLAN.md v2:
 *
 * Step 1: CEO role detection fix
 * Step 2: CEO phased prompts + pending approvals + credential escalation
 * Step 3: Deferred wake queue
 * Step 4: Hire approval wake
 * Step 5: Task status + comment wake propagation
 * Step 6: Run failure escalation
 * Step 7: Worker crash recovery
 * Step 8: Wake reason injection into prompt
 */

import { mkdtemp, rm } from "node:fs/promises";
import { join } from "node:path";
import { tmpdir } from "node:os";
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import { AppDatabase } from "../../src/main/database";
import { buildSystemPrompt, buildTaskPrompt } from "../../src/main/prompt-builder";
import type { AgentRecord, ApprovalRecord, TaskRecord } from "../../src/shared/types";

const tempDirs: string[] = [];

async function createTempDir(prefix: string) {
  const dir = await mkdtemp(join(tmpdir(), prefix));
  tempDirs.push(dir);
  return dir;
}

let db: AppDatabase;
let companyId: string;
let workspaceId: string;

beforeEach(async () => {
  const profileDir = await createTempDir("agentcompany-chain-test-");
  db = new AppDatabase(profileDir);
  db.init();

  companyId = db.saveCompany({
    name: "Autonomous Test Corp",
    description: "Test company for autonomous chain",
    status: "active",
  });

  workspaceId = db.saveWorkspace({
    companyId,
    name: "Primary",
    localPath: profileDir,
    repoUrl: "https://example.com/repo.git",
    repoRef: "main",
    isPrimary: true,
  });
});

afterEach(async () => {
  db?.close();
  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
});

function createAgent(overrides: Partial<Parameters<typeof db.saveAgent>[0]> = {}): string {
  return db.saveAgent({
    companyId,
    name: "TestAgent",
    role: "CEO",
    title: "Test",
    status: "idle",
    reportsTo: null,
    connectorId: "codex_local",
    workspaceId,
    model: null,
    capabilities: "Test capabilities",
    budgetMonthlyUsd: 200,
    ...overrides,
  });
}

function buildCtx(overrides: Record<string, unknown> = {}): Parameters<typeof buildSystemPrompt>[0] {
  const agent = db.getAgent(overrides.agentId as string ?? createAgent());
  return {
    agent,
    apiUrl: "http://127.0.0.1:3000",
    apiKey: "test-key",
    runId: "test-run-id",
    task: null,
    companyName: "Autonomous Test Corp",
    goals: [],
    projects: [],
    directReports: overrides.directReports as AgentRecord[] ?? [],
    chainOfCommand: overrides.chainOfCommand as AgentRecord[] ?? [],
    assignedTasks: [],
    allAgents: [],
    pendingApprovals: overrides.pendingApprovals as ApprovalRecord[] ?? [],
    tasksAwaitingReview: overrides.tasksAwaitingReview as TaskRecord[] ?? [],
    wakeReason: overrides.wakeReason as string | null ?? null,
    allTasks: [],
    recentComments: [],
    companyDescription: "",
    socialAccounts: [],
    ...overrides,
  } as Parameters<typeof buildSystemPrompt>[0];
}

// ─── Step 1: CEO Role Detection ─────────────────────────────────────

describe("Step 1: CEO role detection", () => {
  it("identifies CEO when chainOfCommand is empty, even with no direct reports", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const ctx = buildCtx({
      agentId: ceoId,
      directReports: [], // no reports yet!
      chainOfCommand: [], // top-level
    });

    const prompt = buildSystemPrompt(ctx);

    // CEO should NOT get IC instructions
    expect(prompt).not.toContain("Individual Contributor");
    // CEO should get executive instructions (Phase 0: Team Building)
    expect(prompt).toContain("CEO");
    expect(prompt).toContain("Team Building");
  });

  it("identifies manager when has reports and has chain of command", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const managerId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId });
    const ceo = db.getAgent(ceoId);
    const icId = createAgent({ name: "IC", role: "Engineer", reportsTo: managerId });
    const ic = db.getAgent(icId);

    const ctx = buildCtx({
      agentId: managerId,
      directReports: [ic],
      chainOfCommand: [ceo], // reports to CEO
    });

    const prompt = buildSystemPrompt(ctx);
    expect(prompt).toContain("Operating Instructions (Manager)");
    expect(prompt).not.toContain("Individual Contributor");
    expect(prompt).not.toContain("Executive / CEO");
  });

  it("identifies IC when has chain of command and no direct reports", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const ceo = db.getAgent(ceoId);
    const icId = createAgent({ name: "Dev", role: "Engineer", reportsTo: ceoId });

    const ctx = buildCtx({
      agentId: icId,
      directReports: [],
      chainOfCommand: [ceo],
    });

    const prompt = buildSystemPrompt(ctx);
    expect(prompt).toContain("Individual Contributor");
    expect(prompt).not.toContain("Operating Instructions (Manager)");
  });
});

// ─── Step 2: CEO Phased Prompts ─────────────────────────────────────

describe("Step 2: CEO phased prompts", () => {
  it("Phase 0: shows team building instructions when no reports at all", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });

    const ctx = buildCtx({
      agentId: ceoId,
      directReports: [], // truly no reports
      chainOfCommand: [],
      pendingApprovals: [],
    });

    const prompt = buildSystemPrompt(ctx);
    expect(prompt).toContain("Team Building Phase");
    expect(prompt).toContain("Design the Organization Structure");
    expect(prompt).toContain("Submit Org Strategy for Approval");
    expect(prompt).not.toContain("Awaiting Org Approval");
    expect(prompt).not.toContain("Goal Decomposition");
  });

  it("Phase 0.5: shows awaiting hire approvals when pending_approval hires exist but no org approval", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });

    const hireId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId, status: "pending_approval" as "idle" });
    const hire = db.getAgent(hireId);

    const ctx = buildCtx({
      agentId: ceoId,
      directReports: [hire],
      chainOfCommand: [],
      pendingApprovals: [],
    });

    const prompt = buildSystemPrompt(ctx);
    expect(prompt).toContain("Awaiting Hire Approvals");
    expect(prompt).not.toContain("Team Building Phase");
    expect(prompt).not.toContain("Goal Decomposition");
  });

  it("Phase 1: shows awaiting org approval when pending approve_ceo_strategy exists", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });

    const ctx = buildCtx({
      agentId: ceoId,
      directReports: [],
      chainOfCommand: [],
      pendingApprovals: [
        {
          id: "approval-1",
          companyId,
          type: "approve_ceo_strategy",
          state: "pending",
          payloadSummary: "Org structure: CEO + CTO + CMO",
          impactSummary: "Team of 3",
          requestedByAgentId: ceoId,
          relatedTaskId: null,
          decisionNote: "",
          createdAt: new Date().toISOString(),
          updatedAt: new Date().toISOString(),
        } as ApprovalRecord,
      ],
    });

    const prompt = buildSystemPrompt(ctx);
    expect(prompt).toContain("Awaiting Org Approval");
    expect(prompt).not.toContain("Team Building Phase");
    expect(prompt).not.toContain("Goal Decomposition");
  });

  it("Phase 2: shows normal executive instructions when active reports and no pending org approval", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const ctoId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId, status: "idle" });
    const cto = db.getAgent(ctoId);

    const ctx = buildCtx({
      agentId: ceoId,
      directReports: [cto],
      chainOfCommand: [],
      pendingApprovals: [],
    });

    const prompt = buildSystemPrompt(ctx);
    expect(prompt).toContain("Executive / CEO");
    expect(prompt).toContain("Goal Decomposition");
    expect(prompt).toContain("Delegation");
    expect(prompt).toContain("Unblock & Coordinate");
    expect(prompt).not.toContain("Team Building Phase");
    expect(prompt).not.toContain("Awaiting Org Approval");
  });

  it("includes pending approvals section in prompt", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const ctoId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId, status: "idle" });
    const cto = db.getAgent(ctoId);

    const ctx = buildCtx({
      agentId: ceoId,
      directReports: [cto],
      chainOfCommand: [],
      pendingApprovals: [
        {
          id: "approval-x",
          companyId,
          type: "secret_access",
          state: "pending",
          payloadSummary: "Need Twitter API keys",
          impactSummary: "",
          requestedByAgentId: ceoId,
          relatedTaskId: null,
          decisionNote: "",
          createdAt: new Date().toISOString(),
          updatedAt: new Date().toISOString(),
        } as ApprovalRecord,
      ],
    });

    const prompt = buildSystemPrompt(ctx);
    expect(prompt).toContain("Pending Approvals");
    expect(prompt).toContain("Need Twitter API keys");
  });

  it("Manager prompt includes credential escalation guidance", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const ceo = db.getAgent(ceoId);
    const managerId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId });
    const icId = createAgent({ name: "Dev", role: "Engineer", reportsTo: managerId });
    const ic = db.getAgent(icId);

    const ctx = buildCtx({
      agentId: managerId,
      directReports: [ic],
      chainOfCommand: [ceo],
    });

    const prompt = buildSystemPrompt(ctx);
    expect(prompt).toContain("Break down work and delegate it");
  });

  it("IC prompt includes credential escalation guidance", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const ceo = db.getAgent(ceoId);
    const icId = createAgent({ name: "Dev", role: "Engineer", reportsTo: ceoId });

    const ctx = buildCtx({
      agentId: icId,
      directReports: [],
      chainOfCommand: [ceo],
    });

    const prompt = buildSystemPrompt(ctx);
    expect(prompt).toContain("Your manager is auto-notified and will help");
    expect(prompt).toContain("explain what API key/account you need");
  });
});

// ─── Step 3: Deferred Wake Queue ────────────────────────────────────

describe("Step 3: Deferred wake queue (database)", () => {
  it("enqueue and consume pending wakes", () => {
    const agentId = createAgent({ name: "TestAgent" });

    // Enqueue two wakes for the same busy agent. The queue deduplicates by agent
    // so only the freshest trigger is retained.
    db.enqueuePendingWake(companyId, agentId, "subtask_completed");
    db.enqueuePendingWake(companyId, agentId, "comment");

    // Consume returns the latest retained wake
    const wakes = db.consumePendingWakes(agentId);
    expect(wakes).toHaveLength(1);
    expect(wakes[0].trigger).toBe("comment");
    expect(wakes[0].companyId).toBe(companyId);

    // Second consume returns empty (they've been deleted)
    const wakes2 = db.consumePendingWakes(agentId);
    expect(wakes2).toHaveLength(0);
  });

  it("returns empty array when no pending wakes exist", () => {
    const agentId = createAgent({ name: "TestAgent" });
    const wakes = db.consumePendingWakes(agentId);
    expect(wakes).toHaveLength(0);
  });

  it("does not consume wakes for other agents", () => {
    const agent1 = createAgent({ name: "Agent1" });
    const agent2 = createAgent({ name: "Agent2" });

    db.enqueuePendingWake(companyId, agent1, "comment");
    db.enqueuePendingWake(companyId, agent2, "subtask_completed");

    const wakes1 = db.consumePendingWakes(agent1);
    expect(wakes1).toHaveLength(1);
    expect(wakes1[0].trigger).toBe("comment");

    // Agent2's wake should still be there
    const wakes2 = db.consumePendingWakes(agent2);
    expect(wakes2).toHaveLength(1);
    expect(wakes2[0].trigger).toBe("subtask_completed");
  });
});

// ─── Step 4: Hire Approval Wake ─────────────────────────────────────

describe("Step 4: Hire approval + decideApproval", () => {
  it("decideApproval sets hired agent to idle when approved", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const hireId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId, status: "pending_approval" as "idle" });

    const approvalId = db.requestApproval({
      companyId,
      requestedByAgentId: ceoId,
      type: "hire_agent",
      payloadSummary: "Hire CTO",
      impactSummary: "Test impact",
      payloadJson: JSON.stringify({ agentId: hireId }),
    });

    db.decideApproval({
      approvalId,
      state: "approved",
      decisionNote: "Approved by board",
    });

    const updatedAgent = db.getAgent(hireId);
    expect(updatedAgent.status).toBe("idle");
  });

  it("decideApproval sets hired agent to terminated when rejected", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const hireId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId, status: "pending_approval" as "idle" });

    const approvalId = db.requestApproval({
      companyId,
      requestedByAgentId: ceoId,
      type: "hire_agent",
      payloadSummary: "Hire CTO",
      impactSummary: "Test impact",
      payloadJson: JSON.stringify({ agentId: hireId }),
    });

    db.decideApproval({
      approvalId,
      state: "rejected",
      decisionNote: "Not needed",
    });

    const updatedAgent = db.getAgent(hireId);
    expect(updatedAgent.status).toBe("terminated");
  });

  it("getApprovalRecord includes payloadJson", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const hireId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId, status: "pending_approval" as "idle" });
    const approvalId = db.requestApproval({
      companyId,
      requestedByAgentId: ceoId,
      type: "hire_agent",
      payloadSummary: "Hire CTO",
      impactSummary: "Test",
      payloadJson: JSON.stringify({ agentId: hireId, config: { connector: "codex_local" } }),
    });

    const approval = db.getApprovalRecord(approvalId);
    expect(approval.payloadJson).toBeTruthy();
    const payload = JSON.parse(approval.payloadJson!);
    expect(payload.agentId).toBe(hireId);
  });
});

// ─── Step 5: Task Status + Comment Wake Propagation ─────────────────

describe("Step 5: Task status + comment wake propagation", () => {
  it("getChainOfCommand returns correct hierarchy", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO", reportsTo: null });
    const ctoId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId });
    const icId = createAgent({ name: "Dev", role: "Engineer", reportsTo: ctoId });

    const chain = db.getChainOfCommand(icId);
    expect(chain).toHaveLength(2);
    expect(chain[0].id).toBe(ctoId); // immediate manager
    expect(chain[1].id).toBe(ceoId); // top level
  });

  it("getChainOfCommand handles circular references safely", () => {
    // Create a potential cycle (shouldn't happen in practice, but guard against it)
    const agent1 = createAgent({ name: "Agent1" });
    // agent1 reports to no one (CEO), so chain should be empty
    const chain = db.getChainOfCommand(agent1);
    expect(chain).toHaveLength(0);
  });

  it("task tree supports parent-child relationships", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const ctoId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId });

    const parentTaskId = db.saveTask({
      companyId,
      title: "Build feature X",
      description: "Top-level task",
      assigneeAgentId: ctoId,
      workspaceId,
      priority: "high",
      status: "in_progress",
    });

    const childTaskId = db.saveTask({
      companyId,
      title: "Implement module A",
      description: "Subtask",
      assigneeAgentId: ctoId,
      parentId: parentTaskId,
      workspaceId,
      priority: "medium",
      status: "todo",
    });

    const childTask = db.getTask(childTaskId);
    expect(childTask.parentId).toBe(parentTaskId);

    const parentTask = db.getTask(parentTaskId);
    expect(parentTask.assigneeAgentId).toBe(ctoId);
  });
});

// ─── Step 6: Run Failure Escalation ─────────────────────────────────

describe("Step 6: Run failure escalation (database layer)", () => {
  it("finishRun marks run as failed and returns outcome", () => {
    const agentId = createAgent({ name: "IC", role: "Engineer" });
    const taskId = db.saveTask({
      companyId,
      title: "Failing task",
      description: "Will fail",
      assigneeAgentId: agentId,
      workspaceId,
      priority: "medium",
      status: "in_progress",
    });

    const run = db.createRun({
      companyId,
      taskId,
      agentId,
      workspaceId,
      connectorId: "codex_local",
    });

    db.markRunStatus(run.id, "running", "Started");

    const outcome = db.finishRun({
      runId: run.id,
      status: "failed",
      summary: null,
      errorMessage: "Process crashed",
      exitCode: 1,
      signal: null,
      model: "gpt-5-codex",
      sessionDisplayId: null,
      costUsd: 0.5,
      unattributedCost: false,
    });

    expect(outcome.budgetHardStopped).toBe(false);

    const snapshot = db.listSnapshot();
    const finishedRun = snapshot.runs.find((r) => r.id === run.id);
    expect(finishedRun?.status).toBe("failed");
    expect(finishedRun?.errorMessage).toBe("Process crashed");
  });

  it("getChainOfCommand returns manager for failure escalation", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const ctoId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId });
    const icId = createAgent({ name: "Dev", role: "Engineer", reportsTo: ctoId });

    const chain = db.getChainOfCommand(icId);
    // First in chain is the immediate manager (CTO)
    expect(chain.length).toBeGreaterThan(0);
    expect(chain[0].name).toBe("CTO");
  });
});

// ─── Step 7: Worker Crash Recovery ──────────────────────────────────

describe("Step 7: Worker crash recovery (database layer)", () => {
  it("interruptStaleRuns clears running and queued runs on init", async () => {
    const agentId = createAgent({ name: "Agent" });
    const taskId = db.saveTask({
      companyId,
      title: "In-progress task",
      description: "Running when crash happened",
      assigneeAgentId: agentId,
      workspaceId,
      priority: "medium",
      status: "in_progress",
    });

    const run = db.createRun({
      companyId,
      taskId,
      agentId,
      workspaceId,
      connectorId: "codex_local",
    });

    db.markRunStatus(run.id, "running", "Started");

    // Verify it's running
    let snapshot = db.listSnapshot();
    expect(snapshot.runs.find((r) => r.id === run.id)?.status).toBe("running");

    // Simulate app restart — close and re-init
    db.close();

    const profileDir = tempDirs[tempDirs.length - 1]!;
    db = new AppDatabase(profileDir);
    db.init(); // This calls interruptStaleRuns()

    snapshot = db.listSnapshot();
    const recoveredRun = snapshot.runs.find((r) => r.id === run.id);
    expect(recoveredRun?.status).toBe("interrupted");
  });

  it("finishRun can mark interrupted runs from crash recovery", () => {
    const agentId = createAgent({ name: "Agent" });
    const taskId = db.saveTask({
      companyId,
      title: "Crash recovery task",
      description: "Test",
      assigneeAgentId: agentId,
      workspaceId,
      priority: "medium",
      status: "in_progress",
    });

    const run = db.createRun({
      companyId,
      taskId,
      agentId,
      workspaceId,
      connectorId: "codex_local",
    });

    db.markRunStatus(run.id, "running", "Started");

    // Simulate crash recovery - mark as interrupted
    db.finishRun({
      runId: run.id,
      status: "interrupted",
      summary: "Worker process crashed.",
      errorMessage: "Worker process exited unexpectedly.",
      exitCode: 1,
      signal: null,
      model: null,
      sessionDisplayId: null,
      costUsd: null,
      unattributedCost: true,
    });

    const snapshot = db.listSnapshot();
    const recovered = snapshot.runs.find((r) => r.id === run.id);
    expect(recovered?.status).toBe("interrupted");
    expect(recovered?.errorMessage).toBe("Worker process exited unexpectedly.");
  });
});

// ─── Step 8: Wake Reason Injection ──────────────────────────────────

describe("Step 8: Wake reason injection", () => {
  it("includes wake reason section for non-timer triggers", () => {
    const agentId = createAgent({ name: "CTO", role: "CTO" });
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const ceo = db.getAgent(ceoId);

    const ctx = buildCtx({
      agentId,
      chainOfCommand: [ceo],
      wakeReason: "subtask_completed",
    });

    const prompt = buildTaskPrompt(ctx);
    expect(prompt).toContain("Wake Reason");
    expect(prompt).toContain("subtask you delegated has been completed");
  });

  it("includes wake reason for timer triggers", () => {
    const agentId = createAgent({ name: "Agent" });

    const ctx = buildCtx({
      agentId,
      wakeReason: "timer",
    });

    const prompt = buildTaskPrompt(ctx);
    expect(prompt).toContain("Wake Reason");
    expect(prompt).toContain("Regular heartbeat check-in");
  });

  it("includes wake reason for manual triggers", () => {
    const agentId = createAgent({ name: "Agent" });

    const ctx = buildCtx({
      agentId,
      wakeReason: "manual",
    });

    const prompt = buildTaskPrompt(ctx);
    expect(prompt).toContain("Wake Reason");
    expect(prompt).toContain("manually triggered by the human operator");
  });

  it("includes correct message for each wake reason", () => {
    const agentId = createAgent({ name: "Agent" });

    const reasons: Record<string, string> = {
      assignment: "You have been assigned a new task",
      goal_activated: "goal you own has been activated",
      approval_resolved: "approval you requested has been decided",
      subtask_completed: "subtask you delegated has been completed",
      comment: "new comment has been posted",
      report_blocked: "reports is blocked",
      report_failed: "reports has failed",
    };

    for (const [reason, expectedText] of Object.entries(reasons)) {
      const ctx = buildCtx({
        agentId,
        wakeReason: reason,
      });
      const prompt = buildTaskPrompt(ctx);
      expect(prompt).toContain("Wake Reason");
      expect(prompt).toContain(expectedText);
    }
  });

  it("handles unknown wake reason gracefully", () => {
    const agentId = createAgent({ name: "Agent" });

    const ctx = buildCtx({
      agentId,
      wakeReason: "custom_trigger_xyz",
    });

    const prompt = buildTaskPrompt(ctx);
    expect(prompt).toContain("Wake Reason");
    expect(prompt).toContain("Trigger: custom_trigger_xyz");
  });

  it("includes wake reason before task description", () => {
    const agentId = createAgent({ name: "Agent" });
    const taskId = db.saveTask({
      companyId,
      title: "Do the thing",
      description: "Test task",
      assigneeAgentId: agentId,
      workspaceId,
      priority: "medium",
      status: "todo",
    });
    const task = db.getTask(taskId);

    const ctx = buildCtx({
      agentId,
      task,
      wakeReason: "assignment",
    });

    const prompt = buildTaskPrompt(ctx);
    const wakeIndex = prompt.indexOf("Wake Reason");
    const taskIndex = prompt.indexOf("Your immediate task");
    expect(wakeIndex).toBeGreaterThan(-1);
    expect(taskIndex).toBeGreaterThan(-1);
    expect(wakeIndex).toBeLessThan(taskIndex);
  });
});

// ─── E2E: Full Autonomous Chain Flow ────────────────────────────────

describe("E2E: Full autonomous CEO cold start flow", () => {
  it("simulates complete chain: CEO creation → team build → org approval → delegation → completion", () => {
    // 1. Create CEO agent
    const ceoId = createAgent({ name: "Atlas", role: "CEO", status: "idle" });

    // CEO has no team yet → Phase 0
    const phase0Ctx = buildCtx({
      agentId: ceoId,
      directReports: [],
      chainOfCommand: [],
      pendingApprovals: [],
    });
    const phase0Prompt = buildSystemPrompt(phase0Ctx);
    expect(phase0Prompt).toContain("Team Building Phase");

    // 2. CEO submits hire requests
    const ctoId = createAgent({ name: "Nova", role: "CTO", reportsTo: ceoId, status: "pending_approval" as "idle" });
    const cmoId = createAgent({ name: "Aria", role: "CMO", reportsTo: ceoId, status: "pending_approval" as "idle" });

    // 3. CEO submits org strategy approval
    const orgApprovalId = db.requestApproval({
      companyId,
      requestedByAgentId: ceoId,
      type: "approve_ceo_strategy",
      payloadSummary: "Org: CEO + CTO + CMO",
      impactSummary: "3-person team",
    });

    // CEO now in Phase 1
    const ctoRecord = db.getAgent(ctoId);
    const cmoRecord = db.getAgent(cmoId);
    const phase1Ctx = buildCtx({
      agentId: ceoId,
      directReports: [ctoRecord, cmoRecord],
      chainOfCommand: [],
      pendingApprovals: [{
        id: orgApprovalId,
        companyId,
        type: "approve_ceo_strategy",
        state: "pending",
        payloadSummary: "Org: CEO + CTO + CMO",
        impactSummary: "3-person team",
        requestedByAgentId: ceoId,
        relatedTaskId: null,
        decisionNote: "",
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      } as ApprovalRecord],
    });
    const phase1Prompt = buildSystemPrompt(phase1Ctx);
    expect(phase1Prompt).toContain("Awaiting Org Approval");

    // 4. Board approves hires
    const hireApprovalCTO = db.requestApproval({
      companyId,
      requestedByAgentId: ceoId,
      type: "hire_agent",
      payloadSummary: "Hire Nova as CTO",
      impactSummary: "Test",
      payloadJson: JSON.stringify({ agentId: ctoId }),
    });
    db.decideApproval({ approvalId: hireApprovalCTO, state: "approved", decisionNote: "Approved" });

    const hireApprovalCMO = db.requestApproval({
      companyId,
      requestedByAgentId: ceoId,
      type: "hire_agent",
      payloadSummary: "Hire Aria as CMO",
      impactSummary: "Test",
      payloadJson: JSON.stringify({ agentId: cmoId }),
    });
    db.decideApproval({ approvalId: hireApprovalCMO, state: "approved", decisionNote: "Approved" });

    // Agents now idle
    expect(db.getAgent(ctoId).status).toBe("idle");
    expect(db.getAgent(cmoId).status).toBe("idle");

    // 5. Board approves org strategy
    db.decideApproval({ approvalId: orgApprovalId, state: "approved", decisionNote: "Go ahead" });

    // 6. CEO now in Phase 2
    const updatedCto = db.getAgent(ctoId);
    const updatedCmo = db.getAgent(cmoId);
    const phase2Ctx = buildCtx({
      agentId: ceoId,
      directReports: [updatedCto, updatedCmo],
      chainOfCommand: [],
      pendingApprovals: [], // all approved now
    });
    const phase2Prompt = buildSystemPrompt(phase2Ctx);
    expect(phase2Prompt).toContain("Executive / CEO");
    expect(phase2Prompt).toContain("Goal Decomposition");
    expect(phase2Prompt).toContain("Delegation");

    // 7. Verify hierarchical chain
    const ctoChain = db.getChainOfCommand(ctoId);
    expect(ctoChain).toHaveLength(1);
    expect(ctoChain[0].id).toBe(ceoId);

    // 8. Create task tree
    const projectId = db.saveProject({
      companyId,
      name: "Launch MVP",
      description: "Build and launch MVP",
      goalId: null,
      leadAgentId: ctoId,
      status: "in_progress",
    });

    const parentTaskId = db.saveTask({
      companyId,
      title: "Build backend",
      description: "Implement API",
      assigneeAgentId: ctoId,
      projectId,
      workspaceId,
      priority: "high",
      status: "in_progress",
    });

    // CTO creates subtask for IC (would be done via API)
    const icId = createAgent({ name: "Dev", role: "Engineer", reportsTo: ctoId, status: "idle" });
    const subtaskId = db.saveTask({
      companyId,
      title: "Implement auth",
      description: "JWT auth",
      assigneeAgentId: icId,
      parentId: parentTaskId,
      projectId,
      workspaceId,
      priority: "medium",
      status: "todo",
    });

    // Verify parent-child relationship
    const subtask = db.getTask(subtaskId);
    expect(subtask.parentId).toBe(parentTaskId);

    // 9. Deferred wake test: enqueue wake while IC is busy
    db.enqueuePendingWake(companyId, icId, "comment");
    const pendingWakes = db.consumePendingWakes(icId);
    expect(pendingWakes).toHaveLength(1);
    expect(pendingWakes[0].trigger).toBe("comment");

    // 10. Verify IC prompt has correct wake reason
    const icPromptCtx = buildCtx({
      agentId: icId,
      task: subtask,
      chainOfCommand: [db.getAgent(ctoId), db.getAgent(ceoId)],
      wakeReason: "assignment",
    });
    const icPrompt = buildTaskPrompt(icPromptCtx);
    expect(icPrompt).toContain("Wake Reason");
    expect(icPrompt).toContain("You have been assigned a new task");
    expect(icPrompt).toContain("Implement auth");
  });
});

// ─── E2E: Deferred Wake + Run Lifecycle ─────────────────────────────

describe("E2E: Deferred wake queue with run lifecycle", () => {
  it("wake enqueue + run finish + consume cycle", () => {
    const agentId = createAgent({ name: "Agent" });

    // Simulate: agent is running, wakes come in. Only the freshest reason is
    // retained so the agent gets one consolidated follow-up wake.
    db.enqueuePendingWake(companyId, agentId, "subtask_completed");
    db.enqueuePendingWake(companyId, agentId, "comment");
    db.enqueuePendingWake(companyId, agentId, "report_blocked");

    // Agent finishes run → consume pending wakes
    const wakes = db.consumePendingWakes(agentId);
    expect(wakes).toHaveLength(1);
    expect(wakes[0].trigger).toBe("report_blocked");

    // All consumed
    expect(db.consumePendingWakes(agentId)).toHaveLength(0);
  });
});

// ─── E2E: Blocked Escalation Chain ──────────────────────────────────

describe("E2E: Blocked escalation through org hierarchy", () => {
  it("getChainOfCommand provides escalation path for blocked IC", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const ctoId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId });
    const icId = createAgent({ name: "Dev", role: "Engineer", reportsTo: ctoId });

    // When IC marks task blocked, we need to find its manager
    const chain = db.getChainOfCommand(icId);
    expect(chain[0].id).toBe(ctoId); // immediate manager gets woken

    // When CTO needs to escalate further
    const ctoChain = db.getChainOfCommand(ctoId);
    expect(ctoChain[0].id).toBe(ceoId);
  });
});

// ─── Adversarial Review Fix Tests ───────────────────────────────────

describe("Review Fix: CEO phase ordering edge case", () => {
  it("shows awaiting hire approvals when org strategy approved first but hires still pending", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    // Hires submitted but not yet approved
    const hireId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId, status: "pending_approval" as "idle" });
    const hire = db.getAgent(hireId);

    // Org strategy already approved (not in pendingApprovals), but hires still pending
    const ctx = buildCtx({
      agentId: ceoId,
      directReports: [hire], // only pending_approval
      chainOfCommand: [],
      pendingApprovals: [], // org strategy already resolved
    });

    const prompt = buildSystemPrompt(ctx);
    // Should NOT get Phase 0 (team building) — hires are already submitted
    expect(prompt).not.toContain("Team Building Phase");
    // Should get the awaiting hire approvals phase
    expect(prompt).toContain("Awaiting Hire Approvals");
  });

  it("moves to Phase 2 once hires are approved (no pending org approval)", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const ctoId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId, status: "idle" });
    const cto = db.getAgent(ctoId);

    const ctx = buildCtx({
      agentId: ceoId,
      directReports: [cto], // active report
      chainOfCommand: [],
      pendingApprovals: [],
    });

    const prompt = buildSystemPrompt(ctx);
    expect(prompt).toContain("Executive / CEO");
    expect(prompt).not.toContain("Awaiting Hire Approvals");
    expect(prompt).not.toContain("Team Building Phase");
  });
});

describe("Review Fix: Org gate consistency (revision_requested)", () => {
  it("org-strategy revision_requested blocks the CEO in Phase 1", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });

    const ctx = buildCtx({
      agentId: ceoId,
      directReports: [],
      chainOfCommand: [],
      pendingApprovals: [
        {
          id: "approval-rev",
          companyId,
          type: "approve_ceo_strategy",
          state: "revision_requested",
          payloadSummary: "Org plan needs changes",
          impactSummary: "",
          requestedByAgentId: ceoId,
          relatedTaskId: null,
          decisionNote: "Please add a CPO",
          createdAt: new Date().toISOString(),
          updatedAt: new Date().toISOString(),
        } as ApprovalRecord,
      ],
    });

    const prompt = buildSystemPrompt(ctx);
    expect(prompt).toContain("Awaiting Org Approval");
    expect(prompt).toContain("revision_requested");
  });
});

describe("Review Fix: Rejected approval wakes agent", () => {
  it("decideApproval with rejected state still triggers wake (tested via DB)", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });

    const approvalId = db.requestApproval({
      companyId,
      requestedByAgentId: ceoId,
      type: "approve_ceo_strategy",
      payloadSummary: "Org plan",
      impactSummary: "test",
    });

    db.decideApproval({
      approvalId,
      state: "rejected",
      decisionNote: "Not ready",
    });

    // Verify approval state
    const approval = db.getApprovalRecord(approvalId);
    expect(approval.state).toBe("rejected");
    // The IPC handler in index.ts now wakes on rejected too —
    // we verify the DB layer works; the wakeAgentIfPossible call is in index.ts
  });
});

describe("Review Fix: Root task completion notification", () => {
  it("root task (no parentId) should still have org hierarchy for manager lookup", () => {
    const ceoId = createAgent({ name: "CEO", role: "CEO" });
    const ctoId = createAgent({ name: "CTO", role: "CTO", reportsTo: ceoId });

    // CTO has a root-level task (no parentId)
    const taskId = db.saveTask({
      companyId,
      title: "Standalone task from CEO",
      description: "No parent",
      assigneeAgentId: ctoId,
      workspaceId,
      priority: "high",
      status: "done",
    });

    const task = db.getTask(taskId);
    expect(task.parentId).toBeNull();

    // CTO's chain of command includes CEO — so api-server can wake CEO on completion
    const chain = db.getChainOfCommand(ctoId);
    expect(chain).toHaveLength(1);
    expect(chain[0].id).toBe(ceoId);
  });
});

// ── Automation Rules CRUD ──────────────────────────────────────────────

describe("Automation Rules CRUD", () => {
  it("creates, reads, toggles, and deletes an automation rule", () => {
    const ruleId = db.saveAutomationRule({
      companyId,
      name: "Auto-escalate blocked tasks",
      description: "When a task is blocked, notify the manager",
      trigger: "task_blocked",
      conditionsJson: JSON.stringify({ department: "engineering" }),
      action: "escalate_to_manager",
      actionConfigJson: JSON.stringify({ message: "Task blocked" }),
      sourceDepartment: "engineering",
      targetDepartment: "executive",
      priority: 80,
      status: "active",
    });

    expect(ruleId).toBeTruthy();

    // Rule appears in snapshot
    const snapshot = db.listSnapshot();
    const rule = snapshot.automationRules.find(r => r.id === ruleId);
    expect(rule).toBeTruthy();
    expect(rule!.name).toBe("Auto-escalate blocked tasks");
    expect(rule!.trigger).toBe("task_blocked");
    expect(rule!.action).toBe("escalate_to_manager");
    expect(rule!.status).toBe("active");
    expect(rule!.priority).toBe(80);
    expect(rule!.executionCount).toBe(0);

    // Toggle to paused
    db.toggleAutomationRule(ruleId, companyId, "paused");
    const updated = db.listSnapshot().automationRules.find(r => r.id === ruleId);
    expect(updated!.status).toBe("paused");

    // Record execution
    db.recordAutomationExecution(ruleId, companyId, "Auto-escalate blocked tasks", "task_blocked", "escalate_to_manager", "Escalated task-123");
    const afterExec = db.listSnapshot().automationRules.find(r => r.id === ruleId);
    expect(afterExec!.executionCount).toBe(1);
    expect(afterExec!.lastExecutedAt).toBeTruthy();

    // Automation log
    const log = db.getAutomationLog(companyId);
    expect(log).toHaveLength(1);
    expect(log[0].ruleName).toBe("Auto-escalate blocked tasks");

    // Delete
    db.deleteAutomationRule(ruleId, companyId);
    const afterDelete = db.listSnapshot().automationRules.find(r => r.id === ruleId);
    expect(afterDelete).toBeUndefined();
  });

  it("updates an existing rule", () => {
    const ruleId = db.saveAutomationRule({
      companyId,
      name: "Original name",
      trigger: "task_created",
      action: "assign_task",
    });

    db.saveAutomationRule({
      id: ruleId,
      companyId,
      name: "Updated name",
      trigger: "task_created",
      action: "notify_agent",
      priority: 90,
    });

    const rule = db.listSnapshot().automationRules.find(r => r.id === ruleId);
    expect(rule!.name).toBe("Updated name");
    expect(rule!.action).toBe("notify_agent");
    expect(rule!.priority).toBe(90);
  });
});

// ── Agent Messages ─────────────────────────────────────────────────────

describe("Agent Messages", () => {
  let agentAId: string;
  let agentBId: string;

  beforeEach(() => {
    agentAId = db.saveAgent({
      companyId, name: "Alice", role: "Engineer", title: "Senior Engineer",
      department: "engineering", connectorId: "claude_local", status: "active",
      capabilities: "Backend development, API design, code review",
      budgetMonthlyUsd: 100,
    });
    agentBId = db.saveAgent({
      companyId, name: "Bob", role: "Designer", title: "UX Designer",
      department: "design", connectorId: "claude_local", status: "active",
      capabilities: "UI design, wireframing, user research",
      budgetMonthlyUsd: 100,
    });
  });

  it("sends and retrieves direct messages", () => {
    const msgId = db.sendAgentMessage({
      companyId,
      fromAgentId: agentAId,
      toAgentId: agentBId,
      channel: "direct",
      subject: "Need design review",
      body: "Can you review the login page mockup?",
      priority: "normal",
    });

    expect(msgId).toBeTruthy();

    const messages = db.listAgentMessages(companyId);
    expect(messages).toHaveLength(1);
    expect(messages[0].subject).toBe("Need design review");
    expect(messages[0].fromAgentId).toBe(agentAId);
    expect(messages[0].toAgentId).toBe(agentBId);
    expect(messages[0].readAt).toBeNull();
  });

  it("marks messages as read", () => {
    const msgId = db.sendAgentMessage({
      companyId,
      fromAgentId: agentAId,
      toAgentId: agentBId,
      subject: "Test",
      body: "Hello",
    });

    db.markMessageRead(msgId, companyId);
    const messages = db.listAgentMessages(companyId);
    const updatedMessage = messages.find((message) => message.id === msgId);
    expect(updatedMessage?.readAt).toBeTruthy();
  });

  it("tracks read state per agent without marking the sender unread", () => {
    const msgId = db.sendAgentMessage({
      companyId,
      fromAgentId: agentAId,
      toAgentId: agentBId,
      subject: "Test",
      body: "Hello",
    });

    const senderView = db.listAgentMessages(companyId, { agentId: agentAId });
    expect(senderView).toHaveLength(1);
    expect(senderView[0].id).toBe(msgId);
    expect(senderView[0].readAt).toBeTruthy();

    const recipientViewBefore = db.listAgentMessages(companyId, { agentId: agentBId, unreadOnly: true });
    expect(recipientViewBefore).toHaveLength(1);
    expect(recipientViewBefore[0].id).toBe(msgId);

    db.markAgentMessageRead(msgId, companyId, agentBId);

    const recipientViewAfter = db.listAgentMessages(companyId, { agentId: agentBId, unreadOnly: true });
    expect(recipientViewAfter).toHaveLength(0);

    const thirdAgentId = createAgent({ name: "Agent C" });
    const thirdView = db.listAgentMessages(companyId, { agentId: thirdAgentId });
    expect(thirdView).toHaveLength(0);
  });

  it("limits department and project messages to relevant members", () => {
    const engineeringLeadId = createAgent({ name: "Engineering Lead", role: "Lead", department: "engineering" });
    const productLeadId = createAgent({ name: "Product Lead", role: "Lead", department: "product" });

    const projectId = db.saveProject({
      companyId,
      name: "Cross-team Project",
      description: "Scope",
      leadAgentId: engineeringLeadId,
      status: "active",
    });
    db.saveTask({
      companyId,
      title: "Project task",
      description: "Do work",
      assigneeAgentId: engineeringLeadId,
      projectId,
      status: "todo",
      priority: "medium",
    });

    const deptMessageId = db.sendAgentMessage({
      companyId,
      fromAgentId: engineeringLeadId,
      channel: "department",
      channelTargetId: "engineering",
      subject: "Engineering update",
      body: "Only engineering should see this",
    });
    const projectMessageId = db.sendAgentMessage({
      companyId,
      fromAgentId: engineeringLeadId,
      channel: "project",
      channelTargetId: projectId,
      subject: "Project update",
      body: "Only project members should see this",
    });

    const engineeringView = db.listAgentMessages(companyId, { agentId: engineeringLeadId });
    expect(engineeringView.some((message) => message.id === deptMessageId)).toBe(true);
    expect(engineeringView.some((message) => message.id === projectMessageId)).toBe(true);

    const productView = db.listAgentMessages(companyId, { agentId: productLeadId });
    expect(productView.some((message) => message.id === deptMessageId)).toBe(false);
    expect(productView.some((message) => message.id === projectMessageId)).toBe(false);
  });

  it("filters messages by channel", () => {
    db.sendAgentMessage({ companyId, fromAgentId: agentAId, subject: "Dept update", body: "All good", channel: "department", channelTargetId: "engineering" });
    db.sendAgentMessage({ companyId, fromAgentId: agentAId, toAgentId: agentBId, subject: "DM", body: "Hey", channel: "direct" });

    const deptMsgs = db.listAgentMessages(companyId, { channel: "department" });
    expect(deptMsgs).toHaveLength(1);
    expect(deptMsgs[0].subject).toBe("Dept update");

    const directMsgs = db.listAgentMessages(companyId, { channel: "direct" });
    expect(directMsgs).toHaveLength(1);
    expect(directMsgs[0].subject).toBe("DM");
  });

  it("appears in snapshot", () => {
    db.sendAgentMessage({ companyId, fromAgentId: agentAId, channel: "company", subject: "Snapshot test", body: "Hi" });
    const snapshot = db.listSnapshot();
    expect(snapshot.agentMessages.length).toBeGreaterThanOrEqual(1);
    expect(snapshot.agentMessages[0].subject).toBe("Snapshot test");
  });
});

// ── Auto Task Assignment ───────────────────────────────────────────────

describe("Auto Task Assignment", () => {
  let backendId: string;
  let frontendId: string;

  beforeEach(() => {
    backendId = db.saveAgent({
      companyId, name: "Backend Dev", role: "Backend Engineer", title: "Senior Backend",
      department: "engineering", connectorId: "codex_local", status: "active",
      capabilities: "API development, database design, Node.js, PostgreSQL, backend testing",
      budgetMonthlyUsd: 200,
    });
    frontendId = db.saveAgent({
      companyId, name: "Frontend Dev", role: "Frontend Engineer", title: "Senior Frontend",
      department: "engineering", connectorId: "codex_local", status: "active",
      capabilities: "React, TypeScript, CSS, Tailwind, responsive design, frontend testing, UI components",
      budgetMonthlyUsd: 200,
    });
  });

  it("assigns to the best-matching agent by capability keywords", () => {
    const taskId = db.saveTask({
      companyId, title: "Build React component for user dashboard",
      description: "Create a responsive React component with Tailwind CSS styling",
      priority: "medium", status: "todo",
    });

    const assignedId = db.autoAssignTask(taskId, companyId);
    expect(assignedId).toBe(frontendId); // "React", "responsive", "Tailwind" match frontend
  });

  it("assigns backend task to backend agent", () => {
    const taskId = db.saveTask({
      companyId, title: "Design database schema for orders",
      description: "PostgreSQL database design with API endpoints for order management",
      priority: "high", status: "todo",
    });

    const assignedId = db.autoAssignTask(taskId, companyId);
    expect(assignedId).toBe(backendId); // "database", "PostgreSQL", "API" match backend
  });

  it("returns existing assignee if task already assigned", () => {
    const taskId = db.saveTask({
      companyId, title: "Already assigned task",
      description: "This task has an assignee",
      assigneeAgentId: frontendId,
      priority: "medium", status: "todo",
    });

    const result = db.autoAssignTask(taskId, companyId);
    expect(result).toBe(frontendId);
  });

  it("returns null if all agents have exhausted their budget", () => {
    // Set positive budgets that are fully spent
    db.saveAgent({ id: backendId, companyId, name: "Backend Dev", role: "Backend", title: "Backend", connectorId: "codex_local", status: "active", capabilities: "backend", budgetMonthlyUsd: 100 });
    db.saveAgent({ id: frontendId, companyId, name: "Frontend Dev", role: "Frontend", title: "Frontend", connectorId: "codex_local", status: "active", capabilities: "frontend", budgetMonthlyUsd: 100 });
    // Exhaust budgets by recording spending via direct SQL (since finishRun would need a real run)
    (db as any).db.prepare("update agents set spent_monthly_usd = 100 where id = ?").run(backendId);
    (db as any).db.prepare("update agents set spent_monthly_usd = 100 where id = ?").run(frontendId);

    const taskId = db.saveTask({ companyId, title: "No budget task", description: "Test", priority: "low", status: "todo" });
    const result = db.autoAssignTask(taskId, companyId);
    expect(result).toBeNull();
  });

  it("penalizes agents with many active tasks", () => {
    // Give backend agent 5 active tasks
    for (let i = 0; i < 5; i++) {
      db.saveTask({ companyId, title: `Backend task ${i}`, description: "", assigneeAgentId: backendId, priority: "medium", status: "in_progress" });
    }

    // Generic task with no strong keyword match — should go to less busy frontend agent
    const taskId = db.saveTask({ companyId, title: "Implement feature", description: "Build the feature", priority: "medium", status: "todo" });
    const assignedId = db.autoAssignTask(taskId, companyId);
    expect(assignedId).toBe(frontendId); // Frontend has 0 active tasks vs backend's 5
  });
});

// ── Workflow Pipelines ─────────────────────────────────────────────────

describe("Workflow Pipelines", () => {
  it("creates, activates, and deletes a workflow", () => {
    const wfId = db.saveWorkflow({
      companyId,
      name: "Code Review Pipeline",
      description: "Auto-review flow for PRs",
      triggerType: "task_status_changed",
      triggerConfigJson: JSON.stringify({ toStatus: "in_review" }),
      stepsJson: JSON.stringify([
        { id: "s1", name: "Run tests", action: "run_task", status: "pending" },
        { id: "s2", name: "Notify reviewer", action: "notify_agent", status: "pending" },
      ]),
      status: "draft",
    });

    expect(wfId).toBeTruthy();
    const snapshot = db.listSnapshot();
    const wf = snapshot.workflows.find(w => w.id === wfId);
    expect(wf!.name).toBe("Code Review Pipeline");
    expect(wf!.status).toBe("draft");
    expect(wf!.runCount).toBe(0);

    // Activate
    db.activateWorkflow(wfId, companyId);
    const activated = db.listSnapshot().workflows.find(w => w.id === wfId);
    expect(activated!.status).toBe("active");
    expect(activated!.runCount).toBe(1);
    expect(activated!.lastRunAt).toBeTruthy();

    // Delete
    db.deleteWorkflow(wfId, companyId);
    expect(db.listSnapshot().workflows.find(w => w.id === wfId)).toBeUndefined();
  });

  it("rejects activating an already-active workflow", () => {
    const wfId = db.saveWorkflow({ companyId, name: "Test", triggerType: "schedule", status: "draft" });
    db.activateWorkflow(wfId, companyId);
    expect(() => db.activateWorkflow(wfId, companyId)).toThrow("already running");
  });
});