@volter/supercode-teams 0.3.120 → 0.3.122

package/bin/teams.mjs

@@ -187,7 +187,12 @@ async function main() {
         process.on('SIGTERM', stop);
         return;
       }
-      if (sub === 'status') { out(readJson(p.machine, { running: false })); return; }
+      if (sub === 'status') {
+        // and every supercode process here still running a release an install replaced (t_8e109edc)
+        let stale_releases = null;
+        try { stale_releases = await (await import('@volter/supercode-health/drift')).staleSupercode(); } catch { /* not read */ }
+        out({ ...readJson(p.machine, { running: false }), stale_releases }); return;
+      }
       // `machine restart [--machine M] [--reason text]`: the daemon (this one, or M's through the server) restarts under its service.
       if (sub === 'restart') return withNode(async (rpc) => out(await rpc.call('machine.restart', { reason: flags.reason ? String(flags.reason) : null })));
       die('machine start|status|restart');

package/bin/workspace.mjs

@@ -2,9 +2,9 @@
 import { StringDecoder } from 'node:string_decoder';
 import { hostname } from 'node:os';
 import { agentSessionHint } from './workspace/agent-session.mjs';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { existsSync, readFileSync, realpathSync, rmSync } from 'node:fs';
-import { basename, join, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { execFileSync, spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
@@ -1119,6 +1119,7 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
       if (!flags.json) {
         process.stdout.write(`Connected ${saved.machine.name} to team ${context.team_name ?? context.team_id}; it stays connected (a ${service.kind ?? 'background'} service).\n`);
         for (const line of service.message_tools ?? []) process.stdout.write(`  ${line}\n`);
+        for (const line of await releaseSkills()) process.stdout.write(`  ${line}\n`);
         return;
       }
       return output({ version: 1, context: scope(context), data: { machine: saved.machine, source: saved.source, service, ...(addedRule ? { rule: addedRule } : {}) } });
@@ -1486,3 +1487,17 @@ function stampStderr() {
   };
   process.stderr.__stamped = true;
 }
+
+/**
+ * The skills of the release this Teams package belongs to (`@volter/supercode`'s lib/skills.mjs, the package that
+ * holds it), put into every harness here: a machine connected to a team has agents that know supercode
+ * (t_266912ff). A Teams package run from a checkout or installed alone has no release beside it, and installs none.
+ */
+async function releaseSkills() {
+  const release = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', '..');
+  try {
+    if (JSON.parse(readFileSync(join(release, 'package.json'), 'utf8')).name !== '@volter/supercode') return [];
+    const { installSkills } = await import(pathToFileURL(join(release, 'lib', 'skills.mjs')).href);
+    return installSkills();
+  } catch { return []; }
+}

package/live-sessions.mjs

@@ -14,7 +14,7 @@
 // - Messaging tools: the marker a `message mcp` server writes for its session process, with the server alive.
 import { EventEmitter } from 'node:events';
 import { execFile } from 'node:child_process';
-import { mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, unlinkSync, watch, writeFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, unlinkSync, watch, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { FrontendClient } from '@volter/supercode-frontend';
@@ -128,7 +128,10 @@ export class LiveSessions extends EventEmitter {
     this.baseClaudeDirs = [...new Set([join(homedir(), '.claude', 'sessions'), ...(env.CLAUDE_CONFIG_DIR ? [join(env.CLAUDE_CONFIG_DIR, 'sessions')] : [])])];
     this.receiptsDir = join(supercodeHome, 'live-runtimes');
     this.homesFile = join(supercodeHome, 'live-claude-homes.json');
-    this.markersDir = join(supercodeHome, 'mail', 'message-mcp');
+    // which session has the messaging tools: told here by each `message mcp` server as it starts (mail step 1c), kept in
+    // this daemon's own state, outside the mail folder; the markers servers from before it wrote are taken in once
+    this.toolsFile = join(supercodeHome, 'message-tools.json');
+    this.legacyMarkersDir = join(supercodeHome, 'mail', 'message-mcp');
     this.codexHooks = join(env.CODEX_HOME || join(homedir(), '.codex'), 'hooks.json');
     this.boardOwner = boardOwner; this.log = log; this.startedAt = Date.now();
     this.claude = new Map(); // pid → { pid, dir, sessionId, name, status, cwd, tmux, procStart, history: [ids, oldest first] }
@@ -171,7 +174,7 @@ export class LiveSessions extends EventEmitter {
     // 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.#loadTools();
     this.#follow('codex_hooks', dirname(this.codexHooks), (name) => { if (!name || name === 'hooks.json') this.#readUserHook(); }, () => this.#readUserHook());
     return this;
   }
@@ -258,7 +261,7 @@ export class LiveSessions extends EventEmitter {
     this.claude.delete(pid);
     // its messaging tools' marker goes with it when it has ended (step 4a: by its end, never a minute's sweep); an entry
     // dropped for another reason (its home no longer declared, a parked process) keeps its marker for its return
-    if (this.markers.has(pid) && !alive(pid)) { this.markers.delete(pid); try { unlinkSync(join(this.markersDir, String(pid))); } catch { /* gone */ } }
+    if (this.markers.has(pid) && !alive(pid)) { this.markers.delete(pid); this.#saveTools(); }
   }
 
   /** Every held process asked whether it is alive (signal 0): a dead one's entry goes. */
@@ -476,25 +479,37 @@ export class LiveSessions extends EventEmitter {
     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;
-    const pid = Number(name);
-    if (!Number.isInteger(pid)) return;
-    let server = null;
-    try { server = Number(readFileSync(join(this.markersDir, name), 'utf8').trim()); } catch { /* removed */ }
-    // a marker whose server has ended names no tools: removed (read at start, and as each is written or changed)
-    if (Number.isInteger(server) && server > 0 && !alive(server)) { try { unlinkSync(join(this.markersDir, name)); } catch { /* gone */ } server = null; }
-    if (!(Number.isInteger(server) && server > 0)) { if (this.markers.delete(pid)) this.#changed(); return; }
-    this.markers.set(pid, server);
-    // its server is the session's own child (a harness starts its MCP servers so), checked once per marker: a server pid
-    // used again by another process names no tools (mail_route.rs `has_message_tools` read it so)
+  /** The messaging tools' markers kept here, and those servers from before wrote into the mail folder, taken in once
+   *  (that folder removed): each checked as a new one is. */
+  #loadTools() {
+    let kept = {};
+    try { kept = JSON.parse(readFileSync(this.toolsFile, 'utf8')) ?? {}; } catch { /* none yet */ }
+    try {
+      for (const name of readdirSync(this.legacyMarkersDir)) { const server = Number(readFileSync(join(this.legacyMarkersDir, name), 'utf8').trim()); if (Number.isInteger(Number(name))) kept[name] = server; }
+      rmSync(this.legacyMarkersDir, { recursive: true, force: true });
+    } catch { /* none written before */ }
+    for (const [session, server] of Object.entries(kept)) this.registerTools(Number(session), Number(server), { save: false });
+    this.#saveTools();
+  }
+
+  #saveTools() {
+    try { writeFileSync(`${this.toolsFile}.tmp`, JSON.stringify(Object.fromEntries(this.markers))); renameSync(`${this.toolsFile}.tmp`, this.toolsFile); }
+    catch (error) { this.log(`live sessions: the messaging tools' markers were not kept: ${error.message}`); }
+  }
+
+  /** A `message mcp` server says the session `session` has the messaging tools while it, `server`, runs: taken when the
+   *  server lives and is the session's own child (a harness starts its MCP servers so; a server pid used again by
+   *  another process names no tools, as mail_route.rs `has_message_tools` read it). Answers whether it was taken. */
+  registerTools(session, server, { save = true } = {}) {
+    if (!Number.isInteger(session) || session <= 0 || !Number.isInteger(server) || server <= 0 || !alive(server)) return false;
+    this.markers.set(session, server);
+    if (save) this.#saveTools();
+    this.#changed();
     void parentOf(server).then((parent) => {
-      if (parent == null || parent === pid || this.markers.get(pid) !== server) return;
-      this.markers.delete(pid);
-      try { unlinkSync(join(this.markersDir, name)); } catch { /* gone */ }
-      this.#changed();
+      if (parent == null || parent === session || this.markers.get(session) !== server) return;
+      this.markers.delete(session); this.#saveTools(); this.#changed();
     });
+    return true;
   }
 
 

package/machine.mjs

@@ -771,7 +771,7 @@ export class TeamsMachine extends MachineCore {
       discover: (params) => this.#serveRequest('harness.v1.sessions.discover', params, 10_000),
       recordedConfig: (locator) => this.#serveRequest('harness.v1.sessions.recorded_config', { locator }, 15_000) });
     // a relay's hooks (`message gate`, `relay-receipt`, `relay-inbound`) run the machine's stable supercode: its front door
-    this.relays = new Relays({ mailRoot, machine, supercodeBin: this.#stableSupercode(), serve: (method, params, timeoutMs) => this.#serveRequest(method, params, timeoutMs),
+    this.relays = new Relays({ mailRoot, machine, supercodeBin: this.#stableSupercode(), hooksServed: () => this.#frontDoorServes('message gate'), serve: (method, params, timeoutMs) => this.#serveRequest(method, params, timeoutMs),
       runtimeOf: (harness, id) => live.runtimeReceipt(harness, id), runtimeNamed: (receiptId) => live.receiptNamed(receiptId),
       runtimesIn: (harness, cwd) => live.runtimesIn(harness, cwd),
       endpointOf: async () => (await this.relayEndpoint)?.url ?? null,
@@ -800,7 +800,7 @@ export class TeamsMachine extends MachineCore {
       handOver: (address, id) => this.mailSend.handOver(address, id),
       // the thread a reply to `id` joins: its filed parent's thread, or the parent itself (mailbox.rs `thread_of_reply`)
       threadOf: (id) => { const found = this.mailStore.find(id).find((item) => item.stored.envelope.id === id); return found?.stored.envelope.thread ?? id; },
-      log: (line) => this.emit('mail-log', line) });
+      stateDir: supercodeHome(this.env), log: (line) => this.emit('mail-log', line) });
     // a relay's inbound mail its hook kept while this daemon did not answer (the front door's spool): filed now, each
     // minute, and before each relay's inbound call
     this.hookSpool = join(supercodeHome(this.env), 'hook-spool', 'relay-inbound');
@@ -1830,6 +1830,19 @@ export class TeamsMachine extends MachineCore {
    * this daemon's native once per daemon (`__stable-program`), for a command a pane records; this daemon's own
    * supercode when its native has no such verb or the shim cannot be written.
    */
+  /** Whether the machine's stable supercode serves `command` in TypeScript (its front door's own list), asked once: a dev
+   *  or cargo build's native, run with no front door, serves no hook verb. */
+  #frontDoorServes(command) {
+    if (this.frontDoorServed === undefined) {
+      this.frontDoorServed = new Set();
+      try {
+        const answer = spawnSync(this.#stableSupercode(), ['front-door', '--json'], { env: this.env, encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] });
+        if (answer.status === 0) for (const row of JSON.parse(answer.stdout).typescript ?? []) this.frontDoorServed.add(row.command);
+      } catch { /* none served */ }
+    }
+    return this.frontDoorServed.has(command);
+  }
+
   #stableSupercode() {
     if (this.stableSupercodePath !== undefined) return this.stableSupercodePath ?? this.supercodeBin;
     this.stableSupercodePath = null;
@@ -1922,14 +1935,7 @@ export class TeamsMachine extends MachineCore {
     if (process.platform === 'win32' || !((params.kind === 'codex' && name === 'codex') ||
       (params.kind === 'claude-code' && name === 'claude'))) return launchCommand(params.program, args);
     // the hook is the front door's (mail step 1b): taken when the machine's stable supercode serves it
-    if (this.nativeQuestionHooksSupported === undefined) {
-      let served = false;
-      try {
-        const answer = spawnSync(this.#stableSupercode(), ['front-door', '--json'], { env: this.env, encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] });
-        served = answer.status === 0 && (JSON.parse(answer.stdout).typescript ?? []).some((row) => row.command === 'message native-question-hook');
-      } catch { /* not served: the launch runs without it */ }
-      this.nativeQuestionHooksSupported = served;
-    }
+    this.nativeQuestionHooksSupported ??= this.#frontDoorServes('message native-question-hook');
     if (!this.nativeQuestionHooksSupported) return launchCommand(params.program, args);
     const mailHome = this.env.SUPERCODE_HOME || join(this.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'supercode');
     const dir = join(mailHome, 'mail', 'native-launches');
@@ -3866,6 +3872,82 @@ export class TeamsMachine extends MachineCore {
         if (method === 'harness.v1.mail.relay_inbound') { this.mailHooks.drainSpool(this.hookSpool); return { print: this.mailHooks.inbound(params.represented, params.directory, input, params.call) }; }
         return { print: await this.mailHooks.questionHook(params.binding, input, params.claim, this.nativeQuestions) };
       }
+      // a `message mcp` server saying its session has the messaging tools while it runs (mail step 1c): the server is the
+      // caller's own process (its claim), or on Windows the native that started it (`server`), the session's child either way
+      case 'harness.v1.mail.tools': {
+        if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('the messaging tools are said here by this machine\'s own processes'), { code: 403 });
+        const server = Number.isInteger(params.server_pid) ? params.server_pid : Number(params.claim?.pid);
+        return { taken: this.live.registerTools(Number(params.session_pid), server) };
+      }
+      // a board's own mailbox (mail step 1c): its owner's round claims its unread mail (board_inbox), and says which it
+      // handled (board_ack: those read, the rest given back unread); a dispatcher waits on it (board_wait) instead of
+      // watching the mail folder
+      case 'harness.v1.mail.board_inbox': case 'harness.v1.mail.board_ack': case 'harness.v1.mail.board_wait': {
+        if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('a board\'s mail is read here by this machine\'s own processes'), { code: 403 });
+        const board = new RegExp(`^sc:${machineName(this.env).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}:board:[^:\\s]+$`);
+        if (method === 'harness.v1.mail.board_wait') {
+          const boards = (Array.isArray(params.boards) ? params.boards : []).filter((address) => typeof address === 'string' && board.test(address)).slice(0, 256);
+          const seconds = Math.min(120, Math.max(0, Number.isFinite(Number(params.timeout)) ? Math.floor(Number(params.timeout)) : 60));
+          const waiting = () => boards.filter((address) => this.mailStore.hasClaimable(address));
+          let woken = waiting();
+          if (!woken.length && boards.length) {
+            woken = await new Promise((resolve) => {
+              const changed = (address) => { if (boards.includes(address)) { const now = waiting(); if (now.length) done(now); } };
+              const done = (value) => { clearTimeout(timer); this.mailStore.off('changed', changed); resolve(value); };
+              const timer = setTimeout(() => done([]), seconds * 1000);
+              this.mailStore.on('changed', changed);
+            });
+          }
+          return { woken };
+        }
+        let caller = null;
+        try { caller = await this.#callerOf(entry, params); } catch { /* not a registered owner's: the lock below may say */ }
+        if (typeof caller !== 'string' || !board.test(caller)) {
+          // a board on a machine that serves no team has no registered owner (registration is its connector's): its round
+          // names its home and holds that home's board lock, and its address is one of that home's boards
+          const named = params.claim?.named, root = typeof params.root === 'string' && params.root ? params.root : null;
+          caller = null;
+          if (root && typeof named === 'string' && board.test(named) && await this.#holdsBoardLock(root, Number(params.claim?.pid))) {
+            let slugs = ['default'];
+            try { slugs = [...slugs, ...readdirSync(join(root, 'kanban', 'boards'))]; } catch { /* the default board only */ }
+            if (slugs.some((slug) => `sc:${machineName(this.env)}:board:${boardName(boardLabel(root, slug))}` === named)) caller = named;
+          }
+        }
+        if (!caller) return { code: 2, text: 'a board\'s mailbox is read by that board\'s own owner only (its registered owner, or the process holding its home\'s board lock)' };
+        this.boardClaims ??= new Map();
+        if (method === 'harness.v1.mail.board_ack') {
+          const pending = this.boardClaims.get(params.token);
+          if (!pending || pending.address !== caller) return { code: 0, acknowledged: 0 };
+          this.boardClaims.delete(params.token);
+          const handled = new Set(Array.isArray(params.ids) ? params.ids : []);
+          let acknowledged = 0;
+          for (const item of pending.claimed) {
+            try { if (handled.has(item.envelope.id)) { this.mailStore.acknowledge(caller, item); acknowledged++; } else this.mailStore.release(caller, item); }
+            catch { /* moved meanwhile: its reader's recovery gives it back */ }
+          }
+          return { code: 0, acknowledged };
+        }
+        const claimed = this.mailStore.claimUnread(caller, 'board', caller, Number(params.claim?.pid) || process.pid);
+        if (!claimed.length) return { code: 0, token: null, envelopes: [] };
+        const token = randomBytes(12).toString('hex');
+        for (const [old] of [...this.boardClaims].slice(0, Math.max(0, this.boardClaims.size - 63))) this.boardClaims.delete(old);
+        this.boardClaims.set(token, { address: caller, claimed });
+        return { code: 0, token, envelopes: claimed.map((item) => this.mailStore.body(item) ?? item.envelope) };
+      }
+      // the Codex hooks' records (Windows), for serve's Codex listing (mail step 1c)
+      case 'harness.v1.mail.codex_hooks': {
+        if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('the Codex hooks\' records are read here by this machine\'s own processes'), { code: 403 });
+        return { records: this.mailHooks.codexHookRecords() };
+      }
+      // the names ledger, kept here from the live map (mail step 1c): the session each name last meant, and the name each
+      // session was last listed by, for the native readers (`message send` by a remembered name, `open`, a session tree)
+      case 'harness.v1.mail.names': {
+        if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('the names ledger is read here by this machine\'s own processes'), { code: 403 });
+        const list = (value) => (Array.isArray(value) ? value.filter((item) => typeof item === 'string').slice(0, 4096) : []);
+        const addresses = {};
+        for (const name of list(params.names)) { const address = this.mailSend.remembered(name); if (address) addresses[name] = address; }
+        return { addresses, names: this.mailSend.rememberedNames(list(params.addresses)) };
+      }
       // `message waiting` and `message expired` (step 1): the carrier's own records
       case 'harness.v1.mail.waiting': case 'harness.v1.mail.expired': {
         if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('mail is read here by this machine\'s own processes'), { code: 403 });

package/mail/hooks.mjs

@@ -32,8 +32,13 @@ const printable = (name) => Array.from(String(name ?? '')).filter((c) => /[A-Za-
 
 export class MailHooks {
   /** `handOver(address, id)` a filed message to its session's door; `threadOf(id)` the thread a reply to `id` joins. */
-  constructor({ machine, mailRoot, store, live, handOver, threadOf, log = () => {} }) {
+  constructor({ machine, mailRoot, store, live, handOver, threadOf, stateDir = null, log = () => {} }) {
     Object.assign(this, { machine, mailRoot, store, live, handOver, threadOf, log });
+    // Windows: each Codex session's last hook (the process it ran under, the rollout it named, when), which serve's
+    // Codex listing reads through this daemon (codex_peer.rs `hook_recorded_rollouts`); kept beside this daemon's state,
+    // never in the mail folder (mail step 1c)
+    this.codexHooksFile = stateDir ? join(stateDir, 'codex-hooks.json') : null;
+    this.codexHooks = new Map(Object.entries((this.codexHooksFile && readJson(this.codexHooksFile)) || {}));
     this.relaysRoot = resolve(mailRoot, 'relays');
     this.questions = join(mailRoot, 'native-questions');
   }
@@ -49,7 +54,8 @@ export class MailHooks {
     // Windows: where the listing cannot see a Codex's open rollout, the session's own hook says it runs (the process
     // that ran it, and the rollout it names), until the live map knows Codex there (step 1c)
     if (process.platform === 'win32' && harness === 'codex' && Number.isInteger(claim?.ppid)) {
-      try { writeFileSync(join(box.dir, 'process'), `${claim.ppid}\n${typeof input.transcript_path === 'string' ? input.transcript_path : ''}\n`); } catch { /* best kept */ }
+      this.codexHooks.set(address, { pid: claim.ppid, rollout: typeof input.transcript_path === 'string' ? input.transcript_path : '', at_ms: Date.now() });
+      this.#saveCodexHooks();
     }
     const event = typeof input.hook_event_name === 'string' ? input.hook_event_name : '';
     // the person's own prompt: filed as theirs, since the harness's transcript does not say who wrote it; no pointer
@@ -68,6 +74,21 @@ export class MailHooks {
       : { decision: 'block', reason: `${pointer} Read them before you finish.` };
   }
 
+  /** The Codex hooks' records (Windows), for serve's listing: `{address, pid, rollout, at_ms}` each; one whose process is
+   *  gone is let go. */
+  codexHookRecords() {
+    let dropped = false;
+    for (const [address, record] of this.codexHooks) if (!alive(record.pid)) { this.codexHooks.delete(address); dropped = true; }
+    if (dropped) this.#saveCodexHooks();
+    return [...this.codexHooks].map(([address, record]) => ({ address, ...record }));
+  }
+
+  #saveCodexHooks() {
+    if (!this.codexHooksFile) return;
+    try { writeFileSync(`${this.codexHooksFile}.tmp`, JSON.stringify(Object.fromEntries(this.codexHooks))); renameSync(`${this.codexHooksFile}.tmp`, this.codexHooksFile); }
+    catch (error) { this.log(`codex hooks: not kept: ${error.message}`); }
+  }
+
   /** How many unread messages, from whom, and the one command that reads them (message.rs `mail_pointer`). */
   #pointer(unread) {
     const senders = [];
@@ -174,7 +195,12 @@ export class MailHooks {
       // drain (its id names its mail, so a filing that half happened is not made twice)
       if (spooled?.input) {
         try { this.inbound(spooled.represented, spooled.directory, spooled.input, spooled.call); filed++; }
-        catch (error) { this.log(`relay inbound: kept mail ${name} not filed yet (${error.message}); kept for the next drain`); continue; }
+        catch (error) {
+          // one this daemon refuses (its folder no longer a relay's, its address not one: a 400) never will be filed: let
+          // go, said; one that failed on its way to the store (an I/O failure) is kept for the next drain
+          if (error.code === 400) this.log(`relay inbound: kept mail ${name} refused (${error.message}); let go`);
+          else { this.log(`relay inbound: kept mail ${name} not filed yet (${error.message}); kept for the next drain`); continue; }
+        }
       }
       rmSync(path, { force: true });
     }

package/mail/relay.mjs

@@ -91,8 +91,8 @@ export class Relays {
    * id)` the live-runtime receipt the live-session map holds for a runtime id (its file read whole), or null;
    * `runtimeNamed(receiptId)` one receipt read by its own name.
    */
-  constructor({ mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed = () => null, runtimesIn = () => [], endpointOf = async () => null, arrived = async () => false, log = () => {} }) {
-    Object.assign(this, { mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed, runtimesIn, endpointOf, arrived, log });
+  constructor({ mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed = () => null, runtimesIn = () => [], endpointOf = async () => null, arrived = async () => false, hooksServed = () => true, log = () => {} }) {
+    Object.assign(this, { mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed, runtimesIn, endpointOf, arrived, hooksServed, log });
     this.lost = new Map(); // relay folder → when a start of its runtime lost its answer (the runtime may run, unnamed)
     this.remoteKept = new Map(); // relay folder of a sender on another machine → the timer that retires it
     this.sending = new Map(); // relay folder → the send in progress through it (one at a time per relay)
@@ -268,6 +268,9 @@ export class Relays {
   /** The relay's runtime, started in this daemon's harness serve when it is not running (claude_relay.rs
    *  `ensure_relay_runtime`): `{ runtime (its receipt), connection }`. */
   async #ensure(spec, step = () => {}, { stale = false } = {}) {
+    // a relay's hooks are the front door's verbs (mail step 1b): a stable supercode with no front door (a dev or cargo
+    // build's native) would answer none of them, and every mail the relay is handed would be blocked unfiled
+    if (!this.hooksServed()) throw new Error('relays run their hooks through the machine\'s stable supercode, which has no front door here (a dev or cargo build); install supercode from npm to send to Claude sessions by relay');
     const endpoint = await this.endpoint();
     step('relay endpoint');
     if (!endpoint) throw new Error('the relay endpoint is not served by this machine\'s daemon (its log says why); a Claude session can be sent mail once the daemon starts again');

package/mail/send.mjs

@@ -890,6 +890,24 @@ export class MailSend {
   /** The session a name last meant here, listed by it within NAME_KEPT_MS (mail_route.rs `remembered_address`). */
   remembered(name) { return this.#rememberedAddress(name); }
 
+  /** The name `address` was last listed by here (the newest it began to carry), or null (mail_route.rs
+   *  `remembered_name`). */
+  rememberedName(address) { return this.rememberedNames([address])[address] ?? null; }
+
+  /** rememberedName for each of `addresses`, the ledger read once. */
+  rememberedNames(addresses) {
+    const names = readJson(join(this.mailRoot, 'names.json'));
+    const wanted = new Set(addresses), best = new Map();
+    if (names && typeof names === 'object') {
+      for (const [name, record] of Object.entries(names)) {
+        if (!wanted.has(record?.address)) continue;
+        const held = best.get(record.address);
+        if (!held || (record.since_ms ?? 0) > (held.since_ms ?? 0)) best.set(record.address, { name, since_ms: record.since_ms ?? 0 });
+      }
+    }
+    return Object.fromEntries([...best].map(([address, { name }]) => [address, name]));
+  }
+
   #rememberedAddress(name) {
     const record = readJson(join(this.mailRoot, 'names.json'))?.[name];
     if (!record || Date.now() - Math.max(record.seen_ms ?? 0, record.since_ms ?? 0) > NAME_KEPT_MS) return null;

package/package.json

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