@volter/supercode-teams 0.3.100 → 0.3.102

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 unread ones always, and a first line says how
+// many older read 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 read 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);
@@ -3468,7 +3490,13 @@ 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);
+            // an unread message to it is always listed, as its own inbox lists its claimed ones
+            const kept = inboxKept(rows.length, (index) => Buffer.byteLength(JSON.stringify(rows[index])), (index) => rows[index].direction === 'in' && rows[index].state === 'unread');
+            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' };
@@ -3491,7 +3519,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

@@ -335,6 +335,12 @@ export class MailSend {
         throw Object.assign(new Error(relayed.detail), { unanswered: true });
       }
       if (!relayed.delivered && !received) { if (filedHere) { try { unlinkSync(filed); } catch { /* gone */ } } throw new Error(relayed.detail); }
+      // relayed: a copy filed unread before this delivery (an earlier unanswered or queued one, held for the receiver's
+      // own read) is moved to cur/, so that read never hands it over a second time
+      if (relayed.delivered && !received) {
+        const now = this.store.findIn(to, handed.id);
+        if (now?.state === 'unread') { try { this.store.markRead(to, now.path); } catch { /* moved meanwhile */ } }
+      }
       delivered = busy ? 'native_busy' : 'native_idle';
     } else if (door.kind === 'hook') {
       this.store.deliver(to, sent);
@@ -368,9 +374,11 @@ export class MailSend {
 
   async #deliverPlanned(caller, sent, plan, { queue, notify_when_idle }) {
     const reached = [], copied = [], failed = [];
+    let recorded = false;
+    const held = []; // recipients whose own copy is held unread with its wake (an unanswered relay)
     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)) {
@@ -381,15 +389,42 @@ 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 only when its copy is here, unread: its wake hands it over, or (queued, no wake) the receiver's own read
+        // does. An unanswered request to another machine's door holds nothing here, so it is a failure, and the agent's
+        // own copy waits with its wake (filing there again is filing the same id, which files nothing new)
+        const kept = this.store.findIn(recipient.address, sent.id);
+        if (error.unanswered && kept?.state === 'unread') held.push(`${label} (unanswered: ${error.message}; ${this.store.hasWake(recipient.address, sent.id) ? 'its wake hands it over' : 'queued: its own mailbox read gives it'})`);
+        else 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 || held.length)) {
+      // reached, or held by a recipient's own wake (which hands it over, once): its record is read (one a retry handed
+      // over was unread), so its own wake, if any, is settled and never hands it over beside the recipient's
+      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) {
+      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}`;
-    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.`;
+    // a held copy is not said not sent: it is handed over by its wake, so a sender that sent it again would duplicate it
+    const heldText = held.length ? ` Held, unanswered, unread in ${held.length === 1 ? 'its receiver\'s' : 'their receivers\''} mailbox, which gives it to the receiver once (don't send it again): ${held.join('; ')}.` : '';
+    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 && !held.length) text = `Not sent: nobody in its thread could be reached.${thread}`;
+    else text = `sent to ${reached.length ? reached.join(', ') : 'no one woken yet'}.${copied.length ? ` CC (filed, not woken): ${copied.join(', ')}.` : ''}${heldText} 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 || held.length || waiting ? 0 : EXIT_FAILED;
+    return { ...outcome(code, text, code === 0 ? { delivered: true, message_ids: [sent.id], receipt: 'agent-mailbox', ...(waiting ? { waiting } : {}), ...(held.length && !reached.length && !copied.length ? { unanswered: true } : {}) } : null), waiting };
   }
 
   /** `sent` filed unread in `address`'s mailbox on this machine's mail, without waking it (mail_agent.rs `file_unread`):
@@ -692,7 +727,7 @@ export class MailSend {
       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' };

package/mail/store.mjs

@@ -403,12 +403,20 @@ 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; }
+  }
+
+  /** Whether a wake is on file for `id` in `address`'s mailbox. */
+  hasWake(address, id) {
+    if (!/^[A-Za-z0-9_-]+$/.test(id)) return false;
+    return existsSync(join(this.open(address).dir, 'wake', id));
   }
 
   /** 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.100",
+  "version": "0.3.102",
   "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",