@volter/supercode-teams 0.3.101 → 0.3.103

package/machine.mjs

@@ -302,8 +302,8 @@ function instructionsFile({ harness, scope = 'user', cwd } = {}) {
 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.
+// 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. */
@@ -317,7 +317,7 @@ function inboxKept(count, sizeOf, always = () => false) {
   }
   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.)`;
+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 {
@@ -3492,7 +3492,8 @@ export class TeamsMachine extends MachineCore {
           const machine = address.split(':')[1];
           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])));
+            // 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])] };
           }

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,7 +374,8 @@ export class MailSend {
 
   async #deliverPlanned(caller, sent, plan, { queue, notify_when_idle }) {
     const reached = [], copied = [], failed = [];
-    let recorded = false, held = false;
+    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); recorded = true; } catch (error) { failed.push(`the agent's mailbox (${error.message})`); }
@@ -383,8 +390,12 @@ export class MailSend {
       }
       try { reached.push(`${label} (${await this.#deliverWoken(sent, recipient.address, sessions, queue, notify_when_idle)})`); }
       catch (error) {
-        held ||= error.unanswered === true;
-        failed.push(error.unanswered ? `${label} (unanswered, whether it arrived is unknown: ${error.message})` : `${label} (${error.message})`);
+        // 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)}.` : '';
@@ -393,10 +404,11 @@ export class MailSend {
     // 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)
+    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 && !held) {
+    } else if (recorded) {
       try {
         const record = this.store.findIn(plan.agent, sent.id);
         if (record?.state === 'read') this.store.markUnread(plan.agent, record.path);
@@ -405,12 +417,14 @@ export class MailSend {
       } catch (error) { failed.push(`its retry (${error.message})`); }
     }
     let text;
+    // 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) 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.`;
+    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 || waiting ? 0 : EXIT_FAILED;
-    return { ...outcome(code, text, code === 0 ? { delivered: true, message_ids: [sent.id], receipt: 'agent-mailbox', ...(waiting ? { waiting } : {}) } : null), waiting };
+    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`):

package/mail/store.mjs

@@ -413,6 +413,12 @@ export class MailStore extends EventEmitter {
     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. */
   wakeState(address, id) {
     const box = this.open(address);

package/native-codex-pane.mjs

@@ -2,7 +2,7 @@
 // Supercode hosts neither the agent nor its run loop; it can attach to native
 // question requests while the stock TUI remains the session's UI.
 import { spawn } from 'node:child_process';
-import { readFileSync, writeFileSync, renameSync, mkdtempSync, existsSync, rmSync } from 'node:fs';
+import { readFileSync, writeFileSync, renameSync, mkdtempSync, existsSync, rmSync, appendFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -42,7 +42,23 @@ for (let index = 0; index < seed.arguments.length; index += 1) {
   }
 }
 if(writableRoots.length)config.push('-c',`sandbox_workspace_write.writable_roots=${JSON.stringify(writableRoots)}`);
-const server = spawn(seed.program, [...config, 'app-server', '--listen', endpoint], { stdio: ['ignore', 'ignore', 'inherit'] });
+// The app-server's stderr is never the pane's: the pane is the TUI's screen, and a record the server writes there lands
+// on the TUI's composer row, which the mail wake then reads as a person's draft and never types over (yuerans,
+// 2026-10-06: `ERROR codex_models_manager::manager: failed to refresh available models` held every wake of the box
+// maintainer off for three hours). It is kept beside the pane's binding instead, at most LOG_BYTES of it.
+const LOG_BYTES = 8 * 1024 * 1024;
+const serverLog = `${path.replace(/\.json$/, '')}.app-server.log`;
+let logged = 0;
+const server = spawn(seed.program, [...config, 'app-server', '--listen', endpoint], { stdio: ['ignore', 'ignore', 'pipe'] });
+server.stderr.on('data', (chunk) => {
+  if (logged >= LOG_BYTES) return;
+  const kept = chunk.subarray(0, LOG_BYTES - logged);
+  logged += kept.length;
+  try {
+    appendFileSync(serverLog, kept, { mode: 0o600 });
+    if (logged >= LOG_BYTES) appendFileSync(serverLog, `\nsupercode: the app-server's stderr past ${LOG_BYTES} bytes is not kept\n`);
+  } catch { /* its log is best kept; the pane never gets it */ }
+});
 let tui;
 let ended = false;
 let serverError;
@@ -67,7 +83,10 @@ try {
   tui = spawn(seed.program, args, { stdio: 'inherit' });
   process.exitCode = await new Promise((resolve, reject) => { tui.once('exit', (code) => resolve(code ?? 1)); tui.once('error', reject); });
 } catch (error) {
-  process.stderr.write(`supercode: ${error.message}\n`);
+  // a server that failed says why in its log, which the pane shows only now, as the pane's own failure
+  let why = '';
+  try { why = readFileSync(serverLog, 'utf8').slice(-2000).trim(); } catch { /* it wrote nothing */ }
+  process.stderr.write(`supercode: ${error.message}\n${why ? `its app-server's stderr (${serverLog}):\n${why}\n` : ''}`);
   process.exitCode = 1;
 } finally {
   clearInterval(guard);

package/package.json

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