@volter/supercode-teams 0.3.122 → 0.3.124

package/live-sessions.mjs

@@ -484,17 +484,19 @@ export class LiveSessions extends EventEmitter {
   #loadTools() {
     let kept = {};
     try { kept = JSON.parse(readFileSync(this.toolsFile, 'utf8')) ?? {}; } catch { /* none yet */ }
+    let legacy = false;
     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 });
+      legacy = true;
     } catch { /* none written before */ }
     for (const [session, server] of Object.entries(kept)) this.registerTools(Number(session), Number(server), { save: false });
-    this.#saveTools();
+    // the merged markers kept first; the old folder removed only once they are (a daemon ended between the two loses none)
+    if (this.#saveTools() && legacy) { try { rmSync(this.legacyMarkersDir, { recursive: true, force: true }); } catch { /* removed at the next start */ } }
   }
 
   #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}`); }
+    try { writeFileSync(`${this.toolsFile}.tmp`, JSON.stringify(Object.fromEntries(this.markers))); renameSync(`${this.toolsFile}.tmp`, this.toolsFile); return true; }
+    catch (error) { this.log(`live sessions: the messaging tools' markers were not kept: ${error.message}`); return false; }
   }
 
   /** A `message mcp` server says the session `session` has the messaging tools while it, `server`, runs: taken when the

package/machine.mjs

@@ -43,6 +43,8 @@ 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 { IdleNotices } from './mail/idle.mjs';
+import { AgentUpkeep } from './mail/upkeep.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.";
@@ -652,7 +654,6 @@ export class TeamsMachine extends MachineCore {
   async afterListen() {
     // Web apps on this machine reach it through the app door when the person has turned it on (app-door.mjs).
     this.appDoor = serveAppDoor({ home: this.home, open: () => { const [page, daemon] = inProcessPair(); void this.acceptLocal(daemon, { appDoor: true }); return page; }, log: (row) => this.log.append({ principal: 'app-door', cap: 'app-door', target: row.origin ?? '*', outcome: row.outcome, detail: row.detail }) });
-    this.#startMailWatch();
     this.#startHealth();
     this.#startLive();
     this.#startMail();
@@ -792,7 +793,8 @@ 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
+    // native questions' files (bindings, questions, replies) as mail_question.rs keeps them, for the question hook and
+    // the poll (started below)
     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
@@ -811,6 +813,18 @@ export class TeamsMachine extends MachineCore {
       handOver: (address, id) => this.mailSend.handOver(address, id),
       typeTurn, askMachine: (to, request) => this.#askMailDoor(to, request, MAIL_SEND_MS),
       log: (line) => this.emit('mail-log', line) }).start();
+    // idle notices and final replies (step 4c): each subscribed session's activity followed through harness serve
+    this.idleNotices = new IdleNotices({ machine, store: this.mailStore, live,
+      serveRequest: (method, params, ms) => this.#serveRequest(method, params, ms),
+      locatorOf: (address) => this.sessionDescriptors?.get(address)?.locator ?? null,
+      log: (line) => this.emit('mail-log', line) }).start();
+    // native Codex questions as mail (step 4c): the poll of each launched Codex pane's own app-server, in process
+    this.nativeQuestions.start();
+    // an agent's upkeep (step 4d): folder sessions become threads, typed lines reach their CC, idle launched threads end
+    this.agentUpkeep = new AgentUpkeep({ machine, mailRoot, store: this.mailStore, agents: this.agents, live,
+      claudeProjects: () => [...live.claudeDirs.keys()].map((dir) => join(dirname(dir), 'projects')),
+      lastMessageAt: (address) => this.sessionDescriptors?.get(address)?.updated_at_ms ?? null,
+      program: this.supercodeBin, env: this.env, log: (line) => this.emit('mail-log', line) }).start();
     // the user's own turns that wait in a pane session's mailbox (a draft in its composer when they came) are typed once
     // its composer is free: tried at each change of its mailbox, and every 2 s while one waits (mail_watch.rs
     // `deliver_waiting_user_turns` read every pane's mailbox every 2 s)
@@ -974,6 +988,7 @@ export class TeamsMachine extends MachineCore {
         noteIndexParts(params.failed, params.error?.message ?? null);
         both();
       } else if (params.subscription && params.subscription === this.recordsActivity) both();
+      else this.idleNotices?.notified(params);
     });
     let indexBackoff = 0;
     const subscribe = () => this.#serveRequest('harness.v1.sessions.index.subscribe', { harnesses: HARNESSES, limit: 0 }, 60_000)
@@ -992,6 +1007,7 @@ export class TeamsMachine extends MachineCore {
     void subscribe();
     // the harness service ended: its subscriptions went with it, said at once, and made again when it is back
     this.on('serve-exit', () => {
+      this.idleNotices?.serveExited();
       if (this.recordsStopped) return;
       this.recordsIndex = null; this.recordsActivity = null; this.recordsActivityFor = null;
       producer.note('sessions_index', 'the harness service exited; its session index subscription is made again when it is back');
@@ -1137,11 +1153,12 @@ export class TeamsMachine extends MachineCore {
     for (const child of this.voiceProcesses.values()) child.kill('SIGTERM');
     this.voiceProcesses.clear();
     this.jobs?.stopAll();
-    this.stoppingMailWatch = true;
-    this.mailWatch?.kill('SIGTERM');
     void this.relayEndpoint?.then((endpoint) => endpoint?.close()).catch(() => {});
     this.carrier?.stop();
     clearInterval(this.hookSpoolTimer);
+    this.idleNotices?.stop();
+    this.agentUpkeep?.stop();
+    this.nativeQuestions?.stop();
     clearInterval(this.turnsSweep);
     this.stoppingServe = true;
     clearTimeout(this.serveRestart);
@@ -1225,23 +1242,6 @@ export class TeamsMachine extends MachineCore {
     try { stdin.write(line); return true; } catch { return false; }
   }
 
-  // Idle notices for every session on this machine (`supercode message watch`):
-  // it settles `--notify-when-idle` subscriptions from session activity. It
-  // lives beside `harness serve` and is restarted if it exits, so a
-  // subscription made at any time has a watcher.
-  #startMailWatch() {
-    if (this.stoppingMailWatch) return;
-    const child = spawn(this.supercodeBin, ['message', 'watch'], { stdio: ['ignore', 'ignore', 'pipe'], env: this.env });
-    child.stderr.setEncoding('utf8');
-    child.stderr.on('data', (text) => this.emit('mail-watch-stderr', text));
-    child.on('error', (error) => this.emit('mail-watch-stderr', error.message));
-    child.on('exit', () => {
-      if (this.mailWatch !== child || this.stoppingMailWatch) return;
-      setTimeout(() => this.#startMailWatch(), 5000).unref();
-    });
-    this.mailWatch = child;
-  }
-
   /** One `harness.v1` request of the daemon's own, to its `harness serve`: the
    *  connection id INTERNAL_CONNECTION marks the answer as ours. */
   #serveRequest(method, params, timeoutMs = 3000) {
@@ -1830,6 +1830,18 @@ 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.
    */
+  /** Which home holds each board address here (`<SUPERCODE_HOME>/board-homes.json`): the first home whose round read it. */
+  #boardHomes() {
+    this.boardHomesHeld ??= (() => { try { return JSON.parse(readFileSync(join(supercodeHome(this.env), 'board-homes.json'), 'utf8')) ?? {}; } catch { return {}; } })();
+    return this.boardHomesHeld;
+  }
+
+  #saveBoardHomes(held) {
+    const path = join(supercodeHome(this.env), 'board-homes.json');
+    try { writeFileSync(`${path}.tmp`, JSON.stringify(held, null, 2)); renameSync(`${path}.tmp`, path); }
+    catch (error) { this.emit('mail-log', `board homes: not kept: ${error.message}`); }
+  }
+
   /** 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) {
@@ -3708,6 +3720,14 @@ export class TeamsMachine extends MachineCore {
         act('mail.send', to, answer.code === 0 ? 'ok' : 'failed');
         return answer;
       }
+      // `message questions`: one pass of the native question poll now (step 4c), this machine's own processes only
+      case 'harness.v1.mail.questions': {
+        if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('native questions are refreshed here by this machine\'s own processes'), { code: 403 });
+        const counted = await this.nativeQuestions.poll();
+        return counted
+          ? { code: 0, text: `Asked ${counted.panes} launched Codex pane${counted.panes === 1 ? '' : 's'}: ${counted.questions} question${counted.questions === 1 ? '' : 's'} waiting, each filed once in its creator's mailbox.`, ...counted }
+          : { code: 0, text: 'A pass of the native question poll is running now; its questions are filed as it finds them.' };
+      }
       // An agent's verbs (docs/architecture/overview.md, 3b-2): `message thread`, `threads`, `delegate`, and `supercode
       // agent declare|show`, this machine's own processes only; a delegation and a thread list without --agent are the
       // caller's, as its claim names it.
@@ -3914,6 +3934,17 @@ export class TeamsMachine extends MachineCore {
           }
         }
         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)' };
+        // two homes whose folders are named alike name the same board address, and so share one mailbox: the home that
+        // first read it holds it (kept beside this daemon's state), and another home's round is refused, never handed the
+        // first one's answers
+        const home = typeof params.root === 'string' && params.root ? params.root : null;
+        if (home) {
+          const held = this.#boardHomes();
+          let real = home; try { real = realpathSync(home); } catch { /* as named */ }
+          const holder = held[caller];
+          if (holder && holder !== real && existsSync(holder)) return { code: 2, text: `${caller} is the board address of the home ${holder} as well as of ${real}: two homes named alike share one address and one mailbox. This round reads nothing; rename one home's folder (its board address follows it).` };
+          if (holder !== real) { held[caller] = real; this.#saveBoardHomes(held); }
+        }
         this.boardClaims ??= new Map();
         if (method === 'harness.v1.mail.board_ack') {
           const pending = this.boardClaims.get(params.token);

package/mail/agents.mjs

@@ -21,7 +21,7 @@ const validName = (name) => typeof name === 'string' && /^[A-Za-z0-9._-]+$/.test
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 /** A record written whole and renamed into place (mail_agent.rs `write_atomically`). */
-function writeAtomically(path, text) {
+export function writeAtomically(path, text) {
   mkdirSync(join(path, '..'), { recursive: true });
   const temporary = `${path.replace(/\.[^./]*$/, '')}.tmp.${process.pid}`;
   writeFileSync(temporary, text);

package/mail/idle.mjs

@@ -0,0 +1,243 @@
+// Idle notices and final replies (step 4c; mail_watch.rs `IdleWatcher`, deleted): a sender that asked for
+// `--notify-when-idle` gets one notice when its receiver is seen working after the message and then idle, one when the
+// receiver ends, or one saying the subscription expired after SUBSCRIPTION_LIFETIME_MS; a sender whose message went in
+// `reply-via=final-message` to a runtime supercode hosts gets the runtime's answer as its reply, or a notice that none
+// came. The native watch read every subscribed session's activity every two seconds; here the daemon follows only the
+// subscribed sessions' activity (harness serve's `sessions.activity` subscription: its first answer, then each change),
+// asks a hosted runtime with a final reply waiting for its turn every RUNTIME_POLL_MS (as the native watch did), and
+// settles what no event names (an expiry, a change it missed) once per SWEEP_MS.
+//
+// A notice or a reply is filed in its subscriber's mailbox with a wake, so the carrier (mail/carrier.mjs) hands it to
+// the subscriber's door, or carries it to the subscriber's machine, with its retries and its records: one delivery path
+// for all mail.
+import { FrontendClient } from '@volter/supercode-frontend';
+import { envelope as makeEnvelope, newMessageId, parseAddress } from './compose.mjs';
+
+export const SUBSCRIPTION_LIFETIME_MS = 24 * 60 * 60_000;
+const RUNTIME_POLL_MS = 2_000;
+const SWEEP_MS = 60_000;
+const MAX_FOLLOWED = 2048;
+
+const textOf = (content) => typeof content === 'string' ? content
+  : Array.isArray(content) ? content.map((part) => typeof part === 'string' ? part : part?.text ?? '').join('') : '';
+
+export class IdleNotices {
+  /**
+   * `store` the mail store; `live` the live-session map; `serveRequest(method, params, ms)` one request to harness serve;
+   * `locatorOf(address)` the session index's locator for a session here, when it has one; `log(line)`.
+   */
+  constructor({ machine, store, live, serveRequest, locatorOf, log = () => {} }) {
+    Object.assign(this, { machine, store, live, serveRequest, locatorOf, log });
+    this.targets = new Set(); // addresses here with a subscription on them
+    this.activity = new Map(); // address → { turn, presence } as serve last reported it
+    this.subscription = null; this.followed = '';
+    this.polling = new Set(); // hosted runtimes asked for their turn
+    this.settling = new Set(); // addresses being settled now
+  }
+
+  start() {
+    this.store.on('subscriptions', (address) => this.#track(address));
+    for (const address of this.store.addresses()) this.#track(address);
+    this.sweeper = setInterval(() => { for (const address of this.targets) void this.#settle(address); }, SWEEP_MS);
+    this.sweeper.unref?.();
+    return this;
+  }
+
+  stop() { clearInterval(this.sweeper); clearInterval(this.runtimeTimer); this.#unfollow(); }
+
+  /** Serve's activity notification for this subscription: each changed session settled. */
+  notified(params) {
+    if (!params?.subscription || params.subscription !== this.subscription) return false;
+    for (const activity of params.activities ?? []) this.#seen(activity);
+    return true;
+  }
+
+  /** Serve ended: its subscription went with it, made again on the next change or sweep. */
+  serveExited() { this.subscription = null; this.followed = ''; this.#follow(); }
+
+  #track(address) {
+    const parsed = parseAddress(address);
+    if (!parsed || parsed.machine !== this.machine) return;
+    const has = this.store.subscriptions(address).length > 0;
+    if (has === this.targets.has(address)) { if (has) void this.#settle(address); return; }
+    if (has) this.targets.add(address); else { this.targets.delete(address); this.activity.delete(address); }
+    this.#follow();
+    if (has) void this.#settle(address);
+  }
+
+  #seen(activity) {
+    const address = `sc:${this.machine}:${activity.harness}:${activity.session_id}`;
+    if (!this.targets.has(address)) return;
+    this.activity.set(address, { turn: activity.turn, presence: activity.presence });
+    void this.#settle(address);
+  }
+
+  // ---- following ---------------------------------------------------------------------------------------------------
+
+  /** The subscribed sessions' activity followed (one subscription for all of them, made again when the set changes). */
+  async #follow() {
+    const locators = [];
+    for (const address of this.targets) {
+      if (this.#runtime(address)) continue; // a hosted runtime is asked itself
+      const { harness, session } = parseAddress(address);
+      locators.push(this.locatorOf(address) ?? { harness, session_id: session, storage: { kind: 'file', path: '' } });
+    }
+    const fingerprint = locators.map((locator) => `${locator.harness}:${locator.session_id}`).sort().join('\n');
+    if (fingerprint === this.followed && (this.subscription || !locators.length)) { this.#pollRuntimes(); return; }
+    this.followed = fingerprint;
+    const previous = this.subscription;
+    this.subscription = null;
+    if (locators.length) {
+      try {
+        const answer = await this.serveRequest('harness.v1.sessions.activity.subscribe', { locators: locators.slice(0, MAX_FOLLOWED) }, 30_000);
+        if (this.followed !== fingerprint) { if (answer?.subscription) void this.serveRequest('harness.v1.sessions.activity.unsubscribe', { subscription: answer.subscription }, 30_000).catch(() => {}); return; }
+        this.subscription = answer?.subscription ?? null;
+        if (locators.length > MAX_FOLLOWED) this.log(`idle notices: ${locators.length - MAX_FOLLOWED} subscribed sessions are not followed (at most ${MAX_FOLLOWED}); they settle on expiry`);
+        for (const activity of answer?.initial ?? []) this.#seen(activity);
+      } catch (error) {
+        this.followed = ''; // tried again at the next change or sweep
+        this.log(`idle notices: the subscribed sessions' activity could not be followed: ${error.message}`);
+      }
+    }
+    if (previous) void this.serveRequest('harness.v1.sessions.activity.unsubscribe', { subscription: previous }, 30_000).catch(() => {});
+    this.#pollRuntimes();
+  }
+
+  #unfollow() {
+    if (this.subscription) void this.serveRequest('harness.v1.sessions.activity.unsubscribe', { subscription: this.subscription }, 30_000).catch(() => {});
+    this.subscription = null; this.followed = '';
+  }
+
+  /** The hosted runtimes with a final reply waiting, asked for their turn every RUNTIME_POLL_MS while one waits. */
+  #pollRuntimes() {
+    const waiting = [...this.targets].filter((address) => this.#runtime(address) && this.store.subscriptions(address).some((item) => item.final_reply));
+    this.polling = new Set(waiting);
+    if (!waiting.length) { clearInterval(this.runtimeTimer); this.runtimeTimer = null; return; }
+    if (this.runtimeTimer) return;
+    this.runtimeTimer = setInterval(() => {
+      if (!this.polling.size) { clearInterval(this.runtimeTimer); this.runtimeTimer = null; return; }
+      for (const address of this.polling) void this.#settle(address);
+    }, RUNTIME_POLL_MS);
+    this.runtimeTimer.unref?.();
+  }
+
+  #runtime(address) {
+    const { harness, session } = parseAddress(address);
+    return this.live.runtimeReceipt(harness, session);
+  }
+
+  // ---- settling ------------------------------------------------------------------------------------------------------
+
+  /** One pass over one receiver's subscriptions (mail_watch.rs `tick`, for one mailbox). */
+  async #settle(address) {
+    if (this.settling.has(address)) return;
+    this.settling.add(address);
+    try {
+      const subscriptions = this.store.subscriptions(address);
+      if (!subscriptions.length) { this.#track(address); return; }
+      let working = false, idle = false, ended = false;
+      const receipt = this.#runtime(address);
+      if (subscriptions.some((item) => item.final_reply)) {
+        // a runtime supercode hosts reports its own turn
+        if (!receipt) ended = true;
+        else {
+          try {
+            const client = new FrontendClient({ baseUrl: receipt.base_url, token: receipt.token, clientId: `mail-${receipt.receipt_id}`, permissions: ['observe'] });
+            const turn = (await client.describe())?.turn_state;
+            working = turn === 'busy'; idle = turn === 'idle';
+          } catch { /* not answering: nothing settles on it */ }
+        }
+      } else {
+        const seen = this.activity.get(address);
+        if (seen) { working = seen.turn === 'working'; idle = seen.turn === 'idle'; ended = seen.presence === 'persisted'; }
+      }
+      // one turn settles every message a sender subscribed with; the sender hears it once, about its latest message,
+      // and its earlier subscriptions settle with it silently
+      subscriptions.sort((a, b) => (b.created_at_ms ?? 0) - (a.created_at_ms ?? 0));
+      const told = new Set();
+      const now = Date.now();
+      for (const subscription of subscriptions) {
+        const expired = now - (subscription.created_at_ms ?? now) > SUBSCRIPTION_LIFETIME_MS;
+        // a reply is the runtime's answer to this message: it settles once the runtime is idle and has answered,
+        // however fast the turn was
+        if (subscription.final_reply && !ended && !expired) {
+          const answer = receipt && idle ? await this.#answerTo(address, receipt, subscription.message_id) : null;
+          if (answer && this.store.removeSubscription(address, subscription.message_id)) {
+            this.#reply(address, subscription, answer);
+            if (subscription.notice !== false) this.#notice(address, subscription, 'idle');
+          }
+          continue;
+        }
+        const settled = ended ? 'ended' : expired ? 'expired' : idle && subscription.seen_working ? 'idle' : null;
+        if (settled) {
+          if (!this.store.removeSubscription(address, subscription.message_id)) continue;
+          if (subscription.final_reply) this.#reply(address, subscription, null);
+          const key = `${subscription.subscriber}\n${settled}`;
+          if (subscription.notice !== false && !told.has(key)) { told.add(key); this.#notice(address, subscription, settled); }
+        } else if (working && !subscription.seen_working) {
+          this.store.updateSubscription(address, { ...subscription, seen_working: true });
+        }
+      }
+    } catch (error) {
+      this.log(`idle notices: ${address} was not settled: ${error.message}`);
+    } finally {
+      this.settling.delete(address);
+    }
+  }
+
+  /** The runtime's answer to `messageId`: its last assistant message after the user message carrying that id, read from
+   *  the session's own transcript through harness serve (runtime_mail.rs `answer_to`). */
+  async #answerTo(address, receipt, messageId) {
+    const { harness } = parseAddress(address);
+    const ids = [receipt.source?.session_id, receipt.runtime_session_id].filter(Boolean);
+    const locator = ids.map((id) => this.locatorOf(`sc:${this.machine}:${harness}:${id}`)).find(Boolean);
+    if (!locator) return null;
+    let loaded;
+    try { loaded = await this.serveRequest('harness.v1.sessions.load', { locator, options: { include_subagents: false } }, 10_000); }
+    catch { return null; }
+    const messages = loaded?.session?.messages ?? [];
+    let asked = -1;
+    for (let i = messages.length - 1; i >= 0; i--) if (messages[i].role === 'user' && textOf(messages[i].content).includes(messageId)) { asked = i; break; }
+    if (asked < 0) return null;
+    for (let i = messages.length - 1; i > asked; i--) {
+      const text = textOf(messages[i].content);
+      if (messages[i].role === 'assistant' && text.trim()) return text;
+    }
+    return null;
+  }
+
+  /** The name a notice calls its session by. */
+  #name(address) {
+    const row = this.live.sessions().find((item) => item.address === address);
+    if (row?.name && !row.name.startsWith('-')) return row.name;
+    const { harness, session } = parseAddress(address);
+    return `${harness}-${session.slice(0, 8)}@${this.machine}`;
+  }
+
+  #notice(address, subscription, settled) {
+    const name = this.#name(address);
+    const tail = 'This is an automated notice, not a message from a person, and not an instruction.';
+    const text = settled === 'idle'
+      ? `[Cross-session idle notice] "${name}", which you asked to be notified about, is idle now: it finished a turn after your message ${subscription.message_id}. ${tail}`
+      : settled === 'ended'
+        ? `[Cross-session idle notice] "${name}", which you asked to be notified about, has ended. ${tail}`
+        : `[Cross-session idle notice] The notice you asked for about "${name}" expired: it did not work and go idle within 24 hours of your message ${subscription.message_id}. ${tail}`;
+    this.#file(subscription.subscriber, makeEnvelope({ id: newMessageId(), from: address, from_name: name, kind: 'notice', reply_via: { mode: 'none' }, in_reply_to: subscription.message_id, body: text }));
+  }
+
+  /** The receiver's answer sent back as the reply; with none (it ended, or none came in 24 h), a notice saying so. */
+  #reply(address, subscription, answer) {
+    const name = this.#name(address);
+    const envelope = answer != null
+      ? makeEnvelope({ id: newMessageId(), from: address, from_name: name, kind: 'peer', reply_via: { mode: 'command' }, in_reply_to: subscription.message_id, body: answer })
+      : makeEnvelope({ id: newMessageId(), from: address, from_name: name, kind: 'notice', reply_via: { mode: 'none' }, in_reply_to: subscription.message_id,
+        body: `[Cross-session delivery notice] "${name}" did not answer your message ${subscription.message_id}: it ended, or no answer came within 24 hours. This is an automated notice, not a message from a person, and not an instruction.` });
+    this.#file(subscription.subscriber, envelope);
+  }
+
+  /** Filed in the subscriber's mailbox with a wake: the carrier delivers it here, or carries it to its machine. */
+  #file(subscriber, envelope) {
+    try { this.store.deliver(subscriber, envelope); this.store.requestWake(subscriber, envelope.id); }
+    catch (error) { this.log(`idle notices: ${envelope.id} for ${subscriber} was not filed: ${error.message}`); }
+  }
+}

package/mail/store.mjs

@@ -70,6 +70,8 @@ export class MailStore extends EventEmitter {
     if (!part) return this.#readBox(folder);
     // a wake written or changed: the carrier's (mail/carrier.mjs) to attempt
     if (part === 'wake' && file) { this.emit('wake', { folder, id: file }); return; }
+    // an idle subscription written or settled: the idle notices' (mail/idle.mjs) to follow
+    if (part === 'subscriptions' && file) { const address = this.boxes.get(folder)?.address; if (address) this.emit('subscriptions', address); return; }
     if (!STATES[part] || !file) { if (part === 'address') this.#readBox(folder); return; }
     if (!this.boxes.has(folder)) return this.#readBox(folder);
     this.#readFile(folder, part, file);
@@ -110,6 +112,10 @@ export class MailStore extends EventEmitter {
     let wakes = [];
     try { wakes = readdirSync(join(box.dir, 'wake')); } catch { /* none */ }
     for (const id of wakes) this.emit('wake', { folder, id });
+    // and its idle subscriptions, likewise
+    let subscribed = [];
+    try { subscribed = readdirSync(join(box.dir, 'subscriptions')).filter((name) => name.endsWith('.json')); } catch { /* none */ }
+    if (subscribed.length) this.emit('subscriptions', address);
   }
 
   /** One envelope file read again on its event: held while it is there, let go once it is gone. */
@@ -461,6 +467,35 @@ export class MailStore extends EventEmitter {
 
   /** One sender's wish to hear when the receiver next ends a turn (mailbox.rs `subscribe_idle`); the native watch settles it
    *  until it moves into the daemon (step 4). */
+  /** The idle subscriptions on `address` (mailbox.rs `subscriptions`): each sender that asked for a notice, or for the
+   *  receiver's final message as its reply, about one message. */
+  subscriptions(address) {
+    const box = this.boxOf(address) ?? this.#named(address);
+    if (!box) return [];
+    let names = [];
+    try { names = readdirSync(join(box.dir, 'subscriptions')); } catch { return []; }
+    return names.filter((name) => name.endsWith('.json')).map((name) => readEnvelope(join(box.dir, 'subscriptions', name))).filter((item) => item && typeof item.message_id === 'string');
+  }
+
+  /** A subscription settled (mailbox.rs `remove_subscription`): true for the one caller that removed it, so its notice is
+   *  sent once whoever else settles it at the same time. */
+  removeSubscription(address, messageId) {
+    const box = this.boxOf(address) ?? this.#named(address);
+    if (!box || !/^[A-Za-z0-9_-]+$/.test(messageId)) return false;
+    try { unlinkSync(join(box.dir, 'subscriptions', `${messageId}.json`)); return true; } catch { return false; }
+  }
+
+  /** A subscription kept with what it has seen (its receiver seen working after the message). */
+  updateSubscription(address, subscription) {
+    const box = this.boxOf(address) ?? this.#named(address);
+    if (!box || !/^[A-Za-z0-9_-]+$/.test(subscription.message_id)) return;
+    const dir = join(box.dir, 'subscriptions');
+    if (!existsSync(join(dir, `${subscription.message_id}.json`))) return; // settled meanwhile
+    const temporary = join(dir, `.${subscription.message_id}.tmp`);
+    writeFileSync(temporary, JSON.stringify(subscription));
+    renameSync(temporary, join(dir, `${subscription.message_id}.json`));
+  }
+
   subscribeIdle(address, subscription) {
     const box = this.open(address);
     const dir = join(box.dir, 'subscriptions');

package/mail/transcript.mjs

@@ -12,7 +12,7 @@ import { blake3Hex } from './envelope.mjs';
 const YIELD_LINES = 2000;
 const yieldTurn = () => new Promise((resolve) => setImmediate(resolve));
 
-const TYPED_ID_PREFIX = 'u-';
+export const TYPED_ID_PREFIX = 'u-';
 const CHANNEL_ID_PREFIX = 'c-';
 const ANSWER_ID_PREFIX = 'a-';
 

package/mail/upkeep.mjs

@@ -0,0 +1,143 @@
+// An agent's upkeep (step 4d; mail_agent.rs `register_folder_sessions`, `copy_typed_lines`, `close_idle_threads`, which
+// the native `message watch` ran every ten seconds, deleted with it):
+// - a session started directly in an agent's folder becomes one of its threads (decision 9);
+// - each line a person typed into an agent's session is copied, from no one (D195), to whoever is CC on it: a delegated
+//   thread's holder's lines to its CC participants (decision 11), every agent session's lines to the owner's account
+//   manager (decision 17), filed unread and not woken;
+// - a thread session the mailbox launched that has been idle past its agent's `idle_minutes` is ended (`supercode
+//   close`); its transcript stays, and the next reply in its thread resumes it.
+// The first and the last follow the live map's changes; the copying passes every TYPED_EVERY_MS while any agent is
+// declared, reading only a transcript written since its cursor.
+import { spawn } from 'node:child_process';
+import { readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { blake3Hex } from './envelope.mjs';
+import { envelope as makeEnvelope, makeAddress } from './compose.mjs';
+import { TYPED_ID_PREFIX, readClaude, transcriptPath, typedLineId } from './transcript.mjs';
+import { writeAtomically } from './agents.mjs';
+
+const SESSION_THREAD_PREFIX = 's-';
+const TYPED_EVERY_MS = 10_000;
+
+export class AgentUpkeep {
+  /** `agents` the agents' records; `live` the live-session map; `lastMessageAt(address)` when a session last spoke (its
+   *  index row); `program` the supercode a session is ended with. */
+  constructor({ machine, mailRoot, store, agents, live, claudeProjects, lastMessageAt, program, env, log = () => {} }) {
+    Object.assign(this, { machine, mailRoot, store, agents, live, claudeProjects, lastMessageAt, program, env, log });
+    this.typedDir = join(mailRoot, 'agents', 'typed');
+    this.running = new Set();
+  }
+
+  start() {
+    let pending = null;
+    this.live.on('changed', () => {
+      if (pending) return;
+      pending = setTimeout(() => { pending = null; void this.#once('sessions', () => this.registerFolderSessions().then(() => this.closeIdleThreads())); }, 1000);
+      pending.unref?.();
+    });
+    this.timer = setInterval(() => void this.#once('typed', () => this.copyTypedLines()), TYPED_EVERY_MS);
+    this.timer.unref?.();
+    // an idle thread's bound passes with no change to the map: checked once a minute as well
+    this.idleTimer = setInterval(() => void this.#once('sessions', () => this.closeIdleThreads()), 60_000);
+    this.idleTimer.unref?.();
+    return this;
+  }
+
+  stop() { clearInterval(this.timer); clearInterval(this.idleTimer); }
+
+  async #once(key, work) {
+    if (this.running.has(key)) return;
+    this.running.add(key);
+    try { await work(); } catch (error) { this.log(`agent upkeep: ${key}: ${error.message}`); } finally { this.running.delete(key); }
+  }
+
+  /** A session started directly in an agent's folder, not its main session and holding no thread yet, becomes a thread
+   *  of that agent: it holds it (To), the agent's main session is CC. */
+  async registerFolderSessions() {
+    const agents = this.agents.all().filter((agent) => agent.folder);
+    if (!agents.length) return;
+    const holders = new Set(this.agents.threads().map((thread) => thread.holder));
+    for (const session of this.live.sessions()) {
+      if (!session.cwd) continue;
+      const agent = agents.find((item) => item.folder === session.cwd && item.main_session !== session.address);
+      if (!agent || holders.has(session.address)) continue;
+      const id = `${SESSION_THREAD_PREFIX}${session.address.split(':').slice(3).join(':')}`;
+      await this.agents.update(id, () => ({ id, agent: agent.name, holder: session.address,
+        participants: [{ address: session.address, role: 'to' }, { address: agent.main_session, role: 'cc' }],
+        markers: {}, surface: null, created_at_ms: Date.now(), holder_launched: false, parent: null }), () => {});
+      holders.add(session.address);
+    }
+  }
+
+  #cursorPath(address) { return join(this.typedDir, blake3Hex(address).slice(0, 24)); }
+
+  /** Each line typed into an agent's session since the last pass, copied to who is CC on it; a session seen the first
+   *  time starts from now, so its history is not copied. */
+  async copyTypedLines() {
+    const agents = this.agents.all();
+    if (!agents.length) return;
+    const threads = this.agents.threads();
+    const accountManager = this.agents.ownersAccountManager();
+    const sessions = agents.map((agent) => [agent.main_session, agent.name]);
+    for (const thread of threads) if (!sessions.some(([address]) => address === thread.holder)) sessions.push([thread.holder, thread.agent]);
+    const now = Date.now();
+    for (const [session, agentName] of sessions) {
+      const cursorPath = this.#cursorPath(session);
+      let cursor = null;
+      try { cursor = Number(readFileSync(cursorPath, 'utf8').trim()); } catch { /* first seen */ }
+      if (!Number.isFinite(cursor)) { writeAtomically(cursorPath, String(now)); continue; }
+      // a transcript not written since the last pass has no new line
+      const path = transcriptPath(session, { claudeProjects: this.claudeProjects(), mailRoot: this.mailRoot });
+      if (path) { try { if (statSync(path).mtimeMs <= cursor) continue; } catch { /* not there: nothing new */ } }
+      // a Claude session's lines are read from its transcript; a Codex session's were filed in its mailbox by its hook
+      let lines;
+      if (session.split(':')[2] === 'codex') {
+        lines = this.store.inventory(session).stored
+          .filter((item) => item.envelope.kind === 'user' && item.envelope.id.startsWith(TYPED_ID_PREFIX) && item.envelope.created_at_ms > cursor)
+          .map((item) => { const whole = this.store.body(item); return [item.envelope.created_at_ms, whole?.body ?? '']; });
+      } else {
+        if (!path) continue;
+        const mail = await readClaude(path).catch(() => null);
+        if (!mail) continue;
+        lines = mail.typed.filter((line) => !line.withdrawn && line.sent_at_ms > cursor).map((line) => [line.sent_at_ms, line.text]);
+      }
+      if (!lines.length) continue;
+      const newest = Math.max(...lines.map(([at]) => at));
+      // the newest thread this session holds as a delegate (its agent's main session is another: mail_agent.rs `delegated`)
+      const held = [...threads].reverse().find((thread) => thread.holder === session && this.agents.load(thread.agent)?.main_session !== thread.holder);
+      const receivers = held ? held.participants.filter((p) => p.role === 'cc' && p.address !== session).map((p) => p.address) : [];
+      if (accountManager && agentName !== accountManager.name && !receivers.includes(accountManager.main_session)) receivers.push(accountManager.main_session);
+      const from = makeAddress(session.split(':')[1], 'operator', 'typed');
+      for (const [sentAt, text] of lines) {
+        const copy = makeEnvelope({ id: typedLineId(session, sentAt, text), created_at_ms: sentAt, from, from_name: `typed into ${session} (unattributed)`,
+          kind: 'typed', reply_via: { mode: 'none' }, thread: held?.id ?? null, body: text });
+        // a copy that cannot be filed is said, never dropped in silence
+        for (const receiver of receivers) { try { this.store.deliver(receiver, copy); } catch (error) { this.log(`agent upkeep: the line typed into ${session} was not copied to ${receiver}: ${error.message}`); } }
+      }
+      writeAtomically(cursorPath, String(newest));
+    }
+  }
+
+  /** A thread session the mailbox launched, idle past its agent's `idle_minutes` since its last message (or its last
+   *  resumption), ended through `supercode close`. */
+  async closeIdleThreads() {
+    const launched = this.agents.threads().filter((thread) => thread.holder_launched)
+      .map((thread) => [thread, this.agents.load(thread.agent)?.idle_minutes]).filter(([, minutes]) => Number.isFinite(minutes));
+    if (!launched.length) return;
+    const live = this.live.sessions();
+    const now = Date.now();
+    for (const [thread, minutes] of launched) {
+      const session = live.find((row) => row.address === thread.holder);
+      if (!session || session.status !== 'idle') continue;
+      const last = this.lastMessageAt(thread.holder);
+      if (!Number.isFinite(last)) continue;
+      let resumed = 0;
+      try { resumed = Number(readFileSync(join(this.mailRoot, 'agents', 'resumed', blake3Hex(thread.holder).slice(0, 24)), 'utf8').trim()) || 0; } catch { /* never resumed */ }
+      if (now - Math.max(last, resumed) < minutes * 60_000) continue;
+      await new Promise((done) => {
+        const child = spawn(this.program, ['close', thread.holder], { env: this.env, stdio: 'ignore' });
+        child.on('exit', done); child.on('error', (error) => { this.log(`agent upkeep: ${thread.holder} was not closed: ${error.message}`); done(); });
+      });
+    }
+  }
+}

package/package.json

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

package/worker/index.mjs

@@ -143,15 +143,42 @@ export class TeamsServer extends DurableObject {
   }
 }
 
+/** What the Durable Object's runtime said of a failed call (its error's own flags), for the log and the answer. */
+const objectFailure = (error) => ({
+  name: String(error?.name ?? 'Error'),
+  message: String(error?.message ?? error).slice(0, 200),
+  retryable: error?.retryable === true,
+  overloaded: error?.overloaded === true,
+  remote: error?.remote === true,
+  reset: error?.durableObjectReset === true,
+});
+
 export default {
   async fetch(request, env) {
-    try { return await env.TEAMS_SERVER.get(env.TEAMS_SERVER.idFromName('server')).fetch(request); }
+    const repeatable = request.method === 'GET' || request.method === 'HEAD';
+    const call = () => env.TEAMS_SERVER.get(env.TEAMS_SERVER.idFromName('server')).fetch(repeatable ? request.clone() : request);
+    // A request safe to repeat (a read, or a link's WebSocket upgrade: every machine's connection) is tried once more
+    // when the runtime says the failure is retryable and the object is not overloaded: a reset object (its code
+    // updated, or evicted and restarted) answers the second call. Fleet-wide 503s for minutes with no deploy behind
+    // them (2026-10-06, 14:04Z and 18:41-18:44Z) dropped every machine's link; what the runtime said of them was only
+    // in the log, which now says it in one JSON line and the answer names it.
+    let first = null;
+    try { return await call(); }
     catch (error) {
-      // Failures before the HTTP handler (object initialization, migrations or
-      // storage) otherwise become a platform HTML page, not our API contract.
-      const requestId = crypto.randomUUID();
-      console.error(`Teams request ${requestId} failed before response: ${error.message}`);
-      return Response.json({ version: 1, error: { code: 'unavailable', message: 'Teams server is temporarily unavailable', request_id: requestId, retryable: true } }, { status: 503, headers: { 'Retry-After': '5', 'X-Request-ID': requestId } });
+      first = objectFailure(error);
+      if (!(repeatable && first.retryable && !first.overloaded)) return unavailable(first, null);
     }
+    try { return await call(); }
+    catch (error) { return unavailable(objectFailure(error), first); }
   },
 };
+
+/** Failures before the HTTP handler (object initialization, migrations, storage, a reset) as our API contract, not a
+ *  platform HTML page. The answer goes to callers not yet authenticated, so it names only the error's kind and the
+ *  runtime's flags; its message (storage or SQL text, internal paths) is in the log line its request id leads to. */
+function unavailable(failure, retried) {
+  const requestId = crypto.randomUUID();
+  console.error(JSON.stringify({ event: 'teams_unavailable', request_id: requestId, failure, ...(retried ? { first: retried } : {}) }));
+  const cause = `${failure.name}${failure.reset ? ', object reset' : ''}${failure.overloaded ? ', overloaded' : ''}${retried ? ', after one retry' : ''}`;
+  return Response.json({ version: 1, error: { code: 'unavailable', message: `Teams server is temporarily unavailable (${cause})`, request_id: requestId, retryable: true, cause: { name: failure.name, retryable: failure.retryable, overloaded: failure.overloaded, remote: failure.remote, reset: failure.reset } } }, { status: 503, headers: { 'Retry-After': failure.overloaded ? '15' : '5', 'X-Request-ID': requestId } });
+}