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

package/dist/agent.js

@@ -2,9 +2,11 @@ import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } fr
 import { spawnSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { headlessEnv, runClaude } from './claude.js';
+import { runChild } from './child.js';
+import { headlessEnv, NO_UPDATES } from './claude-env.js';
 import { localAgent } from './local.js';
-import { currentModel, harnessRunner, permissionMode, systemPrompt } from './route.js';
+import { withLock } from './lock.js';
+import { currentModel, permissionMode, systemPrompt } from './route.js';
 import { installDependencies, ranges, readOrNull } from './runtime-install.js';
 import { findBun, localPort, runtimeDir } from './runtime.js';
 export const RUNNER_SOURCES = 'sdk-runner';
@@ -13,7 +15,8 @@ const ENTRY = join('src', 'main.ts');
 const METRO_MODULES = join('node_modules', '@metro-labs');
 const BUNFIG = '[install]\noptional = false\npeer = false\n';
 const SDK = '@anthropic-ai/claude-agent-sdk';
-const NOT_THE_RUNNER = 'the Harness runs this agent as a Claude Code session, so metro agent does not start: it would take the metro chat away from it. Choose Agent SDK as the Harness runner on metro.box first';
+const PREPARE_LOCK = '.prepare.lock';
+const PREPARE_WAIT = { staleMs: 20 * 60_000, waitMs: 20 * 60_000, pollMs: 250 };
 export function runnerStore(env = process.env) {
     const explicit = env.METRO_RUNNER_STORE?.trim() ?? '';
     return explicit === '' ? join(homedir(), '.metro', 'sdk-runner') : explicit;
@@ -49,14 +52,20 @@ function stageSources(sources, store, stamp) {
         writeFileSync(join(store, 'bunfig.toml'), BUNFIG);
 }
 export function prepareRunner(opts = {}) {
-    const sources = opts.sources ?? join(runtimeDir(), RUNNER_SOURCES);
-    const stamp = readFileSync(join(sources, STAMP), 'utf8');
     const store = opts.store ?? runnerStore();
-    stageSources(sources, store, stamp);
     const log = opts.log ??
         ((line) => {
             process.stderr.write(`metro agent: ${line}\n`);
         });
+    const waiting = () => {
+        log(`waiting for another preparation of ${store} to finish`);
+    };
+    return withLock(join(store, PREPARE_LOCK), { ...PREPARE_WAIT, waiting }, () => prepareIn(store, opts, log));
+}
+function prepareIn(store, opts, log) {
+    const sources = opts.sources ?? join(runtimeDir(), RUNNER_SOURCES);
+    const stamp = readFileSync(join(sources, STAMP), 'utf8');
+    stageSources(sources, store, stamp);
     const pkg = opts.claude ?? claudePackage();
     const claude = join(store, 'node_modules', ...pkg.name.split('/'), pkg.binary);
     const marker = join(store, 'node_modules', '.metro-installed');
@@ -79,17 +88,12 @@ export function runnerEnv(key, port, model, mode, prompt, claude) {
         ...(prompt === null ? {} : { METRO_RUNNER_PROMPT: prompt }),
     };
 }
-export function sdkGatewayEnv(env) {
-    const own = (env.ANTHROPIC_CUSTOM_HEADERS ?? '').trim();
-    const header = 'x-metro-runner: sdk';
-    return { ...env, ANTHROPIC_CUSTOM_HEADERS: own === '' ? header : `${own}\n${header}` };
-}
 function checkBinary(bin) {
-    const run = spawnSync(bin, ['--version'], { stdio: 'ignore', timeout: 30_000 });
+    const run = spawnSync(bin, ['--version'], { env: { ...process.env, ...NO_UPDATES }, stdio: 'ignore', timeout: 30_000 });
     if (run.error !== undefined || run.status !== 0)
         throw new Error(`Runner preflight failed: ${bin} cannot run (${run.error?.message ?? `exit ${String(run.status)}`}).`);
 }
-function checkPreparedRunner(opts) {
+export function prepareAgentRunner(opts = {}) {
     const prepared = prepareRunner(opts);
     try {
         checkBinary(prepared.claude);
@@ -99,30 +103,21 @@ function checkPreparedRunner(opts) {
         throw err;
     }
 }
-export function prepareAgentRunner(runner, opts = {}) {
-    if (runner === 'cli')
-        checkBinary('claude');
-    else if (runner === 'sdk')
-        checkPreparedRunner(opts);
-    else
-        throw new Error('metro agent --prepare needs cli or sdk');
-}
+const prepareOnly = (args) => args[0] === '--prepare' && (args.length === 1 || (args.length === 2 && args[1] === 'sdk'));
 export async function agentSession(args = []) {
-    if (args[0] === '--prepare' && args.length <= 2) {
-        prepareAgentRunner(args[1] ?? 'sdk');
+    if (prepareOnly(args)) {
+        prepareAgentRunner();
         return 0;
     }
     if (args.length > 0)
-        throw new Error('metro agent accepts only --prepare [cli|sdk]');
+        throw new Error('metro agent accepts only --prepare');
     process.chdir(homedir());
-    if (harnessRunner() !== 'sdk')
-        throw new Error(NOT_THE_RUNNER);
     const agent = localAgent();
     if (agent === null)
         throw new Error('metro agent needs the agent of this machine, and there is none yet');
     const bun = findBun();
     const runner = prepareRunner({ bun });
     process.stderr.write('metro agent: this agent runs as one Agent SDK session: a light front talks, background workers do the work\n');
-    const env = { ...sdkGatewayEnv(await headlessEnv()), ...runnerEnv(agent.key, localPort(), currentModel(), permissionMode(), systemPrompt(), runner.claude) };
-    return runClaude([runner.entry], env, undefined, bun);
+    const env = { ...(await headlessEnv(runner.claude, 'metro agent')), ...runnerEnv(agent.key, localPort(), currentModel(), permissionMode(), systemPrompt(), runner.claude) };
+    return runChild(bun, [runner.entry], env);
 }

package/dist/child.js

@@ -0,0 +1,33 @@
+import { spawn } from 'node:child_process';
+const KILL_GRACE_MS = 30_000;
+function deadline(child, timeoutMs) {
+    if (timeoutMs === undefined)
+        return () => undefined;
+    let kill;
+    const term = setTimeout(() => {
+        child.kill('SIGTERM');
+        kill = setTimeout(() => {
+            child.kill('SIGKILL');
+        }, KILL_GRACE_MS);
+    }, timeoutMs);
+    return () => {
+        clearTimeout(term);
+        clearTimeout(kill);
+    };
+}
+export function runChild(command, args, env, headless) {
+    return new Promise((resolve, reject) => {
+        const leaveToChild = () => undefined;
+        process.on('SIGINT', leaveToChild);
+        process.on('SIGTERM', leaveToChild);
+        const child = spawn(command, args, { stdio: [headless === undefined ? 'inherit' : 'ignore', 'inherit', 'inherit'], env });
+        const stop = deadline(child, headless?.timeoutMs);
+        child.on('error', (err) => {
+            reject(new Error(err.code === 'ENOENT' ? `${command} was not found` : err.message));
+        });
+        child.on('exit', (code) => {
+            stop();
+            resolve(code ?? 1);
+        });
+    });
+}

package/dist/claude-env.js

@@ -0,0 +1,104 @@
+import { spawnSync } from 'node:child_process';
+import { currentRoute, routeModelEnv } from './route.js';
+import { settingsConflicts, settingsFiles } from './claude-settings.js';
+import { localAgent } from './local.js';
+import { PROVIDER_FLAGS } from './provider-flags.js';
+import { localPort, localUrl } from './runtime.js';
+const KEY_HEADER = 'x-metro-key';
+const PROBE_MS = 3_000;
+const AUTH_STATUS_MS = 20_000;
+const RM_PROMPT_OFF = 'CLAUDE_CODE_DISABLE_INLINE_SHELL_RM_PROMPT';
+const OWN_CREDENTIALS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'];
+export const AGENT_VIEW_OFF = 'CLAUDE_CODE_DISABLE_AGENT_VIEW';
+export const NO_UPDATES = { DISABLE_AUTOUPDATER: '1' };
+const set = (env, name) => (env[name] ?? '').trim() !== '';
+export function pinnedBy(env) {
+    if (set(env, 'ANTHROPIC_BASE_URL'))
+        return 'ANTHROPIC_BASE_URL';
+    return PROVIDER_FLAGS.find((flag) => set(env, flag)) ?? null;
+}
+export function gatewayEnv(base, agentKey, port) {
+    if (agentKey === null || pinnedBy(base) !== null)
+        return base;
+    const own = (base.ANTHROPIC_CUSTOM_HEADERS ?? '').trim();
+    const mine = `${KEY_HEADER}: ${agentKey}`;
+    return {
+        ...base,
+        ANTHROPIC_BASE_URL: `http://127.0.0.1:${String(port)}/gateway`,
+        ANTHROPIC_CUSTOM_HEADERS: own === '' ? mine : `${own}\n${mine}`,
+        CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '1',
+    };
+}
+export const toolSearchEnv = (env) => set(env, 'ENABLE_TOOL_SEARCH') ? env : { ...env, ENABLE_TOOL_SEARCH: 'true' };
+export const rmPromptEnv = (env) => set(env, RM_PROMPT_OFF) ? env : { ...env, [RM_PROMPT_OFF]: '1' };
+export const keepInSession = (env) => set(env, AGENT_VIEW_OFF) ? env : { ...env, [AGENT_VIEW_OFF]: '1' };
+export function credentialEnv(env, agentKey, signedIn) {
+    if (signedIn || OWN_CREDENTIALS.some((name) => set(env, name)))
+        return env;
+    return { ...env, ANTHROPIC_AUTH_TOKEN: agentKey };
+}
+export function claudeSignedIn(claude, env = process.env) {
+    const run = spawnSync(claude, ['auth', 'status', '--json'], { encoding: 'utf8', env: { ...env, ...NO_UPDATES }, stdio: ['ignore', 'pipe', 'ignore'], timeout: AUTH_STATUS_MS });
+    if (run.error !== undefined || typeof run.stdout !== 'string')
+        return false;
+    try {
+        const parsed = JSON.parse(run.stdout);
+        return parsed.authenticated === true || parsed.loggedIn === true || typeof parsed.email === 'string' || typeof parsed.organization === 'string';
+    }
+    catch {
+        return false;
+    }
+}
+export function servingDaemon(body) {
+    if (typeof body !== 'object' || body === null)
+        return false;
+    const mode = body;
+    return mode.mode === 'local' && mode.stopped !== true;
+}
+async function daemonServing(base = localUrl()) {
+    try {
+        const res = await fetch(`${base}/api/mode`, { signal: AbortSignal.timeout(PROBE_MS) });
+        return res.ok && servingDaemon(await res.json());
+    }
+    catch {
+        return false;
+    }
+}
+export function agentKey(agent) {
+    return agent === null ? { skip: 'no agent lives on this machine yet, so Claude Code talks to Anthropic directly' } : { key: agent.key };
+}
+async function verdict() {
+    const pinned = pinnedBy(process.env);
+    if (pinned !== null)
+        return { skip: `${pinned} is set, so Claude Code keeps talking to it` };
+    const conflicts = settingsConflicts(settingsFiles());
+    if (conflicts.length > 0)
+        return { skip: `a settings file pins the provider (${conflicts.join(', ')}), so Claude Code keeps it` };
+    const picked = agentKey(localAgent());
+    if ('skip' in picked)
+        return picked;
+    if (await daemonServing())
+        return picked;
+    return { skip: 'the daemon is not serving here (stopped, or not running), so Claude Code talks to Anthropic directly' };
+}
+function gatewayLaunchEnv(key, port, claude, say) {
+    say(`inference goes through the daemon at http://127.0.0.1:${String(port)}/gateway (the Model page decides where)`);
+    const pointed = routeModelEnv(gatewayEnv(process.env, key, port), currentRoute());
+    const routed = toolSearchEnv(pointed);
+    if (routed !== pointed)
+        say('MCP tool search is on, so connector tools load when Claude needs them instead of all at start');
+    const env = credentialEnv(routed, key, claudeSignedIn(claude));
+    if (env !== routed)
+        say("Claude Code has no login of its own here, so metro's key stands in as its credential; the Model page must route to Bedrock, OpenRouter or Codex");
+    return env;
+}
+export async function headlessEnv(claude, command) {
+    const say = (line) => {
+        process.stderr.write(`${command}: ${line}\n`);
+    };
+    const decision = await verdict();
+    if ('skip' in decision)
+        say(decision.skip);
+    const env = 'key' in decision ? gatewayLaunchEnv(decision.key, localPort(), claude, say) : process.env;
+    return { ...keepInSession(rmPromptEnv(env)), ...NO_UPDATES };
+}

package/dist/cli.js

@@ -4,13 +4,11 @@ import { stopAll } from './control.js';
 import { tailEvents } from './tail.js';
 import { agentSession } from './agent.js';
 import { automationCommand } from './automation.js';
-import { launchClaude } from './claude.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>]
@@ -31,16 +29,12 @@ const USAGE = `metro: run your agent on this machine
   metro tail [agent-id]
                   follow this machine's inbound events, one JSON line each
   metro whoami    print the agent this machine runs
-  metro claude [args...]
-                  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 agent     run chat, calls and background workers in one Agent SDK conversation,
-                  when the Harness runner is Agent SDK, using the Model page's model;
+                  using the Model page's model through the daemon's model gateway;
                   resume it after a restart; call audio runs independently
-  metro agent --prepare [cli|sdk]
-                  check the runner before selecting it; install the SDK runtime if needed,
-                  without starting a session or connecting to chat
+  metro agent --prepare
+                  install the Agent SDK runtime and the Claude Code it bundles if needed,
+                  and check that it runs, without starting a session or connecting to chat
   metro task submit <routine> <prompt-file> [--slot <UTC ISO timestamp>] [--dry-run]
   metro task status [routine]
   metro task finish <uuid> <token> completed|blocked
@@ -50,15 +44,9 @@ const USAGE = `metro: run your agent on this machine
                   --dry-run writes nothing; local authorization is not fresh owner approval
   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, hooks,
-                  connectors and metro tools (on /mcp/voice, so the chat session keeps its
-                  slot) but no metro channel; tool approvals come back on stdout
+                  the last run, the Claude Code bundled with the Agent SDK 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 update    update to the newest published version (--check only reports)
   metro version   print this CLI's version
 
@@ -91,11 +79,9 @@ const COMMANDS = {
     service: () => service(process.argv.slice(3)),
     stop: stopDaemon,
     tail: () => tailEvents(process.argv.slice(3)),
-    claude: () => launchClaude(process.argv.slice(3)),
     agent: () => agentSession(process.argv.slice(3)),
     task: () => automationCommand(process.argv.slice(3)),
     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/lock.js

@@ -0,0 +1,62 @@
+import { closeSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { readOrNull } from './runtime-install.js';
+const pause = new Int32Array(new SharedArrayBuffer(4));
+export function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === 'EPERM';
+    }
+}
+function lockHeld(path, now, staleMs) {
+    try {
+        if (now - statSync(path).mtimeMs >= staleMs)
+            return false;
+        const pid = Number(readFileSync(path, 'utf8').trim());
+        return !Number.isInteger(pid) || pid <= 0 || processAlive(pid);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return false;
+        throw err;
+    }
+}
+export function takeLock(path, staleMs, now = Date.now(), retry = true) {
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        const fd = openSync(path, 'wx');
+        writeSync(fd, String(process.pid));
+        closeSync(fd);
+        return true;
+    }
+    catch (err) {
+        if (err.code !== 'EEXIST')
+            throw err;
+        if (!retry || lockHeld(path, now, staleMs))
+            return false;
+        rmSync(path, { force: true });
+        return takeLock(path, staleMs, now, false);
+    }
+}
+export function withLock(path, wait, run) {
+    const deadline = Date.now() + wait.waitMs;
+    let told = false;
+    while (!takeLock(path, wait.staleMs)) {
+        if (Date.now() >= deadline)
+            throw new Error(`Another process still holds ${path}; try again later.`);
+        if (!told)
+            wait.waiting?.();
+        told = true;
+        Atomics.wait(pause, 0, 0, wait.pollMs);
+    }
+    try {
+        return run();
+    }
+    finally {
+        if (readOrNull(path)?.trim() === String(process.pid))
+            rmSync(path, { force: true });
+    }
+}

package/dist/memory.js

@@ -1,8 +1,10 @@
-import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { claudeDir, processAlive, projectDir } from './background.js';
-import { headlessEnv, runClaude } from './claude.js';
+import { join } from 'node:path';
+import { prepareRunner } from './agent.js';
+import { runChild } from './child.js';
+import { headlessEnv } from './claude-env.js';
+import { takeLock } from './lock.js';
 import { systemPrompt } from './route.js';
 export const MEMORY_FOLDERS = [
     'entities/people',
@@ -24,6 +26,8 @@ const FINISHED = /^\s*status:\s*["']?(completed|parked|abandoned)["']?\s*$/m;
 const LISTED_MAX = 60;
 const WALK_DEPTH = 4;
 const given = (value) => (typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined);
+const claudeDir = (env) => given(env.CLAUDE_CONFIG_DIR) ?? join(given(env.HOME) ?? homedir(), '.claude');
+export const projectDir = (dir, cwd) => join(dir, 'projects', cwd.replace(/[^A-Za-z0-9]/g, '-'));
 function realHome(home) {
     try {
         return realpathSync(home);
@@ -122,27 +126,6 @@ export function routineArgs(prompt, memory, appended) {
     ];
 }
 export const routineEnv = (env) => ({ ...env, METRO_SESSION: 'memory' });
-function lockHeld(path, now) {
-    const pid = Number(readFileSync(path, 'utf8').trim());
-    return now - statSync(path).mtimeMs < LOCK_STALE_MS && Number.isInteger(pid) && pid > 0 && processAlive(pid);
-}
-export function takeLock(path, now = Date.now(), retry = true) {
-    try {
-        mkdirSync(dirname(path), { recursive: true });
-        const fd = openSync(path, 'wx');
-        writeSync(fd, String(process.pid));
-        closeSync(fd);
-        return true;
-    }
-    catch (err) {
-        if (err.code !== 'EEXIST')
-            throw err;
-        if (!retry || lockHeld(path, now))
-            return false;
-        rmSync(path, { force: true });
-        return takeLock(path, now, false);
-    }
-}
 const frontmatter = (text) => (text.startsWith('---\n') ? text.slice(4, text.indexOf('\n---', 4)) : '');
 export function settleWorkstreams(memory) {
     const active = join(memory, 'workstreams', 'active');
@@ -193,7 +176,9 @@ async function digest(paths, now) {
     for (const folder of MEMORY_FOLDERS)
         mkdirSync(join(paths.memory, folder), { recursive: true });
     const prompt = routinePrompt(now, since, paths, files);
-    const code = await runClaude(routineArgs(prompt, paths.memory, systemPrompt()), routineEnv(await headlessEnv()), { timeoutMs: TIMEOUT_MS });
+    const { claude } = prepareRunner({ log: say });
+    const env = routineEnv(await headlessEnv(claude, 'metro memory'));
+    const code = await runChild(claude, routineArgs(prompt, paths.memory, systemPrompt()), env, { timeoutMs: TIMEOUT_MS });
     if (code === 0) {
         writeFileSync(paths.state, `${JSON.stringify({ lastRun: now.toISOString() })}\n`);
         const moved = settleWorkstreams(paths.memory);
@@ -208,7 +193,7 @@ export async function memoryRoutine(paths = memoryPaths(), now = new Date()) {
         say(`skipped: no memory skill at ${paths.skill}`);
         return 0;
     }
-    if (!takeLock(paths.lock)) {
+    if (!takeLock(paths.lock, LOCK_STALE_MS)) {
         say('skipped: the previous run is still going');
         return 0;
     }

package/dist/root-release-io.js

@@ -4,8 +4,7 @@ import { X509Certificate } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { isRecord } from './background.js';
-import { ISSUER, isVersion, PUBLISHER, RELEASE_DIR } from './root-release.js';
+import { ISSUER, isRecord, isVersion, PUBLISHER, RELEASE_DIR } from './root-release.js';
 import { PACKAGE_NAME } from './version.js';
 const REGISTRY = 'https://registry.npmjs.org';
 const ENCODED = PACKAGE_NAME.replace('/', '%2F');

package/dist/root-release.js

@@ -1,5 +1,4 @@
 import { createHash } from 'node:crypto';
-import { isRecord } from './background.js';
 import { compareVersions, PACKAGE_NAME } from './version.js';
 export const RELEASE_DIR = '/usr/local/lib/metro/release';
 export const PUBLISHER = 'https://github.com/bonustrack/metro/.github/workflows/publish-cli.yml@refs/heads/main';
@@ -8,6 +7,7 @@ const REGISTRY = 'https://registry.npmjs.org';
 const PROVENANCE = 'https://slsa.dev/provenance/v1';
 const IN_TOTO = 'application/vnd.in-toto+json';
 const VERSION_RE = /^\d{1,9}\.\d{1,9}\.\d{1,9}(?:-[0-9A-Za-z]{1,20}(?:\.[0-9A-Za-z]{1,20}){0,4})?$/;
+export const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 export const isVersion = (raw) => VERSION_RE.test(raw);
 export const tarballUrl = (version) => `${REGISTRY}/${PACKAGE_NAME}/-/metro-${version}.tgz`;
 const subjectName = (version) => `pkg:npm/${PACKAGE_NAME.replace('@', '%40')}@${version}`;

package/dist/route.js

@@ -51,7 +51,6 @@ function setupField(dir, field) {
         return undefined;
     }
 }
-export const harnessRunner = (dir = agentsDir()) => (setupField(dir, 'runner') === 'sdk' ? 'sdk' : 'cli');
 export function systemPrompt(dir = agentsDir()) {
     const path = join(dir, 'system-prompt.md');
     if (!existsSync(path))

package/hooks/guard.mjs

@@ -26,7 +26,6 @@ const IMAGE = /\.(png|jpe?g|gif|webp|bmp)$/i;
 const MCP = /^mcp__/;
 const METRO_MCP = /^mcp__metro__/;
 const CONNECTOR_CALL = 'mcp__metro__tool_call';
-const VOICE = process.env.METRO_SESSION === 'voice';
 
 const connectorWork = (tool) =>
   `A connector call is work, not orchestration: ${tool} reads somebody's files, mail or records, and its answer can be long enough to crowd out the chat you are here to follow. Only metro's own tools run on this thread. Delegate it to a subagent with the Agent tool (run_in_background: true; the worker reaches every connector) and relay what it finds.`;
@@ -55,10 +54,7 @@ function verdict(payload, input) {
     return `${tool} blocks the session waiting on the terminal, and nobody is watching it. Decide with your best judgement and state the assumption, or ask over chat with the metro tools and keep working in the meantime.`;
   if (typeof payload.agent_id === 'string' && payload.agent_id !== '') return null;
   if (tool === 'Agent' && input.run_in_background === false)
-    return VOICE
-      ? 'On a voice call a foreground subagent leaves the caller in silence until it finishes. Re-issue the identical Agent call with run_in_background: true, tell the caller you will come back to it, and keep talking.'
-      : 'A foreground subagent blinds the main thread: it cannot see or acknowledge inbound metro messages until the agent finishes. Re-issue the identical Agent call with run_in_background: true, then wait for the task notification.';
-  if (VOICE) return null;
+    return 'A foreground subagent blinds the main thread: it cannot see or acknowledge inbound metro messages until the agent finishes. Re-issue the identical Agent call with run_in_background: true, then wait for the task notification.';
   if (ORCHESTRATION.has(tool)) return null;
   if (tool === CONNECTOR_CALL) return connectorWork(tool);
   if (METRO_MCP.test(tool)) return null;

package/hooks/session-start.mjs

@@ -24,7 +24,7 @@ function guidance() {
   return '';
 }
 
-const text = ['voice', 'memory'].includes(process.env.METRO_SESSION) ? '' : guidance();
+const text = process.env.METRO_SESSION === 'memory' ? '' : guidance();
 if (text !== '')
   process.stdout.write(
     `${JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: `This machine runs as a metro agent. Standing rules, kept in the metro skill:\n\n${text}` } })}\n`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.307",
+  "version": "0.1.0-beta.309",
   "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/node_modules/@metro-labs/daemon/src/agent-user/provision.ts

@@ -1,18 +1,13 @@
-import { spawn, spawnSync } from 'node:child_process';
-import { existsSync } from './agent-fs.js';
+import { spawnSync } from 'node:child_process';
 import { join } from 'node:path';
 import { chmodSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { errMsg, log } from '@metro-labs/core/log';
-import { AGENT_NAME, agentUser, agentUserExpected, asUser, claudeBin, forgetAgentUser, type AgentUser } from './user.js';
+import { AGENT_NAME, agentUser, agentUserExpected, asUser, forgetAgentUser, type AgentUser } from './user.js';
 import { watchAgentView } from './view.js';
 import { closeMetroHome } from './metro-home.js';
 import { mustHelper } from '../metro-user/privilege.js';
-import { CLAUDE_CODE_VERSION } from '../claude/pinned.js';
-import { pinClaudeCode } from '../claude/version.js';
-
-const INSTALL_MS = 10 * 60_000;
-const INSTALLER = `curl -fsSL https://claude.ai/install.sh | bash -s ${CLAUDE_CODE_VERSION}`;
+import { prepareRunnerStore } from '../claude/session.js';
 
 export type Provisioned = 'off' | 'failed' | 'ready';
 
@@ -39,40 +34,11 @@ function ensureUser(): AgentUser | null {
   return user;
 }
 
-function installClaude(user: AgentUser): Promise<void> {
-  if (existsSync(claudeBin(user))) return Promise.resolve();
-  const [file, args] = asUser(user, 'bash', ['-c', INSTALLER]);
-  return new Promise((resolve, reject) => {
-    const child = spawn(file, args, { stdio: ['ignore', 'ignore', 'pipe'], cwd: '/', timeout: INSTALL_MS });
-    let said = '';
-    child.stderr.on('data', (chunk: Buffer) => {
-      said = `${said}${chunk.toString('utf8')}`.slice(-2000);
-    });
-    child.on('error', reject);
-    child.on('close', (code) => {
-      if (code === 0 && existsSync(claudeBin(user))) {
-        log.info({ user: user.name }, 'agent-user: installed Claude Code for the agent user');
-        resolve();
-      } else reject(new Error(`the Claude Code installer failed: ${said.trim() || `exit ${String(code)}`}`));
-    });
-  });
-}
-
-function pinCheckedClaude(): void {
-  try {
-    pinClaudeCode();
-  } catch (err) {
-    log.warn({ want: CLAUDE_CODE_VERSION, err: errMsg(err) }, 'agent-user: could not install the Claude Code version metro was checked with; keeping the installed one');
-  }
-}
-
-export async function provisionAgentUser(): Promise<Provisioned> {
+export function provisionAgentUser(): Provisioned {
   if (!agentUserExpected()) return 'off';
   try {
     const user = ensureUser();
     if (user === null) throw new Error(`the user ${AGENT_NAME} could not be found after creating it`);
-    await installClaude(user);
-    pinCheckedClaude();
     watchAgentView();
     return 'ready';
   } catch (err) {
@@ -80,3 +46,12 @@ export async function provisionAgentUser(): Promise<Provisioned> {
     return 'failed';
   }
 }
+
+export async function prepareAgentRunner(): Promise<void> {
+  try {
+    await prepareRunnerStore();
+    log.info('agent-user: the Agent SDK runner and the Claude Code it bundles are ready for the agent user');
+  } catch (err) {
+    log.error({ err: errMsg(err) }, 'agent-user: could not prepare the Agent SDK runner; the session start runs metro agent, which prepares it again');
+  }
+}

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

@@ -1,4 +1,6 @@
 import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { runningAsMetro } from '../metro-user/privilege.js';
 
@@ -81,8 +83,26 @@ export const agentCommand = (command: readonly string[], extra: Record<string, s
   return [bin, ...argv];
 };
 
+const SDK_PACKAGE = '@anthropic-ai/claude-agent-sdk';
+
+export const CLAUDE_ENV: Readonly<Record<string, string>> = { DISABLE_AUTOUPDATER: '1' };
+
+let musl: boolean | null = null;
+
+function muslFirst(): boolean {
+  if (process.platform !== 'linux') return false;
+  if (musl === null) {
+    const report = process.report.getReport() as { header?: { glibcVersionRuntime?: string } };
+    musl = report.header?.glibcVersionRuntime === undefined;
+  }
+  return musl;
+}
+
 export function claudeBin(user = agentUser()): string {
-  return user === null ? 'claude' : join(user.home, '.local', 'bin', 'claude');
+  const name = `${SDK_PACKAGE}-${process.platform}-${process.arch}`;
+  const packages = muslFirst() ? [`${name}-musl`, name] : [name, `${name}-musl`];
+  const [first = '', other = ''] = packages.map((pkg) => join(user?.home ?? homedir(), '.metro', 'sdk-runner', 'node_modules', pkg, 'claude'));
+  return existsSync(first) || !existsSync(other) ? first : other;
 }
 
 export const claudeHome = (user = agentUser()): string | null => (user === null ? null : user.home);