@volter/supercode-teams 0.3.95 → 0.3.96

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
@@ -211,15 +213,6 @@ export class RecordHolder {
     if (forgot) this.save();
     for (const [machine, held] of this.held) if (!linked.has(machine) && held.state !== 'unlinked') this.let(machine, 'offline: not linked to the team\'s server');
     for (const machine of linked) { const held = this.held.get(machine); if (!held || held.state === 'unlinked' || ((held.state === 'closed' || held.state === 'too-old') && !held.retry)) this.subscribe(machine); }
-    // a machine too old to serve records whose link changed since (it linked again: an update restarts its daemon) is
-    // asked again now, not at its ten-minute re-ask
-    const changedAt = new Map((items ?? []).filter((item) => item.linked).map((item) => [normal(item.name), item.changed_at ?? null]));
-    for (const [machine, held] of this.held) {
-      const at = changedAt.get(machine);
-      if (at == null) continue;
-      if (held.state === 'too-old' && held.linkChangedAt != null && at !== held.linkChangedAt) { held.linkChangedAt = at; this.subscribe(machine); continue; }
-      held.linkChangedAt = at;
-    }
   }
   let(machine, why) {
     const held = this.held.get(machine); if (!held) return;
@@ -245,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?.(); };
@@ -316,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

@@ -622,6 +622,7 @@ export class TeamsMachine extends MachineCore {
           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
@@ -634,6 +635,9 @@ export class TeamsMachine extends MachineCore {
         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`);
@@ -794,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
@@ -817,8 +836,10 @@ 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();
+        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();
       }, (error) => {

package/package.json

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