@bill10/agent-007 0.9.1001 → 0.9.2001

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.1.1
+0.9.2.1

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.1001",
+  "version": "0.9.2001",
   "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/jobs.js

@@ -313,6 +313,7 @@ export function addJob({ title, detail, repoPath, type, schedule, permissionMode
   if (written) result.job.attachments = written.attachments;
   allJobs().push(result.job);
   persist(broadcast);
+  requestDispatch();
   return { job: result.job };
 }
 
@@ -699,6 +700,7 @@ export async function finishJobForAgent({ session, summary, prUrl }, broadcast,
   job.lastErrorAt = null;
   clearPrCheckError(job);
   persist(broadcast);
+  requestDispatch();
   if (broadcast) {
     broadcast({
       type: 'notification', level: 'info',
@@ -876,6 +878,7 @@ export function setJobPaused(jobId, paused, broadcast) {
   job.paused = next;
   if (!next && job.schedule) job.nextRunAt = nextCronIso(job.schedule);
   persist(broadcast);
+  if (!next) requestDispatch();
   return { job };
 }
 
@@ -889,6 +892,7 @@ export async function deleteJob(jobId, broadcast, { killSession } = {}) {
   if (idx === -1) return { error: 'Job not found' };
   const [removed] = jobs.splice(idx, 1);
   persist(broadcast);
+  requestDispatch();
   // After persist, so a file the OS will not let go of (open in a browser tab
   // on Windows) cannot leave a card that is gone from memory but back on the
   // next restart. The id is checked the same way a path is: it too is
@@ -1031,6 +1035,8 @@ export async function moveJob(jobId, state, broadcast, { killSession, findPr = f
   // Persist and repaint before the kill so the card moves immediately; the kill
   // then emits its own session-ended and orphan notifications.
   persist(broadcast);
+  // Back in To do, or a slot freed by leaving In progress.
+  if (state === 'todo' || fromState === 'in-progress') requestDispatch();
   if (retiringSessionId && killSession) {
     const session = sessions.get(retiringSessionId);
     if (session && !session.exited) {
@@ -1103,6 +1109,8 @@ export async function releasePushedOrphans(broadcast) {
 
 export function updateSettings(fields, broadcast) {
   const settings = boardSettings();
+  // Starting the board, or raising its cap, makes room right away.
+  const before = { running: settings.running, maxPerRepo: settings.maxPerRepo };
   if (typeof fields.running === 'boolean') settings.running = fields.running;
   if (Number.isFinite(fields.maxPerRepo)) settings.maxPerRepo = Math.max(1, Math.min(10, Math.floor(fields.maxPerRepo)));
   if (Number.isFinite(fields.intervalMs)) settings.intervalMs = Math.max(30_000, Math.min(60 * 60_000, Math.floor(fields.intervalMs)));
@@ -1114,6 +1122,7 @@ export function updateSettings(fields, broadcast) {
     settings.permissionModeChosen = true;
   }
   persist(broadcast);
+  if (settings.running && (!before.running || settings.maxPerRepo > before.maxPerRepo)) requestDispatch();
   return { settings };
 }
 
@@ -2130,6 +2139,31 @@ export async function runScan(createSession, broadcast, { onSessionCreated, kill
   }
 }
 
+// --- Dispatch on events ---
+
+// A card posted or requeued, or a slot freed, asks for a dispatch pass here
+// instead of waiting out the scan interval (5 minutes by default). Events
+// within DISPATCH_DEBOUNCE_MS coalesce into one pass. The pass is dispatchOnce
+// alone, behind the scan's flag: the PR and merge sweeps ask GitHub about
+// every card and have nothing to do with a card just posted, so they stay on
+// the interval. A pass that finds a scan running asks again, since the scan
+// may have picked its candidates before the event.
+export const DISPATCH_DEBOUNCE_MS = 2000;
+let dispatchPass = null;
+let kickTimer = null;
+
+export function requestDispatch() {
+  if (!dispatchPass || kickTimer) return;
+  kickTimer = setTimeout(async () => {
+    kickTimer = null;
+    try { await dispatchPass(); } catch (err) {
+      console.error('Job dispatch pass failed:', err.message);
+    }
+  }, DISPATCH_DEBOUNCE_MS);
+  // Never the thing keeping a process alive: the interval loop is the board.
+  kickTimer.unref?.();
+}
+
 // --- Loop ---
 
 let dispatchTimer = null;
@@ -2165,12 +2199,25 @@ export function startDispatcher(createSession, broadcast, { onSessionCreated, ki
     if (generation === loopGeneration) ciTimer = setTimeout(ciTick, CI_POLL_MS);
   };
   ciTimer = setTimeout(ciTick, CI_POLL_MS);
+  dispatchPass = async () => {
+    if (!boardSettings().running) return;
+    if (scanInFlight) { requestDispatch(); return; }
+    scanInFlight = true;
+    try {
+      await dispatchOnce(createSession, broadcast, { onSessionCreated, killSession });
+    } finally {
+      scanInFlight = false;
+    }
+  };
 }
 
 export function stopDispatcher() {
   loopGeneration++;
   clearTimeout(dispatchTimer);
   clearTimeout(ciTimer);
+  clearTimeout(kickTimer);
   dispatchTimer = null;
   ciTimer = null;
+  kickTimer = null;
+  dispatchPass = null;
 }

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/pty.js

@@ -3,6 +3,7 @@
 import { spawn as spawnPty } from 'node-pty';
 import { homedir } from 'os';
 import { basename } from 'path';
+import { writeSync } from 'fs';
 import { stripAnsiComplete, detectState, createRingBuffer, parseCommand, isRealOutput, trackSyncFrames, ptyEnv } from '../lib/helpers.js';
 // Re-exported so the handler's tests reach the parser through the module they drive.
 export { trackSyncFrames } from '../lib/helpers.js';
@@ -10,7 +11,7 @@ import { resolveExecutable, isUsableCwd, commandExists, missingCommandMessage }
 import { RING_BUFFER_MAX } from './state.js';
 import { mintAgentToken, authEnabled } from './auth.js';
 import { writeMcpConfig, removeMcpConfig, withMcpConfig, takesMcpConfig, withApprovalHook } from './agent-mcp.js';
-import { broadcastJobs } from './jobs.js';
+import { broadcastJobs, requestDispatch } from './jobs.js';
 import { flushMessages, dropMessages } from './messages.js';
 import { sessionAgentFromCommand, permissionFlagsFromCommand } from '../lib/jobs.js';
 import { trustDialogKey } from './billion.js';
@@ -36,8 +37,10 @@ function installAsyncSpawnGuard() {
     const match = ASYNC_SPAWN_FAILURE_RE.exec(err?.message || '');
     if (!match) {
       // Not ours. Reproduce Node's default uncaughtException behaviour rather
-      // than silently swallowing an unrelated bug.
-      console.error(err);
+      // than silently swallowing an unrelated bug. Written synchronously:
+      // console.error to a pipe is async on Windows, and process.exit dropped
+      // it, leaving a crash with no error to read.
+      try { writeSync(2, `${err?.stack || err}\n`); } catch { /* exiting anyway */ }
       process.exit(1);
     }
 
@@ -158,6 +161,8 @@ export function setupPtyHandlers(session, sessionId, broadcast) {
     dropMessages(sessionId);
     if (session.isBillion) dropApprovals();
     updateState(session, broadcast);
+    // A board worker gone frees its repo's slot.
+    if (session.jobId) requestDispatch();
     // What it is as it ends, which a relink or a board retirement may have
     // changed since session-created: the client's finished-worker path reads it.
     broadcast({ type: 'session-ended', sessionId, reason: `Process exited with code ${exitCode}`,

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);
   });