@stage-labs/metro 0.1.0-beta.235 → 0.1.0-beta.237

package/dist/claude.js

@@ -9,7 +9,7 @@ import { localPort, localUrl } from './runtime.js';
 import { keepInSession, takeBackConversation } from './background.js';
 const CHANNEL_FLAGS = ['--dangerously-load-development-channels', 'server:metro'];
 const FRESH_PROMPT_FLAGS = ['--system-prompt-snapshot', 'off'];
-const PERMISSION_MODE_FLAG = { auto: 'auto', bypass: 'bypassPermissions' };
+export const PERMISSION_MODE_FLAG = { auto: 'auto', bypass: 'bypassPermissions' };
 const KEY_HEADER = 'x-metro-key';
 const PROBE_MS = 3_000;
 const AUTH_STATUS_MS = 20_000;

package/dist/cli.js

@@ -3,11 +3,12 @@ import { whoisAuthorized } from './api.js';
 import { stopAll } from './control.js';
 import { tailEvents } from './tail.js';
 import { launchClaude } from './claude.js';
-import { memoryRoutine } from './memory.js';
+import { memoryPaths, memoryRoutine } from './memory.js';
 import { update } from './update.js';
 import { serve } from './serve.js';
 import { service, serviceStopHint } from './service.js';
 import { currentVersion } from './version.js';
+import { voiceSession } from './voice.js';
 const USAGE = `metro: run your agent on this machine
 
   metro serve [--port <n>] [--owner <organization id>]
@@ -32,9 +33,16 @@ const USAGE = `metro: run your agent on this machine
                   open Claude Code with the metro channel and the metro MCP server, its
                   inference routed through the daemon's model gateway (the Model page);
                   every argument is passed through the same
-  metro memory    run the daily memory routine once: when Claude Code transcripts changed
-                  since the last run, Claude Code reads the memory skill and files them into
-                  its memory, with no metro tools and writes only inside the memory folder
+  metro memory [skill file]
+                  run the memory routine once: when Claude Code transcripts changed since
+                  the last run, Claude Code reads the memory skill (or the file given) and
+                  files them into its memory, with no metro tools and writes only inside
+                  the memory folder
+  metro voice --model <model>
+                  the agent's side of a voice call, which the daemon starts when a call
+                  comes in: Claude Code reads the call's words as stream-json on stdin and
+                  streams its replies on stdout, with the agent's memory, skills and tools
+                  but no metro channel
   metro update    update to the newest published version (--check only reports)
   metro version   print this CLI's version
 
@@ -68,7 +76,8 @@ const COMMANDS = {
     stop: stopDaemon,
     tail: () => tailEvents(process.argv.slice(3)),
     claude: () => launchClaude(process.argv.slice(3)),
-    memory: () => memoryRoutine(),
+    memory: () => memoryRoutine(memoryPaths(process.env, process.argv[3])),
+    voice: () => voiceSession(process.argv.slice(3)),
     update: () => update(process.argv.slice(3)),
     version: async () => {
         process.stdout.write(`${currentVersion()}\n`);

package/dist/memory.js

@@ -46,13 +46,13 @@ function customDir(claude, home) {
         return undefined;
     }
 }
-export function memoryPaths(env = process.env) {
+export function memoryPaths(env = process.env, skill) {
     const home = given(env.HOME) ?? homedir();
     const claude = claudeDir(env);
     return {
         claude,
         memory: customDir(claude, home) ?? join(projectDir(claude, realHome(home)), 'memory'),
-        skill: join(claude, 'skills', 'memory', 'SKILL.md'),
+        skill: given(skill) ?? join(claude, 'skills', 'memory', 'SKILL.md'),
         state: join(home, '.metro', 'memory-routine.json'),
         lock: join(home, '.metro', 'memory-routine.lock'),
     };

package/dist/voice.js

@@ -0,0 +1,39 @@
+import { homedir } from 'node:os';
+import { headlessEnv, PERMISSION_MODE_FLAG, runClaude } from './claude.js';
+import { permissionMode, systemPrompt } from './route.js';
+const VOICE_PROMPT = `You are on a live voice call through Metro. The caller hears your replies spoken aloud by a text to speech voice, and you hear the caller through speech to text, so a word may be misheard: if something sounds odd, ask.
+- Speak like a person on the phone: short sentences, usually one to three. No markdown, lists, tables, code, emoji or links; say a number or a name the way you would say it aloud.
+- Start with the answer. Do not repeat the question.
+- Before you use a tool, first say one short sentence about what you are checking.
+- Look things up yourself with Read, Grep or Glob when it is quick. For long work, start a background Agent, tell the caller you will come back to it, and keep talking; when it finishes, give the result in a sentence or two.
+- Text in [square brackets] comes from the call system, not from the caller.
+- You cannot send chat messages during the call. When the call ends, you will be asked for call notes, which are posted to the chat.`;
+function voiceArgs(model, mode, prompt) {
+    return [
+        '-p',
+        '--input-format',
+        'stream-json',
+        '--output-format',
+        'stream-json',
+        '--verbose',
+        '--include-partial-messages',
+        '--model',
+        model,
+        '--permission-mode',
+        PERMISSION_MODE_FLAG[mode],
+        '--settings',
+        JSON.stringify({ enabledPlugins: { 'metro@metro': false } }),
+        '--strict-mcp-config',
+        '--no-session-persistence',
+        '--append-system-prompt',
+        prompt === null ? VOICE_PROMPT : `${prompt}\n\n${VOICE_PROMPT}`,
+    ];
+}
+export async function voiceSession(argv) {
+    const at = argv.indexOf('--model');
+    const model = at < 0 ? '' : (argv[at + 1] ?? '');
+    if (model === '')
+        throw new Error('metro voice needs --model <model>');
+    process.chdir(homedir());
+    return runClaude(voiceArgs(model, permissionMode(), systemPrompt()), await headlessEnv());
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.235",
+  "version": "0.1.0-beta.237",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.235",
+  "version": "0.1.0-beta.237",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

package/runtime/marketplace/plugin/MEMORY.md

@@ -3,7 +3,7 @@ name: memory
 description: How this agent keeps its long-term memory in the Instinct layout (people, organizations, facts, preferences, decisions, conversation digests, daily and weekly timelines, active and completed work), the note format and rules, and the daily routine that files each day into it. Use when saving or looking something up in memory, and when the daily memory routine runs.
 ---
 
-Your memory is a folder of Markdown notes, found with grep and links, not a database. The layout follows Instinct (https://supermemory.ai/blog/reverse-engineering-instinct-memory/). Once a day a scheduled run (the `memory-routine` job on the Scheduled page) reads this skill and files the day into it. You can use the same rules any time you save something.
+Your memory is a folder of Markdown notes, found with grep and links, not a database. The layout follows Instinct (https://supermemory.ai/blog/reverse-engineering-instinct-memory/). Twice a day, at 00:00 and 12:00 UTC, a scheduled run (the `memory-routine` job on the Scheduled page) reads this skill and files what happened into it. You can use the same rules any time you save something.
 
 **Where it is.** The auto-memory directory of your Claude Code home folder: `~/.claude/projects/<home folder, with every character that is not a letter or digit turned into ->/memory/` (for `/home/agent` that is `~/.claude/projects/-home-agent/memory/`), or the `autoMemoryDirectory` set in `~/.claude/settings.json`. The daily run names it in its prompt.
 
@@ -72,7 +72,7 @@ The scheduled run has no chat tools, no shell, no network and no subagents. It c
    - Work goes into `workstreams/active/`. When it finished, only set its `status` in place (see Rules).
    - Each chat line gets a digest in `comms/phone/`.
    - Turn passing anecdotes into general traits. Drop trivia.
-4. Write `timeline/daily/YYYY-MM-DD.md` for each UTC day with activity since the last run: what happened, with links. Things that need the owner go as one line each under a `## Needs <owner's name>` heading, since this run cannot message anyone.
+4. Write `timeline/daily/YYYY-MM-DD.md` for each UTC day with activity since the last run: what happened, with links. A note an earlier run already wrote gets added to. Things that need the owner go as one line each under a `## Needs <owner's name>` heading, since this run cannot message anyone.
 5. If the prompt names a previous ISO week whose `timeline/weekly/YYYY-Www.md` does not exist yet, and there are daily notes for that week, write it from those daily notes.
 6. Tidy up. Merge duplicates into one note, and keep the other slug in its `aliases`. Cut the other note down to its frontmatter and one line: `Merged into [[slug]].` Fix broken `[[links]]` and update `MEMORY.md`.
 7. End with at most three lines on what changed.

package/runtime/node_modules/@metro-labs/daemon/package.json

@@ -35,6 +35,8 @@
     "@metro-labs/whatsapp": "workspace:*",
     "@metro-labs/xmtp": "workspace:*",
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "opusscript": "^0.1.1",
+    "werift": "^0.24.4",
     "ws": "^8.18.0",
     "zod": "^3.23.8"
   },

package/runtime/node_modules/@metro-labs/daemon/src/agent-user/schedule-detail.ts

@@ -29,8 +29,8 @@ function textFile(path: string): string | null {
 }
 
 export function scriptOf(command: string): { path: string; text: string } | null {
-  const words = command.split(/\s+/).filter((w) => w.startsWith('/') && !w.includes('>'));
-  for (const path of words.slice(0, 3)) {
+  const words = command.split(/\s+/).filter((w) => w.startsWith('/') && !w.includes('>')).slice(0, 3);
+  for (const path of [...words.filter((w) => w.endsWith('.md')), ...words]) {
     const text = textFile(path);
     if (text !== null) return { path, text };
   }

package/runtime/node_modules/@metro-labs/daemon/src/boot/boot.ts

@@ -52,6 +52,7 @@ import type { StationName } from '@metro-labs/core/station-names';
 import { startUploadReaper } from '../files/upload-store.js';
 import { startAttachReaper } from '../files/attach-reaper.js';
 import { startCloudWatchPublisher } from '../server/cloudwatch.js';
+import { isCallEvent, onCallEvent } from '../voice/calls.js';
 
 installCrashGuard();
 acquireLock(join(STATE_DIR, '.tail-lock'));
@@ -67,6 +68,10 @@ const supervisor = new TrainSupervisor();
 const emit = makeEmit();
 
 supervisor.onTrainEvent((env, train) => {
+  if (isCallEvent(env)) {
+    onCallEvent(env);
+    return;
+  }
   const entry = trainEventToMetroEvent(env, train);
   if (entry) emit(entry);
 });

package/runtime/node_modules/@metro-labs/daemon/src/claude/memory-routine.ts

@@ -1,5 +1,3 @@
-import { createHash } from 'node:crypto';
-import { hostname } from 'node:os';
 import { join } from 'node:path';
 import { errMsg, log } from '@metro-labs/core/log';
 import { existsSync, readFileSync } from '../agent-user/agent-fs.js';
@@ -10,8 +8,9 @@ import { agentPath, agentUser, type AgentUser } from '../agent-user/user.js';
 
 const BEGIN = '# metro memory routine: begin';
 const END = '# metro memory routine: end';
+const REPLACED = '# replaced by memory-routine: ';
 const OWN_JOB = /memory/i;
-const HOUR = 0;
+const SCHEDULE = '0 0,12 * * *';
 
 export type MemoryJobState = 'scheduled' | 'own' | 'off' | 'unavailable';
 
@@ -25,7 +24,6 @@ export interface MemoryJobDeps {
   runner?: Runner;
   cli?: string;
   port?: string;
-  seed?: string;
 }
 
 let last: MemoryJob = { state: 'unavailable', job: null };
@@ -33,6 +31,7 @@ let last: MemoryJob = { state: 'unavailable', job: null };
 export const memoryJobStatus = (): MemoryJob => ({ ...last });
 
 export const launcherPath = (user: AgentUser): string => join(user.home, '.metro', 'bin', 'memory-routine');
+export const skillPath = (user: AgentUser): string => join(user.home, '.claude', 'skills', 'memory', 'SKILL.md');
 const logPath = (user: AgentUser): string => join(user.home, '.metro', 'memory-routine.log');
 const quoted = (text: string): string => `'${text.replace(/'/g, '\'\\\'\'')}'`;
 
@@ -43,28 +42,38 @@ export function launcherText(user: AgentUser, cli: string, port: string): string
     'export PATH',
     ...(port === '' ? [] : [`METRO_WEBHOOK_PORT=${quoted(port)}`, 'export METRO_WEBHOOK_PORT']),
     'cd "$HOME" || exit 1',
-    `exec node ${quoted(cli)} memory`,
+    `exec node ${quoted(cli)} memory "$@"`,
     '',
   ].join('\n');
 }
 
-export function cronLine(user: AgentUser, seed: string): string {
-  const minute = parseInt(createHash('sha256').update(seed).digest('hex').slice(0, 8), 16) % 60;
-  return `${String(minute)} ${String(HOUR)} * * * ${launcherPath(user)} >> ${logPath(user)} 2>&1`;
-}
+export const cronLine = (user: AgentUser): string => `${SCHEDULE} ${launcherPath(user)} ${skillPath(user)} >> ${logPath(user)} 2>&1`;
 
 const commandName = (command: string): string => command.split(/\s+/)[0]?.split('/').pop() ?? 'cron';
 
+const ownCommand = (user: AgentUser, line: string): string | null => {
+  const parsed = parseCronLine(line);
+  return parsed === null || parsed.command.includes(launcherPath(user)) || !OWN_JOB.test(parsed.command) ? null : parsed.command;
+};
+
+const replaces = (user: AgentUser, line: string): boolean => OWN_JOB.test(commandName(ownCommand(user, line) ?? ''));
+
 function ownJob(user: AgentUser, runner: Runner, lines: string[]): string | null {
-  const launcher = launcherPath(user);
   const cron = lines.flatMap((line) => {
-    const parsed = parseCronLine(line);
-    return parsed === null || parsed.command.includes(launcher) || !OWN_JOB.test(parsed.command) ? [] : [commandName(parsed.command)];
+    const command = ownCommand(user, line);
+    return command === null || replaces(user, line) ? [] : [commandName(command)];
   });
   const timers = listSchedules(null, runner).filter((job) => job.runsAs === user.name && OWN_JOB.test(`${job.name} ${job.command}`));
   return cron[0] ?? timers[0]?.name ?? null;
 }
 
+const restored = (line: string): string => (line.startsWith(REPLACED) ? line.slice(REPLACED.length) : line);
+
+function marked(user: AgentUser, lines: string[], on: boolean, scheduled: boolean): string[] {
+  if (!on) return lines.map(restored);
+  return lines.map((l) => (scheduled && replaces(user, l) ? `${REPLACED}${l}` : l));
+}
+
 function placeLauncher(path: string, text: string): void {
   if (existsSync(path) && readFileSync(path, 'utf8') === text) return;
   writeHomeText(path, text, 0o755);
@@ -78,7 +87,6 @@ function resolved(deps: MemoryJobDeps): Required<MemoryJobDeps> {
     runner: deps.runner ?? realRunner,
     cli: deps.cli ?? envText('METRO_CLI_BIN'),
     port: deps.port ?? envText('METRO_WEBHOOK_PORT'),
-    seed: deps.seed ?? hostname(),
   };
 }
 
@@ -88,7 +96,7 @@ const stateOf = (scheduled: boolean, own: string | null): MemoryJobState => {
 };
 
 export function ensureMemoryJob(on: boolean, deps: MemoryJobDeps = {}): MemoryJob {
-  const { user, runner, cli, port, seed } = resolved(deps);
+  const { user, runner, cli, port } = resolved(deps);
   if (user === null || cli === '') {
     last = { state: 'unavailable', job: null };
     return memoryJobStatus();
@@ -98,10 +106,11 @@ export function ensureMemoryJob(on: boolean, deps: MemoryJobDeps = {}): MemoryJo
   const scheduled = on && own === null;
   const launcher = launcherPath(user);
   if (scheduled) placeLauncher(launcher, launcherText(user, cli, port));
-  const next = withBlock(lines, BEGIN, END, scheduled ? [cronLine(user, seed)] : [], 'end', (l) => l.includes(launcher));
+  const kept = marked(user, lines, on, scheduled);
+  const next = withBlock(kept, BEGIN, END, scheduled ? [cronLine(user)] : [], 'end', (l) => l.includes(launcher));
   const changed = writeCrontab(user, runner, lines, next);
   last = { state: stateOf(scheduled, own), job: own };
-  if (changed) log.info({ ...last }, 'memory-routine: updated the daily memory job');
+  if (changed) log.info({ ...last, rewritten: kept.filter((l, i) => l !== lines[i]) }, 'memory-routine: updated the memory job');
   return memoryJobStatus();
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/claude/session.ts

@@ -110,13 +110,17 @@ export function hasConversation(home: string, dir = claudeDir()): boolean {
   );
 }
 
-function metroCommand(deps: SessionDeps, home: string): string[] {
+export function metroCli(args: string[], fixed?: string[]): string[] {
   const bin = process.env.METRO_CLI_BIN?.trim() ?? '';
   const runtime = agentUser() === null ? process.execPath : 'node';
-  const base = deps.metro ?? (bin === '' ? ['metro', 'claude'] : [runtime, bin, 'claude']);
-  const continues = (deps.continues ?? hasConversation)(home);
+  const base = fixed ?? (bin === '' ? ['metro', ...args] : [runtime, bin, ...args]);
   const env = Object.entries(sessionEnv()).map(([k, v]) => `${k}=${v}`);
-  const command = env.length === 0 || deps.metro !== undefined ? base : ['env', ...env, ...base];
+  return env.length === 0 || fixed !== undefined ? base : ['env', ...env, ...base];
+}
+
+function metroCommand(deps: SessionDeps, home: string): string[] {
+  const command = metroCli(['claude'], deps.metro);
+  const continues = (deps.continues ?? hasConversation)(home);
   return continues ? [...command, '-c'] : command;
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/claude/setup.ts

@@ -166,7 +166,7 @@ const PRIOR_STAGE: ReadonlySet<string> = new Set([
   'e3b8f9bbdb205311bc643aaf91d9d903a91204fd5b55ca949b85cdfa6fd00136',
   '08a30f5cd5cf8013ab70c1fa9e1109018c0337552296a8efe5c0cf543b284991',
 ]);
-const PRIOR_MEMORY: ReadonlySet<string> = new Set();
+const PRIOR_MEMORY: ReadonlySet<string> = new Set(['08795399635c8cdec2b50cb4e336f89ae880f3997ae52560ef647a9cdc8f1b08']);
 
 interface ShippedSkill {
   name: string;

package/runtime/node_modules/@metro-labs/daemon/src/routes/session-apis.ts

@@ -21,6 +21,7 @@ import { handleTerminalRequest, type TerminalApiDeps } from '../terminal/api.js'
 import { handleSchedulesRequest } from '../agent-user/schedules-api.js';
 import { handleFilesRequest } from '../agent-user/files-api.js';
 import { handleVaultRequest } from '../vault/api.js';
+import { handleVoiceRequest } from '../voice/api.js';
 
 export interface SessionApis {
   agentApi?: AgentApiDeps;
@@ -58,6 +59,7 @@ export function handleSessionApis(
     () => handleSchedulesRequest(req, res),
     () => handleFilesRequest(req, res),
     () => handleVaultRequest(req, res),
+    () => handleVoiceRequest(req, res),
     ...when(apis.ownerApi, (d) => handleOwnerRequest(req, res, d)),
     ...when(apis.machineApi, (d) => handleMachineRequest(req, res, d)),
     ...when(apis.modelApi, (d) => handleModelRequest(req, res, d)),

package/runtime/node_modules/@metro-labs/daemon/src/voice/api.ts

@@ -0,0 +1,14 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { readJsonBody, sessionRoute } from '@metro-labs/http/api-http';
+import { patchVoice, publicVoice, readVoice, writeVoice } from './store.js';
+
+const PATH = '/api/voice';
+
+async function answer(req: IncomingMessage): Promise<unknown> {
+  if (req.method === 'PUT') writeVoice(patchVoice(readVoice(), await readJsonBody(req)));
+  return publicVoice(readVoice());
+}
+
+export function handleVoiceRequest(req: IncomingMessage, res: ServerResponse): boolean {
+  return sessionRoute(req, res, { methods: { [PATH]: ['GET', 'PUT'] }, admin: ['PUT'], label: 'voice-api' }, () => answer(req));
+}

package/runtime/node_modules/@metro-labs/daemon/src/voice/audio.ts

@@ -0,0 +1,153 @@
+import OpusScript from 'opusscript';
+import { errMsg, log } from '@metro-labs/core/log';
+
+const RATE = 48_000;
+const FRAME = 960;
+const FRAME_MS = 20;
+const MAX_LATE_FRAMES = 5;
+
+interface Frame {
+  pcm: Int16Array;
+  chars: number;
+}
+
+export function downsample3(pcm: Int16Array): Int16Array {
+  const out = new Int16Array(Math.floor(pcm.length / 3));
+  for (let i = 0; i < out.length; i += 1)
+    out[i] = Math.round(((pcm[i * 3] ?? 0) + (pcm[i * 3 + 1] ?? 0) + (pcm[i * 3 + 2] ?? 0)) / 3);
+  return out;
+}
+
+export function upsample2(pcm: Int16Array, carry: number): Int16Array {
+  const out = new Int16Array(pcm.length * 2);
+  let prev = carry;
+  for (let i = 0; i < pcm.length; i += 1) {
+    const cur = pcm[i] ?? 0;
+    out[i * 2] = Math.round((prev + cur) / 2);
+    out[i * 2 + 1] = cur;
+    prev = cur;
+  }
+  return out;
+}
+
+export const pcmOf = (bytes: Buffer): Int16Array => {
+  const copy = Buffer.from(bytes);
+  return new Int16Array(copy.buffer, copy.byteOffset, Math.floor(copy.length / 2));
+};
+
+export const bytesOf = (pcm: Int16Array): Buffer => Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength);
+
+export class OpusIn {
+  private readonly decoder = new OpusScript(RATE, 1, OpusScript.Application.VOIP);
+
+  decode(packet: Buffer): Int16Array | null {
+    try {
+      return pcmOf(this.decoder.decode(packet));
+    } catch (err) {
+      log.debug({ err: errMsg(err) }, 'voice: an audio packet could not be decoded');
+      return null;
+    }
+  }
+
+  close(): void {
+    this.decoder.delete();
+  }
+}
+
+export interface Playback {
+  send(opus: Buffer, timestamp: number, marker: boolean): void;
+  played(chars: number): void;
+}
+
+export class Player {
+  private readonly encoder = new OpusScript(RATE, 1, OpusScript.Application.VOIP);
+  private readonly queue: Frame[] = [];
+  private pending = new Int16Array(0);
+  private pendingChars = 0;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private started = 0;
+  private sent = 0;
+  private speaking = false;
+  private onIdle: (() => void) | null = null;
+  private onFirst: (() => void) | null = null;
+
+  constructor(private readonly out: Playback) {}
+
+  get busy(): boolean {
+    return this.queue.length > 0 || this.pending.length > 0;
+  }
+
+  whenFirstPlayed(fn: () => void): void {
+    this.onFirst = fn;
+  }
+
+  whenIdle(fn: () => void): void {
+    this.onIdle = fn;
+  }
+
+  push(pcm: Int16Array, chars: number): void {
+    const joined = new Int16Array(this.pending.length + pcm.length);
+    joined.set(this.pending);
+    joined.set(pcm, this.pending.length);
+    let at = 0;
+    for (; at + FRAME <= joined.length; at += FRAME) this.queue.push({ pcm: joined.slice(at, at + FRAME), chars: 0 });
+    this.pending = joined.slice(at);
+    this.pendingChars += chars;
+    const last = this.queue.at(-1);
+    if (last !== undefined && this.pending.length === 0) {
+      last.chars += this.pendingChars;
+      this.pendingChars = 0;
+    }
+  }
+
+  finish(): void {
+    if (this.pending.length === 0) return;
+    const pcm = new Int16Array(FRAME);
+    pcm.set(this.pending);
+    this.queue.push({ pcm, chars: this.pendingChars });
+    this.pending = new Int16Array(0);
+    this.pendingChars = 0;
+  }
+
+  clear(): void {
+    this.queue.length = 0;
+    this.pending = new Int16Array(0);
+    this.pendingChars = 0;
+  }
+
+  start(): void {
+    if (this.timer !== null) return;
+    this.started = performance.now();
+    this.sent = 0;
+    this.tick();
+  }
+
+  stop(): void {
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = null;
+    this.encoder.delete();
+  }
+
+  private tick(): void {
+    const due = Math.floor((performance.now() - this.started) / FRAME_MS) + 1;
+    if (due - this.sent > MAX_LATE_FRAMES) this.sent = due - 1;
+    while (this.sent < due) this.sendOne();
+    const next = this.started + this.sent * FRAME_MS;
+    this.timer = setTimeout(() => {
+      this.tick();
+    }, Math.max(0, next - performance.now()));
+  }
+
+  private sendOne(): void {
+    const frame = this.queue.shift();
+    const marker = frame !== undefined && !this.speaking;
+    this.speaking = frame !== undefined;
+    const pcm = frame?.pcm ?? new Int16Array(FRAME);
+    this.out.send(this.encoder.encode(bytesOf(pcm), FRAME), (this.sent * FRAME) >>> 0, marker);
+    this.sent += 1;
+    if (frame === undefined) return;
+    if (marker) this.onFirst?.();
+    if (frame.chars > 0) this.out.played(frame.chars);
+    if (!this.busy) this.onIdle?.();
+  }
+}

package/runtime/node_modules/@metro-labs/daemon/src/voice/brain.ts

@@ -0,0 +1,95 @@
+import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
+import { errMsg, log } from '@metro-labs/core/log';
+import { isRecord } from '@metro-labs/core/is-record';
+import { drainLines } from '@metro-labs/core/trains/protocol';
+import { asAgent } from '../agent-user/user.js';
+import { metroCli } from '../claude/session.js';
+
+const CLOSE_GRACE_MS = 10_000;
+
+export interface Thinking {
+  turnStarted(): void;
+  text(delta: string): void;
+  tool(name: string): void;
+  turnEnded(text: string): void;
+  exited(reason: string): void;
+}
+
+const record = (value: unknown): Record<string, unknown> => (isRecord(value) ? value : {});
+
+function streamEvent(msg: Record<string, unknown>, mind: Thinking): void {
+  if (msg.parent_tool_use_id !== null && msg.parent_tool_use_id !== undefined) return;
+  const event = record(msg.event);
+  const delta = record(event.delta);
+  if (event.type === 'content_block_delta' && delta.type === 'text_delta' && typeof delta.text === 'string') mind.text(delta.text);
+  const block = record(event.content_block);
+  if (event.type === 'content_block_start' && block.type === 'tool_use') mind.tool(typeof block.name === 'string' ? block.name : 'tool');
+}
+
+function readBrainLine(line: string, mind: Thinking): void {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return;
+  }
+  const msg = record(parsed);
+  if (msg.type === 'system' && msg.subtype === 'init') mind.turnStarted();
+  else if (msg.type === 'stream_event') streamEvent(msg, mind);
+  else if (msg.type === 'result') mind.turnEnded(typeof msg.result === 'string' ? msg.result : '');
+}
+
+export class Brain {
+  private readonly child: ChildProcessWithoutNullStreams;
+  private out = '';
+  private gone = false;
+
+  constructor(model: string, private readonly mind: Thinking) {
+    const [command = 'metro', ...args] = metroCli(['voice', '--model', model]);
+    const [file, argv] = asAgent(command, args);
+    this.child = spawn(file, argv, { stdio: ['pipe', 'pipe', 'pipe'], cwd: '/' });
+    this.child.stdout.setEncoding('utf8');
+    this.child.stdout.on('data', (chunk: string) => {
+      this.out = drainLines('voice-brain', this.out + chunk, (line) => {
+        readBrainLine(line, this.mind);
+      });
+    });
+    this.child.stderr.setEncoding('utf8');
+    this.child.stderr.on('data', (chunk: string) => {
+      log.debug({ text: chunk.slice(0, 500) }, 'voice: brain stderr');
+    });
+    this.child.stdin.on('error', (err) => {
+      log.debug({ err: errMsg(err) }, 'voice: brain stdin closed');
+    });
+    this.child.on('error', (err) => {
+      this.exit(`could not start: ${errMsg(err)}`);
+    });
+    this.child.on('exit', (code, signal) => {
+      this.exit(`exited (${String(code ?? signal)})`);
+    });
+  }
+
+  get alive(): boolean {
+    return !this.gone;
+  }
+
+  tell(text: string, now = false): void {
+    if (this.gone) return;
+    const message = { type: 'user', message: { role: 'user', content: text }, parent_tool_use_id: null, session_id: '' };
+    this.child.stdin.write(`${JSON.stringify(now ? { ...message, priority: 'now' } : message)}\n`);
+  }
+
+  close(): void {
+    if (this.gone) return;
+    this.child.stdin.end();
+    setTimeout(() => {
+      if (!this.gone) this.child.kill('SIGKILL');
+    }, CLOSE_GRACE_MS).unref();
+  }
+
+  private exit(reason: string): void {
+    if (this.gone) return;
+    this.gone = true;
+    this.mind.exited(reason);
+  }
+}