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

package/dist/cli.js

@@ -56,7 +56,7 @@ const USAGE = `metro: run your agent on this machine
   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, plugin,
+                  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
   metro update    update to the newest published version (--check only reports)

package/dist/memory.js

@@ -116,13 +116,12 @@ export function routineArgs(prompt, memory, appended) {
         'Glob',
         'Grep',
         `Edit(/${memory}/**)`,
-        '--settings',
-        JSON.stringify({ enabledPlugins: { 'metro@metro': false } }),
         '--strict-mcp-config',
         '--no-session-persistence',
         ...(appended === null ? [] : ['--append-system-prompt', 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);
@@ -194,7 +193,7 @@ 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()), await headlessEnv(), { timeoutMs: TIMEOUT_MS });
+    const code = await runClaude(routineArgs(prompt, paths.memory, systemPrompt()), routineEnv(await headlessEnv()), { timeoutMs: TIMEOUT_MS });
     if (code === 0) {
         writeFileSync(paths.state, `${JSON.stringify({ lastRun: now.toISOString() })}\n`);
         const moved = settleWorkstreams(paths.memory);

package/dist/runtime-install.js

@@ -5,7 +5,7 @@ import { dirname, join } from 'node:path';
 import { localStations } from './local.js';
 import { STORE_ENTRY, daemonEntry, findBun, runtimeDir } from './runtime.js';
 const MANIFEST_FILE = 'stations.json';
-const MARKETPLACE = 'marketplace';
+const OLD_MARKETPLACE = 'marketplace';
 const METRO_SOURCES = join('node_modules', '@metro-labs');
 const INSTALL_TIMEOUT_MS = 15 * 60_000;
 export function runtimeStore() {
@@ -54,24 +54,16 @@ export function readOrNull(path) {
         return null;
     }
 }
-function copyMarketplace(sources, store) {
-    const staged = join(sources, MARKETPLACE);
-    if (!existsSync(staged))
-        return false;
-    cpSync(staged, join(store, MARKETPLACE), { recursive: true });
-    return true;
-}
 function syncSources(sources, store) {
     const shim = join(sources, STORE_ENTRY);
     if (existsSync(shim))
         copyFileSync(shim, join(store, STORE_ENTRY));
     const stamp = readOrNull(join(sources, 'runtime.json'));
     if (stamp !== null && readOrNull(join(store, 'runtime.json')) === stamp)
-        return existsSync(join(store, MARKETPLACE)) ? false : copyMarketplace(sources, store);
+        return false;
     rmSync(join(store, METRO_SOURCES), { recursive: true, force: true });
     cpSync(join(sources, METRO_SOURCES), join(store, METRO_SOURCES), { recursive: true });
-    rmSync(join(store, MARKETPLACE), { recursive: true, force: true });
-    copyMarketplace(sources, store);
+    rmSync(join(store, OLD_MARKETPLACE), { recursive: true, force: true });
     if (stamp !== null)
         writeFileSync(join(store, 'runtime.json'), stamp);
     return true;

package/dist/voice.js

@@ -8,7 +8,7 @@ const VOICE_PROMPT = `You are on a live voice call through Metro. This session h
 - 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 (ToolSearch finds 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.
+- 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.

package/{runtime/marketplace/plugin/bin → hooks}/guard.mjs

@@ -2,6 +2,8 @@
 import { readFileSync } from 'node:fs';
 import { policyVerdict } from './policy.mjs';
 
+if (process.env.METRO_SESSION === 'memory') process.exit(0);
+
 const BLOCKING = new Set(['AskUserQuestion', 'ExitPlanMode', 'EnterPlanMode']);
 const ORCHESTRATION = new Set([
   'Agent',
@@ -23,9 +25,12 @@ const ORCHESTRATION = new Set([
 const IMAGE = /\.(png|jpe?g|gif|webp|bmp)$/i;
 const MCP = /^mcp__/;
 const METRO_MCP = /^mcp__metro__/;
-const FIND_TOOLS = 'mcp__plugin_metro_mcp__find_tools';
+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.`;
+
 function answer(decision, reason) {
   process.stdout.write(
     `${JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: decision, permissionDecisionReason: reason } })}\n`,
@@ -55,9 +60,9 @@ function verdict(payload, input) {
       : '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;
   if (ORCHESTRATION.has(tool)) return null;
-  if (METRO_MCP.test(tool) || tool === FIND_TOOLS) return null;
-  if (MCP.test(tool))
-    return `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.`;
+  if (tool === CONNECTOR_CALL) return connectorWork(tool);
+  if (METRO_MCP.test(tool)) return null;
+  if (MCP.test(tool)) return connectorWork(tool);
   if (tool === 'Read' && typeof input.file_path === 'string' && IMAGE.test(input.file_path)) return null;
   return `The main thread is orchestrator-only, so ${tool === '' ? 'this tool' : tool} is not available here. Delegate the work to a subagent with the Agent tool (run_in_background: true; the worker agent has full tool access) or to a Workflow, and report the result over metro.`;
 }

package/{runtime/marketplace/plugin/bin → hooks}/session-start.mjs

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url';
 const given = (value) => (typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined);
 const claudeDir = given(process.env.CLAUDE_CONFIG_DIR) ?? join(given(process.env.HOME) ?? homedir(), '.claude');
 const SKILL = join(claudeDir, 'skills', 'metro', 'SKILL.md');
-const FALLBACK = join(dirname(dirname(fileURLToPath(import.meta.url))), 'METRO.md');
+const FALLBACK = join(dirname(dirname(fileURLToPath(import.meta.url))), 'skills', 'METRO.md');
 
 const body = (text) => text.replace(/^---[\s\S]*?\n---\n/, '').trim();
 
@@ -24,7 +24,7 @@ function guidance() {
   return '';
 }
 
-const text = process.env.METRO_SESSION === 'voice' ? '' : guidance();
+const text = ['voice', 'memory'].includes(process.env.METRO_SESSION) ? '' : 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.305",
+  "version": "0.1.0-beta.307",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {
@@ -18,7 +18,9 @@
   },
   "files": [
     "dist",
-    "runtime"
+    "hooks",
+    "runtime",
+    "skills"
   ],
   "publishConfig": {
     "access": "public",

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

@@ -1,6 +1,6 @@
 import { spawn, spawnSync } from 'node:child_process';
-import { createWriteStream, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, utimesSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { createWriteStream, mkdirSync, renameSync, rmSync, utimesSync } from 'node:fs';
+import { dirname } from 'node:path';
 import type { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { writeAtomic } from '@metro-labs/core/secure-fs';
@@ -37,33 +37,6 @@ export function writeHomeText(path: string, text: string, mode = 0o644, mtime?:
   if (mtime !== undefined) utimesSync(path, mtime, mtime);
 }
 
-export function writeHomeInPlace(path: string, text: string, mode = 0o644, user = agentUser()): void {
-  if (user !== null) {
-    runAs(user, 'mkdir -p -- "$(dirname -- "$1")"; cat > "$1"; chmod -- "$2" "$1"', [path, octal(mode)], text);
-    return;
-  }
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, text, { mode });
-}
-
-function filesUnder(root: string, rel = ''): string[] {
-  return readdirSync(join(root, rel), { withFileTypes: true }).flatMap((entry) => {
-    const inner = rel === '' ? entry.name : `${rel}/${entry.name}`;
-    if (entry.isDirectory()) return filesUnder(root, inner);
-    return entry.isFile() ? [inner] : [];
-  });
-}
-
-export function copyIntoHome(from: string, to: string, user = agentUser()): number {
-  removeHome(to, true, user);
-  const files = filesUnder(from);
-  for (const rel of files) {
-    const source = join(from, rel);
-    writeHomeText(join(to, rel), readFileSync(source, 'utf8'), statSync(source).mode & 0o777, undefined, user);
-  }
-  return files.length;
-}
-
 export function removeHome(path: string, recursive = false, user = agentUser()): void {
   if (user !== null) {
     runAs(user, recursive ? 'rm -rf -- "$1"' : 'rm -f -- "$1"', [path]);

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

@@ -4,12 +4,10 @@ import { join } from 'node:path';
 import { chmodSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { errMsg, log } from '@metro-labs/core/log';
-import { copyIntoHome } from './home-fs.js';
-import { AGENT_NAME, agentMarketplaceDir, agentUser, agentUserExpected, asUser, claudeBin, forgetAgentUser, type AgentUser } from './user.js';
+import { AGENT_NAME, agentUser, agentUserExpected, asUser, claudeBin, 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 { stagedPluginVersion } from '../claude/plugin-install.js';
 import { CLAUDE_CODE_VERSION } from '../claude/pinned.js';
 import { pinClaudeCode } from '../claude/version.js';
 
@@ -68,24 +66,13 @@ function pinCheckedClaude(): void {
   }
 }
 
-function copyMarketplace(user: AgentUser, env: NodeJS.ProcessEnv): void {
-  const store = env.METRO_RUNTIME_STORE?.trim() ?? '';
-  const from = join(store, 'marketplace');
-  if (store === '' || !existsSync(join(from, '.claude-plugin', 'marketplace.json'))) return;
-  const to = agentMarketplaceDir(user);
-  if (stagedPluginVersion(from) !== null && stagedPluginVersion(from) === stagedPluginVersion(to)) return;
-  const files = copyIntoHome(from, to, user);
-  log.info({ files, version: stagedPluginVersion(from) }, 'agent-user: copied the metro plugin where the agent user can load it');
-}
-
-export async function provisionAgentUser(env: NodeJS.ProcessEnv = process.env): Promise<Provisioned> {
+export async function provisionAgentUser(): Promise<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();
-    copyMarketplace(user, env);
     watchAgentView();
     return 'ready';
   } catch (err) {

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

@@ -87,5 +87,4 @@ export function claudeBin(user = agentUser()): string {
 
 export const claudeHome = (user = agentUser()): string | null => (user === null ? null : user.home);
 
-export const agentMarketplaceDir = (user: AgentUser): string => join(user.home, '.metro', 'marketplace');
 export const agentViewDir = (user: AgentUser): string => join(user.home, '.metro', 'agents');

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

@@ -3,13 +3,13 @@ import { join } from 'node:path';
 import { errMsg, log } from '@metro-labs/core/log';
 import { isRecord } from '@metro-labs/core/is-record';
 import { agentsDir } from '../agents/files.js';
-import { mcpServerUrl } from '../mcp-server/config.js';
 import { MCP_TOKEN_FILE } from '../mcp-server/token.js';
 import { removeHome, writeHomeText } from './home-fs.js';
 import { closeMetroHome } from './metro-home.js';
 import { agentUser, agentViewDir, type AgentUser } from './user.js';
 
 const COPIED = ['policy.json', 'claude-setup.json', 'system-prompt.md'] as const;
+const NEVER_COPIED = [MCP_TOKEN_FILE] as const;
 const SYNC_MS = 5_000;
 
 const readText = (path: string): string | null => {
@@ -51,8 +51,8 @@ export function viewFiles(dir = agentsDir()): Map<string, string | null> {
     ['agent.json', agentFile(dir)],
     ['model.json', modelFile(dir)],
   ]);
-  const copied = mcpServerUrl() === null ? COPIED : [...COPIED, MCP_TOKEN_FILE];
-  for (const name of copied) files.set(name, existsSync(join(dir, name)) ? readText(join(dir, name)) : null);
+  for (const name of COPIED) files.set(name, existsSync(join(dir, name)) ? readText(join(dir, name)) : null);
+  for (const name of NEVER_COPIED) files.set(name, null);
   return files;
 }
 

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

@@ -21,11 +21,12 @@ import {
   trainEventToMetroEvent,
 } from '../routes/http.js';
 import { agentsDir, fileSource } from '../agents/files.js';
-import { syncPluginServers } from '../connectors/plugin-sync.js';
 import { stopMcpServer, watchMcpServer } from '../mcp-server/link.js';
+import { refreshConnectorTools, watchConnectorTools } from '../mcp-server/connector-tools.js';
 import { setAnnouncedFile } from '../mcp-server/announced.js';
 import { holdServerApproval } from '../mcp/server-approvals.js';
-import { ensureMetroPlugin } from '../claude/plugin-install.js';
+import { removeConnectorLeftovers } from '../connectors/leftovers.js';
+import { removeMetroPlugin } from '../claude/plugin-cleanup.js';
 import { runningAsRoot } from '../metro-user/privilege.js';
 import { provisionAgentUser } from '../agent-user/provision.js';
 import { applyVault } from '../vault/index.js';
@@ -139,6 +140,7 @@ function sessionApis(setLiveEvents: (on: boolean) => void, switchModel: (model:
 
 
 async function main(): Promise<void> {
+  removeConnectorLeftovers();
   applyLocalOwner();
 installBearerSessions(agentsDir(), localOwner);
   watchPolicySnapshot();
@@ -165,7 +167,13 @@ installBearerSessions(agentsDir(), localOwner);
     hold: (approval, answer) => {
       holdServerApproval(approval, answer, emit);
     },
+    registered: () => {
+      refreshConnectorTools().catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'mcp-server: the connector tools could not be read after the token was registered');
+      });
+    },
   });
+  watchConnectorTools();
   startCloudWatchPublisher();
   watchFallbackUsage();
   announceLocalEndpoint();
@@ -194,14 +202,11 @@ async function startClaude(): Promise<void> {
     const vault = (await applyVault()).status;
     if (vault.enabled) log.info({ running: vault.running, problem: vault.problem }, 'vault: the agent reaches the internet through the vault');
   }
-  ensureMetroPlugin()
-    .then((outcome) => {
-      log.info({ outcome }, 'plugin: metro plugin for Claude Code');
-      if (outcome !== 'skipped') syncPluginServers();
-    })
-    .catch((err: unknown) => {
-      log.warn({ err: errMsg(err) }, 'plugin: could not ensure the Claude Code plugin');
-    });
+  const plugin = await removeMetroPlugin().catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'claude-plugin: could not check for the old metro plugin');
+    return 'failed';
+  });
+  if (plugin !== 'done') log.info({ outcome: plugin }, 'claude-plugin: checked for the old metro Claude Code plugin');
   tryClaudeSetup();
   try { githubSkills().watch(); } catch { log.warn('github-skills: saved source could not be loaded'); }
   tryMemoryJob(memoryRoutine());

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

@@ -0,0 +1,28 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const CHECKOUT = fileURLToPath(new URL('../../../../packages/cli', import.meta.url));
+const HOOKS = 'hooks';
+const SKILLS = 'skills';
+export const GUARD_HOOK = 'guard.mjs';
+export const SESSION_START_HOOK = 'session-start.mjs';
+const UNSAFE_PATH = /["$`\\\n]/;
+
+export function cliPackageDir(env: NodeJS.ProcessEnv = process.env): string {
+  const bin = env.METRO_CLI_BIN?.trim() ?? '';
+  if (bin === '') return CHECKOUT;
+  try {
+    return dirname(dirname(realpathSync(bin)));
+  } catch {
+    return CHECKOUT;
+  }
+}
+
+export const skillsDir = (cli: string): string => join(cli, SKILLS);
+
+export function hooksDir(cli: string): string | null {
+  const dir = join(cli, HOOKS);
+  if (UNSAFE_PATH.test(dir)) return null;
+  return existsSync(join(dir, GUARD_HOOK)) && existsSync(join(dir, SESSION_START_HOOK)) ? dir : null;
+}

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

@@ -0,0 +1,60 @@
+import { join } from 'node:path';
+import { isRecord } from '@metro-labs/core/is-record';
+import { GUARD_HOOK, SESSION_START_HOOK } from './cli-files.js';
+
+interface HookCommand {
+  type: 'command';
+  command: string;
+  statusMessage?: string;
+}
+
+const METRO_COMMAND = /^node "[^"]*\/hooks\/(guard|session-start)\.mjs"$/;
+const METRO_GUARD = /^node "[^"]*\/hooks\/guard\.mjs"$/;
+
+const commandOf = (hook: unknown): string => (isRecord(hook) && typeof hook.command === 'string' ? hook.command : '');
+const metroHook = (hook: unknown): boolean => METRO_COMMAND.test(commandOf(hook));
+const run = (dir: string, file: string): string => `node "${join(dir, file)}"`;
+
+function metroHooks(dir: string): Record<string, HookCommand> {
+  return {
+    PreToolUse: { type: 'command', command: run(dir, GUARD_HOOK), statusMessage: 'Checking the orchestrator boundary' },
+    SessionStart: { type: 'command', command: run(dir, SESSION_START_HOOK) },
+  };
+}
+
+function withHook(groups: unknown[], wanted: HookCommand): unknown[] {
+  let placed = false;
+  const out: unknown[] = [];
+  for (const group of groups) {
+    if (!isRecord(group) || !Array.isArray(group.hooks) || !group.hooks.some(metroHook)) {
+      out.push(group);
+      continue;
+    }
+    const kept = group.hooks.flatMap((hook: unknown) => {
+      if (!metroHook(hook)) return [hook];
+      if (placed) return [];
+      placed = true;
+      return [wanted];
+    });
+    if (kept.length > 0) out.push({ ...group, hooks: kept });
+  }
+  return placed ? out : [...out, { hooks: [wanted] }];
+}
+
+export function withMetroHooks(settings: Record<string, unknown>, dir: string): Record<string, unknown> | null {
+  const hooks = settings.hooks ?? {};
+  if (!isRecord(hooks)) return null;
+  const next: Record<string, unknown> = { ...hooks };
+  for (const [event, wanted] of Object.entries(metroHooks(dir))) {
+    const groups = hooks[event] ?? [];
+    if (!Array.isArray(groups)) return null;
+    next[event] = withHook(groups, wanted);
+  }
+  return { ...settings, hooks: next };
+}
+
+export function hasMetroGuard(settings: Record<string, unknown> | null): boolean {
+  const groups = settings !== null && isRecord(settings.hooks) ? settings.hooks.PreToolUse : undefined;
+  if (!Array.isArray(groups)) return false;
+  return groups.some((group) => isRecord(group) && Array.isArray(group.hooks) && group.hooks.some((hook) => METRO_GUARD.test(commandOf(hook))));
+}

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

@@ -0,0 +1,121 @@
+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/session.ts

@@ -352,7 +352,7 @@ export function ensureSession(deps: SessionDeps = {}): Ensured {
   const held = holdsBack(deps, r.now);
   if (held !== null) return held;
   if (found === 'stale') {
-    log.info({ was: startedVersion(r.agents), now: r.version }, 'claude-session: restarting the session an older metro started, so the new plugin and flags load');
+    log.info({ was: startedVersion(r.agents), now: r.version }, 'claude-session: restarting the session an older metro started, so the new hooks and flags load');
     stopSession(deps);
   }
   startSession(deps);