@volter/supercode-teams 0.3.198 → 0.3.200

package/machine.mjs

@@ -3729,7 +3729,7 @@ export class TeamsMachine extends MachineCore {
         if (config.adapter?.kind !== 'rh2') throw new Error('machine-owned voice needs a persistent meeting adapter; stdio runs in its caller');
         const voiceEntry = this.env.SUPERCODE_VOICE_ENTRY || fileURLToPath(new URL('../voice/bin/voice.mjs', import.meta.url));
         if (!existsSync(voiceEntry)) throw new Error('voice pack is not installed; configure SUPERCODE_VOICE_ENTRY');
-        const child = spawn(process.execPath, [voiceEntry, 'run', '--config', configPath], { env: { ...this.env, SUPERCODE_BIN: this.supercodeBin, SUPERCODE_CALLER: params.session }, stdio: ['ignore', 'ignore', 'ignore'] });
+        const child = spawn(process.execPath, [voiceEntry, 'run', '--config', configPath], { env: { ...this.env, SUPERCODE_BIN: this.supercodeBin, SUPERCODE_CALLER: params.session }, stdio: ['ignore', 'ignore', 'ignore'], windowsHide: true });
         this.voiceProcesses.set(params.session, child);
         const ended = () => { if (this.voiceProcesses.get(params.session) === child) this.voiceProcesses.delete(params.session); };
         child.once('error', ended); child.once('exit', ended);

package/mail/carrier.mjs

@@ -53,12 +53,6 @@ export class MailCarrier {
   start() {
     this.onWake = () => this.#schedule();
     this.store.on('wake', this.onWake);
-    this.onLive = () => {
-      if (this.stopped) return;
-      try { this.store.wakeIdleSessions(this.live.sessions().filter((row) => row.status === 'idle').map((row) => row.address)); }
-      catch (error) { this.log(`carrier: idle waits could not be resumed: ${error.message}`); }
-    };
-    this.live.on('changed', this.onLive);
     this.#sweep();
     this.sweeper = setInterval(() => this.#sweep(), LAST_RETRY_MS);
     this.sweeper.unref?.();
@@ -74,7 +68,6 @@ export class MailCarrier {
   stop() {
     this.stopped = true;
     this.store.off('wake', this.onWake);
-    this.live.off('changed', this.onLive);
     clearInterval(this.sweeper); clearTimeout(this.timer);
     this.timer = null; this.timerAt = null;
   }
@@ -135,7 +128,7 @@ export class MailCarrier {
     let due = this.store.dueWakes(address, now);
     if (!due.length) return;
     // a session in a daemon pane whose mail is typed there: a hooked one (its hook shows it the rest), and one with no
-    // hook and no relay (Grok), whose mail that found its composer busy waits here until it is free
+    // hook and no relay (Grok), whose mail that found a draft in its composer waits here until it is free
     const session = this.live.sessions().find((row) => row.address === address);
     const pane = session ? this.paneOf(session) : null;
     const users = due.filter((id) => this.store.findIn(address, id)?.envelope.kind === 'user');
@@ -198,8 +191,7 @@ export class MailCarrier {
             new Promise((settle) => { bound = setTimeout(() => settle({ outcome: 'later', detail: `its hand-over was still running after ${HANDOVER_BOUND_MS / 1000} s` }), HANDOVER_BOUND_MS); bound.unref?.(); }),
           ]).finally(() => clearTimeout(bound));
           carried = answer?.outcome === 'delivered' ? { kind: 'delivered' } : answer?.outcome === 'filed' ? { kind: 'filed' }
-            : answer?.outcome === 'waiting' ? { kind: 'waiting', reason: answer.detail }
-              : answer?.outcome === 'pending' ? { kind: 'pending', reason: answer.detail } : { kind: 'later', reason: answer?.detail ?? 'not handed over' };
+            : answer?.outcome === 'pending' ? { kind: 'pending', reason: answer.detail } : { kind: 'later', reason: answer?.detail ?? 'not handed over' };
         } catch (error) { carried = { kind: 'later', reason: `this machine's daemon did not hand it over: ${error.message}` }; }
       }
       if (this.stopped) return;
@@ -325,11 +317,6 @@ export class MailCarrier {
       this.store.setWakeState(address, id, { ...state, next_at_ms: Date.now() + FIRST_RETRY_MS, last_error: carried.reason });
       return;
     }
-    if (carried.kind === 'waiting') {
-      const state = this.store.wakeState(address, id);
-      this.store.setWakeState(address, id, { ...state, waiting_for_idle: true, next_at_ms: Date.now() + LAST_RETRY_MS });
-      return;
-    }
     const now = Date.now();
     const state = this.store.wakeState(address, id);
     const envelope = this.store.findIn(address, id)?.envelope;

package/mail/send.mjs

@@ -31,7 +31,7 @@ const CODEX_KNOWN_WAIT_MS = 20_000;
 const RELAY_GRACE_MS = 30_000;
 /** The kinds of delivery that hand nothing over (#deliverWoken's `how`): the copy waits filed. An operator's mailbox,
  *  which its operator reads, and a session's hook, which shows it, are deliveries. */
-const LEFT_FILED = new Set(['queued', 'stored', 'pane_held', 'pane_waits', 'native_waits', 'not_running']);
+const LEFT_FILED = new Set(['queued', 'stored', 'pane_held', 'pane_waits', 'not_running']);
 
 /** Replies in one unbroken chain between two sessions beyond which another is refused. */
 const REPLY_CHAIN_LIMIT = 32;
@@ -428,7 +428,6 @@ export class MailSend {
       steered: [0, 'steered into its running turn'],
       started: [0, 'it was idle, so the message started a turn'],
       native_busy: [0, 'it will read it at its next tool call'],
-      native_waits: [EXIT_STORED, 'Stored: its relay could not deliver it and its session is busy, so its pane fallback waits unread until it is idle. Do not resend'],
       native_idle: [0, 'it was idle, so the message starts its next turn'],
       hooked: [0, 'queued in its mailbox; terminal delivery waits for native transcript confirmation'],
       hook_woken: [0, 'it was idle, so its pane was told to read its mailbox; its hook shows it the message in that turn'],
@@ -499,7 +498,8 @@ export class MailSend {
       const busy = door.session.status !== 'idle' || door.session.panes_current === false;
       if (!wake && !busy) throw new Refused('queue');
       // a busy session is handed it at once, as an idle one is: Claude Code's own cross-session message surfaces at the
-      // receiver's next tool call (D391). Only the pane fallback below waits for idle, since a busy pane is never typed into
+      // receiver's next tool call (D391). Its pane fallback below types it at once too: a prompt submitted mid-turn is queued
+      // and absorbed into the running turn
       // its reply line names the door this session really has: its tools when it runs supercode's MCP server
       const handed = sent.reply_via?.mode === 'command' && door.session.tools ? { ...sent, reply_via: { mode: 'tool' } } : sent;
       const text = render(handed);
@@ -549,15 +549,7 @@ export class MailSend {
       const received = this.store.claimOf(to, handed.id)?.recipient === true;
       // the relay produced no receipt and cannot send it late (known not made, or not in the receiver's transcript after
       // its bound, its queue gone): a session with a daemon pane has the same copy typed there instead
-      if (!relayed.delivered && !received && wake && door.pane && (!relayed.unknown || relayed.landed === false) && busy) {
-        // its pane is typed into only once its turn is idle: the copy waits unread, its wake resumed when it goes idle
-        // (carrier.mjs), which hands it to the relay again first
-        this.log(`relay could not deliver ${shortId(handed.id)} to busy ${to} (${relayed.detail}); its pane fallback waits for idle`);
-        try { this.store.requestWake(to, handed.id, { keep: true }); } catch { /* the wake filed above stands */ }
-        const state = this.store.wakeState(to, handed.id);
-        this.store.setWakeState(to, handed.id, { ...state, waiting_for_idle: true, next_at_ms: Date.now() + 300_000 });
-        delivered = 'native_waits';
-      } else if (!relayed.delivered && !received && wake && door.pane && (!relayed.unknown || relayed.landed === false)) {
+      if (!relayed.delivered && !received && wake && door.pane && (!relayed.unknown || relayed.landed === false)) {
         this.log(`relay could not deliver ${shortId(handed.id)} to ${to} (${relayed.detail}); typing it into its pane ${door.pane}`);
         this.relaying.add(key);
         try { delivered = await this.#typeIntoPane(handed, to, door.pane, wake, attempt); }
@@ -610,7 +602,7 @@ export class MailSend {
     }
     // held by the daemon's queue for the pane, typed once its composer frees: not typed yet, so kept unread
     if (typed?.queued) { this.store.deliver(to, sent); if (wake) this.store.requestWake(to, sent.id, { keep: true }); return 'pane_held'; }
-    // not typed (its composer held a draft or a turn ran): it waits unread with a wake, so the carrier tries it again once
+    // not typed (its composer held a draft, or showed none): it waits unread with a wake, so the carrier tries it again once
     // the composer is empty (mail/carrier.mjs), never left for a read a session with no hook never makes
     this.store.deliver(to, sent);
     if (!wake) return 'queued';
@@ -747,7 +739,7 @@ export class MailSend {
       if (error instanceof Refused) throw new Error(`${error.bytes} bytes; the limit is ${MAX_RELAYED_BYTES}`);
       throw error;
     }
-    return { how, text: { steered: 'steered into its running turn', started: 'started a turn', native_busy: 'read at its next tool call', native_waits: 'waits unread until its native turn is idle', native_idle: 'starts its next turn', hooked: 'in its mailbox, its hook shows it', queued: 'waits in its mailbox', operator: 'filed', already: 'it already had it', stored: 'stored; it has no delivery door', typed: 'typed into its pane', pane_held: 'held for its pane until its composer is free', pane_waits: 'waits in its mailbox (its composer was not empty)' }[how] };
+    return { how, text: { steered: 'steered into its running turn', started: 'started a turn', native_busy: 'read at its next tool call', native_idle: 'starts its next turn', hooked: 'in its mailbox, its hook shows it', queued: 'waits in its mailbox', operator: 'filed', already: 'it already had it', stored: 'stored; it has no delivery door', typed: 'typed into its pane', pane_held: 'held for its pane until its composer is free', pane_waits: 'waits in its mailbox (its composer was not empty)' }[how] };
   }
 
   // ---- a filing --------------------------------------------------------------------------------------------------
@@ -848,9 +840,9 @@ export class MailSend {
       return refused('delivery_failed', error.message);
     }
     return {
-      delivered_to_bus: door.kind !== 'stored' && !['pane_waits', 'pane_held', 'native_waits'].includes(how), message_id: sent.id, reply_to: sender,
+      delivered_to_bus: door.kind !== 'stored' && !['pane_waits', 'pane_held'].includes(how), message_id: sent.id, reply_to: sender,
       target: { harness, session_id: sessionId, name: door.kind === 'native' ? door.session.name.split('@')[0] : null },
-      delivery: { door: door.kind, how: { steered: 'steered', started: 'started', native_busy: 'next_tool_call', native_waits: 'waiting_for_idle', native_idle: 'started', hooked: 'hook', queued: 'queued', stored: 'stored', operator: 'filed', already: 'already', typed: 'typed', pane_held: 'held', pane_waits: 'stored' }[how] },
+      delivery: { door: door.kind, how: { steered: 'steered', started: 'started', native_busy: 'next_tool_call', native_idle: 'started', hooked: 'hook', queued: 'queued', stored: 'stored', operator: 'filed', already: 'already', typed: 'typed', pane_held: 'held', pane_waits: 'stored' }[how] },
     };
   }
 
@@ -1038,7 +1030,7 @@ export class MailSend {
     try {
       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)
-      if (LEFT_FILED.has(how)) return { outcome: how === 'native_waits' ? 'waiting' : how === 'pane_held' ? 'pending' : 'later', detail: how === 'pane_waits' ? this.store.wakeState(address, id).last_error : how };
+      if (LEFT_FILED.has(how)) return { outcome: how === 'pane_held' ? 'pending' : 'later', detail: how === 'pane_waits' ? this.store.wakeState(address, id).last_error : how };
       const now = this.store.findIn(address, id);
       if (how !== 'queued' && now?.state === 'unread') this.store.markRead(address, now.path);
       return { outcome: 'delivered', detail: null };

package/mail/sqlite-store.mjs

@@ -472,7 +472,7 @@ export class SqliteMailStore extends EventEmitter {
   }
   setWakeState(address, id, state) {
     const record = { attempts: state.attempts ?? 0, next_at_ms: state.next_at_ms ?? 0, last_error: state.last_error ?? null,
-      handover_at_ms: state.handover_at_ms ?? null, failing_since_ms: state.failing_since_ms ?? null, waiting_for_idle: state.waiting_for_idle === true };
+      handover_at_ms: state.handover_at_ms ?? null, failing_since_ms: state.failing_since_ms ?? null };
     this.transaction(() => {
       if (this.statement('UPDATE deliveries SET record = ?, due_at_ms = ?, attempts = ? WHERE mailbox = ? AND message = ?')
         .run(JSON.stringify(record), record.next_at_ms, record.attempts, address, id).changes) {
@@ -519,17 +519,6 @@ export class SqliteMailStore extends EventEmitter {
     });
   }
 
-  /** A live idle transition wakes only the native waits for those addresses. */
-  wakeIdleSessions(addresses) {
-    this.transaction(() => {
-      const changed = this.statement(`UPDATE deliveries SET due_at_ms = 0, record = json_set(record, '$.next_at_ms', 0)
-        WHERE mailbox IN (SELECT value FROM json_each(?)) AND json_extract(record, '$.waiting_for_idle') = 1
-        RETURNING mailbox`).all(JSON.stringify(addresses));
-      for (const address of new Set(changed.map((row) => row.mailbox))) this.refreshDeliveryTarget('mailbox', address);
-      if (changed.length) this.database.changed('wake', {});
-    });
-  }
-
   nextDeliveryTarget(excluded = []) {
     return this.statement(`SELECT t.kind, t.target, t.due_at_ms FROM delivery_targets t
       WHERE NOT EXISTS (SELECT 1 FROM json_each(?) e WHERE json_extract(e.value, '$.kind') = t.kind AND json_extract(e.value, '$.target') = t.target)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.198",
+  "version": "0.3.200",
   "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/terminal-mail.mjs

@@ -1,6 +1,8 @@
-// Per-recipient terminal mailbox. A retained paste is never repeated: retries
-// press Enter and look for the exact message in the native transcript (a user row, or the queued_command
-// attachment a running Claude Code turn absorbs it as).
+// Per-recipient terminal mailbox. Mail is typed and submitted at once, into an idle or a busy session alike: a prompt
+// submitted mid-turn is queued by Claude Code and absorbed into the running turn, and held by Codex and written as a
+// user message in that same turn. Only a composer holding a person's unsent text is waited for. A retained paste is
+// never repeated: retries press Enter and look for the exact message in the native transcript (a user row, or the
+// queued_command attachment a running Claude Code turn absorbs it as).
 import { statSync, openSync, readSync, closeSync } from 'node:fs';
 import { createHash, randomUUID } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
@@ -70,6 +72,10 @@ export function confirmed(batch) {
     const decoder = new StringDecoder('utf8');
     const bytes = Buffer.alloc(64 * 1024);
     let matched = 0, fragments = 0;
+    // Claude Code holds a prompt submitted mid-turn in its queue (queue-operation enqueue, with its content) until the
+    // turn absorbs it or the next turn takes it (remove/dequeue). While held it is not yet delivered, but it will land:
+    // the batch is kept, never refused at its deadline, until the transcript shows it or the queue lets it go.
+    if (batch.kind === 'claude-code') batch.claudeQueued = false;
     for (;;) {
       const count = readSync(fd, bytes, 0, bytes.length, offset);
       if (!count) return false;
@@ -78,6 +84,11 @@ export function confirmed(batch) {
       while ((end = buffered.indexOf('\n')) >= 0) {
         const line = buffered.slice(0, end); buffered = buffered.slice(end + 1);
         let row; try { row = JSON.parse(line); } catch { continue; }
+        if (batch.kind === 'claude-code' && row.type === 'queue-operation' && (!batch.sessionId || row.sessionId === batch.sessionId)) {
+          if (row.operation === 'enqueue' && typeof row.content === 'string' && claudeSame(row.content, batch.text)) batch.claudeQueued = true;
+          else if (row.operation !== 'enqueue') batch.claudeQueued = false;
+          continue;
+        }
         // A prompt submitted while a turn runs is queued, and reaches the model as a `queued_command` attachment when
         // the turn absorbs it (queue-operation remove, reason absorbed_mid_turn); no `user` row is written for it.
         // That attachment is its delivery. An enqueue alone is not: a queued prompt can still be withdrawn.
@@ -174,7 +185,7 @@ export class TerminalMailbox {
     const own = claudeHolds(batch, shown, true);
     // One final read/Enter at the deadline, then a bounded native receipt
     // grace. A badge that painted late never goes straight to refusal.
-    if (own && !batch.confirmationError && !batch.finalEnter && !/\besc to (?:interrupt|cancel)\b/iu.test(screen)) {
+    if (own && !batch.confirmationError && !batch.finalEnter) {
       batch.finalEnter = true; batch.phase = 'pasted'; batch.expiresAt = Date.now() + 5000;
       batch.enters++; batch.last_enter = Date.now(); this.save();
       await this.host.sendInput(this.session.id, '\r', { submitMode: 'single', inputOwner: batch.inputOwner });
@@ -295,6 +306,11 @@ export class TerminalMailbox {
     if (batch.kind === 'claude-code' && batch.phase === 'prepared' && batch.expiresAt && Date.now() >= batch.expiresAt) {
       await this.recordRefusal(batch, 'delivery deadline elapsed; no input pasted'); return;
     }
+    if (batch.kind === 'claude-code' && batch.phase !== 'refusing' && batch.claudeQueued) {
+      // submitted and held in Claude Code's own queue: it lands when the running turn absorbs it, so it is never
+      // refused, pressed again or cleaned up meanwhile
+      batch.error = 'queued in its running turn; native transcript confirmation pending'; this.save(); return;
+    }
     if (batch.kind === 'claude-code' && (batch.phase === 'refusing' || (batch.expiresAt && Date.now() >= batch.expiresAt))) {
       await this.refuseClaude(batch); return;
     }
@@ -311,12 +327,13 @@ export class TerminalMailbox {
         } catch (error) {
           await this.recordRefusal(batch, `input ownership unavailable (${error.code ?? error.message}); no input pasted`); return;
         }
+        // A running turn is no reason to hold: only a person's unsent text (or a screen with no composer) is.
         for (let check = 0; check < 2; check++) {
           const screen = await this.host.capture(this.session.id, { lines: 200, preserveEscapes: true });
           const held = composerText(batch.kind, screen);
-          if (held !== '' || /\besc to (?:interrupt|cancel)\b/iu.test(screen)) {
+          if (held !== '') {
             await this.host.releaseInput(this.session.id, batch.inputOwner);
-            batch.error = held == null ? 'no-composer' : held ? 'draft' : 'working'; this.save(); return;
+            batch.error = held == null ? 'no-composer' : 'draft'; this.save(); return;
           }
           if (check === 0) await pause(200);
         }
@@ -357,8 +374,9 @@ export class TerminalMailbox {
         const screen = await this.host.capture(this.session.id, { lines: 200, preserveEscapes: true });
         // Re-read until the deadline: a Windows paste badge can appear well
         // after one second. Ownership is held by the pane host, across daemon
-        // restart, from before the empty reads through receipt/refusal.
-        if (!claudeHolds(batch, composerText(batch.kind, screen), true) || /\besc to (?:interrupt|cancel)\b/iu.test(screen)) {
+        // restart, from before the empty reads through receipt/refusal. A
+        // running turn takes the Enter too: it queues the prompt.
+        if (!claudeHolds(batch, composerText(batch.kind, screen), true)) {
           batch.error = 'composer changed or unreadable; native transcript confirmation pending'; this.save(); return;
         }
       }