@volter/supercode-teams 0.3.94 → 0.3.96

package/live-sessions.mjs

@@ -440,6 +440,9 @@ export class LiveSessions extends EventEmitter {
     if (had) this.#changed();
   }
 
+  /** A new index subscription's first answer replaces the Codex rows the last one held (its rows follow this). */
+  codexRowsReplaced() { this.codexRows.clear(); }
+
   /** 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();

package/machine-records.mjs

@@ -21,8 +21,10 @@ 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;
+/** How often a machine whose daemon is too old to serve records is asked again: its update is what answers it, and the
+ *  server says nothing when its link comes back within the grace (machine-events.mjs records a change of linked only),
+ *  so it is asked each minute and said once. */
+const TOO_OLD_RETRY_MS = 60_000;
 
 /**
  * The producer: `readers[section](detail)` reads one section (async), `detail` naming what changed when the event knows
@@ -236,11 +238,13 @@ export class RecordHolder {
       // 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)
+      const saidBefore = state === 'too-old' && held.saidTooOld;
       held.backoff = state === 'too-old' ? TOO_OLD_RETRY_MS : backoff(held.backoff);
+      held.saidTooOld = state === 'too-old';
       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?.();
-      this.log(`machine records from ${machine}: ${held.why}; read again in ${Math.round(held.backoff / 1000)} s`);
+      if (!saidBefore) this.log(`machine records from ${machine}: ${held.why}; read again in ${Math.round(held.backoff / 1000)} s${state === 'too-old' ? ' (and each minute after, said again only once it changes)' : ''}`);
     };
     // the peer answers within STALE_MS (any frame, its beat included) or its record is stale, with why, and reopened
     const heard = () => { clearTimeout(held.quiet); held.quiet = setTimeout(() => closed(`no frame from ${machine} within ${STALE_MS / 1000} s (its record stream went quiet)`), STALE_MS); held.quiet.unref?.(); };
@@ -307,7 +311,7 @@ export class RecordHolder {
       }
       held.record = record;
     } else return null;
-    Object.assign(held, { state: 'open', since: held.state === 'open' ? held.since : Date.now(), why: null, received_at: Date.now(), backoff: 0 });
+    Object.assign(held, { state: 'open', since: held.state === 'open' ? held.since : Date.now(), why: null, received_at: Date.now(), backoff: 0, saidTooOld: false });
     this.save();
     return null;
   }

package/machine.mjs

@@ -617,8 +617,37 @@ export class TeamsMachine extends MachineCore {
     this.on('internal-notification', (message) => {
       const params = message.params ?? {};
       if (params.subscription && params.subscription === this.liveActivity) this.live.codexActivity(params.activities);
+      else if (params.subscription && params.subscription === this.codexIndex) {
+        for (const change of params.changes ?? []) {
+          if (change.kind === 'removed' && change.key?.harness === 'codex') this.live.codexIndex({ removed: change.key.session_id });
+          else if (change.descriptor) this.live.codexIndex({ descriptor: change.descriptor });
+        }
+        this.emit('codex-index', { changes: params.changes ?? [] });
+      }
+    });
+    // The Codex sessions' own index (Codex rollouts only): the live map knows them from its first answer, never waiting on
+    // the whole index of every harness, which the machine records keep (on yuerans that took 25.6 s to answer: grok's
+    // 11,305 files and claude-code's 6,334 listed, a page of 5,340 rows built; Codex's 980 files listed in 25 ms).
+    let codexIndexBackoff = 0, codexIndexRetry = null;
+    const subscribeCodex = () => this.#serveRequest('harness.v1.sessions.index.subscribe', { harnesses: ['codex'], limit: 0 }, 60_000)
+      .then((answer) => {
+        this.codexIndex = answer?.subscription ?? null; codexIndexBackoff = 0;
+        this.live.codexRowsReplaced();
+        for (const descriptor of answer?.initial ?? []) if (descriptor?.locator) this.live.codexIndex({ descriptor });
+        this.live.codexIndexed();
+        // the records take their Codex rows from this index too (their own whole index leaves Codex out: one watch and
+        // one read of the rollouts)
+        this.emit('codex-index', { initial: answer?.initial ?? [] });
+      }, (error) => {
+        codexIndexBackoff = Math.min(300_000, Math.max(2000, (codexIndexBackoff || 1000) * 2));
+        this.emit('records-log', `live sessions: the Codex sessions' index could not be subscribed (${error.message}); tried again in ${Math.round(codexIndexBackoff / 1000)} s`);
+        clearTimeout(codexIndexRetry); codexIndexRetry = setTimeout(() => void subscribeCodex(), codexIndexBackoff); codexIndexRetry.unref?.();
+      });
+    void subscribeCodex();
+    this.on('serve-exit', () => {
+      this.liveActivity = null; this.codexIndex = null; followed = ''; this.live.codexForget(); this.live.emit('codex-followed');
+      clearTimeout(codexIndexRetry); codexIndexRetry = setTimeout(() => void subscribeCodex(), 2000); codexIndexRetry.unref?.();
     });
-    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") ---------------------------
@@ -769,7 +798,22 @@ export class TeamsMachine extends MachineCore {
     // is back, and holds its own retry (2 s doubling to 5 min) until it is (MR4); nothing reads its fields as current.
     const backoff = (previous) => Math.min(300_000, Math.max(2000, (previous || 1000) * 2));
     const both = () => { producer.touch('sessions'); producer.touch('panes'); };
-    const HARNESSES = ['claude-code', 'codex', 'pi', 'opencode', 'goose', 'gemini', 'grok', 'openclaw', 'hermes', 'supercode'];
+    // every harness but Codex, whose rows come from the live map's Codex-only index ('codex-index' below)
+    const HARNESSES = ['claude-code', 'pi', 'opencode', 'goose', 'gemini', 'grok', 'openclaw', 'hermes', 'supercode'];
+    const isCodex = (key) => key.startsWith('codex:') || key.includes(':codex:');
+    const applyRow = (change) => {
+      if (change.kind === 'removed' && change.key) { this.sessionDescriptors?.delete(`sc:${machineName(this.env)}:${change.key.harness}:${change.key.session_id}`); locators.delete(`${change.key.harness}:${change.key.session_id}`); }
+      else if (change.descriptor?.locator) { const { harness, session_id } = change.descriptor.locator; this.sessionDescriptors?.set(`sc:${machineName(this.env)}:${harness}:${session_id}`, change.descriptor); locators.set(`${harness}:${session_id}`, change.descriptor.locator); }
+    };
+    this.on('codex-index', ({ initial = null, changes = [] }) => {
+      if (initial) {
+        for (const key of [...locators.keys()]) if (isCodex(key)) locators.delete(key);
+        for (const key of [...(this.sessionDescriptors?.keys() ?? [])]) if (isCodex(key)) this.sessionDescriptors.delete(key);
+        for (const descriptor of initial) applyRow({ descriptor });
+      }
+      for (const change of changes) applyRow(change);
+      both();
+    });
     const locators = new Map(); // `${harness}:${session_id}` → the index's locator for it
     const noteIndexParts = (failed, error) => {
       // the index's own unread parts (a store, a folder, a registry it could not read): their sessions are unknown
@@ -782,8 +826,6 @@ export class TeamsMachine extends MachineCore {
         for (const change of params.changes ?? []) {
           if (change.kind === 'removed' && change.key) this.sessionDescriptors?.delete(`sc:${machineName(this.env)}:${change.key.harness}:${change.key.session_id}`);
           else if (change.descriptor?.locator) this.sessionDescriptors?.set(`sc:${machineName(this.env)}:${change.descriptor.locator.harness}:${change.descriptor.locator.session_id}`, change.descriptor);
-          if (change.kind === 'removed' && change.key?.harness === 'codex') this.live?.codexIndex({ removed: change.key.session_id });
-          else if (change.descriptor) this.live?.codexIndex({ descriptor: change.descriptor });
           if (change.kind === 'removed' && change.key) locators.delete(`${change.key.harness}:${change.key.session_id}`);
           else if (change.descriptor?.locator) locators.set(`${change.descriptor.locator.harness}:${change.descriptor.locator.session_id}`, change.descriptor.locator);
         }
@@ -794,11 +836,12 @@ export class TeamsMachine extends MachineCore {
     let indexBackoff = 0;
     const subscribe = () => this.#serveRequest('harness.v1.sessions.index.subscribe', { harnesses: HARNESSES, limit: 0 }, 60_000)
       .then((answer) => {
-        this.recordsIndex = answer?.subscription ?? null; indexBackoff = 0; locators.clear();
-        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); }
+        this.recordsIndex = answer?.subscription ?? null; indexBackoff = 0;
+        // its own rows replaced; the Codex rows (the live map's index's) kept
+        for (const key of [...locators.keys()]) if (!isCodex(key)) locators.delete(key);
+        for (const key of [...(this.sessionDescriptors?.keys() ?? [])]) if (!isCodex(key)) this.sessionDescriptors.delete(key);
+        for (const descriptor of answer?.initial ?? []) if (descriptor?.locator) { locators.set(`${descriptor.locator.harness}:${descriptor.locator.session_id}`, descriptor.locator); 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.94",
+  "version": "0.3.96",
   "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",