@volter/supercode-teams 0.3.194 → 0.3.196

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 };
@@ -441,12 +440,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,6 +485,16 @@ 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) {
@@ -543,43 +553,35 @@ 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)) {
+        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 = '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 +594,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`).

package/package.json

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

package/terminal-mail.mjs

@@ -284,7 +284,8 @@ export class TerminalMailbox {
       let lost = true;
       for (let check = 0; lost && check < 2; check++) {
         const screen = await this.host.capture(this.session.id, { lines: 200, preserveEscapes: true });
-        lost = composerText(batch.kind, screen) === '' && !/\besc to (?:interrupt|cancel)\b/iu.test(screen);
+        // Codex paints its hint as `\x1b[0;1mesc\x1b[0;2m to interrupt`: a running turn is read with the styling removed.
+        lost = composerText(batch.kind, screen) === '' && !/\besc to (?:interrupt|cancel)\b/iu.test(String(screen).replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, ''));
         if (lost && check === 0) await pause(200);
       }
       if (lost && !confirmed(batch)) {