@stage-labs/metro 0.1.0-beta.327 → 0.1.0-beta.329

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.327",
+  "version": "0.1.0-beta.329",
   "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/node_modules/@metro-labs/daemon/src/claude/api.ts

@@ -25,6 +25,7 @@ import {
   type SessionDeps,
 } from './session.js';
 import { receiveSessionFile, sessionFilePath } from './session-files.js';
+import { readToolCall } from './tool-call.js';
 import { createReadStream } from '../agent-user/agent-fs.js';
 import { pipeline } from 'node:stream/promises';
 import {
@@ -50,6 +51,11 @@ export interface ClaudeApiDeps extends SetupApiDeps {
   skillSource?: GitHubSkills;
 }
 
+function optionalProject(query: URLSearchParams): string | null {
+  const project = query.get('project');
+  return project === null || project === '' ? null : project;
+}
+
 function projectOf(query: URLSearchParams): string {
   const project = query.get('project');
   if (project === null || project === '') throw new ApiError('project is required', 400);
@@ -73,7 +79,9 @@ const COLLECTIONS: Record<string, Handler> = {
 };
 
 const ITEMS: Record<string, Handler> = {
-  sessions: (query, dir, id) => {
+  sessions: async (query, dir, id) => {
+    const tool = query.get('tool');
+    if (tool !== null) return { call: await readToolCall(optionalProject(query), id, tool, dir) };
     const { offset, limit } = pageOf(query);
     return readTranscript(projectOf(query), id, offset, limit, dir);
   },

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

@@ -15,8 +15,8 @@ const MEMORY_DEPTH = 6;
 const MEMORY_FILES_MAX = 5000;
 const EDGE_BYTES = 64 * 1024;
 const TEXT_CAP = 20_000;
-const RESULT_CAP = 8_000;
-const INPUT_CAP = 4_000;
+export const RESULT_CAP = 8_000;
+export const INPUT_CAP = 4_000;
 const FILE_CAP = 1_000_000;
 const MEMORY_MAX = 256 * 1024;
 const MEMORY_MODE = 0o644;
@@ -31,7 +31,7 @@ export function claudeDir(): string {
   return join(user === null ? homedir() : user.home, '.claude');
 }
 
-const str = (v: unknown): string | null => (typeof v === 'string' && v !== '' ? v : null);
+export const str = (v: unknown): string | null => (typeof v === 'string' && v !== '' ? v : null);
 
 export function safeName(value: string, re: RegExp, what: string): string {
   if (!re.test(value) || value === '.' || value === '..')
@@ -39,13 +39,13 @@ export function safeName(value: string, re: RegExp, what: string): string {
   return value;
 }
 
-function projectDir(project: string, dir: string): string {
+export function projectDir(project: string, dir: string): string {
   const path = join(dir, 'projects', safeName(project, PROJECT_RE, 'Claude project id'));
   if (!existsSync(path)) throw new ApiError('no such Claude project', 404);
   return path;
 }
 
-function parseLines(text: string): Record<string, unknown>[] {
+export function parseLines(text: string): Record<string, unknown>[] {
   const out: Record<string, unknown>[] = [];
   for (const line of text.split('\n')) {
     if (line.trim() === '') continue;
@@ -187,10 +187,10 @@ export interface TranscriptPage {
   next: number | null;
 }
 
-const cap = (text: string, max: number): string =>
+export const cap = (text: string, max: number): string =>
   text.length > max ? `${text.slice(0, max)}\n… (${String(text.length - max)} more characters)` : text;
 
-function resultText(content: unknown): string {
+export function resultText(content: unknown): string {
   if (typeof content === 'string') return content;
   if (!Array.isArray(content)) return '';
   return content

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

@@ -28,5 +28,5 @@ export function inSessionScope(command: [string, string[]], host: ScopeHost = re
   const asAgent = file === 'sudo' && args[0] === '-n' && args[1] === '-u' && args[3] === '--';
   if (!host.metro || !host.systemd || !asAgent) return command;
   const limit = sessionMemoryLimit(host.total);
-  return helperArgv(['as-agent-scope', String(limit), String(Math.floor(limit * 0.9)), ...args.slice(4)]);
+  return helperArgv(['as-agent-scope', String(limit), String(limit), ...args.slice(4)]);
 }

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

@@ -41,7 +41,7 @@ Keep the change to what the task asks for. A pre-existing bug, a performance pro
 
 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.
 
-Your final message is a report to the orchestrator, not a message to a human. It gets relayed onward, so make it self-contained and concise. Lead with the outcome. Include concrete evidence, command output, file paths with line numbers, test results, for anything you claim to have verified. Report failures faithfully: if a test failed, say so and show the output; if you skipped a step, say that too.
+Your final message is a report to the orchestrator, not a message to a human. It stays in the orchestrator's context for the rest of the conversation and makes every later answer slower, so keep it short: about 150 words at most, self-contained. Lead with the outcome, then the key evidence for what you claim to have verified, such as the test result or the file you changed. Put anything longer, such as full logs, tables or detailed findings, in a file under ~/work and give its path. Report failures faithfully: if a test failed, say so with its key line of output; if you skipped a step, say that too.
 `;
 
 export interface SetupDeps {
@@ -129,7 +129,10 @@ export function setSystemPrompt(text: string, agents = agentsDir()): void {
   writeAtomic(promptPath(agents), `${trimmed}\n`, 0o600);
 }
 
-const PRIOR_WORKER: ReadonlySet<string> = new Set(['08a0cd8710df285d6512245246bb8b658b7cfc7f3e89490514ee5376779eb2ef']);
+const PRIOR_WORKER: ReadonlySet<string> = new Set([
+  '08a0cd8710df285d6512245246bb8b658b7cfc7f3e89490514ee5376779eb2ef',
+  '9db999a7bb7cf1d6c12a679520e21c78d038999d5454d7abbc6b87a87c136c54',
+]);
 const PRIOR_METRO: ReadonlySet<string> = new Set([
   '0b3d122ed95beff09d579cf912cd4238e1db524c41fce4b314de57d6ff5908ad',
   '36f4fb57f231a119d717b5e3d6ccb654f94960fcca708683f376679aead8df25',
@@ -142,6 +145,7 @@ const PRIOR_METRO: ReadonlySet<string> = new Set([
   '256c711a6175266c216e32c88b7190d0f98f5e6b702abe03220b422aba426574',
   '9e164a956437d60d30ea1984115a17d303940d191f5efed04954f244fc89d48f',
   '8b6d7c5a9bc8d02d5e3ae5e5931b36aba9f3d0eb7fd38b371294c2abaa0c94ee',
+  '8b8f21cb1b7608540d8b5ed9557e1644b03ce4809a7f320ba134f28129f08ddb',
 ]);
 const PRIOR_STAGE: ReadonlySet<string> = new Set([
   'dd7d30474765de3865ddc87c1cf3220161ded09502027cdff18597e5df0aab43',

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

@@ -0,0 +1,73 @@
+import { createReadStream, existsSync, readdirNames } from '../agent-user/agent-fs.js';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { isRecord } from '@metro-labs/core/is-record';
+import { cap, claudeDir, INPUT_CAP, parseLines, projectDir, PROJECT_RE, RESULT_CAP, resultText, safeName, SESSION_RE, str } from './files.js';
+
+const TOOL_USE_RE = /^[A-Za-z0-9_-]{1,128}$/;
+
+export interface ToolCall {
+  name: string;
+  input: string;
+  result: string | null;
+  isError: boolean;
+  calledAt: string | null;
+  answeredAt: string | null;
+}
+
+function transcriptFiles(root: string, session: string): string[] {
+  const workers = join(root, session, 'subagents');
+  const extra = existsSync(workers) ? readdirNames(workers).filter((name) => name.endsWith('.jsonl')).map((name) => join(workers, name)) : [];
+  return [join(root, `${session}.jsonl`), ...extra].filter((path) => existsSync(path));
+}
+
+function noteBlock(found: Partial<ToolCall>, block: unknown, toolUse: string, at: string | null): void {
+  if (!isRecord(block)) return;
+  if (block.type === 'tool_use' && block.id === toolUse) {
+    found.name = str(block.name) ?? 'tool';
+    found.input = cap(JSON.stringify(block.input ?? {}, null, 1), INPUT_CAP);
+    found.calledAt = at;
+  }
+  if (block.type === 'tool_result' && block.tool_use_id === toolUse) {
+    found.result = cap(resultText(block.content), RESULT_CAP);
+    found.isError = block.is_error === true;
+    found.answeredAt = at;
+  }
+}
+
+async function scanForCall(path: string, toolUse: string): Promise<Partial<ToolCall>> {
+  const found: Partial<ToolCall> = {};
+  const lines = createInterface({ input: createReadStream(path), crlfDelay: Infinity });
+  for await (const line of lines) {
+    if (!line.includes(toolUse)) continue;
+    const parsed = parseLines(line)[0];
+    const content = parsed !== undefined && isRecord(parsed.message) ? parsed.message.content : null;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) noteBlock(found, block, toolUse, str(parsed?.timestamp));
+    if (found.name !== undefined && found.result !== undefined) break;
+  }
+  return found;
+}
+
+function projectHolding(session: string, dir: string): string | null {
+  const root = join(dir, 'projects');
+  if (!existsSync(root)) return null;
+  return readdirNames(root).find((name) => PROJECT_RE.test(name) && existsSync(join(root, name, `${session}.jsonl`))) ?? null;
+}
+
+function completed(name: string, found: Partial<ToolCall>): ToolCall {
+  return { name, input: found.input ?? '{}', result: found.result ?? null, isError: found.isError ?? false, calledAt: found.calledAt ?? null, answeredAt: found.answeredAt ?? null };
+}
+
+export async function readToolCall(project: string | null, session: string, toolUse: string, dir = claudeDir()): Promise<ToolCall | null> {
+  const id = safeName(session, SESSION_RE, 'session id');
+  const holder = project ?? projectHolding(id, dir);
+  if (holder === null) return null;
+  const root = projectDir(holder, dir);
+  const wanted = safeName(toolUse, TOOL_USE_RE, 'tool call id');
+  for (const path of transcriptFiles(root, id)) {
+    const found = await scanForCall(path, wanted);
+    if (found.name !== undefined) return completed(found.name, found);
+  }
+  return null;
+}

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

@@ -87,9 +87,11 @@ async function relay(req: IncomingMessage, res: ServerResponse, path: string, de
     sendError(res, 503, 'api_error', NOT_ACCEPTED);
     return;
   }
-  await pipeResponse(upstream, res, watch);
+  await pipeResponse(upstream, res, watch, { site: RELAY_SITE });
 }
 
+const RELAY_SITE = { connection: 'gateway.metro.box', model: 'relayed' };
+
 function refusal(req: IncomingMessage, path: string, deps: RelayDeps): [number, string, string] | null {
   if (cameThroughProxy(req)) return [401, 'authentication_error', 'metro gateway: the agent key works only on this machine, not through its public address'];
   if (keyOf(req) === '' || !deps.identify(keyOf(req))) return [401, 'authentication_error', 'metro gateway: no agent key (x-metro-key); start the agent with metro agent'];

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

@@ -15,6 +15,7 @@ import {
 } from './helper-script.js';
 import { AGENT_NAME } from '../agent-user/user.js';
 import { hardenTailscale } from './tailscale-guard.js';
+import { liftSessionSoftLimits } from './session-scopes.js';
 
 interface InstallPaths {
   helper: string;
@@ -73,7 +74,7 @@ if (import.meta.main) {
   installRootHelper();
   installImdsGuard();
   installUpgradeUnit(node);
-  for (const note of hardenTailscale()) process.stderr.write(`metro: ${note}\n`);
+  for (const note of [...hardenTailscale(), ...liftSessionSoftLimits()]) process.stderr.write(`metro: ${note}\n`);
   process.stdout.write(
     `metro: wrote ${HELPER_PATH}, ${SUDOERS_PATH}, ${IMDS_UNIT_PATH} and ${UPGRADE_UNIT_PATH}; only root and metro reach the instance metadata service, and the root side follows every update\n`,
   );

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

@@ -0,0 +1,25 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const SYSTEM_SLICE = '/sys/fs/cgroup/system.slice';
+const SESSION_SCOPE = /^metro-claude-\d+\.scope$/;
+
+type Run = (file: string, args: string[]) => boolean;
+
+const quiet: Run = (file, args) => spawnSync(file, args, { stdio: 'ignore' }).status === 0;
+
+const softLimit = (dir: string): string | null => {
+  const path = join(dir, 'memory.high');
+  return existsSync(path) ? readFileSync(path, 'utf8').trim() : null;
+};
+
+export function liftSessionSoftLimits(run: Run = quiet, slice: string = SYSTEM_SLICE): string[] {
+  if (!existsSync(slice)) return [];
+  const held = readdirSync(slice).filter((name) => SESSION_SCOPE.test(name) && ![null, 'max'].includes(softLimit(join(slice, name))));
+  return held.map((scope) =>
+    run('systemctl', ['set-property', '--runtime', scope, 'MemoryHigh=infinity'])
+      ? `${scope}: its soft memory limit is lifted, so only the hard limit applies`
+      : `${scope}: its soft memory limit could not be lifted; it goes when the session starts again`,
+  );
+}

package/runtime/node_modules/@metro-labs/http/src/connector-oauth.ts

@@ -27,6 +27,21 @@ function challengeOf(verifier: string): string {
   return createHash('sha256').update(verifier).digest('base64url');
 }
 
+const REASON_MAX = 600;
+
+function oneLine(value: unknown): string {
+  if (typeof value !== 'string') return '';
+  const printable = Array.from(value, (char) => (char < ' ' || char === '\u007f' ? ' ' : char)).join('');
+  const text = printable.replace(/\s+/g, ' ').trim();
+  return text.length > REASON_MAX ? `${text.slice(0, REASON_MAX - 1)}…` : text;
+}
+
+function registrationReason(body: unknown): string {
+  if (!isRecord(body)) return '.';
+  const reason = oneLine(body.error_description) || oneLine(body.error);
+  return reason === '' ? '.' : `: ${reason}`;
+}
+
 export async function registerClient(
   server: OAuthServer,
   redirectUri: string,
@@ -58,7 +73,7 @@ export async function registerClient(
   }
   const body: unknown = await res.json().catch(() => null);
   if (!res.ok || !isRecord(body) || typeof body.client_id !== 'string')
-    throw refused('That server refused to register Metro as a client.');
+    throw refused(`That server refused to register Metro as a client${registrationReason(body)}`);
   const secret = body.client_secret;
   return {
     clientId: body.client_id,

package/runtime/node_modules/@metro-labs/inference/src/failures.ts

@@ -34,14 +34,27 @@ export function noteFailure(site: FailureSite, failure: Failure, what: string):
   log.warn({ connection: site.connection, model: site.model, ...failure, message: providerText(failure.message) }, what);
 }
 
+const STOP_DATA = /^\{\s*"type"\s*:\s*"message_stop"/;
+
 export class StreamErrors {
   private readonly parser = new SseParser();
+  private ended = false;
 
   constructor(private readonly site: FailureSite) {}
 
+  get settled(): boolean {
+    return this.ended;
+  }
+
+  cut(): void {
+    noteFailure(this.site, { code: 'stream_cut', message: '' }, 'gateway: the provider ended its stream before the answer was complete');
+  }
+
   feed(text: string): void {
     for (const raw of this.parser.push(text)) {
+      if (raw.event === 'message_stop' || STOP_DATA.test(raw.data)) this.ended = true;
       if (raw.event !== 'error' && !ERROR_DATA.test(raw.data)) continue;
+      this.ended = true;
       const data = parseEvent(raw)?.data ?? {};
       const error = isRecord(data.error) ? data.error : {};
       noteFailure(this.site, { code: stringOf(error.type) || stringOf(error.code), message: stringOf(error.message) }, 'gateway: the provider sent an error in the middle of its stream');

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

@@ -171,16 +171,30 @@ function openResponse(upstream: Response, res: ServerResponse, opts: PipeOptions
 
 type Tap = (chunk: Uint8Array) => void;
 
-function tapOf(opts: PipeOptions, streaming: boolean): Tap | null {
+interface Tapped {
+  tap: Tap | null;
+  errors: StreamErrors | null;
+}
+
+function tapOf(opts: PipeOptions, streaming: boolean): Tapped {
   const scanner = opts.scanner;
   const errors = streaming && opts.site !== undefined ? new StreamErrors(opts.site) : null;
-  if (scanner === undefined && errors === null) return null;
+  if (scanner === undefined && errors === null) return { tap: null, errors };
   const decoder = new TextDecoder();
-  return (chunk) => {
+  const tap: Tap = (chunk) => {
     const text = decoder.decode(chunk, { stream: true });
     scanner?.feed(text);
     errors?.feed(text);
   };
+  return { tap, errors };
+}
+
+const CUT_MESSAGE = 'metro gateway: the provider ended its stream before the answer was complete; try again';
+
+function closeCut(res: ServerResponse, errors: StreamErrors | null): void {
+  if (errors === null || errors.settled || res.writableEnded) return;
+  errors.cut();
+  res.write(errorFrame('api_error', CUT_MESSAGE));
 }
 
 async function pump(body: ReadableStream<Uint8Array>, res: ServerResponse, watch: Watch, tap: Tap | null): Promise<void> {
@@ -202,10 +216,15 @@ export async function pipeResponse(upstream: Response, res: ServerResponse, watc
     return;
   }
   const ping = opts.keepalive === true && streaming ? setInterval(() => res.write(PING_FRAME), PING_MS) : null;
+  const { tap, errors } = tapOf(opts, streaming);
   try {
-    await pump(body, res, watch, tapOf(opts, streaming));
+    await pump(body, res, watch, tap);
+    closeCut(res, errors);
   } catch (err) {
-    if (!watch.idle()) throw err;
+    if (!watch.idle()) {
+      closeCut(res, errors);
+      throw err;
+    }
     if (streaming) res.write(errorFrame('api_error', idleMessage(watch.ms)));
   } finally {
     if (ping !== null) clearInterval(ping);

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.327"
+  "version": "0.1.0-beta.329"
 }

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.327",
+  "version": "0.1.0-beta.329",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "@modelcontextprotocol/sdk": "^1.29.0",

package/runtime/sdk-runner/src/app.ts

@@ -63,7 +63,7 @@ async function connected(cfg: RunnerConfig, hooks: AppHooks, release: () => Prom
     tools = metroTools(link);
     const resume = store.resumable();
     log.info({ resume, model: cfg.model, mode: cfg.permissionMode }, 'sdk-runner: starting the Agent SDK session');
-    const approvals = approvalsThrough(link, (id, ask) => { hooks.activity?.approval(id, ask); }, (tool, input) => runner.calls.approval(tool, input));
+    const approvals = approvalsThrough(link, (id, ask) => { hooks.activity?.approval(id, ask); runner.approval(id, ask); }, (tool, input) => runner.calls.approval(tool, input));
     runner.start(runnerOptions(cfg, tools, approvals, resume, hooks.env));
     return { runner, link, done: runner.run(hooks.observe), stop };
   } catch (err) {

package/runtime/sdk-runner/src/runner.ts

@@ -7,7 +7,6 @@ import { isRecord } from '@metro-labs/core/is-record';
 import type { AutomationStore } from '@metro-labs/core/automation-store';
 import type { Activity } from './activity.js';
 import { Automation } from './automation.js';
-import { ActivityTasks } from './activity-tasks.js';
 import { RunnerCalls } from './calls.js';
 import { channelText, type ChannelEvent } from './channel-text.js';
 import type { RunnerConfig } from './config.js';
@@ -21,7 +20,8 @@ import { METRO_SERVER, type MetroTools } from './tool-proxy.js';
 import { debugFailure, failureSummary, SessionError, StartupDiagnostics } from './errors.js';
 
 const STARTUP_WAIT = 'CLAUDE_CODE_MCP_STARTUP_WAIT_MS';
-export const COMPACT_AT = 120_000;
+export const COMPACT_AT = 80_000;
+const URGENT_FACTOR = 1.5;
 export const COMPACT_IDLE_MS = 60_000;
 
 const MODEL_PINS: ReadonlySet<string> = new Set(['ANTHROPIC_MODEL', 'CLAUDE_CODE_SUBAGENT_MODEL']);
@@ -97,7 +97,6 @@ export class Runner {
   private readonly recovery: TaskRecovery;
   private readonly watch: SessionWatch;
   private readonly diagnostics = new StartupDiagnostics();
-  private readonly tasks = new ActivityTasks(() => undefined);
   private readonly skillWork = new SkillWork();
   private compactTimer: ReturnType<typeof setTimeout> | null = null;
   private session: Query | null = null;
@@ -108,11 +107,12 @@ export class Runner {
   private model: string | null = null;
   private switching: Promise<void> = Promise.resolve();
   private ended = false;
+  private readonly mainAsks = new Set<string>();
   private readonly interrupted: number;
   private interruptionReported = false;
 
   constructor(private readonly parts: RunnerParts) {
-    this.watch = new SessionWatch(parts.readOnly);
+    this.watch = new SessionWatch(parts.readOnly, () => this.mainAsks.size > 0);
     this.inbox = new Inbox((unanswered) => { this.keep(unanswered); }, {
       ready: () => { parts.skills?.check(); return this.watch.admitting && parts.skills?.busy !== true; },
       dispatch: (message) => { this.automation?.dispatched(message.uuid); this.watch.dispatched(message.uuid); },
@@ -167,6 +167,12 @@ export class Runner {
     return this.session;
   }
 
+  approval(id: string, ask: { worker: string | null } | null): void {
+    if (ask === null) this.mainAsks.delete(id);
+    else if (ask.worker === null) this.mainAsks.add(id);
+    this.inbox.notify();
+  }
+
   switchModel(model: string | null): Promise<void> {
     this.queueModel(model);
     return this.switching;
@@ -178,7 +184,6 @@ export class Runner {
       for await (const message of this.session) {
         if (this.ended) break;
         this.cancelCompact();
-        if (message.type === 'system') this.tasks.observe(message);
         const m: Record<string, unknown> = { ...message };
         this.recovery.observe(m);
         this.automation?.observe(m);
@@ -186,8 +191,8 @@ export class Runner {
         this.observeWork(m);
         this.note(m);
         this.parts.activity?.observe(message);
-        this.inbox.notify();
         this.maybeCompact();
+        this.inbox.notify();
         observe?.(message);
       }
     } catch (err) {
@@ -318,14 +323,19 @@ export class Runner {
     return this.ended || this.parts.skills?.busy === true || this.compactAsked !== null || !this.watch.safe || !this.watch.admitting;
   }
 
+  private get compactUrgent(): boolean {
+    return this.watch.context >= (this.parts.compactAt ?? COMPACT_AT) * URGENT_FACTOR;
+  }
+
   private compactReady(resuming = false): boolean {
-    const busy = this.maintenanceBusy || (!resuming && (this.calls.live || this.inbox.pending > 0 || this.tasks.running > 0));
+    const waiting = this.inbox.pending > 0 && !this.compactUrgent;
+    const busy = this.maintenanceBusy || (!resuming && (this.calls.live || waiting));
     return compactDue({ context: this.watch.context, floor: this.compactFloor, limit: this.parts.compactAt ?? COMPACT_AT, busy });
   }
 
   private maybeCompact(resuming = false): void {
     if (!this.compactReady(resuming)) return;
-    if (resuming) { this.askCompact(true); return; }
+    if (resuming || this.compactUrgent) { this.askCompact(resuming); return; }
     this.compactTimer = setTimeout(() => {
       this.compactTimer = null;
       if (this.compactReady()) this.askCompact(false);
@@ -335,7 +345,7 @@ export class Runner {
 
   private askCompact(resuming: boolean): void {
     this.compactAsked = this.inbox.compact();
-    log.info({ context: this.watch.context, resuming }, 'sdk-runner: compacting at a safe idle boundary');
+    log.info({ context: this.watch.context, resuming, urgent: this.compactUrgent, waiting: this.inbox.pending }, 'sdk-runner: compacting at a safe boundary');
   }
 
   private cancelCompact(): void {

package/runtime/sdk-runner/src/session-watch.ts

@@ -35,7 +35,7 @@ export class SessionWatch {
   private lastContext = 0;
   private streamUsage: Record<string, unknown> = {};
 
-  constructor(private readonly readOnly: (tool: string) => boolean) {}
+  constructor(private readonly readOnly: (tool: string) => boolean, private readonly mainAsking: () => boolean = () => true) {}
 
   get compacting(): boolean {
     return this.compactingNow;
@@ -52,7 +52,7 @@ export class SessionWatch {
   get safe(): boolean { return !this.busy && !this.writing && !this.compacting; }
 
   get admitting(): boolean {
-    return this.awaitingInput === null && !this.requiresAction && !this.compacting;
+    return this.awaitingInput === null && !(this.requiresAction && this.mainAsking()) && !this.compacting;
   }
 
   dispatched(uuid?: string): void {

package/runtime/sdk-runner/src/task-ledger.ts

@@ -1,8 +1,9 @@
 import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
 import { runnerTaskDescription } from '@metro-labs/core/runner-activity';
 import { activityName } from './activity-tasks.js';
 import type { Unanswered } from './inbox.js';
-import { pendingNotice, TASK_LIMIT, type SavedTask, type TaskReason } from './task-state.js';
+import { exhausted, pendingNotice, TASK_LIMIT, type SavedTask, type TaskReason } from './task-state.js';
 
 interface Tool { name: string; parent: string | null }
 const failed = (text: unknown): TaskReason => typeof text === 'string' && /\b429\b|rate.?limit/i.test(text.slice(0, 4_096)) ? 'rate_limit' : 'task_error';
@@ -11,6 +12,7 @@ export class TaskLedger {
   private readonly rows = new Map<string, SavedTask>();
   private readonly tools = new Map<string, Tool>();
   private readonly errors = new Map<string, TaskReason>();
+  private warned = false;
 
   constructor(tasks: SavedTask[], private readonly save: (tasks: SavedTask[], handled?: ReadonlySet<string>) => void) {
     for (const task of tasks) this.rows.set(task.id, task);
@@ -102,7 +104,8 @@ export class TaskLedger {
 
   private room(): boolean {
     if (this.rows.size < TASK_LIMIT) return true;
-    const old = this.snapshot().find((task) => task.notice === null && task.state !== 'running');
+    const rows = this.snapshot();
+    const old = rows.find((task) => task.notice === null && task.state !== 'running') ?? rows.find(exhausted);
     if (old === undefined) return false;
     this.rows.delete(old.id);
     return true;
@@ -111,12 +114,18 @@ export class TaskLedger {
   private get(id: string, now: number): SavedTask {
     const known = this.rows.get(id);
     if (known !== undefined) return known;
-    if (!this.room()) throw new Error('The saved Agent SDK task ledger is full. Handle pending recovery notices before starting more work.');
     const task: SavedTask = { id, toolUseId: null, owner: null, attempt: 0, state: 'interrupted', events: [], updatedAt: now, notice: null };
-    this.rows.set(id, task);
+    if (this.room()) this.rows.set(id, task);
+    else this.untracked();
     return task;
   }
 
+  private untracked(): void {
+    if (this.warned) return;
+    this.warned = true;
+    log.warn({ limit: TASK_LIMIT }, 'sdk-runner: the task ledger is full of running work and pending recovery notices, so new work runs without recovery tracking');
+  }
+
   private start(id: string, rawTool: unknown, event: string | null, now: number, description?: unknown): void {
     const task = this.get(id, now);
     if (task.state !== 'running') task.attempt += 1;

package/runtime/sdk-runner/src/task-recovery.ts

@@ -4,9 +4,9 @@ import type { Inbox, Unanswered, Uuid } from './inbox.js';
 import type { SessionStore } from './session-store.js';
 import { completedCommand, startedCommand, uuidsOf } from './session-watch.js';
 import { TaskLedger } from './task-ledger.js';
-import { TASK_LIMIT, type SavedTask } from './task-state.js';
+import { NOTICE_DELIVERIES, TASK_LIMIT, type SavedTask } from './task-state.js';
 
-const DELAYS = [30_000, 120_000, 300_000];
+const DELAYS = [30_000, 120_000, 300_000] as const;
 const marker = (token: string): string => `[metro-task-handled:${token}]`;
 interface Delivery { uuid: Uuid; tokens: string[]; consumed: boolean; completed?: boolean }
 
@@ -159,7 +159,7 @@ export class TaskRecovery {
 
   private eligible(task: SavedTask): boolean {
     const notice = task.notice;
-    if (notice === null || notice.deliveries >= DELAYS.length) return false;
+    if (notice === null || notice.deliveries >= NOTICE_DELIVERIES) return false;
     return ![...this.deliveries.values()].some((delivery) => delivery.completed !== true && delivery.tokens.includes(notice.token));
   }
 

package/runtime/sdk-runner/src/task-state.ts

@@ -5,6 +5,7 @@ import { activityName } from './activity-tasks.js';
 import type { Uuid } from './inbox.js';
 
 export const TASK_LIMIT = 200;
+export const NOTICE_DELIVERIES = 3;
 const STATES = ['running', 'completed', 'failed', 'stopped', 'interrupted'] as const;
 const REASONS = ['task_error', 'rate_limit', 'worker_restart', 'interrupted', 'provider_error'] as const;
 export type TaskReason = (typeof REASONS)[number];
@@ -57,6 +58,9 @@ function task(raw: unknown): raw is SavedTask {
   return integer(raw.attempt) && integer(raw.updatedAt) && STATES.some((state) => state === raw.state) && notice(raw.notice);
 }
 
+export const exhausted = (task: SavedTask): boolean =>
+  task.state !== 'running' && task.notice !== null && task.notice.deliveries >= NOTICE_DELIVERIES && task.notice.offered === undefined;
+
 export const sdkTask = (task: SavedTask): boolean => !/^(?:input|turn):/.test(task.id);
 
 export function savedTasks(raw: unknown): SavedTask[] {

package/skills/METRO.md

@@ -22,7 +22,7 @@ You are the main thread of a Claude Code session that is connected to chat throu
 1. `tool_search` finds a tool and returns its full definition: `select:notion.search` for an exact name, words (`notion create page`) to rank, or `+linear issue` to require `linear` in the name. Each name is `<connector>.<tool>`.
 2. `tool_call` runs it, with the name exactly as found and arguments that match its schema. After `tool_search` with `select:notion.search` returned `notion.search`: `{"calls": [{"tool": "notion.search", "arguments": {"query": "roadmap"}}]}`.
 
-Put up to 10 independent calls in one `tool_call`; they run in parallel and come back in order, each under `[n] <tool>`. `tool_search` may run on this thread, but never call `tool_call` here: delegate it to a worker, as all other work. 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 repeat the same call with `"approval": "<id>"` added to it.
+Put up to 10 independent calls in one `tool_call`; they run in parallel and come back in order, each under `[n] <tool>`. Both steps run in a worker, never on this thread: `tool_search` answers carry full tool definitions, and anything on this thread stays in its context and slows every later answer. 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 repeat the same call with `"approval": "<id>"` added to it.
 
 **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.
 
@@ -30,6 +30,6 @@ The exception is a person describing a problem, asking a question or thinking ou
 
 **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.
+**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. Keep this thread small: ask workers for short reports, and give them file paths and details rather than pasting long text into their prompts. 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.