@tablation/crew 0.91.0 → 0.92.0

package/dist/cli.js

@@ -352,8 +352,8 @@ var Emitter = class _Emitter {
    * actually knows which route it's working (release, per-repo poll) uses
    * this instead, so its events aren't all attributed to `routes[0]`.
    */
-  forRoute(route) {
-    return new _Emitter({ ...this.opts, route, cycleId: this.cycle });
+  forRoute(route2) {
+    return new _Emitter({ ...this.opts, route: route2, cycleId: this.cycle });
   }
   /** Times a step and emits its outcome, so a view can show duration. */
   async timed(step, message, fn, role) {
@@ -363,11 +363,11 @@ var Emitter = class _Emitter {
       const result = await fn();
       this.emit(message, { data: { ms: this.now().getTime() - started, ok: true } });
       return result;
-    } catch (err) {
-      this.error(`${message} \u2014 ${err.message}`, {
+    } catch (err2) {
+      this.error(`${message} \u2014 ${err2.message}`, {
         data: { ms: this.now().getTime() - started, ok: false }
       });
-      throw err;
+      throw err2;
     }
   }
 };
@@ -1521,8 +1521,8 @@ function shipToolchains(ship) {
   };
   return [legacy, ...explicit];
 }
-function resolveToolchain(ship, route, repo) {
-  const name = (repo && route?.repoOverrides?.[repo]?.toolchain) ?? route?.toolchain ?? ship.toolchain ?? LEGACY_TOOLCHAIN;
+function resolveToolchain(ship, route2, repo) {
+  const name = (repo && route2?.repoOverrides?.[repo]?.toolchain) ?? route2?.toolchain ?? ship.toolchain ?? LEGACY_TOOLCHAIN;
   const found = shipToolchains(ship).find((t) => t.name === name);
   if (!found) throw new Error(`toolchain "${name}" is not defined (have: ${shipToolchains(ship).map((t) => t.name).join(", ")})`);
   return found;
@@ -1537,12 +1537,12 @@ function toolchainProvider(spec) {
   if (isOmlxLauncher(spec)) return "local";
   return adapterFor(spec.harness).provider(spec);
 }
-function resolveSeat(ship, route, role, persona = {}, repo) {
+function resolveSeat(ship, route2, role, persona = {}, repo) {
   const warnings = [];
-  const base = resolveToolchain(ship, route, repo);
+  const base = resolveToolchain(ship, route2, repo);
   const baseVendor = toolchainVendor(base);
-  const repoToolchain = repo ? route?.repoOverrides?.[repo]?.toolchain : void 0;
-  const baseWhy = repoToolchain ? `repo ${repo} toolchain ${base.name}` : route?.toolchain ? `route toolchain ${base.name}` : ship.toolchain ? `ship default ${base.name}` : `default ${base.name}`;
+  const repoToolchain = repo ? route2?.repoOverrides?.[repo]?.toolchain : void 0;
+  const baseWhy = repoToolchain ? `repo ${repo} toolchain ${base.name}` : route2?.toolchain ? `route toolchain ${base.name}` : ship.toolchain ? `ship default ${base.name}` : `default ${base.name}`;
   let chosen = base;
   let toolchainWhy = baseWhy;
   if (persona.vendor && persona.vendor !== baseVendor) {
@@ -2626,23 +2626,23 @@ function parseBranchOverride(raw, where, file) {
   if (base === void 0 && name === void 0 && push === void 0 && remote === void 0 && lowercase === void 0) return void 0;
   return { base, name, push, remote, ...lowercase !== void 0 ? { lowercase } : {} };
 }
-function mergeRouteRelease(route, override) {
-  const provider = override?.ci?.provider ?? route.ci?.provider;
-  const ref = override?.ci?.ref ?? route.ci?.ref;
-  const match = override?.verify?.match ?? route.verify?.match;
-  const timeoutSeconds = override?.verify?.timeoutSeconds ?? route.verify?.timeoutSeconds;
-  const intervalSeconds = override?.verify?.intervalSeconds ?? route.verify?.intervalSeconds;
-  const isolateMax = override?.isolateFailures?.maxCandidates ?? route.isolateFailures?.maxCandidates;
+function mergeRouteRelease(route2, override) {
+  const provider = override?.ci?.provider ?? route2.ci?.provider;
+  const ref = override?.ci?.ref ?? route2.ci?.ref;
+  const match = override?.verify?.match ?? route2.verify?.match;
+  const timeoutSeconds = override?.verify?.timeoutSeconds ?? route2.verify?.timeoutSeconds;
+  const intervalSeconds = override?.verify?.intervalSeconds ?? route2.verify?.intervalSeconds;
+  const isolateMax = override?.isolateFailures?.maxCandidates ?? route2.isolateFailures?.maxCandidates;
   return {
-    mode: override?.mode ?? route.mode,
+    mode: override?.mode ?? route2.mode,
     ci: provider !== void 0 || ref !== void 0 ? { provider, ref } : void 0,
     verify: match !== void 0 || timeoutSeconds !== void 0 || intervalSeconds !== void 0 ? { match, timeoutSeconds, intervalSeconds } : void 0,
     ...isolateMax === void 0 ? {} : { isolateFailures: { maxCandidates: isolateMax } },
-    versioning: override?.versioning ?? route.versioning,
-    versionFiles: override?.versionFiles ?? route.versionFiles,
-    changelog: override?.changelog ?? route.changelog,
-    tag: override?.tag ?? route.tag,
-    tagPattern: override?.tagPattern ?? route.tagPattern
+    versioning: override?.versioning ?? route2.versioning,
+    versionFiles: override?.versionFiles ?? route2.versionFiles,
+    changelog: override?.changelog ?? route2.changelog,
+    tag: override?.tag ?? route2.tag,
+    tagPattern: override?.tagPattern ?? route2.tagPattern
   };
 }
 function expand(p, base) {
@@ -2695,30 +2695,30 @@ function configSearchPath(crewHome) {
   ];
 }
 function findConfigFile(crewHome) {
-  const candidates = configSearchPath(crewHome);
-  return candidates.find((c) => existsSync9(c)) ?? candidates[candidates.length - 1];
+  const candidates2 = configSearchPath(crewHome);
+  return candidates2.find((c) => existsSync9(c)) ?? candidates2[candidates2.length - 1];
 }
 var defaultConfigPath = () => join11(process.env.XDG_CONFIG_HOME ?? join11(homedir6(), ".config"), "crew", "crew.yaml");
-function routeSlug(route) {
-  return route.replace(/\//g, "-");
+function routeSlug(route2) {
+  return route2.replace(/\//g, "-");
 }
-function resolvedPathFor(stateDir, route) {
-  const [workspace, project] = splitRoute(route);
+function resolvedPathFor(stateDir, route2) {
+  const [workspace, project] = splitRoute(route2);
   return join11(stateDir, "resolved", workspace, `${project}.json`);
 }
-function apiKeyPathFor(stateDir, route) {
-  const [workspace, project] = splitRoute(route);
+function apiKeyPathFor(stateDir, route2) {
+  const [workspace, project] = splitRoute(route2);
   return join11(stateDir, "keys", workspace, `${project}.env`);
 }
-function splitRoute(route) {
-  const parts = route.split("/");
+function splitRoute(route2) {
+  const parts = route2.split("/");
   if (parts.length !== 2 || !parts[0] || !parts[1]) {
-    throw new ConfigError(`route must be "workspace/project" (got "${route}")`);
+    throw new ConfigError(`route must be "workspace/project" (got "${route2}")`);
   }
   return [parts[0], parts[1]];
 }
-function readResolvedFile(stateDir, route) {
-  const path = resolvedPathFor(stateDir, route);
+function readResolvedFile(stateDir, route2) {
+  const path = resolvedPathFor(stateDir, route2);
   if (!existsSync9(path)) return void 0;
   try {
     return JSON.parse(readFileSync10(path, "utf8"));
@@ -3019,14 +3019,14 @@ function parseOneRoute(c, where, file, base, stateDir, raw, missing, crewHome, t
   if (toolchain !== void 0 && !toolchainNames.has(toolchain)) {
     missing.add(`${where}.toolchain "${toolchain}" is not defined in ship.toolchains (have: ${[...toolchainNames].join(", ")})`);
   }
-  const route = missing.req(c?.route, `${where}.route`);
+  const route2 = missing.req(c?.route, `${where}.route`);
   if (c?.hostPeriscopes === true && c?.hostPassengers !== true) {
-    missing.add(`${where} (route "${route}") sets hostPeriscopes: true without hostPassengers: true \u2014 a Passenger must be able to board before they can open a periscope`);
+    missing.add(`${where} (route "${route2}") sets hostPeriscopes: true without hostPassengers: true \u2014 a Passenger must be able to board before they can open a periscope`);
   }
-  const routeParts = route ? route.split("/") : [];
+  const routeParts = route2 ? route2.split("/") : [];
   const routeWellFormed = routeParts.length === 2 && routeParts.every(Boolean);
-  if (route && !routeWellFormed) {
-    missing.add(`${where}.route must be "workspace/project" (got "${route}")`);
+  if (route2 && !routeWellFormed) {
+    missing.add(`${where}.route must be "workspace/project" (got "${route2}")`);
   }
   const repoDirs = {};
   const repoOverrides = {};
@@ -3063,13 +3063,13 @@ function parseOneRoute(c, where, file, base, stateDir, raw, missing, crewHome, t
   const hasRepos = Object.keys(repoDirs).length > 0;
   const reposBasePath = expand(String(c?.reposBasePath ?? raw.ship?.reposBasePath ?? DEFAULT_REPOS_BASE_PATH), base);
   const dirIsCloneBase = !c?.dir && !hasRepos && !Array.isArray(c?.repos);
-  const dir = c?.dir ? expand(String(c.dir), base) : hasRepos ? Object.values(repoDirs)[0] : dirIsCloneBase ? join11(reposBasePath, splitRoute(route)[0]) : "";
+  const dir = c?.dir ? expand(String(c.dir), base) : hasRepos ? Object.values(repoDirs)[0] : dirIsCloneBase ? join11(reposBasePath, splitRoute(route2)[0]) : "";
   const weight = c?.weight === void 0 ? void 0 : Number(c.weight);
   if (weight !== void 0 && !(Number.isFinite(weight) && weight > 0)) {
     missing.add(`${where}.weight must be a positive number (got "${c?.weight}")`);
   }
   const result = {
-    route,
+    route: route2,
     enabled: c?.enabled === true,
     area: c?.area,
     dir,
@@ -3100,7 +3100,7 @@ function parseOneRoute(c, where, file, base, stateDir, raw, missing, crewHome, t
     hostPassengers: c?.hostPassengers === true,
     hostPeriscopes: c?.hostPeriscopes === true
   };
-  const resolvedFile = routeWellFormed ? readResolvedFile(stateDir, route) : void 0;
+  const resolvedFile = routeWellFormed ? readResolvedFile(stateDir, route2) : void 0;
   result.resolved = parseResolved(resolvedFile ?? c?.resolved, missing, where);
   result.contract = resolvedFile?.contract ?? c?.contract ?? null;
   missing.throwIfAny(file);
@@ -3115,9 +3115,9 @@ function locateDir(cfg, dir, commonDirOf) {
     return target2 === b || target2.startsWith(`${b}/`);
   };
   const find = (target2) => {
-    for (const route of cfg.routes) {
-      const repo = reposOf(route).find((x) => within(x.dir, target2));
-      if (repo) return { route, repo, checkout: resolve(repo.dir) };
+    for (const route2 of cfg.routes) {
+      const repo = reposOf(route2).find((x) => within(x.dir, target2));
+      if (repo) return { route: route2, repo, checkout: resolve(repo.dir) };
     }
     return void 0;
   };
@@ -3127,8 +3127,8 @@ function locateDir(cfg, dir, commonDirOf) {
   const common = commonDirOf?.(target);
   return common ? find(dirname4(resolve(target, common))) : void 0;
 }
-function findRoute(cfg, route) {
-  if (!route) {
+function findRoute(cfg, route2) {
+  if (!route2) {
     const enabled = cfg.routes.filter((r) => r.enabled);
     if (enabled.length === 1) return enabled[0];
     if (cfg.routes.length === 1) return cfg.routes[0];
@@ -3136,9 +3136,9 @@ function findRoute(cfg, route) {
       `this ship has ${cfg.routes.length} routes \u2014 name one: ${cfg.routes.map((r) => r.route).join(", ")}`
     );
   }
-  const found = cfg.routes.find((r) => r.route === route);
+  const found = cfg.routes.find((r) => r.route === route2);
   if (!found) {
-    throw new ConfigError(`no route "${route}" (have: ${cfg.routes.map((r) => r.route).join(", ")})`);
+    throw new ConfigError(`no route "${route2}" (have: ${cfg.routes.map((r) => r.route).join(", ")})`);
   }
   return found;
 }
@@ -3184,13 +3184,13 @@ var KEYCHAIN_ELIGIBLE_ROUTES = /* @__PURE__ */ new WeakSet();
 async function hydrateApiKeys(routes, getStore = getSessionStore) {
   let store;
   let storeUnavailable = false;
-  for (const route of routes) {
-    if (!KEYCHAIN_ELIGIBLE_ROUTES.has(route)) {
+  for (const route2 of routes) {
+    if (!KEYCHAIN_ELIGIBLE_ROUTES.has(route2)) {
       try {
-        resolveApiKey(route);
+        resolveApiKey(route2);
         continue;
       } catch {
-        KEYCHAIN_ELIGIBLE_ROUTES.add(route);
+        KEYCHAIN_ELIGIBLE_ROUTES.add(route2);
       }
     }
     if (storeUnavailable) continue;
@@ -3204,13 +3204,13 @@ async function hydrateApiKeys(routes, getStore = getSessionStore) {
     }
     let workspaceSlug;
     try {
-      [workspaceSlug] = splitRoute(route.route);
+      [workspaceSlug] = splitRoute(route2.route);
     } catch {
       continue;
     }
     try {
-      const session = await store.get(hostFromUrl(route.baseUrl), workspaceSlug);
-      if (session?.apiKey) route.apiKey = session.apiKey;
+      const session = await store.get(hostFromUrl(route2.baseUrl), workspaceSlug);
+      if (session?.apiKey) route2.apiKey = session.apiKey;
     } catch {
     }
   }
@@ -3404,10 +3404,10 @@ function runScript(script, opts) {
     child.stdout.on("data", absorb);
     child.stderr.on("data", absorb);
     const timer = opts.timeoutMs ? setTimeout(() => child.kill("SIGKILL"), opts.timeoutMs) : void 0;
-    child.on("error", (err) => {
+    child.on("error", (err2) => {
       if (timer) clearTimeout(timer);
       resolvePromise({ code: 127, output: `${output}
-crew: cannot run ${shell.bin}: ${err.message}` });
+crew: cannot run ${shell.bin}: ${err2.message}` });
     });
     child.on("close", (code) => {
       if (timer) clearTimeout(timer);
@@ -3418,8 +3418,8 @@ crew: cannot run ${shell.bin}: ${err.message}` });
 }
 
 // src/notify.ts
-async function notify(route, ship, n, emit, dryRun = false) {
-  const script = route.hooks.notify;
+async function notify(route2, ship, n, emit, dryRun = false) {
+  const script = route2.hooks.notify;
   if (!script) return false;
   if (dryRun) {
     emit.emit(`would notify: [${n.level}] ${n.headline}`);
@@ -3427,12 +3427,12 @@ async function notify(route, ship, n, emit, dryRun = false) {
   }
   try {
     const r = await runScript(script, {
-      cwd: route.dir,
+      cwd: route2.dir,
       env: {
         CREW_LEVEL: n.level,
         CREW_HEADLINE: n.headline,
         CREW_DETAIL: n.detail ?? "",
-        CREW_ROUTE: route.route,
+        CREW_ROUTE: route2.route,
         CREW_SHIP: ship.name
       },
       shell: resolveShell(ship.shell),
@@ -3457,18 +3457,18 @@ The \`${f.hook}\` hook (\`${f.label}\`) printed, last lines:
 ${f.tail}
 \`\`\``;
 }
-function describeRelease(o, route) {
+function describeRelease(o, route2) {
   if (o.integrated) {
     return {
       level: "ok",
-      headline: `${route}: integrated ${o.version ?? o.merged.length + " ticket(s)"}`,
+      headline: `${route2}: integrated ${o.version ?? o.merged.length + " ticket(s)"}`,
       detail: "merged to the base branch \u2014 this repo has no deploy step"
     };
   }
   if (o.deployed) {
     return {
       level: o.confirmed === false ? "warn" : "ok",
-      headline: `${route}: released ${o.version ?? "a new version"}`,
+      headline: `${route2}: released ${o.version ?? "a new version"}`,
       detail: o.confirmed === false ? "deploy ran, but the target did not confirm the new commit in time" : `${o.merged.length} ticket(s) shipped`
     };
   }
@@ -3476,7 +3476,7 @@ function describeRelease(o, route) {
   if (o.stopped === "tests failed") {
     return {
       level: "fail",
-      headline: `${route}: release blocked \u2014 tests failed`,
+      headline: `${route2}: release blocked \u2014 tests failed`,
       detail: withHookTail(
         (o.composition ? `the target stays on the previous release
 
@@ -3491,7 +3491,7 @@ ${o.isolation}` : ""),
   if (o.stopped === "setup failed") {
     return {
       level: "fail",
-      headline: `${route}: release blocked \u2014 setup failed`,
+      headline: `${route2}: release blocked \u2014 setup failed`,
       detail: withHookTail(
         "the setup hook failed in the release checkout; the target stays on the previous release",
         o.hookFailure
@@ -3501,7 +3501,7 @@ ${o.isolation}` : ""),
   if (o.stopped === "deploy failed") {
     return {
       level: "fail",
-      headline: `${route}: deploy FAILED`,
+      headline: `${route2}: deploy FAILED`,
       detail: withHookTail(
         "the version is merged to the base branch but not live \u2014 if the deploy target was the problem, run `crew deploy` to retry (do not re-release); if the merged code itself failed to build, fix forward on a ticket branch, and merging it clears the not-retrying guard",
         o.hookFailure
@@ -3511,7 +3511,7 @@ ${o.isolation}` : ""),
   if (o.stopped === "build failed") {
     return {
       level: "fail",
-      headline: `${route}: build FAILED`,
+      headline: `${route2}: build FAILED`,
       detail: withHookTail(`the target stays on the previous release \u2014 nothing was deployed${o.isolation ? `
 
 ${o.isolation}` : ""}`, o.hookFailure)
@@ -3520,25 +3520,25 @@ ${o.isolation}` : ""}`, o.hookFailure)
   if (o.blockedCycles && o.blockedCycles >= 2) {
     return {
       level: "fail",
-      headline: `${route}: release blocked \u2014 ${o.blockKind === "branch" ? "checkout is not on the base branch" : "working tree is not clean"}`,
+      headline: `${route2}: release blocked \u2014 ${o.blockKind === "branch" ? "checkout is not on the base branch" : "working tree is not clean"}`,
       detail: `${o.stopped ?? "blocked"} (blocked ${o.blockedCycles} cycles running) \u2014 a person has to clear it`
     };
   }
   return null;
 }
-function recoveredFailureHeadlines(o, route) {
-  const setup = `${route}: release blocked \u2014 setup failed`;
-  const tests = `${route}: release blocked \u2014 tests failed`;
-  const build = `${route}: build FAILED`;
-  const deploy = `${route}: deploy FAILED`;
+function recoveredFailureHeadlines(o, route2) {
+  const setup = `${route2}: release blocked \u2014 setup failed`;
+  const tests = `${route2}: release blocked \u2014 tests failed`;
+  const build = `${route2}: build FAILED`;
+  const deploy = `${route2}: deploy FAILED`;
   if (o.deployed || o.integrated) {
     return [
       setup,
       tests,
       build,
       deploy,
-      `${route}: release blocked \u2014 checkout is not on the base branch`,
-      `${route}: release blocked \u2014 working tree is not clean`
+      `${route2}: release blocked \u2014 checkout is not on the base branch`,
+      `${route2}: release blocked \u2014 working tree is not clean`
     ];
   }
   switch (o.stopped) {
@@ -3604,8 +3604,8 @@ function pathFor(ship) {
   return parts.join(":");
 }
 function findOnPath(bin, searchPath) {
-  const candidates = bin.includes("/") ? [bin] : searchPath.split(":").filter(Boolean).map((dir) => join12(dir, bin));
-  for (const candidate of candidates) {
+  const candidates2 = bin.includes("/") ? [bin] : searchPath.split(":").filter(Boolean).map((dir) => join12(dir, bin));
+  for (const candidate of candidates2) {
     try {
       accessSync(candidate, constants.X_OK);
       if (statSync3(candidate).isFile()) return candidate;
@@ -4103,18 +4103,18 @@ function gitRaw(cwd, args) {
   try {
     return execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
   } catch (e) {
-    const err = e;
-    const why = [err.stderr, err.stdout].map(streamText).filter(Boolean).join(" / ");
-    throw new GitError(`git ${args.join(" ")}: ${why || err.message.trim()}`);
+    const err2 = e;
+    const why = [err2.stderr, err2.stdout].map(streamText).filter(Boolean).join(" / ");
+    throw new GitError(`git ${args.join(" ")}: ${why || err2.message.trim()}`);
   }
 }
 function git(cwd, args) {
   try {
     return execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
   } catch (e) {
-    const err = e;
-    const why = [err.stderr, err.stdout].map(streamText).filter(Boolean).join(" / ");
-    throw new GitError(`git ${args.join(" ")}: ${why || err.message.trim()}`);
+    const err2 = e;
+    const why = [err2.stderr, err2.stdout].map(streamText).filter(Boolean).join(" / ");
+    throw new GitError(`git ${args.join(" ")}: ${why || err2.message.trim()}`);
   }
 }
 function gitOk(cwd, args) {
@@ -4153,19 +4153,19 @@ function branchForIssue(cwd, issueKey, templates = { name: "issue-{number}" }, r
 function branchCandidates(issueKey, templates, render2) {
   const num = issueKey.replace(/^\D+/, "");
   const unpadded = String(Number.parseInt(num, 10));
-  const candidates = [];
+  const candidates2 = [];
   for (const template of [templates.name, templates.push].filter(Boolean)) {
     const exact = render2(template);
-    candidates.push(exact);
-    if (num !== unpadded) candidates.push(exact.replace(num, unpadded));
+    candidates2.push(exact);
+    if (num !== unpadded) candidates2.push(exact.replace(num, unpadded));
     if (template.includes("{slug}")) {
       const prefix = render2(template.slice(0, template.indexOf("{slug}")));
-      if (prefix) candidates.push(`${prefix}*`);
+      if (prefix) candidates2.push(`${prefix}*`);
     }
   }
-  candidates.push(`issue-${num}`);
-  if (num !== unpadded) candidates.push(`issue-${unpadded}`);
-  return [...new Set(candidates)];
+  candidates2.push(`issue-${num}`);
+  if (num !== unpadded) candidates2.push(`issue-${unpadded}`);
+  return [...new Set(candidates2)];
 }
 function remoteBranchForIssue(cwd, remote, issueKey, templates = { name: "issue-{number}" }, render2 = (t) => t.replace(/\{number\}/g, issueKey.replace(/^\D+/, ""))) {
   const prefix = `refs/remotes/${remote}/`;
@@ -4303,11 +4303,11 @@ function findSquashByBranchTip(cwd, key, branch, range) {
 function findSquashOfBranch(cwd, key, branch, base, range) {
   const byTip = findSquashByBranchTip(cwd, key, branch, range);
   if (byTip) return byTip;
-  const candidates = keyCommitsInRange(cwd, key, range);
-  if (candidates.length === 0) return null;
+  const candidates2 = keyCommitsInRange(cwd, key, range);
+  if (candidates2.length === 0) return null;
   const mb = gitOk(cwd, ["merge-base", base, branch]);
   const branchPatch = mb ? patchIdOf(cwd, mb, branch) : null;
-  for (const sha of candidates) {
+  for (const sha of candidates2) {
     if (gitOk(cwd, ["diff", "--quiet", branch, sha]) !== null) return sha;
     if (branchPatch && gitOk(cwd, ["rev-parse", "--verify", "-q", `${sha}^`]) !== null && patchIdOf(cwd, `${sha}^`, sha) === branchPatch) return sha;
   }
@@ -4556,9 +4556,9 @@ function ensureRepoCheckout(dir, remote, opts = {}) {
   try {
     execFileSync2("git", ["clone", url, dir], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
   } catch (e) {
-    const err = e;
-    const why = [err.stderr, err.stdout].map(streamText).filter(Boolean).join(" / ");
-    throw new GitError(`git clone ${url} ${dir}: ${why || err.message.trim()}`);
+    const err2 = e;
+    const why = [err2.stderr, err2.stdout].map(streamText).filter(Boolean).join(" / ");
+    throw new GitError(`git clone ${url} ${dir}: ${why || err2.message.trim()}`);
   }
   cloneRecorder?.(dir);
   return true;
@@ -4591,8 +4591,8 @@ function acquireCheckoutLock(dir, timeoutMs = 3e4) {
         }
       };
     } catch (e) {
-      const err = e;
-      if (err.code !== "EEXIST") throw err;
+      const err2 = e;
+      if (err2.code !== "EEXIST") throw err2;
       try {
         if (Date.now() - statSync4(lockPath).mtimeMs > CHECKOUT_LOCK_STALE_MS) {
           try {
@@ -4689,13 +4689,13 @@ function baseAttention(repo, outcome, remote, base, nowIso = (/* @__PURE__ */ ne
   if (outcome.action === "level" || outcome.action === "fast-forwarded") return { clear: baseUnsafeKey(repo) };
   return null;
 }
-var agentLogRefusedKey = (route) => `agent_log_refused:${route}`;
-function agentLogRefusedItem(route, role, status2, nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+var agentLogRefusedKey = (route2) => `agent_log_refused:${route2}`;
+function agentLogRefusedItem(route2, role, status2, nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
   return {
     kind: "agent_log_refused",
-    key: agentLogRefusedKey(route),
+    key: agentLogRefusedKey(route2),
     since: nowIso,
-    message: `${route}: 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`
+    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 diskLowKey = (repo) => `disk_low:${repo}`;
@@ -4737,25 +4737,25 @@ function parseHookMissing(key, routeName) {
   if (slash <= 0) return null;
   return { repo: rest.slice(0, slash), hook: rest.slice(slash + 1) };
 }
-function repoStopFor(items, route) {
+function repoStopFor(items, route2) {
   const stops = /* @__PURE__ */ new Map();
   for (const i of items) {
     let repo = null;
     if (i.kind === "base_unsafe") repo = i.key.slice("base_unsafe:".length);
     else if (i.kind === "disk_low") repo = i.key.slice("disk_low:".length);
     else if (i.kind === "hook_missing") {
-      const h = parseHookMissing(i.key, route.route);
+      const h = parseHookMissing(i.key, route2.route);
       if (h?.hook === "setup") repo = h.repo;
     }
     if (repo && !stops.has(repo)) stops.set(repo, i.message);
   }
   if (stops.size === 0) return () => null;
   return (t) => {
-    const name = repoTargetFor(route, t.repo_id)?.name;
+    const name = repoTargetFor(route2, t.repo_id)?.name;
     return name ? stops.get(name) ?? null : null;
   };
 }
-function recheckEnvironmentStops(state, route, ship, deps = {}) {
+function recheckEnvironmentStops(state, route2, ship, deps = {}) {
   const onPath = deps.onPath ?? findOnPath;
   const dockerProblem = deps.dockerProblem ?? dockerPathProblem;
   const cleared = [];
@@ -4768,8 +4768,8 @@ function recheckEnvironmentStops(state, route, ship, deps = {}) {
       continue;
     }
     if (item.kind !== "hook_missing") continue;
-    const h = parseHookMissing(item.key, route.route);
-    const target = h && reposOf(route).find((t) => t.name === h.repo);
+    const h = parseHookMissing(item.key, route2.route);
+    const target = h && reposOf(route2).find((t) => t.name === h.repo);
     if (!h || !target) continue;
     let cfg;
     try {
@@ -4786,11 +4786,11 @@ function recheckEnvironmentStops(state, route, ship, deps = {}) {
   }
   return cleared;
 }
-function recheckBaseStops(state, route) {
+function recheckBaseStops(state, route2) {
   const open = state.shipAttention().previous().filter((i) => i.kind === "base_unsafe");
   const cleared = [];
   for (const item of open) {
-    const target = reposOf(route).find((t) => baseUnsafeKey(t.name) === item.key);
+    const target = reposOf(route2).find((t) => baseUnsafeKey(t.name) === item.key);
     if (!target) continue;
     const cfg = resolveRepoConfig(loadRepoConfig(target.dir), void 0, target.dir);
     const outcome = refreshBaseBranch(target.dir, cfg.branch.remote, cfg.branch.base, true);
@@ -4975,8 +4975,8 @@ function probePushAuth(o, run2 = realGit, baseEnv = process.env) {
     run2(o.dir, ["push", "--dry-run", o.remote, `HEAD:refs/heads/${PROBE_BRANCH}`], env);
     return { state: "ok" };
   } catch (e) {
-    const err = e;
-    const raw = (err.stderr ? String(err.stderr) : err.message).trim().split("\n").filter(Boolean).slice(-2).join(" / ");
+    const err2 = e;
+    const raw = (err2.stderr ? String(err2.stderr) : err2.message).trim().split("\n").filter(Boolean).slice(-2).join(" / ");
     const detail = raw || "push dry-run failed";
     const f = o.forge;
     if (!f) return { state: "failed", detail, hint: pushAuthHint(o.remoteUrl) };
@@ -5350,8 +5350,8 @@ var State = class _State {
    * release blocked in one repo counted cycles for all of them — a dirty tree
    * in one checkout would have silently held up an unrelated project.
    */
-  release(route) {
-    const suffix = _State.safe(route);
+  release(route2) {
+    const suffix = _State.safe(route2);
     const blocked = `.release-blocked-${suffix}`;
     const failed = `.deploy-failed-sha-${suffix}`;
     const gateFailed = `.test-gate-failed-${suffix}`;
@@ -5438,8 +5438,8 @@ var State = class _State {
    * cycle, so "how long has this been waiting" only exists if it survives
    * between them.
    */
-  fairness(route) {
-    const suffix = _State.safe(route);
+  fairness(route2) {
+    const suffix = _State.safe(route2);
     const streakFile = `.fairness-streak-${suffix}`;
     const ticketFile = `.fairness-ticket-${suffix}`;
     const sinceFile = `.fairness-since-${suffix}`;
@@ -5506,8 +5506,8 @@ var State = class _State {
    * currently needing a person emits once, rather than being silently
    * skipped as though already notified.
    */
-  attention(route) {
-    const file = `.attention-${_State.safe(route)}.json`;
+  attention(route2) {
+    const file = `.attention-${_State.safe(route2)}.json`;
     return {
       previous: () => {
         try {
@@ -5529,8 +5529,8 @@ var State = class _State {
    * caller persists the new set beside `attention(route).persist(...)`. A
    * missing or corrupt file reads as empty, so a fresh install warns once.
    */
-  unroutable(route) {
-    const file = `.unroutable-${_State.safe(route)}.json`;
+  unroutable(route2) {
+    const file = `.unroutable-${_State.safe(route2)}.json`;
     return {
       previous: () => {
         try {
@@ -5709,11 +5709,11 @@ function repoSection(r, key, heading) {
   return lines;
 }
 function renderEnvironment(i) {
-  const { route, contract } = i;
+  const { route: route2, contract } = i;
   const repos = i.repos;
   const only = repos.length === 1 ? repos[0] : void 0;
-  const models = route.resolved?.models;
-  const epicsModelId = route.resolved?.epicsModelId;
+  const models = route2.resolved?.models;
+  const epicsModelId = route2.resolved?.epicsModelId;
   const mediaLibraryModelId = i.attachments?.mediaLibraryModelId ?? null;
   const key = "ISSUE-000";
   const lines = [
@@ -5725,7 +5725,7 @@ function renderEnvironment(i) {
     "",
     "## The board",
     "",
-    `- Base URL: \`${route.baseUrl}\``,
+    `- Base URL: \`${route2.baseUrl}\``,
     `- Your key is in the \`${API_KEY_VAR}\` environment variable. Send it as`,
     `  \`Authorization: Bearer $${API_KEY_VAR}\`. **Do not read it out of any file**,`,
     "  and never write it into a comment, a commit or a log line.",
@@ -5743,9 +5743,9 @@ function renderEnvironment(i) {
       ...mediaLibraryModelId ? [`- Media Library: \`${mediaLibraryModelId}\` (what a ticket's \`${contract.columns.attachments}\` ids point into)`] : []
     );
   }
-  const workspaceId = route.resolved?.workspaceId;
+  const workspaceId = route2.resolved?.workspaceId;
   if (workspaceId) {
-    const base = route.baseUrl.replace(/\/+$/, "");
+    const base = route2.baseUrl.replace(/\/+$/, "");
     lines.push(
       "",
       `- Workspace id: \`${workspaceId}\``,
@@ -5801,7 +5801,7 @@ function renderEnvironment(i) {
       "another (the digest prints other ships by name) \u2014 write its name, never a Ships row id."
     );
   }
-  const seatIds = Object.entries(route.resolved?.seats ?? {}).filter(([, id]) => !!id);
+  const seatIds = Object.entries(route2.resolved?.seats ?? {}).filter(([, id]) => !!id);
   if (seatIds.length > 0) {
     lines.push(
       "",
@@ -5854,7 +5854,7 @@ function renderEnvironment(i) {
     "",
     `\`${contract.statuses.verified}\` and the closed statuses are **never yours to set**.`
   );
-  const areaId = route.resolved?.areaId;
+  const areaId = route2.resolved?.areaId;
   if (areaId || repos.some((r) => r.id)) {
     lines.push(
       "",
@@ -6249,7 +6249,7 @@ function queueAgentRun(stateDir, name, q) {
   mkdirSync9(queueDir(stateDir), { recursive: true });
   writeFileSync10(join15(queueDir(stateDir), `${name}.json`), JSON.stringify(q));
 }
-async function replayQueuedAgentRuns(stateDir, route, keyFor, log, now = /* @__PURE__ */ new Date()) {
+async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = queueDir(stateDir);
   if (!existsSync14(dir)) return 0;
   let sent = 0;
@@ -6261,7 +6261,7 @@ async function replayQueuedAgentRuns(stateDir, route, keyFor, log, now = /* @__P
     } catch {
       continue;
     }
-    if (q.version !== 1 || q.route !== route || now.toISOString() < q.nextAttemptAt) continue;
+    if (q.version !== 1 || q.route !== route2 || now.toISOString() < q.nextAttemptAt) continue;
     try {
       const apiKey = await keyFor(q.role);
       if (!apiKey) continue;
@@ -6302,7 +6302,7 @@ function queueTicketCounters(stateDir, name, q) {
   mkdirSync9(countersDir(stateDir), { recursive: true });
   writeFileSync10(join15(countersDir(stateDir), `${name}.json`), JSON.stringify(q));
 }
-async function replayQueuedTicketCounters(stateDir, route, keyFor, log, now = /* @__PURE__ */ new Date()) {
+async function replayQueuedTicketCounters(stateDir, route2, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = countersDir(stateDir);
   if (!existsSync14(dir)) return 0;
   let sent = 0;
@@ -6314,7 +6314,7 @@ async function replayQueuedTicketCounters(stateDir, route, keyFor, log, now = /*
     } catch {
       continue;
     }
-    if (q.version !== 1 || q.route !== route || now.toISOString() < q.nextAttemptAt) continue;
+    if (q.version !== 1 || q.route !== route2 || now.toISOString() < q.nextAttemptAt) continue;
     try {
       const apiKey = await keyFor(q.role);
       if (!apiKey) continue;
@@ -6594,8 +6594,8 @@ function projectModeLabels(rows) {
 
 // src/board-lock.ts
 import { StaleWriteError } from "@tablation/client";
-function releaseLockScope(route, repo) {
-  return `${route}/${repo}`;
+function releaseLockScope(route2, repo) {
+  return `${route2}/${repo}`;
 }
 async function acquireBoardLock(client2, modelId, scope, holderLabel, ttlMs, log = {}) {
   if (!modelId) return { ok: true, release: async () => {
@@ -6723,21 +6723,21 @@ var Tracker = class {
    */
   /** Told once per failed best-effort read (`events`); poll.ts points it at the pass's emitter. */
   onReadFailure;
-  constructor(route, ship, opts = {}) {
-    this.route = route;
-    if (!route.resolved) {
+  constructor(route2, ship, opts = {}) {
+    this.route = route2;
+    if (!route2.resolved) {
       throw new ConfigError(
-        `route "${route.route}" has no resolved ids \u2014 run \`crew connect\` to discover them from the project`
+        `route "${route2.route}" has no resolved ids \u2014 run \`crew connect\` to discover them from the project`
       );
     }
-    this.models = route.resolved.models;
-    this.contract = resolveContract(route.contract);
+    this.models = route2.resolved.models;
+    this.contract = resolveContract(route2.contract);
     this.userAgent = ship.userAgent;
     this.shipName = ship.name;
     this.stateDir = ship.stateDir;
     this.client = new TablationClient({
-      baseUrl: `${route.baseUrl}/api`,
-      apiKey: opts.apiKey ?? resolveApiKey(route),
+      baseUrl: `${route2.baseUrl}/api`,
+      apiKey: opts.apiKey ?? resolveApiKey(route2),
       // Cloudflare 403s (error 1010) default agents on this host.
       headers: { "User-Agent": ship.userAgent }
     });
@@ -7205,8 +7205,8 @@ var Tracker = class {
       if (res.status === 404) return [];
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       rows = await res.json();
-    } catch (err) {
-      this.onReadFailure?.(`reading ${type} events failed: ${err instanceof Error ? err.message : String(err)}`);
+    } catch (err2) {
+      this.onReadFailure?.(`reading ${type} events failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
       return [];
     }
     return rows.filter((e) => e.event_type === type).sort((a, b) => Date.parse(b.occurred_at ?? b.created_at ?? "") - Date.parse(a.occurred_at ?? a.created_at ?? ""));
@@ -8059,14 +8059,14 @@ async function enforceHandoff(i) {
     return { kind: "failed", why: e.message };
   }
 }
-async function guardRunHandoff(route, ship, tracker, role, workingId, log, since2) {
-  const replayed = await replayRoutePending(route, ship, tracker, log, role);
+async function guardRunHandoff(route2, ship, tracker, role, workingId, log, since2) {
+  const replayed = await replayRoutePending(route2, ship, tracker, log, role);
   if (!workingId || role !== "dev" && role !== "design" && role !== "qa") return null;
-  const seatId = route.resolved?.seats[role];
+  const seatId = route2.resolved?.seats[role];
   if (!seatId) return null;
   try {
     const t = await tracker.ticket(workingId);
-    const resolved = repoConfigFor(route, t);
+    const resolved = repoConfigFor(route2, t);
     if (!resolved) return null;
     const { target, cfg } = resolved;
     if (role === "qa") {
@@ -8094,7 +8094,7 @@ async function guardRunHandoff(route, ship, tracker, role, workingId, log, since
         log.emit(`${t.issue_id}: dropped ${branch} \u2014 the run made no commits beyond ${cfg.branch.base}`, { ticket: t.issue_id, step: "handoff" });
       }
     }
-    if (since2) await guardRunStrays(route, ship, tracker, role, workingId, since2, log);
+    if (since2) await guardRunStrays(route2, ship, tracker, role, workingId, since2, log);
     return outcome;
   } catch (e) {
     log.warn(`could not check the hand-off: ${e.message}`, { step: "handoff" });
@@ -8117,29 +8117,29 @@ async function retireRunWorktree(tracker, dir, cfg, t, role, seatId, shipName2,
     log.warn(`could not retire the run's worktree: ${e.message}`, { step: "handoff" });
   }
 }
-function repoConfigFor(route, t) {
-  const target = repoTargetFor(route, t.repo_id);
+function repoConfigFor(route2, t) {
+  const target = repoTargetFor(route2, t.repo_id);
   if (!target) return null;
-  const o = route.repoOverrides[target.name];
+  const o = route2.repoOverrides[target.name];
   const cfg = resolveRepoConfig(loadRepoConfig(target.dir), {
-    hooks: { ...route.hooks, ...o?.hooks },
-    labels: { ...route.labels, ...o?.labels },
-    branch: { ...route.branch, ...o?.branch },
+    hooks: { ...route2.hooks, ...o?.hooks },
+    labels: { ...route2.labels, ...o?.labels },
+    branch: { ...route2.branch, ...o?.branch },
     worktrees: { nameOverride: o?.worktreeName }
   }, target.dir);
   return { target, cfg };
 }
-async function replayRoutePending(route, ship, tracker, log, role) {
+async function replayRoutePending(route2, ship, tracker, log, role) {
   try {
     return await replayPendingHandoffs({
       writer: tracker,
       contract: tracker.contract,
       stateDir: ship.stateDir,
-      route: routeSlug(route.route),
+      route: routeSlug(route2.route),
       role,
-      seats: route.resolved?.seats ?? {},
+      seats: route2.resolved?.seats ?? {},
       checkout: (t) => {
-        const r = repoConfigFor(route, t);
+        const r = repoConfigFor(route2, t);
         return r ? { dir: r.target.dir, cfg: r.cfg } : null;
       },
       log
@@ -8195,23 +8195,23 @@ ${i.shipName ? `${i.shipName}'s ` : "A "}${i.role} run set it to \`${st.handoff}
     }
   }
 }
-async function guardRunStrays(route, ship, tracker, role, workingId, since2, log) {
-  const seatId = route.resolved?.seats[role];
+async function guardRunStrays(route2, ship, tracker, role, workingId, since2, log) {
+  const seatId = route2.resolved?.seats[role];
   if (!seatId) return;
   try {
     const affinity = await tracker.claimAffinity();
-    const candidates = await tracker.handedOffSince(since2, workingId);
-    if (candidates.length === 0) return;
+    const candidates2 = await tracker.handedOffSince(since2, workingId);
+    if (candidates2.length === 0) return;
     await guardStrayHandoffs({
       writer: tracker,
       contract: tracker.contract,
-      candidates,
+      candidates: candidates2,
       seatId,
       role,
       myShipId: affinity?.shipId ?? null,
       shipName: ship.name,
       checkout: (t) => {
-        const r = repoConfigFor(route, t);
+        const r = repoConfigFor(route2, t);
         return r ? { dir: r.target.dir, cfg: r.cfg } : null;
       },
       log
@@ -8230,14 +8230,14 @@ function writePendingHandoff(stateDir, rec) {
   mkdirSync10(dir, { recursive: true });
   writeFileSync11(join18(dir, `${rec.ticketRecordId}.json`), JSON.stringify(rec, null, 2));
 }
-function listPendingHandoffs(stateDir, route) {
+function listPendingHandoffs(stateDir, route2) {
   const dir = pendingDirFor(stateDir);
   if (!existsSync17(dir)) return [];
   const out = [];
   for (const f of readdirSync7(dir).filter((n) => n.endsWith(".json")).sort()) {
     try {
       const rec = JSON.parse(readFileSync15(join18(dir, f), "utf8"));
-      if (rec.version === 1 && rec.ticketRecordId && (!route || rec.route === route)) out.push(rec);
+      if (rec.version === 1 && rec.ticketRecordId && (!route2 || rec.route === route2)) out.push(rec);
     } catch {
     }
   }
@@ -8393,61 +8393,61 @@ function personaDefaultPrompt(promptsDir, role) {
   if (!existsSync18(commonPath)) return readFileSync16(briefPath, "utf8");
   return `${readFileSync16(commonPath, "utf8")}${readFileSync16(briefPath, "utf8")}`;
 }
-async function resolveAgentId(route, role, opts) {
-  const cached = route.resolved?.agentPersonas?.[role]?.agentId;
+async function resolveAgentId(route2, role, opts) {
+  const cached = route2.resolved?.agentPersonas?.[role]?.agentId;
   if (cached) return cached;
-  const seatId = route.resolved?.seats?.[role];
-  if (!seatId || !route.resolved) return void 0;
+  const seatId = route2.resolved?.seats?.[role];
+  if (!seatId || !route2.resolved) return void 0;
   const client2 = new TablationClient2({
-    baseUrl: `${route.baseUrl}/api`,
-    apiKey: resolveApiKey(route),
+    baseUrl: `${route2.baseUrl}/api`,
+    apiKey: resolveApiKey(route2),
     headers: { "User-Agent": opts.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
   });
   try {
-    const row = await client2.records.get(route.resolved.models.crew, seatId);
+    const row = await client2.records.get(route2.resolved.models.crew, seatId);
     return row.agent_id ?? void 0;
   } catch {
     return void 0;
   }
 }
-async function fetchPersonaPrompt(route, role, opts) {
-  const agentId = await resolveAgentId(route, role, opts);
-  if (!agentId || !route.resolved) return {};
+async function fetchPersonaPrompt(route2, role, opts) {
+  const agentId = await resolveAgentId(route2, role, opts);
+  if (!agentId || !route2.resolved) return {};
   const client2 = new TablationClient2({
-    baseUrl: `${route.baseUrl}/api`,
-    apiKey: resolveApiKey(route),
+    baseUrl: `${route2.baseUrl}/api`,
+    apiKey: resolveApiKey(route2),
     headers: { "User-Agent": opts.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
   });
   let row;
   let agentsModelId;
   try {
-    const agentsModel = await client2.dataModels.get("agents", route.resolved.workspaceId);
+    const agentsModel = await client2.dataModels.get("agents", route2.resolved.workspaceId);
     agentsModelId = agentsModel.id;
     row = await client2.records.get(agentsModelId, agentId);
   } catch {
     return {};
   }
   const additions = typeof row.prompt_additions === "string" && row.prompt_additions.trim() !== "" ? row.prompt_additions : void 0;
-  const divergedPrompt = await divergedRowPrompt(route, role, row, agentId, agentsModelId, opts);
+  const divergedPrompt = await divergedRowPrompt(route2, role, row, agentId, agentsModelId, opts);
   return { divergedPrompt, additions };
 }
 function personaPromptOptions(p) {
   return { divergedPrompt: p.divergedPrompt, personaAdditions: p.additions };
 }
-async function divergedRowPrompt(route, role, row, agentId, agentsModelId, opts) {
-  if (!route.resolved) return void 0;
-  const defaultPrompt = personaDefaultPrompt(route.promptsDir, role);
+async function divergedRowPrompt(route2, role, row, agentId, agentsModelId, opts) {
+  if (!route2.resolved) return void 0;
+  const defaultPrompt = personaDefaultPrompt(route2.promptsDir, role);
   if (row.prompt === defaultPrompt) return void 0;
-  const cached = route.resolved.agentPersonas?.[role];
+  const cached = route2.resolved.agentPersonas?.[role];
   if (cached?.agentId === agentId && cached.historyId) {
-    const lastSynced = await fetchLastSyncedPrompt(route, agentsModelId, agentId, cached.historyId, opts.userAgent);
+    const lastSynced = await fetchLastSyncedPrompt(route2, agentsModelId, agentId, cached.historyId, opts.userAgent);
     if (lastSynced !== void 0 && lastSynced === row.prompt) return void 0;
   }
   return row.prompt;
 }
-async function fetchLastSyncedPrompt(route, agentsModelId, recordId, historyId, userAgent) {
+async function fetchLastSyncedPrompt(route2, agentsModelId, recordId, historyId, userAgent) {
   try {
-    const entries = await fetchHistoryEntries(route, agentsModelId, recordId, userAgent);
+    const entries = await fetchHistoryEntries(route2, agentsModelId, recordId, userAgent);
     return entries.find((e) => e.history_id === historyId)?.prompt;
   } catch {
     return void 0;
@@ -8457,16 +8457,16 @@ function choiceValue(v) {
   const raw = typeof v === "string" ? v : v && typeof v === "object" ? v.value ?? v.key : void 0;
   return typeof raw === "string" && raw.trim() ? raw.trim().toLowerCase() : void 0;
 }
-async function fetchSeatPersona(route, role, opts) {
-  const agentId = await resolveAgentId(route, role, opts);
-  if (!agentId || !route.resolved) return void 0;
+async function fetchSeatPersona(route2, role, opts) {
+  const agentId = await resolveAgentId(route2, role, opts);
+  if (!agentId || !route2.resolved) return void 0;
   const client2 = new TablationClient2({
-    baseUrl: `${route.baseUrl}/api`,
-    apiKey: resolveApiKey(route),
+    baseUrl: `${route2.baseUrl}/api`,
+    apiKey: resolveApiKey(route2),
     headers: { "User-Agent": opts.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
   });
   try {
-    const agentsModel = await client2.dataModels.get("agents", route.resolved.workspaceId);
+    const agentsModel = await client2.dataModels.get("agents", route2.resolved.workspaceId);
     const row = await client2.records.get(agentsModel.id, agentId);
     const tier = choiceValue(row.tier);
     const vendor = choiceValue(row.vendor);
@@ -8480,24 +8480,24 @@ async function fetchSeatPersona(route, role, opts) {
     return void 0;
   }
 }
-async function currentPersonaPrompt(route, role, opts) {
-  const { divergedPrompt, additions } = await fetchPersonaPrompt(route, role, opts);
-  return appendAdditions(divergedPrompt ?? personaDefaultPrompt(route.promptsDir, role), additions);
+async function currentPersonaPrompt(route2, role, opts) {
+  const { divergedPrompt, additions } = await fetchPersonaPrompt(route2, role, opts);
+  return appendAdditions(divergedPrompt ?? personaDefaultPrompt(route2.promptsDir, role), additions);
 }
-async function fetchHistoryEntries(route, agentsModelId, recordId, userAgent, limit = 50) {
-  const url = `${route.baseUrl.replace(/\/+$/, "")}/api/data-models/${agentsModelId}/records/${recordId}/history?limit=${limit}`;
+async function fetchHistoryEntries(route2, agentsModelId, recordId, userAgent, limit = 50) {
+  const url = `${route2.baseUrl.replace(/\/+$/, "")}/api/data-models/${agentsModelId}/records/${recordId}/history?limit=${limit}`;
   const res = await fetch(url, {
     headers: {
-      Authorization: `Bearer ${resolveApiKey(route)}`,
+      Authorization: `Bearer ${resolveApiKey(route2)}`,
       "User-Agent": userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0"
     }
   });
   if (!res.ok) throw new AgentsSyncError(`history lookup for ${recordId}: ${res.status} ${res.statusText}`);
   return await res.json();
 }
-async function fetchLatestHistoryId(route, agentsModelId, recordId, userAgent) {
+async function fetchLatestHistoryId(route2, agentsModelId, recordId, userAgent) {
   try {
-    const entries = await fetchHistoryEntries(route, agentsModelId, recordId, userAgent, 1);
+    const entries = await fetchHistoryEntries(route2, agentsModelId, recordId, userAgent, 1);
     return entries[0]?.history_id;
   } catch {
     return void 0;
@@ -8506,11 +8506,11 @@ async function fetchLatestHistoryId(route, agentsModelId, recordId, userAgent) {
 function isAdminRole(role) {
   return role === void 0 || role === "WORKSPACE_ADMIN" || role === "PLATFORM_ADMIN";
 }
-async function fetchKeyRole(route, userAgent) {
-  if (!route.resolved) return void 0;
+async function fetchKeyRole(route2, userAgent) {
+  if (!route2.resolved) return void 0;
   try {
-    const res = await fetch(`${route.baseUrl.replace(/\/+$/, "")}/api/auth/me?workspaceId=${route.resolved.workspaceId}`, {
-      headers: { Authorization: `Bearer ${resolveApiKey(route)}`, "User-Agent": userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
+    const res = await fetch(`${route2.baseUrl.replace(/\/+$/, "")}/api/auth/me?workspaceId=${route2.resolved.workspaceId}`, {
+      headers: { Authorization: `Bearer ${resolveApiKey(route2)}`, "User-Agent": userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
     });
     if (!res.ok) return void 0;
     const me = await res.json();
@@ -8536,14 +8536,14 @@ function isPromptGateRejection(e) {
 }
 var RELEASE_AGENT_NAME = "Release agent";
 var RELEASE_AGENT_PROMPT = "Principal for the crew release phase (merge, deploy, release comments). It runs no model; this row only gives those tracker writes an agent identity.";
-async function syncPersonas(route, opts) {
-  if (!route.resolved) {
-    throw new AgentsSyncError(`route "${route.route}" has no resolved ids \u2014 run \`crew connect\` first`);
+async function syncPersonas(route2, opts) {
+  if (!route2.resolved) {
+    throw new AgentsSyncError(`route "${route2.route}" has no resolved ids \u2014 run \`crew connect\` first`);
   }
-  const workspaceId = route.resolved.workspaceId;
+  const workspaceId = route2.resolved.workspaceId;
   const client2 = new TablationClient2({
-    baseUrl: `${route.baseUrl}/api`,
-    apiKey: resolveApiKey(route),
+    baseUrl: `${route2.baseUrl}/api`,
+    apiKey: resolveApiKey(route2),
     headers: { "User-Agent": opts.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
   });
   let agentsModel;
@@ -8558,12 +8558,12 @@ async function syncPersonas(route, opts) {
     throw e;
   }
   const rows = await client2.records.list(agentsModel.id, { limit: 200 });
-  const cache = route.resolved.agentPersonas ?? {};
+  const cache = route2.resolved.agentPersonas ?? {};
   const outcomes = [];
   const agentPersonas = { ...cache };
   for (const role of ROLE_NAMES) {
     const name = PERSONA_NAME[role];
-    const defaultPrompt = personaDefaultPrompt(route.promptsDir, role);
+    const defaultPrompt = personaDefaultPrompt(route2.promptsDir, role);
     const row = rows.find((r) => r.name === name);
     if (opts.readOnly) {
       if (!row) {
@@ -8581,7 +8581,7 @@ async function syncPersonas(route, opts) {
         continue;
       }
       const created = await client2.records.create(agentsModel.id, { name, prompt: defaultPrompt, ...promptSourceFields(agentsModel, defaultPrompt) });
-      const historyId = await fetchLatestHistoryId(route, agentsModel.id, created.id, opts.userAgent);
+      const historyId = await fetchLatestHistoryId(route2, agentsModel.id, created.id, opts.userAgent);
       agentPersonas[role] = { agentId: created.id, lastSyncedUpdatedAt: created.updated_at, ...historyId ? { historyId } : {} };
       outcomes.push({ role, action: "created", agentId: created.id });
       continue;
@@ -8595,7 +8595,7 @@ async function syncPersonas(route, opts) {
           if (!(e instanceof StaleWriteError2) && !isPromptGateRejection(e)) throw e;
         }
       }
-      const historyId = await fetchLatestHistoryId(route, agentsModel.id, row.id, opts.userAgent);
+      const historyId = await fetchLatestHistoryId(route2, agentsModel.id, row.id, opts.userAgent);
       agentPersonas[role] = { agentId: row.id, lastSyncedUpdatedAt: anchoredAt, ...historyId ? { historyId } : {} };
       outcomes.push({ role, action: "unchanged", agentId: row.id });
       continue;
@@ -8620,7 +8620,7 @@ async function syncPersonas(route, opts) {
         agentPersonas[role] = { agentId: row.id, lastSyncedUpdatedAt: row.updated_at, ...cache[role]?.agentId === row.id && cache[role]?.historyId ? { historyId: cache[role].historyId } : {} };
         continue;
       }
-      const historyId = await fetchLatestHistoryId(route, agentsModel.id, row.id, opts.userAgent);
+      const historyId = await fetchLatestHistoryId(route2, agentsModel.id, row.id, opts.userAgent);
       agentPersonas[role] = { agentId: row.id, lastSyncedUpdatedAt: updated.updated_at, ...historyId ? { historyId } : {} };
       outcomes.push({ role, action: "forced", agentId: row.id, previousPrompt: row.prompt });
       continue;
@@ -8639,7 +8639,7 @@ async function syncPersonas(route, opts) {
       }
       let lastSyncedPrompt;
       try {
-        const entries = await fetchHistoryEntries(route, agentsModel.id, row.id, opts.userAgent);
+        const entries = await fetchHistoryEntries(route2, agentsModel.id, row.id, opts.userAgent);
         lastSyncedPrompt = entries.find((e) => e.history_id === cached.historyId)?.prompt;
       } catch {
         lastSyncedPrompt = void 0;
@@ -8660,7 +8660,7 @@ async function syncPersonas(route, opts) {
         { prompt: defaultPrompt, ...promptSourceFields(agentsModel, defaultPrompt) },
         row.updated_at
       );
-      const historyId = await fetchLatestHistoryId(route, agentsModel.id, row.id, opts.userAgent);
+      const historyId = await fetchLatestHistoryId(route2, agentsModel.id, row.id, opts.userAgent);
       agentPersonas[role] = { agentId: row.id, lastSyncedUpdatedAt: updated.updated_at, ...historyId ? { historyId } : {} };
       outcomes.push({ role, action: "updated", agentId: row.id });
     } catch (e) {
@@ -8676,8 +8676,8 @@ async function syncPersonas(route, opts) {
       throw e;
     }
   }
-  const crewLinks = opts.dryRun ? [] : await linkCrewSeats(route, client2, agentsModel.id, agentPersonas, opts.userAgent, opts.readOnly === true);
-  const release = opts.dryRun ? { agentId: route.resolved.releaseAgentId } : await linkReleaseSeat(route, client2, agentsModel, opts.userAgent, opts.readOnly === true);
+  const crewLinks = opts.dryRun ? [] : await linkCrewSeats(route2, client2, agentsModel.id, agentPersonas, opts.userAgent, opts.readOnly === true);
+  const release = opts.dryRun ? { agentId: route2.resolved.releaseAgentId } : await linkReleaseSeat(route2, client2, agentsModel, opts.userAgent, opts.readOnly === true);
   return {
     outcomes,
     agentPersonas,
@@ -8687,8 +8687,8 @@ async function syncPersonas(route, opts) {
     ...opts.readOnly ? { readOnly: true } : {}
   };
 }
-async function linkReleaseSeat(route, client2, agentsModel, userAgent, readOnly) {
-  const seatId = route.resolved.releaseSeat;
+async function linkReleaseSeat(route2, client2, agentsModel, userAgent, readOnly) {
+  const seatId = route2.resolved.releaseSeat;
   if (!seatId) return {};
   const rows = await client2.records.list(agentsModel.id, { limit: 200 });
   let agentId = rows.find((r) => r.name === RELEASE_AGENT_NAME)?.id;
@@ -8705,11 +8705,11 @@ async function linkReleaseSeat(route, client2, agentsModel, userAgent, readOnly)
       throw e;
     }
   }
-  const crewModelId = route.resolved.models.crew;
+  const crewModelId = route2.resolved.models.crew;
   const crewModel = await client2.dataModels.get(crewModelId);
   let columnName;
   try {
-    columnName = await ensureCrewAgentField(route, client2, crewModel, agentsModel.id, userAgent);
+    columnName = await ensureCrewAgentField(route2, client2, crewModel, agentsModel.id, userAgent);
   } catch (e) {
     if (e instanceof CrewAgentFieldMissing) return { note: `Release: ${CREW_FIELD_MISSING_NOTE}` };
     throw e;
@@ -8722,18 +8722,18 @@ var NO_WRITE_NOTE = "this key has no write access to the Agents table";
 var CREW_FIELD_MISSING_NOTE = "Crew table has no Agent field yet \u2014 a workspace admin's `crew agents sync` adds it";
 var CrewAgentFieldMissing = class extends Error {
 };
-async function linkCrewSeats(route, client2, agentsModelId, agentPersonas, userAgent, readOnly) {
-  const seats2 = route.resolved.seats;
+async function linkCrewSeats(route2, client2, agentsModelId, agentPersonas, userAgent, readOnly) {
+  const seats2 = route2.resolved.seats;
   const rolesWithSeats = ROLE_NAMES.filter((role) => seats2[role] && agentPersonas[role]);
   if (rolesWithSeats.length === 0) {
     if (readOnly) return ROLE_NAMES.map((role) => ({ role, action: seats2[role] ? "no_agents_row" : "no_seat" }));
     return ROLE_NAMES.map((role) => ({ role, action: seats2[role] ? "persona_diverged" : "no_seat" }));
   }
-  const crewModelId = route.resolved.models.crew;
+  const crewModelId = route2.resolved.models.crew;
   const crewModel = await client2.dataModels.get(crewModelId);
   let columnName;
   try {
-    columnName = await ensureCrewAgentField(route, client2, crewModel, agentsModelId, userAgent);
+    columnName = await ensureCrewAgentField(route2, client2, crewModel, agentsModelId, userAgent);
   } catch (e) {
     if (e instanceof CrewAgentFieldMissing) {
       return ROLE_NAMES.map((role) => ({ role, action: seats2[role] ? "no_agent_field" : "no_seat" }));
@@ -8762,14 +8762,14 @@ async function linkCrewSeats(route, client2, agentsModelId, agentPersonas, userA
   }
   return outcomes;
 }
-async function ensureCrewAgentField(route, client2, crewModel, agentsModelId, userAgent) {
+async function ensureCrewAgentField(route2, client2, crewModel, agentsModelId, userAgent) {
   const existing = crewModel.fields.find(
     (f) => f.fieldType?.kind === "REFERENCE" && f.fieldType.targetModelId === agentsModelId && f.fieldType.isMultiple === false
   );
   if (existing) return existing.columnName;
-  const workspaceId = route.resolved.workspaceId;
-  const baseUrl = route.baseUrl.replace(/\/+$/, "");
-  const apiKey = resolveApiKey(route);
+  const workspaceId = route2.resolved.workspaceId;
+  const baseUrl = route2.baseUrl.replace(/\/+$/, "");
+  const apiKey = resolveApiKey(route2);
   const headers = { Authorization: `Bearer ${apiKey}`, "User-Agent": userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" };
   const typesRes = await fetch(`${baseUrl}/api/workspaces/${workspaceId}/field-types`, { headers });
   if (!typesRes.ok) throw new AgentsSyncError(`field-types lookup failed: ${typesRes.status} ${typesRes.statusText}`);
@@ -8855,14 +8855,14 @@ function listLocalSkills(promptsDir) {
   if (!existsSync19(dir)) return [];
   return readdirSync8(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join20(dir, f)));
 }
-async function syncSkills(route, opts) {
-  if (!route.resolved) {
-    throw new SkillSyncError(`route "${route.route}" has no resolved ids \u2014 run \`crew connect\` first`);
+async function syncSkills(route2, opts) {
+  if (!route2.resolved) {
+    throw new SkillSyncError(`route "${route2.route}" has no resolved ids \u2014 run \`crew connect\` first`);
   }
-  const workspaceId = route.resolved.workspaceId;
+  const workspaceId = route2.resolved.workspaceId;
   const client2 = new TablationClient3({
-    baseUrl: `${route.baseUrl}/api`,
-    apiKey: resolveApiKey(route),
+    baseUrl: `${route2.baseUrl}/api`,
+    apiKey: resolveApiKey(route2),
     headers: { "User-Agent": opts.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
   });
   let skillsModel;
@@ -8876,9 +8876,9 @@ async function syncSkills(route, opts) {
     }
     throw e;
   }
-  const local = listLocalSkills(route.promptsDir);
+  const local = listLocalSkills(route2.promptsDir);
   const rows = await client2.records.list(skillsModel.id, { limit: 200 });
-  const cache = route.resolved.agentSkills ?? {};
+  const cache = route2.resolved.agentSkills ?? {};
   const outcomes = [];
   const agentSkills = { ...cache };
   for (const skill of local) {
@@ -8994,22 +8994,22 @@ function describeSkillSyncOutcome(o) {
       return `${o.name}: HAS LOCAL EDITS \u2014 crew's default is newer but was NOT applied; review ${o.skillId} in the app before syncing again`;
   }
 }
-async function fetchSkillOverrides(route, opts) {
-  if (!route.resolved) return {};
+async function fetchSkillOverrides(route2, opts) {
+  if (!route2.resolved) return {};
   const client2 = new TablationClient3({
-    baseUrl: `${route.baseUrl}/api`,
-    apiKey: resolveApiKey(route),
+    baseUrl: `${route2.baseUrl}/api`,
+    apiKey: resolveApiKey(route2),
     headers: { "User-Agent": opts.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
   });
   let rows;
   try {
-    const model = await client2.dataModels.get("agent_skills", route.resolved.workspaceId);
+    const model = await client2.dataModels.get("agent_skills", route2.resolved.workspaceId);
     rows = await client2.records.list(model.id, { limit: 200 });
   } catch {
     return {};
   }
-  const local = new Map(listLocalSkills(route.promptsDir).map((s) => [s.name, s]));
-  const cache = route.resolved.agentSkills ?? {};
+  const local = new Map(listLocalSkills(route2.promptsDir).map((s) => [s.name, s]));
+  const cache = route2.resolved.agentSkills ?? {};
   const out = {};
   for (const row of rows) {
     const name = row.name;
@@ -9625,10 +9625,10 @@ function spawnAgent(plan, emit, hintMoved) {
     const tail3 = new FileTail(plan.streamPath);
     const timer = setInterval(() => obs.feed(tail3.poll()), TAIL_POLL_MS);
     let spawnFailed = false;
-    child.on("error", (err) => {
+    child.on("error", (err2) => {
       spawnFailed = true;
       clearInterval(timer);
-      reject(new AgentSpawnError(`cannot run ${plan.bin}: ${err.message}`));
+      reject(new AgentSpawnError(`cannot run ${plan.bin}: ${err2.message}`));
     });
     child.on("close", async (code) => {
       clearInterval(timer);
@@ -9639,8 +9639,8 @@ function spawnAgent(plan, emit, hintMoved) {
       const { ms: ms3, handoffPending } = await finishRun(id, obs, emit, startedAt, { code: code ?? 1 }, plan.agentLog?.apiKey, hintMoved);
       resolve6({ code: code ?? 1, ms: ms3, ...handoffPending ? { handoffPending } : {} });
     });
-    child.stdin?.on("error", (err) => {
-      emit.warn(`agent closed stdin before the prompt was delivered: ${err.message}`, { step: "agent" });
+    child.stdin?.on("error", (err2) => {
+      emit.warn(`agent closed stdin before the prompt was delivered: ${err2.message}`, { step: "agent" });
     });
     child.stdin?.end(plan.prompt);
   });
@@ -9682,8 +9682,8 @@ async function reattachRun(streamPath, sc, emit, o = {}) {
 // src/seat-keys.ts
 import { getSessionStore as getSessionStore2, hostFromUrl as hostFromUrl2 } from "@tablation/client";
 var SEAT_KEY_ROLES = ROLE_NAMES.filter((r) => r !== "pair");
-function keyIsAdmin(route) {
-  const role = route.resolved?.role;
+function keyIsAdmin(route2) {
+  const role = route2.resolved?.role;
   return role === void 0 || role === "WORKSPACE_ADMIN" || role === "PLATFORM_ADMIN";
 }
 var MEMBER_NO_ROW = "has no linked Agents row \u2014 a workspace admin's `crew agents sync` creates the persona rows; run it here afterwards to link this ship's seats";
@@ -9692,41 +9692,41 @@ var FORBIDDEN_LINE = 'seat keys: not minted \u2014 your role does not grant "Min
 function seatKeySlug(workspaceSlug, agentId) {
   return `${workspaceSlug}#agent:${agentId}`;
 }
-function slugFor(route, agentId) {
-  const [workspaceSlug] = splitRoute(route.route);
+function slugFor(route2, agentId) {
+  const [workspaceSlug] = splitRoute(route2.route);
   return seatKeySlug(workspaceSlug, agentId);
 }
-function seatAgentId(route, role) {
-  return route.resolved?.agentPersonas?.[role]?.agentId;
+function seatAgentId(route2, role) {
+  return route2.resolved?.agentPersonas?.[role]?.agentId;
 }
-async function resolveReleaseKey(route, getStore = getSessionStore2) {
-  const ship = (reason) => ({ kind: "ship", apiKey: resolveApiKey(route), reason });
-  const agentId = route.resolved?.releaseAgentId;
-  if (!agentId) return ship(keyIsAdmin(route) ? "release seat has no linked Agents row (run `crew agents sync`)" : `release seat ${MEMBER_NO_ROW}`);
+async function resolveReleaseKey(route2, getStore = getSessionStore2) {
+  const ship = (reason) => ({ kind: "ship", apiKey: resolveApiKey(route2), reason });
+  const agentId = route2.resolved?.releaseAgentId;
+  if (!agentId) return ship(keyIsAdmin(route2) ? "release seat has no linked Agents row (run `crew agents sync`)" : `release seat ${MEMBER_NO_ROW}`);
   try {
-    const session = await getStore().get(hostFromUrl2(route.baseUrl), slugFor(route, agentId));
+    const session = await getStore().get(hostFromUrl2(route2.baseUrl), slugFor(route2, agentId));
     if (session?.apiKey) return { kind: "agent", apiKey: session.apiKey, agentId };
-    return ship(keyIsAdmin(route) ? "no agent key stored for the release seat (run `crew agents sync`)" : MEMBER_NO_KEY);
+    return ship(keyIsAdmin(route2) ? "no agent key stored for the release seat (run `crew agents sync`)" : MEMBER_NO_KEY);
   } catch (e) {
     return ship(describeReadError(e));
   }
 }
-async function resolveSeatKey(route, role, getStore = getSessionStore2) {
-  const ship = (reason) => ({ kind: "ship", apiKey: resolveApiKey(route), reason });
+async function resolveSeatKey(route2, role, getStore = getSessionStore2) {
+  const ship = (reason) => ({ kind: "ship", apiKey: resolveApiKey(route2), reason });
   if (!SEAT_KEY_ROLES.includes(role)) return ship(`${role} always writes as the ship`);
-  const agentId = seatAgentId(route, role);
-  if (!agentId) return ship(keyIsAdmin(route) ? "seat has no linked Agents row (run `crew agents sync`)" : `seat ${MEMBER_NO_ROW}`);
+  const agentId = seatAgentId(route2, role);
+  if (!agentId) return ship(keyIsAdmin(route2) ? "seat has no linked Agents row (run `crew agents sync`)" : `seat ${MEMBER_NO_ROW}`);
   try {
-    const session = await getStore().get(hostFromUrl2(route.baseUrl), slugFor(route, agentId));
+    const session = await getStore().get(hostFromUrl2(route2.baseUrl), slugFor(route2, agentId));
     if (session?.apiKey) return { kind: "agent", apiKey: session.apiKey, agentId };
-    return ship(keyIsAdmin(route) ? "no agent key stored for this seat (run `crew agents sync`)" : MEMBER_NO_KEY);
+    return ship(keyIsAdmin(route2) ? "no agent key stored for this seat (run `crew agents sync`)" : MEMBER_NO_KEY);
   } catch (e) {
     return ship(describeReadError(e));
   }
 }
 function safeStderrLine(e) {
-  const err = e;
-  const raw = typeof err?.stderr === "string" && err.stderr.trim() ? err.stderr : typeof err?.message === "string" ? err.message : "";
+  const err2 = e;
+  const raw = typeof err2?.stderr === "string" && err2.stderr.trim() ? err2.stderr : typeof err2?.message === "string" ? err2.message : "";
   for (const line of raw.split("\n")) {
     const t = line.trim();
     if (!t || /^Command failed:/i.test(t) || /(^|\s)-w(\s|$)/.test(t)) continue;
@@ -9752,13 +9752,13 @@ function describeStoreError(e) {
   }
   return "keychain unavailable (could not write to the OS keychain)";
 }
-async function mintMissingSeatKeys(route, o) {
+async function mintMissingSeatKeys(route2, o) {
   const out = [];
-  if (!route.resolved) return out;
-  const resolved = route.resolved;
+  if (!route2.resolved) return out;
+  const resolved = route2.resolved;
   const doFetch = o.fetchImpl ?? fetch;
   const targets = [
-    ...SEAT_KEY_ROLES.filter((r) => resolved.seats[r]).map((role) => ({ role, agentId: seatAgentId(route, role) })),
+    ...SEAT_KEY_ROLES.filter((r) => resolved.seats[r]).map((role) => ({ role, agentId: seatAgentId(route2, role) })),
     ...resolved.releaseSeat ? [{ role: "release", agentId: resolved.releaseAgentId }] : []
   ];
   let store;
@@ -9771,10 +9771,10 @@ async function mintMissingSeatKeys(route, o) {
       detail: describeStoreError(e)
     }));
   }
-  const host = hostFromUrl2(route.baseUrl);
-  const base = route.baseUrl.replace(/\/+$/, "");
+  const host = hostFromUrl2(route2.baseUrl);
+  const base = route2.baseUrl.replace(/\/+$/, "");
   if (!o.dryRun) {
-    const probeSlug = seatKeySlug(splitRoute(route.route)[0], "_probe");
+    const probeSlug = seatKeySlug(splitRoute(route2.route)[0], "_probe");
     try {
       await store.set(host, probeSlug, {
         apiKey: "probe",
@@ -9793,7 +9793,7 @@ async function mintMissingSeatKeys(route, o) {
       out.push({ role, action: "no_agent" });
       continue;
     }
-    const slug = slugFor(route, agentId);
+    const slug = slugFor(route2, agentId);
     try {
       if ((await store.get(host, slug))?.apiKey) {
         out.push({ role, action: "already_stored" });
@@ -9806,7 +9806,7 @@ async function mintMissingSeatKeys(route, o) {
       const res = await doFetch(`${base}/api/workspaces/${resolved.workspaceId}/agents/${agentId}/api-keys`, {
         method: "POST",
         headers: {
-          Authorization: `Bearer ${resolveApiKey(route)}`,
+          Authorization: `Bearer ${resolveApiKey(route2)}`,
           "Content-Type": "application/json",
           "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0"
         },
@@ -9840,7 +9840,7 @@ async function mintMissingSeatKeys(route, o) {
           try {
             const del2 = await doFetch(`${base}/api/workspaces/${resolved.workspaceId}/agents/${agentId}/api-keys/${body.id}`, {
               method: "DELETE",
-              headers: { Authorization: `Bearer ${resolveApiKey(route)}`, "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
+              headers: { Authorization: `Bearer ${resolveApiKey(route2)}`, "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
             });
             revoked = del2.ok;
           } catch {
@@ -9875,13 +9875,13 @@ function describeMintOutcome(o) {
       return `${o.role}: could not mint an agent key (${o.detail ?? "unknown"}) \u2014 writes as the ship`;
   }
 }
-async function revokeSeatKeys(route, o) {
+async function revokeSeatKeys(route2, o) {
   const out = [];
-  if (!route.resolved) return out;
-  const resolved = route.resolved;
+  if (!route2.resolved) return out;
+  const resolved = route2.resolved;
   const doFetch = o.fetchImpl ?? fetch;
   const targets = [
-    ...SEAT_KEY_ROLES.filter((r) => resolved.seats[r]).map((role) => ({ role, agentId: seatAgentId(route, role) })),
+    ...SEAT_KEY_ROLES.filter((r) => resolved.seats[r]).map((role) => ({ role, agentId: seatAgentId(route2, role) })),
     ...resolved.releaseSeat ? [{ role: "release", agentId: resolved.releaseAgentId }] : []
   ];
   let store;
@@ -9890,14 +9890,14 @@ async function revokeSeatKeys(route, o) {
   } catch (e) {
     return targets.map(({ role }) => ({ role, action: "failed", detail: describeStoreError(e) }));
   }
-  const host = hostFromUrl2(route.baseUrl);
-  const base = route.baseUrl.replace(/\/+$/, "");
+  const host = hostFromUrl2(route2.baseUrl);
+  const base = route2.baseUrl.replace(/\/+$/, "");
   for (const { role, agentId } of targets) {
     if (!agentId) {
       out.push({ role, action: "no_agent" });
       continue;
     }
-    const slug = slugFor(route, agentId);
+    const slug = slugFor(route2, agentId);
     try {
       const session = await store.get(host, slug);
       if (!session?.apiKey) {
@@ -9914,7 +9914,7 @@ async function revokeSeatKeys(route, o) {
       }
       const del2 = await doFetch(`${base}/api/workspaces/${resolved.workspaceId}/agents/${agentId}/api-keys/${session.keyId}`, {
         method: "DELETE",
-        headers: { Authorization: `Bearer ${resolveApiKey(route)}`, "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
+        headers: { Authorization: `Bearer ${resolveApiKey(route2)}`, "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
       });
       if (!del2.ok && del2.status !== 404) {
         out.push({ role, action: "failed", detail: `${del2.status} ${del2.statusText}` });
@@ -9940,14 +9940,14 @@ function describeRevokeOutcome(o) {
       return `${o.role}: could not revoke the agent key (${o.detail ?? "unknown"}) \u2014 left in the keychain`;
   }
 }
-async function canMintAgentKeys(route, o = {}) {
-  const resolved = route.resolved;
+async function canMintAgentKeys(route2, o = {}) {
+  const resolved = route2.resolved;
   if (!resolved) return void 0;
-  const agentId = seatAgentId(route, "dev") ?? SEAT_KEY_ROLES.map((r) => seatAgentId(route, r)).find(Boolean);
+  const agentId = seatAgentId(route2, "dev") ?? SEAT_KEY_ROLES.map((r) => seatAgentId(route2, r)).find(Boolean);
   if (!agentId) return void 0;
   try {
-    const res = await (o.fetchImpl ?? fetch)(`${route.baseUrl.replace(/\/+$/, "")}/api/workspaces/${resolved.workspaceId}/agents/${agentId}/api-keys`, {
-      headers: { Authorization: `Bearer ${resolveApiKey(route)}`, "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
+    const res = await (o.fetchImpl ?? fetch)(`${route2.baseUrl.replace(/\/+$/, "")}/api/workspaces/${resolved.workspaceId}/agents/${agentId}/api-keys`, {
+      headers: { Authorization: `Bearer ${resolveApiKey(route2)}`, "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
     });
     if (res.ok) return true;
     return res.status === 403 ? false : void 0;
@@ -10175,7 +10175,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve5, dirname as dirname21, join as join42, basename as basename12 } from "path";
+import { resolve as resolve5, dirname as dirname22, join as join43, basename as basename13 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname2, homedir as homedir10 } from "os";
 import { spawnSync as spawnSync7 } from "child_process";
@@ -10246,12 +10246,12 @@ function splitWorktreeArgs(positional2, routeNames) {
   if (a !== void 0 && isTicket(a) && !routeNames.includes(a)) return { ticket: a };
   return { route: a, ticket: void 0 };
 }
-function pickWorktreeRoute(ticketNumber, candidates) {
-  for (const c of candidates) {
-    if (c.hit && (candidates.length === 1 || c.servedRepoIds.includes(c.hit.repoId ?? ""))) return { route: c.route };
+function pickWorktreeRoute(ticketNumber, candidates2) {
+  for (const c of candidates2) {
+    if (c.hit && (candidates2.length === 1 || c.servedRepoIds.includes(c.hit.repoId ?? ""))) return { route: c.route };
   }
-  const looked = candidates.map((c) => c.route).join(", ");
-  const found = candidates.filter((c) => c.hit).map((c) => `${c.route} (repo ${c.hit?.repoId ?? "none"})`);
+  const looked = candidates2.map((c) => c.route).join(", ");
+  const found = candidates2.filter((c) => c.hit).map((c) => `${c.route} (repo ${c.hit?.repoId ?? "none"})`);
   return {
     error: `no open ticket ISSUE-${ticketNumber} served by this ship \u2014 looked on ${looked}` + (found.length ? `; found it only on ${found.join(", ")}, which has no checkout for its repo` : "")
   };
@@ -10502,22 +10502,22 @@ async function runReset(o, fx) {
   for (const url of urls) {
     for (const line of fx.removePair(url, o.dryRun)) steps.push({ step: "pair", target: line, action: mark(o.dryRun) });
   }
-  for (const route of o.routes) {
-    for (const r of await fx.revokeSeatKeys(route, o.dryRun)) {
-      steps.push({ step: "seat-keys", target: `${route.route}: ${r.line}`, action: r.ok ? mark(o.dryRun) : "failed" });
+  for (const route2 of o.routes) {
+    for (const r of await fx.revokeSeatKeys(route2, o.dryRun)) {
+      steps.push({ step: "seat-keys", target: `${route2.route}: ${r.line}`, action: r.ok ? mark(o.dryRun) : "failed" });
     }
   }
-  for (const route of [...o.routes, ...o.droppedRoutes ?? []]) {
+  for (const route2 of [...o.routes, ...o.droppedRoutes ?? []]) {
     try {
-      const cred = await fx.credential(route);
+      const cred = await fx.credential(route2);
       if (!cred.stored) {
-        steps.push({ step: "credential", target: route.route, action: "absent", detail: "no workspace credential in the keychain" });
+        steps.push({ step: "credential", target: route2.route, action: "absent", detail: "no workspace credential in the keychain" });
         continue;
       }
       if (!o.dryRun) await cred.clear();
-      steps.push({ step: "credential", target: route.route, action: mark(o.dryRun), detail: "workspace credential in the keychain" });
+      steps.push({ step: "credential", target: route2.route, action: mark(o.dryRun), detail: "workspace credential in the keychain" });
     } catch (e) {
-      steps.push({ step: "credential", target: route.route, action: "failed", detail: e.message });
+      steps.push({ step: "credential", target: route2.route, action: "failed", detail: e.message });
     }
   }
   const covered = new Set([...o.routes, ...o.droppedRoutes ?? []].map((r) => `${hostFromUrl3(r.baseUrl)}/${splitRoute(r.route)[0]}`));
@@ -10618,12 +10618,12 @@ function outdatedItem(have, floor, nowIso = (/* @__PURE__ */ new Date()).toISOSt
 function sentVersion(ship) {
   return /CrewAgent\/(\d+\.\d+\.\d+\S*)/.exec(ship.userAgent)?.[1] ?? null;
 }
-async function readCrewFloor(route, ship) {
-  const r = route.resolved;
+async function readCrewFloor(route2, ship) {
+  const r = route2.resolved;
   if (!r?.projectId) return void 0;
   try {
-    const res = await fetch(`${route.baseUrl}/api/projects/${encodeURIComponent(r.projectId)}?workspaceId=${r.workspaceId}`, {
-      headers: { Authorization: `Bearer ${resolveApiKey(route)}`, "User-Agent": ship.userAgent }
+    const res = await fetch(`${route2.baseUrl}/api/projects/${encodeURIComponent(r.projectId)}?workspaceId=${r.workspaceId}`, {
+      headers: { Authorization: `Bearer ${resolveApiKey(route2)}`, "User-Agent": ship.userAgent }
     });
     if (!res.ok) return void 0;
     const body = await res.json();
@@ -10648,12 +10648,12 @@ async function checkCrewFloor(o, deps = {}) {
 function openOutdated(state) {
   return state.shipAttention().previous().find((i) => i.key === CREW_OUTDATED_KEY)?.message ?? null;
 }
-function isUpgradeRequired(err) {
-  return err instanceof TablationApiError3 && err.status === 426;
+function isUpgradeRequired(err2) {
+  return err2 instanceof TablationApiError3 && err2.status === 426;
 }
-async function raiseFromUpgradeRequired(o, err) {
+async function raiseFromUpgradeRequired(o, err2) {
   const have = sentVersion(o.ship) ?? "unknown";
-  const floor = /(\d+\.\d+\.\d+)/.exec(err.message.replace(have, ""))?.[1] ?? "a newer version";
+  const floor = /(\d+\.\d+\.\d+)/.exec(err2.message.replace(have, ""))?.[1] ?? "a newer version";
   await raiseShipAttention(o, outdatedItem(have, floor));
 }
 
@@ -10963,10 +10963,10 @@ function rankedCandidates(role, i) {
 }
 function roleTopRank(role, i) {
   if (role !== "qa" && role !== "triage" && !i.seats[role]) return NOTHING_ACTIONABLE;
-  const candidates = roleCandidates(role, i);
-  if (candidates.length === 0) return NOTHING_ACTIONABLE;
+  const candidates2 = roleCandidates(role, i);
+  if (candidates2.length === 0) return NOTHING_ACTIONABLE;
   const c = i.contract ?? DEFAULT_CONTRACT;
-  return Math.min(...candidates.map((t) => rankScalar(t, c)));
+  return Math.min(...candidates2.map((t) => rankScalar(t, c)));
 }
 function actionableSummary(i, pending) {
   const c = i.contract ?? DEFAULT_CONTRACT;
@@ -11461,15 +11461,15 @@ async function runStalledSweep(o, stalled) {
 
 // src/poll.ts
 async function decideCycle(o) {
-  const { route, ship, state, emit } = o;
-  const tracker = new Tracker(route, ship);
+  const { route: route2, ship, state, emit } = o;
+  const tracker = new Tracker(route2, ship);
   tracker.onReadFailure = (m) => emit.warn(m);
   emit.enter("poll");
   const optional = async (what, read, fallback) => {
     try {
       return await read;
-    } catch (err) {
-      emit.warn(`reading ${what} failed: ${err instanceof Error ? err.message : String(err)}`);
+    } catch (err2) {
+      emit.warn(`reading ${what} failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
       return fallback;
     }
   };
@@ -11493,13 +11493,13 @@ async function decideCycle(o) {
   const epicStatusById = new Map(epicRows.map((e) => [e.id, e[epicStatusColumn] ?? null]));
   let epicSync = [];
   try {
-    const candidates = trackedEpics(epicRows, tracker.contract);
-    const outstanding = await tracker.epicTickets(candidates.map((e) => e.id), { closed: false });
+    const candidates2 = trackedEpics(epicRows, tracker.contract);
+    const outstanding = await tracker.epicTickets(candidates2.map((e) => e.id), { closed: false });
     const closed = await tracker.epicTickets(
-      epicsNeedingClosedCheck(candidates, outstanding, tracker.contract),
+      epicsNeedingClosedCheck(candidates2, outstanding, tracker.contract),
       { closed: true }
     );
-    epicSync = planEpicSync(candidates, outstanding, closed, tracker.contract);
+    epicSync = planEpicSync(candidates2, outstanding, closed, tracker.contract);
     for (const s of epicSync) epicStatusById.set(s.epic.id, s.to);
   } catch (e) {
     emit.warn(`could not take stock of epics this cycle: ${e.message}`);
@@ -11515,7 +11515,7 @@ async function decideCycle(o) {
   const info = blockerInfoMap(tickets, extra);
   const blocked = computeBlockedIds(tickets, info);
   emit.enter("sweep");
-  const roster = buildRoster(configuredMembers(route), crewRows);
+  const roster = buildRoster(configuredMembers(route2), crewRows);
   const holds2 = new Set(holdIds(roster));
   const workModes = { modes: projectModes, agentAssignees: agentAssigneeIds(crewRows, (id) => holds2.has(id)) };
   const diag = sweepDiagnostics(tickets, info);
@@ -11558,7 +11558,7 @@ async function decideCycle(o) {
   const unroutable = unroutableTickets.map((t) => t.id);
   const { added, gained } = unroutableChanges(
     unroutableTickets,
-    state.unroutable(route.route).previous(),
+    state.unroutable(route2.route).previous(),
     tickets,
     tracker.contract.columns.externalId
   );
@@ -11580,14 +11580,14 @@ async function decideCycle(o) {
     const reasons = attentionReasons(t, tracker.contract);
     if (reasons.length) attentionCurrent[t.id] = reasons;
   }
-  const attentionPrevious = state.attention(route.route).previous();
+  const attentionPrevious = state.attention(route2.route).previous();
   const transitions2 = attentionTransitions(attentionPrevious, attentionCurrent);
   let mintFailed = false;
   for (const tr of transitions2) {
     const ticket = tickets.find((t) => t.id === tr.ticketId);
     if (!ticket) continue;
     const url = await tracker.recordLinkUrl(ticket.id);
-    if (!url && route.resolved?.recordLinkViewId) mintFailed = true;
+    if (!url && route2.resolved?.recordLinkViewId) mintFailed = true;
     emit.emit(
       `needs a person: ${tr.reasons.join(", ")} \u2014 ${ticket.title}`,
       {
@@ -11606,15 +11606,15 @@ async function decideCycle(o) {
   }
   emit.enter("select");
   const watermark = state.watermark();
-  for (const repo of recheckBaseStops(state, route)) {
+  for (const repo of recheckBaseStops(state, route2)) {
     emit.emit(`${repo}: primary checkout is level again \u2014 building lanes resume for that repo`, { step: "select" });
   }
-  for (const what of recheckEnvironmentStops(state, route, ship)) {
+  for (const what of recheckEnvironmentStops(state, route2, ship)) {
     emit.emit(`${what}: no longer missing from the scheduler PATH \u2014 stop cleared`, { step: "select" });
   }
-  await checkRepoDisks({ state, emit, route, ship });
-  const floorStop = await checkCrewFloor({ state, emit, route, ship });
-  const itemStop = repoStopFor(openShipAttention(state), route);
+  await checkRepoDisks({ state, emit, route: route2, ship });
+  const floorStop = await checkCrewFloor({ state, emit, route: route2, ship });
+  const itemStop = repoStopFor(openShipAttention(state), route2);
   const selectionInput = {
     repoStop: floorStop ? () => floorStop : itemStop,
     workModes,
@@ -11623,7 +11623,7 @@ async function decideCycle(o) {
     watermark,
     blocked,
     holds: holds2,
-    seats: route.resolved.seats,
+    seats: route2.resolved.seats,
     paused: state.pausedRoles(["dev", "design", "qa"]),
     contract: tracker.contract,
     ships: { myShipId: shipIdByName(ships, ship.name), rows: ships }
@@ -11669,7 +11669,7 @@ async function decideCycle(o) {
   }
   return decision;
 }
-var digestPath = (stateDir, route, role, runId) => join25(stateDir, `digest-${route}-${role}${runId ? `-${runId}` : ""}.md`);
+var digestPath = (stateDir, route2, role, runId) => join25(stateDir, `digest-${route2}-${role}${runId ? `-${runId}` : ""}.md`);
 function otherRunsRemoved(tickets, own) {
   if (!own) return tickets;
   return tickets.filter((t) => t.id === own.ticket.id || !own.inFlight(t.id));
@@ -11757,8 +11757,8 @@ ${body}` : body;
     return false;
   }
 }
-function rosterFor(d, route, role) {
-  return rosterMarkdown(d.roster, route.resolved.seats[role] ?? null);
+function rosterFor(d, route2, role) {
+  return rosterMarkdown(d.roster, route2.resolved.seats[role] ?? null);
 }
 
 // src/claim.ts
@@ -11787,11 +11787,11 @@ async function stampResumption(tracker, t, affinity) {
   }
   return { outcome: "unknown" };
 }
-async function resolveTopCandidate(tracker, candidates, seat, approvedStatus, buildingStatus, isServable, affinity, ticketLock) {
+async function resolveTopCandidate(tracker, candidates2, seat, approvedStatus, buildingStatus, isServable, affinity, ticketLock) {
   const contended = [];
   const unservable = [];
   const held = [];
-  for (const t of candidates) {
+  for (const t of candidates2) {
     if (affinity?.isHeldElsewhere?.(t)) {
       held.push(t.issue_id);
       continue;
@@ -12047,9 +12047,9 @@ function failingPaths(output, cwd) {
   }
   return [...found];
 }
-function culpritByFiles(candidates, paths) {
+function culpritByFiles(candidates2, paths) {
   if (paths.length === 0) return null;
-  const hits = candidates.filter((c) => paths.some((p) => c.changed.has(p)));
+  const hits = candidates2.filter((c) => paths.some((p) => c.changed.has(p)));
   return hits.length === 1 ? hits[0] : null;
 }
 function planBuildFailureBounce(cwd, c, base, remote) {
@@ -12942,9 +12942,9 @@ ${h.prFailure.tail}
 function emitReleaseSummary(emit, summaries) {
   if (summaries.length <= 1) return;
   const routes = [...new Set(summaries.map((s) => s.route))];
-  for (const route of routes) {
-    const rows = summaries.filter((s) => s.route === route);
-    const remit = emit.forRoute(route);
+  for (const route2 of routes) {
+    const rows = summaries.filter((s) => s.route === route2);
+    const remit = emit.forRoute(route2);
     remit.enter("release");
     remit.emit(`release summary \u2014 ${rows.length} repo(s):`);
     for (const s of rows) {
@@ -13024,7 +13024,7 @@ var hook = async (o, name, env = {}) => {
   }
   return result;
 };
-async function detectExternalClosures(o, candidates) {
+async function detectExternalClosures(o, candidates2) {
   const script = o.repo.hooks.merged;
   const mergedHook = script ? async (env) => (await runScript(script, {
     cwd: o.cwd,
@@ -13035,7 +13035,7 @@ async function detectExternalClosures(o, candidates) {
     }
   })).code : void 0;
   const out = [];
-  for (const c of candidates) {
+  for (const c of candidates2) {
     if (!c.branch) continue;
     const prRef = c.ticket[o.contract.columns.prRef];
     const closure = await detectClosure({
@@ -13913,14 +13913,14 @@ var FAILURE_ALERT_MARKER = calloutHeader("CAUTION", "Failure Alert");
 function findOpenFailureAlert(tickets, headline) {
   return tickets.find((t) => t.title === headline);
 }
-function ticketBody(n, route) {
+function ticketBody(n, route2) {
   return `${FAILURE_ALERT_MARKER}
 
 ${n.detail ?? n.headline}
 
-Filed automatically \u2014 no \`notify\` hook is configured for route \`${route}\`, so this is the crew's built-in fallback rather than a silent log line. Configure \`hooks.notify\` on this route to replace it.`;
+Filed automatically \u2014 no \`notify\` hook is configured for route \`${route2}\`, so this is the crew's built-in fallback rather than a silent log line. Configure \`hooks.notify\` on this route to replace it.`;
 }
-async function applyFailureAlert(writer, n, route, openTickets, memberId, log, dryRun, placement = {}) {
+async function applyFailureAlert(writer, n, route2, openTickets, memberId, log, dryRun, placement = {}) {
   const existing = findOpenFailureAlert(openTickets, n.headline);
   if (existing) {
     const label = displayKey(existing);
@@ -13951,7 +13951,7 @@ Still failing: ${body}`, memberId, "failure_alert");
   try {
     const created = await writer.fileTicket({
       title: n.headline,
-      description: ticketBody(n, route),
+      description: ticketBody(n, route2),
       report_type: "bug",
       severity: "s2",
       reporter_name: "Crew release",
@@ -14153,15 +14153,15 @@ async function settleRunEnd(o) {
     emit.warn(`could not beat ship idle: ${e.message}`, { step: "agent" });
   }
 }
-function describeRun(run2, route, seatIds, worktreeOf = (d, n) => {
+function describeRun(run2, route2, seatIds, worktreeOf = (d, n) => {
   try {
     return worktreeForNumber(d, n)?.path ?? null;
   } catch {
     return null;
   }
 }) {
-  const ownRoute = run2.route === routeSlug(route.route);
-  const repoDir = run2.repo ? reposOf(route).find((t) => t.name === run2.repo)?.dir : void 0;
+  const ownRoute = run2.route === routeSlug(route2.route);
+  const repoDir = run2.repo ? reposOf(route2).find((t) => t.name === run2.repo)?.dir : void 0;
   const num = run2.ticket?.replace(/^\D+/, "") ?? "";
   return {
     role: run2.role,
@@ -14282,29 +14282,29 @@ function runForge(a, io) {
 // src/whoami.ts
 async function buildWhoami(routes, deps = {}) {
   const doFetch = deps.fetch ?? fetch;
-  return Promise.all(routes.map(async (route) => {
-    const credential = credentialSource(route);
+  return Promise.all(routes.map(async (route2) => {
+    const credential = credentialSource(route2);
     try {
-      const key = resolveApiKey(route);
-      const q = route.resolved ? `?workspaceId=${encodeURIComponent(route.resolved.workspaceId)}` : "";
-      const res = await doFetch(`${route.baseUrl.replace(/\/+$/, "")}/api/auth/me${q}`, {
+      const key = resolveApiKey(route2);
+      const q = route2.resolved ? `?workspaceId=${encodeURIComponent(route2.resolved.workspaceId)}` : "";
+      const res = await doFetch(`${route2.baseUrl.replace(/\/+$/, "")}/api/auth/me${q}`, {
         headers: { Authorization: `Bearer ${key}`, "User-Agent": deps.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
       });
       if (res.status === 401 || res.status === 403) {
-        return { route: route.route, ok: false, credential, error: `key rejected by ${route.baseUrl} (HTTP ${res.status}): expired or revoked, re-run crew connect` };
+        return { route: route2.route, ok: false, credential, error: `key rejected by ${route2.baseUrl} (HTTP ${res.status}): expired or revoked, re-run crew connect` };
       }
-      if (!res.ok) return { route: route.route, ok: false, credential, error: `/auth/me answered HTTP ${res.status}` };
+      if (!res.ok) return { route: route2.route, ok: false, credential, error: `/auth/me answered HTTP ${res.status}` };
       const me = await res.json();
-      const operatorId = route.resolved?.operator ?? null;
+      const operatorId = route2.resolved?.operator ?? null;
       let operatorName = null;
       if (operatorId && deps.operatorName) {
         try {
-          operatorName = await deps.operatorName(route, operatorId) ?? null;
+          operatorName = await deps.operatorName(route2, operatorId) ?? null;
         } catch {
         }
       }
       return {
-        route: route.route,
+        route: route2.route,
         ok: true,
         credential,
         identity: { id: me.id ?? null, email: me.email ?? null, name: me.name ?? null },
@@ -14312,7 +14312,7 @@ async function buildWhoami(routes, deps = {}) {
         operator: { id: operatorId, name: operatorName }
       };
     } catch (e) {
-      return { route: route.route, ok: false, credential, error: e.message };
+      return { route: route2.route, ok: false, credential, error: e.message };
     }
   }));
 }
@@ -14336,10 +14336,10 @@ function formatWhoami(report) {
 
 // src/seat-read-probe.ts
 var SEAT_NO_READ_REMEDY = "the project has no default role for agent keys \u2014 update the Issues app's template, then re-mint with `crew agents sync --revoke-seat-keys`, or assign the Crew seat role to the agent members";
-function probeTables(route) {
-  const m = route.resolved?.models;
+function probeTables(route2) {
+  const m = route2.resolved?.models;
   if (!m) return [];
-  const r = route.resolved;
+  const r = route2.resolved;
   return [
     { name: "Issues", modelId: m.issues },
     { name: "Comments", modelId: m.comments },
@@ -14347,8 +14347,8 @@ function probeTables(route) {
     { name: "Ships", modelId: r?.shipsModelId ?? "" }
   ].filter((t) => !!t.modelId);
 }
-async function probeTableRead(route, modelId, apiKey, o = {}) {
-  const url = `${route.baseUrl.replace(/\/+$/, "")}/api/data-models/${modelId}/records?limit=1`;
+async function probeTableRead(route2, modelId, apiKey, o = {}) {
+  const url = `${route2.baseUrl.replace(/\/+$/, "")}/api/data-models/${modelId}/records?limit=1`;
   try {
     const res = await (o.fetchImpl ?? fetch)(url, {
       headers: { Authorization: `Bearer ${apiKey}`, "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
@@ -14360,25 +14360,25 @@ async function probeTableRead(route, modelId, apiKey, o = {}) {
     return { state: "unknown", detail: e.message };
   }
 }
-async function probeSeatReads(route, o = {}) {
+async function probeSeatReads(route2, o = {}) {
   const out = [];
-  const roles = [...SEAT_KEY_ROLES.filter((r) => route.resolved?.seats[r]), ...route.resolved?.releaseSeat ? ["release"] : []];
+  const roles = [...SEAT_KEY_ROLES.filter((r) => route2.resolved?.seats[r]), ...route2.resolved?.releaseSeat ? ["release"] : []];
   for (const role of roles) {
-    const id = role === "release" ? await resolveReleaseKey(route, o.getStore) : await resolveSeatKey(route, role, o.getStore);
+    const id = role === "release" ? await resolveReleaseKey(route2, o.getStore) : await resolveSeatKey(route2, role, o.getStore);
     if (id.kind !== "agent") continue;
     const tables = [];
-    for (const t of probeTables(route)) tables.push({ table: t.name, ...await probeTableRead(route, t.modelId, id.apiKey, o) });
+    for (const t of probeTables(route2)) tables.push({ table: t.name, ...await probeTableRead(route2, t.modelId, id.apiKey, o) });
     const bad = tables.find((t) => t.state === "forbidden") ?? tables.find((t) => t.state === "unknown");
     out.push({ role, state: bad?.state ?? (tables.length ? "ok" : "unknown"), detail: bad?.detail ?? (tables.length ? void 0 : "route has no resolved tables"), tables });
   }
   return out;
 }
-function forbiddenDetail(e, route) {
+function forbiddenDetail(e, route2) {
   const msg = e instanceof Error ? e.message : String(e);
   const m = /^([A-Z]+) (\S+) -> 403/.exec(msg);
   const verb = /No (READ|WRITE) access/i.exec(msg)?.[1]?.toUpperCase();
   const modelId = /\/data-models\/([\w-]+)/i.exec(m?.[2] ?? "")?.[1];
-  const r = route?.resolved;
+  const r = route2?.resolved;
   const known = [
     [r?.models?.issues, "Issues"],
     [r?.models?.comments, "Comments"],
@@ -14414,8 +14414,8 @@ function isForbiddenError(e) {
   return /\b403\b/.test(e instanceof Error ? e.message : String(e));
 }
 var SEAT_FORBIDDEN_KEY = "seat_forbidden:release";
-function seatForbiddenItem(now = /* @__PURE__ */ new Date(), e, route) {
-  const d = e === void 0 ? {} : forbiddenDetail(e, route);
+function seatForbiddenItem(now = /* @__PURE__ */ new Date(), e, route2) {
+  const d = e === void 0 ? {} : forbiddenDetail(e, route2);
   const what = d.method && d.table ? `${d.method} ${d.table}${d.verb ? ` -> 403 No ${d.verb} access` : " -> 403"}` : "cannot read the Issues table (403)";
   return {
     kind: "seat_forbidden",
@@ -14461,8 +14461,8 @@ var red = paintWith(31);
 var cyan = paintWith(36);
 var STEP_ORDER = ["poll", "sweep", "select", "worktree", "agent", "reconcile", "merge", "release", "idle"];
 var WORKING_STEPS = /* @__PURE__ */ new Set(["worktree", "agent", "reconcile", "merge", "release"]);
-function byRoute(events, route) {
-  return route ? events.filter((e) => e.route === route) : events;
+function byRoute(events, route2) {
+  return route2 ? events.filter((e) => e.route === route2) : events;
 }
 function matches(e, f) {
   if (f.role && e.role !== f.role) return false;
@@ -14482,9 +14482,9 @@ function formatLine(e, showRoute = false) {
   const t = dim(localTime(e.at));
   const scope = e.role ? `${e.step}[${e.role}]` : e.step;
   const paint = e.level === "error" ? red : e.level === "warn" ? yellow : cyan;
-  const route = showRoute ? `${dim(e.route)} ` : "";
+  const route2 = showRoute ? `${dim(e.route)} ` : "";
   const ticket = e.ticket ? ` ${bold(e.ticket)}` : "";
-  return `${t} ${route}${paint(scope.padEnd(14))}${ticket} ${e.message}`;
+  return `${t} ${route2}${paint(scope.padEnd(14))}${ticket} ${e.message}`;
 }
 function foldCycle(events) {
   const last = events[events.length - 1];
@@ -14640,23 +14640,23 @@ async function gatherInbox(routes, ship, opts = {}) {
   const items = [];
   const errors = [];
   const resolved = [];
-  await Promise.all(routes.map(async (route) => {
+  await Promise.all(routes.map(async (route2) => {
     try {
-      const tracker = new Tracker(route, ship);
+      const tracker = new Tracker(route2, ship);
       const [tickets, crewRows] = await Promise.all([tracker.openTickets(), tracker.crewRows()]);
-      const roster = buildRoster(configuredMembers(route), crewRows);
+      const roster = buildRoster(configuredMembers(route2), crewRows);
       let mine;
       if (opts.memberQuery) {
         const hits = matchMembers(crewRows, opts.memberQuery);
         resolved.push({
-          route: route.route,
+          route: route2.route,
           names: hits.map((h) => h.name),
           emails: hits.map((h) => h.email).filter(Boolean),
           by: hits[0]?.by ?? null
         });
         mine = new Set(hits.map((h) => h.id));
       } else {
-        mine = opts.memberIds ?? new Set([route.resolved?.operator].filter(Boolean));
+        mine = opts.memberIds ?? new Set([route2.resolved?.operator].filter(Boolean));
       }
       const c = tracker.contract;
       for (const t of tickets) {
@@ -14664,7 +14664,7 @@ async function gatherInbox(routes, ship, opts = {}) {
         if (opts.statuses && !opts.statuses.has(t.status)) continue;
         if (!opts.includeClosed && c.statuses.resolved.includes(t.status)) continue;
         items.push({
-          route: route.route,
+          route: route2.route,
           ticket: t,
           assignee: crewLabel(roster.get(t.assignee_id)),
           rank: rankScalar(t, c),
@@ -14673,7 +14673,7 @@ async function gatherInbox(routes, ship, opts = {}) {
         });
       }
     } catch (e) {
-      errors.push({ route: route.route, error: e.message });
+      errors.push({ route: route2.route, error: e.message });
     }
   }));
   items.sort((a, b) => a.rank - b.rank);
@@ -14708,29 +14708,29 @@ function renderInbox(items, byConnection = false, subject) {
 }
 
 // src/fleet.ts
-function agedConnectionRank(rawRank, role, route, decision, state, now) {
+function agedConnectionRank(rawRank, role, route2, decision, state, now) {
   if (role !== "dev" && role !== "design") return rawRank;
-  const waiting = state.fairness(route.route).waiting();
+  const waiting = state.fairness(route2.route).waiting();
   if (!waiting || waiting.ticket !== decision.actionable.top?.issue_id) return rawRank;
-  return agedRankScalar(rawRank, { since: waiting.since, weight: route.weight }, now);
+  return agedRankScalar(rawRank, { since: waiting.since, weight: route2.weight }, now);
 }
 async function decideFleet(o) {
   const now = o.now ?? Date.now();
   const eligible = o.routes.filter((c) => o.enabledOnly === false ? true : c.enabled);
-  const entries = await Promise.all(eligible.map(async (route) => {
+  const entries = await Promise.all(eligible.map(async (route2) => {
     try {
-      const decision = await decideCycle({ route, ship: o.ship, state: o.state, emit: o.emit.forRoute(route.route) });
+      const decision = await decideCycle({ route: route2, ship: o.ship, state: o.state, emit: o.emit.forRoute(route2.route) });
       const sel = decision.selection;
-      if (!sel.selected) return { route, decision, rank: NOTHING_ACTIONABLE };
+      if (!sel.selected) return { route: route2, decision, rank: NOTHING_ACTIONABLE };
       const rawRank = sel.ranks[sel.selected] ?? NOTHING_ACTIONABLE;
       return {
-        route,
+        route: route2,
         decision,
         role: sel.selected,
-        rank: agedConnectionRank(rawRank, sel.selected, route, decision, o.state, now)
+        rank: agedConnectionRank(rawRank, sel.selected, route2, decision, o.state, now)
       };
     } catch (e) {
-      return { route, rank: NOTHING_ACTIONABLE, error: e.message };
+      return { route: route2, rank: NOTHING_ACTIONABLE, error: e.message };
     }
   }));
   for (const e of entries) {
@@ -15062,8 +15062,8 @@ async function del(o, path) {
   });
   if (!res.ok) throw new ConnectHttpError(res.status, path, res.statusText);
 }
-async function provisionReleaseLocks(o, locksModelId, route, repoNames) {
-  const scopes = [...new Set(repoNames)].sort().map((r) => releaseLockScope(route, r));
+async function provisionReleaseLocks(o, locksModelId, route2, repoNames) {
+  const scopes = [...new Set(repoNames)].sort().map((r) => releaseLockScope(route2, r));
   if (scopes.length === 0) return [];
   const client2 = {
     // The Locks table is a handful of rows, so read it whole and match in
@@ -15235,14 +15235,14 @@ async function discover(o) {
   out.locksModelId = find("Locks");
   try {
     const views = await get(o, `/views?workspaceId=${ws.id}`);
-    const candidates = views.filter((v) => v.recordLinkOnly === true && v.published === true && !!v.publicSlug && (v.pages ?? []).some((p) => (p.components ?? []).some((c) => c.dataModelId === out.models.issues)));
-    if (candidates.length === 1) {
-      out.recordLinkViewId = candidates[0].id;
-    } else if (candidates.length === 0) {
+    const candidates2 = views.filter((v) => v.recordLinkOnly === true && v.published === true && !!v.publicSlug && (v.pages ?? []).some((p) => (p.components ?? []).some((c) => c.dataModelId === out.models.issues)));
+    if (candidates2.length === 1) {
+      out.recordLinkViewId = candidates2[0].id;
+    } else if (candidates2.length === 0) {
       problems.push("no record-link-only view bound to Issues \u2014 attention events will carry no link");
     } else {
       problems.push(
-        `${candidates.length} record-link-only views bound to Issues \u2014 set resolved.recordLinkViewId by hand`
+        `${candidates2.length} record-link-only views bound to Issues \u2014 set resolved.recordLinkViewId by hand`
       );
     }
   } catch {
@@ -15312,8 +15312,8 @@ async function discover(o) {
       const patchBody = {};
       if (matchedBy === "machine_id") {
         const rowName = (mine[0].name ?? "").trim();
-        const route = `${out.workspaceSlug}/${out.projectSlug ?? out.projectId}`;
-        const plan = planNameSync(o.ship.name.trim(), rowName, o.ship.lastSyncedName?.(route));
+        const route2 = `${out.workspaceSlug}/${out.projectSlug ?? out.projectId}`;
+        const plan = planNameSync(o.ship.name.trim(), rowName, o.ship.lastSyncedName?.(route2));
         if (plan.action === "push") {
           patchBody.name = o.ship.name.trim();
           provisioning.push(`renamed Ships row "${rowName}" to "${o.ship.name.trim()}" (crew.yaml changed)`);
@@ -15477,11 +15477,11 @@ async function discover(o) {
         else if (out.candidates.length === 1) out.operator = out.candidates[0].id;
       }
     } else {
-      const candidates = people.filter((r) => !r.user_id || isMine(r));
+      const candidates2 = people.filter((r) => !r.user_id || isMine(r));
       const mine = people.find(isMine);
-      const byEmail = out.meEmail ? candidates.filter((r) => emailOf(r).some((e) => eq(e, out.meEmail))) : [];
+      const byEmail = out.meEmail ? candidates2.filter((r) => emailOf(r).some((e) => eq(e, out.meEmail))) : [];
       const unlinked = people.filter((r) => !r.user_id);
-      const only = candidates.length === 1 && unlinked.length === 1 ? candidates[0] : void 0;
+      const only = candidates2.length === 1 && unlinked.length === 1 ? candidates2[0] : void 0;
       const pick = mine ?? (byEmail.length === 1 ? byEmail[0] : only);
       if (pick) {
         out.operator = pick.id;
@@ -15492,7 +15492,7 @@ async function discover(o) {
           const m = r.user_id ? members.get(r.user_id) : void 0;
           return `"${r.name || "unnamed row"}" <${r.email ?? "no email"}>` + (r.user_id ? ` linked to member ${m?.email ?? r.user_id}${m?.identityId ? ` (identity ${m.identityId})` : ""}` : " unlinked");
         }).join("; "));
-        if (o.ship && (!o.interactive || candidates.length === 0)) await createOperatorRow(o, out);
+        if (o.ship && (!o.interactive || candidates2.length === 0)) await createOperatorRow(o, out);
       }
     }
   }
@@ -15541,7 +15541,7 @@ async function createOperatorRow(o, found) {
     found.provisioning.push("could not create your Crew row (no write access) \u2014 ask a workspace admin to add one with your user_id");
   }
 }
-function renderConnection(d, route, dir, opts = {}) {
+function renderConnection(d, route2, dir, opts = {}) {
   const apiKeyFileLine = opts.keychainBacked ? "" : opts.apiKeyFile ? `    apiKeyFile: "${opts.apiKeyFile}"` : `    apiKeyFile: "REPLACE \u2014 a file holding this workspace's key"`;
   const apiKeyVarLine = opts.keychainBacked ? "" : opts.apiKeyVar ? `
     apiKeyVar: ${opts.apiKeyVar}` : `
@@ -15549,7 +15549,7 @@ function renderConnection(d, route, dir, opts = {}) {
   const baseUrlLine = opts.baseUrl ? opts.baseUrl.replace(/\/+$/, "") === DEFAULT_BASE_URL ? "" : `    baseUrl: "${opts.baseUrl}"
 ` : '    baseUrl: "REPLACE \u2014 the same baseUrl as your other routes"\n';
   const keyLines = [apiKeyFileLine, apiKeyVarLine.replace(/^\n/, "")].filter(Boolean).join("\n");
-  return `  - route: ${route}
+  return `  - route: ${route2}
     enabled: false          # set to true once \`crew doctor\` is green
 ${opts.area ? `    area: "${opts.area}"
 ` : ""}${dir === null ? "" : `    dir: "${dir}"
@@ -15668,26 +15668,26 @@ import { createHash as createHash5 } from "crypto";
 import { TablationClient as TablationClient4 } from "@tablation/client";
 var LogbookError = class extends Error {
 };
-function client(route, userAgent) {
+function client(route2, userAgent) {
   return new TablationClient4({
-    baseUrl: `${route.baseUrl}/api`,
-    apiKey: resolveApiKey(route),
+    baseUrl: `${route2.baseUrl}/api`,
+    apiKey: resolveApiKey(route2),
     headers: { "User-Agent": userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
   });
 }
-function requireWorkspace(route) {
-  if (!route.resolved) {
-    throw new LogbookError(`route "${route.route}" has no resolved ids \u2014 run \`crew connect\` first`);
+function requireWorkspace(route2) {
+  if (!route2.resolved) {
+    throw new LogbookError(`route "${route2.route}" has no resolved ids \u2014 run \`crew connect\` first`);
   }
 }
-async function listLogEntries(route, opts = {}) {
-  requireWorkspace(route);
-  const c = client(route, opts.userAgent);
-  const agentLogModel = await c.dataModels.get("agent_log", route.resolved.workspaceId);
+async function listLogEntries(route2, opts = {}) {
+  requireWorkspace(route2);
+  const c = client(route2, opts.userAgent);
+  const agentLogModel = await c.dataModels.get("agent_log", route2.resolved.workspaceId);
   const filters = [];
   if (opts.ticket) filters.push({ columnName: "ticket_reference", operator: "EQ", value: opts.ticket });
   if (opts.role) {
-    const agentsModel = await c.dataModels.get("agents", route.resolved.workspaceId);
+    const agentsModel = await c.dataModels.get("agents", route2.resolved.workspaceId);
     const rows = await c.records.list(agentsModel.id, { limit: 200 });
     const match = rows.find((r) => r.name.toLowerCase() === opts.role.toLowerCase());
     if (!match) return [];
@@ -15699,10 +15699,10 @@ async function listLogEntries(route, opts = {}) {
   });
   return [...entries].sort((a, b) => String(b.started_at ?? "").localeCompare(String(a.started_at ?? "")));
 }
-async function showLogEntry(route, entryId, opts = {}) {
-  requireWorkspace(route);
-  const c = client(route, opts.userAgent);
-  const agentLogModel = await c.dataModels.get("agent_log", route.resolved.workspaceId);
+async function showLogEntry(route2, entryId, opts = {}) {
+  requireWorkspace(route2);
+  const c = client(route2, opts.userAgent);
+  const agentLogModel = await c.dataModels.get("agent_log", route2.resolved.workspaceId);
   let entry;
   try {
     entry = await c.records.get(agentLogModel.id, entryId);
@@ -15719,10 +15719,10 @@ async function showLogEntry(route, entryId, opts = {}) {
       }
     };
   }
-  const agentsModel = await c.dataModels.get("agents", route.resolved.workspaceId);
+  const agentsModel = await c.dataModels.get("agents", route2.resolved.workspaceId);
   let historyEntries;
   try {
-    historyEntries = await fetchHistoryEntries(route, agentsModel.id, entry.agent_id, opts.userAgent, 200);
+    historyEntries = await fetchHistoryEntries(route2, agentsModel.id, entry.agent_id, opts.userAgent, 200);
   } catch (e) {
     return { entry, reconstruction: { status: "approximate", reason: `history lookup failed: ${e.message}` } };
   }
@@ -15882,37 +15882,37 @@ function routeNamesOf(text) {
 }
 function parseAddArgs(args, routes, isDir) {
   const rest = [...args];
-  let route;
-  if (rest.length > 0 && routes.includes(rest[0])) route = rest.shift();
+  let route2;
+  if (rest.length > 0 && routes.includes(rest[0])) route2 = rest.shift();
   else if (rest.length > 0 && /^[^/\s]+\/[^/\s]+$/.test(rest[0]) && !isDir(rest[0])) {
     throw new ReposError(`no route "${rest[0]}" in the config (have: ${routes.join(", ") || "none"})`);
   }
-  if (!route) {
-    if (routes.length === 1) route = routes[0];
+  if (!route2) {
+    if (routes.length === 1) route2 = routes[0];
     else throw new ReposError(routes.length === 0 ? "the config has no routes \u2014 run `crew connect` first" : `several routes are configured; name one: ${routes.join(", ")}`);
   }
   if (rest.length > 2) throw new ReposError("too many arguments: expected [route] [name] [path]");
-  if (rest.length === 2) return { route, name: rest[0], path: rest[1] };
-  if (rest.length === 1) return isDir(rest[0]) ? { route, path: rest[0] } : { route, name: rest[0], path: "." };
-  return { route, path: "." };
+  if (rest.length === 2) return { route: route2, name: rest[0], path: rest[1] };
+  if (rest.length === 1) return isDir(rest[0]) ? { route: route2, path: rest[0] } : { route: route2, name: rest[0], path: "." };
+  return { route: route2, path: "." };
 }
 function expandDir(p, base) {
   const home = p === "~" ? homedir9() : p.startsWith("~/") ? `${homedir9()}/${p.slice(2)}` : p;
   return resolve3(base, home);
 }
-function routeMapOf(doc, route) {
+function routeMapOf(doc, route2) {
   const routes = doc.get("routes", true);
   if (isSeq(routes)) {
     for (const item of routes.items) {
-      if (isMap(item) && item.get("route") === route) return item;
+      if (isMap(item) && item.get("route") === route2) return item;
     }
   }
   const have = isSeq(routes) ? routes.items.map((i) => isMap(i) ? String(i.get("route")) : "?").join(", ") : "none";
-  throw new ReposError(`no route "${route}" in the config (have: ${have})`);
+  throw new ReposError(`no route "${route2}" in the config (have: ${have})`);
 }
-function configuredRepos(text, route, base) {
+function configuredRepos(text, route2, base) {
   const doc = parseDocument3(text);
-  const m = routeMapOf(doc, route);
+  const m = routeMapOf(doc, route2);
   const repos = m.get("repos");
   if (isMap(repos)) {
     return repos.items.map((p) => {
@@ -15925,8 +15925,8 @@ function configuredRepos(text, route, base) {
   const dir = m.get("dir");
   return dir ? [{ name: basename9(String(dir)), dir: expandDir(String(dir), base) }] : [];
 }
-function cloneBaseOf(text, route, base, isCheckout) {
-  const m = routeMapOf(parseDocument3(text), route);
+function cloneBaseOf(text, route2, base, isCheckout) {
+  const m = routeMapOf(parseDocument3(text), route2);
   const repos = m.get("repos", true);
   if (isMap(repos) && repos.items.length > 0) return null;
   const dir = m.get("dir");
@@ -15934,8 +15934,8 @@ function cloneBaseOf(text, route, base, isCheckout) {
   const abs = expandDir(String(dir), base);
   return isCheckout(abs) ? null : abs;
 }
-function routeSetsHooks(text, route, name) {
-  const m = routeMapOf(parseDocument3(text), route);
+function routeSetsHooks(text, route2, name) {
+  const m = routeMapOf(parseDocument3(text), route2);
   const repos = m.get("repos", true);
   let target = m;
   if (isMap(repos)) target = repos.get(name, true);
@@ -16042,14 +16042,14 @@ function planRepoAdd(i) {
   }
   return { text: String(doc), mode, name, block: renderBlock(m), warning, unmatched: !matched, droppedDir };
 }
-function planRepoRemove(text, base, route, path) {
+function planRepoRemove(text, base, route2, path) {
   const doc = parseDocument3(text);
   if (doc.errors.length > 0) throw new ReposError(`config is not valid YAML \u2014 ${doc.errors[0].message}`);
-  const m = routeMapOf(doc, route);
+  const m = routeMapOf(doc, route2);
   const target = expandDir(path, base);
-  const existing = configuredRepos(text, route, base);
+  const existing = configuredRepos(text, route2, base);
   const hit = existing.find((e) => e.dir === target);
-  if (!hit) throw new ReposError(`${target} is not configured on route ${route}`);
+  if (!hit) throw new ReposError(`${target} is not configured on route ${route2}`);
   const repos = m.get("repos", true);
   if (isMap(repos)) {
     repos.delete(hit.name);
@@ -16097,15 +16097,15 @@ function resolveRepoProject(projects, opt, routeAreaId) {
 }
 function parseCloneArgs(args, routes) {
   const rest = [...args];
-  let route;
-  if (rest.length > 1 && routes.includes(rest[0])) route = rest.shift();
+  let route2;
+  if (rest.length > 1 && routes.includes(rest[0])) route2 = rest.shift();
   else if (rest.length > 1) throw new ReposError(`no route "${rest[0]}" in the config (have: ${routes.join(", ") || "none"})`);
-  if (!route) {
-    if (routes.length === 1) route = routes[0];
+  if (!route2) {
+    if (routes.length === 1) route2 = routes[0];
     else throw new ReposError(routes.length === 0 ? "the config has no routes \u2014 run `crew connect` first" : `several routes are configured; name one: ${routes.join(", ")}`);
   }
   if (rest.length !== 1) throw new ReposError("expected [route] <name> \u2014 the Repos row to clone (see `crew repos list`)");
-  return { route, name: rest[0] };
+  return { route: route2, name: rest[0] };
 }
 function planRepoClone(i) {
   const names = i.resolved?.repoNames ?? {};
@@ -16257,27 +16257,27 @@ function parseHookOverrides(specs) {
 }
 function parseHooksArgs(args, routes) {
   const rest = [...args];
-  let route;
-  if (rest.length > 1 && routes.includes(rest[0])) route = rest.shift();
-  if (!route) {
-    if (routes.length === 1) route = routes[0];
+  let route2;
+  if (rest.length > 1 && routes.includes(rest[0])) route2 = rest.shift();
+  if (!route2) {
+    if (routes.length === 1) route2 = routes[0];
     else throw new ReposError(routes.length === 0 ? "the config has no routes \u2014 run `crew connect` first" : `several routes are configured; name one: ${routes.join(", ")}`);
   }
   if (rest.length !== 1) throw new ReposError("expected: crew repos hooks [route] <name> [--suggest] [--agent] [--write route|repo] [--recipes ID,ID] [--hook KEY=CMD] [--json]");
-  return { route, name: rest[0] };
+  return { route: route2, name: rest[0] };
 }
-function repoDirOf(text, base, route, name) {
-  const repos = configuredRepos(text, route, base);
+function repoDirOf(text, base, route2, name) {
+  const repos = configuredRepos(text, route2, base);
   const hit = repos.find((r) => r.name === name);
   if (!hit) {
-    throw new ReposError(`route ${route} has no repo named "${name}" (have: ${repos.map((r) => r.name).join(", ") || "none"})`);
+    throw new ReposError(`route ${route2} has no repo named "${name}" (have: ${repos.map((r) => r.name).join(", ") || "none"})`);
   }
   return hit.dir;
 }
-function planRouteHooks(text, route, name, hooks, opts = {}) {
+function planRouteHooks(text, route2, name, hooks, opts = {}) {
   const doc = parseDocument4(text);
   if (doc.errors.length > 0) throw new ReposError(`config is not valid YAML \u2014 ${doc.errors[0].message}`);
-  const m = routeMapOf(doc, route);
+  const m = routeMapOf(doc, route2);
   const repos = m.get("repos", true);
   let target = m;
   if (isMap2(repos)) {
@@ -16311,10 +16311,10 @@ function planRouteHooks(text, route, name, hooks, opts = {}) {
   }
   return { text: String(doc), written, kept, replaced };
 }
-function clearRouteHooks(text, route, name) {
+function clearRouteHooks(text, route2, name) {
   const doc = parseDocument4(text);
   if (doc.errors.length > 0) throw new ReposError(`config is not valid YAML \u2014 ${doc.errors[0].message}`);
-  const m = routeMapOf(doc, route);
+  const m = routeMapOf(doc, route2);
   const repos = m.get("repos", true);
   let target = m;
   if (isMap2(repos)) {
@@ -16476,7 +16476,7 @@ async function runAgentSuggest(o) {
   const signal = o.signal ? AbortSignal.any([o.signal, timeout]) : timeout;
   const run2 = await new Promise((resolve6) => {
     let out = "";
-    let err = "";
+    let err2 = "";
     const child = spawn4(bin, args, { cwd: o.dir, env, detached: true, stdio: ["pipe", "pipe", "pipe"] });
     let settled = false;
     const settle = (r) => {
@@ -16493,7 +16493,7 @@ async function runAgentSuggest(o) {
       }
       child.stdout.destroy();
       child.stderr.destroy();
-      settle({ code: null, out, err, aborted: true });
+      settle({ code: null, out, err: err2, aborted: true });
     };
     if (signal.aborted) onAbort();
     else signal.addEventListener("abort", onAbort, { once: true });
@@ -16501,10 +16501,10 @@ async function runAgentSuggest(o) {
       out += d.toString();
     });
     child.stderr.on("data", (d) => {
-      err += d.toString();
+      err2 += d.toString();
     });
-    child.on("error", (e) => settle({ code: null, out, err, spawnError: e, aborted: false }));
-    child.on("close", (code) => settle({ code, out, err, aborted: false }));
+    child.on("error", (e) => settle({ code: null, out, err: err2, spawnError: e, aborted: false }));
+    child.on("close", (code) => settle({ code, out, err: err2, aborted: false }));
     child.stdin.on("error", () => {
     });
     child.stdin.end(buildAgentPrompt(o.sniff));
@@ -16633,9 +16633,9 @@ async function gatherHealth(c, check) {
 function routesInScope(routes, named) {
   return named ? routes.filter((r) => r.route === named) : routes;
 }
-function planEnable(text, route) {
+function planEnable(text, route2) {
   const doc = parseDocument5(text);
-  routeMapOf(doc, route).set("enabled", true);
+  routeMapOf(doc, route2).set("enabled", true);
   return String(doc);
 }
 function schedulerInstalled(plan, exists, crontab) {
@@ -16975,7 +16975,7 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync34, existsSync as existsSync38, mkdirSync as mkdirSync25, writeFileSync as writeFileSync26, rmSync as rmSync17, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync12, readdirSync as readdirSync17 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync34, existsSync as existsSync39, mkdirSync as mkdirSync25, writeFileSync as writeFileSync26, rmSync as rmSync18, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync13, readdirSync as readdirSync18 } from "fs";
 import { createInterface } from "readline/promises";
 
 // src/periscope-cmd.ts
@@ -17513,8 +17513,8 @@ function ensureShipSshKeypair(stateDir) {
         "-q"
       ], { stdio: ["ignore", "ignore", "pipe"] });
     } catch (e) {
-      const err = e;
-      throw new SshKeyError(`ssh-keygen failed: ${err.stderr?.toString().trim() || err.message}`);
+      const err2 = e;
+      throw new SshKeyError(`ssh-keygen failed: ${err2.stderr?.toString().trim() || err2.message}`);
     }
     chmodSync2(privateKeyPath, 384);
   }
@@ -17540,9 +17540,9 @@ var realExec = (cmd, args, opts) => {
   try {
     return execFileSync9(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: opts?.timeoutMs });
   } catch (e) {
-    const err = e;
-    const why = [err.stderr, err.stdout].map((x) => (x ?? "").trim()).filter(Boolean).join(" / ");
-    throw new Error(`${cmd} ${args.join(" ")}: ${why || err.message.trim()}`);
+    const err2 = e;
+    const why = [err2.stderr, err2.stdout].map((x) => (x ?? "").trim()).filter(Boolean).join(" / ");
+    throw new Error(`${cmd} ${args.join(" ")}: ${why || err2.message.trim()}`);
   }
 };
 var DOCKER_INFO_TIMEOUT_MS = 1e4;
@@ -17583,11 +17583,11 @@ function mountsDigest(mounts, image) {
 function planContainers(cfg) {
   const byWorkspace = /* @__PURE__ */ new Map();
   const image = passengerImageRef(cfg);
-  for (const route of cfg.routes) {
-    if (!route.enabled || !route.hostPassengers || !route.resolved?.workspaceId) continue;
-    const workspaceId = route.resolved.workspaceId;
+  for (const route2 of cfg.routes) {
+    if (!route2.enabled || !route2.hostPassengers || !route2.resolved?.workspaceId) continue;
+    const workspaceId = route2.resolved.workspaceId;
     const mounts = byWorkspace.get(workspaceId) ?? /* @__PURE__ */ new Map();
-    for (const target of passengerCheckoutTargets(route)) {
+    for (const target of passengerCheckoutTargets(route2)) {
       mounts.set(target.name, { hostPath: target.dir, containerPath: `/workspace/${target.name}` });
     }
     byWorkspace.set(workspaceId, mounts);
@@ -17701,17 +17701,17 @@ function syncPassengerContainers(cfg, tablationApiBaseUrl, exec = realExec, sync
 }
 function passengerCheckoutSyncSpecs(cfg, workspaceId) {
   const specs = [];
-  for (const route of cfg.routes) {
-    if (!route.enabled || !route.hostPassengers || !route.resolved?.workspaceId) continue;
-    if (workspaceId && route.resolved.workspaceId !== workspaceId) continue;
-    const routeWorkspaceId = route.resolved.workspaceId;
-    const ordinaryByName = new Map(reposOf(route).map((t) => [t.name, t]));
-    for (const target of passengerCheckoutTargets(route)) {
+  for (const route2 of cfg.routes) {
+    if (!route2.enabled || !route2.hostPassengers || !route2.resolved?.workspaceId) continue;
+    if (workspaceId && route2.resolved.workspaceId !== workspaceId) continue;
+    const routeWorkspaceId = route2.resolved.workspaceId;
+    const ordinaryByName = new Map(reposOf(route2).map((t) => [t.name, t]));
+    for (const target of passengerCheckoutTargets(route2)) {
       const ordinary = ordinaryByName.get(target.name);
-      const override = route.repoOverrides[target.name];
+      const override = route2.repoOverrides[target.name];
       const effective = resolveRepoConfig(
         ordinary ? loadRepoConfig(ordinary.dir) : null,
-        { branch: { ...route.branch, ...override?.branch } },
+        { branch: { ...route2.branch, ...override?.branch } },
         ordinary?.dir ?? target.dir
       );
       specs.push({
@@ -18115,8 +18115,8 @@ function runSyncDaemonFromEnv(env = process.env) {
   const secret = requireEnv(env, "PASSENGER_SYNC_SECRET");
   const targets = JSON.parse(requireEnv(env, "PASSENGER_SYNC_TARGETS"));
   const server = createSyncDaemonServer(targets, secret);
-  server.on("error", (err) => {
-    console.error(`Passenger sync daemon failed to bind 0.0.0.0:${port}: ${err instanceof Error ? err.message : String(err)}`);
+  server.on("error", (err2) => {
+    console.error(`Passenger sync daemon failed to bind 0.0.0.0:${port}: ${err2 instanceof Error ? err2.message : String(err2)}`);
     process.exit(1);
   });
   server.listen(port, "0.0.0.0", () => {
@@ -18233,22 +18233,22 @@ function codeOf(e) {
   const code = e?.code;
   return typeof code === "string" ? code : void 0;
 }
-function isTransientError(err) {
-  if (!(err instanceof Error)) return false;
-  const msg = err.message;
+function isTransientError(err2) {
+  if (!(err2 instanceof Error)) return false;
+  const msg = err2.message;
   if (msg === "fetch failed" || msg.startsWith("fetch failed")) return true;
-  for (let e = err, depth = 0; e && depth < 4; e = e.cause, depth++) {
+  for (let e = err2, depth = 0; e && depth < 4; e = e.cause, depth++) {
     const code = codeOf(e);
     if (code && NETWORK_CODES.includes(code)) return true;
   }
   if (NETWORK_CODES.some((c) => msg.includes(c))) return true;
   if (/\b(?:HTTP|status)\s*:?\s*(502|503|504)\b/i.test(msg) || /^(502|503|504)\b/.test(msg)) return true;
-  if (err instanceof SyntaxError && /Unexpected token '?<|is not valid JSON|Unexpected end of JSON/.test(msg)) return true;
+  if (err2 instanceof SyntaxError && /Unexpected token '?<|is not valid JSON|Unexpected end of JSON/.test(msg)) return true;
   return false;
 }
-function describeCause(err) {
-  const first = (err instanceof Error ? err.message : String(err)).split("\n")[0];
-  const code = codeOf(err?.cause);
+function describeCause(err2) {
+  const first = (err2 instanceof Error ? err2.message : String(err2)).split("\n")[0];
+  const code = codeOf(err2?.cause);
   return code && !first.includes(code) ? `${first} (${code})` : first;
 }
 
@@ -18277,22 +18277,22 @@ async function runDaemonLoop(o) {
         o.onRecovered?.({ downMs: now() - downSince });
         transientRun = 0;
       }
-    } catch (err) {
-      if (isTransientError(err)) {
+    } catch (err2) {
+      if (isTransientError(err2)) {
         passes++;
         if (transientRun === 0) downSince = now();
         transientRun++;
         const wait = transientBackoffMs(transientRun);
         const downMs = now() - downSince;
-        o.onTransient?.({ err, consecutive: transientRun, backoffMs: wait, downMs });
-        if (transientRun === OUTAGE_ESCALATE_AFTER) o.onOutage?.({ err, consecutive: transientRun, downMs });
+        o.onTransient?.({ err: err2, consecutive: transientRun, backoffMs: wait, downMs });
+        if (transientRun === OUTAGE_ESCALATE_AFTER) o.onOutage?.({ err: err2, consecutive: transientRun, downMs });
         if (o.maxPasses !== void 0 && passes >= o.maxPasses) return "maxPasses";
         if (o.signal?.aborted) return "aborted";
         await sleep(wait);
         continue;
       }
       passes++;
-      o.onPassError?.(err);
+      o.onPassError?.(err2);
       if (o.maxPasses !== void 0 && passes >= o.maxPasses) return "maxPasses";
       if (o.signal?.aborted) return "aborted";
       await sleep(backoff);
@@ -18411,7 +18411,7 @@ async function runOnePassUnguarded(o) {
   await hydrateApiKeys([o.route], o.getSessionStore);
   const emit = o.newEmitter();
   const decide = o.decide ?? decideCycle;
-  const spawn7 = o.spawnRoleAgent ?? runRoleAgent;
+  const spawn8 = o.spawnRoleAgent ?? runRoleAgent;
   const breaker = o.spawnBreaker ?? new SpawnBreaker();
   const ctx = { route: o.route, ship: o.ship, state: o.state, emit, getSessionStore: o.getSessionStore };
   if (o.configFile) await reconcileRouteShipName({ route: o.route, ship: o.ship, configFile: o.configFile, emit });
@@ -18515,7 +18515,7 @@ async function runOnePassUnguarded(o) {
       const settled = new Promise((resolve6) => {
         ready = resolve6;
       });
-      const run2 = spawn7(role, decision, ctx, { ready }).then(() => {
+      const run2 = spawn8(role, decision, ctx, { ready }).then(() => {
         breaker.recordSuccess(role);
         clearShipAttention(o.state, `role_parked:${role}`);
       }).catch(async (e) => {
@@ -18571,23 +18571,23 @@ async function publishShipAttention(o) {
   }
 }
 async function replayPendingWrites(ctx) {
-  const { route, ship, emit } = ctx;
+  const { route: route2, ship, emit } = ctx;
   try {
-    const roles = [...new Set(listPendingHandoffs(ship.stateDir, routeSlug(route.route)).map((r) => r.role))];
+    const roles = [...new Set(listPendingHandoffs(ship.stateDir, routeSlug(route2.route)).map((r) => r.role))];
     for (const role of roles) {
-      const identity = await resolveSeatKey(route, role, ctx.getSessionStore);
-      await replayRoutePending(route, ship, new Tracker(route, ship, { apiKey: identity.apiKey }), emit, role);
+      const identity = await resolveSeatKey(route2, role, ctx.getSessionStore);
+      await replayRoutePending(route2, ship, new Tracker(route2, ship, { apiKey: identity.apiKey }), emit, role);
     }
     await replayQueuedAgentRuns(
       ship.stateDir,
-      routeSlug(route.route),
-      async (role) => (await resolveSeatKey(route, role, ctx.getSessionStore)).apiKey,
+      routeSlug(route2.route),
+      async (role) => (await resolveSeatKey(route2, role, ctx.getSessionStore)).apiKey,
       emit
     );
     await replayQueuedTicketCounters(
       ship.stateDir,
-      routeSlug(route.route),
-      async (role) => (await resolveSeatKey(route, role, ctx.getSessionStore)).apiKey,
+      routeSlug(route2.route),
+      async (role) => (await resolveSeatKey(route2, role, ctx.getSessionStore)).apiKey,
       emit
     );
   } catch (e) {
@@ -18595,27 +18595,27 @@ async function replayPendingWrites(ctx) {
   }
 }
 async function reconcileForRoute(ctx, o) {
-  const { route, ship, emit } = ctx;
+  const { route: route2, ship, emit } = ctx;
   await replayPendingWrites(ctx);
   await reconcileRuns({
     stateDir: ship.stateDir,
-    routeLabel: routeSlug(route.route),
+    routeLabel: routeSlug(route2.route),
     emit,
     state: o.state,
     maxConcurrentAgents: o.maxConcurrentAgents,
     roleConcurrency: o.roleConcurrency,
     inFlight: o.inFlight,
-    agentLogKey: async (role) => (await resolveSeatKey(route, role, ctx.getSessionStore)).apiKey,
+    agentLogKey: async (role) => (await resolveSeatKey(route2, role, ctx.getSessionStore)).apiKey,
     afterRun: async (sc, result) => {
-      const identity = await resolveSeatKey(route, sc.role, ctx.getSessionStore);
-      const tracker = new Tracker(route, ship, { apiKey: identity.apiKey });
-      const memberId = route.resolved?.seats[sc.role];
+      const identity = await resolveSeatKey(route2, sc.role, ctx.getSessionStore);
+      const tracker = new Tracker(route2, ship, { apiKey: identity.apiKey });
+      const memberId = route2.resolved?.seats[sc.role];
       try {
         if (!sc.ticketRecordId) return;
         if (result.interrupted) {
           if (!memberId) return;
           const t = await tracker.ticket(sc.ticketRecordId);
-          const target = repoTargetFor(route, t.repo_id);
+          const target = repoTargetFor(route2, t.repo_id);
           const num = String(t[tracker.contract.columns.key] ?? "").replace(/^\D+/, "");
           const wt = target && num ? worktreeForNumber(target.dir, num) : null;
           let dirty = null;
@@ -18629,13 +18629,13 @@ async function reconcileForRoute(ctx, o) {
             reason: result.interrupted === "daemon-exit" ? "the crew daemon exited" : "it exited without a result"
           }), memberId, "interrupted");
         } else {
-          await guardRunHandoff(route, ship, tracker, sc.role, sc.ticketRecordId, emit, sc.spawnedAt);
+          await guardRunHandoff(route2, ship, tracker, sc.role, sc.ticketRecordId, emit, sc.spawnedAt);
         }
       } finally {
         await settleRunEnd({
           tracker,
           shipName: ship.name,
-          route,
+          route: route2,
           role: sc.role,
           memberId,
           ownTicketRecordId: sc.ticketRecordId,
@@ -18656,30 +18656,30 @@ async function runRoleAgent(role, decision, ctx, hooks) {
   }
 }
 async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
-  const { route, ship, emit } = ctx;
+  const { route: route2, ship, emit } = ctx;
   const runId = randomBytes2(3).toString("hex");
-  const identity = await resolveSeatKey(route, role, ctx.getSessionStore);
+  const identity = await resolveSeatKey(route2, role, ctx.getSessionStore);
   if (identity.kind === "ship" && SEAT_KEY_ROLES.includes(role)) {
     emit.warn(`${role} writes as the ship, not its own agent: ${identity.reason}`, { step: "agent", role });
   } else if (identity.kind === "agent") {
     emit.emit(`${role} writes as its own agent principal`, { step: "agent", role });
   }
-  const tracker = new Tracker(route, ship, { apiKey: identity.apiKey });
+  const tracker = new Tracker(route2, ship, { apiKey: identity.apiKey });
   let ticketHint = decision.actionable.top?.issue_id;
-  let ticketRepo = repoTargetFor(route, decision.actionable.top?.repo_id)?.name;
+  let ticketRepo = repoTargetFor(route2, decision.actionable.top?.repo_id)?.name;
   let workingId = decision.actionable.top?.id ?? null;
   if (role === "dev" || role === "design" || role === "qa") {
-    const seat = route.resolved?.seats[role];
+    const seat = route2.resolved?.seats[role];
     if (seat) {
-      const candidates = rankedCandidates(role, decision.selectionInput);
+      const candidates2 = rankedCandidates(role, decision.selectionInput);
       const contract = decision.selectionInput.contract ?? DEFAULT_CONTRACT;
       const result = await resolveTopCandidate(
         tracker,
-        candidates,
+        candidates2,
         seat,
         claimStatuses(role, contract).approved,
         claimStatuses(role, contract).building,
-        (t) => dirForRepo(route, t.repo_id) !== null,
+        (t) => dirForRepo(route2, t.repo_id) !== null,
         withHoldCheck(await tracker.claimAffinity(), decision.selectionInput),
         (t) => {
           const got = ctx.state.acquireTicket(t.id);
@@ -18710,7 +18710,7 @@ async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
         decision.selectionInput.ships?.rows ?? [],
         ship.name,
         (t) => {
-          const d = dirForRepo(route, t.repo_id);
+          const d = dirForRepo(route2, t.repo_id);
           return d ? originBranchSha(d, t, resolve2) : null;
         }
       );
@@ -18721,16 +18721,16 @@ async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
       if (result.claimed) {
         const idx = decision.tickets.findIndex((t) => t.id === result.ticket.id);
         if (idx >= 0) decision.tickets[idx] = result.ticket;
-        writeDigest({ route, ship, state: ctx.state, emit }, decision, role, ship.stateDir);
+        writeDigest({ route: route2, ship, state: ctx.state, emit }, decision, role, ship.stateDir);
       }
-      writeDigest({ route, ship, state: ctx.state, emit }, decision, role, ship.stateDir, runId, {
+      writeDigest({ route: route2, ship, state: ctx.state, emit }, decision, role, ship.stateDir, runId, {
         ticket: result.ticket,
         inFlight: (id) => ctx.state.ticketInFlight(id)
       });
       hooks?.ready(true);
       ticketHint = result.ticket.issue_id;
       workingId = result.ticket.id;
-      const target = repoTargetFor(route, result.ticket.repo_id);
+      const target = repoTargetFor(route2, result.ticket.repo_id);
       ticketRepo = target?.name;
       try {
         if (target && ensureRepoCheckout(target.dir, target.remote)) {
@@ -18746,25 +18746,25 @@ async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
   }
   const plan = planAgentRun({
     role,
-    route,
+    route: route2,
     ship,
     stateDir: ship.stateDir,
-    roster: rosterFor(decision, route, role),
-    environment: await buildEnvironment(route, ship, ticketHint),
+    roster: rosterFor(decision, route2, role),
+    environment: await buildEnvironment(route2, ship, ticketHint),
     apiKey: identity.apiKey,
     cycle: emit.cycle,
     runId,
     ticket: ticketHint,
     repo: ticketRepo,
     ticketRecordId: workingId,
-    ...personaPromptOptions(await fetchPersonaPrompt(route, role, { userAgent: ship.userAgent })),
-    skillOverrides: await fetchSkillOverrides(route, { userAgent: ship.userAgent }),
-    agentPersona: await fetchSeatPersona(route, role, { userAgent: ship.userAgent }),
-    resolvedAgentId: await resolveAgentId(route, role, { userAgent: ship.userAgent })
+    ...personaPromptOptions(await fetchPersonaPrompt(route2, role, { userAgent: ship.userAgent })),
+    skillOverrides: await fetchSkillOverrides(route2, { userAgent: ship.userAgent }),
+    agentPersona: await fetchSeatPersona(route2, role, { userAgent: ship.userAgent }),
+    resolvedAgentId: await resolveAgentId(route2, role, { userAgent: ship.userAgent })
   });
   emit.enter("agent", role);
-  emit.emit(`starting agent run for ${route.route}`);
-  const memberId = route.resolved?.seats[role];
+  emit.emit(`starting agent run for ${route2.route}`);
+  const memberId = route2.resolved?.seats[role];
   if (memberId) {
     try {
       await tracker.setCrewStatus(memberId, "working", workingId);
@@ -18773,7 +18773,7 @@ async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
     }
   }
   try {
-    await tracker.beatEngaged(ship.name, route.route, workingId);
+    await tracker.beatEngaged(ship.name, route2.route, workingId);
   } catch (e) {
     emit.warn(`could not beat ship engaged: ${e.message}`, { step: "agent" });
   }
@@ -18792,12 +18792,12 @@ async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
       }
     }
     await spawnAgent(plan, emit, hintMoved);
-    await guardRunHandoff(route, ship, tracker, role, workingId, emit, runStart);
+    await guardRunHandoff(route2, ship, tracker, role, workingId, emit, runStart);
   } finally {
     await settleRunEnd({
       tracker,
       shipName: ship.name,
-      route,
+      route: route2,
       role,
       memberId,
       ownTicketRecordId: workingId,
@@ -18806,31 +18806,441 @@ async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
     });
   }
 }
-async function buildEnvironment(route, ship, ticket) {
-  const tracker = new Tracker(route, ship);
+async function buildEnvironment(route2, ship, ticket) {
+  const tracker = new Tracker(route2, ship);
   const contract = tracker.contract;
-  const repos = reposOf(route).map((t) => {
-    const id = repoIdForName(route, t.name);
-    const o = route.repoOverrides[t.name];
+  const repos = reposOf(route2).map((t) => {
+    const id = repoIdForName(route2, t.name);
+    const o = route2.repoOverrides[t.name];
     return {
       name: t.name,
       dir: t.dir,
       id,
       config: resolveRepoConfig(loadRepoConfig(t.dir), {
-        hooks: { ...route.hooks, ...o?.hooks },
-        labels: { ...route.labels, ...o?.labels },
-        branch: { ...route.branch, ...o?.branch },
+        hooks: { ...route2.hooks, ...o?.hooks },
+        labels: { ...route2.labels, ...o?.labels },
+        branch: { ...route2.branch, ...o?.branch },
         worktrees: { nameOverride: o?.worktreeName }
       }, t.dir)
     };
   });
   const authorship = await tracker.authorshipProbe().catch(() => null);
   const attachments = await tracker.attachmentsProbe().catch(() => null);
-  return renderEnvironment({ route, userAgent: ship.userAgent, repos, contract, sourceTicket: ticket, authorship, attachments, shipName: ship.name });
+  return renderEnvironment({ route: route2, userAgent: ship.userAgent, repos, contract, sourceTicket: ticket, authorship, attachments, shipName: ship.name });
+}
+
+// src/control-api.ts
+import { createHash as createHash8 } from "crypto";
+import {
+  chmodSync as chmodSync3,
+  closeSync as closeSync5,
+  existsSync as existsSync38,
+  fstatSync,
+  openSync as openSync5,
+  readSync as readSync3,
+  readdirSync as readdirSync17,
+  rmSync as rmSync17,
+  statSync as statSync12,
+  watch
+} from "fs";
+import { createConnection } from "net";
+import { createServer } from "http";
+import { basename as basename12, dirname as dirname21, join as join42 } from "path";
+import { execFile, spawn as spawn7 } from "child_process";
+var PAUSABLE = ["dev", "design", "qa"];
+var CONTROL_SOCKET_NAME = "control.sock";
+var controlSocketFor = (stateDir) => join42(stateDir, CONTROL_SOCKET_NAME);
+var MAX_SOCKET_PATH = 100;
+var MAX_TAIL_BYTES = 1024 * 1024;
+var MAX_WAIT_SECONDS = 30;
+var DEFAULT_TAIL_LINES = 100;
+var MAX_BODY_BYTES = 4096;
+var ControlAuth = class {
+  cache = /* @__PURE__ */ new Map();
+  o;
+  constructor(o) {
+    this.o = o;
+  }
+  async verify(token) {
+    if (!token) return "unauthorized";
+    for (const k of this.o.shipKeys()) if (k && secretsMatch(token, k)) return "ok";
+    const now = (this.o.now ?? Date.now)();
+    const id = createHash8("sha256").update(token).digest("hex");
+    const hit = this.cache.get(id);
+    if (hit && now - hit.at < (this.o.cacheMs ?? 6e4)) return hit.verdict;
+    const verdict = await this.ask(token);
+    if (verdict !== "unavailable") {
+      this.cache.set(id, { verdict, at: now });
+      if (this.cache.size > 256) {
+        for (const [k, v] of this.cache) if (now - v.at >= (this.o.cacheMs ?? 6e4)) this.cache.delete(k);
+      }
+    }
+    return verdict;
+  }
+  async ask(token) {
+    const doFetch = this.o.fetch ?? fetch;
+    const base = this.o.baseUrl.replace(/\/+$/, "");
+    let forbidden = false;
+    for (const ws of this.o.workspaceIds) {
+      let res;
+      try {
+        res = await doFetch(`${base}/api/auth/me?workspaceId=${encodeURIComponent(ws)}`, {
+          headers: { Authorization: `Bearer ${token}`, "User-Agent": this.o.userAgent ?? "Mozilla/5.0 CrewShipControl/1.0" },
+          signal: AbortSignal.timeout(this.o.timeoutMs ?? 5e3)
+        });
+      } catch {
+        return "unavailable";
+      }
+      if (res.status === 401) return "unauthorized";
+      if (res.status === 403) {
+        forbidden = true;
+        continue;
+      }
+      if (res.status !== 200) return "unavailable";
+      if (!(res.headers.get("content-type") ?? "").includes("application/json")) return "unavailable";
+      return "ok";
+    }
+    return forbidden ? "forbidden" : "unauthorized";
+  }
+};
+function encodeCursor(c) {
+  return Buffer.from(JSON.stringify([c.dev, c.ino, c.off])).toString("base64url");
+}
+function decodeCursor(s) {
+  try {
+    const a = JSON.parse(Buffer.from(s, "base64url").toString("utf8"));
+    if (Array.isArray(a) && a.length === 3 && a.every((n) => Number.isSafeInteger(n) && n >= 0)) {
+      return { dev: a[0], ino: a[1], off: a[2] };
+    }
+  } catch {
+  }
+  return null;
+}
+function candidates(live, rotated) {
+  const out = [live];
+  if (!rotated) return out;
+  try {
+    for (const n of readdirSync17(dirname21(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join42(dirname21(live), n));
+  } catch {
+  }
+  return out;
+}
+function readRange(path, from, max) {
+  const fd = openSync5(path, "r");
+  try {
+    const size = fstatSync(fd).size;
+    const len = Math.max(0, Math.min(size - from, max));
+    const buf = Buffer.alloc(len);
+    let got = 0;
+    while (got < len) {
+      const n = readSync3(fd, buf, got, len - got, from + got);
+      if (n <= 0) break;
+      got += n;
+    }
+    return { text: buf.subarray(0, got).toString("utf8"), size };
+  } finally {
+    closeSync5(fd);
+  }
+}
+function lastLines2(path, n) {
+  const st = statSync12(path);
+  const cursorAt = (off) => encodeCursor({ dev: st.dev, ino: st.ino, off });
+  if (n <= 0 || st.size === 0) return { lines: [], cursor: cursorAt(st.size), reset: false };
+  let start = st.size;
+  let text = "";
+  while (start > 0 && text.split("\n").length <= n + 1 && st.size - start < MAX_TAIL_BYTES) {
+    const step = Math.min(64 * 1024, start);
+    start -= step;
+    text = readRange(path, start, step).text + text;
+  }
+  let lines = text.split("\n");
+  if (start > 0) lines = lines.slice(1);
+  let end = st.size;
+  if (!text.endsWith("\n")) {
+    const frag = lines.pop() ?? "";
+    end -= Buffer.byteLength(frag);
+  } else lines.pop();
+  return { lines: lines.slice(-n).filter((l) => l.length), cursor: cursorAt(end), reset: false };
+}
+function readTail(live, opts) {
+  const max = opts.maxBytes ?? MAX_TAIL_BYTES;
+  if (!existsSync38(live)) {
+    return { lines: [], cursor: opts.after ?? encodeCursor({ dev: 0, ino: 0, off: 0 }), reset: false };
+  }
+  const cur = opts.after ? decodeCursor(opts.after) : null;
+  if (!opts.after) return lastLines2(live, opts.tail ?? DEFAULT_TAIL_LINES);
+  let reset = false;
+  let path = live;
+  let off = 0;
+  if (!cur) {
+    reset = true;
+  } else {
+    const found = candidates(live, opts.rotated ?? false).find((p) => {
+      try {
+        const s = statSync12(p);
+        return s.ino === cur.ino && s.dev === cur.dev;
+      } catch {
+        return false;
+      }
+    });
+    if (found) {
+      path = found;
+      off = cur.off;
+    } else reset = true;
+  }
+  let size = statSync12(path).size;
+  if (off > size) {
+    off = 0;
+    reset = true;
+  }
+  if (off >= size && path !== live) {
+    path = live;
+    off = 0;
+    size = statSync12(path).size;
+  }
+  const { text } = readRange(path, off, max);
+  const cut = text.lastIndexOf("\n");
+  const whole = cut < 0 ? "" : text.slice(0, cut + 1);
+  const st = statSync12(path);
+  return {
+    lines: whole.split("\n").filter((l) => l.length),
+    cursor: encodeCursor({ dev: st.dev, ino: st.ino, off: off + Buffer.byteLength(whole) }),
+    reset
+  };
+}
+function waitForChange(dir, ms3, signal) {
+  return new Promise((resolve6) => {
+    let w;
+    const done = () => {
+      clearTimeout(t);
+      clearInterval(poll);
+      signal.removeEventListener("abort", done);
+      try {
+        w?.close();
+      } catch {
+      }
+      resolve6();
+    };
+    const t = setTimeout(done, ms3);
+    const poll = setInterval(done, 500);
+    signal.addEventListener("abort", done);
+    try {
+      w = watch(dir, done);
+      w.on("error", () => {
+      });
+    } catch {
+    }
+  });
+}
+var reply = (status2, body) => ({ status: status2, body });
+var err = (status2, message) => reply(status2, { error: message });
+function pauseDoc(state) {
+  return {
+    crew: state.isPaused(),
+    release: state.isReleasePaused(),
+    roles: Object.fromEntries(PAUSABLE.map((r) => [r, state.isRolePaused(r)]))
+  };
+}
+function describeStream(r) {
+  return {
+    run: basename12(r.streamPath).replace(/\.jsonl$/, ""),
+    pid: r.pid,
+    ticket: r.ticket,
+    role: r.role,
+    model: r.model,
+    startedAt: r.spawnedAt,
+    // No run-time limit is enforced today; the field is here so a reader needs no change when one is.
+    deadline: null
+  };
+}
+var RUN_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+async function readJsonBody(req) {
+  const chunks = [];
+  let n = 0;
+  for await (const c of req) {
+    n += c.length;
+    if (n > MAX_BODY_BYTES) return null;
+    chunks.push(c);
+  }
+  if (!n) return {};
+  try {
+    const v = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+async function tailReply(path, q, rotated, abort) {
+  const after = q.get("after") ?? void 0;
+  const tail3 = q.has("tail") ? Number(q.get("tail")) : void 0;
+  if (tail3 !== void 0 && !(Number.isInteger(tail3) && tail3 >= 0 && tail3 <= 1e3)) return err(400, "tail must be an integer from 0 to 1000");
+  const wait = q.has("wait") ? Number(q.get("wait")) : 0;
+  if (!(Number.isFinite(wait) && wait >= 0)) return err(400, "wait must be a number of seconds");
+  if (after !== void 0 && !decodeCursor(after)) return err(400, "after is not a cursor this API issued");
+  const deadline = Date.now() + Math.min(wait, MAX_WAIT_SECONDS) * 1e3;
+  let r = readTail(path, { after, tail: tail3, rotated });
+  while (after && !r.lines.length && !r.reset && Date.now() < deadline && !abort.aborted) {
+    await waitForChange(dirname21(path), deadline - Date.now(), abort);
+    r = readTail(path, { after: r.cursor, rotated });
+  }
+  return reply(200, r);
+}
+async function route(deps, method, url, req, abort) {
+  const p = url.pathname.replace(/\/+$/, "") || "/";
+  const get2 = method === "GET";
+  const post3 = method === "POST";
+  if (p === "/status" && get2) {
+    const doc = await deps.status();
+    if (!doc) return err(502, "could not produce the status document");
+    return reply(200, {
+      ...doc,
+      daemon: {
+        alive: true,
+        pid: process.pid,
+        startedAt: deps.startedAt ?? readDaemonStarted(deps.stateDir),
+        uptimeSeconds: Math.round(process.uptime())
+      },
+      pause: pauseDoc(deps.state)
+    });
+  }
+  if (p === "/events" && get2) return tailReply(eventFileFor(deps.stateDir), url.searchParams, true, abort);
+  if (p === "/streams" && get2) return reply(200, { streams: liveRuns(deps.stateDir).map(describeStream) });
+  if (p.startsWith("/streams/") && get2) {
+    const run2 = decodeURIComponent(p.slice("/streams/".length));
+    if (!RUN_NAME_RE.test(run2) || run2.includes("..") || /\.(pid|meta\.json|events\.jsonl)$/.test(run2)) return err(400, "not a run name");
+    const file = join42(deps.stateDir, "streams", run2.endsWith(".jsonl") ? run2 : `${run2}.jsonl`);
+    if (!existsSync38(file)) return err(404, "no such run");
+    return tailReply(file, url.searchParams, false, abort);
+  }
+  if ((p === "/pause" || p === "/resume") && post3) {
+    const body = await readJsonBody(req);
+    if (!body) return err(400, "body must be a small JSON object");
+    const role = body.role;
+    if (role !== void 0 && !PAUSABLE.includes(role)) return err(400, `role must be one of ${PAUSABLE.join(", ")}`);
+    if (p === "/pause") deps.state.pause(role);
+    else deps.state.resume(role);
+    return reply(200, { ok: true, pause: pauseDoc(deps.state) });
+  }
+  if ((p === "/release/pause" || p === "/release/resume") && post3) {
+    deps.state.setReleasePaused(p === "/release/pause");
+    return reply(200, { ok: true, pause: pauseDoc(deps.state) });
+  }
+  const sched = /^\/scheduler\/(start|stop|restart)$/.exec(p);
+  if (sched && post3) {
+    const r = deps.scheduler(sched[1]);
+    return r.accepted ? reply(202, { accepted: true, detail: r.detail }) : err(409, r.detail);
+  }
+  if (p === "/doctor" && get2) {
+    const doc = await deps.doctor();
+    return doc ? reply(200, doc) : err(502, "could not produce the doctor report");
+  }
+  const known = ["/status", "/events", "/streams", "/pause", "/resume", "/release/pause", "/release/resume", "/doctor"];
+  if (known.includes(p) || p.startsWith("/streams/") || sched) return err(405, "method not allowed");
+  return err(404, "not found");
+}
+function send(res, r) {
+  const body = JSON.stringify(r.body);
+  res.writeHead(r.status, { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body), "Cache-Control": "no-store" });
+  res.end(body);
+}
+async function socketIsStale(path) {
+  if (!existsSync38(path)) return false;
+  return new Promise((resolve6) => {
+    const c = createConnection(path);
+    c.once("connect", () => {
+      c.destroy();
+      resolve6(false);
+    });
+    c.once("error", () => resolve6(true));
+  });
+}
+async function startControlServer(deps) {
+  const path = controlSocketFor(deps.stateDir);
+  const log = deps.log ?? (() => {
+  });
+  if (Buffer.byteLength(path) > MAX_SOCKET_PATH) {
+    log(`control API not started: socket path is too long for a unix socket (${path})`);
+    return null;
+  }
+  if (await socketIsStale(path)) rmSync17(path, { force: true });
+  else if (existsSync38(path)) {
+    log(`control API not started: ${path} is in use by another process`);
+    return null;
+  }
+  const server = createServer((req, res) => {
+    const abort = new AbortController();
+    res.on("close", () => abort.abort());
+    void (async () => {
+      try {
+        const m = /^Bearer (.+)$/.exec(req.headers.authorization ?? "");
+        const verdict = await deps.auth.verify(m?.[1]?.trim() ?? "");
+        if (verdict === "unauthorized") return send(res, err(401, "invalid or revoked key"));
+        if (verdict === "forbidden") return send(res, err(403, "this key does not belong to a workspace this ship serves"));
+        if (verdict === "unavailable") return send(res, err(503, "could not verify the key right now"));
+        send(res, await route(deps, req.method ?? "GET", new URL(req.url ?? "/", "http://ship"), req, abort.signal));
+      } catch (e) {
+        log(`control API request failed: ${e.message}`);
+        if (!res.headersSent) send(res, err(500, "internal error"));
+        else res.end();
+      }
+    })();
+  });
+  return new Promise((resolve6) => {
+    server.once("error", (e) => {
+      log(`control API not started: ${e.message}`);
+      resolve6(null);
+    });
+    server.listen(path, () => {
+      try {
+        chmodSync3(path, 384);
+      } catch {
+      }
+      server.on("error", (e) => log(`control API error: ${e.message}`));
+      resolve6({
+        server,
+        path,
+        close: () => new Promise((done) => {
+          server.close(() => {
+            rmSync17(path, { force: true });
+            done();
+          });
+        })
+      });
+    });
+  });
+}
+var shq2 = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+function runDetached(commands, spawnFn = spawn7) {
+  const script = `sleep 1; ${commands.map((c) => c.map(shq2).join(" ")).join("; ")}`;
+  const child = spawnFn("/bin/sh", ["-c", script], { detached: true, stdio: "ignore" });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+function schedulerHandler(control, run2 = runDetached) {
+  return (action) => {
+    const { startCommand: start, stopCommand: stop } = control;
+    if (!start || !stop) return { accepted: false, detail: "this host has no service manager for the daemon (cron or none)" };
+    const commands = action === "start" ? [start] : action === "stop" ? [stop] : [stop, start];
+    run2(commands);
+    return { accepted: true, detail: `${action} requested` };
+  };
+}
+function crewJson(args, timeoutMs = 6e4) {
+  return new Promise((resolve6) => {
+    execFile(process.execPath, [process.argv[1] ?? "", ...args], { timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024 }, (_e, stdout) => {
+      try {
+        const v = JSON.parse(String(stdout));
+        resolve6(v && typeof v === "object" && !Array.isArray(v) ? v : null);
+      } catch {
+        resolve6(null);
+      }
+    });
+  });
 }
 
 // src/cli.ts
-var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname21(process.execPath) : resolve5(dirname21(fileURLToPath(import.meta.url)), "..");
+var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname22(process.execPath) : resolve5(dirname22(fileURLToPath(import.meta.url)), "..");
 var RELEASE_LOCK_TTL_MS = 20 * 60 * 1e3;
 var CYCLE_SECONDS2 = 120;
 var STALE_CYCLES = 3;
@@ -19155,9 +19565,9 @@ if (command === "passenger-sync-daemon") {
   runSyncDaemonFromEnv();
 } else {
   let requireArmed = function(what) {
-    if (dryRun || route.enabled) return;
+    if (dryRun || route2.enabled) return;
     process.stderr.write(
-      `crew: route "${route.route}" is not enabled in ${cfg.configFile} \u2014 refusing to ${what}.
+      `crew: route "${route2.route}" is not enabled in ${cfg.configFile} \u2014 refusing to ${what}.
       Add --dry-run to see what it would do.
 `
     );
@@ -19268,7 +19678,7 @@ if (command === "passenger-sync-daemon") {
     } else {
       const toleratesNoRoutes = command === "credential" || command === "forge" || command === "repos" || command === "ship" || command === "disconnect" && flag("reset") || command === "connect" && flag("sign-out");
       const configless = command === "connect" && flag("sign-out") || command === "disconnect" && flag("reset");
-      if (configless && !existsSync38(findConfigFile(CREW_HOME))) {
+      if (configless && !existsSync39(findConfigFile(CREW_HOME))) {
         cfg = loadConfig(CREW_HOME, firstRunConfigPath(), { text: "ship: {}\n", allowNoRoutes: true });
       } else {
         cfg = loadConfig(CREW_HOME, void 0, toleratesNoRoutes ? { allowNoRoutes: true } : {});
@@ -19318,9 +19728,9 @@ if (command === "passenger-sync-daemon") {
   const worktreeArgs = command === "worktree" ? splitWorktreeArgs(positional, cfg.routes.map((r) => r.route)) : void 0;
   const named = worktreeArgs ? worktreeArgs.route : command === "daemon" && DAEMON_SUBCOMMANDS.has(positional[1] ?? "") ? positional[2] : positional[1];
   const fleetWide = command === "inbox" || command === "connect" || command === "disconnect" || command === "agents" || command === "skills" || command === "logbook" || command === "repos" || command === "ship" || command === "projects" || command === "periscope" || command === "whoami" || releaseFleetWide || command === "pause" || command === "resume" || command === "reload" || FLEET_CAPABLE.has(command) && !named && cfg.routes.length > 1 || worktreeArgs !== void 0 && !named && cfg.routes.length > 1;
-  let route;
+  let route2;
   try {
-    route = fleetWide ? cfg.routes[0] : findRoute(cfg, named);
+    route2 = fleetWide ? cfg.routes[0] : findRoute(cfg, named);
   } catch (e) {
     if (e instanceof ConfigError) {
       process.stderr.write(`crew: ${e.message}
@@ -19335,7 +19745,7 @@ if (command === "passenger-sync-daemon") {
   const force = flag("force");
   const EXCLUSIVE = { passengers: "passengers" };
   const emit = new Emitter({
-    route: route?.route ?? "",
+    route: route2?.route ?? "",
     eventFile: dryRun ? void 0 : eventFileFor(cfg.ship.stateDir),
     rotateBytes: cfg.ship.eventsRotateBytes,
     logFile: dryRun ? void 0 : cfg.ship.logFile,
@@ -19434,18 +19844,18 @@ if (command === "passenger-sync-daemon") {
     if (releaseRefused()) return;
     precheckTickets.clear();
     const only = value("repo");
-    const targets = reposOf(route);
+    const targets = reposOf(route2);
     const chosen = only ? targets.filter((t) => t.name === only) : targets;
     if (only && chosen.length === 0) {
       process.stderr.write(
-        `crew: no repo named "${only}" on route "${route.route}" (have: ${targets.map((t) => t.name).join(", ")})
+        `crew: no repo named "${only}" on route "${route2.route}" (have: ${targets.map((t) => t.name).join(", ")})
 `
       );
       process.exit(2);
     }
     const summaries = [];
     if (!dryRun) state.releaseHeartbeat().touch();
-    for (const t of chosen) summaries.push({ ...await releasePhase(route, t, opts), route: route.route });
+    for (const t of chosen) summaries.push({ ...await releasePhase(route2, t, opts), route: route2.route });
     emitReleaseSummary(emit, summaries);
     if (!dryRun) state.releaseHeartbeat().touch();
     try {
@@ -19533,8 +19943,8 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join42(homedir10(), ".config", "systemd", "user", `${label}.timer`);
-      if (existsSync38(staleTimer)) {
+      const staleTimer = join43(homedir10(), ".config", "systemd", "user", `${label}.timer`);
+      if (existsSync39(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
@@ -19561,7 +19971,7 @@ if (command === "passenger-sync-daemon") {
     const tracker = new Tracker(c, cfg.ship);
     problems.push(...validateContract(tracker.contract).map((p) => `contract: ${p}`));
     for (const r of await resolvedRepos(c)) {
-      if (!existsSync38(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
+      if (!existsSync39(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
       if (!satisfies(host, r.config.platform)) problems.push(`repo ${r.name}: requires ${r.config.platform}, this host is ${host}`);
       readiness.push(...validateEffective(r.config).map((p) => `repo ${r.name}: ${p}`));
     }
@@ -19579,7 +19989,7 @@ if (command === "passenger-sync-daemon") {
   }
   async function doctorFix(o) {
     const routes = await Promise.all(routesInScope(cfg.routes, named).map((c) => gatherHealth({ route: c.route, enabled: c.enabled, hasRepos: reposOf(c).length > 0 }, () => routeProblems(c))));
-    const unitExists = (p) => existsSync38(p);
+    const unitExists = (p) => existsSync39(p);
     const crontab = o.host === "linux" ? spawnSync7("crontab", ["-l"], { encoding: "utf8" }).stdout ?? "" : "";
     const schedulerAbsent = o.host !== "windows" ? !schedulerInstalled(planInstall(cfg.ship, CREW_HOME, o.host, detectSystemd(), "run"), unitExists, crontab) : true;
     const plan = planFix({ routes, schedulerAbsent, host: o.host });
@@ -20142,7 +20552,7 @@ ${cu.tail.trimEnd()}
     case "run": {
       const skipInlineRelease = flag("no-release");
       if (!dryRun) {
-        for (const r of fleetWide ? cfg.routes : [route]) {
+        for (const r of fleetWide ? cfg.routes : [route2]) {
           await reconcileRouteShipName({ route: r, ship: cfg.ship, configFile: cfg.configFile, emit: emit.forRoute(r.route) });
         }
       }
@@ -20189,8 +20599,8 @@ ${cu.tail.trimEnd()}
               `swept ${r.parked} parked, ${r.restored} restored${r.failed ? `, ${r.failed} failed` : ""}${r.contended ? `, ${r.contended} contended` : ""} (${e.route.route})`,
               { step: "sweep", data: r }
             );
-          } catch (err) {
-            remit.warn(`could not sweep ${e.route.route}: ${err.message}`, { step: "sweep" });
+          } catch (err2) {
+            remit.warn(`could not sweep ${e.route.route}: ${err2.message}`, { step: "sweep" });
           }
         }
         process.stdout.write(renderFleet(fleet, state));
@@ -20256,11 +20666,11 @@ ${cu.tail.trimEnd()}
         if (w.role === "dev" || w.role === "design" || w.role === "qa") {
           const seat = w.route.resolved?.seats[w.role];
           if (seat) {
-            const candidates = rankedCandidates(w.role, w.decision.selectionInput);
+            const candidates2 = rankedCandidates(w.role, w.decision.selectionInput);
             const contract = w.decision.selectionInput.contract ?? DEFAULT_CONTRACT;
             const result = await resolveTopCandidate(
               fleetTracker,
-              candidates,
+              candidates2,
               seat,
               claimStatuses(w.role, contract).approved,
               claimStatuses(w.role, contract).building,
@@ -20382,9 +20792,9 @@ ${cu.tail.trimEnd()}
         if (!skipInlineRelease) await releaseFleet();
         break;
       }
-      if (!await anyRepoServable(route)) {
+      if (!await anyRepoServable(route2)) {
         emit.error(
-          `refusing this route \u2014 this ship is ${cfg.ship.platform}, but ${await explainUnservable(route)}`
+          `refusing this route \u2014 this ship is ${cfg.ship.platform}, but ${await explainUnservable(route2)}`
         );
         process.exit(1);
       }
@@ -20392,10 +20802,10 @@ ${cu.tail.trimEnd()}
         emit.emit("the crew is paused");
         break;
       }
-      const decision = await decideCycle({ route, ship: cfg.ship, state, emit });
+      const decision = await decideCycle({ route: route2, ship: cfg.ship, state, emit });
       if (!dryRun) {
-        state.attention(route.route).persist(decision.attention);
-        state.unroutable(route.route).persist(decision.unroutable);
+        state.attention(route2.route).persist(decision.attention);
+        state.unroutable(route2.route).persist(decision.unroutable);
       }
       if (decision.sweep.length) {
         if (dryRun) {
@@ -20406,8 +20816,8 @@ ${cu.tail.trimEnd()}
             });
           }
         } else {
-          const seat = route.resolved?.seats.qa ?? route.resolved?.seats.dev;
-          const r = await applySweep(new Tracker(route, cfg.ship), decision.sweep, seat ?? "", emit);
+          const seat = route2.resolved?.seats.qa ?? route2.resolved?.seats.dev;
+          const r = await applySweep(new Tracker(route2, cfg.ship), decision.sweep, seat ?? "", emit);
           emit.emit(
             `swept ${r.parked} parked, ${r.restored} restored${r.failed ? `, ${r.failed} failed` : ""}${r.contended ? `, ${r.contended} contended` : ""}`,
             { step: "sweep", data: r }
@@ -20418,19 +20828,19 @@ ${cu.tail.trimEnd()}
         if (dryRun) {
           for (const s of decision.epicSync) emit.emit(`would move ${describeEpicStep(s)}`, { step: "sweep" });
         } else {
-          const tracker = new Tracker(route, cfg.ship);
+          const tracker = new Tracker(route2, cfg.ship);
           await applyEpicSync(tracker, decision.epicSync, tracker.contract, emit);
         }
       }
       if (!dryRun && decision.holdReleases?.length) {
-        const tracker = new Tracker(route, cfg.ship);
+        const tracker = new Tracker(route2, cfg.ship);
         await applyHoldReleases(tracker, decision.holdReleases, tracker.contract, emit);
       }
       const role = value("role") ?? decision.selection.selected;
       if (command === "poll") break;
       if (!dryRun) {
         try {
-          await new Tracker(route, cfg.ship).beatShip(cfg.ship.name);
+          await new Tracker(route2, cfg.ship).beatShip(cfg.ship.name);
         } catch (e) {
           emit.warn(`could not beat ship: ${e.message}`, { step: "poll" });
         }
@@ -20445,7 +20855,7 @@ ${cu.tail.trimEnd()}
       const explicitRole = value("role") !== void 0;
       const ran = [];
       let current = role;
-      const tracker2 = new Tracker(route, cfg.ship);
+      const tracker2 = new Tracker(route2, cfg.ship);
       while (current) {
         if (!dryRun) {
           const got = state.acquireRun(current, cfg.ship.maxConcurrentAgents, cfg.ship.roleConcurrency[current] ?? 1);
@@ -20462,20 +20872,20 @@ ${cu.tail.trimEnd()}
           lock = got;
         }
         let ticketHint = decision.actionable.top?.issue_id;
-        let ticketRepo = repoTargetFor(route, decision.actionable.top?.repo_id)?.name;
+        let ticketRepo = repoTargetFor(route2, decision.actionable.top?.repo_id)?.name;
         let workingId = decision.actionable.top?.id ?? null;
         if (!dryRun && (current === "dev" || current === "design" || current === "qa")) {
-          const seat = route.resolved?.seats[current];
+          const seat = route2.resolved?.seats[current];
           if (seat) {
-            const candidates = rankedCandidates(current, decision.selectionInput);
+            const candidates2 = rankedCandidates(current, decision.selectionInput);
             const contract = decision.selectionInput.contract ?? DEFAULT_CONTRACT;
             const result = await resolveTopCandidate(
               tracker2,
-              candidates,
+              candidates2,
               seat,
               claimStatuses(current, contract).approved,
               claimStatuses(current, contract).building,
-              (t) => dirForRepo(route, t.repo_id) !== null,
+              (t) => dirForRepo(route2, t.repo_id) !== null,
               withHoldCheck(await tracker2.claimAffinity(), decision.selectionInput),
               (t) => {
                 const got = state.acquireTicket(t.id);
@@ -20513,7 +20923,7 @@ ${cu.tail.trimEnd()}
               decision.selectionInput.ships?.rows ?? [],
               cfg.ship.name,
               (t) => {
-                const d = dirForRepo(route, t.repo_id);
+                const d = dirForRepo(route2, t.repo_id);
                 return d ? originBranchSha(d, t, resolve2) : null;
               }
             );
@@ -20531,11 +20941,11 @@ ${cu.tail.trimEnd()}
             if (result.claimed) {
               const idx = decision.tickets.findIndex((t) => t.id === result.ticket.id);
               if (idx >= 0) decision.tickets[idx] = result.ticket;
-              writeDigest({ route, ship: cfg.ship, state, emit }, decision, current, cfg.ship.stateDir);
+              writeDigest({ route: route2, ship: cfg.ship, state, emit }, decision, current, cfg.ship.stateDir);
             }
             ticketHint = result.ticket.issue_id;
             workingId = result.ticket.id;
-            const target = repoTargetFor(route, result.ticket.repo_id);
+            const target = repoTargetFor(route2, result.ticket.repo_id);
             ticketRepo = target?.name;
             try {
               if (target && ensureRepoCheckout(target.dir, target.remote)) {
@@ -20556,19 +20966,19 @@ ${cu.tail.trimEnd()}
         }
         const plan = planAgentRun({
           role: current,
-          route,
+          route: route2,
           ship: cfg.ship,
           stateDir: cfg.ship.stateDir,
-          roster: rosterFor(decision, route, current),
-          environment: await environmentFor(route, ticketHint),
-          apiKey: resolveApiKey(route),
+          roster: rosterFor(decision, route2, current),
+          environment: await environmentFor(route2, ticketHint),
+          apiKey: resolveApiKey(route2),
           cycle: emit.cycle,
           ticket: ticketHint,
           repo: ticketRepo,
-          ...personaPromptOptions(await fetchPersonaPrompt(route, current, { userAgent: cfg.ship.userAgent })),
-          skillOverrides: await fetchSkillOverrides(route, { userAgent: cfg.ship.userAgent }),
-          agentPersona: await fetchSeatPersona(route, current, { userAgent: cfg.ship.userAgent }),
-          resolvedAgentId: await resolveAgentId(route, current, { userAgent: cfg.ship.userAgent })
+          ...personaPromptOptions(await fetchPersonaPrompt(route2, current, { userAgent: cfg.ship.userAgent })),
+          skillOverrides: await fetchSkillOverrides(route2, { userAgent: cfg.ship.userAgent }),
+          agentPersona: await fetchSeatPersona(route2, current, { userAgent: cfg.ship.userAgent }),
+          resolvedAgentId: await resolveAgentId(route2, current, { userAgent: cfg.ship.userAgent })
         });
         if (dryRun) {
           process.stdout.write(`${describePlan(plan)}
@@ -20576,7 +20986,7 @@ ${cu.tail.trimEnd()}
           if (workingId && (current === "dev" || current === "design")) {
             try {
               const t = await tracker2.ticket(workingId);
-              const r = repoConfigFor(route, t);
+              const r = repoConfigFor(route2, t);
               const would = r && describeHandoffPush(r.target.dir, r.cfg, t, current);
               if (would) process.stdout.write(`${would}
 `);
@@ -20588,7 +20998,7 @@ ${cu.tail.trimEnd()}
         const before = snapshot(await tracker2.openTickets());
         emit.enter("agent", current);
         emit.emit("starting agent run");
-        const memberId = route.resolved?.seats[current];
+        const memberId = route2.resolved?.seats[current];
         if (memberId) {
           try {
             await tracker2.setCrewStatus(memberId, "working", workingId);
@@ -20597,20 +21007,20 @@ ${cu.tail.trimEnd()}
           }
         }
         try {
-          await tracker2.beatEngaged(cfg.ship.name, route.route, workingId);
+          await tracker2.beatEngaged(cfg.ship.name, route2.route, workingId);
         } catch (e) {
           emit.warn(`could not beat ship engaged: ${e.message}`, { step: "agent" });
         }
         try {
           const runStart = (/* @__PURE__ */ new Date()).toISOString();
           await spawnAgent(plan, emit);
-          await guardRunHandoff(route, cfg.ship, tracker2, current, workingId, emit, runStart);
+          await guardRunHandoff(route2, cfg.ship, tracker2, current, workingId, emit, runStart);
         } finally {
           dropLock();
           await settleRunEnd({
             tracker: tracker2,
             shipName: cfg.ship.name,
-            route,
+            route: route2,
             role: current,
             memberId,
             ownTicketRecordId: workingId,
@@ -20693,21 +21103,43 @@ ${cu.tail.trimEnd()}
         process.stderr.write("crew: daemon does not support --dry-run \u2014 it only ever performs real cycles.\n");
         process.exit(2);
       }
-      if (!await anyRepoServable(route)) {
+      if (!await anyRepoServable(route2)) {
         emit.error(
-          `refusing this route \u2014 this ship is ${cfg.ship.platform}, but ${await explainUnservable(route)}`
+          `refusing this route \u2014 this ship is ${cfg.ship.platform}, but ${await explainUnservable(route2)}`
         );
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join42(CREW_HOME, "src"), join42(CREW_HOME, "dist"), join42(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join43(CREW_HOME, "src"), join43(CREW_HOME, "dist"), join43(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
       const spawnBreaker = new SpawnBreaker();
+      const controlRoutes = cfg.routes.filter((r) => r.resolved?.workspaceId);
+      const controlServer = await startControlServer({
+        stateDir: cfg.ship.stateDir,
+        state,
+        auth: new ControlAuth({
+          baseUrl: route2.baseUrl || DEFAULT_BASE_URL,
+          workspaceIds: [...new Set(controlRoutes.map((r) => r.resolved.workspaceId))],
+          shipKeys: () => cfg.routes.flatMap((r) => {
+            try {
+              return [resolveApiKey(r)];
+            } catch {
+              return [];
+            }
+          }),
+          userAgent: cfg.ship.userAgent
+        }),
+        status: () => crewJson(["status", route2.route, "--json"]),
+        doctor: () => crewJson(["doctor", route2.route, "--json", "--offline"]),
+        scheduler: schedulerHandler(planDaemonControl(CREW_HOME, hostPlatform(), detectSystemd())),
+        log: (m) => emit.warn(m)
+      });
+      if (controlServer) emit.emit(`control API listening on ${controlServer.path}`);
       const stopReason = await runDaemonLoop({
         runPass: () => runOnePass({
-          route,
+          route: route2,
           ship: cfg.ship,
           state,
           maxConcurrentAgents: cfg.ship.maxConcurrentAgents,
@@ -20715,7 +21147,7 @@ ${cu.tail.trimEnd()}
           spawnBreaker,
           configFile: cfg.configFile,
           newEmitter: () => new Emitter({
-            route: route.route,
+            route: route2.route,
             eventFile: eventFileFor(cfg.ship.stateDir),
             rotateBytes: cfg.ship.eventsRotateBytes,
             logFile: cfg.ship.logFile,
@@ -20723,13 +21155,13 @@ ${cu.tail.trimEnd()}
 `)
           })
         }),
-        onTransient: ({ err, consecutive, backoffMs }) => emit.warn(
-          `tracker unavailable (${describeCause(err)}); attempt ${consecutive}, retrying in ${Math.round(backoffMs / 1e3)}s`
+        onTransient: ({ err: err2, consecutive, backoffMs }) => emit.warn(
+          `tracker unavailable (${describeCause(err2)}); attempt ${consecutive}, retrying in ${Math.round(backoffMs / 1e3)}s`
         ),
-        onOutage: ({ err, downMs }) => {
-          const msg = `tracker unreachable for ${Math.max(1, Math.round(downMs / 6e4))} minutes: ${describeCause(err)}`;
+        onOutage: ({ err: err2, downMs }) => {
+          const msg = `tracker unreachable for ${Math.max(1, Math.round(downMs / 6e4))} minutes: ${describeCause(err2)}`;
           emit.error(msg);
-          void raiseShipAttention({ state, emit, route, ship: cfg.ship }, {
+          void raiseShipAttention({ state, emit, route: route2, ship: cfg.ship }, {
             kind: "tracker_unreachable",
             key: TRACKER_OUTAGE_KEY,
             message: msg,
@@ -20740,8 +21172,8 @@ ${cu.tail.trimEnd()}
           clearShipAttention(state, TRACKER_OUTAGE_KEY);
           emit.emit(`tracker is back after ${Math.max(1, Math.round(downMs / 1e3))}s`);
         },
-        onPassError: (err) => emit.error(
-          `daemon pass failed, continuing: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
+        onPassError: (err2) => emit.error(
+          `daemon pass failed, continuing: ${err2 instanceof Error ? err2.stack ?? err2.message : String(err2)}`
         ),
         checkStale: makeStaleChecker(watchPaths, { reloadSentinel: reloadSentinelFor(cfg.ship.stateDir) }),
         onPass: (result) => {
@@ -20749,6 +21181,7 @@ ${cu.tail.trimEnd()}
           for (const s of result.skipped) emit.emit(`daemon pass skipped ${s.role} \u2014 ${s.reason}`);
         }
       });
+      await controlServer?.close();
       if (stopReason === "stale") {
         emit.emit(
           "crew daemon: installed tree, crew.yaml or a reload request changed on disk \u2014 exiting cleanly so the OS-level restart relaunches with the update"
@@ -20777,7 +21210,7 @@ ${cu.tail.trimEnd()}
           role: value("role"),
           ticket: value("ticket"),
           level: value("level"),
-          route: positional[1] ? route.route : void 0
+          route: positional[1] ? route2.route : void 0
         }
       });
       process.on("SIGINT", () => {
@@ -20929,7 +21362,7 @@ ${cu.tail.trimEnd()}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync38(resolvedPath) ? JSON.parse(readFileSync34(resolvedPath, "utf8")) : {};
+        const raw = existsSync39(resolvedPath) ? JSON.parse(readFileSync34(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
         mkdirSync25(dirOf2(resolvedPath), { recursive: true });
         writeFileSync26(resolvedPath, `${JSON.stringify(raw, null, 2)}
@@ -21009,7 +21442,7 @@ ${cu.tail.trimEnd()}
           const found = cfg.routes.find((r) => r.route === routeArg);
           if (!found) throw new ReposError(`no route "${routeArg}" in the config (have: ${cfg.routes.map((r) => r.route).join(", ") || "none"})`);
           const named2 = value("route") ? void 0 : positional[3];
-          const dir = named2 ? repoDirOf(configText, dirname21(cfg.configFile), found.route, named2) : resolvePath(positional[value("route") ? 2 : 3] ?? ".");
+          const dir = named2 ? repoDirOf(configText, dirname22(cfg.configFile), found.route, named2) : resolvePath(positional[value("route") ? 2 : 3] ?? ".");
           const target = reposOf(found).find((t) => resolvePath(t.dir) === dir || t.name === named2);
           const o = target ? found.repoOverrides[target.name] : void 0;
           runReposCheck(dir, {
@@ -21032,11 +21465,11 @@ ${cu.tail.trimEnd()}
       if (sub === "hooks") {
         try {
           const a = parseHooksArgs(positional.slice(2), routeNamesOf(configText));
-          const dir = repoDirOf(configText, dirname21(cfg.configFile), a.route, a.name);
-          if (!existsSync38(dir)) throw new ReposError(`${dir} does not exist on disk`);
-          const files = { exists: (r) => existsSync38(resolvePath(dir, r)), list: (r) => {
+          const dir = repoDirOf(configText, dirname22(cfg.configFile), a.route, a.name);
+          if (!existsSync39(dir)) throw new ReposError(`${dir} does not exist on disk`);
+          const files = { exists: (r) => existsSync39(resolvePath(dir, r)), list: (r) => {
             try {
-              return readdirSync17(resolvePath(dir, r));
+              return readdirSync18(resolvePath(dir, r));
             } catch {
               return [];
             }
@@ -21152,7 +21585,7 @@ ${cu.tail.trimEnd()}
       if (sub === "list" && !routeName) usage2();
       if (sub === "add") {
         try {
-          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync38(resolvePath(p.replace(/^~(?=\/|$)/, homedir10()))));
+          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync39(resolvePath(p.replace(/^~(?=\/|$)/, homedir10()))));
           routeName = a.route;
           addPath = a.path;
           addName = a.name;
@@ -21181,7 +21614,7 @@ ${cu.tail.trimEnd()}
       }
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, routeName);
       let resolvedRemotes;
-      if (existsSync38(resolvedFile)) {
+      if (existsSync39(resolvedFile)) {
         try {
           resolvedRemotes = JSON.parse(readFileSync34(resolvedFile, "utf8"));
         } catch {
@@ -21189,8 +21622,8 @@ ${cu.tail.trimEnd()}
       }
       const originOf = (dir) => gitOk(dir, ["remote", "get-url", "origin"]) ?? void 0;
       const text = configText;
-      const base = dirname21(cfg.configFile);
-      const isCheckout = (d) => existsSync38(`${d}/.git`);
+      const base = dirname22(cfg.configFile);
+      const isCheckout = (d) => existsSync39(`${d}/.git`);
       try {
         if (sub === "list") {
           if (flag("json")) {
@@ -21200,7 +21633,7 @@ ${cu.tail.trimEnd()}
               base,
               resolved: resolvedRemotes,
               originOf,
-              exists: (d) => existsSync38(d),
+              exists: (d) => existsSync39(d),
               isCheckout,
               repoHasHooks: (d) => REPO_CONFIG_FILENAMES.some((f) => {
                 try {
@@ -21221,7 +21654,7 @@ ${cu.tail.trimEnd()}
           for (const r of repos) {
             const origin2 = originOf(r.dir);
             const row = matchRepoName(origin2, resolvedRemotes);
-            const note = !existsSync38(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
+            const note = !existsSync39(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
             process.stdout.write(`${r.name}	${r.dir}	${note}
 `);
           }
@@ -21233,9 +21666,9 @@ ${cu.tail.trimEnd()}
 ` : `${human}
 `);
           const plan2 = planRepoClone({ text, base, route: routeName, name: addName, resolved: resolvedRemotes, dir: value("dir"), isCheckout });
-          if (existsSync38(plan2.target) && (existsSync38(`${plan2.target}/.git`) || readdirSync17(plan2.target).length > 0)) {
+          if (existsSync39(plan2.target) && (existsSync39(`${plan2.target}/.git`) || readdirSync18(plan2.target).length > 0)) {
             throw new ReposError(
-              existsSync38(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
+              existsSync39(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
             );
           }
           if (dryRun) {
@@ -21260,7 +21693,7 @@ ${cu.tail.trimEnd()}
           break;
         }
         const target = resolvePath(addPath.replace(/^~(?=\/|$)/, homedir10()));
-        const top = existsSync38(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
+        const top = existsSync39(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
         if (!top) throw new ReposError(`${target} is not a git checkout`);
         const origin = originOf(top);
         const plan = planRepoAdd({
@@ -21312,7 +21745,7 @@ ${cu.tail.trimEnd()}
           const created = await rowTracker.createRepoRow(rowPayload);
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
-          if (existsSync38(resolvedFile)) {
+          if (existsSync39(resolvedFile)) {
             const raw = JSON.parse(readFileSync34(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
@@ -21693,11 +22126,11 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         if (found.shipRow) {
           connectEvents.emit("ship_row", `Ships row "${found.shipRow.name}" ${found.shipRow.action}`, found.shipRow);
         }
-        const route2 = `${found.workspaceSlug}/${found.projectSlug ?? found.projectId}`;
-        const resolvedPath = resolvedPathFor(cfg.ship.stateDir, route2);
+        const route3 = `${found.workspaceSlug}/${found.projectSlug ?? found.projectId}`;
+        const resolvedPath = resolvedPathFor(cfg.ship.stateDir, route3);
         const capabilities = await checkCapabilities(authOpts, found);
         if (flag("json")) {
-          process.stdout.write(`${JSON.stringify({ event: "capabilities", route: route2, items: capabilities })}
+          process.stdout.write(`${JSON.stringify({ event: "capabilities", route: route3, items: capabilities })}
 `);
         } else {
           process.stderr.write("capabilities for this key:\n");
@@ -21706,10 +22139,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         }
         const capabilityMisses = capabilities.filter((i) => i.status === "missing").map(missLine);
         if (found.locksModelId && !dryRun) {
-          const configured = cfg.routes.find((r) => r.route === route2);
+          const configured = cfg.routes.find((r) => r.route === route3);
           const repoNames = [...Object.values(found.repoNames ?? {}), ...configured ? reposOf(configured).map((t) => t.name) : []].filter((n) => !!n);
           try {
-            const made = await provisionReleaseLocks(authOpts, found.locksModelId, route2, repoNames);
+            const made = await provisionReleaseLocks(authOpts, found.locksModelId, route3, repoNames);
             for (const sc of made) process.stderr.write(`created release lock row ${sc}
 `);
           } catch (e) {
@@ -21730,7 +22163,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           }
         }
         let previous;
-        const hadPreviousFile = existsSync38(resolvedPath);
+        const hadPreviousFile = existsSync39(resolvedPath);
         if (hadPreviousFile) {
           try {
             previous = JSON.parse(readFileSync34(resolvedPath, "utf8"));
@@ -21785,7 +22218,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         }
         if (!operator && !hadPreviousFile && !operatorWouldBeCreated) {
           process.stderr.write(
-            `crew connect ${route2}: cannot determine the operator \u2014 ${found.candidates.length} Crew row(s) could be it, none matching this key's own email, and there's no terminal to ask.
+            `crew connect ${route3}: cannot determine the operator \u2014 ${found.candidates.length} Crew row(s) could be it, none matching this key's own email, and there's no terminal to ask.
   Re-run from a real terminal to pick one, or pass --key for a key whose own
   identity email matches exactly one Crew row.
 `
@@ -21862,7 +22295,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.stderr.write(`(dry run) would write resolved ids to ${resolvedPath}
 `);
         } else {
-          mkdirSync25(dirname21(resolvedPath), { recursive: true });
+          mkdirSync25(dirname22(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
           writeFileSync26(tmpPath, `${JSON.stringify(resolved, null, 2)}
@@ -21906,12 +22339,12 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           stopWithProblem(msg, "wizard");
         }
         if ((mintedFromDevice || firstRunFromFlags) && !keychainBacked) {
-          apiKeyFile = apiKeyPathFor(cfg.ship.stateDir, route2);
+          apiKeyFile = apiKeyPathFor(cfg.ship.stateDir, route3);
           if (dryRun) {
             process.stderr.write(`(dry run) would write the minted API key to ${apiKeyFile}
 `);
           } else {
-            mkdirSync25(dirname21(apiKeyFile), { recursive: true });
+            mkdirSync25(dirname22(apiKeyFile), { recursive: true });
             writeFileSync26(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
@@ -21924,7 +22357,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         const routeDir = value("dir");
         const routeBlock = renderConnection(
           found,
-          route2,
+          route3,
           routeDir ?? (writeFirstRun ? null : "REPLACE \u2014 the local checkout this route works"),
           {
             area: value("area"),
@@ -22006,7 +22439,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         }
         if (wroteConfig) {
           process.stderr.write(nextSteps({
-            route: route2,
+            route: route3,
             configPath: wizard.configPath,
             platform: cfg.ship.platform,
             needsRepos: !value("dir")
@@ -22016,14 +22449,14 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         } else if (operator) {
           process.stderr.write(
             `
-  Paste the block above under routes: in crew.yaml (if "${route2}" isn't there already), then: crew doctor ${route2}
+  Paste the block above under routes: in crew.yaml (if "${route3}" isn't there already), then: crew doctor ${route3}
 `
           );
         } else {
           process.stderr.write(
             `
-  Paste the block above under routes: in crew.yaml (if "${route2}" isn't there
-  already), set operator in ${resolvedPath}, then: crew doctor ${route2}
+  Paste the block above under routes: in crew.yaml (if "${route3}" isn't there
+  already), set operator in ${resolvedPath}, then: crew doctor ${route3}
 `
           );
         }
@@ -22032,12 +22465,12 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             process.stderr.write(`
   agents sync: skipped (${why})
 `);
-            connectEvents.emit("agents_synced", `agents sync skipped: ${why}`, { route: route2, skipped: why });
+            connectEvents.emit("agents_synced", `agents sync skipped: ${why}`, { route: route3, skipped: why });
           };
           let syncRoute;
           try {
             const reloaded = loadConfig(CREW_HOME, wizard?.configPath ?? cfg.configFile, { allowNoRoutes: true });
-            syncRoute = reloaded.routes.find((r) => r.route === route2);
+            syncRoute = reloaded.routes.find((r) => r.route === route3);
             if (syncRoute) await hydrateApiKeys([syncRoute]);
           } catch (e) {
             skip(`config did not load: ${e.message}`);
@@ -22065,24 +22498,24 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
                 process.stderr.write(missing ? "  A workspace admin has to open the Crew app or run `crew agents sync` once before this ship's seats can run.\n" : "  Seats are linked to the workspace's existing personas.\n");
               }
               connectEvents.emit("agents_synced", run2.readOnly ? "agents linked (read-only key)" : "agents synced", {
-                route: route2,
+                route: route3,
                 admin: !run2.readOnly,
                 personas: run2.personaResult.outcomes,
                 skills: run2.skillResult?.outcomes ?? [],
                 diverged: run2.diverged
               });
-              for (const m of minted) connectEvents.emit("seat_key", describeMintOutcome(m), { route: route2, ...m });
+              for (const m of minted) connectEvents.emit("seat_key", describeMintOutcome(m), { route: route3, ...m });
               if (run2.diverged) process.exitCode = 1;
             } catch (e) {
               if (e instanceof AgentsSyncError || e instanceof SkillSyncError) skip(e.message);
               else throw e;
             }
           } else if (!syncRoute) {
-            skip(`"${route2}" is not in crew.yaml yet; add the block above, then run \`crew agents sync\``);
+            skip(`"${route3}" is not in crew.yaml yet; add the block above, then run \`crew agents sync\``);
           }
         }
-        connectEvents.emit("done", `connected ${route2}`, {
-          route: route2,
+        connectEvents.emit("done", `connected ${route3}`, {
+          route: route3,
           resolvedPath: dryRun ? void 0 : resolvedPath,
           configPath: wroteConfig ? wizard.configPath : void 0,
           wroteConfig,
@@ -22196,7 +22629,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       break;
     }
     case "ports": {
-      const where = await worktreeLocations(route);
+      const where = await worktreeLocations(route2);
       const rows = listeners().map((l) => ({ ...l, t: ticketForPort(l.port) })).filter((r) => r.t).sort((a, b) => a.port - b.port);
       if (!rows.length) {
         process.stdout.write("nothing of ours is listening\n");
@@ -22214,7 +22647,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
     case "reap": {
       emit.enter("worktree");
       let anything = false;
-      const orphans = findOrphansIn(await worktreeLocations(route));
+      const orphans = findOrphansIn(await worktreeLocations(route2));
       for (const o of orphans) {
         anything = true;
         emit.emit(
@@ -22222,12 +22655,12 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         );
       }
       if (!dryRun && orphans.length) await killGently(orphans.map((o) => o.pid));
-      const tracker = new Tracker(route, cfg.ship);
+      const tracker = new Tracker(route2, cfg.ship);
       const truncated = (limit) => emit.warn(`ticket lookup for the sweep hit its ${limit}-row limit; some tickets may be missed`, { step: "worktree" });
-      for (const r of await resolvedRepos(route)) {
-        const wtTickets = ticketsByRepo(route, await tracker.ticketsByNumbers(worktreeTicketNumbers(r), truncated)).byRepo.get(r.name) ?? [];
+      for (const r of await resolvedRepos(route2)) {
+        const wtTickets = ticketsByRepo(route2, await tracker.ticketsByNumbers(worktreeTicketNumbers(r), truncated)).byRepo.get(r.name) ?? [];
         const brTickets = ticketsByRepo(
-          route,
+          route2,
           await tracker.ticketsByNumbers(remoteBranchTicketNumbers(r.dir, r.config.branch.remote, r.config.branch.base), truncated)
         ).byRepo.get(r.name) ?? [];
         const actions = planWorktreeSweep(r, wtTickets, tracker.contract);
@@ -22282,26 +22715,26 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         process.exit(2);
       }
       const num = Number(n);
-      const repos = await resolvedRepos(route);
-      const candidates = repos.map((r) => ({ repo: r, found: worktreeForNumber(r.dir, n) })).filter((c) => c.found !== null);
-      if (candidates.length === 0) {
+      const repos = await resolvedRepos(route2);
+      const candidates2 = repos.map((r) => ({ repo: r, found: worktreeForNumber(r.dir, n) })).filter((c) => c.found !== null);
+      if (candidates2.length === 0) {
         process.stderr.write(
           `drop: no worktree for ISSUE-${n} in any of this route's repositories (looked in: ${repos.map((r) => r.dir).join(", ")})
 `
         );
         process.exit(2);
       }
-      if (candidates.length > 1) {
+      if (candidates2.length > 1) {
         process.stderr.write(
-          `drop: ISSUE-${n} has a worktree in more than one repository (${candidates.map((c) => c.repo.name).join(", ")}) \u2014 remove them one at a time by path
+          `drop: ISSUE-${n} has a worktree in more than one repository (${candidates2.map((c) => c.repo.name).join(", ")}) \u2014 remove them one at a time by path
 `
         );
         process.exit(2);
       }
-      const { repo: target, found } = candidates[0];
+      const { repo: target, found } = candidates2[0];
       const wt = found.path;
       try {
-        const trD = new Tracker(route, cfg.ship);
+        const trD = new Tracker(route2, cfg.ship);
         const tD = (await trD.ticketsByNumbers([n])).find((t) => t.issue_id.replace(/^\D+/, "") === String(num));
         if (tD && tD[trD.contract.columns.status] === trD.contract.statuses.draft) {
           process.stderr.write(`drop: ${tD.issue_tag ?? tD.issue_id} is a draft ticket \u2014 its worktree belongs to a periscope; end it with \`crew periscope down ${num} --keep\` or \`--discard\`
@@ -22340,9 +22773,9 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
     }
     case "rotate-passenger-url": {
       emit.enter("passengers");
-      if (!route.hostPassengers) {
+      if (!route2.hostPassengers) {
         process.stderr.write(
-          `crew rotate-passenger-url: route "${route.route}" does not have hostPassengers enabled
+          `crew rotate-passenger-url: route "${route2.route}" does not have hostPassengers enabled
 `
         );
         process.exit(2);
@@ -22351,16 +22784,16 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         process.stderr.write("crew rotate-passenger-url: this ship has no relayHost configured \u2014 nothing to rotate\n");
         process.exit(2);
       }
-      const workspaceId = route.resolved?.workspaceId;
+      const workspaceId = route2.resolved?.workspaceId;
       if (!workspaceId) {
-        process.stderr.write(`crew rotate-passenger-url: route "${route.route}" has no resolved ids \u2014 run \`crew connect\`
+        process.stderr.write(`crew rotate-passenger-url: route "${route2.route}" has no resolved ids \u2014 run \`crew connect\`
 `);
         process.exit(2);
       }
       const plans = planContainers(cfg).filter((p) => p.workspaceId === workspaceId);
       if (!plans.length) {
         process.stderr.write(
-          `crew rotate-passenger-url: no Host Passengers container is planned for "${route.route}" right now
+          `crew rotate-passenger-url: no Host Passengers container is planned for "${route2.route}" right now
 `
         );
         process.exit(2);
@@ -22369,7 +22802,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       const hasLiveTunnel = existing !== void 0 && isPidAlive(existing.pid);
       if (dryRun) {
         emit.emit(
-          hasLiveTunnel ? `would kill tunnel pid ${existing.pid} for ${route.route} and reconnect with a fresh public URL` : `would reconnect ${route.route} with a fresh public URL (no live tunnel to kill)`
+          hasLiveTunnel ? `would kill tunnel pid ${existing.pid} for ${route2.route} and reconnect with a fresh public URL` : `would reconnect ${route2.route} with a fresh public URL (no live tunnel to kill)`
         );
         break;
       }
@@ -22381,13 +22814,13 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         }
       }
       const { privateKeyPath } = ensureShipSshKeypair(cfg.ship.stateDir);
-      const rotateReconcile = endpointReconcileDeps([route], cfg.ship.relayHost);
+      const rotateReconcile = endpointReconcileDeps([route2], cfg.ship.relayHost);
       const rotatePending = [];
       syncPassengerTunnels(plans, cfg.ship.relayHost, cfg.ship.relayPort, privateKeyPath, cfg.ship.stateDir, /* @__PURE__ */ new Map(), {
-        apiKeys: passengerApiKeys([route]),
+        apiKeys: passengerApiKeys([route2]),
         onStatus: (wsId, status2, info) => {
           rotatePending.push(
-            new Tracker(route, cfg.ship).updateTunnelState(cfg.ship.name, { tunnel_status: status2 }).catch((e) => {
+            new Tracker(route2, cfg.ship).updateTunnelState(cfg.ship.name, { tunnel_status: status2 }).catch((e) => {
               emit.warn(`could not write tunnel_status: ${e.message}`, { step: "passengers" });
             })
           );
@@ -22395,7 +22828,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         }
       });
       await Promise.all(rotatePending);
-      emit.emit(`rotated the passenger tunnel for ${route.route} \u2014 it reconnects under a fresh slug and the registered endpoint follows on the next passengers cycle`);
+      emit.emit(`rotated the passenger tunnel for ${route2.route} \u2014 it reconnects under a fresh slug and the registered endpoint follows on the next passengers cycle`);
       break;
     }
     case "worktree": {
@@ -22406,7 +22839,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         process.stderr.write("worktree: need a ticket number (326, ISSUE-326, or TABL-326)\n");
         process.exit(2);
       }
-      const candidatesWt = !named && cfg.routes.length > 1 ? cfg.routes.filter((r) => r.enabled) : [route];
+      const candidatesWt = !named && cfg.routes.length > 1 ? cfg.routes.filter((r) => r.enabled) : [route2];
       let ticketWt;
       const lookedWt = [];
       const hitsWt = /* @__PURE__ */ new Map();
@@ -22426,7 +22859,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
 `);
         process.exit(2);
       }
-      const routeWt = candidatesWt.find((r) => r.route === pickedWt.route) ?? route;
+      const routeWt = candidatesWt.find((r) => r.route === pickedWt.route) ?? route2;
       ticketWt = hitsWt.get(pickedWt.route);
       if (!ticketWt) process.exit(2);
       const repoWt = (await resolvedRepos(routeWt)).find((r) => r.id === ticketWt.repo_id) ?? (await resolvedRepos(routeWt))[0];
@@ -22646,7 +23079,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           const shellR = hit && resolveShell(hit.repo.config.shell ?? cfg.ship.shell);
           const resumed = await runPeriscopeResume({
             find: async () => hit && { row: hit.row, tag: hit.tag },
-            worktreeExists: (p) => existsSync38(p),
+            worktreeExists: (p) => existsSync39(p),
             caps: periscopeCaps(cfg.ship),
             runHook: async (name, cwd, env) => {
               const script = hit?.repo.config.hooks[name];
@@ -22740,10 +23173,10 @@ ${where.join("\n")}`);
           },
           prepare: async (path) => {
             for (const f of repoP.config.worktrees.copy) {
-              const src = join42(repoP.dir, f);
-              if (!existsSync38(src)) continue;
-              mkdirSync25(dirOf2(join42(path, f)), { recursive: true });
-              copyFileSync2(src, join42(path, f));
+              const src = join43(repoP.dir, f);
+              if (!existsSync39(src)) continue;
+              mkdirSync25(dirOf2(join43(path, f)), { recursive: true });
+              copyFileSync2(src, join43(path, f));
             }
             const setup = repoP.config.hooks.setup;
             return setup ? runScript(setup, { cwd: path, shell: shellP, onLine: (l) => {
@@ -22852,13 +23285,13 @@ ${where.join("\n")}`);
         process.stderr.write("unassign: need a ticket number (326, ISSUE-326, or TABL-326)\n");
         process.exit(2);
       }
-      const tracker3 = new Tracker(route, cfg.ship);
+      const tracker3 = new Tracker(route2, cfg.ship);
       const c = tracker3.contract;
       const key = `ISSUE-${n}`;
       const open = await tracker3.openTickets();
       const ticket = open.find((t) => t[c.columns.key] === key);
       if (!ticket) {
-        process.stderr.write(`unassign: no open ticket ${key} on ${route.route} (already resolved, or not this route's)
+        process.stderr.write(`unassign: no open ticket ${key} on ${route2.route} (already resolved, or not this route's)
 `);
         process.exit(2);
       }
@@ -22892,10 +23325,10 @@ ${where.join("\n")}`);
       let baseChecked = 0;
       let baseActed = 0;
       let baseUnsafe = 0;
-      for (const r of await resolvedRepos(route)) {
+      for (const r of await resolvedRepos(route2)) {
         const base = refreshBaseBranch(r.dir, r.config.branch.remote, r.config.branch.base, dryRun);
         const att = dryRun ? null : baseAttention(r.name, base, r.config.branch.remote, r.config.branch.base);
-        if (att && "raise" in att) await raiseShipAttention({ state, emit, route, ship: cfg.ship }, att.raise);
+        if (att && "raise" in att) await raiseShipAttention({ state, emit, route: route2, ship: cfg.ship }, att.raise);
         else if (att) clearShipAttention(state, att.clear);
         if (base.action !== "not-applicable") {
           baseChecked++;
@@ -23133,13 +23566,13 @@ ${where.join("\n")}`);
 `);
         return process.exit(2);
       };
-      if (!route.resolved) fail(`route ${route.route} is not connected \u2014 run \`crew connect\` first`);
-      const tracker = new Tracker(route, cfg.ship);
+      if (!route2.resolved) fail(`route ${route2.route} is not connected \u2014 run \`crew connect\` first`);
+      const tracker = new Tracker(route2, cfg.ship);
       const configText = readFileSync34(cfg.configFile, "utf8");
-      const cfgBase = dirname21(cfg.configFile);
-      const configured = configuredRepos(configText, route.route, cfgBase);
-      const dir = configured.find((r) => r.name === SAMPLE_REPO)?.dir ?? sampleDir(configured.map((r) => r.dir), route.reposBasePath, route.route.split("/")[0]);
-      const resolvedFile = resolvedPathFor(cfg.ship.stateDir, route.route);
+      const cfgBase = dirname22(cfg.configFile);
+      const configured = configuredRepos(configText, route2.route, cfgBase);
+      const dir = configured.find((r) => r.name === SAMPLE_REPO)?.dir ?? sampleDir(configured.map((r) => r.dir), route2.reposBasePath, route2.route.split("/")[0]);
+      const resolvedFile = resolvedPathFor(cfg.ship.stateDir, route2.route);
       const rows = await tracker.repoRows();
       const row = rows.find((r) => r.name === SAMPLE_REPO);
       if (flag("remove")) {
@@ -23164,7 +23597,7 @@ ${where.join("\n")}`);
         }
         if (configured.some((r) => r.dir === dir)) {
           try {
-            writeFileSync26(cfg.configFile, planRepoRemove(configText, cfgBase, route.route, dir).text);
+            writeFileSync26(cfg.configFile, planRepoRemove(configText, cfgBase, route2.route, dir).text);
           } catch (e) {
             if (e instanceof ReposError) fail(e.message);
             throw e;
@@ -23172,7 +23605,7 @@ ${where.join("\n")}`);
         }
         if (row) {
           await tracker.deleteRepoRow(row.id);
-          if (existsSync38(resolvedFile)) {
+          if (existsSync39(resolvedFile)) {
             const raw = JSON.parse(readFileSync34(resolvedFile, "utf8"));
             if (raw.repoNames) delete raw.repoNames[row.id];
             if (raw.repoRemotes) delete raw.repoRemotes[row.id];
@@ -23180,21 +23613,21 @@ ${where.join("\n")}`);
 `);
           }
         }
-        if (existsSync38(join42(dir, ".git")) && basename12(dir) === SAMPLE_REPO) rmSync17(dir, { recursive: true, force: true });
+        if (existsSync39(join43(dir, ".git")) && basename13(dir) === SAMPLE_REPO) rmSync18(dir, { recursive: true, force: true });
         say("removed", { dir, closed }, `removed the sample repo${closed.length ? `, closed ${closed.join(", ")}` : ""}`);
         break;
       }
-      const projectId = route.resolved.areaId ?? resolveRepoProject(await tracker.projectRows(), value("project"));
-      const fresh = !existsSync38(join42(dir, ".git"));
-      if (existsSync38(dir) && fresh && readdirSync17(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
+      const projectId = route2.resolved.areaId ?? resolveRepoProject(await tracker.projectRows(), value("project"));
+      const fresh = !existsSync39(join43(dir, ".git"));
+      if (existsSync39(dir) && fresh && readdirSync18(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
       if (dryRun) {
         say("dry-run", { dir, newCheckout: fresh, repoRow: row?.id ?? null }, `would ${fresh ? "create" : "reuse"} ${dir}${row ? "" : ", create the Repos row"}, and file one ${tracker.contract.statuses.approved} ticket`);
         break;
       }
       if (fresh) {
         mkdirSync25(dir, { recursive: true });
-        writeFileSync26(join42(dir, "README.md"), SAMPLE_README);
-        writeFileSync26(join42(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        writeFileSync26(join43(dir, "README.md"), SAMPLE_README);
+        writeFileSync26(join43(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
         const g = (...a) => {
           const r = spawnSync7("git", a, { cwd: dir, encoding: "utf8" });
           if (r.status !== 0) fail(`git ${a[0]} failed in ${dir}: ${(r.stderr || r.stdout).trim()}`);
@@ -23212,7 +23645,7 @@ ${where.join("\n")}`);
           spec: { platform: "unix", releaseMode: "integrate", ciProvider: "none" }
         });
         repoId = (await tracker.createRepoRow(payload)).id;
-        if (existsSync38(resolvedFile)) {
+        if (existsSync39(resolvedFile)) {
           const raw = JSON.parse(readFileSync34(resolvedFile, "utf8"));
           raw.repoNames = { ...raw.repoNames, [repoId]: SAMPLE_REPO };
           raw.repoRemotes = { ...raw.repoRemotes, [repoId]: SAMPLE_REMOTE };
@@ -23222,7 +23655,7 @@ ${where.join("\n")}`);
       }
       if (!configured.some((r) => r.dir === dir)) {
         try {
-          writeFileSync26(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route.route, path: dir, name: SAMPLE_REPO }).text);
+          writeFileSync26(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route2.route, path: dir, name: SAMPLE_REPO }).text);
         } catch (e) {
           if (e instanceof ReposError) fail(e.message);
           throw e;
@@ -23230,7 +23663,7 @@ ${where.join("\n")}`);
       }
       const ticket = await tracker.fileTicket(
         planSampleTicket({ projectId, repoId, approvedStatus: tracker.contract.statuses.approved }),
-        route.resolved.seats.dev ?? ""
+        route2.resolved.seats.dev ?? ""
       );
       const tag = ticket.issue_tag ?? ticket.issue_id;
       say("filed", { ticket: tag, id: ticket.id, dir, repoId }, `filed ${tag} against ${dir}; follow it with \`crew watch\``);
@@ -23245,20 +23678,20 @@ ${where.join("\n")}`);
 `);
         process.exit(2);
       }
-      if (!route.resolved) {
-        process.stderr.write(`crew selftest: route ${route.route} is not connected \u2014 run \`crew connect\` first
+      if (!route2.resolved) {
+        process.stderr.write(`crew selftest: route ${route2.route} is not connected \u2014 run \`crew connect\` first
 `);
         process.exit(2);
       }
-      const seatKey = await resolveSeatKey(route, "dev");
+      const seatKey = await resolveSeatKey(route2, "dev");
       const keychainDown = seatKey.kind === "ship" && /keychain/i.test(seatKey.reason);
       const apiKey = keychainDown ? void 0 : seatKey.apiKey;
-      const baseUrl = route.baseUrl || DEFAULT_BASE_URL;
+      const baseUrl = route2.baseUrl || DEFAULT_BASE_URL;
       let workspaceName = "";
       let upfront;
       if (apiKey) {
         try {
-          const res = await fetch(`${baseUrl.replace(/\/+$/, "")}/api/workspaces/${route.resolved.workspaceId}`, {
+          const res = await fetch(`${baseUrl.replace(/\/+$/, "")}/api/workspaces/${route2.resolved.workspaceId}`, {
             headers: { Authorization: `Bearer ${apiKey}`, "User-Agent": cfg.ship.userAgent }
           });
           if (res.status === 401 || res.status === 403) {
@@ -23284,7 +23717,7 @@ ${where.join("\n")}`);
           ship: cfg.ship,
           toolchain: tc,
           baseUrl,
-          workspaceId: route.resolved.workspaceId,
+          workspaceId: route2.resolved.workspaceId,
           apiKey,
           // Only the seat's reason: runSelftest appends the remedy itself, as for every other class.
           keyProblem: keychainDown && seatKey.kind === "ship" ? seatKey.reason : void 0,
@@ -23333,25 +23766,25 @@ ${where.join("\n")}`);
       break;
     }
     case "status": {
-      const fairness = state.fairness(route.route);
+      const fairness = state.fairness(route2.route);
       const waiting = fairness.waiting();
-      const statusTracker = new Tracker(route, cfg.ship);
+      const statusTracker = new Tracker(route2, cfg.ship);
       const shipRows = await statusTracker.shipRows();
       const engagedTicketIds = shipRows.map((s) => s.engaged_ticket_id).filter((id) => !!id);
       const engagedTickets = engagedTicketIds.length ? await statusTracker.ticketsByIds(engagedTicketIds) : [];
       const issueLabelById = new Map(engagedTickets.map((t) => [t.id, t.issue_id]));
-      const todo = await statusTracker.openTickets().then((open) => operatorTodo(open, statusTracker.contract, route.resolved?.operator ?? "")).catch(() => []);
+      const todo = await statusTracker.openTickets().then((open) => operatorTodo(open, statusTracker.contract, route2.resolved?.operator ?? "")).catch(() => []);
       const projects = projectModeLabels(await statusTracker.projectRowsWithModes().catch(() => []));
-      const crewMinVersion = await readCrewFloor(route, cfg.ship) ?? null;
+      const crewMinVersion = await readCrewFloor(route2, cfg.ship) ?? null;
       const runs = liveRuns(cfg.ship.stateDir);
       const periscopes = await periscopesForStatus(cfg.ship.stateDir);
       if (flag("json")) {
-        const nameSync = await reconcileRouteShipName({ route, ship: cfg.ship, configFile: cfg.configFile, readOnly: true });
-        const repos = await resolvedRepos(route);
-        const seatIds = route.resolved?.seats ?? {};
+        const nameSync = await reconcileRouteShipName({ route: route2, ship: cfg.ship, configFile: cfg.configFile, readOnly: true });
+        const repos = await resolvedRepos(route2);
+        const seatIds = route2.resolved?.seats ?? {};
         const crewRows = Object.keys(seatIds).length ? await statusTracker.crewRows() : [];
         const crewRowById = new Map(crewRows.map((c) => [c.id, c]));
-        const agentPersonas = route.resolved?.agentPersonas ?? {};
+        const agentPersonas = route2.resolved?.agentPersonas ?? {};
         const seats2 = ROLE_NAMES.filter((r) => r !== "pair").map((r) => {
           const seatId = seatIds[r];
           const crewRow = seatId ? crewRowById.get(seatId) : void 0;
@@ -23364,7 +23797,7 @@ ${where.join("\n")}`);
             name: crewRow?.name ?? null,
             personaName,
             // Additive (CREW-2822): how many runs this seat has live right now.
-            running: runs.filter((x) => x.role === r && x.route === routeSlug(route.route)).length
+            running: runs.filter((x) => x.role === r && x.route === routeSlug(route2.route)).length
           };
         });
         process.stdout.write(`${JSON.stringify({
@@ -23408,30 +23841,30 @@ ${where.join("\n")}`);
             seats: seats2
           },
           // Additive (CREW-2822): every live run on this ship. `version` stays 1.
-          runs: runs.map((x) => describeRun(x, route, seatIds)),
+          runs: runs.map((x) => describeRun(x, route2, seatIds)),
           // Additive (CREW-2857): every live periscope on this ship, from its local record. `version` stays 1.
           periscopes,
           watermark: state.watermark(),
           route: {
-            name: route.route,
+            name: route2.route,
             // Additive (CREW-2248): the running version and the workspace's floor. `version` stays 1.
             crewVersion: sentVersion(cfg.ship),
             crewMinVersion,
             // Additive (CREW-1496): each project and its work mode. `version` stays 1.
             projects: projects.map((p) => ({ id: p.id, name: p.name, workMode: p.mode })),
-            dir: route.dir,
+            dir: route2.dir,
             // Additive (CREW-2548): open tickets with no repository, as of the last cycle.
-            unroutable: state.unroutable(route.route).previous().length,
-            enabled: route.enabled,
-            area: route.area ?? null,
+            unroutable: state.unroutable(route2.route).previous().length,
+            enabled: route2.enabled,
+            area: route2.area ?? null,
             // Additive (CREW-1511): the toolchain this route's sessions run on.
-            toolchain: resolveToolchain(cfg.ship, route).name,
-            baseUrl: route.baseUrl,
+            toolchain: resolveToolchain(cfg.ship, route2).name,
+            baseUrl: route2.baseUrl,
             repos: repos.map((r) => ({
               name: r.name,
               dir: r.dir,
               // Additive (CREW-1529): the toolchain a ticket in this repo runs on.
-              toolchain: resolveToolchain(cfg.ship, route, r.name).name,
+              toolchain: resolveToolchain(cfg.ship, route2, r.name).name,
               // Additive (CREW-1379): `unsafe` means a ship must not cut a
               // worktree or release from this base. `version` stays 1.
               baseBranch: baseHealth(r),
@@ -23453,7 +23886,7 @@ ${where.join("\n")}`);
               // `synthesis-tabl-123`. `worktreePrefix` above is kept for
               // config-provenance display; this is the field that actually
               // describes where a worktree lands by default.
-              worktreeDirPattern: r.config.worktrees.name ?? (r.config.provenance["worktrees.prefix"] !== "default" ? `${r.config.worktrees.prefix}<number>` : `${basename12(r.dir.replace(/[/\\]+$/, ""))}-<branch>`),
+              worktreeDirPattern: r.config.worktrees.name ?? (r.config.provenance["worktrees.prefix"] !== "default" ? `${r.config.worktrees.prefix}<number>` : `${basename13(r.dir.replace(/[/\\]+$/, ""))}-<branch>`),
               worktreeParent: resolvePath(r.dir, "..")
             })),
             waiting: waiting ? { ticket: waiting.ticket, since: waiting.since, streak: fairness.streak() } : null
@@ -23482,8 +23915,8 @@ ${owed.map((l) => `  ${l}
 `);
       process.stdout.write(
         `ship:       ${cfg.ship.name} (${cfg.ship.platform})
-route:      ${route.route} -> ${route.dir}
-enabled:    ${route.enabled}
+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}
 `).join("") + `crew:       ${state.isPaused() ? "paused" : "active"}
@@ -23501,11 +23934,11 @@ watermark:  ${state.watermark()}
         process.stdout.write(`attention:  ${i.kind} \u2014 ${i.message}
 `);
       }
-      for (const r of await resolvedRepos(route)) {
+      for (const r of await resolvedRepos(route2)) {
         const bh = baseHealth(r);
         if (bh.unsafe) process.stdout.write(`base:       ${r.name} \u2014 UNSAFE, no worktree cuts or releases: ${bh.detail}
 `);
-        process.stdout.write(`releaser:   ${r.name} \u2014 ${await releaserLine(statusTracker, route.route, r.name, r.config.release)}
+        process.stdout.write(`releaser:   ${r.name} \u2014 ${await releaserLine(statusTracker, route2.route, r.name, r.config.release)}
 `);
       }
       try {
@@ -23550,14 +23983,14 @@ watermark:  ${state.watermark()}
       {
         const prBased = /* @__PURE__ */ new Set();
         let mentionNode = false;
-        for (const c of [route]) {
+        for (const c of [route2]) {
           const { settled: repos, errors } = await settleRepos(reposOf(c), (t) => t.name, (t) => resolveOneRepo(c, t));
           for (const e of errors) {
             pushAuth.push({ route: c.route, repo: e.repo, result: { state: "failed", detail: `could not resolve this repo's configuration: ${e.detail}`, hint: "fix the repo's .crew.yaml" } });
           }
           for (const r of repos) {
             const remote = r.config.branch.remote;
-            if (existsSync38(r.dir)) {
+            if (existsSync39(r.dir)) {
               pushAuth.push({
                 route: c.route,
                 repo: r.name,
@@ -23582,7 +24015,7 @@ watermark:  ${state.watermark()}
       if (flag("json")) {
         const problems = [];
         let passed = 0;
-        for (const c of [route]) {
+        for (const c of [route2]) {
           const { settled: repos, errors } = await settleRepos(reposOf(c), (t) => t.name, (t) => resolveOneRepo(c, t));
           for (const e of errors) {
             problems.push({ severity: "blocker", kind: "repo_config_invalid", route: c.route, repo: e.repo, message: `could not resolve this repo's configuration: ${e.detail}`, remedy: "fix the repo's .crew.yaml" });
@@ -23602,19 +24035,19 @@ watermark:  ${state.watermark()}
           }
         }
         if (!flag("offline")) {
-          for (const p of await probeSeatReads(route, { userAgent: cfg.ship.userAgent })) {
+          for (const p of await probeSeatReads(route2, { userAgent: cfg.ship.userAgent })) {
             if (p.state === "forbidden") {
-              problems.push({ severity: "blocker", kind: "seat_cannot_read_issues", route: route.route, message: `${p.role} agent key refused on ${p.tables.filter((t) => t.state === "forbidden").map((t) => t.table).join(", ")} (403)`, remedy: describeSeatForbidden(p.role, p.tables).replace(/^.*?— /, "") });
+              problems.push({ severity: "blocker", kind: "seat_cannot_read_issues", route: route2.route, message: `${p.role} agent key refused on ${p.tables.filter((t) => t.state === "forbidden").map((t) => t.table).join(", ")} (403)`, remedy: describeSeatForbidden(p.role, p.tables).replace(/^.*?— /, "") });
             } else if (p.state === "ok") passed++;
           }
         }
         for (const message of roleCapWarnings(cfg.ship)) problems.push({ severity: "note", kind: "role_cap_above_ship_cap", message });
         const previewProblem2 = await previewHostProblem(cfg);
         if (previewProblem2) problems.push(previewHostFinding(previewProblem2));
-        if (cfg.routes.some((x) => x.route === route.route && x.enabled && x.hostPeriscopes)) {
-          const { settled } = await settleRepos(reposOf(route), (t) => t.name, (t) => resolveOneRepo(route, t));
-          const tablePresent = flag("offline") ? void 0 : (await new Tracker(route, cfg.ship).periscopesStatus().catch(() => ({ present: true }))).present;
-          problems.push(...routePeriscopeProblems({ route: route.route, hosts: true, repos: settled.map((r) => ({ name: r.name, hasPreviewHook: !!r.config.hooks.preview })), tablePresent }));
+        if (cfg.routes.some((x) => x.route === route2.route && x.enabled && x.hostPeriscopes)) {
+          const { settled } = await settleRepos(reposOf(route2), (t) => t.name, (t) => resolveOneRepo(route2, t));
+          const tablePresent = flag("offline") ? void 0 : (await new Tracker(route2, cfg.ship).periscopesStatus().catch(() => ({ present: true }))).present;
+          problems.push(...routePeriscopeProblems({ route: route2.route, hosts: true, repos: settled.map((r) => ({ name: r.name, hasPreviewHook: !!r.config.hooks.preview })), tablePresent }));
         }
         problems.push(...attentionProblems(openShipAttention(state), problems));
         if (problems.some((p) => p.severity === "blocker")) process.exitCode = 1;
@@ -23640,7 +24073,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       }
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
-        const evSize = existsSync38(evFile) ? statSync12(evFile).size : 0;
+        const evSize = existsSync39(evFile) ? statSync13(evFile).size : 0;
         process.stdout.write(
           evSize > cfg.ship.eventsRotateBytes * 4 ? `events log:        WARN ${evFile} is ${Math.round(evSize / 1048576)} MB (> 4x eventsRotateBytes); run \`crew reap\` to rotate it
 ` : "events log:        ok\n"
@@ -23667,15 +24100,15 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
         const changed2 = configChangedAfter(daemonConfigPaths(cfg), daemonStartedAt);
         if (changed2) {
           process.stdout.write(
-            `daemon config:     WARN ${changed2} changed at ${new Date(statSync12(changed2).mtimeMs).toISOString()} but the daemon started at ${new Date(daemonStartedAt).toISOString()} \u2014 run \`crew reload\`
+            `daemon config:     WARN ${changed2} changed at ${new Date(statSync13(changed2).mtimeMs).toISOString()} but the daemon started at ${new Date(daemonStartedAt).toISOString()} \u2014 run \`crew reload\`
 `
           );
         }
       }
-      const tracker = new Tracker(route, cfg.ship);
+      const tracker = new Tracker(route2, cfg.ship);
       {
         const have = sentVersion(cfg.ship);
-        const floor = await readCrewFloor(route, cfg.ship);
+        const floor = await readCrewFloor(route2, cfg.ship);
         if (have && floor) {
           process.stdout.write(
             `crew version:      ${belowFloor(have, floor) ? "WARN " : ""}${have} (workspace requires ${floor})${belowFloor(have, floor) ? " \u2014 update crew (the Crew app, or `npm install -g @tablation/crew`)" : ""}
@@ -23692,9 +24125,9 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
 ` + contractProblems.map((p) => `                   - ${p}
 `).join("") : "contract:          consistent\n"
       );
-      for (const r of await resolvedRepos(route)) {
+      for (const r of await resolvedRepos(route2)) {
         const { config } = r;
-        const worktreePattern = config.worktrees.name ?? (config.provenance["worktrees.prefix"] !== "default" ? `${config.worktrees.prefix}<number>` : `${basename12(r.dir.replace(/[/\\]+$/, ""))}-${effectiveBranchTemplate(config, void 0)}`);
+        const worktreePattern = config.worktrees.name ?? (config.provenance["worktrees.prefix"] !== "default" ? `${config.worktrees.prefix}<number>` : `${basename13(r.dir.replace(/[/\\]+$/, ""))}-${effectiveBranchTemplate(config, void 0)}`);
         process.stdout.write(
           `${`repo ${r.name}:`.padEnd(19)}${r.dir}
                    worktrees at ../${worktreePattern} (${config.provenance["worktrees.name"] ?? config.provenance["worktrees.prefix"] ?? "default"}), branch ${config.branch.name}
@@ -23725,7 +24158,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
           if (warn) process.stdout.write(`                   WARNING ${warn}
 `);
         }
-        const scope = releaseLockScope(route.route, r.name);
+        const scope = releaseLockScope(route2.route, r.name);
         const lock2 = await tracker.lockState(scope).catch(() => void 0);
         if (lock2?.holder && staleOwnLockClaim(lock2.holder, cfg.ship.name)) {
           process.stdout.write(`                   ${formatStaleOwnLock(scope, lock2.holder)}`);
@@ -23742,10 +24175,10 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
 `
       );
       const periscopes = await tracker.periscopesStatus();
-      if (cfg.routes.some((x) => x.route === route.route && x.enabled && x.hostPeriscopes)) {
-        const { settled } = await settleRepos(reposOf(route), (t) => t.name, (t) => resolveOneRepo(route, t));
+      if (cfg.routes.some((x) => x.route === route2.route && x.enabled && x.hostPeriscopes)) {
+        const { settled } = await settleRepos(reposOf(route2), (t) => t.name, (t) => resolveOneRepo(route2, t));
         for (const f of routePeriscopeProblems({
-          route: route.route,
+          route: route2.route,
           hosts: true,
           tablePresent: periscopes.present,
           repos: settled.map((r) => ({ name: r.name, hasPreviewHook: !!r.config.hooks.preview }))
@@ -23760,26 +24193,26 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
 `
       );
       process.stdout.write(
-        route.resolved?.releaseSeat ? "release seat:    this ship has its own Release Crew row\n" : "release seat:    none \u2014 release comments are credited to the dev seat; run `crew connect` once the Crew table has this ship's row\n"
+        route2.resolved?.releaseSeat ? "release seat:    this ship has its own Release Crew row\n" : "release seat:    none \u2014 release comments are credited to the dev seat; run `crew connect` once the Crew table has this ship's row\n"
       );
-      const keyRole = route.resolved?.role ?? await fetchKeyRole(route, cfg.ship.userAgent);
-      const roleRoute = route.resolved && keyRole ? { ...route, resolved: { ...route.resolved, role: keyRole } } : route;
+      const keyRole = route2.resolved?.role ?? await fetchKeyRole(route2, cfg.ship.userAgent);
+      const roleRoute = route2.resolved && keyRole ? { ...route2, resolved: { ...route2.resolved, role: keyRole } } : route2;
       process.stdout.write(`api key role:     ${keyRole ?? "unknown"}
 `);
-      for (const m of route.resolved?.capabilityMisses ?? []) process.stdout.write(`capability:       MISSING ${m} (re-run \`crew connect\` once granted)
+      for (const m of route2.resolved?.capabilityMisses ?? []) process.stdout.write(`capability:       MISSING ${m} (re-run \`crew connect\` once granted)
 `);
       const canMint = await canMintAgentKeys(roleRoute, { userAgent: cfg.ship.userAgent });
       process.stdout.write(`can mint agent keys: ${canMint === void 0 ? "unknown" : canMint ? "yes" : "no"}
 `);
       for (const role of SEAT_KEY_ROLES) {
-        if (!route.resolved?.seats[role]) continue;
+        if (!route2.resolved?.seats[role]) continue;
         const id = await resolveSeatKey(roleRoute, role);
         process.stdout.write(
           `seat identity:    ${role} writes as ${id.kind === "agent" ? `its own agent (${id.agentId})` : `the ship (${id.reason})`}
 `
         );
       }
-      if (route.resolved?.releaseSeat) {
+      if (route2.resolved?.releaseSeat) {
         const id = await resolveReleaseKey(roleRoute);
         process.stdout.write(
           `seat identity:    release writes as ${id.kind === "agent" ? `its own agent (${id.agentId})` : `the ship (${id.reason})`}
@@ -23829,7 +24262,7 @@ crew manifest:     ${seats2.length ? seats2.map((c) => c.name).join(", ") : "non
         }
       }
       {
-        const op = route.resolved?.operator;
+        const op = route2.resolved?.operator;
         const row = op ? crewRows.find((c) => c.id === op) : void 0;
         if (!op) {
           process.stdout.write("operator identity: no operator on this route \u2014 run `crew connect`\n");
@@ -23844,7 +24277,7 @@ crew manifest:     ${seats2.length ? seats2.map((c) => c.name).join(", ") : "non
           );
           process.exitCode = 1;
         } else {
-          const resolves = memberByIdentity(buildRoster(configuredMembers(route), crewRows), row.user_id);
+          const resolves = memberByIdentity(buildRoster(configuredMembers(route2), crewRows), row.user_id);
           process.stdout.write(
             resolves ? `operator identity: comments from ${row.name ?? op} resolve to ${crewLabel(resolves)}
 ` : `operator identity: ERROR user_id ${row.user_id} does not resolve through the roster
@@ -23855,7 +24288,7 @@ crew manifest:     ${seats2.length ? seats2.map((c) => c.name).join(", ") : "non
       }
       if (ships.length > 0) {
         try {
-          const humanHolds = new Set(holdIds(buildRoster(configuredMembers(route), crewRows)));
+          const humanHolds = new Set(holdIds(buildRoster(configuredMembers(route2), crewRows)));
           const warnings = holdWarnings(await tracker.openTickets(), ships, tracker.contract, humanHolds);
           process.stdout.write(
             warnings.length === 0 ? "ship holds:       every in-flight ticket is held by a live ship\n" : warnings.map((w) => `ship holds:       WARNING ${w}
@@ -23910,7 +24343,7 @@ crew manifest:     ${seats2.length ? seats2.map((c) => c.name).join(", ") : "non
 `);
         }
       }
-      for (const [repoName, ov] of Object.entries(route.repoOverrides)) {
+      for (const [repoName, ov] of Object.entries(route2.repoOverrides)) {
         if (ov.toolchain) process.stdout.write(`repo toolchain:    ${repoName} \u2192 ${ov.toolchain} (binary and MCP checked above, as for every ship toolchain)
 `);
       }
@@ -23924,15 +24357,15 @@ crew manifest:     ${seats2.length ? seats2.map((c) => c.name).join(", ") : "non
 `
         );
       }
-      if (route.apiKey) {
-        const mcpUrl = mcpUrlFor(route.baseUrl);
+      if (route2.apiKey) {
+        const mcpUrl = mcpUrlFor(route2.baseUrl);
         const seenMcp = /* @__PURE__ */ new Set();
         for (const tc of shipToolchains(cfg.ship)) {
           const id = `${tc.harness}\0${tc.bin}`;
           if (seenMcp.has(id)) continue;
           seenMcp.add(id);
           const adapter = adapterFor(tc.harness);
-          const m = adapter.inspectMcp({ bin: tc.bin, url: mcpUrl, key: route.apiKey });
+          const m = adapter.inspectMcp({ bin: tc.bin, url: mcpUrl, key: route2.apiKey });
           process.stdout.write(
             m.state === "registered" ? `mcp:               tablation registered (user scope) \u2192 ${m.url}
 ` : m.state === "no-binary" ? `mcp:               ${tc.bin} not found \u2014 ${adapter.displayName} was not checked
@@ -23944,22 +24377,22 @@ crew manifest:     ${seats2.length ? seats2.map((c) => c.name).join(", ") : "non
       }
       for (const h of shipPair(cfg.ship).filter((x) => x !== "claude")) {
         const inst = pairInstallerFor(h);
-        const v = inst.verifyPair({ url: mcpUrlFor(route.baseUrl) });
+        const v = inst.verifyPair({ url: mcpUrlFor(route2.baseUrl) });
         process.stdout.write(`pair ${h}:`.padEnd(19) + (v.ok ? ` installed (${v.detail})
 ` : ` NOT installed \u2014 ${v.detail}; run crew connect
 `));
-        const envWarn = inst.envWarning?.({ url: mcpUrlFor(route.baseUrl) });
+        const envWarn = inst.envWarning?.({ url: mcpUrlFor(route2.baseUrl) });
         if (envWarn) process.stdout.write(`pair ${h} env:`.padEnd(19) + ` WARN \u2014 ${envWarn}
 `);
       }
       const shipVendors = new Set(shipToolchains(cfg.ship).map(toolchainVendor));
-      if (route.apiKey && route.resolved) {
+      if (route2.apiKey && route2.resolved) {
         let flagged = 0;
         for (const role of ROLE_NAMES) {
-          const persona = await fetchSeatPersona(route, role, { userAgent: cfg.ship.userAgent });
+          const persona = await fetchSeatPersona(route2, role, { userAgent: cfg.ship.userAgent });
           if (persona?.vendor && !shipVendors.has(persona.vendor)) {
             flagged++;
-            process.stdout.write(`seat vendor:       ${role} persona wants "${persona.vendor}" \u2014 no toolchain on this ship serves it (have: ${[...shipVendors].join(", ")}); it will run ${resolveSeat(cfg.ship, route, role).toolchain.name} with a warning
+            process.stdout.write(`seat vendor:       ${role} persona wants "${persona.vendor}" \u2014 no toolchain on this ship serves it (have: ${[...shipVendors].join(", ")}); it will run ${resolveSeat(cfg.ship, route2, role).toolchain.name} with a warning
 `);
           }
         }