pi-radar 0.7.0 → 0.10.0

package/extension/radar-launch.ts

@@ -5,135 +5,49 @@ import {
 	type RadarErrorCode,
 	type RadarLocation,
 	type RadarResult,
-	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 = {
-	generation: string;
-	runId: string;
-	ownerSessionId: string;
-	workspaceId: string;
-	agentLabel: string;
-	paneId: string;
-};
-
-/**
- * The mailbox readers a launch needs. The mailbox belongs to the caller (Herdsman
- * supplies its own state shape and readers); this module only takes the path it
- * is handed and asks these questions of it.
- */
-export type LaunchState = { paneId: string };
-
-export type LaunchMailbox<State extends LaunchState> = {
-	readState(path: string): State | undefined;
-	waitForState(
-		path: string,
-		predicate: (state: State) => boolean,
-		options: { timeoutMs: number; signal?: AbortSignal },
-	): Promise<State>;
-	startupAckMatches(state: State | undefined, expected: StartupExpectation): boolean;
-};
-
-/**
- * Launching one fresh managed worker through Radar's spawn operation.
- *
- * A spawn is one durable effect behind the caller's own request UUID, and three
- * separate facts decide whether a child can take an assignment:
- *
- * 1. the daemon created a pane under this process's registered pane, launched
- *    the child's exact command into it, and still reports that pane in its own
- *    inventory;
- * 2. a child registered with the launch's private token, so the edge names the
- *    exact `registration_id` that child obtained — never a label, pane or session;
- * 3. that child wrote a fresh startup acknowledgment for this launch generation
- *    after Herdsman startup finished, naming the pane the daemon created as its
- *    own location.
- *
- * Only the third is application readiness; the first two are prerequisites. A
- * lost reply is reconciled against the same request UUID and never re-sent, so a
- * failed launch cannot leave a second pane or a second child behind.
- *
- * The child's location is a fact about the pane the daemon created, not about
- * the environment it was launched with: the daemon passes an environment overlay
- * to a mux-created pane and cannot remove what that pane already carries, so a
- * child that inherited its parent's pane coordinates would claim the parent's
- * pane. The daemon's fresh record of the created pane and the child's own claim
- * must therefore name the same pane, and either one being stale, missing or
- * 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;
-};
+/** A launch succeeds when Radar grants its child's verified first presence. */
 
 /** 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[];
 	cwd: string;
 	/** The environment overlay the child needs, not a replacement environment. */
 	env: Record<string, string>;
-	/** The child's mailbox: its own state is the readiness evidence. */
-	mailbox: string;
-	/** The identity the child's state and acknowledgment must repeat exactly. */
-	identity: {
-		runId: string;
-		ownerSessionId: string;
-		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> = {
+export type RadarWorkerLaunched = {
 	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;
 };
 
 /**
- * `refused` is a launch that provably did not begin; `unresolved` is one whose
- * pane, child or readiness cannot be established, which the caller reports
- * rather than retries.
+ * `ready` is a child whose first presence the daemon granted. `failed` is a launch
+ * the daemon withdrew (or that provably never began), so a retry is safe.
+ * `unresolved` is the rare launch whose outcome cannot be read at all, which the
+ * caller reports rather than retries.
  */
-export type RadarLaunchOutcome<State = unknown> =
-	| { kind: "ready"; value: RadarWorkerLaunched<State> }
-	| { kind: "refused"; message: string }
+export type RadarLaunchOutcome =
+	| { kind: "ready"; value: RadarWorkerLaunched }
+	| { kind: "failed"; message: string }
 	| { kind: "unresolved"; request_id: string; message: string };
 
 /**
@@ -178,8 +92,8 @@ function trajectory(reason: string): string {
  *
  * The durable spawn record and the child's own binding say *which* subject this
  * launch created; they are provenance, not liveness, and they stay true after a
- * child is gone. The startup acknowledgment says the child is ready, which is
- * also not liveness. Only a current topology read decides: `bound` has to name
+ * child is gone. A presence grant is startup evidence, not perpetual liveness.
+ * Only a current topology read decides: `bound` has to name
  * the same subject, the read has to record the pane this launch claims, no
  * process exit may have been observed, and the read's own `freshness` has to
  * report that the daemon's inventory currently places that pane. Anything else -
@@ -313,24 +227,25 @@ export async function relaunchRefusalForChild(
 	return `the child's registered process is ${verification === "verified" ? "still running" : "not proved gone"}`;
 }
 
-export type RadarLaunchOptions<State extends LaunchState = LaunchState> = {
+export type RadarLaunchOptions = {
 	client: RadarClient;
-	readers: LaunchMailbox<State>;
+	/** This process's own publication, which names the parent of the launch. */
+	publication: Pick<RadarPublication, "subject">;
 	launch: RadarWorkerLaunch;
-	timeoutMs: number;
-	/** How often the binding and readiness waits re-read; 0 in driven tests. */
+	/** How often the wait re-reads the launch; 0 in driven tests. */
 	pollMs?: number;
+	/** Stops the wait. The daemon's own deadline still withdraws the launch. */
 	signal?: AbortSignal;
 };
 
-function refusedLaunch(message: string): Extract<RadarLaunchOutcome, { kind: "refused" | "unresolved" }> {
-	return { kind: "refused", message };
+function refusedLaunch(message: string): Extract<RadarLaunchOutcome, { kind: "failed" | "unresolved" }> {
+	return { kind: "failed", message };
 }
 
 function unresolvedLaunch(
 	requestId: string,
 	message: string,
-): Extract<RadarLaunchOutcome, { kind: "refused" | "unresolved" }> {
+): Extract<RadarLaunchOutcome, { kind: "failed" | "unresolved" }> {
 	return {
 		kind: "unresolved",
 		request_id: requestId,
@@ -338,19 +253,6 @@ function unresolvedLaunch(
 	};
 }
 
-/** Whether the edge's own two effects already prove a launch happened. */
-function edgeStanding(edge: RadarSpawnEdge): "launched" | "refused" | "unknown" {
-	if (edge.created === "refused" || edge.launched === "refused")
-		return "refused";
-	return edge.created === "completed" && edge.launched === "completed"
-		? "launched"
-		: "unknown";
-}
-
-function edgeMessage(edge: RadarSpawnEdge): string {
-	return `the daemon's spawn record is created ${edge.created} and launched ${edge.launched}`;
-}
-
 /**
  * The daemon's own refusals, which prove no effect was dispatched. Every other
  * failure — a lost reply, a timeout, an internal error, an unreadable answer —
@@ -371,155 +273,98 @@ const PRE_EFFECT_CODES: readonly RadarErrorCode[] = [
 	"backend_unavailable",
 ];
 
-function spawnFailure(
-	result: Extract<RadarResult<RadarSpawnEdge>, { ok: false }>,
+export function launchFailure(
+	result: Extract<RadarResult<unknown>, { ok: false }>,
 	requestId: string,
-): Extract<RadarLaunchOutcome, { kind: "refused" | "unresolved" }> {
+): Extract<RadarLaunchOutcome, { kind: "failed" | "unresolved" }> {
 	return PRE_EFFECT_CODES.includes(result.code)
 		? refusedLaunch(result.message)
 		: unresolvedLaunch(requestId, result.message);
 }
 
 /**
- * Wait for the child's own registration to bind this edge, then for its startup
- * acknowledgment. The edge is re-read by the same request UUID: a spawn that
- * already answered is never sent again.
+ * Wait for the child's verified presence grant or the daemon's withdrawal. The
+ * same request UUID is read throughout; a lost reply never starts another child.
  */
-export async function launchRadarWorker<State extends LaunchState>(
-	options: RadarLaunchOptions<State>,
-): Promise<RadarLaunchOutcome<State>> {
+export async function launchRadarWorker(
+	options: RadarLaunchOptions,
+): Promise<RadarLaunchOutcome> {
 	const { client, launch, signal } = options;
 	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 } : {}),
 	});
 	if (spawned.ok === false) {
-		const refusal = spawnFailure(spawned, launch.request_id);
-		if (refusal.kind === "refused") return refusal;
-	}
-	if (spawned.ok === true) {
-		const standing = edgeStanding(spawned.value);
-		if (standing === "refused")
-			return refusedLaunch(edgeMessage(spawned.value));
-		if (standing === "unknown")
-			return unresolvedLaunch(launch.request_id, edgeMessage(spawned.value));
+		const refusal = launchFailure(spawned, launch.request_id);
+		if (refusal.kind === "failed") return refusal;
 	}
 
 	const bound = await waitForChild(client, launch.request_id, {
-		remaining,
 		pollMs,
 		...(signal !== undefined ? { signal } : {}),
 	});
 	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,
-			(candidate) =>
-				options.readers.startupAckMatches(candidate, {
-					generation: launch.generation,
-					runId: launch.identity.runId,
-					ownerSessionId: launch.identity.ownerSessionId,
-					workspaceId: launch.identity.workspaceId,
-					agentLabel: launch.identity.agentLabel,
-						// The child writes the raw TMUX_PANE of the pane it runs in. Requiring
-						// 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,
-				pane_id: bound.pane_id,
-				bound_process: {
-					source: bound.source,
-					incarnation: bound.incarnation,
-				},
-				state,
-			},
-		};
-	} catch (error) {
-		const claimed = options.readers.readState(launch.mailbox)?.paneId;
-		return unresolvedLaunch(
-			launch.request_id,
-			claimed !== undefined && claimed !== radarPaneHandle(bound.pane_id)
-				? `the bound child ${agentId} claims the pane ${claimed}, not the pane ${bound.pane_id} this launch created for it`
-				: `the bound child ${agentId} has not acknowledged this launch's startup (${String(error)})`,
-		);
-	}
+	return {
+		kind: "ready",
+		value: {
+			request_id: launch.request_id,
+			subject_id: bound.subject_id,
+			pane_id: bound.pane_id,
+		},
+	};
 }
 
 type BoundChild =
 	| {
 			kind: "bound";
-			registration_id: string;
+			subject_id: string;
 			pane_id: string;
-			source: string;
-			incarnation: string;
 	  }
-	| Extract<RadarLaunchOutcome, { kind: "refused" | "unresolved" }>;
+	| Extract<RadarLaunchOutcome, { kind: "failed" | "unresolved" }>;
 
 /**
- * Poll the edge this request id authored until a child presents its token.
+ * Poll the edge this request id authored until the daemon grants its child or
+ * withdraws the launch. There is no timeout here: the daemon owns the deadline and
+ * records a withdrawal on the edge, so waiting longer than it would only wait for
+ * an outcome that is already decided.
  *
- * The daemon binds the edge once, to the exact registration the token produced,
- * so `bound.registration_id` is the child identity. A refusal or an unknown launch
- * effect ends the wait at once: neither becomes a child by waiting longer. An
- * edge whose recorded pane the daemon no longer reports ends it too: waiting
- * cannot create the pane a launch claims, and a location read afterwards would
- * be that of whatever moved in.
+ * Registration binding alone is not success: a pending or duplicate presence
+ * can bind an edge without ever acquiring attachment authority.
  */
-async function waitForChild(
-	client: RadarClient,
+export async function waitForChild(
+	client: Pick<RadarClient, "spawnGet">,
 	requestId: string,
 	options: {
-		remaining: () => number;
 		pollMs: number;
 		signal?: AbortSignal;
 	},
@@ -530,69 +375,41 @@ async function waitForChild(
 			return unresolvedLaunch(requestId, `the launch was cancelled (${last})`);
 		const answer = await client.spawnGet(requestId);
 		if (answer.ok === true) {
-			const { edge, state, freshness } = answer.value;
-			const standing = edgeStanding(edge);
-			if (standing === "refused")
-				return refusedLaunch(`${edgeMessage(edge)}`);
-			if (standing === "unknown")
-				return unresolvedLaunch(requestId, edgeMessage(edge));
+			const { edge } = answer.value;
+			if (edge.withdrawn !== undefined)
+				return refusedLaunch(`the daemon withdrew this launch: ${edge.withdrawn.reason}`);
+			if (edge.granted_at === undefined) {
+				await delay(options.pollMs);
+				continue;
+			}
 			const pane = edge.location?.pane;
 			if (pane === undefined || pane === "")
 				return unresolvedLaunch(
 					requestId,
 					"the daemon's launch recorded no pane to verify the child against",
 				);
-			// The recorded pane is the daemon's own statement about where it created
-			// and launched this child, and `fresh` is its inventory confirming that
-			// pane right now. Without that confirmation the launch has no verified
-			// location to give the child, and no later read can supply one.
-			if (freshness !== "fresh")
-				return unresolvedLaunch(
-					requestId,
-					state === "unresolved"
-						? `the daemon's inventory does not report the pane ${pane} its own record names for this child`
-						: `the daemon cannot confirm the pane ${pane} it recorded for this child`,
-				);
-			// An observed exit is the child's process, and a pane's shell can outlive it.
-			if (edge.exit_observation?.state === "exited")
-				return unresolvedLaunch(
-					requestId,
-					"the daemon observed the launched child's process exit",
-				);
+
 			const agentId = edge.bound?.registration_id;
 			if (agentId !== undefined && isUuid(agentId)) {
-				// A child the daemon bound without the process it registered as is a
-				// child no assignment can be addressed to, and an unaddressed Radar
-				// assignment is exactly what addressing exists to prevent: the launch
-				// stays unresolved rather than degrading to a V5 request.
-				const source = edge.bound?.source;
-				const incarnation = edge.bound?.incarnation;
-				if (
-					source === undefined ||
-					source === "" ||
-					incarnation === undefined ||
-					incarnation === ""
-				)
+				// 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 the process it registered as`,
+						`the daemon bound the child ${agentId} without recording its subject`,
 					);
 				return {
 					kind: "bound",
-					registration_id: agentId,
+					subject_id: subjectId,
 					pane_id: pane,
-					source,
-					incarnation,
 				};
 			}
 			last = "no child has registered with this launch's token yet";
 		} else {
-			last = answer.message;
+			return unresolvedLaunch(requestId, answer.message);
 		}
-		if (options.remaining() <= 0)
-			return unresolvedLaunch(requestId, last);
-		await delay(options.pollMs, undefined, {
-			...(options.signal !== undefined ? { signal: options.signal } : {}),
-		});
+		await delay(options.pollMs);
 	}
 }

package/extension/radar-runtime.ts

@@ -1,10 +1,11 @@
 import type { RadarExecutionAdapter } from "./radar-execution.ts";
+import type { RadarChildren } from "./radar-children.ts";
 import type { RadarHandoffPort } from "./radar-communication.ts";
 import type { RadarPublication } from "./radar-publication.ts";
 
 /** The event channel through which Pi extensions obtain the baseline runtime. */
 export const RADAR_RUNTIME_REQUEST = "pi-radar/runtime-request";
-export const RADAR_RUNTIME_VERSION = 2 as const;
+export const RADAR_RUNTIME_VERSION = 4 as const;
 
 /** The sole baseline publisher's session-scoped runtime, shared with consumers. */
 export type RadarRuntimeServices = {
@@ -12,6 +13,8 @@ export type RadarRuntimeServices = {
 	publication: RadarPublication;
 	/** Durable handoffs bound to this process's registration and managed parent. */
 	communication: RadarHandoffPort;
+	/** This process's own children, addressed by subject. */
+	children: RadarChildren;
 	execution: RadarExecutionAdapter;
 };
 

package/index.ts

@@ -1,3 +1,4 @@
+export * as children from "./extension/radar-children.ts";
 export * as client from "./extension/radar-client.ts";
 export * as communication from "./extension/radar-communication.ts";
 export * as execution from "./extension/radar-execution.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-radar",
-  "version": "0.7.0",
+  "version": "0.10.0",
   "type": "module",
   "description": "Radar daemon client, communication, publication, execution, location, launch and inspection surface for Pi extensions.",
   "license": "Apache-2.0",
@@ -23,6 +23,10 @@
       "types": "./index.ts",
       "import": "./dist/index.js"
     },
+    "./children": {
+      "types": "./extension/radar-children.ts",
+      "import": "./dist/extension/radar-children.js"
+    },
     "./client": {
       "types": "./extension/radar-client.ts",
       "import": "./dist/extension/radar-client.js"
@@ -72,6 +76,7 @@
     "README.md",
     "schema/public/v1/**",
     "extension/generated-contracts.ts",
+    "extension/radar-children.ts",
     "extension/radar-client.ts",
     "extension/radar-communication.ts",
     "extension/radar-execution.ts",
@@ -83,10 +88,10 @@
     "extension/baseline.ts"
   ],
   "scripts": {
-    "build": "esbuild index.ts extension/generated-contracts.ts extension/radar-client.ts extension/radar-communication.ts extension/radar-execution.ts extension/radar-inspection.ts extension/radar-launch.ts extension/radar-location.ts extension/radar-publication.ts extension/radar-runtime.ts extension/baseline.ts --outbase=. --outdir=dist --bundle --platform=node --format=esm --target=node22",
+    "build": "esbuild index.ts extension/generated-contracts.ts extension/radar-children.ts extension/radar-client.ts extension/radar-communication.ts extension/radar-execution.ts extension/radar-inspection.ts extension/radar-launch.ts extension/radar-location.ts extension/radar-publication.ts extension/radar-runtime.ts extension/baseline.ts --outbase=. --outdir=dist --bundle --platform=node --format=esm --target=node22",
     "generate:contracts": "node tools/generate-contracts.mjs",
     "check:contracts": "node tools/generate-contracts.mjs --check",
-    "typecheck:contracts": "tsc --noEmit --strict --skipLibCheck --target ES2022 --module NodeNext --moduleResolution NodeNext --allowImportingTsExtensions --types node index.ts extension/baseline.ts extension/generated-contracts.ts extension/generated-contracts.typecheck.ts extension/radar-client.ts extension/radar-communication.ts extension/radar-execution.ts extension/radar-launch.test.ts extension/radar-publication.ts extension/radar-runtime.ts extension/radar-runtime.test.ts",
+    "typecheck:contracts": "tsc --noEmit --strict --skipLibCheck --target ES2022 --module NodeNext --moduleResolution NodeNext --allowImportingTsExtensions --types node index.ts extension/baseline.ts extension/generated-contracts.ts extension/generated-contracts.typecheck.ts extension/radar-children.ts extension/radar-client.ts extension/radar-communication.ts extension/radar-execution.ts extension/radar-launch.test.ts extension/radar-publication.ts extension/radar-runtime.ts extension/radar-runtime.test.ts",
     "prepack": "npm run build",
     "test": "npm run check:contracts && npm run typecheck:contracts && node --experimental-strip-types --test extension/*.test.ts"
   },

package/schema/public/v1/observation-get-response.deserialize.schema.json

@@ -893,12 +893,6 @@
         },
         "subject_id": {
           "type": "string"
-        },
-        "successor": {
-          "type": [
-            "string",
-            "null"
-          ]
         }
       },
       "required": [
@@ -1060,12 +1054,6 @@
         },
         "subject_id": {
           "type": "string"
-        },
-        "successor": {
-          "type": [
-            "string",
-            "null"
-          ]
         }
       },
       "required": [
@@ -2448,7 +2436,7 @@
         },
         {
           "const": "captured",
-          "description": "The bootstrap's process is captured and released to exec.",
+          "description": "The launch's process is captured and has been given its program.",
           "type": "string"
         },
         {

package/schema/public/v1/observation-get-response.serialize.schema.json

@@ -941,12 +941,6 @@
         },
         "subject_id": {
           "type": "string"
-        },
-        "successor": {
-          "type": [
-            "string",
-            "null"
-          ]
         }
       },
       "required": [
@@ -954,8 +948,7 @@
         "bound_registration_id",
         "process",
         "state",
-        "session",
-        "successor"
+        "session"
       ],
       "type": "object"
     },
@@ -1119,12 +1112,6 @@
         },
         "subject_id": {
           "type": "string"
-        },
-        "successor": {
-          "type": [
-            "string",
-            "null"
-          ]
         }
       },
       "required": [
@@ -1135,8 +1122,7 @@
         "metadata",
         "child_close",
         "state",
-        "session",
-        "successor"
+        "session"
       ],
       "type": "object"
     },
@@ -2567,7 +2553,7 @@
         },
         {
           "const": "captured",
-          "description": "The bootstrap's process is captured and released to exec.",
+          "description": "The launch's process is captured and has been given its program.",
           "type": "string"
         },
         {