pi-radar 0.0.0-stage → 0.2.0

package/dist/extension/baseline.js

@@ -0,0 +1,2626 @@
+// extension/baseline.ts
+import { homedir } from "node:os";
+import { join as join3 } from "node:path";
+
+// extension/radar-client.ts
+import { randomUUID } from "node:crypto";
+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 = 3;
+var RADAR_REGISTRY_CONTRACT = "registry.v1";
+var RADAR_REGISTRY_FACTS_CONTRACT = "registry.facts.v1";
+var RADAR_SPAWN_CONTRACT = "spawn.v1";
+var RADAR_SPAWN_CLOSE_CONTRACT = "spawn.close.v1";
+var RADAR_SPAWN_LAUNCH_CONTEXT_CONTRACT = "spawn.launch_context.v1";
+var RADAR_EVENTS_CONTRACT = "events.v1";
+var RADAR_REQUESTER = "pi-radar";
+var RADAR_MAX_LINE_BYTES = 1024 * 1024;
+var RADAR_CALL_TIMEOUT_MS = 2e3;
+var DAEMON_ERROR_CODES = [
+  "bad_version",
+  "bad_request",
+  "bad_params",
+  "unknown_method",
+  "refused",
+  "not_found",
+  "busy",
+  "backend_unavailable",
+  "internal"
+];
+var DAEMON_CODE_ALIASES = {
+  outcome_unknown: "unknown"
+};
+var wallClock = { setTimeout, clearTimeout, setInterval, clearInterval };
+var systemScheduler = {
+  setTimeout: (handler, ms) => wallClock.setTimeout(handler, ms),
+  clearTimeout: (timer) => wallClock.clearTimeout(timer),
+  setInterval: (handler, ms) => wallClock.setInterval(handler, ms),
+  clearInterval: (timer) => wallClock.clearInterval(timer),
+  now: () => Date.now()
+};
+function radarControlSocketPath(env, uid) {
+  const override = env.RADAR_CONTROL_SOCKET?.trim();
+  if (override) return { path: override, explicit: true };
+  const runtime = env.XDG_RUNTIME_DIR?.trim();
+  const directory = runtime ? join(runtime, "agent-radar") : `/tmp/agent-radar-${uid}`;
+  return { path: join(directory, "control.sock"), explicit: false };
+}
+function untrustedControlSocket(path, uid) {
+  const directory = dirname(path);
+  try {
+    const parent = lstatSync(directory);
+    if (parent.isSymbolicLink() || !parent.isDirectory())
+      return `${directory} is not a real directory`;
+    if (parent.uid !== uid)
+      return `${directory} is not owned by uid ${uid}`;
+    if ((parent.mode & 511) !== 448)
+      return `${directory} is not mode 0700`;
+    const socket = lstatSync(path);
+    if (socket.isSymbolicLink()) return `${path} is a symlink`;
+    if (!socket.isSocket()) return `${path} is not a socket`;
+    if (socket.uid !== uid) return `${path} is not owned by uid ${uid}`;
+    return void 0;
+  } catch (error) {
+    const code = error?.code ?? "unavailable";
+    return `${path} is unavailable (${code})`;
+  }
+}
+function protocol(message) {
+  return { ok: false, code: "protocol", message };
+}
+function bounded(text, bytes) {
+  if (Buffer.byteLength(text, "utf8") <= bytes) return text;
+  let end = text.length;
+  while (end > 0 && Buffer.byteLength(text.slice(0, end), "utf8") > bytes)
+    end -= 1;
+  return text.slice(0, end);
+}
+function decodeReply(line, requestId) {
+  if (Buffer.byteLength(line, "utf8") > RADAR_MAX_LINE_BYTES)
+    return protocol("reply exceeds the control-plane line bound");
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return protocol("reply is not JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return protocol("reply is not an object");
+  const answer = parsed;
+  if (answer.id !== requestId)
+    return protocol("reply does not match the request id");
+  if (answer.error !== void 0) {
+    const error = answer.error;
+    const code = error?.code;
+    const message = error?.message;
+    return {
+      ok: false,
+      code: typeof code === "string" ? DAEMON_CODE_ALIASES[code] ?? (DAEMON_ERROR_CODES.includes(code) ? code : "internal") : "internal",
+      message: `${typeof code === "string" ? code : "error"}: ${typeof message === "string" ? message : "no message"}`
+    };
+  }
+  if (!("result" in answer)) return protocol("reply carries no result");
+  return { ok: true, value: answer.result };
+}
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function recordAt(value, field) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  return value[field];
+}
+function isUuid(value) {
+  return typeof value === "string" && UUID.test(value);
+}
+function stringAt(value, field) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const found = value[field];
+  return typeof found === "string" ? found : void 0;
+}
+function numberAt(value, field) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const found = value[field];
+  return typeof found === "number" && Number.isFinite(found) ? found : void 0;
+}
+function writerBinding(value) {
+  const handle = stringAt(value, "handle");
+  const source = stringAt(value, "source");
+  const incarnation = stringAt(value, "incarnation");
+  const generation = numberAt(value, "generation");
+  const sequence = numberAt(value, "sequence");
+  if (!isUuid(handle) || source === void 0 || incarnation === void 0 || generation === void 0 || sequence === void 0)
+    return void 0;
+  const reportingOwner = stringAt(value, "reporting_owner");
+  const retiredAt = stringAt(value, "retired_at");
+  return {
+    handle,
+    source,
+    incarnation,
+    ...reportingOwner !== void 0 ? { reporting_owner: reportingOwner } : {},
+    generation,
+    sequence,
+    ...retiredAt !== void 0 ? { retired_at: retiredAt } : {}
+  };
+}
+function observedAgent(value) {
+  const location = recordAt(value, "location");
+  const workspaceId = stringAt(location, "workspace_id");
+  const tabId = stringAt(location, "tab_id");
+  const paneId = stringAt(location, "pane_id");
+  if (!workspaceId || !tabId || !paneId)
+    return protocol("observe reply carries a malformed agent location");
+  const observed = recordAt(value, "session");
+  let session;
+  if (observed !== void 0 && observed !== null) {
+    const kind = stringAt(observed, "kind");
+    const identity = stringAt(observed, "value");
+    if (kind === "uuid" && isUuid(identity)) session = { kind: "uuid", value: identity };
+    else if (kind === "reported") {
+      const reported = recordAt(observed, "value");
+      const reference = stringAt(reported, "value");
+      if (reference === void 0 || reference === "")
+        return protocol("observe reply carries a malformed session reference");
+      const source = stringAt(reported, "source");
+      session = {
+        kind: "reported",
+        value: reference,
+        ...source !== void 0 ? { source } : {}
+      };
+    } else return protocol("observe reply carries an unrecognized session identity");
+  }
+  const facts = recordAt(value, "facts");
+  const name = stringAt(value, "name");
+  const status = runtimeStatus(value);
+  const managedLabel = stringAt(facts, "label");
+  const managedRun = stringAt(facts, "run");
+  return {
+    ok: true,
+    value: {
+      workspace_id: workspaceId,
+      tab_id: tabId,
+      pane_id: paneId,
+      ...name !== void 0 ? { name } : {},
+      ...status !== void 0 ? { status } : {},
+      ...managedLabel !== void 0 ? { managed_label: managedLabel } : {},
+      ...managedRun !== void 0 ? { managed_run: managedRun } : {},
+      ...session === void 0 ? {} : { session }
+    }
+  };
+}
+function runtimeStatus(value) {
+  const status = recordAt(value, "status");
+  if (typeof status === "string") return status;
+  return stringAt(status, "other");
+}
+function observedPane(value) {
+  const location = recordAt(value, "location");
+  const workspaceId = stringAt(location, "workspace_id");
+  const tabId = stringAt(location, "tab_id");
+  const paneId = stringAt(location, "pane_id");
+  if (!workspaceId || !tabId || !paneId)
+    return protocol("observe reply carries a malformed pane location");
+  return {
+    ok: true,
+    value: { workspace_id: workspaceId, tab_id: tabId, pane_id: paneId }
+  };
+}
+var DISPATCH_REFUSED_CODES = [
+  "absent",
+  "unsupported",
+  "bad_version",
+  "bad_request",
+  "bad_params",
+  "unknown_method",
+  "refused",
+  "not_found",
+  "busy",
+  "backend_unavailable"
+];
+function unresolvedOperation(requestId, detail) {
+  return {
+    ok: false,
+    code: "unknown",
+    message: `focus ${requestId} is unresolved (${detail})`
+  };
+}
+var RADAR_SPAWN_TOKEN_ENV = "PI_RADAR_SPAWN_TOKEN";
+var RADAR_MANAGED_IDENTITY_ENV = /* @__PURE__ */ new Set([
+  "PI_RADAR_MANAGED_SUBJECT_ID",
+  "PI_RADAR_MANAGED_LAUNCH_ID",
+  "PI_RADAR_MANAGED_EXECUTION_GENERATION"
+]);
+function unresolvedSpawn(requestId, detail) {
+  return {
+    ok: false,
+    code: "unknown",
+    message: `spawn ${requestId} is unresolved (${detail})`
+  };
+}
+var EFFECT_OUTCOMES = [
+  "completed",
+  "refused",
+  "unknown"
+];
+function effectAt(value, field) {
+  const found = stringAt(value, field);
+  return found !== void 0 && EFFECT_OUTCOMES.includes(found) ? found : void 0;
+}
+function locationAt(value) {
+  const location = recordAt(value, "location");
+  const backend = stringAt(location, "backend");
+  if (backend === void 0 || backend === "") return void 0;
+  const instance = stringAt(location, "instance");
+  const workspace = stringAt(location, "workspace");
+  const tab = stringAt(location, "tab");
+  const pane = stringAt(location, "pane");
+  return {
+    backend,
+    ...instance !== void 0 ? { instance } : {},
+    ...workspace !== void 0 ? { workspace } : {},
+    ...tab !== void 0 ? { tab } : {},
+    ...pane !== void 0 ? { pane } : {}
+  };
+}
+function spawnEdge(value) {
+  const requestId = stringAt(value, "request_id");
+  const parent = stringAt(value, "parent");
+  const created = effectAt(value, "created");
+  const launched = effectAt(value, "launched");
+  if (!isUuid(requestId) || !isUuid(parent) || created === void 0 || launched === void 0)
+    return protocol("spawn reply carries no durable edge");
+  const location = locationAt(value);
+  const bound = recordAt(value, "bound");
+  const source = stringAt(bound, "source");
+  const incarnation = stringAt(bound, "incarnation");
+  const agentId = stringAt(bound, "agent_id");
+  const exit = exitAt(recordAt(value, "exit_observation"));
+  return {
+    ok: true,
+    value: {
+      request_id: requestId,
+      parent,
+      created,
+      launched,
+      ...location !== void 0 ? { location } : {},
+      ...source !== void 0 && incarnation !== void 0 ? {
+        bound: {
+          source,
+          incarnation,
+          ...isUuid(agentId) ? { agent_id: agentId } : {}
+        }
+      } : {},
+      ...exit !== void 0 ? { exit_observation: exit } : {}
+    }
+  };
+}
+var PROCESS_VERDICTS = [
+  "verified",
+  "absent",
+  "mismatched",
+  "unavailable"
+];
+function agentProcessAt(agent) {
+  const process2 = recordAt(agent, "process");
+  const claimed = recordAt(process2, "claimed");
+  const verification = stringAt(process2, "verification");
+  if (typeof claimed !== "boolean" || verification === void 0 || !PROCESS_VERDICTS.includes(verification))
+    return protocol("agent.get reply carries no process verdict");
+  const registration = recordAt(agent, "registration");
+  const location = locationAt(registration);
+  const session = stringAt(registration, "session");
+  const context = recordAt(recordAt(agent, "context"), "context");
+  const contextSession = stringAt(context, "freshness") === "fresh" ? stringAt(context, "session") : void 0;
+  const execution = recordAt(recordAt(agent, "execution"), "snapshot");
+  const activity = stringAt(execution, "freshness") === "fresh" ? stringAt(recordAt(execution, "snapshot"), "activity") : void 0;
+  return {
+    ok: true,
+    value: {
+      claimed,
+      verification,
+      ...location !== void 0 ? { location } : {},
+      ...session !== void 0 ? { session } : {},
+      ...contextSession !== void 0 ? { contextSession } : {},
+      ...activity !== void 0 ? { activity } : {}
+    }
+  };
+}
+function exitAt(value) {
+  if (value === void 0) return void 0;
+  if (stringAt(value, "state") === "unknown") return { state: "unknown" };
+  if (stringAt(value, "state") !== "exited") return void 0;
+  const code = recordAt(value, "code");
+  const signal = recordAt(value, "signal");
+  const observedAt = stringAt(value, "observed_at");
+  const isInt32OrNull = (found) => found === null || typeof found === "number" && Number.isInteger(found) && found >= -2147483648 && found <= 2147483647;
+  if (!isInt32OrNull(code) || !isInt32OrNull(signal) || observedAt === void 0)
+    return void 0;
+  return {
+    state: "exited",
+    code,
+    signal,
+    observed_at: observedAt
+  };
+}
+function spawnTopology(value) {
+  const edge = spawnEdge(value);
+  if (edge.ok === false) return edge;
+  const state = stringAt(value, "state");
+  const freshness = stringAt(value, "freshness");
+  return {
+    ok: true,
+    value: {
+      edge: edge.value,
+      ...state === "unbound" || state === "bound" || state === "unresolved" ? { state } : {},
+      ...freshness === "fresh" || freshness === "stale" ? { freshness } : {}
+    }
+  };
+}
+function spawnRequestShape(request) {
+  if (!isUuid(request.request_id))
+    return "spawn requires a canonical request UUID";
+  if (!isUuid(request.parent))
+    return "spawn requires the parent's canonical agent UUID";
+  if (!isUuid(request.parent_session_id))
+    return "spawn requires a canonical parent session UUID";
+  if (!request.executable.startsWith("/") || new RegExp("\\p{Cc}", "u").test(request.executable))
+    return "spawn requires an absolute, printable executable path";
+  if (request.argv.some((argument) => new RegExp("\\p{Cc}", "u").test(argument)))
+    return "no supported backend carries a control character or a second line in an argument";
+  if (request.cwd !== void 0 && !request.cwd.startsWith("/"))
+    return "spawn cwd must be an absolute path";
+  const env = Object.entries(request.env ?? {});
+  if (env.length > 256) return "spawn env names more than 256 entries";
+  for (const [name, value] of env) {
+    if (name === RADAR_SPAWN_TOKEN_ENV)
+      return `spawn env cannot set the reserved ${RADAR_SPAWN_TOKEN_ENV}`;
+    if (RADAR_MANAGED_IDENTITY_ENV.has(name))
+      return `spawn env cannot set Radar-issued identity variable ${name}`;
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name) || new RegExp("\\p{Cc}", "u").test(value))
+      return `spawn env contains an invalid name or value: ${name}`;
+  }
+  if (request.managed !== void 0) {
+    if (typeof request.managed !== "object" || request.managed === null)
+      return "managed launch metadata must be an object";
+    for (const [name, value] of Object.entries(request.managed)) {
+      if (!["owner", "run", "label", "role", "parent_subject_id"].includes(name))
+        return `unknown managed launch metadata field: ${name}`;
+      if (value != null && (typeof value !== "string" || value.trim() === "" || new TextEncoder().encode(value).length > 256 || new RegExp("\\p{Cc}", "u").test(value)))
+        return `managed launch ${name} must be non-empty, control-free, and at most 256 UTF-8 bytes`;
+    }
+    if (request.managed.parent_subject_id != null && !isUuid(request.managed.parent_subject_id))
+      return "managed parent_subject_id must be a canonical UUID";
+  }
+  return void 0;
+}
+function focusOutcome(record, requestId) {
+  if (typeof record !== "object" || record === null)
+    return unresolvedOperation(requestId, "the daemon returned no operation record");
+  const outcome = stringAt(record, "outcome");
+  if (outcome === "completed") return { ok: true, value: { request_id: requestId } };
+  if (outcome === "refused")
+    return {
+      ok: false,
+      code: "refused",
+      message: stringAt(record, "message") ?? `the daemon refused focus ${requestId}`
+    };
+  return unresolvedOperation(
+    requestId,
+    `the record is ${stringAt(record, "state") ?? "unreadable"} with ${outcome === void 0 ? "no outcome" : `outcome ${outcome}`}`
+  );
+}
+function eventsReplyAt(after, value) {
+  const expired = recordAt(value, "cursor_expired");
+  if (expired !== void 0) {
+    const epoch2 = stringAt(expired, "epoch");
+    const sequence2 = numberAt(recordAt(expired, "cursor"), "sequence");
+    return epoch2 !== void 0 && sequence2 !== void 0 ? { kind: "expired", epoch: epoch2, sequence: sequence2 } : void 0;
+  }
+  const epoch = stringAt(value, "epoch");
+  const events = recordAt(value, "events");
+  const more = recordAt(value, "more");
+  if (epoch === void 0 || !Array.isArray(events) || typeof more !== "boolean")
+    return void 0;
+  let sequence = after;
+  for (const event of events) {
+    const seq = numberAt(event, "seq");
+    if (seq === void 0 || seq <= sequence) return void 0;
+    sequence = seq;
+  }
+  return { kind: "page", epoch, sequence, more };
+}
+var RADAR_EVENT_WAIT_MS = 1e3;
+function createRadarClient(options = {}) {
+  const env = options.env ?? process.env;
+  const uid = options.uid ?? process.getuid?.() ?? 0;
+  const scheduler = options.scheduler ?? systemScheduler;
+  const timeoutMs = options.timeoutMs ?? RADAR_CALL_TIMEOUT_MS;
+  const requester = options.requester ?? RADAR_REQUESTER;
+  const dial = options.dial ?? ((path) => createConnection(path));
+  const currentPath = () => radarControlSocketPath(env, uid).path;
+  async function call(method, params, id = randomUUID()) {
+    const path = currentPath();
+    const refused = untrustedControlSocket(path, uid);
+    if (refused !== void 0)
+      return { ok: false, code: "absent", message: refused };
+    const line = `${JSON.stringify({
+      version: RADAR_PROTOCOL_VERSION,
+      id,
+      method,
+      params
+    })}
+`;
+    if (Buffer.byteLength(line, "utf8") - 1 > RADAR_MAX_LINE_BYTES)
+      return {
+        ok: false,
+        code: "bad_params",
+        message: "request exceeds the control-plane line bound"
+      };
+    return new Promise((resolve2) => {
+      let settled = false;
+      let socket;
+      let timer;
+      let received = 0;
+      const chunks = [];
+      const finish = (result) => {
+        if (settled) return;
+        settled = true;
+        if (timer !== void 0) scheduler.clearTimeout(timer);
+        try {
+          socket?.destroy();
+        } catch {
+        }
+        resolve2(result);
+      };
+      try {
+        socket = dial(path);
+      } catch (error) {
+        finish({
+          ok: false,
+          code: "transport",
+          message: String(error?.message ?? error)
+        });
+        return;
+      }
+      timer = scheduler.setTimeout(() => {
+        finish({
+          ok: false,
+          code: "timeout",
+          message: `${method} got no reply within ${timeoutMs}ms`
+        });
+      }, timeoutMs);
+      timer.unref?.();
+      socket.on("error", (error) => {
+        finish({
+          ok: false,
+          code: "transport",
+          message: String(error?.message ?? error)
+        });
+      });
+      socket.on("close", () => {
+        finish({
+          ok: false,
+          code: "transport",
+          message: `${method} connection closed without a reply`
+        });
+      });
+      socket.on("connect", () => {
+        try {
+          socket?.write(line);
+        } catch (error) {
+          finish({
+            ok: false,
+            code: "transport",
+            message: String(error?.message ?? error)
+          });
+        }
+      });
+      socket.on("data", (value) => {
+        const chunk = Buffer.isBuffer(value) ? value : Buffer.from(String(value ?? ""), "utf8");
+        received += chunk.length;
+        if (received > RADAR_MAX_LINE_BYTES + 1) {
+          finish(protocol("reply exceeds the control-plane line bound"));
+          return;
+        }
+        chunks.push(chunk);
+        const text = Buffer.concat(chunks).toString("utf8");
+        const end = text.indexOf("\n");
+        if (end < 0) return;
+        finish(decodeReply(text.slice(0, end), id));
+      });
+    });
+  }
+  const socketPath = currentPath;
+  const probe = async () => {
+    const answer = await call("daemon.ping", {});
+    if (answer.ok === false) return answer;
+    const protocolVersion = numberAt(answer.value, "protocol");
+    if (protocolVersion !== RADAR_PROTOCOL_VERSION)
+      return {
+        ok: false,
+        code: "unsupported",
+        message: `the daemon at ${currentPath()} speaks protocol ${protocolVersion ?? "unknown"}, not ${RADAR_PROTOCOL_VERSION}`
+      };
+    const revision = numberAt(answer.value, "revision");
+    if (revision === void 0 || !Number.isSafeInteger(revision) || revision < RADAR_MINIMUM_REVISION)
+      return {
+        ok: false,
+        code: "unsupported",
+        message: `the daemon at ${currentPath()} does not support wire revision ${RADAR_MINIMUM_REVISION}; run systemctl --user restart radar-daemon`
+      };
+    const backend = stringAt(answer.value, "backend");
+    const instance = recordAt(answer.value, "instance");
+    const rawContracts = recordAt(answer.value, "contracts");
+    const rawTasks = recordAt(answer.value, "tasks");
+    const taskError = recordAt(rawTasks, "error");
+    const taskAvailable = recordAt(rawTasks, "available");
+    if (backend === void 0 || instance !== null && typeof instance !== "string" || !Array.isArray(rawContracts) || rawContracts.some((name) => typeof name !== "string") || typeof taskAvailable !== "boolean" || taskError !== null && typeof taskError !== "string")
+      return protocol("daemon.ping reply does not match the public response schema");
+    return {
+      ok: true,
+      value: {
+        protocol: protocolVersion,
+        revision,
+        backend,
+        instance,
+        contracts: rawContracts,
+        tasks: { available: taskAvailable, error: taskError }
+      }
+    };
+  };
+  const ping = async () => {
+    const answer = await probe();
+    if (answer.ok === false) return answer;
+    if (!answer.value.contracts.includes(RADAR_REGISTRY_CONTRACT))
+      return {
+        ok: false,
+        code: "unsupported",
+        message: `the daemon at ${currentPath()} does not provide \`${RADAR_REGISTRY_CONTRACT}\``
+      };
+    return answer;
+  };
+  let handshake;
+  const negotiated = async () => {
+    handshake ??= probe();
+    const attempt = handshake;
+    try {
+      const result = await attempt;
+      if (result.ok === false && handshake === attempt) handshake = void 0;
+      return result;
+    } catch (error) {
+      if (handshake === attempt) handshake = void 0;
+      throw error;
+    }
+  };
+  const withContract = async (contract, operation) => {
+    const ready = await negotiated();
+    if (ready.ok === false) return ready;
+    return ready.value.contracts.includes(contract) ? operation() : {
+      ok: false,
+      code: "unsupported",
+      message: `the daemon at ${currentPath()} does not provide \`${contract}\``
+    };
+  };
+  const withContracts = async (needed, operation) => {
+    const ready = await negotiated();
+    if (ready.ok === false) return ready;
+    const missing = needed.find((contract) => !ready.value.contracts.includes(contract));
+    if (missing === void 0) return operation();
+    return {
+      ok: false,
+      code: "unsupported",
+      message: `the daemon at ${currentPath()} does not provide \`${missing}\``
+    };
+  };
+  const withRegistry = (operation) => withContract(RADAR_REGISTRY_CONTRACT, operation);
+  const withRegistryChannel = (channel, operation) => withContracts(
+    [
+      RADAR_REGISTRY_CONTRACT,
+      ...channel === "facts" || channel === "assignment" ? [RADAR_REGISTRY_FACTS_CONTRACT] : []
+    ],
+    operation
+  );
+  const withDaemon = async (operation) => {
+    const ready = await negotiated();
+    return ready.ok === false ? ready : operation();
+  };
+  return {
+    socketPath,
+    ping,
+    async register(registration) {
+      return withRegistry(async () => {
+        const answer = await call("agent.register", {
+          source: registration.source,
+          ...registration.spawn_token !== void 0 ? { spawn_token: registration.spawn_token } : {},
+          incarnation: registration.incarnation,
+          ...registration.session !== void 0 ? { session: registration.session } : {},
+          ...registration.owner !== void 0 ? { owner: registration.owner } : {},
+          ...registration.run !== void 0 ? { run: registration.run } : {},
+          ...registration.label !== void 0 ? { label: registration.label } : {},
+          ...registration.location !== void 0 ? { location: registration.location } : {},
+          ...registration.process !== void 0 ? { process: registration.process } : {}
+        });
+        if (answer.ok === false) return answer;
+        const record = answer.value.registration;
+        const agentId = stringAt(record, "agent_id");
+        if (!isUuid(agentId)) return protocol("registration reply carries no agent_id");
+        return { ok: true, value: { agent_id: agentId } };
+      });
+    },
+    async acquire(request) {
+      return withRegistryChannel(request.channel, async () => {
+        const answer = await call("agent.acquire", {
+          agent_id: request.agent_id,
+          channel: request.channel,
+          publisher: request.publisher,
+          ...request.replace !== void 0 ? { replace: request.replace } : {}
+        });
+        if (answer.ok === false) return answer;
+        const writer = writerBinding(
+          answer.value.writer
+        );
+        if (writer === void 0)
+          return protocol("acquire reply carries no writer binding");
+        return { ok: true, value: writer };
+      });
+    },
+    async publish(request) {
+      let snapshot = request.snapshot;
+      if (request.channel === "facts") {
+        try {
+          snapshot = boundedRadarFacts(request.snapshot);
+        } catch (error) {
+          return {
+            ok: false,
+            code: "bad_params",
+            message: error instanceof Error ? error.message : "invalid facts snapshot"
+          };
+        }
+      }
+      return withRegistryChannel(request.channel, async () => {
+        const answer = await call("agent.publish", {
+          agent_id: request.agent_id,
+          channel: request.channel,
+          writer_handle: request.writer_handle,
+          sequence: request.sequence,
+          ...request.lease_ms !== void 0 ? { lease_ms: request.lease_ms } : {},
+          ...request.observed_at !== void 0 ? { observed_at: request.observed_at } : {},
+          snapshot
+        });
+        if (answer.ok === false) return answer;
+        const channel = answer.value.channel;
+        const writer = channel?.writer;
+        const sequence = numberAt(writer, "sequence");
+        if (sequence === void 0) return protocol("publish reply carries no accepted sequence");
+        return { ok: true, value: { sequence } };
+      });
+    },
+    async context(request) {
+      return withRegistry(async () => {
+        const answer = await call("agent.context", {
+          agent_id: request.agent_id,
+          publisher: request.publisher,
+          ...request.writer_handle !== void 0 ? { writer_handle: request.writer_handle } : {},
+          ...request.replace !== void 0 ? { replace: request.replace } : {},
+          sequence: request.sequence,
+          ...request.lease_ms !== void 0 ? { lease_ms: request.lease_ms } : {},
+          ...request.observed_at !== void 0 ? { observed_at: request.observed_at } : {},
+          context: request.context
+        });
+        if (answer.ok === false) return answer;
+        const writer = writerBinding(
+          answer.value.writer
+        );
+        if (writer === void 0)
+          return protocol("context reply carries no writer binding");
+        const warning = stringAt(answer.value, "warning");
+        return {
+          ok: true,
+          value: { writer, ...warning !== void 0 ? { warning } : {} }
+        };
+      });
+    },
+    async retire(request) {
+      return withRegistryChannel(request.channel, async () => {
+        const answer = await call("agent.retire", request);
+        return answer.ok === true ? { ok: true, value: void 0 } : answer;
+      });
+    },
+    async spawn(request) {
+      const shape = spawnRequestShape(request);
+      if (shape !== void 0)
+        return { ok: false, code: "bad_params", message: shape };
+      const carriesContext = request.cwd !== void 0 || request.env !== void 0 && Object.keys(request.env).length > 0;
+      return withContracts(
+        carriesContext ? [RADAR_SPAWN_CONTRACT, RADAR_SPAWN_LAUNCH_CONTEXT_CONTRACT] : [RADAR_SPAWN_CONTRACT],
+        async () => {
+          const answer = await call(
+            "spawn.create",
+            {
+              request: {
+                parent: request.parent,
+                parent_session_id: request.parent_session_id,
+                executable: request.executable,
+                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 } : {}
+              },
+              requester
+            },
+            request.request_id
+          );
+          if (answer.ok === true) return spawnEdge(recordAt(answer.value, "spawn"));
+          if (DISPATCH_REFUSED_CODES.includes(answer.code)) return answer;
+          const readback = await call("spawn.get", {
+            request_id: request.request_id
+          });
+          if (readback.ok === false)
+            return unresolvedSpawn(
+              request.request_id,
+              `${answer.message}; its edge could not be read back (${readback.code}: ${readback.message})`
+            );
+          const recovered = spawnTopology(recordAt(readback.value, "spawn"));
+          if (recovered.ok === false) return recovered;
+          const recorded = recovered.value.edge;
+          if (recorded.created === "completed" && recorded.launched === "completed")
+            return { ok: true, value: recorded };
+          return unresolvedSpawn(
+            request.request_id,
+            `${answer.message}; the recorded edge is created ${recorded.created} and launched ${recorded.launched}`
+          );
+        }
+      );
+    },
+    async spawnGet(requestId) {
+      if (!isUuid(requestId))
+        return {
+          ok: false,
+          code: "bad_params",
+          message: "spawn.get requires a canonical request UUID"
+        };
+      return withRegistry(async () => {
+        const answer = await call("spawn.get", { request_id: requestId });
+        if (answer.ok === false) return answer;
+        return spawnTopology(recordAt(answer.value, "spawn"));
+      });
+    },
+    async agentGet(agentId) {
+      if (!isUuid(agentId))
+        return {
+          ok: false,
+          code: "bad_params",
+          message: "agent.get requires a canonical agent UUID"
+        };
+      return withRegistry(async () => {
+        const answer = await call("agent.get", { agent_id: agentId });
+        if (answer.ok === false) return answer;
+        return agentProcessAt(recordAt(answer.value, "agent"));
+      });
+    },
+    async childClose(request) {
+      if (!isUuid(request.request_id) || !isUuid(request.spawn_request_id) || !isUuid(request.incarnation))
+        return {
+          ok: false,
+          code: "bad_params",
+          message: "spawn.close requires canonical request, spawn and incarnation UUIDs"
+        };
+      return withContract(RADAR_SPAWN_CLOSE_CONTRACT, async () => {
+        const answer = await call(
+          "spawn.close",
+          {
+            spawn_request_id: request.spawn_request_id,
+            source: request.source,
+            incarnation: request.incarnation,
+            intent: request.intent
+          },
+          request.request_id
+        );
+        if (answer.ok === false) return answer;
+        const close = recordAt(answer.value, "close");
+        const outcome = stringAt(close, "outcome");
+        const pane = stringAt(close, "pane");
+        const detail = stringAt(close, "message");
+        if (outcome === "completed")
+          return pane !== void 0 ? { ok: true, value: { outcome, pane } } : protocol("spawn.close reply does not name the closed pane");
+        if (outcome === "already_exited") {
+          const exit = exitAt(recordAt(close, "exit_observation"));
+          return pane !== void 0 && exit !== void 0 ? {
+            ok: true,
+            value: { outcome, pane, exit_observation: exit }
+          } : protocol(
+            "spawn.close reply does not report the exit it cleaned up"
+          );
+        }
+        if (outcome === "refused" || outcome === "unknown")
+          return {
+            ok: true,
+            value: {
+              outcome,
+              ...pane !== void 0 ? { pane } : {},
+              ...detail !== void 0 ? { message: detail } : {}
+            }
+          };
+        return protocol("spawn.close reply carries no close outcome");
+      });
+    },
+    async events(request) {
+      if (!Number.isSafeInteger(request.after) || request.after < 0 || !Number.isSafeInteger(request.wait_ms) || request.wait_ms < 0 || request.wait_ms > RADAR_EVENT_WAIT_MS)
+        return {
+          ok: false,
+          code: "bad_params",
+          message: "events.read requires a sequence and a wait of 0 to 1000 ms"
+        };
+      return withContract(RADAR_EVENTS_CONTRACT, async () => {
+        const answer = await call("events.read", {
+          after: request.after,
+          wait_ms: request.wait_ms,
+          ...request.epoch !== void 0 ? { epoch: request.epoch } : {}
+        });
+        if (answer.ok === false) return answer;
+        const reply = eventsReplyAt(request.after, answer.value);
+        return reply !== void 0 ? { ok: true, value: reply } : protocol("events.read reply carries no journal page or cursor_expired");
+      });
+    },
+    async observe() {
+      return withDaemon(async () => {
+        const answer = await call("mux.observe", {});
+        if (answer.ok === false) return answer;
+        const inventory = recordAt(answer.value, "inventory");
+        const workspaces = recordAt(inventory, "workspaces");
+        const tabs = recordAt(inventory, "tabs");
+        const panes = recordAt(inventory, "panes");
+        const agents = recordAt(inventory, "agents");
+        if (!Array.isArray(workspaces) || !Array.isArray(tabs) || !Array.isArray(panes) || !Array.isArray(agents))
+          return protocol(
+            "mux.observe reply carries no canonical fleet inventory"
+          );
+        const observed = {
+          workspaces: [],
+          tabs: [],
+          panes: [],
+          agents: []
+        };
+        for (const workspace of workspaces) {
+          const id = stringAt(workspace, "workspace_id");
+          if (id === void 0 || id === "")
+            return protocol("observe reply carries a malformed workspace");
+          observed.workspaces.push({ workspace_id: id });
+        }
+        for (const tab of tabs) {
+          const id = stringAt(tab, "tab_id");
+          const workspaceId = stringAt(tab, "workspace_id");
+          if (!id || !workspaceId)
+            return protocol("observe reply carries a malformed tab");
+          observed.tabs.push({ tab_id: id, workspace_id: workspaceId });
+        }
+        for (const pane of panes) {
+          const decoded = observedPane(pane);
+          if (decoded.ok === false) return decoded;
+          observed.panes.push(decoded.value);
+        }
+        for (const agent of agents) {
+          const decoded = observedAgent(agent);
+          if (decoded.ok === false) return decoded;
+          observed.agents.push(decoded.value);
+        }
+        return { ok: true, value: observed };
+      });
+    },
+    async output(request) {
+      return withDaemon(async () => {
+        const answer = await call("mux.output", request);
+        if (answer.ok === false) return answer;
+        const read = recordAt(answer.value, "output");
+        const text = stringAt(read, "text");
+        const truncated = recordAt(read, "truncated");
+        if (text === void 0 || typeof truncated !== "boolean")
+          return protocol("mux.output reply carries no output read");
+        const revision = recordAt(read, "revision");
+        return {
+          ok: true,
+          value: {
+            text,
+            truncated,
+            ...typeof revision === "number" ? { revision } : {}
+          }
+        };
+      });
+    },
+    async processInfo(request) {
+      return withDaemon(async () => {
+        const answer = await call("mux.process_info", request);
+        if (answer.ok === false) return answer;
+        const evidence = recordAt(answer.value, "evidence");
+        const kind = stringAt(evidence, "kind");
+        if (kind === "shell") return { ok: true, value: { kind: "shell" } };
+        if (kind === "inconclusive")
+          return { ok: true, value: { kind: "inconclusive" } };
+        const pid = recordAt(evidence, "pid");
+        if (kind === "non_shell" && typeof pid === "number")
+          return {
+            ok: true,
+            value: {
+              kind: "non_shell",
+              pid,
+              ...stringAt(evidence, "name") !== void 0 ? { name: stringAt(evidence, "name") } : {},
+              ...stringAt(evidence, "command") !== void 0 ? { command: stringAt(evidence, "command") } : {}
+            }
+          };
+        return protocol("mux.process_info reply carries no foreground evidence");
+      });
+    },
+    async focus(request) {
+      if (!isUuid(request.request_id))
+        return {
+          ok: false,
+          code: "bad_params",
+          message: "focus requires a canonical operation UUID"
+        };
+      return withDaemon(async () => {
+        const answer = await call(
+          "mux.focus",
+          {
+            target: request.pane_id,
+            target_kind: "pane",
+            requester
+          },
+          request.request_id
+        );
+        if (answer.ok === true)
+          return focusOutcome(
+            recordAt(answer.value, "request"),
+            request.request_id
+          );
+        if (DISPATCH_REFUSED_CODES.includes(answer.code)) return answer;
+        const readback = await call("mux.request.get", {
+          id: request.request_id
+        });
+        if (readback.ok === false)
+          return unresolvedOperation(
+            request.request_id,
+            readback.code === "not_found" ? `${answer.message}; the daemon holds no record of it` : `${answer.message}; its record could not be read back (${readback.code}: ${readback.message})`
+          );
+        return focusOutcome(
+          recordAt(readback.value, "request"),
+          request.request_id
+        );
+      });
+    }
+  };
+}
+var RADAR_MAX_BACKGROUND_TASKS = 64;
+var RADAR_MAX_AWAITED = 64;
+function boundedRadarFacts(facts) {
+  const allowed = /* @__PURE__ */ new Set([
+    "model",
+    "provider",
+    "thinking",
+    "context_window",
+    "session_name",
+    "background_tasks",
+    "background_started_unix_ms"
+  ]);
+  const unknown = Object.keys(facts).find((key) => !allowed.has(key));
+  if (unknown !== void 0) throw new RangeError(`unknown facts field ${unknown}`);
+  const text = (value) => {
+    if (typeof value !== "string") throw new RangeError("facts fields must be strings");
+    return bounded(value, 1024);
+  };
+  const contextWindow = facts.context_window;
+  if (contextWindow !== void 0 && contextWindow !== null) {
+    if (typeof contextWindow !== "object" || Object.keys(contextWindow).sort().join(",") !== "tokens,window" || !Number.isSafeInteger(contextWindow.tokens) || contextWindow.tokens < 0 || !Number.isSafeInteger(contextWindow.window) || contextWindow.window <= 0 || contextWindow.tokens > contextWindow.window)
+      throw new RangeError("context_window requires integer tokens within a positive window");
+  }
+  const backgroundTasks = facts.background_tasks;
+  if (backgroundTasks !== void 0 && (!Array.isArray(backgroundTasks) || backgroundTasks.length > RADAR_MAX_BACKGROUND_TASKS))
+    throw new RangeError(`background_tasks exceeds ${RADAR_MAX_BACKGROUND_TASKS} valid entries`);
+  const taskIds = /* @__PURE__ */ new Set();
+  const boundedTasks = backgroundTasks?.map((task) => {
+    if (typeof task !== "object" || task === null || Array.isArray(task) || Object.keys(task).sort().join(",") !== "id,phase" || typeof task.id !== "string" || !task.id || typeof task.phase !== "string" || !task.phase)
+      throw new RangeError("background_tasks requires non-empty id and phase fields");
+    const id = text(task.id);
+    if (taskIds.has(id)) throw new RangeError("background_tasks ids must be unique");
+    taskIds.add(id);
+    return { id, phase: text(task.phase) };
+  });
+  const started = facts.background_started_unix_ms;
+  if (started !== void 0 && started !== null && (!Number.isSafeInteger(started) || started < 0))
+    throw new RangeError("background_started_unix_ms must be a non-negative integer");
+  const optionalText = (value) => value === void 0 ? void 0 : value === null ? null : text(value);
+  return {
+    ...facts.model !== void 0 ? { model: optionalText(facts.model) } : {},
+    ...facts.provider !== void 0 ? { provider: optionalText(facts.provider) } : {},
+    ...facts.thinking !== void 0 ? { thinking: optionalText(facts.thinking) } : {},
+    ...contextWindow !== void 0 ? {
+      context_window: contextWindow === null ? null : { tokens: contextWindow.tokens, window: contextWindow.window }
+    } : {},
+    ...facts.session_name !== void 0 ? { session_name: optionalText(facts.session_name) } : {},
+    ...boundedTasks !== void 0 ? { background_tasks: boundedTasks } : {},
+    ...started !== void 0 ? { background_started_unix_ms: started } : {}
+  };
+}
+function boundedRadarAssignment(snapshot) {
+  const base = boundedRadarSnapshot(snapshot);
+  return {
+    ...base,
+    ...snapshot.request !== void 0 ? { request: bounded(snapshot.request, 1024) } : {},
+    ...snapshot.awaited !== void 0 ? {
+      awaited: snapshot.awaited.slice(0, RADAR_MAX_AWAITED).map((item) => bounded(item, 1024))
+    } : {}
+  };
+}
+function boundedRadarSnapshot(snapshot) {
+  const text = (value) => bounded(value, 1024);
+  return {
+    activity: text(snapshot.activity),
+    ...snapshot.waiting_reason !== void 0 ? { waiting_reason: text(snapshot.waiting_reason) } : {},
+    ...snapshot.last_outcome !== void 0 ? {
+      last_outcome: {
+        result: text(snapshot.last_outcome.result),
+        ...snapshot.last_outcome.detail !== void 0 ? { detail: text(snapshot.last_outcome.detail) } : {}
+      }
+    } : {}
+  };
+}
+
+// extension/radar-publication.ts
+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";
+
+// extension/radar-session-marker.ts
+var RADAR_LAUNCH_MARKER_TYPE = "pi-radar.launch-identity";
+var RADAR_LAUNCH_MARKER_VERSION = 1;
+var RADAR_MAX_EXECUTION_GENERATION = 4294967295;
+var RADAR_MANAGED_SUBJECT_ENV = "PI_RADAR_MANAGED_SUBJECT_ID";
+var RADAR_MANAGED_LAUNCH_ENV = "PI_RADAR_MANAGED_LAUNCH_ID";
+var RADAR_MANAGED_GENERATION_ENV = "PI_RADAR_MANAGED_EXECUTION_GENERATION";
+var UUID2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+function decodeRadarLaunchMarker(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const record = value;
+  if (Object.keys(record).sort().join(",") !== "execution_generation,launch_id,subject_id,version") {
+    return void 0;
+  }
+  if (record.version !== RADAR_LAUNCH_MARKER_VERSION || typeof record.subject_id !== "string" || !UUID2.test(record.subject_id) || typeof record.launch_id !== "string" || !UUID2.test(record.launch_id) || !Number.isSafeInteger(record.execution_generation) || record.execution_generation < 1 || record.execution_generation > RADAR_MAX_EXECUTION_GENERATION) {
+    return void 0;
+  }
+  return {
+    version: RADAR_LAUNCH_MARKER_VERSION,
+    subject_id: record.subject_id,
+    launch_id: record.launch_id,
+    execution_generation: record.execution_generation
+  };
+}
+function appendRadarLaunchMarker(appendEntry, marker) {
+  const validated = decodeRadarLaunchMarker(marker);
+  if (!validated) throw new Error("invalid Radar launch identity marker");
+  appendEntry(RADAR_LAUNCH_MARKER_TYPE, validated);
+}
+function latestRadarLaunchMarker(branch) {
+  let latest;
+  for (const entry of branch) {
+    if (entry.type === "custom" && entry.customType === RADAR_LAUNCH_MARKER_TYPE) {
+      latest = entry;
+    }
+  }
+  if (!latest) return { status: "absent" };
+  const marker = decodeRadarLaunchMarker(latest.data);
+  return marker ? { status: "valid", marker } : { status: "invalid" };
+}
+function radarLaunchMarkerFromEnvironment(env = process.env) {
+  const rawGeneration = env[RADAR_MANAGED_GENERATION_ENV];
+  if (env[RADAR_MANAGED_SUBJECT_ENV] === void 0 || env[RADAR_MANAGED_LAUNCH_ENV] === void 0 || rawGeneration === void 0 || !/^[1-9][0-9]*$/.test(rawGeneration)) {
+    return void 0;
+  }
+  return decodeRadarLaunchMarker({
+    version: RADAR_LAUNCH_MARKER_VERSION,
+    subject_id: env[RADAR_MANAGED_SUBJECT_ENV],
+    launch_id: env[RADAR_MANAGED_LAUNCH_ENV],
+    execution_generation: Number(rawGeneration)
+  });
+}
+function activeRadarLaunchMarker(host) {
+  if (!host.sessionManager) return { status: "absent" };
+  return latestRadarLaunchMarker(host.sessionManager.getBranch());
+}
+function persistRadarLaunchMarker(host, env = process.env) {
+  const marker = radarLaunchMarkerFromEnvironment(env);
+  if (!marker) return "absent";
+  if (!host.appendEntry || !host.sessionManager) return "unsupported";
+  const current = latestRadarLaunchMarker(host.sessionManager.getBranch());
+  if (current.status === "valid" && sameMarker(current.marker, marker)) return "unchanged";
+  appendRadarLaunchMarker(host.appendEntry, marker);
+  return "written";
+}
+function sameMarker(a, b) {
+  return a.version === b.version && a.subject_id === b.subject_id && a.launch_id === b.launch_id && a.execution_generation === b.execution_generation;
+}
+
+// extension/radar-publication.ts
+var 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 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;
+  }
+}
+var RECORD_NAME = /^(?: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);
+  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;
+      }
+    }
+  };
+}
+function createRadarProcessSlot() {
+  return { publications: /* @__PURE__ */ new Map() };
+}
+function radarProcessSlot() {
+  const host = globalThis;
+  return host[PROCESS_SLOT] ??= createRadarProcessSlot();
+}
+function radarProcessIncarnation(slot = radarProcessSlot()) {
+  return slot.incarnation ??= randomUUID2();
+}
+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;
+}
+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 } : {}
+    };
+  }
+  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;
+    }
+    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;
+  }
+  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 };
+}
+var CONTEXT_PENDING_KEYS = "lease_ms,observed_at,sequence,session";
+var CONTEXT_PENDING_MARKED_KEYS = "launch_identity,lease_ms,observed_at,sequence,session";
+var CONTEXT_ACCEPTED_KEYS = "lease_ms,observed_at,sent_at,sequence,session";
+var CONTEXT_ACCEPTED_MARKED_KEYS = "launch_identity,lease_ms,observed_at,sent_at,sequence,session";
+function sessionAt(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const found = value.session;
+  if (found === null) return null;
+  return typeof found === "string" ? found : void 0;
+}
+function sameLaunchIdentity(a, b) {
+  return a === b || a !== void 0 && b !== void 0 && a.version === b.version && a.subject_id === b.subject_id && a.launch_id === b.launch_id && a.execution_generation === b.execution_generation;
+}
+function contextReportAt(value, keys, markedKeys) {
+  const marked = exactKeys(value, markedKeys);
+  if (!exactKeys(value, keys) && !marked) return void 0;
+  const sequence = numberAt2(value, "sequence");
+  const lease = numberAt2(value, "lease_ms");
+  const observed = textAt(value, "observed_at");
+  const session = sessionAt(value);
+  if (sequence === void 0 || sequence < 1) return void 0;
+  if (lease === void 0 || observed === void 0 || session === void 0)
+    return void 0;
+  const marker = marked ? decodeRadarLaunchMarker(value.launch_identity) : void 0;
+  if (marked && marker === void 0) return void 0;
+  return {
+    sequence,
+    session,
+    lease_ms: lease,
+    observed_at: observed,
+    ...marker !== void 0 ? { launch_identity: marker } : {}
+  };
+}
+function createChannelWriter(input) {
+  const { store, client, scheduler, recordName, channel, publisher } = input;
+  const codec = input.codec ?? executionCodec;
+  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,
+      agent_id: agentId,
+      channel,
+      publisher,
+      sequence: 0
+    };
+  }
+  function loadRecord() {
+    const value = store.read(recordName);
+    const agentId = textAt(value, "agent_id");
+    const storedPublisher = recordAt2(value, "publisher");
+    if (numberAt2(value, "version") !== RADAR_PUBLICATION_VERSION || agentId === void 0 || !isUuid(agentId) || 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,
+      agent_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.agent_id !== agentId) {
+      record = blank(agentId);
+      save();
+    }
+    const answer = await client.acquire({
+      agent_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({
+      agent_id: record.agent_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.agent_id;
+      try {
+        void client.retire({ agent_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 createContextWriter(input) {
+  const { store, client, scheduler, recordName, publisher } = input;
+  let record = loadRecord();
+  let desired;
+  let desiredMarker;
+  let running = false;
+  let again = false;
+  let recovering = false;
+  let stopped = false;
+  let fenced = false;
+  let pump;
+  function blank(agentId) {
+    return {
+      version: RADAR_PUBLICATION_VERSION,
+      agent_id: agentId,
+      publisher,
+      sequence: 0
+    };
+  }
+  function loadRecord() {
+    const value = store.read(recordName);
+    const agentId = textAt(value, "agent_id");
+    const storedPublisher = recordAt2(value, "publisher");
+    if (numberAt2(value, "version") !== RADAR_PUBLICATION_VERSION || agentId === void 0 || !isUuid(agentId) && agentId !== "" || textAt(storedPublisher, "source") !== publisher.source || textAt(storedPublisher, "incarnation") !== publisher.incarnation || textAt(storedPublisher, "reporting_owner") !== publisher.reporting_owner)
+      return blank("");
+    const writer = recordAt2(value, "writer");
+    const handle = textAt(writer, "handle");
+    const generation = numberAt2(writer, "generation");
+    if (writer !== void 0 && (!exactKeys(writer, WRITER_KEYS) || !isUuid(handle) || generation === void 0))
+      return blank(agentId);
+    const pending = contextReportAt(
+      recordAt2(value, "pending"),
+      CONTEXT_PENDING_KEYS,
+      CONTEXT_PENDING_MARKED_KEYS
+    );
+    const acceptedValue = recordAt2(value, "accepted");
+    const accepted = contextReportAt(
+      acceptedValue,
+      CONTEXT_ACCEPTED_KEYS,
+      CONTEXT_ACCEPTED_MARKED_KEYS
+    );
+    const sentAt = numberAt2(acceptedValue, "sent_at");
+    return {
+      version: RADAR_PUBLICATION_VERSION,
+      agent_id: agentId,
+      publisher,
+      ...handle !== void 0 && generation !== void 0 ? { writer: { handle, generation } } : {},
+      sequence: numberAt2(value, "sequence") ?? 0,
+      ...pending !== void 0 ? { pending } : {},
+      ...accepted !== void 0 && sentAt !== void 0 ? { accepted: { ...accepted, sent_at: sentAt } } : {},
+      ...textAt(value, "diagnostic") !== void 0 ? { diagnostic: textAt(value, "diagnostic") } : {}
+    };
+  }
+  function note(message) {
+    if (record.diagnostic !== void 0) return;
+    record.diagnostic = message.slice(0, 256);
+    save();
+  }
+  function save() {
+    store.write(recordName, record);
+  }
+  function fence(message) {
+    fenced = true;
+    stopPump();
+    note(`context stopped: ${message}`);
+  }
+  function startPump() {
+    if (pump !== void 0 || stopped || fenced) return;
+    pump = scheduler.setInterval(() => kick(), input.heartbeatMs);
+    pump.unref?.();
+  }
+  function stopPump() {
+    if (pump === void 0) return;
+    scheduler.clearInterval(pump);
+    pump = void 0;
+  }
+  async function ensureSubject() {
+    if (record.writer !== void 0) return true;
+    const agentId = await input.subject(recovering);
+    if (agentId === void 0) return false;
+    if (record.agent_id !== agentId) {
+      record = blank(agentId);
+      save();
+    }
+    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;
+    const answer = await client.context({
+      agent_id: record.agent_id,
+      publisher,
+      // A first publish presents no handle: the daemon binds the writer the
+      // publisher already is, which is the binding this writer then keeps.
+      ...writer !== void 0 ? { writer_handle: writer.handle } : {},
+      sequence: pending.sequence,
+      lease_ms: pending.lease_ms,
+      observed_at: pending.observed_at,
+      context: {
+        session: pending.session,
+        ...pending.launch_identity !== void 0 ? { launch_identity: pending.launch_identity } : {}
+      }
+    });
+    if (answer.ok === true) {
+      recovering = false;
+      record.writer = {
+        handle: answer.value.writer.handle,
+        generation: answer.value.writer.generation
+      };
+      record.sequence = Math.max(record.sequence, answer.value.writer.sequence);
+      record.accepted = {
+        ...pending,
+        sent_at: answer.value.warning === void 0 ? scheduler.now() : record.accepted?.sent_at ?? scheduler.now()
+      };
+      record.pending = void 0;
+      save();
+      return;
+    }
+    if (answer.code === "refused" || answer.code === "bad_params" || // A daemon that speaks the registry but does not serve this record would
+    // refuse every retry the same way; one diagnostic beats a silent retry
+    // loop once per heartbeat.
+    answer.code === "unknown_method") {
+      fence(answer.message);
+      return;
+    }
+    if (answer.code === "not_found") {
+      record = blank("");
+      recovering = true;
+      save();
+      return;
+    }
+  }
+  async function stage(session, launchIdentity) {
+    const pending = {
+      sequence: record.sequence + 1,
+      session,
+      lease_ms: input.leaseMs,
+      observed_at: new Date(scheduler.now()).toISOString(),
+      ...launchIdentity !== void 0 ? { launch_identity: launchIdentity } : {}
+    };
+    record.pending = pending;
+    save();
+    await send(pending);
+  }
+  async function drainOnce() {
+    if (fenced) return;
+    if (record.pending !== void 0) {
+      await send(record.pending);
+      return;
+    }
+    if (desired === void 0) return;
+    if (!await ensureSubject()) return;
+    if (fenced) return;
+    if (record.writer === void 0 || record.accepted === void 0 || record.accepted.session !== desired || !sameLaunchIdentity(record.accepted.launch_identity, desiredMarker)) {
+      await stage(desired, desiredMarker);
+      return;
+    }
+    if (heartbeatDue()) await stage(record.accepted.session, desiredMarker);
+  }
+  async function drain() {
+    if (running || stopped || fenced) return;
+    running = true;
+    try {
+      await drainOnce();
+    } catch (error) {
+      fenced = true;
+      stopPump();
+      try {
+        note(`context storage failure: ${String(error).slice(0, 180)}`);
+      } catch {
+      }
+    } finally {
+      running = false;
+      if (again && !stopped && !fenced) {
+        again = false;
+        kick();
+      }
+    }
+  }
+  function kick() {
+    if (stopped || fenced) return;
+    startPump();
+    if (running) {
+      again = true;
+      return;
+    }
+    void drain().catch(() => void 0);
+  }
+  return {
+    update(session, launchIdentity) {
+      if (fenced || session === desired && sameLaunchIdentity(desiredMarker, launchIdentity))
+        return;
+      desired = session;
+      desiredMarker = launchIdentity;
+      if (stopped) return;
+      kick();
+    },
+    stop() {
+      stopped = true;
+      stopPump();
+    },
+    reopen() {
+      stopped = false;
+      if (desired !== void 0 || record.pending !== void 0) kick();
+    },
+    diagnostic: () => record.diagnostic
+  };
+}
+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 createRadarPublication(options) {
+  try {
+    return createRadarPublicationInner(options);
+  } catch (error) {
+    return unavailablePublication(error);
+  }
+}
+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,
+    context: {
+      update: () => void 0,
+      stop: () => void 0,
+      reopen: () => 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
+  };
+}
+function createRadarPublicationInner(options) {
+  const dataRoot = options.dataRoot;
+  const store = options.store ?? createPublicationStore(dataRoot);
+  const scheduler = options.scheduler ?? systemScheduler;
+  const client = options.client;
+  const spawnToken = options.spawnToken;
+  const slot = options.slot ?? radarProcessSlot();
+  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 subjectName = `subjects/${createHash("sha256").update(`${options.registration.source}\0${incarnation}`).digest("hex").slice(0, 32)}.json`;
+  const channelRecord = (channel, target) => `channels/${createHash("sha256").update(`${channel}\0${incarnation}\0${target ?? ""}`).digest("hex").slice(0, 32)}.json`;
+  const contextRecord = `context/${createHash("sha256").update(`context\0${incarnation}`).digest("hex").slice(0, 32)}.json`;
+  function readSubject() {
+    const value = store.read(subjectName);
+    const registration = recordAt2(value, "registration");
+    if (numberAt2(value, "version") !== RADAR_PUBLICATION_VERSION || textAt(registration, "source") !== options.registration.source || textAt(registration, "incarnation") !== incarnation)
+      return void 0;
+    const storedAgentId = textAt(value, "agent_id");
+    return {
+      version: RADAR_PUBLICATION_VERSION,
+      registration,
+      ...storedAgentId !== void 0 && isUuid(storedAgentId) ? { agent_id: storedAgentId } : {}
+    };
+  }
+  const stored = readSubject();
+  let subject = stored;
+  let registrationDiagnostic;
+  let registrationRecord;
+  async function ensureRegistration() {
+    if (subject !== void 0) return subject;
+    registrationRecord ??= (async () => {
+      const resolution = options.location ? await options.location() : { state: "absent", reason: "this process publishes no location" };
+      if (resolution.state === "pending") {
+        registrationDiagnostic = `location bootstrap pending: ${resolution.reason}`.slice(0, 256);
+        return void 0;
+      }
+      const built = {
+        version: RADAR_PUBLICATION_VERSION,
+        registration: {
+          ...options.registration,
+          ...resolution.state === "resolved" ? { location: resolution.location } : {},
+          incarnation,
+          ...options.birth !== void 0 ? { process: options.birth } : {}
+        }
+      };
+      try {
+        store.write(subjectName, built);
+      } catch (error) {
+        registrationDiagnostic ??= `private storage unavailable: ${String(error)}`.slice(0, 256);
+        return void 0;
+      }
+      registrationDiagnostic = void 0;
+      subject = built;
+      return built;
+    })();
+    try {
+      return await registrationRecord;
+    } finally {
+      registrationRecord = void 0;
+    }
+  }
+  let agentId = stored?.agent_id;
+  let subjectReady;
+  async function ensureSubject(recheck) {
+    if (recheck) agentId = void 0;
+    if (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 answer = await client.register({
+        ...record.registration,
+        ...spawnToken !== void 0 ? { spawn_token: spawnToken } : {}
+      });
+      if (answer.ok === false) {
+        if (answer.code !== "absent" && answer.code !== "timeout" && answer.code !== "transport")
+          registrationDiagnostic ??= `subject registration refused: ${answer.message}`.slice(0, 256);
+        return void 0;
+      }
+      agentId = answer.value.agent_id;
+      subject = { ...record, agent_id: agentId };
+      store.write(subjectName, subject);
+      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,
+      agent_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 context = createContextWriter({
+    store,
+    client,
+    scheduler,
+    recordName: contextRecord,
+    publisher: publisher("herdsman-pi"),
+    subject: ensureSubject,
+    leaseMs: options.leaseMs ?? RADAR_LEASE_MS,
+    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,
+    context,
+    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
+          // agent_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, "agent_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,
+        agent_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 location = record.registration.location;
+      return {
+        agent_id: agentId2,
+        ...location !== void 0 ? { location } : {}
+      };
+    },
+    diagnostic: () => registrationDiagnostic ?? execution.diagnostic() ?? context.diagnostic() ?? facts.diagnostic(),
+    stop() {
+      for (const writer of assignmentWriters.values()) writer.stop();
+      execution.stop();
+      context.stop();
+      facts.stop();
+    },
+    reopen() {
+      for (const writer of assignmentWriters.values()) writer.reopen();
+      execution.reopen();
+      context.reopen();
+      facts.reopen();
+    }
+  };
+  slot.publications.set(cacheKey, publication);
+  return publication;
+}
+
+// extension/radar-execution.ts
+var RADAR_SUBJECT_SOURCE = "herdsman-pi";
+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 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 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 },
+    context: {
+      update: () => void 0,
+      stop: () => void 0,
+      reopen: () => 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 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 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.spawnToken !== void 0 ? { spawnToken: options.spawnToken } : {}
+    });
+  } 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 reportSession(context, launchIdentity) {
+    const session = context?.sessionManager?.getSessionId?.();
+    if (!isUuid(session)) return;
+    try {
+      publication.context.update(session, launchIdentity);
+    } catch {
+    }
+  }
+  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 {
+    }
+  }
+  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) => {
+    const sessionHost = {
+      appendEntry: pi.appendEntry ? (customType, data) => pi.appendEntry?.(customType, data) : void 0,
+      sessionManager: context?.sessionManager
+    };
+    let launchIdentity;
+    try {
+      const result = persistRadarLaunchMarker(
+        sessionHost,
+        options.markerEnvironment
+      );
+      if (result === "written" || result === "unchanged") {
+        const expected = radarLaunchMarkerFromEnvironment(options.markerEnvironment);
+        const activeMarker = activeRadarLaunchMarker(sessionHost);
+        if (expected && activeMarker.status === "valid" && JSON.stringify(activeMarker.marker) === JSON.stringify(expected)) {
+          launchIdentity = activeMarker.marker;
+        } else {
+          options.diagnostic?.("Radar launch marker was not visible on the active Pi session branch");
+        }
+      } else if (result === "unsupported") {
+        options.diagnostic?.("Pi host does not support Radar launch identity session entries");
+      } else if (options.markerEnvironment && [
+        "PI_RADAR_MANAGED_SUBJECT_ID",
+        "PI_RADAR_MANAGED_LAUNCH_ID",
+        "PI_RADAR_MANAGED_EXECUTION_GENERATION"
+      ].some((key) => options.markerEnvironment?.[key] !== void 0)) {
+        options.diagnostic?.("incomplete or invalid Radar launch identity environment");
+      }
+    } catch (error) {
+      options.diagnostic?.(`could not persist Radar launch marker: ${String(error)}`);
+    }
+    rootSession = true;
+    reportSession(context, launchIdentity);
+    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", () => {
+    suspend();
+  });
+  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-location.ts
+import { basename } from "node:path";
+function radarLocalPane(env) {
+  const pane = env.TMUX_PANE?.trim();
+  return pane && /^%\d+$/.test(pane) ? pane : void 0;
+}
+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 {
+    state: "resolved",
+    location: {
+      backend,
+      ...instance !== void 0 ? { instance } : {},
+      workspace: row.workspace_id,
+      tab: row.tab_id,
+      pane: paneId
+    }
+  };
+}
+
+// extension/radar-runtime.ts
+var RADAR_RUNTIME_REQUEST = "pi-radar/runtime-request";
+var RADAR_RUNTIME_VERSION = 1;
+function lazyRadarRuntime(start) {
+  let pending;
+  return {
+    version: RADAR_RUNTIME_VERSION,
+    start: () => pending ??= Promise.resolve().then(start)
+  };
+}
+function provideRadarRuntime(events, handle) {
+  return events.on(RADAR_RUNTIME_REQUEST, (value) => {
+    if (!isRuntimeRequest(value)) return;
+    value.provide(handle);
+  });
+}
+function isRuntimeRequest(value) {
+  return typeof value === "object" && value !== null && value.version === RADAR_RUNTIME_VERSION && typeof value.provide === "function";
+}
+
+// extension/baseline.ts
+function registerPiRadar(pi) {
+  const client = createRadarClient();
+  const execution = createRadarExecutionAdapter(pi, {
+    client,
+    dataRoot: join3(homedir(), ".pi", "agent", "pi-radar"),
+    location: () => resolveRadarProcessLocation(client)
+  });
+  const runtime = lazyRadarRuntime(async () => ({
+    publication: execution.publication,
+    execution
+  }));
+  provideRadarRuntime(pi.events, runtime);
+}
+export {
+  registerPiRadar as default
+};