@volter/supercode-teams 0.3.88 → 0.3.90

package/bin/teams.mjs

@@ -174,6 +174,7 @@ async function main() {
         // --verbose narrates every door with its latency, so a slow machine is diagnosed from its own log.
         machine.on('door', (d) => { if (flags.verbose) process.stderr.write(`door ${d.method} ${d.outcome} ${d.ms}ms${d.detail ? ` ${d.detail}` : ''}\n`); });
         machine.on('serve-stderr', (t) => process.stderr.write(t));
+        machine.on('mail-log', (line) => process.stderr.write(`mail: ${line}\n`));
         machine.on('serve-exit', (e) => process.stderr.write(`harness serve exited: ${JSON.stringify(e)}\n`));
         machine.on('unrouted-notification', (m) => { if (flags.verbose) process.stderr.write(`unrouted: ${m.method}\n`); });
         const socket = await machine.start();

package/bin/workspace.mjs

@@ -1135,6 +1135,7 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
     // what ends the daemon's harness serve is said in the connector's log, as `machine start` says it
     machine.on('serve-exit', (exit) => process.stderr.write(`supercode teams: harness serve exited: ${JSON.stringify(exit)}\n`));
     machine.on('serve-stderr', (text) => process.stderr.write(`supercode teams: harness serve: ${String(text).trimEnd().slice(-2000)}\n`));
+    machine.on('mail-log', (line) => process.stderr.write(`supercode teams: mail: ${line}\n`));
     // its mail goes through the daemon's own send, in this process
     machineEvents.send = (request) => machine.sendOwn(request);
     // the Claude worker homes the roots declare: their live sessions are this machine's too (the live-session map)

package/live-sessions.mjs

@@ -17,6 +17,7 @@ import { execFile } from 'node:child_process';
 import { mkdirSync, readFileSync, readdirSync, renameSync, watch, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
+import { FrontendClient } from '@volter/supercode-frontend';
 
 /** A relay registers in Claude's registry under this prefix; it is not a session. */
 const RELAY_PREFIX = 'sc-';
@@ -49,6 +50,29 @@ function linuxStart(pid) {
   } catch { return null; }
 }
 
+/** When the process on `pid` started, in ms (Linux's /proc, or one `ps` on macOS), or null when it cannot be read. */
+function startedMs(pid) {
+  if (process.platform === 'linux') { const started = linuxStart(pid); return Promise.resolve(started ? Date.parse(`${started.date} UTC`) : null); }
+  if (process.platform !== 'darwin') return Promise.resolve(null);
+  return new Promise((resolve) => execFile('ps', ['-o', 'lstart=', '-p', String(pid)], { env: { ...process.env, TZ: 'UTC', LC_ALL: 'C' }, timeout: 10_000 }, (error, stdout) => {
+    const started = error ? null : String(stdout).replace(/\s+/g, ' ').trim();
+    resolve(started ? Date.parse(`${started} UTC`) : null);
+  }));
+}
+
+/** Whether the runtime a receipt names answers at its address as that runtime (its own identity, with the receipt's
+ *  token): the proof a start read off the wall clock cannot give, as the clock may have stepped since the receipt.
+ *  true or false, or null when it did not answer within 2 s (the request is aborted then): not known either way. */
+async function answersAs(receipt) {
+  try {
+    const client = new FrontendClient({ baseUrl: receipt.base_url, token: receipt.token, clientId: `live-${receipt.receipt_id}`, permissions: ['observe'] });
+    return (await client.describe({ signal: AbortSignal.timeout(2000) }))?.session_id === receipt.runtime_session_id;
+  } catch (error) {
+    if (error?.name === 'TimeoutError' || error?.name === 'AbortError') return null;
+    return false;
+  }
+}
+
 /** Why a claim names no caller. */
 export class CallerRefused extends Error {
   constructor(message) { super(message); this.code = 403; }
@@ -284,8 +308,44 @@ export class LiveSessions extends EventEmitter {
       if (this.runtimes.delete(id)) this.#changed();
       return;
     }
-    this.runtimes.set(id, { pid: receipt.pid, harness: source.harness, sessionId: source.session_id, runtimeSessionId: typeof receipt.runtime_session_id === 'string' ? receipt.runtime_session_id : null, cwd: typeof source.workspace === 'string' ? source.workspace : null });
+    this.#holdRuntime(id, receipt);
+  }
+
+  /**
+   * A live-runtime receipt held in the map, its process's start checked once (on Linux from /proc, on macOS by one `ps`,
+   * as a Claude entry's is): a process that started after its receipt was written is its pid used again, and the
+   * receipt is let go, never named as that runtime.
+   */
+  #holdRuntime(id, receipt) {
+    const source = receipt.source;
+    const entry = { pid: receipt.pid, harness: source.harness, sessionId: source.session_id, runtimeSessionId: typeof receipt.runtime_session_id === 'string' ? receipt.runtime_session_id : null, cwd: typeof source.workspace === 'string' ? source.workspace : null,
+      // what a later check of the same pid needs: when the receipt was written, and how to ask the runtime itself
+      created: Number(receipt.created_at_ms), probe: { base_url: receipt.base_url, token: receipt.token, receipt_id: id, runtime_session_id: receipt.runtime_session_id } };
+    const known = this.runtimes.get(id);
+    if (known && known.pid === entry.pid && known.startChecked) entry.startChecked = true;
+    this.runtimes.set(id, entry);
     this.#changed();
+    if (entry.startChecked || !Number.isFinite(entry.created)) return;
+    entry.startChecked = true;
+    void this.#samePid(entry).then((same) => {
+      if (same || this.runtimes.get(id) !== entry) return;
+      this.runtimes.delete(id);
+      this.log(`live sessions: the runtime receipt ${id} names pid ${entry.pid}, but that process started after the receipt was written and does not answer as the runtime: the pid was used again; the receipt is let go`);
+      this.#changed();
+    });
+  }
+
+  /**
+   * Whether the process on a held runtime's pid is still the runtime its receipt names: one that started no later than
+   * the receipt was written (ps and /proc say a start to the second, so within 2 s), or, when its start reads later,
+   * one that answers as the runtime at the receipt's address (a wall clock that stepped forward makes a live runtime's
+   * start read late; a pid used again does not answer as it).
+   */
+  async #samePid(entry) {
+    if (!alive(entry.pid)) return false;
+    const started = await startedMs(entry.pid);
+    if (!Number.isFinite(started) || !Number.isFinite(entry.created) || started <= entry.created + 2000) return true;
+    return (await answersAs(entry.probe)) !== false;
   }
 
   /** One messaging-tools marker: the session process named by its file, the server pid in it. */
@@ -425,10 +485,7 @@ export class LiveSessions extends EventEmitter {
     if (typeof receiptId !== 'string' || !/^[0-9a-f]+$/i.test(receiptId)) return null;
     const receipt = readReceiptFile(join(this.receiptsDir, `${receiptId}.json`));
     if (!receipt || receipt.receipt_id !== receiptId || typeof receipt.source?.harness !== 'string' || typeof receipt.source?.session_id !== 'string') return null;
-    if (!this.runtimes.has(receiptId)) {
-      this.runtimes.set(receiptId, { pid: receipt.pid, harness: receipt.source.harness, sessionId: receipt.source.session_id, runtimeSessionId: typeof receipt.runtime_session_id === 'string' ? receipt.runtime_session_id : null, cwd: typeof receipt.source.workspace === 'string' ? receipt.source.workspace : null });
-      this.#changed();
-    }
+    if (!this.runtimes.has(receiptId)) this.#holdRuntime(receiptId, receipt);
     return receipt;
   }
 
@@ -453,11 +510,13 @@ export class LiveSessions extends EventEmitter {
   }
 
   /** The session a client runs in, from its claim: its parent's current session, else its environment's id through the map. */
-  #sessionOfClaim({ pid, ppid, session, runtime }) {
+  async #sessionOfClaim({ pid, ppid, session, runtime }) {
     // a runtime supercode hosts (the native agent) says so in its claim: it is named by its own process first, never by
     // the session whose shell started it; one with no receipt is named by the rest of its claim, as any client is
     if (runtime === true) {
-      const own = this.#runtimeOfPid(Number(pid));
+      // a pid several receipts name is no one runtime: the rest of the claim names it, never a refusal here
+      let own = null;
+      try { own = await this.#runtimeOfPid(Number(pid)); } catch (error) { if (!(error instanceof CallerRefused) || error.unconfirmed) throw error; }
       if (own) return own;
     }
     const parent = this.claude.get(Number(ppid));
@@ -471,18 +530,26 @@ export class LiveSessions extends EventEmitter {
     // only when exactly one live runtime's receipt names that process. A process several receipts name (harness serve
     // records its own pid on each runtime it hosts with no child of its own) is no one runtime, and is refused.
     for (const candidate of [Number(pid), Number(ppid)]) {
-      const found = this.#runtimeOfPid(candidate);
+      const found = await this.#runtimeOfPid(candidate);
       if (found) return found;
     }
     return null;
   }
 
   /** The runtime whose live receipt alone names process `pid`, or null; several receipts naming it are no one runtime, refused. */
-  #runtimeOfPid(pid) {
+  async #runtimeOfPid(pid) {
     if (!Number.isInteger(pid) || pid <= 0) return null;
     const held = [...this.runtimes.values()].filter((runtime) => runtime.pid === pid && alive(runtime.pid));
     if (held.length > 1) throw new CallerRefused(`process ${pid} hosts ${held.length} runtimes, so which one is calling is not known; nothing was done`);
-    return held.length === 1 ? this.#address(held[0].harness, held[0].sessionId) : null;
+    if (held.length !== 1) return null;
+    // a caller's identity: checked again now, with no process (the runtime asked at its own address), as a runtime that
+    // ended may have left its pid to another process before the sweep lets its receipt go
+    const answered = await answersAs(held[0].probe);
+    // one that did not answer in time is not known either way: refused, never taken for its parent's session or its
+    // environment's (which would name another caller)
+    if (answered === null) throw Object.assign(new CallerRefused(`process ${pid} is a runtime that did not answer within 2 s, so which session is calling was not confirmed; nothing was done`), { unconfirmed: true });
+    if (!answered) return null;
+    return this.#address(held[0].harness, held[0].sessionId);
   }
 
   /**
@@ -490,7 +557,7 @@ export class LiveSessions extends EventEmitter {
    * calling"): a session's address, a board's address, or null for a person. Throws CallerRefused when the claim names
    * a caller the map does not hold.
    */
-  callerOf(claim) {
+  async callerOf(claim) {
     const { pid, owner, named } = claim ?? {};
     const board = typeof named === 'string' ? new RegExp(`^sc:${this.machine.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}:board:([^:\\s]+)$`).exec(named) : null;
     // a board's owner, by the pid it registered with: the client itself, or the owner that started it as the board
@@ -499,7 +566,7 @@ export class LiveSessions extends EventEmitter {
     if (registered && [pid, Number(owner)].includes(registered) && alive(registered)) return named;
     // A board's name from anything but its owner is not taken (a card's session, a pane run for the board): the caller
     // is the session the claim resolves to, or a person, as before (a board's name stood only under its own process).
-    const session = this.#sessionOfClaim(claim ?? {});
+    const session = await this.#sessionOfClaim(claim ?? {});
     if (session) return session;
     if (board) return null;
     // a verb a pane runs for the session that launched it names that session: accepted while it is live

package/machine.mjs

@@ -36,6 +36,7 @@ import { RecordHolder, RecordProducer, RECENT_PER_MAILBOX, RECORDS_NOT_GRANTED }
 import { LiveSessions, ACTING_VARIABLES } from './live-sessions.mjs';
 import { MailStore } from './mail/store.mjs';
 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 { MailSend } from './mail/send.mjs';
@@ -635,6 +636,7 @@ export class TeamsMachine extends MachineCore {
       homes: { get claudeProjects() { return [...live.claudeDirs.keys()].map((dir) => join(dirname(dir), 'projects')); }, mailRoot },
       paneQuestion: async (pane) => { const session = await this.#paneByContext(pane); return session ? panePrompt(await this.host.capture(session.id, { lines: 60 })) : null; },
       askMachine: (machine, request) => this.#askMailDoor(machine, request),
+      log: (line) => this.emit('mail-log', line),
     });
     // a send to a session, for every entry (3b-1): its routing on the live map, an agent's plan and its doors
     const machine = machineName(this.env);
@@ -642,11 +644,21 @@ export class TeamsMachine extends MachineCore {
       discover: (params) => this.#serveRequest('harness.v1.sessions.discover', params, 10_000),
       recordedConfig: (locator) => this.#serveRequest('harness.v1.sessions.recorded_config', { locator }, 15_000) });
     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) });
+      runtimeOf: (harness, id) => live.runtimeReceipt(harness, id), runtimeNamed: (receiptId) => live.receiptNamed(receiptId),
+      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
       askMachine: (to, request) => this.#askMailDoor(to, request, MAIL_SEND_MS),
-      deliverRuntime: deliverToRuntime, codexAnswer: (request) => codexQuestions(request) });
+      deliverRuntime: deliverToRuntime, codexAnswer: (request) => codexQuestions(request),
+      // a user's own turn typed into its pane, in process (as `panes.turn` types one)
+      typeTurn: async (pane, harness, text, messageIds) => {
+        const session = await this.#paneByContext(pane);
+        if (!session) throw new Error(`no pane with context ${pane}`);
+        const result = await this.#paneTurn(session, pane, text, { messageIds, harness });
+        if (result.refused) throw new Error(result.refused.reason);
+        return result.waits ?? result;
+      },
+      log: (line) => this.emit('mail-log', line) });
     // an agent's verbs (3b-2): its threads, a delegation, its record
     this.agentVerbs = new AgentVerbs({ machine, store: this.mailStore, agents: this.agents, live, supercodeBin: this.supercodeBin, env: this.env,
       paneOf: (session) => this.mail.paneOf(session), mailRoot,
@@ -941,6 +953,8 @@ export class TeamsMachine extends MachineCore {
     this.mailWatch?.kill('SIGTERM');
     this.stoppingServe = true;
     clearTimeout(this.serveRestart);
+    // said, so a stop reads as one in the log and never as a serve that broke
+    if (this.serve) this.emit('serve-stderr', 'stopping harness serve: the daemon is stopping\n');
     this.serve?.kill('SIGTERM');
     this.host.dispose();
   }
@@ -987,7 +1001,9 @@ export class TeamsMachine extends MachineCore {
     };
     // a write into a serve that has gone (EPIPE, ECONNRESET) is its pipe's error: the serve is over, the daemon is not
     child.stdin.on('error', (error) => {
-      this.emit('serve-stderr', `harness serve's input: ${error.message}\n`);
+      // a write that races a stop's SIGTERM is the stop's, already said
+      if (this.stoppingServe) return;
+      this.emit('serve-stderr', `harness serve's input: ${error.message} (pid ${child.pid}, up ${Math.round((Date.now() - started) / 1000)} s)\n`);
       try { child.kill('SIGTERM'); } catch { /* gone */ }
       // one that does not end on SIGTERM within 5 s is killed: a serve that no longer reads is never left behind
       const grace = setTimeout(() => { if (child.exitCode === null && child.signalCode === null) { try { child.kill('SIGKILL'); } catch { /* gone */ } } }, 5000);
@@ -999,7 +1015,7 @@ export class TeamsMachine extends MachineCore {
     child.stderr.on('error', () => {});
     child.on('error', (error) => end(`could not run (${error.message})`));
     child.on('exit', (code, signal) => {
-      this.emit('serve-exit', { code, signal });
+      this.emit('serve-exit', { code, signal, pid: child.pid, up_s: Math.round((Date.now() - started) / 1000), stopping: this.stoppingServe === true });
       end(`exited (${signal ?? `code ${code}`})`);
     });
     this.serve = child;
@@ -1262,7 +1278,7 @@ export class TeamsMachine extends MachineCore {
 
   #noticeTarget(address){
     return sessionNoticeTarget(address,{machine:machineName(this.env),
-      // liveness is the live-session map's, read in-process (no process, no remote-deliver)
+      // liveness is the live-session map's, read in-process (no process)
       mail:async()=>({code:0,sessions:this.live.sessions()}),
       discover:params=>this.#serveRequest('harness.v1.sessions.discover',params,10000),
       recordedConfig:locator=>this.#serveRequest('harness.v1.sessions.recorded_config',{locator},15000)});
@@ -1276,9 +1292,10 @@ export class TeamsMachine extends MachineCore {
       if(status.state==='running')return;
       if(!status.resumable)throw Object.assign(new Error(status.reason??'native session cannot resume'),{noticeCode:'session_resume_unavailable'});
       const code=await new Promise((resolve,reject)=>{
-        // Explicit native approval and sandbox flags suppress open's unattended defaults.
-        const child=spawn(this.supercodeBin,['open',address,'--detach','--',...status.resume.args],
-          {cwd:status.resume.cwd,env:{...this.env,SUPERCODE_POPUPS:'0'},stdio:'ignore'});
+        // Explicit native approval and sandbox flags suppress open's unattended defaults. A resume made for a notice opens
+        // no window on the machine's screen: `--window=false` is the launch's own choice, which the daemon honours.
+        const child=spawn(this.supercodeBin,['open',address,'--detach','--window=false','--',...status.resume.args],
+          {cwd:status.resume.cwd,env:this.env,stdio:'ignore'});
         const timer=setTimeout(()=>{child.kill('SIGTERM');resolve(null);},15000);
         child.once('error',error=>{clearTimeout(timer);reject(error);});child.once('close',code=>{clearTimeout(timer);resolve(code);});
       });
@@ -1360,7 +1377,7 @@ export class TeamsMachine extends MachineCore {
     })();
   }
 
-  /** A send through the mail door, for a session here (message.rs `remote_deliver` send): one for another machine is
+  /** A send through the mail door, for a session here: one for another machine is
    *  refused when it came through a link (never forwarded on this machine's own credential), and this machine's own
    *  daemon sends on through the one way out. */
   async #sendHere(request, link) {
@@ -1373,7 +1390,7 @@ export class TeamsMachine extends MachineCore {
     }, { link });
   }
 
-  /** A message another machine's mailbox carried here, filed in a mailbox here (message.rs `remote_deliver` file): the
+  /** A message another machine's mailbox carried here, filed in a mailbox here: the
    *  sender is resolved here from the link it came through, never from the filer's own claim; a wake it carries is
    *  requested once, for a message new here. */
   #fileHere(request, link) {
@@ -1504,8 +1521,9 @@ export class TeamsMachine extends MachineCore {
       return refuse(`no interact grant for ${target}`);
     }
     accept();
-    // The user-turn door every supercode has (harness.v1 sessions.message, as_user): the session's runtime input,
-    // its pane's empty composer, or its mailbox until the composer is free. The sender is named after the member.
+    // The user-turn door every supercode has (sessions.message as_user, this daemon's own: mail/send.mjs): the session's
+    // runtime input, its pane's empty composer, or its mailbox until the composer is free. The sender is named after the
+    // member.
     const answer = (value) => { if (!stream.closed) { stream.write(JSON.stringify(value)); stream.close('delivered'); } };
     // A keyed line is typed once: the server retries a line whose open outlived its bound, and the attempt it gave up
     // on may still be accepted here. A repeat of a key answers what its first attempt answers.
@@ -1528,12 +1546,12 @@ export class TeamsMachine extends MachineCore {
       : request.text;
     const note = { harness, session, text, at: Date.now(), source: { via: 'room', from: { principalId: principal ?? null, name: entry.name ?? null } } };
     try { this.onTurn?.(note); } catch { /* naming is best-effort; the turn goes either way */ }
-    this.#serveRequest('harness.v1.sessions.message', {
-      locator: { harness, session_id: session, storage: { kind: 'file', path: '' } },
-      text,
-      from_name: entry.name ?? principal ?? 'a Room member',
-      as_user: true,
-    }, TURN_CONFIRM_MS).then((result) => {
+    const confirmed = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error(`no answer in ${TURN_CONFIRM_MS} ms`)), TURN_CONFIRM_MS);
+      this.mailSend.message({ locator: { harness, session_id: session }, text, from_name: entry.name ?? principal ?? 'a Room member', as_user: true })
+        .then(resolve, reject).finally(() => clearTimeout(timer));
+    });
+    confirmed.then((result) => {
       const delivered = result?.message_id && !result.refusal;
       this.log.append({ principal, cap: 'interact', target, outcome: delivered ? 'turn' : 'failed', detail: result?.refusal?.message?.slice(0, 200) });
       if (!delivered) try { this.onTurnWithdrawn?.(note); } catch { /* nothing to withdraw */ }
@@ -1709,8 +1727,7 @@ export class TeamsMachine extends MachineCore {
     return Number((await run('ps', ['-o', 'ppid=', '-p', String(holder)])).trim()) === pid;
   }
 
-  /** A filing's sender as this machine knows it, with no process and no request (the rule remote-deliver keeps,
-   * mailbox.rs sender_identity): this filing door is local, so a sender from this machine's address is a session here
+  /** A filing's sender as this machine knows it, with no process and no request (mailbox.rs `sender_identity`'s rule): this filing door is local, so a sender from this machine's address is a session here
    * (`local`, the same user, D186), and one claiming another machine's address is unresolved: another machine's mail
    * reaches this one only through its link, so a return address is never an identity. */
   #observeSender(from) {
@@ -2124,6 +2141,41 @@ export class TeamsMachine extends MachineCore {
 
   /** The program a pane runs, as the terminal package names kinds: what it was
    *  launched as, else what its foreground command is. */
+  /**
+   * A user's own turn typed into `pane` (its `session`) as its own submitted turn, only into an empty composer (read twice,
+   * so a person who just started typing is not typed over): `panes.turn`, and the daemon's own user turns (mail/send.mjs
+   * `userTurn`). Answers `#deliverPaneText`'s result; `{ refused }` for a pane running another harness than `harness`
+   * names; `{ waits }` for a draft or a screen with no composer (the caller keeps the turn and asks again).
+   */
+  async #paneTurn(session, pane, text, { messageIds, harness } = {}) {
+    if (this.suspended.has(pane)) throw Object.assign(new Error(`pane ${pane} is suspended: remote input is refused until resume`), { code: 423 });
+    const kind = this.#paneKind(pane, session);
+    // Mail is typed only into its own harness's pane. A process inherits SUPERCODE_TEAMS_PANE from whatever ran it,
+    // so a headless `codex exec` a Claude pane's tool started once took that pane for its own, and the Codex's mail
+    // was typed into Claude's composer (m-72bc65eb). The addressed harness names the program the text is for. Only a
+    // pane known to run another harness is refused: an unrecorded pane's kind is its command's name, which a native
+    // Claude install shows as its version.
+    const addressed = harness == null ? null : String(harness).trim().toLowerCase().replace(/^claude$/u, 'claude-code');
+    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') {
+      // 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 }))) {
+        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 }));
+      const first = await draftOf();
+      await new Promise(resolve => setTimeout(resolve, COMPOSER_RECHECK_MS));
+      const second = await draftOf();
+      if (first !== false || second !== false) return { waits: { delivered: false, reason: first === true || second === true ? 'draft' : 'no-composer' } };
+    }
+    return this.#deliverPaneText(session, pane, text, { deadlineMs: Date.now() + 10_000, messageIds });
+  }
+
   #paneKind(contextKey, session) {
     const launched = this.launches.all().find((row) => row.pane === contextKey && row.kind)?.kind;
     const named = String(launched ?? '').trim().toLowerCase();
@@ -3121,34 +3173,9 @@ export class TeamsMachine extends MachineCore {
         if (sessionTurn?.refused) { act('control', `pane:${params.pane}`, 'refused', JSON.stringify(sessionTurn.refused)); return sessionTurn.refused; }
         const session = await this.#paneByContext(params.pane);
         if (!session) throw Object.assign(new Error(`no pane with context ${params.pane}`), { code: 404 });
-        if (this.suspended.has(params.pane)) throw Object.assign(new Error(`pane ${params.pane} is suspended: remote input is refused until resume`), { code: 423 });
-        const kind = this.#paneKind(params.pane, session);
-        // Mail is typed only into its own harness's pane. A process inherits SUPERCODE_TEAMS_PANE from whatever ran it,
-        // so a headless `codex exec` a Claude pane's tool started once took that pane for its own, and the Codex's mail
-        // was typed into Claude's composer (m-72bc65eb). The addressed harness names the program the text is for. Only a
-        // pane known to run another harness is refused: an unrecorded pane's kind is its command's name, which a native
-        // Claude install shows as its version.
-        const addressed = params.harness == null ? null : String(params.harness).trim().toLowerCase().replace(/^claude$/u, 'claude-code');
-        if (addressed && addressed !== kind && ['claude-code', 'codex', 'grok', 'gemini', 'goose', 'opencode', 'pi', 'hermes', 'openclaw'].includes(kind)) {
-          const refused = { delivered: false, reason: `harness-mismatch: mail for ${addressed} is not typed into a ${kind || 'unknown'} pane` };
-          act('control', `pane:${params.pane}`, 'refused', JSON.stringify(refused));
-          return refused;
-        }
-        if (kind === 'claude-code') {
-          // 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 }))) {
-            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 }));
-          const first = await draftOf();
-          await new Promise(resolve => setTimeout(resolve, COMPOSER_RECHECK_MS));
-          const second = await draftOf();
-          if (first !== false || second !== false) return { delivered: false, reason: first === true || second === true ? 'draft' : 'no-composer' };
-        }
-        let result = await this.#deliverPaneText(session, params.pane, params.text, { deadlineMs: Date.now() + 10_000, messageIds: params.message_ids });
+        let result = await this.#paneTurn(session, params.pane, params.text, { messageIds: params.message_ids, harness: params.harness });
+        if (result.refused) { act('control', `pane:${params.pane}`, 'refused', JSON.stringify(result.refused)); return result.refused; }
+        if (result.waits) return result.waits;
         if ((result.delivered || result.queued) && !params.message_ids?.length && !turnBy) { const unrecorded = await this.#recordInput(entry, params.pane, session, params.text); if (unrecorded) result = { ...result, unrecorded }; }
         act('control', `pane:${params.pane}`, result.delivered ? 'input' : result.queued ? 'input-pending' : 'failed', JSON.stringify(result));
         return result;
@@ -3320,7 +3347,8 @@ export class TeamsMachine extends MachineCore {
       // 3a): this machine's own processes only, answered here.
       case 'harness.v1.mail.list': case 'harness.v1.mail.show': case 'harness.v1.mail.inbox': case 'harness.v1.mail.acknowledge': {
         if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('mail is read here by this machine\'s own processes'), { code: 403 });
-        if (method === 'harness.v1.mail.list') return { rows: await this.mail.list() };
+        // `local`: this machine's sessions only (`message mcp`'s list_agents, as the native one listed them)
+        if (method === 'harness.v1.mail.list') return { rows: params.local === true ? await this.mail.localRows() : await this.mail.list() };
         if (method === 'harness.v1.mail.show') {
           const ids = (Array.isArray(params.ids) ? params.ids : []).filter((id) => typeof id === 'string');
           return params.replies ? this.mail.showReplies(ids) : await this.mail.show(ids);
@@ -3352,7 +3380,9 @@ export class TeamsMachine extends MachineCore {
         // acknowledged once it has printed it (harness.v1.mail.acknowledge)
         const caller = await this.#callerOf(entry, params);
         if (typeof caller !== 'string' || /^sc:[^:]+:board:/.test(caller)) return { code: 2, text: "Can't tell which session is running this command, so replies would have nowhere to go. Nothing was sent. Run it from your agent session's own shell tool." };
-        const read = await this.mail.inbox(caller, { all: params.all === true, last, pid: Number(params.claim?.pid) || process.pid });
+        // `via`: the door the claims record (`inbox`, or `read_messages` for `message mcp`'s tool)
+        const via = params.via === 'read_messages' ? 'read_messages' : 'inbox';
+        const read = await this.mail.inbox(caller, { all: params.all === true, last, pid: Number(params.claim?.pid) || process.pid, via });
         let token = null;
         if (read.claimed.length) {
           token = randomBytes(12).toString('hex');
@@ -3362,7 +3392,8 @@ export class TeamsMachine extends MachineCore {
           for (const [old] of [...this.inboxClaims].slice(0, Math.max(0, this.inboxClaims.size - 255))) this.inboxClaims.delete(old);
           this.inboxClaims.set(token, { address: caller, claimed: read.claimed });
         }
-        return { code: 0, address: caller, rendered: read.rendered, rows: read.rows, token };
+        // `plain`: each message as its reader is shown it (the envelope rendered), with no listing's line about when
+        return { code: 0, address: caller, rendered: read.rendered, plain: read.stored.map((item) => render(item.envelope)), rows: read.rows, token };
       }
       // Who a local client is, from its claim (live-sessions.mjs callerOf): what a command acting on another machine sends
       // there as its caller, resolved here, where the map that holds it is. Local only; never the app door's.

package/mail/agents.mjs

@@ -72,26 +72,43 @@ export class Agents {
    * channel marker. Every writer (this daemon, and mail_agent.rs's in the native watch until step 4) renames a whole
    * record into the folder, which moves its time: one stat a call, never a read of every record, though a send's plan
    * asks on every send and an agent's threads grow with its history. A folder time within RACY_MS of now is not trusted
-   * (a write in the same tick of a coarse clock leaves it unmoved): read again, and not kept, until it is older.
+   * (a write in the same tick of a coarse clock leaves it unmoved): the folder is listed again, each record checked by
+   * its inode, until its time is older.
    */
   #records() {
     let changed;
     try { changed = statSync(this.threadsDir).mtimeMs; } catch { return { list: [], byHolder: new Map(), byMarker: new Map() }; }
-    if (this.threadsCache?.changed === changed && Date.now() - changed > RACY_MS) return this.threadsCache;
+    const cache = this.threadsCache;
+    if (cache?.changed === changed && Date.now() - changed > RACY_MS) return cache;
+    // The folder changed, or changed too recently for its time to be trusted: its names are listed and each record's
+    // file is stat'ed, and only a record whose inode moved (every writer renames a whole new file into place) is read
+    // again. A burst of writes costs a listing and a stat a record, not a read of every record.
     let names = [];
     try { names = readdirSync(this.threadsDir); } catch { return { list: [], byHolder: new Map(), byMarker: new Map() }; }
-    const list = names.filter((name) => name.endsWith('.json')).map((name) => readJson(join(this.threadsDir, name))).filter((thread) => thread?.id)
+    const files = new Map();
+    for (const name of names) {
+      if (!name.endsWith('.json')) continue;
+      // its inode, time and size together (an inode can be used again once freed): a rename moves at least one
+      let stamp;
+      try { const stat = statSync(join(this.threadsDir, name)); stamp = `${stat.ino}:${stat.mtimeMs}:${stat.size}`; } catch { continue; }
+      const known = cache?.files?.get(name);
+      const thread = known && known.stamp === stamp ? known.thread : readJson(join(this.threadsDir, name));
+      if (thread?.id) files.set(name, { stamp, thread });
+    }
+    const list = [...files.values()].map((file) => file.thread)
       .sort((a, b) => (a.created_at_ms - b.created_at_ms) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
     const byHolder = new Map(), byMarker = new Map();
     for (const thread of list) {
       byHolder.set(thread.holder, [...(byHolder.get(thread.holder) ?? []), thread]);
       for (const [marker, id] of Object.entries(thread.markers ?? {})) if (!byMarker.has(marker)) byMarker.set(marker, { thread, id });
     }
-    const records = { changed, list, byHolder, byMarker };
-    if (Date.now() - changed > RACY_MS) this.threadsCache = records;
+    const records = { changed, list, byHolder, byMarker, files };
+    // kept either way (its records are each current by inode); trusted without a listing only once its time is old
+    this.threadsCache = records;
     return records;
   }
 
+
   /** The thread `address` holds for an agent other than as its main session (mail_agent.rs `thread_held_by`). */
   heldBy(address) {
     const held = [...(this.#records().byHolder.get(address) ?? [])].reverse().find((thread) => {
@@ -325,8 +342,8 @@ export class Agents {
     return (await this.#resumeArguments(address)) != null;
   }
 
-  /** Resume the stopped session at `address` in a daemon pane, by `supercode open <session> --detach -- <its recorded
-   *  mode>`: never open's unattended defaults (mail_agent.rs `resume`). */
+  /** Resume the stopped session at `address` in a daemon pane, by `supercode open <session> --detach --window=false --
+   *  <its recorded mode>`: never open's unattended defaults (mail_agent.rs `resume`), and no window on the screen. */
   async resume(address) {
     const recorded = await this.#resumeArguments(address);
     if (!recorded) throw new Error(`${address} has no recorded permissions to resume with; its mail waits`);
@@ -339,7 +356,8 @@ export class Agents {
     }
     writeAtomically(join(this.agentsDir, 'resumed', blake3Hex(address).slice(0, 24)), String(Date.now()));
     const { code, stderr } = await new Promise((resolve) => {
-      const child = spawn(this.supercodeBin, ['open', parsed.session, '--detach', '--', ...recorded], { stdio: ['ignore', 'ignore', 'pipe'], env: this.env });
+      // a holder resumed by mail runs in the background: no window opens on the machine's screen for it
+      const child = spawn(this.supercodeBin, ['open', parsed.session, '--detach', '--window=false', '--', ...recorded], { stdio: ['ignore', 'ignore', 'pipe'], env: this.env });
       let err = '';
       child.stderr.on('data', (chunk) => { err += chunk; });
       child.on('error', (error) => resolve({ code: 1, stderr: error.message }));

package/mail/reads.mjs

@@ -116,8 +116,8 @@ function pendingFromTranscript(path) {
 export class MailReads {
   /** `records()` answers `{ records, unread, self }`: the records this daemon holds (machine-records.mjs `read`), why
    *  it holds none when it follows no machine, and this machine's name. */
-  constructor({ machine, live, store, records, descriptors, homes, paneQuestion = async () => null, askMachine }) {
-    Object.assign(this, { machine, live, store, records, descriptors, homes, paneQuestion, askMachine });
+  constructor({ machine, live, store, records, descriptors, homes, paneQuestion = async () => null, askMachine, log = () => {} }) {
+    Object.assign(this, { machine, live, store, records, descriptors, homes, paneQuestion, askMachine, log });
   }
 
   // ---- list ------------------------------------------------------------------------------------------------------
@@ -248,9 +248,12 @@ export class MailReads {
    * `{ rows, code }`.
    */
   async show(ids) {
+    const began = performance.now();
     const rows = await this.showRows(ids);
+    const here = performance.now();
     const wanted = rows.filter((row) => row.found === false && !row.ambiguous).map((row) => row.id);
     const unsearched = [];
+    const timing = {};
     if (wanted.length) {
       const held = heldRecords(this.records());
       const holds = (record, id) => Object.values(record?.mail ?? {}).some((box) => ['unread', 'recent'].some((part) => (Array.isArray(box?.[part]) ? box[part] : []).some((header) => typeof header?.id === 'string' && (header.id === id || header.id.startsWith(id)))));
@@ -267,6 +270,7 @@ export class MailReads {
         if (short.length) shorts.push([entry.machine, short]);
       }
       if (wanted.some((id) => id.length < FULL_ID_LEN || !placed.has(id))) for (const [machine, short] of shorts) unsearched.push([machine, `its mail window may be incomplete: ${short.join('; ')}`]);
+      timing.records = performance.now();
       const answers = await Promise.all([...asks].map(async ([machine, asked]) => {
         try { return [machine, await this.askMachine(machine, { op: 'show', ids: asked })]; } catch (error) { return [machine, error]; }
       }));
@@ -285,6 +289,9 @@ export class MailReads {
         unsearched.push(['*', `${older.join(', ')} ${older.length === 1 ? 'is' : 'are'} in no pushed mail window (each machine's record holds its unread mail and the last ${RECENT_PER_MAILBOX} messages of each mailbox): an older message is shown by \`supercode message show\` on the machine that holds it${followed.length ? ` (${followed.join(', ')})` : ''}`]);
       }
     }
+    // a slow show says where its time went (this machine's mailboxes, the held records, the machines it asked)
+    const total = performance.now() - began;
+    if (total > 1000) this.log(`show of ${ids.join(' ')} took ${Math.round(total)} ms: here ${Math.round(here - began)} ms${timing.records ? `, held records ${Math.round(timing.records - here)} ms, other machines ${Math.round(performance.now() - timing.records)} ms` : ''}`);
     const missing = rows.some((row) => row.found !== true);
     const notSearched = unsearched.map(([machine, why]) => (machine === '*' ? why : `${machine}: ${why}`));
     if (notSearched.length) for (const row of rows) if (row.found === false && !row.ambiguous) { row.found = null; row.unsearched = notSearched; }
@@ -314,8 +321,8 @@ export class MailReads {
    * mail with when each reached the model, from its transcript; the newest `last` of the read only (`inbox`). Answers
    * `{ stored, deliveries, claimed }`; the caller acknowledges each claimed one once it is printed (`acknowledge`).
    */
-  async inbox(address, { all = false, last = null, pid = process.pid } = {}) {
-    const claimed = this.store.claimUnread(address, 'inbox', address, pid).map((stored) => this.#whole(stored) ?? stored);
+  async inbox(address, { all = false, last = null, pid = process.pid, via = 'inbox' } = {}) {
+    const claimed = this.store.claimUnread(address, via, address, pid).map((stored) => this.#whole(stored) ?? stored);
     const transcript = all ? await readTranscript(address, this.homes) : null;
     let stored;
     if (all) {

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, utimesSync, watch, writeFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, rmSync, watch, writeFileSync } from 'node:fs';
 import { connect } from 'node:net';
 import { join } from 'node:path';
 import { blake3Hex } from './envelope.mjs';
@@ -18,8 +18,13 @@ 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;
+/** 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. */
 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;
 
 const alive = (pid) => { if (!Number.isInteger(pid) || pid <= 0) return false; try { process.kill(pid, 0); return true; } catch (error) { return error.code === 'EPERM'; } };
 const readJson = (path) => { try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; } };
@@ -56,9 +61,40 @@ 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 }) {
-    Object.assign(this, { mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed });
+  constructor({ mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed = () => null, log = () => {} }) {
+    Object.assign(this, { mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed, log });
     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
+  }
+
+  /** The relays beyond the RELAYS_RUNNING most recently used have their runtimes closed, none carrying a send: this
+   *  daemon starts every relay and holds every relay's send lock, so it alone closes one (a closer that did not hold the
+   *  lock closed relays mid-send, and every send after paid a relay's start). */
+  #cap() {
+    const kept = [...this.running].sort(([, a], [, b]) => b.usedAt - a.usedAt);
+    for (const [directory, relay] of kept.slice(RELAYS_RUNNING)) {
+      if (this.sending.has(directory)) continue;
+      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))
+        .catch((error) => this.log(`relay ${directory.split(/[\\/]/).pop()} beyond the ${RELAYS_RUNNING} most recent was not closed: ${error.message}`));
+    }
+  }
+
+  /** `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();
+    let release;
+    const mine = new Promise((resolve) => { release = resolve; });
+    const turn = previous.then(() => mine);
+    this.sending.set(directory, turn);
+    await previous;
+    try { return await work(); }
+    finally {
+      release();
+      if (this.sending.get(directory) === turn) this.sending.delete(directory);
+    }
   }
 
   /** The relay that speaks for `represented`, known as `representedName`: its name and its files. */
@@ -108,8 +144,9 @@ 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) {
+  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)');
     // written on every send: Claude Code reloads a changed settings file, so a running relay takes the hooks this
     // supercode installs
@@ -118,8 +155,11 @@ export class Relays {
     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())))) {
+        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'})`);
       // 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); }
       catch (error) { if (this.runtimeOf('claude-code', record.runtime_id)) throw new Error(`could not retire the old relay: ${error.message}`); }
@@ -129,7 +169,7 @@ export class Relays {
       harness: 'claude-code',
       launch: {
         program: 'claude',
-        arguments: ['--print', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--permission-prompt-tool', 'stdio', '--model', RELAY_MODEL, '--name', spec.name, '--permission-mode', 'bypassPermissions', '--setting-sources', 'project', '--settings', spec.settings, '--tools', 'ListAgents,SendMessage', '--no-session-persistence'],
+        arguments: ['--print', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--permission-prompt-tool', 'stdio', '--model', RELAY_MODEL, '--name', spec.name, '--permission-mode', 'bypassPermissions', '--setting-sources', 'project', '--settings', spec.settings, '--tools', 'ListAgents,SendMessage', '--no-session-persistence', '--strict-mcp-config'],
         // its API is the relay endpoint, its key the relay's folder there (which also keeps account connectors out)
         env: { ANTHROPIC_API_KEY: key, ANTHROPIC_BASE_URL: endpoint, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1', SUPERCODE_CLAUDE_RELAY: '1' },
       },
@@ -139,18 +179,27 @@ export class Relays {
     if (typeof runtimeId !== 'string') throw new Error(`the machine daemon did not start the relay: ${JSON.stringify(started)}`);
     const connection = typeof started.connection === 'string' ? started.connection : '';
     const pid = Number.isInteger(started?.handle?.endpoint?.pid) ? started.handle.endpoint.pid : null;
+    step('runtime started (runtimes.start)');
     writeFileSync(spec.record, JSON.stringify({ runtime_id: runtimeId, pid, endpoint, connection }));
+    // the daemon's from its start: counted by the cap even when the rest of this start fails
+    this.running.set(spec.directory, { connection, runtime_id: runtimeId, usedAt: Date.now() });
     // harness serve writes its receipt before it answers the start; the map learns it from its watch a moment later, so
     // one it does not hold yet is read by its own name (the receipt the runtime's terminal launch opens), never waited on
     const known = this.runtimeOf('claude-code', runtimeId);
-    if (known) return { runtime: known, connection };
+    if (known) { step('its receipt held'); return { runtime: known, connection }; }
     let receiptId = null;
     try {
       const launch = (await this.serve('harness.v1.runtimes.terminal_instructions', { connection }, 5000))?.launch;
       receiptId = (Array.isArray(launch?.arguments) ? launch.arguments : []).find((arg) => typeof arg === 'string' && arg.startsWith('supercode-live://'))?.slice('supercode-live://'.length) ?? null;
     } catch { /* said below */ }
     const runtime = receiptId ? this.runtimeNamed(receiptId) : null;
-    if (!runtime) throw new Error('the relay started but registered no live runtime');
+    step('its receipt read');
+    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 */ }
+      throw new Error('the relay started but registered no live runtime; it was closed');
+    }
     return { runtime, connection };
   }
 
@@ -180,28 +229,30 @@ export class Relays {
   async send(sender, senderName, receiver, message, messageId) {
     const spec = this.spec(sender, senderName);
     mkdirSync(spec.directory, { recursive: true });
-    const previous = this.sending.get(spec.directory) ?? Promise.resolve();
-    let release;
-    const mine = new Promise((resolve) => { release = resolve; });
-    const turn = previous.then(() => mine);
-    this.sending.set(spec.directory, turn);
-    await previous;
+    const asked = performance.now();
+    try { return await this.#locked(spec.directory, () => this.#send(spec, receiver, message, messageId, asked)); }
+    finally { this.#cap(); }
+  }
+
+  async #send(spec, receiver, message, messageId, asked) {
     try {
-      // its record is the relay's last use: the native sweep that keeps the most recently used relays running reads its
-      // time, and a relay carrying a send is the most recent
-      try { const now = new Date(); utimesSync(spec.record, now, now); } catch { /* none yet */ }
       const queued = { to: receiver.socket ? `uds:${receiver.socket}` : receiver.name, message };
-      let { runtime, connection } = await this.#ensure(spec);
+      const steps = [], began = asked;
+      let mark = began;
+      const step = (name) => { const now = performance.now(); steps.push(`${name} ${Math.round(now - mark)} ms`); mark = now; };
+      step('lock');
+      let { runtime, connection } = await this.#ensure(spec, step);
+      this.#used(spec, connection);
       rmSync(spec.receipt, { force: true });
       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); receipt = await this.#receipt(spec, this.#pid(spec, runtime)); }
+        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}` }; }
         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;
-        try { ({ runtime, connection } = await this.#ensure(spec)); } catch (error) { receipt = { delivered: false, detail: error.message }; break; }
+        try { ({ runtime, connection } = await this.#ensure(spec, step)); this.#used(spec, connection); } catch (error) { receipt = { delivered: false, detail: error.message }; break; }
         rmSync(spec.receipt, { force: true });
       }
       rmSync(spec.queue, { force: true });
@@ -210,15 +261,20 @@ export class Relays {
         sent[receiver.sessionId] = messageId;
         writeFileSync(spec.sent, JSON.stringify(sent));
       }
+      // a slow relay send says where its time went, in the daemon's log (what a person reads of the connector)
+      if (performance.now() - began > SLOW_SEND_MS) this.log(`relay send to ${receiver.name || receiver.sessionId} took ${Math.round(performance.now() - began)} ms: ${steps.join(', ')}`);
       return receipt;
     } catch (error) {
       rmSync(spec.queue, { force: true });
       return { delivered: false, detail: error.message };
-    } finally {
-      release();
-      if (this.sending.get(spec.directory) === turn) this.sending.delete(spec.directory);
     }
   }
+
+  /** A relay this daemon runs, used now. */
+  #used(spec, connection) {
+    const runtimeId = readJson(spec.record)?.runtime_id;
+    if (typeof runtimeId === 'string') this.running.set(spec.directory, { connection, runtime_id: runtimeId, usedAt: Date.now() });
+  }
 }
 
 /** Whether a local port answers a connection within 300 ms. */

package/mail/send.mjs

@@ -9,7 +9,7 @@ import { join } from 'node:path';
 import { blake3Hex, render, shortId } from './envelope.mjs';
 import { AGENT_HARNESS, RESUME_WAIT_MS } from './agents.mjs';
 import { MAX_RELAYED_BYTES, RELAY_NAME_PREFIX } from './relay.mjs';
-import { FULL_ID_LEN, cameThroughLink, envelope as makeEnvelope, makeAddress, messageIdFor, normalMachineName, parseAddress, senderIdentity, subjectLine, threadOf } from './compose.mjs';
+import { FULL_ID_LEN, cameThroughLink, envelope as makeEnvelope, makeAddress, messageIdFor, newMessageId, normalMachineName, parseAddress, senderIdentity, subjectLine, threadOf } from './compose.mjs';
 
 export const EXIT_REFUSED = 2;
 export const EXIT_UNKNOWN = 3;
@@ -32,6 +32,8 @@ const NAME_SEEN_EVERY_MS = 60 * 60 * 1000;
 
 const outcome = (code, text, receipt = null) => ({ code, text, receipt });
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** The daemon pane a live session runs in, or null (mail_route.rs `daemon_pane`). */
+const paneOf = (session) => { const pane = typeof session.pane === 'string' ? session.pane.split(':')[0] : null; return pane && /^p_[A-Za-z0-9_-]+$/.test(pane) ? pane : null; };
 const readJson = (path) => { try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; } };
 
 /** A delivery a door refused before anything was sent. */
@@ -42,10 +44,11 @@ export class MailSend {
    * `live` the live-session map; `store` the mail store; `agents` an agent's records and plan; `relays` the Claude relay
    * sender; `askMachine(machine, request)` one request to another machine's mail door; `deliverRuntime(receipt, text,
    * wake)` one hosted runtime's input ('steered', 'started' or 'not_woken'); `codexAnswer(request)` a native Codex
-   * question's answer through its app-server.
+   * question's answer through its app-server; `typeTurn(pane, harness, text, ids)` a user's own turn typed into a daemon
+   * pane's empty composer (machine.mjs `#paneTurn`: `{ delivered }`, `{ queued }`, or neither when it waits).
    */
-  constructor({ machine, mailRoot, live, store, agents, relays, askMachine, deliverRuntime, codexAnswer, log = () => {} }) {
-    Object.assign(this, { machine, mailRoot, live, store, agents, relays, askMachine, deliverRuntime, codexAnswer, log });
+  constructor({ machine, mailRoot, live, store, agents, relays, askMachine, deliverRuntime, codexAnswer, typeTurn, log = () => {} }) {
+    Object.assign(this, { machine, mailRoot, live, store, agents, relays, askMachine, deliverRuntime, codexAnswer, typeTurn, log });
   }
 
   // ---- one send ----------------------------------------------------------------------------------------------------
@@ -424,9 +427,10 @@ export class MailSend {
   // ---- harness serve's sessions.message ----------------------------------------------------------------------------
 
   /**
-   * `harness.v1.sessions.message` without `as_user` (harness_service.rs `message_live_session`): `text` from an operator
-   * mailbox (`from_name`, `supercode` by default) into the session or agent `locator` names. A refusal is a result, not
-   * an error: `{ delivered_to_bus: false, refusal: { reason, message } }`. harness serve adds its own inbound controls.
+   * `harness.v1.sessions.message` (harness_service.rs `message_live_session`): `text` from an operator mailbox
+   * (`from_name`, `supercode` by default) into the session or agent `locator` names; with `as_user`, as that session's
+   * own user turn. A refusal is a result, not an error: `{ delivered_to_bus: false, refusal: { reason, message } }`.
+   * harness serve adds its own inbound controls.
    */
   async message(params) {
     const refused = (reason, message) => ({ delivered_to_bus: false, refusal: { reason, message } });
@@ -448,6 +452,8 @@ export class MailSend {
       const short = target.name.split('@')[0];
       if (sessions.filter((row) => row.door === 'native' && row.name.split('@')[0] === short).length !== 1) return refused('identity_mismatch', `the registry name \`${short}\` no longer resolves to session \`${sessionId}\` alone; refusing rather than delivering into another session`);
     }
+    // the session's own user speaking (a Room member's line, a voice bridge, a board the owner types in)
+    if (params.as_user === true) return this.#userTurn(params, sender, fromName, receiver, text);
     const door = harness === AGENT_HARNESS ? null : this.#door(receiver, sessions);
     const subject = subjectLine(params.subject ?? null);
     let id = null;
@@ -488,6 +494,127 @@ export class MailSend {
     };
   }
 
+  // ---- the user's own turn ------------------------------------------------------------------------------------------
+
+  /**
+   * `sessions.message` with `as_user`: user mail, through the one door that carries
+   * the user's authority (a hosted runtime's input, or the session's pane when its composer is empty; otherwise it waits
+   * in the mailbox). A line to an agent is typed into the session its plan wakes (main for a root, a thread's holder for
+   * a reply in it), its other participants filed a record of it unread.
+   */
+  async #userTurn(params, sender, fromName, receiver, text) {
+    const refused = (reason, message) => ({ delivered_to_bus: false, refusal: { reason, message } });
+    const sent = makeEnvelope({ id: newMessageId(), from: sender, from_name: `${fromName}@${this.machine}`, sender_identity: senderIdentity(sender, null, this.machine), kind: 'user', reply_via: { mode: 'none' }, body: text });
+    const target = { harness: params.locator.harness, session_id: params.locator.session_id };
+    let to = receiver;
+    const agentAddress = parseAddress(receiver).harness === AGENT_HARNESS ? receiver : null;
+    if (agentAddress) {
+      // The owner writing to an agent types into its main session (docs/adr/0008-agent-mailbox.md, decisions 3 and 12): a
+      // typed line there is the owner's, and main answers or delegates it.
+      const agent = this.agents.load(parseAddress(receiver).session);
+      if (!agent) return refused('delivery_failed', `no agent named ${parseAddress(receiver).session} is declared on this machine`);
+      to = agent.main_session;
+      // A line to an agent is a root (or a reply in its thread): the agent's mailbox files its thread, with the owner a
+      // participant, before it is typed
+      const inReplyTo = typeof params.in_reply_to === 'string' ? params.in_reply_to : null;
+      sent.in_reply_to = inReplyTo;
+      sent.thread = inReplyTo ? (this.#filedThread(inReplyTo) ?? inReplyTo) : null;
+      let plan;
+      try { plan = await this.agents.plan(sent, agentAddress, {}); } catch (error) { return refused('delivery_failed', error.message); }
+      if (plan) {
+        const typedTo = plan.recipients.find((item) => item.wake && parseAddress(item.address)?.harness !== 'operator')?.address;
+        if (typedTo) to = typedTo;
+        // the agent's own mailbox keeps the record of what was addressed to it
+        if (plan.agent) { try { this.store.deliverRead(plan.agent, sent); } catch { /* the record is best kept */ } }
+        // a copy of the owner's line is a record of a line typed elsewhere (as decision 12's copies are), never a turn
+        // of the copy's session: pending user mail would be typed into it
+        const copy = { ...sent, kind: 'typed' };
+        for (const other of plan.recipients.filter((item) => item.address !== to && item.address !== sender)) {
+          try { this.#fileUnread(other.address, copy); } catch { /* a copy is best kept */ }
+        }
+        // every owner line to any agent is the owner's account manager's as CC (decision 17), unless it is that agent's own
+        const accountManager = this.agents.ownersAccountManager();
+        if (accountManager && accountManager.name !== parseAddress(agentAddress).session) {
+          const main = accountManager.main_session;
+          if (main !== to && !plan.recipients.some((item) => item.address === main)) { try { this.#fileUnread(main, copy); } catch { /* best kept */ } }
+        }
+      }
+      // A thread's holder the mailbox launched that has since closed (decision 9) is resumed the way it was launched, and
+      // takes the line once its door is back (decision 5); the line is never a new root.
+      if (!this.live.sessions().some((row) => row.address === to) && await this.agents.resumable(to)) {
+        try { await this.agents.resume(to); } catch (error) { return refused('no_user_door', `${to} was not resumed: ${error.message}`); }
+        for (const started = Date.now(); !this.live.sessions().some((row) => row.address === to) && Date.now() - started < RESUME_WAIT_MS;) await sleep(1000);
+      }
+    }
+    let turn;
+    try { turn = await this.#deliverUserTurn(sent, to); }
+    catch (error) {
+      // `no_user_door` says only that the session has no door for its user's turn (a caller may then reach it as a
+      // peer); a door that failed is `delivery_failed`, so the line is never sent twice
+      return refused(this.#hasUserDoor(to) ? 'delivery_failed' : 'no_user_door', error.message);
+    }
+    return { delivered_to_bus: turn !== 'waiting', message_id: sent.id, target, delivery: { door: turn === 'steered' || turn === 'started' ? 'runtime' : 'pane', how: turn } };
+  }
+
+  /** Whether `to` runs here with a door that carries its user's own turn: a hosted runtime's input or a daemon pane. */
+  #hasUserDoor(to) {
+    const session = this.live.sessions().find((row) => row.address === to);
+    return Boolean(session && (session.door === 'runtime' || paneOf(session)));
+  }
+
+  /**
+   * The user's own turn into `to`: a hosted runtime's input ('steered' or 'started'),
+   * or filed in its mailbox and typed into its pane once the composer is empty ('typed', or 'waiting' until then). A
+   * session with neither (running outside supercode) is refused, never reached as a peer instead.
+   */
+  async #deliverUserTurn(sent, to) {
+    const session = this.live.sessions().find((row) => row.address === to);
+    if (!session) throw new Error(`${to} is not running; nothing was sent`);
+    this.store.open(to);
+    if (session.door === 'runtime') {
+      const parsed = parseAddress(to);
+      const receipt = this.live.runtimeReceipt(parsed.harness, parsed.session);
+      if (!receipt) throw new Error('the live runtime\'s receipt is gone');
+      const how = await this.deliverRuntime(receipt, sent.body, true);
+      this.store.deliverRead(to, sent);
+      return how === 'steered' ? 'steered' : 'started';
+    }
+    const pane = paneOf(session);
+    if (!pane) {
+      const name = session.name.split('@')[0];
+      throw new Error(`${name} runs outside supercode, where nothing can speak as its user. Open it in a pane with \`supercode open ${name}\`; nothing was sent.`);
+    }
+    this.store.deliver(to, sent);
+    const typed = await this.typeUserTurns(to, pane);
+    return typed.includes(sent.id) ? 'typed' : 'waiting';
+  }
+
+  /**
+   * The user's waiting turns of `address` typed into `pane`, oldest first, each only when its composer is empty; stops
+   * at the first that has to wait. Each is claimed before it is typed: the native watch types waiting turns too (until
+   * step 4), and two typers filling one composer sent a turn's text twice in one prompt. Answers the ids typed
+   * (mail_route.rs `type_user_turns`).
+   */
+  async typeUserTurns(address, pane) {
+    const typed = [];
+    const harness = parseAddress(address).harness;
+    for (const waiting of this.store.userTurns(address)) {
+      const claimed = this.store.claimUserTurn(address, waiting);
+      if (!claimed) break;
+      let result;
+      try { result = await this.typeTurn(pane, harness, claimed.envelope.body, [claimed.envelope.id]); }
+      catch (error) {
+        try { this.store.release(address, claimed); } catch { /* recovered when this process ends */ }
+        this.log(`mail: the user's turn ${claimed.envelope.id} for ${address} waits: ${error.message}`);
+        break;
+      }
+      // held: the daemon's queue for the session types it when the composer frees, and is not asked again
+      if (result?.delivered || result?.queued) { try { this.store.acknowledge(address, claimed); } catch { /* typed */ } typed.push(claimed.envelope.id); }
+      else { try { this.store.release(address, claimed); } catch { /* recovered when this process ends */ } break; }
+    }
+    return typed;
+  }
+
   // ---- a filed message handed to its door --------------------------------------------------------------------------
 
   /**

package/mail/store.mjs

@@ -209,6 +209,44 @@ export class MailStore extends EventEmitter {
     return claimed;
   }
 
+  /** The user's own turns of `address` still waiting for their door, whole, oldest first (mailbox.rs `user_turns`). */
+  userTurns(address) {
+    const box = this.boxOf(address) ?? this.#named(address);
+    if (!box) return [];
+    let names = [];
+    try { names = readdirSync(join(box.dir, 'new')); } catch { return []; }
+    const turns = [];
+    for (const file of names) {
+      if (!file.endsWith('.json')) continue;
+      const path = join(box.dir, 'new', file);
+      const envelope = readEnvelope(path);
+      if (envelope?.kind !== 'user' || String(envelope.in_reply_to ?? '').startsWith('q-')) continue;
+      turns.push({ envelope, state: 'unread', path, part: 'new' });
+    }
+    return turns.sort(order);
+  }
+
+  /** One of the user's waiting turns taken for typing, so a second typer (the native watch beside this daemon) does not
+   *  type it too: moved into `claimed/` under this process's pid; null when another typer took it first (mailbox.rs
+   *  `claim_user_turn`). Hand it on and acknowledge it, or release it to wait again. */
+  claimUserTurn(address, waiting) {
+    const box = this.boxOf(address) ?? this.#named(address);
+    if (!box) return null;
+    this.#recoverAbandoned(box);
+    const target = join(box.dir, 'claimed', `${process.pid}.${waiting.path.split(/[\\/]/).pop()}`);
+    try { renameSync(waiting.path, target); }
+    catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+    return { ...waiting, path: target, part: 'claimed' };
+  }
+
+  /** A claimed envelope back to waiting, as it was before it was claimed (mailbox.rs `release`). */
+  release(address, claimed) {
+    const box = this.boxOf(address) ?? this.#named(address);
+    if (!box) return;
+    const name = claimed.path.split(/[\\/]/).pop();
+    renameSync(claimed.path, join(box.dir, 'new', name.includes('.') ? name.slice(name.indexOf('.') + 1) : name));
+  }
+
   /** A claimed envelope reached its reader: moved to `cur/` under its own name (mailbox.rs `acknowledge`). */
   acknowledge(address, claimed) {
     const box = this.boxes.get(this.byAddress.get(address));

package/mail/verbs.mjs

@@ -126,12 +126,13 @@ export class AgentVerbs {
       child.on('close', (code) => resolve({ code, out, err }));
     });
     if (run.code !== 0) throw new Error(`the session did not start: ${run.err.trim()}`);
-    let pane = null;
-    try { pane = JSON.parse(run.out).pane; } catch { /* not reported */ }
+    let pane = null, reused = false;
+    try { const printed = JSON.parse(run.out); pane = printed.pane; reused = printed.reused === true; } catch { /* not reported */ }
     if (known) return known;
     if (typeof pane !== 'string') throw new Error('the new pane was not reported');
-    // a launch that fails once its pane is open closes that pane: nothing it started is left running, holding what was
-    // copied to it, after its thread goes back
+    // a launch that fails once the pane it opened is there closes that pane: nothing it started is left running, holding
+    // what was copied to it, after its thread goes back. A pane its key named already (`reused`, a live pane an earlier
+    // launch opened) is not this launch's, and is never closed by it.
     try {
       const started = Date.now();
       while (Date.now() - started < 60_000) {
@@ -141,6 +142,7 @@ export class AgentVerbs {
       }
       throw new Error(`${program} started in pane ${pane}, but no session appeared there within a minute; its pane is closed`);
     } catch (error) {
+      if (reused) { error.message = error.message.replace('; its pane is closed', `; its pane ${pane} was opened before, and is left open`); throw error; }
       try { await this.closePane(pane); } catch (closing) { error.message += ` (its pane ${pane} could not be closed: ${closing.message})`; }
       throw error;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.88",
+  "version": "0.3.90",
   "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",
@@ -70,7 +70,7 @@
     "@volter/supercode-health": "^0.1.0",
     "@volter/supercode-terminal": "^0.2.54",
     "@volter/supercode-trace": "^0.1.0",
-    "@volter/teams": "0.2.32",
+    "@volter/teams": "0.2.33",
     "@xterm/addon-serialize": "^0.14.0",
     "@xterm/headless": "^6.0.0",
     "protobufjs": "8.8.0",