pi-radar 0.7.0 → 0.9.0

package/dist/index.js

@@ -4,6 +4,69 @@ 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
+});
+
+// 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-client.ts
 var radar_client_exports = {};
 __export(radar_client_exports, {
@@ -11,6 +74,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 +104,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 = 7;
 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,6 +416,7 @@ 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"));
   return {
     ok: true,
@@ -364,7 +430,8 @@ 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 } : {}
@@ -436,6 +503,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 +971,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 +1000,33 @@ 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;
+        return focusOutcome(recordAt(answer.value, "request"), request.request_id);
+      });
+    },
     async spawnList(request) {
       const registrationId = processRegistrationId;
       if (registrationId === void 0)
@@ -1297,1734 +1394,1792 @@ function boundedRadarSnapshot(snapshot) {
   };
 }
 
-// extension/radar-communication.ts
-var radar_communication_exports = {};
-__export(radar_communication_exports, {
-  createRadarHandoffPort: () => createRadarHandoffPort
+// extension/radar-location.ts
+var radar_location_exports = {};
+__export(radar_location_exports, {
+  radarLocalPane: () => radarLocalPane,
+  radarPaneHandle: () => radarPaneHandle,
+  resolveRadarProcessLocation: () => resolveRadarProcessLocation,
+  tmuxServerName: () => tmuxServerName
 });
-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 };
+import { basename } from "node:path";
+function radarLocalPane(env) {
+  const pane = env.TMUX_PANE?.trim();
+  return pane && /^%\d+$/.test(pane) ? pane : void 0;
+}
+function radarPaneHandle(qualified) {
+  return qualified.slice(qualified.lastIndexOf(":") + 1);
+}
+function tmuxServerName(env) {
+  const socket = env.TMUX?.trim().split(",")[0];
+  return socket ? basename(socket) || void 0 : void 0;
+}
+function qualifiedOwnPane(env, backend, instance) {
+  if (backend !== "tmux")
+    return {
+      absent: `the daemon serves the ${backend} backend, and Herdsman drives only tmux`
+    };
+  if (instance === void 0 || instance === "")
+    return {
+      pending: "the daemon did not name the tmux server it addresses"
+    };
+  const server = tmuxServerName(env);
+  if (server === void 0)
+    return {
+      absent: "this process's own tmux client names no server, so it is not in the pane it would publish"
+    };
+  if (server !== instance)
+    return {
+      absent: `this process is attached to tmux server ${server}, not to ${instance}`
+    };
+  const pane = radarLocalPane(env);
+  if (pane === void 0)
+    return {
+      absent: "this process's own environment names no tmux pane of that server"
+    };
+  return { pane: `tmux:${instance}:${pane}` };
+}
+function observedContainment(inventory, paneId) {
+  const rows = inventory.panes.filter((pane) => pane.pane_id === paneId);
+  if (rows.length === 0) return void 0;
+  if (rows.length > 1) return { ambiguous: `topology reports pane ${paneId} twice` };
+  const row = rows[0];
+  const tab = inventory.tabs.find((candidate) => candidate.tab_id === row.tab_id);
+  if (tab !== void 0 && tab.workspace_id !== row.workspace_id)
+    return {
+      ambiguous: `pane ${paneId} is reported in ${row.workspace_id}, but its tab belongs to ${tab.workspace_id}`
+    };
+  return { pane: row };
+}
+async function resolveRadarProcessLocation(client, env = process.env) {
+  let ready;
+  try {
+    ready = await client.ping();
+  } catch {
+    return { state: "pending", reason: "the daemon did not answer this process" };
+  }
+  if (ready.ok === false)
+    return {
+      state: "pending",
+      reason: `the daemon did not answer this process (${ready.code})`
+    };
+  const backend = ready.value.backend;
+  if (backend === void 0 || backend === "none")
+    return { state: "absent", reason: "the daemon serves no physical backend" };
+  const instance = ready.value.instance ?? void 0;
+  const own = qualifiedOwnPane(env, backend, instance);
+  if ("absent" in own) return { state: "absent", reason: own.absent };
+  if ("pending" in own) return { state: "pending", reason: own.pending };
+  const paneId = own.pane;
+  if (paneId === env.PI_HERDSMAN_PARENT_PANE_ID?.trim())
+    return {
+      state: "absent",
+      reason: "this process is in the pane its launch was created beside, not in a pane of its own"
+    };
+  let inventory;
+  try {
+    inventory = await client.observe();
+  } catch {
+    return {
+      state: "pending",
+      reason: "the daemon's topology could not be read for this process's pane"
+    };
   }
+  if (inventory.ok === false)
+    return {
+      state: "pending",
+      reason: `the daemon's topology could not be read (${inventory.code})`
+    };
+  const containment = observedContainment(inventory.value, paneId);
+  if (containment === void 0)
+    return {
+      state: "pending",
+      reason: `the daemon's topology does not report pane ${paneId} yet`
+    };
+  if ("ambiguous" in containment)
+    return { state: "pending", reason: containment.ambiguous };
+  const row = containment.pane;
   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 });
+    state: "resolved",
+    location: {
+      backend,
+      ...instance !== void 0 ? { instance } : {},
+      workspace: row.workspace_id,
+      tab: row.tab_id,
+      pane: paneId
     }
   };
 }
 
-// extension/radar-execution.ts
-var radar_execution_exports = {};
-__export(radar_execution_exports, {
-  RADAR_SUBJECT_SOURCE: () => RADAR_SUBJECT_SOURCE,
-  createRadarExecutionAdapter: () => createRadarExecutionAdapter,
-  radarLocalRegistration: () => radarLocalRegistration
-});
-
-// extension/radar-publication.ts
-var radar_publication_exports = {};
-__export(radar_publication_exports, {
-  RADAR_HEARTBEAT_MS: () => RADAR_HEARTBEAT_MS,
-  RADAR_LEASE_MS: () => RADAR_LEASE_MS,
-  RADAR_PUBLICATION_VERSION: () => RADAR_PUBLICATION_VERSION,
-  createPublicationStore: () => createPublicationStore,
-  createRadarProcessSlot: () => createRadarProcessSlot,
-  createRadarPublication: () => createRadarPublication,
-  parseProcStat: () => parseProcStat,
-  radarBindingKey: () => radarBindingKey,
-  radarProcessIncarnation: () => radarProcessIncarnation,
-  radarProcessSlot: () => radarProcessSlot,
-  readProcessBirth: () => readProcessBirth
-});
-import { createHash, randomUUID as randomUUID2 } from "node:crypto";
-import {
-  closeSync,
-  constants,
-  fstatSync,
-  fsyncSync,
-  lstatSync as lstatSync2,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  renameSync,
-  unlinkSync,
-  writeSync
-} from "node:fs";
-import { dirname as dirname2, join as join2, parse, resolve, sep } from "node:path";
-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;
-function parseProcStat(text) {
-  const close = text.lastIndexOf(")");
-  const separator = text.indexOf(" ");
-  if (close <= 0 || separator <= 0 || separator > close) return void 0;
-  const pid = Number(text.slice(0, separator));
-  const fields = text.slice(close + 1).trim().split(/\s+/);
-  const startTicks = Number(fields[19]);
-  if (!Number.isInteger(pid) || pid <= 0) return void 0;
-  if (!Number.isInteger(startTicks) || startTicks <= 0) return void 0;
-  return { pid, start_ticks: startTicks };
+// extension/radar-launch.ts
+function unknownChild(reason) {
+  return { kind: "unknown", diagnostic: trajectory(reason) };
 }
-function readProcessBirth() {
-  try {
-    const bootId = readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
-    if (!/^[0-9a-f-]{8,64}$/i.test(bootId)) return void 0;
-    const stat = parseProcStat(readFileSync("/proc/self/stat", "utf8"));
-    return stat === void 0 ? void 0 : { boot_id: bootId, pid: stat.pid, start_ticks: stat.start_ticks };
-  } catch {
-    return void 0;
-  }
+function trajectory(reason) {
+  return `the daemon's current record of this launch's child is ${reason}`;
 }
-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;
-var PROCESS_SLOT = /* @__PURE__ */ Symbol.for("pi-radar.radar.process-slot.v1");
-function createPublicationStore(root) {
-  const uid = process.getuid?.();
-  if (uid === void 0) throw new Error("private Radar storage requires an effective uid");
-  const ensureDirectory = (directory) => {
-    let existed = true;
-    try {
-      lstatSync2(directory);
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-      existed = false;
-    }
-    mkdirSync(directory, { recursive: true, mode: PRIVATE_MODE });
-    const absolute = resolve(directory);
-    const rootPath = parse(absolute).root;
-    let current = rootPath;
-    for (const part of absolute.slice(rootPath.length).split(/[\\/]+/u).filter(Boolean)) {
-      current = join2(current, part);
-      const info2 = lstatSync2(current);
-      if (info2.isSymbolicLink() || !info2.isDirectory())
-        throw new Error(`unsafe Radar storage directory: ${current}`);
-    }
-    const info = lstatSync2(absolute);
-    if (info.uid !== uid) throw new Error(`Radar storage directory has wrong owner: ${absolute}`);
-    if (existed && (info.mode & 511) !== PRIVATE_MODE)
-      throw new Error(`Radar storage directory is not mode 0700: ${absolute}`);
-  };
-  const pathOf = (name) => {
-    if (!RECORD_NAME.test(name))
-      throw new Error(`invalid radar record name: ${name}`);
-    return join2(root, name);
-  };
-  const ensureTrustedDirectory = (directory) => {
-    const absoluteRoot = resolve(root);
-    const absoluteDirectory = resolve(directory);
-    if (absoluteDirectory !== absoluteRoot && !absoluteDirectory.startsWith(`${absoluteRoot}${sep}`))
-      throw new Error(`unsafe Radar storage directory: ${directory}`);
-    const rootInfo = lstatSync2(absoluteRoot);
-    if (rootInfo.isSymbolicLink() || !rootInfo.isDirectory() || rootInfo.uid !== uid || (rootInfo.mode & 511) !== PRIVATE_MODE)
-      throw new Error(`unsafe Radar storage directory: ${absoluteRoot}`);
-    if (absoluteDirectory !== absoluteRoot) {
-      const info = lstatSync2(absoluteDirectory);
-      if (info.isSymbolicLink() || !info.isDirectory() || info.uid !== uid || (info.mode & 511) !== PRIVATE_MODE)
-        throw new Error(`unsafe Radar storage directory: ${absoluteDirectory}`);
-    }
-  };
-  ensureDirectory(root);
+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 {
-    path: pathOf,
-    read(name) {
-      const path = pathOf(name);
-      const directory = dirname2(path);
-      try {
-        ensureTrustedDirectory(directory);
-      } catch (error) {
-        if (error.code === "ENOENT") return void 0;
-        throw error;
-      }
-      let descriptor;
-      try {
-        descriptor = openSync(
-          path,
-          constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
-        );
-        const info = fstatSync(descriptor);
-        if (!info.isFile() || info.uid !== uid || (info.mode & 511) !== RECORD_MODE)
-          throw new Error(`unsafe Radar record: ${path}`);
-        if (info.size > MAX_RECORD_BYTES)
-          throw new Error(`oversized Radar record: ${path}`);
-        const contents = readFileSync(descriptor, { encoding: "utf8" });
-        if (Buffer.byteLength(contents, "utf8") > MAX_RECORD_BYTES)
-          throw new Error(`oversized Radar record: ${path}`);
-        return JSON.parse(contents);
-      } catch (error) {
-        if (error.code === "ENOENT") return void 0;
-        throw error;
-      } finally {
-        if (descriptor !== void 0) closeSync(descriptor);
-      }
-    },
-    write(name, value) {
-      const path = pathOf(name);
-      const directory = dirname2(path);
-      ensureDirectory(directory);
-      const temporary = join2(
-        directory,
-        `.${name.slice(name.lastIndexOf("/") + 1)}.${randomUUID2()}.tmp`
-      );
-      const bytes = Buffer.from(JSON.stringify(value), "utf8");
-      if (bytes.length > MAX_RECORD_BYTES)
-        throw new Error(`Radar record exceeds ${MAX_RECORD_BYTES} bytes`);
-      let descriptor;
-      try {
-        descriptor = openSync(temporary, "wx", RECORD_MODE);
-        let offset = 0;
-        while (offset < bytes.length)
-          offset += writeSync(descriptor, bytes, offset, bytes.length - offset);
-        fsyncSync(descriptor);
-        closeSync(descriptor);
-        descriptor = void 0;
-        const info = lstatSync2(directory);
-        if (info.isSymbolicLink() || !info.isDirectory() || info.uid !== uid || (info.mode & 511) !== PRIVATE_MODE)
-          throw new Error(`unsafe Radar storage directory: ${directory}`);
-        renameSync(temporary, path);
-        const directoryFd = openSync(directory, constants.O_RDONLY);
-        try {
-          fsyncSync(directoryFd);
-        } finally {
-          closeSync(directoryFd);
-        }
-      } finally {
-        if (descriptor !== void 0) closeSync(descriptor);
-        try {
-          unlinkSync(temporary);
-        } catch (error) {
-          if (error.code !== "ENOENT") throw error;
-        }
-      }
-    },
-    remove(name) {
-      try {
-        unlinkSync(pathOf(name));
-      } catch (error) {
-        if (error.code !== "ENOENT") throw error;
-      }
+    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
     }
   };
 }
-function createRadarProcessSlot() {
-  return { publications: /* @__PURE__ */ new Map() };
+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;
 }
-function radarProcessSlot() {
-  const host = globalThis;
-  if (!host[PROCESS_SLOT]) {
-    const slot = createRadarProcessSlot();
-    slot.launchRegistrationId = process.env.PI_RADAR_REGISTRATION_ID;
-    delete process.env.PI_RADAR_REGISTRATION_ID;
-    host[PROCESS_SLOT] = slot;
-  }
-  return host[PROCESS_SLOT];
+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 radarProcessIncarnation(slot = radarProcessSlot()) {
-  return slot.incarnation ??= randomUUID2();
+function refusedLaunch(message) {
+  return { kind: "refused", message };
 }
-function radarBindingKey(run, owner, label) {
-  return createHash("sha256").update(`${run}\0${owner}\0${label}`).digest("hex").slice(0, 32);
+function unresolvedLaunch(requestId, message) {
+  return {
+    kind: "unresolved",
+    request_id: requestId,
+    message: `spawn ${requestId} is unresolved (${message})`
+  };
 }
-function recordAt2(value, key) {
-  if (typeof value !== "object" || value === null) return void 0;
-  return value[key];
-}
-function textAt(value, key) {
-  const found = recordAt2(value, key);
-  return typeof found === "string" ? found : void 0;
-}
-function numberAt2(value, key) {
-  const found = recordAt2(value, key);
-  return typeof found === "number" && Number.isFinite(found) ? found : void 0;
+function edgeStanding(edge) {
+  if (edge.created === "refused" || edge.launched === "refused")
+    return "refused";
+  return edge.created === "completed" && edge.launched === "completed" ? "launched" : "unknown";
 }
-var PENDING_KEYS = "lease_ms,observed_at,sequence,snapshot";
-var ACCEPTED_KEYS = "lease_ms,observed_at,sequence,sent_at,snapshot";
-var OUTCOME_KEYS = "detail,result";
-var OUTCOME_KEYS_WITHOUT_DETAIL = "result";
-var WRITER_KEYS = "generation,handle";
-function exactKeys(value, expected) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).sort().join(",") === expected;
+function edgeMessage(edge) {
+  return `the daemon's spawn record is created ${edge.created} and launched ${edge.launched}`;
 }
-var SNAPSHOT_KEY_LIST = ["activity", "last_outcome", "waiting_reason"];
-var ASSIGNMENT_KEY_LIST = [...SNAPSHOT_KEY_LIST, "request", "awaited"];
-var FACTS_KEY_LIST = [
-  "model",
-  "provider",
-  "thinking",
-  "context_window",
-  "session_name",
-  "background_tasks",
-  "background_started_unix_ms"
+var PRE_EFFECT_CODES = [
+  "absent",
+  "unsupported",
+  "bad_version",
+  "bad_request",
+  "bad_params",
+  "unknown_method",
+  "refused",
+  "not_found",
+  "busy",
+  "backend_unavailable"
 ];
-function snapshotAt(value, keys = SNAPSHOT_KEY_LIST) {
-  if (typeof value !== "object" || value === null || Array.isArray(value) || !Object.keys(value).every((key) => keys.includes(key)))
-    return void 0;
-  const activity = textAt(value, "activity");
-  if (activity === void 0) return void 0;
-  const snapshot = { activity };
-  const reason = textAt(value, "waiting_reason");
-  if (reason !== void 0) snapshot.waiting_reason = reason;
-  const outcome = recordAt2(value, "last_outcome");
-  if (outcome !== void 0) {
-    if (!exactKeys(outcome, OUTCOME_KEYS) && !exactKeys(outcome, OUTCOME_KEYS_WITHOUT_DETAIL))
-      return void 0;
-    const result = textAt(outcome, "result");
-    if (result === void 0) return void 0;
-    const detail = textAt(outcome, "detail");
-    snapshot.last_outcome = {
-      result,
-      ...detail !== void 0 ? { detail } : {}
+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 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 = 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;
+  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)
+      }),
+      { timeoutMs: remaining(), ...signal !== void 0 ? { signal } : {} }
+    );
+    return {
+      kind: "ready",
+      value: {
+        request_id: launch.request_id,
+        subject_id: bound.subject_id,
+        pane_id: bound.pane_id,
+        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)})`
+    );
   }
-  return snapshot;
-}
-var executionCodec = {
-  parse: (value) => snapshotAt(value),
-  bound: (snapshot) => boundedRadarSnapshot(snapshot)
-};
-function assignmentAt(value) {
-  const base = snapshotAt(value, ASSIGNMENT_KEY_LIST);
-  if (base === void 0) return void 0;
-  const request = textAt(value, "request");
-  const awaitedValue = recordAt2(value, "awaited");
-  if (awaitedValue !== void 0 && (!Array.isArray(awaitedValue) || awaitedValue.length > RADAR_MAX_AWAITED || !awaitedValue.every((item) => typeof item === "string")))
-    return void 0;
-  if (recordAt2(value, "request") !== void 0 && request === void 0)
-    return void 0;
-  return {
-    ...base,
-    ...request !== void 0 ? { request } : {},
-    ...awaitedValue !== void 0 ? { awaited: awaitedValue } : {}
-  };
 }
-var assignmentCodec = {
-  parse: (value) => assignmentAt(value),
-  bound: (snapshot) => boundedRadarAssignment(snapshot)
-};
-function factsAt(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    return void 0;
-  const record = value;
-  if (!Object.keys(record).every((key) => FACTS_KEY_LIST.includes(key)))
-    return void 0;
-  const facts = {};
-  for (const key of FACTS_KEY_LIST) {
-    const found = record[key];
-    if (found === void 0) continue;
-    if (key === "context_window") {
-      if (typeof found !== "object" || found === null || Array.isArray(found))
-        return void 0;
-      const window = found;
-      if (Object.keys(window).sort().join(",") !== "tokens,window") return void 0;
-      const tokens = window.tokens;
-      const size = window.window;
-      if (!Number.isSafeInteger(tokens) || tokens < 0 || !Number.isSafeInteger(size) || size <= 0 || tokens > size)
-        return void 0;
-      facts[key] = { tokens, window: size };
-      continue;
+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`
+          );
+        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,
+          registration_id: agentId,
+          pane_id: pane,
+          source,
+          incarnation
+        };
+      }
+      last = "no child has registered with this launch's token yet";
+    } else {
+      last = answer.message;
     }
-    if (key === "background_tasks") {
-      if (!Array.isArray(found) || found.length > RADAR_MAX_BACKGROUND_TASKS)
-        return void 0;
-      const ids = /* @__PURE__ */ new Set();
-      const tasks = [];
-      for (const item of found) {
-        if (typeof item !== "object" || item === null || Array.isArray(item))
-          return void 0;
-        const task = item;
-        if (Object.keys(task).sort().join(",") !== "id,phase" || typeof task.id !== "string" || !task.id || typeof task.phase !== "string" || !task.phase || ids.has(task.id))
-          return void 0;
-        ids.add(task.id);
-        tasks.push({ id: task.id, phase: task.phase });
+    if (options.remaining() <= 0)
+      return unresolvedLaunch(requestId, last);
+    await delay(options.pollMs, void 0, {
+      ...options.signal !== void 0 ? { signal: options.signal } : {}
+    });
+  }
+}
+
+// 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.launched !== "completed") 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"
+          }
+        });
       }
-      facts[key] = tasks;
-      continue;
+      if (!read.value.next) return { ok: true, value: newest };
+      after = read.value.next;
     }
-    if (key === "background_started_unix_ms") {
-      if (!Number.isSafeInteger(found) || found < 0) return void 0;
-      facts[key] = found;
-      continue;
-    }
-    if (typeof found !== "string") return void 0;
-    facts[key] = found;
-  }
-  return facts;
-}
-var factsCodec = {
-  parse: (value) => factsAt(value),
-  bound: (snapshot) => boundedRadarFacts(snapshot)
-};
-function pendingAt(value, keys = PENDING_KEYS, codec = executionCodec) {
-  if (!exactKeys(value, keys)) return void 0;
-  const sequence = numberAt2(value, "sequence");
-  const lease = numberAt2(value, "lease_ms");
-  const observed = textAt(value, "observed_at");
-  const snapshot = codec.parse(recordAt2(value, "snapshot"));
-  if (sequence === void 0 || sequence < 1) return void 0;
-  if (lease === void 0 || observed === void 0 || snapshot === void 0)
-    return void 0;
-  return { sequence, snapshot, lease_ms: lease, observed_at: observed };
-}
-function createChannelWriter(input) {
-  const { store, client, scheduler, recordName, channel, publisher } = input;
-  const codec = input.codec ?? executionCodec;
-  let record = loadRecord();
-  let desired;
-  let running = false;
-  let again = false;
-  let recovering = false;
-  let stopped = false;
-  let fenced = false;
-  let retired = false;
-  let pump;
-  function blank(agentId) {
-    return {
-      version: RADAR_PUBLICATION_VERSION,
-      registration_id: agentId,
-      channel,
-      publisher,
-      sequence: 0
-    };
-  }
-  function loadRecord() {
-    const value = store.read(recordName);
-    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("");
-    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 = pendingAt(recordAt2(value, "pending"), PENDING_KEYS, codec);
-    const acceptedValue = recordAt2(value, "accepted");
-    const accepted = pendingAt(acceptedValue, ACCEPTED_KEYS, codec);
-    const sentAt = numberAt2(acceptedValue, "sent_at");
-    return {
-      version: RADAR_PUBLICATION_VERSION,
-      registration_id: agentId,
-      channel,
-      publisher,
-      ...handle !== void 0 && generation !== void 0 ? { writer: { handle, generation } } : {},
-      ...textAt(value, "retired_at") !== void 0 ? { retired_at: textAt(value, "retired_at") } : {},
-      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 save() {
-    store.write(recordName, record);
-  }
-  function sameSnapshot(left, right) {
-    return JSON.stringify(codec.bound(left)) === JSON.stringify(codec.bound(right));
-  }
-  function fence(message) {
-    fenced = true;
-    stopPump();
-    note(`channel ${channel} stopped: ${message}`);
-  }
-  function startPump() {
-    if (pump !== void 0 || stopped || fenced || retired) return;
-    pump = scheduler.setInterval(() => kick(), input.heartbeatMs);
-    pump.unref?.();
-  }
-  function stopPump() {
-    if (pump === void 0) return;
-    scheduler.clearInterval(pump);
-    pump = void 0;
-  }
-  async function ensureWriter() {
-    if (record.writer !== void 0) return true;
-    const agentId = await input.subject(recovering);
-    if (agentId === void 0) return false;
-    if (record.registration_id !== agentId) {
-      record = blank(agentId);
-      save();
-    }
-    const answer = await client.acquire({
-      registration_id: agentId,
-      channel,
-      publisher
-    });
-    if (answer.ok === false) {
-      if (answer.code === "not_found") {
-        recovering = true;
-        return false;
-      }
-      if (answer.code === "refused" || answer.code === "bad_params")
-        fence(answer.message);
-      return false;
-    }
-    recovering = false;
-    record.writer = {
-      handle: answer.value.handle,
-      generation: answer.value.generation
-    };
-    record.sequence = Math.max(record.sequence, answer.value.sequence);
-    save();
-    startPump();
-    return true;
-  }
-  function heartbeatDue() {
-    return record.accepted !== void 0 && scheduler.now() - record.accepted.sent_at >= input.heartbeatMs;
-  }
-  async function send(pending) {
-    const writer = record.writer;
-    if (writer === void 0) return;
-    const answer = await client.publish({
-      registration_id: record.registration_id,
-      channel,
-      writer_handle: writer.handle,
-      sequence: pending.sequence,
-      lease_ms: pending.lease_ms,
-      observed_at: pending.observed_at,
-      snapshot: pending.snapshot
-    });
-    if (answer.ok === true) {
-      recovering = false;
-      record.sequence = Math.max(record.sequence, answer.value.sequence);
-      record.accepted = { ...pending, sent_at: scheduler.now() };
-      record.pending = void 0;
-      save();
-      return;
-    }
-    if (answer.code === "refused" || answer.code === "bad_params") {
-      fence(answer.message);
-      return;
-    }
-    if (answer.code === "not_found") {
-      record.writer = void 0;
-      recovering = true;
-      save();
-      return;
-    }
-  }
-  async function stage(snapshot) {
-    const pending = {
-      sequence: record.sequence + 1,
-      snapshot: codec.bound(snapshot),
-      lease_ms: input.leaseMs,
-      observed_at: new Date(scheduler.now()).toISOString()
-    };
-    record.pending = pending;
-    save();
-    await send(pending);
+    return { ok: false, code: "protocol", message: "the caller's launches exceed the readable pages" };
   }
-  async function drainOnce() {
-    if (fenced || retired) return;
-    if (!await ensureWriter()) return;
-    if (fenced) return;
-    if (record.pending !== void 0) {
-      await send(record.pending);
-      return;
-    }
-    if (desired !== void 0 && (record.accepted === void 0 || !sameSnapshot(desired, record.accepted.snapshot))) {
-      await stage(desired);
-      return;
-    }
-    if (heartbeatDue() && record.accepted !== void 0)
-      await stage(record.accepted.snapshot);
+  async function resolve2(subject) {
+    const all = await resolveAll();
+    return all.ok ? all.value.get(subject) : void 0;
   }
-  async function drain() {
-    if (running || stopped || fenced || retired) return;
-    running = true;
-    try {
-      await drainOnce();
-    } catch (error) {
-      fenced = true;
-      stopPump();
-      try {
-        note(`channel ${channel} storage failure: ${String(error).slice(0, 180)}`);
-      } catch {
-      }
-    } finally {
-      running = false;
-      if (again && !stopped && !fenced && !retired) {
-        again = false;
-        kick();
-      }
-    }
+  async function resolveAndFollow(subject) {
+    const all = await resolveAll();
+    if (!all.ok) return void 0;
+    follow(all.value);
+    return all.value.get(subject);
   }
-  function kick() {
-    if (stopped || fenced || retired) return;
-    startPump();
-    if (running) {
-      again = true;
-      return;
+  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);
     }
-    void drain().catch(() => void 0);
   }
   return {
-    update(snapshot) {
-      if (stopped || fenced || retired) return;
-      desired = snapshot;
-      kick();
+    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) };
     },
-    retire() {
-      if (stopped || fenced || retired) return;
-      retired = true;
-      stopPump();
-      const writer = record.writer;
-      if (writer === void 0) return;
-      const agentId = record.registration_id;
-      try {
-        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();
-              save();
-            } catch {
-            }
-          }
-        }).catch(() => void 0);
-      } catch {
-      }
+    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;
     },
-    stop() {
-      stopped = true;
-      stopPump();
+    retire(subject) {
+      held.get(subject)?.writer.retire();
+      held.delete(subject);
     },
-    reopen() {
-      stopped = false;
-      if (desired !== void 0 || record.pending !== void 0) kick();
+    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
+      });
     },
-    diagnostic: () => record.diagnostic
+    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 } : {}
+      });
+    }
   };
 }
-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() {
-    try {
-      if (state) store.write(recordName, state);
-      return true;
-    } catch (error) {
-      diagnostic = `presence storage unavailable: ${String(error)}`;
-      return false;
-    }
-  }
-  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();
-    }
-  }
-  function schedule() {
-    if (stopped || timer) return;
-    timer = scheduler.setTimeout(() => {
-      timer = void 0;
-      void ensure();
-    }, input.heartbeatMs);
-    timer.unref?.();
-  }
-  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;
-      }
-      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 claim.registration_id;
-    })();
-    try {
-      return await running;
-    } catch (error) {
-      diagnostic = `presence unavailable: ${String(error)}`;
-      return void 0;
-    } finally {
-      running = void 0;
-      if (!stopped && state !== claim) void ensure();
-      else schedule();
-    }
+
+// 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 {
-    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();
+    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
+      });
     },
-    stop() {
-      stopped = true;
-      if (timer) scheduler.clearTimeout(timer);
-      timer = void 0;
+    async inbox() {
+      const identity = await agentId();
+      if (identity.ok === false) return identity;
+      return client.communicationInbox({ registration_id: identity.value });
     },
-    reopen() {
-      stopped = false;
-      void ensure();
+    async get(handoff_id) {
+      const identity = await agentId();
+      if (identity.ok === false) return identity;
+      return client.communicationGet({ registration_id: identity.value, handoff_id });
     },
-    management: () => standing,
-    diagnostic: () => diagnostic
+    async ack(handoff_id) {
+      const identity = await agentId();
+      if (identity.ok === false) return identity;
+      return client.communicationAck({ registration_id: identity.value, handoff_id });
+    }
   };
 }
-var STORE_IDENTITY = /* @__PURE__ */ new WeakMap();
-function storeIdentity(store) {
-  const known = STORE_IDENTITY.get(store);
-  if (known !== void 0) return known;
-  const created = randomUUID2();
-  STORE_IDENTITY.set(store, created);
-  return created;
+
+// extension/radar-execution.ts
+var radar_execution_exports = {};
+__export(radar_execution_exports, {
+  RADAR_SUBJECT_SOURCE: () => RADAR_SUBJECT_SOURCE,
+  createRadarExecutionAdapter: () => createRadarExecutionAdapter,
+  radarLocalRegistration: () => radarLocalRegistration
+});
+
+// extension/radar-publication.ts
+var radar_publication_exports = {};
+__export(radar_publication_exports, {
+  RADAR_HEARTBEAT_MS: () => RADAR_HEARTBEAT_MS,
+  RADAR_LEASE_MS: () => RADAR_LEASE_MS,
+  RADAR_PUBLICATION_VERSION: () => RADAR_PUBLICATION_VERSION,
+  createPublicationStore: () => createPublicationStore,
+  createRadarProcessSlot: () => createRadarProcessSlot,
+  createRadarPublication: () => createRadarPublication,
+  parseProcStat: () => parseProcStat,
+  radarBindingKey: () => radarBindingKey,
+  radarProcessIncarnation: () => radarProcessIncarnation,
+  radarProcessSlot: () => radarProcessSlot,
+  readProcessBirth: () => readProcessBirth
+});
+import { createHash, randomUUID as randomUUID2 } from "node:crypto";
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  fsyncSync,
+  lstatSync as lstatSync2,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeSync
+} from "node:fs";
+import { dirname as dirname2, join as join2, parse, resolve, sep } from "node:path";
+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;
+function parseProcStat(text) {
+  const close = text.lastIndexOf(")");
+  const separator = text.indexOf(" ");
+  if (close <= 0 || separator <= 0 || separator > close) return void 0;
+  const pid = Number(text.slice(0, separator));
+  const fields = text.slice(close + 1).trim().split(/\s+/);
+  const startTicks = Number(fields[19]);
+  if (!Number.isInteger(pid) || pid <= 0) return void 0;
+  if (!Number.isInteger(startTicks) || startTicks <= 0) return void 0;
+  return { pid, start_ticks: startTicks };
 }
-function createRadarPublication(options) {
+function readProcessBirth() {
   try {
-    return createRadarPublicationInner(options);
-  } catch (error) {
-    return unavailablePublication(error);
+    const bootId = readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+    if (!/^[0-9a-f-]{8,64}$/i.test(bootId)) return void 0;
+    const stat = parseProcStat(readFileSync("/proc/self/stat", "utf8"));
+    return stat === void 0 ? void 0 : { boot_id: bootId, pid: stat.pid, start_ticks: stat.start_ticks };
+  } catch {
+    return void 0;
   }
 }
-function unavailablePublication(error) {
-  const diagnostic = `Radar publication unavailable${error ? `: ${String(error).slice(0, 180)}` : ""}`;
-  const writer = {
-    update: () => void 0,
-    retire: () => void 0,
-    stop: () => void 0,
-    reopen: () => void 0,
-    diagnostic: () => diagnostic
+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;
+var PROCESS_SLOT = /* @__PURE__ */ Symbol.for("pi-radar.radar.process-slot.v1");
+function createPublicationStore(root) {
+  const uid = process.getuid?.();
+  if (uid === void 0) throw new Error("private Radar storage requires an effective uid");
+  const ensureDirectory = (directory) => {
+    let existed = true;
+    try {
+      lstatSync2(directory);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      existed = false;
+    }
+    mkdirSync(directory, { recursive: true, mode: PRIVATE_MODE });
+    const absolute = resolve(directory);
+    const rootPath = parse(absolute).root;
+    let current = rootPath;
+    for (const part of absolute.slice(rootPath.length).split(/[\\/]+/u).filter(Boolean)) {
+      current = join2(current, part);
+      const info2 = lstatSync2(current);
+      if (info2.isSymbolicLink() || !info2.isDirectory())
+        throw new Error(`unsafe Radar storage directory: ${current}`);
+    }
+    const info = lstatSync2(absolute);
+    if (info.uid !== uid) throw new Error(`Radar storage directory has wrong owner: ${absolute}`);
+    if (existed && (info.mode & 511) !== PRIVATE_MODE)
+      throw new Error(`Radar storage directory is not mode 0700: ${absolute}`);
   };
-  return {
-    execution: writer,
-    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 },
-    assignment: () => writer,
-    binding: () => void 0,
-    subject: async () => void 0,
-    retireAssignment: () => void 0,
-    diagnostic: () => diagnostic,
-    stop: () => void 0,
-    reopen: () => void 0
+  const pathOf = (name) => {
+    if (!RECORD_NAME.test(name))
+      throw new Error(`invalid radar record name: ${name}`);
+    return join2(root, name);
   };
-}
-function createRadarPublicationInner(options) {
-  const dataRoot = options.dataRoot;
-  const store = options.store ?? createPublicationStore(dataRoot);
-  const scheduler = options.scheduler ?? systemScheduler;
-  const client = options.client;
-  const slot = options.slot ?? radarProcessSlot();
-  const launchRegistrationId = options.launchRegistrationId ?? slot.launchRegistrationId;
-  const incarnation = options.incarnation ?? radarProcessIncarnation(slot);
-  const cacheKey = `${options.store === void 0 ? dataRoot : storeIdentity(options.store)}\0${incarnation}`;
-  const cached = slot.publications.get(cacheKey);
-  if (cached !== void 0) {
-    cached.reopen();
-    return cached;
-  }
-  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 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, "registration_id");
-    return {
-      version: RADAR_PUBLICATION_VERSION,
-      registration,
-      ...storedAgentId !== void 0 && isUuid(storedAgentId) ? { registration_id: storedAgentId } : {}
-    };
-  }
-  const stored = readRegistration();
-  let processRecord = stored;
-  let registrationDiagnostic;
-  let registrationRecord;
-  async function ensureRegistration() {
-    if (processRecord !== void 0) return processRecord;
-    registrationRecord ??= (async () => {
-      const resolution = options.location ? await options.location() : { state: "absent", reason: "this process publishes no location" };
-      const built = {
-        version: RADAR_PUBLICATION_VERSION,
-        registration: {
-          ...options.registration,
-          ...resolution.state === "resolved" ? { location: resolution.location } : {},
-          incarnation,
-          ...options.birth !== void 0 ? { process: options.birth } : {}
-        }
-      };
+  const ensureTrustedDirectory = (directory) => {
+    const absoluteRoot = resolve(root);
+    const absoluteDirectory = resolve(directory);
+    if (absoluteDirectory !== absoluteRoot && !absoluteDirectory.startsWith(`${absoluteRoot}${sep}`))
+      throw new Error(`unsafe Radar storage directory: ${directory}`);
+    const rootInfo = lstatSync2(absoluteRoot);
+    if (rootInfo.isSymbolicLink() || !rootInfo.isDirectory() || rootInfo.uid !== uid || (rootInfo.mode & 511) !== PRIVATE_MODE)
+      throw new Error(`unsafe Radar storage directory: ${absoluteRoot}`);
+    if (absoluteDirectory !== absoluteRoot) {
+      const info = lstatSync2(absoluteDirectory);
+      if (info.isSymbolicLink() || !info.isDirectory() || info.uid !== uid || (info.mode & 511) !== PRIVATE_MODE)
+        throw new Error(`unsafe Radar storage directory: ${absoluteDirectory}`);
+    }
+  };
+  ensureDirectory(root);
+  return {
+    path: pathOf,
+    read(name) {
+      const path = pathOf(name);
+      const directory = dirname2(path);
       try {
-        store.write(registrationName, built);
+        ensureTrustedDirectory(directory);
       } catch (error) {
-        registrationDiagnostic ??= `private storage unavailable: ${String(error)}`.slice(0, 256);
-        return void 0;
-      }
-      registrationDiagnostic = void 0;
-      processRecord = built;
-      return built;
-    })();
-    try {
-      return await registrationRecord;
-    } finally {
-      registrationRecord = void 0;
-    }
-  }
-  let agentId = stored?.registration_id;
-  let subjectReady;
-  async function ensureSubject(recheck) {
-    if (!recheck && agentId !== void 0) return agentId;
-    subjectReady ??= (async () => {
-      const ready = await client.ping();
-      if (ready.ok === false) {
-        if (ready.code !== "absent" && ready.code !== "timeout" && ready.code !== "transport")
-          registrationDiagnostic ??= `daemon negotiation failed: ${ready.message}`.slice(0, 256);
-        return void 0;
+        if (error.code === "ENOENT") return void 0;
+        throw error;
       }
-      const record = await ensureRegistration();
-      if (record === void 0) return void 0;
-      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;
-    })();
-    try {
-      return await subjectReady;
-    } finally {
-      subjectReady = void 0;
-    }
-  }
-  function writeBinding(binding) {
-    if (agentId === void 0) return;
-    store.write(`bindings/${binding.key}.json`, {
-      version: RADAR_PUBLICATION_VERSION,
-      registration_id: agentId,
-      incarnation,
-      run: binding.run,
-      owner: binding.owner,
-      label: binding.label,
-      observed_at: new Date(scheduler.now()).toISOString()
-    });
-  }
-  const publisher = (source, reportingOwner) => ({
-    source,
-    incarnation,
-    ...reportingOwner !== void 0 ? { reporting_owner: reportingOwner } : {}
-  });
-  const execution = createChannelWriter({
-    store,
-    client,
-    scheduler,
-    recordName: channelRecord("execution"),
-    channel: "execution",
-    publisher: publisher("herdsman-pi"),
-    subject: ensureSubject,
-    leaseMs: options.leaseMs ?? RADAR_LEASE_MS,
-    heartbeatMs: options.heartbeatMs ?? RADAR_HEARTBEAT_MS
-  });
-  const presence = createPresenceReporter({
-    store,
-    client,
-    scheduler,
-    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 } : {},
-        ...launchRegistrationId ? { registration_id: launchRegistrationId } : {}
-      };
-    },
-    heartbeatMs: options.heartbeatMs ?? RADAR_HEARTBEAT_MS
-  });
-  const facts = createChannelWriter({
-    store,
-    client,
-    scheduler,
-    recordName: channelRecord("facts"),
-    channel: "facts",
-    publisher: publisher("pi"),
-    codec: factsCodec,
-    subject: ensureSubject,
-    leaseMs: options.leaseMs ?? RADAR_LEASE_MS,
-    heartbeatMs: options.heartbeatMs ?? RADAR_HEARTBEAT_MS
-  });
-  const assignmentWriters = /* @__PURE__ */ new Map();
-  const publication = {
-    execution,
-    presence,
-    facts,
-    assignment(target, reportingOwner) {
-      const existing = assignmentWriters.get(target);
-      if (existing !== void 0) return existing;
+      let descriptor;
       try {
-        const writer = createChannelWriter({
-          store,
-          client,
-          scheduler,
-          recordName: channelRecord("assignment", target),
-          channel: "assignment",
-          publisher: publisher("herdsman-owner", reportingOwner),
-          codec: assignmentCodec,
-          // The owner publishes about a subject it did not register: the exact
-          // 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
-        });
-        assignmentWriters.set(target, writer);
-        return writer;
+        descriptor = openSync(
+          path,
+          constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+        );
+        const info = fstatSync(descriptor);
+        if (!info.isFile() || info.uid !== uid || (info.mode & 511) !== RECORD_MODE)
+          throw new Error(`unsafe Radar record: ${path}`);
+        if (info.size > MAX_RECORD_BYTES)
+          throw new Error(`oversized Radar record: ${path}`);
+        const contents = readFileSync(descriptor, { encoding: "utf8" });
+        if (Buffer.byteLength(contents, "utf8") > MAX_RECORD_BYTES)
+          throw new Error(`oversized Radar record: ${path}`);
+        return JSON.parse(contents);
       } catch (error) {
-        registrationDiagnostic ??= `Radar assignment unavailable: ${String(error).slice(0, 180)}`;
-        return unavailablePublication(error).execution;
+        if (error.code === "ENOENT") return void 0;
+        throw error;
+      } finally {
+        if (descriptor !== void 0) closeSync(descriptor);
       }
     },
-    binding(key) {
-      let value;
+    write(name, value) {
+      const path = pathOf(name);
+      const directory = dirname2(path);
+      ensureDirectory(directory);
+      const temporary = join2(
+        directory,
+        `.${name.slice(name.lastIndexOf("/") + 1)}.${randomUUID2()}.tmp`
+      );
+      const bytes = Buffer.from(JSON.stringify(value), "utf8");
+      if (bytes.length > MAX_RECORD_BYTES)
+        throw new Error(`Radar record exceeds ${MAX_RECORD_BYTES} bytes`);
+      let descriptor;
       try {
-        value = store.read(`bindings/${key}.json`);
-      } catch (error) {
-        registrationDiagnostic ??= `Radar binding unavailable: ${String(error).slice(0, 180)}`;
-        return void 0;
-      }
-      const bound = textAt(value, "registration_id");
-      const boundIncarnation = textAt(value, "incarnation");
-      const run = textAt(value, "run");
-      const owner = textAt(value, "owner");
-      const label = textAt(value, "label");
-      const observedAt = textAt(value, "observed_at");
-      if (!isUuid(bound) || !isUuid(boundIncarnation) || run === void 0 || owner === void 0 || label === void 0 || observedAt === void 0)
-        return void 0;
-      return {
-        version: RADAR_PUBLICATION_VERSION,
-        registration_id: bound,
-        incarnation: boundIncarnation,
-        run,
-        owner,
-        label,
-        observed_at: observedAt
-      };
-    },
-    retireAssignment(targetAgentId) {
-      assignmentWriters.get(targetAgentId)?.retire();
-    },
-    async subject() {
-      const agentId2 = await ensureSubject(false);
-      if (agentId2 === void 0) return void 0;
-      const record = await ensureRegistration();
-      if (record === void 0) return void 0;
-      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 {
-        registration_id: agentId2,
-        ...subjectId !== void 0 ? { subject_id: subjectId } : {},
-        ...location !== void 0 ? { location } : {}
-      };
-    },
-    diagnostic: () => registrationDiagnostic ?? execution.diagnostic() ?? presence.diagnostic() ?? facts.diagnostic(),
-    stop() {
-      for (const writer of assignmentWriters.values()) writer.stop();
-      execution.stop();
-      presence.stop();
-      facts.stop();
+        descriptor = openSync(temporary, "wx", RECORD_MODE);
+        let offset = 0;
+        while (offset < bytes.length)
+          offset += writeSync(descriptor, bytes, offset, bytes.length - offset);
+        fsyncSync(descriptor);
+        closeSync(descriptor);
+        descriptor = void 0;
+        const info = lstatSync2(directory);
+        if (info.isSymbolicLink() || !info.isDirectory() || info.uid !== uid || (info.mode & 511) !== PRIVATE_MODE)
+          throw new Error(`unsafe Radar storage directory: ${directory}`);
+        renameSync(temporary, path);
+        const directoryFd = openSync(directory, constants.O_RDONLY);
+        try {
+          fsyncSync(directoryFd);
+        } finally {
+          closeSync(directoryFd);
+        }
+      } finally {
+        if (descriptor !== void 0) closeSync(descriptor);
+        try {
+          unlinkSync(temporary);
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+        }
+      }
     },
-    reopen() {
-      for (const writer of assignmentWriters.values()) writer.reopen();
-      execution.reopen();
-      presence.reopen();
-      facts.reopen();
+    remove(name) {
+      try {
+        unlinkSync(pathOf(name));
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
     }
   };
-  slot.publications.set(cacheKey, publication);
-  return publication;
 }
-
-// extension/radar-execution.ts
-var RADAR_SUBJECT_SOURCE = "herdsman-pi";
-function radarLocalRegistration() {
-  return {
-    source: RADAR_SUBJECT_SOURCE,
-    incarnation: radarProcessIncarnation()
-  };
+function createRadarProcessSlot() {
+  return { publications: /* @__PURE__ */ new Map() };
 }
-function dialogLabel(event) {
-  if (typeof event !== "object" || event === null) return "";
-  const label = event.label;
-  return typeof label === "string" && label.trim() ? label.trim().slice(0, 256) : "";
+function radarProcessSlot() {
+  const host = globalThis;
+  if (!host[PROCESS_SLOT]) {
+    const slot = createRadarProcessSlot();
+    slot.launchRegistrationId = process.env.PI_RADAR_REGISTRATION_ID;
+    delete process.env.PI_RADAR_REGISTRATION_ID;
+    host[PROCESS_SLOT] = slot;
+  }
+  return host[PROCESS_SLOT];
 }
-function assistantStop(event) {
-  const message = typeof event === "object" && event !== null && "message" in event ? event.message : event;
-  if (typeof message !== "object" || message === null) return {};
-  const value = message;
-  return value.role === "assistant" ? { stopReason: value.stopReason } : {};
+function radarProcessIncarnation(slot = radarProcessSlot()) {
+  return slot.incarnation ??= randomUUID2();
 }
-function unavailablePublication2() {
-  const writer = {
-    update: () => void 0,
-    retire: () => void 0,
-    stop: () => void 0,
-    reopen: () => void 0,
-    diagnostic: () => "Radar private storage is unavailable"
-  };
-  return {
-    execution: writer,
-    facts: { ...writer, 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,
-    binding: () => void 0,
-    subject: async () => void 0,
-    retireAssignment: () => void 0,
-    diagnostic: writer.diagnostic,
-    stop: () => void 0,
-    reopen: () => void 0
-  };
+function radarBindingKey(run, owner, label) {
+  return createHash("sha256").update(`${run}\0${owner}\0${label}`).digest("hex").slice(0, 32);
 }
-function factsFrom(context) {
-  const facts = {};
-  const model = context?.model;
-  if (typeof model?.id === "string" && model.id.length > 0)
-    facts.model = model.id;
-  if (typeof model?.provider === "string" && model.provider.length > 0)
-    facts.provider = model.provider;
-  const thinking = context?.thinkingLevel;
-  if (typeof thinking === "string" && thinking.length > 0)
-    facts.thinking = thinking;
-  const name = context?.sessionManager?.getSessionName?.();
-  if (typeof name === "string" && name.trim().length > 0)
-    facts.session_name = name.trim();
-  return facts;
+function recordAt2(value, key) {
+  if (typeof value !== "object" || value === null) return void 0;
+  return value[key];
 }
-function createRadarExecutionAdapter(pi, options) {
-  const slot = options.slot ?? radarProcessSlot();
-  const incarnation = options.incarnation ?? radarProcessIncarnation(slot);
-  const managed = options.managedBinding;
-  const birth = "birth" in options ? options.birth : readProcessBirth();
-  let publication;
-  try {
-    publication = options.publication ?? createRadarPublication({
-      dataRoot: options.dataRoot,
-      store: options.store,
-      client: options.client,
-      scheduler: options.scheduler,
-      slot,
-      incarnation,
-      birth,
-      registration: {
-        source: RADAR_SUBJECT_SOURCE,
-        ...managed !== void 0 ? { owner: managed.owner, run: managed.run, label: managed.label } : {}
-      },
-      ...options.location !== void 0 ? { location: options.location } : {},
-      ...managed !== void 0 ? { binding: managed } : {},
-      ...options.launchRegistrationId !== void 0 ? { launchRegistrationId: options.launchRegistrationId } : {}
-    });
-  } catch {
-    publication = unavailablePublication2();
-  }
-  const disposers = [];
-  const keep = (disposer) => {
-    if (typeof disposer === "function")
-      disposers.push(disposer);
-  };
-  const on = (name, handler) => {
-    keep(
-      pi.on(name, (event, context) => {
-        if (!stopped) handler(event, context);
-      })
-    );
-  };
-  let stopped = false;
-  let rootSession = false;
-  let active = false;
-  let questionnaire;
-  const permissionPrompts = /* @__PURE__ */ new Set();
-  let lastOutcome;
-  let lastPublished;
-  function blocked() {
-    return questionnaire !== void 0 || permissionPrompts.size > 0;
-  }
-  function currentSnapshot() {
-    const reason = questionnaire ?? (permissionPrompts.size > 0 ? "permission" : void 0);
-    return {
-      activity: blocked() ? "blocked" : active ? "working" : "idle",
-      ...reason !== void 0 ? { waiting_reason: reason } : {},
-      ...lastOutcome !== void 0 ? { last_outcome: lastOutcome } : {}
+function textAt(value, key) {
+  const found = recordAt2(value, key);
+  return typeof found === "string" ? found : void 0;
+}
+function numberAt2(value, key) {
+  const found = recordAt2(value, key);
+  return typeof found === "number" && Number.isFinite(found) ? found : void 0;
+}
+var PENDING_KEYS = "lease_ms,observed_at,sequence,snapshot";
+var ACCEPTED_KEYS = "lease_ms,observed_at,sequence,sent_at,snapshot";
+var OUTCOME_KEYS = "detail,result";
+var OUTCOME_KEYS_WITHOUT_DETAIL = "result";
+var WRITER_KEYS = "generation,handle";
+function exactKeys(value, expected) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).sort().join(",") === expected;
+}
+var SNAPSHOT_KEY_LIST = ["activity", "last_outcome", "waiting_reason"];
+var ASSIGNMENT_KEY_LIST = [...SNAPSHOT_KEY_LIST, "request", "awaited"];
+var FACTS_KEY_LIST = [
+  "model",
+  "provider",
+  "thinking",
+  "context_window",
+  "session_name",
+  "background_tasks",
+  "background_started_unix_ms"
+];
+function snapshotAt(value, keys = SNAPSHOT_KEY_LIST) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || !Object.keys(value).every((key) => keys.includes(key)))
+    return void 0;
+  const activity = textAt(value, "activity");
+  if (activity === void 0) return void 0;
+  const snapshot = { activity };
+  const reason = textAt(value, "waiting_reason");
+  if (reason !== void 0) snapshot.waiting_reason = reason;
+  const outcome = recordAt2(value, "last_outcome");
+  if (outcome !== void 0) {
+    if (!exactKeys(outcome, OUTCOME_KEYS) && !exactKeys(outcome, OUTCOME_KEYS_WITHOUT_DETAIL))
+      return void 0;
+    const result = textAt(outcome, "result");
+    if (result === void 0) return void 0;
+    const detail = textAt(outcome, "detail");
+    snapshot.last_outcome = {
+      result,
+      ...detail !== void 0 ? { detail } : {}
     };
   }
-  function reportSession(context) {
-    const session = context?.sessionManager?.getSessionId?.();
-    if (!isUuid(session)) return;
-    try {
-      publication.presence.report(session);
-    } catch {
+  return snapshot;
+}
+var executionCodec = {
+  parse: (value) => snapshotAt(value),
+  bound: (snapshot) => boundedRadarSnapshot(snapshot)
+};
+function assignmentAt(value) {
+  const base = snapshotAt(value, ASSIGNMENT_KEY_LIST);
+  if (base === void 0) return void 0;
+  const request = textAt(value, "request");
+  const awaitedValue = recordAt2(value, "awaited");
+  if (awaitedValue !== void 0 && (!Array.isArray(awaitedValue) || awaitedValue.length > RADAR_MAX_AWAITED || !awaitedValue.every((item) => typeof item === "string")))
+    return void 0;
+  if (recordAt2(value, "request") !== void 0 && request === void 0)
+    return void 0;
+  return {
+    ...base,
+    ...request !== void 0 ? { request } : {},
+    ...awaitedValue !== void 0 ? { awaited: awaitedValue } : {}
+  };
+}
+var assignmentCodec = {
+  parse: (value) => assignmentAt(value),
+  bound: (snapshot) => boundedRadarAssignment(snapshot)
+};
+function factsAt(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return void 0;
+  const record = value;
+  if (!Object.keys(record).every((key) => FACTS_KEY_LIST.includes(key)))
+    return void 0;
+  const facts = {};
+  for (const key of FACTS_KEY_LIST) {
+    const found = record[key];
+    if (found === void 0) continue;
+    if (key === "context_window") {
+      if (typeof found !== "object" || found === null || Array.isArray(found))
+        return void 0;
+      const window = found;
+      if (Object.keys(window).sort().join(",") !== "tokens,window") return void 0;
+      const tokens = window.tokens;
+      const size = window.window;
+      if (!Number.isSafeInteger(tokens) || tokens < 0 || !Number.isSafeInteger(size) || size <= 0 || tokens > size)
+        return void 0;
+      facts[key] = { tokens, window: size };
+      continue;
     }
-  }
-  let lastFacts;
-  function publishFacts(context) {
-    if (stopped || !rootSession) return;
-    const facts = factsFrom(context);
-    const encoded = JSON.stringify(facts);
-    if (encoded === lastFacts) return;
-    if (lastFacts === void 0 && encoded === "{}") return;
-    lastFacts = encoded;
-    try {
-      publication.facts.update(facts);
-    } catch {
+    if (key === "background_tasks") {
+      if (!Array.isArray(found) || found.length > RADAR_MAX_BACKGROUND_TASKS)
+        return void 0;
+      const ids = /* @__PURE__ */ new Set();
+      const tasks = [];
+      for (const item of found) {
+        if (typeof item !== "object" || item === null || Array.isArray(item))
+          return void 0;
+        const task = item;
+        if (Object.keys(task).sort().join(",") !== "id,phase" || typeof task.id !== "string" || !task.id || typeof task.phase !== "string" || !task.phase || ids.has(task.id))
+          return void 0;
+        ids.add(task.id);
+        tasks.push({ id: task.id, phase: task.phase });
+      }
+      facts[key] = tasks;
+      continue;
+    }
+    if (key === "background_started_unix_ms") {
+      if (!Number.isSafeInteger(found) || found < 0) return void 0;
+      facts[key] = found;
+      continue;
     }
+    if (typeof found !== "string") return void 0;
+    facts[key] = found;
   }
-  for (const name of [
-    "model_select",
-    "thinking_level_select",
-    "session_info_changed",
-    "turn_end"
-  ]) {
-    on(name, (_event, context) => publishFacts(context));
+  return facts;
+}
+var factsCodec = {
+  parse: (value) => factsAt(value),
+  bound: (snapshot) => boundedRadarFacts(snapshot)
+};
+function pendingAt(value, keys = PENDING_KEYS, codec = executionCodec) {
+  if (!exactKeys(value, keys)) return void 0;
+  const sequence = numberAt2(value, "sequence");
+  const lease = numberAt2(value, "lease_ms");
+  const observed = textAt(value, "observed_at");
+  const snapshot = codec.parse(recordAt2(value, "snapshot"));
+  if (sequence === void 0 || sequence < 1) return void 0;
+  if (lease === void 0 || observed === void 0 || snapshot === void 0)
+    return void 0;
+  return { sequence, snapshot, lease_ms: lease, observed_at: observed };
+}
+function createChannelWriter(input) {
+  const { store, client, scheduler, recordName, channel, publisher } = input;
+  const codec = input.codec ?? executionCodec;
+  let record = loadRecord();
+  let desired;
+  let running = false;
+  let again = false;
+  let recovering = false;
+  let stopped = false;
+  let fenced = false;
+  let retired = false;
+  let pump;
+  function blank(agentId) {
+    return {
+      version: RADAR_PUBLICATION_VERSION,
+      registration_id: agentId,
+      channel,
+      publisher,
+      sequence: 0
+    };
   }
-  function emit() {
-    if (stopped || !rootSession) return;
-    const snapshot = boundedRadarSnapshot(currentSnapshot());
-    const encoded = JSON.stringify(snapshot);
-    if (encoded === lastPublished) return;
-    lastPublished = encoded;
-    try {
-      publication.execution.update(snapshot);
-    } catch {
-    }
+  function loadRecord() {
+    const value = store.read(recordName);
+    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("");
+    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 = pendingAt(recordAt2(value, "pending"), PENDING_KEYS, codec);
+    const acceptedValue = recordAt2(value, "accepted");
+    const accepted = pendingAt(acceptedValue, ACCEPTED_KEYS, codec);
+    const sentAt = numberAt2(acceptedValue, "sent_at");
+    return {
+      version: RADAR_PUBLICATION_VERSION,
+      registration_id: agentId,
+      channel,
+      publisher,
+      ...handle !== void 0 && generation !== void 0 ? { writer: { handle, generation } } : {},
+      ...textAt(value, "retired_at") !== void 0 ? { retired_at: textAt(value, "retired_at") } : {},
+      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") } : {}
+    };
   }
-  keep(
-    pi.events?.on("permissions:ui_prompt", (event) => {
-      const requestId = event?.requestId;
-      if (!rootSession || typeof requestId !== "string") return;
-      permissionPrompts.add(requestId);
-      emit();
-    })
-  );
-  keep(
-    pi.events?.on("permissions:decision", (event) => {
-      const requestId = event?.requestId;
-      if (typeof requestId !== "string" || !permissionPrompts.delete(requestId))
-        return;
-      emit();
-    })
-  );
-  if (options.questionnaireEvent !== void 0)
-    keep(
-      pi.events?.on(options.questionnaireEvent, (event) => {
-        if (!rootSession || typeof event !== "object" || event === null)
-          return;
-        const value = event;
-        if (typeof value.active !== "boolean") return;
-        questionnaire = value.active ? dialogLabel(event) || "questionnaire" : void 0;
-        emit();
-      })
-    );
-  on("session_start", (_event, context) => {
-    rootSession = true;
-    reportSession(context);
-    publishFacts(context);
-    publication.reopen();
-    active = context?.isIdle?.() === false;
-    emit();
-  });
-  on("agent_start", () => {
-    if (!rootSession) return;
-    active = true;
-    emit();
-  });
-  on("agent_settled", (event, context) => {
-    if (!rootSession) return;
-    if (event?.aborted === true) lastOutcome = { result: "aborted" };
-    if (context?.isIdle?.() === true) active = false;
-    emit();
-  });
-  on("message_end", (event) => {
-    if (!rootSession) return;
-    const { stopReason } = assistantStop(event);
-    if (stopReason === "error") {
-      lastOutcome = { result: "error" };
-    } else if (stopReason === "aborted") {
-      lastOutcome = { result: "aborted" };
-    } else if (stopReason === "stop") {
-      lastOutcome = { result: "finished" };
-    } else {
-      return;
-    }
-    emit();
-  });
-  on("session_shutdown", async () => {
-    suspend();
-    await publication.presence.release();
-  });
-  function suspend() {
-    if (stopped) return;
-    rootSession = false;
-    active = false;
-    questionnaire = void 0;
-    permissionPrompts.clear();
-    lastOutcome = void 0;
-    lastPublished = void 0;
-    publication.stop();
+  function note(message) {
+    if (record.diagnostic !== void 0) return;
+    record.diagnostic = message.slice(0, 256);
+    save();
   }
-  function stop() {
-    if (stopped) return;
-    suspend();
-    stopped = true;
-    for (const dispose of disposers.splice(0)) dispose();
+  function save() {
+    store.write(recordName, record);
   }
-  return {
-    publication,
-    binding: () => managed !== void 0 ? publication.binding(managed.key) : void 0,
-    blocked,
-    stop
-  };
-}
-
-// 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, {
-  radarLocalPane: () => radarLocalPane,
-  radarPaneHandle: () => radarPaneHandle,
-  resolveRadarProcessLocation: () => resolveRadarProcessLocation,
-  tmuxServerName: () => tmuxServerName
-});
-import { basename } from "node:path";
-function radarLocalPane(env) {
-  const pane = env.TMUX_PANE?.trim();
-  return pane && /^%\d+$/.test(pane) ? pane : void 0;
+  function sameSnapshot(left, right) {
+    return JSON.stringify(codec.bound(left)) === JSON.stringify(codec.bound(right));
+  }
+  function fence(message) {
+    fenced = true;
+    stopPump();
+    note(`channel ${channel} stopped: ${message}`);
+  }
+  function startPump() {
+    if (pump !== void 0 || stopped || fenced || retired) return;
+    pump = scheduler.setInterval(() => kick(), input.heartbeatMs);
+    pump.unref?.();
+  }
+  function stopPump() {
+    if (pump === void 0) return;
+    scheduler.clearInterval(pump);
+    pump = void 0;
+  }
+  async function ensureWriter() {
+    if (record.writer !== void 0) return true;
+    const agentId = await input.subject(recovering);
+    if (agentId === void 0) return false;
+    if (record.registration_id !== agentId) {
+      record = blank(agentId);
+      save();
+    }
+    const answer = await client.acquire({
+      registration_id: agentId,
+      channel,
+      publisher
+    });
+    if (answer.ok === false) {
+      if (answer.code === "not_found") {
+        recovering = true;
+        return false;
+      }
+      if (answer.code === "refused" || answer.code === "bad_params")
+        fence(answer.message);
+      return false;
+    }
+    recovering = false;
+    record.writer = {
+      handle: answer.value.handle,
+      generation: answer.value.generation
+    };
+    record.sequence = Math.max(record.sequence, answer.value.sequence);
+    save();
+    startPump();
+    return true;
+  }
+  function heartbeatDue() {
+    return record.accepted !== void 0 && scheduler.now() - record.accepted.sent_at >= input.heartbeatMs;
+  }
+  async function send(pending) {
+    const writer = record.writer;
+    if (writer === void 0) return;
+    const answer = await client.publish({
+      registration_id: record.registration_id,
+      channel,
+      writer_handle: writer.handle,
+      sequence: pending.sequence,
+      lease_ms: pending.lease_ms,
+      observed_at: pending.observed_at,
+      snapshot: pending.snapshot
+    });
+    if (answer.ok === true) {
+      recovering = false;
+      record.sequence = Math.max(record.sequence, answer.value.sequence);
+      record.accepted = { ...pending, sent_at: scheduler.now() };
+      record.pending = void 0;
+      save();
+      return;
+    }
+    if (answer.code === "refused" || answer.code === "bad_params") {
+      fence(answer.message);
+      return;
+    }
+    if (answer.code === "not_found") {
+      record.writer = void 0;
+      recovering = true;
+      save();
+      return;
+    }
+  }
+  async function stage(snapshot) {
+    const pending = {
+      sequence: record.sequence + 1,
+      snapshot: codec.bound(snapshot),
+      lease_ms: input.leaseMs,
+      observed_at: new Date(scheduler.now()).toISOString()
+    };
+    record.pending = pending;
+    save();
+    await send(pending);
+  }
+  async function drainOnce() {
+    if (fenced || retired) return;
+    if (!await ensureWriter()) return;
+    if (fenced) return;
+    if (record.pending !== void 0) {
+      await send(record.pending);
+      return;
+    }
+    if (desired !== void 0 && (record.accepted === void 0 || !sameSnapshot(desired, record.accepted.snapshot))) {
+      await stage(desired);
+      return;
+    }
+    if (heartbeatDue() && record.accepted !== void 0)
+      await stage(record.accepted.snapshot);
+  }
+  async function drain() {
+    if (running || stopped || fenced || retired) return;
+    running = true;
+    try {
+      await drainOnce();
+    } catch (error) {
+      fenced = true;
+      stopPump();
+      try {
+        note(`channel ${channel} storage failure: ${String(error).slice(0, 180)}`);
+      } catch {
+      }
+    } finally {
+      running = false;
+      if (again && !stopped && !fenced && !retired) {
+        again = false;
+        kick();
+      }
+    }
+  }
+  function kick() {
+    if (stopped || fenced || retired) return;
+    startPump();
+    if (running) {
+      again = true;
+      return;
+    }
+    void drain().catch(() => void 0);
+  }
+  return {
+    update(snapshot) {
+      if (stopped || fenced || retired) return;
+      desired = snapshot;
+      kick();
+    },
+    retire() {
+      if (stopped || fenced || retired) return;
+      retired = true;
+      stopPump();
+      const writer = record.writer;
+      if (writer === void 0) return;
+      const agentId = record.registration_id;
+      try {
+        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();
+              save();
+            } catch {
+            }
+          }
+        }).catch(() => void 0);
+      } catch {
+      }
+    },
+    stop() {
+      stopped = true;
+      stopPump();
+    },
+    reopen() {
+      stopped = false;
+      if (desired !== void 0 || record.pending !== void 0) kick();
+    },
+    diagnostic: () => record.diagnostic
+  };
 }
-function radarPaneHandle(qualified) {
-  return qualified.slice(qualified.lastIndexOf(":") + 1);
+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() {
+    try {
+      if (state) store.write(recordName, state);
+      return true;
+    } catch (error) {
+      diagnostic = `presence storage unavailable: ${String(error)}`;
+      return false;
+    }
+  }
+  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();
+    }
+  }
+  function schedule() {
+    if (stopped || timer) return;
+    timer = scheduler.setTimeout(() => {
+      timer = void 0;
+      void ensure();
+    }, input.heartbeatMs);
+    timer.unref?.();
+  }
+  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;
+      }
+      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 claim.registration_id;
+    })();
+    try {
+      return await running;
+    } catch (error) {
+      diagnostic = `presence unavailable: ${String(error)}`;
+      return void 0;
+    } finally {
+      running = void 0;
+      if (!stopped && state !== claim) void ensure();
+      else schedule();
+    }
+  }
+  return {
+    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;
+      if (timer) scheduler.clearTimeout(timer);
+      timer = void 0;
+    },
+    reopen() {
+      stopped = false;
+      void ensure();
+    },
+    management: () => standing,
+    diagnostic: () => diagnostic
+  };
 }
-function tmuxServerName(env) {
-  const socket = env.TMUX?.trim().split(",")[0];
-  return socket ? basename(socket) || void 0 : void 0;
+var STORE_IDENTITY = /* @__PURE__ */ new WeakMap();
+function storeIdentity(store) {
+  const known = STORE_IDENTITY.get(store);
+  if (known !== void 0) return known;
+  const created = randomUUID2();
+  STORE_IDENTITY.set(store, created);
+  return created;
 }
-function qualifiedOwnPane(env, backend, instance) {
-  if (backend !== "tmux")
-    return {
-      absent: `the daemon serves the ${backend} backend, and Herdsman drives only tmux`
-    };
-  if (instance === void 0 || instance === "")
-    return {
-      pending: "the daemon did not name the tmux server it addresses"
-    };
-  const server = tmuxServerName(env);
-  if (server === void 0)
-    return {
-      absent: "this process's own tmux client names no server, so it is not in the pane it would publish"
-    };
-  if (server !== instance)
-    return {
-      absent: `this process is attached to tmux server ${server}, not to ${instance}`
-    };
-  const pane = radarLocalPane(env);
-  if (pane === void 0)
-    return {
-      absent: "this process's own environment names no tmux pane of that server"
-    };
-  return { pane: `tmux:${instance}:${pane}` };
+function createRadarPublication(options) {
+  try {
+    return createRadarPublicationInner(options);
+  } catch (error) {
+    return unavailablePublication(error);
+  }
 }
-function observedContainment(inventory, paneId) {
-  const rows = inventory.panes.filter((pane) => pane.pane_id === paneId);
-  if (rows.length === 0) return void 0;
-  if (rows.length > 1) return { ambiguous: `topology reports pane ${paneId} twice` };
-  const row = rows[0];
-  const tab = inventory.tabs.find((candidate) => candidate.tab_id === row.tab_id);
-  if (tab !== void 0 && tab.workspace_id !== row.workspace_id)
-    return {
-      ambiguous: `pane ${paneId} is reported in ${row.workspace_id}, but its tab belongs to ${tab.workspace_id}`
-    };
-  return { pane: row };
+function unavailablePublication(error) {
+  const diagnostic = `Radar publication unavailable${error ? `: ${String(error).slice(0, 180)}` : ""}`;
+  const writer = {
+    update: () => void 0,
+    retire: () => void 0,
+    stop: () => void 0,
+    reopen: () => void 0,
+    diagnostic: () => diagnostic
+  };
+  return {
+    execution: writer,
+    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 },
+    assignment: () => writer,
+    binding: () => void 0,
+    subject: async () => void 0,
+    retireAssignment: () => void 0,
+    diagnostic: () => diagnostic,
+    stop: () => void 0,
+    reopen: () => void 0
+  };
 }
-async function resolveRadarProcessLocation(client, env = process.env) {
-  let ready;
-  try {
-    ready = await client.ping();
-  } catch {
-    return { state: "pending", reason: "the daemon did not answer this process" };
+function createRadarPublicationInner(options) {
+  const dataRoot = options.dataRoot;
+  const store = options.store ?? createPublicationStore(dataRoot);
+  const scheduler = options.scheduler ?? systemScheduler;
+  const client = options.client;
+  const slot = options.slot ?? radarProcessSlot();
+  const launchRegistrationId = options.launchRegistrationId ?? slot.launchRegistrationId;
+  const incarnation = options.incarnation ?? radarProcessIncarnation(slot);
+  const cacheKey = `${options.store === void 0 ? dataRoot : storeIdentity(options.store)}\0${incarnation}`;
+  const cached = slot.publications.get(cacheKey);
+  if (cached !== void 0) {
+    cached.reopen();
+    return cached;
   }
-  if (ready.ok === false)
-    return {
-      state: "pending",
-      reason: `the daemon did not answer this process (${ready.code})`
-    };
-  const backend = ready.value.backend;
-  if (backend === void 0 || backend === "none")
-    return { state: "absent", reason: "the daemon serves no physical backend" };
-  const instance = ready.value.instance ?? void 0;
-  const own = qualifiedOwnPane(env, backend, instance);
-  if ("absent" in own) return { state: "absent", reason: own.absent };
-  if ("pending" in own) return { state: "pending", reason: own.pending };
-  const paneId = own.pane;
-  if (paneId === env.PI_HERDSMAN_PARENT_PANE_ID?.trim())
-    return {
-      state: "absent",
-      reason: "this process is in the pane its launch was created beside, not in a pane of its own"
-    };
-  let inventory;
-  try {
-    inventory = await client.observe();
-  } catch {
+  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 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, "registration_id");
     return {
-      state: "pending",
-      reason: "the daemon's topology could not be read for this process's pane"
+      version: RADAR_PUBLICATION_VERSION,
+      registration,
+      ...storedAgentId !== void 0 && isUuid(storedAgentId) ? { registration_id: storedAgentId } : {}
     };
   }
-  if (inventory.ok === false)
-    return {
-      state: "pending",
-      reason: `the daemon's topology could not be read (${inventory.code})`
-    };
-  const containment = observedContainment(inventory.value, paneId);
-  if (containment === void 0)
-    return {
-      state: "pending",
-      reason: `the daemon's topology does not report pane ${paneId} yet`
-    };
-  if ("ambiguous" in containment)
-    return { state: "pending", reason: containment.ambiguous };
-  const row = containment.pane;
-  return {
-    state: "resolved",
-    location: {
-      backend,
-      ...instance !== void 0 ? { instance } : {},
-      workspace: row.workspace_id,
-      tab: row.tab_id,
-      pane: paneId
+  const stored = readRegistration();
+  let processRecord = stored;
+  let registrationDiagnostic;
+  let registrationRecord;
+  async function ensureRegistration() {
+    if (processRecord !== void 0) return processRecord;
+    registrationRecord ??= (async () => {
+      const resolution = options.location ? await options.location() : { state: "absent", reason: "this process publishes no location" };
+      const built = {
+        version: RADAR_PUBLICATION_VERSION,
+        registration: {
+          ...options.registration,
+          ...resolution.state === "resolved" ? { location: resolution.location } : {},
+          incarnation,
+          ...options.birth !== void 0 ? { process: options.birth } : {}
+        }
+      };
+      try {
+        store.write(registrationName, built);
+      } catch (error) {
+        registrationDiagnostic ??= `private storage unavailable: ${String(error)}`.slice(0, 256);
+        return void 0;
+      }
+      registrationDiagnostic = void 0;
+      processRecord = built;
+      return built;
+    })();
+    try {
+      return await registrationRecord;
+    } finally {
+      registrationRecord = void 0;
+    }
+  }
+  let agentId = stored?.registration_id;
+  let subjectReady;
+  async function ensureSubject(recheck) {
+    if (!recheck && agentId !== void 0) return agentId;
+    subjectReady ??= (async () => {
+      const ready = await client.ping();
+      if (ready.ok === false) {
+        if (ready.code !== "absent" && ready.code !== "timeout" && ready.code !== "transport")
+          registrationDiagnostic ??= `daemon negotiation failed: ${ready.message}`.slice(0, 256);
+        return void 0;
+      }
+      const record = await ensureRegistration();
+      if (record === void 0) return void 0;
+      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;
+    })();
+    try {
+      return await subjectReady;
+    } finally {
+      subjectReady = void 0;
+    }
+  }
+  function writeBinding(binding) {
+    if (agentId === void 0) return;
+    store.write(`bindings/${binding.key}.json`, {
+      version: RADAR_PUBLICATION_VERSION,
+      registration_id: agentId,
+      incarnation,
+      run: binding.run,
+      owner: binding.owner,
+      label: binding.label,
+      observed_at: new Date(scheduler.now()).toISOString()
+    });
+  }
+  const publisher = (source, reportingOwner) => ({
+    source,
+    incarnation,
+    ...reportingOwner !== void 0 ? { reporting_owner: reportingOwner } : {}
+  });
+  const execution = createChannelWriter({
+    store,
+    client,
+    scheduler,
+    recordName: channelRecord("execution"),
+    channel: "execution",
+    publisher: publisher("herdsman-pi"),
+    subject: ensureSubject,
+    leaseMs: options.leaseMs ?? RADAR_LEASE_MS,
+    heartbeatMs: options.heartbeatMs ?? RADAR_HEARTBEAT_MS
+  });
+  const presence = createPresenceReporter({
+    store,
+    client,
+    scheduler,
+    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 } : {},
+        ...launchRegistrationId ? { registration_id: launchRegistrationId } : {}
+      };
+    },
+    heartbeatMs: options.heartbeatMs ?? RADAR_HEARTBEAT_MS
+  });
+  const facts = createChannelWriter({
+    store,
+    client,
+    scheduler,
+    recordName: channelRecord("facts"),
+    channel: "facts",
+    publisher: publisher("pi"),
+    codec: factsCodec,
+    subject: ensureSubject,
+    leaseMs: options.leaseMs ?? RADAR_LEASE_MS,
+    heartbeatMs: options.heartbeatMs ?? RADAR_HEARTBEAT_MS
+  });
+  const assignmentWriters = /* @__PURE__ */ new Map();
+  const publication = {
+    execution,
+    presence,
+    facts,
+    assignment(target, reportingOwner) {
+      const existing = assignmentWriters.get(target);
+      if (existing !== void 0) return existing;
+      try {
+        const writer = createChannelWriter({
+          store,
+          client,
+          scheduler,
+          recordName: channelRecord("assignment", target),
+          channel: "assignment",
+          publisher: publisher("herdsman-owner", reportingOwner),
+          codec: assignmentCodec,
+          // The owner publishes about a subject it did not register: the exact
+          // 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
+        });
+        assignmentWriters.set(target, writer);
+        return writer;
+      } catch (error) {
+        registrationDiagnostic ??= `Radar assignment unavailable: ${String(error).slice(0, 180)}`;
+        return unavailablePublication(error).execution;
+      }
+    },
+    binding(key) {
+      let value;
+      try {
+        value = store.read(`bindings/${key}.json`);
+      } catch (error) {
+        registrationDiagnostic ??= `Radar binding unavailable: ${String(error).slice(0, 180)}`;
+        return void 0;
+      }
+      const bound = textAt(value, "registration_id");
+      const boundIncarnation = textAt(value, "incarnation");
+      const run = textAt(value, "run");
+      const owner = textAt(value, "owner");
+      const label = textAt(value, "label");
+      const observedAt = textAt(value, "observed_at");
+      if (!isUuid(bound) || !isUuid(boundIncarnation) || run === void 0 || owner === void 0 || label === void 0 || observedAt === void 0)
+        return void 0;
+      return {
+        version: RADAR_PUBLICATION_VERSION,
+        registration_id: bound,
+        incarnation: boundIncarnation,
+        run,
+        owner,
+        label,
+        observed_at: observedAt
+      };
+    },
+    retireAssignment(targetAgentId) {
+      assignmentWriters.get(targetAgentId)?.retire();
+    },
+    async subject() {
+      const agentId2 = await ensureSubject(false);
+      if (agentId2 === void 0) return void 0;
+      const record = await ensureRegistration();
+      if (record === void 0) return void 0;
+      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 {
+        registration_id: agentId2,
+        ...subjectId !== void 0 ? { subject_id: subjectId } : {},
+        ...location !== void 0 ? { location } : {}
+      };
+    },
+    diagnostic: () => registrationDiagnostic ?? execution.diagnostic() ?? presence.diagnostic() ?? facts.diagnostic(),
+    stop() {
+      for (const writer of assignmentWriters.values()) writer.stop();
+      execution.stop();
+      presence.stop();
+      facts.stop();
+    },
+    reopen() {
+      for (const writer of assignmentWriters.values()) writer.reopen();
+      execution.reopen();
+      presence.reopen();
+      facts.reopen();
     }
   };
+  slot.publications.set(cacheKey, publication);
+  return publication;
 }
 
-// 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}`
-    );
+// extension/radar-execution.ts
+var RADAR_SUBJECT_SOURCE = "herdsman-pi";
+function radarLocalRegistration() {
   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
-    }
+    source: RADAR_SUBJECT_SOURCE,
+    incarnation: radarProcessIncarnation()
   };
 }
-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 dialogLabel(event) {
+  if (typeof event !== "object" || event === null) return "";
+  const label = event.label;
+  return typeof label === "string" && label.trim() ? label.trim().slice(0, 256) : "";
 }
-function refusedLaunch(message) {
-  return { kind: "refused", message };
+function assistantStop(event) {
+  const message = typeof event === "object" && event !== null && "message" in event ? event.message : event;
+  if (typeof message !== "object" || message === null) return {};
+  const value = message;
+  return value.role === "assistant" ? { stopReason: value.stopReason } : {};
 }
-function unresolvedLaunch(requestId, message) {
+function unavailablePublication2() {
+  const writer = {
+    update: () => void 0,
+    retire: () => void 0,
+    stop: () => void 0,
+    reopen: () => void 0,
+    diagnostic: () => "Radar private storage is unavailable"
+  };
   return {
-    kind: "unresolved",
-    request_id: requestId,
-    message: `spawn ${requestId} is unresolved (${message})`
+    execution: writer,
+    facts: { ...writer, 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,
+    binding: () => void 0,
+    subject: async () => void 0,
+    retireAssignment: () => void 0,
+    diagnostic: writer.diagnostic,
+    stop: () => void 0,
+    reopen: () => void 0
   };
 }
-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);
+function factsFrom(context) {
+  const facts = {};
+  const model = context?.model;
+  if (typeof model?.id === "string" && model.id.length > 0)
+    facts.model = model.id;
+  if (typeof model?.provider === "string" && model.provider.length > 0)
+    facts.provider = model.provider;
+  const thinking = context?.thinkingLevel;
+  if (typeof thinking === "string" && thinking.length > 0)
+    facts.thinking = thinking;
+  const name = context?.sessionManager?.getSessionName?.();
+  if (typeof name === "string" && name.trim().length > 0)
+    facts.session_name = name.trim();
+  return facts;
 }
-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"
+function createRadarExecutionAdapter(pi, options) {
+  const slot = options.slot ?? radarProcessSlot();
+  const incarnation = options.incarnation ?? radarProcessIncarnation(slot);
+  const managed = options.managedBinding;
+  const birth = "birth" in options ? options.birth : readProcessBirth();
+  let publication;
+  try {
+    publication = options.publication ?? createRadarPublication({
+      dataRoot: options.dataRoot,
+      store: options.store,
+      client: options.client,
+      scheduler: options.scheduler,
+      slot,
+      incarnation,
+      birth,
+      registration: {
+        source: RADAR_SUBJECT_SOURCE,
+        ...managed !== void 0 ? { owner: managed.owner, run: managed.run, label: managed.label } : {}
+      },
+      ...options.location !== void 0 ? { location: options.location } : {},
+      ...managed !== void 0 ? { binding: managed } : {},
+      ...options.launchRegistrationId !== void 0 ? { launchRegistrationId: options.launchRegistrationId } : {}
+    });
+  } catch {
+    publication = unavailablePublication2();
+  }
+  const disposers = [];
+  const keep = (disposer) => {
+    if (typeof disposer === "function")
+      disposers.push(disposer);
+  };
+  const on = (name, handler) => {
+    keep(
+      pi.on(name, (event, context) => {
+        if (!stopped) handler(event, context);
+      })
     );
-  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;
+  };
+  let stopped = false;
+  let rootSession = false;
+  let active = false;
+  let questionnaire;
+  const permissionPrompts = /* @__PURE__ */ new Set();
+  let lastOutcome;
+  let lastPublished;
+  function blocked() {
+    return questionnaire !== void 0 || permissionPrompts.size > 0;
   }
-  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));
+  function currentSnapshot() {
+    const reason = questionnaire ?? (permissionPrompts.size > 0 ? "permission" : void 0);
+    return {
+      activity: blocked() ? "blocked" : active ? "working" : "idle",
+      ...reason !== void 0 ? { waiting_reason: reason } : {},
+      ...lastOutcome !== void 0 ? { last_outcome: lastOutcome } : {}
+    };
   }
-  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) {
+  function reportSession(context) {
+    const session = context?.sessionManager?.getSessionId?.();
+    if (!isUuid(session)) return;
     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)})`
-      );
+      publication.presence.report(session);
+    } catch {
     }
   }
-  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)})`
-    );
+  let lastFacts;
+  function publishFacts(context) {
+    if (stopped || !rootSession) return;
+    const facts = factsFrom(context);
+    const encoded = JSON.stringify(facts);
+    if (encoded === lastFacts) return;
+    if (lastFacts === void 0 && encoded === "{}") return;
+    lastFacts = encoded;
+    try {
+      publication.facts.update(facts);
+    } catch {
+    }
   }
-}
-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";
+  for (const name of [
+    "model_select",
+    "thinking_level_select",
+    "session_info_changed",
+    "turn_end"
+  ]) {
+    on(name, (_event, context) => publishFacts(context));
+  }
+  function emit() {
+    if (stopped || !rootSession) return;
+    const snapshot = boundedRadarSnapshot(currentSnapshot());
+    const encoded = JSON.stringify(snapshot);
+    if (encoded === lastPublished) return;
+    lastPublished = encoded;
+    try {
+      publication.execution.update(snapshot);
+    } catch {
+    }
+  }
+  keep(
+    pi.events?.on("permissions:ui_prompt", (event) => {
+      const requestId = event?.requestId;
+      if (!rootSession || typeof requestId !== "string") return;
+      permissionPrompts.add(requestId);
+      emit();
+    })
+  );
+  keep(
+    pi.events?.on("permissions:decision", (event) => {
+      const requestId = event?.requestId;
+      if (typeof requestId !== "string" || !permissionPrompts.delete(requestId))
+        return;
+      emit();
+    })
+  );
+  if (options.questionnaireEvent !== void 0)
+    keep(
+      pi.events?.on(options.questionnaireEvent, (event) => {
+        if (!rootSession || typeof event !== "object" || event === null)
+          return;
+        const value = event;
+        if (typeof value.active !== "boolean") return;
+        questionnaire = value.active ? dialogLabel(event) || "questionnaire" : void 0;
+        emit();
+      })
+    );
+  on("session_start", (_event, context) => {
+    rootSession = true;
+    reportSession(context);
+    publishFacts(context);
+    publication.reopen();
+    active = context?.isIdle?.() === false;
+    emit();
+  });
+  on("agent_start", () => {
+    if (!rootSession) return;
+    active = true;
+    emit();
+  });
+  on("agent_settled", (event, context) => {
+    if (!rootSession) return;
+    if (event?.aborted === true) lastOutcome = { result: "aborted" };
+    if (context?.isIdle?.() === true) active = false;
+    emit();
+  });
+  on("message_end", (event) => {
+    if (!rootSession) return;
+    const { stopReason } = assistantStop(event);
+    if (stopReason === "error") {
+      lastOutcome = { result: "error" };
+    } else if (stopReason === "aborted") {
+      lastOutcome = { result: "aborted" };
+    } else if (stopReason === "stop") {
+      lastOutcome = { result: "finished" };
     } else {
-      last = answer.message;
+      return;
     }
-    if (options.remaining() <= 0)
-      return unresolvedLaunch(requestId, last);
-    await delay(options.pollMs, void 0, {
-      ...options.signal !== void 0 ? { signal: options.signal } : {}
-    });
+    emit();
+  });
+  on("session_shutdown", async () => {
+    suspend();
+    await publication.presence.release();
+  });
+  function suspend() {
+    if (stopped) return;
+    rootSession = false;
+    active = false;
+    questionnaire = void 0;
+    permissionPrompts.clear();
+    lastOutcome = void 0;
+    lastPublished = void 0;
+    publication.stop();
+  }
+  function stop() {
+    if (stopped) return;
+    suspend();
+    stopped = true;
+    for (const dispose of disposers.splice(0)) dispose();
   }
+  return {
+    publication,
+    binding: () => managed !== void 0 ? publication.binding(managed.key) : void 0,
+    blocked,
+    stop
+  };
 }
 
 // extension/radar-runtime.ts
@@ -3037,7 +3192,7 @@ __export(radar_runtime_exports, {
   requestRadarRuntime: () => requestRadarRuntime
 });
 var RADAR_RUNTIME_REQUEST = "pi-radar/runtime-request";
-var RADAR_RUNTIME_VERSION = 2;
+var RADAR_RUNTIME_VERSION = 3;
 function lazyRadarRuntime(start) {
   let pending;
   return {
@@ -3071,6 +3226,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,