@volter/supercode-teams 0.3.92 → 0.3.94

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/live-sessions.mjs

@@ -100,7 +100,7 @@ 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
@@ -428,21 +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();
+    // what the ended serve said is not kept as what is true now: a Codex session that ended in the gap would be filed for
+    // a door it no longer has; until serve answers anew, a Codex session is not known yet (a send to it waits)
+    const had = this.codexRunning.size + this.codexPaneOf.size;
+    this.codexRunning.clear(); this.codexPaneOf = new Map();
+    if (had) this.#changed();
+  }
+
   /** 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(); }
+  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.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. */
+  /** 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); resolve(false); }, boundMs);
+      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);
     });

package/machine-records.mjs

@@ -21,6 +21,8 @@ const MIN_READ_MS = 2000;
 export const BEAT_MS = 15_000;
 export const STALE_MS = 45_000;
 const backoff = (previous) => Math.min(300_000, Math.max(2000, (previous || 1000) * 2));
+/** How often a machine whose daemon is too old to serve records is asked again (its update is what answers it). */
+const TOO_OLD_RETRY_MS = 600_000;
 
 /**
  * The producer: `readers[section](detail)` reads one section (async), `detail` naming what changed when the event knows
@@ -231,8 +233,10 @@ export class RecordHolder {
       held.attempt = null;
       Object.assign(held, { stream: null, state, since: Date.now(), why: String(why ?? 'the stream closed').slice(0, 300) });
       try { stream?.close?.(); } catch { /* closing */ }
-      // opened again after a backoff, 2 s doubling to 5 min: an obligation of this machine, never a sweep
-      held.backoff = backoff(held.backoff);
+      // opened again after a backoff, 2 s doubling to 5 min: an obligation of this machine, never a sweep. A daemon too
+      // old to serve records is asked again every TOO_OLD_RETRY_MS: only its update answers it (asked every 8-16 s, it
+      // filled the log)
+      held.backoff = state === 'too-old' ? TOO_OLD_RETRY_MS : backoff(held.backoff);
       if (this.closed) return;
       held.retry = setTimeout(() => { held.retry = null; if ((held.state === 'closed' || held.state === 'too-old') && !this.closed) this.subscribe(machine); }, held.backoff);
       held.retry.unref?.();

package/machine.mjs

@@ -611,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") ---------------------------

package/mail/send.mjs

@@ -189,7 +189,9 @@ export class MailSend {
   /** 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.`;
+    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
@@ -208,9 +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) {
-    await this.#codexKnown();
-    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.');
@@ -458,7 +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');
-    await this.#codexKnown();
+    // 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.92",
+  "version": "0.3.94",
   "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",