@stage-labs/metro 0.1.0-beta.164 → 0.1.0-beta.166

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.164",
+  "version": "0.1.0-beta.166",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.164",
+  "version": "0.1.0-beta.166",
   "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/marketplace/plugin/orchestrator.md

@@ -11,6 +11,12 @@ You are the main thread of a Claude Code session that is connected to chat throu
 
 **Never wait on the terminal.** `AskUserQuestion`, plan mode and anything that blocks for a person at the keyboard are denied everywhere, main thread and subagents alike. When something is ambiguous, do what does not depend on it, choose the most reasonable reading, say so in your reply, and if a real decision is needed ask over chat with `send` and carry on. Tool-approval prompts reach the chat too; the person answers `yes <id>` or `no <id>` there.
 
+**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.
+
+The exception is a person describing a problem, asking a question or thinking out loud. There the answer IS the deliverable: reply, and change nothing until they ask.
+
+**The whole request is the deliverable.** Do not quietly make it smaller, larger or different. Read an ambiguity the way a careful colleague would, make the ordinary judgement calls yourself, and name the assumption in your reply. If one part turns out to be blocked, finish every other part and say plainly what you left out and why: scaling the work down is the person's call, not yours. Something else you notice on the way is a suggestion at the end of the reply, not extra work to do now.
+
 **Report like a relay.** A worker's report is the only evidence you have, so pass on what it verified and say plainly what it did not. Short messages on chat: lead with the outcome, one idea per sentence, no tool names, no file paths unless the person needs them. Send a file out with `create_upload` (the curl line it hands back runs in a worker) and then `send` with the upload id.
 
 **Keep going.** Long tasks run as background agents and loops; check in over chat when something lands rather than going quiet. The session is restarted by the daemon if it exits, so an interrupted task is resumed from chat, not from memory.

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

@@ -49,6 +49,7 @@ import { pipeline } from 'node:stream/promises';
 import {
   claudeDir,
   deleteClaudeSession,
+  deleteMemoryFile,
   listClaudeProjects,
   listClaudeSessions,
   listMemory,
@@ -259,6 +260,7 @@ function removed(rest: string[], query: URLSearchParams, dir: string): unknown {
   const [head = '', item = ''] = rest;
   if (rest.length !== 2) throw new ApiError('method not allowed', 405);
   if (head === 'skills') return { deleted: deleteClaudeSkill(decodeURIComponent(item), dir) };
+  if (head === 'memory') return { deleted: deleteMemoryFile(projectOf(query), decodeURIComponent(item), dir) };
   if (head !== 'sessions') throw new ApiError('method not allowed', 405);
   deleteClaudeSession(projectOf(query), item, dir);
   return { deleted: item };

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

@@ -351,6 +351,14 @@ export function writeMemoryFile(project: string, name: string, text: string, dir
   return { name: file, bytes: stat.size, modifiedAt: stat.mtime.toISOString() };
 }
 
+export function deleteMemoryFile(project: string, name: string, dir = claudeDir()): string {
+  const file = safeName(name, MEMORY_RE, 'memory file name');
+  const path = join(memoryDir(project, dir), file);
+  if (!existsSync(path)) throw new ApiError('no such memory file', 404);
+  rmSync(path);
+  return file;
+}
+
 export function readMemoryFile(project: string, name: string, dir = claudeDir()): string {
   const path = join(memoryDir(project, dir), safeName(name, MEMORY_RE, 'memory file name'));
   if (!existsSync(path)) throw new ApiError('no such memory file', 404);

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

@@ -7,7 +7,7 @@ import { isRecord } from '@metro-labs/core/is-record';
 import { readJson, writeJson } from '@metro-labs/core/secure-fs';
 import { METRO_VERSION } from '@metro-labs/core/version';
 import { agentsDir, listAgentFiles } from '../agents/files.js';
-import { notReady, readModelConfig } from '../gateway/model-config.js';
+import { notReady, readModelConfig, routedConnection } from '../gateway/model-config.js';
 import { claudeDir, listClaudeProjects } from './files.js';
 import { claudeAccount, claudeInstalled } from './login.js';
 import { trustFolder } from './onboarding.js';
@@ -105,7 +105,8 @@ function credentialReady(deps: SessionDeps): string | null {
   if (signedIn()) return null;
   try {
     const cfg = readModelConfig(deps.agents ?? agentsDir());
-    if (cfg.provider !== 'anthropic' && notReady(cfg) === null) return null;
+    const conn = routedConnection(cfg);
+    if (conn !== null && conn.provider !== 'anthropic' && notReady(cfg) === null) return null;
   } catch (err) {
     return `the Model page is not readable (${errMsg(err)})`;
   }

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

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -7,7 +8,7 @@ import { readJson, writeJson } from '@metro-labs/core/secure-fs';
 import { agentsDir } from '../agents/files.js';
 import { claudeDir } from './files.js';
 import { stagedMarketplaceDir } from './plugin-install.js';
-import { readModelConfig, type ModelConfig } from '../gateway/model-config.js';
+import { readModelConfig, routedConnection, type ModelConfig } from '../gateway/model-config.js';
 
 export const PRIVACY_ENV: Record<string, string> = {
   DISABLE_TELEMETRY: '1',
@@ -30,7 +31,9 @@ effort: xhigh
 
 You are a worker agent. The main thread that dispatched you is an orchestrator with no file, shell or network access; it can only delegate and relay messages. That means you are where the actual work happens, and the quality of your output is the quality of the result.
 
-Work to completion. Do not hand back a partial answer with a suggestion that someone else finish it; there is no one else. If part of the task is genuinely blocked, complete every other part in full and say plainly what you left undone and why.
+Work to completion. Do not hand back a partial answer with a suggestion that someone else finish it; there is no one else. If part of the task is genuinely blocked, complete every other part in full and say plainly what you left undone and why. Before you finish, read your own last paragraph: if it is a plan, a question or a promise about work you have not done, do that work now.
+
+Keep the change to what the task asks for. A pre-existing bug, a performance problem or behaviour the task does not mention is a follow-up to report at the end, not something to fix now, unless the requested behaviour cannot work without it. Where the task is ambiguous, build the reading its wording and the surrounding code support best, and state that assumption. Commit tests only where the task asks for them or the repository already keeps tests for that kind of change, sized like the neighbouring test files; scratch checks you used to verify yourself need not be kept. This is about extras only: every behaviour the task does ask for, implement completely.
 
 Never call AskUserQuestion or ExitPlanMode. They are blocked by policy, because nobody is watching the terminal around the clock and a blocking prompt stalls indefinitely. When you hit an ambiguity: do everything that does not depend on it, then choose the most reasonable interpretation, state the assumption explicitly in your report, and continue.
 
@@ -44,7 +47,7 @@ export interface SetupDeps {
   env?: NodeJS.ProcessEnv;
 }
 
-export type Placed = 'written' | 'present' | 'missing';
+export type Placed = 'written' | 'present' | 'updated' | 'missing';
 export type SettingsOutcome = 'written' | 'unchanged' | 'unreadable';
 
 export interface SetupReport {
@@ -127,11 +130,21 @@ export function guidancePath(env: NodeJS.ProcessEnv = process.env): string {
   return fileURLToPath(new URL(`../../../../plugin/${GUIDANCE}`, import.meta.url));
 }
 
-function ensureFile(path: string, text: string): Placed {
-  if (existsSync(path)) return 'present';
-  mkdirSync(dirname(path), { recursive: true });
+const PRIOR_WORKER: ReadonlySet<string> = new Set(['08a0cd8710df285d6512245246bb8b658b7cfc7f3e89490514ee5376779eb2ef']);
+const PRIOR_SKILL: ReadonlySet<string> = new Set(['0b3d122ed95beff09d579cf912cd4238e1db524c41fce4b314de57d6ff5908ad']);
+
+const digest = (text: string): string => createHash('sha256').update(text).digest('hex');
+
+export function placeFile(path: string, text: string, prior: ReadonlySet<string> = new Set()): Placed {
+  if (!existsSync(path)) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, text, { mode: 0o644 });
+    return 'written';
+  }
+  const current = readFileSync(path, 'utf8');
+  if (current === text || !prior.has(digest(current))) return 'present';
   writeFileSync(path, text, { mode: 0o644 });
-  return 'written';
+  return 'updated';
 }
 
 function readSettings(path: string): Record<string, unknown> | null {
@@ -172,9 +185,11 @@ const workerPath = (dir: string): string => join(dir, 'agents', 'worker.md');
 
 function placeSkill(dir: string, guidance: string): Placed {
   if (!existsSync(guidance)) return 'missing';
-  return ensureFile(skillPath(dir), readFileSync(guidance, 'utf8'));
+  return placeFile(skillPath(dir), readFileSync(guidance, 'utf8'), PRIOR_SKILL);
 }
 
+const written = (placed: Placed): boolean => placed === 'written' || placed === 'updated';
+
 export function ensureClaudeSetup(deps: SetupDeps = {}): SetupReport {
   const dir = deps.dir ?? claudeDir();
   const agents = deps.agents ?? agentsDir();
@@ -182,12 +197,12 @@ export function ensureClaudeSetup(deps: SetupDeps = {}): SetupReport {
   const report: SetupReport = {
     privacy,
     guard: 'plugin',
-    worker: ensureFile(workerPath(dir), WORKER_AGENT),
+    worker: placeFile(workerPath(dir), WORKER_AGENT, PRIOR_WORKER),
     skill: placeSkill(dir, deps.guidance ?? guidancePath(deps.env)),
     settings: applyPrivacy(dir, privacy),
   };
   syncAvailableModelsQuietly({ ...deps, dir, agents });
-  if (report.worker === 'written' || report.skill === 'written' || report.settings === 'written')
+  if (written(report.worker) || written(report.skill) || report.settings === 'written')
     log.info(report, 'claude-setup: applied the Claude Code setup for a metro box');
   if (report.settings === 'unreadable') log.warn({ path: join(dir, 'settings.json') }, 'claude-setup: settings.json is not valid JSON, so the privacy settings were not written');
   return report;
@@ -222,9 +237,9 @@ const MODELS_KEY = 'availableModels';
 const ENFORCE_KEY = 'enforceAvailableModels';
 
 export function routeOf(cfg: ModelConfig): string | null {
-  if (cfg.provider === 'anthropic') return null;
-  const model = cfg[cfg.provider].model;
-  return model === '' ? null : `${cfg.provider}:${model}`;
+  const conn = routedConnection(cfg);
+  if (conn === null || conn.provider === 'anthropic' || conn.model === '') return null;
+  return `${conn.provider}:${conn.model}`;
 }
 
 function withAvailableModels(settings: Record<string, unknown>, route: string | null, metroWrote: boolean): Record<string, unknown> {

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

@@ -2,7 +2,7 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import { log } from '@metro-labs/core/log';
 import { EventStreamDecoder, type EventStreamMessage } from './eventstream.js';
 import { errorFrame, GatewayError, idleMessage, providerStatus, sendError, upstreamMessage, type Watch } from './forward.js';
-import type { BedrockSettings } from './model-config.js';
+import type { Connection } from './model-config.js';
 import { UsageScanner } from './usage.js';
 
 const ANTHROPIC_VERSION = 'bedrock-2023-05-31';
@@ -18,7 +18,7 @@ export interface Adaptations {
 export const freshAdaptations = (): Adaptations => ({ fields: new Set(), dropBetas: false });
 
 export interface BedrockUpstream {
-  settings: BedrockSettings;
+  settings: Connection;
   base: string;
   learned: Adaptations;
   watch: Watch;
@@ -253,7 +253,7 @@ export async function bedrockCount(
   res.end(JSON.stringify({ input_tokens: counted ?? estimateTokens(rewritten.body) }));
 }
 
-export function assertBedrockReady(settings: BedrockSettings): void {
+export function assertBedrockReady(settings: Connection): void {
   if (settings.apiKey === '' || settings.region === '')
     throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs an API key and a region: add them on the Model page.');
 }

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

@@ -7,7 +7,7 @@ import { refreshTokens, tokensStale, type CodexTokens } from './codex-auth.js';
 import { assembleMessage, CodexEventTranslator, parseEvent, SseParser } from './codex-stream.js';
 import { ToolNames, toResponsesRequest } from './codex-translate.js';
 import { GatewayError, idleMessage, providerStatus, sendError, upstreamMessage, type Watch } from './forward.js';
-import type { ModelConfig } from './model-config.js';
+import type { Connection } from './model-config.js';
 import { noteUsageHeaders, UsageScanner } from './usage.js';
 
 export const CODEX_BASE = 'https://chatgpt.com/backend-api/codex';
@@ -20,7 +20,7 @@ export interface CodexDeps {
   base?: string;
   issuer?: string;
   fetchImpl?: typeof fetch;
-  save: (tokens: CodexTokens) => void;
+  save: (id: string, tokens: CodexTokens) => void;
 }
 
 export interface CodexState {
@@ -57,13 +57,13 @@ function headersFor(tokens: CodexTokens, sessionId: string): Record<string, stri
 
 const newerThan = (a: CodexTokens, b: CodexTokens): boolean => Date.parse(a.savedAt) > Date.parse(b.savedAt);
 
-function refreshed(tokens: CodexTokens, deps: CodexDeps, state: CodexState): Promise<CodexTokens> {
+function refreshed(id: string, tokens: CodexTokens, deps: CodexDeps, state: CodexState): Promise<CodexTokens> {
   const latest = state.latest;
   if (latest !== null && newerThan(latest, tokens) && !tokensStale(latest)) return Promise.resolve(latest);
   if (state.refreshing !== null) return state.refreshing;
   const run = refreshTokens(tokens, deps.issuer, deps.fetchImpl)
     .then((fresh) => {
-      deps.save(fresh);
+      deps.save(id, fresh);
       state.latest = fresh;
       return fresh;
     })
@@ -77,10 +77,10 @@ function refreshed(tokens: CodexTokens, deps: CodexDeps, state: CodexState): Pro
   return run;
 }
 
-export function currentTokens(cfg: ModelConfig, deps: CodexDeps, state: CodexState): Promise<CodexTokens> {
-  const tokens = cfg.codex.auth;
+export function currentTokens(conn: Connection, deps: CodexDeps, state: CodexState): Promise<CodexTokens> {
+  const tokens = conn.codex;
   if (tokens === null) throw new GatewayError(400, 'invalid_request_error', 'Codex is not connected: sign in on the Model page.');
-  return tokensStale(tokens) ? refreshed(tokens, deps, state) : Promise.resolve(tokens);
+  return tokensStale(tokens) ? refreshed(conn.id, tokens, deps, state) : Promise.resolve(tokens);
 }
 
 function errorKind(status: number): string {
@@ -116,18 +116,18 @@ function send(call: Call, tokens: CodexTokens): Promise<Response> {
   });
 }
 
-async function reach(call: Call, cfg: ModelConfig, state: CodexState): Promise<Response> {
-  let tokens = await currentTokens(cfg, call.deps, state);
+async function reach(call: Call, conn: Connection, state: CodexState): Promise<Response> {
+  let tokens = await currentTokens(conn, call.deps, state);
   let upstream = await send(call, tokens);
   if (upstream.status === 401) {
     await upstream.body?.cancel();
-    tokens = await refreshed(tokens, call.deps, state);
+    tokens = await refreshed(conn.id, tokens, call.deps, state);
     upstream = await send(call, tokens);
   }
   return upstream;
 }
 
-async function relayStream(upstream: Response, res: ServerResponse, model: string, names: ToolNames, watch: Watch): Promise<void> {
+async function relayStream(upstream: Response, res: ServerResponse, model: string, names: ToolNames, watch: Watch, key: string): Promise<void> {
   res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-store', connection: 'keep-alive' });
   const translator = new CodexEventTranslator(model, (name) => names.restore(name));
   const body = upstream.body;
@@ -136,7 +136,7 @@ async function relayStream(upstream: Response, res: ServerResponse, model: strin
     return;
   }
   const ping = setInterval(() => res.write('event: ping\ndata: {"type":"ping"}\n\n'), PING_MS);
-  const scanner = new UsageScanner('codex');
+  const scanner = new UsageScanner(key);
   const emit = (frames: string): void => {
     scanner.feed(frames);
     res.write(frames);
@@ -166,7 +166,7 @@ async function relayStream(upstream: Response, res: ServerResponse, model: strin
   }
 }
 
-async function relayWhole(upstream: Response, res: ServerResponse, model: string, names: ToolNames): Promise<void> {
+async function relayWhole(upstream: Response, res: ServerResponse, model: string, names: ToolNames, key: string): Promise<void> {
   const translator = new CodexEventTranslator(model, (name) => names.restore(name));
   let frames = '';
   const parser = new SseParser();
@@ -175,7 +175,7 @@ async function relayWhole(upstream: Response, res: ServerResponse, model: string
     if (parsed !== null) frames += translator.push(parsed.event, parsed.data);
   }
   frames += translator.close();
-  const scanner = new UsageScanner('codex');
+  const scanner = new UsageScanner(key);
   scanner.feed(frames);
   scanner.done();
   const message = assembleMessage(frames);
@@ -189,21 +189,21 @@ export async function codexMessages(
   res: ServerResponse,
   body: Record<string, unknown>,
   model: string,
-  cfg: ModelConfig,
+  conn: Connection,
   deps: CodexDeps,
   state: CodexState,
   watch: Watch,
 ): Promise<void> {
   const call: Call = { body, model, sessionId: sessionIdOf(req), watch, deps, names: new ToolNames() };
-  const upstream = await reach(call, cfg, state);
-  noteUsageHeaders('codex', upstream.headers);
+  const upstream = await reach(call, conn, state);
+  noteUsageHeaders('codex', conn.id, upstream.headers);
   if (!upstream.ok) {
     const text = await upstream.text();
     sendError(res, providerStatus(upstream.status), errorKind(upstream.status), upstreamMessage(text, `Codex answered ${String(upstream.status)}`));
     return;
   }
-  if (body.stream === true) await relayStream(upstream, res, model, call.names, watch);
-  else await relayWhole(upstream, res, model, call.names);
+  if (body.stream === true) await relayStream(upstream, res, model, call.names, watch, conn.id);
+  else await relayWhole(upstream, res, model, call.names, conn.id);
 }
 
 export function codexCount(res: ServerResponse, body: Record<string, unknown>): void {

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

@@ -0,0 +1,70 @@
+import type { IncomingMessage } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
+
+export const MAIN_EFFORT = 'low';
+export const SUBAGENT_EFFORT = 'max';
+export const BINDING_BETA = 'thinking-binding-controls-2026-08-01';
+
+const SUBAGENT_HEADER = 'x-claude-code-agent-id';
+const SUBAGENT_MARK = 'cc_is_subagent=true';
+const ABOVE_HIGH = new Set(['xhigh', 'max']);
+
+export type RequestKind = 'main' | 'subagent' | 'other';
+
+type Body = Record<string, unknown>;
+
+const record = (value: unknown): Body => (isRecord(value) ? value : {});
+
+const effortOf = (body: Body): string => {
+  const effort = record(body.output_config).effort;
+  return typeof effort === 'string' ? effort : '';
+};
+
+function header(req: IncomingMessage, name: string): string {
+  const raw = req.headers[name];
+  return (Array.isArray(raw) ? raw[0] : raw)?.trim() ?? '';
+}
+
+function systemMarksSubagent(body: Body): boolean {
+  const system = body.system;
+  if (!Array.isArray(system)) return false;
+  return system.some((block) => isRecord(block) && typeof block.text === 'string' && block.text.includes(SUBAGENT_MARK));
+}
+
+const chore = (body: Body): boolean => record(body.output_config).format !== undefined || record(body.thinking).type === 'disabled';
+
+export function requestKind(req: IncomingMessage, body: Body): RequestKind {
+  if (header(req, SUBAGENT_HEADER) !== '' || systemMarksSubagent(body)) return 'subagent';
+  return chore(body) ? 'other' : 'main';
+}
+
+export function plannedEffort(req: IncomingMessage, body: Body): string | null {
+  const current = effortOf(body);
+  if (current === '') return null;
+  const kind = requestKind(req, body);
+  if (kind === 'other') return null;
+  const wanted = kind === 'subagent' ? SUBAGENT_EFFORT : MAIN_EFFORT;
+  return wanted === current ? null : wanted;
+}
+
+export const withEffort = (body: Body, effort: string): Body => ({ ...body, output_config: { ...record(body.output_config), effort } });
+
+export function withoutEffort(body: Body): Body {
+  const config = Object.fromEntries(Object.entries(record(body.output_config)).filter(([key]) => key !== 'effort'));
+  if (Object.keys(config).length > 0) return { ...body, output_config: config };
+  return Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'output_config'));
+}
+
+export function effortToApply(body: Body): string | null {
+  if (chore(body)) return null;
+  const effort = effortOf(body);
+  return effort === '' ? null : effort;
+}
+
+export const cappedEffort = (effort: string): string => (ABOVE_HIGH.has(effort) ? 'high' : effort);
+
+export function withBlockBinding(body: Body): Body {
+  const thinking = body.thinking;
+  if (!isRecord(thinking) || thinking.block_binding !== undefined) return body;
+  return { ...body, thinking: { ...thinking, block_binding: { prefix_mismatch_behavior: 'drop_block' } } };
+}

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

@@ -127,6 +127,15 @@ export function anthropicHeaders(req: IncomingMessage, apiKey: string): Record<s
   return headers;
 }
 
+export function addBeta(headers: Record<string, string>, beta: string): Record<string, string> {
+  const listed = (headers['anthropic-beta'] ?? '')
+    .split(',')
+    .map((one) => one.trim())
+    .filter((one) => one !== '');
+  if (listed.includes(beta)) return headers;
+  return { ...headers, 'anthropic-beta': [...listed, beta].join(',') };
+}
+
 export interface PipeOptions {
   keepalive?: boolean;
   ownCredential?: boolean;