@volter/supercode-teams 0.3.97 → 0.3.99

package/live-sessions.mjs

@@ -53,13 +53,34 @@ function linuxStart(pid) {
   } catch { return null; }
 }
 
-/** The parent of the live process `pid` (Linux's /proc, or one `ps` on macOS), or null when it cannot be read. */
+/** 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) => execFile('ps', ['-o', 'ppid=', '-p', String(pid)], { timeout: 10_000 }, (error, stdout) => resolve(error ? null : Number(String(stdout).trim()) || 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). */
@@ -119,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 = [];
@@ -142,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;
@@ -188,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);
@@ -196,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); }
     };
@@ -231,6 +266,7 @@ export class LiveSessions extends EventEmitter {
     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();
   }
@@ -372,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;
@@ -538,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

@@ -30,6 +30,7 @@ import { spawn, spawnSync, execFile } from 'node:child_process';
 import { EventEmitter } from 'node:events';
 import { appendFileSync, readFileSync, writeFileSync, writeSync, statSync, readdirSync, mkdirSync, renameSync, rmSync, existsSync, openSync, readSync, closeSync, accessSync, constants } from 'node:fs';
 import { basename, join, resolve, dirname, isAbsolute } from 'node:path';
+import { open as openAsync, readdir as readdirAsync } from 'node:fs/promises';
 import { askBoardOwner, BOARD_OPERATION_VERBS, boardHome } from '@volter/teams/board-owner';
 import { openMachine, normalMachineName } from '@volter/teams/machine-door';
 import { RecordHolder, RecordProducer, RECENT_PER_MAILBOX, RECORDS_NOT_GRANTED } from './machine-records.mjs';
@@ -106,6 +107,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
@@ -151,6 +154,31 @@ const LAUNCH_SETTLE_MS = 500;
 /** How long a send to another machine waits for its mail door's answer (its receiver's door there: a relay's receipt
  *  alone may take 90 s). An answer that does not come is unanswered, never refused or failed. */
 const MAIL_SEND_MS = 120_000;
+
+/** How much of a transcript's end is read for a message that just landed. */
+const LANDING_TAIL_BYTES = 4 * 1024 * 1024;
+
+/**
+ * Whether Claude session `sessionId`'s transcript (`<projects>/<folder>/<id>.jsonl`, in any of `projectsDirs`) holds
+ * `landed` in its last LANDING_TAIL_BYTES: a relay's send whose receipt was lost is read where it lands. Read apart from
+ * the daemon's loop (it runs once per unconfirmed send).
+ */
+async function claudeTranscriptHolds(projectsDirs, sessionId, landed) {
+  for (const projects of projectsDirs) {
+    let folders = [];
+    try { folders = await readdirAsync(projects); } catch { continue; }
+    for (const folder of folders) {
+      let file;
+      try { file = await openAsync(join(projects, folder, `${sessionId}.jsonl`), 'r'); } catch { continue; }
+      try {
+        const { size } = await file.stat(), length = Math.min(size, LANDING_TAIL_BYTES);
+        const { buffer } = await file.read(Buffer.alloc(length), 0, length, size - length);
+        if (buffer.toString('utf8').includes(landed)) return true;
+      } finally { await file.close(); }
+    }
+  }
+  return false;
+}
 /**
  * The doors whose work waits on a session, with the bound each answers within (the node door's own is 30 s): a send or
  * a hand-over waits on its receiver's door (a relay's receipt, up to 90 s; another machine's door, MAIL_SEND_MS), a
@@ -547,6 +575,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();
@@ -623,7 +652,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
@@ -636,9 +664,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`);
@@ -683,6 +708,7 @@ export class TeamsMachine extends MachineCore {
       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,
+      arrived: (sessionId, landed) => claudeTranscriptHolds([...live.claudeDirs.keys()].map((dir) => join(dirname(dir), 'projects')), sessionId, landed),
       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
@@ -713,7 +739,8 @@ export class TeamsMachine extends MachineCore {
       // known view stands until they are known again
       if (!live.codexKnown) return;
       const now = new Map(live.sessions().map((row) => [row.address, row.name]));
-      for (const [address, name] of wasLive) if (!now.has(address)) void this.relays.retire(address, name).catch(() => {});
+      // 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) => {
@@ -775,6 +802,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) {
@@ -818,22 +847,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
@@ -856,10 +872,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) => {
@@ -1047,8 +1061,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');
@@ -1125,7 +1142,7 @@ export class TeamsMachine extends MachineCore {
       this.internalRequests.set(id, { resolve, reject });
       if (!this.#toServe(`${JSON.stringify({ jsonrpc: '2.0', id: joinId(INTERNAL_CONNECTION, id), method, params })}\n`)) {
         this.internalRequests.delete(id);
-        return reject(new Error('harness serve is not running'));
+        return reject(Object.assign(new Error('harness serve is not running'), { notAsked: true }));
       }
       setTimeout(() => { if (this.internalRequests.delete(id)) reject(new Error(`${method} timed out`)); }, timeoutMs).unref();
     });
@@ -1140,7 +1157,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') {
@@ -1149,7 +1172,8 @@ export class TeamsMachine extends MachineCore {
             if (typeof value === 'string') { if (!this.routes.has(value)) this.routes.set(value, new Set()); this.routes.get(value).add(INTERNAL_CONNECTION); }
           }
         }
-        if (message.error) pending.reject(new Error(message.error.message ?? 'harness serve refused'));
+        // an answer that is an error is marked answered: a call refused, not one whose outcome is unknown
+        if (message.error) pending.reject(Object.assign(new Error(message.error.message ?? 'harness serve refused'), { answered: true, code: message.error.code ?? null }));
         else pending.resolve(message.result);
         return;
       }
@@ -2228,15 +2252,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.mjs

@@ -10,7 +10,7 @@
 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';
+import { blake3Hex, shortId } from './envelope.mjs';
 
 /** Model name a relay's requests carry; the relay endpoint answers them without any model. */
 const RELAY_MODEL = 'haiku';
@@ -18,6 +18,26 @@ const RELAY_MODEL = 'haiku';
 export const RELAY_NAME_PREFIX = 'sc-';
 /** How long a send waits for Claude's own receipt. */
 const SEND_TIMEOUT_MS = 90_000;
+
+/** How long an unconfirmed send is given to land in its receiver's transcript before that is read: a SendMessage that
+ *  passed the gate just before the send ended lands within it. */
+const LANDING_MS = 2000;
+
+/** How long a hand-in waits for its relay's last turn to end: a relay's receipt is written mid-turn (at its
+ *  SendMessage), so the next send through it may find that turn still finishing. Past this the turn is stuck. */
+const TURN_END_MS = 15_000;
+
+/** A relay close's bound: over harness serve's own (RUNTIME_CONTROL_DEADLINE, 30 s), past which serve ends the
+ *  runtime's process group itself, so a relay stuck in a turn is closed through serve, never left running. */
+const CLOSE_MS = 35_000;
+
+/**
+ * Whether harness serve's error for a relay's input leaves its outcome unknown: no answer (its bound passed, serve ended
+ * mid-call) or serve's own deadline on the runtime ("gave up after", harness_service.rs `within_control_deadline`).
+ * Any other answer is a refusal of the input (a turn in progress, an unknown or closed connection), and a call never
+ * made (no serve to ask) was not handed in either.
+ */
+const answerLost = (error) => !error.notAsked && (!error.answered || /gave up after \d+s/.test(error.message));
 /** A relay send slower than this says where its time went. */
 const SLOW_SEND_MS = 2000;
 /** Largest message relayed into a Claude session: the relay copies it into a model turn byte for byte. */
@@ -28,6 +48,8 @@ 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;
 
@@ -66,8 +88,8 @@ 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 = () => [], endpointOf = async () => null, log = () => {} }) {
-    Object.assign(this, { mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed, runtimesIn, endpointOf, log });
+  constructor({ mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed = () => null, runtimesIn = () => [], endpointOf = async () => null, arrived = async () => false, log = () => {} }) {
+    Object.assign(this, { mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed, runtimesIn, endpointOf, arrived, 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)
@@ -84,7 +106,7 @@ export class Relays {
       this.running.delete(directory);
       // closed under the relay's own lock: a send to it that arrives meanwhile waits for the close, then starts it
       // again, never handing its turn to a runtime that is closing
-      void this.#locked(directory, () => this.serve('harness.v1.runtimes.close', { connection: relay.connection, runtime_id: relay.runtime_id }, 15_000))
+      void this.#locked(directory, () => this.serve('harness.v1.runtimes.close', { connection: relay.connection, runtime_id: relay.runtime_id }, CLOSE_MS))
         .catch((error) => {
           // still running, so still counted: the next cap closes it again (unless a send started it anew meanwhile)
           if (!this.running.has(directory)) this.running.set(directory, relay);
@@ -100,7 +122,7 @@ export class Relays {
       for (const ids of this.runtimesIn('claude-code', directory)) {
         if (ids.includes(named)) continue;
         void this.#locked(directory, async () => {
-          for (const id of ids) { try { await this.serve('harness.v1.runtimes.close', { runtime_id: id }, 15_000); return; } catch { /* the other id */ } }
+          for (const id of ids) { try { await this.serve('harness.v1.runtimes.close', { runtime_id: id }, CLOSE_MS); return; } catch { /* the other id */ } }
           this.log(`relay ${directory.split(/[\\/]/).pop()}: a runtime its lost start left running was not closed`);
         });
       }
@@ -133,7 +155,7 @@ export class Relays {
       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); }
+        try { await this.serve('harness.v1.runtimes.close', { connection: record.connection ?? '', runtime_id: record.runtime_id }, CLOSE_MS); }
         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; }
@@ -172,7 +194,12 @@ export class Relays {
       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 (harness !== 'claude-code' || running(represented)) 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++;
@@ -237,7 +264,7 @@ export class Relays {
 
   /** The relay's runtime, started in this daemon's harness serve when it is not running (claude_relay.rs
    *  `ensure_relay_runtime`): `{ runtime (its receipt), connection }`. */
-  async #ensure(spec, step = () => {}) {
+  async #ensure(spec, step = () => {}, { stale = false } = {}) {
     const endpoint = await this.endpoint();
     step('relay endpoint');
     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');
@@ -247,15 +274,16 @@ export class Relays {
     const record = readJson(spec.record);
     if (record?.runtime_id) {
       const runtime = this.runtimeOf('claude-code', record.runtime_id);
-      if (runtime && alive(this.#pid(spec, runtime)) && record.connection && (record.endpoint === endpoint || await answers(Number(String(record.endpoint ?? '').split(':').pop())))) {
+      if (!stale && runtime && alive(this.#pid(spec, runtime)) && record.connection && (record.endpoint === endpoint || await answers(Number(String(record.endpoint ?? '').split(':').pop())))) {
         step('runtime reused');
         return { runtime, connection: record.connection };
       }
       // why it is not reused, said in the timing line: a relay that should have been warm and was not shows here
-      step(`runtime not reused (${!runtime ? 'no live receipt' : !alive(this.#pid(spec, runtime)) ? 'its process ended' : !record.connection ? 'no connection' : 'endpoint moved'})`);
+      step(`runtime not reused (${stale ? 'it held a stale turn' : !runtime ? 'no live receipt' : !alive(this.#pid(spec, runtime)) ? 'its process ended' : !record.connection ? 'no connection' : 'endpoint moved'})`);
       // closed through the owner's door even after its receipt went
-      try { await this.serve('harness.v1.runtimes.close', { connection: record.connection, runtime_id: record.runtime_id }, 15_000); }
+      try { await this.serve('harness.v1.runtimes.close', { connection: record.connection, runtime_id: record.runtime_id }, CLOSE_MS); }
       catch (error) { if (this.runtimeOf('claude-code', record.runtime_id)) throw new Error(`could not retire the old relay: ${error.message}`); }
+      step('old runtime closed (runtimes.close)');
     }
     const key = spec.directory.split(/[\\/]/).pop();
     const started = await this.#start(spec, {
@@ -290,7 +318,7 @@ export class Relays {
     if (!runtime) {
       // a runtime no send can use is closed, never left running untracked
       this.running.delete(spec.directory);
-      try { await this.serve('harness.v1.runtimes.close', { connection, runtime_id: runtimeId }, 15_000); } catch { /* said below */ }
+      try { await this.serve('harness.v1.runtimes.close', { connection, runtime_id: runtimeId }, CLOSE_MS); } catch { /* said below */ }
       throw new Error('the relay started but registered no live runtime; it was closed');
     }
     return { runtime, connection };
@@ -305,11 +333,12 @@ export class Relays {
       const check = () => {
         const value = readJson(spec.receipt);
         if (value) return finish(readReceipt(value));
-        if (pid && !alive(pid)) finish({ delivered: false, detail: 'the Claude relay process exited before confirming the send' });
+        // not known either way: it may have sent before it ended
+        if (pid && !alive(pid)) finish({ delivered: false, unknown: true, detail: 'the Claude relay process exited before confirming the send' });
       };
       try { watcher = watch(spec.directory, () => check()); watcher.on('error', () => {}); } catch { /* checked on the timer */ }
       timer = setInterval(check, 500);
-      deadline = setTimeout(() => finish({ delivered: false, detail: `the Claude relay did not confirm the send within ${SEND_TIMEOUT_MS / 1000} seconds; it may still arrive` }), SEND_TIMEOUT_MS);
+      deadline = setTimeout(() => finish({ delivered: false, unknown: true, detail: `the Claude relay did not confirm the send within ${SEND_TIMEOUT_MS / 1000} seconds; it may still arrive` }), SEND_TIMEOUT_MS);
       check();
     });
   }
@@ -321,17 +350,20 @@ 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)); }
+    // the message as its receiver's transcript holds it once delivered (envelope.mjs render, its tag escaped there)
+    const landed = `cross-session-message id=\\"${shortId(messageId)}\\" from=\\"${sender}\\"`;
+    try { return await this.#locked(spec.directory, () => this.#send(spec, receiver, message, messageId, asked, landed)); }
     finally {
       if (String(sender).split(':')[1] !== this.machine) this.#keepRemote(spec.directory);
       this.#cap();
     }
   }
 
-  async #send(spec, receiver, message, messageId, asked) {
+  async #send(spec, receiver, message, messageId, asked, landed) {
     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;
@@ -343,8 +375,30 @@ export class Relays {
       writeFileSync(spec.queue, JSON.stringify(queued));
       let receipt;
       for (let attempt = 0; ; attempt++) {
-        try { await this.serve('harness.v1.runtimes.send_input', { connection, text: sendTurn(queued) }, 30_000); step('turn handed in (send_input)'); receipt = await this.#receipt(spec, this.#pid(spec, runtime)); step('Claude\'s receipt'); }
-        catch (error) { receipt = { delivered: false, detail: `could not reach the Claude relay: ${error.message}` }; }
+        // A hand-in whose answer did not come (its bound passed, serve ended mid-call, serve's own deadline on the
+        // runtime) may still have reached the relay, which then sends: its receipt is waited on as after any hand-in. A
+        // hand-in refused (an answer that is an error) or never asked (no serve) did not reach it, and is said at once,
+        // never held for a receipt that cannot come.
+        let handed = true;
+        const error = await this.#handIn(connection, queued, step);
+        if (!error) step('turn handed in (send_input)');
+        else if (answerLost(error)) step(`turn handed in, its answer lost (send_input: ${error.message})`);
+        else {
+          handed = false;
+          // still in a turn after TURN_END_MS while this send holds its lock: a turn of a send that already ended (its
+          // queue gone, so its gate refuses whatever that turn tries), stuck. The relay is closed through serve and
+          // started again, once
+          if (attempt === 0 && /already in progress/.test(error.message)) {
+            step(`relay still in a turn after ${TURN_END_MS / 1000} s, closed (${error.message})`);
+            ({ runtime, connection } = await this.#ensure(spec, step, { stale: true }));
+            this.#used(spec, connection);
+            rmSync(spec.receipt, { force: true });
+            continue;
+          }
+          receipt = { delivered: false, detail: `the Claude relay did not take the send: ${error.message}` };
+        }
+        if (!handed) break;
+        receipt = await this.#receipt(spec, this.#pid(spec, runtime)); step('Claude\'s receipt');
         const pid = this.#pid(spec, runtime);
         // only a relay proven dead is started again; one alive but slow may still deliver
         if (receipt.delivered || attempt === 1 || pid == null || alive(pid)) break;
@@ -352,6 +406,16 @@ export class Relays {
         rmSync(spec.receipt, { force: true });
       }
       rmSync(spec.queue, { force: true });
+      // an outcome not confirmed is read where it would have landed: the relay can no longer send it (its queue is
+      // gone), so the receiver's transcript says whether it did
+      if (!receipt.delivered && receipt.unknown) {
+        await new Promise((resolve) => setTimeout(resolve, LANDING_MS));
+        let found = false;
+        try { found = await this.arrived(receiver.sessionId, landed); } catch { /* unread: unknown */ }
+        step(found ? 'found in its receiver\'s transcript' : 'not in its receiver\'s transcript');
+        if (found) receipt = { delivered: true };
+        else receipt = { ...receipt, landed: false };
+      }
       if (receipt.delivered) {
         const sent = readJson(spec.sent) ?? {};
         sent[receiver.sessionId] = messageId;
@@ -366,6 +430,25 @@ export class Relays {
     }
   }
 
+  /**
+   * Hand the send's turn to the relay (`runtimes.send_input`): null once taken, else the error. A relay still in a turn
+   * (its last send's: its receipt is written mid-turn, the turn ends a moment later) is asked again every 250 ms for up
+   * to TURN_END_MS; the error is then that refusal.
+   */
+  async #handIn(connection, queued, step) {
+    const asked = performance.now();
+    for (;;) {
+      try { await this.serve('harness.v1.runtimes.send_input', { connection, text: sendTurn(queued) }, 30_000); }
+      catch (error) {
+        if (answerLost(error) || !/already in progress/.test(error.message) || performance.now() - asked > TURN_END_MS) return error;
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        continue;
+      }
+      if (performance.now() - asked > 250) step(`waited for its last turn to end`);
+      return null;
+    }
+  }
+
   /** `runtimes.start` for a relay: a start that fails (its answer lost, or late past its bound) may still have left a
    *  runtime running, so its folder is looked at by the next caps (#cap). */
   async #start(spec, params, timeoutMs) {

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 };
   }
 
@@ -252,6 +254,8 @@ export class MailSend {
     catch (error) {
       if (error instanceof Refused && error.kind === 'queue') return outcome(EXIT_REFUSED, `Not sent: ${name} is idle, and a Claude session always starts a turn when a message arrives, so --queue cannot hold it. Send without --queue to wake it.`);
       if (error instanceof Refused) return outcome(EXIT_REFUSED, `Not sent: the message is ${error.bytes} bytes; the limit is ${MAX_RELAYED_BYTES}. Write it to a file and send its path instead.`);
+      // may have arrived: kept filed, and said unanswered with its id (sent again with the same id, nothing is sent twice)
+      if (error.unanswered) { this.#recordSend(caller.address, address, messageId, sentIn); return outcome(EXIT_UNANSWERED, unansweredText(`${name}'s Claude relay`, error.message, messageId)); }
       return outcome(EXIT_FAILED, `Not sent to ${name}: ${error.message}`);
     }
     const [code, what] = {
@@ -264,7 +268,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;
@@ -316,16 +323,34 @@ export class MailSend {
       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);
-      if (!relayed.delivered) { if (filedHere) { try { unlinkSync(filed); } catch { /* gone */ } } throw new Error(relayed.detail); }
+      // 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
+      // 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) {
+        if (filedHere) { try { this.store.markUnread(to, filed); if (wake) this.store.requestWake(to, handed.id); } catch { /* kept read */ } }
+        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); }
       delivered = busy ? 'native_busy' : 'native_idle';
     } else if (door.kind === 'hook') {
       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)
@@ -355,7 +380,7 @@ export class MailSend {
         continue;
       }
       try { reached.push(`${label} (${await this.#deliverWoken(sent, recipient.address, sessions, queue, notify_when_idle)})`); }
-      catch (error) { failed.push(`${label} (${error.message})`); }
+      catch (error) { failed.push(error.unanswered ? `${label} (unanswered, whether it arrived is unknown: ${error.message})` : `${label} (${error.message})`); }
     }
     const thread = plan.thread ? ` Thread ${shortId(plan.thread.id)}.` : '';
     let text;
@@ -409,7 +434,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 --------------------------------------------------------------------------------------------------
@@ -504,12 +529,13 @@ export class MailSend {
     try { how = await this.route(sent, receiver, door, true, params.notify_when_idle === true); }
     catch (error) {
       if (error instanceof Refused && error.kind === 'too_long') return refused('too_long', `the message is ${error.bytes} bytes; the limit is ${MAX_RELAYED_BYTES}`);
+      if (error.unanswered) return { ...refused('unanswered', unansweredText(`the Claude relay`, error.message, sent.id)), message_id: sent.id };
       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] },
     };
   }
 
@@ -673,6 +699,9 @@ export class MailSend {
       return { outcome: 'delivered', detail: null };
     } catch (error) {
       // a message its door can never take (too long for a relay) stays filed for the session to read
+      // one whose hand-over is unanswered was not found where it would have landed: it stays unread and its wake stays,
+      // tried again after its backoff (a wake settled as filed would leave an idle receiver never told)
+      if (error.unanswered) return { outcome: 'later', detail: `unanswered: ${error.message}` };
       return error instanceof Refused ? { outcome: 'filed', detail: error.kind } : { outcome: 'later', detail: error.message };
     } finally {
       const after = this.store.wakeState(address, id);

package/mail/store.mjs

@@ -397,6 +397,12 @@ export class MailStore extends EventEmitter {
     renameSync(path, join(box.dir, 'cur', path.split(/[\\/]/).pop()));
   }
 
+  /** A message filed read moved back to `new/`, unread, under its own name: a hand-over that may not have reached it. */
+  markUnread(address, path) {
+    const box = this.open(address);
+    renameSync(path, join(box.dir, 'new', path.split(/[\\/]/).pop()));
+  }
+
   /** A wake kept beside the envelope (mailbox.rs `request_wake`): its watcher hands it to the session's door. */
   requestWake(address, id) {
     if (!/^[A-Za-z0-9_-]+$/.test(id)) throw new Error('invalid wake message id');

package/package.json

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