@tablation/crew 0.71.13 → 0.72.1

package/dist/cli.js

@@ -5920,6 +5920,12 @@ var Tracker = class {
       return [];
     }
   }
+  /** Renames a Ships row (CREW-2495). Throws on a refused write (a member key may not edit the table). */
+  async renameShipRow(rowId, name) {
+    const model = this.route.resolved?.shipsModelId;
+    if (!model) throw new Error("this workspace has no Ships table");
+    await this.client.records.update(model, rowId, { name });
+  }
   /**
    * This ship's own row on the `Ships` table, matched by name — the same
    * exact-string match `doctor` has always used (see the callsign comment
@@ -8606,7 +8612,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve5, dirname as dirname19, join as join35, basename as basename11 } from "path";
+import { resolve as resolve5, dirname as dirname20, join as join35, basename as basename11 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname2, homedir as homedir9 } from "os";
 import { spawnSync as spawnSync6 } from "child_process";
@@ -8792,40 +8798,47 @@ function readPointers(stateDir) {
   try {
     const parsed = JSON.parse(readFileSync16(lastSessionFile(stateDir), "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
-    return Object.fromEntries(Object.entries(parsed).filter((e) => typeof e[1] === "string"));
+    const out = {};
+    for (const [host, v] of Object.entries(parsed)) {
+      const slugs = (Array.isArray(v) ? v : [v]).filter((x) => typeof x === "string" && x !== "");
+      if (slugs.length) out[host] = slugs;
+    }
+    return out;
   } catch {
     return {};
   }
 }
+function writePointers(stateDir, pointers) {
+  const file = lastSessionFile(stateDir);
+  mkdirSync10(dirname8(file), { recursive: true });
+  writeFileSync11(file, `${JSON.stringify(pointers, null, 2)}
+`, { mode: 384 });
+}
 function rememberSession(stateDir, host, workspaceSlug) {
   try {
-    const file = lastSessionFile(stateDir);
-    mkdirSync10(dirname8(file), { recursive: true });
-    writeFileSync11(file, `${JSON.stringify({ ...readPointers(stateDir), [host]: workspaceSlug }, null, 2)}
-`, { mode: 384 });
+    const all = readPointers(stateDir);
+    writePointers(stateDir, { ...all, [host]: [...(all[host] ?? []).filter((w) => w !== workspaceSlug), workspaceSlug] });
   } catch {
   }
 }
-async function resumeKeychainSession(o) {
-  const workspace = readPointers(o.stateDir)[o.host];
-  if (!workspace) return void 0;
-  try {
-    const stored = await o.store.get(o.host, workspace);
-    if (!stored?.apiKey) return void 0;
-    if (!await o.verify(stored.apiKey)) return void 0;
-    return { workspace, apiKey: stored.apiKey };
-  } catch {
-    return void 0;
+async function resumableSessions(o) {
+  const out = [];
+  for (const workspace of readPointers(o.stateDir)[o.host] ?? []) {
+    try {
+      const stored = await o.store.get(o.host, workspace);
+      if (stored?.apiKey && await o.verify(stored.apiKey)) out.push({ workspace, apiKey: stored.apiKey });
+    } catch {
+    }
   }
+  return out;
 }
 function rememberedSessions(stateDir) {
-  return Object.entries(readPointers(stateDir)).map(([host, workspace]) => ({ host, workspace }));
+  return Object.entries(readPointers(stateDir)).flatMap(([host, ws]) => ws.map((workspace) => ({ host, workspace })));
 }
 function forgetSession(stateDir, host) {
   try {
     const { [host]: _gone, ...rest } = readPointers(stateDir);
-    if (Object.keys(rest).length) writeFileSync11(lastSessionFile(stateDir), `${JSON.stringify(rest, null, 2)}
-`, { mode: 384 });
+    if (Object.keys(rest).length) writePointers(stateDir, rest);
     else rmSync10(lastSessionFile(stateDir), { force: true });
   } catch {
   }
@@ -12636,6 +12649,217 @@ function nextRoles(decision, ran) {
   return decision.selection.pending.filter((r) => !ran.includes(r)).sort((a, b) => (decision.selection.ranks[a] ?? 0) - (decision.selection.ranks[b] ?? 0));
 }
 
+// src/ship-name.ts
+import { existsSync as existsSync25, mkdirSync as mkdirSync15, readFileSync as readFileSync20, renameSync as renameSync2, writeFileSync as writeFileSync17 } from "fs";
+import { dirname as dirname14 } from "path";
+import { parseDocument } from "yaml";
+
+// src/machine-id.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync24, mkdirSync as mkdirSync14, readFileSync as readFileSync19, writeFileSync as writeFileSync16 } from "fs";
+import { dirname as dirname13, join as join25 } from "path";
+function machineIdPathFor(stateDir) {
+  return join25(stateDir, "machine-id");
+}
+var sha256 = (s) => createHash3("sha256").update(s).digest("hex");
+function readRawMachineId(platform2 = process.platform) {
+  try {
+    if (platform2 === "darwin") {
+      const out = execFileSync4("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      return /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(out)?.[1];
+    }
+    for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+      if (existsSync24(p)) {
+        const id = readFileSync19(p, "utf8").trim();
+        if (id) return id;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function ensureMachineId(stateDir, opts = {}) {
+  if (opts.override?.trim()) return sha256(opts.override.trim());
+  const path = machineIdPathFor(stateDir);
+  if (existsSync24(path)) {
+    const cached = readFileSync19(path, "utf8").trim();
+    if (/^[0-9a-f]{64}$/.test(cached)) return cached;
+  }
+  const raw = (opts.read ?? readRawMachineId)();
+  if (!raw) return void 0;
+  const hashed = sha256(raw);
+  mkdirSync14(dirname13(path), { recursive: true });
+  writeFileSync16(path, `${hashed}
+`, { mode: 384 });
+  return hashed;
+}
+function matchShipRows(ships, shipName2, machineId) {
+  const hasColumn = ships.some((r) => "machine_id" in r);
+  const byId = hasColumn && machineId ? ships.filter((r) => r.machine_id === machineId) : [];
+  if (byId.length > 0) return { rows: byId, by: "machine_id", hasColumn };
+  return { rows: ships.filter((r) => (r.name ?? "").trim() === shipName2.trim()), by: "name", hasColumn };
+}
+
+// src/ship-name.ts
+var ShipNameError = class extends Error {
+};
+function validateShipName(raw) {
+  const name = raw.trim();
+  if (!name) throw new ShipNameError("the ship name cannot be empty");
+  if (/[\u0000-\u001f\u007f]/.test(name)) throw new ShipNameError("the ship name cannot contain control characters");
+  return name;
+}
+function planNameSync(local, row, lastSynced) {
+  if (local === row) return { drift: "none", action: "none" };
+  const rowMoved = lastSynced === void 0 || row !== lastSynced;
+  const localMoved = lastSynced === void 0 || local !== lastSynced;
+  if (rowMoved && localMoved) return { drift: "both", action: "row-wins" };
+  if (rowMoved) return { drift: "row", action: "adopt" };
+  return { drift: "local", action: "push" };
+}
+function shipNameOfYaml(text) {
+  const v = parseDocument(text).getIn(["ship", "name"]);
+  return typeof v === "string" && v.trim() ? v.trim() : void 0;
+}
+function setShipNameInYaml(text, name) {
+  const doc = parseDocument(text);
+  doc.setIn(["ship", "name"], name);
+  return doc.toString();
+}
+function pickShipRow(rows, machineId, byName = []) {
+  const hasColumn = rows.some((r) => "machine_id" in r);
+  if (!hasColumn || !machineId) return { kind: "unsupported" };
+  const byId = rows.filter((r) => r.machine_id === machineId);
+  if (byId.length === 1) return { kind: "row", row: byId[0], by: "machine_id" };
+  if (byId.length > 1) return { kind: "ambiguous" };
+  const names = new Set(byName.map((n) => n.trim()));
+  const named = rows.filter((r) => !r.machine_id && names.has((r.name ?? "").trim()));
+  if (named.length === 1) return { kind: "row", row: named[0], by: "name" };
+  return { kind: named.length > 1 ? "ambiguous" : "none" };
+}
+async function syncRouteName(i) {
+  const picked = pickShipRow(i.rows, i.machineId);
+  if (picked.kind !== "row") {
+    const status2 = picked.kind === "none" ? "no-row" : picked.kind;
+    return { status: status2, drift: "none", action: "none", name: i.local };
+  }
+  const rowName = (picked.row.name ?? "").trim();
+  if (!rowName) return { status: "no-row", drift: "none", action: "none", name: i.local };
+  const { drift, action } = planNameSync(i.local, rowName, i.lastSynced);
+  const base = { drift, rowId: picked.row.id, rowName };
+  if (action === "push") {
+    if (!i.rename) return { status: "ok", ...base, action, name: i.local };
+    try {
+      await i.rename(picked.row.id, i.local);
+    } catch (e) {
+      return { status: "refused", ...base, action: "none", name: i.local, error: e.message };
+    }
+    return { status: "ok", ...base, action, name: i.local };
+  }
+  if (action === "adopt" || action === "row-wins") return { status: "ok", ...base, action, name: rowName, from: i.local };
+  return { status: "ok", ...base, action, name: i.local };
+}
+function readSyncedName(resolvedFile) {
+  if (!existsSync25(resolvedFile)) return void 0;
+  try {
+    const v = JSON.parse(readFileSync20(resolvedFile, "utf8")).shipName;
+    return typeof v === "string" ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeSyncedName(resolvedFile, name) {
+  if (!existsSync25(resolvedFile)) return;
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync20(resolvedFile, "utf8"));
+  } catch {
+    return;
+  }
+  if (raw.shipName === name) return;
+  raw.shipName = name;
+  mkdirSync15(dirname14(resolvedFile), { recursive: true });
+  const tmp = `${resolvedFile}.tmp${process.pid}`;
+  writeFileSync17(tmp, `${JSON.stringify(raw, null, 2)}
+`);
+  renameSync2(tmp, resolvedFile);
+}
+async function reconcileShipName(i) {
+  let local = i.ship.name;
+  try {
+    local = shipNameOfYaml(readFileSync20(i.configFile, "utf8")) ?? local;
+  } catch {
+  }
+  const resolvedFile = resolvedPathFor(i.stateDir, i.route);
+  const lastSynced = readSyncedName(resolvedFile);
+  let rows = [];
+  try {
+    rows = await i.rows();
+  } catch {
+  }
+  const result = await syncRouteName({
+    local,
+    lastSynced,
+    rows,
+    machineId: i.machineId,
+    rename: i.readOnly ? void 0 : i.rename
+  });
+  if (i.readOnly || result.status === "unsupported") return result;
+  if (result.status === "refused") {
+    i.emit?.warn(`could not rename the Ships row to "${local}": ${result.error}`, { step: "poll", data: { event: "ship_rename_refused", route: i.route, to: local } });
+    return result;
+  }
+  if (result.status !== "ok") return result;
+  if (result.action === "adopt" || result.action === "row-wins") {
+    const text = readFileSync20(i.configFile, "utf8");
+    writeFileSync17(i.configFile, setShipNameInYaml(text, result.name));
+    i.ship.name = result.name;
+    if (result.action === "row-wins") {
+      i.emit?.warn(
+        `ship name changed in both crew.yaml ("${result.from}") and the Ships table ("${result.name}"); the Ships row wins`,
+        { step: "poll", data: { event: "ship_renamed", route: i.route, from: result.from, to: result.name, source: "table", conflict: true } }
+      );
+    } else {
+      i.emit?.emit(`ship renamed to "${result.name}" in the Ships table; crew.yaml updated`, {
+        step: "poll",
+        data: { event: "ship_renamed", route: i.route, from: result.from, to: result.name, source: "table" }
+      });
+    }
+  } else if (result.action === "push") {
+    i.emit?.emit(`ship name "${result.name}" pushed to the Ships table`, {
+      step: "poll",
+      data: { event: "ship_renamed", route: i.route, from: result.rowName, to: result.name, source: "crew.yaml" }
+    });
+  }
+  writeSyncedName(resolvedFile, result.name);
+  return result;
+}
+async function reconcileRouteShipName(o) {
+  const fallback = { status: "unsupported", drift: "none", action: "none", name: o.ship.name };
+  if (!o.route.resolved?.shipsModelId) return fallback;
+  try {
+    const machineId = o.machineId ?? ensureMachineId(o.ship.stateDir);
+    const tracker = new Tracker(o.route, o.ship);
+    return await reconcileShipName({
+      route: o.route.route,
+      configFile: o.configFile,
+      stateDir: o.ship.stateDir,
+      ship: o.ship,
+      machineId,
+      rows: () => tracker.shipRows(),
+      rename: (id, name) => tracker.renameShipRow(id, name),
+      emit: o.emit,
+      readOnly: o.readOnly
+    });
+  } catch {
+    return fallback;
+  }
+}
+
 // src/connect.ts
 var ConnectHttpError = class extends Error {
   status;
@@ -12941,10 +13165,16 @@ async function discover(o) {
       out.shipRow = { id: shipRowId, name: o.ship.name, action: "matched", matchedBy };
       const patchBody = {};
       if (matchedBy === "machine_id") {
-        const keptName = (mine[0].name ?? "").trim();
-        if (keptName !== o.ship.name.trim()) {
-          out.shipRow.name = keptName;
-          provisioning.push(`matched Ships row "${keptName}" by machine id \u2014 this host is now called "${o.ship.name}"; the row's name is kept`);
+        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));
+        if (plan.action === "push") {
+          patchBody.name = o.ship.name.trim();
+          provisioning.push(`renamed Ships row "${rowName}" to "${o.ship.name.trim()}" (crew.yaml changed)`);
+        } else if (plan.action === "adopt" || plan.action === "row-wins") {
+          out.shipRow.name = rowName;
+          out.shipNameAdopted = rowName;
+          provisioning.push(`matched Ships row "${rowName}" by machine id \u2014 this host's name becomes "${rowName}"${plan.action === "row-wins" ? " (crew.yaml also changed; the Ships row wins)" : ""}`);
         }
         patchBody.last_seen = (/* @__PURE__ */ new Date()).toISOString();
       }
@@ -13494,8 +13724,8 @@ function describeCapability(i) {
 }
 
 // src/agents-sync-run.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync14, readFileSync as readFileSync19, writeFileSync as writeFileSync16 } from "fs";
-import { dirname as dirname13 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync16, readFileSync as readFileSync21, writeFileSync as writeFileSync18 } from "fs";
+import { dirname as dirname15 } from "path";
 async function runAgentsSync(target, o) {
   const dryRun = o.dryRun ?? false;
   const force = o.force ?? false;
@@ -13528,12 +13758,12 @@ async function runAgentsSync(target, o) {
   for (const s of skillResult?.outcomes ?? []) o.say(describeSkillSyncOutcome(s));
   if (!dryRun) {
     const resolvedPath = resolvedPathFor(o.stateDir, target.route);
-    const raw = existsSync24(resolvedPath) ? JSON.parse(readFileSync19(resolvedPath, "utf8")) : {};
+    const raw = existsSync26(resolvedPath) ? JSON.parse(readFileSync21(resolvedPath, "utf8")) : {};
     raw.agentPersonas = personaResult.agentPersonas;
     if (skillResult) raw.agentSkills = skillResult.agentSkills;
     if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
-    mkdirSync14(dirname13(resolvedPath), { recursive: true });
-    writeFileSync16(resolvedPath, `${JSON.stringify(raw, null, 2)}
+    mkdirSync16(dirname15(resolvedPath), { recursive: true });
+    writeFileSync18(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
     if (target.resolved) {
       target.resolved.agentPersonas = personaResult.agentPersonas;
@@ -13548,7 +13778,7 @@ async function runAgentsSync(target, o) {
 }
 
 // src/logbook.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { TablationClient as TablationClient4 } from "@tablation/client";
 var LogbookError = class extends Error {
 };
@@ -13621,7 +13851,7 @@ async function showLogEntry(route, entryId, opts = {}) {
     };
   }
   const prompt = appendAdditions(match.prompt ?? "", match.prompt_additions);
-  const actualSha = createHash3("sha256").update(prompt).digest("hex");
+  const actualSha = createHash4("sha256").update(prompt).digest("hex");
   const exact = !!entry.prompt_sha && actualSha === entry.prompt_sha;
   return {
     entry,
@@ -13636,12 +13866,12 @@ async function showLogEntry(route, entryId, opts = {}) {
 }
 
 // src/repos-hooks.ts
-import { isMap as isMap2, parseDocument as parseDocument2, YAMLMap } from "yaml";
+import { isMap as isMap2, parseDocument as parseDocument3, YAMLMap } from "yaml";
 
 // src/repos-cmd.ts
 import { homedir as homedir8 } from "os";
-import { basename as basename8, join as join25, resolve as resolve3 } from "path";
-import { isMap, isSeq, parseDocument, stringify as stringify2 } from "yaml";
+import { basename as basename8, join as join26, resolve as resolve3 } from "path";
+import { isMap, isSeq, parseDocument as parseDocument2, stringify as stringify2 } from "yaml";
 var ReposError = class extends Error {
 };
 function normalizeRemote(url) {
@@ -13665,7 +13895,7 @@ function matchRepoName(origin, resolved) {
   return void 0;
 }
 function routeNamesOf(text) {
-  const routes = parseDocument(text).get("routes", true);
+  const routes = parseDocument2(text).get("routes", true);
   if (!isSeq(routes)) return [];
   return routes.items.flatMap((i) => isMap(i) && typeof i.get("route") === "string" ? [i.get("route")] : []);
 }
@@ -13700,7 +13930,7 @@ function routeMapOf(doc, route) {
   throw new ReposError(`no route "${route}" in the config (have: ${have})`);
 }
 function configuredRepos(text, route, base) {
-  const doc = parseDocument(text);
+  const doc = parseDocument2(text);
   const m = routeMapOf(doc, route);
   const repos = m.get("repos");
   if (isMap(repos)) {
@@ -13715,7 +13945,7 @@ function configuredRepos(text, route, base) {
   return dir ? [{ name: basename8(String(dir)), dir: expandDir(String(dir), base) }] : [];
 }
 function routeSetsHooks(text, route, name) {
-  const m = routeMapOf(parseDocument(text), route);
+  const m = routeMapOf(parseDocument2(text), route);
   const repos = m.get("repos", true);
   let target = m;
   if (isMap(repos)) target = repos.get(name, true);
@@ -13771,7 +14001,7 @@ function listRepoRows(i) {
   return rows;
 }
 function planRepoAdd(i) {
-  const doc = parseDocument(i.text);
+  const doc = parseDocument2(i.text);
   if (doc.errors.length > 0) throw new ReposError(`config is not valid YAML \u2014 ${doc.errors[0].message}`);
   const m = routeMapOf(doc, i.route);
   const existing = configuredRepos(i.text, i.route, i.base);
@@ -13808,7 +14038,7 @@ function planRepoAdd(i) {
   return { text: String(doc), mode, name, block: renderBlock(m), warning, unmatched: !matched };
 }
 function planRepoRemove(text, base, route, path) {
-  const doc = parseDocument(text);
+  const doc = parseDocument2(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 target = expandDir(path, base);
@@ -13886,7 +14116,7 @@ function planRepoClone(i) {
       `the Repos row "${name}" has no remote to clone from \u2014 attach an existing checkout with \`crew repos add ${i.route} ${name} <path>\`, or set the row's remote in the tracker and re-run \`crew connect\``
     );
   }
-  const doc = parseDocument(i.text);
+  const doc = parseDocument2(i.text);
   const m = routeMapOf(doc, i.route);
   const existing = configuredRepos(i.text, i.route, i.base);
   if (existing.some((e) => e.name.toLowerCase() === name.toLowerCase())) {
@@ -13894,7 +14124,7 @@ function planRepoClone(i) {
   }
   const ship = doc.get("ship", true);
   const basePath = String(m.get("reposBasePath") ?? (isMap(ship) ? ship.get("reposBasePath") : void 0) ?? "~/Crew");
-  const target = i.dir ? expandDir(i.dir, i.base) : join25(expandDir(basePath, i.base), i.route.split("/")[0], name);
+  const target = i.dir ? expandDir(i.dir, i.base) : join26(expandDir(basePath, i.base), i.route.split("/")[0], name);
   const add = planRepoAdd({ text: i.text, base: i.base, route: i.route, path: target, origin: remote, resolved: i.resolved, name });
   return { ...add, remote, target };
 }
@@ -14040,7 +14270,7 @@ function repoDirOf(text, base, route, name) {
   return hit.dir;
 }
 function planRouteHooks(text, route, name, hooks) {
-  const doc = parseDocument2(text);
+  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 repos = m.get("repos", true);
@@ -14102,7 +14332,7 @@ function existingRepoConfig(f) {
 }
 
 // src/repos-hooks-agent.ts
-import { spawn as spawn4, execFileSync as execFileSync4 } from "child_process";
+import { spawn as spawn4, execFileSync as execFileSync5 } from "child_process";
 import { realpathSync as realpathSync2 } from "fs";
 import { isAbsolute as isAbsolute2, relative } from "path";
 var AgentSuggestError = class extends Error {
@@ -14205,7 +14435,7 @@ function classifyFailure(o) {
 }
 function porcelain(dir) {
   try {
-    return execFileSync4("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: dir, encoding: "utf8" });
+    return execFileSync5("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: dir, encoding: "utf8" });
   } catch {
     return void 0;
   }
@@ -14274,7 +14504,7 @@ ${run2.err}` });
 }
 
 // src/sample-ticket.ts
-import { basename as basename9, dirname as dirname15, join as join26 } from "path";
+import { basename as basename9, dirname as dirname17, join as join27 } from "path";
 var SAMPLE_REPO = "crew-sample";
 var SAMPLE_REMOTE = `local/${SAMPLE_REPO}`;
 var SAMPLE_MARKER = "sample: true";
@@ -14297,8 +14527,8 @@ has something safe to work on: its test and build hooks always pass, it has no
 remote, and \`crew sample-ticket --remove\` deletes it.
 `;
 function sampleDir(existing, reposBase, workspace) {
-  if (existing.length > 0) return join26(dirname15(existing[0]), SAMPLE_REPO);
-  return join26(reposBase, workspace, SAMPLE_REPO);
+  if (existing.length > 0) return join27(dirname17(existing[0]), SAMPLE_REPO);
+  return join27(reposBase, workspace, SAMPLE_REPO);
 }
 var SAMPLE_TITLE = "Sample: add a documented `greet` function with a test";
 function sampleDescription() {
@@ -14342,7 +14572,7 @@ function planSampleTicket(i) {
 }
 
 // src/doctor-fix.ts
-import { parseDocument as parseDocument3 } from "yaml";
+import { parseDocument as parseDocument4 } from "yaml";
 var sound = (r) => r.hasRepos && r.problems.length === 0;
 function planFix(f) {
   const actions = [];
@@ -14369,7 +14599,7 @@ function routesInScope(routes, named) {
   return named ? routes.filter((r) => r.route === named) : routes;
 }
 function planEnable(text, route) {
-  const doc = parseDocument3(text);
+  const doc = parseDocument4(text);
   routeMapOf(doc, route).set("enabled", true);
   return String(doc);
 }
@@ -14379,8 +14609,8 @@ function schedulerInstalled(plan, exists, crontab) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync25, readFileSync as readFileSync20, readdirSync as readdirSync8 } from "fs";
-import { basename as basename10, dirname as dirname16, join as join27, resolve as resolve4 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync22, readdirSync as readdirSync8 } from "fs";
+import { basename as basename10, dirname as dirname18, join as join28, resolve as resolve4 } from "path";
 function planWorktreeSweep(target, tickets, contract) {
   const terminal = new Set(contract.statuses.resolved.filter((s) => s !== contract.statuses.verified));
   const verified = contract.statuses.verified;
@@ -14434,7 +14664,7 @@ function worktreeTicketNumbers(target) {
   return [...nums];
 }
 function siblingWorktreeDirs(target) {
-  const parent = dirname16(target.dir.replace(/[/\\]+$/, ""));
+  const parent = dirname18(target.dir.replace(/[/\\]+$/, ""));
   const stem = `${basename10(target.dir.replace(/[/\\]+$/, ""))}-`;
   const registered = new Set(worktrees(target.dir).map((w) => resolve4(w.path)));
   let names;
@@ -14447,7 +14677,7 @@ function siblingWorktreeDirs(target) {
   for (const name of names) {
     if (!name.startsWith(stem)) continue;
     const m = DIR_NUMBER_SUFFIXED.exec(name);
-    const path = join27(parent, name);
+    const path = join28(parent, name);
     if (m && !registered.has(resolve4(path))) out.push({ path, number: m[1] });
   }
   return out;
@@ -14482,7 +14712,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
   let removed = 0;
   let keptBranches = 0;
   for (const a of actions) {
-    if (!dryRun && base && !a.keepBranch && existsSync25(a.path) && isHandBackMerge(a.path, base)) {
+    if (!dryRun && base && !a.keepBranch && existsSync27(a.path) && isHandBackMerge(a.path, base)) {
       if (gitOk(a.path, ["merge", "--abort"]) !== null) {
         log.emit(
           `abandoned the hand-back merge of ${base} in ${a.path}: ${a.ticket.issue_id} deployed without it`,
@@ -14490,7 +14720,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         );
       }
     }
-    if (!dryRun && existsSync25(a.path)) {
+    if (!dryRun && existsSync27(a.path)) {
       let dirty = false;
       try {
         dirty = status(a.path).length > 0;
@@ -14501,7 +14731,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         continue;
       }
     }
-    if (!dryRun && a.requirePushed && a.branch && existsSync25(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
+    if (!dryRun && a.requirePushed && a.branch && existsSync27(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
       refuse(a, "unpushed commits", `${a.branch} has commits that are not on ${remote}`);
       continue;
     }
@@ -14550,7 +14780,7 @@ function isHandBackMerge(path, base) {
   if (!msgPath) return false;
   let first;
   try {
-    first = readFileSync20(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
+    first = readFileSync22(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
   } catch {
     return false;
   }
@@ -14655,14 +14885,14 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync26, readdirSync as readdirSync9, rmSync as rmSync13, statSync as statSync8 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync28, readdirSync as readdirSync9, rmSync as rmSync13, statSync as statSync8 } from "fs";
+import { join as join29 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
-  const dir = join28(stateDir, "streams");
-  if (!existsSync26(dir)) return [];
+  const dir = join29(stateDir, "streams");
+  if (!existsSync28(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync9(dir).map((name) => join28(dir, name)).filter((path) => {
+  return readdirSync9(dir).map((name) => join29(dir, name)).filter((path) => {
     try {
       return statSync8(path).mtimeMs < cutoff;
     } catch {
@@ -14688,9 +14918,9 @@ function applyStreamSweep(paths, dryRun, log) {
   return removed;
 }
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
-  if (!existsSync26(stateDir)) return [];
+  if (!existsSync28(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync9(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join28(stateDir, name)).filter((path) => {
+  return readdirSync9(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join29(stateDir, name)).filter((path) => {
     try {
       return statSync8(path).mtimeMs < cutoff;
     } catch {
@@ -14700,26 +14930,26 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync27, existsSync as existsSync33, mkdirSync as mkdirSync20, writeFileSync as writeFileSync21, rmSync as rmSync15, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync2, statSync as statSync10, readdirSync as readdirSync14 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync28, existsSync as existsSync34, mkdirSync as mkdirSync21, writeFileSync as writeFileSync22, rmSync as rmSync15, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync10, readdirSync as readdirSync14 } from "fs";
 import { createInterface } from "readline/promises";
 import { dirname as dirOf, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
-import { execFileSync as execFileSync5 } from "child_process";
-import { existsSync as existsSync27, mkdirSync as mkdirSync15, readFileSync as readFileSync21, chmodSync } from "fs";
-import { dirname as dirname17, join as join29 } from "path";
+import { execFileSync as execFileSync6 } from "child_process";
+import { existsSync as existsSync29, mkdirSync as mkdirSync17, readFileSync as readFileSync23, chmodSync } from "fs";
+import { dirname as dirname19, join as join30 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join29(stateDir, "ssh", "id_ed25519");
+  return join30(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
-  if (!existsSync27(privateKeyPath)) {
-    mkdirSync15(dirname17(privateKeyPath), { recursive: true });
+  if (!existsSync29(privateKeyPath)) {
+    mkdirSync17(dirname19(privateKeyPath), { recursive: true });
     try {
-      execFileSync5("ssh-keygen", [
+      execFileSync6("ssh-keygen", [
         "-t",
         "ed25519",
         "-N",
@@ -14737,71 +14967,21 @@ function ensureShipSshKeypair(stateDir) {
     }
     chmodSync(privateKeyPath, 384);
   }
-  if (!existsSync27(publicKeyPath)) {
+  if (!existsSync29(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
-  const publicKey = readFileSync21(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync23(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
   try {
-    execFileSync5("ssh-keygen", ["-V"], { stdio: ["ignore", "ignore", "ignore"] });
+    execFileSync6("ssh-keygen", ["-V"], { stdio: ["ignore", "ignore", "ignore"] });
     return true;
   } catch (e) {
     return e.code !== "ENOENT";
   }
 }
 
-// src/machine-id.ts
-import { execFileSync as execFileSync6 } from "child_process";
-import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync28, mkdirSync as mkdirSync16, readFileSync as readFileSync22, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname18, join as join30 } from "path";
-function machineIdPathFor(stateDir) {
-  return join30(stateDir, "machine-id");
-}
-var sha256 = (s) => createHash4("sha256").update(s).digest("hex");
-function readRawMachineId(platform2 = process.platform) {
-  try {
-    if (platform2 === "darwin") {
-      const out = execFileSync6("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"]
-      });
-      return /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(out)?.[1];
-    }
-    for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
-      if (existsSync28(p)) {
-        const id = readFileSync22(p, "utf8").trim();
-        if (id) return id;
-      }
-    }
-  } catch {
-  }
-  return void 0;
-}
-function ensureMachineId(stateDir, opts = {}) {
-  if (opts.override?.trim()) return sha256(opts.override.trim());
-  const path = machineIdPathFor(stateDir);
-  if (existsSync28(path)) {
-    const cached = readFileSync22(path, "utf8").trim();
-    if (/^[0-9a-f]{64}$/.test(cached)) return cached;
-  }
-  const raw = (opts.read ?? readRawMachineId)();
-  if (!raw) return void 0;
-  const hashed = sha256(raw);
-  mkdirSync16(dirname18(path), { recursive: true });
-  writeFileSync17(path, `${hashed}
-`, { mode: 384 });
-  return hashed;
-}
-function matchShipRows(ships, shipName2, machineId) {
-  const hasColumn = ships.some((r) => "machine_id" in r);
-  const byId = hasColumn && machineId ? ships.filter((r) => r.machine_id === machineId) : [];
-  if (byId.length > 0) return { rows: byId, by: "machine_id", hasColumn };
-  return { rows: ships.filter((r) => (r.name ?? "").trim() === shipName2.trim()), by: "name", hasColumn };
-}
-
 // src/passenger-containers.ts
 import { execFileSync as execFileSync7 } from "child_process";
 import { createHash as createHash5 } from "crypto";
@@ -15006,7 +15186,7 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync29, mkdirSync as mkdirSync17, readFileSync as readFileSync23, writeFileSync as writeFileSync18, unlinkSync as unlinkSync3, readdirSync as readdirSync10 } from "fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync18, readFileSync as readFileSync24, writeFileSync as writeFileSync19, unlinkSync as unlinkSync3, readdirSync as readdirSync10 } from "fs";
 import { randomInt } from "crypto";
 import { join as join31 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
@@ -15079,17 +15259,17 @@ function tunnelStatePath(stateDir, workspaceId) {
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
-  if (!existsSync29(path)) return void 0;
+  if (!existsSync30(path)) return void 0;
   try {
-    return JSON.parse(readFileSync23(path, "utf8"));
+    return JSON.parse(readFileSync24(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync17(join31(stateDir, "passengers"), { recursive: true });
-  writeFileSync18(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync18(join31(stateDir, "passengers"), { recursive: true });
+  writeFileSync19(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function updatePersistedTunnel(stateDir, workspaceId, patch2) {
@@ -15187,7 +15367,7 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
 }
 function readAllPersistedWorkspaceIds(stateDir) {
   const dir = join31(stateDir, "passengers");
-  if (!existsSync29(dir)) return [];
+  if (!existsSync30(dir)) return [];
   return readdirSync10(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
@@ -15308,7 +15488,7 @@ async function unregisterEndpoint(workspaceId, info, d) {
 import { createServer as createHttpServer } from "http";
 import { spawn as spawn6 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync30, mkdirSync as mkdirSync18, readFileSync as readFileSync24, writeFileSync as writeFileSync19, unlinkSync as unlinkSync4, readdirSync as readdirSync11 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync19, readFileSync as readFileSync25, writeFileSync as writeFileSync20, unlinkSync as unlinkSync4, readdirSync as readdirSync11 } from "fs";
 import { join as join32 } from "path";
 
 // src/secret-compare.ts
@@ -15402,17 +15582,17 @@ function syncDaemonStatePath(stateDir, workspaceId) {
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
-  if (!existsSync30(path)) return void 0;
+  if (!existsSync31(path)) return void 0;
   try {
-    return JSON.parse(readFileSync24(path, "utf8"));
+    return JSON.parse(readFileSync25(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync18(join32(stateDir, "passengers"), { recursive: true });
-  writeFileSync19(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync19(join32(stateDir, "passengers"), { recursive: true });
+  writeFileSync20(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function removePersistedSyncDaemon(stateDir, workspaceId) {
@@ -15433,7 +15613,7 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
   const dir = join32(stateDir, "passengers");
-  if (!existsSync30(dir)) return [];
+  if (!existsSync31(dir)) return [];
   const suffix = "-sync.json";
   return readdirSync11(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
@@ -15521,11 +15701,11 @@ function describeCause(err) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync19, readFileSync as readFileSync26, readdirSync as readdirSync13, rmSync as rmSync14, statSync as statSync9, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync20, readFileSync as readFileSync27, readdirSync as readdirSync13, rmSync as rmSync14, statSync as statSync9, writeFileSync as writeFileSync21 } from "fs";
 import { join as join34 } from "path";
 
 // src/interrupted.ts
-import { existsSync as existsSync31, readdirSync as readdirSync12, readFileSync as readFileSync25 } from "fs";
+import { existsSync as existsSync32, readdirSync as readdirSync12, readFileSync as readFileSync26 } from "fs";
 import { join as join33 } from "path";
 var INTERRUPTED_MARKER = calloutHeader("NOTE", "Interrupted");
 function interruptedComment(b) {
@@ -15545,16 +15725,16 @@ var pidAlive = (pid) => {
 };
 function runFinished(streamPath) {
   const path = `${streamPath}.meta.json`;
-  if (!existsSync31(path)) return false;
+  if (!existsSync32(path)) return false;
   try {
-    return JSON.parse(readFileSync25(path, "utf8")).running !== true;
+    return JSON.parse(readFileSync26(path, "utf8")).running !== true;
   } catch {
     return true;
   }
 }
 function orphanedStreams(o) {
   const dir = join33(o.stateDir, "streams");
-  if (!existsSync31(dir)) return [];
+  if (!existsSync32(dir)) return [];
   const ownerAlive = o.isOwnerAlive ?? pidAlive;
   const out = [];
   for (const name of readdirSync12(dir)) {
@@ -15688,7 +15868,7 @@ function computeTreeSignature(paths) {
 }
 function makeStaleChecker(paths, opts = {}) {
   const initial = computeTreeSignature(paths);
-  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync32(opts.reloadSentinel);
+  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync33(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
   return join34(stateDir, "reload-requested");
@@ -15697,14 +15877,14 @@ function daemonStampFor(stateDir) {
   return join34(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
-  mkdirSync19(stateDir, { recursive: true });
+  mkdirSync20(stateDir, { recursive: true });
   rmSync14(reloadSentinelFor(stateDir), { force: true });
-  writeFileSync20(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
+  writeFileSync21(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
 `);
 }
 function readDaemonStarted(stateDir) {
   try {
-    const v = JSON.parse(readFileSync26(daemonStampFor(stateDir), "utf8")).startedAt;
+    const v = JSON.parse(readFileSync27(daemonStampFor(stateDir), "utf8")).startedAt;
     return typeof v === "number" ? v : null;
   } catch {
     return null;
@@ -15767,6 +15947,7 @@ async function runOnePassUnguarded(o) {
   const spawn7 = 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 });
   try {
     await (o.reconcile ?? reconcileForRoute)(ctx, o);
   } catch (e) {
@@ -16089,7 +16270,7 @@ async function buildEnvironment(route, ship, ticket) {
 }
 
 // src/cli.ts
-var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname19(process.execPath) : resolve5(dirname19(fileURLToPath(import.meta.url)), "..");
+var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname20(process.execPath) : resolve5(dirname20(fileURLToPath(import.meta.url)), "..");
 var RELEASE_LOCK_TTL_MS = 20 * 60 * 1e3;
 var CYCLE_SECONDS2 = 120;
 var STALE_CYCLES = 3;
@@ -16245,6 +16426,7 @@ function usage(problem, requested = false) {
   crew agents sync [route] [--force] [--revoke-seat-keys]   push crew's personas AND skill files into the workspace Agents/Agent Skills tables (--force overwrites even a diverged persona or skill; never one marked Customize prompt)
   crew agents prompt R [route] print one persona's current prompt (e.g. R=pair, for a SessionStart hook; --harness H adds which CLI it serves)
   crew skills sync [route]      push only crew's skill files (e.g. grill-me) into the workspace Agent Skills table
+  crew ship rename NAME [--json] rename this ship in crew.yaml and on every workspace's Ships row
   crew repos add [ROUTE] [NAME] [PATH]  attach a local checkout to a route in crew.yaml (--dry-run previews)
   crew repos clone [ROUTE] NAME  clone a Repos row's remote into the route directory and attach it (--dir PATH, --dry-run, --json)
   crew repos hooks [ROUTE] NAME suggest test/build hooks for a checkout (--agent, --write route|repo, --recipes, --json)
@@ -16333,6 +16515,7 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "run",
   "sample-ticket",
   "selftest",
+  "ship",
   "skills",
   "status",
   "sync",
@@ -16482,9 +16665,9 @@ if (command === "passenger-sync-daemon") {
       firstRun = { answers, configPath };
       cfg = loadConfig(CREW_HOME, configPath, { text: renderShipBlock(answers), allowNoRoutes: true });
     } else {
-      const toleratesNoRoutes = command === "repos" || command === "disconnect" && flag("reset") || command === "connect" && flag("sign-out");
+      const toleratesNoRoutes = 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 && !existsSync33(findConfigFile(CREW_HOME))) {
+      if (configless && !existsSync34(findConfigFile(CREW_HOME))) {
         cfg = loadConfig(CREW_HOME, firstRunConfigPath(), { text: "ship: {}\n", allowNoRoutes: true });
       } else {
         cfg = loadConfig(CREW_HOME, void 0, toleratesNoRoutes ? { allowNoRoutes: true } : {});
@@ -16506,7 +16689,7 @@ if (command === "passenger-sync-daemon") {
   const DAEMON_SUBCOMMANDS = /* @__PURE__ */ new Set(["start", "stop", "status", "restart"]);
   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 === "projects" || 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;
+  const fleetWide = command === "inbox" || command === "connect" || command === "disconnect" || command === "agents" || command === "skills" || command === "logbook" || command === "repos" || command === "ship" || command === "projects" || 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;
   try {
     route = fleetWide ? cfg.routes[0] : findRoute(cfg, named);
@@ -16723,7 +16906,7 @@ if (command === "passenger-sync-daemon") {
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
       const staleTimer = join35(homedir9(), ".config", "systemd", "user", `${label}.timer`);
-      if (existsSync33(staleTimer)) {
+      if (existsSync34(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
@@ -16749,7 +16932,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 (!existsSync33(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
+      if (!existsSync34(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}`);
       problems.push(...validateEffective(r.config).map((p) => `repo ${r.name}: ${p}`));
     }
@@ -16767,7 +16950,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) => existsSync33(p);
+    const unitExists = (p) => existsSync34(p);
     const crontab = o.host === "linux" ? spawnSync6("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 });
@@ -16784,7 +16967,7 @@ if (command === "passenger-sync-daemon") {
       for (const a of plan.actions) {
         if (a.kind === "enable") {
           if (prompter && !await prompter.confirm(`Route ${a.route} passes every check \u2014 set enabled: true in ${cfg.configFile}?`, false)) continue;
-          writeFileSync21(cfg.configFile, planEnable(readFileSync27(cfg.configFile, "utf8"), a.route));
+          writeFileSync22(cfg.configFile, planEnable(readFileSync28(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
@@ -17267,6 +17450,11 @@ ${changed2.map((c) => `  - ${c}
     case "poll":
     case "run": {
       const skipInlineRelease = flag("no-release");
+      if (!dryRun) {
+        for (const r of fleetWide ? cfg.routes : [route]) {
+          await reconcileRouteShipName({ route: r, ship: cfg.ship, configFile: cfg.configFile, emit: emit.forRoute(r.route) });
+        }
+      }
       if (fleetWide) {
         const fleet = await decideFleet({
           routes: cfg.routes,
@@ -17800,6 +17988,7 @@ ${changed2.map((c) => `  - ${c}
           state,
           maxConcurrentAgents: cfg.ship.maxConcurrentAgents,
           spawnBreaker,
+          configFile: cfg.configFile,
           newEmitter: () => new Emitter({
             route: route.route,
             eventFile: eventFileFor(cfg.ship.stateDir),
@@ -18006,15 +18195,72 @@ ${changed2.map((c) => `  - ${c}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync33(resolvedPath) ? JSON.parse(readFileSync27(resolvedPath, "utf8")) : {};
+        const raw = existsSync34(resolvedPath) ? JSON.parse(readFileSync28(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
-        mkdirSync20(dirOf(resolvedPath), { recursive: true });
-        writeFileSync21(resolvedPath, `${JSON.stringify(raw, null, 2)}
+        mkdirSync21(dirOf(resolvedPath), { recursive: true });
+        writeFileSync22(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
       }
       if (result.outcomes.some((o) => o.action === "diverged")) process.exitCode = 1;
       break;
     }
+    case "ship": {
+      if (positional[1] !== "rename" || positional.length !== 3) {
+        process.stderr.write("crew ship rename NAME [--json]\n");
+        process.exit(2);
+      }
+      let newName;
+      try {
+        newName = validateShipName(positional[2]);
+      } catch (e) {
+        if (e instanceof ShipNameError) {
+          process.stderr.write(`crew ship: ${e.message}
+`);
+          process.exit(2);
+        }
+        throw e;
+      }
+      const oldName = cfg.ship.name;
+      writeFileSync22(cfg.configFile, setShipNameInYaml(readFileSync28(cfg.configFile, "utf8"), newName));
+      cfg.ship.name = newName;
+      let renameMachineId;
+      try {
+        renameMachineId = ensureMachineId(cfg.ship.stateDir);
+      } catch {
+      }
+      const outcomes = [];
+      for (const r of cfg.routes) {
+        if (!r.resolved?.shipsModelId) {
+          outcomes.push({ route: r.route, status: "no-ships-table" });
+          continue;
+        }
+        const resolvedFile = resolvedPathFor(cfg.ship.stateDir, r.route);
+        const tracker = new Tracker(r, cfg.ship);
+        const picked = pickShipRow(await tracker.shipRows(), renameMachineId, [oldName, readSyncedName(resolvedFile) ?? ""]);
+        if (picked.kind !== "row") {
+          outcomes.push({ route: r.route, status: picked.kind === "unsupported" ? "unsupported" : picked.kind === "none" ? "no-row" : "ambiguous" });
+          continue;
+        }
+        try {
+          await tracker.renameShipRow(picked.row.id, newName);
+          writeSyncedName(resolvedFile, newName);
+          outcomes.push({ route: r.route, status: "renamed", rowId: picked.row.id });
+        } catch (e) {
+          outcomes.push({ route: r.route, status: "refused", rowId: picked.row.id, error: e.message });
+        }
+      }
+      if (flag("json")) {
+        process.stdout.write(`${JSON.stringify({ name: newName, previous: oldName, configFile: cfg.configFile, routes: outcomes })}
+`);
+      } else {
+        process.stdout.write(`ship renamed "${oldName}" -> "${newName}" in ${cfg.configFile}
+`);
+        for (const o of outcomes) process.stdout.write(`  ${o.route}: ${o.status}${o.error ? ` (${o.error})` : ""}
+`);
+      }
+      if (outcomes.some((o) => o.status === "refused")) process.exitCode = 1;
+      break;
+    }
     case "repos": {
       const sub = positional[1];
       const usage2 = () => {
@@ -18022,13 +18268,13 @@ ${changed2.map((c) => `  - ${c}
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list" && sub !== "clone" && sub !== "hooks") usage2();
-      const configText = readFileSync27(cfg.configFile, "utf8");
+      const configText = readFileSync28(cfg.configFile, "utf8");
       if (sub === "hooks") {
         try {
           const a = parseHooksArgs(positional.slice(2), routeNamesOf(configText));
-          const dir = repoDirOf(configText, dirname19(cfg.configFile), a.route, a.name);
-          if (!existsSync33(dir)) throw new ReposError(`${dir} does not exist on disk`);
-          const files = { exists: (r) => existsSync33(resolvePath(dir, r)), list: (r) => {
+          const dir = repoDirOf(configText, dirname20(cfg.configFile), a.route, a.name);
+          if (!existsSync34(dir)) throw new ReposError(`${dir} does not exist on disk`);
+          const files = { exists: (r) => existsSync34(resolvePath(dir, r)), list: (r) => {
             try {
               return readdirSync14(resolvePath(dir, r));
             } catch {
@@ -18036,7 +18282,7 @@ ${changed2.map((c) => `  - ${c}
             }
           }, read: (r) => {
             try {
-              return readFileSync27(resolvePath(dir, r), "utf8");
+              return readFileSync28(resolvePath(dir, r), "utf8");
             } catch {
               return void 0;
             }
@@ -18074,13 +18320,13 @@ ${changed2.map((c) => `  - ${c}
           if (write && suggestion.source === null && recipeIds.length === 0 && hookSpecs.length === 0) throw new ReposError(`nothing to write: ${suggestion.notes[0]}`);
           if (write === "route") {
             const plan = planRouteHooks(configText, a.route, a.name, picked.hooks);
-            writeFileSync21(cfg.configFile, plan.text);
+            writeFileSync22(cfg.configFile, plan.text);
             written = { target: "route", file: cfg.configFile, hooks: plan.written, kept: plan.kept };
           } else if (write === "repo") {
             const have = existingRepoConfig(files);
             if (have) throw new ReposError(`${resolvePath(dir, have)} already exists; not overwriting it`);
             const file = resolvePath(dir, ".crew.yaml");
-            writeFileSync21(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
+            writeFileSync22(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
             written = { target: "repo", file, hooks: Object.keys(picked.hooks), kept: [] };
           }
           if (flag("json")) {
@@ -18132,7 +18378,7 @@ ${changed2.map((c) => `  - ${c}
       if (sub === "list" && !routeName) usage2();
       if (sub === "add") {
         try {
-          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync33(resolvePath(p.replace(/^~(?=\/|$)/, homedir9()))));
+          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync34(resolvePath(p.replace(/^~(?=\/|$)/, homedir9()))));
           routeName = a.route;
           addPath = a.path;
           addName = a.name;
@@ -18161,15 +18407,15 @@ ${changed2.map((c) => `  - ${c}
       }
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, routeName);
       let resolvedRemotes;
-      if (existsSync33(resolvedFile)) {
+      if (existsSync34(resolvedFile)) {
         try {
-          resolvedRemotes = JSON.parse(readFileSync27(resolvedFile, "utf8"));
+          resolvedRemotes = JSON.parse(readFileSync28(resolvedFile, "utf8"));
         } catch {
         }
       }
       const originOf = (dir) => gitOk(dir, ["remote", "get-url", "origin"]) ?? void 0;
       const text = configText;
-      const base = dirname19(cfg.configFile);
+      const base = dirname20(cfg.configFile);
       try {
         if (sub === "list") {
           if (flag("json")) {
@@ -18179,10 +18425,10 @@ ${changed2.map((c) => `  - ${c}
               base,
               resolved: resolvedRemotes,
               originOf,
-              exists: (d) => existsSync33(d),
+              exists: (d) => existsSync34(d),
               repoHasHooks: (d) => REPO_CONFIG_FILENAMES.some((f) => {
                 try {
-                  return Object.keys(parseRepoConfig(readFileSync27(resolvePath(d, f), "utf8"), f).hooks).length > 0;
+                  return Object.keys(parseRepoConfig(readFileSync28(resolvePath(d, f), "utf8"), f).hooks).length > 0;
                 } catch {
                   return false;
                 }
@@ -18198,7 +18444,7 @@ ${changed2.map((c) => `  - ${c}
           for (const r of repos) {
             const origin2 = originOf(r.dir);
             const row = matchRepoName(origin2, resolvedRemotes);
-            const note = !existsSync33(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
+            const note = !existsSync34(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}
 `);
           }
@@ -18210,9 +18456,9 @@ ${changed2.map((c) => `  - ${c}
 ` : `${human}
 `);
           const plan2 = planRepoClone({ text, base, route: routeName, name: addName, resolved: resolvedRemotes, dir: value("dir") });
-          if (existsSync33(plan2.target) && (existsSync33(`${plan2.target}/.git`) || readdirSync14(plan2.target).length > 0)) {
+          if (existsSync34(plan2.target) && (existsSync34(`${plan2.target}/.git`) || readdirSync14(plan2.target).length > 0)) {
             throw new ReposError(
-              existsSync33(`${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`
+              existsSync34(`${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) {
@@ -18230,12 +18476,12 @@ ${changed2.map((c) => `  - ${c}
             throw new ReposError(`${e.message}${authHint}
   crew.yaml was not changed`);
           }
-          writeFileSync21(cfg.configFile, plan2.text);
+          writeFileSync22(cfg.configFile, plan2.text);
           say("attached", { route: routeName, name: plan2.name, dir: plan2.target, mode: plan2.mode }, `cloned and attached ${plan2.target} to ${routeName} as ${plan2.mode === "dir" ? "dir" : `repos.${plan2.name}`} in ${cfg.configFile}`);
           break;
         }
         const target = resolvePath(addPath.replace(/^~(?=\/|$)/, homedir9()));
-        const top = existsSync33(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
+        const top = existsSync34(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({
@@ -18284,15 +18530,15 @@ ${changed2.map((c) => `  - ${c}
           const created = await rowTracker.createRepoRow(rowPayload);
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
-          if (existsSync33(resolvedFile)) {
-            const raw = JSON.parse(readFileSync27(resolvedFile, "utf8"));
+          if (existsSync34(resolvedFile)) {
+            const raw = JSON.parse(readFileSync28(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
-            writeFileSync21(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync22(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        writeFileSync21(cfg.configFile, plan.text);
+        writeFileSync22(cfg.configFile, plan.text);
         process.stdout.write(`added ${top} to ${routeName} as ${plan.mode === "dir" ? "dir" : `repos.${plan.name}`} in ${cfg.configFile}
 `);
       } catch (e) {
@@ -18447,8 +18693,8 @@ ${reconstruction.prompt}
         }
       }
       let signInSource = apiKey ? "key" : "device";
-      if (!apiKey && !workspace && dryRun && store) {
-        const resumed = await resumeKeychainSession({
+      if (!apiKey && !workspace && store) {
+        const resumable = await resumableSessions({
           store,
           stateDir: cfg.ship.stateDir,
           host: hostFromUrl4(baseUrl),
@@ -18461,6 +18707,14 @@ ${reconstruction.prompt}
             }
           }
         });
+        if (resumable.length > 1 && connectEvents.json) {
+          stopForChoice(
+            "workspace",
+            `${resumable.length} workspaces have a remembered sign-in on ${hostFromUrl4(baseUrl)} \u2014 which one?`,
+            resumable.map((r) => ({ value: r.workspace, label: r.workspace }))
+          );
+        }
+        const resumed = resumable.length === 1 ? resumable[0] : void 0;
         if (resumed) {
           apiKey = resumed.apiKey;
           workspace = resumed.workspace;
@@ -18576,7 +18830,8 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         platform: cfg.ship.platform,
         machineId,
         hostPassengers: firstRun?.answers.hostPassengers ?? existingRoute?.hostPassengers === true,
-        sshPublicKey
+        sshPublicKey,
+        lastSyncedName: (r) => readSyncedName(resolvedPathFor(cfg.ship.stateDir, r))
       };
       const runConnect = async (ws, proj) => {
         let found = await discover({ ...authOpts, workspace: ws, project: proj, area: value("area"), ship, dryRun, interactive: canAsk || connectEvents.json });
@@ -18633,6 +18888,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           }
           process.exit(2);
         }
+        if (found.shipNameAdopted && !dryRun) {
+          writeFileSync22(cfg.configFile, setShipNameInYaml(readFileSync28(cfg.configFile, "utf8"), found.shipNameAdopted));
+          cfg.ship.name = found.shipNameAdopted;
+        }
         if (found.shipRow) {
           connectEvents.emit("ship_row", `Ships row "${found.shipRow.name}" ${found.shipRow.action}`, found.shipRow);
         }
@@ -18673,10 +18932,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           }
         }
         let previous;
-        const hadPreviousFile = existsSync33(resolvedPath);
+        const hadPreviousFile = existsSync34(resolvedPath);
         if (hadPreviousFile) {
           try {
-            previous = JSON.parse(readFileSync27(resolvedPath, "utf8"));
+            previous = JSON.parse(readFileSync28(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -18788,18 +19047,20 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           // nothing about its prompt actually changed.
           ...previous?.agentPersonas ? { agentPersonas: previous.agentPersonas } : {},
           ...previous?.agentSkills ? { agentSkills: previous.agentSkills } : {},
-          ...previous?.releaseAgentId ? { releaseAgentId: previous.releaseAgentId } : {}
+          ...previous?.releaseAgentId ? { releaseAgentId: previous.releaseAgentId } : {},
+          // CREW-2495: the ship name this route last saw agree with its Ships row.
+          ...found.shipRow ? { shipName: found.shipRow.name } : previous?.shipName ? { shipName: previous.shipName } : {}
         };
         if (dryRun) {
           process.stderr.write(`(dry run) would write resolved ids to ${resolvedPath}
 `);
         } else {
-          mkdirSync20(dirname19(resolvedPath), { recursive: true });
+          mkdirSync21(dirname20(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
-          writeFileSync21(tmpPath, `${JSON.stringify(resolved, null, 2)}
+          writeFileSync22(tmpPath, `${JSON.stringify(resolved, null, 2)}
 `);
-          renameSync2(tmpPath, resolvedPath);
+          renameSync3(tmpPath, resolvedPath);
           process.stderr.write(`Resolved ids written to ${resolvedPath}
 `);
         }
@@ -18839,8 +19100,8 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             process.stderr.write(`(dry run) would write the minted API key to ${apiKeyFile}
 `);
           } else {
-            mkdirSync20(dirname19(apiKeyFile), { recursive: true });
-            writeFileSync21(apiKeyFile, `${apiKeyVar}=${apiKey}
+            mkdirSync21(dirname20(apiKeyFile), { recursive: true });
+            writeFileSync22(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
 `);
@@ -19528,7 +19789,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       };
       const droppedRoutes = [];
       try {
-        const rawCfg = parseYaml2(readFileSync27(cfg.configFile, "utf8"));
+        const rawCfg = parseYaml2(readFileSync28(cfg.configFile, "utf8"));
         for (const r of rawCfg?.routes ?? []) {
           if (typeof r?.route !== "string" || cfg.routes.some((x) => x.route === r.route)) continue;
           try {
@@ -19570,8 +19831,8 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         process.stdout.write("crew reload: no daemon unit is running \u2014 nothing to reload (the next run reads crew.yaml fresh)\n");
         break;
       }
-      mkdirSync20(cfg.ship.stateDir, { recursive: true });
-      writeFileSync21(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
+      mkdirSync21(cfg.ship.stateDir, { recursive: true });
+      writeFileSync22(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
       process.stdout.write("crew reload: requested \u2014 the daemon finishes its in-flight pass, then relaunches with the new config\n");
       if (flag("now") && control?.stopCommand && control.startCommand) {
@@ -19622,7 +19883,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
     }
     case "log": {
       try {
-        const text = readFileSync27(cfg.ship.logFile, "utf8").split("\n");
+        const text = readFileSync28(cfg.ship.logFile, "utf8").split("\n");
         process.stdout.write(`${text.slice(-(Number(value("tail")) || 40)).join("\n")}
 `);
       } catch {
@@ -19645,8 +19906,8 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       };
       if (!route.resolved) fail(`route ${route.route} is not connected \u2014 run \`crew connect\` first`);
       const tracker = new Tracker(route, cfg.ship);
-      const configText = readFileSync27(cfg.configFile, "utf8");
-      const cfgBase = dirname19(cfg.configFile);
+      const configText = readFileSync28(cfg.configFile, "utf8");
+      const cfgBase = dirname20(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);
@@ -19674,7 +19935,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         }
         if (configured.some((r) => r.dir === dir)) {
           try {
-            writeFileSync21(cfg.configFile, planRepoRemove(configText, cfgBase, route.route, dir).text);
+            writeFileSync22(cfg.configFile, planRepoRemove(configText, cfgBase, route.route, dir).text);
           } catch (e) {
             if (e instanceof ReposError) fail(e.message);
             throw e;
@@ -19682,29 +19943,29 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         }
         if (row) {
           await tracker.deleteRepoRow(row.id);
-          if (existsSync33(resolvedFile)) {
-            const raw = JSON.parse(readFileSync27(resolvedFile, "utf8"));
+          if (existsSync34(resolvedFile)) {
+            const raw = JSON.parse(readFileSync28(resolvedFile, "utf8"));
             if (raw.repoNames) delete raw.repoNames[row.id];
             if (raw.repoRemotes) delete raw.repoRemotes[row.id];
-            writeFileSync21(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync22(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        if (existsSync33(join35(dir, ".git")) && basename11(dir) === SAMPLE_REPO) rmSync15(dir, { recursive: true, force: true });
+        if (existsSync34(join35(dir, ".git")) && basename11(dir) === SAMPLE_REPO) rmSync15(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 = !existsSync33(join35(dir, ".git"));
-      if (existsSync33(dir) && fresh && readdirSync14(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
+      const fresh = !existsSync34(join35(dir, ".git"));
+      if (existsSync34(dir) && fresh && readdirSync14(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) {
-        mkdirSync20(dir, { recursive: true });
-        writeFileSync21(join35(dir, "README.md"), SAMPLE_README);
-        writeFileSync21(join35(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        mkdirSync21(dir, { recursive: true });
+        writeFileSync22(join35(dir, "README.md"), SAMPLE_README);
+        writeFileSync22(join35(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
         const g = (...a) => {
           const r = spawnSync6("git", a, { cwd: dir, encoding: "utf8" });
           if (r.status !== 0) fail(`git ${a[0]} failed in ${dir}: ${(r.stderr || r.stdout).trim()}`);
@@ -19722,17 +19983,17 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           spec: { platform: "unix", releaseMode: "integrate", ciProvider: "none" }
         });
         repoId = (await tracker.createRepoRow(payload)).id;
-        if (existsSync33(resolvedFile)) {
-          const raw = JSON.parse(readFileSync27(resolvedFile, "utf8"));
+        if (existsSync34(resolvedFile)) {
+          const raw = JSON.parse(readFileSync28(resolvedFile, "utf8"));
           raw.repoNames = { ...raw.repoNames, [repoId]: SAMPLE_REPO };
           raw.repoRemotes = { ...raw.repoRemotes, [repoId]: SAMPLE_REMOTE };
-          writeFileSync21(resolvedFile, `${JSON.stringify(raw, null, 2)}
+          writeFileSync22(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
         }
       }
       if (!configured.some((r) => r.dir === dir)) {
         try {
-          writeFileSync21(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route.route, path: dir, name: SAMPLE_REPO }).text);
+          writeFileSync22(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route.route, path: dir, name: SAMPLE_REPO }).text);
         } catch (e) {
           if (e instanceof ReposError) fail(e.message);
           throw e;
@@ -19853,6 +20114,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       const projects = projectModeLabels(await statusTracker.projectRowsWithModes().catch(() => []));
       const crewMinVersion = await readCrewFloor(route, cfg.ship) ?? null;
       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 crewRows = Object.keys(seatIds).length ? await statusTracker.crewRows() : [];
@@ -19896,7 +20158,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             eventFile: eventFileFor(cfg.ship.stateDir),
             // Additive (CREW-1373): open ship-level items, including the
             // derived `release_stale`. `version` stays 1.
-            attention: openShipAttention(state)
+            attention: openShipAttention(state),
+            // Additive (CREW-2495): this ship's Ships-row name and whether it has drifted from `name`.
+            rowName: nameSync.rowName ?? null,
+            nameDrift: nameSync.drift
           },
           // Additive (CREW-1402): what the operator owes. `version` stays 1.
           todo: todo.map((i) => ({ ticket: displayKey(i.ticket), title: i.ticket.title ?? null, reasons: i.reasons })),
@@ -20043,7 +20308,7 @@ watermark:  ${state.watermark()}
           }
           for (const r of repos) {
             const remote = r.config.branch.remote;
-            if (existsSync33(r.dir)) {
+            if (existsSync34(r.dir)) {
               pushAuth.push({
                 route: c.route,
                 repo: r.name,
@@ -20071,7 +20336,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       );
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
-        const evSize = existsSync33(evFile) ? statSync10(evFile).size : 0;
+        const evSize = existsSync34(evFile) ? statSync10(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"
@@ -20082,7 +20347,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
         const unitPlan = planInstall(cfg.ship, CREW_HOME, host, detectSystemd(), "run");
         const abandons = unitAbandonsAgents(unitPlan, (p) => {
           try {
-            return readFileSync27(p, "utf8");
+            return readFileSync28(p, "utf8");
           } catch {
             return null;
           }