@bill10/agent-007 0.9.2000 → 0.9.3000

package/.env.example

@@ -55,6 +55,11 @@
 # always speaks every message; never is text only. Speaking needs macOS `say`
 # and ffmpeg; long or link-heavy messages always go as text.
 # TELEGRAM_VOICE=mirror
+# The macOS voice Billion speaks with, as `say -v '?'` lists it. Unset: the best
+# installed English voice, Premium then Enhanced (download them free in System
+# Settings > Accessibility > Spoken Content > System voice > Manage Voices),
+# else say's default. A voice that is not installed is logged and skipped.
+# SAY_VOICE=Ava (Premium)
 # Your voice notes are transcribed with whisper.cpp (brew install whisper-cpp).
 # WHISPER_MODEL is the full path to a ggml model, e.g. ggml-base.en.bin;
 # WHISPER_CPP_BIN only if whisper-cli is not on PATH. Unset: voice notes get a

package/VERSION

@@ -1 +1 @@
-0.9.2.0
+0.9.3.0

package/bin/agent-007.js

@@ -45,6 +45,8 @@ Settings (default in brackets):
   TELEGRAM_CHAT_ID        Your chat with that bot; only it reaches Billion [none]
   TELEGRAM_VOICE          mirror, always or never: Billion's messages as
                           voice (macOS say + ffmpeg) [mirror]
+  SAY_VOICE               macOS voice for that, from say -v '?' [best
+                          installed English Premium/Enhanced voice]
   WHISPER_MODEL           whisper.cpp model file; your voice notes are
                           transcribed locally [off]
   WHISPER_CPP_BIN         whisper.cpp CLI if not on PATH [whisper-cli]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bill10/agent-007",
-  "version": "0.9.2000",
+  "version": "0.9.3000",
   "description": "From web terminals for your coding agents to a self-running agent company: Claude Code and Codex in parallel git worktrees, a job board they pick work from, and one agent that runs the board from a goal.",
   "license": "MIT",
   "repository": {

package/server/messages.js

@@ -35,6 +35,14 @@ export const USER_TYPING_HOLD_MS = 30 * 1000;
 // Enter is a newline; with this gap codex-cli 0.155.1 takes paste and Enter as
 // one turn (checked in review).
 export const SUBMIT_DELAY_MS = 150;
+// Claude Code (2.1.x) folds a long paste into a "[Pasted text #1]" placeholder
+// and hands the model that part wrapped as pasted_content, which it treats as
+// maybe not from the user: a long message got a question back, not action.
+// Seen at 500 chars or 31 lines in one paste; 300 chars, or a line or two,
+// comes through as plain typing. So a message goes in as many small pastes,
+// a line or less each, still bracketed so a newline stays a newline.
+export const PASTE_CHUNK_CHARS = 200;
+export const PASTE_GAP_MS = 10;
 
 const queues = new Map();   // recipient session id -> [formatted text]
 // How many at the front of a queue the server wrote (approvals, board
@@ -44,7 +52,7 @@ const queues = new Map();   // recipient session id -> [formatted text]
 const serverAhead = new Map();
 const sends = new Map();    // `${from.id}>${to.id}` -> [timestamps]
 
-// Everything but newline and tab. The text goes inside a bracketed paste, and a
+// Everything but newline and tab. The text goes inside bracketed pastes, and a
 // message carrying ESC[201~ would end the paste early and type the rest as raw
 // keystrokes — arrow keys, Enter, whatever it liked.
 const clean = (s) => String(s ?? '').replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, '');
@@ -147,7 +155,7 @@ export function formatNotice(headline, lines = []) {
 // the permission rule nor the pair limit applies; the queue cap does, and
 // text over it is refused.
 //
-// Cleaned here, whoever wrote it: it goes into a bracketed paste, and a stray
+// Cleaned here, whoever wrote it: it goes into bracketed pastes, and a stray
 // ESC[201~ anywhere in it — a tool name, a card title — would end the paste
 // and type the rest as keystrokes of the user's own.
 export function sendText(session, text, now = Date.now()) {
@@ -185,6 +193,8 @@ export function canDeliver(session, now = Date.now()) {
   // Billion holds its mail until it says it is ready (billion_ready), so
   // nothing lands in the middle of its introduction.
   if (session.messagesHeld) return false;
+  // Still typing the last one: a second would interleave with its pastes.
+  if (session.messageTyping) return false;
   // Both: the stored state is up to a second old, and a dialog that opened
   // since is what this must not type into.
   if (session.exited || session.state !== 'WAITING' || detectState(session, { now }) !== 'WAITING') return false;
@@ -202,23 +212,42 @@ function write(session, data) {
   try { session.pty.write(data); return true; } catch { return false; }
 }
 
+// Lines, newline kept, cut to PASTE_CHUNK_CHARS by code point so an emoji's
+// surrogate pair is never split across two pastes.
+export function pasteChunks(text) {
+  return text.split(/(?<=\n)/).flatMap(line => {
+    const chars = Array.from(line);
+    const out = [];
+    for (let i = 0; i < chars.length; i += PASTE_CHUNK_CHARS) out.push(chars.slice(i, i + PASTE_CHUNK_CHARS).join(''));
+    return out;
+  });
+}
+
 function deliver(session, text, now) {
   session.messageDeliveredAt = now;
-  write(session, `\x1b[200~${text}\x1b[201~`);
+  session.messageTyping = true;
+  const chunks = pasteChunks(text);
+  const type = () => {
+    if (session.exited) return;
+    write(session, `\x1b[200~${chunks.shift()}\x1b[201~`);
+    setTimeout(chunks.length ? type : submit, chunks.length ? PASTE_GAP_MS : SUBMIT_DELAY_MS);
+  };
   // Checked again at the Enter: in those 150 ms a dialog may have opened, which
   // the Enter would answer, or a person may have started typing, whose text
   // would go with it. Left unsent, the message sits in the composer instead.
   // The screen is read afresh rather than through session.state, which lags a
   // second behind and reads WORKING for three after any output — the paste's
   // own echo included.
-  setTimeout(() => {
+  const submit = () => {
+    session.messageTyping = false;
     if (session.exited) return;
     if (detectState(session, { stateTimeoutMs: 0 }) === 'MESSAGE' || (session.lastUserInputAt || 0) > now) {
       session.messageUnsubmittedAt = Date.now();
       return;
     }
     write(session, '\r');
-  }, SUBMIT_DELAY_MS);
+  };
+  type();
 }
 
 /**

package/server/owner.js

@@ -16,7 +16,7 @@ import { CONFIG_DIR } from './state.js';
 import { liveBillion } from './billion.js';
 import { sendText } from './messages.js';
 import {
-  chooseMode, speechUnavailable, synthesize, whisperSetup, transcribe, MAX_NOTE_SECONDS, MAX_NOTE_BYTES,
+  chooseMode, voiceSetting, speechUnavailable, synthesize, sayVoice, whisperSetup, transcribe, MAX_NOTE_SECONDS, MAX_NOTE_BYTES,
 } from './voice.js';
 
 export const MAX_NOTIFY_CHARS = 3000;          // Telegram's own limit is 4096
@@ -98,7 +98,7 @@ function saveOwnerMode(mode) {
 export async function sendVoice(text, { env = process.env } = {}) {
   const { chatId } = telegramSettings(env);
   try {
-    const ogg = await synthesize(text);
+    const ogg = await synthesize(text, env);
     const form = new FormData();
     form.append('chat_id', chatId);
     form.append('caption', text);   // under Telegram's 1024: voice is for texts of 900 or fewer
@@ -296,6 +296,9 @@ export function startTelegram({ broadcast, env = process.env } = {}) {
   if (!token || stopper) return false;
   if (!chatId) console.log('  Telegram: send any message to your bot, then set TELEGRAM_CHAT_ID=<id> (the id is shown here when it arrives)');
   else console.log('  Telegram: on');
+  if (voiceSetting(env) !== 'never' && !speechUnavailable(env)) {
+    sayVoice(env).then(v => console.log(`  Telegram: speaking with ${v ? `the ${v} voice` : "say's default voice"}`));
+  }
   const controller = new AbortController();
   stopper = controller;
   (async () => {

package/server/voice.js

@@ -79,12 +79,54 @@ export function speechUnavailable(env = process.env, platform = process.platform
   return null;
 }
 
+// `say -v '?'` lines, e.g. "Ava (Premium)       en_US    # Hello! My name is Ava."
+export function parseVoices(out) {
+  return out.split('\n').map(l => l.match(/^(.+?)\s+([a-z]{2,3}[_-]\w+)\s+#/)).filter(Boolean)
+    .map(([, name, locale]) => ({ name, locale: locale.replace('-', '_') }));
+}
+
+// The first Premium voice, then Enhanced (however macOS words the name), in
+// these locales in order.
+function best(voices, locales) {
+  for (const tier of ['Premium', 'Enhanced']) {
+    for (const locale of locales) {
+      const v = voices.find(v => (!locale || v.locale === locale) && v.name.includes(tier));
+      if (v) return v;
+    }
+  }
+  return null;
+}
+
+// SAY_VOICE if it is installed, else the best English voice installed:
+// Premium, then Enhanced, en_US before en_GB. null keeps say's own default.
+export function pickVoice(voices, env = process.env) {
+  const wanted = (env.SAY_VOICE || '').trim();
+  if (wanted) {
+    // "Ava" also matches "Ava (Premium)" or "Samantha" "Samantha (English (US))",
+    // as `say -v` itself does, the best of them first.
+    const w = wanted.toLowerCase();
+    const named = voices.filter(v => v.name.toLowerCase().startsWith(`${w} (`));
+    const found = voices.find(v => v.name.toLowerCase() === w) || best(named, [null]) || named[0];
+    if (found) return found.name;
+    console.log(`  Telegram: SAY_VOICE "${wanted}" is not installed (say -v '?' lists what is); using the best installed voice`);
+  }
+  return best(voices, ['en_US', 'en_GB'])?.name ?? null;
+}
+
+let voicePick;
+// The voice Billion speaks with, chosen once for the process's lifetime.
+export function sayVoice(env = process.env) {
+  voicePick ??= run('say', ['-v', '?']).catch(() => '').then(out => pickVoice(parseVoices(out), env));
+  return voicePick;
+}
+
 // text → OGG/Opus bytes. URLs are said as "link"; the caption carries them.
-export function synthesize(text) {
+export function synthesize(text, env = process.env) {
   return inTempDir(async dir => {
     const txt = join(dir, 'say.txt'), aiff = join(dir, 'say.aiff'), ogg = join(dir, 'say.ogg');
     await writeFile(txt, text.replace(URL_RE, 'link'));
-    await run('say', ['-o', aiff, '-f', txt]);
+    const voice = await sayVoice(env);
+    await run('say', [...(voice ? ['-v', voice] : []), '-o', aiff, '-f', txt]);
     await run('ffmpeg', ['-y', '-loglevel', 'error', '-protocol_whitelist', 'file', '-i', aiff, '-c:a', 'libopus', '-b:a', '32k', ogg]);
     return readFile(ogg);
   });