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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.304",
+  "version": "0.1.0-beta.305",
   "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,7 +1,7 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.304",
-  "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 (or one `mcp` server on mcp.metro.box), 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.",
+  "version": "0.1.0-beta.305",
+  "description": "Metro for Claude Code, installed by the metro daemon on this machine: one `mcp` server on mcp.metro.box for the organization connectors (find_tools, call_tool), the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever reaches this machine.",
   "author": {
     "name": "Bonustrack",
     "url": "https://metro.box"
@@ -11,7 +11,6 @@
   "keywords": [
     "metro",
     "mcp",
-    "connectors",
-    "relay"
+    "connectors"
   ]
 }

package/runtime/marketplace/plugin/METRO.md

@@ -15,7 +15,7 @@ You are the main thread of a Claude Code session that is connected to chat throu
 
 **Calls that need the owner's approval run in a worker.** The owner can make a metro tool on a channel wait for approval. On the main thread such a call is refused, because waiting for the answer would stop the whole session: hand that exact call to a background worker (`run_in_background: true`) and keep answering. The worker waits for the owner's answer on its own.
 
-**Connectors through the `mcp` server.** When the `mcp` server is present, it holds every connector tool behind two tools. Find what you need with `find_tools`: `select:notion.search,linear.create_issue` for exact names, keywords (`notion page update`) to rank, or `+slack send` to require `slack` in the tool name. Have a worker run them with `call_tool`, up to 10 independent calls in one go. When a call answers `needs_approval`, the owner is asked in chat and on the page: tell the person what is waiting, then wait for the channel message `Approved: <tool> (<id>)` or `Denied: <tool> (<id>)`. After an approval, have a worker call `call_tool` again with the same tool and arguments and `approval: "<id>"`.
+**Connectors through the `mcp` server.** Every connector the organization gave this agent sits behind the `mcp` server's two tools. Find what you need with `find_tools`: `select:notion.search,linear.create_issue` for exact names, keywords (`notion page update`) to rank, or `+slack send` to require `slack` in the tool name. Have a worker run them with `call_tool`, up to 10 independent calls in one go. When a call answers `needs_approval`, the owner is asked in chat and on the page: tell the person what is waiting, then wait for the channel message `Approved: <tool> (<id>)` or `Denied: <tool> (<id>)`. After an approval, have a worker call `call_tool` again with the same tool and arguments and `approval: "<id>"`.
 
 **Finish what was asked.** You work on your own. Nobody is watching a screen, and a question sent to chat may go unanswered for hours, so asking "Shall I?" about work already requested simply stops it. Anything reversible that follows from the request, do. Stop only for a destructive action or a genuine change of scope. Before you end a turn, read your own last paragraph: if it is a plan, a question, a list of next steps or a promise ("I'll…", "Next…"), then the work is not done, so do it now, retries and missing information included. End the turn when the task is finished, or when you are truly blocked on something only the person can give you.
 

package/runtime/marketplace/plugin/bin/metro-plugin.mjs

@@ -6,18 +6,6 @@ import { join } from 'node:path';
 const agentsDir = () => process.env.METRO_AGENTS_DIR || join(homedir(), '.metro', 'agents');
 const MCP_TOKEN = /^mcp_[A-Za-z0-9_-]{43}$/;
 
-function readAgent() {
-  const path = join(agentsDir(), 'agent.json');
-  let parsed;
-  try {
-    parsed = JSON.parse(readFileSync(path, 'utf8'));
-  } catch {
-    throw new Error(`no agent on this machine yet (${path})`);
-  }
-  if (typeof parsed?.key !== 'string') throw new Error(`no agent key in ${path}`);
-  return parsed;
-}
-
 function readMcpToken() {
   try {
     const token = readFileSync(join(agentsDir(), 'mcp-token'), 'utf8').trim();
@@ -27,22 +15,10 @@ function readMcpToken() {
   }
 }
 
-const command = process.argv[2];
-
-if (command === 'mcp-headers') {
-  const token = readMcpToken();
-  if (token !== null) process.stdout.write(`${JSON.stringify({ Authorization: `Bearer ${token}` })}\n`);
-  process.exit(0);
-}
-
-if (command !== 'headers') {
-  process.stderr.write('usage: metro-plugin.mjs headers | mcp-headers\n');
+if (process.argv[2] !== 'mcp-headers') {
+  process.stderr.write('usage: metro-plugin.mjs mcp-headers\n');
   process.exit(1);
 }
 
-try {
-  process.stdout.write(`${JSON.stringify({ Authorization: `Bearer ${readAgent().key}` })}\n`);
-} catch (err) {
-  process.stderr.write(`metro: ${err.message}\n`);
-  process.stdout.write('{}\n');
-}
+const token = readMcpToken();
+if (token !== null) process.stdout.write(`${JSON.stringify({ Authorization: `Bearer ${token}` })}\n`);

package/runtime/marketplace/plugin/bin/policy.mjs

@@ -56,42 +56,11 @@ function decide(policy, name, group) {
   return access in RANK ? access : 'allow';
 }
 
-const normalized = (name) => name.replace(/[^a-zA-Z0-9_-]/g, '_');
-
-function connectorCall(snap, toolName) {
-  const entries = Object.entries(isRecord(snap.connectors) ? snap.connectors : {});
-  const legacy = entries.filter(([, entry]) => isRecord(entry) && !/^org-[A-Za-z0-9][A-Za-z0-9_-]{10}$/.test(text(entry.id)) && toolName.startsWith(`mcp__${normalized(`metro.box ${text(entry.name)}`)}__`));
-  if (legacy.length > 1) return { name: 'ambiguous connector name; use its instance server key', tool: toolName, group: 'write', policy: { write: 'deny' } };
-  for (const [server, entry] of entries) {
-    if (!isRecord(entry)) continue;
-    const name = text(entry.name);
-    const prefixes = [`mcp__plugin_metro_${server}__`, `mcp__${server}__`];
-    if (!/^org-[A-Za-z0-9][A-Za-z0-9_-]{10}$/.test(text(entry.id))) prefixes.push(`mcp__${normalized(`metro.box ${name}`)}__`);
-    const prefix = prefixes.find((p) => toolName.startsWith(p) && toolName.length > p.length);
-    if (prefix === undefined) continue;
-    const called = toolName.slice(prefix.length);
-    const tools = isRecord(entry.tools) ? entry.tools : {};
-    const policy = isRecord(entry.policy) ? entry.policy : {};
-    const known = [...Object.keys(tools), ...Object.keys(isRecord(policy.tools) ? policy.tools : {})];
-    const tool = known.find((k) => k === called) ?? known.find((k) => normalized(k) === called) ?? called;
-    return { name: name || server, tool, group: tools[tool] === 'read' ? 'read' : 'write', policy };
-  }
-  return null;
-}
-
-function connectorVerdict(snap, toolName) {
-  const call = connectorCall(snap, toolName);
-  if (call === null) return null;
-  const access = decide(call.policy, call.tool, call.group);
-  return access === 'allow' ? null : { access, tool: call.tool, owner: call.name, where: `${call.tool} on ${call.name}` };
-}
-
 export function policyVerdict(toolName, input) {
   const name = METRO_TOOL.exec(toolName)?.[1];
-  if (name === undefined && !toolName.startsWith('mcp__')) return null;
+  if (name === undefined) return null;
   const snap = readSnapshot();
   if (snap === null) return null;
-  if (name === undefined) return connectorVerdict(snap, toolName);
   const tools = isRecord(snap.tools) ? snap.tools : {};
   const group = tools[name] === 'read' ? 'read' : 'write';
   const accounts = isRecord(snap.accounts) ? snap.accounts : {};

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

@@ -6,7 +6,6 @@
   "type": "module",
   "exports": {
     "./log": "./src/log.ts",
-    "./connector-sync": "./src/connector-sync.ts",
     "./events": "./src/events.ts",
     "./is-record": "./src/is-record.ts",
     "./runner-activity": "./src/runner-activity.ts",

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

@@ -26,7 +26,6 @@ export interface AgentApiDeps extends AccountApiDeps {
   toolGroups?: () => Record<string, { name: string; group: string }[]>;
   attachable?: string[];
   features?: string[];
-  connectorIds: (agentIds: string[]) => Promise<Map<string, string[]>>;
 }
 
 type Routable =
@@ -51,8 +50,8 @@ export function target(path: string): Target {
   return id === null ? { kind: 'unknown' } : subTarget(id, segments.slice(1));
 }
 
-function agentPayload(agent: AgentSummary, connectors: Map<string, string[]>): Record<string, unknown> {
-  return { id: agent.id, name: agent.name, connector_ids: connectors.get(agent.id) ?? [] };
+function agentPayload(agent: AgentSummary): Record<string, unknown> {
+  return { id: agent.id, name: agent.name };
 }
 
 function wantsAccounts(req: IncomingMessage): boolean {
@@ -66,9 +65,8 @@ async function handleList(
   deps: AgentApiDeps,
 ): Promise<void> {
   const list = await deps.listAgents();
-  const connectors = await deps.connectorIds(list.map((a) => a.id));
   const base = {
-    agents: list.map((a) => agentPayload(a, connectors)),
+    agents: list.map((a) => agentPayload(a)),
     capabilities: deps.capabilities(),
     features: deps.features ?? [],
     attachable: deps.attachable ?? ATTACHABLE,

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

@@ -145,19 +145,13 @@ export function cancelPrompt(requestId: string, owner: object): void {
   });
 }
 
-export function revokeToolPrompts(matches: (tool: string) => boolean): void {
-  grants = grants.filter((entry) => !matches(entry.tool));
-  for (const entry of held.values())
-    if (matches(entry.tool)) cancelPrompt(entry.requestId, entry.owner);
-}
-
 export function revokeCallPrompts(route: CallRoute): void {
   grants = grants.filter((entry) => entry.call === undefined || !sameCall(entry.call.route, route));
   for (const entry of held.values())
     if (entry.call !== undefined && sameCall(entry.call.route, route)) cancelPrompt(entry.requestId, entry.owner);
 }
 
-export function settlePrompts(toolMatches: (tool: string) => boolean, args: Record<string, unknown>): void {
+function settlePrompts(toolMatches: (tool: string) => boolean, args: Record<string, unknown>): void {
   for (const [id, entry] of held)
     if (entry.origin !== 'mcp-server' && toolMatches(entry.tool) && previewMatches(entry.preview, args)) {
       held.delete(id);

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

@@ -21,11 +21,9 @@ import {
   trainEventToMetroEvent,
 } from '../routes/http.js';
 import { agentsDir, fileSource } from '../agents/files.js';
-import { connectorsReady, publishConnectors } from '../connectors/publication.js';
-import { adoptOrgServerKeys } from '../connectors/org-adopt.js';
-import { readAgentKey } from '../connectors/agent-key.js';
-import { stopOrgConnectorSync, watchOrgConnectorSync } from '../connectors/org-sync-watch.js';
+import { syncPluginServers } from '../connectors/plugin-sync.js';
 import { stopMcpServer, watchMcpServer } from '../mcp-server/link.js';
+import { setAnnouncedFile } from '../mcp-server/announced.js';
 import { holdServerApproval } from '../mcp/server-approvals.js';
 import { ensureMetroPlugin } from '../claude/plugin-install.js';
 import { runningAsRoot } from '../metro-user/privilege.js';
@@ -67,6 +65,7 @@ import { isCallEvent, leaveCallsForShutdown, onCallEvent, sweepLeftoverCalls } f
 installCrashGuard();
 acquireLock(join(STATE_DIR, '.tail-lock'));
 setOwnerLineFile(join(STATE_DIR, 'approval-line.json'));
+setAnnouncedFile(join(agentsDir(), 'mcp-approvals.json'));
 
 log.info({ self: userSelf() }, 'user identity');
 
@@ -142,7 +141,6 @@ function sessionApis(setLiveEvents: (on: boolean) => void, switchModel: (model:
 async function main(): Promise<void> {
   applyLocalOwner();
 installBearerSessions(agentsDir(), localOwner);
-  adoptOrgServerKeys();
   watchPolicySnapshot();
   log.info({ agent: await ensureLocalAgent() }, 'local daemon: agent');
   await materializeFrom(fileSource);
@@ -162,7 +160,6 @@ installBearerSessions(agentsDir(), localOwner);
   startPromptExpiry();
   startUploadReaper();
   startAttachReaper();
-  watchOrgConnectorSync({ owner: localOwner, key: readAgentKey });
   watchMcpServer({
     owner: localOwner,
     hold: (approval, answer) => {
@@ -200,7 +197,7 @@ async function startClaude(): Promise<void> {
   ensureMetroPlugin()
     .then((outcome) => {
       log.info({ outcome }, 'plugin: metro plugin for Claude Code');
-      if (outcome !== 'skipped') publishConnectors();
+      if (outcome !== 'skipped') syncPluginServers();
     })
     .catch((err: unknown) => {
       log.warn({ err: errMsg(err) }, 'plugin: could not ensure the Claude Code plugin');
@@ -208,7 +205,7 @@ async function startClaude(): Promise<void> {
   tryClaudeSetup();
   try { githubSkills().watch(); } catch { log.warn('github-skills: saved source could not be loaded'); }
   tryMemoryJob(memoryRoutine());
-  watchSession({ connectorsReady: () => connectorsReady() });
+  watchSession();
 }
 
 const SHUTDOWN_TIMEOUT_MS = 3_000;
@@ -220,7 +217,6 @@ async function shutdown(): Promise<void> {
   if (shuttingDown) return;
   shuttingDown = true;
   log.info('dispatcher shutting down');
-  stopOrgConnectorSync(true);
   stopMcpServer().catch((err: unknown) => {
     log.warn({ err: errMsg(err) }, 'mcp-server: could not stop the approval relay');
   });

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

@@ -49,7 +49,6 @@ export interface SessionDeps {
   now?: () => number;
   version?: string;
   prepare?: (runner: HarnessRunner) => Promise<void>;
-  connectorsReady?: () => boolean;
 }
 
 export interface SessionStatus {
@@ -317,10 +316,9 @@ function strike(now: number): boolean {
   return true;
 }
 
-export type Ensured = 'started' | 'restarted' | 'running' | 'blocked' | 'off' | 'paused' | 'waiting';
+export type Ensured = 'started' | 'restarted' | 'running' | 'blocked' | 'off' | 'paused';
 
 function holdsBack(deps: SessionDeps, now: number): Ensured | null {
-  if (deps.connectorsReady?.() === false) return 'waiting';
   if (now < memory.pausedUntil) return 'paused';
   if (sessionBlocked(deps) !== null) return 'blocked';
   return strike(now) ? 'paused' : null;

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

@@ -152,6 +152,7 @@ const PRIOR_METRO: ReadonlySet<string> = new Set([
   '5ce3f76d610aae91adc922d0edc6c8be1f27aa2fec4a5e3a6d6231a04fb9310b',
   'b910597d24f31fa479b130a2545f94dd23684d802d99e36b637fc57c818a33be',
   'd3f7ed0f5175b9a7a77f06f6204ae0020369d0c8f6e2724196bb3c5822d4d8ba',
+  '587a1334f91a8b61541573cef16eaf44fbe63049a8d8b461fa9f5cc55bacbcb8',
 ]);
 const PRIOR_STAGE: ReadonlySet<string> = new Set([
   'dd7d30474765de3865ddc87c1cf3220161ded09502027cdff18597e5df0aab43',

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

@@ -18,7 +18,6 @@ export interface EnrollApiDeps {
   owner: () => string | null;
   dir?: () => string;
   api?: MetroApi;
-  invalidate?: () => void;
 }
 
 export interface Enrolled {
@@ -89,7 +88,6 @@ async function enroll(req: IncomingMessage, session: ApiSession, deps: EnrollApi
   if (enrolling.has(dir)) throw new ApiError('This agent is already enrolling. Wait for it to finish before trying again.', 409);
   enrolling.add(dir);
   try {
-    deps.invalidate?.();
     return await exchange(ticket, owner, dir, deps);
   } finally {
     enrolling.delete(dir);

package/runtime/node_modules/@metro-labs/daemon/src/connectors/plugin-sync.ts

@@ -4,64 +4,20 @@ import { agentMarketplaceDir, agentUser } from '../agent-user/user.js';
 import { join } from 'node:path';
 import { errMsg, log } from '@metro-labs/core/log';
 import { claudeDir } from '../claude/files.js';
-import { loopbackBase } from '../files/attach-serve.js';
 import { MCP_SERVER_KEY, mcpServerUrl } from '../mcp-server/config.js';
 
 const MARKER = join('bin', 'metro-plugin.mjs');
 const FILE = '.mcp.json';
-const HELPER = 'node "${CLAUDE_PLUGIN_ROOT}/bin/metro-plugin.mjs" headers';
 const MCP_HELPER = 'node "${CLAUDE_PLUGIN_ROOT}/bin/metro-plugin.mjs" mcp-headers';
-const SLUG_MAX = 40;
 
-export interface PluginRow {
-  id: string;
-  name: string;
-}
-
-export interface PluginServer {
+interface PluginServer {
   type: 'http';
   url: string;
   headersHelper: string;
 }
 
-export function serverKey(name: string): string {
-  const slug = name
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, SLUG_MAX)
-    .replace(/-+$/, '');
-  return slug === '' ? 'connector' : slug;
-}
-
-function availableKey(wanted: string, reserved: ReadonlySet<string>): string {
-  let key = wanted;
-  let suffix = 1;
-  while (reserved.has(key)) key = `${wanted}-${String(suffix++)}`;
-  return key;
-}
-
-const reservedKeys = (): ReadonlySet<string> => new Set(mcpServerUrl() === null ? [] : [MCP_SERVER_KEY]);
-
-export function serverKeysOf(rows: PluginRow[], saved?: ReadonlyMap<string, string>, reserved: ReadonlySet<string> = reservedKeys()): Map<string, string> {
-  const keys = new Map([...(saved ?? [])].filter(([, key]) => !reserved.has(key)));
-  const used = new Set([...keys.values(), ...reserved]);
-  for (const row of [...rows].sort((a, b) => a.id.localeCompare(b.id))) {
-    if (keys.has(row.id)) continue;
-    const key = availableKey(serverKey(row.name), used);
-    used.add(key);
-    keys.set(row.id, key);
-  }
-  return keys;
-}
-
-export function pluginServers(rows: PluginRow[], base: string, keys: ReadonlyMap<string, string> = serverKeysOf(rows), mcpUrl = mcpServerUrl()): Record<string, PluginServer> {
-  const out: Record<string, PluginServer> = {};
-  const visible = new Set(rows.map((row) => row.id));
-  for (const [id, key] of keys) if (visible.has(id)) out[key] = { type: 'http', url: `${base}/relay/${id}`, headersHelper: HELPER };
-  if (mcpUrl !== null) out[MCP_SERVER_KEY] = { type: 'http', url: mcpUrl, headersHelper: MCP_HELPER };
-  return out;
-}
+const pluginServers = (url: string | null): Record<string, PluginServer> =>
+  url === null ? {} : { [MCP_SERVER_KEY]: { type: 'http', url, headersHelper: MCP_HELPER } };
 
 const SEARCH_DEPTH = 5;
 
@@ -113,9 +69,8 @@ function writeIfChanged(path: string, text: string): boolean {
 
 export interface PluginSyncOptions {
   dir?: string;
-  base?: string;
   staged?: string | null;
-  keys?: ReadonlyMap<string, string>;
+  url?: string | null;
 }
 
 function filesFor(opts: PluginSyncOptions): string[] {
@@ -123,23 +78,23 @@ function filesFor(opts: PluginSyncOptions): string[] {
   return installedPluginFiles(opts.dir ?? claudeDir(), staged);
 }
 
-export function syncPluginServers(rows: PluginRow[], opts: PluginSyncOptions = {}): number {
+export function syncPluginServers(opts: PluginSyncOptions = {}): number {
   const files = filesFor(opts);
   if (files.length === 0) return 0;
-  const servers = pluginServers(rows, opts.base ?? loopbackBase(), opts.keys);
+  const servers = pluginServers(opts.url === undefined ? mcpServerUrl() : opts.url);
   const text = `${JSON.stringify(servers, null, 2)}\n`;
   let written = 0;
   for (const file of files) {
     try {
       if (writeIfChanged(file, text)) written += 1;
     } catch (err) {
-      log.warn({ file, err: errMsg(err) }, 'plugin: could not write the connector servers');
+      log.warn({ file, err: errMsg(err) }, 'plugin: could not write the MCP servers');
     }
   }
   if (written > 0)
     log.info(
-      { files: written, servers: Object.keys(servers).length },
-      'plugin: connector servers written; run /reload-plugins --force to pick them up in a running session',
+      { files: written, servers: Object.keys(servers) },
+      'plugin: MCP servers written; run /reload-plugins --force to pick them up in a running session',
     );
   return written;
 }

package/runtime/node_modules/@metro-labs/daemon/src/mcp/permission-prompt.ts

@@ -1,6 +1,5 @@
 import { str } from '@metro-labs/core/str';
 import { readPreview, shownValue } from '../approvals/preview.js';
-import { connectorGates, connectorToolOf } from '../connectors/gates.js';
 import { stationByName } from '../stations/registry.js';
 import { stationOfAccount } from './read-tool.js';
 
@@ -83,21 +82,11 @@ function argLines(input: Record<string, unknown> | undefined): string[] {
   return args.length > ARGS_MAX ? [...args.slice(0, ARGS_MAX), `(${String(args.length - ARGS_MAX)} more)`] : args;
 }
 
-function connectorLines(name: string, tool: string, input: Record<string, unknown> | undefined): string[] {
-  return [`Approval needed: ${tool}`, `Connector: ${name}`, ...argLines(input)];
-}
-
 function bodyLines(params: PermissionParams): string[] {
   const metro = METRO_TOOL.exec(params.tool_name)?.[1];
   const { input } = readPreview(params.input_preview);
   const raw = params.input_preview.trim() === '' ? [] : [shorten(params.input_preview, RAW_MAX)];
   if (metro !== undefined) return input === undefined ? [`Approval needed: ${metro}`, ...raw] : metroLines(metro, input);
-  const connector = connectorToolOf(params.tool_name);
-  if (connector !== undefined) {
-    const { gate, tool } = connector;
-    const duplicate = connectorGates().some((entry) => entry.id !== gate.id && entry.name === gate.name);
-    return connectorLines(duplicate ? `${gate.name} (${gate.id})` : gate.name, tool, input);
-  }
   return [`Claude wants to run ${params.tool_name}: ${shorten(params.description)}`, '', ...raw];
 }
 
@@ -115,7 +104,6 @@ export function promptBody(params: PermissionParams): string {
 export interface ServerPrompt {
   requestId: string;
   tool: string;
-  connector: string | undefined;
   preview: string;
 }
 
@@ -123,5 +111,5 @@ export function serverPromptBody(prompt: ServerPrompt): string {
   const { input } = readPreview(prompt.preview);
   const raw = prompt.preview.trim() === '' ? [] : [shorten(prompt.preview, RAW_MAX)];
   const args = input === undefined ? raw : argLines(input);
-  return withAnswer(prompt.requestId, [`Approval needed: ${prompt.tool}`, ...(prompt.connector === undefined ? [] : [`Connector: ${prompt.connector}`]), ...args]);
+  return withAnswer(prompt.requestId, [`Approval needed: ${prompt.tool}`, ...args]);
 }

package/runtime/node_modules/@metro-labs/daemon/src/mcp/policy-snapshot.ts

@@ -7,7 +7,6 @@ import { agentsDir } from '../agents/files.js';
 import { knownAccounts } from '../agents/map.js';
 import { onPoliciesChanged, storedPolicies, type ToolPolicy } from '../policy/policy.js';
 import { UNGATED } from './policy-gate.js';
-import { connectorGates } from '../connectors/gates.js';
 import { stationToolOwners, TOOL_DEFS, toolGroupOf } from './tool-catalog.js';
 
 interface PolicySnapshot {
@@ -17,14 +16,6 @@ interface PolicySnapshot {
   ungated: string[];
   accounts: Record<string, ToolPolicy>;
   stations: Record<string, string[]>;
-  connectors: Record<string, SnapshotConnector>;
-}
-
-interface SnapshotConnector {
-  id: string;
-  name: string;
-  policy: ToolPolicy;
-  tools: Record<string, ToolGroup>;
 }
 
 const FILE = 'policy.json';
@@ -44,11 +35,6 @@ function policySnapshot(): PolicySnapshot {
     ungated: [...UNGATED],
     accounts,
     stations,
-    connectors: Object.fromEntries(
-      connectorGates()
-        .filter((gate) => gate.server !== '')
-        .map((gate) => [gate.server, { id: gate.id, name: gate.name, policy: gate.policy, tools: gate.tools }]),
-    ),
   };
 }
 

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

@@ -4,8 +4,7 @@ import type { McpApproval, McpDecision } from '@metro-labs/http/mcp-server-proto
 import { holdPrompt, isPromptHeld, type Behavior } from '../approvals/pending.js';
 import { ownerLine } from '../approvals/owner-line.js';
 import { metroNotice } from '../channels/notice.js';
-import { connectorGates } from '../connectors/gates.js';
-import { serverKey } from '../connectors/plugin-sync.js';
+import { announcedLine, noteAnnounced } from '../mcp-server/announced.js';
 import type { AnswerOutcome } from '../mcp-server/link.js';
 import { serverPromptBody } from './permission-prompt.js';
 import { metroSend, relayLine } from './permission-relay.js';
@@ -42,11 +41,6 @@ function remember(id: string, now = Date.now()): void {
 
 const answeredRecently = (id: string, now = Date.now()): boolean => now - (recent.get(id) ?? -Infinity) < RECENT_MS;
 
-function connectorName(key: string): string | undefined {
-  const names = new Set(connectorGates().filter((gate) => gate.server === key || serverKey(gate.name) === key).map((gate) => gate.name));
-  return names.size === 1 ? [...names][0] : undefined;
-}
-
 const noticeText = (tool: string, id: string, behavior: Behavior): string =>
   behavior === 'allow' ? `Approved: ${tool} (${id}). Call call_tool again with the same arguments and approval: "${id}".` : `Denied: ${tool} (${id}).`;
 
@@ -84,23 +78,28 @@ function sender(held: Held): (behavior: Behavior) => Promise<void> {
   };
 }
 
+function announce(id: string, line: string, text: string): void {
+  metroSend(line, text).then(() => {
+    noteAnnounced(id, line);
+  }).catch((err: unknown) => {
+    log.warn({ id, err: errMsg(err) }, 'mcp-server: the approval prompt could not be posted');
+  });
+}
+
 export function holdServerApproval(approval: McpApproval, answer: Held['answer'], publish: Held['publish']): boolean {
   if (isPromptHeld(approval.id) || answeredRecently(approval.id)) return false;
   const tool = `${approval.connector}.${approval.tool}`;
-  const name = connectorName(approval.connector);
-  const line = promptLineFor(approval.id);
+  const announced = announcedLine(approval.id);
+  const line = announced ?? promptLineFor(approval.id);
   const held: Held = { id: approval.id, tool, line, answer, publish };
   holdPrompt(
-    { requestId: approval.id, tool, description: name ?? approval.connector, preview: approval.preview, line, at: requestedAt(approval.requestedAt), origin: 'mcp-server' },
+    { requestId: approval.id, tool, description: approval.connector, preview: approval.preview, line, at: requestedAt(approval.requestedAt), origin: 'mcp-server' },
     owner,
     sender(held),
     line === undefined ? undefined : async (text) => metroSend(line, text),
   );
-  log.info({ id: approval.id, tool, inChat: line !== undefined }, 'mcp-server: an approval is waiting for the owner');
-  if (line !== undefined)
-    metroSend(line, serverPromptBody({ requestId: approval.id, tool, connector: name, preview: approval.preview })).catch((err: unknown) => {
-      log.warn({ id: approval.id, err: errMsg(err) }, 'mcp-server: the approval prompt could not be posted');
-    });
+  log.info({ id: approval.id, tool, inChat: line !== undefined, announced: announced !== undefined }, 'mcp-server: an approval is waiting for the owner');
+  if (line !== undefined && announced === undefined) announce(approval.id, line, serverPromptBody({ requestId: approval.id, tool, preview: approval.preview }));
   return true;
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/mcp-server/announced.ts

@@ -0,0 +1,68 @@
+import { errMsg, log } from '@metro-labs/core/log';
+import { isRecord } from '@metro-labs/core/is-record';
+import { readJson, writeSecure } from '@metro-labs/core/secure-fs';
+import { MCP_APPROVAL_ID_RE } from '@metro-labs/http/mcp-server-protocol';
+
+const KEEP_MS = 24 * 3_600_000;
+const MAX = 200;
+
+interface Announced {
+  line: string;
+  at: number;
+}
+
+let file: string | undefined;
+let known = new Map<string, Announced>();
+
+function entryOf(raw: unknown): Announced | null {
+  if (!isRecord(raw) || typeof raw.line !== 'string' || !raw.line.startsWith('metro://') || typeof raw.at !== 'number' || !Number.isFinite(raw.at)) return null;
+  return { line: raw.line, at: raw.at };
+}
+
+function parse(raw: unknown): Map<string, Announced> {
+  const out = new Map<string, Announced>();
+  const entries = isRecord(raw) && raw.version === 1 && isRecord(raw.announced) ? raw.announced : {};
+  for (const [id, value] of Object.entries(entries)) {
+    const entry = entryOf(value);
+    if (MCP_APPROVAL_ID_RE.test(id) && entry !== null) out.set(id, entry);
+  }
+  return out;
+}
+
+function prune(now: number): void {
+  for (const [id, entry] of known) if (now - entry.at >= KEEP_MS || entry.at > now) known.delete(id);
+  const oldest = [...known].sort(([, a], [, b]) => a.at - b.at);
+  for (const [id] of oldest.slice(0, Math.max(0, known.size - MAX))) known.delete(id);
+}
+
+function save(): void {
+  if (file === undefined) return;
+  const announced = Object.fromEntries([...known].map(([id, entry]) => [id, { line: entry.line, at: entry.at }]));
+  try {
+    writeSecure(file, `${JSON.stringify({ version: 1, announced })}\n`);
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'mcp-server: the announced approvals could not be saved, so they are kept in memory only');
+  }
+}
+
+export function setAnnouncedFile(path: string, now = Date.now()): void {
+  file = path;
+  known = parse(readJson<unknown>(path, null, { warn: 'mcp-server: the announced approvals file is not valid JSON, so it was ignored' }));
+  prune(now);
+}
+
+export function announcedLine(id: string, now = Date.now()): string | undefined {
+  const entry = known.get(id);
+  return entry !== undefined && now - entry.at < KEEP_MS && entry.at <= now ? entry.line : undefined;
+}
+
+export function noteAnnounced(id: string, line: string, now = Date.now()): void {
+  known.set(id, { line, at: now });
+  prune(now);
+  save();
+}
+
+export function forgetAnnounced(): void {
+  file = undefined;
+  known = new Map();
+}

package/runtime/node_modules/@metro-labs/daemon/src/mcp-server/config.ts

@@ -2,6 +2,8 @@ import { log } from '@metro-labs/core/log';
 
 export const MCP_SERVER_KEY = 'mcp';
 
+const DEFAULT_URL = 'https://mcp.metro.box';
+
 const LOOPBACK = new Set(['localhost', '127.0.0.1', '[::1]']);
 
 let refused: string | undefined;
@@ -18,7 +20,7 @@ function usable(raw: string): boolean {
 }
 
 export function mcpServerUrl(env: NodeJS.ProcessEnv = process.env): string | null {
-  const raw = env.METRO_MCP_SERVER_URL?.trim() ?? '';
+  const raw = env.METRO_MCP_SERVER_URL?.trim() ?? DEFAULT_URL;
   if (raw === '') return null;
   if (usable(raw)) return raw.replace(/\/+$/, '');
   if (refused !== raw) {