@stage-labs/metro 0.1.0-beta.165 → 0.1.0-beta.167

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.165",
+  "version": "0.1.0-beta.167",
   "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.165",
+  "version": "0.1.0-beta.167",
   "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/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';
@@ -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;

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;

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

@@ -9,7 +9,8 @@ import {
   freshAdaptations,
   type Adaptations,
 } from './bedrock.js';
-import { anthropicHeaders, forwardedHeaders, GatewayError, parseJson, pipeResponse, readBody, sendError, watchUpstream } from './forward.js';
+import { addBeta, anthropicHeaders, forwardedHeaders, GatewayError, parseJson, pipeResponse, readBody, sendError, watchUpstream } from './forward.js';
+import { BINDING_BETA, cappedEffort, effortToApply, plannedEffort, withBlockBinding, withEffort } from './effort.js';
 import { notReady, readModelConfig, resolveRoute, routeLabel, setCodexAuth, setGeminiAuth, writeModelConfig, type Connection, type ModelConfig, type Route } from './model-config.js';
 import { codexCount, codexMessages, freshCodexState } from './codex.js';
 import { freshGeminiState, geminiCount, geminiMessages } from './gemini.js';
@@ -89,17 +90,41 @@ const standsInFor = (req: IncomingMessage): boolean => {
   return typeof metroKey === 'string' && metroKey !== '' && req.headers.authorization === `Bearer ${metroKey}`;
 };
 
+interface Payloads {
+  metro: Buffer;
+  asSent: Buffer | null;
+  bound: boolean;
+}
+
+function anthropicPayloads(raw: Buffer, sent: Record<string, unknown>, shaped: Record<string, unknown>, model: string): Payloads {
+  const rewrite = typeof sent.model === 'string' && sent.model !== model;
+  const asSent = rewrite ? Buffer.from(JSON.stringify({ ...sent, model })) : raw;
+  const bound = withBlockBinding(shaped);
+  if (bound === sent) return { metro: asSent, asSent: null, bound: false };
+  return { metro: Buffer.from(JSON.stringify(rewrite ? { ...bound, model } : bound)), asSent, bound: bound !== shaped };
+}
+
+type Send = (payload: Buffer, headers: Record<string, string>) => Promise<Response>;
+
+async function asAnthropicWants(send: Send, base: Record<string, string>, payloads: Payloads, connection: string, model: string): Promise<Response> {
+  const { metro, asSent, bound } = payloads;
+  const upstream = await send(metro, bound ? addBeta(base, BINDING_BETA) : base);
+  if (upstream.status !== 400 || asSent === null) return upstream;
+  await upstream.body?.cancel();
+  log.warn({ connection, model }, 'gateway: Anthropic refused the request metro shaped, so it was sent again as Claude Code wrote it');
+  return send(asSent, base);
+}
+
 async function toAnthropic(
   req: IncomingMessage,
   res: ServerResponse,
   raw: Buffer,
-  body: Record<string, unknown>,
+  sent: Record<string, unknown>,
+  shaped: Record<string, unknown>,
   route: Route,
   deps: GatewayDeps,
 ): Promise<void> {
   const conn = route.connection;
-  const explicit = typeof body.model === 'string' && body.model !== route.model;
-  const payload = explicit ? Buffer.from(JSON.stringify({ ...body, model: route.model })) : raw;
   const url = `${deps.anthropicBase ?? ANTHROPIC_BASE}${(req.url ?? '').slice(GATEWAY_PREFIX.length)}`;
   const key = conn.apiKey;
   if (key === '' && standsInFor(req))
@@ -109,13 +134,10 @@ async function toAnthropic(
       'Claude Code on this machine has no Anthropic login of its own; choose Bedrock, OpenRouter, Codex or Gemini on the Model page, or sign in on the Claude tab',
     );
   const watch = watchUpstream(res);
-  const upstream = await fetch(url, {
-    method: 'POST',
-    headers: key === '' ? forwardedHeaders(req) : anthropicHeaders(req, key),
-    body: new Uint8Array(payload),
-    signal: watch.signal,
-    redirect: 'manual',
-  });
+  const base = key === '' ? forwardedHeaders(req) : anthropicHeaders(req, key);
+  const send = (payload: Buffer, headers: Record<string, string>): Promise<Response> =>
+    fetch(url, { method: 'POST', headers, body: new Uint8Array(payload), signal: watch.signal, redirect: 'manual' });
+  const upstream = await asAnthropicWants(send, base, anthropicPayloads(raw, sent, shaped, route.model), conn.label, route.model);
   noteRefusal(conn.label, route.model, upstream);
   noteUsageHeaders('anthropic', conn.id, upstream.headers);
   const scanner = new UsageScanner(conn.id);
@@ -160,6 +182,8 @@ const thinkingOff = (body: Record<string, unknown>): boolean => isRecord(body.th
 export function openrouterBody(body: Record<string, unknown>, model: string, zdr: boolean): Record<string, unknown> {
   const sent: Record<string, unknown> = { ...body, model };
   if (thinkingOff(body)) delete sent.thinking;
+  const effort = effortToApply(body);
+  if (effort !== null) sent.reasoning = { ...(isRecord(body.reasoning) ? body.reasoning : {}), effort: cappedEffort(effort) };
   if (!zdr) return sent;
   const provider = isRecord(body.provider) ? body.provider : {};
   return { ...sent, provider: { ...provider, zdr: true } };
@@ -180,10 +204,16 @@ async function toSubscription(req: IncomingMessage, res: ServerResponse, path: s
   else await codexMessages(req, res, body, route.model, conn, { save: saveCodexTokens, ...deps.codex }, codexState, watchUpstream(res));
 }
 
+function shapedFor(req: IncomingMessage, sent: Record<string, unknown>): Record<string, unknown> {
+  const effort = plannedEffort(req, sent);
+  return effort === null ? sent : withEffort(sent, effort);
+}
+
 async function dispatch(req: IncomingMessage, res: ServerResponse, path: string, deps: GatewayDeps): Promise<void> {
   const cfg = deps.config();
   const raw = await readBody(req);
-  const body = parseJson(raw);
+  const sent = parseJson(raw);
+  const body = shapedFor(req, sent);
   const route = resolveRoute(requestedModel(body), cfg) ?? passthrough(body);
   const conn = route.connection;
   log.info({ route: routeLabel(route), connection: conn.label, path }, 'gateway: routing');
@@ -204,7 +234,7 @@ async function dispatch(req: IncomingMessage, res: ServerResponse, path: string,
     await toSubscription(req, res, path, body, route, deps);
     return;
   }
-  await toAnthropic(req, res, raw, body, route, deps);
+  await toAnthropic(req, res, raw, sent, body, route, deps);
 }
 
 function failed(res: ServerResponse, err: unknown): void {

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

@@ -2,6 +2,7 @@ import { randomBytes } from 'node:crypto';
 import { isRecord } from '@metro-labs/core/is-record';
 import { ToolNames } from './codex-translate.js';
 import { CLIENT_NAME, requestId, SYSTEM_PREFIX } from './gemini-client.js';
+import { cappedEffort, effortToApply } from './effort.js';
 
 type Item = Record<string, unknown>;
 
@@ -190,6 +191,8 @@ function generationConfig(body: Item): Item {
   if (typeof body.temperature === 'number') out.temperature = body.temperature;
   if (typeof body.top_p === 'number') out.topP = body.top_p;
   if (isRecord(body.thinking) && body.thinking.type === 'enabled') out.thinkingConfig = { includeThoughts: true };
+  const effort = effortToApply(body);
+  if (effort !== null) out.thinkingLevel = cappedEffort(effort);
   return out;
 }
 

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

@@ -10,6 +10,7 @@ import { assembleMessage, SseParser } from './codex-stream.js';
 import { GatewayError, idleMessage, providerStatus, sendError, upstreamMessage, type Watch } from './forward.js';
 import type { Connection } from './model-config.js';
 import { UsageScanner } from './usage.js';
+import { effortToApply, withoutEffort } from './effort.js';
 
 const PING_MS = 25_000;
 const STATUS_OF: Record<string, number> = { rate_limit_error: 429, invalid_request_error: 400, permission_error: 403, overloaded_error: 529 };
@@ -255,6 +256,13 @@ async function relayWhole(upstream: Response, res: ServerResponse, call: Call):
   res.end(JSON.stringify(message));
 }
 
+const NAMES_THINKING = /thinking|thought/i;
+
+function refuse(res: ServerResponse, model: string, status: number, text: string): void {
+  log.warn({ provider: 'gemini', model, status, body: text.slice(0, REFUSAL_LOG_MAX) }, 'gateway: the provider refused the request');
+  sendError(res, providerStatus(status), errorKind(status), refusalMessage(text, status));
+}
+
 export async function geminiMessages(
   req: IncomingMessage,
   res: ServerResponse,
@@ -266,12 +274,20 @@ export async function geminiMessages(
   watch: Watch,
 ): Promise<void> {
   const stream = body.stream === true;
-  const call: Call = { body, model, promptId: promptIdOf(req), watch, deps, names: new ToolNames(), conn };
-  const upstream = await reach(call, conn, state, stream);
-  if (!upstream.ok) {
+  let call: Call = { body, model, promptId: promptIdOf(req), watch, deps, names: new ToolNames(), conn };
+  let upstream = await reach(call, conn, state, stream);
+  if (upstream.status === 400 && effortToApply(body) !== null) {
     const text = await upstream.text();
-    log.warn({ provider: 'gemini', model, status: upstream.status, body: text.slice(0, REFUSAL_LOG_MAX) }, 'gateway: the provider refused the request');
-    sendError(res, providerStatus(upstream.status), errorKind(upstream.status), refusalMessage(text, upstream.status));
+    if (!NAMES_THINKING.test(text)) {
+      refuse(res, model, 400, text);
+      return;
+    }
+    log.warn({ provider: 'gemini', model }, 'gateway: Gemini refused the thinking level, so metro asked again without it');
+    call = { ...call, body: withoutEffort(body) };
+    upstream = await reach(call, conn, state, stream);
+  }
+  if (!upstream.ok) {
+    refuse(res, model, upstream.status, await upstream.text());
     return;
   }
   if (stream) await relayStream(upstream, res, call);

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

@@ -130,8 +130,14 @@ export function parseModelConfig(raw: unknown): ModelConfig {
   return { version: 2, route: connections.some((c) => c.id === route) ? route : (connections[0]?.id ?? ''), connections };
 }
 
+const needsIds = (raw: unknown): boolean =>
+  isRecord(raw) && (!Array.isArray(raw.connections) || raw.connections.some((c: unknown) => isRecord(c) && text(c.id) === ''));
+
 export function readModelConfig(dir = agentsDir()): ModelConfig {
-  return parseModelConfig(readJson<unknown>(join(dir, MODEL_FILE), null, { warn: 'model-config: model.json is unreadable, so every request goes to Anthropic until it is fixed' }));
+  const raw = readJson<unknown>(join(dir, MODEL_FILE), null, { warn: 'model-config: model.json is unreadable, so every request goes to Anthropic until it is fixed' });
+  const cfg = parseModelConfig(raw);
+  if (needsIds(raw)) writeModelConfig(cfg, dir);
+  return cfg;
 }
 
 export function writeModelConfig(cfg: ModelConfig, dir = agentsDir()): void {

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.165"
+  "version": "0.1.0-beta.167"
 }