@stage-labs/metro 0.1.0-beta.259 → 0.1.0-beta.260

package/dist/agent.js

@@ -0,0 +1,128 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { headlessEnv, runClaude } from './claude.js';
+import { localAgent } from './local.js';
+import { currentModel, harnessRunner, 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';
+const STAMP = 'runner.json';
+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';
+export function runnerStore(env = process.env) {
+    const explicit = env.METRO_RUNNER_STORE?.trim() ?? '';
+    return explicit === '' ? join(homedir(), '.metro', 'sdk-runner') : explicit;
+}
+export function readRunnerManifest(text) {
+    const raw = JSON.parse(text);
+    return {
+        version: typeof raw.version === 'string' ? raw.version : '',
+        dependencies: ranges(raw.dependencies),
+    };
+}
+function glibcMissing() {
+    const report = process.report.getReport();
+    return report.header?.glibcVersionRuntime === undefined;
+}
+export function claudePackage(platform = process.platform, arch = process.arch, musl = platform === 'linux' && glibcMissing()) {
+    return { name: `${SDK}-${platform}-${arch}${musl ? '-musl' : ''}`, binary: platform === 'win32' ? 'claude.exe' : 'claude' };
+}
+export function runnerDependencies(manifest, pkg) {
+    const sdk = manifest.dependencies[SDK];
+    return sdk === undefined ? manifest.dependencies : { ...manifest.dependencies, [pkg.name]: sdk };
+}
+function stageSources(sources, store, stamp) {
+    mkdirSync(store, { recursive: true });
+    if (readOrNull(join(store, STAMP)) !== stamp || !existsSync(join(store, ENTRY))) {
+        rmSync(join(store, 'src'), { recursive: true, force: true });
+        rmSync(join(store, METRO_MODULES), { recursive: true, force: true });
+        cpSync(join(sources, 'src'), join(store, 'src'), { recursive: true });
+        cpSync(join(sources, METRO_MODULES), join(store, METRO_MODULES), { recursive: true });
+        writeFileSync(join(store, STAMP), stamp);
+    }
+    if (readOrNull(join(store, 'bunfig.toml')) !== BUNFIG)
+        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 pkg = opts.claude ?? claudePackage();
+    const claude = join(store, 'node_modules', ...pkg.name.split('/'), pkg.binary);
+    const marker = join(store, 'node_modules', '.metro-installed');
+    if (!existsSync(claude))
+        rmSync(marker, { force: true });
+    installDependencies(store, runnerDependencies(readRunnerManifest(stamp), pkg), opts.bun ?? findBun(), log);
+    if (!existsSync(claude)) {
+        rmSync(marker, { force: true });
+        throw new Error(`The Claude Code binary bundled with the Agent SDK is missing at ${claude}. Try preparing the runner again.`);
+    }
+    return { entry: join(store, ENTRY), claude };
+}
+export function runnerEnv(key, port, model, mode, prompt, claude) {
+    return {
+        METRO_RUNNER_MCP_URL: `http://127.0.0.1:${String(port)}/mcp`,
+        METRO_RUNNER_CLAUDE: claude,
+        METRO_AGENT_KEY: key,
+        METRO_RUNNER_PERMISSION_MODE: mode,
+        ...(model === null ? {} : { METRO_RUNNER_MODEL: model }),
+        ...(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 });
+    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) {
+    const prepared = prepareRunner(opts);
+    try {
+        checkBinary(prepared.claude);
+    }
+    catch (err) {
+        rmSync(join(opts.store ?? runnerStore(), 'node_modules', '.metro-installed'), { force: true });
+        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');
+}
+export async function agentSession(args = []) {
+    if (args[0] === '--prepare' && args.length <= 2) {
+        prepareAgentRunner(args[1] ?? 'sdk');
+        return 0;
+    }
+    if (args.length > 0)
+        throw new Error('metro agent accepts only --prepare [cli|sdk]');
+    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);
+}

package/dist/background.js

@@ -96,6 +96,20 @@ function stopBackground(id, env = process.env) {
     const said = `${run.stdout}${run.stderr}`.trim().split('\n').at(-1) ?? '';
     return { ok: run.status === 0, detail: said === '' ? `exit ${String(run.status)}` : said };
 }
+export function resumeSessionId(args) {
+    const index = args.findLastIndex((arg) => arg === '--resume' || arg === '-r');
+    const id = index === -1 ? undefined : args[index + 1];
+    return id !== undefined && /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(id) ? id : undefined;
+}
+function pinnedHeld(dir, live, id) {
+    if (live.has(id))
+        return id;
+    const path = join(dir, `${id}.jsonl`);
+    if (!existsSync(path))
+        return null;
+    const moved = continuedIn(readFileSync(path, 'utf8'));
+    return moved !== null && live.has(moved) ? moved : null;
+}
 const sleep = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
@@ -107,12 +121,16 @@ async function settled(sessions, held, alive, ms) {
     await sleep(POLL_MS);
     return settled(sessions, held, alive, ms - POLL_MS);
 }
+function heldFor(deps, dir, live) {
+    const project = projectDir(dir, deps.cwd ?? process.cwd());
+    return deps.sessionId === undefined ? heldConversation(project, live) : pinnedHeld(project, live, deps.sessionId);
+}
 export async function takeBackConversation(deps = {}) {
     const env = deps.env ?? process.env;
     const alive = deps.alive ?? processAlive;
     const dir = claudeDir(env);
     const sessions = join(dir, 'sessions');
-    const held = heldConversation(projectDir(dir, deps.cwd ?? process.cwd()), liveBackground(sessions, alive));
+    const held = heldFor(deps, dir, liveBackground(sessions, alive));
     if (held === null)
         return null;
     const id = held.slice(0, 8);

package/dist/claude.js

@@ -1,12 +1,12 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { markOnboardingDone, seedChannels } from './onboarding.js';
 import { writeMcpConfig } from './mcp-config.js';
-import { currentRoute, permissionMode, routeModelEnv, systemPrompt } from './route.js';
+import { currentRoute, harnessRunner, permissionMode, routeModelEnv, systemPrompt } 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';
-import { keepInSession, takeBackConversation } from './background.js';
+import { keepInSession, resumeSessionId, takeBackConversation } from './background.js';
 const CHANNEL_FLAGS = ['--dangerously-load-development-channels', 'server:metro'];
 const FRESH_PROMPT_FLAGS = ['--system-prompt-snapshot', 'off'];
 export const PERMISSION_MODE_FLAG = { auto: 'auto', bypass: 'bypassPermissions' };
@@ -108,16 +108,16 @@ function deadline(child, timeoutMs) {
         clearTimeout(kill);
     };
 }
-export function runClaude(args, env, headless) {
+export function runClaude(args, env, headless, command = 'claude') {
     return new Promise((resolve, reject) => {
         const leaveToChild = () => undefined;
         process.on('SIGINT', leaveToChild);
         process.on('SIGTERM', leaveToChild);
-        const child = spawn('claude', args, { stdio: [headless === undefined ? 'inherit' : 'ignore', 'inherit', 'inherit'], env });
+        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'
-                ? 'the `claude` command is not on PATH — install Claude Code first'
+                ? `the \`${command}\` command is not on PATH${command === 'claude' ? ' — install Claude Code first' : ''}`
                 : err.message));
         });
         child.on('exit', (code) => {
@@ -167,10 +167,11 @@ export async function headlessEnv() {
 }
 const continues = (args) => args.includes('-c') || args.includes('--continue');
 async function reclaimConversation(extra) {
-    if (!continues(extra))
+    const sessionId = resumeSessionId(extra);
+    if (sessionId === undefined && !continues(extra))
         return;
     try {
-        const note = await takeBackConversation();
+        const note = await takeBackConversation({ sessionId });
         if (note !== null)
             process.stderr.write(`metro claude: ${note}\n`);
     }
@@ -179,7 +180,10 @@ async function reclaimConversation(extra) {
         process.stderr.write(`metro claude: could not check for a Claude Code background session holding the conversation (${message})\n`);
     }
 }
+const SDK_HOLDS_CHAT = 'the Harness runs this agent as an Agent SDK session (metro agent), which holds the metro chat; a metro claude session would take it away. Switch the Harness runner back to the Claude Code session first, or open the conversation with plain claude --resume <session id>';
 export async function launchClaude(extra) {
+    if (harnessRunner() === 'sdk')
+        throw new Error(SDK_HOLDS_CHAT);
     await reclaimConversation(extra);
     const decision = await verdict();
     const port = localPort();

package/dist/cli.js

@@ -2,6 +2,7 @@
 import { whoisAuthorized } from './api.js';
 import { stopAll } from './control.js';
 import { tailEvents } from './tail.js';
+import { agentSession } from './agent.js';
 import { launchClaude } from './claude.js';
 import { memoryPaths, memoryRoutine } from './memory.js';
 import { update } from './update.js';
@@ -33,6 +34,12 @@ 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 agent     run chat and background workers in one Agent SDK conversation,
+                  when the Harness runner is Agent SDK, using the Model page's model;
+                  resume it after a restart; voice calls remain separate
+  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 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
@@ -77,6 +84,7 @@ const COMMANDS = {
     stop: stopDaemon,
     tail: () => tailEvents(process.argv.slice(3)),
     claude: () => launchClaude(process.argv.slice(3)),
+    agent: () => agentSession(process.argv.slice(3)),
     memory: () => memoryRoutine(memoryPaths(process.env, process.argv[3])),
     voice: () => voiceSession(process.argv.slice(3)),
     update: () => update(process.argv.slice(3)),

package/dist/route.js

@@ -2,8 +2,9 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { agentsDir } from './local.js';
 const PROVIDERS = new Set(['bedrock', 'openrouter', 'codex', 'gemini']);
+const ANTHROPIC = 'anthropic';
 const text = (value) => (typeof value === 'string' ? value : '');
-function routeIn(cfg) {
+function routedIn(cfg) {
     if (typeof cfg !== 'object' || cfg === null)
         return null;
     const { route, connections } = cfg;
@@ -12,38 +13,45 @@ function routeIn(cfg) {
     const conn = connections.find((c) => typeof c === 'object' && c !== null && c.id === route);
     if (typeof conn !== 'object' || conn === null)
         return null;
-    const provider = text(conn.provider);
     const model = text(conn.model);
-    return PROVIDERS.has(provider) && model !== '' ? `${provider}:${model}` : null;
+    return model === '' ? null : { provider: text(conn.provider), model };
 }
-export function currentRoute(dir = agentsDir()) {
+function routed(dir) {
     const path = join(dir, 'model.json');
     if (!existsSync(path))
         return null;
     try {
-        return routeIn(JSON.parse(readFileSync(path, 'utf8')));
+        return routedIn(JSON.parse(readFileSync(path, 'utf8')));
     }
     catch {
         return null;
     }
 }
+const prefixed = (found) => (found !== null && PROVIDERS.has(found.provider) ? `${found.provider}:${found.model}` : null);
+export const currentRoute = (dir = agentsDir()) => prefixed(routed(dir));
+export function currentModel(dir = agentsDir()) {
+    const found = routed(dir);
+    return found?.provider === ANTHROPIC ? found.model : prefixed(found);
+}
 export function routeModelEnv(env, route) {
     if (route === null || (env.ANTHROPIC_MODEL ?? '').trim() !== '')
         return env;
     return { ...env, ANTHROPIC_MODEL: route };
 }
-export function permissionMode(dir = agentsDir()) {
+export const permissionMode = (dir = agentsDir()) => (setupField(dir, 'permissionMode') === 'bypass' ? 'bypass' : 'auto');
+function setupField(dir, field) {
     const path = join(dir, 'claude-setup.json');
     if (!existsSync(path))
-        return 'auto';
+        return undefined;
     try {
         const state = JSON.parse(readFileSync(path, 'utf8'));
-        return state.permissionMode === 'bypass' ? 'bypass' : 'auto';
+        return state[field];
     }
     catch {
-        return 'auto';
+        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/dist/runtime-install.js

@@ -13,7 +13,7 @@ export function runtimeStore() {
     return env === '' ? join(homedir(), '.metro', 'runtime') : env;
 }
 const isRecord = (v) => typeof v === 'object' && v !== null;
-const ranges = (raw) => isRecord(raw)
+export const ranges = (raw) => isRecord(raw)
     ? Object.fromEntries(Object.entries(raw).filter((e) => typeof e[1] === 'string'))
     : {};
 export function readManifest(path) {
@@ -33,7 +33,7 @@ export function dependenciesFor(manifest, stations) {
     return Object.fromEntries(Object.entries(out).sort(([a], [b]) => a.localeCompare(b)));
 }
 const packageText = (deps) => `${JSON.stringify({ name: 'metro-runtime', private: true, dependencies: deps }, null, 2)}\n`;
-function readOrNull(path) {
+export function readOrNull(path) {
     try {
         return readFileSync(path, 'utf8');
     }
@@ -68,6 +68,7 @@ export function installDependencies(store, deps, bun, log) {
     const marker = join(store, 'node_modules', '.metro-installed');
     if (existsSync(marker) && readOrNull(join(store, 'package.json')) === wanted)
         return false;
+    rmSync(marker, { force: true });
     writeFileSync(join(store, 'package.json'), wanted);
     log(`Installing the channel SDKs this machine needs into ${store}`);
     const run = spawnSync(bun, ['install', '--no-summary', '--no-progress'], {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.259",
+  "version": "0.1.0-beta.260",
   "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.259",
+  "version": "0.1.0-beta.260",
   "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/node_modules/@metro-labs/core/package.json

@@ -8,6 +8,7 @@
     "./log": "./src/log.ts",
     "./events": "./src/events.ts",
     "./is-record": "./src/is-record.ts",
+    "./runner-activity": "./src/runner-activity.ts",
     "./secure-fs": "./src/secure-fs.ts",
     "./version": "./src/version.ts",
     "./train-error": "./src/train-error.ts",

package/runtime/node_modules/@metro-labs/core/src/ids.ts

@@ -1,7 +1,11 @@
-import { randomBytes } from 'node:crypto';
+import { randomBytes, randomInt } from 'node:crypto';
 
 const ID_BYTES = 8;
 const REROLLS = 16;
+const APPROVAL_LETTERS = 'abcdefghijkmnopqrstuvwxyz';
+const APPROVAL_LENGTH = 5;
+
+export const approvalId = (): string => Array.from({ length: APPROVAL_LENGTH }, () => APPROVAL_LETTERS[randomInt(APPROVAL_LETTERS.length)]).join('');
 
 export const ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{10}$/;
 

package/runtime/node_modules/@metro-labs/core/src/runner-activity.ts

@@ -0,0 +1,103 @@
+import { isRecord } from './is-record.js';
+
+const PHASES = ['starting', 'idle', 'working', 'approval', 'compacting', 'stopped', 'error'] as const;
+const TASK_STATES = ['pending', 'running', 'completed', 'failed', 'stopped', 'paused', 'unknown'] as const;
+const EVENTS = ['turn_started', 'turn_finished', 'turn_failed', 'tool_started', 'tool_finished', 'tool_failed', 'task_started', 'task_completed', 'task_failed', 'task_stopped', 'task_updated', 'compacting', 'compacted', 'compact_failed', 'api_retry', 'approval_waiting', 'approval_ended', 'permission_denied', 'session_failed'] as const;
+export type RunnerPhase = (typeof PHASES)[number];
+export type RunnerTaskState = (typeof TASK_STATES)[number];
+export type RunnerEventKind = (typeof EVENTS)[number];
+
+export interface RunnerTask {
+  id: string;
+  kind: string | null;
+  agent: string | null;
+  status: RunnerTaskState;
+  background: boolean;
+  startedAt: number;
+  updatedAt: number;
+  endedAt: number | null;
+  lastTool: string | null;
+  toolUses: number;
+  durationMs: number;
+}
+
+export interface RunnerTool {
+  id: string;
+  name: string;
+  taskId: string | null;
+  worker?: boolean;
+  startedAt: number;
+}
+
+export interface RunnerEvent {
+  at: number;
+  kind: RunnerEventKind;
+  tool: string | null;
+  taskId: string | null;
+}
+
+export interface RunnerActivity {
+  pid: number;
+  procStart?: string;
+  runner: 'sdk';
+  phase: RunnerPhase;
+  mainPhase: RunnerPhase;
+  mainStartedAt: number | null;
+  sessionId: string | null;
+  updatedAt: number;
+  pending: number;
+  workers: number;
+  approvals: number;
+  tools: string[];
+  activeTools: RunnerTool[];
+  tasks: RunnerTask[];
+  events: RunnerEvent[];
+  lastError: string | null;
+}
+
+const count = (value: unknown): number => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : 0;
+const phase = (value: unknown): value is RunnerPhase => PHASES.some((p) => p === value);
+const taskState = (value: unknown): value is RunnerTaskState => TASK_STATES.some((s) => s === value);
+const eventKind = (value: unknown): value is RunnerEventKind => EVENTS.some((e) => e === value);
+const name = (value: unknown): string | null => typeof value === 'string' && /^[A-Za-z0-9_.:-]{1,128}$/.test(value) ? value : null;
+const sessionId = (value: unknown): string | null => typeof value === 'string' && /^[0-9a-f-]{36}$/.test(value) ? value : null;
+
+function task(raw: unknown): RunnerTask | null {
+  if (!isRecord(raw) || !name(raw.id) || !taskState(raw.status)) return null;
+  return {
+    id: String(raw.id), kind: name(raw.kind), agent: name(raw.agent), status: raw.status, background: raw.background === true,
+    startedAt: count(raw.startedAt), updatedAt: count(raw.updatedAt), endedAt: count(raw.endedAt) || null,
+    lastTool: name(raw.lastTool), toolUses: count(raw.toolUses), durationMs: count(raw.durationMs),
+  };
+}
+
+function tool(raw: unknown): RunnerTool | null {
+  if (!isRecord(raw) || !name(raw.id) || !name(raw.name)) return null;
+  return { id: String(raw.id), name: String(raw.name), taskId: name(raw.taskId), startedAt: count(raw.startedAt), ...(typeof raw.worker === 'boolean' ? { worker: raw.worker } : {}) };
+}
+
+function event(raw: unknown): RunnerEvent | null {
+  if (!isRecord(raw) || !eventKind(raw.kind) || count(raw.at) === 0) return null;
+  return { at: count(raw.at), kind: raw.kind, tool: name(raw.tool), taskId: name(raw.taskId) };
+}
+
+function list<T>(raw: unknown, parse: (item: unknown) => T | null, max: number): T[] {
+  if (!Array.isArray(raw)) return [];
+  return raw.map(parse).filter((item): item is T => item !== null).slice(0, max);
+}
+
+function processIdentity(value: unknown): Pick<RunnerActivity, 'procStart'> {
+  return typeof value === 'string' && /^\d{1,32}$/.test(value) ? { procStart: value } : {};
+}
+
+export function parseRunnerActivity(raw: unknown): RunnerActivity | null {
+  if (!isRecord(raw) || raw.runner !== 'sdk' || !phase(raw.phase) || count(raw.pid) === 0 || count(raw.updatedAt) === 0) return null;
+  return {
+    runner: 'sdk', pid: count(raw.pid), ...processIdentity(raw.procStart), phase: raw.phase, mainPhase: phase(raw.mainPhase) ? raw.mainPhase : raw.phase,
+    mainStartedAt: count(raw.mainStartedAt) || null, sessionId: sessionId(raw.sessionId), updatedAt: count(raw.updatedAt),
+    pending: count(raw.pending), workers: count(raw.workers), approvals: count(raw.approvals),
+    tools: list(raw.tools, name, 20), activeTools: list(raw.activeTools, tool, 20),
+    tasks: list(raw.tasks, task, 30), events: list(raw.events, event, 40),
+    lastError: typeof raw.lastError === 'string' ? raw.lastError.slice(0, 300) : null,
+  };
+}

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

@@ -90,13 +90,13 @@ function openGuarded(path: string): number {
   }
 }
 
-function asAgentSh(script: string, args: string[]): Buffer {
+function asAgentSh(script: string, args: string[], failure = 'ENOENT'): Buffer {
   const [file, argv] = asUser(agentUser(), 'sh', ['-c', script, 'metro', ...args]);
   const run = spawnSync(file, argv, { maxBuffer: MAX_OUTPUT, stdio: ['ignore', 'pipe', 'pipe'] });
   if (run.error !== undefined) throw run.error;
   if (run.status !== 0) {
     const err = new Error(run.stderr.toString('utf8').trim() || `no such file or directory, ${args[0] ?? ''}`) as Error & { code: string };
-    err.code = 'ENOENT';
+    err.code = run.status === 66 ? 'ENOENT' : failure;
     throw err;
   }
   return run.stdout;
@@ -169,7 +169,7 @@ export function readFileSync(path: string, encoding: 'utf8'): string {
         fs.closeSync(fd);
       }
     },
-    () => asAgentSh('cat -- "$1"', [path]).toString('utf8'),
+    () => asAgentSh('if test -x "${1%/*}" && ! test -e "$1" && ! test -L "$1"; then exit 66; fi; cat -- "$1"', [path], 'EIO').toString('utf8'),
   );
 }
 

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

@@ -55,7 +55,7 @@ export function viewFiles(dir = agentsDir()): Map<string, string | null> {
 
 const written = new Map<string, string | null>();
 
-function syncAgentView(user: AgentUser | null = agentUser(), dir = agentsDir()): number {
+export function syncAgentView(user: AgentUser | null = agentUser(), dir = agentsDir()): number {
   if (user === null) return 0;
   const target = agentViewDir(user);
   let changed = 0;

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

@@ -106,7 +106,7 @@ async function syncStations(station: StationName): Promise<void> {
   }
 }
 
-function sessionApis(setLiveEvents: (on: boolean) => void): SessionApis {
+function sessionApis(setLiveEvents: (on: boolean) => void, switchModel: (model: string | null) => boolean): SessionApis {
   return localSessionApis({
       syncStations,
       reloadAgents: async () => {
@@ -125,6 +125,7 @@ function sessionApis(setLiveEvents: (on: boolean) => void): SessionApis {
       toolGroups: stationToolGroups,
       prepareAccount,
       liveEvents: setLiveEvents,
+      switchModel,
     });
 }
 
@@ -144,7 +145,7 @@ installBearerSessions(agentsDir(), localOwner);
   const metroMcp = await createMetroMcp({ liveEvents: liveEvents() });
   webhookServer = await startWebhookServer(
     emit,
-    sessionApis(metroMcp.setLiveEvents),
+    sessionApis(metroMcp.setLiveEvents, metroMcp.switchModel),
     metroMcp.httpHandler,
     true,
   );