pi-radar 0.2.0 → 0.4.0

package/dist/index.js

@@ -8,6 +8,7 @@ var __export = (target, all) => {
 var radar_client_exports = {};
 __export(radar_client_exports, {
   RADAR_CALL_TIMEOUT_MS: () => RADAR_CALL_TIMEOUT_MS,
+  RADAR_COMMUNICATION_CONTRACT: () => RADAR_COMMUNICATION_CONTRACT,
   RADAR_EVENTS_CONTRACT: () => RADAR_EVENTS_CONTRACT,
   RADAR_EVENT_RETRY_MS: () => RADAR_EVENT_RETRY_MS,
   RADAR_MAX_AWAITED: () => RADAR_MAX_AWAITED,
@@ -45,6 +46,7 @@ var RADAR_SPAWN_CONTRACT = "spawn.v1";
 var RADAR_SPAWN_CLOSE_CONTRACT = "spawn.close.v1";
 var RADAR_SPAWN_LAUNCH_CONTEXT_CONTRACT = "spawn.launch_context.v1";
 var RADAR_EVENTS_CONTRACT = "events.v1";
+var RADAR_COMMUNICATION_CONTRACT = "communication.handoff.v1";
 var RADAR_REQUESTER = "pi-radar";
 var RADAR_MAX_LINE_BYTES = 1024 * 1024;
 var RADAR_CALL_TIMEOUT_MS = 2e3;
@@ -142,6 +144,25 @@ function recordAt(value, field) {
 function isUuid(value) {
   return typeof value === "string" && UUID.test(value);
 }
+function decodePresenceAnswer(value) {
+  const registrationId = recordAt(value, "registration_id");
+  const claimId = recordAt(value, "claim_id");
+  const standing = recordAt(value, "standing");
+  const subjectId = recordAt(value, "subject_id");
+  if (!isUuid(registrationId) || !isUuid(claimId) || !["pending", "granted", "duplicate", "released"].includes(String(standing)) || subjectId !== void 0 && !isUuid(subjectId) || standing === "granted" && !isUuid(subjectId))
+    return protocol("presence reply carries no valid claim standing");
+  return { ok: true, value };
+}
+function managementAt(value) {
+  const field = recordAt(value, "management");
+  const state = stringAt(field, "state");
+  if (state === "managed") {
+    const subjectId = stringAt(field, "subject_id");
+    return subjectId === void 0 ? void 0 : { state, subject_id: subjectId };
+  }
+  if (state === "duplicate" || state === "pending" || state === "unmanaged") return { state };
+  return void 0;
+}
 function stringAt(value, field) {
   if (typeof value !== "object" || value === null) return void 0;
   const found = value[field];
@@ -152,6 +173,28 @@ function numberAt(value, field) {
   const found = value[field];
   return typeof found === "number" && Number.isFinite(found) ? found : void 0;
 }
+function handoffAt(value) {
+  const version = numberAt(value, "version");
+  const id = stringAt(value, "id");
+  const sender = recordAt(value, "sender");
+  const senderGeneration = numberAt(sender, "execution_generation");
+  const target = stringAt(value, "recipient_subject_id");
+  const summary = stringAt(value, "summary");
+  const content = stringAt(value, "content");
+  const published = numberAt(value, "published_at_unix_ms");
+  const correlation = typeof value === "object" && value !== null ? value.correlation_id : void 0;
+  if (version !== 1 || !isUuid(id) || !isUuid(stringAt(sender, "registration_id")) || !isUuid(stringAt(sender, "session_id")) || !isUuid(stringAt(sender, "subject_id")) || !isUuid(stringAt(sender, "execution_id")) || !Number.isSafeInteger(senderGeneration) || (senderGeneration ?? 0) < 1 || !isUuid(target) || summary === void 0 || content === void 0 || published === void 0 || !Number.isSafeInteger(published) || published < 0 || correlation !== void 0 && correlation !== null && (typeof correlation !== "string" || correlation.length === 0 || Buffer.byteLength(correlation, "utf8") > 256 || new RegExp("\\p{Cc}", "u").test(correlation))) return void 0;
+  return value;
+}
+function handoffReceiptAt(value) {
+  const version = numberAt(value, "version");
+  const handoffId = stringAt(value, "handoff_id");
+  const recipient = recordAt(value, "recipient");
+  const generation = numberAt(recipient, "execution_generation");
+  const received = numberAt(value, "received_at_unix_ms");
+  if (version !== 1 || !isUuid(handoffId) || !isUuid(stringAt(recipient, "registration_id")) || !isUuid(stringAt(recipient, "session_id")) || !isUuid(stringAt(recipient, "subject_id")) || !isUuid(stringAt(recipient, "execution_id")) || !Number.isSafeInteger(generation) || (generation ?? 0) < 1 || received === void 0 || !Number.isSafeInteger(received) || received < 0) return void 0;
+  return value;
+}
 function writerBinding(value) {
   const handle = stringAt(value, "handle");
   const source = stringAt(value, "source");
@@ -261,7 +304,8 @@ var RADAR_SPAWN_TOKEN_ENV = "PI_RADAR_SPAWN_TOKEN";
 var RADAR_MANAGED_IDENTITY_ENV = /* @__PURE__ */ new Set([
   "PI_RADAR_MANAGED_SUBJECT_ID",
   "PI_RADAR_MANAGED_LAUNCH_ID",
-  "PI_RADAR_MANAGED_EXECUTION_GENERATION"
+  "PI_RADAR_MANAGED_EXECUTION_GENERATION",
+  "PI_RADAR_MANAGED_PARENT_SUBJECT_ID"
 ]);
 function unresolvedSpawn(requestId, detail) {
   return {
@@ -306,7 +350,7 @@ function spawnEdge(value) {
   const bound = recordAt(value, "bound");
   const source = stringAt(bound, "source");
   const incarnation = stringAt(bound, "incarnation");
-  const agentId = stringAt(bound, "agent_id");
+  const agentId = stringAt(bound, "registration_id");
   const exit = exitAt(recordAt(value, "exit_observation"));
   return {
     ok: true,
@@ -320,7 +364,7 @@ function spawnEdge(value) {
         bound: {
           source,
           incarnation,
-          ...isUuid(agentId) ? { agent_id: agentId } : {}
+          ...isUuid(agentId) ? { registration_id: agentId } : {}
         }
       } : {},
       ...exit !== void 0 ? { exit_observation: exit } : {}
@@ -718,6 +762,22 @@ function createRadarClient(options = {}) {
   return {
     socketPath,
     ping,
+    async presence(request) {
+      return withRegistry(async () => {
+        const answer = await call("agent.presence", { ...request });
+        if (!answer.ok) return answer;
+        return decodePresenceAnswer(answer.value);
+      });
+    },
+    async releasePresence(request) {
+      return withRegistry(async () => {
+        const answer = await call("agent.release", { ...request });
+        if (!answer.ok) return answer;
+        const decoded = decodePresenceAnswer(answer.value);
+        if (!decoded.ok) return decoded;
+        return decoded.value.standing === "released" ? decoded : protocol("release reply did not confirm the claim release");
+      });
+    },
     async register(registration) {
       return withRegistry(async () => {
         const answer = await call("agent.register", {
@@ -733,15 +793,15 @@ function createRadarClient(options = {}) {
         });
         if (answer.ok === false) return answer;
         const record = answer.value.registration;
-        const agentId = stringAt(record, "agent_id");
-        if (!isUuid(agentId)) return protocol("registration reply carries no agent_id");
-        return { ok: true, value: { agent_id: agentId } };
+        const agentId = stringAt(record, "registration_id");
+        if (!isUuid(agentId)) return protocol("registration reply carries no registration_id");
+        return { ok: true, value: { registration_id: agentId } };
       });
     },
     async acquire(request) {
       return withRegistryChannel(request.channel, async () => {
         const answer = await call("agent.acquire", {
-          agent_id: request.agent_id,
+          registration_id: request.registration_id,
           channel: request.channel,
           publisher: request.publisher,
           ...request.replace !== void 0 ? { replace: request.replace } : {}
@@ -770,7 +830,7 @@ function createRadarClient(options = {}) {
       }
       return withRegistryChannel(request.channel, async () => {
         const answer = await call("agent.publish", {
-          agent_id: request.agent_id,
+          registration_id: request.registration_id,
           channel: request.channel,
           writer_handle: request.writer_handle,
           sequence: request.sequence,
@@ -789,7 +849,7 @@ function createRadarClient(options = {}) {
     async context(request) {
       return withRegistry(async () => {
         const answer = await call("agent.context", {
-          agent_id: request.agent_id,
+          registration_id: request.registration_id,
           publisher: request.publisher,
           ...request.writer_handle !== void 0 ? { writer_handle: request.writer_handle } : {},
           ...request.replace !== void 0 ? { replace: request.replace } : {},
@@ -805,9 +865,14 @@ function createRadarClient(options = {}) {
         if (writer === void 0)
           return protocol("context reply carries no writer binding");
         const warning = stringAt(answer.value, "warning");
+        const management = managementAt(answer.value);
         return {
           ok: true,
-          value: { writer, ...warning !== void 0 ? { warning } : {} }
+          value: {
+            writer,
+            ...warning !== void 0 ? { warning } : {},
+            ...management !== void 0 ? { management } : {}
+          }
         };
       });
     },
@@ -884,7 +949,7 @@ function createRadarClient(options = {}) {
           message: "agent.get requires a canonical agent UUID"
         };
       return withRegistry(async () => {
-        const answer = await call("agent.get", { agent_id: agentId });
+        const answer = await call("agent.get", { registration_id: agentId });
         if (answer.ok === false) return answer;
         return agentProcessAt(recordAt(answer.value, "agent"));
       });
@@ -935,6 +1000,56 @@ function createRadarClient(options = {}) {
         return protocol("spawn.close reply carries no close outcome");
       });
     },
+    async communicationPublish(request) {
+      return withContract(RADAR_COMMUNICATION_CONTRACT, async () => {
+        const answer = await call("communication.publish", {
+          sender_registration_id: request.sender_registration_id,
+          recipient_subject_id: request.recipient_subject_id,
+          ...request.correlation_id !== void 0 ? { correlation_id: request.correlation_id } : {},
+          summary: request.summary,
+          content: request.content
+        }, request.request_id);
+        if (answer.ok === false) return answer;
+        const handoff = handoffAt(recordAt(answer.value, "handoff"));
+        const created = recordAt(answer.value, "created");
+        if (handoff === void 0 || typeof created !== "boolean")
+          return protocol("communication.publish reply carries no handoff");
+        return { ok: true, value: { handoff, created } };
+      });
+    },
+    async communicationInbox(request) {
+      return withContract(RADAR_COMMUNICATION_CONTRACT, async () => {
+        const answer = await call("communication.inbox", request);
+        if (answer.ok === false) return answer;
+        const handoffIds = recordAt(answer.value, "handoff_ids");
+        if (!Array.isArray(handoffIds) || handoffIds.some((id) => !isUuid(id)))
+          return protocol("communication.inbox reply carries malformed handoff IDs");
+        return { ok: true, value: answer.value };
+      });
+    },
+    async communicationGet(request) {
+      return withContract(RADAR_COMMUNICATION_CONTRACT, async () => {
+        const answer = await call("communication.get", request);
+        if (answer.ok === false) return answer;
+        const handoff = handoffAt(recordAt(answer.value, "handoff"));
+        const receiptValue = recordAt(answer.value, "receipt");
+        const receipt = receiptValue === null ? null : handoffReceiptAt(receiptValue);
+        if (handoff === void 0 || receiptValue !== null && receipt === void 0)
+          return protocol("communication.get reply carries malformed content or receipt");
+        return { ok: true, value: { handoff, receipt: receipt ?? null } };
+      });
+    },
+    async communicationAck(request) {
+      return withContract(RADAR_COMMUNICATION_CONTRACT, async () => {
+        const answer = await call("communication.ack", request);
+        if (answer.ok === false) return answer;
+        const receipt = handoffReceiptAt(recordAt(answer.value, "receipt"));
+        const created = recordAt(answer.value, "created");
+        if (receipt === void 0 || typeof created !== "boolean")
+          return protocol("communication.ack reply carries no receipt");
+        return { ok: true, value: { receipt, created } };
+      });
+    },
     async events(request) {
       if (!Number.isSafeInteger(request.after) || request.after < 0 || !Number.isSafeInteger(request.wait_ms) || request.wait_ms < 0 || request.wait_ms > RADAR_EVENT_WAIT_MS)
         return {
@@ -1155,6 +1270,47 @@ function boundedRadarSnapshot(snapshot) {
   };
 }
 
+// extension/radar-communication.ts
+var radar_communication_exports = {};
+__export(radar_communication_exports, {
+  createRadarHandoffPort: () => createRadarHandoffPort
+});
+function createRadarHandoffPort(client, publication, parentSubjectId = () => process.env.PI_RADAR_MANAGED_PARENT_SUBJECT_ID) {
+  async function agentId() {
+    const subject = await publication.subject();
+    return subject === void 0 ? { ok: false, code: "absent", message: "this process has no current Radar registration" } : { ok: true, value: subject.registration_id };
+  }
+  return {
+    async publish(request) {
+      const identity = await agentId();
+      if (identity.ok === false) return identity;
+      const parent = parentSubjectId();
+      if (parent === void 0)
+        return { ok: false, code: "absent", message: "this managed execution has no Radar parent subject" };
+      return client.communicationPublish({
+        ...request,
+        sender_registration_id: identity.value,
+        recipient_subject_id: parent
+      });
+    },
+    async inbox() {
+      const identity = await agentId();
+      if (identity.ok === false) return identity;
+      return client.communicationInbox({ registration_id: identity.value });
+    },
+    async get(handoff_id) {
+      const identity = await agentId();
+      if (identity.ok === false) return identity;
+      return client.communicationGet({ registration_id: identity.value, handoff_id });
+    },
+    async ack(handoff_id) {
+      const identity = await agentId();
+      if (identity.ok === false) return identity;
+      return client.communicationAck({ registration_id: identity.value, handoff_id });
+    }
+  };
+}
+
 // extension/radar-execution.ts
 var radar_execution_exports = {};
 __export(radar_execution_exports, {
@@ -1193,77 +1349,7 @@ import {
   writeSync
 } from "node:fs";
 import { dirname as dirname2, join as join2, parse, resolve, sep } from "node:path";
-
-// extension/radar-session-marker.ts
-var RADAR_LAUNCH_MARKER_TYPE = "pi-radar.launch-identity";
-var RADAR_LAUNCH_MARKER_VERSION = 1;
-var RADAR_MAX_EXECUTION_GENERATION = 4294967295;
-var RADAR_MANAGED_SUBJECT_ENV = "PI_RADAR_MANAGED_SUBJECT_ID";
-var RADAR_MANAGED_LAUNCH_ENV = "PI_RADAR_MANAGED_LAUNCH_ID";
-var RADAR_MANAGED_GENERATION_ENV = "PI_RADAR_MANAGED_EXECUTION_GENERATION";
-var UUID2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
-function decodeRadarLaunchMarker(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-  const record = value;
-  if (Object.keys(record).sort().join(",") !== "execution_generation,launch_id,subject_id,version") {
-    return void 0;
-  }
-  if (record.version !== RADAR_LAUNCH_MARKER_VERSION || typeof record.subject_id !== "string" || !UUID2.test(record.subject_id) || typeof record.launch_id !== "string" || !UUID2.test(record.launch_id) || !Number.isSafeInteger(record.execution_generation) || record.execution_generation < 1 || record.execution_generation > RADAR_MAX_EXECUTION_GENERATION) {
-    return void 0;
-  }
-  return {
-    version: RADAR_LAUNCH_MARKER_VERSION,
-    subject_id: record.subject_id,
-    launch_id: record.launch_id,
-    execution_generation: record.execution_generation
-  };
-}
-function appendRadarLaunchMarker(appendEntry, marker) {
-  const validated = decodeRadarLaunchMarker(marker);
-  if (!validated) throw new Error("invalid Radar launch identity marker");
-  appendEntry(RADAR_LAUNCH_MARKER_TYPE, validated);
-}
-function latestRadarLaunchMarker(branch) {
-  let latest;
-  for (const entry of branch) {
-    if (entry.type === "custom" && entry.customType === RADAR_LAUNCH_MARKER_TYPE) {
-      latest = entry;
-    }
-  }
-  if (!latest) return { status: "absent" };
-  const marker = decodeRadarLaunchMarker(latest.data);
-  return marker ? { status: "valid", marker } : { status: "invalid" };
-}
-function radarLaunchMarkerFromEnvironment(env = process.env) {
-  const rawGeneration = env[RADAR_MANAGED_GENERATION_ENV];
-  if (env[RADAR_MANAGED_SUBJECT_ENV] === void 0 || env[RADAR_MANAGED_LAUNCH_ENV] === void 0 || rawGeneration === void 0 || !/^[1-9][0-9]*$/.test(rawGeneration)) {
-    return void 0;
-  }
-  return decodeRadarLaunchMarker({
-    version: RADAR_LAUNCH_MARKER_VERSION,
-    subject_id: env[RADAR_MANAGED_SUBJECT_ENV],
-    launch_id: env[RADAR_MANAGED_LAUNCH_ENV],
-    execution_generation: Number(rawGeneration)
-  });
-}
-function activeRadarLaunchMarker(host) {
-  if (!host.sessionManager) return { status: "absent" };
-  return latestRadarLaunchMarker(host.sessionManager.getBranch());
-}
-function persistRadarLaunchMarker(host, env = process.env) {
-  const marker = radarLaunchMarkerFromEnvironment(env);
-  if (!marker) return "absent";
-  if (!host.appendEntry || !host.sessionManager) return "unsupported";
-  const current = latestRadarLaunchMarker(host.sessionManager.getBranch());
-  if (current.status === "valid" && sameMarker(current.marker, marker)) return "unchanged";
-  appendRadarLaunchMarker(host.appendEntry, marker);
-  return "written";
-}
-function sameMarker(a, b) {
-  return a.version === b.version && a.subject_id === b.subject_id && a.launch_id === b.launch_id && a.execution_generation === b.execution_generation;
-}
-
-// extension/radar-publication.ts
+var DUPLICATE_SESSION_DIAGNOSTIC = "Radar rejected this session claim as a duplicate; reload or resume the session before retrying";
 var RADAR_PUBLICATION_VERSION = 1;
 var RADAR_LEASE_MS = 3e4;
 var RADAR_HEARTBEAT_MS = 15e3;
@@ -1288,7 +1374,7 @@ function readProcessBirth() {
     return void 0;
   }
 }
-var RECORD_NAME = /^(?:subjects|channels|context|bindings)\/[a-z0-9-]{1,64}\.json$/;
+var RECORD_NAME = /^(?:registrations|presence|subjects|channels|context|bindings)\/[a-z0-9-]{1,64}\.json$/;
 var MAX_RECORD_BYTES = 64 * 1024;
 var PRIVATE_MODE = 448;
 var RECORD_MODE = 384;
@@ -1573,39 +1659,6 @@ function pendingAt(value, keys = PENDING_KEYS, codec = executionCodec) {
     return void 0;
   return { sequence, snapshot, lease_ms: lease, observed_at: observed };
 }
-var CONTEXT_PENDING_KEYS = "lease_ms,observed_at,sequence,session";
-var CONTEXT_PENDING_MARKED_KEYS = "launch_identity,lease_ms,observed_at,sequence,session";
-var CONTEXT_ACCEPTED_KEYS = "lease_ms,observed_at,sent_at,sequence,session";
-var CONTEXT_ACCEPTED_MARKED_KEYS = "launch_identity,lease_ms,observed_at,sent_at,sequence,session";
-function sessionAt(value) {
-  if (typeof value !== "object" || value === null) return void 0;
-  const found = value.session;
-  if (found === null) return null;
-  return typeof found === "string" ? found : void 0;
-}
-function sameLaunchIdentity(a, b) {
-  return a === b || a !== void 0 && b !== void 0 && a.version === b.version && a.subject_id === b.subject_id && a.launch_id === b.launch_id && a.execution_generation === b.execution_generation;
-}
-function contextReportAt(value, keys, markedKeys) {
-  const marked = exactKeys(value, markedKeys);
-  if (!exactKeys(value, keys) && !marked) return void 0;
-  const sequence = numberAt2(value, "sequence");
-  const lease = numberAt2(value, "lease_ms");
-  const observed = textAt(value, "observed_at");
-  const session = sessionAt(value);
-  if (sequence === void 0 || sequence < 1) return void 0;
-  if (lease === void 0 || observed === void 0 || session === void 0)
-    return void 0;
-  const marker = marked ? decodeRadarLaunchMarker(value.launch_identity) : void 0;
-  if (marked && marker === void 0) return void 0;
-  return {
-    sequence,
-    session,
-    lease_ms: lease,
-    observed_at: observed,
-    ...marker !== void 0 ? { launch_identity: marker } : {}
-  };
-}
 function createChannelWriter(input) {
   const { store, client, scheduler, recordName, channel, publisher } = input;
   const codec = input.codec ?? executionCodec;
@@ -1621,7 +1674,7 @@ function createChannelWriter(input) {
   function blank(agentId) {
     return {
       version: RADAR_PUBLICATION_VERSION,
-      agent_id: agentId,
+      registration_id: agentId,
       channel,
       publisher,
       sequence: 0
@@ -1629,7 +1682,7 @@ function createChannelWriter(input) {
   }
   function loadRecord() {
     const value = store.read(recordName);
-    const agentId = textAt(value, "agent_id");
+    const agentId = textAt(value, "registration_id");
     const storedPublisher = recordAt2(value, "publisher");
     if (numberAt2(value, "version") !== RADAR_PUBLICATION_VERSION || agentId === void 0 || !isUuid(agentId) || textAt(value, "channel") !== channel || textAt(storedPublisher, "source") !== publisher.source || textAt(storedPublisher, "incarnation") !== publisher.incarnation || textAt(storedPublisher, "reporting_owner") !== publisher.reporting_owner)
       return blank("");
@@ -1644,7 +1697,7 @@ function createChannelWriter(input) {
     const sentAt = numberAt2(acceptedValue, "sent_at");
     return {
       version: RADAR_PUBLICATION_VERSION,
-      agent_id: agentId,
+      registration_id: agentId,
       channel,
       publisher,
       ...handle !== void 0 && generation !== void 0 ? { writer: { handle, generation } } : {},
@@ -1685,12 +1738,12 @@ function createChannelWriter(input) {
     if (record.writer !== void 0) return true;
     const agentId = await input.subject(recovering);
     if (agentId === void 0) return false;
-    if (record.agent_id !== agentId) {
+    if (record.registration_id !== agentId) {
       record = blank(agentId);
       save();
     }
     const answer = await client.acquire({
-      agent_id: agentId,
+      registration_id: agentId,
       channel,
       publisher
     });
@@ -1720,7 +1773,7 @@ function createChannelWriter(input) {
     const writer = record.writer;
     if (writer === void 0) return;
     const answer = await client.publish({
-      agent_id: record.agent_id,
+      registration_id: record.registration_id,
       channel,
       writer_handle: writer.handle,
       sequence: pending.sequence,
@@ -1814,9 +1867,9 @@ function createChannelWriter(input) {
       stopPump();
       const writer = record.writer;
       if (writer === void 0) return;
-      const agentId = record.agent_id;
+      const agentId = record.registration_id;
       try {
-        void client.retire({ agent_id: agentId, channel, writer_handle: writer.handle }).then((answer) => {
+        void client.retire({ registration_id: agentId, channel, writer_handle: writer.handle }).then((answer) => {
           if (answer.ok === true) {
             try {
               record.retired_at = new Date(scheduler.now()).toISOString();
@@ -1839,214 +1892,127 @@ function createChannelWriter(input) {
     diagnostic: () => record.diagnostic
   };
 }
-function createContextWriter(input) {
-  const { store, client, scheduler, recordName, publisher } = input;
-  let record = loadRecord();
-  let desired;
-  let desiredMarker;
-  let running = false;
-  let again = false;
-  let recovering = false;
-  let stopped = false;
-  let fenced = false;
-  let pump;
-  function blank(agentId) {
-    return {
-      version: RADAR_PUBLICATION_VERSION,
-      agent_id: agentId,
-      publisher,
-      sequence: 0
-    };
-  }
-  function loadRecord() {
-    const value = store.read(recordName);
-    const agentId = textAt(value, "agent_id");
-    const storedPublisher = recordAt2(value, "publisher");
-    if (numberAt2(value, "version") !== RADAR_PUBLICATION_VERSION || agentId === void 0 || !isUuid(agentId) && agentId !== "" || textAt(storedPublisher, "source") !== publisher.source || textAt(storedPublisher, "incarnation") !== publisher.incarnation || textAt(storedPublisher, "reporting_owner") !== publisher.reporting_owner)
-      return blank("");
-    const writer = recordAt2(value, "writer");
-    const handle = textAt(writer, "handle");
-    const generation = numberAt2(writer, "generation");
-    if (writer !== void 0 && (!exactKeys(writer, WRITER_KEYS) || !isUuid(handle) || generation === void 0))
-      return blank(agentId);
-    const pending = contextReportAt(
-      recordAt2(value, "pending"),
-      CONTEXT_PENDING_KEYS,
-      CONTEXT_PENDING_MARKED_KEYS
-    );
-    const acceptedValue = recordAt2(value, "accepted");
-    const accepted = contextReportAt(
-      acceptedValue,
-      CONTEXT_ACCEPTED_KEYS,
-      CONTEXT_ACCEPTED_MARKED_KEYS
-    );
-    const sentAt = numberAt2(acceptedValue, "sent_at");
-    return {
-      version: RADAR_PUBLICATION_VERSION,
-      agent_id: agentId,
-      publisher,
-      ...handle !== void 0 && generation !== void 0 ? { writer: { handle, generation } } : {},
-      sequence: numberAt2(value, "sequence") ?? 0,
-      ...pending !== void 0 ? { pending } : {},
-      ...accepted !== void 0 && sentAt !== void 0 ? { accepted: { ...accepted, sent_at: sentAt } } : {},
-      ...textAt(value, "diagnostic") !== void 0 ? { diagnostic: textAt(value, "diagnostic") } : {}
-    };
-  }
-  function note(message) {
-    if (record.diagnostic !== void 0) return;
-    record.diagnostic = message.slice(0, 256);
-    save();
+function createPresenceReporter(input) {
+  const { store, client, scheduler, recordName } = input;
+  let state;
+  let standing;
+  let diagnostic;
+  try {
+    const saved = store.read(recordName);
+    if (saved?.version === 2 && isUuid(saved.claim_id) && isUuid(saved.session) && Array.isArray(saved.releases))
+      state = saved;
+  } catch (error) {
+    diagnostic = `presence storage unavailable: ${String(error)}`;
   }
+  let timer;
+  let stopped = false;
+  let running;
   function save() {
-    store.write(recordName, record);
-  }
-  function fence(message) {
-    fenced = true;
-    stopPump();
-    note(`context stopped: ${message}`);
-  }
-  function startPump() {
-    if (pump !== void 0 || stopped || fenced) return;
-    pump = scheduler.setInterval(() => kick(), input.heartbeatMs);
-    pump.unref?.();
-  }
-  function stopPump() {
-    if (pump === void 0) return;
-    scheduler.clearInterval(pump);
-    pump = void 0;
+    try {
+      if (state) store.write(recordName, state);
+      return true;
+    } catch (error) {
+      diagnostic = `presence storage unavailable: ${String(error)}`;
+      return false;
+    }
   }
-  async function ensureSubject() {
-    if (record.writer !== void 0) return true;
-    const agentId = await input.subject(recovering);
-    if (agentId === void 0) return false;
-    if (record.agent_id !== agentId) {
-      record = blank(agentId);
+  async function releasePending() {
+    if (!state) return;
+    const registration = await input.registration();
+    if (!registration?.process) return;
+    for (const release of [...state.releases]) {
+      const answer = await client.releasePresence({ ...release, process: registration.process });
+      if (!answer.ok) return;
+      state.releases = state.releases.filter((r) => r.claim_id !== release.claim_id);
       save();
     }
-    return true;
   }
-  function heartbeatDue() {
-    return record.accepted !== void 0 && scheduler.now() - record.accepted.sent_at >= input.heartbeatMs;
+  function schedule() {
+    if (stopped || timer) return;
+    timer = scheduler.setTimeout(() => {
+      timer = void 0;
+      void ensure();
+    }, input.heartbeatMs);
+    timer.unref?.();
   }
-  async function send(pending) {
-    const writer = record.writer;
-    const answer = await client.context({
-      agent_id: record.agent_id,
-      publisher,
-      // A first publish presents no handle: the daemon binds the writer the
-      // publisher already is, which is the binding this writer then keeps.
-      ...writer !== void 0 ? { writer_handle: writer.handle } : {},
-      sequence: pending.sequence,
-      lease_ms: pending.lease_ms,
-      observed_at: pending.observed_at,
-      context: {
-        session: pending.session,
-        ...pending.launch_identity !== void 0 ? { launch_identity: pending.launch_identity } : {}
+  async function ensure() {
+    if (running) return running;
+    if (stopped || !state) return void 0;
+    const claim = state;
+    if (!save()) return void 0;
+    running = (async () => {
+      await releasePending();
+      const registration = await input.registration();
+      if (!registration?.process || state !== claim || stopped) return void 0;
+      const answer = await client.presence({
+        ...registration,
+        process: registration.process,
+        session_id: claim.session,
+        claim_id: claim.claim_id,
+        ...claim.registration_id ? { registration_id: claim.registration_id } : {},
+        ...claim.subject_id ? { subject_id: claim.subject_id } : {}
+      });
+      if (state !== claim) return void 0;
+      if (!answer.ok) {
+        if (!["absent", "timeout", "transport"].includes(answer.code)) diagnostic = answer.message;
+        return void 0;
       }
-    });
-    if (answer.ok === true) {
-      recovering = false;
-      record.writer = {
-        handle: answer.value.writer.handle,
-        generation: answer.value.writer.generation
-      };
-      record.sequence = Math.max(record.sequence, answer.value.writer.sequence);
-      record.accepted = {
-        ...pending,
-        sent_at: answer.value.warning === void 0 ? scheduler.now() : record.accepted?.sent_at ?? scheduler.now()
-      };
-      record.pending = void 0;
+      claim.registration_id = answer.value.registration_id;
+      claim.subject_id = answer.value.standing === "granted" ? answer.value.subject_id ?? void 0 : void 0;
+      standing = answer.value.standing === "granted" ? { state: "managed", subject_id: claim.subject_id } : answer.value.standing === "duplicate" ? { state: "duplicate" } : answer.value.standing === "pending" ? { state: "pending" } : { state: "unmanaged" };
+      diagnostic = answer.value.standing === "duplicate" ? DUPLICATE_SESSION_DIAGNOSTIC : void 0;
       save();
-      return;
-    }
-    if (answer.code === "refused" || answer.code === "bad_params" || // A daemon that speaks the registry but does not serve this record would
-    // refuse every retry the same way; one diagnostic beats a silent retry
-    // loop once per heartbeat.
-    answer.code === "unknown_method") {
-      fence(answer.message);
-      return;
-    }
-    if (answer.code === "not_found") {
-      record = blank("");
-      recovering = true;
-      save();
-      return;
-    }
-  }
-  async function stage(session, launchIdentity) {
-    const pending = {
-      sequence: record.sequence + 1,
-      session,
-      lease_ms: input.leaseMs,
-      observed_at: new Date(scheduler.now()).toISOString(),
-      ...launchIdentity !== void 0 ? { launch_identity: launchIdentity } : {}
-    };
-    record.pending = pending;
-    save();
-    await send(pending);
-  }
-  async function drainOnce() {
-    if (fenced) return;
-    if (record.pending !== void 0) {
-      await send(record.pending);
-      return;
-    }
-    if (desired === void 0) return;
-    if (!await ensureSubject()) return;
-    if (fenced) return;
-    if (record.writer === void 0 || record.accepted === void 0 || record.accepted.session !== desired || !sameLaunchIdentity(record.accepted.launch_identity, desiredMarker)) {
-      await stage(desired, desiredMarker);
-      return;
-    }
-    if (heartbeatDue()) await stage(record.accepted.session, desiredMarker);
-  }
-  async function drain() {
-    if (running || stopped || fenced) return;
-    running = true;
+      return claim.registration_id;
+    })();
     try {
-      await drainOnce();
+      return await running;
     } catch (error) {
-      fenced = true;
-      stopPump();
-      try {
-        note(`context storage failure: ${String(error).slice(0, 180)}`);
-      } catch {
-      }
+      diagnostic = `presence unavailable: ${String(error)}`;
+      return void 0;
     } finally {
-      running = false;
-      if (again && !stopped && !fenced) {
-        again = false;
-        kick();
-      }
+      running = void 0;
+      if (!stopped && state !== claim) void ensure();
+      else schedule();
     }
   }
-  function kick() {
-    if (stopped || fenced) return;
-    startPump();
-    if (running) {
-      again = true;
-      return;
-    }
-    void drain().catch(() => void 0);
-  }
   return {
-    update(session, launchIdentity) {
-      if (fenced || session === desired && sameLaunchIdentity(desiredMarker, launchIdentity))
-        return;
-      desired = session;
-      desiredMarker = launchIdentity;
-      if (stopped) return;
-      kick();
+    report(session) {
+      const releases = [...state?.releases ?? []];
+      if (state?.registration_id && !releases.some((release) => release.claim_id === state.claim_id)) {
+        releases.push({ registration_id: state.registration_id, claim_id: state.claim_id });
+      }
+      standing = void 0;
+      state = { version: 2, session, claim_id: randomUUID2(), releases };
+      save();
+      stopped = false;
+      void ensure();
+    },
+    ensure,
+    async release() {
+      const releasing = state;
+      standing = void 0;
+      stopped = true;
+      if (timer) scheduler.clearTimeout(timer);
+      timer = void 0;
+      if (running) await running;
+      if (state === releasing) standing = void 0;
+      if (releasing?.registration_id && !releasing.releases.some((r) => r.claim_id === releasing.claim_id)) {
+        releasing.releases.push({ registration_id: releasing.registration_id, claim_id: releasing.claim_id });
+        if (!save()) return;
+      }
+      await releasePending();
     },
     stop() {
       stopped = true;
-      stopPump();
+      if (timer) scheduler.clearTimeout(timer);
+      timer = void 0;
     },
     reopen() {
       stopped = false;
-      if (desired !== void 0 || record.pending !== void 0) kick();
+      void ensure();
     },
-    diagnostic: () => record.diagnostic
+    management: () => standing,
+    diagnostic: () => diagnostic
   };
 }
 var STORE_IDENTITY = /* @__PURE__ */ new WeakMap();
@@ -2075,10 +2041,13 @@ function unavailablePublication(error) {
   };
   return {
     execution: writer,
-    context: {
-      update: () => void 0,
+    presence: {
+      report: () => void 0,
+      ensure: async () => void 0,
+      release: async () => void 0,
       stop: () => void 0,
       reopen: () => void 0,
+      management: () => void 0,
       diagnostic: () => diagnostic
     },
     facts: { ...writer, update: () => void 0 },
@@ -2105,33 +2074,29 @@ function createRadarPublicationInner(options) {
     cached.reopen();
     return cached;
   }
-  const subjectName = `subjects/${createHash("sha256").update(`${options.registration.source}\0${incarnation}`).digest("hex").slice(0, 32)}.json`;
+  const registrationName = `registrations/${createHash("sha256").update(`${options.registration.source}\0${incarnation}`).digest("hex").slice(0, 32)}.json`;
   const channelRecord = (channel, target) => `channels/${createHash("sha256").update(`${channel}\0${incarnation}\0${target ?? ""}`).digest("hex").slice(0, 32)}.json`;
-  const contextRecord = `context/${createHash("sha256").update(`context\0${incarnation}`).digest("hex").slice(0, 32)}.json`;
-  function readSubject() {
-    const value = store.read(subjectName);
+  const presenceRecord = `presence/${createHash("sha256").update(`presence\0${incarnation}`).digest("hex").slice(0, 32)}.json`;
+  function readRegistration() {
+    const value = store.read(registrationName);
     const registration = recordAt2(value, "registration");
     if (numberAt2(value, "version") !== RADAR_PUBLICATION_VERSION || textAt(registration, "source") !== options.registration.source || textAt(registration, "incarnation") !== incarnation)
       return void 0;
-    const storedAgentId = textAt(value, "agent_id");
+    const storedAgentId = textAt(value, "registration_id");
     return {
       version: RADAR_PUBLICATION_VERSION,
       registration,
-      ...storedAgentId !== void 0 && isUuid(storedAgentId) ? { agent_id: storedAgentId } : {}
+      ...storedAgentId !== void 0 && isUuid(storedAgentId) ? { registration_id: storedAgentId } : {}
     };
   }
-  const stored = readSubject();
-  let subject = stored;
+  const stored = readRegistration();
+  let processRecord = stored;
   let registrationDiagnostic;
   let registrationRecord;
   async function ensureRegistration() {
-    if (subject !== void 0) return subject;
+    if (processRecord !== void 0) return processRecord;
     registrationRecord ??= (async () => {
       const resolution = options.location ? await options.location() : { state: "absent", reason: "this process publishes no location" };
-      if (resolution.state === "pending") {
-        registrationDiagnostic = `location bootstrap pending: ${resolution.reason}`.slice(0, 256);
-        return void 0;
-      }
       const built = {
         version: RADAR_PUBLICATION_VERSION,
         registration: {
@@ -2142,13 +2107,13 @@ function createRadarPublicationInner(options) {
         }
       };
       try {
-        store.write(subjectName, built);
+        store.write(registrationName, built);
       } catch (error) {
         registrationDiagnostic ??= `private storage unavailable: ${String(error)}`.slice(0, 256);
         return void 0;
       }
       registrationDiagnostic = void 0;
-      subject = built;
+      processRecord = built;
       return built;
     })();
     try {
@@ -2157,11 +2122,10 @@ function createRadarPublicationInner(options) {
       registrationRecord = void 0;
     }
   }
-  let agentId = stored?.agent_id;
+  let agentId = stored?.registration_id;
   let subjectReady;
   async function ensureSubject(recheck) {
-    if (recheck) agentId = void 0;
-    if (agentId !== void 0) return agentId;
+    if (!recheck && agentId !== void 0) return agentId;
     subjectReady ??= (async () => {
       const ready = await client.ping();
       if (ready.ok === false) {
@@ -2171,18 +2135,11 @@ function createRadarPublicationInner(options) {
       }
       const record = await ensureRegistration();
       if (record === void 0) return void 0;
-      const answer = await client.register({
-        ...record.registration,
-        ...spawnToken !== void 0 ? { spawn_token: spawnToken } : {}
-      });
-      if (answer.ok === false) {
-        if (answer.code !== "absent" && answer.code !== "timeout" && answer.code !== "transport")
-          registrationDiagnostic ??= `subject registration refused: ${answer.message}`.slice(0, 256);
-        return void 0;
-      }
-      agentId = answer.value.agent_id;
-      subject = { ...record, agent_id: agentId };
-      store.write(subjectName, subject);
+      const registered = await presence.ensure();
+      if (registered === void 0) return void 0;
+      agentId = registered;
+      processRecord = { ...record, registration_id: agentId };
+      store.write(registrationName, processRecord);
       if (options.binding !== void 0) writeBinding(options.binding);
       return agentId;
     })();
@@ -2196,7 +2153,7 @@ function createRadarPublicationInner(options) {
     if (agentId === void 0) return;
     store.write(`bindings/${binding.key}.json`, {
       version: RADAR_PUBLICATION_VERSION,
-      agent_id: agentId,
+      registration_id: agentId,
       incarnation,
       run: binding.run,
       owner: binding.owner,
@@ -2220,14 +2177,22 @@ function createRadarPublicationInner(options) {
     leaseMs: options.leaseMs ?? RADAR_LEASE_MS,
     heartbeatMs: options.heartbeatMs ?? RADAR_HEARTBEAT_MS
   });
-  const context = createContextWriter({
+  const presence = createPresenceReporter({
     store,
     client,
     scheduler,
-    recordName: contextRecord,
-    publisher: publisher("herdsman-pi"),
-    subject: ensureSubject,
-    leaseMs: options.leaseMs ?? RADAR_LEASE_MS,
+    recordName: presenceRecord,
+    registration: async () => {
+      const record = await ensureRegistration();
+      if (!record) return void 0;
+      const location = await options.location?.();
+      const { location: _initialLocation, ...identity } = record.registration;
+      return {
+        ...identity,
+        ...location?.state === "resolved" ? { location: location.location } : {},
+        ...spawnToken ? { spawn_token: spawnToken } : {}
+      };
+    },
     heartbeatMs: options.heartbeatMs ?? RADAR_HEARTBEAT_MS
   });
   const facts = createChannelWriter({
@@ -2245,7 +2210,7 @@ function createRadarPublicationInner(options) {
   const assignmentWriters = /* @__PURE__ */ new Map();
   const publication = {
     execution,
-    context,
+    presence,
     facts,
     assignment(target, reportingOwner) {
       const existing = assignmentWriters.get(target);
@@ -2260,7 +2225,7 @@ function createRadarPublicationInner(options) {
           publisher: publisher("herdsman-owner", reportingOwner),
           codec: assignmentCodec,
           // The owner publishes about a subject it did not register: the exact
-          // agent_id from the child's sidecar is the whole correlation.
+          // registration_id from the child's sidecar is the whole correlation.
           subject: async () => target,
           leaseMs: options.leaseMs ?? RADAR_LEASE_MS,
           heartbeatMs: options.heartbeatMs ?? RADAR_HEARTBEAT_MS
@@ -2280,7 +2245,7 @@ function createRadarPublicationInner(options) {
         registrationDiagnostic ??= `Radar binding unavailable: ${String(error).slice(0, 180)}`;
         return void 0;
       }
-      const bound = textAt(value, "agent_id");
+      const bound = textAt(value, "registration_id");
       const boundIncarnation = textAt(value, "incarnation");
       const run = textAt(value, "run");
       const owner = textAt(value, "owner");
@@ -2290,7 +2255,7 @@ function createRadarPublicationInner(options) {
         return void 0;
       return {
         version: RADAR_PUBLICATION_VERSION,
-        agent_id: bound,
+        registration_id: bound,
         incarnation: boundIncarnation,
         run,
         owner,
@@ -2306,23 +2271,27 @@ function createRadarPublicationInner(options) {
       if (agentId2 === void 0) return void 0;
       const record = await ensureRegistration();
       if (record === void 0) return void 0;
-      const location = record.registration.location;
+      const currentLocation = await options.location?.();
+      const location = currentLocation?.state === "resolved" ? currentLocation.location : void 0;
+      const standing = presence.management();
+      const subjectId = standing?.state === "managed" ? standing.subject_id : void 0;
       return {
-        agent_id: agentId2,
+        registration_id: agentId2,
+        ...subjectId !== void 0 ? { subject_id: subjectId } : {},
         ...location !== void 0 ? { location } : {}
       };
     },
-    diagnostic: () => registrationDiagnostic ?? execution.diagnostic() ?? context.diagnostic() ?? facts.diagnostic(),
+    diagnostic: () => registrationDiagnostic ?? execution.diagnostic() ?? presence.diagnostic() ?? facts.diagnostic(),
     stop() {
       for (const writer of assignmentWriters.values()) writer.stop();
       execution.stop();
-      context.stop();
+      presence.stop();
       facts.stop();
     },
     reopen() {
       for (const writer of assignmentWriters.values()) writer.reopen();
       execution.reopen();
-      context.reopen();
+      presence.reopen();
       facts.reopen();
     }
   };
@@ -2360,10 +2329,13 @@ function unavailablePublication2() {
   return {
     execution: writer,
     facts: { ...writer, update: () => void 0 },
-    context: {
-      update: () => void 0,
+    presence: {
+      report: () => void 0,
       stop: () => void 0,
       reopen: () => void 0,
+      management: () => void 0,
+      ensure: async () => void 0,
+      release: async () => void 0,
       diagnostic: () => "Radar private storage is unavailable"
     },
     assignment: () => writer,
@@ -2446,11 +2418,11 @@ function createRadarExecutionAdapter(pi, options) {
       ...lastOutcome !== void 0 ? { last_outcome: lastOutcome } : {}
     };
   }
-  function reportSession(context, launchIdentity) {
+  function reportSession(context) {
     const session = context?.sessionManager?.getSessionId?.();
     if (!isUuid(session)) return;
     try {
-      publication.context.update(session, launchIdentity);
+      publication.presence.report(session);
     } catch {
     }
   }
@@ -2514,38 +2486,8 @@ function createRadarExecutionAdapter(pi, options) {
       })
     );
   on("session_start", (_event, context) => {
-    const sessionHost = {
-      appendEntry: pi.appendEntry ? (customType, data) => pi.appendEntry?.(customType, data) : void 0,
-      sessionManager: context?.sessionManager
-    };
-    let launchIdentity;
-    try {
-      const result = persistRadarLaunchMarker(
-        sessionHost,
-        options.markerEnvironment
-      );
-      if (result === "written" || result === "unchanged") {
-        const expected = radarLaunchMarkerFromEnvironment(options.markerEnvironment);
-        const activeMarker = activeRadarLaunchMarker(sessionHost);
-        if (expected && activeMarker.status === "valid" && JSON.stringify(activeMarker.marker) === JSON.stringify(expected)) {
-          launchIdentity = activeMarker.marker;
-        } else {
-          options.diagnostic?.("Radar launch marker was not visible on the active Pi session branch");
-        }
-      } else if (result === "unsupported") {
-        options.diagnostic?.("Pi host does not support Radar launch identity session entries");
-      } else if (options.markerEnvironment && [
-        "PI_RADAR_MANAGED_SUBJECT_ID",
-        "PI_RADAR_MANAGED_LAUNCH_ID",
-        "PI_RADAR_MANAGED_EXECUTION_GENERATION"
-      ].some((key) => options.markerEnvironment?.[key] !== void 0)) {
-        options.diagnostic?.("incomplete or invalid Radar launch identity environment");
-      }
-    } catch (error) {
-      options.diagnostic?.(`could not persist Radar launch marker: ${String(error)}`);
-    }
     rootSession = true;
-    reportSession(context, launchIdentity);
+    reportSession(context);
     publishFacts(context);
     publication.reopen();
     active = context?.isIdle?.() === false;
@@ -2576,8 +2518,9 @@ function createRadarExecutionAdapter(pi, options) {
     }
     emit();
   });
-  on("session_shutdown", () => {
+  on("session_shutdown", async () => {
     suspend();
+    await publication.presence.release();
   });
   function suspend() {
     if (stopped) return;
@@ -2785,7 +2728,7 @@ function trajectory(reason) {
   return `the daemon's current record of this launch's child is ${reason}`;
 }
 async function observeRadarChild(client, provenance) {
-  if (provenance.agent_id === void 0)
+  if (provenance.registration_id === void 0)
     return unknownChild("not bound to a child by this launch");
   if (provenance.pane_id === void 0)
     return unknownChild("without a pane this launch recorded for it");
@@ -2796,11 +2739,11 @@ async function observeRadarChild(client, provenance) {
     );
   const topology = read.value;
   const edge = topology.edge;
-  if (edge.bound === void 0 || edge.bound.agent_id === void 0)
+  if (edge.bound === void 0 || edge.bound.registration_id === void 0)
     return unknownChild("not bound to a child by the daemon");
-  if (edge.bound.agent_id !== provenance.agent_id)
+  if (edge.bound.registration_id !== provenance.registration_id)
     return unknownChild(
-      `bound to another subject (${edge.bound.agent_id}), not to ${provenance.agent_id}`
+      `bound to another subject (${edge.bound.registration_id}), not to ${provenance.registration_id}`
     );
   if (edge.location?.pane === void 0)
     return unknownChild("recorded without a pane");
@@ -2818,7 +2761,7 @@ async function observeRadarChild(client, provenance) {
     return unknownChild(
       `not currently placed (state ${topology.state ?? "unreported"})`
     );
-  const reply = await client.agentGet(edge.bound.agent_id);
+  const reply = await client.agentGet(edge.bound.registration_id);
   if (reply.ok === false)
     return unknownChild(
       `process verdict not readable (${reply.code}: ${reply.message})`
@@ -2846,7 +2789,7 @@ async function observeRadarChild(client, provenance) {
     kind: "live",
     evidence: {
       request_id: provenance.request_id,
-      agent_id: edge.bound.agent_id,
+      registration_id: edge.bound.registration_id,
       source: edge.bound.source,
       incarnation: edge.bound.incarnation,
       pane_id: edge.location.pane
@@ -2906,19 +2849,24 @@ async function launchRadarWorker(options) {
   const deadline = Date.now() + options.timeoutMs;
   const remaining = () => Math.max(0, deadline - Date.now());
   const pane = launch.parent.location?.pane;
-  if (!isUuid(launch.parent.agent_id))
+  if (!isUuid(launch.parent.registration_id))
     return refusedLaunch(
       "the launch has no exact parent registration to spawn under"
     );
+  if (!isUuid(launch.parent.subject_id))
+    return refusedLaunch(
+      "the launch has no managed Radar subject for its parent"
+    );
   if (pane === void 0 || pane === "")
     return refusedLaunch(
       "this process's Radar registration names no pane, so it cannot be a spawn parent"
     );
   const spawned = await client.spawn({
     request_id: launch.request_id,
-    parent: launch.parent.agent_id,
+    parent: launch.parent.registration_id,
     parent_session_id: launch.parent_session_id,
     executable: launch.executable,
+    managed: { parent_subject_id: launch.parent.subject_id },
     argv: launch.argv,
     ...launch.cwd !== "" ? { cwd: launch.cwd } : {},
     ...Object.keys(launch.env).length > 0 ? { env: launch.env } : {}
@@ -2940,10 +2888,10 @@ async function launchRadarWorker(options) {
     ...signal !== void 0 ? { signal } : {}
   });
   if (bound.kind !== "bound") return bound;
-  const agentId = bound.agent_id;
+  const agentId = bound.registration_id;
   if (launch.onBound !== void 0) {
     try {
-      launch.onBound({ agent_id: agentId, pane_id: bound.pane_id });
+      launch.onBound({ registration_id: agentId, pane_id: bound.pane_id });
     } catch (error) {
       return unresolvedLaunch(
         launch.request_id,
@@ -2971,7 +2919,7 @@ async function launchRadarWorker(options) {
       kind: "ready",
       value: {
         request_id: launch.request_id,
-        agent_id: agentId,
+        registration_id: agentId,
         pane_id: bound.pane_id,
         bound_process: {
           source: bound.source,
@@ -3017,7 +2965,7 @@ async function waitForChild(client, requestId, options) {
           requestId,
           "the daemon observed the launched child's process exit"
         );
-      const agentId = edge.bound?.agent_id;
+      const agentId = edge.bound?.registration_id;
       if (agentId !== void 0 && isUuid(agentId)) {
         const source = edge.bound?.source;
         const incarnation = edge.bound?.incarnation;
@@ -3028,7 +2976,7 @@ async function waitForChild(client, requestId, options) {
           );
         return {
           kind: "bound",
-          agent_id: agentId,
+          registration_id: agentId,
           pane_id: pane,
           source,
           incarnation
@@ -3056,7 +3004,7 @@ __export(radar_runtime_exports, {
   requestRadarRuntime: () => requestRadarRuntime
 });
 var RADAR_RUNTIME_REQUEST = "pi-radar/runtime-request";
-var RADAR_RUNTIME_VERSION = 1;
+var RADAR_RUNTIME_VERSION = 2;
 function lazyRadarRuntime(start) {
   let pending;
   return {
@@ -3091,6 +3039,7 @@ function isRadarRuntimeHandle(value) {
 }
 export {
   radar_client_exports as client,
+  radar_communication_exports as communication,
   radar_execution_exports as execution,
   radar_inspection_exports as inspection,
   radar_launch_exports as launch,