@volter/supercode-teams 0.3.96 → 0.3.98

package/live-sessions.mjs

@@ -14,7 +14,7 @@
 // - Messaging tools: the marker a `message mcp` server writes for its session process, with the server alive.
 import { EventEmitter } from 'node:events';
 import { execFile } from 'node:child_process';
-import { mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, watch, writeFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, unlinkSync, watch, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { FrontendClient } from '@volter/supercode-frontend';
@@ -53,6 +53,36 @@ function linuxStart(pid) {
   } catch { return null; }
 }
 
+/** The parent of the live process `pid` (Linux's /proc; on macOS one `ps` for every pid asked in the same tick, as a
+ *  start's read of thirty markers asks thirty), or null when it cannot be read. */
+const parentsAsked = new Map(); // pid → [resolve], asked of the next `ps`
+function parentOf(pid) {
+  if (process.platform === 'linux') {
+    try { const stat = readFileSync(`/proc/${pid}/stat`, 'utf8'); return Promise.resolve(Number(stat.slice(stat.lastIndexOf(')') + 2).split(' ')[1]) || null); } catch { return Promise.resolve(null); }
+  }
+  if (process.platform !== 'darwin') return Promise.resolve(null);
+  return new Promise((resolve) => {
+    const first = parentsAsked.size === 0;
+    if (!parentsAsked.has(pid)) parentsAsked.set(pid, []);
+    parentsAsked.get(pid).push(resolve);
+    if (!first) return;
+    setImmediate(() => {
+      const asked = new Map(parentsAsked); parentsAsked.clear();
+      execFile('ps', ['-o', 'pid=,ppid=', '-p', [...asked.keys()].join(',')], { timeout: 10_000 }, (_error, stdout) => {
+        const parents = new Map(String(stdout ?? '').trim().split('\n').map((line) => line.trim().split(/\s+/).map(Number)).filter(([child, parent]) => child && parent).map(([child, parent]) => [child, parent]));
+        for (const [child, waiters] of asked) for (const done of waiters) done(parents.get(child) ?? null);
+      });
+    });
+  });
+}
+
+/** The command name of the live process `pid` (Linux's /proc comm, or one `ps` on macOS), or null. */
+function commandOf(pid) {
+  if (process.platform === 'linux') { try { return Promise.resolve(readFileSync(`/proc/${pid}/comm`, 'utf8').trim()); } catch { return Promise.resolve(null); } }
+  if (process.platform !== 'darwin') return Promise.resolve(null);
+  return new Promise((resolve) => execFile('ps', ['-o', 'comm=', '-p', String(pid)], { timeout: 10_000 }, (error, stdout) => resolve(error ? null : String(stdout).trim() || null)));
+}
+
 /** `path` with its symlinks resolved, or null when it cannot be (gone, or not a string). */
 function realPath(path) { try { return typeof path === 'string' ? realpathSync(path) : null; } catch { return null; } }
 
@@ -110,6 +140,11 @@ export class LiveSessions extends EventEmitter {
     this.codexIndexRead = false; this.codexKnown = false; this.codexWaiters = [];
     this.codexRunning = new Map(); // session id → turn (from activity)
     this.codexPaneOf = new Map(); // session id → pane
+    // Grok's own registry of its open sessions (`<grok home>/active_sessions.json`: session_id, pid, cwd, opened_at): a
+    // session is live while its process is; the daemon pane it runs in, when it does, from the panes the records read
+    this.grokHome = env.GROK_HOME || join(homedir(), '.grok');
+    this.grok = new Map(); // session id → { pid, ppid, cwd, openedAt, pane }
+    this.grokPaneRoots = [];
     this.projectHooks = new Map(); // directory → whether its .codex/hooks.json carries the hook
     this.userHook = false;
     this.watchers = [];
@@ -133,6 +168,9 @@ export class LiveSessions extends EventEmitter {
     this.sweep = setInterval(() => this.#sweepDead(), 30_000);
     this.sweep.unref?.();
     this.#follow('live_runtimes', this.receiptsDir, (name) => this.#readReceipt(name), () => this.#readAll(this.receiptsDir, (name) => this.#readReceipt(name)));
+    // Grok's registry, followed where Grok is installed (its home is never made here; a symlinked home is followed at its
+    // target, where its file events are)
+    this.#followGrok();
     this.#follow('tools_markers', this.markersDir, (name) => this.#readMarker(name), () => this.#readAll(this.markersDir, (name) => this.#readMarker(name)));
     this.#follow('codex_hooks', dirname(this.codexHooks), (name) => { if (!name || name === 'hooks.json') this.#readUserHook(); }, () => this.#readUserHook());
     return this;
@@ -179,7 +217,13 @@ export class LiveSessions extends EventEmitter {
       if (stopped) return;
       try {
         mkdirSync(folder, { recursive: true });
-        watcher = watch(folder, (_event, name) => (name ? onFile(String(name)) : readAll()));
+        // a read that throws is said, never the daemon's end (a malformed entry of a source this map follows)
+        // said once until a read passes: a source that keeps throwing does not fill the log
+        const guarded = (read) => {
+          try { read(); this.failing?.delete(source); }
+          catch (error) { this.failing ??= new Set(); if (!this.failing.has(source)) { this.failing.add(source); this.log(`live sessions: ${source} could not be read (${error.message}); said again once it reads`); } }
+        };
+        watcher = watch(folder, (_event, name) => guarded(() => (name ? onFile(String(name)) : readAll())));
         watcher.on('error', (error) => {
           try { watcher.close(); } catch { /* closed */ }
           this.watchers = this.watchers.filter((w) => w !== watcher);
@@ -187,7 +231,7 @@ export class LiveSessions extends EventEmitter {
         });
         this.watchers.push(watcher);
         this.unread.delete(source);
-        readAll();
+        guarded(readAll);
         delay = 0;
       } catch (error) { lost(error); }
     };
@@ -210,13 +254,19 @@ export class LiveSessions extends EventEmitter {
   }
 
   /** A Claude process's entry let go, with what was read of its process's start (a new process may take its pid). */
-  #dropClaude(pid) { this.claude.delete(pid); }
+  #dropClaude(pid) {
+    this.claude.delete(pid);
+    // its messaging tools' marker goes with it when it has ended (step 4a: by its end, never a minute's sweep); an entry
+    // dropped for another reason (its home no longer declared, a parked process) keeps its marker for its return
+    if (this.markers.has(pid) && !alive(pid)) { this.markers.delete(pid); try { unlinkSync(join(this.markersDir, String(pid))); } catch { /* gone */ } }
+  }
 
   /** Every held process asked whether it is alive (signal 0): a dead one's entry goes. */
   #sweepDead() {
     let changed = false;
     for (const pid of [...this.claude.keys()]) if (!alive(pid)) { this.#dropClaude(pid); changed = true; }
     for (const [id, runtime] of [...this.runtimes]) if (!alive(runtime.pid)) { this.runtimes.delete(id); changed = true; }
+    for (const [id, entry] of [...this.grok]) if (!alive(entry.pid)) { this.grok.delete(id); changed = true; }
     for (const [pid, server] of [...this.markers]) if (!alive(server)) this.markers.delete(pid);
     if (changed) this.#changed();
   }
@@ -358,6 +408,74 @@ export class LiveSessions extends EventEmitter {
     return (await answersAs(entry.probe)) !== false;
   }
 
+  /**
+   * Grok's registry read whole: each entry whose process is alive is a live Grok session; one whose process started after
+   * its `opened_at` is its pid used again (checked once per entry, as a receipt's is). Grok may write the file only at a
+   * session's open, so each entry is judged by its process, never by the file's age.
+   */
+  #readGrok(home) {
+    let entries = null;
+    try { entries = JSON.parse(readFileSync(join(home, 'active_sessions.json'), 'utf8')); } catch { return; } // torn or absent: its next event reads it again
+    if (!Array.isArray(entries)) return;
+    const next = new Map();
+    for (const entry of entries) {
+      if (typeof entry?.session_id !== 'string' || !entry.session_id || !Number.isInteger(entry.pid) || !alive(entry.pid)) continue;
+      const known = this.grok.get(entry.session_id);
+      next.set(entry.session_id, known && known.pid === entry.pid ? known : { pid: entry.pid, ppid: null, cwd: typeof entry.cwd === 'string' ? entry.cwd : null, openedAt: Date.parse(entry.opened_at), pane: null, checked: false });
+    }
+    // an entry Grok dropped while its process lives (Grok may drop one before the process ends) is kept while that
+    // process lives and no entry names its pid now (a session switched in the same process names it anew)
+    const named = new Set([...next.values()].map((entry) => entry.pid));
+    for (const [id, entry] of this.grok) if (!next.has(id) && !named.has(entry.pid) && alive(entry.pid)) next.set(id, entry);
+    this.grok = next;
+    for (const [id, entry] of next) {
+      if (entry.checked) continue;
+      entry.checked = true;
+      void Promise.all([startedMs(entry.pid), parentOf(entry.pid), commandOf(entry.pid)]).then(([started, parent, command]) => {
+        if (this.grok.get(id) !== entry) return;
+        // a pid used again: its process started after the session opened, and it is no Grok (a wall clock that stepped
+        // makes a live Grok's start read late; its command still names it)
+        if (Number.isFinite(started) && Number.isFinite(entry.openedAt) && started > entry.openedAt + 2000 && command != null && !/grok/i.test(command)) {
+          this.grok.delete(id);
+          this.log(`live sessions: Grok's registry names pid ${entry.pid} for ${id}, but that process started after the session opened: the pid was used again; it is not taken`);
+        } else { entry.ppid = parent; this.#grokPane(entry); }
+        this.#changed();
+      });
+    }
+    this.#changed();
+  }
+
+  /** Grok's registry followed once its home exists: at start, or when Grok is installed later (its home's parent watched,
+   *  for that one name, until it appears). */
+  #followGrok() {
+    const grokHome = realPath(this.grokHome);
+    if (grokHome) { this.#follow('grok_sessions', grokHome, (name) => { if (name === 'active_sessions.json') this.#readGrok(grokHome); }, () => this.#readGrok(grokHome)); return; }
+    try {
+      const parent = dirname(this.grokHome), name = this.grokHome.slice(parent.length + 1);
+      const watcher = watch(parent, (_event, changed) => {
+        if (String(changed ?? '') !== name || !realPath(this.grokHome)) return;
+        try { watcher.close(); } catch { /* closed */ }
+        this.watchers = this.watchers.filter((w) => w !== watcher);
+        this.#followGrok();
+      });
+      watcher.on('error', () => { try { watcher.close(); } catch { /* closed */ } });
+      this.watchers.push(watcher);
+    } catch { /* its parent is not watchable: Grok installed later is followed at the next start */ }
+  }
+
+  /** The daemon pane a Grok session runs in: the pane whose process it is, or whose process started it. */
+  #grokPane(entry) {
+    entry.pane = this.grokPaneRoots.find((root) => root.pid === entry.pid || (entry.ppid != null && root.pid === entry.ppid))?.pane ?? null;
+  }
+
+  /** The daemon's live panes and their root processes (`[{ pane, pid }]`), as the records read them: Grok's panes. */
+  grokPanes(roots) {
+    this.grokPaneRoots = (roots ?? []).filter((root) => root?.pane && Number.isInteger(root.pid));
+    const before = JSON.stringify([...this.grok].map(([id, entry]) => [id, entry.pane]));
+    for (const entry of this.grok.values()) this.#grokPane(entry);
+    if (JSON.stringify([...this.grok].map(([id, entry]) => [id, entry.pane])) !== before) this.#changed();
+  }
+
   /** One messaging-tools marker: the session process named by its file, the server pid in it. */
   #readMarker(name) {
     if (!name) return;
@@ -365,9 +483,21 @@ export class LiveSessions extends EventEmitter {
     if (!Number.isInteger(pid)) return;
     let server = null;
     try { server = Number(readFileSync(join(this.markersDir, name), 'utf8').trim()); } catch { /* removed */ }
-    if (Number.isInteger(server) && server > 0) this.markers.set(pid, server); else this.markers.delete(pid);
+    // a marker whose server has ended names no tools: removed (read at start, and as each is written or changed)
+    if (Number.isInteger(server) && server > 0 && !alive(server)) { try { unlinkSync(join(this.markersDir, name)); } catch { /* gone */ } server = null; }
+    if (!(Number.isInteger(server) && server > 0)) { if (this.markers.delete(pid)) this.#changed(); return; }
+    this.markers.set(pid, server);
+    // its server is the session's own child (a harness starts its MCP servers so), checked once per marker: a server pid
+    // used again by another process names no tools (mail_route.rs `has_message_tools` read it so)
+    void parentOf(server).then((parent) => {
+      if (parent == null || parent === pid || this.markers.get(pid) !== server) return;
+      this.markers.delete(pid);
+      try { unlinkSync(join(this.markersDir, name)); } catch { /* gone */ }
+      this.#changed();
+    });
   }
 
+
   #readUserHook() {
     let text = '';
     try { text = readFileSync(this.codexHooks, 'utf8'); } catch { /* none */ }
@@ -512,6 +642,12 @@ export class LiveSessions extends EventEmitter {
       const hooked = this.userHook || this.#projectHooked(row?.cwd ?? null);
       out.push({ address, name: `codex-${sessionId.slice(0, 8)}@${this.machine}`, status, door: hooked ? 'hook' : 'stored', pid: null, cwd: row?.cwd ?? null, pane: this.codexPaneOf.get(sessionId) ?? null, tools: false });
     }
+    // Grok: no hook and no relay reaches it; its mail is typed into its daemon pane, or filed in its mailbox (stored)
+    for (const [sessionId, entry] of this.grok) {
+      const address = this.#address('grok', sessionId);
+      if (seen.has(address) || !alive(entry.pid)) continue; seen.add(address);
+      out.push({ address, name: `grok-${sessionId.slice(0, 8)}@${this.machine}`, status: 'idle', door: entry.pane ? 'pane' : 'stored', pid: entry.pid, cwd: entry.cwd, pane: entry.pane, tools: false });
+    }
     return out;
   }
 

package/machine.mjs

@@ -39,6 +39,7 @@ import { MailReads, panePrompt } from './mail/reads.mjs';
 import { render } from './mail/envelope.mjs';
 import { Agents } from './mail/agents.mjs';
 import { Relays } from './mail/relay.mjs';
+import { serveRelayEndpoint } from './mail/relay-endpoint.mjs';
 import { MailSend } from './mail/send.mjs';
 import { AgentVerbs } from './mail/verbs.mjs';
 import { deliverToRuntime } from './mail/runtime.mjs';
@@ -105,6 +106,8 @@ const INITIAL_INPUT_READY_DEADLINE_MS = 90_000;
 const INITIAL_INPUT_POLL_MS = 250;
 /** The pause between the two composer readings a user's turn waits on. */
 const COMPOSER_RECHECK_MS = 400;
+/** The harnesses whose composer a capture is read for a draft (sdk/terminal `composerHoldsDraft`). */
+const DRAFT_KINDS = new Set(['claude-code', 'codex', 'gemini', 'grok']);
 // Claude Code waits out a usage limit and queues every message typed meanwhile until the limit's reset ("new messages
 // wait for your usage limit to reset"; esc or /rate-limit-options ends the wait). A limit raised early, or a weekly
 // one past 24 hours, never ends that wait, so a session sat with every turn it was sent queued behind it. Read from the
@@ -546,6 +549,7 @@ export class TeamsMachine extends MachineCore {
   // ---- lifecycle ------------------------------------------------------------
 
   async beforeListen() {
+    this.bornAt ??= Date.now();
     mkdirSync(this.portsDir, { recursive: true }); // the port table's announce directory exists before any pane launches
     this.#startServe();
     if (this.#pendingNotices().length) this.#watchEnds();
@@ -622,7 +626,6 @@ export class TeamsMachine extends MachineCore {
           if (change.kind === 'removed' && change.key?.harness === 'codex') this.live.codexIndex({ removed: change.key.session_id });
           else if (change.descriptor) this.live.codexIndex({ descriptor: change.descriptor });
         }
-        this.emit('codex-index', { changes: params.changes ?? [] });
       }
     });
     // The Codex sessions' own index (Codex rollouts only): the live map knows them from its first answer, never waiting on
@@ -635,9 +638,6 @@ export class TeamsMachine extends MachineCore {
         this.live.codexRowsReplaced();
         for (const descriptor of answer?.initial ?? []) if (descriptor?.locator) this.live.codexIndex({ descriptor });
         this.live.codexIndexed();
-        // the records take their Codex rows from this index too (their own whole index leaves Codex out: one watch and
-        // one read of the rollouts)
-        this.emit('codex-index', { initial: answer?.initial ?? [] });
       }, (error) => {
         codexIndexBackoff = Math.min(300_000, Math.max(2000, (codexIndexBackoff || 1000) * 2));
         this.emit('records-log', `live sessions: the Codex sessions' index could not be subscribed (${error.message}); tried again in ${Math.round(codexIndexBackoff / 1000)} s`);
@@ -653,6 +653,9 @@ export class TeamsMachine extends MachineCore {
   // ---- this machine's mail (mail/; docs/architecture/overview.md, "The mail operations") ---------------------------
   #startMail() {
     const mailRoot = join(supercodeHome(this.env), 'mail');
+    // the Messages API a Claude relay talks to (step 4a: the daemon's, in process; the native watch served it)
+    this.relayEndpoint = serveRelayEndpoint(mailRoot, { log: (line) => this.emit('mail-log', line) })
+      .catch((error) => { this.emit('mail-log', `relay endpoint: not served (${error.message}); a Claude session cannot be sent mail until the daemon starts again`); return null; });
     this.mailStore = new MailStore({ mailRoot, machine: machineName(this.env), log: (line) => this.emit('records-log', line) }).start();
     // the session index's rows by address (its descriptors, as the records' index subscription hands them over)
     this.sessionDescriptors = new Map();
@@ -678,6 +681,7 @@ export class TeamsMachine extends MachineCore {
     this.relays = new Relays({ mailRoot, machine, supercodeBin: this.supercodeBin, serve: (method, params, timeoutMs) => this.#serveRequest(method, params, timeoutMs),
       runtimeOf: (harness, id) => live.runtimeReceipt(harness, id), runtimeNamed: (receiptId) => live.receiptNamed(receiptId),
       runtimesIn: (harness, cwd) => live.runtimesIn(harness, cwd),
+      endpointOf: async () => (await this.relayEndpoint)?.url ?? null,
       log: (line) => this.emit('mail-log', line) });
     this.mailSend = new MailSend({ machine, mailRoot, live, store: this.mailStore, agents: this.agents, relays: this.relays,
       // a send waits on its receiver's door there (a relay's receipt takes up to 90 s), never past MAIL_SEND_MS
@@ -700,6 +704,22 @@ export class TeamsMachine extends MachineCore {
     // the names sessions ran under (`<mail>/names.json`): a name an agent was given reaches the same session after it
     // runs under another, kept from the map's changes (at most once a second)
     let naming = null;
+    // a session that has ended has its relay retired (step 4a: by its end, never a minute's sweep); the relays of
+    // sessions that ended while no daemon ran are retired once, at start, when the live sessions are known
+    let wasLive = new Map(live.sessions().map((row) => [row.address, row.name]));
+    live.on('changed', () => {
+      // while the Codex sessions are not known (a start, a serve restart) a Codex session missing has not ended: the last
+      // known view stands until they are known again
+      if (!live.codexKnown) return;
+      const now = new Map(live.sessions().map((row) => [row.address, row.name]));
+      // a Codex session that leaves the map has not provably ended (idle over a day, it is no longer followed): kept
+      for (const [address, name] of wasLive) if (!now.has(address) && address.split(':')[2] !== 'codex') void this.relays.retire(address, name).catch(() => {});
+      wasLive = now;
+    });
+    void live.whenCodexKnown(120_000).then((known) => {
+      if (!known) { this.emit('mail-log', 'relays: the live sessions were not known within two minutes of start; relays of ended sessions are retired at their next end'); return; }
+      return this.relays.sweepAtStart((address) => live.sessions().some((row) => row.address === address));
+    }).catch((error) => this.emit('mail-log', `relays: the start sweep failed: ${error.message}`));
     live.on('changed', () => {
       if (naming) return;
       naming = setTimeout(() => { naming = null; try { this.mailSend.rememberNames(live.sessions()); } catch { /* kept at the next change */ } }, 1000);
@@ -755,6 +775,8 @@ export class TeamsMachine extends MachineCore {
         const titles = readJson(this.p.titles, { v: 1, titles: {} }).titles;
         const panes = rows.filter((row) => row.session?.id).map(({ session: s }) => ({ pane: s.contextKey, dead: Boolean(s.dead), pid: s.rootPid ?? null, label: s.label ?? null, title: titles[`pane:${s.contextKey}`] ?? s.label ?? null, cwd: s.cwd ?? null }));
         const live = panes.filter((pane) => !pane.dead && pane.pid);
+        // the pane each Grok session runs in (Grok's registry names its process; its pane is the one rooted at it)
+        this.live?.grokPanes(live.map((pane) => ({ pane: pane.pane, pid: pane.pid })));
         // the harness session under each live pane, as the board reads it: unread is said, never no session
         let activities = [], sessions_unread = null;
         if (live.length) {
@@ -798,22 +820,9 @@ export class TeamsMachine extends MachineCore {
     // is back, and holds its own retry (2 s doubling to 5 min) until it is (MR4); nothing reads its fields as current.
     const backoff = (previous) => Math.min(300_000, Math.max(2000, (previous || 1000) * 2));
     const both = () => { producer.touch('sessions'); producer.touch('panes'); };
-    // every harness but Codex, whose rows come from the live map's Codex-only index ('codex-index' below)
-    const HARNESSES = ['claude-code', 'pi', 'opencode', 'goose', 'gemini', 'grok', 'openclaw', 'hermes', 'supercode'];
-    const isCodex = (key) => key.startsWith('codex:') || key.includes(':codex:');
-    const applyRow = (change) => {
-      if (change.kind === 'removed' && change.key) { this.sessionDescriptors?.delete(`sc:${machineName(this.env)}:${change.key.harness}:${change.key.session_id}`); locators.delete(`${change.key.harness}:${change.key.session_id}`); }
-      else if (change.descriptor?.locator) { const { harness, session_id } = change.descriptor.locator; this.sessionDescriptors?.set(`sc:${machineName(this.env)}:${harness}:${session_id}`, change.descriptor); locators.set(`${harness}:${session_id}`, change.descriptor.locator); }
-    };
-    this.on('codex-index', ({ initial = null, changes = [] }) => {
-      if (initial) {
-        for (const key of [...locators.keys()]) if (isCodex(key)) locators.delete(key);
-        for (const key of [...(this.sessionDescriptors?.keys() ?? [])]) if (isCodex(key)) this.sessionDescriptors.delete(key);
-        for (const descriptor of initial) applyRow({ descriptor });
-      }
-      for (const change of changes) applyRow(change);
-      both();
-    });
+    // every harness, Codex among them: the live map reads Codex alone for its speed, and the records keep the whole
+    // index (a session's parent may be of another harness, which only the whole index links)
+    const HARNESSES = ['claude-code', 'codex', 'pi', 'opencode', 'goose', 'gemini', 'grok', 'openclaw', 'hermes', 'supercode'];
     const locators = new Map(); // `${harness}:${session_id}` → the index's locator for it
     const noteIndexParts = (failed, error) => {
       // the index's own unread parts (a store, a folder, a registry it could not read): their sessions are unknown
@@ -836,10 +845,8 @@ export class TeamsMachine extends MachineCore {
     let indexBackoff = 0;
     const subscribe = () => this.#serveRequest('harness.v1.sessions.index.subscribe', { harnesses: HARNESSES, limit: 0 }, 60_000)
       .then((answer) => {
-        this.recordsIndex = answer?.subscription ?? null; indexBackoff = 0;
-        // its own rows replaced; the Codex rows (the live map's index's) kept
-        for (const key of [...locators.keys()]) if (!isCodex(key)) locators.delete(key);
-        for (const key of [...(this.sessionDescriptors?.keys() ?? [])]) if (!isCodex(key)) this.sessionDescriptors.delete(key);
+        this.recordsIndex = answer?.subscription ?? null; indexBackoff = 0; locators.clear();
+        this.sessionDescriptors?.clear();
         for (const descriptor of answer?.initial ?? []) if (descriptor?.locator) { locators.set(`${descriptor.locator.harness}:${descriptor.locator.session_id}`, descriptor.locator); this.sessionDescriptors?.set(`sc:${machineName(this.env)}:${descriptor.locator.harness}:${descriptor.locator.session_id}`, descriptor); }
         producer.note('sessions_index', null); noteIndexParts(answer?.failed, null); both();
       }, (error) => {
@@ -999,6 +1006,7 @@ export class TeamsMachine extends MachineCore {
     this.jobs?.stopAll();
     this.stoppingMailWatch = true;
     this.mailWatch?.kill('SIGTERM');
+    void this.relayEndpoint?.then((endpoint) => endpoint?.close()).catch(() => {});
     this.stoppingServe = true;
     clearTimeout(this.serveRestart);
     // said, so a stop reads as one in the log and never as a serve that broke
@@ -1026,8 +1034,11 @@ export class TeamsMachine extends MachineCore {
     const serveLines = lineSplitter();
     // a serve already replaced never answers into the streams that its successor serves (its late answers would reach a
     // reopened stream that uses the same ids)
+    let answered = false;
     child.stdout.on('data', (chunk) => {
       if (this.serve !== child) return;
+      // when serve first answers, and so how much of a start's wait is serve's own start (said once per serve)
+      if (!answered) { answered = true; this.emit('records-log', `harness serve: its first line ${((Date.now() - started) / 1000).toFixed(1)} s after its spawn (${((Date.now() - (this.bornAt ?? started)) / 1000).toFixed(1)} s after the daemon's start)`); }
       for (const line of serveLines(chunk)) if (line) this.#routeServeLine(line);
     });
     child.stderr.setEncoding('utf8');
@@ -1119,7 +1130,13 @@ export class TeamsMachine extends MachineCore {
       const entry = this.connections.get(conn);
       if (conn === INTERNAL_CONNECTION) {
         const pending = this.internalRequests?.get(original);
-        if (!pending) return;
+        if (!pending) {
+          // an answer that came after its request gave up: an index it opened is registered in serve with nobody reading
+          // it (one more at each retry), so it is let go at once
+          const late = message.result?.subscription;
+          if (typeof late === 'string' && late.startsWith('index-sub-')) this.#toServe(`${JSON.stringify({ jsonrpc: '2.0', id: joinId(INTERNAL_CONNECTION, `late-${late}`), method: 'harness.v1.sessions.index.unsubscribe', params: { subscription: late } })}\n`);
+          return;
+        }
         this.internalRequests.delete(original);
         // the daemon's own subscriptions (its machine record's session index) are routed back to it, as an operator's are
         if (message.result && typeof message.result === 'object') {
@@ -2207,15 +2224,19 @@ export class TeamsMachine extends MachineCore {
     if (addressed && addressed !== kind && ['claude-code', 'codex', 'grok', 'gemini', 'goose', 'opencode', 'pi', 'hermes', 'openclaw'].includes(kind)) {
       return { refused: { delivered: false, reason: `harness-mismatch: mail for ${addressed} is not typed into a ${kind || 'unknown'} pane` } };
     }
-    if (kind === 'claude-code') {
+    // the composer read for a draft: the pane's own program, or (a pane whose program shows another name, as Grok's
+    // versioned binary does) the harness the text is for; a program whose composer this cannot read is not read
+    const draftKind = DRAFT_KINDS.has(kind) ? kind : (addressed && DRAFT_KINDS.has(addressed) ? addressed : null);
+    if (draftKind) {
       // A usage-limit wait would queue this turn until the limit's reset: esc ends the wait first. A limit that
       // still holds refuses the turn at once and the session waits again, for the next turn to try.
       const queued = [...this.terminalMailboxes.values()].some(queue => queue.session?.id === session.id && (queue.state.active || queue.state.pending.length));
-      if (!this.inputInFlight.has(session.id) && !queued && claudeUsageLimitWait(await this.host.capture(session.id, { lines: 60 }))) {
+      if (draftKind === 'claude-code' && !this.inputInFlight.has(session.id) && !queued && claudeUsageLimitWait(await this.host.capture(session.id, { lines: 60 }))) {
         await this.host.sendInput(session.id, '\u001b', { submitMode: 'single', deadlineMs: Date.now() + 5_000 });
         await new Promise(resolve => setTimeout(resolve, COMPOSER_RECHECK_MS));
       }
-      const draftOf = async () => composerHoldsDraft(kind, await this.host.capture(session.id, { lines: 200, preserveEscapes: true }));
+      // a person's draft is never typed over, nor a screen with no composer (a menu, a dialog) typed into
+      const draftOf = async () => composerHoldsDraft(draftKind, await this.host.capture(session.id, { lines: 200, preserveEscapes: true }));
       const first = await draftOf();
       await new Promise(resolve => setTimeout(resolve, COMPOSER_RECHECK_MS));
       const second = await draftOf();

package/mail/relay-endpoint.mjs

@@ -0,0 +1,120 @@
+// The Messages API a Claude relay talks to: deterministic, no model (docs/architecture/overview.md, step 4a; the native
+// watch served it before, and its answers are kept byte for byte).
+//
+// A relay (relay.mjs) is a real Claude Code process, because only a live Claude peer's `SendMessage` gets a Claude
+// session's reply back. What it asks its model is always the same: send the queued message. So a relay's
+// `ANTHROPIC_BASE_URL` points here, and this endpoint answers as the model would, from the relay's own queue:
+// - a send turn gets one `SendMessage` tool call carrying the queued `to` and `message`, byte for byte;
+// - the turn after a tool result, or with nothing queued, gets RELAY_STATUS_LINE and ends.
+// No model runs and nothing is billed. The gate hook still checks every tool call against the queue, and the receipt is
+// still Claude's own `SendMessage` result. A relay's API key names its folder under `<mail root>/relays/`. The machine
+// daemon serves it on loopback, on the port recorded in `<mail root>/relay-endpoint.json` (a restarted daemon binds the
+// same port again).
+import { createServer } from 'node:http';
+import { randomBytes } from 'node:crypto';
+import { mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/** The text every relay turn ends with. Claude quotes a session's last line in its idle notices, so this is where the
+ *  correction reaches the agent. */
+export const RELAY_STATUS_LINE = "relay, not the session's status";
+
+const readJson = (path) => { try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; } };
+const newId = () => `m-${randomBytes(12).toString('hex')}`;
+
+/**
+ * Serve the endpoint for `mailRoot`'s relays: answers `{ url, close() }` once it listens. The port the record names is
+ * taken again when it is free, so relays started before a restart keep reaching it.
+ */
+export async function serveRelayEndpoint(mailRoot, { log = () => {} } = {}) {
+  const record = join(mailRoot, 'relay-endpoint.json');
+  const server = createServer((request, response) => {
+    const chunks = [];
+    request.on('data', (chunk) => chunks.push(chunk));
+    request.on('error', () => {});
+    request.on('end', () => {
+      const [status, type, body] = answer(mailRoot, request, Buffer.concat(chunks));
+      response.writeHead(status, { 'content-type': type, 'content-length': Buffer.byteLength(body) });
+      response.end(body);
+    });
+  });
+  server.on('clientError', (_error, socket) => { try { socket.destroy(); } catch { /* gone */ } });
+  const listen = (port) => new Promise((resolve, reject) => {
+    const failed = (error) => { server.off('listening', done); reject(error); };
+    const done = () => { server.off('error', failed); resolve(); };
+    server.once('error', failed); server.once('listening', done);
+    server.listen(port, '127.0.0.1');
+  });
+  const recorded = readJson(record)?.port;
+  try { await listen(Number.isInteger(recorded) ? recorded : 0); }
+  catch (error) {
+    if (!Number.isInteger(recorded)) throw error;
+    log(`relay endpoint: its recorded port ${recorded} is taken (${error.code ?? error.message}); listening on another, so relays started before this daemon start again`);
+    await listen(0);
+  }
+  const port = server.address().port;
+  mkdirSync(mailRoot, { recursive: true });
+  const staging = `${record}.tmp`;
+  writeFileSync(staging, JSON.stringify({ port }));
+  renameSync(staging, record);
+  return { url: `http://127.0.0.1:${port}`, port, close: () => new Promise((resolve) => server.close(() => resolve())) };
+}
+
+/** The relay folder an API key names, when it is one. */
+function relayFolder(mailRoot, request) {
+  const key = request.headers['x-api-key'];
+  if (typeof key !== 'string' || !key || !/^[0-9a-fA-F]+$/.test(key)) return null;
+  const folder = join(mailRoot, 'relays', key);
+  try { return statSync(folder).isDirectory() ? folder : null; } catch { return null; }
+}
+
+/** One request's answer: `[status, content type, body]`. */
+function answer(mailRoot, request, raw) {
+  const error = (status, message) => [status, 'application/json', JSON.stringify({ type: 'error', error: { type: 'invalid_request_error', message } })];
+  if (request.method !== 'POST') return error(404, 'not found');
+  const folder = relayFolder(mailRoot, request);
+  if (!folder) return error(401, 'not a supercode relay');
+  const path = String(request.url ?? '').split('?')[0];
+  if (path.endsWith('/v1/messages/count_tokens')) return [200, 'application/json', JSON.stringify({ input_tokens: 1 })];
+  if (!path.endsWith('/v1/messages')) return error(404, 'not found');
+  let body;
+  try { body = JSON.parse(raw.toString('utf8')); } catch { return error(400, 'unreadable request'); }
+  const queued = readJson(join(folder, 'queue.json'));
+  const content = queued && typeof queued.to === 'string' && typeof queued.message === 'string' && !afterToolResult(body)
+    ? { type: 'tool_use', id: `toolu_${newId()}`, name: 'SendMessage', input: { to: queued.to, message: queued.message } }
+    : { type: 'text', text: RELAY_STATUS_LINE };
+  const model = body?.model ?? null;
+  return body?.stream === true
+    ? [200, 'text/event-stream', stream(model, content)]
+    : [200, 'application/json', JSON.stringify(message(model, content))];
+}
+
+/** Whether the conversation's last turn carries a tool result: the send happened (or was denied), and the turn ends. */
+function afterToolResult(body) {
+  const messages = Array.isArray(body?.messages) ? body.messages : [];
+  const last = messages[messages.length - 1]?.content;
+  return Array.isArray(last) && last.some((block) => block?.type === 'tool_result');
+}
+
+const stopReason = (content) => (content.type === 'tool_use' ? 'tool_use' : 'end_turn');
+
+function message(model, content) {
+  return { id: `msg_${newId()}`, type: 'message', role: 'assistant', model, content: [content], stop_reason: stopReason(content), stop_sequence: null, usage: { input_tokens: 1, output_tokens: 1 } };
+}
+
+/** The same message as the server-sent events a streaming request expects. */
+function stream(model, content) {
+  const start = { ...message(model, content), content: [], stop_reason: null };
+  const [opening, delta] = content.type === 'tool_use'
+    ? [{ ...content, input: {} }, { type: 'input_json_delta', partial_json: JSON.stringify(content.input) }]
+    : [{ type: 'text', text: '' }, { type: 'text_delta', text: content.text }];
+  const events = [
+    ['message_start', { type: 'message_start', message: start }],
+    ['content_block_start', { type: 'content_block_start', index: 0, content_block: opening }],
+    ['content_block_delta', { type: 'content_block_delta', index: 0, delta }],
+    ['content_block_stop', { type: 'content_block_stop', index: 0 }],
+    ['message_delta', { type: 'message_delta', delta: { stop_reason: stopReason(content), stop_sequence: null }, usage: { output_tokens: 1 } }],
+    ['message_stop', { type: 'message_stop' }],
+  ];
+  return events.map(([name, data]) => `event: ${name}\ndata: ${JSON.stringify(data)}\n\n`).join('');
+}

package/mail/relay.mjs

@@ -7,7 +7,7 @@
 // doors, run by the relay's Claude (docs/architecture/overview.md, "Pinned native doors"). Its folder is the native
 // sender's own (`<mail>/relays/<blake3(name)[..24]>/`, its record, settings and send log), so the native `message
 // watch`, which retires relays until step 4, reads what the daemon writes.
-import { mkdirSync, readFileSync, rmSync, watch, writeFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, readdirSync, rmSync, statSync, watch, writeFileSync } from 'node:fs';
 import { connect } from 'node:net';
 import { join } from 'node:path';
 import { blake3Hex } from './envelope.mjs';
@@ -25,6 +25,11 @@ export const MAX_RELAYED_BYTES = 100_000;
 /** How many relays run at once, the most recently used (a relay runtime is some hundreds of MB; 10 held 2.1 GB on one
  *  machine): beyond them a relay's runtime is closed (its folder kept: it starts again when next needed). */
 export const RELAYS_RUNNING = 4;
+/** How long a relay speaking for a sender on another machine is kept after its last send (it carries that sender's
+ *  mail while it is in use; retired after every send, each message from it started a relay). */
+const REMOTE_RELAY_KEPT_MS = 60 * 60_000;
+/** How long a Codex sender's relay is kept unused at a start (a Codex session idle over a day leaves the map). */
+const CODEX_RELAY_KEPT_MS = 7 * 24 * 60 * 60_000;
 /** How long a relay whose runtime start lost its answer is looked at for a runtime that start left running. */
 const LOST_START_KEPT_MS = 5 * 60_000;
 
@@ -63,9 +68,10 @@ export class Relays {
    * id)` the live-runtime receipt the live-session map holds for a runtime id (its file read whole), or null;
    * `runtimeNamed(receiptId)` one receipt read by its own name.
    */
-  constructor({ mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed = () => null, runtimesIn = () => [], log = () => {} }) {
-    Object.assign(this, { mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed, runtimesIn, log });
+  constructor({ mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed = () => null, runtimesIn = () => [], endpointOf = async () => null, log = () => {} }) {
+    Object.assign(this, { mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed, runtimesIn, endpointOf, log });
     this.lost = new Map(); // relay folder → when a start of its runtime lost its answer (the runtime may run, unnamed)
+    this.remoteKept = new Map(); // relay folder of a sender on another machine → the timer that retires it
     this.sending = new Map(); // relay folder → the send in progress through it (one at a time per relay)
     this.running = new Map(); // relay folder → { connection, runtime_id, usedAt }: the relays this daemon runs
   }
@@ -103,6 +109,84 @@ export class Relays {
     }
   }
 
+  /**
+   * The relay that speaks for `represented` (known as `name`), retired: its runtime closed and its folder removed, under
+   * its own lock (as the native watch's minute sweep did, by event here: the session's end, or a remote
+   * sender's quiet hour). A board's or an operator's relay is kept: nothing ends it. Answers whether it was retired.
+   */
+  async retire(represented, name) {
+    const parsed = String(represented).split(':');
+    if (parsed[2] === 'board' || parsed[2] === 'operator') return false;
+    // a folder is named by its sender's name, not its address: it is retired only while it still represents this ended
+    // address (another live session of that name, or one renamed since, may hold it now)
+    return this.#retireFolder(this.spec(represented, name).directory, represented);
+  }
+
+  /** The address a relay folder speaks for, as its inbound hook names it (its settings), or null. */
+  #representedOf(directory) {
+    try { return /relay-inbound '([^']+)'/.exec(readFileSync(join(directory, 'settings.json'), 'utf8'))?.[1] ?? null; } catch { return null; }
+  }
+
+  async #retireFolder(directory, expected = null) {
+    try { statSync(directory); } catch { return false; }
+    if (expected && this.#representedOf(directory) !== expected) return false;
+    return this.#locked(directory, async () => {
+      // read again under its lock: a send that ran meanwhile writes its own sender's settings
+      if (expected && this.#representedOf(directory) !== expected) return false;
+      const record = readJson(join(directory, 'relay.json'));
+      if (record?.runtime_id) {
+        try { await this.serve('harness.v1.runtimes.close', { connection: record.connection ?? '', runtime_id: record.runtime_id }, 15_000); }
+        catch (error) {
+          // a runtime still live that could not be closed keeps its folder: it is retired again at the next end or start
+          if (this.runtimeOf('claude-code', record.runtime_id)) { this.log(`relay ${directory.split(/[\\/]/).pop()} was not retired: ${error.message}`); return false; }
+        }
+      }
+      this.running.delete(directory); this.lost.delete(directory);
+      clearTimeout(this.remoteKept.get(directory)); this.remoteKept.delete(directory);
+      try { rmSync(directory, { recursive: true, force: true }); } catch (error) { this.log(`relay ${directory.split(/[\\/]/).pop()}: its folder was not removed: ${error.message}`); return false; }
+      return true;
+    });
+  }
+
+  /** A relay speaking for a sender on another machine is retired REMOTE_RELAY_KEPT_MS after its last send. */
+  #keepRemote(directory, quietSinceMs = Date.now()) {
+    clearTimeout(this.remoteKept.get(directory));
+    const timer = setTimeout(() => { this.remoteKept.delete(directory); void this.#retireFolder(directory); }, Math.max(0, quietSinceMs + REMOTE_RELAY_KEPT_MS - Date.now()));
+    timer.unref?.();
+    this.remoteKept.set(directory, timer);
+  }
+
+  /**
+   * At a daemon's start, once its live sessions are known: the relays whose sessions ended while no daemon ran are
+   * retired, and a remote sender's relay is kept for the rest of its hour (one read of the relays folder, at start only).
+   * `running(address)` says whether a session here runs.
+   */
+  async sweepAtStart(running) {
+    let folders = [];
+    try { folders = readdirSync(join(this.mailRoot, 'relays')); } catch { return; }
+    let retired = 0;
+    for (const folder of folders) {
+      const directory = join(this.mailRoot, 'relays', folder);
+      const represented = this.#representedOf(directory);
+      if (!represented) continue;
+      const [, machine, harness] = represented.split(':');
+      if (harness === 'board' || harness === 'operator') continue;
+      if (machine !== this.machine) {
+        let last = 0; try { last = statSync(join(directory, 'receipt.json')).mtimeMs; } catch { /* never sent */ }
+        if (Date.now() - last < REMOTE_RELAY_KEPT_MS) { this.#keepRemote(directory, last); continue; }
+      } else if (running(represented)) continue;
+      else if (harness === 'codex') {
+        // a Codex session the map does not hold may be idle, not ended: its relay is kept until unused for a week
+        let last = 0; for (const file of ['receipt.json', 'relay.json']) { try { last = Math.max(last, statSync(join(directory, file)).mtimeMs); } catch { /* none */ } }
+        if (Date.now() - last < CODEX_RELAY_KEPT_MS) continue;
+      } else if (harness !== 'claude-code') continue;
+      // only a Claude session is provably ended when the map does not hold it (its registry lists every live Claude
+      // process); a sender of another harness the map may not see (Grok, Gemini, a Codex session idle a day) is kept
+      if (await this.#retireFolder(directory, represented)) retired++;
+    }
+    if (retired) this.log(`relays: ${retired} of sessions that ended while no daemon ran retired`);
+  }
+
   /** `work` run under the relay folder's lock: one send, or one close, at a time per relay, in arrival order. */
   async #locked(directory, work) {
     const previous = this.sending.get(directory) ?? Promise.resolve();
@@ -129,13 +213,8 @@ export class Relays {
     };
   }
 
-  /** The relay endpoint's base URL, when it answers (claude_relay.rs `relay_endpoint`; the native watch serves it until
-   *  step 4, its port in `<mail>/relay-endpoint.json`). */
-  async endpoint() {
-    const port = readJson(join(this.mailRoot, 'relay-endpoint.json'))?.port;
-    if (!Number.isInteger(port)) return null;
-    return (await answers(port)) ? `http://127.0.0.1:${port}` : null;
-  }
+  /** The relay endpoint's base URL: this daemon's own (relay-endpoint.mjs), or null when it is not served. */
+  async endpoint() { return this.endpointOf(); }
 
   /** Settings installing a relay's hooks: its gate on every tool, its receipt on SendMessage and on a turn's end, and its
    *  inbound filing (claude_relay.rs `relay_settings`). */
@@ -168,7 +247,7 @@ export class Relays {
   async #ensure(spec, step = () => {}) {
     const endpoint = await this.endpoint();
     step('relay endpoint');
-    if (!endpoint) throw new Error('the relay endpoint is not answering; the machine daemon\'s `supercode message watch` serves it (see mail/machine-daemon.log)');
+    if (!endpoint) throw new Error('the relay endpoint is not served by this machine\'s daemon (its log says why); a Claude session can be sent mail once the daemon starts again');
     // written on every send: Claude Code reloads a changed settings file, so a running relay takes the hooks this
     // supercode installs
     writeFileSync(spec.settings, JSON.stringify(this.#settings(spec), null, 2));
@@ -249,14 +328,18 @@ export class Relays {
    */
   async send(sender, senderName, receiver, message, messageId) {
     const spec = this.spec(sender, senderName);
-    mkdirSync(spec.directory, { recursive: true });
     const asked = performance.now();
     try { return await this.#locked(spec.directory, () => this.#send(spec, receiver, message, messageId, asked)); }
-    finally { this.#cap(); }
+    finally {
+      if (String(sender).split(':')[1] !== this.machine) this.#keepRemote(spec.directory);
+      this.#cap();
+    }
   }
 
   async #send(spec, receiver, message, messageId, asked) {
     try {
+      // made under its lock: a retire that held the lock meanwhile may have removed it
+      mkdirSync(spec.directory, { recursive: true });
       const queued = { to: receiver.socket ? `uds:${receiver.socket}` : receiver.name, message };
       const steps = [], began = asked;
       let mark = began;

package/mail/send.mjs

@@ -205,6 +205,8 @@ export class MailSend {
     if (session.door === 'runtime') return { kind: 'runtime', session };
     if (session.door === 'native') return { kind: 'native', 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 };
     return { kind: 'stored', session };
   }
 
@@ -264,7 +266,10 @@ export class MailSend {
       queued: [0, 'it is idle and --queue leaves it so; the message waits in its mailbox'],
       operator: [0, 'filed in its mailbox'],
       already: [0, 'it already had this message; nothing was sent again'],
-      stored: [EXIT_STORED, 'Stored (not failed): it has no delivery door, so it sees this only if it runs supercode message inbox (a Codex session gets one with: supercode message setup codex). Don\'t resend, and don\'t wait for a reply'],
+      typed: [0, 'typed into its pane as its next turn'],
+      pane_held: [0, 'held for its pane: typed once its composer is free'],
+      pane_waits: [EXIT_STORED, 'Stored (not failed): its pane\'s composer was not empty, so the message waits in its mailbox; it sees it with supercode message inbox. Don\'t resend'],
+      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);
     const harness = parseAddress(address).harness;
@@ -322,10 +327,18 @@ export class MailSend {
       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;
+      if (wake) { try { typed = await this.typeTurn(door.pane, parseAddress(to).harness, render(sent), [sent.id]); } catch { /* waits */ } }
+      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); delivered = 'pane_held'; }
+      else { this.store.deliver(to, sent); delivered = wake ? 'pane_waits' : 'queued'; }
     } else if (door.kind === 'stored') { this.store.deliver(to, sent); delivered = 'stored'; }
     else { this.store.deliver(to, sent); delivered = 'operator'; }
     // a hand-over to the recipient's own door is its delivery, recorded as such
-    if (['steered', 'started', 'native_busy', 'native_idle'].includes(delivered)) {
+    if (['steered', 'started', 'native_busy', 'native_idle', 'typed'].includes(delivered)) {
       try { this.store.claimFor(to, sent.id, { pid: process.pid, via: 'door', caller: null, recipient: true, at_ms: Date.now() }); } catch { /* best kept */ }
     }
     // nor is an idle notice routed to a claimed address (D200)
@@ -409,7 +422,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' }[how];
+    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];
   }
 
   // ---- a filing --------------------------------------------------------------------------------------------------
@@ -507,9 +520,9 @@ export class MailSend {
       return refused('delivery_failed', error.message);
     }
     return {
-      delivered_to_bus: door.kind !== 'stored', message_id: sent.id, reply_to: sender,
+      delivered_to_bus: door.kind !== 'stored' && how !== 'pane_waits', 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_busy: 'next_tool_call', native_idle: 'started', hooked: 'hook', queued: 'queued', stored: 'stored', operator: 'filed', already: 'already' }[how] },
+      delivery: { door: door.kind, how: { steered: 'steered', started: 'started', native_busy: 'next_tool_call', 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.96",
+  "version": "0.3.98",
   "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",