@stage-labs/metro 0.1.0-beta.315 → 0.1.0-beta.317

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.315",
+  "version": "0.1.0-beta.317",
   "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/core/package.json

@@ -19,12 +19,14 @@
     "./trains/protocol": "./src/protocol.ts",
     "./ids": "./src/ids.ts",
     "./claude-token": "./src/claude-token.ts",
+    "./effort": "./src/effort.ts",
     "./tickets": "./src/tickets.ts",
     "./station-names": "./src/station-names.ts",
     "./str": "./src/str.ts",
     "./lines": "./src/lines.ts",
     "./endpoints": "./src/endpoints.ts",
     "./stations/types": "./src/stations/types.ts",
+    "./stations/account-status": "./src/stations/account-status.ts",
     "./stations/channel-directory": "./src/stations/channel-directory.ts",
     "./stations/channel-pages": "./src/stations/channel-pages.ts",
     "./stations/account-files": "./src/stations/account-files.ts",

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

@@ -0,0 +1,21 @@
+import { isRecord } from './is-record.js';
+
+export const EFFORT_LEVELS = ['low', 'medium', 'high', 'max', 'asked'] as const;
+
+export type EffortLevel = (typeof EFFORT_LEVELS)[number];
+
+export interface RouteEffort {
+  main?: EffortLevel;
+  helpers?: EffortLevel;
+}
+
+export const EFFORT_DEFAULTS: Required<RouteEffort> = { main: 'low', helpers: 'max' };
+
+export const isEffortLevel = (value: unknown): value is EffortLevel => typeof value === 'string' && (EFFORT_LEVELS as readonly string[]).includes(value);
+
+export function readEffort(raw: unknown): RouteEffort {
+  if (!isRecord(raw)) return {};
+  return { ...(isEffortLevel(raw.main) ? { main: raw.main } : {}), ...(isEffortLevel(raw.helpers) ? { helpers: raw.helpers } : {}) };
+}
+
+export const effortSet = (effort: RouteEffort): boolean => effort.main !== undefined || effort.helpers !== undefined;

package/runtime/node_modules/@metro-labs/core/src/stations/account-status.ts

@@ -0,0 +1,26 @@
+import { isRecord } from '../is-record.js';
+
+export const ACCOUNT_STATES = ['connected', 'connecting', 'logged_out', 'disconnected'] as const;
+
+export type AccountState = (typeof ACCOUNT_STATES)[number];
+
+export interface AccountStatus {
+  state: AccountState;
+  reason?: string;
+  since: number;
+}
+
+const REASON_MAX = 300;
+
+export function accountStatus(state: AccountState, reason?: string, since = Date.now()): AccountStatus {
+  const text = reason?.trim().slice(0, REASON_MAX) ?? '';
+  return text === '' ? { state, since } : { state, reason: text, since };
+}
+
+export function accountStatusOf(raw: unknown): AccountStatus | null {
+  if (!isRecord(raw)) return null;
+  const state = ACCOUNT_STATES.find((s) => s === raw.state);
+  const since = raw.since;
+  if (state === undefined || typeof since !== 'number' || !Number.isFinite(since)) return null;
+  return accountStatus(state, typeof raw.reason === 'string' ? raw.reason : undefined, since);
+}

package/runtime/node_modules/@metro-labs/core/src/stations/types.ts

@@ -114,6 +114,8 @@ export interface Station {
   readFilters?: ReadonlySet<ReadFilter>;
   approvals?: boolean;
   sendsFrames?: boolean;
+  reportsStatus?: boolean;
+  pairAgain?: { identity: string };
   attachmentMode: AttachmentMode;
   forget?: (accountId: string) => void;
   forgetExcept?: (keptAccountIds: readonly string[]) => void;

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

@@ -13,6 +13,7 @@ export type AccountRoute =
   | { kind: 'enabled'; station: StationName; accountId: string }
   | { kind: 'policy'; station: StationName; accountId: string }
   | { kind: 'profiles'; station: StationName; accountId: string }
+  | { kind: 'repair'; station: StationName; accountId: string }
   | { kind: 'name'; station: StationName; accountId: string };
 
 const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
@@ -26,10 +27,11 @@ const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
   enabled: ['PUT'],
   policy: ['PUT'],
   profiles: ['GET'],
+  repair: ['POST'],
   name: ['GET', 'POST'],
 };
 
-const SUB_ROUTES = ['allowlist', 'senders', 'resolve', 'enabled', 'name', 'policy', 'profiles'] as const;
+const SUB_ROUTES = ['allowlist', 'senders', 'resolve', 'enabled', 'name', 'policy', 'profiles', 'repair'] as const;
 
 type SubRoute = (typeof SUB_ROUTES)[number];
 

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

@@ -37,6 +37,7 @@ interface AttachSessionApi {
     owner: AttachOwner,
     station: InteractiveStation,
     input: Record<string, unknown>,
+    repair?: string,
   ) => Promise<AttachView>;
   view: (owner: AttachOwner, attachId: string) => AttachView;
   submit: (
@@ -315,16 +316,36 @@ async function handleStep(
   sendJson(req, res, 200, view);
 }
 
+async function handleRepair(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AccountApiDeps,
+  owner: AttachOwner,
+  target: { station: StationName; accountId: string },
+): Promise<void> {
+  const { station, accountId } = target;
+  if (!isInteractiveStation(station) || stationByName(station)?.pairAgain === undefined)
+    throw new ApiError(`${station} cannot pair again`, 400);
+  const view = await deps.attachSessions.start(owner, station, asInput(await readJsonBody(req)), accountId);
+  sendJson(req, res, 201, view);
+}
+
+type AttachRoute = Extract<AccountRoute, { kind: 'start' | 'session' | 'step' | 'repair' }>;
+
+const isAttachRoute = (route: AccountRoute): route is AttachRoute =>
+  route.kind === 'start' || route.kind === 'session' || route.kind === 'step' || route.kind === 'repair';
+
 async function dispatchAttach(
   req: IncomingMessage,
   res: ServerResponse,
   deps: AccountApiDeps,
   agentId: string,
-  route: Extract<AccountRoute, { kind: 'start' | 'session' | 'step' }>,
+  route: AttachRoute,
   session?: ApiSession,
 ): Promise<void> {
   const owner: AttachOwner = { agentId, organization: session?.subject, userId: session?.userId, sessionId: session?.sessionId, authorization: req.headers.authorization };
   if (route.kind === 'start') return handleStart(req, res, deps, agentId, owner);
+  if (route.kind === 'repair') return handleRepair(req, res, deps, owner, route);
   if (route.kind === 'session') return handleSession(req, res, deps, owner, route.attachId);
   return handleStep(req, res, deps, owner, route.attachId);
 }
@@ -337,7 +358,7 @@ async function dispatchRoute(
   route: AccountRoute,
   session?: ApiSession,
 ): Promise<void> {
-  if (route.kind === 'start' || route.kind === 'session' || route.kind === 'step') return dispatchAttach(req, res, deps, agentId, route, session);
+  if (isAttachRoute(route)) return dispatchAttach(req, res, deps, agentId, route, session);
   if (route.kind === 'allowlist') return handleAllowlist(req, res, deps, agentId, route);
   if (route.kind === 'enabled') return handleEnabled(req, res, deps, agentId, route);
   if (route.kind === 'policy') return handlePolicy(req, res, deps, agentId, route);

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

@@ -13,6 +13,7 @@ import {
   type AccountRoute,
 } from './account-routes.js';
 import type { AgentSummary } from './admin.js';
+import { pairAgainStations, statusStations } from '../stations/registry.js';
 
 const PREFIX = '/api/agents';
 
@@ -70,6 +71,8 @@ async function handleList(
     capabilities: deps.capabilities(),
     features: deps.features ?? [],
     attachable: deps.attachable ?? ATTACHABLE,
+    reportsStatus: statusStations(),
+    pairAgain: pairAgainStations(),
     ...(deps.toolGroups === undefined ? {} : { tools: deps.toolGroups() }),
   };
   if (!wantsAccounts(req)) {

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

@@ -210,6 +210,23 @@ export function localRenewGmail(agentId: string, accountId: string, previous: st
   return { agentId, station: 'gmail', accountId };
 }
 
+const sameIdentity = (a: unknown, b: unknown): boolean =>
+  typeof a === 'string' && typeof b === 'string' && a.replace(/[\s()+-]/g, '').toLowerCase() === b.replace(/[\s()+-]/g, '').toLowerCase();
+
+const shownIdentity = (value: unknown): string => (typeof value === 'string' && value !== '' ? value : 'unknown');
+
+export function localPairAgain(agentId: string, station: StationName, accountId: string, identity: string, config: Record<string, unknown>, dir = agentsDir()): AccountRef {
+  const stored = agentOrThrow(agentId, dir);
+  const account = stored.file.stations.find((s) => s.station === station && s.id === accountId);
+  if (account === undefined) throw new AgentAdminError('This channel is gone. Nothing was changed.', 404);
+  const before = account.config[identity];
+  const after = config[identity];
+  if (!sameIdentity(before, after)) throw new AgentAdminError(`This channel is ${shownIdentity(before)}, not ${shownIdentity(after)}. Nothing was changed.`, 400);
+  account.config = { ...account.config, ...config };
+  save(stored);
+  return { agentId, station, accountId };
+}
+
 export function readLocalAgentFile(agentId: string, dir = agentsDir()): AgentFile {
   const found = storedAgents(dir).find((s) => s.file.id === agentId);
   if (found === undefined) throw missing();

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

@@ -1,9 +1,12 @@
+import { readEffort, type RouteEffort } from '@metro-labs/core/effort';
 import { isRecord } from '@metro-labs/core/is-record';
-import { isProvider, type Account, type CodexAccess, type Connection, type Fallback, type Provider, type RouteSource } from './model-config.js';
+import { isProvider, type Account, type Chain, type CodexAccess, type Connection, type Fallback, type Provider, type RouteSource } from './model-config.js';
 
 export interface DeliveredRoute {
   primary: Fallback | null;
   fallbacks: Fallback[];
+  helpers: Chain | null;
+  effort: RouteEffort;
 }
 
 export interface Delivered {
@@ -24,10 +27,20 @@ function refOf(raw: unknown): Fallback | null {
   return ref.connection === '' ? null : ref;
 }
 
+function fallbacksOf(raw: Record<string, unknown>): Fallback[] {
+  const fallbacks = Array.isArray(raw.fallbacks) ? raw.fallbacks.flatMap((f: unknown) => refOf(f) ?? []) : [];
+  return fallbacks.filter((f) => f.model !== '').slice(0, MAX_FALLBACKS);
+}
+
+function helpersOf(raw: unknown): Chain | null {
+  if (!isRecord(raw)) return null;
+  const primary = refOf(raw.primary);
+  return primary === null ? null : { primary, fallbacks: fallbacksOf(raw) };
+}
+
 function routeOf(raw: unknown): DeliveredRoute | null {
   if (!isRecord(raw)) return null;
-  const fallbacks = Array.isArray(raw.fallbacks) ? raw.fallbacks.flatMap((f: unknown) => refOf(f) ?? []) : [];
-  return { primary: refOf(raw.primary), fallbacks: fallbacks.filter((f) => f.model !== '').slice(0, MAX_FALLBACKS) };
+  return { primary: refOf(raw.primary), fallbacks: fallbacksOf(raw), helpers: helpersOf(raw.helpers), effort: readEffort(raw.effort) };
 }
 
 function accountOf(raw: unknown): Account {

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

@@ -6,7 +6,7 @@ import { deliveredSetup, type OrgModels } from './org-models.js';
 export function setupOf(delivered: Delivered | null): ModelSetup {
   const route = delivered?.route ?? null;
   if (delivered === null || route === null) return { ...emptySetup(), source: delivered?.source ?? null };
-  return { primary: route.primary, fallbacks: route.fallbacks, connections: delivered.connections, source: delivered.source };
+  return { primary: route.primary, fallbacks: route.fallbacks, connections: delivered.connections, source: delivered.source, helpers: route.helpers, effort: route.effort };
 }
 
 export const effectiveSetup = (delivered: Delivered | null = deliveredSetup()): ModelSetup => setupOf(delivered);

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

@@ -1,8 +1,7 @@
 import type { IncomingMessage } from 'node:http';
+import { EFFORT_DEFAULTS, type RouteEffort } from '@metro-labs/core/effort';
 import { isRecord } from '@metro-labs/core/is-record';
 
-const MAIN_EFFORT = 'low';
-const SUBAGENT_EFFORT = 'max';
 export const BINDING_BETA = 'thinking-binding-controls-2026-08-01';
 
 const SUBAGENT_HEADER = 'x-claude-code-agent-id';
@@ -42,12 +41,13 @@ const messagesOf = (body: Body): unknown[] => (Array.isArray(body.messages) ? bo
 
 const askedEfforts = (body: Body): string[] => [body, ...messagesOf(body).map(record)].map(effortOf).filter((effort) => effort !== '');
 
-export function plannedEffort(req: IncomingMessage, body: Body): string | null {
+export function plannedEffort(req: IncomingMessage, body: Body, setting: RouteEffort = {}): string | null {
   const asked = askedEfforts(body);
   if (asked.length === 0) return null;
   const kind = requestKind(req, body);
   if (kind === 'other') return null;
-  const wanted = kind === 'subagent' ? SUBAGENT_EFFORT : MAIN_EFFORT;
+  const wanted = kind === 'subagent' ? (setting.helpers ?? EFFORT_DEFAULTS.helpers) : (setting.main ?? EFFORT_DEFAULTS.main);
+  if (wanted === 'asked') return null;
   return asked.every((effort) => effort === wanted) ? null : wanted;
 }
 

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

@@ -18,14 +18,16 @@ interface Cooling {
   reason: string;
 }
 
+export type Lane = 'main' | 'helpers';
+
 const cooling = new Map<string, Cooling>();
-let lastChoice = '';
+const lastChoice = new Map<Lane, string>();
 
 const keyOf = (route: Route): string => `${route.connection.id}\n${route.model}`;
 
 export function forgetFallbackState(): void {
   cooling.clear();
-  lastChoice = '';
+  lastChoice.clear();
 }
 
 function scopeOf(label: string): string | null {
@@ -96,18 +98,18 @@ export function noteRefused(route: Route, status: number, headers: Headers, next
   log.warn({ from: routeLabel(route), to: next === undefined ? null : routeLabel(next), status }, why);
 }
 
-export function noteChoice(primary: Route, chosen: Route, now = Date.now()): void {
+export function noteChoice(primary: Route, chosen: Route, lane: Lane, now = Date.now()): void {
   const key = keyOf(chosen);
-  if (key === lastChoice) return;
-  const first = lastChoice === '';
-  lastChoice = key;
+  const last = lastChoice.get(lane);
+  if (key === last) return;
+  lastChoice.set(lane, key);
   if (key === keyOf(primary)) {
-    if (!first) log.info({ model: routeLabel(chosen), connection: chosen.connection.label }, 'gateway: back on the first model of the fallback list');
+    if (last !== undefined) log.info({ lane, model: routeLabel(chosen), connection: chosen.connection.label }, 'gateway: back on the first model of the fallback list');
     return;
   }
   const hold = holdOf(primary, now);
   log.info(
-    { from: routeLabel(primary), to: routeLabel(chosen), connection: chosen.connection.label, reason: hold?.reason ?? null, until: hold?.until ?? null },
+    { lane, from: routeLabel(primary), to: routeLabel(chosen), connection: chosen.connection.label, reason: hold?.reason ?? null, until: hold?.until ?? null },
     'gateway: the first model is over its limit, so requests go to a fallback model',
   );
 }

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

@@ -26,7 +26,7 @@ import {
   type Watch,
   type Refusal,
 } from './forward.js';
-import { chainOf, forgetFallbackState, noteChoice, noteRefused, routesToTry } from './fallback.js';
+import { chainOf, forgetFallbackState, noteChoice, noteRefused, routesToTry, type Lane } from './fallback.js';
 import {
   BINDING_BETA,
   cappedEffort,
@@ -34,12 +34,13 @@ import {
   forgetLearnedThinking,
   learnAlwaysThinks,
   plannedEffort,
+  requestKind,
   thinkingOff,
   withBlockBinding,
   withEffort,
   withThinkingFor,
 } from './effort.js';
-import { notReady, resolveRoute, routeLabel, type Connection, type ModelSetup, type Route } from './model-config.js';
+import { helperSetup, notReady, pinnedRoute, resolveRoute, routeLabel, type Connection, type ModelSetup, type Route } from './model-config.js';
 import { codexMessages, type CodexDeps } from './codex.js';
 import { countTokens } from './subscription.js';
 import { OPENROUTER_BASE } from './openrouter.js';
@@ -241,11 +242,23 @@ async function toCodex(req: IncomingMessage, res: ServerResponse, path: string,
   else await codexMessages(req, res, body, route.model, route.connection, { refresh: refreshCodex, ...deps.codex }, watchUpstream(res));
 }
 
-function shapedFor(req: IncomingMessage, sent: Record<string, unknown>): Record<string, unknown> {
-  const effort = plannedEffort(req, sent);
+function shapedFor(req: IncomingMessage, sent: Record<string, unknown>, setup: ModelSetup): Record<string, unknown> {
+  const effort = plannedEffort(req, sent, setup.effort);
   return effort === null ? sent : withEffort(sent, effort);
 }
 
+interface Chosen {
+  lane: Lane;
+  setup: ModelSetup;
+  primary: Route;
+}
+
+function chosenChain(req: IncomingMessage, sent: Record<string, unknown>, setup: ModelSetup, requested: string): Chosen {
+  const helpers = requestKind(req, sent) === 'subagent' ? helperSetup(setup) : null;
+  if (helpers === null) return { lane: 'main', setup, primary: resolveRoute(requested, setup) ?? noRoute() };
+  return { lane: 'helpers', setup: helpers, primary: pinnedRoute(requested, helpers) ?? noRoute() };
+}
+
 const bytesOf = (raw: Buffer, parsed: Record<string, unknown>, sent: Record<string, unknown>): Buffer => (sent === parsed ? raw : Buffer.from(JSON.stringify(sent)));
 
 interface Request {
@@ -299,12 +312,12 @@ async function dispatch(req: IncomingMessage, res: ServerResponse, path: string,
   const parsed = parseJson(raw);
   const sent = fitToolSearch(req, parsed);
   const requested = requestedModel(sent);
-  const primary = resolveRoute(requested, setup) ?? noRoute();
-  const ask: Request = { path, raw, parsed, sent, body: shapedFor(req, sent), setup };
-  const routes = routesToTry(chainOf(primary, setup, requested));
+  const { lane, setup: chain, primary } = chosenChain(req, sent, setup, requested);
+  const ask: Request = { path, raw, parsed, sent, body: shapedFor(req, sent, setup), setup };
+  const routes = routesToTry(chainOf(primary, chain, requested));
   for (const [at, route] of routes.entries()) {
     const next = routes[at + 1];
-    if (path === MESSAGES) noteChoice(primary, route);
+    if (path === MESSAGES) noteChoice(primary, route, lane);
     if (next === undefined) {
       await attempt(req, res, ask, route, deps);
       return;

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

@@ -1,9 +1,10 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import { EFFORT_DEFAULTS } from '@metro-labs/core/effort';
 import { ApiError } from '@metro-labs/http/api-error';
 import { apiFailure, apiSession, cors, sendJson } from '@metro-labs/http/api-http';
 import { effectiveSetup } from './effective.js';
 import { chainStatus } from './fallback.js';
-import { notReady, primaryRoute, type Connection, type ModelSetup } from './model-config.js';
+import { helperSetup, notReady, primaryRoute, type Connection, type ModelSetup } from './model-config.js';
 import { orgModels, type SyncStatus } from './org-models.js';
 import { lastServed } from './served.js';
 import { refreshUsage, type UsageDeps } from './usage-refresh.js';
@@ -41,6 +42,13 @@ function publicConnection(c: Connection): Record<string, unknown> {
 
 const setupOf = (deps: ModelApiDeps): ModelSetup => (deps.setup ?? (() => effectiveSetup()))();
 
+function helpersBody(setup: ModelSetup): Record<string, unknown> | null {
+  const helpers = helperSetup(setup);
+  if (helpers === null) return null;
+  const primary = primaryRoute(helpers);
+  return { route: primary?.connection.id ?? '', model: primary?.model ?? '', fallbacks: helpers.fallbacks, chain: chainStatus(helpers) };
+}
+
 export function settingsBody(deps: ModelApiDeps): Record<string, unknown> {
   const setup = setupOf(deps);
   const primary = primaryRoute(setup);
@@ -55,6 +63,8 @@ export function settingsBody(deps: ModelApiDeps): Record<string, unknown> {
     connections: setup.connections.map(publicConnection),
     fallbacks: setup.fallbacks,
     chain: chainStatus(setup),
+    helpers: helpersBody(setup),
+    effort: { ...EFFORT_DEFAULTS, ...setup.effort },
     lastServed: lastServed(),
     usage: usageSeen(),
   };

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

@@ -1,3 +1,5 @@
+import type { RouteEffort } from '@metro-labs/core/effort';
+
 export const PROVIDERS = ['anthropic', 'bedrock', 'openrouter', 'codex', 'routeway'] as const;
 export type Provider = (typeof PROVIDERS)[number];
 export type CodexMethod = 'chatgpt' | 'code';
@@ -36,11 +38,18 @@ export interface Fallback {
   model: string;
 }
 
+export interface Chain {
+  primary: Fallback;
+  fallbacks: Fallback[];
+}
+
 export interface ModelSetup {
   primary: Fallback | null;
   fallbacks: Fallback[];
   connections: Connection[];
   source: RouteSource | null;
+  helpers?: Chain | null;
+  effort?: RouteEffort;
 }
 
 export interface Route {
@@ -119,6 +128,19 @@ export function resolveRoute(requested: string, setup: ModelSetup): Route | null
   return { connection: primary.connection, model: DEFAULTS[primary.connection.provider](bareModel(requested), primary.model) };
 }
 
+export function pinnedRoute(requested: string, setup: ModelSetup): Route | null {
+  const primary = primaryRoute(setup);
+  if (primary === null) return null;
+  const bare = bareModel(requested);
+  const passes = primary.connection.provider === 'anthropic' && (primary.model === '' || isSmallModel(bare));
+  return passes ? { connection: primary.connection, model: bare } : primary;
+}
+
+export function helperSetup(setup: ModelSetup): ModelSetup | null {
+  const helpers = setup.helpers ?? null;
+  return helpers === null ? null : { ...setup, primary: helpers.primary, fallbacks: helpers.fallbacks, helpers: null };
+}
+
 export const routeLabel = (route: Route): string =>
   route.connection.provider === 'anthropic' ? route.model : `${route.connection.provider}:${route.model}`;
 

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

@@ -42,7 +42,7 @@ export async function refreshUsage(setup: ModelSetup, deps: UsageDeps = {}, now
 export function watchFallbackUsage(setup: () => ModelSetup, deps: UsageDeps = {}, every = CREDITS_TTL_MS): void {
   const run = (): void => {
     const current = setup();
-    if (current.fallbacks.length === 0) return;
+    if (current.fallbacks.length === 0 && (current.helpers ?? null) === null) return;
     refreshUsage(current, deps).catch((err: unknown) => {
       log.warn({ err: errMsg(err) }, 'model-api: could not refresh the usage of the fallback models');
     });

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

@@ -6,6 +6,7 @@ import {
 } from '../stations/registry.js';
 import { listEndpoints } from '../stations/webhook-endpoints.js';
 import { hookUrl, threemaCallbackUrl } from '../stations/attach.js';
+import { accountStatusOf } from '@metro-labs/core/stations/account-status';
 import { accountEnabled, agentIdForAccount, allowlistForAccount, approversForAccount, knownAccounts, type KnownAccount } from '../agents/map.js';
 
 const accountId = (acc: unknown): string | undefined => {
@@ -85,8 +86,33 @@ function withCallbackUrl(acc: unknown): unknown {
   return { ...rest, callback: threemaCallbackUrl(callbackId, callbackToken) };
 }
 
-const decorate = (station: string, rows: unknown[]): unknown[] =>
-  station === 'threema' ? rows.map(withCallbackUrl) : rows;
+function withStatus(reports: boolean, acc: unknown): unknown {
+  const rec = asRecord(acc);
+  if (rec === undefined || !('status' in rec)) return acc;
+  const { status, ...rest } = rec;
+  const live = reports ? accountStatusOf(status) : null;
+  return live === null ? rest : { ...rest, status: live };
+}
+
+function decorate(station: string, rows: unknown[]): unknown[] {
+  const reports = stationByName(station)?.reportsStatus === true;
+  const live = rows.map((row) => withStatus(reports, row));
+  return station === 'threema' ? live.map(withCallbackUrl) : live;
+}
+
+const STATUS_WAIT_MS = 5_000;
+
+function answerIn<T>(call: Promise<T>, ms: number): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const late = new Promise<never>((_resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(`no answer within ${String(ms)} ms`));
+    }, ms);
+  });
+  return Promise.race([call, late]).finally(() => {
+    clearTimeout(timer);
+  });
+}
 
 export interface ScopedAccounts {
   accounts: Record<string, unknown[]>;
@@ -99,7 +125,8 @@ async function liveAccounts(
   if (!hasTrain(station))
     return { rows: inCoreAccounts(station), reachable: true };
   try {
-    const resp = await forwardTrainCall(station, 'accounts', {});
+    const call = forwardTrainCall(station, 'accounts', {});
+    const resp = await (stationByName(station)?.reportsStatus === true ? answerIn(call, STATUS_WAIT_MS) : call);
     const list = (resp.result as { accounts?: unknown[] } | undefined)?.accounts;
     return { rows: decorate(station, Array.isArray(list) ? list : []), reachable: true };
   } catch {

package/runtime/node_modules/@metro-labs/daemon/src/routes/local-mode.ts

@@ -4,6 +4,7 @@ import { AttachSessions } from '../stations/attach-session.js';
 import { startInteractiveAttach } from '../stations/attach-interactive.js';
 import { assertAttachOwner, finishGmailUpgrade, startGmailAttach } from './gmail-attach.js';
 import { detachWithGmailRevocation } from './gmail-detach.js';
+import { finishPairAgain, pairAgainInput } from './pair-again.js';
 import { recentSenders } from '../agents/senders.js';
 import { forwardTrainCall } from '../stations/train-call.js';
 import type { AgentApiDeps } from '../agents/api.js';
@@ -44,11 +45,16 @@ function attachSessions(deps: LocalModeDeps): AttachSessions {
       assertAttachOwner(owner);
       return Promise.resolve();
     },
-    start: (station, input, hooks, owner) => station === 'gmail' ? startGmailAttach(station, input, hooks, owner) : startInteractiveAttach(station, input, hooks),
-    complete: async (owner, station, config, active) => {
+    start: (station, input, hooks, owner, repair) => {
+      if (repair !== undefined) return startInteractiveAttach(station, pairAgainInput(owner, station, repair, input), hooks);
+      return station === 'gmail' ? startGmailAttach(station, input, hooks, owner) : startInteractiveAttach(station, input, hooks);
+    },
+    complete: async (owner, station, config, active, repair) => {
       assertAttachOwner(owner);
       if (!active()) throw new ApiError('This sign-in was cancelled or expired.', 409);
-      const ref = (station === 'gmail' ? finishGmailUpgrade(owner, config) : null) ?? await localAttachAccount(owner.agentId, station, config);
+      const ref = repair !== undefined
+        ? finishPairAgain(owner, station, repair, config)
+        : (station === 'gmail' ? finishGmailUpgrade(owner, config) : null) ?? await localAttachAccount(owner.agentId, station, config);
       const activated = await deps.syncStations(station).then(
         () => true,
         (err: unknown) => {

package/runtime/node_modules/@metro-labs/daemon/src/routes/pair-again.ts

@@ -0,0 +1,23 @@
+import { ApiError } from '@metro-labs/http/api-error';
+import type { StationName } from '@metro-labs/core/station-names';
+import { localPairAgain, readLocalAgentFile } from '../agents/file-admin.js';
+import type { AccountRef } from '../agents/account-attach.js';
+import { stationByName } from '../stations/registry.js';
+import type { AttachOwner } from '../stations/attach-session.js';
+
+function identityOf(station: string): string {
+  const identity = stationByName(station)?.pairAgain?.identity;
+  if (identity === undefined) throw new ApiError(`${station} cannot pair again`, 400);
+  return identity;
+}
+
+export function pairAgainInput(owner: AttachOwner, station: string, accountId: string, input: Record<string, unknown>): Record<string, unknown> {
+  const identity = identityOf(station);
+  const account = readLocalAgentFile(owner.agentId).stations.find((s) => s.station === station && s.id === accountId);
+  if (account === undefined) throw new ApiError('No such channel on this agent.', 404);
+  return { ...input, expect: account.config[identity] };
+}
+
+export function finishPairAgain(owner: AttachOwner, station: StationName, accountId: string, config: Record<string, unknown>): AccountRef {
+  return localPairAgain(owner.agentId, station, accountId, identityOf(station), config);
+}

package/runtime/node_modules/@metro-labs/daemon/src/stations/attach-interactive.ts

@@ -97,7 +97,7 @@ async function startWhatsapp(
       },
       onPaired: hooks.done,
       onFailed: hooks.fail,
-    });
+    }, normalizePhone(input.expect));
     await login.start();
   } catch (err) {
     await login?.cancel();