@volter/supercode-teams 0.3.126 → 0.3.127

package/mail/relay.mjs

@@ -371,6 +371,18 @@ export class Relays {
    * (claude_relay.rs `send_through_relay`): the receiver is named by its own socket (`uds:<path>`), unique to it, never
    * by its name. One send at a time per relay; a relay whose process is proven dead is started again once.
    */
+  /** 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; }
+  }
+
+  /** Whether message `messageId` from `sender` landed in Claude session `sessionId`'s transcript, as a relay send reads
+   *  an unconfirmed outcome (send.mjs handOver asks it of a hand-over the daemon did not live to settle). */
+  async landed(sessionId, messageId, sender) {
+    return this.arrived(sessionId, `cross-session-message id=\\"${shortId(messageId)}\\" from=\\"${sender}\\"`);
+  }
+
   async send(sender, senderName, receiver, message, messageId) {
     const spec = this.spec(sender, senderName);
     const asked = performance.now();

package/mail/send.mjs

@@ -25,6 +25,12 @@ export function unansweredText(where, detail, id) {
 
 /** How long a send waits, in a daemon's first moments, for its Codex sessions to be known before it resolves a receiver. */
 const CODEX_KNOWN_WAIT_MS = 20_000;
+// A relayed message's wake is due this long after its relay send begins: a send still running here holds it (handOver),
+// so it fires only for a send the daemon did not live to finish (t_b0f9a2a0)
+const RELAY_GRACE_MS = 30_000;
+/** The kinds of delivery that hand nothing over (#deliverWoken's `how`): the copy waits filed. An operator's mailbox,
+ *  which its operator reads, and a session's hook, which shows it, are deliveries. */
+const LEFT_FILED = new Set(['queued', 'stored', 'pane_held', 'pane_waits', 'not_running']);
 
 /** Replies in one unbroken chain between two sessions beyond which another is refused. */
 const REPLY_CHAIN_LIMIT = 32;
@@ -53,6 +59,7 @@ export class MailSend {
   constructor({ machine, mailRoot, live, store, agents, relays, askMachine, deliverRuntime, codexAnswer, typeTurn, log = () => {} }) {
     Object.assign(this, { machine, mailRoot, live, store, agents, relays, askMachine, deliverRuntime, codexAnswer, typeTurn, log });
     this.handing = new Set(); // `<address>\n<id>` of each hand-over running here (handOver)
+    this.relaying = new Set(); // `<address>\n<id>` of each relay send running here (route): its wake waits for it
   }
 
   // ---- one send ----------------------------------------------------------------------------------------------------
@@ -319,11 +326,21 @@ export class MailSend {
       const handed = sent.reply_via?.mode === 'command' && door.session.tools ? { ...sent, reply_via: { mode: 'tool' } } : sent;
       const text = render(handed);
       if (Buffer.byteLength(text) > MAX_RELAYED_BYTES) throw new Refused('too_long', Buffer.byteLength(text));
-      // filed before it is handed over: a session that reads its mailbox at its first tool call finds it; a relay that
-      // fails takes back the copy this delivery filed
+      // filed before it is handed over, unread, with a wake due RELAY_GRACE_MS from now: a session that reads its mailbox
+      // 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
       const filedHere = this.store.findIn(to, handed.id) == null;
-      const filed = this.store.deliverRead(to, handed);
-      const 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);
+      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); }
+      finally { this.relaying.delete(key); }
       // a send the relay may have made keeps its copy and is unanswered, never taken back and said not sent; only one the
       // relay is known not to have made (refused, never handed in) takes its copy back. One its receiver read from its
       // mailbox meanwhile (its recipient claim) has reached it. Otherwise the relay can no longer make it (its queue is
@@ -331,7 +348,8 @@ export class MailSend {
       // goes back unread, for the receiver's own mailbox read and the mailbox's wake, which hands it over again
       const received = this.store.claimOf(to, handed.id)?.recipient === true;
       if (!relayed.delivered && relayed.unknown && !received) {
-        if (filedHere) { try { this.store.markUnread(to, filed); if (wake) this.store.requestWake(to, handed.id); } catch { /* kept read */ } }
+        // kept unread, its wake due now: the carrier hands it over again after its backoff
+        if (filedHere && wake) { try { this.store.requestWake(to, handed.id); } catch { /* the wake filed above stands */ } }
         throw Object.assign(new Error(relayed.detail), { unanswered: true });
       }
       if (!relayed.delivered && !received) { if (filedHere) { try { unlinkSync(filed); } catch { /* gone */ } } throw new Error(relayed.detail); }
@@ -378,10 +396,19 @@ export class MailSend {
     const reached = [], copied = [], failed = [];
     let recorded = false;
     const held = []; // recipients whose own copy is held unread with its wake (an unanswered relay)
+    let agentKey = null;
     if (plan.agent) {
-      // the agent's own mailbox keeps the record of what was addressed to it
-      try { this.store.deliverRead(plan.agent, sent); recorded = true; } catch (error) { failed.push(`the agent's mailbox (${error.message})`); }
+      // the agent's own mailbox keeps the record of what was addressed to it: unread, with a wake due RELAY_GRACE_MS on,
+      // until a recipient has it, so a daemon that ends while the plan runs (a resume, a relay send, another machine
+      // asked) leaves it for the carrier to plan again (#1264 review P1). While this plan runs its wake waits for it
+      try {
+        const fresh = this.store.findIn(plan.agent, sent.id) == null;
+        this.store.deliver(plan.agent, sent); recorded = true;
+        if (fresh && !this.store.hasWake(plan.agent, sent.id)) { this.store.requestWake(plan.agent, sent.id); this.store.setWakeState(plan.agent, sent.id, { attempts: 0, next_at_ms: Date.now() + RELAY_GRACE_MS }); }
+        agentKey = `${plan.agent}\n${sent.id}`; this.relaying.add(agentKey);
+      } catch (error) { failed.push(`the agent's mailbox (${error.message})`); }
     }
+    try {
     const sessions = this.live.sessions();
     for (const recipient of plan.recipients.filter((item) => item.address !== caller.address)) {
       const label = this.#label(sessions, recipient.address);
@@ -390,7 +417,16 @@ export class MailSend {
         try { this.#fileUnread(recipient.address, sent); copied.push(label); } catch (error) { failed.push(`${label} (${error.message})`); }
         continue;
       }
-      try { reached.push(`${label} (${await this.#deliverWoken(sent, recipient.address, sessions, queue, notify_when_idle)})`); }
+      try {
+        const { how, text: said } = await this.#deliverWoken(sent, recipient.address, sessions, queue, notify_when_idle);
+        // only a hand-over is a reach: a copy left filed with nothing to carry it (queued, stored, held in the daemon's
+        // memory for a pane, or for a session not running) is held when its own wake carries it, and otherwise the
+        // agent's copy keeps its retry (t_b0f9a2a0: such a send was counted reached, and nothing carried it). One the
+        // sender asked to queue (--queue) is held as asked: its receiver reads it at its next turn
+        if (!LEFT_FILED.has(how)) reached.push(`${label} (${said})`);
+        else if (this.store.hasWake(recipient.address, sent.id) || (queue && how === 'queued')) held.push(`${label} (${said})`);
+        else failed.push(`${label} (${said}; handed over again when it can be)`);
+      }
       catch (error) {
         // held only when its copy is here, unread: its wake hands it over, or (queued, no wake) the receiver's own read
         // does. An unanswered request to another machine's door holds nothing here, so it is a failure, and the agent's
@@ -400,6 +436,7 @@ export class MailSend {
         else failed.push(error.unanswered ? `${label} (unanswered, whether it arrived is unknown: ${error.message})` : `${label} (${error.message})`);
       }
     }
+    } finally { if (agentKey) this.relaying.delete(agentKey); }
     const thread = plan.thread ? ` Thread ${shortId(plan.thread.id)}.` : '';
     // agent mail that reached nobody is never left only as a read record: its copy in the agent's mailbox goes back
     // unread with a wake, and the carrier hands it over again (handOver plans it anew) after its backoff, until a
@@ -450,18 +487,18 @@ export class MailSend {
       if (cameThroughLink(sent)) throw new Error(`not carried on to ${door.machine}: a message that came to this machine through a link is for its own sessions only`);
       const answer = await this.askMachine(door.machine, { op: 'file', to, envelope: sent });
       if (answer?.code !== 0) throw new Error(typeof answer?.text === 'string' ? answer.text : 'the other machine refused the message');
-      return 'filed on its machine';
+      return { how: 'other_machine', text: 'filed on its machine' };
     }
     if (!door) {
       // a reply to a closed session resumes it; only one the mailbox launched, the way it was launched
       this.store.deliver(to, sent);
-      if (!(await this.agents.resumable(to))) return 'stopped; not resumed, since the mailbox did not launch it: the message waits in its mailbox';
+      if (!(await this.agents.resumable(to))) return { how: 'not_running', text: 'stopped; not resumed, since the mailbox did not launch it: the message waits in its mailbox' };
       try { await this.agents.resume(to); } catch (error) { throw new Error(`not resumed: ${error.message}`); }
       const started = Date.now();
       for (;;) {
         door = this.#door(to, this.live.sessions());
         if (door) break;
-        if (Date.now() - started > RESUME_WAIT_MS) return 'resumed; the message waits in its mailbox';
+        if (Date.now() - started > RESUME_WAIT_MS) return { how: 'not_running', text: 'resumed; the message waits in its mailbox' };
         await sleep(1000);
       }
     }
@@ -472,7 +509,7 @@ export class MailSend {
       if (error instanceof Refused) throw new Error(`${error.bytes} bytes; the limit is ${MAX_RELAYED_BYTES}`);
       throw error;
     }
-    return { steered: 'steered into its running turn', started: 'started a turn', native_busy: 'read at its next tool call', native_idle: 'starts its next turn', hooked: 'in its mailbox, its hook shows it', queued: 'waits in its mailbox', operator: 'filed', already: 'it already had it', stored: 'stored; it has no delivery door', typed: 'typed into its pane', pane_held: 'held for its pane until its composer is free', pane_waits: 'waits in its mailbox (its composer was not empty)' }[how];
+    return { how, text: { steered: 'steered into its running turn', started: 'started a turn', native_busy: 'read at its next tool call', native_idle: 'starts its next turn', hooked: 'in its mailbox, its hook shows it', queued: 'waits in its mailbox', operator: 'filed', already: 'it already had it', stored: 'stored; it has no delivery door', typed: 'typed into its pane', pane_held: 'held for its pane until its composer is free', pane_waits: 'waits in its mailbox (its composer was not empty)' }[how] };
   }
 
   // ---- a filing --------------------------------------------------------------------------------------------------
@@ -724,6 +761,8 @@ export class MailSend {
       this.store.markRead(address, found.path);
       return { outcome: 'filed', detail: 'already handed over' };
     }
+    // a plan or a relay send still running here holds its wake (#1264 review P1)
+    if (this.relaying.has(`${address}\n${id}`)) return { outcome: 'later', detail: 'its delivery is still in progress' };
     const parsed = parseAddress(address);
     if (parsed?.harness === AGENT_HARNESS) {
       const plan = await this.#plan(sent, address, {});
@@ -743,8 +782,20 @@ export class MailSend {
     // one still running here (its carrier gave up on its answer, past its bound) is waited for: the wake stays and is
     // tried again after its backoff, settled by that hand-over's own outcome
     const key = `${address}\n${id}`;
-    if (this.handing.has(key)) return { outcome: 'later', detail: 'its hand-over is still in progress' };
-    if (state.handover_at_ms != null) return { outcome: 'filed', detail: 'an earlier hand-over never settled' };
+    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.126",
+  "version": "0.3.127",
   "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",