synabun 2.0.5 → 2.0.7

package/neural-interface/lib/whatsapp/baileys-adapter.js

@@ -7,7 +7,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { CONN, ERR, LIMITS } from './protocol.js';
+import { CONN, CONN_WARNINGS, ERR, LIMITS, VOICE_MARKER } from './protocol.js';
 import { parseJid, sameAccount } from './identity.js';
 import { redactWa } from './redact.js';
 
@@ -18,7 +18,7 @@ export const RUNTIME_EXPORTS = Object.freeze([
 ]);
 
 const QUOTED_MAX = 1000;
-const DOWNLOAD_TIMEOUT_MS = 30_000;
+export const DOWNLOAD_TIMEOUT_MS = 30_000;
 const VERSION_RECHECK_MS = 6 * 3600_000;
 
 function adapterError(code, message, cause) {
@@ -235,68 +235,103 @@ export function disconnectCode(err) {
   return null;
 }
 
+// Baileys 7.0.0-rc14 (the pinned connector) closes with 500 for more than a
+// bad session: 500 is DisconnectReason.badSession, but it is also the code
+// getErrorCodeFromStreamError (Utils/generics.js) gives any <stream:error>
+// without a code of its own ("Stream Errored (<first child tag>)", the child
+// node in `data`), the code getCodeFromWSError gives a WebSocket error it
+// cannot place ("WebSocket Error (…)"), and the default of a <failure> without
+// a reason ("Connection Failure"). Baileys itself never names a bad session:
+// only WhatsApp's own stream-error child tag can, and only that wipes the
+// saved credentials. Every other 500 is transport noise and is retried.
+const STREAM_ERROR = /^Stream Errored \(/;
+const INVALID_SESSION_TAG = /\b(?:bad[-_ ]?session|not[-_ ]?authori[sz]ed|invalid[-_ ]?session)\b/i;
+
+/** WhatsApp said the saved session is invalid: a stream error whose reason tag names it (`<not-authorized/>`). */
+export function invalidSessionSignal(err) {
+  const message = typeof err?.message === 'string' ? err.message : '';
+  if (!STREAM_ERROR.test(message)) return false;
+  const tag = typeof err?.data?.tag === 'string' ? err.data.tag : '';
+  return INVALID_SESSION_TAG.test(`${message} ${tag}`);
+}
+
+/** Which kind of generic 500 this is (the reason a log line and lastDisconnect carry). */
+function transportReason(err) {
+  const message = typeof err?.message === 'string' ? err.message : '';
+  if (STREAM_ERROR.test(message)) return 'stream_error';
+  if (/^WebSocket Error \(/.test(message)) return 'websocket_error';
+  if (/^Connection Failure\b/.test(message)) return 'connection_failure';
+  return 'status_500';
+}
+
 /**
  * Map a lastDisconnect error to what the host does next, by DisconnectReason
  * NAME (408 is both connectionLost and timedOut; the enum's reverse map says
- * timedOut).
- * @returns {{action:'reconnect_now'|'refresh_version'|'backoff'|'stop', state:string, wipe:boolean, reason:string, code:number|null}}
+ * timedOut). A saved session never gives up on its own: only 401 (logged out)
+ * and an explicitly invalid session stop it, and both wipe the credentials.
+ * 440 and 403 retry from the longest delay (`delay: 'long'`) and carry a
+ * `warning` the service shows (CONN_WARNINGS). While linking (no saved
+ * session) anything but 515, 405, 401 and 403 means the QR or code ran out.
+ * @returns {{action:'reconnect_now'|'refresh_version'|'backoff'|'stop', state:string, wipe:boolean, reason:string, code:number|null,
+ *   delay?:'long', warning?:'replaced'|'forbidden'}}
  */
 export function classifyDisconnect(err, { linking = false, DisconnectReason = {} } = {}) {
   const code = disconnectCode(err);
   const name = code !== null && typeof DisconnectReason[code] === 'string' ? DisconnectReason[code] : null;
-  const out = (action, state, wipe, reason) => ({ action, state, wipe, reason, code });
+  const out = (action, state, wipe, reason, extra = null) => ({ action, state, wipe, reason, code, ...(extra || {}) });
+  // 500: an explicit bad session, or noise (a generic stream / WebSocket / failure error).
+  const reason = name === 'badSession' ? (invalidSessionSignal(err) ? 'badSession' : transportReason(err)) : name;
   if (code === 405) return out('refresh_version', linking ? CONN.CONNECTING : CONN.RECONNECTING, false, 'outdated_version');
-  switch (name) {
-    case 'restartRequired':
-      return out('reconnect_now', CONN.CONNECTING, false, name);
-    case 'loggedOut':
-      return out('stop', CONN.LOGGED_OUT, true, name);
-    case 'connectionReplaced':
-      return out('stop', CONN.REPLACED, false, name);
-    case 'forbidden':
-      return out('stop', CONN.FORBIDDEN, false, name);
-    case 'badSession':
-    case 'multideviceMismatch':
-      return out('stop', CONN.ERROR, false, name);
-    default:
-      // timedOut / connectionLost / connectionClosed / unavailableService /
-      // anything unknown. While linking that means the QR or code ran out:
-      // stop instead of looping through fresh QR codes.
-      if (linking) return out('stop', CONN.LINK_EXPIRED, true, name || 'link_failed');
-      return out('backoff', CONN.RECONNECTING, false, name || (code === null ? 'closed' : `status_${code}`));
+  if (name === 'restartRequired') return out('reconnect_now', CONN.CONNECTING, false, name);
+  if (name === 'loggedOut') return out('stop', CONN.LOGGED_OUT, true, name);
+  if (linking) {
+    if (name === 'forbidden') return out('stop', CONN.FORBIDDEN, false, name);
+    // A timeout or a closed stream means the QR / code ran out: stop instead of looping through fresh QR codes.
+    return out('stop', CONN.LINK_EXPIRED, true, reason || 'link_failed');
+  }
+  if (reason === 'badSession') return out('stop', CONN.LOGGED_OUT, true, reason);
+  const warning = CONN_WARNINGS[code];
+  if (warning) {
+    // Two copies of one session would kick each other every few seconds, and a refused account is not hammered.
+    return out('backoff', CONN.RECONNECTING, false, name || `status_${code}`, { delay: 'long', warning });
   }
+  // timedOut / connectionLost / connectionClosed / unavailableService / multideviceMismatch /
+  // a generic 500 / anything unknown: keep the credentials and try again.
+  return out('backoff', CONN.RECONNECTING, false, reason || (code === null ? 'closed' : `status_${code}`));
 }
 
 /**
- * Reconnect delays 2/5/15/30/60/120/300 s ±20%; the ladder resets after 10
- * minutes connected; more than 10 reconnects inside 10 minutes gives up.
+ * Reconnect delays 2/4/8/16/32/64/128/256/300 s, each ±20% and never above
+ * 300 s; the ladder starts over after 10 minutes connected (noteStable). It
+ * never gives up. `next({ long: true })` (440, 403) goes to the top at once and
+ * stays there until that stable connection: after a session another copy took
+ * or an account WhatsApp refused, any drop waits the long delay (a refused
+ * account may fail in other ways too, and two copies must not trade quick
+ * retries), the same 10 minutes that end the warning Settings shows.
  */
 export function createReconnectPolicy({
-  now = () => Date.now(),
   rng = Math.random,
-  scheduleSec = [2, 5, 15, 30, 60, 120, 300],
+  scheduleSec = [2, 4, 8, 16, 32, 64, 128, 256, 300],
   jitter = 0.2,
-  limit = 10,
-  windowMs = 10 * 60_000,
+  maxMs = 300_000,
 } = {}) {
   let idx = 0;
-  let attempts = [];
+  let attempts = 0;
   return {
-    /** @returns {{delayMs:number} | {giveUp:true}} */
-    next() {
-      const t = now();
-      attempts = attempts.filter((a) => t - a < windowMs);
-      if (attempts.length >= limit) return { giveUp: true };
-      attempts.push(t);
+    /** @returns {{delayMs:number}} */
+    next({ long = false } = {}) {
+      if (long) idx = Math.max(idx, scheduleSec.length - 1);
       const base = scheduleSec[Math.min(idx, scheduleSec.length - 1)] * 1000;
       idx += 1;
+      attempts += 1;
       const factor = 1 + (rng() * 2 - 1) * jitter;
-      return { delayMs: Math.max(0, Math.round(base * factor)) };
+      return { delayMs: Math.min(maxMs, Math.max(0, Math.round(base * factor))) };
     },
     /** Connected long enough: start the ladder over. */
     noteStable() { idx = 0; },
-    reset() { idx = 0; attempts = []; },
-    get attempts() { return attempts.length; },
+    reset() { idx = 0; attempts = 0; },
+    /** Retries scheduled since the last reset (an explicit connect). */
+    get attempts() { return attempts; },
   };
 }
 
@@ -323,8 +358,8 @@ const DROP_TYPES = Object.freeze({
   stickerPackMessage: 'sticker',
 });
 
+// audioMessage (voice notes and audio files) is kind 'audio': transcribed on this computer (transcription.js).
 const UNSUPPORTED = Object.freeze({
-  audioMessage: 'audio',
   videoMessage: 'video',
   ptvMessage: 'video',
   documentMessage: 'document',
@@ -347,7 +382,7 @@ function captionOf(inner) {
 
 /**
  * Classify the content of one message without downloading anything.
- * @returns {{drop:string} | {type:string, kind:'text'|'image'|'unsupported', inner:object|null,
+ * @returns {{drop:string} | {type:string, kind:'text'|'image'|'audio'|'unsupported', inner:object|null,
  *   contextInfo:object|null, text:string, unsupportedType:string|null}}
  */
 export function describeContent(msg, mod) {
@@ -370,6 +405,9 @@ export function describeContent(msg, mod) {
   if (type === 'imageMessage') {
     return { type, kind: 'image', inner, contextInfo, text: captionOf(inner), unsupportedType: null };
   }
+  if (type === 'audioMessage') {
+    return { type, kind: 'audio', inner, contextInfo, text: captionOf(inner), unsupportedType: null };
+  }
   return { type, kind: 'unsupported', inner, contextInfo, text: captionOf(inner), unsupportedType: UNSUPPORTED[type] || 'other' };
 }
 
@@ -401,13 +439,65 @@ function withTimeout(promise, ms, label) {
 
 const MSG_ID_RE = /^[A-Za-z0-9._:+/=-]{1,128}$/;
 
+/** A size or duration a message declares about itself (a number, a protobuf Long, a string), or null when it says none. */
+function declared(value) {
+  if (value === null || value === undefined || value === '') return null;
+  let n = NaN;
+  if (typeof value === 'number') n = value;
+  else if (typeof value === 'bigint' || typeof value === 'string') n = Number(value);
+  else if (typeof value?.toNumber === 'function') { try { n = value.toNumber(); } catch { n = NaN; } }
+  return Number.isFinite(n) && n >= 0 ? n : null;
+}
+
+/**
+ * A voice note or audio file (kind 'audio'), only for a message host-core already accepted:
+ * → { transcript, recorded } or { unsupported: { type: 'audio', reason } }. `recorded`: a voice note
+ * the sender recorded in WhatsApp (ptt), not an audio file attached to the chat. Nothing is downloaded while
+ * transcription is off or cannot run here, or when the message says it is over a limit.
+ *   transcriber  transcription.js createTranscriber() (enabled, available(), transcribe())
+ *   stale        sent so long ago that the bridge will skip it anyway: not worth transcribing
+ */
+async function readAudio(msg, { mod, sock, logger, inner, transcriber, stale }) {
+  const refuse = (reason) => ({ unsupported: { type: 'audio', reason } });
+  if (!transcriber || !transcriber.enabled) return refuse('transcription_disabled');
+  let ready = false;
+  try { ready = transcriber.available() === true; } catch { ready = false; }
+  if (!ready) return refuse('transcription_unavailable');
+  if ((declared(inner?.fileLength) ?? 0) > LIMITS.MAX_AUDIO_BYTES) return refuse('too_large');
+  if ((declared(inner?.seconds) ?? 0) > LIMITS.MAX_AUDIO_SECONDS) return refuse('too_long');
+  if (stale) return refuse('stale');
+  let bytes;
+  try {
+    const buf = await withTimeout(
+      mod.downloadMediaMessage(msg, 'buffer', {}, { logger, reuploadRequest: sock?.updateMediaMessage }),
+      DOWNLOAD_TIMEOUT_MS,
+      'audio download',
+    );
+    bytes = Buffer.isBuffer(buf) ? buf : Buffer.from(buf || []);
+  } catch {
+    return refuse('transcription_failed');
+  }
+  if (bytes.length > LIMITS.MAX_AUDIO_BYTES) return refuse('too_large');
+  if (!bytes.length) return refuse('transcription_failed');
+  let result = null;
+  try { result = await transcriber.transcribe(bytes); } catch { result = null; }
+  if (result?.ok && typeof result.text === 'string' && result.text.trim()) return { transcript: result.text.trim(), recorded: inner?.ptt === true };
+  // Turned off while the note waited its turn: said as such, not as a failure.
+  return refuse(['too_long', 'too_large', 'transcription_disabled'].includes(result?.reason) ? result.reason : 'transcription_failed');
+}
+
 /**
  * Turn an accepted message into the parts of an InboundMessage (never a JID).
- * @returns {Promise<{text:string, images:Array, unsupported:null|{type:string, reason?:string}, forwarded:boolean, quoted:null|{id:string,text:string,fromBot:boolean}}>}
+ * A transcribed voice note: `text` is VOICE_MARKER + the transcript, then "\n" + the caption when
+ * there is one (the transcript first when the text is cut), and `voice: true`; `audioFile: true` when
+ * it is an audio file rather than a note recorded in WhatsApp (its words may be anyone's: the bridge
+ * treats it like a picture).
+ * @returns {Promise<{text:string, images:Array, unsupported:null|{type:string, reason?:string}, forwarded:boolean,
+ *   quoted:null|{id:string,text:string,fromBot:boolean}, voice:boolean, audioFile:boolean}>}
  */
-export async function extractInbound(msg, { mod, sock, logger, sentIds, described, text }) {
+export async function extractInbound(msg, { mod, sock, logger, sentIds, described, text, transcriber = null, audioStale = false }) {
   const d = described;
-  const body = String(text ?? d.text ?? '').slice(0, LIMITS.MAX_INBOUND_TEXT);
+  let body = String(text ?? d.text ?? '').slice(0, LIMITS.MAX_INBOUND_TEXT);
   const ctx = d.contextInfo;
   const forwarded = !!(ctx && (ctx.isForwarded || Number(ctx.forwardingScore) > 0));
   let quoted = null;
@@ -420,7 +510,21 @@ export async function extractInbound(msg, { mod, sock, logger, sentIds, describe
   }
   const images = [];
   let unsupported = null;
+  let voice = false;
+  let audioFile = false;
   if (d.kind === 'unsupported') unsupported = { type: d.unsupportedType };
+  if (d.kind === 'audio') {
+    const audio = await readAudio(msg, { mod, sock, logger, inner: d.inner, transcriber, stale: audioStale });
+    if (audio.transcript) {
+      const caption = String(text ?? d.text ?? '');
+      body = `${VOICE_MARKER} ${audio.transcript}${caption.trim() ? `\n${caption}` : ''}`.slice(0, LIMITS.MAX_INBOUND_TEXT);
+      voice = true;
+      audioFile = !audio.recorded;
+    } else {
+      // The same unsupported-audio shape as before, with why; a caption still gets through.
+      unsupported = audio.unsupported;
+    }
+  }
   if (d.kind === 'image') {
     const mime = String(d.inner?.mimetype || '').split(';')[0].trim().toLowerCase();
     const declared = Number(d.inner?.fileLength ?? 0);
@@ -443,7 +547,23 @@ export async function extractInbound(msg, { mod, sock, logger, sentIds, describe
       }
     }
   }
-  return { text: body, images, unsupported, forwarded, quoted };
+  return { text: body, images, unsupported, forwarded, quoted, voice, audioFile };
+}
+
+/**
+ * The sendMessage content for a file prepared by local-file.js (prepareLocalFile): a document
+ * (mimetype + fileName, the caption when there is one), a photo or a video (the caption), or audio
+ * (never a caption, never a voice note). `jpegThumbnail: null` keeps Baileys from building a preview,
+ * which for a video means running FFmpeg through a shell: SynaBun never decodes the file it sends.
+ */
+export function fileMessage(file) {
+  const caption = typeof file?.caption === 'string' && file.caption ? { caption: file.caption } : {};
+  switch (file?.type) {
+    case 'image': return { image: file.data, mimetype: file.mimetype, jpegThumbnail: null, ...caption };
+    case 'video': return { video: file.data, mimetype: file.mimetype, jpegThumbnail: null, ...caption };
+    case 'audio': return { audio: file.data, mimetype: file.mimetype, ptt: false };
+    default: return { document: file.data, mimetype: file.mimetype, fileName: file.fileName || 'file', ...caption };
+  }
 }
 
 /** The minimal message Baileys needs to quote an owner message in a reply. */

package/neural-interface/lib/whatsapp/bridge.js

@@ -13,6 +13,14 @@
 // owner's messages; a synabun.mailbox event is RUNNING(mailbox), a turn the
 // CLI starts itself RUNNING(background), and a turn nobody here submitted (a
 // prompt typed on the desktop) RUNNING(external) — tracked, never forwarded.
+// A task the router continues on another model (a synabun.continuation event:
+// a route decided automatically, by a remembered route, or on a card) answers
+// where its prompt came from: RUNNING(followup) for a prompt from the phone,
+// whose answer is sent once as the reply (not an update, whatever "Forward
+// background results" says), RUNNING(external) for any other. A follow-up is
+// how a turn's answer is delivered, nothing more: what may run unasked or be
+// approved is the runtime's (a continuation is its own turn, never the owner's
+// message: computer use asks once in it) and the owner's typed answers.
 // The turn object exists before submit is called: brain events can arrive
 // before it resolves.
 //
@@ -23,8 +31,9 @@
 // closes WITHOUT being granted (denied, cancelled) and the message goes to the
 // Assistant as the next prompt. An approval is only ever granted by a "yes"
 // the bridge matched on a message the owner typed, aimed at that request while
-// it is open: never by the model, by a forwarded message, by a reply that
-// quotes something else or by anything that merely looks like an answer.
+// it is open: never by the model, by a forwarded message, by a voice note (its
+// transcript is an ordinary message, `voice: true`), by a reply that quotes
+// something else or by anything that merely looks like an answer.
 // Messages that arrive while a turn runs wait as one merged prompt and go in
 // as soon as it ends; a queue watch lets go of a turn whose end never came.
 // A request that appears while such a message waits closes at once, unseen and
@@ -87,14 +96,28 @@ export const BRIDGE_LIMITS = Object.freeze({
   policyTickMs: 30_000,
 });
 
+/**
+ * Why a voice note was not transcribed (the host's unsupported.reason), told to the phone once per
+ * reason every unsupportedEveryMs. Anything else unsupported gets the generic line.
+ */
+export const AUDIO_NOT_TRANSCRIBED = Object.freeze({
+  transcription_disabled: 'Voice notes are not transcribed: that is turned off in Settings → WhatsApp on your computer. Type your message instead.',
+  transcription_unavailable: 'I can\'t transcribe voice notes yet: this computer needs whisper.cpp, its speech model and FFmpeg (Settings → WhatsApp says what is missing). Type your message instead.',
+  too_large: 'That voice note is too large for me to transcribe (20 MB at most). Send a shorter one, or type it.',
+  too_long: 'That voice note is too long for me to transcribe (10 minutes at most). Send a shorter one, or type it.',
+  stale: 'That voice note was sent a while ago, so I did not transcribe it. Send it again if you still need it.',
+  transcription_failed: 'I couldn\'t transcribe that voice note. Try again, or type your message.',
+});
+
 /** Send refusals that mean "not now": the reply waits in the outbox for the next connect. */
 const RESEND_ON_CONNECT = /DISCONNECT|NOT_CONNECTED|OFFLINE|RECONNECT|CLOSED|TIMEOUT|HOST_UNAVAILABLE/i;
 /**
  * What happens to a reply the transport refused: 'connect' (it waits for the
  * next connect), 'later' (THROTTLED: sent again after its retryAfterMs) or
- * 'drop'. PAUSED (an owner anomaly paused sending) and HELD (the connector
- * kept crashing) drop it: the service records why in the activity log and the
- * Settings tab shows the state.
+ * 'drop'. PAUSED (an owner anomaly paused sending) and HELD (a connector
+ * process of another SynaBun version, down until a restart; a crash is not
+ * HELD: it reads HOST_UNAVAILABLE and the reply waits) drop it: the service
+ * records why in the activity log and the Settings tab shows the state.
  */
 export function outboxPlan(code) {
   const value = String(code || '');
@@ -104,7 +127,7 @@ export function outboxPlan(code) {
 
 const DEFAULT_CONFIG = Object.freeze({
   enabled: true, level: 'ask', progress: 'key', forwardBackground: true, replyLabel: null, maxMessages: 3,
-  rotation: 'idle6h', strictWorkerApprovals: false, computerUse: false, mode: 'self', paused: false, pausedBy: null, autonomousUntil: null,
+  rotation: 'idle6h', strictWorkerApprovals: false, computerUse: false, mode: 'self', paused: false, pausedBy: null,
 });
 const ALREADY_ANSWERED = new Set(['CONTROL_UNKNOWN', 'ROUTE_ALREADY_DECIDED', 'ROUTE_NOT_FOUND', 'CLARIFY_ALREADY_ANSWERED', 'CLARIFY_NOT_FOUND', 'PERMISSION_ALREADY_RESOLVED', 'NO_PENDING_REQUEST', 'RUN_NOT_FOUND']);
 const ROUTE_DONE_PHASES = new Set(['decided', 'auto', 'expired', 'declined', 'cancelled']);
@@ -191,6 +214,8 @@ export function createWhatsAppBridge({
     outboxTimer: null,            // a THROTTLED reply's retry
     staleSkipped: 0,
     staleTimer: null,
+    stoppedAt: 0,                 // when the owner's last /stop was sent (its message time)
+    stopLateNoted: false,         // one note per /stop for what was sent before it and arrived after it
     unsupportedAt: new Map(),
     minuteWindow: { start: 0, count: 0, noticed: false },
     dayWindow: { start: 0, count: 0, noticed: false },
@@ -435,14 +460,16 @@ export function createWhatsAppBridge({
     state.brainApplied = { sessionId, signature };
     persistBridgeState();
   }
+  // Autonomous has no time limit on WhatsApp: the policy carries no autonomousUntil (lib/remote-policy.js effectiveLevel).
+  // WhatsApp turned off on this computer (`enabled: false`, which also stops the connector) ends computer use like the switch.
   function remoteFromConfig(cfg = readConfig()) {
-    return { channel: 'whatsapp', level: cfg.level || 'ask', strictWorkerApprovals: cfg.strictWorkerApprovals === true, autonomousUntil: cfg.autonomousUntil || null, paused: state.paused, computerUse: cfg.computerUse === true && state.computerEnded !== true };
+    return { channel: 'whatsapp', level: cfg.level || 'ask', strictWorkerApprovals: cfg.strictWorkerApprovals === true, paused: state.paused, computerUse: cfg.computerUse === true && cfg.enabled !== false && state.computerEnded !== true };
   }
   /** The policy of one of our sessions: computer use is the current conversation's alone. */
   function remoteFor(id, base = remoteFromConfig()) {
     return id === state.sessionId ? base : { ...base, computerUse: false };
   }
-  const policySignature = (remote) => JSON.stringify([remote.level, remote.strictWorkerApprovals, remote.autonomousUntil, remote.paused, remote.computerUse]);
+  const policySignature = (remote) => JSON.stringify([remote.level, remote.strictWorkerApprovals, remote.paused, remote.computerUse]);
   async function createSession() {
     const rt = runtime();
     if (!rt?.createSession) throw Object.assign(new Error('The Assistant is not available right now.'), { code: 'RUNTIME_UNAVAILABLE' });
@@ -500,9 +527,8 @@ export function createWhatsAppBridge({
   // ── policy ─────────────────────────────────────────────────────────────────
   /**
    * Keep the level of every WhatsApp session in line with the config (level,
-   * strict approvals, the autonomous window, pause). A change — or an
-   * autonomous window that just ran out — re-registers, which makes the
-   * runtime re-apply the clamp and stop runs above it.
+   * strict approvals, pause, computer use). A change re-registers, which makes
+   * the runtime re-apply the clamp and stop runs above it.
    */
   function syncPolicies() {
     const cfg = readConfig();
@@ -652,7 +678,8 @@ export function createWhatsAppBridge({
       if (turn.kind === 'followup') state.followUp = null;
       else { presence('paused'); state.inflight = null; persistBridgeState(); react(turn.sourceIds, 'done'); }
     } else if (turn.kind === 'followup') {
-      // The task the phone decided on a card: its answer is a reply, not an update.
+      // The task the phone decided on a card, or that its prompt carried on to another model: its answer
+      // is a reply, not an update. Said once: the turn is gone already, a repeated end finds nothing.
       state.followUp = null;
       const text = finalText(turn);
       if (outcome === 'failed') await say(`Something went wrong: ${String(message || turn.resultError || 'the turn failed').slice(0, 400)}`, { maxChunks: 1 });
@@ -767,6 +794,12 @@ export function createWhatsAppBridge({
         // Our own prompt (the WhatsApp turn exists already); any other is someone else's turn.
         if (ev.origin !== 'whatsapp' && !state.turns.has(sessionId)) makeTurn(sessionId, 'external');
         return;
+      case 'synabun.continuation':
+        // The router carries a task on (another model, the same conversation), before any of its output.
+        // A prompt from the phone: its answer is the reply to the phone. Anything else stays as before:
+        // someone else's turn, unless a card the phone saw was just decided (ensureTurn).
+        if (!state.turns.has(sessionId)) ensureTurn(sessionId, ev.origin === 'whatsapp' ? 'followup' : 'external');
+        return;
       case 'synabun.mailbox': {
         const items = Array.isArray(ev.items) ? ev.items : [];
         const turn = state.turns.get(sessionId);
@@ -1031,6 +1064,10 @@ export function createWhatsAppBridge({
       case 'help': await say(HELP_TEXT, { maxChunks: 2 }); return;
       case 'status': await say(statusText(statusSnapshot()), { maxChunks: 1 }); return;
       case 'stop': {
+        // What was sent before this /stop and arrives after it (a voice note still being transcribed, and
+        // what waited behind it) is not acted on, as /stop clears what already waits in line.
+        state.stoppedAt = Math.max(state.stoppedAt, tsMs(message.ts, now()));
+        state.stopLateNoted = false;
         const { stoppedRuns, clearedQueue } = await stopEverything({ reason: 'phone' });
         const n = stoppedRuns + clearedQueue;
         await say(`Stopped. Cancelled ${n} task${n === 1 ? '' : 's'}.`, { maxChunks: 1 });
@@ -1067,18 +1104,14 @@ export function createWhatsAppBridge({
   function statusSnapshot() {
     const view = state.sessionId ? sessionView(state.sessionId) : null;
     const turn = state.sessionId ? state.turns.get(state.sessionId) : null;
-    const rt = runtime();
-    let brainCapUsd = null;
-    try { brainCapUsd = rt?.brainCapUsd?.() ?? null; } catch { brainCapUsd = null; }
     const cfg = readConfig();
     const current = currentCard();
     return {
       connected: isConnected(), sessionId: state.sessionId, title: view?.title || null, brain: view?.brain || null,
       running: !!turn || !!view?.running, turnKind: turn?.kind || null, queued: state.queue.length,
       pendingCards: state.cards.size, currentCard: current ? (current.kind === 'route' ? 'where to run a task' : current.kind === 'computer' ? 'controlling your Mac' : current.kind) : null,
-      budget: view?.budget || null, brainUsd: view?.costUsd ?? null, brainCapUsd,
+      budget: view?.budget || null, brainUsd: view?.costUsd ?? null,
       level: state.sessionId ? levelOf(state.sessionId) : cfg.level, paused: state.paused, pausedBy: state.pausedBy,
-      autonomousUntil: cfg.autonomousUntil || null,
     };
   }
   /** /stop and stopAll: the turn, the session's runs, open cards and the queue. */
@@ -1168,6 +1201,16 @@ export function createWhatsAppBridge({
     // `backlog`): never acted on, only counted for one note. Checked first, so a
     // backlog neither uses up the rate limits nor counts as activity.
     if (now() - tsMs(message.ts, now()) > L.staleMs) { noteStale(); return; }
+    // Sent before the owner's last /stop, delivered after it (a typed /stop does not wait for a voice note
+    // being transcribed): /stop already stopped it. A command still runs. What WhatsApp held while SynaBun was
+    // offline arrives in order and is never overtaken (a backlog is never sent ahead), so it is not affected.
+    if (state.stoppedAt && message.backlog !== true && tsMs(message.ts, now()) < state.stoppedAt && !parseCommand(message)) {
+      if (!state.stopLateNoted) {
+        state.stopLateNoted = true;
+        await say('A message you sent before /stop arrived after it, so I did not act on it. Send it again if you still need it.', { maxChunks: 1 });
+      }
+      return;
+    }
     if (rateLimited()) return;
     const activityBefore = state.lastActivityAt;
     state.lastActivityAt = now();
@@ -1178,10 +1221,12 @@ export function createWhatsAppBridge({
     const images = Array.isArray(message.images) ? message.images : [];
     if (message.unsupported && !text.trim() && !images.length) {
       const type = String(message.unsupported.type || 'this kind of');
-      const last = state.unsupportedAt.get(type) || 0;
+      const audio = type === 'audio' && Object.hasOwn(AUDIO_NOT_TRANSCRIBED, String(message.unsupported.reason)) ? AUDIO_NOT_TRANSCRIBED[message.unsupported.reason] : null;
+      const key = audio ? `audio:${message.unsupported.reason}` : type;
+      const last = state.unsupportedAt.get(key) || 0;
       if (now() - last >= L.unsupportedEveryMs) {
-        state.unsupportedAt.set(type, now());
-        await say(`I can read text and pictures for now; ${type} messages are not supported yet.`, { maxChunks: 1 });
+        state.unsupportedAt.set(key, now());
+        await say(audio || `I can read text and pictures for now; ${type} messages are not supported yet.`, { maxChunks: 1 });
       }
       return;
     }
@@ -1198,8 +1243,8 @@ export function createWhatsAppBridge({
     }
     // Something is waiting for the owner: a clear answer answers it; anything else closes it
     // without a grant and carries on as the next prompt. Only words the owner typed can answer:
-    // never a forwarded message, a picture or "//text".
-    const answerable = !images.length && command?.kind !== 'literal' && message.forwarded !== true;
+    // never a forwarded message, a picture, a voice note (its transcript) or "//text".
+    const answerable = !images.length && command?.kind !== 'literal' && message.forwarded !== true && message.voice !== true;
     if (await replyToPending(message, { answerable })) return;
     if (rotationDue(activityBefore)) state.rotateOnNextSubmit = true;
     // A request raised between that look and here is older than this message too (onCard only sees
@@ -1271,7 +1316,7 @@ export function createWhatsAppBridge({
     if (!list.length) return;
     let composed = null;
     try { composed = inbound?.composePrompt ? inbound.composePrompt(list, { rng }) : null; } catch (error) { log('whatsapp:bridge', `compose: ${error?.message || error}`); }
-    if (!composed) composed = { text: list.map((part) => String(part.text || '')).filter(Boolean).join('\n\n'), images: list.flatMap((part) => part.images || []), sourceIds: list.map((part) => part.id).filter(Boolean), untrusted: list.some((part) => part.forwarded || part.quoted) };
+    if (!composed) composed = { text: list.map((part) => String(part.text || '')).filter(Boolean).join('\n\n'), images: list.flatMap((part) => part.images || []), sourceIds: list.map((part) => part.id).filter(Boolean), untrusted: list.some((part) => part.forwarded || part.quoted || part.audioFile === true) };
     const images = Array.isArray(composed.images) ? composed.images.filter(Boolean) : [];
     const job = {
       text: String(composed.text || ''), images,
@@ -1402,22 +1447,21 @@ export function createWhatsAppBridge({
     }
     persistBridgeState();
     react(job.sourceIds, 'failed');
-    if (code === 'SESSION_BUDGET_EXCEEDED' || code === 'BRAIN_BUDGET_EXCEEDED') { await say(budgetText(code, sessionId, result.message), { maxChunks: 1 }); return; }
+    if (code === 'SESSION_BUDGET_EXCEEDED' || code === 'BRAIN_SHARE_EXHAUSTED') { await say(budgetText(code, sessionId, result.message), { maxChunks: 1 }); return; }
     if (code === 'EMPTY_PROMPT') return;
     await say(`Could not start that: ${String(result.message || code).slice(0, 400)}`, { maxChunks: 1 });
   }
-  /** Spend against the cap, and the two ways on: /new or a higher cap. Never a silent new session. */
+  /** Spend against the budget, and the two ways on: /new or a higher budget. Never a silent new session. */
   function budgetText(code, sessionId, fallback) {
     const view = sessionView(sessionId);
+    const budget = view?.budget || null;
     let line = '';
-    if (code === 'SESSION_BUDGET_EXCEEDED' && view?.budget && Number.isFinite(Number(view.budget.hardUsd))) {
-      line = `This conversation spent ${usd(view.budget.totalUsd)} of its ${usd(view.budget.hardUsd)} cap.`;
-    } else if (code === 'BRAIN_BUDGET_EXCEEDED') {
-      let cap = null;
-      try { cap = runtime()?.brainCapUsd?.() ?? null; } catch { cap = null; }
-      line = cap !== null ? `The Assistant spent ${usd(view?.costUsd)} of its ${usd(cap)} cap in this conversation.` : '';
+    if (code === 'SESSION_BUDGET_EXCEEDED' && budget && Number.isFinite(Number(budget.amountUsd))) {
+      line = `This conversation spent ${usd(budget.totalUsd)} of its ${usd(budget.amountUsd)} budget.`;
+    } else if (code === 'BRAIN_SHARE_EXHAUSTED' && budget && Number.isFinite(Number(budget.amountUsd))) {
+      line = `The Assistant's share of this conversation's ${usd(budget.amountUsd)} budget is used up.`;
     }
-    return `${line || String(fallback || 'This conversation reached its budget cap.')} Send /new to start a fresh conversation, or raise the cap in SynaBun.`;
+    return `${line || String(fallback || 'This conversation reached its budget.')} Send /new to start a fresh conversation, or raise the budget (or choose No limit) in SynaBun.`;
   }
 
   // ── lifecycle ──────────────────────────────────────────────────────────────
@@ -1484,14 +1528,14 @@ export function createWhatsAppBridge({
     persistBridgeState();
   }
 
-  // Keep the level in line with the config (Settings edits, the autonomous window running out).
+  // Keep the level in line with the config (a change that reached it without a refresh).
   state.policyTimer = T.setInterval(() => { try { runtime(); syncPolicies(); } catch {} }, L.policyTickMs);
   state.policyTimer?.unref?.();
   runtime();
 
   return {
     onInbound, onConnection, status, newSession, pause, resume, stopAll, shutdown,
-    // Settings changed (level, strict approvals, autonomous window): re-apply now instead of at the next tick.
+    // Settings changed (level, strict approvals, computer use): re-apply now instead of at the next tick.
     refresh: () => { state.policySeen.clear(); runtime(); syncPolicies(); return status(); },
     endComputerUse,
     _internals: { state, finalText, syncPolicies, drain, onPacket, brainTarget, moveOn },

package/neural-interface/lib/whatsapp/commands.js

@@ -2,10 +2,10 @@
 // SynaBun — WhatsApp Link: the owner's slash commands
 // ═══════════════════════════════════════════
 //
-// Pure parsing and fixed texts. A command is the owner's own text — never a
-// forwarded or quoted message — that starts with one of COMMANDS
-// (case-insensitive). Commands run at once, busy or paused. Any other "/x" is
-// a prompt; "//x" sends the literal "/x". No command raises the level or
+// Pure parsing and fixed texts. A command is the owner's own typed text —
+// never a forwarded or quoted message, never a voice note — that starts with
+// one of COMMANDS (case-insensitive). Commands run at once, busy or paused.
+// Any other "/x" is a prompt; "//x" sends the literal "/x". No command raises the level or
 // changes a setting: those names get a fixed refusal (they would otherwise
 // reach the brain's CLI as its own slash commands).
 
@@ -21,7 +21,7 @@ const REFUSED = new Set([
 
 export const HELP_TEXT = [
   '*SynaBun on WhatsApp*',
-  'Write to me like you would in SynaBun. Pictures work too.',
+  'Write to me like you would in SynaBun. Pictures work too, and voice notes when this computer can transcribe them.',
   '',
   '/status — what I am doing, spend and level',
   '/stop — stop the current task, its agents and anything waiting for your answer',
@@ -31,7 +31,7 @@ export const HELP_TEXT = [
   '/cards — ask again what is still waiting for your answer',
   '/help — this list',
   '',
-  'When I ask something, just answer in your own words. An approval takes a plain yes or no; any other message approves nothing and carries on the conversation. Start with // to send text that begins with a slash.',
+  'When I ask something, just answer in your own words. An approval takes a plain yes or no, typed; any other message (a voice note too) approves nothing and carries on the conversation. Start with // to send text that begins with a slash.',
   'Levels, models and other settings change only in SynaBun on your computer (Settings → WhatsApp).',
 ].join('\n');
 
@@ -40,10 +40,10 @@ export const SETTINGS_REFUSAL = 'Settings change only in SynaBun on your compute
 /**
  * An inbound message → { kind: 'command', name, args } | { kind: 'refused', name }
  * | { kind: 'literal', text } ("//x" → "/x") | null (not a command: a prompt).
- * Only the owner's own text counts: forwarded or quoted messages are prompts.
+ * Only the owner's own typed text counts: forwarded or quoted messages and voice notes are prompts.
  */
 export function parseCommand(message) {
-  if (!message || message.owner === false || message.forwarded || message.quoted) return null;
+  if (!message || message.owner === false || message.forwarded || message.quoted || message.voice === true) return null;
   const text = String(message.text ?? '').trim();
   if (!text.startsWith('/')) return null;
   if (text.startsWith('//')) return { kind: 'literal', text: text.slice(1) };
@@ -66,8 +66,8 @@ function levelLabel(level) {
 
 /**
  * /status text from a snapshot: { connected, sessionId, title, brain:{provider,model},
- * running, turnKind, queued, pendingCards, currentCard, budget:{totalUsd, hardUsd},
- * brainUsd, brainCapUsd, level, paused, pausedBy, autonomousUntil }.
+ * running, turnKind, queued, pendingCards, currentCard, budget:{ unlimited, totalUsd, amountUsd, leftUsd },
+ * brainUsd, level, paused, pausedBy }. Autonomous has no time limit: it holds until it is turned off in Settings.
  */
 export function statusText(s = {}) {
   const lines = ['*SynaBun status*'];
@@ -83,10 +83,9 @@ export function statusText(s = {}) {
     : 'idle';
   lines.push(`Now: ${doing}${s.queued ? ` · ${s.queued} message${s.queued === 1 ? '' : 's'} queued` : ''}`);
   if (s.pendingCards) lines.push(`Waiting for you: ${s.pendingCards} question${s.pendingCards === 1 ? '' : 's'} or approval${s.pendingCards === 1 ? '' : 's'}${s.currentCard ? ` (${s.currentCard})` : ''} — /cards asks again`);
-  if (s.budget && Number.isFinite(Number(s.budget.hardUsd))) lines.push(`Spend: ${usd(s.budget.totalUsd)} of ${usd(s.budget.hardUsd)} session cap${Number.isFinite(Number(s.brainCapUsd)) ? ` (brain ${usd(s.brainUsd)} of ${usd(s.brainCapUsd)})` : ''}`);
-  let level = `Level: ${levelLabel(s.level)}`;
-  if (s.level === 'autonomous' && s.autonomousUntil) level += ` until ${new Date(Number(s.autonomousUntil)).toTimeString().slice(0, 5)}`;
-  lines.push(level);
+  if (s.budget?.unlimited === true) lines.push(`Spend: ${usd(s.budget.totalUsd)} (no limit)`);
+  else if (s.budget && Number.isFinite(Number(s.budget.amountUsd))) lines.push(`Spend: ${usd(s.budget.totalUsd)} of the ${usd(s.budget.amountUsd)} budget${Number.isFinite(Number(s.brainUsd)) ? ` (brain ${usd(s.brainUsd)})` : ''}`);
+  lines.push(`Level: ${levelLabel(s.level)}${s.level === 'autonomous' ? ' until turned off' : ''}`);
   if (s.paused) lines.push(`Paused${s.pausedBy === 'desktop' ? ' from your computer' : ''} — ${s.pausedBy === 'desktop' ? 'resume it in SynaBun' : 'send /resume'}`);
   return lines.join('\n');
 }