@stage-labs/metro 0.1.0-beta.307 → 0.1.0-beta.308

package/dist/voice.js

@@ -1,56 +0,0 @@
-import { homedir, tmpdir } from 'node:os';
-import { headlessEnv, PERMISSION_MODE_FLAG, runClaude } from './claude.js';
-import { localAgent } from './local.js';
-import { VOICE_MCP_PATH, writeMcpConfig } from './mcp-config.js';
-import { permissionMode, systemPrompt } from './route.js';
-import { localPort } from './runtime.js';
-const VOICE_PROMPT = `You are on a live voice call through Metro. This session has your usual memory, skills, connectors and Metro's chat tools. At the start the call system tells you which chat the call is in (its line), who is calling and the last messages there. 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, like "Let me check."
-- Use your tools yourself when it is quick: files, memory, the metro tools (read with the call's line shows that chat) and connectors (tool_search finds them, tool_call runs them). 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.
-- Your spoken words are your reply. Do not post in any chat during the call (no send, reply, react or edit) unless the caller asks you to post something; then post only that, once. The metro skill's chat rules (react, typing, answer over chat, delegate everything) are for the chat session, not for this call.
-- A tool that needs the owner's approval runs in a background worker. The approval is asked in the chat of the call; a spoken yes does not count.
-- Text in [square brackets] comes from the call system, not from the caller.
-- Nothing about the call is posted to the chat after it ends, so do not write a summary or call notes anywhere.`;
-export function voiceArgs(model, mode, prompt, mcpConfig) {
-    return [
-        '-p',
-        '--input-format',
-        'stream-json',
-        '--output-format',
-        'stream-json',
-        '--verbose',
-        '--include-partial-messages',
-        '--model',
-        model,
-        '--permission-mode',
-        PERMISSION_MODE_FLAG[mode],
-        '--permission-prompt-tool',
-        'stdio',
-        ...(mcpConfig === undefined ? [] : ['--mcp-config', mcpConfig]),
-        '--no-session-persistence',
-        '--append-system-prompt',
-        prompt === null ? VOICE_PROMPT : `${prompt}\n\n${VOICE_PROMPT}`,
-    ];
-}
-export const voiceEnv = (env) => ({
-    CLAUDE_CODE_MCP_STARTUP_WAIT_MS: '0',
-    ...env,
-    METRO_SESSION: 'voice',
-});
-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());
-    const agent = localAgent();
-    const mcp = agent === null ? null : writeMcpConfig(agent.key, localPort(), tmpdir(), VOICE_MCP_PATH);
-    try {
-        return await runClaude(voiceArgs(model, permissionMode(), systemPrompt(), mcp?.path), voiceEnv(await headlessEnv()));
-    }
-    finally {
-        mcp?.cleanup();
-    }
-}

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

@@ -1,56 +0,0 @@
-import { join } from 'node:path';
-import { errMsg, log } from '@metro-labs/core/log';
-import { existsSync, readdirNames, readRange } from '../agent-user/agent-fs.js';
-
-const HEAD_BYTES = 64 * 1024;
-const SKIPPED_RE = /Channel notifications skipped: ([^"\\]+)/;
-const REGISTERED = 'Channel notifications registered';
-const NAME_RE = /^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z\.jsonl$/;
-const SLACK_MS = 5_000;
-
-export interface ChannelState {
-  registered: boolean;
-  reason: string | null;
-}
-
-let state: ChannelState | null = null;
-
-export const channelState = (): ChannelState | null => state;
-
-export function forgetChannelState(): void {
-  state = null;
-}
-
-export const mcpLogDir = (home: string): string =>
-  join(home, '.cache', 'claude-cli-nodejs', home.replace(/[^a-zA-Z0-9]/g, '-'), 'mcp-logs-metro');
-
-const openedAt = (name: string): number => {
-  const m = NAME_RE.exec(name);
-  return m === null ? Number.NaN : Date.parse(`${m[1] ?? ''}T${m[2] ?? ''}:${m[3] ?? ''}:${m[4] ?? ''}.${m[5] ?? ''}Z`);
-};
-
-export function readChannelState(home: string, since: number): ChannelState | null {
-  const dir = mcpLogDir(home);
-  if (!existsSync(dir)) return null;
-  const newest = readdirNames(dir).filter((name) => openedAt(name) >= since - SLACK_MS).sort().at(-1);
-  if (newest === undefined) return null;
-  const head = readRange(join(dir, newest), 0, HEAD_BYTES).toString('utf8');
-  const skipped = SKIPPED_RE.exec(head);
-  if (skipped !== null) return { registered: false, reason: skipped[1]?.trim() ?? null };
-  return head.includes(REGISTERED) ? { registered: true, reason: null } : null;
-}
-
-export function noteChannelState(home: string, since: number): boolean {
-  let found: ChannelState | null;
-  try {
-    found = readChannelState(home, since);
-  } catch (err) {
-    log.debug({ err: errMsg(err) }, 'claude-session: could not read the metro MCP log of Claude Code');
-    return false;
-  }
-  if (found === null) return false;
-  state = found;
-  if (found.registered) log.info('claude-session: Claude Code registered the metro channel');
-  else log.error({ reason: found.reason }, 'claude-session: Claude Code skipped the metro channel, so chat messages do not reach the session');
-  return true;
-}

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

@@ -1,16 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { errMsg } from '@metro-labs/core/log';
-import { asAgent } from '../agent-user/user.js';
-
-export const CLAUDE_CODE_VERSION = '2.1.289';
-
-const INSTALL_TIMEOUT_MS = 5 * 60_000;
-const TAIL = 400;
-
-export function installClaudeCode(bin: string): void {
-  const run = spawnSync(...asAgent(bin, ['install', CLAUDE_CODE_VERSION]), { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: INSTALL_TIMEOUT_MS });
-  const failed = `claude install ${CLAUDE_CODE_VERSION} failed`;
-  if (run.error !== undefined) throw new Error(`${failed}: ${errMsg(run.error)}`);
-  if (run.status === 0) return;
-  throw new Error(`${failed}: ${`${run.stderr}${run.stdout}`.trim().slice(-TAIL)}`);
-}

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

@@ -1,121 +0,0 @@
-import { execFile } from 'node:child_process';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { isRecord } from '@metro-labs/core/is-record';
-import { errMsg, log } from '@metro-labs/core/log';
-import { existsSync } from '../agent-user/agent-fs.js';
-import { removeHome } from '../agent-user/home-fs.js';
-import { agentUser, asAgent, claudeBin } from '../agent-user/user.js';
-import { agentsDir } from '../agents/files.js';
-import { readSetupState, writeSetupState } from './setup-state.js';
-
-const PLUGIN = 'metro@metro';
-const MARKETPLACE = 'metro';
-const DONE = 'pluginRemoved';
-const STEP_MS = 60_000;
-const SAID_MAX = 300;
-
-export interface Answer {
-  status: number;
-  stdout: string;
-  stderr: string;
-}
-
-export type Run = (args: string[]) => Promise<Answer>;
-
-export interface CleanupDeps {
-  run?: Run | null;
-  agents?: string;
-  leftover?: string | null;
-}
-
-export type CleanupOutcome = 'done' | 'clean' | 'removed' | 'skipped' | 'failed';
-
-export const claudeAt =
-  (bin: string): Run =>
-  (args) =>
-    new Promise((resolve) => {
-      execFile(...asAgent(bin, args), { encoding: 'utf8', timeout: STEP_MS, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
-        const code = (err as { code?: unknown } | null)?.code;
-        resolve({ status: err === null ? 0 : typeof code === 'number' ? code : 1, stdout, stderr });
-      });
-    });
-
-async function findClaude(): Promise<Run | null> {
-  const candidates = agentUser() === null ? ['claude', join(homedir(), '.local', 'bin', 'claude')] : [claudeBin()];
-  for (const bin of candidates) {
-    const run = claudeAt(bin);
-    if ((await run(['--version'])).status === 0) return run;
-  }
-  return null;
-}
-
-function listOf(stdout: string): Record<string, unknown>[] {
-  try {
-    const parsed: unknown = JSON.parse(stdout);
-    return Array.isArray(parsed) ? parsed.filter(isRecord) : [];
-  } catch {
-    return [];
-  }
-}
-
-async function listed(run: Run, args: string[], key: string, wanted: string): Promise<boolean | null> {
-  const answer = await run(args);
-  if (answer.status !== 0) {
-    log.warn({ args, said: `${answer.stderr}${answer.stdout}`.trim().slice(0, SAID_MAX) }, 'claude-plugin: claude could not list');
-    return null;
-  }
-  return listOf(answer.stdout).some((entry) => entry[key] === wanted);
-}
-
-async function step(run: Run, args: string[]): Promise<boolean> {
-  const answer = await run(args);
-  if (answer.status === 0) {
-    log.info({ args }, 'claude-plugin: removed what the old metro plugin left');
-    return true;
-  }
-  log.warn({ args, said: `${answer.stderr}${answer.stdout}`.trim().slice(0, SAID_MAX) }, 'claude-plugin: claude refused');
-  return false;
-}
-
-async function removeIfListed(run: Run, list: string[], key: string, wanted: string, remove: string[]): Promise<'gone' | 'removed' | 'failed'> {
-  const present = await listed(run, list, key, wanted);
-  if (present === null) return 'failed';
-  if (!present) return 'gone';
-  return (await step(run, remove)) ? 'removed' : 'failed';
-}
-
-function leftoverDir(): string | null {
-  const user = agentUser();
-  return user === null ? null : join(user.home, '.metro', 'marketplace');
-}
-
-function removeLeftover(dir: string | null): boolean {
-  if (dir === null || !existsSync(dir)) return true;
-  try {
-    removeHome(dir, true);
-    log.info({ dir }, 'claude-plugin: removed the old plugin marketplace copy');
-    return true;
-  } catch (err) {
-    log.warn({ dir, err: errMsg(err) }, 'claude-plugin: could not remove the old plugin marketplace copy');
-    return false;
-  }
-}
-
-async function cleanUp(run: Run, leftover: string | null): Promise<'removed' | 'clean' | 'failed'> {
-  const plugin = await removeIfListed(run, ['plugin', 'list', '--json'], 'id', PLUGIN, ['plugin', 'uninstall', PLUGIN]);
-  const market = await removeIfListed(run, ['plugin', 'marketplace', 'list', '--json'], 'name', MARKETPLACE, ['plugin', 'marketplace', 'remove', MARKETPLACE]);
-  const folder = removeLeftover(leftover);
-  if (plugin === 'failed' || market === 'failed' || !folder) return 'failed';
-  return plugin === 'removed' || market === 'removed' ? 'removed' : 'clean';
-}
-
-export async function removeMetroPlugin(deps: CleanupDeps = {}): Promise<CleanupOutcome> {
-  const agents = deps.agents ?? agentsDir();
-  if (readSetupState(agents)[DONE] === true) return 'done';
-  const run = deps.run === undefined ? await findClaude() : deps.run;
-  if (run === null) return 'skipped';
-  const outcome = await cleanUp(run, deps.leftover === undefined ? leftoverDir() : deps.leftover);
-  if (outcome !== 'failed') writeSetupState(agents, { [DONE]: true });
-  return outcome;
-}

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

@@ -1,45 +0,0 @@
-import { agentsDir } from '../agents/files.js';
-import type { CodexMethod } from '../gateway/codex-auth.js';
-import { connectionOf, readModelConfig, routedConnection, type Connection, type ModelConfig } from '../gateway/model-config.js';
-import { readSetupState, writeSetupState } from './setup-state.js';
-
-const RUNNERS = ['cli', 'sdk'] as const;
-export type HarnessRunner = (typeof RUNNERS)[number];
-
-export const SDK_NEEDS_KEY =
-  'The Agent SDK runner needs an API key or a ChatGPT sign-in on every model the Model page lists, the first one and each fallback: use Anthropic with an API key, Amazon Bedrock, OpenRouter, or a signed-in Codex connection (with ChatGPT or with a code). Anthropic does not allow products built on the Agent SDK to use a Claude login, so on a login it runs only where the Metro operator allows it.';
-
-export const isHarnessRunner = (value: unknown): value is HarnessRunner => RUNNERS.some((r) => r === value);
-
-export function harnessRunner(agents = agentsDir()): HarnessRunner {
-  const runner = readSetupState(agents).runner;
-  return isHarnessRunner(runner) ? runner : 'cli';
-}
-
-export function setHarnessRunner(runner: HarnessRunner, agents = agentsDir()): void {
-  writeSetupState(agents, { runner });
-}
-
-export const sdkOnLogin = (agents = agentsDir()): boolean => readSetupState(agents).sdkOnLogin === true;
-
-export function setSdkOnLogin(on: boolean, agents = agentsDir()): void {
-  writeSetupState(agents, { sdkOnLogin: on });
-}
-
-const SDK_ON_CODEX: Record<CodexMethod, boolean> = { chatgpt: true, code: true };
-
-const permitted = (conn: Connection | null): boolean => conn !== null && (conn.apiKey !== '' || (conn.codex !== null && SDK_ON_CODEX[conn.codex.method]));
-
-const servingConnections = (cfg: ModelConfig): (Connection | null)[] => [routedConnection(cfg), ...(cfg.fallbacks ?? []).map((f) => connectionOf(cfg, f.connection))];
-
-const permittedRoute = (cfg: ModelConfig): boolean => servingConnections(cfg).every(permitted);
-
-export const sdkAllowed = (agents = agentsDir(), cfg: ModelConfig = readModelConfig(agents), loginAllowed?: boolean): boolean => permittedRoute(cfg) || (loginAllowed ?? sdkOnLogin(agents));
-
-export const sdkConnectionAllowed = (connection: Connection, agents = agentsDir()): boolean => permitted(connection) || sdkOnLogin(agents);
-
-export function runnerModel(cfg: ModelConfig): string | null {
-  const conn = routedConnection(cfg);
-  if (conn === null || conn.model === '') return null;
-  return conn.provider === 'anthropic' ? conn.model : `${conn.provider}:${conn.model}`;
-}

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

@@ -1,57 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { join } from 'node:path';
-import { isRecord } from '@metro-labs/core/is-record';
-import { readJson, writeJson } from '@metro-labs/core/secure-fs';
-import { agentsDir } from '../agents/files.js';
-import { existsSync, readFileSync, realpathSync } from '../agent-user/agent-fs.js';
-import { claudeDir } from './files.js';
-
-const SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-const sessionId = (value: unknown): string | null => typeof value === 'string' && SESSION_ID_RE.test(value) ? value : null;
-
-function sdkSavedSession(home: string): Record<string, unknown> | null {
-  try {
-    const raw: unknown = JSON.parse(readFileSync(join(home, '.metro', 'agent-session.json'), 'utf8'));
-    return isRecord(raw) ? raw : null;
-  } catch (err) {
-    return isRecord(err) && err.code === 'ENOENT' ? {} : null;
-  }
-}
-
-const inputState = (value: unknown): boolean => value === undefined || value === 'queued' || value === 'started';
-
-function sdkInput(value: unknown): boolean {
-  if (!isRecord(value)) return false;
-  return typeof value.text === 'string' && typeof value.at === 'number' && Number.isFinite(value.at) && (value.uuid === undefined || sessionId(value.uuid) !== null) && inputState(value.state);
-}
-
-const sdkInputs = (value: unknown): value is unknown[] | undefined => value === undefined || (Array.isArray(value) && value.every(sdkInput));
-
-export function sdkPending(home: string): number | null {
-  const state = sdkSavedSession(home);
-  if (state === null) return null;
-  if (state.sessionId !== undefined && state.sessionId !== null && sessionId(state.sessionId) === null) return null;
-  if (!sdkInputs(state.unanswered) || !sdkInputs(state.interrupted)) return null;
-  return state.unanswered?.length ?? 0;
-}
-
-function projectFolder(home: string, dir: string): string {
-  let cwd = home;
-  try {
-    cwd = realpathSync(home);
-  } catch {
-    cwd = home;
-  }
-  return join(dir, 'projects', cwd.replace(/[^A-Za-z0-9]/g, '-'));
-}
-
-export function continueArgs(home: string, dir = claudeDir(), agents = agentsDir()): string[] {
-  const path = join(agents, 'claude-session.json');
-  const raw = readJson<unknown>(path, null);
-  const state = isRecord(raw) ? raw : {};
-  const project = projectFolder(home, dir);
-  const pinned = sessionId(state.cliSessionId);
-  const id = pinned ?? randomUUID();
-  if (pinned === null) writeJson(path, { ...state, cliSessionId: id });
-  return [existsSync(join(project, `${id}.jsonl`)) ? '--resume' : '--session-id', id];
-}

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

@@ -1,76 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { ApiError } from '@metro-labs/http/api-error';
-import { errMsg, log } from '@metro-labs/core/log';
-import { sessionRunning, stopSession, type SessionDeps } from './session.js';
-import { agentUser, asAgent, claudeBin } from '../agent-user/user.js';
-import { CLAUDE_CODE_VERSION, installClaudeCode } from './pinned.js';
-
-const VERSION_RE = /(\d+)\.(\d+)\.(\d+)/;
-
-export interface VersionDeps {
-  claude?: string;
-  session?: SessionDeps;
-}
-
-export interface ClaudeVersion {
-  installed: string | null;
-  latest: string;
-  newer: boolean;
-}
-
-function candidates(deps: VersionDeps): string[] {
-  if (deps.claude !== undefined) return [deps.claude];
-  return agentUser() === null ? ['claude', join(homedir(), '.local', 'bin', 'claude')] : [claudeBin()];
-}
-
-const parse = (text: string): string | null => {
-  const m = VERSION_RE.exec(text);
-  return m === null ? null : `${m[1] ?? ''}.${m[2] ?? ''}.${m[3] ?? ''}`;
-};
-
-function probe(bin: string): string | null {
-  const run = spawnSync(...asAgent(bin, ['--version']), { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
-  return run.error === undefined && run.status === 0 && typeof run.stdout === 'string' ? parse(run.stdout) : null;
-}
-
-function located(deps: VersionDeps): { bin: string; installed: string } | null {
-  for (const bin of candidates(deps)) {
-    const installed = probe(bin);
-    if (installed !== null) return { bin, installed };
-  }
-  return null;
-}
-
-export function claudeVersion(deps: VersionDeps = {}): ClaudeVersion {
-  const installed = located(deps)?.installed ?? null;
-  return { installed, latest: CLAUDE_CODE_VERSION, newer: installed !== null && installed !== CLAUDE_CODE_VERSION };
-}
-
-function restartIfChanged(changed: boolean, session: SessionDeps): boolean {
-  if (!changed || !sessionRunning(session.tmux ?? 'tmux')) return false;
-  stopSession(session);
-  return true;
-}
-
-export function updateClaude(deps: VersionDeps = {}): ClaudeVersion & { restarted: boolean } {
-  const found = located(deps);
-  if (found === null) throw new ApiError('Claude Code is not installed on this machine', 404);
-  try {
-    installClaudeCode(found.bin);
-  } catch (err) {
-    throw new ApiError(errMsg(err), 502);
-  }
-  const after = claudeVersion(deps);
-  const restarted = restartIfChanged(after.installed !== null && after.installed !== found.installed, deps.session ?? {});
-  log.info({ from: found.installed, to: after.installed, restarted }, 'claude-version: Claude Code updated');
-  return { ...after, restarted };
-}
-
-export function pinClaudeCode(deps: VersionDeps = {}): void {
-  const found = located(deps);
-  if (found === null || found.installed === CLAUDE_CODE_VERSION) return;
-  installClaudeCode(found.bin);
-  log.info({ from: found.installed, to: located(deps)?.installed ?? null }, 'claude-version: installed the Claude Code version metro was checked with');
-}

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

@@ -1,38 +0,0 @@
-import { approvalId } from '@metro-labs/core/ids';
-import { errMsg, log } from '@metro-labs/core/log';
-import { forgetPromptsOf, holdPrompt, type Behavior } from '../approvals/pending.js';
-import { promptBody } from '../mcp/permission-prompt.js';
-import type { ToolAsk } from './brain.js';
-
-export class CallApprovals {
-  private closed = false;
-
-  constructor(
-    private readonly line: string,
-    private readonly post: (text: string) => Promise<void>,
-  ) {}
-
-  ask(ask: ToolAsk, answer: (behavior: Behavior) => void): string | null {
-    if (this.closed) return null;
-    const id = approvalId();
-    const preview = JSON.stringify(ask.input);
-    holdPrompt(
-      { requestId: id, tool: ask.tool, description: ask.description, preview, line: this.line, at: Date.now() },
-      this,
-      (behavior) => {
-        answer(behavior);
-        return Promise.resolve();
-      },
-      this.post,
-    );
-    this.post(promptBody({ request_id: id, tool_name: ask.tool, description: ask.description, input_preview: preview })).catch((err: unknown) => {
-      log.warn({ err: errMsg(err) }, 'voice: could not ask for an approval in the chat of the call');
-    });
-    return id;
-  }
-
-  close(): void {
-    this.closed = true;
-    forgetPromptsOf(this);
-  }
-}

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

@@ -1,146 +0,0 @@
-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;
-const DENIED = 'The owner did not approve this.';
-
-export interface ToolAsk {
-  requestId: string;
-  tool: string;
-  input: Record<string, unknown>;
-  description: string;
-  fromWorker: boolean;
-}
-
-export interface Thinking {
-  turnStarted(): void;
-  text(delta: string): void;
-  tool(name: string): void;
-  turnEnded(): void;
-  asked(ask: ToolAsk): void;
-  exited(reason: string): void;
-}
-
-const record = (value: unknown): Record<string, unknown> => (isRecord(value) ? value : {});
-const str = (value: unknown): string => (typeof value === 'string' ? value : '');
-
-export function toolAsk(msg: Record<string, unknown>): ToolAsk | null {
-  const request = record(msg.request);
-  const requestId = str(msg.request_id);
-  if (request.subtype !== 'can_use_tool' || requestId === '' || str(request.tool_name) === '') return null;
-  return {
-    requestId,
-    tool: str(request.tool_name),
-    input: record(request.input),
-    description: str(request.description) || str(request.decision_reason),
-    fromWorker: str(request.agent_id) !== '',
-  };
-}
-
-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 startBrain(model: string): ChildProcessWithoutNullStreams {
-  const [command = 'metro', ...args] = metroCli(['voice', '--model', model]);
-  const [file, argv] = asAgent(command, args);
-  return spawn(file, argv, { stdio: ['pipe', 'pipe', 'pipe'], cwd: '/' });
-}
-
-export class Brain {
-  private readonly child: ChildProcessWithoutNullStreams;
-  private out = '';
-  private gone = false;
-  private closing = false;
-  private killTimer: ReturnType<typeof setTimeout> | undefined;
-
-  constructor(model: string, private readonly mind: Thinking, launch = startBrain) {
-    this.child = launch(model);
-    this.child.stdout.setEncoding('utf8');
-    this.child.stdout.on('data', (chunk: string) => {
-      this.out = drainLines('voice-brain', this.out + chunk, (line) => {
-        this.read(line);
-      });
-    });
-    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)})`);
-    });
-  }
-
-  tell(text: string, now = false): void {
-    const message = { type: 'user', message: { role: 'user', content: text }, parent_tool_use_id: null, session_id: '' };
-    this.write(now ? { ...message, priority: 'now' } : message);
-  }
-
-  answer(ask: ToolAsk, behavior: 'allow' | 'deny'): void {
-    const response = behavior === 'allow' ? { behavior, updatedInput: ask.input } : { behavior, message: DENIED };
-    this.write({ type: 'control_response', response: { subtype: 'success', request_id: ask.requestId, response } });
-  }
-
-  close(): void {
-    if (this.gone || this.closing) return;
-    this.closing = true;
-    this.child.stdin.end();
-    this.child.kill('SIGTERM');
-    this.killTimer = setTimeout(() => {
-      if (!this.gone) this.child.kill('SIGKILL');
-    }, CLOSE_GRACE_MS);
-    this.killTimer.unref();
-  }
-
-  private write(message: Record<string, unknown>): void {
-    if (!this.gone && !this.closing && this.child.stdin.writable) this.child.stdin.write(`${JSON.stringify(message)}\n`);
-  }
-
-  private read(line: string): void {
-    if (this.closing || this.gone) return;
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      return;
-    }
-    const msg = record(parsed);
-    if (msg.type === 'system' && msg.subtype === 'init') this.mind.turnStarted();
-    else if (msg.type === 'stream_event') streamEvent(msg, this.mind);
-    else if (msg.type === 'result') this.mind.turnEnded();
-    else if (msg.type === 'control_request') this.control(msg);
-  }
-
-  private control(msg: Record<string, unknown>): void {
-    const ask = toolAsk(msg);
-    if (ask !== null) {
-      this.mind.asked(ask);
-      return;
-    }
-    const subtype = str(record(msg.request).subtype);
-    log.warn({ subtype }, 'voice: the agent session asked for something the call does not handle');
-    this.write({ type: 'control_response', response: { subtype: 'error', request_id: str(msg.request_id), error: `not supported on a voice call: ${subtype}` } });
-  }
-
-  private exit(reason: string): void {
-    if (this.gone) return;
-    this.gone = true;
-    clearTimeout(this.killTimer);
-    if (!this.closing) this.mind.exited(reason);
-  }
-}

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

@@ -1,54 +0,0 @@
-const FIRST_CLAUSE_MIN = 24;
-const LONGEST = 220;
-const SENTENCE_END = /[.!?…]+["')\]]*\s+|\n+/g;
-const CLAUSE_END = /[,;:]\s+/g;
-
-function speakable(text: string): string {
-  return text
-    .replace(/https?:\/\/\S+/g, 'the link')
-    .replace(/`{1,3}[^`]*`{1,3}/g, (code) => code.replace(/`/g, ''))
-    .replace(/^\s*(?:#+|[-*•]|\d+\.)\s+/gm, '')
-    .replace(/[*_~#|<>[\]{}]/g, '')
-    .replace(/\s+/g, ' ')
-    .trim();
-}
-
-function lastEnd(text: string, pattern: RegExp): number {
-  let end = -1;
-  for (const match of text.matchAll(pattern)) end = match.index + match[0].length;
-  return end;
-}
-
-function cutAt(text: string, first: boolean): number {
-  const sentence = lastEnd(text, SENTENCE_END);
-  if (sentence > 0) return sentence;
-  if (first && text.length >= FIRST_CLAUSE_MIN) {
-    const clause = lastEnd(text, CLAUSE_END);
-    if (clause > 0) return clause;
-  }
-  if (text.length < LONGEST) return -1;
-  const space = text.lastIndexOf(' ');
-  return space > 0 ? space + 1 : text.length;
-}
-
-export class Chunker {
-  private buffer = '';
-  private first = true;
-
-  add(delta: string): string[] {
-    this.buffer += delta;
-    const at = cutAt(this.buffer, this.first);
-    if (at < 0) return [];
-    const ready = speakable(this.buffer.slice(0, at));
-    this.buffer = this.buffer.slice(at);
-    if (ready === '') return [];
-    this.first = false;
-    return [ready];
-  }
-
-  flush(): string[] {
-    const rest = speakable(this.buffer);
-    this.buffer = '';
-    return rest === '' ? [] : [rest];
-  }
-}