pi-radar 0.7.0 → 0.10.0

package/dist/index.js

@@ -4,6 +4,72 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// extension/radar-children.ts
+var radar_children_exports = {};
+__export(radar_children_exports, {
+  createRadarChildren: () => createRadarChildren
+});
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// extension/radar-inspection.ts
+var radar_inspection_exports = {};
+__export(radar_inspection_exports, {
+  inspectRadarChild: () => inspectRadarChild,
+  provedRead: () => provedRead
+});
+var INSPECTION_LINES = 80;
+var INSPECTION_OUTPUT_BYTES = 16 * 1024;
+async function provedRead(client, target) {
+  const read = await client.agentGet(target.agentId);
+  return read.ok === true && read.value.verification === "verified" && read.value.location?.pane === target.paneId && (target.session === void 0 || read.value.contextSession === target.session) ? read.value : void 0;
+}
+async function inspectRadarChild(client, target) {
+  const before = await provedRead(client, target);
+  if (before === void 0)
+    throw new Error("Inspection target identity did not match");
+  const output = await client.output({
+    pane_id: target.paneId,
+    source: "recent_unwrapped",
+    lines: INSPECTION_LINES
+  });
+  if (output.ok === false)
+    throw new Error(
+      `Inspection output unavailable (${output.code}: ${output.message})`
+    );
+  const foreground = await client.processInfo({ pane_id: target.paneId });
+  const after = await provedRead(client, target);
+  if (after === void 0)
+    throw new Error("Inspection target changed during capture");
+  const lines = output.value.text.trim().split(/\r?\n/).slice(-INSPECTION_LINES);
+  const bounded2 = utf8Tail(lines.join("\n"), INSPECTION_OUTPUT_BYTES);
+  return Object.freeze({
+    capturedAt: Date.now(),
+    recentOutputTruncated: output.value.truncated || bounded2.truncated,
+    ...bounded2.text ? { recentOutput: bounded2.text } : {},
+    ...foreground.ok === true ? { foreground: foreground.value } : {},
+    ...after.activity !== void 0 ? { activity: after.activity } : {}
+  });
+}
+function utf8Tail(value, maxBytes) {
+  const bytes = Buffer.from(value);
+  if (bytes.length <= maxBytes) return { text: value, truncated: false };
+  let start = bytes.length - maxBytes;
+  while (start < bytes.length && (bytes[start] & 192) === 128) start++;
+  return { text: bytes.subarray(start).toString(), truncated: true };
+}
+
+// extension/radar-launch.ts
+var radar_launch_exports = {};
+__export(radar_launch_exports, {
+  launchFailure: () => launchFailure,
+  launchRadarWorker: () => launchRadarWorker,
+  observeRadarChild: () => observeRadarChild,
+  readProcessGone: () => readProcessGone,
+  relaunchRefusalForChild: () => relaunchRefusalForChild,
+  waitForChild: () => waitForChild
+});
+import { setTimeout as delay } from "node:timers/promises";
+
 // extension/radar-client.ts
 var radar_client_exports = {};
 __export(radar_client_exports, {
@@ -11,6 +77,7 @@ __export(radar_client_exports, {
   RADAR_COMMUNICATION_CONTRACT: () => RADAR_COMMUNICATION_CONTRACT,
   RADAR_EVENTS_CONTRACT: () => RADAR_EVENTS_CONTRACT,
   RADAR_EVENT_RETRY_MS: () => RADAR_EVENT_RETRY_MS,
+  RADAR_LIFECYCLE_RESTART_CONTRACT: () => RADAR_LIFECYCLE_RESTART_CONTRACT,
   RADAR_MAX_AWAITED: () => RADAR_MAX_AWAITED,
   RADAR_MAX_BACKGROUND_TASKS: () => RADAR_MAX_BACKGROUND_TASKS,
   RADAR_MAX_LINE_BYTES: () => RADAR_MAX_LINE_BYTES,
@@ -40,12 +107,13 @@ import { lstatSync } from "node:fs";
 import { createConnection } from "node:net";
 import { dirname, join } from "node:path";
 var RADAR_PROTOCOL_VERSION = 2;
-var RADAR_MINIMUM_REVISION = 6;
+var RADAR_MINIMUM_REVISION = 8;
 var RADAR_REGISTRY_CONTRACT = "registry.v1";
 var RADAR_REGISTRY_FACTS_CONTRACT = "registry.facts.v1";
 var RADAR_SPAWN_CONTRACT = "spawn.v1";
 var RADAR_SPAWN_LIST_CONTRACT = "spawn.list.v1";
 var RADAR_SPAWN_CLOSE_CONTRACT = "spawn.close.v1";
+var RADAR_LIFECYCLE_RESTART_CONTRACT = "lifecycle.restart.v1";
 var RADAR_SPAWN_LAUNCH_CONTEXT_CONTRACT = "spawn.launch_context.v1";
 var RADAR_EVENTS_CONTRACT = "events.v1";
 var RADAR_COMMUNICATION_CONTRACT = "communication.handoff.v1";
@@ -351,7 +419,11 @@ function spawnEdge(value) {
   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"));
+  const withdrawnRecord = recordAt(value, "withdrawn");
+  const withdrawnAt = stringAt(withdrawnRecord, "at");
+  const withdrawnReason = stringAt(withdrawnRecord, "reason");
   return {
     ok: true,
     value: {
@@ -364,10 +436,13 @@ function spawnEdge(value) {
         bound: {
           source,
           incarnation,
-          ...isUuid(agentId) ? { registration_id: agentId } : {}
+          ...isUuid(agentId) ? { registration_id: agentId } : {},
+          ...isUuid(subjectId) ? { subject_id: subjectId } : {}
         }
       } : {},
-      ...exit !== void 0 ? { exit_observation: exit } : {}
+      ...exit !== void 0 ? { exit_observation: exit } : {},
+      ...stringAt(value, "granted_at") !== void 0 ? { granted_at: stringAt(value, "granted_at") } : {},
+      ...withdrawnAt !== void 0 && withdrawnReason !== void 0 ? { withdrawn: { at: withdrawnAt, reason: withdrawnReason } } : {}
     }
   };
 }
@@ -436,6 +511,8 @@ function spawnTopology(value) {
 function spawnRequestShape(request) {
   if (!isUuid(request.request_id))
     return "spawn requires a canonical request UUID";
+  if (request.continue_subject_id !== void 0 && !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))
@@ -902,7 +979,8 @@ function createRadarClient(options = {}) {
                 argv: request.argv,
                 ...request.cwd !== void 0 ? { cwd: request.cwd } : {},
                 ...carriesContext && request.env !== void 0 ? { env: request.env } : {},
-                ...request.managed !== void 0 ? { managed: request.managed } : {}
+                ...request.managed !== void 0 ? { managed: request.managed } : {},
+                ...request.continue_subject_id !== void 0 ? { continue_subject_id: request.continue_subject_id } : {}
               },
               requester
             },
@@ -930,6 +1008,37 @@ function createRadarClient(options = {}) {
         }
       );
     },
+    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 !== void 0 ? { cwd: request.cwd } : {},
+              ...request.env !== void 0 ? { env: request.env } : {}
+            },
+            requester
+          },
+          request.request_id
+        );
+        if (answer.ok === false) return answer;
+        const settled = focusOutcome(recordAt(answer.value, "request"), request.request_id);
+        if (settled.ok === false) return settled;
+        const launch = recordAt(recordAt(answer.value, "request"), "launch_request_id");
+        if (!isUuid(launch)) return protocol("lifecycle.restart reply names no launch");
+        return { ok: true, value: { ...settled.value, launch_request_id: launch } };
+      });
+    },
     async spawnList(request) {
       const registrationId = processRegistrationId;
       if (registrationId === void 0)
@@ -1297,6 +1406,357 @@ function boundedRadarSnapshot(snapshot) {
   };
 }
 
+// extension/radar-launch.ts
+function unknownChild(reason) {
+  return { kind: "unknown", diagnostic: trajectory(reason) };
+}
+function trajectory(reason) {
+  return `the daemon's current record of this launch's child is ${reason}`;
+}
+async function observeRadarChild(client, provenance) {
+  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");
+  const read = await client.spawnGet(provenance.request_id);
+  if (read.ok === false)
+    return unknownChild(
+      `not readable (${read.code}: ${read.message})`
+    );
+  const topology = read.value;
+  const edge = topology.edge;
+  if (edge.bound === void 0 || edge.bound.registration_id === void 0)
+    return unknownChild("not bound to a child by the daemon");
+  if (edge.bound.registration_id !== provenance.registration_id)
+    return unknownChild(
+      `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");
+  if (edge.location.pane !== provenance.pane_id)
+    return unknownChild(
+      `recorded on pane ${edge.location.pane}, not on ${provenance.pane_id}`
+    );
+  if (edge.exit_observation?.state !== "unknown")
+    return unknownChild("recorded with an observed process exit");
+  if (topology.freshness !== "fresh")
+    return unknownChild(
+      "on a pane the daemon's own inventory does not currently report"
+    );
+  if (topology.state !== "bound")
+    return unknownChild(
+      `not currently placed (state ${topology.state ?? "unreported"})`
+    );
+  const reply = await client.agentGet(edge.bound.registration_id);
+  if (reply.ok === false)
+    return unknownChild(
+      `process verdict not readable (${reply.code}: ${reply.message})`
+    );
+  const { verification, location, contextSession } = reply.value;
+  if (verification === "absent" || verification === "mismatched")
+    return {
+      kind: "gone",
+      verification,
+      diagnostic: trajectory(`the registered process is ${verification}`)
+    };
+  if (verification !== "verified")
+    return unknownChild(`process verdict is ${verification}`);
+  if (location?.pane !== provenance.pane_id)
+    return unknownChild(
+      `registered on ${location?.pane ?? "no pane"}, not on ${provenance.pane_id}`
+    );
+  if (provenance.session_id === void 0)
+    return unknownChild("without a session this launch recorded for it");
+  if (contextSession !== provenance.session_id)
+    return unknownChild(
+      `publishing session ${contextSession ?? "none"}, not ${provenance.session_id}`
+    );
+  return {
+    kind: "live",
+    evidence: {
+      request_id: provenance.request_id,
+      registration_id: edge.bound.registration_id,
+      source: edge.bound.source,
+      incarnation: edge.bound.incarnation,
+      pane_id: edge.location.pane
+    }
+  };
+}
+async function readProcessGone(client, agentId) {
+  const read = await client.agentGet(agentId);
+  if (read.ok === false) return void 0;
+  const { verification } = read.value;
+  return verification === "absent" || verification === "mismatched" ? verification : void 0;
+}
+async function relaunchRefusalForChild(client, agentId) {
+  const read = await client.agentGet(agentId);
+  if (read.ok === false)
+    return `the child's process cannot be read (${read.code}: ${read.message})`;
+  const { verification } = read.value;
+  if (verification === "absent" || verification === "mismatched") return void 0;
+  return `the child's registered process is ${verification === "verified" ? "still running" : "not proved gone"}`;
+}
+function refusedLaunch(message) {
+  return { kind: "failed", message };
+}
+function unresolvedLaunch(requestId, message) {
+  return {
+    kind: "unresolved",
+    request_id: requestId,
+    message: `spawn ${requestId} is unresolved (${message})`
+  };
+}
+var PRE_EFFECT_CODES = [
+  "absent",
+  "unsupported",
+  "bad_version",
+  "bad_request",
+  "bad_params",
+  "unknown_method",
+  "refused",
+  "not_found",
+  "busy",
+  "backend_unavailable"
+];
+function launchFailure(result, requestId) {
+  return PRE_EFFECT_CODES.includes(result.code) ? refusedLaunch(result.message) : unresolvedLaunch(requestId, result.message);
+}
+async function launchRadarWorker(options) {
+  const { client, launch, signal } = options;
+  const pollMs = options.pollMs ?? 250;
+  const parent = await options.publication.subject();
+  if (parent === void 0 || !isUuid(parent.registration_id))
+    return refusedLaunch(
+      "this process has no Radar registration, so a worker cannot be spawned under it"
+    );
+  if (parent.subject_id === void 0 || !isUuid(parent.subject_id))
+    return refusedLaunch(
+      "this process has no managed Radar subject, so a worker cannot be spawned under it"
+    );
+  const pane = parent.location?.pane;
+  if (pane === void 0 || pane === "")
+    return refusedLaunch(
+      "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: parent.registration_id,
+    parent_session_id: launch.parent_session_id,
+    executable: launch.executable,
+    managed: { parent_subject_id: parent.subject_id },
+    ...launch.continues !== void 0 ? { 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 = launchFailure(spawned, launch.request_id);
+    if (refusal.kind === "failed") return refusal;
+  }
+  const bound = await waitForChild(client, launch.request_id, {
+    pollMs,
+    ...signal !== void 0 ? { signal } : {}
+  });
+  if (bound.kind !== "bound") return bound;
+  return {
+    kind: "ready",
+    value: {
+      request_id: launch.request_id,
+      subject_id: bound.subject_id,
+      pane_id: bound.pane_id
+    }
+  };
+}
+async function waitForChild(client, requestId, options) {
+  let last = "the daemon has not answered";
+  for (; ; ) {
+    if (options.signal?.aborted)
+      return unresolvedLaunch(requestId, `the launch was cancelled (${last})`);
+    const answer = await client.spawnGet(requestId);
+    if (answer.ok === true) {
+      const { edge } = answer.value;
+      if (edge.withdrawn !== void 0)
+        return refusedLaunch(`the daemon withdrew this launch: ${edge.withdrawn.reason}`);
+      if (edge.granted_at === void 0) {
+        await delay(options.pollMs);
+        continue;
+      }
+      const pane = edge.location?.pane;
+      if (pane === void 0 || pane === "")
+        return unresolvedLaunch(
+          requestId,
+          "the daemon's launch recorded no pane to verify the child against"
+        );
+      const agentId = edge.bound?.registration_id;
+      if (agentId !== void 0 && isUuid(agentId)) {
+        const subjectId = edge.bound?.subject_id;
+        if (subjectId === void 0 || !isUuid(subjectId))
+          return unresolvedLaunch(
+            requestId,
+            `the daemon bound the child ${agentId} without recording its subject`
+          );
+        return {
+          kind: "bound",
+          subject_id: subjectId,
+          pane_id: pane
+        };
+      }
+      last = "no child has registered with this launch's token yet";
+    } else {
+      return unresolvedLaunch(requestId, answer.message);
+    }
+    await delay(options.pollMs);
+  }
+}
+
+// extension/radar-children.ts
+var PAGE = 100;
+var MAX_PAGES = 20;
+function createRadarChildren(client, publication) {
+  const held = /* @__PURE__ */ new Map();
+  async function resolveAll() {
+    const newest = /* @__PURE__ */ new Map();
+    let after;
+    for (let page = 0; page < MAX_PAGES; page++) {
+      const read = await client.spawnList({ ...after !== void 0 ? { after } : {}, limit: PAGE });
+      if (read.ok === false) return read;
+      for (const edge of read.value.spawns) {
+        const bound = edge.bound;
+        if (!bound?.subject_id || !bound.registration_id || edge.granted_at == null || edge.withdrawn != null) continue;
+        const at = Date.parse(bound.bound_at);
+        if (Number.isNaN(at)) continue;
+        const current = newest.get(bound.subject_id);
+        if (current !== void 0 && 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 resolve2(subject) {
+    const all = await resolveAll();
+    return all.ok ? all.value.get(subject) : void 0;
+  }
+  async function resolveAndFollow(subject) {
+    const all = await resolveAll();
+    if (!all.ok) return void 0;
+    follow(all.value);
+    return all.value.get(subject);
+  }
+  function follow(all) {
+    for (const [subject, entry] of held) {
+      const target = all.get(subject);
+      if (target !== void 0 && 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) };
+    },
+    async restart(subject, program, options) {
+      const parent = await publication.subject();
+      if (parent?.subject_id === void 0)
+        return { kind: "failed", message: "this process has no Radar registration to restart a child under" };
+      const request_id = randomUUID2();
+      const requested = await client.restart({
+        request_id,
+        parent: parent.registration_id,
+        subject_id: subject,
+        ...program
+      });
+      if (requested.ok === false)
+        return launchFailure(requested, request_id);
+      const bound = await waitForChild(client, requested.value.launch_request_id, {
+        pollMs: options?.pollMs ?? 250,
+        ...options?.signal !== void 0 ? { signal: options.signal } : {}
+      });
+      if (bound.kind !== "bound") return bound;
+      await resolveAndFollow(subject);
+      return {
+        kind: "ready",
+        value: {
+          request_id: requested.value.launch_request_id,
+          subject_id: bound.subject_id,
+          pane_id: bound.pane_id
+        }
+      };
+    },
+    assignment(subject, owner) {
+      const existing = held.get(subject);
+      if (existing !== void 0) return existing.writer;
+      let latest;
+      const entry = { writer: void 0 };
+      const send = (target) => {
+        if (latest === void 0) return;
+        if (entry.published !== void 0 && 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 resolve2(subject).then((target) => {
+            if (target !== void 0) send(target);
+          });
+        },
+        retire() {
+          latest = void 0;
+          if (entry.published !== void 0) publication.retireAssignment(entry.published);
+          entry.published = void 0;
+        }
+      };
+      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 === void 0)
+        return { kind: "unknown", diagnostic: "the daemon records no bound launch for this child" };
+      return observeRadarChild(client, {
+        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 === void 0)
+        throw new Error("Inspection target is not a bound child with a pane");
+      return inspectRadarChild(client, {
+        agentId: target.registration_id,
+        paneId: target.child.pane_id,
+        ...session_id !== void 0 ? { session: session_id } : {}
+      });
+    }
+  };
+}
+
 // extension/radar-communication.ts
 var radar_communication_exports = {};
 __export(radar_communication_exports, {
@@ -1361,7 +1821,7 @@ __export(radar_publication_exports, {
   radarProcessSlot: () => radarProcessSlot,
   readProcessBirth: () => readProcessBirth
 });
-import { createHash, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash, randomUUID as randomUUID3 } from "node:crypto";
 import {
   closeSync,
   constants,
@@ -1491,7 +1951,7 @@ function createPublicationStore(root) {
       ensureDirectory(directory);
       const temporary = join2(
         directory,
-        `.${name.slice(name.lastIndexOf("/") + 1)}.${randomUUID2()}.tmp`
+        `.${name.slice(name.lastIndexOf("/") + 1)}.${randomUUID3()}.tmp`
       );
       const bytes = Buffer.from(JSON.stringify(value), "utf8");
       if (bytes.length > MAX_RECORD_BYTES)
@@ -1547,7 +2007,7 @@ function radarProcessSlot() {
   return host[PROCESS_SLOT];
 }
 function radarProcessIncarnation(slot = radarProcessSlot()) {
-  return slot.incarnation ??= randomUUID2();
+  return slot.incarnation ??= randomUUID3();
 }
 function radarBindingKey(run, owner, label) {
   return createHash("sha256").update(`${run}\0${owner}\0${label}`).digest("hex").slice(0, 32);
@@ -2015,7 +2475,7 @@ function createPresenceReporter(input) {
         releases.push({ registration_id: state.registration_id, claim_id: state.claim_id });
       }
       standing = void 0;
-      state = { version: 2, session, claim_id: randomUUID2(), releases };
+      state = { version: 2, session, claim_id: randomUUID3(), releases };
       save();
       stopped = false;
       void ensure();
@@ -2052,7 +2512,7 @@ var STORE_IDENTITY = /* @__PURE__ */ new WeakMap();
 function storeIdentity(store) {
   const known = STORE_IDENTITY.get(store);
   if (known !== void 0) return known;
-  const created = randomUUID2();
+  const created = randomUUID3();
   STORE_IDENTITY.set(store, created);
   return created;
 }
@@ -2579,63 +3039,6 @@ function createRadarExecutionAdapter(pi, options) {
   };
 }
 
-// extension/radar-inspection.ts
-var radar_inspection_exports = {};
-__export(radar_inspection_exports, {
-  inspectRadarChild: () => inspectRadarChild,
-  provedRead: () => provedRead
-});
-var INSPECTION_LINES = 80;
-var INSPECTION_OUTPUT_BYTES = 16 * 1024;
-async function provedRead(client, target) {
-  const read = await client.agentGet(target.agentId);
-  return read.ok === true && read.value.verification === "verified" && read.value.location?.pane === target.paneId && (target.session === void 0 || read.value.contextSession === target.session) ? read.value : void 0;
-}
-async function inspectRadarChild(client, target) {
-  const before = await provedRead(client, target);
-  if (before === void 0)
-    throw new Error("Inspection target identity did not match");
-  const output = await client.output({
-    pane_id: target.paneId,
-    source: "recent_unwrapped",
-    lines: INSPECTION_LINES
-  });
-  if (output.ok === false)
-    throw new Error(
-      `Inspection output unavailable (${output.code}: ${output.message})`
-    );
-  const foreground = await client.processInfo({ pane_id: target.paneId });
-  const after = await provedRead(client, target);
-  if (after === void 0)
-    throw new Error("Inspection target changed during capture");
-  const lines = output.value.text.trim().split(/\r?\n/).slice(-INSPECTION_LINES);
-  const bounded2 = utf8Tail(lines.join("\n"), INSPECTION_OUTPUT_BYTES);
-  return Object.freeze({
-    capturedAt: Date.now(),
-    recentOutputTruncated: output.value.truncated || bounded2.truncated,
-    ...bounded2.text ? { recentOutput: bounded2.text } : {},
-    ...foreground.ok === true ? { foreground: foreground.value } : {},
-    ...after.activity !== void 0 ? { activity: after.activity } : {}
-  });
-}
-function utf8Tail(value, maxBytes) {
-  const bytes = Buffer.from(value);
-  if (bytes.length <= maxBytes) return { text: value, truncated: false };
-  let start = bytes.length - maxBytes;
-  while (start < bytes.length && (bytes[start] & 192) === 128) start++;
-  return { text: bytes.subarray(start).toString(), truncated: true };
-}
-
-// extension/radar-launch.ts
-var radar_launch_exports = {};
-__export(radar_launch_exports, {
-  launchRadarWorker: () => launchRadarWorker,
-  observeRadarChild: () => observeRadarChild,
-  readProcessGone: () => readProcessGone,
-  relaunchRefusalForChild: () => relaunchRefusalForChild
-});
-import { setTimeout as delay } from "node:timers/promises";
-
 // extension/radar-location.ts
 var radar_location_exports = {};
 __export(radar_location_exports, {
@@ -2753,280 +3156,6 @@ async function resolveRadarProcessLocation(client, env = process.env) {
   };
 }
 
-// extension/radar-launch.ts
-function unknownChild(reason) {
-  return { kind: "unknown", diagnostic: trajectory(reason) };
-}
-function trajectory(reason) {
-  return `the daemon's current record of this launch's child is ${reason}`;
-}
-async function observeRadarChild(client, provenance) {
-  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");
-  const read = await client.spawnGet(provenance.request_id);
-  if (read.ok === false)
-    return unknownChild(
-      `not readable (${read.code}: ${read.message})`
-    );
-  const topology = read.value;
-  const edge = topology.edge;
-  if (edge.bound === void 0 || edge.bound.registration_id === void 0)
-    return unknownChild("not bound to a child by the daemon");
-  if (edge.bound.registration_id !== provenance.registration_id)
-    return unknownChild(
-      `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");
-  if (edge.location.pane !== provenance.pane_id)
-    return unknownChild(
-      `recorded on pane ${edge.location.pane}, not on ${provenance.pane_id}`
-    );
-  if (edge.exit_observation?.state !== "unknown")
-    return unknownChild("recorded with an observed process exit");
-  if (topology.freshness !== "fresh")
-    return unknownChild(
-      "on a pane the daemon's own inventory does not currently report"
-    );
-  if (topology.state !== "bound")
-    return unknownChild(
-      `not currently placed (state ${topology.state ?? "unreported"})`
-    );
-  const reply = await client.agentGet(edge.bound.registration_id);
-  if (reply.ok === false)
-    return unknownChild(
-      `process verdict not readable (${reply.code}: ${reply.message})`
-    );
-  const { verification, location, contextSession } = reply.value;
-  if (verification === "absent" || verification === "mismatched")
-    return {
-      kind: "gone",
-      verification,
-      diagnostic: trajectory(`the registered process is ${verification}`)
-    };
-  if (verification !== "verified")
-    return unknownChild(`process verdict is ${verification}`);
-  if (location?.pane !== provenance.pane_id)
-    return unknownChild(
-      `registered on ${location?.pane ?? "no pane"}, not on ${provenance.pane_id}`
-    );
-  if (provenance.session_id === void 0)
-    return unknownChild("without a session this launch recorded for it");
-  if (contextSession !== provenance.session_id)
-    return unknownChild(
-      `publishing session ${contextSession ?? "none"}, not ${provenance.session_id}`
-    );
-  return {
-    kind: "live",
-    evidence: {
-      request_id: provenance.request_id,
-      registration_id: edge.bound.registration_id,
-      source: edge.bound.source,
-      incarnation: edge.bound.incarnation,
-      pane_id: edge.location.pane
-    }
-  };
-}
-async function readProcessGone(client, agentId) {
-  const read = await client.agentGet(agentId);
-  if (read.ok === false) return void 0;
-  const { verification } = read.value;
-  return verification === "absent" || verification === "mismatched" ? verification : void 0;
-}
-async function relaunchRefusalForChild(client, agentId) {
-  const read = await client.agentGet(agentId);
-  if (read.ok === false)
-    return `the child's process cannot be read (${read.code}: ${read.message})`;
-  const { verification } = read.value;
-  if (verification === "absent" || verification === "mismatched") return void 0;
-  return `the child's registered process is ${verification === "verified" ? "still running" : "not proved gone"}`;
-}
-function refusedLaunch(message) {
-  return { kind: "refused", message };
-}
-function unresolvedLaunch(requestId, message) {
-  return {
-    kind: "unresolved",
-    request_id: requestId,
-    message: `spawn ${requestId} is unresolved (${message})`
-  };
-}
-function edgeStanding(edge) {
-  if (edge.created === "refused" || edge.launched === "refused")
-    return "refused";
-  return edge.created === "completed" && edge.launched === "completed" ? "launched" : "unknown";
-}
-function edgeMessage(edge) {
-  return `the daemon's spawn record is created ${edge.created} and launched ${edge.launched}`;
-}
-var PRE_EFFECT_CODES = [
-  "absent",
-  "unsupported",
-  "bad_version",
-  "bad_request",
-  "bad_params",
-  "unknown_method",
-  "refused",
-  "not_found",
-  "busy",
-  "backend_unavailable"
-];
-function spawnFailure(result, requestId) {
-  return PRE_EFFECT_CODES.includes(result.code) ? refusedLaunch(result.message) : unresolvedLaunch(requestId, result.message);
-}
-async function launchRadarWorker(options) {
-  const { client, launch, signal } = options;
-  const pollMs = options.pollMs ?? 250;
-  const deadline = Date.now() + options.timeoutMs;
-  const remaining = () => Math.max(0, deadline - Date.now());
-  const pane = launch.parent.location?.pane;
-  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.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 } : {}
-  });
-  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 bound = await waitForChild(client, launch.request_id, {
-    remaining,
-    pollMs,
-    ...signal !== void 0 ? { signal } : {}
-  });
-  if (bound.kind !== "bound") return bound;
-  const agentId = bound.registration_id;
-  if (launch.onBound !== void 0) {
-    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 === void 0 || launch.observedChildAgent() === agentId),
-      { timeoutMs: remaining(), ...signal !== void 0 ? { 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 !== void 0 && 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)})`
-    );
-  }
-}
-async function waitForChild(client, requestId, options) {
-  let last = "the daemon has not answered";
-  for (; ; ) {
-    if (options.signal?.aborted)
-      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 pane = edge.location?.pane;
-      if (pane === void 0 || pane === "")
-        return unresolvedLaunch(
-          requestId,
-          "the daemon's launch recorded no pane to verify the child against"
-        );
-      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`
-        );
-      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 !== void 0 && isUuid(agentId)) {
-        const source = edge.bound?.source;
-        const incarnation = edge.bound?.incarnation;
-        if (source === void 0 || source === "" || incarnation === void 0 || incarnation === "")
-          return unresolvedLaunch(
-            requestId,
-            `the daemon bound the child ${agentId} without recording the process it registered as`
-          );
-        return {
-          kind: "bound",
-          registration_id: agentId,
-          pane_id: pane,
-          source,
-          incarnation
-        };
-      }
-      last = "no child has registered with this launch's token yet";
-    } else {
-      last = answer.message;
-    }
-    if (options.remaining() <= 0)
-      return unresolvedLaunch(requestId, last);
-    await delay(options.pollMs, void 0, {
-      ...options.signal !== void 0 ? { signal: options.signal } : {}
-    });
-  }
-}
-
 // extension/radar-runtime.ts
 var radar_runtime_exports = {};
 __export(radar_runtime_exports, {
@@ -3037,7 +3166,7 @@ __export(radar_runtime_exports, {
   requestRadarRuntime: () => requestRadarRuntime
 });
 var RADAR_RUNTIME_REQUEST = "pi-radar/runtime-request";
-var RADAR_RUNTIME_VERSION = 2;
+var RADAR_RUNTIME_VERSION = 4;
 function lazyRadarRuntime(start) {
   let pending;
   return {
@@ -3071,6 +3200,7 @@ function isRadarRuntimeHandle(value) {
   return handle.version === RADAR_RUNTIME_VERSION && typeof handle.start === "function";
 }
 export {
+  radar_children_exports as children,
   radar_client_exports as client,
   radar_communication_exports as communication,
   radar_execution_exports as execution,