@shivaedev/agent-claude-code 0.2.0 → 0.3.0

package/src/adapters/openWorkflowNodes.ts

@@ -0,0 +1,73 @@
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import { type WorkflowAgentRef, workflowRunRef } from "#adapters/mirrorKeys.ts";
+import { claudeRaw } from "#adapters/rawPayload.ts";
+import type { WorkflowIdentities, WorkflowIdentity } from "#adapters/workflowIdentity.ts";
+import type { Origin } from "#protocol.ts";
+
+interface NodeState {
+	named: boolean;
+	settled: boolean;
+}
+interface WorkflowNodes {
+	readonly known: (agentId: string) => boolean;
+	readonly opened: (ref: WorkflowAgentRef) => readonly RunEvent[];
+	readonly originOf: (ref: WorkflowAgentRef) => Origin;
+	readonly settled: () => readonly RunEvent[];
+}
+function openedEvent(ref: WorkflowAgentRef, identity: WorkflowIdentity | undefined, spawnedBy: string): RunEvent {
+	return {
+		...(identity?.label === undefined ? {} : { label: identity.label }),
+		childRef: ref.agentId,
+		raw: claudeRaw("workflow/agent", { ...ref, ...identity }),
+		spawnedBy,
+		type: "child.opened",
+	};
+}
+export function openWorkflowNodes(identities: WorkflowIdentities): WorkflowNodes {
+	const nodes = new Map<string, NodeState>();
+	function spawnerOf(ref: WorkflowAgentRef): string {
+		return identities.of(ref.agentId)?.spawnedBy ?? workflowRunRef(ref.runId);
+	}
+	function opened(ref: WorkflowAgentRef): readonly RunEvent[] {
+		const identity = identities.of(ref.agentId);
+		const state = nodes.get(ref.agentId);
+		if (state === undefined) {
+			nodes.set(ref.agentId, {
+				named: identity?.label !== undefined,
+				settled: false,
+			});
+			return [openedEvent(ref, identity, spawnerOf(ref))];
+		}
+		if (state.named || identity?.label === undefined) {
+			return [];
+		}
+		state.named = true;
+		return [openedEvent(ref, identity, spawnerOf(ref))];
+	}
+	function settled(): readonly RunEvent[] {
+		return [...nodes].flatMap(([agentId, state]) => {
+			const ending = identities.of(agentId)?.ended;
+			if (state.settled || ending === undefined) {
+				return [];
+			}
+			state.settled = true;
+			return [
+				{
+					childRef: agentId,
+					outcome: ending,
+					raw: claudeRaw("workflow/agent-ended", {
+						agentId,
+						...identities.of(agentId),
+					}),
+					type: "child.ended",
+				} satisfies RunEvent,
+			];
+		});
+	}
+	return {
+		known: (agentId) => nodes.has(agentId),
+		opened,
+		originOf: (ref) => ({ node: ref.agentId, spawnedBy: spawnerOf(ref) }),
+		settled,
+	};
+}

package/src/adapters/rateLimitEvent.ts

@@ -0,0 +1,45 @@
+import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import type { RawPayload } from "#protocol.ts";
+
+type Info = Extract<
+	SDKMessage,
+	{
+		type: "rate_limit_event";
+	}
+>["rate_limit_info"];
+const STATUS = { allowed: "allowed", "allowed_warning": "warning", rejected: "rejected" } as const;
+const WINDOWS = {
+	"five_hour": { durationMinutes: 300 },
+	overage: {},
+	"seven_day": { durationMinutes: 10_080 },
+	"seven_day_opus": { durationMinutes: 10_080, model: "opus" },
+	"seven_day_overage_included": { durationMinutes: 10_080 },
+	"seven_day_sonnet": { durationMinutes: 10_080, model: "sonnet" },
+};
+export function rateLimitEvent(
+	raw: RawPayload,
+	message: Extract<
+		SDKMessage,
+		{
+			type: "rate_limit_event";
+		}
+	>,
+): RunEvent {
+	const info: Info = message.rate_limit_info;
+	return {
+		raw,
+		status: STATUS[info.status],
+		type: "rate.limit",
+		windows:
+			info.utilization === undefined
+				? []
+				: [
+						{
+							...(info.rateLimitType === undefined ? {} : WINDOWS[info.rateLimitType]),
+							...(info.resetsAt === undefined ? {} : { resetsAt: info.resetsAt * 1000 }),
+							usedPercent: Math.round(info.utilization * 100),
+						},
+					],
+	};
+}

package/src/adapters/rawPayload.ts

@@ -0,0 +1,13 @@
+import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { RawPayload } from "#protocol.ts";
+export function claudeRaw(kind: string, payload: unknown): RawPayload {
+	return {
+		kind,
+		payload: JSON.stringify(payload),
+		source: "claude",
+	};
+}
+export function rawOf(message: SDKMessage): RawPayload {
+	const subtype = "subtype" in message && typeof message.subtype === "string" ? `/${message.subtype}` : "";
+	return claudeRaw(`${message.type}${subtype}`, message);
+}

package/src/adapters/repairSession.ts

@@ -0,0 +1,20 @@
+import { Effect } from "effect";
+import { BackendUnavailable } from "@shivaedev/agent/failures.ts";
+import { ClaudeProvider } from "#adapters/ClaudeProvider.ts";
+import type { Repair } from "#adapters/workflowAdoption.ts";
+
+export const repairSession = Effect.fn("ClaudeCode.repairSession")(function* (sessionId: string, cwd: string) {
+	const peer = yield* ClaudeProvider;
+	return yield* Effect.tryPromise({
+		catch: (error) => new BackendUnavailable({ backend: "claude-code", message: String(error) }),
+		try: async () => {
+			const ids = await peer.listSubagents(sessionId, { dir: cwd });
+			return Promise.all(ids.map(async (agentId) => ({ agentId, messages: await peer.getSubagentMessages(sessionId, agentId, { dir: cwd }) })));
+		},
+	}).pipe(
+		Effect.match({
+			onFailure: (error): Repair => ({ agents: [], failure: error.message }),
+			onSuccess: (agents): Repair => ({ agents, failure: undefined }),
+		}),
+	);
+});

package/src/adapters/sessionLanes.ts

@@ -0,0 +1,127 @@
+import type { SDKMessage, SessionKey, SessionStoreEntry } from "@anthropic-ai/claude-agent-sdk";
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import { agentFileRef, subagentRef, workflowAgentRef } from "#adapters/mirrorKeys.ts";
+import { openSessionMapping } from "#adapters/openSessionMapping.ts";
+import { openWorkflowNodes } from "#adapters/openWorkflowNodes.ts";
+import { claudeRaw } from "#adapters/rawPayload.ts";
+import { transcriptEvents } from "#adapters/transcriptEvents.ts";
+import { adoptedEvents, censusGap, type Repair } from "#adapters/workflowAdoption.ts";
+import { openWorkflowIdentities } from "#adapters/workflowIdentity.ts";
+import type { Origin } from "#protocol.ts";
+export interface MirrorWrite {
+	readonly entries: readonly SessionStoreEntry[];
+	readonly key: SessionKey;
+}
+export type Delivery =
+	| {
+			readonly kind: "frame";
+			readonly message: SDKMessage;
+			readonly inputId?: string;
+	  }
+	| {
+			readonly kind: "mirror";
+			readonly write: MirrorWrite;
+	  }
+	| {
+			readonly kind: "repair";
+			readonly repair: Repair;
+	  };
+export function openSessionLanes() {
+	const mapping = openSessionMapping();
+	const identities = openWorkflowIdentities();
+	const nodes = openWorkflowNodes(identities);
+	const seen = new Set<string>();
+	const mirroredOrigins = new Map<string, Origin>();
+	function recorded(id: string) {
+		return mirroredOrigins.has(id) || nodes.known(id) || mapping.spawnerOf(id) !== undefined;
+	}
+	function unique(uuid: string | undefined, events: readonly RunEvent[]): readonly RunEvent[] {
+		if (uuid === undefined) {
+			return events;
+		}
+		return events.filter((event, index) => {
+			if (event.type === "child.opened" || event.type === "child.ended") {
+				return true;
+			}
+			const key = `${uuid}:${event.type}:${index}`;
+			if (seen.has(key)) {
+				return false;
+			}
+			seen.add(key);
+			return true;
+		});
+	}
+	function mirrored({ entries, key }: MirrorWrite): readonly RunEvent[] {
+		const ref = workflowAgentRef(key);
+		const node = subagentRef(key);
+		let origin: Origin | undefined;
+		if (ref !== undefined) {
+			origin = nodes.originOf(ref);
+		} else if (node !== undefined) {
+			origin = { node, spawnedBy: mapping.spawnerOf(node) ?? agentFileRef(node) };
+		}
+		const opened: RunEvent[] =
+			node !== undefined && ref === undefined && !recorded(node)
+				? [{ childRef: node, spawnedBy: origin?.spawnedBy ?? agentFileRef(node), type: "child.opened" }]
+				: [];
+		if (node !== undefined && origin !== undefined) {
+			mirroredOrigins.set(node, origin);
+		}
+		return [
+			...opened,
+			...(ref === undefined ? [] : nodes.opened(ref)),
+			...entries.flatMap((entry) => unique(entry.uuid, transcriptEvents(entry, origin))),
+			...nodes.settled(),
+		];
+	}
+	function repaired(repair: Repair): readonly RunEvent[] {
+		return [
+			...repair.agents.flatMap((agent): readonly RunEvent[] => {
+				if (!recorded(agent.agentId)) {
+					const missing = agent.messages.flatMap((message) =>
+						unique(
+							message.uuid,
+							transcriptEvents(message, { node: agent.agentId, spawnedBy: message.parent_tool_use_id ?? agentFileRef(agent.agentId) }),
+						),
+					);
+					return adoptedEvents(agent, missing);
+				}
+				const origin = mirroredOrigins.get(agent.agentId) ?? {
+					node: agent.agentId,
+					spawnedBy: mapping.spawnerOf(agent.agentId) ?? agentFileRef(agent.agentId),
+				};
+				const missing = agent.messages.flatMap((message) => unique(message.uuid, transcriptEvents(message, origin)));
+				if (missing.length === 0) {
+					return [];
+				}
+				const gap: RunEvent = {
+					detail: "Stored transcript UUIDs reveal output absent from the stream and mirror; recovered output follows",
+					kind: "missing-output",
+					origin,
+					raw: claudeRaw("subagent/unrecorded-lines", { agentId: agent.agentId, uuids: agent.messages.map((message) => message.uuid) }),
+					type: "gap",
+				};
+				return [gap, ...missing];
+			}),
+			...(repair.failure === undefined ? [] : [censusGap(repair.failure)]),
+		];
+	}
+	return {
+		deliver: (delivery: Delivery): readonly RunEvent[] => {
+			if (delivery.kind === "mirror") {
+				return mirrored(delivery.write);
+			}
+			if (delivery.kind === "repair") {
+				return repaired(delivery.repair);
+			}
+			const message = delivery.message;
+			if (message.type === "system" && message.subtype === "task_progress") {
+				identities.observe(message);
+				return nodes.settled();
+			}
+			return unique(message.uuid, mapping.frame(message)).map((event) =>
+				event.type === "message" && delivery.inputId !== undefined ? { ...event, inputId: delivery.inputId } : event,
+			);
+		},
+	};
+}

package/src/adapters/sessionOptions.ts

@@ -0,0 +1,42 @@
+import { resolve } from "node:path";
+import type { EffortLevel, Options, SessionStore } from "@anthropic-ai/claude-agent-sdk";
+import type { StartRequest } from "@shivaedev/agent/run.ts";
+import type { makeToolServer } from "#adapters/toolServer.ts";
+import { TOOL_SERVER_NAME } from "#adapters/toolServer.ts";
+import type { ClaudeOptions } from "#options.ts";
+
+function harness(config: ClaudeOptions): Partial<Options> {
+	if (config.systemPrompt !== undefined) {
+		return { settingSources: [], strictMcpConfig: true, systemPrompt: config.systemPrompt, tools: [] };
+	}
+	return config.skills === undefined ? {} : { plugins: [{ path: config.skills, type: "local" }] };
+}
+
+export function sessionOptions(
+	request: StartRequest,
+	config: ClaudeOptions,
+	store: SessionStore,
+	effort: EffortLevel | undefined,
+	resume: string | undefined,
+	server: Awaited<ReturnType<typeof makeToolServer>> | undefined,
+): Options {
+	return {
+		cwd: resolve(request.cwd),
+		forwardSubagentText: true,
+		permissionMode: "auto",
+		sessionStore: store,
+		sessionStoreFlush: "eager",
+		settings: { env: { "CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS": "1" } },
+		...(request.model === undefined ? {} : { model: request.model }),
+		...(effort === undefined ? {} : { effort }),
+		...(resume === undefined ? {} : { resume }),
+		...(config.executable === undefined ? {} : { pathToClaudeCodeExecutable: config.executable }),
+		...harness(config),
+		...(server === undefined
+			? {}
+			: {
+					allowedTools: (config.tools ?? []).map((tool) => `mcp__${TOOL_SERVER_NAME}__${tool.name}`),
+					mcpServers: { [TOOL_SERVER_NAME]: { instance: server, name: TOOL_SERVER_NAME, type: "sdk" } },
+				}),
+	};
+}

package/src/adapters/spilledPreview.ts

@@ -0,0 +1,24 @@
+import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import { isRecord } from "#adapters/blocks.ts";
+import type { Origin, RawPayload } from "#protocol.ts";
+// Oversized tool results carry only a preview inline and name the stored full output in `persistedOutputPath`.
+export function spilledPreview(raw: RawPayload, message: SDKMessage, origin: Origin | undefined): readonly RunEvent[] {
+	if (!("tool_use_result" in message && isRecord(message.tool_use_result))) {
+		return [];
+	}
+	const spill = message.tool_use_result;
+	if (typeof spill.persistedOutputPath !== "string") {
+		return [];
+	}
+	const size = typeof spill.persistedOutputSize === "number" ? ` (${spill.persistedOutputSize} bytes)` : "";
+	return [
+		{
+			detail: `full tool output spilled to ${spill.persistedOutputPath}${size}`,
+			kind: "spilled-preview",
+			...(origin === undefined ? {} : { origin }),
+			raw,
+			type: "gap",
+		},
+	];
+}

package/src/adapters/subsessionEndings.ts

@@ -0,0 +1,80 @@
+import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import { isRecord, textOf } from "#adapters/blocks.ts";
+import type { ChildOutcome, RawPayload } from "#protocol.ts";
+
+type SystemMessage = Extract<
+	SDKMessage,
+	{
+		type: "system";
+	}
+>;
+type TaskUpdated = Extract<
+	SystemMessage,
+	{
+		subtype: "task_updated";
+	}
+>;
+type TaskNotification = Extract<
+	SystemMessage,
+	{
+		subtype: "task_notification";
+	}
+>;
+export interface Ending {
+	readonly childRef: string;
+	readonly outcome: ChildOutcome;
+	readonly summary: string | undefined;
+}
+export function endedEvent(raw: RawPayload, ending: Ending): RunEvent {
+	return {
+		childRef: ending.childRef,
+		outcome: ending.outcome,
+		raw,
+		...(ending.summary === undefined ? {} : { summary: ending.summary }),
+		type: "child.ended",
+	};
+}
+const LIVE = new Set(["paused", "pending", "running"]);
+function patchedOutcome(status: string): ChildOutcome {
+	if (status === "completed") {
+		return "completed";
+	}
+	if (status === "failed") {
+		return "failed";
+	}
+	return status === "killed" ? "interrupted" : "unknown";
+}
+// Claude emits no task-completed frame; the first patch outside the live states is terminal.
+export function updatedEnding(message: TaskUpdated): Ending | undefined {
+	const status = message.patch.status;
+	if (status === undefined || LIVE.has(status)) {
+		return undefined;
+	}
+	return {
+		childRef: message.task_id,
+		outcome: patchedOutcome(status),
+		summary: undefined,
+	};
+}
+export function notifiedEnding(message: TaskNotification): Ending {
+	return {
+		childRef: message.task_id,
+		outcome: message.status === "stopped" ? "interrupted" : message.status,
+		summary: message.summary,
+	};
+}
+export function reportedEnding(message: SDKMessage): Ending | undefined {
+	if (!("tool_use_result" in message && isRecord(message.tool_use_result))) {
+		return undefined;
+	}
+	const output = message.tool_use_result;
+	if (output.status !== "completed" || typeof output.agentId !== "string") {
+		return undefined;
+	}
+	return {
+		childRef: output.agentId,
+		outcome: "completed",
+		summary: Array.isArray(output.content) ? textOf(output.content) : undefined,
+	};
+}

package/src/adapters/systemEvents.ts

@@ -0,0 +1,60 @@
+import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import type { RawPayload } from "#protocol.ts";
+
+type StateMessage = Extract<
+	SDKMessage,
+	{
+		subtype: "session_state_changed";
+	}
+>;
+type TasksMessage = Extract<
+	SDKMessage,
+	{
+		subtype: "background_tasks_changed";
+	}
+>;
+const STATE: Record<StateMessage["state"], "running" | "awaiting-input"> = {
+	idle: "awaiting-input",
+	"requires_action": "awaiting-input",
+	running: "running",
+};
+function stateEvent(raw: RawPayload, message: StateMessage): RunEvent {
+	return {
+		raw,
+		state: STATE[message.state],
+		type: "execution",
+	};
+}
+function backgroundEvent(raw: RawPayload, message: TasksMessage): RunEvent {
+	return {
+		raw,
+		tasks: message.tasks.map((task) => ({
+			description: task.description,
+			id: task.task_id,
+			kind: task.task_type,
+		})),
+		type: "session.background",
+	};
+}
+type SystemMessage = Extract<
+	SDKMessage,
+	{
+		type: "system";
+	}
+>;
+export function systemEvents(raw: RawPayload, message: SystemMessage): readonly RunEvent[] | undefined {
+	if (message.subtype === "init") {
+		return [{ raw, reference: message.session_id, type: "session.opened" }];
+	}
+	if (message.subtype === "session_state_changed") {
+		return [stateEvent(raw, message)];
+	}
+	if (message.subtype === "background_tasks_changed") {
+		return [backgroundEvent(raw, message)];
+	}
+	if (message.subtype === "thinking_tokens" || message.subtype === "task_progress") {
+		return [];
+	}
+	return undefined;
+}

package/src/adapters/toolIdentity.ts

@@ -0,0 +1,12 @@
+import { TOOL_SERVER_NAME } from "#adapters/toolServer.ts";
+export function toolIdentity(wireName: string): {
+	name: string;
+	providerName?: string;
+} {
+	const match = /^mcp__(?<server>.+?)__(?<tool>.+)$/u.exec(wireName);
+	const server = match?.groups?.server;
+	const tool = match?.groups?.tool;
+	return server === undefined || tool === undefined
+		? { name: wireName }
+		: { name: server === TOOL_SERVER_NAME ? tool : `${server}: ${tool}`, providerName: wireName };
+}

package/src/adapters/toolServer.ts

@@ -0,0 +1,31 @@
+import { randomUUID } from "node:crypto";
+import { Effect } from "effect";
+import type { ClaudeTool } from "#options.ts";
+export const TOOL_SERVER_NAME = "platform";
+export async function makeToolServer(tools: readonly ClaudeTool[]) {
+	const [{ McpServer }, { CallToolRequestSchema, ListToolsRequestSchema }] = await Promise.all([
+		import("@modelcontextprotocol/sdk/server/mcp.js"),
+		import("@modelcontextprotocol/sdk/types.js"),
+	]);
+	const namespace = randomUUID();
+	const byName = new Map(tools.map((tool) => [tool.name, tool]));
+	const server = new McpServer({ name: TOOL_SERVER_NAME, version: "0.0.0" });
+	server.server.registerCapabilities({ tools: { listChanged: true } });
+	server.server.setRequestHandler(ListToolsRequestSchema, () => ({
+		tools: tools.map((tool) => ({
+			"_meta": { "anthropic/alwaysLoad": true },
+			description: tool.description,
+			inputSchema: { ...tool.inputSchema, type: "object" as const },
+			name: tool.name,
+		})),
+	}));
+	server.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+		const tool = byName.get(request.params.name);
+		const outcome =
+			tool === undefined
+				? { ok: false, text: `No tool named ${request.params.name}` }
+				: await Effect.runPromise(tool.call(request.params.arguments, `${namespace}:${String(extra.requestId)}`), { signal: extra.signal });
+		return { content: [{ text: outcome.text, type: "text" }], isError: !outcome.ok };
+	});
+	return server;
+}

package/src/adapters/transcriptEvents.ts

@@ -0,0 +1,21 @@
+import type { SessionMessage, SessionStoreEntry } from "@anthropic-ai/claude-agent-sdk";
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import { blockEvent, contentBlocks } from "#adapters/blocks.ts";
+import { claudeRaw } from "#adapters/rawPayload.ts";
+import type { Origin } from "#protocol.ts";
+
+const ROLES = { assistant: "agent", user: "user" } as const;
+function roleOf(type: string): "agent" | "user" | undefined {
+	return type === "assistant" || type === "user" ? ROLES[type] : undefined;
+}
+export function transcriptEvents(entry: SessionStoreEntry | SessionMessage, origin: Origin | undefined): readonly RunEvent[] {
+	const raw = claudeRaw(`transcript/${entry.type}`, entry);
+	const role = roleOf(entry.type);
+	if (role === undefined) {
+		return [{ raw, type: "raw" }];
+	}
+	const events = contentBlocks(entry)
+		.map((block) => blockEvent(raw, role, block, origin))
+		.filter((event): event is RunEvent => event !== undefined);
+	return events.length === 0 ? [{ raw, type: "raw" }] : events;
+}

package/src/adapters/workflowAdoption.ts

@@ -0,0 +1,58 @@
+import type { SessionMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import { agentFileRef } from "#adapters/mirrorKeys.ts";
+import { claudeRaw } from "#adapters/rawPayload.ts";
+import type { Origin } from "#protocol.ts";
+export interface AdoptedAgent {
+	readonly agentId: string;
+	readonly messages: readonly SessionMessage[];
+}
+export interface Repair {
+	readonly agents: readonly AdoptedAgent[];
+	readonly failure: string | undefined;
+}
+function admissionOrigin(agent: AdoptedAgent): Origin {
+	return {
+		node: agent.agentId,
+		spawnedBy: agent.messages[0]?.parent_tool_use_id ?? agentFileRef(agent.agentId),
+	};
+}
+function adoptedGap(agent: AdoptedAgent, origin: Origin): RunEvent {
+	return {
+		detail: `this node was read back from its stored transcript after the live record missed it, ${agent.messages.length} messages already written`,
+		kind: "adopted-late",
+		origin,
+		raw: claudeRaw("workflow/adopted-late", { agentId: agent.agentId }),
+		type: "gap",
+	};
+}
+function adoptedEnding(agent: AdoptedAgent): RunEvent {
+	return {
+		childRef: agent.agentId,
+		outcome: "unknown",
+		raw: claudeRaw("workflow/adopted-late", { agentId: agent.agentId }),
+		type: "child.ended",
+	};
+}
+export function censusGap(failure: string): RunEvent {
+	return {
+		detail: `subagent backfill source unreachable; this session's workflow census could not be checked: ${failure}`,
+		kind: "unknown",
+		raw: claudeRaw("workflow/census-unreadable", { failure }),
+		type: "gap",
+	};
+}
+export function adoptedEvents(agent: AdoptedAgent, recovered: readonly RunEvent[]): readonly RunEvent[] {
+	const origin = admissionOrigin(agent);
+	return [
+		{
+			childRef: agent.agentId,
+			raw: claudeRaw("workflow/adopted-late", { agentId: agent.agentId }),
+			spawnedBy: origin.spawnedBy,
+			type: "child.opened",
+		},
+		adoptedGap(agent, origin),
+		...recovered,
+		adoptedEnding(agent),
+	];
+}