@sjawhar/pi-envoy 10.20.0 → 10.22.0

package/dist/dispatch.js

@@ -19342,8 +19342,14 @@ function dispatchSettings(env, config2) {
 
 // ../envoy-client/src/envoy-settings.ts
 var DEFAULT_ENVOY_URL = "http://127.0.0.1:9020";
-var DEFAULT_HEARTBEAT_MS = 120000;
-var MIN_HEARTBEAT_MS = 25;
+var DEFAULT_HEARTBEAT_MS = 90000;
+var MIN_PASS_DEADLINE_MS = 30000;
+var MIN_INTERVAL_MS = 25;
+var MAX_INTERVAL_MS = 2147483647;
+function namedInterval(raw) {
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
 function natsSeedFromEnvironment(env) {
   const { NATS_NKEY_SEED_FILE: file2, NATS_NKEY_SEED: plain } = env;
   if (file2 !== undefined) {
@@ -19430,13 +19436,17 @@ function envoySettings(env, config2, options = {}) {
       inbound = { off: messageFor(error48) };
     }
   }
-  const rawHeartbeatMs = Number(env.ENVOY_HEARTBEAT_MS);
+  const namedHeartbeatMs = namedInterval(env.ENVOY_HEARTBEAT_MS);
+  const heartbeatMs = namedHeartbeatMs === undefined ? DEFAULT_HEARTBEAT_MS : Math.min(Math.max(namedHeartbeatMs, MIN_INTERVAL_MS), MAX_INTERVAL_MS);
+  const namedPassDeadlineMs = namedInterval(env.ENVOY_PASS_DEADLINE_MS);
   return {
     enabled: true,
     url: normalizeEnvoyUrl(url2),
     token,
     inbound,
-    heartbeatMs: Number.isFinite(rawHeartbeatMs) && rawHeartbeatMs > 0 ? Math.max(rawHeartbeatMs, MIN_HEARTBEAT_MS) : DEFAULT_HEARTBEAT_MS
+    heartbeatMs,
+    passDeadlineMs: Math.min(Math.max(namedPassDeadlineMs ?? MIN_PASS_DEADLINE_MS, heartbeatMs), MAX_INTERVAL_MS),
+    passDeadlineRaisedFrom: namedPassDeadlineMs !== undefined && namedPassDeadlineMs < heartbeatMs ? namedPassDeadlineMs : undefined
   };
 }
 function normalizeEnvoyUrl(value) {

package/dist/envoy.js

@@ -33567,29 +33567,16 @@ function writeSessionTitle(dir, title) {
   writeAtomically(join3(dir, "title"), title);
 }
 
-// ../envoy-client/src/nats-auth.ts
-var import_nats = __toESM(require_mod4(), 1);
-var seedKeys = import_nats.nkeys;
-function natsAuthOptions(seed) {
-  if (seed === undefined)
-    return {};
-  const bytes = new TextEncoder().encode(seed.value);
-  let publicKey;
-  try {
-    publicKey = seedKeys.fromSeed(bytes).getPublicKey();
-  } catch (error48) {
-    throw new Error(`${seed.source} does not hold a valid nkey seed: ${messageFor(error48)}`);
-  }
-  if (!publicKey.startsWith("U")) {
-    throw new Error(`${seed.source} holds an nkey seed that is not a user's (public key ${publicKey})`);
-  }
-  return { authenticator: import_nats.nkeyAuthenticator(bytes) };
-}
-
 // ../envoy-client/src/envoy-settings.ts
 var DEFAULT_ENVOY_URL = "http://127.0.0.1:9020";
-var DEFAULT_HEARTBEAT_MS = 120000;
-var MIN_HEARTBEAT_MS = 25;
+var DEFAULT_HEARTBEAT_MS = 90000;
+var MIN_PASS_DEADLINE_MS = 30000;
+var MIN_INTERVAL_MS = 25;
+var MAX_INTERVAL_MS = 2147483647;
+function namedInterval(raw) {
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
 function natsSeedFromEnvironment(env) {
   const { NATS_NKEY_SEED_FILE: file2, NATS_NKEY_SEED: plain } = env;
   if (file2 !== undefined) {
@@ -33676,19 +33663,42 @@ function envoySettings(env, config2, options = {}) {
       inbound = { off: messageFor(error48) };
     }
   }
-  const rawHeartbeatMs = Number(env.ENVOY_HEARTBEAT_MS);
+  const namedHeartbeatMs = namedInterval(env.ENVOY_HEARTBEAT_MS);
+  const heartbeatMs = namedHeartbeatMs === undefined ? DEFAULT_HEARTBEAT_MS : Math.min(Math.max(namedHeartbeatMs, MIN_INTERVAL_MS), MAX_INTERVAL_MS);
+  const namedPassDeadlineMs = namedInterval(env.ENVOY_PASS_DEADLINE_MS);
   return {
     enabled: true,
     url: normalizeEnvoyUrl(url2),
     token,
     inbound,
-    heartbeatMs: Number.isFinite(rawHeartbeatMs) && rawHeartbeatMs > 0 ? Math.max(rawHeartbeatMs, MIN_HEARTBEAT_MS) : DEFAULT_HEARTBEAT_MS
+    heartbeatMs,
+    passDeadlineMs: Math.min(Math.max(namedPassDeadlineMs ?? MIN_PASS_DEADLINE_MS, heartbeatMs), MAX_INTERVAL_MS),
+    passDeadlineRaisedFrom: namedPassDeadlineMs !== undefined && namedPassDeadlineMs < heartbeatMs ? namedPassDeadlineMs : undefined
   };
 }
 function normalizeEnvoyUrl(value) {
   return value.replace(/\/+$/, "");
 }
 
+// ../envoy-client/src/nats-auth.ts
+var import_nats = __toESM(require_mod4(), 1);
+var seedKeys = import_nats.nkeys;
+function natsAuthOptions(seed) {
+  if (seed === undefined)
+    return {};
+  const bytes = new TextEncoder().encode(seed.value);
+  let publicKey;
+  try {
+    publicKey = seedKeys.fromSeed(bytes).getPublicKey();
+  } catch (error48) {
+    throw new Error(`${seed.source} does not hold a valid nkey seed: ${messageFor(error48)}`);
+  }
+  if (!publicKey.startsWith("U")) {
+    throw new Error(`${seed.source} holds an nkey seed that is not a user's (public key ${publicKey})`);
+  }
+  return { authenticator: import_nats.nkeyAuthenticator(bytes) };
+}
+
 // ../envoy-client/src/session-settings.ts
 function sessionConfigFile(harness, env) {
   try {
@@ -33727,6 +33737,9 @@ function startNotice(config2, dispatch, envoy, nats) {
   if (envoy.enabled && nats && "off" in envoy.inbound) {
     parts.push(`Envoy's inbound messages are off: ${envoy.inbound.off}; the Envoy tools still work`);
   }
+  if (envoy.enabled && envoy.passDeadlineRaisedFrom !== undefined) {
+    parts.push(`Envoy's pass deadline is ${envoy.passDeadlineMs} ms, not the ${envoy.passDeadlineRaisedFrom} ms ENVOY_PASS_DEADLINE_MS names: a deadline inside one ${envoy.heartbeatMs} ms heartbeat interval would abandon every pass before the next tick, so the registration refresh the heartbeat posts for a stalled pass would never run`);
+  }
   return parts.length === 0 ? null : parts.join("; ");
 }
 function sessionSettings(file2, env, options) {
@@ -33737,7 +33750,11 @@ function sessionSettings(file2, env, options) {
   const config2 = readEnvoyConfig(file2.path, env, options);
   const dispatch = dispatchSettings(env, config2);
   const envoy = envoySettings(env, config2, { nats: options.nats });
-  return { dispatch, envoy, notice: startNotice(config2, dispatch, envoy, options.nats !== false) };
+  return {
+    dispatch,
+    envoy,
+    notice: startNotice(config2, dispatch, envoy, options.nats !== false)
+  };
 }
 function sessionDispatchSettings(file2, env, options) {
   if (file2.path === null)
@@ -35301,11 +35318,31 @@ import("@oh-my-pi/pi-coding-agent/extensibility/extensions/send-user-input-handl
 var codec2 = import_nats2.StringCodec();
 var NATS_RETRY_INTERVAL_MS = 15000;
 var DELIVERY_PICTURES_TIMEOUT_MS = 20000;
-function serialQueue() {
+var UNFENCED = () => true;
+
+class AbandonedTaskError extends Error {
+}
+function serialQueue(deadlineMs) {
   let tail = Promise.resolve();
   return {
     run(task) {
-      const next = tail.then(task);
+      const next = tail.then(() => new Promise((resolve3, reject) => {
+        let abandoned = false;
+        const taskDeadlineMs = deadlineMs();
+        const timer = setTimeout(() => {
+          abandoned = true;
+          reject(new AbandonedTaskError(`a queued task did not settle within ${taskDeadlineMs}ms and was abandoned; the queue moved on`));
+        }, taskDeadlineMs);
+        (async () => task(() => !abandoned))().then((value) => {
+          clearTimeout(timer);
+          if (!abandoned)
+            resolve3(value);
+        }, (error48) => {
+          clearTimeout(timer);
+          if (!abandoned)
+            reject(error48);
+        });
+      }));
       tail = next.catch(() => {
         return;
       });
@@ -35456,6 +35493,7 @@ function envoyExtension(pi) {
     }
     return active;
   };
+  const passDeadlineMs = () => active?.settings.passDeadlineMs ?? MIN_PASS_DEADLINE_MS;
   const subscriptions = new Map;
   const delivered = createDeliveryDedupe();
   let connection;
@@ -35485,7 +35523,7 @@ function envoyExtension(pi) {
   let roleNoticesFor;
   const roleNoticeSubjects = new Set;
   let roleEnds = 0;
-  const roleMoves = serialQueue();
+  const roleMoves = serialQueue(passDeadlineMs);
   const isRoleBound = (subject2) => roleNoticeSubjects.has(subject2);
   const heldRole = () => claimedRoleTopic?.slice(ROLE_TOPIC_PREFIX.length);
   let activeSessionContext;
@@ -35621,11 +35659,11 @@ function envoyExtension(pi) {
     }
     return inbound2;
   };
-  const ensureConnection = async () => {
+  const ensureConnection = async (live = UNFENCED) => {
     if (connection?.isClosed() === false)
       return connection;
     const { natsUrls, natsSeed } = requireInbound();
-    connection = await import_nats2.connect({
+    const dialled = await import_nats2.connect({
       servers: [...natsUrls],
       name: `omp-${sessionID || "unknown"}`,
       ...natsAuthOptions(natsSeed),
@@ -35633,6 +35671,13 @@ function envoyExtension(pi) {
       maxReconnectAttempts: -1,
       reconnectTimeWait: 2000
     });
+    if (!live() || shuttingDown || connection?.isClosed() === false) {
+      await dialled.close().catch(() => {});
+      if (!shuttingDown && connection?.isClosed() === false)
+        return connection;
+      throw new AbandonedTaskError(shuttingDown ? "the session shut down while its NATS dial was in flight; the connection it opened was closed" : "the pass that dialled NATS was abandoned at its deadline while the dial was in flight; the connection it opened was closed");
+    }
+    connection = dialled;
     return connection;
   };
   const postDispatchReply = async (delivery, result, replySessionID = sessionID) => {
@@ -35868,11 +35913,13 @@ function envoyExtension(pi) {
     };
     retry(RESUBSCRIBE_DELAY_MS);
   };
-  const subscribe = async (topic) => {
+  const subscribe = async (topic, live = UNFENCED) => {
     const subjects = expandSubscriptionTopics([topic]).filter((candidate) => !subscriptions.has(candidate));
     if (subjects.length === 0)
       return false;
-    const activeConnection = await ensureConnection();
+    const activeConnection = await ensureConnection(live);
+    if (!live())
+      return false;
     for (const subject2 of subjects) {
       const subscription = activeConnection.subscribe(subject2);
       intentionallyClosed.delete(subject2);
@@ -35971,7 +36018,7 @@ function envoyExtension(pi) {
       });
     }, RESUBSCRIBE_DELAY_MS);
   };
-  const watchAgentStream = async (session) => {
+  const watchAgentStream = async (session, live = UNFENCED) => {
     if (agentStreamControlSession === session && agentStreamControl !== undefined)
       return;
     agentStreamControl?.unsubscribe();
@@ -35982,8 +36029,10 @@ function envoyExtension(pi) {
       agentStreamCommandsRefreshedOnWatchAt = -Infinity;
     }
     agentStreamControlSession = session;
-    const active2 = await ensureConnection();
-    const subscription = active2.subscribe(agentStreamControlSubject(session));
+    const connected = await ensureConnection(live);
+    if (!live())
+      return;
+    const subscription = connected.subscribe(agentStreamControlSubject(session));
     agentStreamControl = subscription;
     pumpAgentStreamControl(subscription, session);
   };
@@ -36046,12 +36095,15 @@ function envoyExtension(pi) {
       closeIntentionally(subject2);
     return false;
   };
+  let registeredFor = "";
+  let registeredAt = -Infinity;
   const registerSession = () => {
-    for (const [topic, hold] of abandonedHolds) {
+    const registeringFor = sessionID;
+    for (const [key, hold] of abandonedHolds) {
       if (hold.id !== sessionID)
         continue;
-      abandonedHolds.delete(topic);
-      pendingHandBacks.set(`${topic}@${sessionID}`, { topic, id: sessionID });
+      abandonedHolds.delete(key);
+      pendingHandBacks.set(key, { topic: hold.topic, id: sessionID });
     }
     return requireEnvoy().client.subscribe({
       sessionID,
@@ -36067,17 +36119,23 @@ function envoyExtension(pi) {
       capabilities: sideTurn(activeSessionContext) === undefined ? CAPABILITIES_WITHOUT_BTW : DELIVERY_CAPABILITIES,
       driving: false,
       selfSubscribed: true
+    }).then((result) => {
+      registeredFor = registeringFor;
+      registeredAt = Date.now();
+      return result;
     });
   };
-  const reassertRoleNow = async (id, role, afterOutage, context) => {
+  const reassertRoleNow = async (id, role, afterOutage, context, live) => {
     const topic = ROLE_TOPIC_PREFIX + role;
     const { client } = requireEnvoy();
+    const owns = () => live() && sessionOpen(id);
+    const stillHolds = () => claimedRoleTopic === topic;
     const holder = await client.getRole(role).then((info) => info.holder, (error48) => {
       if (error48 instanceof EnvoyApiError && error48.details.status === 404)
         return;
       throw error48;
     });
-    if (claimedRoleTopic !== topic || !sessionOpen(id))
+    if (!owns() || !stillHolds())
       return false;
     let reason;
     if (holder === id) {
@@ -36086,7 +36144,7 @@ function envoyExtension(pi) {
       reason = "reregistered";
     } else {
       const result = await client.setRole({ sessionID: id, role, soft: true });
-      if (claimedRoleTopic !== topic || !sessionOpen(id))
+      if (!owns() || !stillHolds())
         return false;
       if (!result.claimed) {
         endRole();
@@ -36118,23 +36176,48 @@ function envoyExtension(pi) {
     if (heartbeatRegistered)
       return;
     let heartbeatOutageNotified = false;
+    let stallNotified = false;
     let registrationFailed = false;
     let healing = false;
+    const noteStall = (detail) => {
+      if (stallNotified)
+        return;
+      stallNotified = true;
+      logger3.warn("envoy: reconcile pass stalled; registration refreshed on its own", {
+        detail,
+        sessionID: context.sessionManager.getSessionId()
+      });
+      context.ui.notify(`envoy: a reconcile pass has stalled (${detail}); the session registration is being refreshed on its own, and recovers once the pass settles`, "warning");
+    };
     context.setInterval(() => {
       if (context.sessionManager.getSessionId() === "")
         return;
-      if (healing)
+      if (healing) {
+        const refreshMs = requireEnvoy().settings.heartbeatMs;
+        if (registeredFor === sessionID && Date.now() - registeredAt < refreshMs)
+          return;
+        noteStall("a pass has not settled a whole refresh interval after the last accepted registration");
+        registerSession().catch(() => {
+          return;
+        });
         return;
+      }
       healing = true;
       const afterOutage = registrationFailed;
       const settled = (decided) => {
         if (decided)
           registrationFailed = false;
         heartbeatOutageNotified = false;
+        stallNotified = false;
       };
       reconcile(context, { heartbeat: true, afterOutage }).then(settled, (error48) => {
         if (error48 instanceof InboundError)
           return settled(error48.decided);
+        if (error48 instanceof AbandonedTaskError) {
+          registrationFailed = true;
+          noteStall(messageFor(error48));
+          return;
+        }
         if (error48 instanceof RegistrationError)
           registrationFailed = true;
         throw error48 instanceof RegistrationError ? error48.cause : error48;
@@ -36149,12 +36232,12 @@ function envoyExtension(pi) {
     }, requireEnvoy().settings.heartbeatMs);
     heartbeatRegistered = true;
   };
-  const recoverRegisteredInterests = async () => {
+  const recoverRegisteredInterests = async (live) => {
     const { client } = requireEnvoy();
     const registry2 = await client.getInterest(sessionID).catch(() => {
       return;
     });
-    if (registry2 === undefined)
+    if (registry2 === undefined || !live())
       return;
     const retired = publishedInterface?.roleClaim.slackRoleOwned === true ? registry2.topics.filter((topic) => slackTopicChannel(topic) !== undefined) : [];
     if (retired.length > 0) {
@@ -36166,31 +36249,34 @@ function envoyExtension(pi) {
         });
       });
     }
+    if (!live())
+      return;
     for (const topic of registry2.topics) {
       if (topic === agentSubject(sessionID) || topic.startsWith(ROLE_TOPIC_PREFIX))
         continue;
       if (retired.includes(topic))
         continue;
-      await subscribe(topic);
+      await subscribe(topic, live);
     }
   };
-  const observeAbandonedHold = async (topic, role, holder) => {
-    const abandoned = abandonedHolds.get(topic);
-    if (abandoned === undefined || abandoned.id !== holder)
+  const observeAbandonedHold = async (topic, role, holder, live) => {
+    const key = `${topic}@${holder}`;
+    const abandoned = abandonedHolds.get(key);
+    if (abandoned === undefined)
       return false;
     const seen = await requireEnvoy().client.getRole(role).then((info) => info.holder === holder ? info.last_seen : undefined, () => {
       return;
     });
-    if (seen === undefined)
+    if (!live() || seen === undefined)
       return true;
     if (abandoned.lastSeen !== undefined && seen !== abandoned.lastSeen) {
-      abandonedHolds.delete(topic);
+      abandonedHolds.delete(key);
       return false;
     }
-    abandonedHolds.set(topic, { id: abandoned.id, lastSeen: seen });
+    abandonedHolds.set(key, { topic, id: abandoned.id, lastSeen: seen });
     return true;
   };
-  const setEnvoyRole = async (role, forSession, options = {}) => {
+  const setEnvoyRole = async (role, forSession, live, options = {}) => {
     if (!sessionOpen(forSession)) {
       throw new SessionLeftError(`the session moved from ${forSession} to ${hostSessionID()} before its claim of role ${role} ran; nothing was claimed`);
     }
@@ -36205,10 +36291,18 @@ function envoyExtension(pi) {
       soft: options.soft,
       previousSessionID: options.previousSessionID
     });
+    if (!live()) {
+      if (result.claimed)
+        pendingHandBacks.set(`${topic}@${id}`, { topic, id });
+      throw new AbandonedTaskError(`the role move that claimed ${role} for session ${id} was abandoned at its deadline while the claim was in flight; ${result.claimed ? "the hold the listener granted is left for the next pass to hand back" : "nothing was claimed"}`);
+    }
     if (result.claimed) {
       refusedRoles.delete(id);
       holdUnconfirmed = false;
-      abandonedHolds.delete(topic);
+      for (const [key, hold] of abandonedHolds) {
+        if (hold.topic === topic)
+          abandonedHolds.delete(key);
+      }
       for (const [key, hold] of pendingHandBacks) {
         if (hold.topic === topic)
           pendingHandBacks.delete(key);
@@ -36228,10 +36322,11 @@ function envoyExtension(pi) {
     }
     if (!result.claimed) {
       endRole();
-      const waitingOnReap = await observeAbandonedHold(topic, role, result.holder);
-      if (!waitingOnReap)
+      const waitingOnReap = await observeAbandonedHold(topic, role, result.holder, live);
+      const notRecorded = !live() ? "the move was abandoned at its deadline before the refusal was recorded" : sessionOpen(id) ? undefined : `the session moved to ${hostSessionID()} before the refusal was recorded`;
+      if (notRecorded === undefined && !waitingOnReap)
         refusedRoles.set(id, role);
-      logger3.warn(waitingOnReap ? "envoy: role still held by a session this process left; claiming again once the listener reaps it" : "envoy: role held by another live session; not reclaimed", { role, sessionID: id, holder: result.holder });
+      logger3.warn(notRecorded !== undefined ? `envoy: role held by another live session; ${notRecorded}` : waitingOnReap ? "envoy: role still held by a session this process left; claiming again once the listener reaps it" : "envoy: role held by another live session; not reclaimed", { role, sessionID: id, holder: result.holder });
       return false;
     }
     if (previousTopic !== undefined && previousTopic !== topic)
@@ -36340,12 +36435,13 @@ function envoyExtension(pi) {
     knownSessions.add(host3);
   };
   const knownSessions = new Set;
-  const passes = serialQueue();
-  const reconcile = (context, cause = {}) => passes.run(() => reconcileNow(context, cause));
+  const passes = serialQueue(passDeadlineMs);
+  const reconcile = (context, cause = {}) => passes.run((live) => reconcileNow(context, cause, live));
   const agentSessions = new Set;
   let inboundOpenFor = "";
-  const reconcileNow = async (context, cause) => {
+  const reconcileNow = async (context, cause, live) => {
     const host3 = context.sessionManager.getSessionId();
+    const owns = () => live() && sessionOpen(host3);
     noteMove(host3);
     if (sessionID !== host3)
       restoreLocalSessionState(context);
@@ -36375,27 +36471,39 @@ function envoyExtension(pi) {
     if (inbound && inboundOpenFor !== host3) {
       try {
         agentSessions.add(host3);
-        await ensureConnection();
-        await subscribe(agentSubject(host3));
-        await watchAgentStream(host3);
+        await ensureConnection(live);
+        if (!owns())
+          return false;
+        await subscribe(agentSubject(host3), live);
+        if (!owns())
+          return false;
+        await watchAgentStream(host3, live);
+        if (!owns())
+          return false;
         if ((context.sessionManager.getBranch?.() ?? []).length > 0) {
-          await recoverRegisteredInterests();
+          await recoverRegisteredInterests(live);
+          if (!owns())
+            return false;
         }
         inboundOpenFor = host3;
       } catch (error48) {
         inboundFailure = error48;
       }
     }
-    if (hostSessionID() !== host3)
+    if (!owns())
       return false;
     const registration = await registerSession().then(() => {
       return;
     }, (error48) => ({ error: error48 }));
+    if (!owns())
+      return false;
     if (registration === undefined) {
       establishedSession = host3;
       ensureHeartbeat(context);
     }
-    const decided = await roleMoves.run(() => settleRole(context, host3, cause, registration === undefined));
+    const decided = await roleMoves.run((moveLive) => settleRole(context, host3, cause, registration === undefined, moveLive));
+    if (!owns())
+      return false;
     if (registration !== undefined) {
       throw new RegistrationError(messageFor(registration.error), { cause: registration.error });
     }
@@ -36406,12 +36514,14 @@ function envoyExtension(pi) {
   };
   let roleSettledFor = "";
   let lastHeard = "";
-  const settleEndedHolds = async (host3, wanted) => {
+  const settleEndedHolds = async (wanted, live) => {
     let restored = false;
     const failed = [];
     for (const [key, hold] of pendingHandBacks) {
+      if (!live())
+        break;
       pendingHandBacks.delete(key);
-      if (wanted !== undefined && hold.topic === ROLE_TOPIC_PREFIX + wanted) {
+      if (wanted !== undefined && hold.topic === ROLE_TOPIC_PREFIX + wanted && sessionOpen(hold.id)) {
         claimedRoleTopic = hold.topic;
         claimedRoleSessionID = hold.id;
         holdUnconfirmed = true;
@@ -36427,21 +36537,20 @@ function envoyExtension(pi) {
         });
       });
     }
-    for (const { key, topic, id } of failed) {
-      if (id === host3)
-        pendingHandBacks.set(key, { topic, id });
-      else
-        abandonedHolds.set(topic, { id });
-    }
+    for (const { key, topic, id } of failed)
+      abandonedHolds.set(key, { topic, id });
+    if (!live())
+      return false;
     return restored;
   };
-  const settleRole = async (context, host3, cause, registered) => {
-    if (!sessionOpen(host3))
+  const settleRole = async (context, host3, cause, registered, live) => {
+    const owns = () => live() && sessionOpen(host3);
+    if (!owns())
       return false;
     const branch = context.sessionManager.getBranch?.() ?? [];
     const readRows = roleSettledFor !== host3 && (branch.length > 0 || roleSettledFor !== "");
     const desired = await desiredRole(host3, branch, readRows);
-    if (!sessionOpen(host3))
+    if (!owns())
       return false;
     const unheard = lastHeard !== host3;
     const held = heldRole();
@@ -36449,13 +36558,13 @@ function envoyExtension(pi) {
       const ended = await handBackRole();
       if (ended !== undefined && unheard)
         warnRoleEnded(context, host3, ended);
-      if (!sessionOpen(host3))
+      if (!owns())
         return false;
     }
-    if (await settleEndedHolds(host3, desired) && unheard && desired !== undefined) {
+    if (await settleEndedHolds(desired, live) && unheard && desired !== undefined) {
       warnNoticesClosed(context, desired);
     }
-    if (!sessionOpen(host3))
+    if (!owns())
       return false;
     if (!registered)
       return false;
@@ -36465,7 +36574,7 @@ function envoyExtension(pi) {
     }
     if (!holdUnconfirmed && heldRole() === desired && claimedRoleSessionID === host3) {
       roleSettledFor = host3;
-      return cause.heartbeat === true ? reassertRoleNow(host3, desired, cause.afterOutage === true, context) : true;
+      return cause.heartbeat === true ? reassertRoleNow(host3, desired, cause.afterOutage === true, context, live) : true;
     }
     if (!inbound) {
       roleSettledFor = host3;
@@ -36479,18 +36588,18 @@ function envoyExtension(pi) {
       });
       if (holder !== undefined && holder !== host3 && lineage.includes(holder))
         supersedes = holder;
-      if (!sessionOpen(host3))
+      if (!owns())
         return false;
     }
     try {
-      const claimed = await setEnvoyRole(desired, host3, {
+      const claimed = await setEnvoyRole(desired, host3, live, {
         soft: true,
         previousSessionID: supersedes
       });
       if (claimed && unheard)
         warnNoticesClosed(context, desired);
     } catch (error48) {
-      if (error48 instanceof SessionLeftError)
+      if (error48 instanceof SessionLeftError || error48 instanceof AbandonedTaskError)
         return false;
       logger3.warn("envoy: role reclaim failed", {
         role: desired,
@@ -36498,6 +36607,8 @@ function envoyExtension(pi) {
         error: messageFor(error48)
       });
     }
+    if (!owns())
+      return false;
     roleSettledFor = host3;
     return true;
   };
@@ -36530,7 +36641,7 @@ function envoyExtension(pi) {
     if (establishedSession !== targetSessionID)
       await establishForBridge(context);
     await registerSession();
-    await roleMoves.run(() => setEnvoyRole(role, targetSessionID));
+    await roleMoves.run((live) => setEnvoyRole(role, targetSessionID, live));
   };
   const subscribeNotice = async (targetSessionID, topic, callerContext, whileHolding) => {
     const context = callerContext ?? activeSessionContext;
@@ -36963,13 +37074,13 @@ Not delivered: that holder is the session this subagent sends as, and the listen
         }
         case EnvoyToolOperation.setRole: {
           const role = stringFor(parameters, "role");
-          const released = await roleMoves.run(async () => {
+          const released = await roleMoves.run(async (live) => {
             const held = heldRole();
             const moving = held !== undefined && held !== role;
             if (moving && roleNoticeSubjects.size > 0) {
               throw new Error(`This session holds role ${held}, and ${[...roleNoticeSubjects].join(", ")} lasts only while it does; envoy_role_set does not move it to ${role}`);
             }
-            await setEnvoyRole(role, sessionID);
+            await setEnvoyRole(role, sessionID, live);
             return moving ? held : undefined;
           });
           return toolSuccess(released === undefined ? `Now holding role: ${role}` : `Now holding role: ${role} (released role ${released})`, { role, ...released === undefined ? {} : { released } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/pi-envoy",
-  "version": "10.20.0",
+  "version": "10.22.0",
   "license": "Apache-2.0",
   "type": "module",
   "omp": {