@volter/supercode-teams 0.3.104 → 0.3.106

package/machine.mjs

@@ -41,6 +41,7 @@ import { render } from './mail/envelope.mjs';
 import { Agents } from './mail/agents.mjs';
 import { Relays } from './mail/relay.mjs';
 import { serveRelayEndpoint } from './mail/relay-endpoint.mjs';
+import { MailCarrier } from './mail/carrier.mjs';
 import { MailSend } from './mail/send.mjs';
 import { AgentVerbs } from './mail/verbs.mjs';
 import { deliverToRuntime } from './mail/runtime.mjs';
@@ -729,19 +730,44 @@ export class TeamsMachine extends MachineCore {
       endpointOf: async () => (await this.relayEndpoint)?.url ?? null,
       arrived: (sessionId, landed) => claudeTranscriptHolds([...live.claudeDirs.keys()].map((dir) => join(dirname(dir), 'projects')), sessionId, landed),
       log: (line) => this.emit('mail-log', line) });
+    // a turn or a wake typed into a daemon pane's empty composer, in process (as `panes.turn` types one)
+    const 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;
+    };
     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),
       // 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;
-      },
+      typeTurn,
       log: (line) => this.emit('mail-log', line) });
+    // the mailbox's own delivery (step 4b): each wake attempted by its session's door, or carried to its machine
+    this.carrier = new MailCarrier({ machine, mailRoot, store: this.mailStore, live,
+      handOver: (address, id) => this.mailSend.handOver(address, id),
+      typeTurn, askMachine: (to, request) => this.#askMailDoor(to, request, MAIL_SEND_MS),
+      log: (line) => this.emit('mail-log', line) }).start();
+    // the user's own turns that wait in a pane session's mailbox (a draft in its composer when they came) are typed once
+    // its composer is free: tried at each change of its mailbox, and every 2 s while one waits (mail_watch.rs
+    // `deliver_waiting_user_turns` read every pane's mailbox every 2 s)
+    const turnsWaiting = new Map(); // address → timer
+    const typeWaiting = async (address) => {
+      clearTimeout(turnsWaiting.get(address)); turnsWaiting.delete(address);
+      const session = live.sessions().find((row) => row.address === address);
+      const pane = session ? this.mail.paneOf(session) : null;
+      if (!pane || !this.mailStore.userTurns(address).length) return;
+      try { await this.mailSend.typeUserTurns(address, pane); } catch (error) { this.emit('mail-log', `the user's turns for ${address} wait: ${error.message}`); }
+      if (this.mailStore.userTurns(address).length) { const timer = setTimeout(() => void typeWaiting(address), 2000); timer.unref?.(); turnsWaiting.set(address, timer); }
+    };
+    this.mailStore.on('changed', (address) => { if (address && !turnsWaiting.has(address)) void typeWaiting(address); });
+    // the turns already waiting when this listener came (the store read every mailbox at its start, before it), and every
+    // mailbox again once per 5 min, so a turn no event named is typed within that bound
+    const everyMailbox = () => { for (const address of this.mailStore.addresses()) if (!turnsWaiting.has(address)) void typeWaiting(address); };
+    everyMailbox();
+    this.turnsSweep = setInterval(everyMailbox, 300_000); this.turnsSweep.unref?.();
     // 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,
@@ -1053,6 +1079,8 @@ export class TeamsMachine extends MachineCore {
     this.stoppingMailWatch = true;
     this.mailWatch?.kill('SIGTERM');
     void this.relayEndpoint?.then((endpoint) => endpoint?.close()).catch(() => {});
+    this.carrier?.stop();
+    clearInterval(this.turnsSweep);
     this.stoppingServe = true;
     clearTimeout(this.serveRestart);
     // said, so a stop reads as one in the log and never as a serve that broke

package/mail/carrier.mjs

@@ -0,0 +1,311 @@
+// The mailbox's own delivery (D140; docs/architecture/overview.md, step 4b): every message filed with a wake (by a filer
+// that does not wait, a board's dispatcher, a send to a hooked session) is handed to its session by the session's own
+// door, by this daemon. Mail for another machine is carried there through its mail door and filed with the same wake,
+// so that machine's daemon delivers it. The native watch did this by reading every mailbox every two seconds
+// (mail_watch.rs `MailCarrier`); here a wake is followed from its own file event (one read of the mail folder at start),
+// and each is attempted when it is due. Its rules and its records are the native carrier's, file for file:
+// - a failed attempt waits FIRST_RETRY_MS doubling to LAST_RETRY_MS, kept in the wake itself (`wake/<id>`);
+// - a wake expires once it has failed WAKE_ATTEMPTS counted times and its first counted failure is older than its bound
+//   (LOCAL_WAKE_LIFETIME_MS here, REMOTE_WAKE_LIFETIME_MS for another machine): the message stays filed and unread, and
+//   the expiry is recorded in its mailbox (`expired/<id>.json`, read by `supercode message expired`);
+// - mail for a machine that is offline is not failing: the machine is probed once per LAST_RETRY_MS (its wait kept once
+//   per machine, `machines/<machine>.json`, read by `supercode message waiting`), all its mail is carried when it
+//   answers, and the mail expires only past OFFLINE_CEILING_MS;
+// - a hand-over is waited for at most HANDOVER_BOUND_MS, and one mailbox's attempt never waits on another's;
+// - each attempt is a line of `carrier.jsonl`.
+import { appendFileSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { render } from './envelope.mjs';
+
+const FIRST_RETRY_MS = 2_000;
+const LAST_RETRY_MS = 300_000;
+const WAKE_ATTEMPTS = 8;
+const LOCAL_WAKE_LIFETIME_MS = 30 * 60_000;
+const REMOTE_WAKE_LIFETIME_MS = 3 * 24 * 60 * 60_000;
+const OFFLINE_CEILING_MS = 30 * 24 * 60 * 60_000;
+// a hand-over is waited for this long (mail_watch.rs HANDOVER_BOUND); one still running past it is attempted again later,
+// and the hand-over itself answers 'later' until it settles (MailSend.handOver), so a frozen door holds only its own
+// mailbox's wakes, and only for this long
+const HANDOVER_BOUND_MS = 150_000;
+
+const readJson = (path) => { try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; } };
+const offline = (text) => String(text).includes('machine_offline');
+const safeMachine = (machine) => String(machine).replace(/[^A-Za-z0-9._-]/g, '_');
+
+export class MailCarrier {
+  /**
+   * `store` the mail store (its events name each wake); `live` the live-session map (a hooked session's pane);
+   * `handOver(address, id)` the daemon's hand-over of a filed message to its session's door (mail/send.mjs);
+   * `typeTurn(pane, harness, text, ids)` a wake typed into a hooked session's pane; `askMachine(machine, request)` one
+   * request to another machine's mail door.
+   */
+  constructor({ machine, mailRoot, store, live, handOver, typeTurn, askMachine, log = () => {} }) {
+    Object.assign(this, { machine, mailRoot, store, live, handOver, typeTurn, askMachine, log });
+    this.timers = new Map(); // `${folder}\0${id}` → timer of a wake here, due
+    this.running = new Set(); // mailbox folders with an attempt in flight
+    this.machines = new Map(); // machine → timer of its next carry
+    this.carrying = new Set(); // machines with a carry in flight
+    this.remote = new Map(); // machine → Map(`${folder}\0${id}` → { folder, address, id }): wakes for another machine
+  }
+
+  /** Follow every wake: those filed before this daemon (one read of the mail folder), each as the store names it (its
+   *  file's event, or a mailbox the store read whole), and every wake again once per LAST_RETRY_MS, so a wake no event
+   *  named is carried within that bound. */
+  start() {
+    this.store.on('wake', ({ folder, id }) => this.#wake(folder, id));
+    this.#sweep();
+    this.sweeper = setInterval(() => this.#sweep(), LAST_RETRY_MS);
+    this.sweeper.unref?.();
+    return this;
+  }
+
+  /** Every mailbox's wakes read from its folder and followed (one already due or scheduled is not scheduled twice). */
+  #sweep() {
+    let folders = [];
+    try { folders = readdirSync(this.mailRoot); } catch { return; }
+    for (const folder of folders) this.#rewake(folder);
+  }
+
+  stop() { clearInterval(this.sweeper); for (const timer of [...this.timers.values(), ...this.machines.values()]) clearTimeout(timer); this.timers.clear(); this.machines.clear(); }
+
+  #address(folder) { try { return readFileSync(join(this.mailRoot, folder, 'address'), 'utf8').trim(); } catch { return null; } }
+
+  /** A wake seen (its file written or changed): attempted when it is due. */
+  #wake(folder, id) {
+    if (!/^[A-Za-z0-9_-]+$/.test(id)) return;
+    const address = this.#address(folder);
+    if (!address) return;
+    const machine = address.split(':')[1];
+    if (machine !== this.machine) {
+      if (!this.remote.has(machine)) this.remote.set(machine, new Map());
+      this.remote.get(machine).set(`${folder}\0${id}`, { folder, address, id });
+      this.#scheduleMachine(machine);
+      return;
+    }
+    const key = `${folder}\0${id}`;
+    if (this.timers.has(key)) return;
+    const state = this.store.wakeState(address, id);
+    const timer = setTimeout(() => { this.timers.delete(key); void this.#local(folder, address); }, Math.max(0, (state.next_at_ms ?? 0) - Date.now()));
+    timer.unref?.();
+    this.timers.set(key, timer);
+  }
+
+  /** The wakes of one mailbox here that are due, attempted (mail_watch.rs `tick`, its local half). */
+  async #local(folder, address) {
+    if (this.running.has(folder)) { setTimeout(() => this.#rewake(folder), 1000).unref?.(); return; }
+    this.running.add(folder);
+    try {
+      const now = Date.now();
+      const due = this.#pending(folder, address).filter((id) => (this.store.wakeState(address, id).next_at_ms ?? 0) <= now);
+      if (!due.length) return;
+      // a session in a daemon pane whose mail is typed there: a hooked one (its hook shows it the rest), and one with no
+      // hook and no relay (Grok), whose mail that found its composer busy waits here until it is free
+      const session = this.live.sessions().find((row) => row.address === address);
+      if ((session?.door === 'hook' || session?.door === 'pane') && session.pane) {
+        for (const id of due) {
+          const stored = this.store.findIn(address, id);
+          const envelope = stored ? readJson(stored.path) : null;
+          let carried;
+          if (!envelope) carried = { kind: 'filed' };
+          else {
+            try {
+              const typed = await this.typeTurn(session.pane, address.split(':')[2], render(envelope), [id]);
+              // held: the daemon's queue for the session types it once the composer frees; nothing asks it again
+              carried = typed?.delivered ? { kind: 'delivered' } : typed?.queued ? { kind: 'filed' } : { kind: 'later', reason: 'its pane was not at its prompt' };
+            } catch (error) { carried = { kind: 'later', reason: error.message }; }
+          }
+          this.#record({ to: address, id, path: `${session.door}-pane`, carried });
+          this.#settle(folder, address, id, carried);
+        }
+        return;
+      }
+      for (const id of due) {
+        const found = this.store.findIn(address, id);
+        let carried;
+        // its recipient has it already (its own read, or a hand-over by an attempt that ended before it was settled):
+        // never delivered twice; a read by anyone else does not count
+        if (!found || (found.state === 'read' && this.store.claimOf(address, id)?.recipient === true)) carried = { kind: 'filed' };
+        else {
+          try {
+            let bound;
+            const answer = await Promise.race([
+              this.handOver(address, id),
+              new Promise((settle) => { bound = setTimeout(() => settle({ outcome: 'later', detail: `its hand-over was still running after ${HANDOVER_BOUND_MS / 1000} s` }), HANDOVER_BOUND_MS); bound.unref?.(); }),
+            ]).finally(() => clearTimeout(bound));
+            carried = answer?.outcome === 'delivered' ? { kind: 'delivered' } : answer?.outcome === 'filed' ? { kind: 'filed' } : { kind: 'later', reason: answer?.detail ?? 'not handed over' };
+          } catch (error) { carried = { kind: 'later', reason: `this machine's daemon did not hand it over: ${error.message}` }; }
+        }
+        this.#record({ to: address, id, path: 'door', carried });
+        this.#settle(folder, address, id, carried);
+      }
+    } finally {
+      this.running.delete(folder);
+      this.#rewake(folder);
+    }
+  }
+
+  /** A mailbox's wakes followed again (each one scheduled at its own due time). */
+  #rewake(folder) {
+    let ids = [];
+    try { ids = readdirSync(join(this.mailRoot, folder, 'wake')); } catch { return; }
+    for (const id of ids) this.#wake(folder, id);
+  }
+
+  /** A mailbox's wakes whose message is still filed; a wake whose message is gone is let go (mailbox.rs `pending_wakes`). */
+  #pending(folder, address) {
+    let ids = [];
+    try { ids = readdirSync(join(this.mailRoot, folder, 'wake')); } catch { return []; }
+    return ids.filter((id) => {
+      if (this.store.findIn(address, id)) return true;
+      try { rmSync(join(this.mailRoot, folder, 'wake', id), { force: true }); } catch { /* gone */ }
+      return false;
+    });
+  }
+
+  // ---- another machine's mail ------------------------------------------------------------------------------------
+
+  #machineWaitPath(machine) { return join(this.mailRoot, 'machines', `${safeMachine(machine)}.json`); }
+
+  /** A machine's mail carried at its next due time: its wait's next probe when it is offline, else its earliest wake. */
+  #scheduleMachine(machine) {
+    if (this.machines.has(machine) || this.carrying.has(machine)) return;
+    const wait = readJson(this.#machineWaitPath(machine));
+    let at = wait?.next_probe_ms ?? null;
+    if (at == null) {
+      at = Infinity;
+      for (const { address, id } of this.#remoteWakes(machine)) at = Math.min(at, this.store.wakeState(address, id).next_at_ms ?? 0);
+      if (!Number.isFinite(at)) return;
+    }
+    const timer = setTimeout(() => { this.machines.delete(machine); void this.#carry(machine); }, Math.max(0, at - Date.now()));
+    timer.unref?.();
+    this.machines.set(machine, timer);
+  }
+
+  /** Every wake filed here for `machine` (as their events named them), with when its message was filed, oldest first; a
+   *  wake whose file or message is gone is let go. */
+  #remoteWakes(machine) {
+    const items = [];
+    for (const [key, item] of this.remote.get(machine) ?? []) {
+      let present = true;
+      try { readFileSync(join(this.mailRoot, item.folder, 'wake', item.id)); } catch { present = false; }
+      const found = present ? this.store.findIn(item.address, item.id) : null;
+      if (!found) { this.remote.get(machine).delete(key); if (present) { try { rmSync(join(this.mailRoot, item.folder, 'wake', item.id), { force: true }); } catch { /* gone */ } } continue; }
+      const envelope = readJson(found.path);
+      items.push({ ...item, filed: Number(envelope?.created_at_ms) || 0 });
+    }
+    return items.sort((a, b) => a.filed - b.filed);
+  }
+
+  /** One machine's mail carried (mail_watch.rs `tick`, its remote half): its oldest due message probes the machine, and
+   *  when it answers, the rest follow in this pass. */
+  async #carry(machine) {
+    this.carrying.add(machine);
+    try {
+      const now = Date.now();
+      const items = this.#remoteWakes(machine);
+      if (!items.length) return;
+      const wait = readJson(this.#machineWaitPath(machine));
+      if (wait) {
+        // a machine away longer than the ceiling is not coming back for this mail: it expires, saying so
+        if (now - (wait.offline_since_ms ?? now) >= OFFLINE_CEILING_MS) {
+          const reason = `${machine} has been offline for ${OFFLINE_CEILING_MS / 86_400_000} days (since epoch ms ${wait.offline_since_ms}): ${wait.last_error ?? 'not linked'}`;
+          for (const item of items) this.#expire(item.folder, item.address, item.id, this.store.wakeState(item.address, item.id).attempts ?? 0, reason);
+          this.#setMachineWait(machine, null);
+          this.#line({ t: now, machine, outcome: 'expired', messages: items.length, reason });
+          return;
+        }
+        if ((wait.next_probe_ms ?? 0) > now) return;
+      }
+      let carriedHere = 0, offlineAnswer = null, called = false;
+      for (const item of items) {
+        if (!wait && (this.store.wakeState(item.address, item.id).next_at_ms ?? 0) > now) continue;
+        const found = this.store.findIn(item.address, item.id);
+        let carried;
+        // carried already (this carrier's own record): never carried twice
+        if (!found || (found.state === 'read' && this.store.claimOf(item.address, item.id)?.recipient === true)) carried = { kind: 'filed' };
+        else {
+          called = true;
+          carried = await this.#carryOne(machine, item.address, readJson(found.path));
+        }
+        if (carried.kind === 'offline') { offlineAnswer = carried.reason; break; }
+        carriedHere++;
+        this.#settle(item.folder, item.address, item.id, carried);
+      }
+      if (called) this.#line({ t: now, machine, outcome: offlineAnswer ? 'offline' : 'carried', waiting: items.length, carried: carriedHere, reason: offlineAnswer });
+      if (offlineAnswer) this.#setMachineWait(machine, { machine, offline_since_ms: wait?.offline_since_ms ?? now, next_probe_ms: now + LAST_RETRY_MS, probes: (wait?.probes ?? 0) + 1, last_error: offlineAnswer });
+      else if (called) this.#setMachineWait(machine, null);
+    } finally {
+      this.carrying.delete(machine);
+      this.#scheduleMachine(machine);
+    }
+  }
+
+  /** One message carried to its machine's mail door, filed there with a wake. */
+  async #carryOne(machine, to, envelope) {
+    if (!envelope) return { kind: 'filed' };
+    try {
+      const answer = await this.askMachine(machine, { op: 'file', to, envelope, wake: true });
+      if (answer?.code === 0) return { kind: 'delivered' };
+      const reason = `${machine} did not take it: ${answer?.text ?? answer?.detail ?? 'no reason given'}`;
+      return offline(JSON.stringify(answer)) ? { kind: 'offline', reason } : { kind: 'later', reason };
+    } catch (error) {
+      return offline(error.code ?? error.message) || offline(error.message)
+        ? { kind: 'offline', reason: `${machine} is offline: ${error.message}` }
+        : { kind: 'later', reason: `its mail door did not carry it to ${machine}: ${error.message}` };
+    }
+  }
+
+  #setMachineWait(machine, wait) {
+    const path = this.#machineWaitPath(machine);
+    if (!wait) { try { rmSync(path, { force: true }); } catch { /* gone */ } return; }
+    try { mkdirSync(join(this.mailRoot, 'machines'), { recursive: true }); writeFileSync(`${path}.tmp`, JSON.stringify(wait)); renameSync(`${path}.tmp`, path); }
+    catch (error) { this.log(`carrier: ${machine}'s wait was not kept: ${error.message}`); }
+  }
+
+  // ---- how an attempt went ---------------------------------------------------------------------------------------
+
+  /** Record how a wake went: done, waiting for its next attempt, or expired at its bound (mail_watch.rs `settle`). */
+  #settle(folder, address, id, carried) {
+    const wakePath = join(this.mailRoot, folder, 'wake', id);
+    if (carried.kind === 'delivered' || carried.kind === 'filed') {
+      if (carried.kind === 'delivered') {
+        // the carrier's own hand-off record: delivered here by its door, or carried to its machine
+        try { this.store.claimFor(address, id, { pid: process.pid, via: 'carrier', caller: null, recipient: true, at_ms: Date.now() }); } catch { /* best kept */ }
+        const found = this.store.findIn(address, id);
+        if (found && found.state !== 'read') { try { this.store.markRead(address, found.path); } catch { /* read already */ } }
+      }
+      try { rmSync(wakePath, { force: true }); } catch { /* gone */ }
+      return;
+    }
+    if (carried.kind === 'offline') return;
+    const now = Date.now();
+    const state = this.store.wakeState(address, id);
+    const attempts = (state.attempts ?? 0) + 1;
+    const since = state.failing_since_ms ?? now;
+    const lifetime = address.split(':')[1] === this.machine ? LOCAL_WAKE_LIFETIME_MS : REMOTE_WAKE_LIFETIME_MS;
+    if (attempts >= WAKE_ATTEMPTS && now - since >= lifetime) { this.#expire(folder, address, id, attempts, carried.reason); return; }
+    const wait = Math.min(LAST_RETRY_MS, FIRST_RETRY_MS * 2 ** Math.min(attempts - 1, 16));
+    this.store.setWakeState(address, id, { ...state, attempts, failing_since_ms: since, next_at_ms: now + wait, last_error: carried.reason });
+  }
+
+  /** End a wake undelivered: the message stays filed and unread, and the expiry is recorded in its mailbox. */
+  #expire(folder, address, id, attempts, reason) {
+    const found = this.store.findIn(address, id);
+    const envelope = found ? readJson(found.path) : null;
+    const expiry = { id, to: address, from: envelope?.from ?? '', subject: envelope?.subject ?? null, filed_at_ms: Number(envelope?.created_at_ms) || 0, expired_at_ms: Date.now(), attempts, reason };
+    try {
+      mkdirSync(join(this.mailRoot, folder, 'expired'), { recursive: true });
+      const temporary = join(this.mailRoot, folder, 'tmp', `expired.${id}`);
+      writeFileSync(temporary, JSON.stringify(expiry));
+      renameSync(temporary, join(this.mailRoot, folder, 'expired', `${id}.json`));
+      rmSync(join(this.mailRoot, folder, 'wake', id), { force: true });
+    } catch (error) { this.log(`carrier: the expiry of ${id} was not recorded: ${error.message}`); }
+  }
+
+  /** One local delivery attempt in the carrier's record (`carrier.jsonl`). */
+  #record({ to, id, path, carried }) {
+    this.#line({ t: Date.now(), to, id, path, outcome: carried.kind, reason: carried.reason ?? null });
+  }
+
+  #line(line) { try { appendFileSync(join(this.mailRoot, 'carrier.jsonl'), `${JSON.stringify(line)}\n`); } catch { /* the record is best kept */ } }
+}

package/mail/send.mjs

@@ -353,7 +353,9 @@ export class MailSend {
       if (typed?.delivered) { this.store.deliverRead(to, sent); delivered = 'typed'; }
       // held by the daemon's queue for the pane, typed once its composer frees: not typed yet, so kept unread
       else if (typed?.queued) { this.store.deliver(to, sent); delivered = 'pane_held'; }
-      else { this.store.deliver(to, sent); delivered = wake ? 'pane_waits' : 'queued'; }
+      // not typed (its composer held a draft or a turn ran): it waits unread with a wake, so the carrier types it once the
+      // composer is empty (mail/carrier.mjs), never left for a read a session with no hook never makes
+      else { this.store.deliver(to, sent); if (wake) this.store.requestWake(to, sent.id); delivered = wake ? 'pane_waits' : 'queued'; }
     } else if (door.kind === 'stored') { this.store.deliver(to, sent); delivered = 'stored'; }
     else { this.store.deliver(to, sent); delivered = 'operator'; }
     // a hand-over to the recipient's own door is its delivery, recorded as such

package/mail/store.mjs

@@ -68,6 +68,8 @@ export class MailStore extends EventEmitter {
     const [folder, part, file] = name.split(/[\\/]/);
     if (!folder) return;
     if (!part) return this.#readBox(folder);
+    // a wake written or changed: the carrier's (mail/carrier.mjs) to attempt
+    if (part === 'wake' && file) { this.emit('wake', { folder, id: file }); return; }
     if (!STATES[part] || !file) { if (part === 'address') this.#readBox(folder); return; }
     if (!this.boxes.has(folder)) return this.#readBox(folder);
     this.#readFile(folder, part, file);
@@ -103,6 +105,11 @@ export class MailStore extends EventEmitter {
       for (const file of files) this.#take(box, part, file);
     }
     this.emit('changed', address);
+    // every wake the mailbox holds, read with it: a mailbox read whole (at start, or on a rescan once a lost watch is back)
+    // names each one to the carrier, so a wake written while no event could say so is carried all the same
+    let wakes = [];
+    try { wakes = readdirSync(join(box.dir, 'wake')); } catch { /* none */ }
+    for (const id of wakes) this.emit('wake', { folder, id });
   }
 
   /** One envelope file read again on its event: held while it is there, let go once it is gone. */

package/native-codex-pane.mjs

@@ -2,9 +2,9 @@
 // Supercode hosts neither the agent nor its run loop; it can attach to native
 // question requests while the stock TUI remains the session's UI.
 import { spawn } from 'node:child_process';
-import { readFileSync, writeFileSync, renameSync, mkdtempSync, existsSync, rmSync, appendFileSync } from 'node:fs';
+import { readFileSync, writeFileSync, renameSync, mkdtempSync, existsSync, rmSync, appendFileSync, mkdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 
 const path = process.argv[2];
 const seed = JSON.parse(readFileSync(path, 'utf8'));
@@ -45,9 +45,11 @@ if(writableRoots.length)config.push('-c',`sandbox_workspace_write.writable_roots
 // The app-server's stderr is never the pane's: the pane is the TUI's screen, and a record the server writes there lands
 // on the TUI's composer row, which the mail wake then reads as a person's draft and never types over (yuerans,
 // 2026-10-06: `ERROR codex_models_manager::manager: failed to refresh available models` held every wake of the box
-// maintainer off for three hours). It is kept beside the pane's binding instead, at most LOG_BYTES of it.
+// maintainer off for three hours). It is kept in a folder beside the bindings' (never among them: the carrier reads
+// every file there on each poll, mail_question.rs `poll`), at most LOG_BYTES of it.
 const LOG_BYTES = 8 * 1024 * 1024;
-const serverLog = `${path.replace(/\.json$/, '')}.app-server.log`;
+const serverLog = join(dirname(path), '..', 'native-launch-logs', `${basename(path).replace(/\.json$/, '')}.app-server.log`);
+try { mkdirSync(dirname(serverLog), { recursive: true, mode: 0o700 }); } catch { /* its log is best kept */ }
 let logged = 0;
 const server = spawn(seed.program, [...config, 'app-server', '--listen', endpoint], { stdio: ['ignore', 'ignore', 'pipe'] });
 server.stderr.on('data', (chunk) => {

package/package.json

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