@volter/supercode-teams 0.3.159 → 0.3.161

package/connector/index.mjs

@@ -1117,10 +1117,10 @@ export class TeamsConnector {
       let started=null;
       try{
         const seen=this.origins[key]?.capture_stamps?.[options.ruleId];
-        // an unchanged stamp satisfies the messages, not a native bundle still owed and ready to be taken
+        // An unchanged stamp cannot satisfy a held full capture or a native bundle ready to be taken.
         const artifact=(()=>{try{return statSync(realpathSync(options.locator.storage.path));}catch{return null;}})();
         const nativeOwed=Boolean(this.origins[key]?.native_deferred&&artifact&&this.nativeReady(key,artifact));
-        if(options.live&&!nativeOwed&&seen?.rule_revision===options.ruleRevision&&seen.stamp===this.sessionStamp(options))continue;
+        if(options.live&&!nativeOwed&&!this.redactionHolds.needed(key)&&seen?.rule_revision===options.ruleRevision&&seen.stamp===this.sessionStamp(options))continue;
         const artifactBefore=statSync(realpathSync(options.locator.storage.path));
         // A session is loaded again no sooner than ten times its last load took (a 0.5 s load: every 5 s; a load
         // that takes minutes: every LARGE_CAPTURE_EVERY_MS), so a live session streams while the lanes stay light.

package/live-sessions.mjs

@@ -478,11 +478,20 @@ export class LiveSessions extends EventEmitter {
     return this.paneRoots.find((root) => root.pid === entry.pid)?.pane ?? entry.tmux ?? null;
   }
 
+  /** Delivery never uses the registry's tmux label: a headless process can
+   * inherit another session's label. Only this daemon's pane/process reading
+   * binds input to the addressed native conversation. */
+  #claudeDeliveryPane(entry) {
+    return this.paneRoots.find((root) => root.activity?.harness === 'claude-code'
+      && root.activity.session_id === entry.sessionId)?.pane ?? null;
+  }
+
   /** The daemon's live panes and their root processes (`[{ pane, pid }]`), as the records read them: the panes of the
    *  sessions whose own records name none (Grok's; Claude's on Windows). */
-  panes(roots) {
-    const placed = () => JSON.stringify([...[...this.grok].map(([id, entry]) => [id, entry.pane]), ...[...this.claude.values()].map((entry) => [entry.sessionId, this.#claudePane(entry)])]);
+  panes(roots, { current = true } = {}) {
+    const placed = () => JSON.stringify([this.panesCurrent === true, ...[...this.grok].map(([id, entry]) => [id, entry.pane]), ...[...this.claude.values()].map((entry) => [entry.sessionId, this.#claudePane(entry), this.#claudeDeliveryPane(entry)])]);
     const before = placed();
+    this.panesCurrent = current;
     this.paneRoots = (roots ?? []).filter((root) => root?.pane && Number.isInteger(root.pid));
     for (const entry of this.grok.values()) this.#grokPane(entry);
     if (placed() !== before) this.#changed();
@@ -656,7 +665,7 @@ export class LiveSessions extends EventEmitter {
       if (entry.name.startsWith(RELAY_PREFIX) || !alive(entry.pid)) continue;
       const address = this.#address('claude-code', entry.sessionId);
       if (seen.has(address)) continue; seen.add(address);
-      out.push({ address, name: `${entry.name}@${this.machine}`, status: entry.status, door: 'native', pid: entry.pid, cwd: entry.cwd, pane: this.#claudePane(entry), tools: this.hasTools(entry.pid), socket: entry.socket ?? null });
+      out.push({ address, name: `${entry.name}@${this.machine}`, status: entry.status, door: 'native', pid: entry.pid, cwd: entry.cwd, pane: this.#claudePane(entry), delivery_pane: this.#claudeDeliveryPane(entry), panes_current: this.panesCurrent === true, tools: this.hasTools(entry.pid), socket: entry.socket ?? null });
     }
     const codex = new Set([...this.codexRunning.keys(), ...this.codexPaneOf.keys()]);
     for (const sessionId of codex) {

package/machine-records.mjs

@@ -5,8 +5,7 @@
 // its mail folder's file events); a subscriber gets a snapshot and then every change, and holds the latest of each
 // machine it follows. A held record says how current it is: its producer's time, its stream's state and why it is not
 // open. A machine with no record is said as unread, with why; nothing reads a stale or missing record as absent.
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
+import { RecordState } from './record-state.mjs';
 
 /** How many of each mailbox's newest messages a record carries beside its unread mail: enough for `show` of what a
  *  session was just sent or just read, small enough that a busy machine's record stays a few hundred kilobytes. */
@@ -31,20 +30,25 @@ const TOO_OLD_RETRY_MS = 60_000;
  * (a mailbox's address). `touch(section, detail)` is an event; changed sections reach every subscriber as one delta.
  */
 export class RecordProducer {
-  constructor({ machine, readers, log = () => {} }) {
+  constructor({ machine, readers, store, log = () => {} }) {
     this.machine = machine; this.readers = readers; this.log = log;
-    this.record = { machine, seq: 0, at: null, sessions: null, panes: null, capabilities: null, mail: {} };
-    this.unread = {}; // section → why its last read failed (said in the record, never an empty section)
+    this.state = new RecordState(store, 'producer'); this.changes = store.changes;
+    this.record = this.state.load(machine)?.record ?? { machine, seq: 0, at: null, sessions: null, panes: null, capabilities: null, mail: {} };
+    this.unread = { ...this.record.unread };
+    if (this.record.seq) for (const section of SECTIONS) this.unread[section] = 'held from the previous daemon; awaiting this source\'s current snapshot';
+    this.record.unread = { ...this.unread };
     this.subscribers = new Map(); this.due = new Map(); this.timer = null; this.reading = null; this.lastRead = 0; // write → its granted sections (null: all)
     this.retries = new Map(); // section → { timer, backoff }: a failed read holds its retry until a read passes
   }
   /** Every section read once (the record's first snapshot), and the stream's heartbeat started. */
   start() {
     for (const section of SECTIONS) this.touch(section);
-    this.beat = setInterval(() => { const frame = JSON.stringify({ type: 'beat', machine: this.machine, seq: this.record.seq, at: Date.now() }) + '\n'; for (const write of this.subscribers.keys()) write(frame); }, BEAT_MS);
+    this.beat = setInterval(() => {
+      for (const subscriber of this.subscribers.values()) if (subscriber.expected === this.record.seq) subscriber.send({ type: 'beat', machine: this.machine, seq: subscriber.expected, cursor: subscriber.cursor, at: Date.now() });
+    }, BEAT_MS);
     this.beat.unref?.();
   }
-  stop() { this.stopped = true; clearInterval(this.beat); clearTimeout(this.timer); for (const { timer } of this.retries.values()) clearTimeout(timer); this.retries.clear(); this.subscribers.clear(); }
+  stop() { this.stopped = true; clearInterval(this.beat); clearTimeout(this.timer); for (const { timer } of this.retries.values()) clearTimeout(timer); this.retries.clear(); for (const subscriber of this.subscribers.values()) subscriber.end(); }
   /** A section's read failed: it is read again after a backoff (2 s doubling to 5 min) until a read passes. */
   retry(section, detail) {
     if (this.stopped) return;
@@ -82,8 +86,10 @@ export class RecordProducer {
     // a read in progress takes what is due when it ends (its finally schedules the next settle)
     if (this.reading) return;
     const due = this.due; this.due = new Map();
+    let commitFailed = false;
     this.reading = (async () => {
       const changed = {};
+      const record = { ...this.record };
       if (this.noted) { this.noted = false; changed.unread = { ...this.unread }; }
       for (const [section, details] of due) {
         const reader = this.readers[section];
@@ -91,15 +97,17 @@ export class RecordProducer {
         try {
           if (section === 'mail' && !details.has('*')) {
             const boxes = await reader([...details]);
-            const mail = { ...this.record.mail };
+            if (this.stopped) return;
+            const mail = { ...record.mail };
             for (const address of details) { if (boxes[address]) mail[address] = boxes[address]; else delete mail[address]; }
-            if (JSON.stringify(mail) !== JSON.stringify(this.record.mail)) { this.record.mail = mail; changed.mail = Object.fromEntries([...details].map((address) => [address, mail[address] ?? null])); }
+            if (JSON.stringify(mail) !== JSON.stringify(record.mail)) { record.mail = mail; changed.mail = Object.fromEntries([...details].map((address) => [address, mail[address] ?? null])); }
           } else {
             const value = await reader(null);
-            if (JSON.stringify(value) !== JSON.stringify(this.record[section])) {
+            if (this.stopped) return;
+            if (JSON.stringify(value) !== JSON.stringify(record[section])) {
               // the sessions go as rows changed and gone (by address), not the whole list each turn
-              changed[section] = section === 'mail' ? { '*': value } : section === 'sessions' && Array.isArray(this.record.sessions) && Array.isArray(value) ? rowDelta(this.record.sessions, value) : value;
-              this.record[section] = value;
+              changed[section] = section === 'mail' ? { '*': value } : section === 'sessions' && Array.isArray(record.sessions) && Array.isArray(value) ? rowDelta(record.sessions, value) : value;
+              record[section] = value;
             }
           }
           if (this.unread[section]) { delete this.unread[section]; changed.unread = { ...this.unread }; }
@@ -111,21 +119,63 @@ export class RecordProducer {
           this.retry(section, details.has('*') ? null : [...details]);
         }
       }
-      if (!Object.keys(changed).length) return;
-      this.record.seq += 1; this.record.at = Date.now(); this.record.unread = { ...this.unread };
-      // every follower gets every delta (its sequence continues), each with only the sections it is granted
-      for (const [write, allowed] of this.subscribers) write(JSON.stringify({ type: 'delta', machine: this.machine, seq: this.record.seq, at: this.record.at, sections: granted(changed, allowed) }) + '\n');
+      if (this.stopped || !Object.keys(changed).length) return;
+      record.seq += 1; record.at = Date.now(); record.unread = { ...this.unread };
+      record.cursor = this.state.save(record, changed, { publish: true });
+      this.record = record;
     })();
     // reads are spaced from the end of the last one: a read longer than the interval is never followed at once
-    try { await this.reading; } finally { this.reading = null; this.lastRead = Date.now(); if (this.due.size || this.noted) this.schedule(); }
+    try { await this.reading; }
+    catch (error) {
+      if (!this.stopped) {
+        commitFailed = true;
+        this.log(`machine record: its changed rows could not be committed: ${error.message}`);
+        for (const [section, details] of due) this.retry(section, details.has('*') ? null : [...details]);
+        if (!due.size) this.retry('mail', null);
+        this.noted = true;
+      }
+    } finally { this.reading = null; this.lastRead = Date.now(); if (!commitFailed && (this.due.size || this.noted)) this.schedule(); }
   }
   /** A subscriber: its snapshot now, then each change. Answers its unsubscribe. */
   /** A subscriber: its snapshot now, then each change, with only the sections `allowed` (null: all; a section not
    *  granted is left out, said in its `unread`). Answers its unsubscribe. */
-  subscribe(write, allowed = null) {
-    write(JSON.stringify({ type: 'snapshot', record: grantedRecord(this.record, allowed) }) + '\n');
-    this.subscribers.set(write, allowed);
-    return () => this.subscribers.delete(write);
+  subscribe(write, allowed = null, { after = null, sequence = null, sections = null } = {}) {
+    const scope = allowed ? [...allowed].sort() : null;
+    const subscriber = { cursor: after, expected: sequence, closed: false };
+    subscriber.end = () => { subscriber.closed = true; subscriber.stop?.(); this.subscribers.delete(write); };
+    subscriber.send = (frame) => {
+      if (subscriber.closed) return;
+      try { write(JSON.stringify(frame) + '\n'); } catch { subscriber.end(); }
+    };
+    this.subscribers.set(write, subscriber);
+    const resumable = Number.isSafeInteger(sequence) && sequence >= 0 && JSON.stringify(scope) === JSON.stringify(sections);
+    subscriber.stop = this.changes.follow((page) => {
+      if (subscriber.closed || this.stopped) return;
+      if (page.error) { subscriber.end(); return; }
+      const snapshot = () => {
+        const cursor = this.changes.cursor();
+        subscriber.resumed = true;
+        subscriber.expected = this.record.seq; subscriber.cursor = cursor;
+        subscriber.send({ type: 'snapshot', record: { ...grantedRecord(this.record, allowed), cursor, sections_granted: scope } });
+        return cursor;
+      };
+      if (page.reset || subscriber.expected == null) return snapshot();
+      if (!subscriber.resumed) {
+        subscriber.resumed = true;
+        subscriber.send({ type: 'resume', machine: this.machine, seq: subscriber.expected, cursor: after, sections_granted: scope });
+      }
+      for (const change of page.changes) {
+        if (change.key.machine !== this.machine) continue;
+        if (change.value?.seq !== subscriber.expected + 1) return snapshot();
+        subscriber.expected = change.value.seq;
+        subscriber.cursor = { id: page.cursor.id, sequence: change.sequence };
+        subscriber.send({ type: 'delta', machine: this.machine, seq: subscriber.expected, cursor: subscriber.cursor, at: change.value.at, sections: granted(change.value.sections, allowed) });
+      }
+      if (!page.more && subscriber.expected !== this.record.seq) return snapshot();
+      subscriber.cursor = page.cursor;
+      subscriber.send({ type: 'cursor', machine: this.machine, seq: subscriber.expected, cursor: page.cursor, caught_up: !page.more });
+    }, { after: resumable ? after : null, topics: ['machine-record'], initial: true });
+    return subscriber.end;
   }
 }
 
@@ -179,28 +229,24 @@ function notGranted(error) {
  * said so, its last record kept as stale.
  */
 export class RecordHolder {
-  constructor({ self, open, file, log = () => {} }) {
+  constructor({ self, open, file, store, log = () => {} }) {
     this.self = self; this.open = open; this.file = file; this.log = log;
+    this.state = new RecordState(store, 'holder');
     this.held = new Map(); // machine → { record, state: open|opening|closed|too-old|unlinked, since, why, received_at, stream, retry, backoff }
     this.load();
   }
   load() {
-    let saved = {};
-    try { saved = JSON.parse(readFileSync(this.file, 'utf8')).machines ?? {}; } catch { /* none kept yet */ }
+    this.state.importLegacy(this.file);
     // a record kept from before this daemon started is stale until its machine's stream gives it again
-    for (const [machine, kept] of Object.entries(saved)) this.held.set(machine, { record: kept.record ?? null, state: 'closed', since: kept.received_at ?? null, why: 'held from before this daemon started; not read since', received_at: kept.received_at ?? null });
+    for (const [machine, kept] of this.state.all()) this.held.set(machine, { record: kept.record, state: 'closed', since: kept.meta?.received_at ?? null, why: 'held from before this daemon started; not read since', received_at: kept.meta?.received_at ?? null });
   }
-  save() {
-    if (this.saving) return; this.saving = true;
-    setTimeout(() => {
-      this.saving = false;
-      try {
-        mkdirSync(dirname(this.file), { recursive: true, mode: 0o700 });
-        const machines = Object.fromEntries([...this.held].map(([machine, held]) => [machine, { record: held.record, received_at: held.received_at }]));
-        const temp = `${this.file}.${process.pid}.tmp`;
-        writeFileSync(temp, JSON.stringify({ version: 1, machines }) + '\n', { mode: 0o600 }); renameSync(temp, this.file);
-      } catch (error) { this.log(`machine records could not be kept: ${error.message}`); }
-    }, 500).unref?.();
+  save(machine, changed = {}) {
+    if (this.closed) return;
+    const held = this.held.get(machine);
+    const meta = { received_at: held?.received_at ?? null, stream: held?.state ?? 'closed', since: held?.since ?? null, why: held?.why ?? null };
+    if (held?.record) this.state.save(held.record, changed, { meta });
+    else if (held) this.state.saveEmpty(machine, meta);
+    else this.state.remove(machine);
   }
   /** The linked machines of this machine's team, from the presence stream (its own events): followed or let go. */
   follow(items) {
@@ -208,9 +254,7 @@ export class RecordHolder {
     const linked = new Set((items ?? []).filter((item) => item.linked).map((item) => normal(item.name)).filter((name) => name && name !== this.self));
     // a machine no longer in the team is forgotten (its record too); one in it but not linked is offline: unlinked,
     // its last record kept as offline (readers leave it out, as they leave out any machine that is not online)
-    let forgot = false;
-    for (const machine of [...this.held.keys()]) if (!team.has(machine)) { this.let(machine, 'no longer in the team'); this.held.delete(machine); forgot = true; }
-    if (forgot) this.save();
+    for (const machine of [...this.held.keys()]) if (!team.has(machine)) { this.let(machine, 'no longer in the team'); this.held.delete(machine); this.state.remove(machine); }
     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); }
   }
@@ -219,12 +263,14 @@ export class RecordHolder {
     clearTimeout(held.retry); held.retry = null; clearTimeout(held.quiet); held.attempt = null;
     try { held.stream?.close?.(); held.stream?.destroy?.(); } catch { /* closed */ }
     Object.assign(held, { stream: null, state: 'unlinked', since: Date.now(), why });
+    this.save(machine);
   }
   subscribe(machine) {
     const held = this.held.get(machine) ?? { record: null, received_at: null, backoff: 0 };
     this.held.set(machine, held);
     clearTimeout(held.retry); held.retry = null; clearTimeout(held.quiet);
     Object.assign(held, { state: 'opening', why: null });
+    this.save(machine);
     let buffer = '';
     const attempt = {}; held.attempt = attempt;
     const closed = (why, state = 'closed') => {
@@ -234,6 +280,7 @@ export class RecordHolder {
       const stream = held.stream;
       held.attempt = null;
       Object.assign(held, { stream: null, state, since: Date.now(), why: String(why ?? 'the stream closed').slice(0, 300) });
+      this.save(machine);
       try { stream?.close?.(); } catch { /* closing */ }
       // 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
@@ -251,6 +298,7 @@ export class RecordHolder {
     // the opener attaches these at once, before the stream can deliver anything: the snapshot and each delta after it
     // are applied in order, none lost to a listener attached late
     const sink = {
+      resume: held.record?.cursor ? { after: held.record.cursor, sequence: held.record.seq, sections: held.record.sections_granted ?? null } : {},
       data: (chunk) => {
         if (held.attempt !== attempt) return;
         heard();
@@ -260,7 +308,9 @@ export class RecordHolder {
           const line = buffer.slice(0, at); buffer = buffer.slice(at + 1);
           if (!line) continue;
           let frame; try { frame = JSON.parse(line); } catch { continue; }
-          const gap = this.apply(machine, held, frame);
+          let gap;
+          try { gap = this.apply(machine, held, frame); }
+          catch (error) { closed(`its record rows could not be applied: ${error.message}`); return; }
           if (gap) { closed(gap); return; }
         }
       },
@@ -273,7 +323,7 @@ export class RecordHolder {
     }, (error) => {
       // refused for want of any grant (the machine's or its records door's): what was read under the grant is not
       // kept, here or in the saved file; a grant given again reads it afresh
-      if (held.attempt === attempt && notGranted(error) && held.record) { held.record = null; held.received_at = null; this.save(); }
+      if (held.attempt === attempt && notGranted(error) && held.record) { held.record = null; held.received_at = null; this.save(machine); }
       // a daemon from before machine records (supercode v0.5.200) has no such door: too old to read, not a stream
       // that closed; asked again on the same backoff, so an update is read once it runs
       const message = String(error?.message ?? error);
@@ -282,19 +332,35 @@ export class RecordHolder {
     });
   }
   apply(machine, held, frame) {
+    let changed = {};
     if (frame.type === 'snapshot' && frame.record) {
+      if (frame.record.machine !== machine) return `the snapshot names ${frame.record.machine}, not ${machine}`;
       held.record = frame.record;
+      changed = { sessions: frame.record.sessions, mail: { '*': frame.record.mail ?? {} }, panes: frame.record.panes, capabilities: frame.record.capabilities, unread: frame.record.unread ?? {} };
+    } else if (frame.type === 'resume') {
+      if (!held.record || frame.seq !== held.record.seq || frame.cursor?.id !== held.record.cursor?.id || JSON.stringify(frame.sections_granted) !== JSON.stringify(held.record.sections_granted)) return 'the resumed record does not match the held snapshot or its grants';
+      Object.assign(held, { state: 'catching-up', why: 'resuming its retained row changes' });
+      this.save(machine);
+      return null;
+    } else if (frame.type === 'cursor') {
+      if (!held.record || frame.seq !== held.record.seq || frame.cursor?.id !== held.record.cursor?.id) return 'the record cursor does not match its applied sequence';
+      held.record.cursor = frame.cursor;
+      Object.assign(held, { state: frame.caught_up ? 'open' : 'catching-up', why: frame.caught_up ? null : 'resuming its retained row changes', received_at: Date.now(), backoff: 0 });
+      this.save(machine);
+      return null;
     } else if (frame.type === 'beat') {
       // a beat at the held sequence keeps the record fresh; one past it is a delta this stream lost: read anew
       if (held.state !== 'open' || frame.seq !== held.record?.seq) return `a beat at sequence ${frame.seq} does not match the held record (${held.state === 'open' ? held.record?.seq : 'no snapshot yet'}): read again from a snapshot`;
       // a beat changes nothing kept: only how recently the machine answered
       held.received_at = Date.now(); held.backoff = 0;
+      if (frame.cursor?.id === held.record.cursor?.id) { held.record.cursor = frame.cursor; this.save(machine); }
       return null;
     } else if (frame.type === 'delta') {
       // a delta that does not follow the held sequence (or comes before this stream's snapshot) is a gap: the stream is
       // read again from a snapshot
-      if (held.state !== 'open' || frame.seq !== held.record?.seq + 1) return `a delta at sequence ${frame.seq} does not follow the held record (${held.state === 'open' ? held.record?.seq : 'no snapshot yet'}): read again from a snapshot`;
-      const record = { ...held.record, seq: frame.seq, at: frame.at };
+      if (!['open', 'catching-up'].includes(held.state) || frame.seq !== held.record?.seq + 1) return `a delta at sequence ${frame.seq} does not follow the held record (${held.record?.seq ?? 'no snapshot yet'}): read again from a snapshot`;
+      const record = { ...held.record, seq: frame.seq, at: frame.at, ...(frame.cursor ? { cursor: frame.cursor } : {}) };
+      if (frame.cursor && held.record.cursor?.id !== frame.cursor.id) return 'the delta names a different record database';
       for (const [section, value] of Object.entries(frame.sections ?? {})) {
         if (section === 'unread') record.unread = value;
         else if (section === 'sessions' && value?.delta) {
@@ -310,9 +376,11 @@ export class RecordHolder {
         } else record[section] = value;
       }
       held.record = record;
+      changed = frame.sections ?? {};
     } else return null;
-    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();
+    const catchingUp = held.state === 'catching-up' && frame.type !== 'snapshot';
+    Object.assign(held, { state: catchingUp ? 'catching-up' : 'open', since: held.state === 'open' ? held.since : Date.now(), why: catchingUp ? 'resuming its retained row changes' : null, received_at: Date.now(), backoff: 0, saidTooOld: false });
+    this.save(machine, changed);
     return null;
   }
   /** Every followed machine's latest record and how current it is. */