@volter/supercode-teams 0.3.117 → 0.3.119

package/bin/workspace.mjs

@@ -1064,6 +1064,10 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
     // The service's own run (no terminal; no flag, or --foreground on Windows) never adds a rule or returns early: a
     // service whose folder is not among the roots (an enrollment from before roots were kept) only gets its root back.
     const serviceRun = !addingRoot && !flags.install && !(process.stdin.isTTY && process.stdout.isTTY) && (!flags.foreground || process.platform === 'win32');
+    // A service's error log keeps no time of its own: each line the connector writes there is stamped, so an outage,
+    // a restart or a refused link can be placed against the server's and the service manager's records (2026-10-06:
+    // a restart and a window of "temporarily unavailable" could be timed only from a killed process's uptime).
+    if (serviceRun) stampStderr();
     // A folder a person adds gets its sync rule first, whatever runs the connector, so a refused or failed rule leaves
     // the enrollment as it was; a machine context adds none.
     const addedRule = (addedRoot || addingRoot) && !serviceRun && !context.machine_only ? await addedRootRule({ team, saved, root, harnesses: ruleHarnesses, flags }).catch(error => { core.close(); throw error; }) : null;
@@ -1462,3 +1466,18 @@ if (import.meta.url === new URL(`file://${process.argv[1]}`).href) workspaceMain
   // still holds the event loop open gets a moment, then the exit is forced.
   setTimeout(() => process.exit(process.exitCode), 2_000).unref();
 });
+
+/** Every line this process writes to stderr from here on, stamped with its UTC time (a write's line starts only). */
+function stampStderr() {
+  if (process.stderr.__stamped) return;
+  const write = process.stderr.write.bind(process.stderr);
+  let atStart = true;
+  process.stderr.write = (chunk, ...rest) => {
+    const text = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8');
+    const stamp = new Date().toISOString();
+    const stamped = text.replace(/(^|\n)(?=[^\n])/g, (match, newline, offset) => (offset === 0 && !atStart ? match : `${newline}${stamp} `));
+    atStart = text.endsWith('\n');
+    return write(stamped, ...rest);
+  };
+  process.stderr.__stamped = true;
+}

package/machine.mjs

@@ -42,6 +42,8 @@ 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 { MailHooks } from './mail/hooks.mjs';
+import { NativeQuestions } from './mail/questions.mjs';
 
 const NO_CALLER = "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.";
 import { MailSend } from './mail/send.mjs';
@@ -768,7 +770,8 @@ export class TeamsMachine extends MachineCore {
     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),
+    // 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),
       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,
@@ -789,6 +792,20 @@ export class TeamsMachine extends MachineCore {
       // a user's own turn typed into its pane, in process (as `panes.turn` types one)
       typeTurn,
       log: (line) => this.emit('mail-log', line) });
+    // native questions' files (bindings, questions, replies) as mail_question.rs keeps them; their poll is step 4c's
+    this.nativeQuestions = new NativeQuestions({ machine, mailRoot, store: this.mailStore, codexQuestions: (request) => codexQuestions(request),
+      log: (line) => this.emit('mail-log', line) });
+    // the harnesses' mail hooks (step 1b): each hook a front-door verb asking here, so none opens the mail folder
+    this.mailHooks = new MailHooks({ machine, mailRoot, store: this.mailStore, live,
+      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) });
+    // 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');
+    this.mailHooks.drainSpool(this.hookSpool);
+    this.hookSpoolTimer = setInterval(() => this.mailHooks.drainSpool(this.hookSpool), 60_000); this.hookSpoolTimer.unref?.();
     // 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),
@@ -1124,6 +1141,7 @@ export class TeamsMachine extends MachineCore {
     this.mailWatch?.kill('SIGTERM');
     void this.relayEndpoint?.then((endpoint) => endpoint?.close()).catch(() => {});
     this.carrier?.stop();
+    clearInterval(this.hookSpoolTimer);
     clearInterval(this.turnsSweep);
     this.stoppingServe = true;
     clearTimeout(this.serveRestart);
@@ -1816,7 +1834,8 @@ export class TeamsMachine extends MachineCore {
     if (this.stableSupercodePath !== undefined) return this.stableSupercodePath ?? this.supercodeBin;
     this.stableSupercodePath = null;
     try {
-      const answer = spawnSync(this.supercodeBin, ['__stable-program'], { env: this.env, encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] });
+      // with this Node named, the shim it writes runs the front door (claude_relay.rs ensure_stable_program)
+      const answer = spawnSync(this.supercodeBin, ['__stable-program'], { env: { ...this.env, SUPERCODE_NODE_BIN: this.env.SUPERCODE_NODE_BIN || process.execPath }, encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] });
       const path = answer.status === 0 ? answer.stdout.trim() : '';
       if (path && isAbsolute(path) && existsSync(path)) this.stableSupercodePath = path;
     } catch { /* this daemon's own supercode */ }
@@ -1902,7 +1921,15 @@ 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);
-    this.nativeQuestionHooksSupported ??= spawnSync(this.supercodeBin, ['message', 'native-question-hook', '--help'], { env: this.env, timeout: 2000, stdio: 'ignore' }).status === 0;
+    // 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;
+    }
     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');
@@ -3824,6 +3851,19 @@ export class TeamsMachine extends MachineCore {
         this.mail.acknowledge(address, read.claimed);
         return { address, messages };
       }
+      // the harnesses' mail hooks (step 1b): the hook's input in, what the hook prints out (`print`, null for nothing)
+      case 'harness.v1.mail.hook': case 'harness.v1.mail.relay_gate': case 'harness.v1.mail.relay_receipt': case 'harness.v1.mail.relay_inbound': case 'harness.v1.mail.question_hook': {
+        if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('a mail hook is answered here for this machine\'s own processes'), { code: 403 });
+        const input = params.input && typeof params.input === 'object' ? params.input : {};
+        if (method === 'harness.v1.mail.hook') {
+          if (typeof params.harness !== 'string' || !/^[a-z0-9-]+$/.test(params.harness)) throw Object.assign(new Error('a hook names its harness'), { code: 400 });
+          return { print: this.mailHooks.hook(params.harness, input, params.claim) };
+        }
+        if (method === 'harness.v1.mail.relay_gate') return { print: this.mailHooks.gate(params.directory, input) };
+        if (method === 'harness.v1.mail.relay_receipt') return { print: this.mailHooks.receipt(params.directory, input) };
+        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) };
+      }
       // `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

@@ -0,0 +1,285 @@
+// The harnesses' mail hooks, answered by this daemon (mail step 1b; docs/plans/typescript-architecture.md): each hook is
+// a front-door verb that hands its hook input here and prints what comes back, so no hook opens the mail folder.
+// - `message hook <harness>` (Codex's hooks; mail_route.rs and message.rs `hook`): the person's typed prompt filed as a
+//   typed line; on a tool's end or a turn's end, a pointer to the unread mail (never the mail itself: hook context
+//   carries the harness's own authority, and peer text travels only through `inbox`, which wraps it).
+// - a relay's hooks (claude_relay.rs): `gate` lets the relay make only its one queued send, `relay-receipt` records how
+//   that send went, `relay-inbound` files mail a relay's Claude was handed in the mailbox of the session it speaks for.
+// - `message native-question-hook` (mail_question.rs `hook`): a native session's creator recorded at its start, and its
+//   AskUserQuestion asked as mail and answered by the reply.
+import { existsSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { join, resolve, sep } from 'node:path';
+import { envelope as makeEnvelope, makeAddress, newMessageId, parseAddress } from './compose.mjs';
+import { blake3Hex } from './envelope.mjs';
+import { typedLineId } from './transcript.mjs';
+
+const readJson = (path) => { try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; } };
+const alive = (pid) => { if (!Number.isInteger(pid) || pid <= 0) return false; try { process.kill(pid, 0); return true; } catch (error) { return error.code === 'EPERM'; } };
+
+// what Claude wraps mail in when it hands it to a relay (claude_relay.rs)
+const NATIVE_PEER_PREAMBLE = 'Another Claude session sent a message:';
+const NATIVE_PEER_OPENING = '<cross-session-message ';
+const NATIVE_PEER_CLOSING = '</cross-session-message>';
+const NATIVE_IDLE_NOTICE = '[Cross-session idle notice]';
+const NATIVE_DELIVERY_NOTICE = '[Cross-session delivery notice]';
+const INBOUND_BLOCK = { decision: 'block', reason: 'filed in the mailbox of the session this relay speaks for' };
+const sendTurn = ({ to, message }) => `Send one message with SendMessage.\nto: ${to}\nmessage: the exact text between the markers, without the markers\n---BEGIN MESSAGE---\n${message}\n---END MESSAGE---`;
+
+/** A line no person typed (mail_transcript.rs `machine_made`). */
+const machineMade = (text) => text.includes('<cross-session-message') || text.startsWith('[Cross-session') || text.startsWith('[channel: ') || text.startsWith('<task-notification>');
+/** A sender name reduced to characters that cannot break out of a hook's sentence (message.rs `printable`). */
+const printable = (name) => Array.from(String(name ?? '')).filter((c) => /[A-Za-z0-9\-_.@ ]/.test(c)).slice(0, 80).join('');
+
+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 = () => {} }) {
+    Object.assign(this, { machine, mailRoot, store, live, handOver, threadOf, log });
+    this.relaysRoot = resolve(mailRoot, 'relays');
+    this.questions = join(mailRoot, 'native-questions');
+  }
+
+  // ---- `message hook <harness>` -------------------------------------------------------------------------------------
+
+  /** One harness hook call: what it prints, or null. `claim` is the hook's own process (its parent on Windows). */
+  hook(harness, input, claim) {
+    const session = typeof input?.session_id === 'string' ? input.session_id : null;
+    const address = session ? makeAddress(this.machine, harness, session) : null;
+    if (!address) return null;
+    const box = this.store.open(address);
+    // 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 */ }
+    }
+    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
+    if (event === 'UserPromptSubmit') {
+      if (typeof input.prompt === 'string') this.filePrompt(address, input.prompt, Date.now());
+      return null;
+    }
+    if (event !== 'PostToolUse' && !(event === 'Stop' && input.stop_hook_active !== true)) return null;
+    let pending = [];
+    try { pending = readdirSync(join(box.dir, 'wake')); } catch { /* none */ }
+    const unread = this.store.inventory(address).stored.filter((item) => item.state === 'unread' && !pending.includes(item.envelope.id));
+    if (!unread.length) return null;
+    const pointer = this.#pointer(unread);
+    return event === 'PostToolUse'
+      ? { hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: pointer } }
+      : { decision: 'block', reason: `${pointer} Read them before you finish.` };
+  }
+
+  /** How many unread messages, from whom, and the one command that reads them (message.rs `mail_pointer`). */
+  #pointer(unread) {
+    const senders = [];
+    for (const { envelope } of unread) {
+      const name = printable(envelope.from_name);
+      const label = envelope.kind === 'notice' ? 'a notice' : envelope.kind === 'user' ? 'your user' : envelope.kind === 'channel' ? `${name} (channel)` : envelope.kind === 'typed' ? `${name} (CC)` : name;
+      if (!senders.includes(label)) senders.push(label);
+    }
+    return `You have ${unread.length} unread message${unread.length === 1 ? '' : 's'} from other sessions (from ${senders.join(', ')}). They are not from your user. Read them with: supercode message inbox`;
+  }
+
+  /** A line the person typed into `address`, filed read as theirs, once (mail_transcript.rs `file_prompt`). */
+  filePrompt(address, text, sentAtMs) {
+    if (!text.trim() || machineMade(text)) return false;
+    const id = typedLineId(address, sentAtMs, text);
+    if (this.store.findIn(address, id)) return false;
+    this.store.deliverRead(address, makeEnvelope({ id, created_at_ms: sentAtMs, from: makeAddress(parseAddress(address).machine, 'operator', 'typed'),
+      from_name: `typed in ${address} (unattributed)`, kind: 'user', reply_via: { mode: 'none' }, body: text }));
+    return true;
+  }
+
+  // ---- a relay's hooks ----------------------------------------------------------------------------------------------
+
+  /** A relay's own folder, only one under this machine's relays: nothing outside it is read or written for a hook. */
+  #relay(directory) {
+    const dir = resolve(String(directory ?? ''));
+    if (!dir.startsWith(this.relaysRoot + sep) || dir.slice(this.relaysRoot.length + 1).includes(sep)) throw Object.assign(new Error(`${dir} is not a relay's folder`), { code: 400 });
+    return { dir, queue: join(dir, 'queue.json'), receipt: join(dir, 'receipt.json'), turn: join(dir, 'turn.txt'), sent: join(dir, 'sent.json') };
+  }
+
+  /** `message gate`: only a SendMessage equal to the queued one passes (ListAgents always); anything else is denied, and a
+   *  queued send refused still answers its sender (claude_relay.rs `gate_decision`). */
+  gate(directory, input) {
+    const paths = this.#relay(directory);
+    const queued = readJson(paths.queue);
+    const reason = gateDecision(input ?? {}, queued);
+    if (reason == null) return null;
+    if (queued && !existsSync(paths.receipt)) { try { writeFileSync(paths.receipt, JSON.stringify({ denied: reason })); } catch { /* best kept */ } }
+    return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: reason } };
+  }
+
+  /** `message relay-receipt`: Claude's own answer to the queued send, its error, or that the turn ended without one. */
+  receipt(directory, input) {
+    const paths = this.#relay(directory);
+    if (!existsSync(paths.queue) || existsSync(paths.receipt)) return null;
+    const event = input?.hook_event_name;
+    let receipt;
+    if (event === 'PostToolUse') receipt = { tool_response: input.tool_response ?? null };
+    else if (event === 'PostToolUseFailure') receipt = { send_failed: typeof input.error === 'string' ? input.error : input.error == null ? '' : JSON.stringify(input.error) };
+    else if (event === 'Stop' || event === 'StopFailure') {
+      // a turn that began before this send was queued (the last send's, still ending) is not its answer
+      const queued = readJson(paths.queue);
+      let prompt = null; try { prompt = readFileSync(paths.turn, 'utf8'); } catch { /* none recorded */ }
+      if (queued && prompt != null && !prompt.includes(sendTurn(queued))) return null;
+      const text = (key) => (typeof input[key] === 'string' ? input[key] : null);
+      const said = event === 'StopFailure' ? `${text('error_details') ?? text('last_assistant_message') ?? ''} (${text('error') ?? 'error'})` : text('last_assistant_message');
+      receipt = { turn_ended: true, said: said == null ? null : Array.from(said).slice(0, 300).join('') };
+    } else return null;
+    writeFileSync(paths.receipt, JSON.stringify(receipt));
+    return null;
+  }
+
+  /** `message relay-inbound`: mail a relay's Claude was handed is filed for the session it speaks for, threaded by what
+   *  the relay last sent, and kept from the relay's model; its own send turns pass, recorded for the receipt. */
+  inbound(represented, directory, input, call = null) {
+    const paths = this.#relay(directory);
+    const prompt = typeof input?.prompt === 'string' ? input.prompt : '';
+    const trimmed = prompt.trimStart();
+    if (!(trimmed.startsWith(NATIVE_PEER_OPENING) || trimmed.startsWith(NATIVE_IDLE_NOTICE) || trimmed.startsWith(NATIVE_DELIVERY_NOTICE))) {
+      try { writeFileSync(paths.turn, prompt); } catch { /* best kept */ }
+      return null;
+    }
+    if (!parseAddress(represented)) throw Object.assign(new Error(`not an address: ${represented}`), { code: 400 });
+    const event = parseInbound(prompt);
+    // named by its hook call when it has one: filed once, however it reaches here (its answer, or its kept copy)
+    const id = typeof call === 'string' && /^[0-9a-f]{8,64}$/.test(call) ? `m-${blake3Hex(`relay-inbound\0${call}`).slice(0, 24)}` : newMessageId();
+    if (event?.kind === 'peer') {
+      // the replying Claude session runs beside the relay, on this machine
+      const sender = this.live.sessions().find((row) => row.door === 'native' && row.socket && row.socket === event.from.replace(/^uds:/, ''));
+      const sessionId = sender ? sender.address.split(':').slice(3).join(':') : null;
+      const lastSent = readJson(paths.sent) ?? {};
+      const inReplyTo = sessionId ? lastSent[sessionId] ?? null : null;
+      this.#fileHome(represented, makeEnvelope({ id, from: makeAddress(this.machine, 'claude-code', sessionId ?? 'unknown'),
+        from_name: sender ? sender.name : event.fromName ?? 'an unknown Claude session', kind: 'peer', reply_via: { mode: 'command' },
+        in_reply_to: inReplyTo, in_reply_to_inferred: inReplyTo != null, thread: inReplyTo ? this.threadOf(inReplyTo) : null,
+        native_from: event.from, body: event.body }));
+    } else if (event) {
+      this.#fileHome(represented, makeEnvelope({ id, from: makeAddress(this.machine, 'claude-code', 'notice'), from_name: 'Claude Code',
+        kind: 'notice', reply_via: { mode: 'none' }, body: event.text }));
+    }
+    return INBOUND_BLOCK;
+  }
+
+  /** A relay's inbound mail its hook kept while this daemon did not answer it (the front door's spool, outside the mail
+   *  folder): each filed as the hook would have filed it, then let go; oldest first. */
+  drainSpool(dir) {
+    let names = [];
+    try { names = readdirSync(dir).filter((name) => name.endsWith('.json')).sort(); } catch { return 0; }
+    let filed = 0;
+    for (const name of names) {
+      const path = join(dir, name);
+      const spooled = readJson(path);
+      // one that cannot be read, or names no hook input, is no mail: let go; one whose filing fails is kept for the next
+      // 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; }
+      }
+      rmSync(path, { force: true });
+    }
+    return filed;
+  }
+
+  /** Filed for the session a relay speaks for: here, then handed to its door (not waited on); for another machine, with
+   *  a wake, so the carrier carries it there with its retries. */
+  #fileHome(represented, envelope) {
+    // not filed is a failed filing, never a quiet one: the hook keeps the mail (its spool), and a drain keeps its file
+    this.store.deliver(represented, envelope);
+    if (parseAddress(represented).machine === this.machine) void Promise.resolve(this.handOver(represented, envelope.id)).catch((error) => this.log(`relay inbound: ${envelope.id} stays in ${represented}'s mailbox: ${error.message}`));
+    else this.store.requestWake(represented, envelope.id);
+  }
+
+  // ---- `message native-question-hook <binding>` ---------------------------------------------------------------------
+
+  /** One native question hook call (mail_question.rs `hook`): the session's creator bound at its start; a Claude
+   *  AskUserQuestion filed as mail before the tool runs and answered by its reply (waited for while the hook's process
+   *  lives), and confirmed after it ran. `questions` is the daemon's NativeQuestions. */
+  async questionHook(seedPath, input, claim, questions) {
+    const seedFile = resolve(String(seedPath ?? ''));
+    const launches = resolve(this.mailRoot, 'native-launches');
+    if (!seedFile.startsWith(launches + sep)) throw Object.assign(new Error(`${seedFile} is not a native launch's binding`), { code: 400 });
+    const seed = readJson(seedFile);
+    if (!seed || (seed.kind !== 'codex' && seed.kind !== 'claude-code')) throw new Error('unsupported native question harness');
+    const binding = questions.bind(seed, { session_id: input?.session_id, transcript_path: typeof input?.transcript_path === 'string' ? input.transcript_path : null }, seed.kind);
+    if (input?.hook_event_name === 'SessionStart' && binding.transcript_path) {
+      // this launch's baseline precedes its native initial prompt, including on resume
+      const receipt = `${seedFile.replace(/\.json$/, '')}.session.json`;
+      let offset = 0; try { offset = statSync(binding.transcript_path).size; } catch { /* not there yet */ }
+      try { questions.create(receipt, { path: binding.transcript_path, offset }); } catch (error) { if (error.code !== 'EEXIST') throw error; }
+    }
+    if (input?.tool_name !== 'AskUserQuestion') return {};
+    const tool = input.tool_input ?? {};
+    const asked = (Array.isArray(tool.questions) ? tool.questions : []).map((question) => ({ ...question, id: question.question }));
+    if (typeof input.tool_use_id !== 'string') throw new Error('native question tool_use_id missing');
+    const native = { threadId: binding.session.split(':').slice(3).join(':'), turnId: 'claude', itemId: input.tool_use_id, questions: asked };
+    const id = questions.idOf(binding.session, native);
+    const answersOf = (reply) => Object.fromEntries(Object.entries(reply?.answers ?? {}).map(([key, value]) => [key, value?.answers?.[0] ?? null]));
+    if (input.hook_event_name === 'PostToolUse') {
+      const reply = readJson(join(this.questions, `${id}.reply`));
+      if (reply && JSON.stringify(input.tool_response?.answers ?? null) === JSON.stringify(answersOf(reply))) questions.confirm(id, reply);
+      return {};
+    }
+    if (input.hook_event_name !== 'PreToolUse') return {};
+    // one hook owns this wait, marked by its process: a hook its harness killed ends the wait, and never answers
+    const waiting = join(this.questions, `${id}.waiting`);
+    questions.create(waiting, { pid: claim?.pid ?? null });
+    try {
+      questions.file(binding, native);
+      for (;;) {
+        const reply = readJson(join(this.questions, `${id}.reply`));
+        if (reply) return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow', updatedInput: { ...tool, answers: answersOf(reply) } } };
+        if (claim?.pid && !alive(Number(claim.pid))) return {};
+        await new Promise((done) => setTimeout(done, 250));
+      }
+    } finally { rmSync(waiting, { force: true }); }
+  }
+}
+
+/** One PreToolUse call of a relay: null allows it, a reason denies it (claude_relay.rs `gate_decision`). */
+export function gateDecision(input, queued) {
+  const tool = typeof input.tool_name === 'string' ? input.tool_name : '';
+  if (tool === 'ListAgents') return null;
+  if (tool !== 'SendMessage') return `a relay may not use ${tool}`;
+  if (!queued) return 'nothing is queued to send; mail for the host is not answered by the relay';
+  const to = typeof input.tool_input?.to === 'string' ? input.tool_input.to : '';
+  const message = typeof input.tool_input?.message === 'string' ? input.tool_input.message : '';
+  if (to !== queued.to) return `not the queued outbound message: \`to\` is ${JSON.stringify(to)}, the queue says ${JSON.stringify(queued.to)}`;
+  if (message !== queued.message) {
+    // the first character that differs, at its byte in what was sent; each text from that byte (none from a byte inside
+    // one of its characters), as the native gate said it
+    const sent = Array.from(message), want = Array.from(queued.message);
+    let at = 0, index = 0;
+    while (index < sent.length && index < want.length && sent[index] === want[index]) { at += Buffer.byteLength(sent[index]); index++; }
+    if (index >= sent.length || index >= want.length) at = Math.min(Buffer.byteLength(message), Buffer.byteLength(queued.message));
+    const tail = (text) => { const bytes = Buffer.from(text); if (at > bytes.length || (at < bytes.length && (bytes[at] & 0xc0) === 0x80)) return ''; return Array.from(bytes.subarray(at).toString('utf8')).slice(0, 40).join(''); };
+    return `not the queued outbound message: \`message\` (${Buffer.byteLength(message)} bytes) differs from the queue (${Buffer.byteLength(queued.message)} bytes) at byte ${at}: sent ${JSON.stringify(tail(message))}, queued ${JSON.stringify(tail(queued.message))}`;
+  }
+  return null;
+}
+
+/** An inbound peer envelope or notice in the text Claude handed a relay (claude_relay.rs `parse_inbound_text`). */
+export function parseInbound(text) {
+  const trimmed = text.trimStart();
+  if (trimmed.startsWith(NATIVE_IDLE_NOTICE) || trimmed.startsWith(NATIVE_DELIVERY_NOTICE)) return { kind: 'notice', text: trimmed };
+  if (!trimmed.startsWith(NATIVE_PEER_PREAMBLE) && !trimmed.startsWith(NATIVE_PEER_OPENING)) return null;
+  const start = text.indexOf(NATIVE_PEER_OPENING);
+  if (start < 0) return null;
+  const headerEnd = text.indexOf('>\n', start);
+  if (headerEnd < 0) return null;
+  const header = text.slice(start + NATIVE_PEER_OPENING.length, headerEnd);
+  const bodyStart = headerEnd + 2;
+  // the body is not escaped by Claude: the closing tag is the last one
+  const bodyEnd = text.lastIndexOf(`\n${NATIVE_PEER_CLOSING}`);
+  if (bodyEnd < bodyStart) return null;
+  const attributes = {};
+  // each key="value" in turn, a later one of the same key in its place (claude_relay.rs `parse_attributes`)
+  for (let rest = header, equals; (equals = rest.indexOf('="')) >= 0;) {
+    const close = rest.indexOf('"', equals + 2);
+    if (close < 0) break;
+    attributes[rest.slice(0, equals).trim()] = rest.slice(equals + 2, close);
+    rest = rest.slice(close + 1);
+  }
+  if (!attributes.from) return null;
+  return { kind: 'peer', from: attributes.from, fromName: attributes['from-name'] ?? null, body: text.slice(bodyStart, bodyEnd) };
+}

package/mail/questions.mjs

@@ -0,0 +1,131 @@
+// Native Codex questions as mail (step 4c; mail_question.rs `poll`, deleted): every POLL_MS the daemon asks each Codex
+// pane it launched (its native-launches seed: a socket of its own, its owner alive) for the threads it runs and the
+// questions waiting on them, records each thread's creator (`native-questions/binding-<blake3(address)>.json`) and files
+// each question once (`<q-id>.json`) in the session's mailbox, read, and in its creator's, with a wake, so the carrier
+// hands it over (or carries it to the creator's machine). A reply is answered by mail/send.mjs; the files are the native
+// hook's (`message hook`) as well, so they are kept byte for byte as mail_question.rs writes them. Native request
+// identities decide which question a reply answers, never screen text or terminal keys.
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, writeSync } from 'node:fs';
+import { join } from 'node:path';
+import { blake3Hex } from './envelope.mjs';
+import { envelope as makeEnvelope, makeAddress } from './compose.mjs';
+
+const POLL_MS = 10_000;
+
+const readJson = (path) => { try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; } };
+const alive = (pid) => { if (!Number.isInteger(pid) || pid <= 0) return false; try { process.kill(pid, 0); return true; } catch (error) { return error.code === 'EPERM'; } };
+
+export class NativeQuestions {
+  /** `codexQuestions(request)` the in-process native question client (native-questions.mjs). */
+  constructor({ machine, mailRoot, store, codexQuestions, log = () => {} }) {
+    Object.assign(this, { machine, mailRoot, store, codexQuestions, log });
+    this.dir = join(mailRoot, 'native-questions');
+    this.running = false;
+  }
+
+  start() {
+    this.timer = setInterval(() => void this.poll(), POLL_MS);
+    this.timer.unref?.();
+    void this.poll();
+    return this;
+  }
+
+  stop() { clearInterval(this.timer); }
+
+  /** One pass over the launched Codex panes; a pass still running is not started twice. Answers how many panes were
+   *  asked and how many questions they hold, or null when a pass was already running. */
+  async poll() {
+    if (this.running) return null;
+    this.running = true;
+    const counted = { panes: 0, questions: 0 };
+    try {
+      let names = [];
+      try { names = readdirSync(join(this.mailRoot, 'native-launches')); } catch { return counted; }
+      for (const name of names) {
+        if (!name.endsWith('.json') || name.endsWith('.session.json')) continue;
+        const seedPath = join(this.mailRoot, 'native-launches', name);
+        const seed = readJson(seedPath);
+        // only a socket belonging to a launched pane whose owner lives: a retained socket file is not a live endpoint,
+        // and a global shared app-server or a cwd is never guessed at
+        if (seed?.kind !== 'codex' || typeof seed.socketPath !== 'string' || !alive(seed.ownerPid) || !existsSync(seed.socketPath)) continue;
+        let reply;
+        try { reply = await this.codexQuestions({ socketPath: seed.socketPath, discover: true }); } catch { continue; }
+        counted.panes++; counted.questions += reply?.questions?.length ?? 0;
+        for (const thread of reply?.threads ?? []) {
+          try { this.bind(seed, { session_id: thread.id, transcript_path: thread.path ?? null }); }
+          catch (error) { this.log(`native questions: the creator of ${thread.id} could not be recorded: ${error.message}`); }
+        }
+        for (const native of reply?.questions ?? []) {
+          try { this.file(this.bind(seed, { session_id: native.threadId }), native); }
+          catch (error) { this.log(`native questions: a question of ${native.threadId} could not be filed: ${error.message}`); }
+        }
+      }
+      return counted;
+    } finally { this.running = false; }
+  }
+
+  // ---- the files, as mail_question.rs writes them ------------------------------------------------------------------
+
+  #bindingPath(address) { return join(this.dir, `binding-${blake3Hex(address)}.json`); }
+
+  /** Written whole and synced, never over an existing file (mail_question.rs `create`). */
+  create(path, value) {
+    mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+    const fd = openSync(path, 'wx', 0o600);
+    try { writeSync(fd, JSON.stringify(value)); fsyncSync(fd); } finally { closeSync(fd); }
+  }
+
+  /** A session's binding: its creator recorded at its first launch, its pane, socket and transcript kept current. */
+  bind(seed, input, harness = 'codex') {
+    const session = makeAddress(this.machine, harness, String(input.session_id ?? ''));
+    if (!session) throw new Error('the thread has no session id');
+    const creator = typeof seed.by === 'string' ? seed.by : makeAddress(this.machine, 'operator', 'user');
+    const binding = { session, creator, pane: seed.pane ?? '', socket_path: seed.socketPath ?? null, transcript_path: input.transcript_path ?? null };
+    const path = this.#bindingPath(session);
+    try { this.create(path, binding); return binding; }
+    catch (error) { if (error.code !== 'EEXIST') throw error; }
+    const existing = readJson(path);
+    if (!existing) throw new Error(`its binding ${path} could not be read`);
+    if (existing.pane !== binding.pane || existing.socket_path !== binding.socket_path || (binding.transcript_path != null && existing.transcript_path !== binding.transcript_path)) {
+      existing.pane = binding.pane; existing.socket_path = binding.socket_path;
+      if (binding.transcript_path != null) existing.transcript_path = binding.transcript_path;
+      const staged = `${path.slice(0, -'.json'.length)}.${process.pid}.tmp`;
+      this.create(staged, existing);
+      renameSync(staged, path);
+    }
+    return existing;
+  }
+
+  /** A question's id, from its native identity (mail_question.rs `question_id`): each poll and hook finds the same one. */
+  idOf(session, native) {
+    return `q-${blake3Hex(JSON.stringify([session, native.threadId ?? null, native.turnId ?? null, native.itemId ?? null])).slice(0, 24)}`;
+  }
+
+  /** One question filed once. */
+  file(binding, native) {
+    const id = this.idOf(binding.session, native);
+    let body = '';
+    for (const question of native.questions ?? []) {
+      body += `${question.id ?? ''}: ${question.question ?? ''}\n`;
+      for (const option of question.options ?? []) body += `- ${option.label ?? ''}\n`;
+    }
+    body += '\nReply with the answer text for one question, or a JSON object mapping each question id to its answer for several questions.';
+    let question = { binding, native, envelope: makeEnvelope({ id, from: binding.session, from_name: binding.session, kind: 'question', reply_via: { mode: 'command' }, body }) };
+    try { this.create(join(this.dir, `${id}.json`), question); }
+    catch (error) { if (error.code !== 'EEXIST') throw error; question = readJson(join(this.dir, `${id}.json`)) ?? question; }
+    this.store.deliverRead(binding.session, question.envelope);
+    // its creator's copy, filed once with a wake: the carrier hands it over, here or on the creator's machine (whose
+    // copy kept here is the session's timeline's mirror, marked read once carried)
+    if (!this.store.findIn(binding.creator, id)) { this.store.deliver(binding.creator, question.envelope); this.store.requestWake(binding.creator, id); }
+  }
+
+  /** A reply the native harness used confirmed (mail_question.rs `confirm`): the reply read in the session's mailbox, and
+   *  when it was used recorded once (`<q-id>.delivered`, which a listing reads as its delivery). */
+  confirm(id, reply) {
+    const question = readJson(join(this.dir, `${id}.json`));
+    if (!question) throw new Error(`question ${id} is not on file`);
+    const found = reply?.envelope?.id ? this.store.findIn(question.binding.session, reply.envelope.id) : null;
+    if (found && found.state === 'unread') { try { this.store.markRead(question.binding.session, found.path); } catch { /* read meanwhile */ } }
+    try { this.create(join(this.dir, `${id}.delivered`), Date.now()); } catch (error) { if (error.code !== 'EEXIST') throw error; }
+  }
+}

package/mail/store.mjs

@@ -188,9 +188,6 @@ export class MailStore extends EventEmitter {
 
   // ---- writes, as mailbox.rs makes them --------------------------------------------------------------------------
 
-  /** The unread mail of `address` (not the user's own turns) moved into `claimed/` under its reader's pid (`pid`, the
-   *  reading process: a claim whose reader ends goes back to `new/`), each claim recorded; another reader that took one
-   *  first keeps it (mailbox.rs `claim_unread`). Oldest first. */
   /** Whether `claimUnread` would take anything now, taking nothing: abandoned claims given back first, as it does, then
    *  any envelope in new/ that is not a user's own turn (`message wait` wakes only for mail it can claim). From the
    *  mailbox's own folders, as claimUnread reads them. */
@@ -207,6 +204,9 @@ export class MailStore extends EventEmitter {
     });
   }
 
+  /** The unread mail of `address` (not the user's own turns) moved into `claimed/` under its reader's pid (`pid`, the
+   *  reading process: a claim whose reader ends goes back to `new/`), each claim recorded; another reader that took one
+   *  first keeps it (mailbox.rs `claim_unread`). Oldest first. */
   claimUnread(address, via, caller, pid = process.pid) {
     // the mailbox's own folders, read here (one named read): what decides a delivery never comes from the watch-fed
     // index alone, whose events a platform can drop (an FSEvents drop, an inotify overflow)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.117",
+  "version": "0.3.119",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",
@@ -70,7 +70,7 @@
     "@volter/supercode-health": "^0.1.0",
     "@volter/supercode-terminal": "^0.2.54",
     "@volter/supercode-trace": "^0.1.0",
-    "@volter/teams": "0.2.33",
+    "@volter/teams": "0.2.34",
     "@xterm/addon-serialize": "^0.14.0",
     "@xterm/headless": "^6.0.0",
     "protobufjs": "8.8.0",