@volter/supercode-teams 0.3.91 → 0.3.93

package/bin/teams.mjs

@@ -175,6 +175,7 @@ async function main() {
         machine.on('door', (d) => { if (flags.verbose) process.stderr.write(`door ${d.method} ${d.outcome} ${d.ms}ms${d.detail ? ` ${d.detail}` : ''}\n`); });
         machine.on('serve-stderr', (t) => process.stderr.write(t));
         machine.on('mail-log', (line) => process.stderr.write(`mail: ${line}\n`));
+        machine.on('records-log', (line) => process.stderr.write(`records: ${line}\n`));
         machine.on('serve-exit', (e) => process.stderr.write(`harness serve exited: ${JSON.stringify(e)}\n`));
         machine.on('unrouted-notification', (m) => { if (flags.verbose) process.stderr.write(`unrouted: ${m.method}\n`); });
         const socket = await machine.start();

package/bin/workspace.mjs

@@ -1136,6 +1136,7 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
     machine.on('serve-exit', (exit) => process.stderr.write(`supercode teams: harness serve exited: ${JSON.stringify(exit)}\n`));
     machine.on('serve-stderr', (text) => process.stderr.write(`supercode teams: harness serve: ${String(text).trimEnd().slice(-2000)}\n`));
     machine.on('mail-log', (line) => process.stderr.write(`supercode teams: mail: ${line}\n`));
+    machine.on('records-log', (line) => process.stderr.write(`supercode teams: records: ${line}\n`));
     // its mail goes through the daemon's own send, in this process
     machineEvents.send = (request) => machine.sendOwn(request);
     // the Claude worker homes the roots declare: their live sessions are this machine's too (the live-session map)

package/connector/index.mjs

@@ -19,8 +19,22 @@ import { NativeEffects } from './native-effects.mjs';
 import { consumeAgentClosures } from './agent-closures.mjs';
 
 const SYNC_PROBLEM_LIMIT=20;
-// How many times a session's launch agent is asked of harness serve: when first seen, and after a change at most twice more.
-const LAUNCH_AGENT_ASKS=3;
+// 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;}};
@@ -640,12 +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 after a change at most twice more (a launch
-    // record written just after its session appeared), until queued for binding. Never on every change: a launch's agent
-    // is fixed at the launch, and asking on every transcript write of every live session kept harness serve's loop
-    // busy with more than one call a second (yuerans: 1357 calls over a second each in ten minutes).
-    const asked=this.launchChecked?.get(key)??0;
-    if(captured&&!this.state.agent_sessions?.[key]&&asked<LAUNCH_AGENT_ASKS&&(asked===0||changed)){(this.launchChecked??=new Map()).set(key,asked+1);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);
@@ -1215,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); }
@@ -94,11 +100,14 @@ export class LiveSessions extends EventEmitter {
     this.homesFile = join(supercodeHome, 'live-claude-homes.json');
     this.markersDir = join(supercodeHome, 'mail', 'message-mcp');
     this.codexHooks = join(env.CODEX_HOME || join(homedir(), '.codex'), 'hooks.json');
-    this.boardOwner = boardOwner; this.log = log;
+    this.boardOwner = boardOwner; this.log = log; this.startedAt = Date.now();
     this.claude = new Map(); // pid → { pid, dir, sessionId, name, status, cwd, tmux, procStart, history: [ids, oldest first] }
     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,41 @@ export class LiveSessions extends EventEmitter {
 
   #codexChanged() { this.emit('codex-followed'); }
 
+  /** harness serve ended: its index and activity subscriptions went with it, so the Codex sessions are not known again
+   *  until it answers anew (a session missing meanwhile is not known yet, never not running). */
+  codexForget() {
+    if (!this.codexIndexRead && !this.codexKnown) return;
+    this.codexIndexRead = false; this.codexKnown = false; this.codexWaitedOut = false; this.startedAt = Date.now();
+  }
+
+  /** The session index's first answer is read: its Codex sessions' activity is followed next (even when it has none). */
+  codexIndexed() {
+    if (!this.codexIndexRead) this.codexIndexedAt = Date.now();
+    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; this.codexWaitedOut = false;
+    // how long a daemon's start took to know its Codex sessions, and in which part (said once)
+    const now = Date.now();
+    this.log(`live sessions: Codex sessions known ${Math.round((now - this.startedAt) / 100) / 10} s after start (the session index answered at ${Math.round((this.codexIndexedAt - this.startedAt) / 100) / 10} s; their activity followed ${Math.round((now - this.codexIndexedAt) / 100) / 10} s later, ${this.codexFollowed().length} followed)`);
+    for (const resolve of this.codexWaiters.splice(0)) resolve(true);
+  }
+
+  /** Resolves true once the Codex sessions are known, or false when `boundMs` passes first. Once a wait has run out,
+   *  later ones answer false at once until they are known: a harness serve that does not answer holds no send twice. */
+  whenCodexKnown(boundMs) {
+    if (this.codexKnown) return Promise.resolve(true);
+    if (this.codexWaitedOut) return Promise.resolve(false);
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => { this.codexWaiters = this.codexWaiters.filter((waiter) => waiter !== done); this.codexWaitedOut = true; resolve(false); }, boundMs);
+      const done = (value) => { clearTimeout(timer); resolve(value); };
+      this.codexWaiters.push(done);
+    });
+  }
+
   #changed() { this.emit('changed'); }
 
   // ---- what it holds ------------------------------------------------------------------------------------------------
@@ -469,7 +514,8 @@ export class LiveSessions extends EventEmitter {
    */
   /** 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) {
-    return [...this.runtimes.values()].filter((runtime) => runtime.harness === harness && runtime.cwd === cwd && alive(runtime.pid))
+    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))]);
   }
 
@@ -517,12 +563,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));
@@ -536,26 +584,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
-    // a host stalled by load answers late, not never: one that did not answer in 2 s is asked once more, for 8 s
-    let answered = await answersAs(held[0].probe);
-    if (answered === null) answered = await answersAs(held[0].probe, 8000);
+    // 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 10 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));
@@ -610,12 +611,14 @@ export class TeamsMachine extends MachineCore {
         pending = setTimeout(follow, backoffMs); pending.unref?.();
       }
     };
-    this.live.on('codex-followed', () => { if (!pending) { pending = setTimeout(follow, 2000); pending.unref?.(); } });
+    // a change is followed after 2 s (changes come in bursts); the first follow after the index's first answer at once,
+    // as sends wait on it (the Codex sessions are not known until it is done)
+    this.live.on('codex-followed', () => { if (!pending) { pending = setTimeout(follow, this.live.codexKnown ? 2000 : 0); pending.unref?.(); } });
     this.on('internal-notification', (message) => {
       const params = message.params ?? {};
       if (params.subscription && params.subscription === this.liveActivity) this.live.codexActivity(params.activities);
     });
-    this.on('serve-exit', () => { this.liveActivity = null; followed = ''; this.live.emit('codex-followed'); });
+    this.on('serve-exit', () => { this.liveActivity = null; followed = ''; this.live.codexForget(); this.live.emit('codex-followed'); });
   }
 
   // ---- this machine's mail (mail/; docs/architecture/overview.md, "The mail operations") ---------------------------
@@ -795,6 +798,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/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,19 @@ 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 this.live.codexWaitedOut
+      ? `${what} is not known: this machine's harness serve has not reported its Codex sessions yet (it may be starting again, or not answering; the daemon's log says which). Nothing was sent.`
+      : `${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,8 +210,10 @@ 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) {
-    const sessions = this.live.sessions();
-    const receiver = this.#receiver(to, sessions);
+    let sessions = this.live.sessions();
+    let receiver = this.#receiver(to, sessions);
+    // only a receiver not found waits for the Codex sessions to be known (one the map holds is reached at once)
+    if (receiver.outcome && !this.live.codexKnown) { await this.#codexKnown(); sessions = this.live.sessions(); receiver = this.#receiver(to, sessions); }
     if (receiver.outcome) return receiver.outcome;
     const { address, name } = receiver;
     if (address === caller.address) return outcome(EXIT_REFUSED, 'Not sent: that address is your own session.');
@@ -226,7 +243,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 +461,8 @@ 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');
+    // only a receiver the map does not hold waits for the Codex sessions to be known
+    if (!this.live.codexKnown && !this.live.sessions().some((row) => row.address === receiver)) 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.91",
+  "version": "0.3.93",
   "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",