@volter/supercode-teams 0.3.197 → 0.3.199

package/README.md

@@ -61,8 +61,8 @@ Before the first SQLite start, `supercode teams mail migration-check --home /abs
 reads that guard locally without a daemon connection or migration. Admission is not proof that the import will finish.
 The [source boundary and pending qualification](../../docs/evidence/legacy-wrapper-migration-2026-10-08.md)
 name the trusted legacy ABI, loss of later legacy diagnostics and existing retirement recovery.
-Settled read bodies expire after 30 days, with explicit placeholders and retained thread headers; pending mail keeps
-its originals. Expired read headers are capped at 1,000,000 and carrier/terminal event log tables at 10,000 rows each. Read the
+Mail bodies are kept like their headers. Read headers whose body is not kept show an explicit placeholder and are
+capped at 1,000,000; carrier/terminal event log tables keep 10,000 rows each. Read the
 [dated qualification scope](../../docs/evidence/sqlite-mail-store-2026-10-08.md) before inferring platform support.
 
 Native mail-history reads process the opened file's initial extent in 64 KiB blocks,

package/machine.mjs

@@ -84,7 +84,7 @@ import { WorkspaceContexts, fromContext } from '@volter/teams/context';
 import { TeamsClient } from '@volter/teams/http-client';
 import { supercodeHome } from '@volter/teams/home';
 import { readMailHistory, machineName } from './mail-history.mjs';
-import { randomBytes, createHash, randomUUID } from 'node:crypto';
+import { randomBytes, createHash } from 'node:crypto';
 import { WebSocket } from 'ws';
 import { TmuxTerminalHost, classifyAttentionSignal, composerHoldsDraft, composerReadyForInput } from '@volter/supercode-terminal';
 // The ConPTY host is read from the namespace, where a terminal package too old to have it gives undefined rather
@@ -909,30 +909,16 @@ export class TeamsMachine extends MachineCore {
       const reading = await this.#serveRequest('harness.v1.sessions.activity_under', { pids: [session.rootPid] }, 4_000);
       const native = reading?.activities?.find(row => row.pid === session.rootPid)?.activity;
       if (native?.harness !== expected.harness || native.session_id !== expected.session) return { delivered: false, reason: 'the pane no longer runs the addressed native session; no input submitted' };
-      // A lifecycle wake belongs to the board's owned session, not the /btw
-      // composer. Dismiss only that identified panel; never answer a question,
-      // approve a permission, clear a draft or interrupt the underlying turn.
+      // A board wake is never typed into a Claude /btw panel, and the daemon sends
+      // no keys to close it: the wake waits unread and the board reports the
+      // session's `dialog open` turn to the manager.
       const boardWake = messageIds?.length && messageIds.every(id => {
         const stored = this.mailStore.findIn(address, id);
         const envelope = stored ? this.mailStore.body(stored) : null;
         return envelope?.kind === 'notice' && parseAddress(envelope.from)?.harness === 'board';
       });
-      if (boardWake && claudeSideQuestionPanel(await this.host.capture(session.id, { lines: 200, preserveEscapes: true }), native)) {
-        const owner = randomUUID();
-        if (await this.host.acquireInput?.(session.id, owner)) {
-          try {
-            await new Promise(resolve => setTimeout(resolve, COMPOSER_RECHECK_MS));
-            const latest = await this.#serveRequest('harness.v1.sessions.activity_under', { pids: [session.rootPid] }, 4_000);
-            const current = latest?.activities?.find(row => row.pid === session.rootPid)?.activity;
-            const screen = await this.host.capture(session.id, { lines: 200, preserveEscapes: true });
-            if (!this.stopping && current?.session_id === expected.session && claudeSideQuestionPanel(screen, current)) {
-              await this.host.sendInput(session.id, '\u001b', { submitMode: 'single', inputOwner: owner, deadlineMs: Date.now() + 5_000 });
-              this.log.append({ principal: null, cap: 'control', target: `pane:${pane}`, outcome: 'board-side-question-dismissed', detail: JSON.stringify({ address, message_ids: messageIds }) });
-              await new Promise(resolve => setTimeout(resolve, COMPOSER_RECHECK_MS));
-            }
-          } finally { await this.host.releaseInput?.(session.id, owner); }
-        }
-      }
+      if (boardWake && claudeSideQuestionPanel(await this.host.capture(session.id, { lines: 200, preserveEscapes: true }), native))
+        return { delivered: false, reason: 'a Claude /btw panel is open on the pane; the board wake waits unread and no keys were sent' };
       const result = await this.#paneTurn(session, pane, text, { messageIds, harness });
       if (result.refused) throw new Error(result.refused.reason);
       return result.waits ?? result;

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/mail/sqlite.mjs

@@ -10,12 +10,12 @@ import { RECORD_SCHEMA } from '../record-state.mjs';
 
 export const MAIL_SCHEMA_VERSION = 3;
 export const MAIL_RETENTION = Object.freeze({
-  bodyDays: 30,
+  relayTextDays: 30,
   maxReadHeaders: 1_000_000,
   maxCarrierRows: 10_000,
   maxTerminalLogRows: 10_000,
 });
-export const RETAINED_BODY = `[this message's body was let go after ${MAIL_RETENTION.bodyDays} days (mail retention); its header and thread are kept]`;
+export const RETAINED_BODY = `[this message's body was not kept; its header and thread are kept]`;
 
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS mail_metadata (
@@ -331,51 +331,24 @@ export class MailDatabase extends EventEmitter {
     });
   }
 
-  /** Only settled read mail is eligible. Pending deliveries, subscriptions and
-   * claim holders protect their originals; an unresolved message never loses its body. */
+  /** Mail bodies are kept. Retention removes old relay scratch copies (their
+   * originals stay in the mailbox) and caps headers whose body is already gone. */
   retain(now = Date.now()) {
-    const cutoff = now - this.retention.bodyDays * 86_400_000;
+    const cutoff = now - this.retention.relayTextDays * 86_400_000;
     return this.transaction(() => {
-      const expired = this.statement(`UPDATE messages SET body_digest = coalesce(body_digest, supercode_sha256(body)), body = NULL, first_line = '', body_expired_at_ms = ?
-        WHERE state = 'cur' AND created_at_ms < ? AND body IS NOT NULL
-        AND NOT EXISTS (SELECT 1 FROM deliveries d WHERE d.mailbox = messages.mailbox AND d.message = messages.id)
-        AND NOT EXISTS (SELECT 1 FROM subscriptions s WHERE s.mailbox = messages.mailbox AND s.message = messages.id)`)
-        .run(now, cutoff).changes;
-      // Completed native questions duplicate an envelope and its answer input.
-      // Keep the claim/binding/header so a repeat cannot submit another answer,
-      // but let go of those text copies after the mailbox copies have expired.
-      const questions = this.statement(`UPDATE mail_records AS r SET record = json_set(
-        json_remove(record, '$.native', '$.answers'), '$.envelope.body', ?, '$.body_expired_at_ms', ?)
-        WHERE collection = 'native_questions' AND json_type(record, '$.envelope') = 'object'
-        AND json_type(record, '$.body_expired_at_ms') IS NULL
-        AND json_extract(record, '$.envelope.created_at_ms') < ?
-        AND EXISTS (SELECT 1 FROM mail_records d WHERE d.collection = 'native_questions'
-          AND d.key = substr(r.key, 1, instr(r.key, '.') - 1) || '.delivered' AND CAST(d.record AS INTEGER) < ?)
-        AND NOT EXISTS (SELECT 1 FROM mail_records w WHERE w.collection = 'native_questions'
-          AND w.key = substr(r.key, 1, instr(r.key, '.') - 1) || '.waiting')
-        AND NOT EXISTS (SELECT 1 FROM messages m WHERE m.id = json_extract(r.record, '$.envelope.id') AND m.body IS NOT NULL)`)
-        .run(RETAINED_BODY, now, cutoff, cutoff).changes;
       const relayRecords = this.statement(`DELETE FROM mail_records AS r WHERE collection = 'relays'
         AND (key LIKE '%/turn.txt' OR key LIKE '%/receipt.json') AND updated_at_ms < ?
         AND NOT EXISTS (SELECT 1 FROM mail_records q WHERE q.collection = 'relays'
           AND q.key = substr(r.key, 1, instr(r.key, '/')) || 'queue.json')`).run(cutoff).changes;
-      const launchInputs = this.statement(`UPDATE mail_records SET record = json_set(
-        json_remove(record, '$.initialInput', '$.claudeInput.text'), '$.input_body_expired_at_ms', ?)
-        WHERE collection = 'native_launches' AND json_type(record, '$.input_body_expired_at_ms') IS NULL
-        AND json_type(record, '$.input_settled_at_ms') = 'integer'
-        AND json_extract(record, '$.input_settled_at_ms') < ?
-        AND (json_type(record, '$.initialInput') = 'text' OR json_type(record, '$.claudeInput.text') = 'text')`)
-        .run(now, cutoff).changes;
       const removed = this.statement(`DELETE FROM messages WHERE (mailbox, id) IN (
         SELECT mailbox, id FROM messages m WHERE state = 'cur' AND body_expired_at_ms IS NOT NULL
         AND NOT EXISTS (SELECT 1 FROM deliveries d WHERE d.mailbox = m.mailbox AND d.message = m.id)
         AND NOT EXISTS (SELECT 1 FROM subscriptions s WHERE s.mailbox = m.mailbox AND s.message = m.id)
         ORDER BY created_at_ms DESC, id DESC LIMIT -1 OFFSET ?)`)
         .run(this.retention.maxReadHeaders).changes;
-      const result = { at_ms: now, expired_bodies: expired, expired_question_records: questions,
-        removed_relay_text_records: relayRecords, expired_launch_inputs: launchInputs, removed_headers: removed, policy: this.retention };
+      const result = { at_ms: now, removed_relay_text_records: relayRecords, removed_headers: removed, policy: this.retention };
       this.setMetadata('retention', result);
-      if (expired || questions || relayRecords || launchInputs || removed) this.changed('retention', result);
+      if (relayRecords || removed) this.changed('retention', result);
       return result;
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.197",
+  "version": "0.3.199",
   "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;
         }
       }