AgentCompany/tests/unit/domain-services.test.ts

import { mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import { tmpdir } from "node:os";
import { createHash, randomUUID } from "node:crypto";
import { DatabaseSync } from "node:sqlite";
import { describe, expect, test } from "vitest";
import { DatabaseConnection } from "../../src/main/database/connection";
import { FileService } from "../../src/main/services/file-service";
import { OrganizationService } from "../../src/main/services/organization-service";
import { SnapshotService } from "../../src/main/services/snapshot-service";
import { SkillService } from "../../src/main/services/skill-service";
import { ChatService } from "../../src/main/services/chat-service";
import { MigrationService } from "../../src/main/services/migration-service";
import { OnboardingService } from "../../src/main/services/onboarding-service";
import { RISK_LEVEL, TASK_STATUS } from "../../src/shared/domain";
import { createId } from "../../src/shared/ids";

function createConnection(): DatabaseConnection {
  return new DatabaseConnection(join(tmpdir(), `agentcompany-new-${randomUUID()}.db`));
}

describe("domain services", () => {
  test("records every applied schema migration version", () => {
    const connection = createConnection();

    const rows = connection.db.prepare("select version from schema_migrations order by version asc").all() as Array<{ version: number }>;
    expect(rows.map((row) => row.version)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65]);
    connection.close();
  });

  test("creates an organization with providers, chat spaces, employee, and audit", () => {
    const connection = createConnection();
    const organization = new OrganizationService(connection.db);
    const snapshot = new SnapshotService(connection.db);

    connection.transaction(() => organization.createOrganization({
      organizationName: "Acme Operations",
      employeeName: "Dana Lee",
      mission: "Coordinate agents with auditable approvals.",
      goal: "Ship a verified control plane.",
    }));

    const state = snapshot.load();
    expect(state.organizations).toHaveLength(1);
    expect(state.employees[0]?.displayName).toBe("Dana Lee");
    expect(state.providers.length).toBeGreaterThanOrEqual(6);
    expect(state.employeeIdentities).toHaveLength(1);
    expect(state.roleGrants.map((grant) => grant.roleKey).sort()).toEqual(["approval_decider", "hiring_manager", "org_admin"]);
    expect(state.orgDepartments.map((department) => department.name)).toContain("Engineering");
    expect(state.hiringPolicies.some((policy) => policy.departmentName === "Engineering")).toBe(true);
    expect(state.approvalRoutingRules[0]).toMatchObject({ kind: "*", minimumRisk: "low", routeToType: "employee" });
    expect(state.featureFlags.map((flag) => flag.key)).toContain("chaos_drills");
    expect(state.sloTargets.map((target) => target.signalKey)).toContain("provider_request_success");
    expect(state.chaosDrills.map((drill) => drill.scenarioKey)).toContain("approval_backlog_gate");
    expect(state.sdlcReviewAgents.map((agent) => agent.key)).toContain("code_reviewer");
    expect(state.evalSuites.map((suite) => suite.key)).toContain("contract");
    expect(state.prBotGates.map((gate) => gate.key)).toContain("static_checks");
    expect(state.chatSpaces.map((space) => space.name)).toContain("board");
    expect(state.policyRules[0]?.action).toBe("task_create");
    expect(state.auditEvents[0]?.action).toBe("created");
    connection.close();
  });

  test("high risk work creates a pending approval", () => {
    const connection = createConnection();
    const organization = new OrganizationService(connection.db);
    const snapshot = new SnapshotService(connection.db);
    let orgId = "";

    connection.transaction(() => {
      orgId = organization.createOrganization({
        organizationName: "Acme Operations",
        employeeName: "Dana Lee",
        mission: "Coordinate agents with auditable approvals.",
        goal: "Ship a verified control plane.",
        executionMode: "ai_cofounder",
      });
      organization.createTask({
        orgId,
        title: "Production deploy",
        description: "Deploy a high-risk change.",
        status: TASK_STATUS.BACKLOG,
        assigneeAgentId: null,
        risk: RISK_LEVEL.HIGH,
        projectId: null,
        goalId: null,
        workspaceId: null,
        priority: "normal",
        requiresFilesystem: false,
      });
    });

    const state = snapshot.load();
    expect(state.tasks).toHaveLength(1);
    expect(state.approvals).toHaveLength(1);
    expect(state.approvalAssignments).toHaveLength(1);
    expect(state.approvals[0]?.state).toBe("pending");
    expect(state.approvals[0]).toMatchObject({ sourceEntityType: "task", sourceEntityId: state.tasks[0]?.id });
    connection.close();
  });

  test("ai ceo mode auto-approves high risk work without operator review", () => {
    const connection = createConnection();
    const organization = new OrganizationService(connection.db);
    const snapshot = new SnapshotService(connection.db);
    let orgId = "";

    connection.transaction(() => {
      orgId = organization.createOrganization({
        organizationName: "Autonomy Inc",
        employeeName: "Robin Park",
        mission: "Run the company autonomously.",
        goal: "Ship without manual gates.",
        executionMode: "ai_ceo",
      });
      organization.createTask({
        orgId,
        title: "Production deploy",
        description: "Deploy a high-risk change.",
        status: TASK_STATUS.BACKLOG,
        assigneeAgentId: null,
        risk: RISK_LEVEL.HIGH,
        projectId: null,
        goalId: null,
        workspaceId: null,
        priority: "normal",
        requiresFilesystem: false,
      });
    });

    const state = snapshot.load();
    const employeeId = state.employees.find((employee) => employee.orgId === orgId)?.id;
    expect(state.approvals).toHaveLength(1);
    expect(state.approvals[0]?.state).toBe("approved");
    expect(state.approvals[0]?.decidedByEmployeeId).toBe(employeeId);
    expect(state.approvalAssignments).toHaveLength(0);
    connection.close();
  });

  test("imports a versioned skill revision from a local directory", () => {
    const connection = createConnection();
    const organization = new OrganizationService(connection.db);
    const skills = new SkillService(connection.db, join(tmpdir(), `agentcompany-skill-artifacts-${randomUUID()}`));
    const snapshot = new SnapshotService(connection.db);
    const skillDir = join(tmpdir(), `agentcompany-skill-${randomUUID()}`);
    mkdirSync(skillDir, { recursive: true });
    mkdirSync(join(skillDir, "tests"), { recursive: true });
    writeFileSync(join(skillDir, "SKILL.md"), "# Review Routes\n");
    writeFileSync(join(skillDir, "tests", "happy_path.yaml"), "input: review\n");
    writeFileSync(join(skillDir, "skill.manifest.json"), JSON.stringify({
      name: "review-routes",
      version: "1.0.0",
      entrypoint: "SKILL.md",
      capabilities: ["architecture-review"],
      required_tools: ["file_search"],
      compatible_models: ["openai/*", "anthropic/*"],
      risk_level: "medium",
      inputs: { diff: "markdown" },
      outputs: { recommendation: "markdown" },
      tests: ["tests/happy_path.yaml"],
    }));
    let orgId = "";
    let agentId = "";
    let revisionId = "";

    connection.transaction(() => {
      orgId = organization.createOrganization({
        organizationName: "Acme Operations",
        employeeName: "Dana Lee",
        mission: "Coordinate agents with auditable approvals.",
        goal: "Ship a verified control plane.",
      });
      agentId = organization.createAgent({
        orgId,
        name: "Ada",
        role: "Architecture reviewer",
        department: "Engineering",
        modelProviderId: null,
        modelId: null,
        budgetCents: 10000,
        managerAgentId: null,
      });
      revisionId = skills.importDirectory({ orgId, directoryPath: skillDir, versionSemver: "1.0.0" });
      const skill = connection.db.prepare("select id from skill_definitions where org_id = ? and slug = ?")
        .get(orgId, "review-routes") as { id: string };
      skills.bind({ orgId, agentId, skillId: skill.id, revisionId });
      rmSync(skillDir, { recursive: true, force: true });
      skills.runTests({ orgId, revisionId });
      skills.resolveRuntimeSnapshot({ orgId, agentId, runId: "run-review-1", maxTokens: 44_800, taskText: "" });
    });

    // Catalogue metadata ships in the snapshot; skill internals stay in the
    // database (the snapshot rides IPC on every refresh).
    const state = snapshot.load();
    expect(state.skillDefinitions[0]?.slug).toBe("review-routes");
    expect(state).not.toHaveProperty("skillRuntimeSnapshots");
    const revision = connection.db.prepare("select version_semver, immutable_checksum, manifest_json from skill_revisions where id = ?")
      .get(revisionId) as { version_semver: string; immutable_checksum: string; manifest_json: string };
    expect(revision.version_semver).toBe("1.0.0");
    expect(revision.immutable_checksum).toHaveLength(64);
    expect(revision.manifest_json).toContain("architecture-review");
    const skillTest = connection.db.prepare("select last_result, last_run_at from skill_tests where revision_id = ?")
      .get(revisionId) as { last_result: string; last_run_at: string };
    expect(skillTest.last_result).toContain("\"status\":\"passed\"");
    expect(skillTest.last_run_at).toBeTruthy();
    const runtime = connection.db.prepare("select source_revision_ids, compiled_prompt from skill_runtime_snapshots where run_id = 'run-review-1'")
      .get() as { source_revision_ids: string; compiled_prompt: string };
    expect(runtime.source_revision_ids).toContain(revisionId);
    expect(runtime.compiled_prompt).toContain("# Review Routes");
    expect(state.auditEvents.some((event) => event.entityType === "skill_revision" && event.action === "tests_run")).toBe(true);
    connection.close();
  });

  test("rejects cross-organization skill binding and duplicate runtime snapshots", () => {
    const connection = createConnection();
    const organization = new OrganizationService(connection.db);
    const skills = new SkillService(connection.db, join(tmpdir(), `agentcompany-skill-artifacts-${randomUUID()}`));
    const skillDir = join(tmpdir(), `agentcompany-skill-${randomUUID()}`);
    mkdirSync(skillDir, { recursive: true });
    writeFileSync(join(skillDir, "SKILL.md"), "# Review Routes\n");
    writeFileSync(join(skillDir, "skill.manifest.json"), JSON.stringify({
      name: "review-routes",
      version: "1.0.0",
      entrypoint: "SKILL.md",
      capabilities: [],
      required_tools: [],
      compatible_models: ["openai/*"],
      risk_level: "low",
      inputs: {},
      outputs: {},
      tests: [],
    }));
    let orgA = "";
    let orgB = "";
    let agentA = "";
    let agentB = "";
    let skillId = "";
    let revisionId = "";

    connection.transaction(() => {
      orgA = organization.createOrganization({ organizationName: "Acme A", employeeName: "Dana Lee", mission: "A", goal: "A" });
      orgB = organization.createOrganization({ organizationName: "Acme B", employeeName: "Riley Chen", mission: "B", goal: "B" });
      agentA = organization.createAgent({ orgId: orgA, name: "Ada", role: "Reviewer", department: "Engineering", modelProviderId: null, modelId: null, budgetCents: 10000, managerAgentId: null });
      agentB = organization.createAgent({ orgId: orgB, name: "Ben", role: "Reviewer", department: "Engineering", modelProviderId: null, modelId: null, budgetCents: 10000, managerAgentId: null });
      revisionId = skills.importDirectory({ orgId: orgA, directoryPath: skillDir, versionSemver: "1.0.0" });
      skillId = (connection.db.prepare("select id from skill_definitions where org_id = ? and slug = ?")
        .get(orgA, "review-routes") as { id: string }).id;
      expect(() => skills.bind({ orgId: orgA, agentId: agentB, skillId, revisionId })).toThrow("Agent was not found.");
      skills.bind({ orgId: orgA, agentId: agentA, skillId, revisionId });
      const firstResolve = skills.resolveRuntimeSnapshot({ orgId: orgA, agentId: agentA, runId: "run-review-1", maxTokens: 44_800, taskText: "" });
      // Idempotent per run: a recovered run reuses its frozen snapshot
      // instead of failing on the uniqueness guard.
      expect(skills.resolveRuntimeSnapshot({ orgId: orgA, agentId: agentA, runId: "run-review-1", maxTokens: 44_800, taskText: "" })).toBe(firstResolve);
      expect(connection.db.prepare("select count(*) as n from skill_runtime_snapshots where run_id = 'run-review-1'").get())
        .toEqual({ n: 1 });
    });

    expect(agentA).not.toBe(agentB);
    connection.close();
  });

  test("records collaborative chat semantics for threads, commands, mentions, and files", () => {
    const connection = createConnection();
    const organization = new OrganizationService(connection.db);
    const chat = new ChatService(connection.db);
    const snapshot = new SnapshotService(connection.db);
    let orgId = "";
    let fileId = "";

    connection.transaction(() => {
      orgId = organization.createOrganization({
        organizationName: "Acme Operations",
        employeeName: "Dana Lee",
        mission: "Coordinate agents with auditable approvals.",
        goal: "Ship a verified control plane.",
      });
      const spaceId = chat.createSpace({
        orgId,
        spaceType: "project",
        name: "release",
        topic: "Release coordination",
        visibility: "workspace",
      });
      const employee = connection.db.prepare("select id from employees where org_id = ?")
        .get(orgId) as { id: string };
      fileId = createId("file");
      connection.db.prepare(`
        insert into file_objects(id, org_id, name, kind, size_bytes, sha256, storage_path, owner_type, owner_id, created_at)
        values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
      `).run(fileId, orgId, "runbook.md", "text/markdown", 16, "8f3a", "artifacts/runbook.md", "employee", employee.id, new Date().toISOString());

      chat.sendMessage({
        orgId,
        spaceId,
        threadId: null,
        senderType: "employee",
        senderId: employee.id,
        bodyMd: "/handoff @Board review the deployment runbook",
        attachmentFileIds: [fileId],
      });
    });

    const state = snapshot.load();
    expect(state.chatSpaces.map((space) => space.name)).toContain("release");
    expect(state.chatMessages).toHaveLength(1);
    expect(state.chatThreads).toHaveLength(1);
    expect(state.chatAttachments).toHaveLength(1);
    expect(state.files[0]?.scanState).toBe("approved");
    expect(state.fileAccessGrants[0]).toMatchObject({ grantedToType: "board", grantedToId: orgId, accessLevel: "read" });
    expect(state.fileHandoffRecords[0]).toMatchObject({
      fileId,
      targetPrincipalType: "board",
      targetPrincipalId: orgId,
      checksum: "8f3a",
      scanState: "approved",
      policyDecision: "approved_for_handoff",
      objectRef: "artifacts/runbook.md",
    });
    expect(state.chatMentions[0]).toMatchObject({ targetType: "board", targetId: orgId });
    expect(state.chatSlashInvocations[0]).toMatchObject({ command: "handoff" });
    expect(state.chatPresence).toHaveLength(1);
    const slash = connection.db.prepare("select command from chat_slash_invocations").get() as { command: string };
    const mention = connection.db.prepare("select target_type, target_id from chat_mentions").get() as { target_type: string; target_id: string };
    expect(slash.command).toBe("handoff");
    expect(mention.target_type).toBe("board");
    expect(mention.target_id).toBe(orgId);
    connection.close();
  });

  test("enforces scanned file grants for agent handoff", () => {
    const connection = createConnection();
    const organization = new OrganizationService(connection.db);
    const chat = new ChatService(connection.db);
    const snapshot = new SnapshotService(connection.db);
    let orgId = "";
    let spaceId = "";
    let adaId = "";
    let benId = "";
    let approvedFileId = "";
    let blockedFileId = "";

    connection.transaction(() => {
      orgId = organization.createOrganization({
        organizationName: "Acme Operations",
        employeeName: "Dana Lee",
        mission: "Coordinate agents with auditable approvals.",
        goal: "Ship a verified control plane.",
      });
      adaId = organization.createAgent({
        orgId,
        name: "Ada",
        role: "Release reviewer",
        department: "Engineering",
        modelProviderId: null,
        modelId: null,
        budgetCents: 10000,
        managerAgentId: null,
      });
      benId = organization.createAgent({
        orgId,
        name: "Ben",
        role: "Runtime owner",
        department: "Engineering",
        modelProviderId: null,
        modelId: null,
        budgetCents: 10000,
        managerAgentId: null,
      });
      spaceId = chat.createSpace({ orgId, spaceType: "project", name: "release", topic: "Release coordination", visibility: "workspace" });
      approvedFileId = createId("fil");
      blockedFileId = createId("fil");
      const now = new Date().toISOString();
      connection.db.prepare(`
        insert into file_objects(
          id, org_id, name, kind, size_bytes, sha256, storage_path,
          owner_type, owner_id, space_id, pinned, scan_state, scan_labels_json, scanned_at, created_at, updated_at
        )
        values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
      `).run(approvedFileId, orgId, "release-notes.md", "md", 24, "sha-approved", "artifacts/release-notes.md", "agent", adaId, null, 0, "approved", "[]", now, now, now);
      connection.db.prepare(`
        insert into file_objects(
          id, org_id, name, kind, size_bytes, sha256, storage_path,
          owner_type, owner_id, space_id, pinned, scan_state, scan_labels_json, scanned_at, created_at, updated_at
        )
        values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
      `).run(blockedFileId, orgId, "quarantine.bin", "file", 8, "sha-blocked", "artifacts/quarantine.bin", "agent", adaId, null, 0, "blocked", "[\"signature\"]", now, now, now);
    });

    expect(() => connection.transaction(() => chat.sendMessage({
      orgId,
      spaceId,
      threadId: null,
      senderType: "agent",
      senderId: benId,
      bodyMd: "Attach release notes",
      attachmentFileIds: [approvedFileId],
    }))).toThrow("Attachment file access is required.");

    connection.transaction(() => chat.sendMessage({
      orgId,
      spaceId,
      threadId: null,
      senderType: "agent",
      senderId: adaId,
      bodyMd: "/handoff @Ben release notes",
      attachmentFileIds: [approvedFileId],
    }));

    expect(() => connection.transaction(() => chat.sendMessage({
      orgId,
      spaceId,
      threadId: null,
      senderType: "agent",
      senderId: adaId,
      bodyMd: "/handoff @Ben blocked payload",
      attachmentFileIds: [blockedFileId],
    }))).toThrow("Attachment file is not approved for handoff.");

    connection.transaction(() => chat.sendMessage({
      orgId,
      spaceId,
      threadId: null,
      senderType: "agent",
      senderId: benId,
      bodyMd: "Received release notes",
      attachmentFileIds: [approvedFileId],
    }));

    const state = snapshot.load();
    const benGrant = state.fileAccessGrants.find((grant) => grant.fileId === approvedFileId && grant.grantedToId === benId);
    if (!benGrant) throw new Error("Agent handoff grant was not created.");
    const benHandoff = state.fileHandoffRecords.find((record) => (
      record.fileId === approvedFileId && record.sourcePrincipalId === adaId && record.targetPrincipalId === benId
    ));
    if (!benHandoff) throw new Error("Agent handoff record was not created.");
    expect(benGrant).toMatchObject({ grantedToType: "agent", accessLevel: "read" });
    expect(benHandoff).toMatchObject({
      sourcePrincipalType: "agent",
      sourcePrincipalId: adaId,
      targetPrincipalType: "agent",
      checksum: "sha-approved",
      objectRef: "artifacts/release-notes.md",
      scanState: "approved",
      policyDecision: "approved_for_handoff",
    });
    expect(state.chatMessages).toHaveLength(2);
    expect(state.auditEvents.some((event) => event.entityType === "file_object" && event.action === "access_granted")).toBe(true);
    connection.close();
  });

  test("imports files with checksum, scan labels, object refs, and workspace grants", () => {
    const connection = createConnection();
    const organization = new OrganizationService(connection.db);
    const snapshot = new SnapshotService(connection.db);
    const artifactRoot = join(tmpdir(), `agentcompany-file-artifacts-${randomUUID()}`);
    const fileService = new FileService(connection.db, artifactRoot);
    const sourceDir = join(tmpdir(), `agentcompany-file-sources-${randomUUID()}`);
    mkdirSync(sourceDir, { recursive: true });
    const cleanBody = "Release checklist for dana@example.com\n";
    const secretBody = "-----BEGIN OPENSSH PRIVATE KEY-----\nabc123\n-----END OPENSSH PRIVATE KEY-----\n";
    const cleanPath = join(sourceDir, "release-notes.md");
    const secretPath = join(sourceDir, "deploy.env");
    writeFileSync(cleanPath, cleanBody);
    writeFileSync(secretPath, secretBody);
    let orgId = "";

    connection.transaction(() => {
      orgId = organization.createOrganization({
        organizationName: "Acme Operations",
        employeeName: "Dana Lee",
        mission: "Coordinate agents with auditable approvals.",
        goal: "Ship a verified control plane.",
      });
    });
    const cleanFileId = fileService.importPath(orgId, cleanPath);
    const blockedFileId = fileService.importPath(orgId, secretPath);

    const state = snapshot.load();
    const cleanFile = state.files.find((file) => file.id === cleanFileId);
    const blockedFile = state.files.find((file) => file.id === blockedFileId);
    if (!cleanFile || !blockedFile) throw new Error("Imported files were not recorded.");
    expect(cleanFile.sha256).toBe(createHash("sha256").update(cleanBody).digest("hex"));
    expect(cleanFile.storagePath).toContain(cleanFileId);
    expect(cleanFile.scanState).toBe("approved");
    expect(JSON.parse(cleanFile.scanLabelsJson)).toEqual(expect.arrayContaining(["classification:confidential", "dlp:email", "kind:md"]));
    expect(blockedFile.scanState).toBe("blocked");
    expect(JSON.parse(blockedFile.scanLabelsJson)).toEqual(expect.arrayContaining(["classification:restricted", "dlp:private-key", "kind:env"]));
    expect(state.fileAccessGrants).toContainEqual(expect.objectContaining({
      fileId: cleanFileId,
      grantedToType: "org_group",
      grantedToId: `${orgId}:workspace`,
      accessLevel: "manage",
    }));
    expect(state.fileAccessGrants).toContainEqual(expect.objectContaining({
      fileId: blockedFileId,
      grantedToType: "org_group",
      grantedToId: `${orgId}:workspace`,
      accessLevel: "manage",
    }));
    const importAudit = state.auditEvents.find((event) => event.entityId === blockedFileId && event.action === "imported");
    if (!importAudit) throw new Error("File import audit event was not recorded.");
    expect(importAudit.payloadJson).toContain("\"scanState\":\"blocked\"");
    expect(importAudit.payloadJson).toContain("dlp:private-key");
    expect(importAudit.payloadJson).toContain("objectRef");
    rmSync(sourceDir, { recursive: true, force: true });
    rmSync(artifactRoot, { recursive: true, force: true });
    connection.close();
  });

  test("creates approval and waiting presence from chat escalation", () => {
    const connection = createConnection();
    const organization = new OrganizationService(connection.db);
    const chat = new ChatService(connection.db);
    const snapshot = new SnapshotService(connection.db);
    let orgId = "";
    let employeeId = "";
    let spaceId = "";

    connection.transaction(() => {
      orgId = organization.createOrganization({
        organizationName: "Acme Operations",
        employeeName: "Dana Lee",
        mission: "Coordinate agents with auditable approvals.",
        goal: "Ship a verified control plane.",
      });
      employeeId = (connection.db.prepare("select id from employees where org_id = ?").get(orgId) as { id: string }).id;
      spaceId = chat.createSpace({
        orgId,
        spaceType: "project",
        name: "release",
        topic: "Release coordination",
        visibility: "workspace",
      });
      chat.sendMessage({
        orgId,
        spaceId,
        threadId: null,
        senderType: "employee",
        senderId: employeeId,
        bodyMd: "/escalate @Board freeze deployment",
        attachmentFileIds: [],
      });
    });

    const state = snapshot.load();
    const approval = state.approvals.find((item) => item.kind === "chat_escalation");
    if (!approval) throw new Error("Chat escalation approval was not created.");
    expect(approval.title).toBe("Escalate release");
    expect(approval.details).toBe("@Board freeze deployment");
    expect(approval.risk).toBe("high");
    expect(state.chatSlashInvocations[0]?.resultRef).toBe(approval.id);
    expect(state.chatPresence[0]).toMatchObject({ principalId: employeeId, status: "waiting_approval" });
    const audit = state.auditEvents.find((event) => event.entityId === approval.id && event.action === "requested");
    if (!audit) throw new Error("Chat escalation audit event was not created.");
    expect(audit.payloadJson).toContain(state.chatMessages[0]!.id);
    connection.close();
  });

  test("creates a read-only migration report from a legacy database", () => {
    const connection = createConnection();
    const organization = new OrganizationService(connection.db);
    const migrations = new MigrationService(connection.db);
    const snapshot = new SnapshotService(connection.db);
    const legacyPath = join(tmpdir(), `agentcompany-legacy-${randomUUID()}.db`);
    const legacy = new DatabaseSync(legacyPath);
    legacy.exec("create table agents(id text primary key); insert into agents(id) values ('agent-1');");
    legacy.close();
    let orgId = "";

    connection.transaction(() => {
      orgId = organization.createOrganization({
        organizationName: "Acme Operations",
        employeeName: "Dana Lee",
        mission: "Coordinate agents with auditable approvals.",
        goal: "Ship a verified control plane.",
      });
      migrations.createReport({ orgId, sourceDatabasePath: legacyPath });
    });

    const state = snapshot.load();
    expect(state.migrationReports).toHaveLength(1);
    expect(state.migrationReports[0]?.reportJson).toContain("\"agents\":1");
    const report = JSON.parse(state.migrationReports[0]!.reportJson) as {
      tableChecksums: Record<string, string>;
      idMaps: Record<string, string[]>;
      failures: Array<{ table: string; reason: string }>;
      validationSummary: { missingTableCount: number; passed: boolean };
      rollbackPack: { sourceDatabasePath: string };
    };
    expect(report.tableChecksums.agents).toHaveLength(64);
    expect(report.idMaps.agents).toEqual(["agent-1"]);
    expect(report.failures.some((failure) => failure.reason === "missing_table")).toBe(true);
    expect(report.validationSummary.missingTableCount).toBeGreaterThan(0);
    expect(report.validationSummary.passed).toBe(false);
    expect(report.rollbackPack.sourceDatabasePath).toBe(realpathSync.native(legacyPath));
    connection.close();
  });

  test("bootstraps the original onboarding chain with company, CEO, goal, project, task, and run", () => {
    const connection = createConnection();
    const onboarding = new OnboardingService({
      db: connection.db,
      saveProviderCredential: ({ orgId, providerId, model }) => {
        connection.db.prepare("update providers set credential_id = ?, model = ?, enabled = 1 where id = ? and org_id = ?")
          .run("cred_test", model, providerId, orgId);
      },
    });
    const snapshot = new SnapshotService(connection.db);

    connection.transaction(() => onboarding.bootstrap({
      companyName: "Acme Operations",
      companyDescription: "Coordinate agents with auditable approvals.",
      employeeName: "Dana Lee",
      workspacePath: join(tmpdir(), `agentcompany-workspace-${randomUUID()}`),
      executionMode: "ai_ceo",
      autoApproveHires: true,
      reviewDeliverables: false,
      goalTitle: "Ship a verified control plane",
      goalDescription: "Bring the desktop operating loop online.",
      providerKey: "openai",
      providerSecret: "test-secret",
      providerModel: "gpt-5.1",
    }));

    const state = snapshot.load();
    expect(state.organizations[0]?.executionMode).toBe("ai_ceo");
    expect(state.agents[0]?.roleLevel).toBe("c_suite");
    expect(state.agents[0]?.modelStrategy).toBe("explicit");
    expect(state.workspaces).toHaveLength(1);
    expect(state.goals[0]?.status).toBe("active");
    expect(state.projects[0]?.leadAgentId).toBe(state.agents[0]?.id);
    const projectRoom = state.chatSpaces.find((space) => space.spaceType === "project" && space.topic === state.projects[0]?.name);
    expect(projectRoom).toMatchObject({ name: "execution-plan-ship-a-verified-control-plane", visibility: "workspace" });
    expect(state.chatMemberships).toContainEqual(expect.objectContaining({ spaceId: projectRoom?.id, principalType: "employee" }));
    expect(state.chatMemberships).toContainEqual(expect.objectContaining({ spaceId: projectRoom?.id, principalType: "agent", principalId: state.agents[0]?.id }));
    expect(state.tasks[0]?.assigneeAgentId).toBe(state.agents[0]?.id);
    expect(state.taskRuns[0]?.trigger).toBe("bootstrap");
    expect(state.taskRuns[0]?.executionContextId).toMatch(/^ctx_/);
    expect(state.taskRuns[0]?.serviceIdentityId).toMatch(/^sid_/);
    connection.close();
  });

  test("creating a goal kicks off an operationalize task for its owner or the CEO", () => {
    const connection = createConnection();
    const organization = new OrganizationService(connection.db);
    let orgId = "";

    connection.transaction(() => {
      orgId = organization.createOrganization({
        organizationName: "Acme Operations",
        employeeName: "Dana Lee",
        mission: "Coordinate agents with auditable approvals.",
        goal: "Ship a verified control plane.",
      });
    });

    // Without any agent there is nobody to operationalize the goal yet.
    let waitingGoalId = "";
    connection.transaction(() => {
      waitingGoalId = organization.createGoal({ orgId, title: "Open the Berlin market", description: "Win the first ten customers.", ownerAgentId: null });
    });
    expect(connection.db.prepare("select count(*) as n from tasks where org_id = ?").get(orgId)).toMatchObject({ n: 0 });

    let ceoId = "";
    let ownerId = "";
    connection.transaction(() => {
      ceoId = organization.createAgent({
        orgId,
        name: "CEO",
        role: "CEO",
        department: "Executive",
        modelProviderId: null,
        modelId: null,
        budgetCents: 25000,
        managerAgentId: null,
        roleLevel: "c_suite",
      });
      ownerId = organization.createAgent({
        orgId,
        name: "Mara Quinn",
        role: "Growth Marketer",
        department: "Marketing",
        modelProviderId: null,
        modelId: null,
        budgetCents: 25000,
        managerAgentId: ceoId,
      });
    });

    // The first hire operationalizes the goal that was waiting, exactly once.
    expect(connection.db.prepare("select count(*) as n from tasks where goal_id = ?").get(waitingGoalId)).toMatchObject({ n: 1 });
    const revived = connection.db.prepare("select status, assignee_agent_id from tasks where goal_id = ?")
      .get(waitingGoalId) as { status: string; assignee_agent_id: string };
    expect(revived).toMatchObject({ status: TASK_STATUS.BACKLOG, assignee_agent_id: ceoId });

    // Ownerless goals land with the top-level agent; the kickoff re-enables its heartbeat.
    let ceoGoalId = "";
    connection.transaction(() => {
      ceoGoalId = organization.createGoal({ orgId, title: "Launch the loyalty program", description: "Ship the first reward tier.", ownerAgentId: null });
    });
    const ceoKickoff = connection.db.prepare("select title, status, assignee_agent_id from tasks where goal_id = ?")
      .get(ceoGoalId) as { title: string; status: string; assignee_agent_id: string };
    expect(ceoKickoff).toMatchObject({
      title: "Operationalize goal: Launch the loyalty program",
      status: TASK_STATUS.BACKLOG,
      assignee_agent_id: ceoId,
    });
    const ceo = connection.db.prepare("select heartbeat_enabled, heartbeat_interval_sec from agents where id = ?")
      .get(ceoId) as { heartbeat_enabled: number; heartbeat_interval_sec: number };
    expect(ceo).toMatchObject({ heartbeat_enabled: 1, heartbeat_interval_sec: 120 });

    // Goals with an explicit owner land with that owner.
    let ownedGoalId = "";
    connection.transaction(() => {
      ownedGoalId = organization.createGoal({ orgId, title: "Win the spring campaign", description: "Double qualified leads.", ownerAgentId: ownerId });
    });
    const ownedKickoff = connection.db.prepare("select assignee_agent_id from tasks where goal_id = ?")
      .get(ownedGoalId) as { assignee_agent_id: string };
    expect(ownedKickoff.assignee_agent_id).toBe(ownerId);
    connection.close();
  });

  test("hiring normalizes department case and rejects unknown departments with guidance", () => {
    const connection = createConnection();
    const organization = new OrganizationService(connection.db);
    let orgId = "";
    connection.transaction(() => {
      orgId = organization.createOrganization({
        organizationName: "Acme Operations",
        employeeName: "Dana Lee",
        mission: "Coordinate agents with auditable approvals.",
        goal: "Ship a verified control plane.",
      });
    });

    let agentId = "";
    connection.transaction(() => {
      agentId = organization.createAgent({
        orgId,
        name: "Zhang Hao",
        role: "Algorithm Lead",
        department: "engineering",
        modelProviderId: null,
        modelId: null,
        budgetCents: 25000,
        managerAgentId: null,
      });
    });
    const hired = connection.db.prepare("select department from agents where id = ?").get(agentId) as { department: string };
    expect(hired.department).toBe("Engineering");

    expect(() => connection.transaction(() => organization.createAgent({
      orgId,
      name: "Chen Wei",
      role: "Research Lead",
      department: "general",
      modelProviderId: null,
      modelId: null,
      budgetCents: 25000,
      managerAgentId: null,
    }))).toThrow(/Unknown department "general"\. Departments: .*Engineering.*Executive/);
    connection.close();
  });
});