@volter/supercode-teams 0.3.97 → 0.3.98

package/live-sessions.mjs

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

package/machine.mjs

@@ -106,6 +106,8 @@ const INITIAL_INPUT_READY_DEADLINE_MS = 90_000;
 const INITIAL_INPUT_POLL_MS = 250;
 /** The pause between the two composer readings a user's turn waits on. */
 const COMPOSER_RECHECK_MS = 400;
+/** The harnesses whose composer a capture is read for a draft (sdk/terminal `composerHoldsDraft`). */
+const DRAFT_KINDS = new Set(['claude-code', 'codex', 'gemini', 'grok']);
 // Claude Code waits out a usage limit and queues every message typed meanwhile until the limit's reset ("new messages
 // wait for your usage limit to reset"; esc or /rate-limit-options ends the wait). A limit raised early, or a weekly
 // one past 24 hours, never ends that wait, so a session sat with every turn it was sent queued behind it. Read from the
@@ -547,6 +549,7 @@ export class TeamsMachine extends MachineCore {
   // ---- lifecycle ------------------------------------------------------------
 
   async beforeListen() {
+    this.bornAt ??= Date.now();
     mkdirSync(this.portsDir, { recursive: true }); // the port table's announce directory exists before any pane launches
     this.#startServe();
     if (this.#pendingNotices().length) this.#watchEnds();
@@ -623,7 +626,6 @@ export class TeamsMachine extends MachineCore {
           if (change.kind === 'removed' && change.key?.harness === 'codex') this.live.codexIndex({ removed: change.key.session_id });
           else if (change.descriptor) this.live.codexIndex({ descriptor: change.descriptor });
         }
-        this.emit('codex-index', { changes: params.changes ?? [] });
       }
     });
     // The Codex sessions' own index (Codex rollouts only): the live map knows them from its first answer, never waiting on
@@ -636,9 +638,6 @@ export class TeamsMachine extends MachineCore {
         this.live.codexRowsReplaced();
         for (const descriptor of answer?.initial ?? []) if (descriptor?.locator) this.live.codexIndex({ descriptor });
         this.live.codexIndexed();
-        // the records take their Codex rows from this index too (their own whole index leaves Codex out: one watch and
-        // one read of the rollouts)
-        this.emit('codex-index', { initial: answer?.initial ?? [] });
       }, (error) => {
         codexIndexBackoff = Math.min(300_000, Math.max(2000, (codexIndexBackoff || 1000) * 2));
         this.emit('records-log', `live sessions: the Codex sessions' index could not be subscribed (${error.message}); tried again in ${Math.round(codexIndexBackoff / 1000)} s`);
@@ -713,7 +712,8 @@ export class TeamsMachine extends MachineCore {
       // known view stands until they are known again
       if (!live.codexKnown) return;
       const now = new Map(live.sessions().map((row) => [row.address, row.name]));
-      for (const [address, name] of wasLive) if (!now.has(address)) void this.relays.retire(address, name).catch(() => {});
+      // a Codex session that leaves the map has not provably ended (idle over a day, it is no longer followed): kept
+      for (const [address, name] of wasLive) if (!now.has(address) && address.split(':')[2] !== 'codex') void this.relays.retire(address, name).catch(() => {});
       wasLive = now;
     });
     void live.whenCodexKnown(120_000).then((known) => {
@@ -775,6 +775,8 @@ export class TeamsMachine extends MachineCore {
         const titles = readJson(this.p.titles, { v: 1, titles: {} }).titles;
         const panes = rows.filter((row) => row.session?.id).map(({ session: s }) => ({ pane: s.contextKey, dead: Boolean(s.dead), pid: s.rootPid ?? null, label: s.label ?? null, title: titles[`pane:${s.contextKey}`] ?? s.label ?? null, cwd: s.cwd ?? null }));
         const live = panes.filter((pane) => !pane.dead && pane.pid);
+        // the pane each Grok session runs in (Grok's registry names its process; its pane is the one rooted at it)
+        this.live?.grokPanes(live.map((pane) => ({ pane: pane.pane, pid: pane.pid })));
         // the harness session under each live pane, as the board reads it: unread is said, never no session
         let activities = [], sessions_unread = null;
         if (live.length) {
@@ -818,22 +820,9 @@ export class TeamsMachine extends MachineCore {
     // is back, and holds its own retry (2 s doubling to 5 min) until it is (MR4); nothing reads its fields as current.
     const backoff = (previous) => Math.min(300_000, Math.max(2000, (previous || 1000) * 2));
     const both = () => { producer.touch('sessions'); producer.touch('panes'); };
-    // every harness but Codex, whose rows come from the live map's Codex-only index ('codex-index' below)
-    const HARNESSES = ['claude-code', 'pi', 'opencode', 'goose', 'gemini', 'grok', 'openclaw', 'hermes', 'supercode'];
-    const isCodex = (key) => key.startsWith('codex:') || key.includes(':codex:');
-    const applyRow = (change) => {
-      if (change.kind === 'removed' && change.key) { this.sessionDescriptors?.delete(`sc:${machineName(this.env)}:${change.key.harness}:${change.key.session_id}`); locators.delete(`${change.key.harness}:${change.key.session_id}`); }
-      else if (change.descriptor?.locator) { const { harness, session_id } = change.descriptor.locator; this.sessionDescriptors?.set(`sc:${machineName(this.env)}:${harness}:${session_id}`, change.descriptor); locators.set(`${harness}:${session_id}`, change.descriptor.locator); }
-    };
-    this.on('codex-index', ({ initial = null, changes = [] }) => {
-      if (initial) {
-        for (const key of [...locators.keys()]) if (isCodex(key)) locators.delete(key);
-        for (const key of [...(this.sessionDescriptors?.keys() ?? [])]) if (isCodex(key)) this.sessionDescriptors.delete(key);
-        for (const descriptor of initial) applyRow({ descriptor });
-      }
-      for (const change of changes) applyRow(change);
-      both();
-    });
+    // every harness, Codex among them: the live map reads Codex alone for its speed, and the records keep the whole
+    // index (a session's parent may be of another harness, which only the whole index links)
+    const HARNESSES = ['claude-code', 'codex', 'pi', 'opencode', 'goose', 'gemini', 'grok', 'openclaw', 'hermes', 'supercode'];
     const locators = new Map(); // `${harness}:${session_id}` → the index's locator for it
     const noteIndexParts = (failed, error) => {
       // the index's own unread parts (a store, a folder, a registry it could not read): their sessions are unknown
@@ -856,10 +845,8 @@ export class TeamsMachine extends MachineCore {
     let indexBackoff = 0;
     const subscribe = () => this.#serveRequest('harness.v1.sessions.index.subscribe', { harnesses: HARNESSES, limit: 0 }, 60_000)
       .then((answer) => {
-        this.recordsIndex = answer?.subscription ?? null; indexBackoff = 0;
-        // its own rows replaced; the Codex rows (the live map's index's) kept
-        for (const key of [...locators.keys()]) if (!isCodex(key)) locators.delete(key);
-        for (const key of [...(this.sessionDescriptors?.keys() ?? [])]) if (!isCodex(key)) this.sessionDescriptors.delete(key);
+        this.recordsIndex = answer?.subscription ?? null; indexBackoff = 0; locators.clear();
+        this.sessionDescriptors?.clear();
         for (const descriptor of answer?.initial ?? []) if (descriptor?.locator) { locators.set(`${descriptor.locator.harness}:${descriptor.locator.session_id}`, descriptor.locator); this.sessionDescriptors?.set(`sc:${machineName(this.env)}:${descriptor.locator.harness}:${descriptor.locator.session_id}`, descriptor); }
         producer.note('sessions_index', null); noteIndexParts(answer?.failed, null); both();
       }, (error) => {
@@ -1047,8 +1034,11 @@ export class TeamsMachine extends MachineCore {
     const serveLines = lineSplitter();
     // a serve already replaced never answers into the streams that its successor serves (its late answers would reach a
     // reopened stream that uses the same ids)
+    let answered = false;
     child.stdout.on('data', (chunk) => {
       if (this.serve !== child) return;
+      // when serve first answers, and so how much of a start's wait is serve's own start (said once per serve)
+      if (!answered) { answered = true; this.emit('records-log', `harness serve: its first line ${((Date.now() - started) / 1000).toFixed(1)} s after its spawn (${((Date.now() - (this.bornAt ?? started)) / 1000).toFixed(1)} s after the daemon's start)`); }
       for (const line of serveLines(chunk)) if (line) this.#routeServeLine(line);
     });
     child.stderr.setEncoding('utf8');
@@ -1140,7 +1130,13 @@ export class TeamsMachine extends MachineCore {
       const entry = this.connections.get(conn);
       if (conn === INTERNAL_CONNECTION) {
         const pending = this.internalRequests?.get(original);
-        if (!pending) return;
+        if (!pending) {
+          // an answer that came after its request gave up: an index it opened is registered in serve with nobody reading
+          // it (one more at each retry), so it is let go at once
+          const late = message.result?.subscription;
+          if (typeof late === 'string' && late.startsWith('index-sub-')) this.#toServe(`${JSON.stringify({ jsonrpc: '2.0', id: joinId(INTERNAL_CONNECTION, `late-${late}`), method: 'harness.v1.sessions.index.unsubscribe', params: { subscription: late } })}\n`);
+          return;
+        }
         this.internalRequests.delete(original);
         // the daemon's own subscriptions (its machine record's session index) are routed back to it, as an operator's are
         if (message.result && typeof message.result === 'object') {
@@ -2228,15 +2224,19 @@ export class TeamsMachine extends MachineCore {
     if (addressed && addressed !== kind && ['claude-code', 'codex', 'grok', 'gemini', 'goose', 'opencode', 'pi', 'hermes', 'openclaw'].includes(kind)) {
       return { refused: { delivered: false, reason: `harness-mismatch: mail for ${addressed} is not typed into a ${kind || 'unknown'} pane` } };
     }
-    if (kind === 'claude-code') {
+    // the composer read for a draft: the pane's own program, or (a pane whose program shows another name, as Grok's
+    // versioned binary does) the harness the text is for; a program whose composer this cannot read is not read
+    const draftKind = DRAFT_KINDS.has(kind) ? kind : (addressed && DRAFT_KINDS.has(addressed) ? addressed : null);
+    if (draftKind) {
       // A usage-limit wait would queue this turn until the limit's reset: esc ends the wait first. A limit that
       // still holds refuses the turn at once and the session waits again, for the next turn to try.
       const queued = [...this.terminalMailboxes.values()].some(queue => queue.session?.id === session.id && (queue.state.active || queue.state.pending.length));
-      if (!this.inputInFlight.has(session.id) && !queued && claudeUsageLimitWait(await this.host.capture(session.id, { lines: 60 }))) {
+      if (draftKind === 'claude-code' && !this.inputInFlight.has(session.id) && !queued && claudeUsageLimitWait(await this.host.capture(session.id, { lines: 60 }))) {
         await this.host.sendInput(session.id, '\u001b', { submitMode: 'single', deadlineMs: Date.now() + 5_000 });
         await new Promise(resolve => setTimeout(resolve, COMPOSER_RECHECK_MS));
       }
-      const draftOf = async () => composerHoldsDraft(kind, await this.host.capture(session.id, { lines: 200, preserveEscapes: true }));
+      // a person's draft is never typed over, nor a screen with no composer (a menu, a dialog) typed into
+      const draftOf = async () => composerHoldsDraft(draftKind, await this.host.capture(session.id, { lines: 200, preserveEscapes: true }));
       const first = await draftOf();
       await new Promise(resolve => setTimeout(resolve, COMPOSER_RECHECK_MS));
       const second = await draftOf();

package/mail/relay.mjs

@@ -28,6 +28,8 @@ export const RELAYS_RUNNING = 4;
 /** How long a relay speaking for a sender on another machine is kept after its last send (it carries that sender's
  *  mail while it is in use; retired after every send, each message from it started a relay). */
 const REMOTE_RELAY_KEPT_MS = 60 * 60_000;
+/** How long a Codex sender's relay is kept unused at a start (a Codex session idle over a day leaves the map). */
+const CODEX_RELAY_KEPT_MS = 7 * 24 * 60 * 60_000;
 /** How long a relay whose runtime start lost its answer is looked at for a runtime that start left running. */
 const LOST_START_KEPT_MS = 5 * 60_000;
 
@@ -172,7 +174,12 @@ export class Relays {
       if (machine !== this.machine) {
         let last = 0; try { last = statSync(join(directory, 'receipt.json')).mtimeMs; } catch { /* never sent */ }
         if (Date.now() - last < REMOTE_RELAY_KEPT_MS) { this.#keepRemote(directory, last); continue; }
-      } else if (harness !== 'claude-code' || running(represented)) continue;
+      } else if (running(represented)) continue;
+      else if (harness === 'codex') {
+        // a Codex session the map does not hold may be idle, not ended: its relay is kept until unused for a week
+        let last = 0; for (const file of ['receipt.json', 'relay.json']) { try { last = Math.max(last, statSync(join(directory, file)).mtimeMs); } catch { /* none */ } }
+        if (Date.now() - last < CODEX_RELAY_KEPT_MS) continue;
+      } else if (harness !== 'claude-code') continue;
       // only a Claude session is provably ended when the map does not hold it (its registry lists every live Claude
       // process); a sender of another harness the map may not see (Grok, Gemini, a Codex session idle a day) is kept
       if (await this.#retireFolder(directory, represented)) retired++;
@@ -321,7 +328,6 @@ export class Relays {
    */
   async send(sender, senderName, receiver, message, messageId) {
     const spec = this.spec(sender, senderName);
-    mkdirSync(spec.directory, { recursive: true });
     const asked = performance.now();
     try { return await this.#locked(spec.directory, () => this.#send(spec, receiver, message, messageId, asked)); }
     finally {
@@ -332,6 +338,8 @@ export class Relays {
 
   async #send(spec, receiver, message, messageId, asked) {
     try {
+      // made under its lock: a retire that held the lock meanwhile may have removed it
+      mkdirSync(spec.directory, { recursive: true });
       const queued = { to: receiver.socket ? `uds:${receiver.socket}` : receiver.name, message };
       const steps = [], began = asked;
       let mark = began;

package/mail/send.mjs

@@ -205,6 +205,8 @@ export class MailSend {
     if (session.door === 'runtime') return { kind: 'runtime', session };
     if (session.door === 'native') return { kind: 'native', session };
     if (session.door === 'hook') return { kind: 'hook', session, pane: session.pane ?? null, idle: session.status === 'idle' };
+    // a session with no hook and no relay (Grok) in a daemon pane: its mail is typed there, into an empty composer
+    if (session.door === 'pane' && session.pane) return { kind: 'pane', session, pane: session.pane };
     return { kind: 'stored', session };
   }
 
@@ -264,7 +266,10 @@ export class MailSend {
       queued: [0, 'it is idle and --queue leaves it so; the message waits in its mailbox'],
       operator: [0, 'filed in its mailbox'],
       already: [0, 'it already had this message; nothing was sent again'],
-      stored: [EXIT_STORED, 'Stored (not failed): it has no delivery door, so it sees this only if it runs supercode message inbox (a Codex session gets one with: supercode message setup codex). Don\'t resend, and don\'t wait for a reply'],
+      typed: [0, 'typed into its pane as its next turn'],
+      pane_held: [0, 'held for its pane: typed once its composer is free'],
+      pane_waits: [EXIT_STORED, 'Stored (not failed): its pane\'s composer was not empty, so the message waits in its mailbox; it sees it with supercode message inbox. Don\'t resend'],
+      stored: [EXIT_STORED, `Stored (not failed): it has no delivery door, so it sees this only if it runs supercode message inbox${parseAddress(address).harness === 'codex' ? ' (a Codex session gets one with: supercode message setup codex)' : ''}. Don't resend, and don't wait for a reply`],
     }[delivered];
     this.#recordSend(caller.address, address, messageId, sentIn);
     const harness = parseAddress(address).harness;
@@ -322,10 +327,18 @@ export class MailSend {
       this.store.deliver(to, sent);
       if (wake) this.store.requestWake(to, sent.id);
       delivered = 'hooked';
+    } else if (door.kind === 'pane') {
+      // typed as its next turn only into an empty composer (machine.mjs #paneTurn); otherwise it waits in its mailbox
+      let typed = null;
+      if (wake) { try { typed = await this.typeTurn(door.pane, parseAddress(to).harness, render(sent), [sent.id]); } catch { /* waits */ } }
+      if (typed?.delivered) { this.store.deliverRead(to, sent); delivered = 'typed'; }
+      // held by the daemon's queue for the pane, typed once its composer frees: not typed yet, so kept unread
+      else if (typed?.queued) { this.store.deliver(to, sent); delivered = 'pane_held'; }
+      else { this.store.deliver(to, sent); delivered = wake ? 'pane_waits' : 'queued'; }
     } else if (door.kind === 'stored') { this.store.deliver(to, sent); delivered = 'stored'; }
     else { this.store.deliver(to, sent); delivered = 'operator'; }
     // a hand-over to the recipient's own door is its delivery, recorded as such
-    if (['steered', 'started', 'native_busy', 'native_idle'].includes(delivered)) {
+    if (['steered', 'started', 'native_busy', 'native_idle', 'typed'].includes(delivered)) {
       try { this.store.claimFor(to, sent.id, { pid: process.pid, via: 'door', caller: null, recipient: true, at_ms: Date.now() }); } catch { /* best kept */ }
     }
     // nor is an idle notice routed to a claimed address (D200)
@@ -409,7 +422,7 @@ export class MailSend {
       if (error instanceof Refused) throw new Error(`${error.bytes} bytes; the limit is ${MAX_RELAYED_BYTES}`);
       throw error;
     }
-    return { steered: 'steered into its running turn', started: 'started a turn', native_busy: 'read at its next tool call', native_idle: 'starts its next turn', hooked: 'in its mailbox, its hook shows it', queued: 'waits in its mailbox', operator: 'filed', already: 'it already had it', stored: 'stored; it has no delivery door' }[how];
+    return { steered: 'steered into its running turn', started: 'started a turn', native_busy: 'read at its next tool call', native_idle: 'starts its next turn', hooked: 'in its mailbox, its hook shows it', queued: 'waits in its mailbox', operator: 'filed', already: 'it already had it', stored: 'stored; it has no delivery door', typed: 'typed into its pane', pane_held: 'held for its pane until its composer is free', pane_waits: 'waits in its mailbox (its composer was not empty)' }[how];
   }
 
   // ---- a filing --------------------------------------------------------------------------------------------------
@@ -507,9 +520,9 @@ export class MailSend {
       return refused('delivery_failed', error.message);
     }
     return {
-      delivered_to_bus: door.kind !== 'stored', message_id: sent.id, reply_to: sender,
+      delivered_to_bus: door.kind !== 'stored' && how !== 'pane_waits', message_id: sent.id, reply_to: sender,
       target: { harness, session_id: sessionId, name: door.kind === 'native' ? door.session.name.split('@')[0] : null },
-      delivery: { door: door.kind, how: { steered: 'steered', started: 'started', native_busy: 'next_tool_call', native_idle: 'started', hooked: 'hook', queued: 'queued', stored: 'stored', operator: 'filed', already: 'already' }[how] },
+      delivery: { door: door.kind, how: { steered: 'steered', started: 'started', native_busy: 'next_tool_call', native_idle: 'started', hooked: 'hook', queued: 'queued', stored: 'stored', operator: 'filed', already: 'already', typed: 'typed', pane_held: 'held', pane_waits: 'stored' }[how] },
     };
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.97",
+  "version": "0.3.98",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",