@volter/supercode-teams 0.3.90 → 0.3.92

package/connector/index.mjs

@@ -19,6 +19,22 @@ import { NativeEffects } from './native-effects.mjs';
 import { consumeAgentClosures } from './agent-closures.mjs';
 
 const SYNC_PROBLEM_LIMIT=20;
+// How long after a session is first seen a change has its launch agent read again (a launch record written late).
+const LAUNCH_AGENT_WINDOW_MS=120000;
+/**
+ * The agent variables a session's launch recorded in its harness home (`<home>/supercode/launches/<session id>.json`,
+ * crates/harness/src/launch_agent.rs `read`), read here with no request: a Codex rollout's home is the folder above its
+ * `sessions/`, a Claude transcript's the folder above its `projects/`. Null when its launch named no agent.
+ */
+export function readLaunchAgent(locator){
+  const id=locator?.session_id,path=locator?.storage?.kind==='file'?locator.storage.path:null;
+  const store={codex:'sessions','claude-code':'projects'}[locator?.harness];
+  if(typeof path!=='string'||!store||typeof id!=='string'||!/^[A-Za-z0-9_-]+$/.test(id))return null;
+  let home=null;for(let dir=dirname(path);dirname(dir)!==dir;dir=dirname(dir))if(basename(dir)===store){home=dirname(dir);break;}
+  if(!home)return null;
+  try{const environment=JSON.parse(readFileSync(join(home,'supercode','launches',`${id}.json`),'utf8'))?.environment;return environment&&typeof environment==='object'&&!Array.isArray(environment)?environment:null;}
+  catch{return null;}
+}
 const CAPACITY_CODE='SUBSCRIPTION_OPEN_CAPACITY';
 // Whether a root covers a session's folder: the root's own, or (unless the root is exact-only) one under it, by real path.
 const realOr=path=>{try{return realpathSync(path);}catch{return path;}};
@@ -638,8 +654,11 @@ export class TeamsConnector {
     // the binding is written only while this work is still the session's (checked again after its awaits)
     const bindingRead=this.clock.nowMs();
     try{await this.nativeEffects.discover(descriptor,ruleId,()=>this.sessionLive(key,ruleId,epoch)&&!((this.runtimeEnded?.get(key)??-Infinity)>=bindingRead));}catch(error){this.lastError=error;}
-    // The agent this session's launch named, read when first seen here and whenever it changes, until queued for binding.
-    if(captured&&!this.state.agent_sessions?.[key]&&(changed||!this.launchChecked?.has(key))){(this.launchChecked??=new Set()).add(key);await this.noteLaunchAgent(locator,()=>this.sessionLive(key,ruleId,epoch));}
+    // The agent this session's launch named, read (in this process, one file) when first seen here, and on a change in
+    // the LAUNCH_AGENT_WINDOW_MS after (a launch record written late), until queued for binding. A launch's agent is
+    // fixed at its launch: read on every change it was a call into harness serve's loop per transcript write.
+    const firstSeen=this.launchChecked?.get(key),now=this.clock.nowMs();
+    if(captured&&!this.state.agent_sessions?.[key]&&(firstSeen===undefined||(changed&&now-firstSeen<LAUNCH_AGENT_WINDOW_MS))){if(firstSeen===undefined)(this.launchChecked??=new Map()).set(key,now);this.noteLaunchAgent(locator,()=>this.sessionLive(key,ruleId,epoch));}
     // A session seen with its native bundle still owed (from before this start) waits for its file to go quiet; one
     // captured now has its wait armed by the commit that records it (flushOutbox).
     if(!changed)this.armNativeIdle(key);
@@ -1209,11 +1228,9 @@ export class TeamsConnector {
       if(error.status!==409&&error.status!==404)throw error;
     }
   }
-  /** The agent a session's launch named, as its home recorded it (`harness.v1.sessions.launch_agent`): queued for binding. */
-  async noteLaunchAgent(locator,live=()=>true){
-    if(typeof this.daemon?.launchAgent!=='function')return;
-    let environment;
-    try{environment=await this.daemon.launchAgent(locator);}catch(error){this.lastError=error;return;}
+  /** The agent a session's launch named, as its home recorded it (read here, readLaunchAgent): queued for binding. */
+  noteLaunchAgent(locator,live=()=>true){
+    const environment=readLaunchAgent(locator);
     if(!live())return;
     if(environment?.SUPERCODE_AGENT_ID)this.queueAgentSession(`${locator.harness}:${locator.session_id}`,environment);
   }

package/live-sessions.mjs

@@ -14,7 +14,7 @@
 // - Messaging tools: the marker a `message mcp` server writes for its session process, with the server alive.
 import { EventEmitter } from 'node:events';
 import { execFile } from 'node:child_process';
-import { mkdirSync, readFileSync, readdirSync, renameSync, watch, writeFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, watch, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { FrontendClient } from '@volter/supercode-frontend';
@@ -30,6 +30,9 @@ const HISTORY_KEPT = 64;
 /** The argument a Codex hook file carries when supercode's mail hook is installed. */
 const CODEX_HOOK = 'message hook codex';
 
+/** How long the runtime probes of one claim may take in all (a host stalled by load answers late, not never). */
+const CLAIM_PROBE_MS = 10_000;
+
 const alive = (pid) => {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try { process.kill(pid, 0); return true; } catch (error) { return error.code === 'EPERM'; }
@@ -50,6 +53,9 @@ function linuxStart(pid) {
   } catch { return null; }
 }
 
+/** `path` with its symlinks resolved, or null when it cannot be (gone, or not a string). */
+function realPath(path) { try { return typeof path === 'string' ? realpathSync(path) : null; } catch { return null; } }
+
 /** When the process on `pid` started, in ms (Linux's /proc, or one `ps` on macOS), or null when it cannot be read. */
 function startedMs(pid) {
   if (process.platform === 'linux') { const started = linuxStart(pid); return Promise.resolve(started ? Date.parse(`${started.date} UTC`) : null); }
@@ -62,11 +68,11 @@ function startedMs(pid) {
 
 /** Whether the runtime a receipt names answers at its address as that runtime (its own identity, with the receipt's
  *  token): the proof a start read off the wall clock cannot give, as the clock may have stepped since the receipt.
- *  true or false, or null when it did not answer within 2 s (the request is aborted then): not known either way. */
-async function answersAs(receipt) {
+ *  true or false, or null when it did not answer within `boundMs` (the request is aborted then): not known either way. */
+async function answersAs(receipt, boundMs = 2000) {
   try {
     const client = new FrontendClient({ baseUrl: receipt.base_url, token: receipt.token, clientId: `live-${receipt.receipt_id}`, permissions: ['observe'] });
-    return (await client.describe({ signal: AbortSignal.timeout(2000) }))?.session_id === receipt.runtime_session_id;
+    return (await client.describe({ signal: AbortSignal.timeout(boundMs) }))?.session_id === receipt.runtime_session_id;
   } catch (error) {
     if (error?.name === 'TimeoutError' || error?.name === 'AbortError') return null;
     return false;
@@ -99,6 +105,9 @@ export class LiveSessions extends EventEmitter {
     this.runtimes = new Map(); // receipt id → { pid, harness, sessionId, runtimeSessionId, cwd }
     this.markers = new Map(); // session pid → server pid
     this.codexRows = new Map(); // session id → { cwd, updatedAt }
+    // whether the Codex sessions are known yet: the index's first answer read, then their activity followed once after
+    // it (until then a Codex session missing from the map is not yet known, never not running)
+    this.codexIndexRead = false; this.codexKnown = false; this.codexWaiters = [];
     this.codexRunning = new Map(); // session id → turn (from activity)
     this.codexPaneOf = new Map(); // session id → pane
     this.projectHooks = new Map(); // directory → whether its .codex/hooks.json carries the hook
@@ -320,7 +329,8 @@ export class LiveSessions extends EventEmitter {
     const source = receipt.source;
     const entry = { pid: receipt.pid, harness: source.harness, sessionId: source.session_id, runtimeSessionId: typeof receipt.runtime_session_id === 'string' ? receipt.runtime_session_id : null, cwd: typeof source.workspace === 'string' ? source.workspace : null,
       // what a later check of the same pid needs: when the receipt was written, and how to ask the runtime itself
-      created: Number(receipt.created_at_ms), probe: { base_url: receipt.base_url, token: receipt.token, receipt_id: id, runtime_session_id: receipt.runtime_session_id } };
+      // its workspace as a real path too, so a relay folder named through a symlinked home still matches it
+      realCwd: realPath(source.workspace), created: Number(receipt.created_at_ms), probe: { base_url: receipt.base_url, token: receipt.token, receipt_id: id, runtime_session_id: receipt.runtime_session_id } };
     const known = this.runtimes.get(id);
     if (known && known.pid === entry.pid && known.startChecked) entry.startChecked = true;
     this.runtimes.set(id, entry);
@@ -418,6 +428,26 @@ export class LiveSessions extends EventEmitter {
 
   #codexChanged() { this.emit('codex-followed'); }
 
+  /** The session index's first answer is read: its Codex sessions' activity is followed next (even when it has none). */
+  codexIndexed() { this.codexIndexRead = true; this.#codexChanged(); }
+
+  /** The Codex sessions' activity was followed: after the index's first answer, the Codex sessions are known. */
+  codexFollowedNow() {
+    if (!this.codexIndexRead || this.codexKnown) return;
+    this.codexKnown = true;
+    for (const resolve of this.codexWaiters.splice(0)) resolve(true);
+  }
+
+  /** Resolves true once the Codex sessions are known, or false when `boundMs` passes first. */
+  whenCodexKnown(boundMs) {
+    if (this.codexKnown) return Promise.resolve(true);
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => { this.codexWaiters = this.codexWaiters.filter((waiter) => waiter !== done); resolve(false); }, boundMs);
+      const done = (value) => { clearTimeout(timer); resolve(value); };
+      this.codexWaiters.push(done);
+    });
+  }
+
   #changed() { this.emit('changed'); }
 
   // ---- what it holds ------------------------------------------------------------------------------------------------
@@ -467,6 +497,13 @@ export class LiveSessions extends EventEmitter {
    * file and checked as live_runtime.rs `resolve_live_runtime` checks it (its schema, a loopback address, its process
    * alive, the source it names): the bearer token a delivery uses is read here, at the delivery, never kept in the map.
    */
+  /** The live runtimes of `harness` whose workspace is `cwd`, each by the ids it may be closed by (in-memory, no read). */
+  runtimesIn(harness, cwd) {
+    const real = realPath(cwd);
+    return [...this.runtimes.values()].filter((runtime) => runtime.harness === harness && (runtime.cwd === cwd || (real && runtime.realCwd === real)) && alive(runtime.pid))
+      .map((runtime) => [...new Set([runtime.sessionId, runtime.runtimeSessionId].filter((id) => typeof id === 'string' && id))]);
+  }
+
   runtimeReceipt(harness, id) {
     for (const [receiptId, runtime] of this.runtimes) {
       if (runtime.harness !== harness || (runtime.sessionId !== id && runtime.runtimeSessionId !== id) || !alive(runtime.pid)) continue;
@@ -511,12 +548,14 @@ export class LiveSessions extends EventEmitter {
 
   /** The session a client runs in, from its claim: its parent's current session, else its environment's id through the map. */
   async #sessionOfClaim({ pid, ppid, session, runtime }) {
+    // the probes of one claim share one bound (CLAIM_PROBE_MS), however many of its processes are runtimes
+    const deadline = Date.now() + CLAIM_PROBE_MS;
     // a runtime supercode hosts (the native agent) says so in its claim: it is named by its own process first, never by
     // the session whose shell started it; one with no receipt is named by the rest of its claim, as any client is
     if (runtime === true) {
       // a pid several receipts name is no one runtime: the rest of the claim names it, never a refusal here
       let own = null;
-      try { own = await this.#runtimeOfPid(Number(pid)); } catch (error) { if (!(error instanceof CallerRefused) || error.unconfirmed) throw error; }
+      try { own = await this.#runtimeOfPid(Number(pid), deadline); } catch (error) { if (!(error instanceof CallerRefused) || error.unconfirmed) throw error; }
       if (own) return own;
     }
     const parent = this.claude.get(Number(ppid));
@@ -530,24 +569,27 @@ export class LiveSessions extends EventEmitter {
     // only when exactly one live runtime's receipt names that process. A process several receipts name (harness serve
     // records its own pid on each runtime it hosts with no child of its own) is no one runtime, and is refused.
     for (const candidate of [Number(pid), Number(ppid)]) {
-      const found = await this.#runtimeOfPid(candidate);
+      const found = await this.#runtimeOfPid(candidate, deadline);
       if (found) return found;
     }
     return null;
   }
 
   /** The runtime whose live receipt alone names process `pid`, or null; several receipts naming it are no one runtime, refused. */
-  async #runtimeOfPid(pid) {
+  async #runtimeOfPid(pid, deadline = Date.now() + CLAIM_PROBE_MS) {
     if (!Number.isInteger(pid) || pid <= 0) return null;
     const held = [...this.runtimes.values()].filter((runtime) => runtime.pid === pid && alive(runtime.pid));
     if (held.length > 1) throw new CallerRefused(`process ${pid} hosts ${held.length} runtimes, so which one is calling is not known; nothing was done`);
     if (held.length !== 1) return null;
     // a caller's identity: checked again now, with no process (the runtime asked at its own address), as a runtime that
     // ended may have left its pid to another process before the sweep lets its receipt go
-    const answered = await answersAs(held[0].probe);
-    // one that did not answer in time is not known either way: refused, never taken for its parent's session or its
+    // a host stalled by load answers late, not never: one that did not answer in 2 s is asked once more, for what is left
+    // of the claim's bound
+    let answered = await answersAs(held[0].probe, Math.max(1, Math.min(2000, deadline - Date.now())));
+    if (answered === null && deadline - Date.now() > 250) answered = await answersAs(held[0].probe, deadline - Date.now());
+    // one that did not answer then is not known either way: refused, never taken for its parent's session or its
     // environment's (which would name another caller)
-    if (answered === null) throw Object.assign(new CallerRefused(`process ${pid} is a runtime that did not answer within 2 s, so which session is calling was not confirmed; nothing was done`), { unconfirmed: true });
+    if (answered === null) throw Object.assign(new CallerRefused(`process ${pid} is a runtime that did not answer within ${CLAIM_PROBE_MS / 1000} s, so which session is calling was not confirmed; nothing was done`), { unconfirmed: true });
     if (!answered) return null;
     return this.#address(held[0].harness, held[0].sessionId);
   }

package/machine.mjs

@@ -594,7 +594,7 @@ export class TeamsMachine extends MachineCore {
     const followNow = async () => {
       const locators = this.live.codexFollowed();
       const key = locators.map((locator) => locator.session_id).sort().join('\n');
-      if (key === followed) return;
+      if (key === followed) { this.live.codexFollowedNow(); return; }
       const previous = this.liveActivity;
       try {
         if (locators.length) {
@@ -603,6 +603,7 @@ export class TeamsMachine extends MachineCore {
           this.live.codexActivity(opened?.initial ?? [], { replace: true });
         } else { this.liveActivity = null; this.live.codexActivity([], { replace: true }); }
         followed = key; backoffMs = 0;
+        this.live.codexFollowedNow();
         if (previous) void this.#serveRequest('harness.v1.sessions.activity.unsubscribe', { subscription: previous }, 30_000).catch(() => {});
       } catch (error) {
         backoffMs = Math.min(300_000, Math.max(2000, (backoffMs || 1000) * 2));
@@ -645,6 +646,7 @@ export class TeamsMachine extends MachineCore {
       recordedConfig: (locator) => this.#serveRequest('harness.v1.sessions.recorded_config', { locator }, 15_000) });
     this.relays = new Relays({ mailRoot, machine, supercodeBin: this.supercodeBin, serve: (method, params, timeoutMs) => this.#serveRequest(method, params, timeoutMs),
       runtimeOf: (harness, id) => live.runtimeReceipt(harness, id), runtimeNamed: (receiptId) => live.receiptNamed(receiptId),
+      runtimesIn: (harness, cwd) => live.runtimesIn(harness, cwd),
       log: (line) => this.emit('mail-log', line) });
     this.mailSend = new MailSend({ machine, mailRoot, live, store: this.mailStore, agents: this.agents, relays: this.relays,
       // a send waits on its receiver's door there (a relay's receipt takes up to 90 s), never past MAIL_SEND_MS
@@ -794,6 +796,7 @@ export class TeamsMachine extends MachineCore {
         this.sessionDescriptors?.clear();
         for (const descriptor of answer?.initial ?? []) if (descriptor?.locator) { locators.set(`${descriptor.locator.harness}:${descriptor.locator.session_id}`, descriptor.locator); this.live?.codexIndex({ descriptor }); this.sessionDescriptors?.set(`sc:${machineName(this.env)}:${descriptor.locator.harness}:${descriptor.locator.session_id}`, descriptor); }
         producer.note('sessions_index', null); noteIndexParts(answer?.failed, null); both();
+        this.live?.codexIndexed();
       }, (error) => {
         indexBackoff = backoff(indexBackoff);
         const why = `the session index could not be subscribed: ${error.message}; sessions and panes change on pane and mail events only until it is`;

package/mail/relay.mjs

@@ -25,6 +25,8 @@ export const MAX_RELAYED_BYTES = 100_000;
 /** How many relays run at once, the most recently used (a relay runtime is some hundreds of MB; 10 held 2.1 GB on one
  *  machine): beyond them a relay's runtime is closed (its folder kept: it starts again when next needed). */
 export const RELAYS_RUNNING = 4;
+/** How long a relay whose runtime start lost its answer is looked at for a runtime that start left running. */
+const LOST_START_KEPT_MS = 5 * 60_000;
 
 const alive = (pid) => { if (!Number.isInteger(pid) || pid <= 0) return false; try { process.kill(pid, 0); return true; } catch (error) { return error.code === 'EPERM'; } };
 const readJson = (path) => { try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; } };
@@ -61,8 +63,9 @@ export class Relays {
    * id)` the live-runtime receipt the live-session map holds for a runtime id (its file read whole), or null;
    * `runtimeNamed(receiptId)` one receipt read by its own name.
    */
-  constructor({ mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed = () => null, log = () => {} }) {
-    Object.assign(this, { mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed, log });
+  constructor({ mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed = () => null, runtimesIn = () => [], log = () => {} }) {
+    Object.assign(this, { mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed, runtimesIn, log });
+    this.lost = new Map(); // relay folder → when a start of its runtime lost its answer (the runtime may run, unnamed)
     this.sending = new Map(); // relay folder → the send in progress through it (one at a time per relay)
     this.running = new Map(); // relay folder → { connection, runtime_id, usedAt }: the relays this daemon runs
   }
@@ -78,7 +81,25 @@ export class Relays {
       // closed under the relay's own lock: a send to it that arrives meanwhile waits for the close, then starts it
       // again, never handing its turn to a runtime that is closing
       void this.#locked(directory, () => this.serve('harness.v1.runtimes.close', { connection: relay.connection, runtime_id: relay.runtime_id }, 15_000))
-        .catch((error) => this.log(`relay ${directory.split(/[\\/]/).pop()} beyond the ${RELAYS_RUNNING} most recent was not closed: ${error.message}`));
+        .catch((error) => {
+          // still running, so still counted: the next cap closes it again (unless a send started it anew meanwhile)
+          if (!this.running.has(directory)) this.running.set(directory, relay);
+          this.log(`relay ${directory.split(/[\\/]/).pop()} beyond the ${RELAYS_RUNNING} most recent was not closed: ${error.message}`);
+        });
+    }
+    // a start whose answer was lost may have left a runtime running in its relay's folder that no record names: closed by
+    // its id once the live-session map holds it (looked for over five minutes: the start may finish after its answer)
+    for (const [directory, lostAt] of this.lost) {
+      if (Date.now() - lostAt > LOST_START_KEPT_MS) { this.lost.delete(directory); continue; }
+      if (this.sending.has(directory)) continue;
+      const named = readJson(join(directory, 'relay.json'))?.runtime_id;
+      for (const ids of this.runtimesIn('claude-code', directory)) {
+        if (ids.includes(named)) continue;
+        void this.#locked(directory, async () => {
+          for (const id of ids) { try { await this.serve('harness.v1.runtimes.close', { runtime_id: id }, 15_000); return; } catch { /* the other id */ } }
+          this.log(`relay ${directory.split(/[\\/]/).pop()}: a runtime its lost start left running was not closed`);
+        });
+      }
     }
   }
 
@@ -165,7 +186,7 @@ export class Relays {
       catch (error) { if (this.runtimeOf('claude-code', record.runtime_id)) throw new Error(`could not retire the old relay: ${error.message}`); }
     }
     const key = spec.directory.split(/[\\/]/).pop();
-    const started = await this.serve('harness.v1.runtimes.start', {
+    const started = await this.#start(spec, {
       harness: 'claude-code',
       launch: {
         program: 'claude',
@@ -270,6 +291,13 @@ export class Relays {
     }
   }
 
+  /** `runtimes.start` for a relay: a start that fails (its answer lost, or late past its bound) may still have left a
+   *  runtime running, so its folder is looked at by the next caps (#cap). */
+  async #start(spec, params, timeoutMs) {
+    try { return await this.serve('harness.v1.runtimes.start', params, timeoutMs); }
+    catch (error) { this.lost.set(spec.directory, Date.now()); throw error; }
+  }
+
   /** A relay this daemon runs, used now. */
   #used(spec, connection) {
     const runtimeId = readJson(spec.record)?.runtime_id;

package/mail/send.mjs

@@ -23,6 +23,9 @@ export function unansweredText(where, detail, id) {
   return `Unanswered: ${where} took the message, but its answer was lost (${detail}), so whether it was delivered is unknown. Message id ${shortId(id)}. Don't send it again as a new message; supercode message show ${shortId(id)} says where it stands.`;
 }
 
+/** How long a send waits, in a daemon's first moments, for its Codex sessions to be known before it resolves a receiver. */
+const CODEX_KNOWN_WAIT_MS = 20_000;
+
 /** Replies in one unbroken chain between two sessions beyond which another is refused. */
 const REPLY_CHAIN_LIMIT = 32;
 /** How long a name no running session carries still reaches the session that last carried it. */
@@ -148,7 +151,7 @@ export class MailSend {
     }
     if (parsed) {
       const session = sessions.find((row) => row.address === parsed.address);
-      if (!session) return { outcome: outcome(EXIT_UNKNOWN, `${to} is no longer running. Nothing was sent. Run supercode message list for the live sessions.`) };
+      if (!session) return { outcome: outcome(EXIT_UNKNOWN, this.#notYetKnown(to) ?? `${to} is no longer running. Nothing was sent. Run supercode message list for the live sessions.`) };
       return { address: session.address, name: session.name, session };
     }
     // a name: unique among the sessions here, else the session it last named (the names ledger)
@@ -176,7 +179,17 @@ export class MailSend {
       }).slice(0, 3).map((row) => `${row.name} (${row.address.split(':')[2]}, ${row.status})`);
       if (near.length) hint = ` Did you mean: ${near.join(', ')}?`;
     }
-    return { outcome: outcome(EXIT_UNKNOWN, `No session named "${wanted}" is reachable.${hint} Run supercode message list. Nothing was sent.`) };
+    return { outcome: outcome(EXIT_UNKNOWN, this.#notYetKnown(wanted) ?? `No session named "${wanted}" is reachable.${hint} Run supercode message list. Nothing was sent.`) };
+  }
+
+  /** In a daemon's first moments the Codex sessions are not known yet (its session index and their activity still being
+   *  read): a send waits for them, at most CODEX_KNOWN_WAIT_MS. */
+  async #codexKnown() { if (!this.live.codexKnown) await this.live.whenCodexKnown?.(CODEX_KNOWN_WAIT_MS); }
+
+  /** What a receiver not found is, while the Codex sessions are not known yet: not known yet, never not running. */
+  #notYetKnown(what) {
+    if (this.live.codexKnown !== false) return null;
+    return `${what} is not known yet: this machine's daemon started a moment ago and is still reading its sessions (its Codex sessions among them). Nothing was sent. Send it again in a minute.`;
   }
 
   /** The door that reaches `address` here, from one read of the live sessions (mail_route.rs `door_in`): null when no
@@ -195,6 +208,7 @@ export class MailSend {
 
   /** Deliver from `caller` to `to` on this machine (mail_send.rs `deliver`). */
   async #deliver(caller, to, body, { subject, in_reply_to, notify_when_idle, queue, id, notice, thread: carried, chosen }, link) {
+    await this.#codexKnown();
     const sessions = this.live.sessions();
     const receiver = this.#receiver(to, sessions);
     if (receiver.outcome) return receiver.outcome;
@@ -226,7 +240,7 @@ export class MailSend {
     if (plan.plan) return this.#deliverPlanned(caller, sent, plan.plan, { queue, notify_when_idle });
     // the thread this message is in, kept in the send log: a later reply to it continues that thread
     const sentIn = threadOf(sent);
-    if (!door || door.kind === 'other_machine') return outcome(EXIT_UNKNOWN, `${name} is no longer running. Nothing was sent. Run supercode message list for the live sessions.`);
+    if (!door || door.kind === 'other_machine') return outcome(EXIT_UNKNOWN, this.#notYetKnown(name) ?? `${name} is no longer running. Nothing was sent. Run supercode message list for the live sessions.`);
     const idleNote = notify_when_idle && cameThroughLink(sent)
       ? ' No idle notice: this message came through a link, so its return address is as claimed, and nothing is sent to it on its own (D200); a reply is the receiver\'s own send.'
       : notify_when_idle ? ' Subscribed: one idle notice reaches you when its next turn ends.' : '';
@@ -444,6 +458,7 @@ export class MailSend {
     const receiver = typeof harness === 'string' && typeof sessionId === 'string' ? makeAddress(this.machine, harness, sessionId) : null;
     if (!receiver) return refused('delivery_failed', `\`sc:${this.machine}:${harness}:${sessionId}\` is not a session address; addresses look like sc:<machine>:<harness>:<session-id>`);
     if (params.voice_for != null && params.voice_for !== receiver) return refused('invalid_sender', 'a voice front must represent the receiving session');
+    await this.#codexKnown();
     const sessions = this.live.sessions();
     // a Claude session's registry name must still name only that session; a holder the mailbox launched may have stopped
     if (harness === 'claude-code' && !(await this.agents.resumable(receiver)) && !this.live.runtimeReceipt('claude-code', sessionId)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.90",
+  "version": "0.3.92",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",