The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
import { randomUUID } from "node:crypto";
import { existsSync } from "node:fs";
import { chmod, mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
import { createServer, type Server } from "node:http";
import type { AddressInfo } from "node:net";
import { tmpdir } from "node:os";
import { join } from "node:path";
import express from "express";
import { and, eq } from "drizzle-orm";
import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
import { agents, agentTaskSessions, agentWakeupRequests, authUsers, caseDocuments, caseEvents, caseHandoffs, cases, companies, companyMemberships, createDb, documents, heartbeatRuns, issueDocuments, issues } from "@paperclipai/db";
import { actorMiddleware } from "../middleware/auth.js";
import { errorHandler } from "../middleware/error-handler.js";
import { caseRoutes } from "../routes/cases.js";
import { caseHandoffRoutes } from "../routes/case-handoffs.js";
import { issueRoutes } from "../routes/issues.js";
import { setupRunnerPrpWebSocketServer, runnerPrpWebSocketInternals } from "../realtime/runner-prp-ws.js";
import { caseHandoffService } from "../services/case-handoffs.js";
import { caseHandoffDeliveryService } from "../services/case-handoff-delivery.js";
import { heartbeatService } from "../services/heartbeat.js";
import { instanceSettingsService } from "../services/instance-settings.js";
import { defaultCapabilityRunnerdBinary } from "../vendor/paperclip-runner/index.js";
import type { StorageService } from "../storage/types.js";
import { getEmbeddedPostgresTestSupport, startEmbeddedPostgresTestDatabase } from "./helpers/embedded-postgres.js";
const supported = await getEmbeddedPostgresTestSupport();
const suite = supported.supported && existsSync(defaultCapabilityRunnerdBinary()) ? describe : describe.skip;
/** The provider alone is scripted. Tool discovery, calls, auto-yield, retirement,
* run finalization, queue admission and recipient context use production code. */
suite("case handoff through the assembled native runner", () => {
let temporary: Awaited<ReturnType<typeof startEmbeddedPostgresTestDatabase>>;
let db: ReturnType<typeof createDb>;
let heartbeat: ReturnType<typeof heartbeatService>;
let server: Server;
let root: string;
const restore = new Map<string, string | undefined>();
let restoreCodex: (() => void) | undefined;
beforeAll(async () => {
root = await mkdtemp(join(tmpdir(), "case-native-integration-"));
for (const key of ["PAPERCLIP_AGENT_JWT_SECRET", "PAPERCLIP_API_URL", "PAPERCLIP_HOME", "PAPERCLIP_INSTANCE_ID", "PAPERCLIP_RUNNER_STATE_DIR"]) restore.set(key, process.env[key]);
process.env.PAPERCLIP_AGENT_JWT_SECRET = "case-native-integration-secret";
process.env.PAPERCLIP_HOME = join(root, "paperclip-home");
process.env.PAPERCLIP_INSTANCE_ID = "case-native-integration";
process.env.PAPERCLIP_RUNNER_STATE_DIR = join(root, "runner-state");
await mkdir(process.env.PAPERCLIP_HOME, { recursive: true });
temporary = await startEmbeddedPostgresTestDatabase("case-native-integration-db-");
db = createDb(temporary.connectionString);
await instanceSettingsService(db).updateExperimental({ enableCases: true });
heartbeat = heartbeatService(db, { runtimeEnv: {} });
const app = express(); app.use(express.json());
app.use(actorMiddleware(db, { deploymentMode: "authenticated" }));
const storage = { provider: "local_disk", putFile: async () => { throw new Error("unused"); }, getObject: async () => { throw new Error("unused"); },
headObject: async () => ({ exists: false }), deleteObject: async () => {} } satisfies StorageService;
app.use("/api", caseRoutes(db, storage)); app.use("/api", caseHandoffRoutes(db)); app.use("/api", issueRoutes(db, storage)); app.use(errorHandler);
server = createServer(app);
await new Promise<void>(resolve => server.listen(0, "127.0.0.1", resolve));
const apiUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
process.env.PAPERCLIP_API_URL = apiUrl;
setupRunnerPrpWebSocketServer(server, { apiUrl });
}, 30_000);
afterAll(async () => {
if (db) {
const live = await db.select().from(heartbeatRuns).where(eq(heartbeatRuns.status, "running"));
for (const run of live) await heartbeat.cancelRun(run.id).catch(() => undefined);
await heartbeat.drainActiveRunExecutions();
}
restoreCodex?.();
if (server) { runnerPrpWebSocketInternals.resetForTests(); server.closeAllConnections();
await new Promise<void>(resolve => server.close(() => resolve())); }
await temporary?.cleanup();
async function writable(directory: string) {
await chmod(directory, 0o700).catch(() => undefined);
for (const entry of await readdir(directory, { withFileTypes: true }).catch(() => [])) {
const file = join(directory, entry.name);
if (entry.isDirectory()) await writable(file);
}
}
await writable(root);
await rm(root, { recursive: true, force: true });
for (const [key, value] of restore) { if (value === undefined) delete process.env[key]; else process.env[key] = value; }
});
it("yields through A→B→A, resumes each agent's own session, then closes only after accepted task completion", async () => {
const companyId = randomUUID(), triage = randomUUID(), engineer = randomUUID(), userId = randomUUID();
const sourceHome = join(root, "provider-home"), workspace = join(root, "workspace"), bin = join(root, "bin");
await Promise.all([sourceHome, workspace, bin].map(path => mkdir(path, { recursive: true })));
await db.insert(authUsers).values({ id: userId, name: "Factory operator", email: `${userId}@example.test`, createdAt: new Date(), updatedAt: new Date() });
await db.insert(companies).values({ id: companyId, name: "Native factory proof", issuePrefix: `N${companyId.slice(0, 6)}`, defaultResponsibleUserId: userId });
await db.insert(companyMemberships).values({ companyId, principalType: "user", principalId: userId, membershipRole: "operator", status: "active" });
for (const [id, role] of [[triage, "ceo"], [engineer, "engineer"]] as const) await db.insert(agents).values({ id, companyId, name: role,
role, ...(id === engineer ? { reportsTo: triage } : {}), status: "idle", adapterType: "paperclip_runner",
adapterConfig: { provider: "codex", model: "gpt-5.6-sol", cwd: workspace, lifecycleMode: "per_turn", codexPermissionMode: "never", timeoutSec: 30,
env: { CODEX_HOME: sourceHome, OPENAI_API_KEY: "", CODEX_API_KEY: "" } }, runtimeConfig: { heartbeat: { enabled: false } } });
const initial = await caseHandoffService(db).handoff(companyId, { type: "board", source: "local_implicit", userId }, {
idempotencyKey: "native-factory-start", case: { create: { caseType: "work", title: "Native factory proof", fields: { specification: "persisted native specification canary" } } },
workflow_document_text: "Workflow routing canary: triage reads the brief, implementation saves evidence, verification checks it, and finalization closes this same task.",
toAgentId: triage, phase: "triage", instructions: "Research then hand this same task to implementation",
initialDocuments: [{ key: "brief", title: "Factory brief", body: "Seeded native task brief canary" }],
});
const provider = join(root, "scripted-codex.mjs"), command = join(bin, "codex");
const config = { caseId: initial.caseId, taskId: initial.taskId, triage, engineer,
errors: join(root, "provider-error.json"), exposed: join(root, "exposed.json"), accepted: join(root, "accepted.json"),
observed: join(root, "observed.json"), returned: join(root, "returned.json"), finalTurn: join(root, "final-turn.json"), terminal: join(root, "terminal.json") };
await writeFile(provider, `
import { createInterface } from 'node:readline';
import { randomUUID } from 'node:crypto';
import { existsSync, writeFileSync } from 'node:fs';
const config=${JSON.stringify(config)};
const send=value=>process.stdout.write(JSON.stringify(value)+'\\n');
let turn='native-case-turn-'+randomUUID(), thread='native-case-thread-'+randomUUID(), step=0, context, prompt='', active=false, contract, returning=false, finishing=false, threadMethod;
process.on('uncaughtException', error=>{writeFileSync(config.errors,JSON.stringify({message:error.message}));process.exit(1);});
const call=(tool,args)=>{step++;send({id:'call-'+step,method:'item/tool/call',params:{threadId:thread,turnId:turn,callId:'tool-'+step,tool,arguments:args}});};
for await (const line of createInterface({input:process.stdin})) {
const m=JSON.parse(line), p=m.params??{};
if (!m.method) {
if (!String(m.id).startsWith('call-')) continue;
if(m.error||m.result?.success!==true) throw new Error('fixture native tool rejected');
const content=m.result.contentItems??m.result.content??[];
const value=JSON.parse(content.find(item=>typeof item.text==='string')?.text??'{}');
if(step===1) {
context=value.result?.activeTask?value.result:value;
if(context.activeTask?.id!==config.taskId) throw new Error('fixture task identity mismatch');
if(context.actor.id===config.triage&&existsSync(config.accepted)) {
returning=true;
finishing=existsSync(config.returned);
writeFileSync(finishing?config.finalTurn:config.returned,JSON.stringify({actorId:context.actor.id,taskId:context.activeTask.id,prompt,threadMethod,pid:process.pid}));
if(finishing) call('handoff_case',{idempotencyKey:'native-case-done',case:{id:config.caseId},to:'done',instructions:'The native handoff observation document is persisted; finish the task normally.',expectedHandoffVersion:4,expectedIssueStatusVersion:context.activeTask.statusVersion});
else call('handoff_case',{idempotencyKey:'native-verification-handoff',case:{id:config.caseId},toAgentId:config.triage,phase:'finalization',instructions:'Finish the verified native handoff case',expectedHandoffVersion:3,expectedIssueStatusVersion:context.activeTask.statusVersion});
} else if(context.actor.id===config.triage) {
if(prompt.includes('Workflow routing canary:')) throw new Error('workflow body was duplicated into bootstrap prompt');
call('read_document',{key:'workflow'});
}
else call('read_case',{});
} else if(context.actor.id===config.triage&&!returning&&step===2) {
const document=(value.result??value).document;
if(document?.issueId!==config.taskId||!document.body?.startsWith('Workflow routing canary:')) throw new Error('required workflow document not readable before handoff');
call('read_document',{key:'brief'});
} else if(context.actor.id===config.triage&&!returning&&step===3) {
const document=(value.result??value).document;
if(document?.issueId!==config.taskId||(document.body??document.latestBody)!=='Seeded native task brief canary') throw new Error('initial task brief not readable before handoff');
call('handoff_case',{idempotencyKey:'native-triage-handoff',case:{id:config.caseId},toAgentId:config.engineer,phase:'implementation',instructions:'Implement the persisted native specification canary',expectedHandoffVersion:1,expectedIssueStatusVersion:context.activeTask.statusVersion});
} else if(context.actor.id===config.triage&&!returning) writeFileSync(config.accepted,JSON.stringify({value,pid:process.pid}));
else if(returning&&!finishing) {}
else if(finishing&&step===2) {
writeFileSync(config.terminal,JSON.stringify(value));
if(!contract) throw new Error('fixture did not receive the current completion contract');
call('paperclip_finish',{reportedWorkDisposition:'done',summary:'Saved the native handoff observation document and completed this same task.',completionClaim:{contractRevision:contract.revision,objectiveSatisfied:true,criteria:contract.criteria.map(c=>({criterionId:c.id,status:'satisfied',evidenceRefs:[]})),remainingWork:[]},evidence:[],verification:[],attentionRequests:[],artifacts:[]});
} else if(returning) {active=false;send({method:'turn/completed',params:{threadId:thread,turn:{id:turn,status:'completed'}}});}
else if(step===2) {
const response=value.result??value;
if(response.ok!==true||response.data?.id!==config.caseId) throw new Error('native read_case did not resolve the primary case');
call('update_case',{idempotencyKey:'successor-case-facts',fields:{...response.data.fields,verified:true}});
} else if(step===3) {
const response=value.result??value;
if(response.ok!==true||response.data?.fields?.verified!==true) throw new Error('native update_case did not persist facts');
call('write_document',{idempotencyKey:'successor-observation',key:'native-handoff-observed',title:'Native handoff observation',baseRevisionId:null,body:JSON.stringify({taskId:config.taskId,caseId:config.caseId,freshPrompt:prompt.includes('persisted native specification canary')&&prompt.includes('implementation')&&prompt.includes('handoffVersion')})});
} else if(step===4) {
const response=value.result??value;
if(response.document?.latestRevisionNumber!==1) throw new Error('native write_document did not save revision 1');
call('read_document',{key:'native-handoff-observed'});
} else if(step===5) {
const response=value.result??value;
if(JSON.parse(response.document?.body??response.document?.latestBody??'{}').taskId!==config.taskId) throw new Error('native read_document did not load the saved body');
writeFileSync(config.observed,JSON.stringify({actorId:context.actor.id,taskId:context.activeTask.id,pid:process.pid}));
call('handoff_case',{idempotencyKey:'native-implementation-handoff',case:{id:config.caseId},toAgentId:config.triage,phase:'verification',instructions:'Verify the saved native handoff observation and finish this case',expectedHandoffVersion:2,expectedIssueStatusVersion:context.activeTask.statusVersion});
}
continue;
}
if(m.id===undefined) continue;
if(m.method==='initialize') send({id:m.id,result:{user:{sessionId:'native-case-provider'}}});
else if(['thread/start','thread/resume','thread/read'].includes(m.method)) {
if(m.method!=='thread/read') threadMethod=m.method;
if(m.method!=='thread/start'&&typeof p.threadId==='string') thread=p.threadId;
const names=(p.dynamicTools??[]).map(t=>t.name);
if(m.method!=='thread/read') {
if(names.includes('read_case_document')||names.includes('write_case_document')) throw new Error('retired case document tool still exposed');
for(const name of ['create_case','handoff_case','read_case','update_case','read_document','write_document']) if(!names.includes(name)) throw new Error(name+' not exposed by production');
const creation=p.dynamicTools.find(tool=>tool.name==='create_case');
if(!creation.inputSchema?.required?.includes('kickoff')) throw new Error('create_case must require kickoff in provider tool discovery');
writeFileSync(config.exposed,JSON.stringify({names,creationSchema:creation.inputSchema}));
}
send({id:m.id,result:{model:'gpt-5.6-sol',thread:{id:thread,sessionId:thread,status:{type:active?'active':'idle'},turns:active?[{id:turn,status:'inProgress'}]:[]}}});
} else if(m.method==='thread/turns/list') send({id:m.id,result:{data:active?[{id:turn,status:'inProgress',items:[],itemsView:'notLoaded'}]:[],nextCursor:null}});
else if(m.method==='turn/start') {active=true;prompt=JSON.stringify(p);const envelope=JSON.parse(p.input.find(i=>i.type==='text').text);contract=envelope.completionContract??(envelope.completion?{revision:envelope.completion.revision,criteria:envelope.completion.criterionIds.map(id=>({id}))}:null);send({id:m.id,result:{turn:{id:turn,status:'inProgress'}}});send({method:'turn/started',params:{threadId:thread,turn:{id:turn,status:'inProgress'}}});call('get_task_context',{});}
else if(m.method==='turn/interrupt') {active=false;send({id:m.id,result:{}});send({method:'turn/completed',params:{threadId:thread,turn:{id:p.turnId??turn,status:'interrupted'}}});}
else send({id:m.id,result:{}});
}
`, { mode: 0o600 });
const quote = (value: string) => `'${value.replaceAll("'", "'\\''")}'`;
await writeFile(command, `#!/bin/sh\nexec ${quote(process.execPath)} ${quote(provider)}\n`, { mode: 0o700 });
await chmod(command, 0o700);
const resolver = await vi.importActual<{ resolveCodexCommand: () => string }>("../../../packages/paperclip-runner/src/drivers/codex/codex-command.js");
const spy = vi.spyOn(resolver, "resolveCodexCommand").mockReturnValue(command); restoreCodex = () => spy.mockRestore();
const wait = async (predicate: () => Promise<boolean>, label: string, bound = 35_000) => {
const deadline = Date.now() + bound;
while (Date.now() < deadline) { if (await predicate()) return; await new Promise(resolve => setTimeout(resolve, 20)); }
const state = await db.select({ id: heartbeatRuns.id, agentId: heartbeatRuns.agentId, status: heartbeatRuns.status, error: heartbeatRuns.error, result: heartbeatRuns.resultJson }).from(heartbeatRuns);
const ledger = await db.select().from(caseHandoffs).where(eq(caseHandoffs.caseId, initial.caseId));
const wakes = await db.select().from(agentWakeupRequests).where(eq(agentWakeupRequests.companyId, companyId));
throw new Error(`${label}: runs=${JSON.stringify(state)}; handoffs=${JSON.stringify(ledger)}; wakes=${JSON.stringify(wakes)}; provider=${await readFile(config.errors, "utf8").catch(() => "no scripted-provider error")}`);
};
const delivery = caseHandoffDeliveryService(db, { heartbeat });
const seeded = await db.select({ issueId: issueDocuments.issueId, key: issueDocuments.key, body: documents.latestBody })
.from(issueDocuments).innerJoin(documents, eq(documents.id, issueDocuments.documentId))
.where(eq(issueDocuments.issueId, initial.taskId)).orderBy(issueDocuments.key);
expect(seeded).toEqual([
{ issueId: initial.taskId, key: "brief", body: "Seeded native task brief canary" },
{ issueId: initial.taskId, key: "workflow", body: "Workflow routing canary: triage reads the brief, implementation saves evidence, verification checks it, and finalization closes this same task." },
]);
expect(await db.select().from(caseDocuments).where(eq(caseDocuments.caseId, initial.caseId))).toHaveLength(0);
await delivery.sweepPending();
await wait(async () => existsSync(config.accepted), "scripted provider did not receive a successful native handoff response");
const accepted = JSON.parse(await readFile(config.accepted, "utf8"));
const receipt = accepted.value.result?.handoffId ? accepted.value.result : accepted.value;
expect(receipt).toMatchObject({ taskId: initial.taskId, state: "awaiting_release", callerMustYield: true });
expect(JSON.parse(await readFile(config.exposed, "utf8")).names).toContain("create_case");
expect(JSON.parse(await readFile(config.exposed, "utf8")).creationSchema.required).toContain("kickoff");
expect(await db.select().from(cases).where(eq(cases.companyId, companyId))).toHaveLength(1);
// No provider finish call exists in the script. Only the production native
// governed-wait observer can settle this run successfully.
await heartbeat.drainActiveRunExecutions();
const [source] = await db.select().from(heartbeatRuns).where(and(eq(heartbeatRuns.companyId, companyId), eq(heartbeatRuns.agentId, triage)));
expect(source).toMatchObject({ runtimeMode: "native", status: "succeeded" });
expect(source!.resultJson).toMatchObject({ caseHandoffExecutionReleased: { issueId: initial.taskId },
nativeResult: { reportedWorkDisposition: "yielded", continuation: { kind: "case_handoff", handoffId: receipt.handoffId } } });
const [sourceSession] = await db.select().from(agentTaskSessions).where(and(eq(agentTaskSessions.agentId, triage), eq(agentTaskSessions.taskKey, initial.taskId)));
expect(sourceSession).toMatchObject({ lastRunId: source!.id, sessionParamsJson: {
__paperclipConfigFingerprint: expect.any(String), __paperclipConfigFingerprintVersion: expect.any(Number),
} });
expect(sourceSession!.sessionDisplayId).toBeTruthy();
expect(() => process.kill(accepted.pid, 0)).toThrow();
expect(await db.select().from(heartbeatRuns).where(eq(heartbeatRuns.agentId, engineer))).toHaveLength(0);
expect((await db.select().from(issues).where(eq(issues.id, initial.taskId)))[0]!.status).not.toBe("done");
await caseHandoffDeliveryService(db, { heartbeat }).sweepPending();
await wait(async () => existsSync(config.observed), "native successor did not read and save its admitted context");
const observed = JSON.parse(await readFile(config.observed, "utf8"));
expect(observed).toMatchObject({ actorId: engineer, taskId: initial.taskId });
const [successor] = await db.select().from(heartbeatRuns).where(eq(heartbeatRuns.agentId, engineer));
expect(successor).toMatchObject({ runtimeMode: "native", nativeIssueId: initial.taskId });
expect(successor!.contextSnapshot?.paperclipCase).toMatchObject({ phase: "implementation", handoffVersion: 2, taskId: initial.taskId,
incomingHandoff: { instructions: expect.stringContaining("Implement the persisted native specification canary") } });
const [document] = await db.select({ body: documents.latestBody }).from(issueDocuments)
.innerJoin(documents, eq(documents.id, issueDocuments.documentId))
.where(and(eq(issueDocuments.issueId, initial.taskId), eq(issueDocuments.key, "native-handoff-observed")));
expect(JSON.parse(document!.body)).toMatchObject({ taskId: initial.taskId, caseId: initial.caseId, freshPrompt: true });
expect((await db.select().from(cases).where(eq(cases.id, initial.caseId)))[0]?.fields).toMatchObject({ verified: true });
expect(await db.select().from(issues).where(eq(issues.companyId, companyId))).toHaveLength(1);
await heartbeat.drainActiveRunExecutions();
expect((await db.select().from(heartbeatRuns).where(eq(heartbeatRuns.id, successor!.id)))[0]).toMatchObject({
status: "succeeded", resultJson: { nativeResult: { reportedWorkDisposition: "yielded" } },
});
await delivery.sweepPending();
await wait(async () => existsSync(config.returned), "returning native agent did not resume its own task session");
const returned = JSON.parse(await readFile(config.returned, "utf8"));
expect(returned).toMatchObject({ actorId: triage, taskId: initial.taskId, threadMethod: "thread/resume" });
expect(returned.prompt).toContain("Verify the saved native handoff observation and finish this case");
expect(returned.prompt.split("Verify the saved native handoff observation and finish this case")).toHaveLength(2);
expect(returned.prompt).toContain("verification");
const returningEnvelope = JSON.parse(JSON.parse(returned.prompt).input.find((item: { type: string }) => item.type === "text").text);
expect(returningEnvelope.schema).toBe("paperclip.native-continuation.v1");
await heartbeat.drainActiveRunExecutions();
await delivery.sweepPending();
await wait(async () => existsSync(config.finalTurn), "verified native agent did not resume the unchanged case");
const finalTurn = JSON.parse(await readFile(config.finalTurn, "utf8"));
expect(finalTurn.threadMethod).toBe("thread/resume");
const finalEnvelope = JSON.parse(JSON.parse(finalTurn.prompt).input.find((item: { type: string }) => item.type === "text").text);
expect(finalEnvelope.schema).toBe("paperclip.native-continuation.v1");
const finalEvents = JSON.parse(finalEnvelope.events);
expect(finalEvents.workflowCase).toMatchObject({ phase: "finalization", factsUnchanged: true,
incomingHandoff: { instructions: "Handoff to finalization\n\nFinish the verified native handoff case" } });
expect(finalEvents.workflowCase).not.toHaveProperty("data");
expect(finalTurn.prompt).not.toContain("persisted native specification canary");
expect(finalTurn.prompt.split("Finish the verified native handoff case")).toHaveLength(2);
await heartbeat.drainActiveRunExecutions();
const terminalValue = JSON.parse(await readFile(config.terminal, "utf8"));
const terminalReceipt = terminalValue.result?.handoffId ? terminalValue.result : terminalValue;
expect(terminalReceipt).toMatchObject({ taskId: initial.taskId, state: "awaiting_completion", callerMustYield: false });
const finished = (await db.select().from(heartbeatRuns).where(and(eq(heartbeatRuns.companyId, companyId), eq(heartbeatRuns.agentId, triage)))).find(run => run.resultJson?.nativeResult && (run.resultJson.nativeResult as { reportedWorkDisposition?: string }).reportedWorkDisposition === "done");
expect(finished).toMatchObject({ status: "succeeded", sessionIdBefore: sourceSession!.sessionDisplayId,
usageJson: { sessionReused: true, taskSessionReused: true, freshSession: false },
resultJson: { nativeResult: { reportedWorkDisposition: "done" }, configFreshness: { session: { reset: false, storedFingerprintPresent: true } } } });
expect((await db.select().from(issues).where(eq(issues.id, initial.taskId)))[0]).toMatchObject({ status: "done" });
expect((await db.select().from(cases).where(eq(cases.id, initial.caseId)))[0]).toMatchObject({ status: "done", phase: "done", completedAt: expect.any(Date) });
const ledger = await db.select().from(caseHandoffs).where(eq(caseHandoffs.caseId, initial.caseId));
expect(ledger).toHaveLength(5);
expect(ledger.map(row => row.issueId)).toEqual([initial.taskId, initial.taskId, initial.taskId, initial.taskId, initial.taskId]);
expect(ledger.find(row => row.destinationKind === "done")).toMatchObject({ state: "completed", deliveredAt: null, completedAt: expect.any(Date) });
expect(await db.select().from(caseEvents).where(and(eq(caseEvents.caseId, initial.caseId), eq(caseEvents.kind, "handoff_completed")))).toHaveLength(1);
}, 90_000);
});