@volter/supercode-teams 0.3.129 → 0.3.131

package/bin/fleet.mjs

@@ -162,19 +162,50 @@ async function main() {
         if (typeof flags.for === 'string') setTimeout(() => { fc.detachChannel(); channel.close(); process.exit(0); }, Number(flags.for));
         return;
       }
-      const term = await attachPane(channel, { pane, mode, cols: process.stdout.columns ?? 120, rows: process.stdout.rows ?? 40, acting: await launcher() });
-      term.on('hello', (frame) => process.stderr.write(`[attached ${pane} ${frame.cols}x${frame.rows}${mode === 'control' ? ' — ctrl-] detaches' : ''}]\n`));
-      term.on('error-message', (message) => process.stderr.write(`[${message}]\n`));
-      term.on('data', (text) => process.stdout.write(text));
-      term.on('close', (reason) => { process.stderr.write(`\n[detached${reason ? `: ${reason}` : ''}]\n`); channel.close(); process.exit(0); });
+      // The view outlives a restart of the machine daemon (an upgrade restarts it; the pane itself lives in the pane
+      // host and goes on): when the daemon's connection drops, this window attaches again once it answers, for up to
+      // REATTACH_MS. The pane ending, a refusal, or ctrl-] ends the view as before.
+      const REATTACH_MS = 180_000;
+      let term = null;
+      let detaching = false;
+      const attach = async (into) => {
+        const next = await attachPane(into, { pane, mode, cols: process.stdout.columns ?? 120, rows: process.stdout.rows ?? 40, acting: await launcher() });
+        next.on('hello', (frame) => process.stderr.write(`[attached ${pane} ${frame.cols}x${frame.rows}${mode === 'control' ? ' — ctrl-] detaches' : ''}]\n`));
+        next.on('error-message', (message) => process.stderr.write(`[${message}]\n`));
+        next.on('data', (text) => process.stdout.write(text));
+        next.on('close', (reason) => {
+          into.close();
+          if (!detaching && typeof reason === 'string' && reason.startsWith('connection closed')) { void reattach(); return; }
+          process.stderr.write(`\n[detached${reason ? `: ${reason}` : ''}]\n`);
+          process.exit(0);
+        });
+        term = next;
+      };
+      const reattach = async () => {
+        process.stderr.write('\n[the machine daemon went away (an upgrade restarts it); attaching again when it is back…]\n');
+        const deadline = Date.now() + REATTACH_MS;
+        let last = null;
+        while (Date.now() < deadline) {
+          await new Promise((done) => setTimeout(done, 1_000));
+          try { await attach(await channelForOn()); return; } catch (error) {
+            last = error;
+            // the daemon saying this pane is gone (`terminal refused: no pane …`) will not change by waiting; a daemon not
+            // answering yet (ECONNREFUSED, no pipe) will
+            if (/terminal refused: .*(no pane|no \w+ on pane)/i.test(error?.message ?? '')) break;
+          }
+        }
+        process.stderr.write(`\n[detached: the machine daemon did not take this pane back${last ? ` (${last.message})` : ''}]\n`);
+        process.exit(1);
+      };
+      await attach(channel);
       if (mode === 'control' && process.stdin.isTTY) {
         process.stdin.setRawMode(true);
         process.stdin.on('data', (chunk) => {
-          if (chunk[0] === 0x1d) { term.close(); return; } // ctrl-] detaches
-          term.write(chunk.toString('utf8'));
+          if (chunk[0] === 0x1d) { detaching = true; term?.close(); return; } // ctrl-] detaches
+          term?.write(chunk.toString('utf8'));
         });
       }
-      process.stdout.on('resize', () => term.resize(process.stdout.columns, process.stdout.rows));
+      process.stdout.on('resize', () => term?.resize(process.stdout.columns, process.stdout.rows));
       return;
     }
     default:

package/mail/relay.mjs

@@ -373,8 +373,8 @@ export class Relays {
    */
   /** Whether `sender`'s relay still holds a send queued (its queue file, written within SEND_TIMEOUT_MS twice over): a
    *  relay runtime outlives a daemon that ended mid-send and may still make it. */
-  sending(sender) {
-    try { return Date.now() - statSync(this.spec(sender).queue).mtimeMs < 2 * SEND_TIMEOUT_MS; } catch { return false; }
+  sending(sender, senderName) {
+    try { return Date.now() - statSync(this.spec(sender, senderName).queue).mtimeMs < 2 * SEND_TIMEOUT_MS; } catch { return false; }
   }
 
   /** Whether message `messageId` from `sender` landed in Claude session `sessionId`'s transcript, as a relay send reads

package/mail/send.mjs

@@ -330,13 +330,29 @@ export class MailSend {
       // at its first tool call finds it, and a daemon that ends before the relay answers (an upgrade's restart, a crash)
       // leaves it for the carrier, which hands it over again (t_b0f9a2a0: filed read before, such a send was lost). It is
       // read once the relay has made it; a relay that fails takes back the copy this delivery filed
+      // never beside another hand-over of the same message: one running here, one a relay that outlived its daemon may
+      // still be making, or one an earlier daemon made that landed (every path: a wake's handOver, an agent's re-plan)
+      const key = `${to}\n${handed.id}`;
+      const unanswered = (detail) => Object.assign(new Error(detail), { unanswered: true });
+      if (this.relaying.has(key)) throw unanswered('its relay send is still running here');
+      const earlier = this.store.hasWake(to, handed.id) ? this.store.wakeState(to, handed.id).handover_at_ms : null;
+      if (earlier != null) {
+        if (this.relays.sending?.(handed.from, handed.from_name)) throw unanswered('its relay may still be making it');
+        let landed = false;
+        try { landed = await this.relays.landed(door.session.address.split(':').slice(3).join(':'), handed.id, handed.from); } catch { /* unread: hand it over */ }
+        if (landed) {
+          try { this.store.claimFor(to, handed.id, { pid: process.pid, via: 'door', caller: null, recipient: true, at_ms: Date.now() }); } catch { /* best kept */ }
+          const now = this.store.findIn(to, handed.id);
+          if (now?.state === 'unread') { try { this.store.markRead(to, now.path); } catch { /* moved meanwhile */ } }
+          return 'already';
+        }
+      }
       const filedHere = this.store.findIn(to, handed.id) == null;
       const filed = this.store.deliver(to, handed);
       if (wake && !this.store.hasWake(to, handed.id)) {
         // its hand-over begins now: a daemon that restarts reads the receiver's transcript before sending it again
         try { this.store.requestWake(to, handed.id); this.store.setWakeState(to, handed.id, { attempts: 0, next_at_ms: Date.now() + RELAY_GRACE_MS, handover_at_ms: Date.now() }); } catch { /* the relay's own outcome stands */ }
       }
-      const key = `${to}\n${handed.id}`;
       this.relaying.add(key);
       let relayed;
       try { relayed = await this.relays.send(handed.from, handed.from_name, { sessionId: door.session.address.split(':').slice(3).join(':'), name: door.session.name.split('@')[0], socket: door.session.socket }, text, handed.id); }
@@ -783,19 +799,6 @@ export class MailSend {
     // tried again after its backoff, settled by that hand-over's own outcome
     const key = `${address}\n${id}`;
     if (this.handing.has(key) || this.relaying.has(key)) return { outcome: 'later', detail: 'its hand-over is still in progress' };
-    // an earlier hand-over never settled (the daemon ended mid-way): one its receiver's transcript holds landed, and is
-    // read; any other is handed over again, never given up (t_b0f9a2a0)
-    if (state.handover_at_ms != null && door.kind === 'native') {
-      // a relay that outlived its daemon may still be making that send (its queue still there, fresh): waited for, never
-      // sent beside it (#1264 review P2a)
-      if (this.relays.sending?.(sent.from, id)) return { outcome: 'later', detail: 'its relay may still be making it' };
-      let landed = false;
-      try { landed = await this.relays.landed(door.session.address.split(':').slice(3).join(':'), id, sent.from); } catch { /* unread: hand it over */ }
-      if (landed) {
-        try { this.store.claimFor(address, id, { pid: process.pid, via: 'door', caller: null, recipient: true, at_ms: Date.now() }); this.store.markRead(address, found.path); } catch { /* moved meanwhile */ }
-        return { outcome: 'filed', detail: 'an earlier hand-over landed' };
-      }
-    }
     this.store.setWakeState(address, id, { ...state, handover_at_ms: Date.now() });
     this.handing.add(key);
     try {

package/package.json

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