@volter/supercode-teams 0.3.99 → 0.3.101

package/machine.mjs

@@ -300,6 +300,25 @@ function instructionsFile({ harness, scope = 'user', cwd } = {}) {
 }
 // A board verb's answer goes in pieces of this many characters (JSON, so about as many bytes).
 const BOARD_ANSWER_PIECE = 512 * 1024;
+// What an inbox answer carries at most: the channel's frame is 8 MiB (channel.mjs MAX_FRAME), and an answer holds each
+// message three ways (rendered, plain, its row). A mailbox's whole history did not fit (yuerans, 2026-10-06: 6,496 read
+// envelopes, a 43 MB frame refused); the newest that fit are listed, its claimed (unread) ones always, and a first line
+// says how many older ones are not.
+const INBOX_ANSWER_BYTES = 4 * 1024 * 1024;
+
+/** The indexes of `count` messages kept in an answer, newest first until `sizeOf` passes the bound; `always` kept. */
+function inboxKept(count, sizeOf, always = () => false) {
+  const kept = [];
+  let bytes = 0, full = false;
+  for (let index = count - 1; index >= 0; index -= 1) {
+    const size = sizeOf(index);
+    if (always(index) || (!full && bytes + size <= INBOX_ANSWER_BYTES)) { kept.push(index); bytes += size; }
+    else full = true;
+  }
+  return kept.reverse();
+}
+const inboxNote = (left) => `(${left} older message${left === 1 ? ' is' : 's are'} not listed: an answer holds at most ${INBOX_ANSWER_BYTES / 1024 / 1024} MiB. --recent <N> lists the newest N.)`;
+
 
 export class TeamsMachine extends MachineCore {
   /** Typed lines by key → the answer their first attempt gives (see #serveTurn). */
@@ -1158,10 +1177,13 @@ export class TeamsMachine extends MachineCore {
       if (conn === INTERNAL_CONNECTION) {
         const pending = this.internalRequests?.get(original);
         if (!pending) {
-          // an answer that came after its request gave up: an index it opened is registered in serve with nobody reading
-          // it (one more at each retry), so it is let go at once
+          // an answer that came after its request gave up: a subscription it opened (an index, or an activity follow of up
+          // to 2048 sessions) is registered in serve with nobody reading it, one more at each retry, and serve resolves
+          // every activity subscription on every poll round; so it is let go at once (yuerans, 2026-10-06: leaked activity
+          // follows held serve's loop in poll rounds 294 s of 420, and its relay starts timed out)
           const late = message.result?.subscription;
-          if (typeof late === 'string' && late.startsWith('index-sub-')) this.#toServe(`${JSON.stringify({ jsonrpc: '2.0', id: joinId(INTERNAL_CONNECTION, `late-${late}`), method: 'harness.v1.sessions.index.unsubscribe', params: { subscription: late } })}\n`);
+          const kind = typeof late === 'string' ? /^(index|activity)-sub-/.exec(late)?.[1] : null;
+          if (kind) this.#toServe(`${JSON.stringify({ jsonrpc: '2.0', id: joinId(INTERNAL_CONNECTION, `late-${late}`), method: `harness.v1.sessions.${kind}.unsubscribe`, params: { subscription: late } })}\n`);
           return;
         }
         this.internalRequests.delete(original);
@@ -3419,7 +3441,8 @@ export class TeamsMachine extends MachineCore {
       case 'harness.v1.mail.handover': {
         if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('mail is handed over here by this machine\'s own processes'), { code: 403 });
         if (typeof params.address !== 'string' || typeof params.id !== 'string' || !parseAddress(params.address)) throw Object.assign(new Error('a hand-over names an address and a message id'), { code: 400 });
-        return this.mailSend.handOver(params.address, params.id, { markRead: params.mark_read === true, wake: params.wake === true });
+        // a hand-over is moved to cur/ once delivered whatever `mark_read` says (MailSend.handOver)
+        return this.mailSend.handOver(params.address, params.id, { wake: params.wake === true });
       }
       // harness serve's `sessions.message` (its mail to a session or an agent, not its `as_user` turn), asked here by
       // harness serve itself: one implementation of a send, whatever the entry.
@@ -3467,7 +3490,12 @@ export class TeamsMachine extends MachineCore {
             address = found.address;
           }
           const machine = address.split(':')[1];
-          if (machine === machineName(this.env)) return { code: 0, address, rows: await this.mail.inboxRows(address, last) };
+          if (machine === machineName(this.env)) {
+            const rows = await this.mail.inboxRows(address, last);
+            const kept = inboxKept(rows.length, (index) => Buffer.byteLength(JSON.stringify(rows[index])));
+            const left = rows.length - kept.length;
+            return { code: 0, address, rows: [...(left ? [{ direction: 'note', omitted: left, rendered: inboxNote(left) }] : []), ...kept.map((index) => rows[index])] };
+          }
           try {
             const answer = await this.#askMailDoor(machine, { op: 'inbox', session: address, recent: last });
             return answer?.code === 0 ? { code: 0, address, rows: Array.isArray(answer.rows) ? answer.rows : [] } : { code: 3, text: answer?.text ?? 'its machine refused' };
@@ -3490,7 +3518,14 @@ export class TeamsMachine extends MachineCore {
           this.inboxClaims.set(token, { address: caller, claimed: read.claimed });
         }
         // `plain`: each message as its reader is shown it (the envelope rendered), with no listing's line about when
-        return { code: 0, address: caller, rendered: read.rendered, plain: read.stored.map((item) => render(item.envelope)), rows: read.rows, token };
+        const plain = read.stored.map((item) => render(item.envelope));
+        const claimedIds = new Set(read.claimed.map((item) => item.envelope.id));
+        const kept = inboxKept(read.stored.length,
+          (index) => Buffer.byteLength(read.rendered[index] ?? '') + Buffer.byteLength(plain[index] ?? '') + Buffer.byteLength(JSON.stringify(read.rows[index] ?? null)),
+          (index) => claimedIds.has(read.stored[index].envelope.id));
+        const left = read.stored.length - kept.length;
+        const note = left ? [inboxNote(left)] : [];
+        return { code: 0, address: caller, rendered: [...note, ...kept.map((index) => read.rendered[index])], plain: [...note, ...kept.map((index) => plain[index])], rows: kept.map((index) => read.rows[index]), omitted: left, token };
       }
       // Who a local client is, from its claim (live-sessions.mjs callerOf): what a command acting on another machine sends
       // there as its caller, resolved here, where the map that holds it is. Local only; never the app door's.

package/mail/send.mjs

@@ -52,6 +52,7 @@ export class MailSend {
    */
   constructor({ machine, mailRoot, live, store, agents, relays, askMachine, deliverRuntime, codexAnswer, typeTurn, log = () => {} }) {
     Object.assign(this, { machine, mailRoot, live, store, agents, relays, askMachine, deliverRuntime, codexAnswer, typeTurn, log });
+    this.handing = new Set(); // `<address>\n<id>` of each hand-over running here (handOver)
   }
 
   // ---- one send ----------------------------------------------------------------------------------------------------
@@ -367,9 +368,10 @@ export class MailSend {
 
   async #deliverPlanned(caller, sent, plan, { queue, notify_when_idle }) {
     const reached = [], copied = [], failed = [];
+    let recorded = false, held = false;
     if (plan.agent) {
       // the agent's own mailbox keeps the record of what was addressed to it
-      try { this.store.deliverRead(plan.agent, sent); } catch (error) { failed.push(`the agent's mailbox (${error.message})`); }
+      try { this.store.deliverRead(plan.agent, sent); recorded = true; } catch (error) { failed.push(`the agent's mailbox (${error.message})`); }
     }
     const sessions = this.live.sessions();
     for (const recipient of plan.recipients.filter((item) => item.address !== caller.address)) {
@@ -380,15 +382,35 @@ export class MailSend {
         continue;
       }
       try { reached.push(`${label} (${await this.#deliverWoken(sent, recipient.address, sessions, queue, notify_when_idle)})`); }
-      catch (error) { failed.push(error.unanswered ? `${label} (unanswered, whether it arrived is unknown: ${error.message})` : `${label} (${error.message})`); }
+      catch (error) {
+        held ||= error.unanswered === true;
+        failed.push(error.unanswered ? `${label} (unanswered, whether it arrived is unknown: ${error.message})` : `${label} (${error.message})`);
+      }
     }
     const thread = plan.thread ? ` Thread ${shortId(plan.thread.id)}.` : '';
+    // agent mail that reached nobody is never left only as a read record: its copy in the agent's mailbox goes back
+    // unread with a wake, and the carrier hands it over again (handOver plans it anew) after its backoff, until a
+    // recipient has it or the wake expires. Not when a recipient's own copy is held unread with its wake (an unanswered
+    // relay), which hands it over itself: two wakes would deliver it twice
+    let waiting = false;
+    if (recorded && (reached.length || copied.length)) {
+      // reached: its record is read (one a retry handed over was unread)
+      try { const record = this.store.findIn(plan.agent, sent.id); if (record?.state === 'unread') this.store.markRead(plan.agent, record.path); } catch { /* kept unread */ }
+    } else if (recorded && !held) {
+      try {
+        const record = this.store.findIn(plan.agent, sent.id);
+        if (record?.state === 'read') this.store.markUnread(plan.agent, record.path);
+        this.store.requestWake(plan.agent, sent.id, { keep: true });
+        waiting = true;
+      } catch (error) { failed.push(`its retry (${error.message})`); }
+    }
     let text;
-    if (!reached.length && !copied.length) text = `Not sent: nobody in its thread could be reached.${thread}`;
+    if (waiting) text = `not sent yet: nobody in its thread could be reached, so it waits unread in ${plan.agent}'s mailbox and is handed over again when one can be. Message id ${shortId(sent.id)}.${thread} Don't poll; carry on.`;
+    else if (!reached.length && !copied.length) text = `Not sent: nobody in its thread could be reached.${thread}`;
     else text = `sent to ${reached.length ? reached.join(', ') : 'no one woken'}.${copied.length ? ` CC (filed, not woken): ${copied.join(', ')}.` : ''} Message id ${shortId(sent.id)}.${thread} Don't poll; carry on.`;
     if (failed.length) text += ` Not delivered to: ${failed.join('; ')}.`;
-    const code = reached.length || copied.length ? 0 : EXIT_FAILED;
-    return outcome(code, text, code === 0 ? { delivered: true, message_ids: [sent.id], receipt: 'agent-mailbox' } : null);
+    const code = reached.length || copied.length || waiting ? 0 : EXIT_FAILED;
+    return { ...outcome(code, text, code === 0 ? { delivered: true, message_ids: [sent.id], receipt: 'agent-mailbox', ...(waiting ? { waiting } : {}) } : null), waiting };
   }
 
   /** `sent` filed unread in `address`'s mailbox on this machine's mail, without waking it (mail_agent.rs `file_unread`):
@@ -665,22 +687,33 @@ export class MailSend {
   /**
    * A message filed unread in `address`'s mailbox handed to its session's door, once (mail_watch.rs `carry` and message.rs
    * `push`, and the native watch's notices): only a door that hands it to the session (a relay, a runtime) takes it, a
-   * hook's is woken when `wake`, and an agent's mail is planned; `markRead` moves it to `cur/` once handed over. The
-   * hand-over is recorded on its wake before it starts, so one interrupted mid-way is never handed over again. Answers
+   * hook's is woken when `wake`, and an agent's mail is planned. One handed over is moved to `cur/` here, whoever asked:
+   * its receiver has it, so its next inbox read never shows it again (the carrier marks it read only when its own call
+   * answers delivered, which a hand-over past its bound never does). The
+   * hand-over is recorded on its wake before it starts, so one interrupted mid-way (its daemon ended) is never handed over
+   * again; one still running here, its carrier past its bound, answers 'later' until it settles. Answers
    * `{ outcome: 'delivered' | 'filed' | 'later', detail }`.
    */
-  async handOver(address, id, { markRead = false, wake = false } = {}) {
+  async handOver(address, id, { wake = false } = {}) {
     const found = this.store.findIn(address, id);
     if (!found) return { outcome: 'filed', detail: 'not in its mailbox' };
     const sent = readJson(found.path);
     if (!sent) return { outcome: 'later', detail: 'its envelope could not be read' };
     if (found.state !== 'unread') return { outcome: 'filed', detail: 'already read' };
+    // one already handed to its receiver's door (that delivery's claim, the door's or the carrier's: a daemon that ended
+    // between the delivery and moving the copy left it unread) is moved to `cur/`, never handed over again. A reader's
+    // claim is not one: a reader that ended before reading put the copy back unread, and it is handed over
+    const claim = this.store.claimOf(address, id);
+    if (claim?.recipient === true && (claim.via === 'door' || claim.via === 'carrier')) {
+      this.store.markRead(address, found.path);
+      return { outcome: 'filed', detail: 'already handed over' };
+    }
     const parsed = parseAddress(address);
     if (parsed?.harness === AGENT_HARNESS) {
       const plan = await this.#plan(sent, address, {});
       if (!plan.plan) return { outcome: 'filed', detail: plan.outcome?.text ?? 'no plan' };
       const done = await this.#deliverPlanned({ address: sent.from, name: sent.from_name }, sent, plan.plan, { queue: false, notify_when_idle: false });
-      return done.code === 0 ? { outcome: 'delivered', detail: done.text } : { outcome: 'later', detail: done.text };
+      return done.code === 0 && !done.waiting ? { outcome: 'delivered', detail: done.text } : { outcome: 'later', detail: done.text };
     }
     const door = this.#door(address, this.live.sessions());
     if (!door) return { outcome: 'later', detail: 'its session is not running' };
@@ -691,11 +724,18 @@ export class MailSend {
       return { outcome: 'filed', detail: `its door is ${door.kind}` };
     }
     const state = this.store.wakeState(address, id);
+    // one still running here (its carrier gave up on its answer, past its bound) is waited for: the wake stays and is
+    // tried again after its backoff, settled by that hand-over's own outcome
+    const key = `${address}\n${id}`;
+    if (this.handing.has(key)) return { outcome: 'later', detail: 'its hand-over is still in progress' };
     if (state.handover_at_ms != null) return { outcome: 'filed', detail: 'an earlier hand-over never settled' };
     this.store.setWakeState(address, id, { ...state, handover_at_ms: Date.now() });
+    this.handing.add(key);
     try {
-      await this.route(sent, address, door, true, false);
-      if (markRead) { const now = this.store.findIn(address, id); if (now?.state === 'unread') this.store.markRead(address, now.path); }
+      const how = await this.route(sent, address, door, true, false);
+      // handed to the session (or already its): moved to cur/ (one only queued for a runtime not woken would stay unread)
+      const now = this.store.findIn(address, id);
+      if (how !== 'queued' && now?.state === 'unread') this.store.markRead(address, now.path);
       return { outcome: 'delivered', detail: null };
     } catch (error) {
       // a message its door can never take (too long for a relay) stays filed for the session to read
@@ -704,6 +744,7 @@ export class MailSend {
       if (error.unanswered) return { outcome: 'later', detail: `unanswered: ${error.message}` };
       return error instanceof Refused ? { outcome: 'filed', detail: error.kind } : { outcome: 'later', detail: error.message };
     } finally {
+      this.handing.delete(key);
       const after = this.store.wakeState(address, id);
       this.store.setWakeState(address, id, { ...after, handover_at_ms: null });
     }

package/mail/store.mjs

@@ -403,12 +403,14 @@ export class MailStore extends EventEmitter {
     renameSync(path, join(box.dir, 'new', path.split(/[\\/]/).pop()));
   }
 
-  /** A wake kept beside the envelope (mailbox.rs `request_wake`): its watcher hands it to the session's door. */
-  requestWake(address, id) {
+  /** A wake kept beside the envelope (mailbox.rs `request_wake`): its watcher hands it to the session's door. With
+   *  `keep`, a wake already there is kept as it is (its attempts and backoff so far), never made fresh again. */
+  requestWake(address, id, { keep = false } = {}) {
     if (!/^[A-Za-z0-9_-]+$/.test(id)) throw new Error('invalid wake message id');
     const box = this.open(address);
     mkdirSync(join(box.dir, 'wake'), { recursive: true });
-    writeFileSync(join(box.dir, 'wake', id), '');
+    try { writeFileSync(join(box.dir, 'wake', id), '', { flag: keep ? 'wx' : 'w' }); }
+    catch (error) { if (!keep || error.code !== 'EEXIST') throw error; }
   }
 
   /** A wake's delivery so far (mailbox.rs `wake_state`): an empty or absent file is a fresh wake. */

package/package.json

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