@tablation/crew 0.96.0 → 0.98.0

package/dist/cli.js

@@ -684,11 +684,17 @@ var claudePair = {
   },
   removePair: (o) => removeClaudeMcp({ bin: o.bin ?? "claude", dryRun: o.dryRun })
 };
+var inferenceBaseUrl = (baseUrl, workspaceId) => `${baseUrl.replace(/\/+$/, "")}/api/workspaces/${workspaceId}/inference`;
+function workspaceSettings(baseUrl) {
+  const blank = BILLING_VARS_TO_UNSET.filter((v) => v !== "ANTHROPIC_AUTH_TOKEN");
+  return JSON.stringify({ env: { ...Object.fromEntries(blank.map((v) => [v, ""])), ANTHROPIC_BASE_URL: baseUrl } });
+}
 function subscriptionSettings() {
   return JSON.stringify({ env: Object.fromEntries(BILLING_VARS_TO_UNSET.map((v) => [v, ""])) });
 }
 function describeClaudeAuth(spec, env = process.env, home = homedir3()) {
   if (spec.auth === "subscription") return "subscription (settings override)";
+  if (spec.auth === "workspace") return `workspace${spec.inference ? ` (${new URL(spec.inference.baseUrl).host})` : " (endpoint resolved per route at run time)"}`;
   let fromSettings;
   try {
     const parsed = JSON.parse(readFileSync6(join6(home, ".claude", "settings.json"), "utf8"));
@@ -702,6 +708,9 @@ function describeClaudeAuth(spec, env = process.env, home = homedir3()) {
   const shell = BILLING_VARS_TO_UNSET.find((v) => v.startsWith("ANTHROPIC_API") && env[v]);
   return shell ? `inherit: ${shell} in env (unset at exec)` : "inherit: subscription login";
 }
+function withoutProviderVars(env) {
+  return Object.fromEntries(Object.entries(env).filter(([k]) => !BILLING_VARS_TO_UNSET.includes(k) && k !== "ANTHROPIC_BASE_URL" && !/^(CLAUDE_CODE_USE_|ANTHROPIC_(VERTEX|BEDROCK|FOUNDRY))/.test(k)));
+}
 var claudeAdapter = {
   harness: "claude",
   displayName: "Claude Code",
@@ -757,6 +766,7 @@ var claudeAdapter = {
         }
       })] : [],
       ...spec.auth === "subscription" ? ["--settings", subscriptionSettings()] : [],
+      ...spec.auth === "workspace" && spec.inference ? ["--settings", workspaceSettings(spec.inference.baseUrl)] : [],
       ...spec.args
     ];
     return wrapInvocation(spec, { model: o.model, args });
@@ -767,7 +777,11 @@ var claudeAdapter = {
       // blocks at all — without it, Agent Log Cycles reporting has nothing
       // to report (ISSUE-558).
       ...spec.maxThinkingTokens > 0 ? { MAX_THINKING_TOKENS: String(spec.maxThinkingTokens) } : {},
-      ...spec.env
+      // CREW-2796: under `workspace` the only route to a model is the endpoint. The provider
+      // variables are already unset at exec (`unsetEnv`), and a spec-level `env:` entry must not
+      // smuggle one back in.
+      ...spec.auth === "workspace" ? withoutProviderVars(spec.env) : spec.env,
+      ...spec.auth === "workspace" && spec.inference ? { ANTHROPIC_BASE_URL: spec.inference.baseUrl, ANTHROPIC_AUTH_TOKEN: spec.inference.token } : {}
     };
   },
   provider: () => "anthropic",
@@ -3168,10 +3182,10 @@ function parseToolchains(raw, base, missing, file) {
     const maxRunMinutes = parseMaxRunMinutes(entryRaw.maxRunMinutes, `${where}.maxRunMinutes`, missing);
     let auth;
     if (entryRaw.auth !== void 0) {
-      if (entryRaw.auth !== "subscription" && entryRaw.auth !== "inherit") {
-        missing.add(`${where}.auth must be subscription|inherit (got "${entryRaw.auth}")`);
+      if (entryRaw.auth !== "subscription" && entryRaw.auth !== "inherit" && entryRaw.auth !== "workspace") {
+        missing.add(`${where}.auth must be subscription|inherit|workspace (got "${entryRaw.auth}")`);
       } else if (harness !== "claude") {
-        missing.add(`${where}.auth is only supported on the claude harness`);
+        missing.add(`${where}.auth is only supported on the claude harness (${entryRaw.auth === "workspace" ? "workspace is not available for codex or gemini yet" : "got " + harness})`);
       } else {
         auth = entryRaw.auth;
       }
@@ -4939,6 +4953,16 @@ function agentLogRefusedItem(route2, role, status2, nowIso = (/* @__PURE__ */ ne
     message: `${route2}: the tracker refused the ${role} seat's run report (${status2}) \u2014 runs and ticket spend are not being recorded; check the seat key's role`
   };
 }
+var workspaceAuthKey = (role) => `workspace_auth:${role}`;
+var workspaceAllowanceKey = (role) => `workspace_allowance:${role}`;
+function workspaceAllowanceItem(route2, role, nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    kind: "workspace_allowance",
+    key: workspaceAllowanceKey(role),
+    since: nowIso,
+    message: `${route2}: the ${role} seat is paused \u2014 the workspace is past its AI allowance; it resumes on its own once the limit is raised`
+  };
+}
 var diskLowKey = (repo) => `disk_low:${repo}`;
 var LOW_DISK_BYTES = 2 * 1024 ** 3;
 var gib = (bytes) => (bytes / 1024 ** 3).toFixed(1);
@@ -7278,6 +7302,18 @@ var Tracker = class {
     if (!row) return;
     await this.client.records.update(this.route.resolved.shipsModelId, row.id, patch2);
   }
+  /**
+   * Writes (or, with `null`, clears) this ship's `relay_url` (CREW-2803). A
+   * no-op when there is no row for this ship or the Ships table has not taken
+   * the column (probed by the key's absence from the row), so the tunnel
+   * still runs on an install that predates it.
+   */
+  async updateRelayUrl(shipName2, url) {
+    const row = await this.myShipRow(shipName2);
+    if (!row || !("relay_url" in row)) return;
+    if ((row.relay_url ?? null) === url) return;
+    await this.client.records.update(this.route.resolved.shipsModelId, row.id, { relay_url: url });
+  }
   /** The other half of `beatEngaged` — clears engagement back to idle. */
   async beatIdle(shipName2) {
     const row = await this.myShipRow(shipName2);
@@ -9367,6 +9403,37 @@ var AgentError = class extends Error {
 };
 var AgentSpawnError = class extends AgentError {
 };
+var WorkspaceAuthRefused = class extends AgentSpawnError {
+};
+var WorkspaceAllowanceExhausted = class extends AgentError {
+};
+var ALLOWANCE_REFUSAL_MARKER = "AI_ALLOWANCE_EXCEEDED";
+function streamShowsAllowanceRefusal(streamPath) {
+  let raw;
+  try {
+    raw = readFileSync19(streamPath, "utf8");
+  } catch {
+    return false;
+  }
+  if (!raw.includes(ALLOWANCE_REFUSAL_MARKER)) return false;
+  for (const line of raw.split("\n")) {
+    if (!line.includes(ALLOWANCE_REFUSAL_MARKER)) continue;
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof ev !== "object" || ev === null) continue;
+    const e = ev;
+    if (e.type === "result" && e.is_error === true) {
+      if (typeof e.result === "string" && e.result.includes(ALLOWANCE_REFUSAL_MARKER)) return true;
+    } else if (e.type === "assistant" && (e.isApiErrorMessage === true || e.error !== void 0)) {
+      if (JSON.stringify(e.message ?? "").includes(ALLOWANCE_REFUSAL_MARKER)) return true;
+    }
+  }
+  return false;
+}
 var digestPathFor = (stateDir, routeLabel, role, runId) => join22(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
 function planAgentRun(o) {
   const briefPath = join22(o.route.promptsDir, "personas", `lane-${o.role}.md`);
@@ -9411,7 +9478,17 @@ function planAgentRun(o) {
   const streamsDir = join22(o.stateDir, "streams");
   const base = `${routeLabel}-${o.role}-${o.cycle}${o.runId ? `-${o.runId}` : ""}`;
   const seat = resolveSeat(o.ship, o.route, o.role, o.agentPersona ?? (o.agentModel ? { model: o.agentModel } : {}), o.repo);
-  const { toolchain, model } = seat;
+  const { model } = seat;
+  let toolchain = seat.toolchain;
+  if (toolchain.auth === "workspace") {
+    if (!o.apiKey || o.seatKind === "ship") {
+      throw new WorkspaceAuthRefused(`${o.role}: toolchain ${toolchain.name} has auth: workspace, which needs the seat's own agent key \u2014 this seat would fall back to the ship key (run \`crew agents sync\`)`);
+    }
+    if (!o.route.resolved) {
+      throw new WorkspaceAuthRefused(`${o.role}: toolchain ${toolchain.name} has auth: workspace, but route ${o.route.route} is not connected (run \`crew connect\`)`);
+    }
+    toolchain = { ...toolchain, inference: { baseUrl: inferenceBaseUrl(o.route.baseUrl, o.route.resolved.workspaceId), token: o.apiKey } };
+  }
   const adapter = adapterFor(toolchain.harness);
   const invocation = adapter.invocation(toolchain, {
     role: o.role,
@@ -9456,6 +9533,7 @@ function planAgentRun(o) {
     args: invocation.args,
     toolchain: toolchain.name,
     harness: toolchain.harness,
+    workspaceAuth: toolchain.auth === "workspace",
     provider: toolchainProvider(toolchain),
     maxRunMinutes: resolveMaxRunMinutes(o.route.maxRunMinutes, toolchain.maxRunMinutes),
     resolution: { toolchain: seat.toolchainWhy, model: seat.modelWhy },
@@ -18145,6 +18223,26 @@ function sshKeygenAvailable() {
   }
 }
 
+// src/relay-probe.ts
+async function probeRelayControl(relayUrl, apiKey, userAgent, fetchFn = fetch, timeoutMs = 1e4) {
+  const started = Date.now();
+  try {
+    const res = await fetchFn(`${relayUrl.replace(/\/+$/, "")}/control/status`, {
+      headers: { Authorization: `Bearer ${apiKey}`, "User-Agent": userAgent },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    const latencyMs = Date.now() - started;
+    await res.arrayBuffer().catch(() => void 0);
+    if (res.ok) return { ok: true, status: res.status, latencyMs };
+    return { ok: false, status: res.status, error: `HTTP ${res.status}` };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+function describeRelayProbe(url, p) {
+  return p.ok ? `relay control:     OK ${url}/control/status (${p.status}, ${p.latencyMs} ms)` : `relay control:     FAILED ${url}/control/status \u2014 ${p.error}`;
+}
+
 // src/passenger-containers.ts
 import { execFileSync as execFileSync9 } from "child_process";
 import { createHash as createHash7 } from "crypto";
@@ -18362,15 +18460,21 @@ function generateTunnelSlug() {
   for (let i = 0; i < SLUG_LENGTH; i++) out += SLUG_ALPHABET[randomInt(SLUG_ALPHABET.length)];
   return out;
 }
-function bindAddrFor(o) {
-  const base = `workspace-${o.workspaceId}-slug-${o.slug}-key-${o.apiKey}`;
-  return o.mcpSecret ? `${base}-secret-${o.mcpSecret}` : base;
+function bindAddrFor(o, path) {
+  const base = `workspace-${o.workspaceId}-slug-${o.slug}${path ? `-path-${path}` : ""}-key-${o.apiKey}`;
+  return o.mcpSecret && !path ? `${base}-secret-${o.mcpSecret}` : base;
 }
-function publicUrlFor(slug, relayHost, relayHttpPort, relayPublicDomain) {
+function relayBaseUrlFor(slug, relayHost, relayHttpPort, relayPublicDomain) {
   const domain = relayPublicDomain ?? relayHost.replace(/^.*@/, "");
-  return `https://${slug}.${domain}${relayHttpPort === 443 ? "" : `:${relayHttpPort}`}/mcp`;
+  return `https://${slug}.${domain}${relayHttpPort === 443 ? "" : `:${relayHttpPort}`}`;
+}
+function publicUrlFor(slug, relayHost, relayHttpPort, relayPublicDomain) {
+  return `${relayBaseUrlFor(slug, relayHost, relayHttpPort, relayPublicDomain)}/mcp`;
 }
 function sshArgsFor(o) {
+  const forwards = [];
+  if (o.localPort !== void 0) forwards.push("-R", `${bindAddrFor(o)}:0:127.0.0.1:${o.localPort}`);
+  if (o.controlSocket) forwards.push("-R", `${bindAddrFor(o, "control")}:0:${o.controlSocket}`);
   return [
     "-N",
     "-o",
@@ -18385,8 +18489,7 @@ function sshArgsFor(o) {
     o.privateKeyPath,
     "-p",
     String(o.relayPort),
-    "-R",
-    `${bindAddrFor(o)}:0:127.0.0.1:${o.localPort}`,
+    ...forwards,
     o.relayHost
   ];
 }
@@ -18457,16 +18560,19 @@ function isPidAlive(pid) {
     return false;
   }
 }
+var CONTROL_ONLY_HASH = "control-only";
 function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, stateDir, mcpSecrets = /* @__PURE__ */ new Map(), deps = {}) {
   const alive = deps.isPidAlive ?? isPidAlive;
   const plannedIds = new Set(plans.map((p) => p.workspaceId));
   for (const plan of plans) {
     const existing = readPersistedTunnel(stateDir, plan.workspaceId);
+    const mountsHash = plan.mountsHash ?? CONTROL_ONLY_HASH;
+    const controlUnchanged = existing?.controlSocket === deps.controlSocket;
     const currentSecret = mcpSecrets.get(plan.workspaceId);
     const secretUnchanged = (existing?.mcpSecret ?? void 0) === (currentSecret ?? void 0);
     const slug = existing?.slug ?? generateTunnelSlug();
     const slugUnchanged = existing?.liveSlug === slug;
-    if (existing && alive(existing.pid) && existing.mountsHash === plan.mountsHash && secretUnchanged && slugUnchanged) {
+    if (existing && alive(existing.pid) && existing.mountsHash === mountsHash && secretUnchanged && slugUnchanged && controlUnchanged) {
       if (existing.status === "connecting") {
         const settled = { ...existing, status: "connected" };
         writePersistedTunnel(stateDir, settled);
@@ -18493,6 +18599,7 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
       slug,
       apiKey,
       localPort: plan.port,
+      controlSocket: deps.controlSocket,
       privateKeyPath,
       mcpSecret: currentSecret,
       spawnFn: deps.spawnFn,
@@ -18502,9 +18609,10 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
     });
     const started = {
       pid: tunnel.pid ?? -1,
-      containerName: plan.containerName,
+      containerName: plan.containerName ?? "",
       workspaceId: plan.workspaceId,
-      mountsHash: plan.mountsHash,
+      mountsHash,
+      controlSocket: deps.controlSocket,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       status: settledStatus,
       mcpSecret: currentSecret,
@@ -18870,6 +18978,7 @@ import { join as join42 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
+var ALLOWANCE_PAUSE_MS = 5 * 60 * 1e3;
 var defaultSleep = (ms3) => new Promise((resolve6) => setTimeout(resolve6, ms3));
 async function runDaemonLoop(o) {
   const floor = o.floorMs ?? DEFAULT_FLOOR_MS;
@@ -19003,6 +19112,10 @@ var SpawnBreaker = class {
     this.states.set(role, { failures, retryAt: this.now() + retryInMs, lastMessage: message });
     return { parked, firstOfMessage: prev?.lastMessage !== message, failures, retryInMs };
   }
+  /** CREW-2796: holds `role` back for `ms` without counting a failed start (an allowance pause). */
+  pause(role, ms3) {
+    this.states.set(role, { failures: 0, retryAt: this.now() + ms3, lastMessage: "paused" });
+  }
   /** A run for `role` spawned: forget its earlier failed starts. */
   recordSuccess(role) {
     this.states.delete(role);
@@ -19130,8 +19243,27 @@ async function runOnePassUnguarded(o) {
       const run2 = spawn9(role, decision, ctx, { ready }).then(() => {
         breaker.recordSuccess(role);
         clearShipAttention(o.state, `role_parked:${role}`);
+        clearShipAttention(o.state, workspaceAuthKey(role));
+        clearShipAttention(o.state, workspaceAllowanceKey(role));
       }).catch(async (e) => {
         const message = e.message;
+        if (e instanceof WorkspaceAllowanceExhausted) {
+          breaker.pause(role, ALLOWANCE_PAUSE_MS);
+          emit.warn(`${role} paused: ${message}`, { step: "agent", role });
+          await raiseShipAttention({ state: o.state, emit, route: o.route, ship: o.ship }, workspaceAllowanceItem(o.route.route, role));
+          return;
+        }
+        if (e instanceof WorkspaceAuthRefused) {
+          breaker.recordFailure(role, message);
+          emit.warn(`${role} agent refused: ${message}`, { step: "agent", role });
+          await raiseShipAttention({ state: o.state, emit, route: o.route, ship: o.ship }, {
+            kind: "workspace_auth",
+            key: workspaceAuthKey(role),
+            message: `${o.route.route}: ${message}`,
+            since: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return;
+        }
         if (!(e instanceof AgentSpawnError)) {
           emit.warn(`${role} agent run failed: ${message}`, { step: "agent", role });
           return;
@@ -19398,6 +19530,7 @@ async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
     roster: rosterFor(decision, route2, role),
     environment: await buildEnvironment(route2, ship, ticketHint),
     apiKey: identity.apiKey,
+    seatKind: identity.kind,
     cycle: emit.cycle,
     runId,
     ticket: ticketHint,
@@ -19442,6 +19575,9 @@ async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
       await postRunKilled(route2, tracker, workingId, memberId, result.killed.limitMinutes, emit);
     } else {
       await guardRunHandoff(route2, ship, tracker, role, workingId, emit, runStart);
+      if (plan.workspaceAuth && streamShowsAllowanceRefusal(plan.streamPath)) {
+        throw new WorkspaceAllowanceExhausted("the inference endpoint refused the run: the workspace is past its AI allowance");
+      }
     }
   } finally {
     await settleRunEnd({
@@ -20484,6 +20620,11 @@ if (command === "passenger-sync-daemon") {
   }, parseTicketNumber = function(input) {
     const m = /^(?:[A-Za-z]+-)?(\d+)$/.exec(input.trim());
     return m ? m[1] : null;
+  }, routeRelayUrl = function(route3) {
+    const ws = route3.resolved?.workspaceId;
+    const slug = ws ? readPersistedTunnel(cfg.ship.stateDir, ws)?.slug : void 0;
+    if (!cfg.ship.relayHost || !slug) return null;
+    return relayBaseUrlFor(slug, cfg.ship.relayHost, cfg.ship.relayHttpPort, cfg.ship.relayPublicDomain);
   }, passengerApiKeys = function(routes) {
     const keys = /* @__PURE__ */ new Map();
     for (const r of routes) {
@@ -20531,7 +20672,7 @@ if (command === "passenger-sync-daemon") {
     const unsafe = baseBranchUnsafe(out);
     return { action: out.action, unsafe, detail: unsafe ? describeUnsafeBase(out, remote, base) : out.detail };
   };
-  requireArmed2 = requireArmed, parseTicketNumber2 = parseTicketNumber, passengerApiKeys2 = passengerApiKeys, endpointApiFor2 = endpointApiFor, endpointReconcileDeps2 = endpointReconcileDeps, releaseRefused2 = releaseRefused, doctorMachineId2 = doctorMachineId, baseHealth2 = baseHealth;
+  requireArmed2 = requireArmed, parseTicketNumber2 = parseTicketNumber, routeRelayUrl2 = routeRelayUrl, passengerApiKeys2 = passengerApiKeys, endpointApiFor2 = endpointApiFor, endpointReconcileDeps2 = endpointReconcileDeps, releaseRefused2 = releaseRefused, doctorMachineId2 = doctorMachineId, baseHealth2 = baseHealth;
   let cfg;
   let firstRun;
   let firstRunFromFlags = false;
@@ -20664,7 +20805,10 @@ if (command === "passenger-sync-daemon") {
   async function syncHostPassengers() {
     if (dryRun) return;
     const passengerRoutes = cfg.routes.filter((r) => r.enabled && r.hostPassengers);
-    if (passengerRoutes.length === 0) return;
+    if (passengerRoutes.length === 0) {
+      await syncShipTunnels([], /* @__PURE__ */ new Map(), []);
+      return;
+    }
     if (!dockerAvailable()) {
       const pathProblem = dockerPathProblem(cfg.ship, COMMON_DOCKER_DIRS);
       emit.warn(
@@ -20706,37 +20850,64 @@ if (command === "passenger-sync-daemon") {
           { step: "passengers", data: { ...result } }
         );
       }
-      if (cfg.ship.relayHost) {
-        try {
-          const { privateKeyPath } = ensureShipSshKeypair(cfg.ship.stateDir);
-          const plans = planContainers(cfg);
-          const mcpSecrets = new Map([...syncEndpoints].map(([workspaceId, e]) => [workspaceId, e.secret]));
-          const relayHost = cfg.ship.relayHost;
-          const reconcile = endpointReconcileDeps(passengerRoutes, relayHost);
-          const pending = [];
-          syncPassengerTunnels(plans, relayHost, cfg.ship.relayPort, privateKeyPath, cfg.ship.stateDir, mcpSecrets, {
-            apiKeys: passengerApiKeys(passengerRoutes),
-            onStatus: (workspaceId, status2, info) => {
-              const owningRoute = passengerRoutes.find((r) => r.resolved?.workspaceId === workspaceId);
-              if (!owningRoute) return;
-              pending.push(
-                new Tracker(owningRoute, cfg.ship).updateTunnelState(cfg.ship.name, { tunnel_status: status2 }).catch((e) => {
-                  emit.warn(`could not write tunnel_status: ${e.message}`, { step: "passengers" });
-                })
-              );
-              if (status2 === "disconnected") pending.push(unregisterEndpoint(workspaceId, info, reconcile));
-            }
-          });
-          for (const plan of plans) pending.push(reconcileEndpoint(plan.workspaceId, reconcile));
-          await Promise.all(pending);
-        } catch (e) {
-          emit.warn(`passenger tunnel sync failed: ${e.message}`, { step: "passengers" });
-        }
-      }
+      await syncShipTunnels(planContainers(cfg), new Map([...syncEndpoints].map(([workspaceId, e]) => [workspaceId, e.secret])), passengerRoutes);
     } catch (e) {
       emit.warn(`passenger container sync failed: ${e.message}`, { step: "passengers" });
     }
   }
+  async function syncShipTunnels(containerPlans, mcpSecrets, passengerRoutes) {
+    if (!cfg.ship.relayHost) return;
+    const relayHost = cfg.ship.relayHost;
+    try {
+      const { privateKeyPath } = ensureShipSshKeypair(cfg.ship.stateDir);
+      const controlRoutes = cfg.routes.filter((r) => r.enabled && r.resolved?.workspaceId);
+      const planned = new Set(containerPlans.map((p) => p.workspaceId));
+      const plans = [...containerPlans];
+      for (const r of controlRoutes) {
+        const ws = r.resolved.workspaceId;
+        if (planned.has(ws)) continue;
+        planned.add(ws);
+        plans.push({ workspaceId: ws });
+      }
+      const apiRoutes = controlRoutes;
+      const reconcile = endpointReconcileDeps(passengerRoutes, relayHost);
+      const pending = [];
+      syncPassengerTunnels(plans, relayHost, cfg.ship.relayPort, privateKeyPath, cfg.ship.stateDir, mcpSecrets, {
+        apiKeys: passengerApiKeys(apiRoutes),
+        controlSocket: controlSocketFor(cfg.ship.stateDir),
+        onStatus: (workspaceId, status2, info) => {
+          const owningRoute = apiRoutes.find((r) => r.resolved?.workspaceId === workspaceId);
+          if (!owningRoute) return;
+          pending.push(
+            new Tracker(owningRoute, cfg.ship).updateTunnelState(cfg.ship.name, { tunnel_status: status2 }).catch((e) => {
+              emit.warn(`could not write tunnel_status: ${e.message}`, { step: "passengers" });
+            })
+          );
+          if (status2 === "disconnected") pending.push(unregisterEndpoint(workspaceId, info, reconcile));
+        }
+      });
+      for (const plan of containerPlans) pending.push(reconcileEndpoint(plan.workspaceId, reconcile));
+      for (const plan of plans) pending.push(reconcileRelayUrl(plan.workspaceId, apiRoutes));
+      await Promise.all(pending);
+    } catch (e) {
+      emit.warn(`ship tunnel sync failed: ${e.message}`, { step: "passengers" });
+    }
+  }
+  async function reconcileRelayUrl(workspaceId, routes) {
+    if (!cfg.ship.relayHost) return;
+    const persisted = readPersistedTunnel(cfg.ship.stateDir, workspaceId);
+    if (!persisted?.slug || persisted.status !== "connected") return;
+    const url = relayBaseUrlFor(persisted.slug, cfg.ship.relayHost, cfg.ship.relayHttpPort, cfg.ship.relayPublicDomain);
+    if (persisted.relayUrl === url) return;
+    const route3 = routes.find((r) => r.resolved?.workspaceId === workspaceId);
+    if (!route3) return;
+    try {
+      await new Tracker(route3, cfg.ship).updateRelayUrl(cfg.ship.name, url);
+      updatePersistedTunnel(cfg.ship.stateDir, workspaceId, { relayUrl: url });
+    } catch (e) {
+      emit.warn(`could not write relay_url: ${e.message}`, { step: "passengers" });
+    }
+  }
   async function releaseFleet(opts = {}) {
     if (releaseRefused()) return;
     precheckTickets.clear();
@@ -23753,6 +23924,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       const rotatePending = [];
       syncPassengerTunnels(plans, cfg.ship.relayHost, cfg.ship.relayPort, privateKeyPath, cfg.ship.stateDir, /* @__PURE__ */ new Map(), {
         apiKeys: passengerApiKeys([route2]),
+        controlSocket: controlSocketFor(cfg.ship.stateDir),
         onStatus: (wsId, status2, info) => {
           rotatePending.push(
             new Tracker(route2, cfg.ship).updateTunnelState(cfg.ship.name, { tunnel_status: status2 }).catch((e) => {
@@ -24329,6 +24501,14 @@ ${where.join("\n")}`);
       const url = mcpUrlFor(value("base-url") ?? cfg.routes[0]?.baseUrl ?? DEFAULT_BASE_URL);
       const disconnectHarnesses = /* @__PURE__ */ new Set([...shipPair(cfg.ship), ...shipToolchains(cfg.ship).map((t) => t.harness).filter(isPairHarness)]);
       const removePairEntries = (mcpUrl, dry) => [...disconnectHarnesses].map((h) => pairInstallerFor(h).removePair({ url: mcpUrl, bin: cfg.ship.agent.bin, dryRun: dry }));
+      if (!dryRun) {
+        for (const r of cfg.routes.filter((x) => x.resolved?.shipsModelId)) {
+          await new Tracker(r, cfg.ship).updateRelayUrl(cfg.ship.name, null).catch((e) => {
+            process.stderr.write(`could not clear relay_url for ${r.route}: ${e.message}
+`);
+          });
+        }
+      }
       if (!flag("reset")) {
         for (const line of removePairEntries(url, dryRun)) process.stderr.write(`${line}
 `);
@@ -24763,7 +24943,9 @@ ${where.join("\n")}`);
             attention: openShipAttention(state),
             // Additive (CREW-2495): this ship's Ships-row name and whether it has drifted from `name`.
             rowName: nameSync.rowName ?? null,
-            nameDrift: nameSync.drift
+            nameDrift: nameSync.drift,
+            // Additive (CREW-2803): the relay URL this route's tunnel is reachable at, or null.
+            relayUrl: routeRelayUrl(route2)
           },
           // Additive (CREW-1402): what the operator owes. `version` stays 1.
           todo: todo.map((i) => ({ ticket: displayKey(i.ticket), title: i.ticket.title ?? null, reasons: i.reasons })),
@@ -24853,7 +25035,8 @@ ${owed.map((l) => `  ${l}
 route:      ${route2.route} -> ${route2.dir}
 enabled:    ${route2.enabled}
 periscopes: ${periscopeSummary(cfg)}
-` + periscopes.map((p) => `periscope:  ${p.ticket} ${p.repo} ${p.url} ${p.state}${p.serving ? "" : " (not serving)"} expires ${p.expiresAt}
+` + (routeRelayUrl(route2) ? `relay:      ${routeRelayUrl(route2)}
+` : "") + periscopes.map((p) => `periscope:  ${p.ticket} ${p.repo} ${p.url} ${p.state}${p.serving ? "" : " (not serving)"} expires ${p.expiresAt}
 `).join("") + `crew:       ${state.isPaused() ? "paused" : "active"}
 release:    ${state.releaseSkipReason() ? "paused" : "active"}
 watermark:  ${state.watermark()}
@@ -25445,11 +25628,34 @@ ${foreign.join("\n")}
           );
         }
       }
+      if (cfg.ship.relayHost && !flag("offline")) {
+        const relayUrl = routeRelayUrl(route2);
+        if (!relayUrl) {
+          process.stdout.write("relay control:     no tunnel URL yet (the first `crew passengers` cycle opens it)\n");
+        } else {
+          let key;
+          try {
+            key = resolveApiKey(route2);
+          } catch {
+            key = void 0;
+          }
+          process.stdout.write(`${key ? describeRelayProbe(relayUrl, await probeRelayControl(relayUrl, key, cfg.ship.userAgent)) : "relay control:     could not check (no API key for this route)"}
+`);
+        }
+      }
       for (const l of doctorSelftestLines(readSelftest(cfg.ship.stateDir), shipToolchains(cfg.ship).map((t) => t.name))) {
         process.stdout.write(`${l}
 `);
       }
       for (const t of shipToolchains(cfg.ship).filter((t2) => t2.harness === "claude")) {
+        if (t.auth === "workspace") {
+          for (const r of cfg.routes.filter((r2) => r2.enabled)) {
+            const inference = r.resolved ? { baseUrl: inferenceBaseUrl(r.baseUrl, r.resolved.workspaceId), token: "" } : void 0;
+            process.stdout.write(`auth:              ${t.name}: ${r.route}: ${describeClaudeAuth({ ...t, inference })}
+`);
+          }
+          continue;
+        }
         process.stdout.write(`auth:              ${t.name}: ${describeClaudeAuth(t)}
 `);
       }
@@ -25466,6 +25672,7 @@ ${foreign.join("\n")}
 }
 var requireArmed2;
 var parseTicketNumber2;
+var routeRelayUrl2;
 var passengerApiKeys2;
 var endpointApiFor2;
 var endpointReconcileDeps2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.96.0",
+  "version": "0.98.0",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",