pi-radar 0.6.0 → 0.9.0

package/extension/baseline.ts

@@ -1,6 +1,7 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createRadarClient } from "./radar-client.ts";
+import { createRadarChildren } from "./radar-children.ts";
 import { createRadarHandoffPort } from "./radar-communication.ts";
 import {
 	createRadarExecutionAdapter,
@@ -33,6 +34,7 @@ export default function registerPiRadar(pi: PiRadarHost): void {
 	const runtime = lazyRadarRuntime(async () => ({
 		publication: execution.publication,
 		communication: createRadarHandoffPort(client, execution.publication),
+		children: createRadarChildren(client, execution.publication),
 		execution,
 	}));
 	provideRadarRuntime(pi.events, runtime);

package/extension/generated-contracts.ts

@@ -11,7 +11,6 @@ export interface PresenceReportDeserialize {
   run?: string | null;
   session_id: string;
   source: string;
-  spawn_token?: string | null;
   subject_id?: string | null;
 }
 /**
@@ -54,7 +53,7 @@ export interface PresenceReportProcessIdentity {
   start_ticks: number;
   [k: string]: unknown;
 }
-export type PresenceAnswerStanding = "pending" | "granted" | "duplicate" | "released";
+export type PresenceAnswerStanding = "reserved" | "pending" | "granted" | "duplicate" | "released";
 
 /**
  * The small public receipt; session/location context stays inside Radar.
@@ -284,7 +283,7 @@ export type Freshness = "fresh" | "stale";
  * refused rather than silently dropped.
  */
 export type Report = Snapshot | AssignmentSnapshot | FactsSnapshot;
-export type Standing = "pending" | "granted" | "duplicate" | "released";
+export type Standing = "reserved" | "pending" | "granted" | "duplicate" | "released";
 /**
  * How a registration relates to the live panes.
  */
@@ -675,6 +674,11 @@ export interface RegistryAgent {
   facts: PublicChannelFacts | null;
   process: ProcessEvidence;
   registration: PublicRegistration;
+  /**
+   * Whether this process runs inside a Radar-established execution scope. A
+   * process started outside the managed launch path has none and is observed.
+   */
+  scoped?: boolean | null;
 }
 /**
  * A channel read for a reader that is not its writer: the same identity,
@@ -1472,6 +1476,11 @@ export interface SpawnListPageSerializeBoundChild {
    */
   registration_id?: string | null;
   source: string;
+  /**
+   * The durable agent the bound child attaches as. Absent for an edge without
+   * a tracked launch and in records written before it was recorded.
+   */
+  subject_id?: string | null;
 }
 /**
  * Where an agent's incarnation lives on one backend, in that backend's own

package/extension/radar-children.ts

@@ -0,0 +1,176 @@
+import type { RadarClient, RadarChannelSnapshot, RadarResult } from "./radar-client.ts";
+import type { SpawnListPageSerializePublicSpawnTopology as ListedEdge } from "./generated-contracts.ts";
+import { inspectRadarChild, type RadarInspection } from "./radar-inspection.ts";
+import { observeRadarChild, type RadarChildObservation } from "./radar-launch.ts";
+import type { RadarPublication } from "./radar-publication.ts";
+
+const PAGE = 100;
+const MAX_PAGES = 20;
+
+/** One child of the caller, named by the agent that survives its restarts. */
+export type RadarChild = {
+	subject_id: string;
+	/** The launch that last bound this child. */
+	request_id: string;
+	pane_id?: string;
+	state: "unbound" | "bound" | "unresolved";
+	exited: boolean;
+};
+
+/** The assignment a child is held to: published again when its process is replaced. */
+export type RadarChildAssignment = {
+	update(snapshot: RadarChannelSnapshot): void;
+	retire(): void;
+};
+
+export type RadarChildren = {
+	list(): Promise<RadarResult<RadarChild[]>>;
+	assignment(subject: string, owner: string): RadarChildAssignment;
+	retire(subject: string): void;
+	observe(
+		subject: string,
+		session_id: string | undefined,
+	): Promise<RadarChildObservation>;
+	inspect(subject: string, session_id?: string): Promise<RadarInspection>;
+};
+
+type Resolved = { child: RadarChild; registration_id: string };
+
+/**
+ * The caller's children, addressed by subject. A subject gains an edge per launch,
+ * so the newest bound edge is the current process; its registration is read per
+ * call and never remembered, because a remembered registration is the stale key
+ * this surface exists to hide. An edge bound without a subject is not addressable.
+ */
+export function createRadarChildren(
+	client: Pick<RadarClient, "spawnList" | "spawnGet" | "agentGet" | "output" | "processInfo">,
+	publication: Pick<RadarPublication, "assignment" | "retireAssignment">,
+): RadarChildren {
+	const held = new Map<
+		string,
+		{ writer: RadarChildAssignment; published?: string; publish?: (target: Resolved) => void }
+	>();
+
+	async function resolveAll(): Promise<RadarResult<Map<string, Resolved & { at: number }>>> {
+		const newest = new Map<string, Resolved & { at: number }>();
+		let after: string | undefined;
+		for (let page = 0; page < MAX_PAGES; page++) {
+			const read = await client.spawnList({ ...(after !== undefined ? { after } : {}), limit: PAGE });
+			if (read.ok === false) return read;
+			for (const edge of read.value.spawns as ListedEdge[]) {
+				const bound = edge.bound;
+				if (!bound?.subject_id || !bound.registration_id || edge.launched !== "completed") continue;
+				const at = Date.parse(bound.bound_at);
+				if (Number.isNaN(at)) continue;
+				const current = newest.get(bound.subject_id);
+				if (current !== undefined && current.at >= at) continue;
+				newest.set(bound.subject_id, {
+					at,
+					registration_id: bound.registration_id,
+					child: {
+						subject_id: bound.subject_id,
+						request_id: edge.request_id,
+						...(edge.location?.pane ? { pane_id: edge.location.pane } : {}),
+						state: edge.state,
+						exited: edge.exit_observation != null && edge.exit_observation.state !== "unknown",
+					},
+				});
+			}
+			if (!read.value.next) return { ok: true, value: newest };
+			after = read.value.next;
+		}
+		return { ok: false, code: "protocol", message: "the caller's launches exceed the readable pages" };
+	}
+
+	async function resolve(subject: string): Promise<Resolved | undefined> {
+		const all = await resolveAll();
+		return all.ok ? all.value.get(subject) : undefined;
+	}
+
+	async function resolveAndFollow(subject: string): Promise<Resolved | undefined> {
+		const all = await resolveAll();
+		if (!all.ok) return undefined;
+		follow(all.value);
+		return all.value.get(subject);
+	}
+
+	/**
+	 * A child replaced under its subject has a new process with no assignment. Each
+	 * read the caller already makes finds the new registration and moves the held
+	 * assignment onto it, so no caller has to notice a replacement.
+	 */
+	function follow(all: Map<string, Resolved>): void {
+		for (const [subject, entry] of held) {
+			const target = all.get(subject);
+			if (target !== undefined && entry.published !== target.registration_id)
+				entry.publish?.(target);
+		}
+	}
+
+	return {
+		async list() {
+			const all = await resolveAll();
+			if (!all.ok) return all;
+			follow(all.value);
+			return { ok: true, value: [...all.value.values()].map((entry) => entry.child) };
+		},
+		assignment(subject, owner) {
+			const existing = held.get(subject);
+			if (existing !== undefined) return existing.writer;
+			let latest: RadarChannelSnapshot | undefined;
+			const entry: {
+				writer: RadarChildAssignment;
+				published?: string;
+				publish?: (target: Resolved) => void;
+			} = { writer: undefined as unknown as RadarChildAssignment };
+			const send = (target: Resolved): void => {
+				if (latest === undefined) return;
+				if (entry.published !== undefined && entry.published !== target.registration_id)
+					publication.retireAssignment(entry.published);
+				entry.published = target.registration_id;
+				publication.assignment(target.registration_id, owner).update(latest);
+			};
+			entry.publish = send;
+			entry.writer = {
+				update(snapshot) {
+					latest = snapshot;
+					void resolve(subject).then((target) => {
+						if (target !== undefined) send(target);
+					});
+				},
+				retire() {
+					latest = undefined;
+					if (entry.published !== undefined) publication.retireAssignment(entry.published);
+					entry.published = undefined;
+				},
+			};
+			held.set(subject, entry);
+			return entry.writer;
+		},
+		retire(subject) {
+			held.get(subject)?.writer.retire();
+			held.delete(subject);
+		},
+		async observe(subject, session_id) {
+			const target = await resolveAndFollow(subject);
+			if (target === undefined)
+				return { kind: "unknown", diagnostic: "the daemon records no bound launch for this child" };
+			return observeRadarChild(client as RadarClient, {
+				request_id: target.child.request_id,
+				pane_id: target.child.pane_id,
+				registration_id: target.registration_id,
+				session_id,
+			});
+		},
+		async inspect(subject, session_id) {
+			const target = await resolveAndFollow(subject);
+			if (target?.child.pane_id === undefined)
+				throw new Error("Inspection target is not a bound child with a pane");
+			return inspectRadarChild(client as RadarClient, {
+				agentId: target.registration_id,
+				paneId: target.child.pane_id,
+				...(session_id !== undefined ? { session: session_id } : {}),
+			});
+		},
+	};
+}

package/extension/radar-client.ts

@@ -34,15 +34,18 @@ import type {
 export const RADAR_PROTOCOL_VERSION = 2;
 /**
  * Revision 5 names attempts by claim_id and requires exact-claim controls.
+ * Revision 7 starts every managed launch through `radar run --launch` and lets a
+ * parent continue or restart its own child by subject.
  * Earlier daemons expose different identity fields; require a coordinated update.
  */
-export const RADAR_MINIMUM_REVISION = 5;
+export const RADAR_MINIMUM_REVISION = 7;
 /** Public daemon contracts this client may preflight. */
 export const RADAR_REGISTRY_CONTRACT = "registry.v1";
 export const RADAR_REGISTRY_FACTS_CONTRACT = "registry.facts.v1";
 export const RADAR_SPAWN_CONTRACT = "spawn.v1";
 export const RADAR_SPAWN_LIST_CONTRACT = "spawn.list.v1";
 export const RADAR_SPAWN_CLOSE_CONTRACT = "spawn.close.v1";
+export const RADAR_LIFECYCLE_RESTART_CONTRACT = "lifecycle.restart.v1";
 export const RADAR_SPAWN_LAUNCH_CONTEXT_CONTRACT = "spawn.launch_context.v1";
 export const RADAR_EVENTS_CONTRACT = "events.v1";
 export const RADAR_COMMUNICATION_CONTRACT = "communication.handoff.v1";
@@ -304,7 +307,7 @@ export type RadarSpawnEdge = {
 	created: RadarEffectOutcome;
 	launched: RadarEffectOutcome;
 	location?: RadarLocation;
-	bound?: { source: string; incarnation: string; registration_id?: string };
+	bound?: { source: string; incarnation: string; registration_id?: string; subject_id?: string };
 	exit_observation?: RadarSpawnExitObservation;
 };
 
@@ -517,7 +520,7 @@ function decodePresenceAnswer(value: unknown): RadarResult<RadarPresenceAnswer>
 	if (
 		!isUuid(registrationId) ||
 		!isUuid(claimId) ||
-		!["pending", "granted", "duplicate", "released"].includes(String(standing)) ||
+		!["reserved", "pending", "granted", "duplicate", "released"].includes(String(standing)) ||
 		(subjectId !== undefined && !isUuid(subjectId)) ||
 		(standing === "granted" && !isUuid(subjectId))
 	)
@@ -745,7 +748,7 @@ function unresolvedOperation(requestId: string, detail: string): RadarResult<nev
 	};
 }
 
-export const RADAR_SPAWN_TOKEN_ENV = "PI_RADAR_SPAWN_TOKEN";
+export const RADAR_REGISTRATION_ENV = "PI_RADAR_REGISTRATION_ID";
 const RADAR_MANAGED_IDENTITY_ENV = new Set([
 	"PI_RADAR_MANAGED_SUBJECT_ID",
 	"PI_RADAR_MANAGED_LAUNCH_ID",
@@ -825,6 +828,7 @@ function spawnEdge(value: unknown): RadarResult<RadarSpawnEdge> {
 	const source = stringAt(bound, "source");
 	const incarnation = stringAt(bound, "incarnation");
 	const agentId = stringAt(bound, "registration_id");
+	const subjectId = stringAt(bound, "subject_id");
 	const exit = exitAt(recordAt(value, "exit_observation"));
 	return {
 		ok: true,
@@ -840,6 +844,7 @@ function spawnEdge(value: unknown): RadarResult<RadarSpawnEdge> {
 							source,
 							incarnation,
 							...(isUuid(agentId) ? { registration_id: agentId } : {}),
+							...(isUuid(subjectId) ? { subject_id: subjectId } : {}),
 						},
 					}
 				: {}),
@@ -959,9 +964,12 @@ function spawnRequestShape(request: {
 	cwd?: string;
 	env?: Record<string, string>;
 	managed?: RadarManagedLaunchMetadata;
+	continue_subject_id?: string;
 }): string | undefined {
 	if (!isUuid(request.request_id))
 		return "spawn requires a canonical request UUID";
+	if (request.continue_subject_id !== undefined && !isUuid(request.continue_subject_id))
+		return "continue_subject_id must be a canonical UUID";
 	if (!isUuid(request.parent))
 		return "spawn requires the parent's canonical agent UUID";
 	if (!isUuid(request.parent_session_id))
@@ -975,8 +983,8 @@ function spawnRequestShape(request: {
 	const env = Object.entries(request.env ?? {});
 	if (env.length > 256) return "spawn env names more than 256 entries";
 	for (const [name, value] of env) {
-		if (name === RADAR_SPAWN_TOKEN_ENV)
-			return `spawn env cannot set the reserved ${RADAR_SPAWN_TOKEN_ENV}`;
+		if (name === RADAR_REGISTRATION_ENV)
+			return `spawn env cannot set the reserved ${RADAR_REGISTRATION_ENV}`;
 		if (RADAR_MANAGED_IDENTITY_ENV.has(name))
 			return `spawn env cannot set Radar-issued identity variable ${name}`;
 		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name) || /\p{Cc}/u.test(value))
@@ -1100,7 +1108,23 @@ export type RadarClient = {
 		cwd?: string;
 		env?: Record<string, string>;
 		managed?: RadarManagedLaunchMetadata;
+		/** Start this released child agent again, in the session the daemon recorded for it. */
+		continue_subject_id?: string;
 	}): Promise<RadarResult<RadarSpawnEdge>>;
+	/**
+	 * Restart this caller's own live child under a new program. The daemon finds the
+	 * child's current process from the subject and replaces it in its own pane and
+	 * session; a program with a bare argument that may be a message is refused.
+	 */
+	restart(request: {
+		request_id: string;
+		parent: string;
+		subject_id: string;
+		executable: string;
+		argv: string[];
+		cwd?: string;
+		env?: Record<string, string>;
+	}): Promise<RadarResult<{ request_id: string }>>;
 	/** List launches owned by this client's registered process. */
 	spawnList(request: Pick<SpawnListParamsDeserialize, "after" | "limit">): Promise<RadarResult<SpawnListPageSerialize>>;
 	spawnGet(request_id: string): Promise<RadarResult<RadarSpawnTopology>>;
@@ -1671,6 +1695,9 @@ export function createRadarClient(options: RadarClientOptions = {}): RadarClient
 								...(request.managed !== undefined
 									? { managed: request.managed }
 									: {}),
+								...(request.continue_subject_id !== undefined
+									? { continue_subject_id: request.continue_subject_id }
+									: {}),
 							},
 							requester,
 						},
@@ -1706,6 +1733,33 @@ export function createRadarClient(options: RadarClientOptions = {}): RadarClient
 				},
 			);
 		},
+		async restart(request) {
+			if (!isUuid(request.request_id) || !isUuid(request.parent) || !isUuid(request.subject_id))
+				return {
+					ok: false,
+					code: "bad_params",
+					message: "restart requires canonical request, parent and subject UUIDs",
+				};
+			return withContract(RADAR_LIFECYCLE_RESTART_CONTRACT, async () => {
+				const answer = await call(
+					"lifecycle.restart",
+					{
+						request: {
+							subject_id: request.subject_id,
+							parent: request.parent,
+							executable: request.executable,
+							argv: request.argv,
+							...(request.cwd !== undefined ? { cwd: request.cwd } : {}),
+							...(request.env !== undefined ? { env: request.env } : {}),
+						},
+						requester,
+					},
+					request.request_id,
+				);
+				if (answer.ok === false) return answer;
+				return focusOutcome(recordAt(answer.value, "request"), request.request_id);
+			});
+		},
 		async spawnList(request) {
 			const registrationId = processRegistrationId;
 			if (registrationId === undefined)

package/extension/radar-execution.ts

@@ -51,10 +51,10 @@ export type RadarExecutionOptions = {
 	 */
 	location?: () => Promise<RadarLocationResolution>;
 	/**
-	 * A daemon-spawned child's one-use launch token, captured before this process
-	 * could observe anything else. It travels with the registration request only.
+	 * Registration allocated by Radar before this process launched. Normally
+	 * captured from the launch environment by the process-local publication.
 	 */
-	spawnToken?: string;
+	launchRegistrationId?: string;
 	/** Only a real fixed managed assignment is part of immutable registration. */
 	managedBinding?: { key: string; run: string; owner: string; label: string };
 	/**
@@ -207,8 +207,8 @@ export function createRadarExecutionAdapter(
 				? { location: options.location }
 				: {}),
 			...(managed !== undefined ? { binding: managed } : {}),
-			...(options.spawnToken !== undefined
-				? { spawnToken: options.spawnToken }
+			...(options.launchRegistrationId !== undefined
+				? { launchRegistrationId: options.launchRegistrationId }
 				: {}),
 		});
 	} catch {

package/extension/radar-launch.ts

@@ -8,6 +8,7 @@ import {
 	type RadarSpawnEdge,
 } from "./radar-client.ts";
 import { radarPaneHandle } from "./radar-location.ts";
+import type { RadarPublication } from "./radar-publication.ts";
 
 /** The startup acknowledgement a launch waits for, named by its identity. */
 export type StartupExpectation = {
@@ -64,21 +65,22 @@ export type LaunchMailbox<State extends LaunchState> = {
  * different leaves the launch unresolved rather than placed.
  */
 
-/** The exact managed parent this launch may use, and nothing inferred about it. */
-export type RadarLaunchParent = {
-	registration_id: string;
-	/** Stable subject from this process's current Radar registration. */
-	subject_id: string;
-	location?: RadarLocation;
-};
-
 /** Everything one fresh managed worker is launched with. */
 export type RadarWorkerLaunch = {
 	/** The caller's durable key, persisted before dispatch and never replaced. */
 	request_id: string;
 	/** The nonce the child must repeat in its startup acknowledgment. */
 	generation: string;
-	parent: RadarLaunchParent;
+	/**
+	 * Start this released child agent again rather than a new one. The daemon takes
+	 * the session from its own record, so no session id or path is sent.
+	 */
+	continues?: string;
+	/**
+	 * The pane this launch splits. The parent is the calling process itself, read
+	 * from its own publication, and must be registered on exactly this pane.
+	 */
+	pane_id: string;
 	parent_session_id: string;
 	executable: string;
 	argv: string[];
@@ -94,35 +96,13 @@ export type RadarWorkerLaunch = {
 		workspaceId: string;
 		agentLabel: string;
 	};
-	/**
-	 * The child's own published registration, once it has one. It is the second
-	 * witness that the edge's bound id is this launch's child, and it is read
-	 * through the owner's publication store rather than assumed from the pane.
-	 */
-	observedChildAgent?: () => string | undefined;
-	/**
-	 * Persist the daemon's own binding of this launch's edge, the subject it bound
-	 * and the pane it recorded, before readiness is waited for. This is the only
-	 * moment those facts are authoritative: the launch can end without ever
-	 * reaching an acknowledgment, and a reload in that window still has to read
-	 * where the daemon put this child. Throwing leaves the launch unresolved,
-	 * because a binding that was not persisted is one no later reader can hold the
-	 * child by.
-	 */
-	onBound?: (bound: { registration_id: string; pane_id: string }) => void;
 };
 
 export type RadarWorkerLaunched<State = unknown> = {
 	request_id: string;
-	registration_id: string;
+	/** The child's durable identity: the key that survives its restart and resume. */
+	subject_id: string;
 	pane_id: string;
-	/**
-	 * The process the daemon bound this launch's edge to, taken from that same
-	 * answer: the source and incarnation the child registered under. They are what
-	 * an assignment to this child is addressed with, so the first task of a fresh
-	 * launch is addressed exactly as a retained continuation is.
-	 */
-	bound_process: { source: string; incarnation: string };
 	state: State;
 };
 
@@ -315,6 +295,8 @@ export async function relaunchRefusalForChild(
 
 export type RadarLaunchOptions<State extends LaunchState = LaunchState> = {
 	client: RadarClient;
+	/** This process's own publication, which names the parent of the launch. */
+	publication: Pick<RadarPublication, "subject">;
 	readers: LaunchMailbox<State>;
 	launch: RadarWorkerLaunch;
 	timeoutMs: number;
@@ -392,29 +374,35 @@ export async function launchRadarWorker<State extends LaunchState>(
 	const pollMs = options.pollMs ?? 250;
 	const deadline = Date.now() + options.timeoutMs;
 	const remaining = (): number => Math.max(0, deadline - Date.now());
-	const pane = launch.parent.location?.pane;
-	if (!isUuid(launch.parent.registration_id))
+	const parent = await options.publication.subject();
+	if (parent === undefined || !isUuid(parent.registration_id))
 		return refusedLaunch(
-			"the launch has no exact parent registration to spawn under",
+			"this process has no Radar registration, so a worker cannot be spawned under it",
 		);
-	if (!isUuid(launch.parent.subject_id))
+	if (parent.subject_id === undefined || !isUuid(parent.subject_id))
 		return refusedLaunch(
-			"the launch has no managed Radar subject for its parent",
+			"this process has no managed Radar subject, so a worker cannot be spawned under it",
 		);
 	// A spawn is created under the pane its parent registered, and this port
 	// registers no location it was not given: without one there is nothing to
 	// place the child beside, and a name or session lookup is not a substitute.
+	const pane = parent.location?.pane;
 	if (pane === undefined || pane === "")
 		return refusedLaunch(
-			"this process's Radar registration names no pane, so it cannot be a spawn parent",
+			"this process's Radar registration names no pane, so a worker cannot be placed beside it",
+		);
+	if (pane !== launch.pane_id)
+		return refusedLaunch(
+			`this process's Radar registration places it in pane ${pane}, not in the pane this launch would split`,
 		);
 
 	const spawned = await client.spawn({
 		request_id: launch.request_id,
-		parent: launch.parent.registration_id,
+		parent: parent.registration_id,
 		parent_session_id: launch.parent_session_id,
 		executable: launch.executable,
-		managed: { parent_subject_id: launch.parent.subject_id },
+		managed: { parent_subject_id: parent.subject_id },
+		...(launch.continues !== undefined ? { continue_subject_id: launch.continues } : {}),
 		argv: launch.argv,
 		...(launch.cwd !== "" ? { cwd: launch.cwd } : {}),
 		...(Object.keys(launch.env).length > 0 ? { env: launch.env } : {}),
@@ -438,20 +426,6 @@ export async function launchRadarWorker<State extends LaunchState>(
 	});
 	if (bound.kind !== "bound") return bound;
 	const agentId = bound.registration_id;
-	// The binding is recorded before the readiness wait, not after it: the child
-	// may never acknowledge, and the subject and pane the daemon named are still
-	// what a reload has to prove this child by.
-	if (launch.onBound !== undefined) {
-		try {
-			launch.onBound({ registration_id: agentId, pane_id: bound.pane_id });
-		} catch (error) {
-			return unresolvedLaunch(
-				launch.request_id,
-				`the daemon's binding of the child ${agentId} could not be recorded (${String(error)})`,
-			);
-		}
-	}
-
 	try {
 		const state = await options.readers.waitForState(
 			launch.mailbox,
@@ -466,21 +440,15 @@ export async function launchRadarWorker<State extends LaunchState>(
 						// the pane the daemon created is what refuses a child that inherited
 						// another process's coordinates.
 					paneId: radarPaneHandle(bound.pane_id),
-				}) &&
-				(launch.observedChildAgent === undefined ||
-					launch.observedChildAgent() === agentId),
+				}),
 			{ timeoutMs: remaining(), ...(signal !== undefined ? { signal } : {}) },
 		);
 		return {
 			kind: "ready",
 			value: {
 				request_id: launch.request_id,
-				registration_id: agentId,
+				subject_id: bound.subject_id,
 				pane_id: bound.pane_id,
-				bound_process: {
-					source: bound.source,
-					incarnation: bound.incarnation,
-				},
 				state,
 			},
 		};
@@ -498,6 +466,7 @@ export async function launchRadarWorker<State extends LaunchState>(
 type BoundChild =
 	| {
 			kind: "bound";
+			subject_id: string;
 			registration_id: string;
 			pane_id: string;
 			source: string;
@@ -577,8 +546,18 @@ async function waitForChild(
 						requestId,
 						`the daemon bound the child ${agentId} without recording the process it registered as`,
 					);
+				// The edge names the agent as well as its process. Without it the child
+				// has no durable key to be returned by, and a registration is never
+				// offered in its place.
+				const subjectId = edge.bound?.subject_id;
+				if (subjectId === undefined || !isUuid(subjectId))
+					return unresolvedLaunch(
+						requestId,
+						`the daemon bound the child ${agentId} without recording its subject`,
+					);
 				return {
 					kind: "bound",
+					subject_id: subjectId,
 					registration_id: agentId,
 					pane_id: pane,
 					source,