pi-radar 0.3.0 → 0.4.0

package/dist/extension/radar-execution.js

@@ -110,77 +110,7 @@ import {
   writeSync
 } from "node:fs";
 import { dirname, join, parse, resolve, sep } from "node:path";
-
-// extension/radar-session-marker.ts
-var RADAR_LAUNCH_MARKER_TYPE = "pi-radar.launch-identity";
-var RADAR_LAUNCH_MARKER_VERSION = 1;
-var RADAR_MAX_EXECUTION_GENERATION = 4294967295;
-var RADAR_MANAGED_SUBJECT_ENV = "PI_RADAR_MANAGED_SUBJECT_ID";
-var RADAR_MANAGED_LAUNCH_ENV = "PI_RADAR_MANAGED_LAUNCH_ID";
-var RADAR_MANAGED_GENERATION_ENV = "PI_RADAR_MANAGED_EXECUTION_GENERATION";
-var UUID2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
-function decodeRadarLaunchMarker(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-  const record = value;
-  if (Object.keys(record).sort().join(",") !== "execution_generation,launch_id,subject_id,version") {
-    return void 0;
-  }
-  if (record.version !== RADAR_LAUNCH_MARKER_VERSION || typeof record.subject_id !== "string" || !UUID2.test(record.subject_id) || typeof record.launch_id !== "string" || !UUID2.test(record.launch_id) || !Number.isSafeInteger(record.execution_generation) || record.execution_generation < 1 || record.execution_generation > RADAR_MAX_EXECUTION_GENERATION) {
-    return void 0;
-  }
-  return {
-    version: RADAR_LAUNCH_MARKER_VERSION,
-    subject_id: record.subject_id,
-    launch_id: record.launch_id,
-    execution_generation: record.execution_generation
-  };
-}
-function appendRadarLaunchMarker(appendEntry, marker) {
-  const validated = decodeRadarLaunchMarker(marker);
-  if (!validated) throw new Error("invalid Radar launch identity marker");
-  appendEntry(RADAR_LAUNCH_MARKER_TYPE, validated);
-}
-function latestRadarLaunchMarker(branch) {
-  let latest;
-  for (const entry of branch) {
-    if (entry.type === "custom" && entry.customType === RADAR_LAUNCH_MARKER_TYPE) {
-      latest = entry;
-    }
-  }
-  if (!latest) return { status: "absent" };
-  const marker = decodeRadarLaunchMarker(latest.data);
-  return marker ? { status: "valid", marker } : { status: "invalid" };
-}
-function radarLaunchMarkerFromEnvironment(env = process.env) {
-  const rawGeneration = env[RADAR_MANAGED_GENERATION_ENV];
-  if (env[RADAR_MANAGED_SUBJECT_ENV] === void 0 || env[RADAR_MANAGED_LAUNCH_ENV] === void 0 || rawGeneration === void 0 || !/^[1-9][0-9]*$/.test(rawGeneration)) {
-    return void 0;
-  }
-  return decodeRadarLaunchMarker({
-    version: RADAR_LAUNCH_MARKER_VERSION,
-    subject_id: env[RADAR_MANAGED_SUBJECT_ENV],
-    launch_id: env[RADAR_MANAGED_LAUNCH_ENV],
-    execution_generation: Number(rawGeneration)
-  });
-}
-function activeRadarLaunchMarker(host) {
-  if (!host.sessionManager) return { status: "absent" };
-  return latestRadarLaunchMarker(host.sessionManager.getBranch());
-}
-function persistRadarLaunchMarker(host, env = process.env) {
-  const marker = radarLaunchMarkerFromEnvironment(env);
-  if (!marker) return "absent";
-  if (!host.appendEntry || !host.sessionManager) return "unsupported";
-  const current = latestRadarLaunchMarker(host.sessionManager.getBranch());
-  if (current.status === "valid" && sameMarker(current.marker, marker)) return "unchanged";
-  appendRadarLaunchMarker(host.appendEntry, marker);
-  return "written";
-}
-function sameMarker(a, b) {
-  return a.version === b.version && a.subject_id === b.subject_id && a.launch_id === b.launch_id && a.execution_generation === b.execution_generation;
-}
-
-// extension/radar-publication.ts
+var DUPLICATE_SESSION_DIAGNOSTIC = "Radar rejected this session claim as a duplicate; reload or resume the session before retrying";
 var RADAR_PUBLICATION_VERSION = 1;
 var RADAR_LEASE_MS = 3e4;
 var RADAR_HEARTBEAT_MS = 15e3;
@@ -205,7 +135,7 @@ function readProcessBirth() {
     return void 0;
   }
 }
-var RECORD_NAME = /^(?:subjects|channels|context|bindings)\/[a-z0-9-]{1,64}\.json$/;
+var RECORD_NAME = /^(?:registrations|presence|subjects|channels|context|bindings)\/[a-z0-9-]{1,64}\.json$/;
 var MAX_RECORD_BYTES = 64 * 1024;
 var PRIVATE_MODE = 448;
 var RECORD_MODE = 384;
@@ -487,39 +417,6 @@ function pendingAt(value, keys = PENDING_KEYS, codec = executionCodec) {
     return void 0;
   return { sequence, snapshot, lease_ms: lease, observed_at: observed };
 }
-var CONTEXT_PENDING_KEYS = "lease_ms,observed_at,sequence,session";
-var CONTEXT_PENDING_MARKED_KEYS = "launch_identity,lease_ms,observed_at,sequence,session";
-var CONTEXT_ACCEPTED_KEYS = "lease_ms,observed_at,sent_at,sequence,session";
-var CONTEXT_ACCEPTED_MARKED_KEYS = "launch_identity,lease_ms,observed_at,sent_at,sequence,session";
-function sessionAt(value) {
-  if (typeof value !== "object" || value === null) return void 0;
-  const found = value.session;
-  if (found === null) return null;
-  return typeof found === "string" ? found : void 0;
-}
-function sameLaunchIdentity(a, b) {
-  return a === b || a !== void 0 && b !== void 0 && a.version === b.version && a.subject_id === b.subject_id && a.launch_id === b.launch_id && a.execution_generation === b.execution_generation;
-}
-function contextReportAt(value, keys, markedKeys) {
-  const marked = exactKeys(value, markedKeys);
-  if (!exactKeys(value, keys) && !marked) return void 0;
-  const sequence = numberAt(value, "sequence");
-  const lease = numberAt(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;
@@ -535,7 +432,7 @@ function createChannelWriter(input) {
   function blank(agentId) {
     return {
       version: RADAR_PUBLICATION_VERSION,
-      agent_id: agentId,
+      registration_id: agentId,
       channel,
       publisher,
       sequence: 0
@@ -543,7 +440,7 @@ function createChannelWriter(input) {
   }
   function loadRecord() {
     const value = store.read(recordName);
-    const agentId = textAt(value, "agent_id");
+    const agentId = textAt(value, "registration_id");
     const storedPublisher = recordAt(value, "publisher");
     if (numberAt(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("");
@@ -558,7 +455,7 @@ function createChannelWriter(input) {
     const sentAt = numberAt(acceptedValue, "sent_at");
     return {
       version: RADAR_PUBLICATION_VERSION,
-      agent_id: agentId,
+      registration_id: agentId,
       channel,
       publisher,
       ...handle !== void 0 && generation !== void 0 ? { writer: { handle, generation } } : {},
@@ -599,12 +496,12 @@ function createChannelWriter(input) {
     if (record.writer !== void 0) return true;
     const agentId = await input.subject(recovering);
     if (agentId === void 0) return false;
-    if (record.agent_id !== agentId) {
+    if (record.registration_id !== agentId) {
       record = blank(agentId);
       save();
     }
     const answer = await client.acquire({
-      agent_id: agentId,
+      registration_id: agentId,
       channel,
       publisher
     });
@@ -634,7 +531,7 @@ function createChannelWriter(input) {
     const writer = record.writer;
     if (writer === void 0) return;
     const answer = await client.publish({
-      agent_id: record.agent_id,
+      registration_id: record.registration_id,
       channel,
       writer_handle: writer.handle,
       sequence: pending.sequence,
@@ -728,9 +625,9 @@ function createChannelWriter(input) {
       stopPump();
       const writer = record.writer;
       if (writer === void 0) return;
-      const agentId = record.agent_id;
+      const agentId = record.registration_id;
       try {
-        void client.retire({ agent_id: agentId, channel, writer_handle: writer.handle }).then((answer) => {
+        void client.retire({ registration_id: agentId, channel, writer_handle: writer.handle }).then((answer) => {
           if (answer.ok === true) {
             try {
               record.retired_at = new Date(scheduler.now()).toISOString();
@@ -753,214 +650,127 @@ function createChannelWriter(input) {
     diagnostic: () => record.diagnostic
   };
 }
-function createContextWriter(input) {
-  const { store, client, scheduler, recordName, publisher } = input;
-  let record = loadRecord();
-  let desired;
-  let desiredMarker;
-  let running = false;
-  let again = false;
-  let recovering = false;
-  let stopped = false;
-  let fenced = false;
-  let pump;
-  function blank(agentId) {
-    return {
-      version: RADAR_PUBLICATION_VERSION,
-      agent_id: agentId,
-      publisher,
-      sequence: 0
-    };
-  }
-  function loadRecord() {
-    const value = store.read(recordName);
-    const agentId = textAt(value, "agent_id");
-    const storedPublisher = recordAt(value, "publisher");
-    if (numberAt(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 = recordAt(value, "writer");
-    const handle = textAt(writer, "handle");
-    const generation = numberAt(writer, "generation");
-    if (writer !== void 0 && (!exactKeys(writer, WRITER_KEYS) || !isUuid(handle) || generation === void 0))
-      return blank(agentId);
-    const pending = contextReportAt(
-      recordAt(value, "pending"),
-      CONTEXT_PENDING_KEYS,
-      CONTEXT_PENDING_MARKED_KEYS
-    );
-    const acceptedValue = recordAt(value, "accepted");
-    const accepted = contextReportAt(
-      acceptedValue,
-      CONTEXT_ACCEPTED_KEYS,
-      CONTEXT_ACCEPTED_MARKED_KEYS
-    );
-    const sentAt = numberAt(acceptedValue, "sent_at");
-    return {
-      version: RADAR_PUBLICATION_VERSION,
-      agent_id: agentId,
-      publisher,
-      ...handle !== void 0 && generation !== void 0 ? { writer: { handle, generation } } : {},
-      sequence: numberAt(value, "sequence") ?? 0,
-      ...pending !== void 0 ? { pending } : {},
-      ...accepted !== void 0 && sentAt !== void 0 ? { accepted: { ...accepted, sent_at: sentAt } } : {},
-      ...textAt(value, "diagnostic") !== void 0 ? { diagnostic: textAt(value, "diagnostic") } : {}
-    };
-  }
-  function note(message) {
-    if (record.diagnostic !== void 0) return;
-    record.diagnostic = message.slice(0, 256);
-    save();
+function createPresenceReporter(input) {
+  const { store, client, scheduler, recordName } = input;
+  let state;
+  let standing;
+  let diagnostic;
+  try {
+    const saved = store.read(recordName);
+    if (saved?.version === 2 && isUuid(saved.claim_id) && isUuid(saved.session) && Array.isArray(saved.releases))
+      state = saved;
+  } catch (error) {
+    diagnostic = `presence storage unavailable: ${String(error)}`;
   }
+  let timer;
+  let stopped = false;
+  let running;
   function save() {
-    store.write(recordName, record);
-  }
-  function fence(message) {
-    fenced = true;
-    stopPump();
-    note(`context stopped: ${message}`);
-  }
-  function startPump() {
-    if (pump !== void 0 || stopped || fenced) return;
-    pump = scheduler.setInterval(() => kick(), input.heartbeatMs);
-    pump.unref?.();
-  }
-  function stopPump() {
-    if (pump === void 0) return;
-    scheduler.clearInterval(pump);
-    pump = void 0;
+    try {
+      if (state) store.write(recordName, state);
+      return true;
+    } catch (error) {
+      diagnostic = `presence storage unavailable: ${String(error)}`;
+      return false;
+    }
   }
-  async function ensureSubject() {
-    if (record.writer !== void 0) return true;
-    const agentId = await input.subject(recovering);
-    if (agentId === void 0) return false;
-    if (record.agent_id !== agentId) {
-      record = blank(agentId);
+  async function releasePending() {
+    if (!state) return;
+    const registration = await input.registration();
+    if (!registration?.process) return;
+    for (const release of [...state.releases]) {
+      const answer = await client.releasePresence({ ...release, process: registration.process });
+      if (!answer.ok) return;
+      state.releases = state.releases.filter((r) => r.claim_id !== release.claim_id);
       save();
     }
-    return true;
   }
-  function heartbeatDue() {
-    return record.accepted !== void 0 && scheduler.now() - record.accepted.sent_at >= input.heartbeatMs;
+  function schedule() {
+    if (stopped || timer) return;
+    timer = scheduler.setTimeout(() => {
+      timer = void 0;
+      void ensure();
+    }, input.heartbeatMs);
+    timer.unref?.();
   }
-  async function send(pending) {
-    const writer = record.writer;
-    const answer = await client.context({
-      agent_id: record.agent_id,
-      publisher,
-      // A first publish presents no handle: the daemon binds the writer the
-      // publisher already is, which is the binding this writer then keeps.
-      ...writer !== void 0 ? { writer_handle: writer.handle } : {},
-      sequence: pending.sequence,
-      lease_ms: pending.lease_ms,
-      observed_at: pending.observed_at,
-      context: {
-        session: pending.session,
-        ...pending.launch_identity !== void 0 ? { launch_identity: pending.launch_identity } : {}
+  async function ensure() {
+    if (running) return running;
+    if (stopped || !state) return void 0;
+    const claim = state;
+    if (!save()) return void 0;
+    running = (async () => {
+      await releasePending();
+      const registration = await input.registration();
+      if (!registration?.process || state !== claim || stopped) return void 0;
+      const answer = await client.presence({
+        ...registration,
+        process: registration.process,
+        session_id: claim.session,
+        claim_id: claim.claim_id,
+        ...claim.registration_id ? { registration_id: claim.registration_id } : {},
+        ...claim.subject_id ? { subject_id: claim.subject_id } : {}
+      });
+      if (state !== claim) return void 0;
+      if (!answer.ok) {
+        if (!["absent", "timeout", "transport"].includes(answer.code)) diagnostic = answer.message;
+        return void 0;
       }
-    });
-    if (answer.ok === true) {
-      recovering = false;
-      record.writer = {
-        handle: answer.value.writer.handle,
-        generation: answer.value.writer.generation
-      };
-      record.sequence = Math.max(record.sequence, answer.value.writer.sequence);
-      record.accepted = {
-        ...pending,
-        sent_at: answer.value.warning === void 0 ? scheduler.now() : record.accepted?.sent_at ?? scheduler.now()
-      };
-      record.pending = void 0;
-      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;
+      claim.registration_id = answer.value.registration_id;
+      claim.subject_id = answer.value.standing === "granted" ? answer.value.subject_id ?? void 0 : void 0;
+      standing = answer.value.standing === "granted" ? { state: "managed", subject_id: claim.subject_id } : answer.value.standing === "duplicate" ? { state: "duplicate" } : answer.value.standing === "pending" ? { state: "pending" } : { state: "unmanaged" };
+      diagnostic = answer.value.standing === "duplicate" ? DUPLICATE_SESSION_DIAGNOSTIC : void 0;
       save();
-      return;
-    }
-  }
-  async function stage(session, launchIdentity) {
-    const pending = {
-      sequence: record.sequence + 1,
-      session,
-      lease_ms: input.leaseMs,
-      observed_at: new Date(scheduler.now()).toISOString(),
-      ...launchIdentity !== void 0 ? { launch_identity: launchIdentity } : {}
-    };
-    record.pending = pending;
-    save();
-    await send(pending);
-  }
-  async function drainOnce() {
-    if (fenced) return;
-    if (record.pending !== void 0) {
-      await send(record.pending);
-      return;
-    }
-    if (desired === void 0) return;
-    if (!await ensureSubject()) return;
-    if (fenced) return;
-    if (record.writer === void 0 || record.accepted === void 0 || record.accepted.session !== desired || !sameLaunchIdentity(record.accepted.launch_identity, desiredMarker)) {
-      await stage(desired, desiredMarker);
-      return;
-    }
-    if (heartbeatDue()) await stage(record.accepted.session, desiredMarker);
-  }
-  async function drain() {
-    if (running || stopped || fenced) return;
-    running = true;
+      return claim.registration_id;
+    })();
     try {
-      await drainOnce();
+      return await running;
     } catch (error) {
-      fenced = true;
-      stopPump();
-      try {
-        note(`context storage failure: ${String(error).slice(0, 180)}`);
-      } catch {
-      }
+      diagnostic = `presence unavailable: ${String(error)}`;
+      return void 0;
     } finally {
-      running = false;
-      if (again && !stopped && !fenced) {
-        again = false;
-        kick();
-      }
+      running = void 0;
+      if (!stopped && state !== claim) void ensure();
+      else schedule();
     }
   }
-  function kick() {
-    if (stopped || fenced) return;
-    startPump();
-    if (running) {
-      again = true;
-      return;
-    }
-    void drain().catch(() => void 0);
-  }
   return {
-    update(session, launchIdentity) {
-      if (fenced || session === desired && sameLaunchIdentity(desiredMarker, launchIdentity))
-        return;
-      desired = session;
-      desiredMarker = launchIdentity;
-      if (stopped) return;
-      kick();
+    report(session) {
+      const releases = [...state?.releases ?? []];
+      if (state?.registration_id && !releases.some((release) => release.claim_id === state.claim_id)) {
+        releases.push({ registration_id: state.registration_id, claim_id: state.claim_id });
+      }
+      standing = void 0;
+      state = { version: 2, session, claim_id: randomUUID(), releases };
+      save();
+      stopped = false;
+      void ensure();
+    },
+    ensure,
+    async release() {
+      const releasing = state;
+      standing = void 0;
+      stopped = true;
+      if (timer) scheduler.clearTimeout(timer);
+      timer = void 0;
+      if (running) await running;
+      if (state === releasing) standing = void 0;
+      if (releasing?.registration_id && !releasing.releases.some((r) => r.claim_id === releasing.claim_id)) {
+        releasing.releases.push({ registration_id: releasing.registration_id, claim_id: releasing.claim_id });
+        if (!save()) return;
+      }
+      await releasePending();
     },
     stop() {
       stopped = true;
-      stopPump();
+      if (timer) scheduler.clearTimeout(timer);
+      timer = void 0;
     },
     reopen() {
       stopped = false;
-      if (desired !== void 0 || record.pending !== void 0) kick();
+      void ensure();
     },
-    diagnostic: () => record.diagnostic
+    management: () => standing,
+    diagnostic: () => diagnostic
   };
 }
 var STORE_IDENTITY = /* @__PURE__ */ new WeakMap();
@@ -989,10 +799,13 @@ function unavailablePublication(error) {
   };
   return {
     execution: writer,
-    context: {
-      update: () => void 0,
+    presence: {
+      report: () => void 0,
+      ensure: async () => void 0,
+      release: async () => void 0,
       stop: () => void 0,
       reopen: () => void 0,
+      management: () => void 0,
       diagnostic: () => diagnostic
     },
     facts: { ...writer, update: () => void 0 },
@@ -1019,33 +832,29 @@ function createRadarPublicationInner(options) {
     cached.reopen();
     return cached;
   }
-  const subjectName = `subjects/${createHash("sha256").update(`${options.registration.source}\0${incarnation}`).digest("hex").slice(0, 32)}.json`;
+  const registrationName = `registrations/${createHash("sha256").update(`${options.registration.source}\0${incarnation}`).digest("hex").slice(0, 32)}.json`;
   const channelRecord = (channel, target) => `channels/${createHash("sha256").update(`${channel}\0${incarnation}\0${target ?? ""}`).digest("hex").slice(0, 32)}.json`;
-  const contextRecord = `context/${createHash("sha256").update(`context\0${incarnation}`).digest("hex").slice(0, 32)}.json`;
-  function readSubject() {
-    const value = store.read(subjectName);
+  const presenceRecord = `presence/${createHash("sha256").update(`presence\0${incarnation}`).digest("hex").slice(0, 32)}.json`;
+  function readRegistration() {
+    const value = store.read(registrationName);
     const registration = recordAt(value, "registration");
     if (numberAt(value, "version") !== RADAR_PUBLICATION_VERSION || textAt(registration, "source") !== options.registration.source || textAt(registration, "incarnation") !== incarnation)
       return void 0;
-    const storedAgentId = textAt(value, "agent_id");
+    const storedAgentId = textAt(value, "registration_id");
     return {
       version: RADAR_PUBLICATION_VERSION,
       registration,
-      ...storedAgentId !== void 0 && isUuid(storedAgentId) ? { agent_id: storedAgentId } : {}
+      ...storedAgentId !== void 0 && isUuid(storedAgentId) ? { registration_id: storedAgentId } : {}
     };
   }
-  const stored = readSubject();
-  let subject = stored;
+  const stored = readRegistration();
+  let processRecord = stored;
   let registrationDiagnostic;
   let registrationRecord;
   async function ensureRegistration() {
-    if (subject !== void 0) return subject;
+    if (processRecord !== void 0) return processRecord;
     registrationRecord ??= (async () => {
       const resolution = options.location ? await options.location() : { state: "absent", reason: "this process publishes no location" };
-      if (resolution.state === "pending") {
-        registrationDiagnostic = `location bootstrap pending: ${resolution.reason}`.slice(0, 256);
-        return void 0;
-      }
       const built = {
         version: RADAR_PUBLICATION_VERSION,
         registration: {
@@ -1056,13 +865,13 @@ function createRadarPublicationInner(options) {
         }
       };
       try {
-        store.write(subjectName, built);
+        store.write(registrationName, built);
       } catch (error) {
         registrationDiagnostic ??= `private storage unavailable: ${String(error)}`.slice(0, 256);
         return void 0;
       }
       registrationDiagnostic = void 0;
-      subject = built;
+      processRecord = built;
       return built;
     })();
     try {
@@ -1071,11 +880,10 @@ function createRadarPublicationInner(options) {
       registrationRecord = void 0;
     }
   }
-  let agentId = stored?.agent_id;
+  let agentId = stored?.registration_id;
   let subjectReady;
   async function ensureSubject(recheck) {
-    if (recheck) agentId = void 0;
-    if (agentId !== void 0) return agentId;
+    if (!recheck && agentId !== void 0) return agentId;
     subjectReady ??= (async () => {
       const ready = await client.ping();
       if (ready.ok === false) {
@@ -1085,18 +893,11 @@ function createRadarPublicationInner(options) {
       }
       const record = await ensureRegistration();
       if (record === void 0) return void 0;
-      const answer = await client.register({
-        ...record.registration,
-        ...spawnToken !== void 0 ? { spawn_token: spawnToken } : {}
-      });
-      if (answer.ok === false) {
-        if (answer.code !== "absent" && answer.code !== "timeout" && answer.code !== "transport")
-          registrationDiagnostic ??= `subject registration refused: ${answer.message}`.slice(0, 256);
-        return void 0;
-      }
-      agentId = answer.value.agent_id;
-      subject = { ...record, agent_id: agentId };
-      store.write(subjectName, subject);
+      const registered = await presence.ensure();
+      if (registered === void 0) return void 0;
+      agentId = registered;
+      processRecord = { ...record, registration_id: agentId };
+      store.write(registrationName, processRecord);
       if (options.binding !== void 0) writeBinding(options.binding);
       return agentId;
     })();
@@ -1110,7 +911,7 @@ function createRadarPublicationInner(options) {
     if (agentId === void 0) return;
     store.write(`bindings/${binding.key}.json`, {
       version: RADAR_PUBLICATION_VERSION,
-      agent_id: agentId,
+      registration_id: agentId,
       incarnation,
       run: binding.run,
       owner: binding.owner,
@@ -1134,14 +935,22 @@ function createRadarPublicationInner(options) {
     leaseMs: options.leaseMs ?? RADAR_LEASE_MS,
     heartbeatMs: options.heartbeatMs ?? RADAR_HEARTBEAT_MS
   });
-  const context = createContextWriter({
+  const presence = createPresenceReporter({
     store,
     client,
     scheduler,
-    recordName: contextRecord,
-    publisher: publisher("herdsman-pi"),
-    subject: ensureSubject,
-    leaseMs: options.leaseMs ?? RADAR_LEASE_MS,
+    recordName: presenceRecord,
+    registration: async () => {
+      const record = await ensureRegistration();
+      if (!record) return void 0;
+      const location = await options.location?.();
+      const { location: _initialLocation, ...identity } = record.registration;
+      return {
+        ...identity,
+        ...location?.state === "resolved" ? { location: location.location } : {},
+        ...spawnToken ? { spawn_token: spawnToken } : {}
+      };
+    },
     heartbeatMs: options.heartbeatMs ?? RADAR_HEARTBEAT_MS
   });
   const facts = createChannelWriter({
@@ -1159,7 +968,7 @@ function createRadarPublicationInner(options) {
   const assignmentWriters = /* @__PURE__ */ new Map();
   const publication = {
     execution,
-    context,
+    presence,
     facts,
     assignment(target, reportingOwner) {
       const existing = assignmentWriters.get(target);
@@ -1174,7 +983,7 @@ function createRadarPublicationInner(options) {
           publisher: publisher("herdsman-owner", reportingOwner),
           codec: assignmentCodec,
           // The owner publishes about a subject it did not register: the exact
-          // agent_id from the child's sidecar is the whole correlation.
+          // registration_id from the child's sidecar is the whole correlation.
           subject: async () => target,
           leaseMs: options.leaseMs ?? RADAR_LEASE_MS,
           heartbeatMs: options.heartbeatMs ?? RADAR_HEARTBEAT_MS
@@ -1194,7 +1003,7 @@ function createRadarPublicationInner(options) {
         registrationDiagnostic ??= `Radar binding unavailable: ${String(error).slice(0, 180)}`;
         return void 0;
       }
-      const bound = textAt(value, "agent_id");
+      const bound = textAt(value, "registration_id");
       const boundIncarnation = textAt(value, "incarnation");
       const run = textAt(value, "run");
       const owner = textAt(value, "owner");
@@ -1204,7 +1013,7 @@ function createRadarPublicationInner(options) {
         return void 0;
       return {
         version: RADAR_PUBLICATION_VERSION,
-        agent_id: bound,
+        registration_id: bound,
         incarnation: boundIncarnation,
         run,
         owner,
@@ -1220,25 +1029,27 @@ function createRadarPublicationInner(options) {
       if (agentId2 === void 0) return void 0;
       const record = await ensureRegistration();
       if (record === void 0) return void 0;
-      const location = record.registration.location;
-      const subjectId = process.env.PI_RADAR_MANAGED_SUBJECT_ID;
+      const currentLocation = await options.location?.();
+      const location = currentLocation?.state === "resolved" ? currentLocation.location : void 0;
+      const standing = presence.management();
+      const subjectId = standing?.state === "managed" ? standing.subject_id : void 0;
       return {
-        agent_id: agentId2,
+        registration_id: agentId2,
         ...subjectId !== void 0 ? { subject_id: subjectId } : {},
         ...location !== void 0 ? { location } : {}
       };
     },
-    diagnostic: () => registrationDiagnostic ?? execution.diagnostic() ?? context.diagnostic() ?? facts.diagnostic(),
+    diagnostic: () => registrationDiagnostic ?? execution.diagnostic() ?? presence.diagnostic() ?? facts.diagnostic(),
     stop() {
       for (const writer of assignmentWriters.values()) writer.stop();
       execution.stop();
-      context.stop();
+      presence.stop();
       facts.stop();
     },
     reopen() {
       for (const writer of assignmentWriters.values()) writer.reopen();
       execution.reopen();
-      context.reopen();
+      presence.reopen();
       facts.reopen();
     }
   };
@@ -1276,10 +1087,13 @@ function unavailablePublication2() {
   return {
     execution: writer,
     facts: { ...writer, update: () => void 0 },
-    context: {
-      update: () => void 0,
+    presence: {
+      report: () => void 0,
       stop: () => void 0,
       reopen: () => void 0,
+      management: () => void 0,
+      ensure: async () => void 0,
+      release: async () => void 0,
       diagnostic: () => "Radar private storage is unavailable"
     },
     assignment: () => writer,
@@ -1362,11 +1176,11 @@ function createRadarExecutionAdapter(pi, options) {
       ...lastOutcome !== void 0 ? { last_outcome: lastOutcome } : {}
     };
   }
-  function reportSession(context, launchIdentity) {
+  function reportSession(context) {
     const session = context?.sessionManager?.getSessionId?.();
     if (!isUuid(session)) return;
     try {
-      publication.context.update(session, launchIdentity);
+      publication.presence.report(session);
     } catch {
     }
   }
@@ -1430,38 +1244,8 @@ function createRadarExecutionAdapter(pi, options) {
       })
     );
   on("session_start", (_event, context) => {
-    const sessionHost = {
-      appendEntry: pi.appendEntry ? (customType, data) => pi.appendEntry?.(customType, data) : void 0,
-      sessionManager: context?.sessionManager
-    };
-    let launchIdentity;
-    try {
-      const result = persistRadarLaunchMarker(
-        sessionHost,
-        options.markerEnvironment
-      );
-      if (result === "written" || result === "unchanged") {
-        const expected = radarLaunchMarkerFromEnvironment(options.markerEnvironment);
-        const activeMarker = activeRadarLaunchMarker(sessionHost);
-        if (expected && activeMarker.status === "valid" && JSON.stringify(activeMarker.marker) === JSON.stringify(expected)) {
-          launchIdentity = activeMarker.marker;
-        } else {
-          options.diagnostic?.("Radar launch marker was not visible on the active Pi session branch");
-        }
-      } else if (result === "unsupported") {
-        options.diagnostic?.("Pi host does not support Radar launch identity session entries");
-      } else if (options.markerEnvironment && [
-        "PI_RADAR_MANAGED_SUBJECT_ID",
-        "PI_RADAR_MANAGED_LAUNCH_ID",
-        "PI_RADAR_MANAGED_EXECUTION_GENERATION"
-      ].some((key) => options.markerEnvironment?.[key] !== void 0)) {
-        options.diagnostic?.("incomplete or invalid Radar launch identity environment");
-      }
-    } catch (error) {
-      options.diagnostic?.(`could not persist Radar launch marker: ${String(error)}`);
-    }
     rootSession = true;
-    reportSession(context, launchIdentity);
+    reportSession(context);
     publishFacts(context);
     publication.reopen();
     active = context?.isIdle?.() === false;
@@ -1492,8 +1276,9 @@ function createRadarExecutionAdapter(pi, options) {
     }
     emit();
   });
-  on("session_shutdown", () => {
+  on("session_shutdown", async () => {
     suspend();
+    await publication.presence.release();
   });
   function suspend() {
     if (stopped) return;