@volter/supercode-teams 0.3.85 → 0.3.87

package/machine.mjs

@@ -36,6 +36,13 @@ 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 { Agents } from './mail/agents.mjs';
+import { Relays } from './mail/relay.mjs';
+import { MailSend } from './mail/send.mjs';
+import { AgentVerbs } from './mail/verbs.mjs';
+import { deliverToRuntime } from './mail/runtime.mjs';
+import { envelope as envelopeOf, linkOf, parseAddress, senderIdentity } from './mail/compose.mjs';
+import { codexQuestions } from './native-questions.mjs';
 import { Duplex, PassThrough } from 'node:stream';
 
 /** Two ends of a connection made inside this process: what one writes, the other reads. Ending or destroying either
@@ -139,6 +146,22 @@ function trustClaudeFolder(cwd) {
 
 /** How long a launch watches its new pane before answering, so a program that ends at once is reported. */
 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;
+/**
+ * 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
+ * delegation or a declaration that starts a session waits for it to appear (up to a minute). Past its bound a call is
+ * answered 504, which its client reads as unanswered: the work may still finish.
+ */
+const DOOR_BOUNDS_MS = {
+  'harness.v1.mail.send': 170_000,
+  'harness.v1.mail.message': 170_000,
+  'harness.v1.mail.handover': 140_000,
+  'harness.v1.mail.delegate': 110_000,
+  'harness.v1.agent.declare': 110_000,
+};
 /** How many typed lines' keys a machine remembers; a server retries a line for minutes, not thousands of lines. */
 const TURN_KEYS_KEPT = 1000;
 /** How long a typed line's door gets to confirm it: a loaded machine's reader types it in seconds and answers late. */
@@ -257,7 +280,11 @@ export class TeamsMachine extends MachineCore {
   async sessionBindings(machineId,incarnationId) {
     const panes=await this.host.listSessions();
     const live=panes.filter(pane=>!pane.dead&&pane.rootPid);
-    const reading=live.length?await this.#serveRequest('harness.v1.sessions.activity_under',{pids:live.map(pane=>pane.rootPid)}):{activities:[]};
+    // a harness serve that is not there (between restarts, or still starting) leaves the bindings as last read: a
+    // heartbeat never fails, nor marks every session unknown, for want of one reading
+    let reading;
+    try{reading=live.length?await this.#serveRequest('harness.v1.sessions.activity_under',{pids:live.map(pane=>pane.rootPid)}):{activities:[]};}
+    catch{return [...this.#sessionBindings.values()];}
     const byPid=new Map((reading.activities??[]).map(item=>[item.pid,item.activity]));
     const current=new Set(panes.filter(pane=>!pane.dead).map(pane=>pane.contextKey));
     let launchAgents=null;
@@ -593,7 +620,7 @@ export class TeamsMachine extends MachineCore {
   // ---- this machine's mail (mail/; docs/architecture/overview.md, "The mail operations") ---------------------------
   #startMail() {
     const mailRoot = join(supercodeHome(this.env), 'mail');
-    this.mailStore = new MailStore({ mailRoot, log: (line) => this.emit('records-log', line) }).start();
+    this.mailStore = new MailStore({ mailRoot, machine: machineName(this.env), log: (line) => this.emit('records-log', line) }).start();
     // the session index's rows by address (its descriptors, as the records' index subscription hands them over)
     this.sessionDescriptors = new Map();
     const live = this.live;
@@ -609,20 +636,57 @@ export class TeamsMachine extends MachineCore {
       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),
     });
+    // 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);
+    this.agents = new Agents({ mailRoot, machine, supercodeBin: this.supercodeBin, env: this.env,
+      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) });
+    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) });
+    // 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 });
+    // the names sessions ran under (`<mail>/names.json`): a name an agent was given reaches the same session after it
+    // runs under another, kept from the map's changes (at most once a second)
+    let naming = null;
+    live.on('changed', () => {
+      if (naming) return;
+      naming = setTimeout(() => { naming = null; try { this.mailSend.rememberNames(live.sessions()); } catch { /* kept at the next change */ } }, 1000);
+      naming.unref?.();
+    });
   }
 
-  /** One named read of another machine's mail door, over Teams, given up after ONE_MACHINE_READ_MS with a reason (the
-   *  `show` of a message that machine's record names). */
-  async #askMailDoor(machine, request) {
-    const ONE_MACHINE_READ_MS = 10_000;
+  /** One send of this machine's own, made in its daemon's process (the connector's machine events): from the sender
+   *  the request names, which is this machine's own operator address. */
+  async sendOwn(request) {
+    if (!this.mailSend) throw new Error('this machine\'s daemon has not started its mail yet');
+    return this.mailSend.send({ address: request.from, name: request.from_name ?? '' }, request.to, request.body, { id: request.id ?? null, queue: request.queue === true, notice: request.notice === true });
+  }
+
+  /** The name a caller is known by in its envelopes: its session's, else an operator's or a board's `name@machine`. */
+  #callerName(address) {
+    const row = this.live.sessions().find((session) => session.address === address);
+    if (row) return row.name;
+    const parsed = parseAddress(address);
+    return parsed ? `${parsed.session}@${parsed.machine}` : String(address);
+  }
+
+  /** One request to another machine's mail door, over Teams, given up after `boundMs` with a reason: a named read (the
+   *  `show` of a message that machine's record names, 10 s) or a send (MAIL_SEND_MS). */
+  async #askMailDoor(machine, request, boundMs = 10_000) {
     const channel = await openMachine({ machine, env: this.env });
     try {
-      const stream = await channel.open('mail', { request }, { timeoutMs: ONE_MACHINE_READ_MS });
+      const stream = await channel.open('mail', { request }, { timeoutMs: Math.min(boundMs, 15_000) });
+      // once the door took the request, an answer that never comes is unanswered: what it did there is unknown
       const text = await new Promise((resolve, reject) => {
         let answer = '';
-        const timer = setTimeout(() => { try { stream.close('timed out'); } catch { /* closed */ } reject(new Error(`${machine} did not answer within ${ONE_MACHINE_READ_MS / 1000} s`)); }, ONE_MACHINE_READ_MS);
+        const timer = setTimeout(() => { try { stream.close('timed out'); } catch { /* closed */ } reject(Object.assign(new Error(`${machine} did not answer within ${boundMs / 1000} s`), { unanswered: true })); }, boundMs);
         stream.on('data', (chunk) => { answer += chunk; });
-        stream.on('close', (reason) => { clearTimeout(timer); answer.trim() ? resolve(answer) : reject(new Error(String(reason ?? 'its mail door closed without answering'))); });
+        stream.on('close', (reason) => { clearTimeout(timer); answer.trim() ? resolve(answer) : reject(Object.assign(new Error(String(reason ?? 'its mail door closed without answering')), { unanswered: true })); });
       });
       const answer = JSON.parse(text.trim().split('\n').pop());
       if (answer?.outcome === 'failed') throw new Error(answer.detail ?? 'its mail door failed');
@@ -873,6 +937,8 @@ export class TeamsMachine extends MachineCore {
     this.jobs?.stopAll();
     this.stoppingMailWatch = true;
     this.mailWatch?.kill('SIGTERM');
+    this.stoppingServe = true;
+    clearTimeout(this.serveRestart);
     this.serve?.kill('SIGTERM');
     this.host.dispose();
   }
@@ -881,21 +947,69 @@ export class TeamsMachine extends MachineCore {
     for (const [key, owners] of this.routes) { owners.delete(index); if (owners.size === 0) this.routes.delete(key); }
   }
 
+  /**
+   * The daemon's `harness serve`. Its pipes are a peer that can go away: a write into them after it has ended (EPIPE) is
+   * that pipe's error, handled here, never the daemon's end. When it ends, every request waiting on it is answered at
+   * once (failed, saying so), every harness stream relayed into it is closed, and it is started again (a growing wait
+   * between restarts, from 1 s up to 1 min, reset once one has run a minute); the subscriptions made on it are made
+   * again on its `serve-exit`. Only the daemon's own stop ends it for good.
+   */
   #startServe() {
     const child = spawn(this.supercodeBin, ['harness', 'serve'], { stdio: ['pipe', 'pipe', 'pipe'], env: this.env });
+    const started = Date.now();
     child.stdout.setEncoding('utf8');
     // A restarted serve starts on a line of its own, never on the tail its predecessor left unfinished.
     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)
     child.stdout.on('data', (chunk) => {
+      if (this.serve !== child) return;
       for (const line of serveLines(chunk)) if (line) this.#routeServeLine(line);
     });
     child.stderr.setEncoding('utf8');
     child.stderr.on('data', (text) => this.emit('serve-stderr', text));
+    let ended = false;
+    const end = (why) => {
+      if (ended) return;
+      ended = true;
+      if (this.serve === child) this.serve = null;
+      // what waited on it is answered now, never left to its own bound
+      for (const [id, pending] of this.internalRequests ?? []) { this.internalRequests.delete(id); pending.reject(new Error(`harness serve ${why}`)); }
+      for (const [, entry] of this.connections) entry.harness?.close(`harness serve ${why}`);
+      if (this.stoppingServe) return;
+      const ranLong = Date.now() - started > 60_000;
+      this.serveBackoff = ranLong ? 1000 : Math.min(60_000, Math.max(1000, (this.serveBackoff ?? 500) * 2));
+      this.emit('serve-stderr', `harness serve ${why}; started again in ${Math.round(this.serveBackoff / 1000)} s\n`);
+      this.serveRestart = setTimeout(() => { if (!this.stoppingServe) this.#startServe(); }, this.serveBackoff);
+      this.serveRestart.unref?.();
+    };
+    // 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`);
+      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);
+      grace.unref?.();
+      child.once('exit', () => clearTimeout(grace));
+      end(`stopped taking input (${error.code ?? error.message})`);
+    });
+    child.stdout.on('error', () => {});
+    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 });
-      for (const [, entry] of this.connections) entry.harness?.close('harness serve exited');
+      end(`exited (${signal ?? `code ${code}`})`);
     });
     this.serve = child;
+    child.once('spawn', () => { if (this.serve === child) this.emit('serve-started'); });
+  }
+
+  /** One line into the daemon's `harness serve`, when it is there to take it: false when it is not (ended, or between
+   *  restarts). A write's own failure is its pipe's error (handled in #startServe), never a throw here. */
+  #toServe(line) {
+    const stdin = this.serve?.stdin;
+    if (!stdin || !stdin.writable || stdin.destroyed) return false;
+    try { stdin.write(line); return true; } catch { return false; }
   }
 
   // Idle notices for every session on this machine (`supercode message watch`):
@@ -921,10 +1035,12 @@ export class TeamsMachine extends MachineCore {
     this.internalRequests ??= new Map();
     const id = (this.internalNext = (this.internalNext ?? 0) + 1);
     return new Promise((resolve, reject) => {
-      if (!this.serve?.stdin?.writable) return reject(new Error('harness serve is not running'));
       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'));
+      }
       setTimeout(() => { if (this.internalRequests.delete(id)) reject(new Error(`${method} timed out`)); }, timeoutMs).unref();
-      this.serve.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: joinId(INTERNAL_CONNECTION, id), method, params })}\n`);
     });
   }
 
@@ -1016,8 +1132,12 @@ export class TeamsMachine extends MachineCore {
         if (!line) continue;
         let message;
         try { message = JSON.parse(line); } catch { continue; }
-        if (message.id !== undefined && message.id !== null) message.id = joinId(index, message.id);
-        this.serve?.stdin.write(JSON.stringify(message) + '\n');
+        const asked = message.id !== undefined && message.id !== null ? message.id : null;
+        if (asked !== null) message.id = joinId(index, message.id);
+        // a serve that is not there to take it answers the request at once, on this stream only
+        if (!this.#toServe(JSON.stringify(message) + '\n') && asked !== null && !stream.closed) {
+          try { stream.write(`${JSON.stringify({ jsonrpc: '2.0', id: asked, error: { code: -32000, message: 'harness serve is not running; it is being started again' } })}\n`); } catch { /* the stream went */ }
+        }
       }
     });
     stream.on('close', () => { entry.harness = null; });
@@ -1128,16 +1248,12 @@ export class TeamsMachine extends MachineCore {
     }
   }
 
-  /** One mail request from this machine: its own mail door, which delivers here or sends on through the one way out to
-   *  another machine (`ask_machine`, with its guards), never a second exit of its own. */
+  /** One mail request from this machine (its launch notices): its own send, which delivers here or sends on through
+   *  the one way out to another machine, in this process. */
   #sendMail(request, target) {
-    const child = spawn(this.supercodeBin, ['message', 'remote-deliver'], { stdio: ['pipe', 'pipe', 'pipe'], env: this.env });
-    let out = '';
-    child.stdout.on('data', (chunk) => { out += chunk; });
-    child.stderr.on('data', () => {});
-    child.on('error', (error) => this.log.append({ principal: null, cap: 'mail', target, outcome: 'failed', detail: error.message }));
-    child.on('close', (code) => this.log.append({ principal: null, cap: 'mail', target, outcome: code === 0 ? 'send' : 'failed', detail: out.trim().slice(0, 200) || undefined }));
-    child.stdin.end(JSON.stringify(request));
+    void this.mailSend.send({ address: request.from, name: request.from_name }, request.to, request.body, { queue: request.queue === true, notice: request.notice === true })
+      .then((answer) => this.log.append({ principal: null, cap: 'mail', target, outcome: answer.code === 0 ? 'send' : 'failed', detail: answer.text.slice(0, 200) || undefined }),
+        (error) => this.log.append({ principal: null, cap: 'mail', target, outcome: 'failed', detail: String(error.message).slice(0, 200) }));
   }
 
   // ---- mail ----------------------------------------------------------------
@@ -1174,8 +1290,8 @@ export class TeamsMachine extends MachineCore {
   }
 
   #serveMail(entry, stream, accept, refuse,requestOverride=null) {
-    // One message into a session on this machine, delivered by `supercode message
-    // remote-deliver` through the same doors a local send uses. The receiver is the
+    // One message into a session on this machine, delivered by this daemon's own send (mail/send.mjs) through the same
+    // doors a local send uses. The receiver is the
     // target: `mail:*` reaches every session here, `mail:<address>` one of them; a
     // receiver named rather than addressed needs `mail:*`.
     const { admitted, principal } = entry;
@@ -1217,7 +1333,7 @@ export class TeamsMachine extends MachineCore {
         try {
           const answer = request.op === 'list'
             ? { code: 0, sessions: await this.mail.localRows() }
-            : { code: 0, rows: this.mail.showRows((Array.isArray(request.ids) ? request.ids : []).filter((id) => typeof id === 'string')) };
+            : { code: 0, rows: await this.mail.showRows((Array.isArray(request.ids) ? request.ids : []).filter((id) => typeof id === 'string')) };
           this.log.append({ principal, cap: 'mail', target, outcome: request.op });
           if (!stream.closed) { stream.write(JSON.stringify(answer)); stream.close('answered'); }
         } catch (error) {
@@ -1227,27 +1343,51 @@ export class TeamsMachine extends MachineCore {
       })();
       return;
     }
-    const child = spawn(this.supercodeBin, ['message', 'remote-deliver'], { stdio: ['pipe', 'pipe', 'pipe'], env: this.env });
-    let out = '';
-    let err = '';
-    child.stdout.on('data', (chunk) => { out += chunk; });
-    child.stderr.on('data', (chunk) => { err += chunk; });
-    child.on('error', (error) => { err += error.message; });
-    child.on('close', (code) => {
-      this.log.append({ principal, cap: 'mail', target, outcome: code === 0 ? request.op : 'failed', detail: err.trim().slice(0, 200) || undefined });
+    // Who sent it is the stream's principal, as Teams authenticated it, and the name Teams has for it (never a name the
+    // caller's app asserts): an envelope made here says so, never the return address the request claims. A local caller
+    // is no link.
+    const link = linkOf(principal, entry.principalName ?? null);
+    void (async () => {
+      let answer;
+      try { answer = request.op === 'file' ? this.#fileHere(request, link) : await this.#sendHere(request, link); }
+      catch (error) { answer = { outcome: 'failed', detail: error.message }; }
+      this.log.append({ principal, cap: 'mail', target, outcome: answer.outcome === 'failed' || (answer.code ?? 0) !== 0 ? 'failed' : request.op, detail: answer.outcome === 'failed' ? String(answer.detail).slice(0, 200) : undefined });
       if (stream.closed) return;
-      stream.write(out.trim() || JSON.stringify({ outcome: 'failed', detail: err.trim() || `remote-deliver exited ${code}` }));
+      stream.write(JSON.stringify(answer));
       stream.close('delivered');
-    });
-    // A list the asker stopped waiting for (its stream closed: it gave up at its bound) ends here too, so its reader does
-    // not outlive the ask. A write (a send, a turn, a filing, an inbox read that claims what it shows) is never cancelled
-    // half done: it finishes and is logged.
-    // Who asked travels with the request, so the receiving session's envelope can say so.
-    // Who sent it is the stream's principal, as Teams authenticated it, and the name Teams has for it (never a name the
-    // caller's app asserts): remote-deliver takes the sender's identity from these, never from the return address the
-    // request claims. A local caller is no link.
-    const linked = principal && principal !== 'local';
-    child.stdin.end(JSON.stringify({ ...request, via_principal: linked ? principal : null, via_name: linked ? (entry.principalName ?? null) : null }));
+    })();
+  }
+
+  /** A send through the mail door, for a session here (message.rs `remote_deliver` send): 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) {
+    const from = parseAddress(request.from)?.address;
+    if (!from) return { code: 2, text: `\`${request.from}\` is not a session address; addresses look like sc:<machine>:<harness>:<session-id>`, receipt: null };
+    const text = (key) => (typeof request[key] === 'string' ? request[key] : null);
+    return this.mailSend.send({ address: from, name: text('from_name') ?? '' }, text('to') ?? '', text('body') ?? '', {
+      subject: text('subject'), in_reply_to: text('in_reply_to'), notify_when_idle: request.notify_when_idle === true, queue: request.queue === true,
+      id: text('id'), notice: request.notice === true, thread: text('thread'),
+    }, { link });
+  }
+
+  /** A message another machine's mailbox carried here, filed in a mailbox here (message.rs `remote_deliver` file): 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) {
+    const to = parseAddress(request.to);
+    const envelope = request.envelope;
+    const valid = envelope && typeof envelope === 'object' && typeof envelope.id === 'string' && /^[A-Za-z0-9_-]+$/.test(envelope.id) && parseAddress(envelope.from)
+      && typeof envelope.from_name === 'string' && typeof envelope.body === 'string' && Number.isSafeInteger(envelope.created_at_ms) && typeof envelope.kind === 'string' && envelope.reply_via && typeof envelope.reply_via.mode === 'string';
+    if (!to || !valid) return { code: 2, text: 'Not filed: the mail door files one envelope for one address here.', receipt: null };
+    if (to.machine !== machineName(this.env)) return { code: 3, text: `${to.address} is not on this machine.`, receipt: null };
+    const { sender_identity: _claimed, ...rest } = envelope;
+    const filed = envelopeOf({ ...rest, sender_identity: senderIdentity(envelope.from, link, machineName(this.env)) });
+    const fresh = this.mailStore.findIn(to.address, filed.id) == null;
+    this.mailStore.deliver(to.address, filed);
+    // carried here by another machine's mailbox: its wake comes with it, once, and this machine's watch delivers it
+    if (fresh && request.wake === true) this.mailStore.requestWake(to.address, filed.id);
+    return { code: 0, text: `filed for ${to.address}`, receipt: null };
   }
 
   /**
@@ -1577,17 +1717,12 @@ export class TeamsMachine extends MachineCore {
     return { observation: `mailbox:${from}`, principal: null, classification: 'unresolved', label: 'unresolved', why: `it claims ${machine ?? 'another machine'}'s address but did not come through that machine's link` };
   }
 
-  /** The mailbox's own filing door (`supercode message file`), started and awaited, never waited on synchronously. */
-  #runFiling(request) {
-    return new Promise((resolve) => {
-      let out = '';
-      const child = spawn(this.supercodeBin, ['message', 'file'], { stdio: ['pipe', 'pipe', 'ignore'], env: this.env, windowsHide: true });
-      const timer = setTimeout(() => { child.kill('SIGKILL'); resolve({ code: 1, text: 'the mailbox\'s filing door did not answer within 30 s' }); }, 30_000);
-      child.stdout.setEncoding('utf8').on('data', (chunk) => { out += chunk; });
-      child.on('error', (error) => { clearTimeout(timer); resolve({ code: 1, text: error.message }); });
-      child.on('close', () => { clearTimeout(timer); try { resolve(JSON.parse(out.trim().split('\n').pop())); } catch { resolve({ code: 1, text: out.trim().slice(-300) || 'the mailbox\'s filing door answered nothing' }); } });
-      child.stdin.on('error', () => {});
-      child.stdin.end(JSON.stringify(request));
+  /** A filing in this machine's mail (mail/send.mjs `file`), in this process. */
+  async #runFiling(request) {
+    if (!this.mailSend) return { code: 1, text: 'this machine\'s daemon has not started its mail yet' };
+    return this.mailSend.file({ address: request.from, name: request.from_name ?? '' }, request.to, request.body ?? '', {
+      subject: request.subject ?? null, key: request.id ?? null, wake: request.wake !== false,
+      sender_identity: request.sender_identity && typeof request.sender_identity === 'object' ? request.sender_identity : null, typed: request.typed === true,
     });
   }
 
@@ -2352,8 +2487,10 @@ export class TeamsMachine extends MachineCore {
         const reply = (envelope) => { if (stream.closed) return; try { stream.write(JSON.stringify(envelope) + '\n'); } catch { /* peer gone */ } };
         try {
           // Every door answers or fails within a bound; a hung substrate call becomes an error, never silence.
-          // The caller may shorten the bound, never lengthen it past the daemon's own 30 s.
-          const bound = Math.min(Number(request.params?.timeoutMs) || 30_000, 30_000);
+          // The caller may shorten the bound, never lengthen it past the daemon's own: 30 s, or the longer one a door
+          // that waits on a session states (DOOR_BOUNDS_MS), each above its own inner waits.
+          const own = DOOR_BOUNDS_MS[request.method] ?? 30_000;
+          const bound = Math.min(Number(request.params?.timeoutMs) || own, own);
           const result = await withTimeout(this.#dispatch(entry, request.method, request.params ?? {}), bound, request.method);
           reply({ id: request.id, result });
           this.emit('door', { method: request.method, ms: Date.now() - startedAt, outcome: 'ok' });
@@ -3095,12 +3232,80 @@ export class TeamsMachine extends MachineCore {
         act('title', params.target, 'ok', renamed);
         return { ok: true, target: params.target, title: params.title ?? null, window: renamed };
       }
+      // A send to a session (docs/architecture/overview.md, "The mail operations", 3b-1): `supercode message send` and
+      // `reply`, a session's `send_message` and the native callers' client (D207, pending) on this machine's own socket,
+      // each with its claim; the caller is who the claim resolves to, never who the request says it is.
+      case 'harness.v1.mail.send': {
+        if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('a send is made here by this machine\'s own processes; another machine\'s goes through its mail door'), { code: 403 });
+        const caller = await this.#callerOf(entry, params);
+        if (typeof caller !== 'string' || !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.", receipt: null };
+        const text = (key) => (typeof params[key] === 'string' ? params[key] : null);
+        const body = text('body') ?? '';
+        if (!body.trim()) return { code: 1, text: 'Nothing was sent: the message is empty.', receipt: null };
+        const from = { address: caller, name: this.#callerName(caller) };
+        let to = text('to'), options = { subject: text('subject'), in_reply_to: text('in_reply_to'), notify_when_idle: params.notify_when_idle === true, queue: params.queue === true, id: text('id'), message_id: text('message_id') };
+        if (text('reply')) {
+          // a reply: to the message's sender, in its thread, its subject kept (message.rs `Reply`)
+          const found = this.mailStore.findPrefixIn(caller, text('reply'));
+          if (found.length !== 1) return { code: 2, text: `Not sent: ${text('reply')} names ${found.length} messages in your mailbox. Name the one you answer as its envelope shows it.`, receipt: null };
+          const answered = found[0].envelope;
+          if (answered.kind === 'notice') return { code: 2, text: `Not sent: ${text('reply')} is an automated notice; nothing reads a reply to it.`, receipt: null };
+          to = answered.from;
+          options = { ...options, subject: typeof answered.subject === 'string' ? (answered.subject.startsWith('Re: ') ? answered.subject : `Re: ${answered.subject}`) : null, in_reply_to: answered.id, id: null, thread: answered.thread ?? answered.id };
+        }
+        if (!to) return { code: 2, text: 'Not sent: a send names its receiver.', receipt: null };
+        // a bare name no session here answers to may be a session on the team's other machines (their held records)
+        const team = text('reply') ? { to: null } : this.mail.teamAddress(to, (name) => this.mailSend.remembered(name));
+        if (team.error) return { code: 5, text: `Not sent: ${team.error}. Name it as \`name@machine\` or its address.`, receipt: null };
+        const answer = { ...(await this.mailSend.send(from, team.to ?? to, body, options)), ...(team.notes?.length ? { notes: team.notes } : {}) };
+        act('mail.send', to, answer.code === 0 ? 'ok' : 'failed');
+        return answer;
+      }
+      // An agent's verbs (docs/architecture/overview.md, 3b-2): `message thread`, `threads`, `delegate`, and `supercode
+      // agent declare|show`, this machine's own processes only; a delegation and a thread list without --agent are the
+      // caller's, as its claim names it.
+      case 'harness.v1.mail.thread': case 'harness.v1.mail.threads': case 'harness.v1.mail.delegate': case 'harness.v1.agent.declare': case 'harness.v1.agent.show': {
+        if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('an agent\'s verbs are answered here for this machine\'s own processes'), { code: 403 });
+        const text = (key) => (typeof params[key] === 'string' && params[key] ? params[key] : null);
+        if (method === 'harness.v1.mail.thread') {
+          if (!text('id')) throw Object.assign(new Error('thread names a message id'), { code: 400 });
+          return this.agentVerbs.thread(text('id'));
+        }
+        if (method === 'harness.v1.agent.show') return this.agentVerbs.show(text('name'));
+        if (method === 'harness.v1.agent.declare') {
+          if (!text('name')) throw Object.assign(new Error('declare names its agent'), { code: 400 });
+          const answer = await this.agentVerbs.declare({ name: text('name'), main: text('main'), open: text('open'), input: text('input'), folder: text('folder'), harness: text('harness'),
+            idle_minutes: Number.isInteger(params.idle_minutes) && params.idle_minutes >= 0 ? params.idle_minutes : null, owners_account_manager: params.owners_account_manager === true });
+          act('agent.declare', text('name'), answer.code === 0 ? 'ok' : 'failed');
+          return answer;
+        }
+        let caller = null;
+        try { caller = await this.#callerOf(entry, params); } catch (error) { if (method === 'harness.v1.mail.delegate') throw error; }
+        if (method === 'harness.v1.mail.threads') return this.agentVerbs.threads(text('agent'), typeof caller === 'string' ? caller : null);
+        if (typeof caller !== 'string' || !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." };
+        if (!text('root')) throw Object.assign(new Error('delegate names its root'), { code: 400 });
+        const answer = await this.agentVerbs.delegate(caller, text('root'), { folder: text('folder'), harness: text('harness') });
+        act('mail.delegate', caller, answer.code === 0 ? 'ok' : 'failed');
+        return answer;
+      }
+      // A filed message handed to its session's door (the native watch's carrier and a relay's `message push`, until
+      // step 4): once, by its id, recorded on its wake.
+      case 'harness.v1.mail.handover': {
+        if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('mail is handed over here by this machine\'s own processes'), { code: 403 });
+        if (typeof params.address !== 'string' || typeof params.id !== 'string' || !parseAddress(params.address)) throw Object.assign(new Error('a hand-over names an address and a message id'), { code: 400 });
+        return this.mailSend.handOver(params.address, params.id, { markRead: params.mark_read === true, wake: params.wake === true });
+      }
+      // harness serve's `sessions.message` (its mail to a session or an agent, not its `as_user` turn), asked here by
+      // harness serve itself: one implementation of a send, whatever the entry.
+      case 'harness.v1.mail.message': {
+        if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('sessions.message is answered here for this machine\'s own harness serve'), { code: 403 });
+        return this.mailSend.message(params);
+      }
       case 'harness.v1.mail.file': {
         // One message filed in a receiver's mailbox here (a board owner's notices and mail, D138 step 6): the sender's
-        // identity is observed by this daemon, in this process, and handed to the mailbox's filing door with the message,
-        // so no filing starts a process of its own to observe it. An observation that cannot be made is said in the
-        // record (unresolved, with why), never waited on past its bound. Operators only: the filing door takes the
-        // sender a local operator names, as `supercode message file` itself does.
+        // identity is observed by this daemon, in this process, and filed with the message here (mail/send.mjs `file`):
+        // no filing starts a process. An observation that cannot be made is said in the record (unresolved, with why),
+        // never waited on past its bound. Operators only: the filing takes the sender a local operator names.
         if (!operator) throw Object.assign(new Error('operators only'), { code: 403 });
         for (const key of ['from', 'to', 'body']) if (typeof params[key] !== 'string' || !params[key]) throw Object.assign(new Error(`a filing names its ${key}`), { code: 400 });
         const sender_identity = await this.#observeSender(params.from, params.from_name ?? null, typeof params.context === 'string' && params.context ? params.context : null);
@@ -3135,7 +3340,7 @@ export class TeamsMachine extends MachineCore {
             address = found.address;
           }
           const machine = address.split(':')[1];
-          if (machine === machineName(this.env)) return { code: 0, address, rows: this.mail.inboxRows(address, last) };
+          if (machine === machineName(this.env)) return { code: 0, address, rows: await this.mail.inboxRows(address, last) };
           try {
             const answer = await this.#askMailDoor(machine, { op: 'inbox', session: address, recent: last });
             return answer?.code === 0 ? { code: 0, address, rows: Array.isArray(answer.rows) ? answer.rows : [] } : { code: 3, text: answer?.text ?? 'its machine refused' };
@@ -3145,7 +3350,7 @@ 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 = this.mail.inbox(caller, { all: params.all === true, last, pid: Number(params.claim?.pid) || process.pid });
+        const read = await this.mail.inbox(caller, { all: params.all === true, last, pid: Number(params.claim?.pid) || process.pid });
         let token = null;
         if (read.claimed.length) {
           token = randomBytes(12).toString('hex');