@volter/supercode-teams 0.3.195 → 0.3.197

package/mail/send.mjs

@@ -357,10 +357,9 @@ export class MailSend {
     const session = sessions.find((row) => row.address === address);
     if (!session) return null;
     if (session.door === 'runtime') return { kind: 'runtime', session };
-    if (session.door === 'native') {
-      const pane = paneOf(session);
-      return pane ? { kind: 'pane', session, pane } : { kind: 'native', session };
-    }
+    // a native Claude session is reached by its relay; its daemon pane, when it has one, is the fallback for a message
+    // the relay could not deliver
+    if (session.door === 'native') return { kind: 'native', session, pane: paneOf(session) };
     if (session.door === 'hook') return { kind: 'hook', session, pane: session.pane ?? null, idle: session.status === 'idle' };
     // a session with no hook and no relay (Grok) in a daemon pane: its mail is typed there, into an empty composer
     if (session.door === 'pane' && session.pane) return { kind: 'pane', session, pane: session.pane };
@@ -428,7 +427,8 @@ export class MailSend {
     const [code, what] = {
       steered: [0, 'steered into its running turn'],
       started: [0, 'it was idle, so the message started a turn'],
-      native_waits: [EXIT_STORED, 'Stored: its native session is not known to be idle, so the message waits unread until it is idle. Do not resend'],
+      native_busy: [0, 'it will read it at its next tool call'],
+      native_waits: [EXIT_STORED, 'Stored: its relay could not deliver it and its session is busy, so its pane fallback waits unread until it is idle. Do not resend'],
       native_idle: [0, 'it was idle, so the message starts its next turn'],
       hooked: [0, 'queued in its mailbox; terminal delivery waits for native transcript confirmation'],
       hook_woken: [0, 'it was idle, so its pane was told to read its mailbox; its hook shows it the message in that turn'],
@@ -441,12 +441,13 @@ export class MailSend {
       stored: [EXIT_STORED, `Stored (not failed): it has no delivery door, so it sees this only if it runs supercode message inbox${parseAddress(address).harness === 'codex' ? ' (a Codex session gets one with: supercode message setup codex)' : ''}. Don't resend, and don't wait for a reply`],
     }[delivered];
     this.#recordSend(caller.address, address, messageId, sentIn, receiver.continuation);
+    const viaPane = terminal || (door.kind === 'native' && ['typed', 'pane_held', 'pane_waits'].includes(delivered));
     const harness = parseAddress(address).harness;
     const text = code === 0
       ? `sent to ${name} (${harness}, ${door.kind}): ${what}. Message id ${shortId(messageId)}.${receiver.alias ?? ''}${idleNote} Don't poll; carry on.`
       : `${name} (${harness}): ${what}. Message id ${shortId(messageId)}.${idleNote}`;
-    if ((code === 0 || (terminal && code === EXIT_STORED)) && id != null) { try { this.store.setSentMarker(caller.address, messageId, text); } catch { /* the marker is best kept */ } }
-    return outcome(code, text, code === 0 || terminal ? this.#deliveryReceipt(address, messageId, terminal) : null);
+    if ((code === 0 || (viaPane && code === EXIT_STORED)) && id != null) { try { this.store.setSentMarker(caller.address, messageId, text); } catch { /* the marker is best kept */ } }
+    return outcome(code, text, code === 0 || viaPane ? this.#deliveryReceipt(address, messageId, viaPane) : null);
   }
 
   /** An agent's plan for `sent` (its thread store decides), or an outcome when the plan refused it. */
@@ -485,17 +486,20 @@ export class MailSend {
       if (how === 'not_woken') { this.store.deliver(to, sent); delivered = 'queued'; }
       else { this.store.deliverRead(to, handed); finalReply = answers; delivered = how === 'steered' ? 'steered' : 'started'; }
     } else if (door.kind === 'native') {
+      // one its pane fallback already holds (typed, or queued for its composer) is never handed to the relay as well
+      const held = door.pane ? terminalReceipt(this.store, to, sent.id) : null;
+      if (held?.delivered) {
+        attempt?.begin('existing-native-delivery');
+        try { this.store.claimFor(to, sent.id, { pid: process.pid, via: 'door', caller: null, recipient: true, at_ms: Date.now() }); } catch { /* best kept */ }
+        const now = this.store.findIn(to, sent.id);
+        if (now?.state === 'unread') { try { this.store.markRead(to, now.path); } catch { /* moved meanwhile */ } }
+        return 'already';
+      }
+      if (held?.queued) return 'pane_held';
       const busy = door.session.status !== 'idle' || door.session.panes_current === false;
       if (!wake && !busy) throw new Refused('queue');
-      if (busy) {
-        attempt?.begin('native-mailbox');
-        this.store.deliver(to, sent);
-        this.store.requestWake(to, sent.id, { keep: true });
-        const state = this.store.wakeState(to, sent.id);
-        this.store.setWakeState(to, sent.id, { ...state, waiting_for_idle: true, next_at_ms: Date.now() + 300_000 });
-        if (notifyWhenIdle && !cameThroughLink(sent)) this.store.subscribeIdle(to, { message_id: sent.id, subscriber: sent.from, notice: true, final_reply: false });
-        return 'native_waits';
-      }
+      // a busy session is handed it at once, as an idle one is: Claude Code's own cross-session message surfaces at the
+      // receiver's next tool call (D391). Only the pane fallback below waits for idle, since a busy pane is never typed into
       // its reply line names the door this session really has: its tools when it runs supercode's MCP server
       const handed = sent.reply_via?.mode === 'command' && door.session.tools ? { ...sent, reply_via: { mode: 'tool' } } : sent;
       const text = render(handed);
@@ -543,43 +547,43 @@ export class MailSend {
       // gone, so its gate refuses a late send) and it is not in the receiver's transcript: a copy this delivery filed
       // 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) {
+      // the relay produced no receipt and cannot send it late (known not made, or not in the receiver's transcript after
+      // its bound, its queue gone): a session with a daemon pane has the same copy typed there instead
+      if (!relayed.delivered && !received && wake && door.pane && (!relayed.unknown || relayed.landed === false) && busy) {
+        // its pane is typed into only once its turn is idle: the copy waits unread, its wake resumed when it goes idle
+        // (carrier.mjs), which hands it to the relay again first
+        this.log(`relay could not deliver ${shortId(handed.id)} to busy ${to} (${relayed.detail}); its pane fallback waits for idle`);
+        try { this.store.requestWake(to, handed.id, { keep: true }); } catch { /* the wake filed above stands */ }
+        const state = this.store.wakeState(to, handed.id);
+        this.store.setWakeState(to, handed.id, { ...state, waiting_for_idle: true, next_at_ms: Date.now() + 300_000 });
+        delivered = 'native_waits';
+      } else if (!relayed.delivered && !received && wake && door.pane && (!relayed.unknown || relayed.landed === false)) {
+        this.log(`relay could not deliver ${shortId(handed.id)} to ${to} (${relayed.detail}); typing it into its pane ${door.pane}`);
+        this.relaying.add(key);
+        try { delivered = await this.#typeIntoPane(handed, to, door.pane, wake, attempt); }
+        finally { this.relaying.delete(key); }
+      } else if (!relayed.delivered && relayed.unknown && !received) {
         // 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 { this.store.remove(to, filed); } catch { /* gone */ } } throw new Error(relayed.detail); }
+      else if (!relayed.delivered && !received) { if (filedHere) { try { this.store.remove(to, filed); } catch { /* gone */ } } throw new Error(relayed.detail); }
       // relayed: a copy filed unread before this delivery (an earlier unanswered or queued one, held for the receiver's
       // own read) is moved to cur/, so that read never hands it over a second time
-      if (relayed.delivered && !received) {
-        const now = this.store.findIn(to, handed.id);
-        if (now?.state === 'unread') { try { this.store.markRead(to, now.path); } catch { /* moved meanwhile */ } }
+      else {
+        if (relayed.delivered && !received) {
+          const now = this.store.findIn(to, handed.id);
+          if (now?.state === 'unread') { try { this.store.markRead(to, now.path); } catch { /* moved meanwhile */ } }
+        }
+        delivered = busy ? 'native_busy' : 'native_idle';
       }
-      delivered = 'native_idle';
     } else if (door.kind === 'hook') {
       attempt?.begin('hook-mailbox');
       this.store.deliver(to, sent);
       if (wake) this.store.requestWake(to, sent.id);
       delivered = 'hooked';
     } else if (door.kind === 'pane') {
-      // typed as its next turn only into an empty composer (machine.mjs #paneTurn); otherwise it waits in its mailbox
-      let typed = null;
-      attempt?.begin(wake ? 'terminal-input' : 'terminal-mailbox');
-      if (wake) { try { typed = await this.typeTurn(door.pane, parseAddress(to).harness, render(sent), [sent.id], to); } catch (error) { typed = { reason: error.message }; } }
-      if (typed?.delivered) { this.store.deliverRead(to, sent); delivered = 'typed'; }
-      // held by the daemon's queue for the pane, typed once its composer frees: not typed yet, so kept unread
-      else if (typed?.queued) { this.store.deliver(to, sent); if (wake) this.store.requestWake(to, sent.id, { keep: true }); delivered = 'pane_held'; }
-      // not typed (its composer held a draft or a turn ran): it waits unread with a wake, so the carrier types it once the
-      // composer is empty (mail/carrier.mjs), never left for a read a session with no hook never makes
-      else {
-        this.store.deliver(to, sent);
-        if (wake) {
-          this.store.requestWake(to, sent.id, { keep: true });
-          const state = this.store.wakeState(to, sent.id);
-          this.store.setWakeState(to, sent.id, { ...state, next_at_ms: Date.now() + 2_000, last_error: paneWaitReason(typed) });
-        }
-        delivered = wake ? 'pane_waits' : 'queued';
-      }
+      delivered = await this.#typeIntoPane(sent, to, door.pane, wake, attempt);
     } else if (door.kind === 'stored') { attempt?.begin('stored-mailbox'); this.store.deliver(to, sent); delivered = 'stored'; }
     else { attempt?.begin('operator-mailbox'); this.store.deliver(to, sent); delivered = 'operator'; }
     // a hand-over to the recipient's own door is its delivery, recorded as such
@@ -592,6 +596,30 @@ export class MailSend {
     return delivered;
   }
 
+  /** Type `sent` into `pane` as its next turn, only into an empty composer (machine.mjs #paneTurn); otherwise it waits
+   *  in its mailbox. Answers 'typed', 'pane_held', 'pane_waits' or 'queued'. */
+  async #typeIntoPane(sent, to, pane, wake, attempt) {
+    let typed = null;
+    attempt?.begin(wake ? 'terminal-input' : 'terminal-mailbox');
+    if (wake) { try { typed = await this.typeTurn(pane, parseAddress(to).harness, render(sent), [sent.id], to); } catch (error) { typed = { reason: error.message }; } }
+    if (typed?.delivered) {
+      this.store.deliverRead(to, sent);
+      const now = this.store.findIn(to, sent.id);
+      if (now?.state === 'unread') { try { this.store.markRead(to, now.path); } catch { /* moved meanwhile */ } }
+      return 'typed';
+    }
+    // held by the daemon's queue for the pane, typed once its composer frees: not typed yet, so kept unread
+    if (typed?.queued) { this.store.deliver(to, sent); if (wake) this.store.requestWake(to, sent.id, { keep: true }); return 'pane_held'; }
+    // not typed (its composer held a draft or a turn ran): it waits unread with a wake, so the carrier tries it again once
+    // the composer is empty (mail/carrier.mjs), never left for a read a session with no hook never makes
+    this.store.deliver(to, sent);
+    if (!wake) return 'queued';
+    this.store.requestWake(to, sent.id, { keep: true });
+    const state = this.store.wakeState(to, sent.id);
+    this.store.setWakeState(to, sent.id, { ...state, next_at_ms: Date.now() + 2_000, last_error: paneWaitReason(typed) });
+    return 'pane_waits';
+  }
+
   /**
    * Deliver `sent` to every receiver `plan` names: a `to` receiver through its door (a stopped holder the mailbox
    * launched is resumed first), a `cc` receiver filed unread and not woken (mail_send.rs `deliver_planned`).
@@ -719,7 +747,7 @@ export class MailSend {
       if (error instanceof Refused) throw new Error(`${error.bytes} bytes; the limit is ${MAX_RELAYED_BYTES}`);
       throw error;
     }
-    return { how, text: { steered: 'steered into its running turn', started: 'started a turn', native_waits: 'waits unread until its native turn is idle', 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_waits: 'waits unread until its native turn is idle', 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 --------------------------------------------------------------------------------------------------
@@ -822,7 +850,7 @@ export class MailSend {
     return {
       delivered_to_bus: door.kind !== 'stored' && !['pane_waits', 'pane_held', 'native_waits'].includes(how), message_id: sent.id, reply_to: sender,
       target: { harness, session_id: sessionId, name: door.kind === 'native' ? door.session.name.split('@')[0] : null },
-      delivery: { door: door.kind, how: { steered: 'steered', started: 'started', native_waits: 'waiting_for_idle', native_idle: 'started', hooked: 'hook', queued: 'queued', stored: 'stored', operator: 'filed', already: 'already', typed: 'typed', pane_held: 'held', pane_waits: 'stored' }[how] },
+      delivery: { door: door.kind, how: { steered: 'steered', started: 'started', native_busy: 'next_tool_call', native_waits: 'waiting_for_idle', native_idle: 'started', hooked: 'hook', queued: 'queued', stored: 'stored', operator: 'filed', already: 'already', typed: 'typed', pane_held: 'held', pane_waits: 'stored' }[how] },
     };
   }
 

package/package.json

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