@launchsecure/launch-kit 0.0.34 → 0.0.36

package/dist/server/orbit-entry.js

@@ -361,9 +361,15 @@ function resolvePgClient(versionHint) {
   const dumpOnPath = which("pg_dump");
   const psqlOnPath = which("psql");
   if (dumpOnPath && psqlOnPath) {
-    return { kind: "binary", pgDump: dumpOnPath, psql: psqlOnPath, version: probeVersion(dumpOnPath) };
-  }
-  if (dumpOnPath || psqlOnPath) {
+    const pathVer = probeVersion(dumpOnPath);
+    const pathMajor = pathVer ? parseInt(pathVer, 10) : void 0;
+    if (versionHint === void 0 || pathMajor === void 0 || pathMajor >= versionHint) {
+      return { kind: "binary", pgDump: dumpOnPath, psql: psqlOnPath, version: pathVer };
+    }
+    reasons.push(
+      `PATH pg_dump is v${pathMajor} but the server is v${versionHint} \u2014 pg_dump must be \u2265 the server; trying version-matched installs`
+    );
+  } else if (dumpOnPath || psqlOnPath) {
     reasons.push(`PATH has only ${dumpOnPath ? "pg_dump" : "psql"} \u2014 need both`);
   } else {
     reasons.push("pg_dump + psql not on PATH");
@@ -428,6 +434,7 @@ function findPostgresApp(versionHint) {
   }
   versions.sort((a, b) => parseFloat(b) - parseFloat(a));
   for (const v of versions) {
+    if (versionHint && parseInt(v, 10) < versionHint) continue;
     const r = tryVersion(v);
     if (r) return r;
   }
@@ -803,18 +810,575 @@ var init_adapter_registry = __esm({
   }
 });
 
+// src/server/orbit/cleanliness.ts
+async function runCleanlinessReport(opts) {
+  const start = Date.now();
+  const { entry, manifest, base, deep } = opts;
+  const checks = [];
+  const pgState = findPgState(entry);
+  const portState = findPortState(entry);
+  checks.push(checkGitClean(entry));
+  checks.push(checkGitMerged(entry, base));
+  let orbitClient = null;
+  let orbitConnError = null;
+  if (pgState) {
+    try {
+      orbitClient = new Client2({ connectionString: orbitDbUrl(pgState) });
+      await orbitClient.connect();
+    } catch (e) {
+      orbitConnError = errMsg(e);
+      orbitClient = null;
+    }
+  }
+  checks.push(await checkOrbitOnlyRows(pgState, orbitClient, orbitConnError));
+  checks.push(await checkUncommittedMigrations(entry, pgState, orbitClient, orbitConnError));
+  checks.push(checkSnapshot(pgState));
+  checks.push(checkRegistry(entry));
+  checks.push(checkEnvParity(entry, manifest, pgState));
+  checks.push(await checkDbReachable(pgState, orbitClient, orbitConnError));
+  checks.push(deep ? await checkSchemaDrift(entry, pgState) : skip("db.schema-drift", "Schema \u2194 migration drift", "working-health", "not run (pass --deep to enable)"));
+  checks.push(checkPorts(portState));
+  checks.push(await checkBackupResidue(orbitClient, orbitConnError, pgState));
+  if (orbitClient) {
+    try {
+      await orbitClient.end();
+    } catch {
+    }
+  }
+  const dropChecks = checks.filter((c) => c.section === "drop-safety");
+  const healthChecks = checks.filter((c) => c.section === "working-health");
+  const dropSafe = dropChecks.every((c) => c.status === "pass" || c.status === "skip");
+  const healthy = healthChecks.every((c) => c.status !== "fail");
+  const { recommendation, actions } = deriveActions(entry, base, checks, dropSafe, healthy);
+  return {
+    slug: entry.slug,
+    branch: entry.branch,
+    path: entry.path,
+    projectRoot: entry.projectRoot,
+    base,
+    dropSafe,
+    healthy,
+    recommendation,
+    actions,
+    checks,
+    durationMs: Date.now() - start
+  };
+}
+function deriveActions(entry, base, checks, dropSafe, healthy) {
+  const by = (id) => checks.find((c) => c.id === id);
+  const preserve = [];
+  if (by("git.clean")?.status === "fail") {
+    preserve.push("Commit or stash the uncommitted changes \u2014 they are NOT carried by a merge and are lost on drop.");
+  }
+  const merged = by("git.merged");
+  if (merged?.status === "fail") preserve.push(`Merge ${entry.branch} into ${base} to preserve its commits \u2014 ${merged.summary}.`);
+  const mig = by("db.uncommitted-migrations");
+  if (mig?.status === "fail") preserve.push(`Commit the applied-but-uncommitted migration(s) \u2014 ${mig.summary}.`);
+  if (by("db.orbit-only-rows")?.status === "warn") {
+    preserve.push("Review possible orbit-only DB rows before dropping (heuristic \u2014 verify against source).");
+  }
+  const health = [];
+  const env = by("env.parity");
+  if (env?.status === "fail") health.push(`Fix the orbit env file \u2014 ${env.summary}${envDetail(env)}.`);
+  else if (env?.status === "warn") health.push(`Reconcile env drift with the main repo${envDetail(env)}.`);
+  if (by("db.reachable")?.status === "fail") {
+    health.push(`Start the database cluster so the forked DB is reachable, then re-run \`launch-orbit check ${entry.branch} --deep\` to validate the DB checks.`);
+  } else if (by("db.reachable")?.status === "warn") {
+    health.push("Forked DB server version differs from the recorded one \u2014 re-fork if you need parity.");
+  }
+  const ports = by("ports.liveness");
+  if (ports?.status === "warn") health.push(`${ports.summary} \u2014 stop it if it's stale.`);
+  if (by("db.schema-drift")?.status === "warn") health.push("Resolve schema drift vs schema.prisma (run prisma migrate in the orbit).");
+  if (by("db.backup-residue")?.status === "warn") health.push("Drop the leftover _backup_ tables in a follow-up migration.");
+  const actions = [];
+  let recommendation;
+  if (dropSafe) {
+    recommendation = healthy ? "DROP \u2014 merged, clean, healthy; nothing would be lost." : "DROP-SAFE \u2014 merged & clean. Remove it, or fix the health items below if you mean to keep working in it.";
+    actions.push(`Remove it:  launch-orbit drop ${entry.branch}   (a pg_dump backup is taken by default)`);
+    for (const h of health) actions.push(`If keeping \u2014 ${h}`);
+  } else {
+    recommendation = "KEEP \u2014 unmerged or uncommitted work would be lost on drop. Address the actions below.";
+    actions.push(...preserve, ...health);
+  }
+  return { recommendation, actions };
+}
+function envDetail(check2) {
+  const d = (check2.detail ?? []).map((l) => l.trim()).filter(Boolean);
+  return d.length > 0 ? ` (${d.join("; ")})` : "";
+}
+function checkGitClean(entry) {
+  if (!(0, import_node_fs6.existsSync)(entry.path)) {
+    return mk("git.clean", "Working tree clean", "drop-safety", "fail", `worktree path missing: ${entry.path}`);
+  }
+  const r = gitTry(entry.path, ["status", "--porcelain"]);
+  if (!r.ok) {
+    return mk("git.clean", "Working tree clean", "drop-safety", "skip", `git status failed: ${r.err}`);
+  }
+  const lines = r.out.split("\n").filter((l) => l.length > 0);
+  if (lines.length === 0) {
+    return mk("git.clean", "Working tree clean", "drop-safety", "pass", "no uncommitted changes");
+  }
+  return mk(
+    "git.clean",
+    "Working tree clean",
+    "drop-safety",
+    "fail",
+    `${lines.length} uncommitted/untracked ${lines.length === 1 ? "entry" : "entries"} \u2014 dropping would lose them`,
+    lines.map((l) => `  ${l}`)
+  );
+}
+function checkGitMerged(entry, base) {
+  const label = `Merged into ${base}`;
+  if (!refExists(entry.projectRoot, base)) {
+    return mk("git.merged", label, "drop-safety", "skip", `base ref "${base}" not found \u2014 pass --base <ref>`);
+  }
+  if (!refExists(entry.projectRoot, entry.branch)) {
+    return mk("git.merged", label, "drop-safety", "skip", `orbit branch "${entry.branch}" not found`);
+  }
+  const r = gitTry(entry.projectRoot, ["rev-list", "--count", `${base}..${entry.branch}`]);
+  if (!r.ok) {
+    return mk("git.merged", label, "drop-safety", "skip", `rev-list failed: ${r.err}`);
+  }
+  const ahead = Number(r.out.trim());
+  if (ahead === 0) {
+    return mk("git.merged", label, "drop-safety", "pass", `fully merged (0 commits ahead of ${base})`);
+  }
+  return mk(
+    "git.merged",
+    label,
+    "drop-safety",
+    "fail",
+    `${ahead} commit${ahead === 1 ? "" : "s"} ahead of ${base} \u2014 unmerged work would be lost on drop`
+  );
+}
+async function checkOrbitOnlyRows(pgState, orbit, connError) {
+  const id = "db.orbit-only-rows";
+  const label = "No orbit-only DB rows";
+  if (!pgState) return skip(id, label, "drop-safety", "no orbit-pg resource");
+  if (!orbit) return skip(id, label, "drop-safety", `orbit DB unreachable: ${connError ?? "unknown"}`);
+  let source;
+  try {
+    source = new Client2({ connectionString: pgState.sourceUrl });
+    await source.connect();
+  } catch (e) {
+    return skip(id, label, "drop-safety", `source DB unreachable: ${errMsg(e)}`);
+  }
+  try {
+    const tables = await userTables(orbit);
+    const grown = [];
+    for (const t of tables) {
+      const oc = await rowCount(orbit, t);
+      const sc = await rowCount(source, t);
+      if (oc !== null && sc !== null && oc > sc) grown.push(`  ${t}: ${oc} (orbit) vs ${sc} (source) \u2014 +${oc - sc}`);
+    }
+    if (grown.length === 0) {
+      return mk(id, label, "drop-safety", "pass", `no table grew vs source (${tables.length} tables checked)`);
+    }
+    return mk(
+      id,
+      label,
+      "drop-safety",
+      "warn",
+      `${grown.length} table${grown.length === 1 ? "" : "s"} grew vs source \u2014 possible orbit-only data (heuristic)`,
+      grown
+    );
+  } catch (e) {
+    return skip(id, label, "drop-safety", `count comparison failed: ${e.message}`);
+  } finally {
+    try {
+      await source.end();
+    } catch {
+    }
+  }
+}
+async function checkUncommittedMigrations(entry, pgState, orbit, connError) {
+  const id = "db.uncommitted-migrations";
+  const label = "No applied-but-uncommitted migrations";
+  if (!pgState) return skip(id, label, "drop-safety", "no orbit-pg resource");
+  if (!orbit) return skip(id, label, "drop-safety", `orbit DB unreachable: ${connError ?? "unknown"}`);
+  let applied;
+  try {
+    const res = await orbit.query(
+      `SELECT migration_name FROM _prisma_migrations WHERE finished_at IS NOT NULL`
+    );
+    applied = res.rows.map((r) => r.migration_name);
+  } catch (e) {
+    return skip(id, label, "drop-safety", `_prisma_migrations not readable: ${e.message}`);
+  }
+  const committed = committedMigrations(entry.path);
+  const orphan = applied.filter((m) => !committed.has(m));
+  if (orphan.length === 0) {
+    return mk(id, label, "drop-safety", "pass", `all ${applied.length} applied migrations are committed`);
+  }
+  return mk(
+    id,
+    label,
+    "drop-safety",
+    "fail",
+    `${orphan.length} migration${orphan.length === 1 ? "" : "s"} applied to the orbit DB but not committed \u2014 SQL would be lost on drop`,
+    orphan.map((m) => `  ${m}`)
+  );
+}
+function checkSnapshot(pgState) {
+  const id = "db.snapshot";
+  const label = "Fork snapshot present";
+  if (!pgState) return skip(id, label, "drop-safety", "no orbit-pg resource");
+  const matches = listSnapshots(pgState.dbName);
+  if (matches.length > 0) {
+    return mk(id, label, "drop-safety", "pass", `${matches.length} fork snapshot(s) under ${SNAPSHOT_DIR2}`);
+  }
+  return mk(
+    id,
+    label,
+    "drop-safety",
+    "warn",
+    "no fork snapshot found \u2014 drop still takes a pg_dump backup, but the create-time baseline is gone"
+  );
+}
+function checkRegistry(entry) {
+  const id = "registry.consistency";
+  const label = "Registry consistency";
+  const issues = doctor().filter((i) => i.slug === entry.slug);
+  if (issues.length === 0) {
+    return mk(id, label, "working-health", "pass", "registry matches disk + git");
+  }
+  return mk(
+    id,
+    label,
+    "working-health",
+    "fail",
+    `${issues.length} registry issue(s)`,
+    issues.map((i) => `  [${i.kind}] ${i.detail}`)
+  );
+}
+function checkEnvParity(entry, manifest, pgState) {
+  const id = "env.parity";
+  const label = "Env parity with main repo";
+  const envName = manifest.envFile ?? ".env.local";
+  const mainPath = (0, import_node_path5.join)(entry.projectRoot, envName);
+  const orbitPath = (0, import_node_path5.join)(entry.path, envName);
+  if (!(0, import_node_fs6.existsSync)(orbitPath)) {
+    return mk(id, label, "working-health", "fail", `orbit ${envName} is missing \u2014 resources can't resolve`);
+  }
+  if (!(0, import_node_fs6.existsSync)(mainPath)) {
+    return skip(id, label, "working-health", `main repo ${envName} not present \u2014 nothing to compare`);
+  }
+  const main2 = parseEnvKeys(mainPath);
+  const orbit = parseEnvKeys(orbitPath);
+  const rewritten = rewrittenKeys(manifest);
+  const detail = [];
+  let status = "pass";
+  if (pgState) {
+    for (const key of pgState.envKeys) {
+      const v = orbit.get(key);
+      if (v === void 0) continue;
+      const path = urlPath(v);
+      if (path !== null && path !== `/${pgState.dbName}`) {
+        status = "fail";
+        detail.push(`  ${key} points at "${path}" \u2014 expected "/${pgState.dbName}" (not pointing at the fork)`);
+      }
+    }
+  }
+  const missingInOrbit = [...main2.keys()].filter((k) => !orbit.has(k));
+  const orphanInOrbit = [...orbit.keys()].filter((k) => !main2.has(k));
+  const divergent = [...main2.keys()].filter(
+    (k) => orbit.has(k) && !rewritten.has(k) && orbit.get(k) !== main2.get(k)
+  );
+  if (missingInOrbit.length > 0) {
+    if (status !== "fail") status = "warn";
+    detail.push(`  missing in orbit (added to main since fork?): ${missingInOrbit.join(", ")}`);
+  }
+  if (orphanInOrbit.length > 0) {
+    if (status !== "fail") status = "warn";
+    detail.push(`  present only in orbit: ${orphanInOrbit.join(", ")}`);
+  }
+  if (divergent.length > 0) {
+    if (status !== "fail") status = "warn";
+    detail.push(`  value differs (non-rewritten keys): ${divergent.join(", ")}`);
+  }
+  if (status === "pass") {
+    return mk(id, label, "working-health", "pass", `in sync (${rewritten.size} rewritten keys ignored)`);
+  }
+  return mk(
+    id,
+    label,
+    "working-health",
+    status,
+    status === "fail" ? "env drift includes a broken fork pointer" : "env drift vs main repo",
+    detail
+  );
+}
+async function checkDbReachable(pgState, orbit, connError) {
+  const id = "db.reachable";
+  const label = "Forked DB reachable";
+  if (!pgState) return skip(id, label, "working-health", "no orbit-pg resource");
+  if (!orbit) return mk(id, label, "working-health", "fail", `cannot connect to ${pgState.dbName}: ${connError ?? "unknown"}`);
+  try {
+    const res = await orbit.query(`SELECT current_setting('server_version_num')::int AS v`);
+    const v = res.rows[0]?.v;
+    if (v === pgState.version) {
+      return mk(id, label, "working-health", "pass", `${pgState.dbName} reachable (server ${v})`);
+    }
+    return mk(
+      id,
+      label,
+      "working-health",
+      "warn",
+      `${pgState.dbName} reachable but server version ${v} \u2260 recorded ${pgState.version}`
+    );
+  } catch (e) {
+    return mk(id, label, "working-health", "fail", `version probe failed: ${errMsg(e)}`);
+  }
+}
+async function checkSchemaDrift(entry, pgState) {
+  const id = "db.schema-drift";
+  const label = "Schema \u2194 migration drift";
+  if (!pgState) return skip(id, label, "working-health", "no orbit-pg resource");
+  const schemaPath = (0, import_node_path5.join)(entry.path, "prisma", "schema.prisma");
+  if (!(0, import_node_fs6.existsSync)(schemaPath)) return skip(id, label, "working-health", "no prisma/schema.prisma in worktree");
+  const res = (0, import_node_child_process5.spawnSync)(
+    "npx",
+    [
+      "prisma",
+      "migrate",
+      "diff",
+      "--from-url",
+      orbitDbUrl(pgState),
+      "--to-schema-datamodel",
+      "prisma/schema.prisma",
+      "--exit-code"
+    ],
+    { cwd: entry.path, encoding: "utf-8", timeout: 6e4, stdio: ["ignore", "pipe", "pipe"] }
+  );
+  if (res.status === 0) {
+    return mk(id, label, "working-health", "pass", "live schema matches schema.prisma");
+  }
+  if (res.status === 2) {
+    const summary = (res.stdout || "").trim().split("\n").slice(0, 8);
+    return mk(id, label, "working-health", "warn", "live DB schema drifts from schema.prisma", summary.map((l) => `  ${l}`));
+  }
+  return skip(id, label, "working-health", `prisma migrate diff errored: ${(res.stderr || res.stdout || "").trim().split("\n")[0] ?? "unknown"}`);
+}
+function checkPorts(portState) {
+  const id = "ports.liveness";
+  const label = "Allocated ports free";
+  if (!portState) return skip(id, label, "working-health", "no port-range resource");
+  if (portInUse(portState.base)) {
+    return mk(id, label, "working-health", "warn", `port ${portState.base} is bound \u2014 a dev server is likely still running in this orbit`);
+  }
+  return mk(id, label, "working-health", "pass", `port ${portState.base} free`);
+}
+async function checkBackupResidue(orbit, connError, pgState) {
+  const id = "db.backup-residue";
+  const label = "No leftover _backup_ tables";
+  if (!pgState) return skip(id, label, "working-health", "no orbit-pg resource");
+  if (!orbit) return skip(id, label, "working-health", `orbit DB unreachable: ${connError ?? "unknown"}`);
+  try {
+    const res = await orbit.query(
+      `SELECT table_name FROM information_schema.tables
+       WHERE table_schema = 'public' AND table_name LIKE '\\_backup\\_%'`
+    );
+    if (res.rows.length === 0) {
+      return mk(id, label, "working-health", "pass", "no migration sidecar tables left behind");
+    }
+    return mk(
+      id,
+      label,
+      "working-health",
+      "warn",
+      `${res.rows.length} leftover _backup_ table(s) \u2014 drop in a follow-up migration`,
+      res.rows.map((r) => `  ${r.table_name}`)
+    );
+  } catch (e) {
+    return skip(id, label, "working-health", `query failed: ${e.message}`);
+  }
+}
+function orbitDbUrl(pgState) {
+  const u = new URL(pgState.sourceUrl);
+  u.pathname = `/${pgState.dbName}`;
+  return u.toString();
+}
+async function userTables(client) {
+  const res = await client.query(
+    `SELECT table_name FROM information_schema.tables
+     WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+       AND table_name <> '_prisma_migrations'
+       AND table_name NOT LIKE '\\_backup\\_%'
+     ORDER BY table_name`
+  );
+  return res.rows.map((r) => r.table_name);
+}
+async function rowCount(client, table) {
+  try {
+    const res = await client.query(`SELECT count(*)::bigint AS c FROM "public".${quoteIdent(table)}`);
+    return Number(res.rows[0]?.c ?? 0);
+  } catch {
+    return null;
+  }
+}
+function quoteIdent(ident) {
+  return `"${ident.replace(/"/g, '""')}"`;
+}
+function gitTry(cwd, args) {
+  try {
+    const out = (0, import_node_child_process5.execFileSync)("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+    return { ok: true, out };
+  } catch (e) {
+    return { ok: false, err: e.message };
+  }
+}
+function refExists(cwd, ref) {
+  try {
+    (0, import_node_child_process5.execFileSync)("git", ["rev-parse", "--verify", ref], { cwd, stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function committedMigrations(worktreePath) {
+  const r = gitTry(worktreePath, ["ls-files", "prisma/migrations"]);
+  const out = /* @__PURE__ */ new Set();
+  if (!r.ok) return out;
+  for (const line of r.out.split("\n")) {
+    const m = /^prisma\/migrations\/([^/]+)\//.exec(line.trim());
+    if (m) out.add(m[1]);
+  }
+  return out;
+}
+function parseEnvKeys(path) {
+  const out = /* @__PURE__ */ new Map();
+  let text2;
+  try {
+    text2 = (0, import_node_fs6.readFileSync)(path, "utf-8");
+  } catch {
+    return out;
+  }
+  for (const line of text2.split(/\r?\n/)) {
+    const m = ENV_LINE_RE.exec(line);
+    if (!m) continue;
+    out.set(m[2], stripQuotes(m[4]));
+  }
+  return out;
+}
+function stripQuotes(raw) {
+  const trimmed = raw.replace(/\s+#.*$/, "").trim();
+  if (trimmed.length >= 2) {
+    const f = trimmed[0];
+    const l = trimmed[trimmed.length - 1];
+    if (f === '"' && l === '"' || f === "'" && l === "'") return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function rewrittenKeys(manifest) {
+  const out = /* @__PURE__ */ new Set();
+  for (const r of manifest.resources) {
+    const rewrite = r.config?.rewrite;
+    const env = rewrite?.env;
+    if (Array.isArray(env)) {
+      for (const k of env) if (typeof k === "string") out.add(k);
+    }
+  }
+  return out;
+}
+function urlPath(value) {
+  try {
+    return new URL(value).pathname;
+  } catch {
+    return null;
+  }
+}
+function findPgState(entry) {
+  for (const r of Object.values(entry.resources)) {
+    if (r.adapter === "orbit-pg") {
+      const s = r.state;
+      if (s && typeof s.dbName === "string" && typeof s.sourceUrl === "string") {
+        return {
+          dbName: s.dbName,
+          sourceUrl: s.sourceUrl,
+          version: typeof s.version === "number" ? s.version : 0,
+          strategy: typeof s.strategy === "string" ? s.strategy : "dump-restore",
+          envKeys: Array.isArray(s.envKeys) ? s.envKeys : ["DATABASE_URL"]
+        };
+      }
+    }
+  }
+  return null;
+}
+function findPortState(entry) {
+  for (const r of Object.values(entry.resources)) {
+    if (r.adapter === "builtin/port-range") {
+      const s = r.state;
+      if (s && typeof s.base === "number") {
+        return {
+          base: s.base,
+          stride: typeof s.stride === "number" ? s.stride : 10,
+          replace: typeof s.replace === "string" ? s.replace : ":3000",
+          envKeys: Array.isArray(s.envKeys) ? s.envKeys : []
+        };
+      }
+    }
+  }
+  return null;
+}
+function listSnapshots(dbName) {
+  if (!(0, import_node_fs6.existsSync)(SNAPSHOT_DIR2)) return [];
+  try {
+    return (0, import_node_fs6.readdirSync)(SNAPSHOT_DIR2).filter((f) => f.includes(`_to_${dbName}.`) || f.endsWith(`_${dbName}.sql.gz`));
+  } catch {
+    return [];
+  }
+}
+function portInUse(port) {
+  try {
+    const out = (0, import_node_child_process5.execFileSync)("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 500
+    }).trim();
+    return out.length > 0;
+  } catch {
+    return false;
+  }
+}
+function errMsg(e) {
+  const err2 = e;
+  return err2?.message || err2?.cause?.message || err2?.code || String(e);
+}
+function mk(id, label, section, status, summary, detail) {
+  return { id, label, section, status, summary, ...detail && detail.length > 0 ? { detail } : {} };
+}
+function skip(id, label, section, summary) {
+  return { id, label, section, status: "skip", summary };
+}
+var import_node_child_process5, import_node_fs6, import_node_os3, import_node_path5, import_pg2, Client2, SNAPSHOT_DIR2, ENV_LINE_RE;
+var init_cleanliness = __esm({
+  "src/server/orbit/cleanliness.ts"() {
+    "use strict";
+    import_node_child_process5 = require("node:child_process");
+    import_node_fs6 = require("node:fs");
+    import_node_os3 = require("node:os");
+    import_node_path5 = require("node:path");
+    import_pg2 = __toESM(require("pg"));
+    init_launch_kit_paths();
+    init_orchestrator();
+    ({ Client: Client2 } = import_pg2.default);
+    SNAPSHOT_DIR2 = (0, import_node_path5.join)((0, import_node_os3.homedir)(), LAUNCHSECURE_DIR, "orbit", "snapshots");
+    ENV_LINE_RE = /^(\s*)([A-Za-z_][A-Za-z0-9_]*)(\s*=\s*)(.*)$/;
+  }
+});
+
 // src/server/orbit/env-rewriter.ts
 function copyEnvFile(srcPath, dstPath) {
-  if (!(0, import_node_fs6.existsSync)(srcPath)) {
+  if (!(0, import_node_fs7.existsSync)(srcPath)) {
     throw new Error(`env source file not found: ${srcPath}`);
   }
-  (0, import_node_fs6.copyFileSync)(srcPath, dstPath);
+  (0, import_node_fs7.copyFileSync)(srcPath, dstPath);
 }
 function rewriteEnvFile(filePath, rewrites) {
-  if (!(0, import_node_fs6.existsSync)(filePath)) {
+  if (!(0, import_node_fs7.existsSync)(filePath)) {
     throw new Error(`env file not found for rewrite: ${filePath}`);
   }
-  const original = (0, import_node_fs6.readFileSync)(filePath, "utf-8");
+  const original = (0, import_node_fs7.readFileSync)(filePath, "utf-8");
   const lines = original.split(/\r?\n/);
   const result = { changed: [], unchanged: [], missing: [] };
   const touched = /* @__PURE__ */ new Set();
@@ -824,7 +1388,7 @@ function rewriteEnvFile(filePath, rewrites) {
     const [, indent, key, sep, rawValue] = m;
     if (!(key in rewrites)) return line;
     touched.add(key);
-    const { quote, inner } = stripQuotes(rawValue);
+    const { quote, inner } = stripQuotes2(rawValue);
     const transform = rewrites[key];
     const next2 = transform(inner, key);
     if (next2 === void 0 || next2 === inner) {
@@ -840,12 +1404,12 @@ function rewriteEnvFile(filePath, rewrites) {
   const next = out.join("\n");
   if (next !== original) {
     const tmp = `${filePath}.tmp.${process.pid}`;
-    (0, import_node_fs6.writeFileSync)(tmp, next, "utf-8");
-    (0, import_node_fs6.renameSync)(tmp, filePath);
+    (0, import_node_fs7.writeFileSync)(tmp, next, "utf-8");
+    (0, import_node_fs7.renameSync)(tmp, filePath);
   }
   return result;
 }
-function stripQuotes(raw) {
+function stripQuotes2(raw) {
   const trimmed = raw.replace(/\s+#.*$/, "");
   if (trimmed.length >= 2) {
     const first = trimmed[0];
@@ -856,11 +1420,11 @@ function stripQuotes(raw) {
   }
   return { quote: "", inner: trimmed };
 }
-var import_node_fs6, LINE_RE;
+var import_node_fs7, LINE_RE;
 var init_env_rewriter = __esm({
   "src/server/orbit/env-rewriter.ts"() {
     "use strict";
-    import_node_fs6 = require("node:fs");
+    import_node_fs7 = require("node:fs");
     LINE_RE = /^(\s*)([A-Za-z_][A-Za-z0-9_]*)(\s*=\s*)(.*)$/;
   }
 });
@@ -868,13 +1432,13 @@ var init_env_rewriter = __esm({
 // src/server/orbit/gates/build-lint.ts
 function finalize(checkPath, ctx, blockers, artifacts) {
   try {
-    (0, import_node_child_process5.execFileSync)("git", ["worktree", "remove", "--force", checkPath], {
+    (0, import_node_child_process6.execFileSync)("git", ["worktree", "remove", "--force", checkPath], {
       cwd: ctx.projectRoot,
       stdio: "ignore"
     });
   } catch {
     try {
-      (0, import_node_fs7.rmSync)(checkPath, { recursive: true, force: true });
+      (0, import_node_fs8.rmSync)(checkPath, { recursive: true, force: true });
     } catch {
     }
   }
@@ -887,9 +1451,9 @@ function finalize(checkPath, ctx, blockers, artifacts) {
   };
 }
 function detectInstallCmd(projectRoot) {
-  if ((0, import_node_fs7.existsSync)((0, import_node_path5.join)(projectRoot, "pnpm-lock.yaml"))) return "pnpm install --prefer-offline";
-  if ((0, import_node_fs7.existsSync)((0, import_node_path5.join)(projectRoot, "yarn.lock"))) return "yarn install --prefer-offline";
-  if ((0, import_node_fs7.existsSync)((0, import_node_path5.join)(projectRoot, "bun.lockb"))) return "bun install";
+  if ((0, import_node_fs8.existsSync)((0, import_node_path6.join)(projectRoot, "pnpm-lock.yaml"))) return "pnpm install --prefer-offline";
+  if ((0, import_node_fs8.existsSync)((0, import_node_path6.join)(projectRoot, "yarn.lock"))) return "yarn install --prefer-offline";
+  if ((0, import_node_fs8.existsSync)((0, import_node_path6.join)(projectRoot, "bun.lockb"))) return "bun install";
   return "npm install --prefer-offline --no-audit --no-fund";
 }
 function detectLintCmd(worktreePath) {
@@ -899,11 +1463,11 @@ function detectBuildCmd(worktreePath) {
   return detectScriptCmd(worktreePath, "build");
 }
 function detectScriptCmd(worktreePath, scriptName) {
-  const pkgPath = (0, import_node_path5.join)(worktreePath, "package.json");
-  if (!(0, import_node_fs7.existsSync)(pkgPath)) return null;
+  const pkgPath = (0, import_node_path6.join)(worktreePath, "package.json");
+  if (!(0, import_node_fs8.existsSync)(pkgPath)) return null;
   let pkg;
   try {
-    pkg = JSON.parse((0, import_node_fs7.readFileSync)(pkgPath, "utf-8"));
+    pkg = JSON.parse((0, import_node_fs8.readFileSync)(pkgPath, "utf-8"));
   } catch {
     return null;
   }
@@ -912,12 +1476,12 @@ function detectScriptCmd(worktreePath, scriptName) {
   return `${pm} run ${scriptName}`;
 }
 function loadOrbitEnv(orbitPath) {
-  const file = (0, import_node_path5.join)(orbitPath, ".env.local");
-  if (!(0, import_node_fs7.existsSync)(file)) return {};
+  const file = (0, import_node_path6.join)(orbitPath, ".env.local");
+  if (!(0, import_node_fs8.existsSync)(file)) return {};
   const out = {};
   let content;
   try {
-    content = (0, import_node_fs7.readFileSync)(file, "utf-8");
+    content = (0, import_node_fs8.readFileSync)(file, "utf-8");
   } catch {
     return {};
   }
@@ -933,9 +1497,9 @@ function loadOrbitEnv(orbitPath) {
   return out;
 }
 function detectPmFromLock(worktreePath) {
-  if ((0, import_node_fs7.existsSync)((0, import_node_path5.join)(worktreePath, "pnpm-lock.yaml"))) return "pnpm";
-  if ((0, import_node_fs7.existsSync)((0, import_node_path5.join)(worktreePath, "yarn.lock"))) return "yarn";
-  if ((0, import_node_fs7.existsSync)((0, import_node_path5.join)(worktreePath, "bun.lockb"))) return "bun";
+  if ((0, import_node_fs8.existsSync)((0, import_node_path6.join)(worktreePath, "pnpm-lock.yaml"))) return "pnpm";
+  if ((0, import_node_fs8.existsSync)((0, import_node_path6.join)(worktreePath, "yarn.lock"))) return "yarn";
+  if ((0, import_node_fs8.existsSync)((0, import_node_path6.join)(worktreePath, "bun.lockb"))) return "bun";
   return "npm";
 }
 function combineOutput(stdout, stderr) {
@@ -952,54 +1516,54 @@ ${err2}
 }
 function saveLog(slug, label, content) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const path = (0, import_node_path5.join)(LOG_DIR, `${ts}_${slug}_${label}.log`);
-  (0, import_node_fs7.writeFileSync)(path, content, "utf-8");
+  const path = (0, import_node_path6.join)(LOG_DIR, `${ts}_${slug}_${label}.log`);
+  (0, import_node_fs8.writeFileSync)(path, content, "utf-8");
   return path;
 }
 function shellQuote2(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
 }
-var import_node_child_process5, import_node_fs7, import_node_os3, import_node_path5, LOG_DIR, buildLintGate;
+var import_node_child_process6, import_node_fs8, import_node_os4, import_node_path6, LOG_DIR, buildLintGate;
 var init_build_lint = __esm({
   "src/server/orbit/gates/build-lint.ts"() {
     "use strict";
-    import_node_child_process5 = require("node:child_process");
-    import_node_fs7 = require("node:fs");
-    import_node_os3 = require("node:os");
-    import_node_path5 = require("node:path");
+    import_node_child_process6 = require("node:child_process");
+    import_node_fs8 = require("node:fs");
+    import_node_os4 = require("node:os");
+    import_node_path6 = require("node:path");
     init_launch_kit_paths();
-    LOG_DIR = (0, import_node_path5.join)((0, import_node_os3.homedir)(), LAUNCHSECURE_DIR, "orbit", "gate-logs");
+    LOG_DIR = (0, import_node_path6.join)((0, import_node_os4.homedir)(), LAUNCHSECURE_DIR, "orbit", "gate-logs");
     buildLintGate = {
       id: "builtin/build-lint",
       name: "Build + lint on merged state",
       async detect(ctx) {
         try {
-          (0, import_node_child_process5.execFileSync)("git", ["--version"], { cwd: ctx.projectRoot, stdio: "ignore" });
+          (0, import_node_child_process6.execFileSync)("git", ["--version"], { cwd: ctx.projectRoot, stdio: "ignore" });
         } catch {
           return { ok: false, reason: "git not available" };
         }
         return { ok: true };
       },
       async check(ctx, config) {
-        (0, import_node_fs7.mkdirSync)(LOG_DIR, { recursive: true });
-        const checkPath = (0, import_node_path5.join)(ctx.projectRoot, ".claude", "worktrees", `__orbit-check-${ctx.entry.slug}__`);
-        if ((0, import_node_fs7.existsSync)(checkPath)) {
+        (0, import_node_fs8.mkdirSync)(LOG_DIR, { recursive: true });
+        const checkPath = (0, import_node_path6.join)(ctx.projectRoot, ".claude", "worktrees", `__orbit-check-${ctx.entry.slug}__`);
+        if ((0, import_node_fs8.existsSync)(checkPath)) {
           try {
-            (0, import_node_child_process5.execFileSync)("git", ["worktree", "remove", "--force", checkPath], {
+            (0, import_node_child_process6.execFileSync)("git", ["worktree", "remove", "--force", checkPath], {
               cwd: ctx.projectRoot,
               stdio: "ignore"
             });
           } catch {
           }
           try {
-            (0, import_node_fs7.rmSync)(checkPath, { recursive: true, force: true });
+            (0, import_node_fs8.rmSync)(checkPath, { recursive: true, force: true });
           } catch {
           }
         }
         const blockers = [];
         const artifacts = {};
         try {
-          (0, import_node_child_process5.execFileSync)(
+          (0, import_node_child_process6.execFileSync)(
             "git",
             ["worktree", "add", "--detach", checkPath, ctx.entry.branch],
             { cwd: ctx.projectRoot, stdio: ["ignore", "pipe", "pipe"] }
@@ -1013,7 +1577,7 @@ var init_build_lint = __esm({
           };
         }
         try {
-          const mergeRes = (0, import_node_child_process5.spawnSync)(
+          const mergeRes = (0, import_node_child_process6.spawnSync)(
             "git",
             ["merge", "--no-commit", "--no-ff", ctx.target],
             { cwd: checkPath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }
@@ -1025,10 +1589,10 @@ var init_build_lint = __esm({
           }
           const orbitEnv = loadOrbitEnv(ctx.entry.path);
           const spawnEnv = { ...process.env, ...orbitEnv };
-          if (!(0, import_node_fs7.existsSync)((0, import_node_path5.join)(checkPath, "node_modules"))) {
+          if (!(0, import_node_fs8.existsSync)((0, import_node_path6.join)(checkPath, "node_modules"))) {
             const installCmd = config.installCmd ?? detectInstallCmd(ctx.projectRoot);
             ctx.logger.step(`[build-lint] ${installCmd}`);
-            const installRes = (0, import_node_child_process5.spawnSync)("bash", ["-c", `cd ${shellQuote2(checkPath)} && ${installCmd}`], {
+            const installRes = (0, import_node_child_process6.spawnSync)("bash", ["-c", `cd ${shellQuote2(checkPath)} && ${installCmd}`], {
               stdio: ["ignore", "pipe", "pipe"],
               encoding: "utf-8",
               env: spawnEnv
@@ -1040,10 +1604,10 @@ var init_build_lint = __esm({
               return finalize(checkPath, ctx, blockers, artifacts);
             }
           }
-          if ((0, import_node_fs7.existsSync)((0, import_node_path5.join)(checkPath, "prisma", "schema.prisma"))) {
+          if ((0, import_node_fs8.existsSync)((0, import_node_path6.join)(checkPath, "prisma", "schema.prisma"))) {
             const prismaCmd = "npx prisma generate";
             ctx.logger.step(`[build-lint] ${prismaCmd}`);
-            const prismaRes = (0, import_node_child_process5.spawnSync)("bash", ["-c", `cd ${shellQuote2(checkPath)} && ${prismaCmd}`], {
+            const prismaRes = (0, import_node_child_process6.spawnSync)("bash", ["-c", `cd ${shellQuote2(checkPath)} && ${prismaCmd}`], {
               stdio: ["ignore", "pipe", "pipe"],
               encoding: "utf-8",
               env: spawnEnv
@@ -1063,7 +1627,7 @@ var init_build_lint = __esm({
           if (tscMode !== false) {
             const tscCmd = typeof tscMode === "string" ? tscMode : "npx tsc --noEmit";
             ctx.logger.step(`[build-lint] ${tscCmd}`);
-            const tscRes = (0, import_node_child_process5.spawnSync)("bash", ["-c", `cd ${shellQuote2(checkPath)} && ${tscCmd}`], {
+            const tscRes = (0, import_node_child_process6.spawnSync)("bash", ["-c", `cd ${shellQuote2(checkPath)} && ${tscCmd}`], {
               stdio: ["ignore", "pipe", "pipe"],
               encoding: "utf-8",
               env: spawnEnv
@@ -1079,7 +1643,7 @@ var init_build_lint = __esm({
             const lintCmd = typeof lintMode === "string" ? lintMode : detectLintCmd(checkPath);
             if (lintCmd) {
               ctx.logger.step(`[build-lint] ${lintCmd}`);
-              const lintRes = (0, import_node_child_process5.spawnSync)("bash", ["-c", `cd ${shellQuote2(checkPath)} && ${lintCmd}`], {
+              const lintRes = (0, import_node_child_process6.spawnSync)("bash", ["-c", `cd ${shellQuote2(checkPath)} && ${lintCmd}`], {
                 stdio: ["ignore", "pipe", "pipe"],
                 encoding: "utf-8",
                 env: spawnEnv
@@ -1098,7 +1662,7 @@ var init_build_lint = __esm({
             const buildCmd = typeof buildMode === "string" ? buildMode : detectBuildCmd(checkPath);
             if (buildCmd) {
               ctx.logger.step(`[build-lint] ${buildCmd}`);
-              const buildRes = (0, import_node_child_process5.spawnSync)("bash", ["-c", `cd ${shellQuote2(checkPath)} && ${buildCmd}`], {
+              const buildRes = (0, import_node_child_process6.spawnSync)("bash", ["-c", `cd ${shellQuote2(checkPath)} && ${buildCmd}`], {
                 stdio: ["ignore", "pipe", "pipe"],
                 encoding: "utf-8",
                 env: spawnEnv
@@ -1123,21 +1687,21 @@ var init_build_lint = __esm({
 });
 
 // src/server/orbit/gates/clean-tree.ts
-var import_node_child_process6, import_node_fs8, cleanTreeGate;
+var import_node_child_process7, import_node_fs9, cleanTreeGate;
 var init_clean_tree = __esm({
   "src/server/orbit/gates/clean-tree.ts"() {
     "use strict";
-    import_node_child_process6 = require("node:child_process");
-    import_node_fs8 = require("node:fs");
+    import_node_child_process7 = require("node:child_process");
+    import_node_fs9 = require("node:fs");
     cleanTreeGate = {
       id: "builtin/clean-tree",
       name: "Orbit worktree has no uncommitted changes",
       async detect(ctx) {
-        if (!(0, import_node_fs8.existsSync)(ctx.entry.path)) {
+        if (!(0, import_node_fs9.existsSync)(ctx.entry.path)) {
           return { ok: false, reason: `orbit worktree path missing: ${ctx.entry.path}` };
         }
         try {
-          (0, import_node_child_process6.execFileSync)("git", ["rev-parse", "--is-inside-work-tree"], {
+          (0, import_node_child_process7.execFileSync)("git", ["rev-parse", "--is-inside-work-tree"], {
             cwd: ctx.entry.path,
             stdio: "ignore"
           });
@@ -1149,7 +1713,7 @@ var init_clean_tree = __esm({
       async check(ctx, _config) {
         let output;
         try {
-          output = (0, import_node_child_process6.execFileSync)("git", ["status", "--porcelain"], {
+          output = (0, import_node_child_process7.execFileSync)("git", ["status", "--porcelain"], {
             cwd: ctx.entry.path,
             encoding: "utf-8",
             stdio: ["ignore", "pipe", "pipe"]
@@ -1182,25 +1746,25 @@ var init_clean_tree = __esm({
 });
 
 // src/server/orbit/gates/mergeability.ts
-function refExists(cwd, ref) {
+function refExists2(cwd, ref) {
   try {
-    (0, import_node_child_process7.execFileSync)("git", ["rev-parse", "--verify", ref], { cwd, stdio: "ignore" });
+    (0, import_node_child_process8.execFileSync)("git", ["rev-parse", "--verify", ref], { cwd, stdio: "ignore" });
     return true;
   } catch {
     return false;
   }
 }
-var import_node_child_process7, mergeabilityGate;
+var import_node_child_process8, mergeabilityGate;
 var init_mergeability = __esm({
   "src/server/orbit/gates/mergeability.ts"() {
     "use strict";
-    import_node_child_process7 = require("node:child_process");
+    import_node_child_process8 = require("node:child_process");
     mergeabilityGate = {
       id: "builtin/mergeability",
       name: "Textual mergeability (git merge-tree)",
       async detect(ctx) {
         try {
-          (0, import_node_child_process7.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
+          (0, import_node_child_process8.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
             cwd: ctx.projectRoot,
             stdio: "ignore"
           });
@@ -1211,10 +1775,10 @@ var init_mergeability = __esm({
       },
       async check(ctx, _config) {
         const blockers = [];
-        if (!refExists(ctx.projectRoot, ctx.target)) {
+        if (!refExists2(ctx.projectRoot, ctx.target)) {
           blockers.push(`target ref "${ctx.target}" does not exist`);
         }
-        if (!refExists(ctx.projectRoot, ctx.entry.branch)) {
+        if (!refExists2(ctx.projectRoot, ctx.entry.branch)) {
           blockers.push(`orbit branch "${ctx.entry.branch}" does not exist`);
         }
         if (blockers.length > 0) {
@@ -1223,7 +1787,7 @@ var init_mergeability = __esm({
         let stdout = "";
         let exitCode = 0;
         try {
-          stdout = (0, import_node_child_process7.execFileSync)(
+          stdout = (0, import_node_child_process8.execFileSync)(
             "git",
             ["merge-tree", "--write-tree", "--messages", ctx.target, ctx.entry.branch],
             { cwd: ctx.projectRoot, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }
@@ -1282,17 +1846,17 @@ var init_gate_registry = __esm({
 // src/server/orbit/gate-runner.ts
 async function runMergeGates(manifest, ctx, options = {}) {
   const refs = manifest.gates?.merge ?? DEFAULT_GATES;
-  const skip = new Set(options.skipGates ?? []);
-  if (skip.size > 0) {
+  const skip2 = new Set(options.skipGates ?? []);
+  if (skip2.size > 0) {
     const declared = new Set(refs.map((r) => r.adapter));
-    for (const id of skip) {
+    for (const id of skip2) {
       if (!declared.has(id)) {
         ctx.logger.warn(
           `--skip-gate "${id}" does not match any declared gate (declared: ${[...declared].join(", ")})`
         );
       }
     }
-    const blockedRequired = refs.filter((r) => r.required && skip.has(r.adapter)).map((r) => r.adapter);
+    const blockedRequired = refs.filter((r) => r.required && skip2.has(r.adapter)).map((r) => r.adapter);
     if (blockedRequired.length > 0) {
       throw new Error(
         `cannot skip required gate(s): ${blockedRequired.join(", ")}. Remove "required": true from orbit.json if you really need to bypass.`
@@ -1302,7 +1866,7 @@ async function runMergeGates(manifest, ctx, options = {}) {
   const start = Date.now();
   const results = [];
   for (const ref of refs) {
-    if (skip.has(ref.adapter)) {
+    if (skip2.has(ref.adapter)) {
       ctx.logger.info(`[gate] skip ${ref.adapter} (--skip-gate)`);
       continue;
     }
@@ -1361,21 +1925,21 @@ var init_gate_runner = __esm({
 
 // src/server/orbit/manifest.ts
 function findManifestPath(projectRoot) {
-  return (0, import_node_path6.join)(projectRoot, DEFAULT_MANIFEST_FILENAME);
+  return (0, import_node_path7.join)(projectRoot, DEFAULT_MANIFEST_FILENAME);
 }
 function manifestExists(projectRoot) {
-  return (0, import_node_fs9.existsSync)(findManifestPath(projectRoot));
+  return (0, import_node_fs10.existsSync)(findManifestPath(projectRoot));
 }
 function loadManifest(projectRoot) {
   const path = findManifestPath(projectRoot);
-  if (!(0, import_node_fs9.existsSync)(path)) {
+  if (!(0, import_node_fs10.existsSync)(path)) {
     throw new Error(
       `orbit.json not found at ${path}. Run \`launch-orbit init\` to create one.`
     );
   }
   let raw;
   try {
-    raw = JSON.parse((0, import_node_fs9.readFileSync)(path, "utf-8"));
+    raw = JSON.parse((0, import_node_fs10.readFileSync)(path, "utf-8"));
   } catch (e) {
     throw new Error(`orbit.json is not valid JSON: ${e.message}`);
   }
@@ -1520,16 +2084,83 @@ function isRecord(x) {
 function err(msg, sourcePath) {
   return new Error(`orbit.json (${sourcePath}): ${msg}`);
 }
-var import_node_fs9, import_node_path6, DEFAULT_MANIFEST_FILENAME;
+var import_node_fs10, import_node_path7, DEFAULT_MANIFEST_FILENAME;
 var init_manifest = __esm({
   "src/server/orbit/manifest.ts"() {
     "use strict";
-    import_node_fs9 = require("node:fs");
-    import_node_path6 = require("node:path");
+    import_node_fs10 = require("node:fs");
+    import_node_path7 = require("node:path");
     DEFAULT_MANIFEST_FILENAME = "orbit.json";
   }
 });
 
+// src/server/orbit/active.ts
+function anchorPaths(projectRoot) {
+  const dir = (0, import_node_path8.join)(projectRoot, LAUNCHSECURE_DIR, "orbit");
+  return { dir, current: (0, import_node_path8.join)(dir, "current"), activeJson: (0, import_node_path8.join)(dir, "active.json") };
+}
+function present(p) {
+  try {
+    (0, import_node_fs11.lstatSync)(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function setActiveOrbit(entry, envFileName) {
+  const paths = anchorPaths(entry.projectRoot);
+  (0, import_node_fs11.mkdirSync)(paths.dir, { recursive: true });
+  const tmpLink = `${paths.current}.tmp.${process.pid}`;
+  if (present(tmpLink)) (0, import_node_fs11.rmSync)(tmpLink, { force: true });
+  (0, import_node_fs11.symlinkSync)(entry.path, tmpLink);
+  (0, import_node_fs11.renameSync)(tmpLink, paths.current);
+  const active = {
+    slug: entry.slug,
+    branch: entry.branch,
+    path: entry.path,
+    envFile: (0, import_node_path8.join)(entry.path, envFileName),
+    projectRoot: entry.projectRoot,
+    anchor: paths.current,
+    switchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const tmpJson = `${paths.activeJson}.tmp.${process.pid}`;
+  (0, import_node_fs11.writeFileSync)(tmpJson, JSON.stringify(active, null, 2) + "\n", "utf-8");
+  (0, import_node_fs11.renameSync)(tmpJson, paths.activeJson);
+  return active;
+}
+function clearActiveOrbit(projectRoot) {
+  const paths = anchorPaths(projectRoot);
+  let cleared = false;
+  for (const p of [paths.current, paths.activeJson]) {
+    if (present(p)) {
+      try {
+        (0, import_node_fs11.rmSync)(p, { force: true });
+        cleared = true;
+      } catch {
+      }
+    }
+  }
+  return cleared;
+}
+function readActiveOrbit(projectRoot) {
+  const { activeJson } = anchorPaths(projectRoot);
+  if (!present(activeJson)) return null;
+  try {
+    return JSON.parse((0, import_node_fs11.readFileSync)(activeJson, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+var import_node_fs11, import_node_path8;
+var init_active = __esm({
+  "src/server/orbit/active.ts"() {
+    "use strict";
+    import_node_fs11 = require("node:fs");
+    import_node_path8 = require("node:path");
+    init_launch_kit_paths();
+  }
+});
+
 // src/server/orbit/slug.ts
 function slugify(branch) {
   let s = branch.toLowerCase();
@@ -1556,7 +2187,7 @@ async function create(opts) {
   const envFileName = opts.envFileName ?? manifest.envFile ?? DEFAULT_ENV_FILE;
   const ctx = {
     projectRoot: opts.projectRoot,
-    manifestPath: (0, import_node_path7.join)(opts.projectRoot, "orbit.json"),
+    manifestPath: (0, import_node_path9.join)(opts.projectRoot, "orbit.json"),
     manifest,
     logger: opts.logger,
     envFileName
@@ -1610,13 +2241,13 @@ async function create(opts) {
         Object.assign(rewriteFns, adapter.envRewrites(state, ctx));
       }
     }
-    const srcEnv = (0, import_node_path7.join)(opts.projectRoot, envFileName);
-    const dstEnv = (0, import_node_path7.join)(worktreeState.path, envFileName);
-    if ((0, import_node_fs10.existsSync)(srcEnv) && !(0, import_node_fs10.existsSync)(dstEnv)) {
+    const srcEnv = (0, import_node_path9.join)(opts.projectRoot, envFileName);
+    const dstEnv = (0, import_node_path9.join)(worktreeState.path, envFileName);
+    if ((0, import_node_fs12.existsSync)(srcEnv) && !(0, import_node_fs12.existsSync)(dstEnv)) {
       opts.logger.step(`copy ${envFileName} into worktree`);
       copyEnvFile(srcEnv, dstEnv);
     }
-    if ((0, import_node_fs10.existsSync)(dstEnv) && Object.keys(rewriteFns).length > 0) {
+    if ((0, import_node_fs12.existsSync)(dstEnv) && Object.keys(rewriteFns).length > 0) {
       opts.logger.step(`rewrite ${envFileName} (${Object.keys(rewriteFns).join(", ")})`);
       const r = rewriteEnvFile(dstEnv, rewriteFns);
       if (r.missing.length > 0) {
@@ -1636,8 +2267,8 @@ async function create(opts) {
     opts.logger.ok(`registered ${slug}`);
     try {
       opts.logger.step(`generate chart graph for worktree`);
-      const chartEntry = (0, import_node_path7.join)(__dirname, "graph-mcp-entry.js");
-      const result = (0, import_node_child_process8.spawnSync)(
+      const chartEntry = (0, import_node_path9.join)(__dirname, "graph-mcp-entry.js");
+      const result = (0, import_node_child_process9.spawnSync)(
         process.execPath,
         [chartEntry, "generate"],
         {
@@ -1685,10 +2316,23 @@ async function drop(opts) {
   if (!entry) {
     return { slug, backups: {}, freed: {} };
   }
+  if (!opts.force) {
+    const report = await check({ branch: opts.branch, projectRoot: opts.projectRoot, logger: opts.logger, base: opts.base });
+    if (!report.dropSafe) {
+      const blockers = report.checks.filter(
+        (c) => c.section === "drop-safety" && (c.status === "fail" || c.status === "warn")
+      );
+      throw new Error(
+        `refusing to drop "${slug}" \u2014 not drop-safe:
+` + blockers.map((b) => `  \u2717 ${b.label}: ${b.summary}`).join("\n") + `
+Resolve the above, or re-run with --force to drop anyway (work will be lost).`
+      );
+    }
+  }
   const manifest = loadManifestOrThrow(opts.projectRoot);
   const ctx = {
     projectRoot: opts.projectRoot,
-    manifestPath: (0, import_node_path7.join)(opts.projectRoot, "orbit.json"),
+    manifestPath: (0, import_node_path9.join)(opts.projectRoot, "orbit.json"),
     manifest,
     logger: opts.logger,
     envFileName: manifest.envFile ?? DEFAULT_ENV_FILE
@@ -1709,7 +2353,7 @@ async function drop(opts) {
     if (result.backupPath) backups[ref.name] = result.backupPath;
     freed[ref.name] = state.state;
   }
-  if ((0, import_node_fs10.existsSync)(entry.path)) {
+  if ((0, import_node_fs12.existsSync)(entry.path)) {
     const blockers = findBlockingPids(entry.path);
     if (blockers.length > 0) {
       opts.logger.warn(`${blockers.length} process(es) holding files in worktree \u2014 terminating:`);
@@ -1728,15 +2372,19 @@ async function drop(opts) {
   } catch (e) {
     opts.logger.warn(`worktree remove failed (continuing anyway): ${e.message}`);
   }
-  if ((0, import_node_fs10.existsSync)(entry.path)) {
+  if ((0, import_node_fs12.existsSync)(entry.path)) {
     opts.logger.step(`remove leftover dir at ${entry.path}`);
     try {
-      (0, import_node_fs10.rmSync)(entry.path, { recursive: true, force: true });
+      (0, import_node_fs12.rmSync)(entry.path, { recursive: true, force: true });
     } catch (e) {
       opts.logger.warn(`leftover dir cleanup failed: ${e.message}`);
     }
   }
   await deregisterWorktree(slug);
+  if (readActiveOrbit(opts.projectRoot)?.slug === slug) {
+    clearActiveOrbit(opts.projectRoot);
+    opts.logger.step("cleared active-orbit anchor (current)");
+  }
   opts.logger.ok(`dropped ${slug}`);
   return { slug, backups, freed };
 }
@@ -1753,12 +2401,19 @@ function switchTo(opts) {
   const slug = slugify(opts.branch);
   const entry = lookupWorktree(slug);
   if (!entry) throw new Error(`no orbit registered for branch "${opts.branch}" (slug ${slug})`);
+  const active = setActiveOrbit(entry, DEFAULT_ENV_FILE);
   return {
     path: entry.path,
-    envFile: (0, import_node_path7.join)(entry.path, DEFAULT_ENV_FILE),
+    envFile: active.envFile,
+    anchor: active.anchor,
+    activeJson: anchorPaths(entry.projectRoot).activeJson,
+    nextAction: `cd "${active.anchor}"`,
     entry
   };
 }
+function deactivate(opts) {
+  return { cleared: clearActiveOrbit(opts.projectRoot), projectRoot: opts.projectRoot };
+}
 function doctor() {
   const issues = [];
   const trackedByRoot = /* @__PURE__ */ new Map();
@@ -1767,7 +2422,7 @@ function doctor() {
     if (s) return s;
     s = /* @__PURE__ */ new Set();
     try {
-      const out = (0, import_node_child_process8.execFileSync)("git", ["worktree", "list", "--porcelain"], {
+      const out = (0, import_node_child_process9.execFileSync)("git", ["worktree", "list", "--porcelain"], {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "ignore"]
@@ -1781,7 +2436,7 @@ function doctor() {
     return s;
   };
   for (const w of listWorktrees()) {
-    if (!(0, import_node_fs10.existsSync)(w.path)) {
+    if (!(0, import_node_fs12.existsSync)(w.path)) {
       issues.push({ kind: "missing-worktree", slug: w.slug, detail: `path ${w.path} does not exist` });
       continue;
     }
@@ -1795,10 +2450,47 @@ function doctor() {
   }
   return issues;
 }
+async function check(opts) {
+  const slug = slugify(opts.branch);
+  const entry = lookupWorktree(slug);
+  if (!entry) throw new Error(`no orbit registered for branch "${opts.branch}" (slug ${slug})`);
+  const manifest = loadManifestOrThrow(opts.projectRoot);
+  const base = opts.base ?? resolveBaseBranch(opts.projectRoot);
+  return runCleanlinessReport({ entry, manifest, base, deep: opts.deep, logger: opts.logger });
+}
+async function checkAll(opts) {
+  const manifest = loadManifestOrThrow(opts.projectRoot);
+  const base = opts.base ?? resolveBaseBranch(opts.projectRoot);
+  const mine = listWorktrees().filter((w) => w.projectRoot === opts.projectRoot);
+  const reports = [];
+  for (const entry of mine) {
+    reports.push(await runCleanlinessReport({ entry, manifest, base, deep: opts.deep, logger: opts.logger }));
+  }
+  return reports;
+}
+function resolveBaseBranch(projectRoot) {
+  try {
+    const head = (0, import_node_child_process9.execFileSync)("git", ["symbolic-ref", "refs/remotes/origin/HEAD", "--short"], {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (head) return head.replace(/^origin\//, "");
+  } catch {
+  }
+  for (const candidate of ["origin/main", "origin/master", "main", "master"]) {
+    try {
+      (0, import_node_child_process9.execFileSync)("git", ["rev-parse", "--verify", candidate], { cwd: projectRoot, stdio: "ignore" });
+      return candidate.replace(/^origin\//, "");
+    } catch {
+    }
+  }
+  return "main";
+}
 function findBlockingPids(path) {
   let out;
   try {
-    out = (0, import_node_child_process8.execFileSync)("lsof", ["-F", "pc", "+D", path], {
+    out = (0, import_node_child_process9.execFileSync)("lsof", ["-F", "pc", "+D", path], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -1866,22 +2558,22 @@ async function checkMergeable(opts) {
 async function merge(opts) {
   const start = Date.now();
   const cleanup = opts.cleanup ?? "full";
-  const check = await checkMergeable({
+  const check2 = await checkMergeable({
     branch: opts.branch,
     target: opts.target,
     skipGates: opts.skipGates,
     projectRoot: opts.projectRoot,
     logger: opts.logger
   });
-  if (!check.passed) {
-    const blockers = check.gates.flatMap((g) => g.blockers);
+  if (!check2.passed) {
+    const blockers = check2.gates.flatMap((g) => g.blockers);
     opts.logger.error(`gates blocked the merge \u2014 fix the above and retry`);
     return {
-      slug: check.slug,
-      branch: check.branch,
+      slug: check2.slug,
+      branch: check2.branch,
       target: opts.target,
       merged: false,
-      gates: check.gates,
+      gates: check2.gates,
       cleanedUp: false,
       blockedBy: blockers,
       durationMs: Date.now() - start
@@ -1890,70 +2582,72 @@ async function merge(opts) {
   const targetWorktree = findWorktreeFor(opts.projectRoot, opts.target);
   if (!targetWorktree) {
     return {
-      slug: check.slug,
-      branch: check.branch,
+      slug: check2.slug,
+      branch: check2.branch,
       target: opts.target,
       merged: false,
-      gates: check.gates,
+      gates: check2.gates,
       cleanedUp: false,
       blockedBy: [`no worktree currently has "${opts.target}" checked out \u2014 check it out in main and retry`],
       durationMs: Date.now() - start
     };
   }
-  opts.logger.step(`git merge --ff-only ${check.branch} (in ${targetWorktree})`);
-  const mergeRes = (0, import_node_child_process8.spawnSync)(
+  opts.logger.step(`git merge --ff-only ${check2.branch} (in ${targetWorktree})`);
+  const mergeRes = (0, import_node_child_process9.spawnSync)(
     "git",
-    ["merge", "--ff-only", check.branch],
+    ["merge", "--ff-only", check2.branch],
     { cwd: targetWorktree, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }
   );
   if (mergeRes.status !== 0) {
     const stderr = (mergeRes.stderr ?? "").toString().trim();
     opts.logger.warn(`ff-only failed (${stderr.split("\n")[0]}); attempting non-ff merge`);
-    const merge2 = (0, import_node_child_process8.spawnSync)(
+    const merge2 = (0, import_node_child_process9.spawnSync)(
       "git",
-      ["merge", "--no-ff", "-m", `Merge orbit ${check.slug} into ${opts.target}`, check.branch],
+      ["merge", "--no-ff", "-m", `Merge orbit ${check2.slug} into ${opts.target}`, check2.branch],
       { cwd: targetWorktree, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }
     );
     if (merge2.status !== 0) {
       const detail = (merge2.stderr ?? merge2.stdout ?? "").toString().trim();
       return {
-        slug: check.slug,
-        branch: check.branch,
+        slug: check2.slug,
+        branch: check2.branch,
         target: opts.target,
         merged: false,
-        gates: check.gates,
+        gates: check2.gates,
         cleanedUp: false,
         blockedBy: [`git merge failed despite passing gates: ${detail.split("\n")[0] ?? "unknown"}`],
         durationMs: Date.now() - start
       };
     }
   }
-  const mergeSha = (0, import_node_child_process8.execFileSync)("git", ["rev-parse", "HEAD"], {
+  const mergeSha = (0, import_node_child_process9.execFileSync)("git", ["rev-parse", "HEAD"], {
     cwd: targetWorktree,
     encoding: "utf-8"
   }).trim();
-  opts.logger.ok(`merged ${check.branch} \u2192 ${opts.target} (${mergeSha.slice(0, 7)})`);
+  opts.logger.ok(`merged ${check2.branch} \u2192 ${opts.target} (${mergeSha.slice(0, 7)})`);
   let backupPath;
   let cleanedUp = false;
   if (cleanup === "full") {
-    opts.logger.step(`cleanup: dropping orbit ${check.slug}`);
+    opts.logger.step(`cleanup: dropping orbit ${check2.slug}`);
     const dropResult = await drop({
       branch: opts.branch,
       backup: true,
+      force: true,
+      // already gated by the merge gates above
       projectRoot: opts.projectRoot,
       logger: opts.logger
     });
     backupPath = dropResult.backups.db;
     cleanedUp = true;
-    opts.logger.ok(`cleaned up ${check.slug} (backup: ${backupPath ?? "n/a"})`);
+    opts.logger.ok(`cleaned up ${check2.slug} (backup: ${backupPath ?? "n/a"})`);
   }
   return {
-    slug: check.slug,
-    branch: check.branch,
+    slug: check2.slug,
+    branch: check2.branch,
     target: opts.target,
     merged: true,
     mergeSha,
-    gates: check.gates,
+    gates: check2.gates,
     cleanedUp,
     backupPath,
     durationMs: Date.now() - start
@@ -1961,7 +2655,7 @@ async function merge(opts) {
 }
 function findWorktreeFor(projectRoot, branch) {
   try {
-    const out = (0, import_node_child_process8.execFileSync)("git", ["worktree", "list", "--porcelain"], {
+    const out = (0, import_node_child_process9.execFileSync)("git", ["worktree", "list", "--porcelain"], {
       cwd: projectRoot,
       encoding: "utf-8"
     });
@@ -2018,18 +2712,20 @@ function formatAge(iso) {
   const d = Math.floor(h / 24);
   return `${d}d`;
 }
-var import_node_child_process8, import_node_fs10, import_node_path7, DEFAULT_ENV_FILE;
+var import_node_child_process9, import_node_fs12, import_node_path9, DEFAULT_ENV_FILE;
 var init_orchestrator = __esm({
   "src/server/orbit/orchestrator.ts"() {
     "use strict";
-    import_node_child_process8 = require("node:child_process");
-    import_node_fs10 = require("node:fs");
-    import_node_path7 = require("node:path");
+    import_node_child_process9 = require("node:child_process");
+    import_node_fs12 = require("node:fs");
+    import_node_path9 = require("node:path");
     init_adapter_registry();
+    init_cleanliness();
     init_env_rewriter();
     init_gate_runner();
     init_manifest();
     init_registry();
+    init_active();
     init_slug();
     DEFAULT_ENV_FILE = ".env.local";
   }
@@ -2093,16 +2789,23 @@ async function handleTool(name, args) {
       const result = switchTo({ branch, projectRoot });
       return text({
         slug: result.entry.slug,
+        branch: result.entry.branch,
+        anchor: result.anchor,
         path: result.path,
         envFile: result.envFile,
-        nextAction: `cd ${result.path}`
+        nextAction: result.nextAction
       });
     }
+    case "orbit.deactivate": {
+      return text(deactivate({ projectRoot }));
+    }
     case "orbit.drop": {
       const branch = String(args.branch ?? "");
       if (!branch) return text({ error: "branch is required" });
       const backup = args.backup === false ? false : true;
-      const result = await drop({ branch, backup, projectRoot, logger });
+      const force = args.force === true;
+      const base = args.base;
+      const result = await drop({ branch, backup, force, base, projectRoot, logger });
       return text(result);
     }
     case "orbit.doctor": {
@@ -2118,6 +2821,17 @@ async function handleTool(name, args) {
       const result = await checkMergeable({ branch, target, skipGates, projectRoot, logger });
       return text(result);
     }
+    case "orbit.check": {
+      const all = args.all === true;
+      const base = args.base;
+      const deep = args.deep === true;
+      if (all) {
+        return text(await checkAll({ projectRoot, logger, base, deep }));
+      }
+      const branch = String(args.branch ?? "");
+      if (!branch) return text({ error: "branch is required (or pass all: true)" });
+      return text(await check({ branch, projectRoot, logger, base, deep }));
+    }
     case "orbit.merge": {
       const branch = String(args.branch ?? "");
       const target = String(args.target ?? "");
@@ -2256,23 +2970,30 @@ var init_orbit_mcp = __esm({
       },
       {
         name: "orbit.switch",
-        description: "Look up the path + env file of an existing orbit by branch name. Does NOT change any shell \u2014 the caller is expected to `cd` into the returned path. Useful for agents that need to operate inside an already-created orbit.",
+        description: 'Activate an orbit by branch name. Atomically repoints the stable anchor <project>/.launchsecure/orbit/current at the orbit\'s worktree and records active.json, then returns `anchor` (the current/ path) + `nextAction`. AFTER calling this, operate on the anchor: Read/Edit/Write under `.launchsecure/orbit/current/<path>`, pass `project_root: ".launchsecure/orbit/current"` to chart, and run the returned `nextAction` (cd into current) so commands execute in the orbit. Switching to a different orbit just repoints the anchor; re-run nextAction afterwards.',
         inputSchema: {
           type: "object",
           properties: {
-            branch: { type: "string", description: "Branch name to look up." }
+            branch: { type: "string", description: "Branch name of the orbit to activate." }
           },
           required: ["branch"]
         }
       },
+      {
+        name: "orbit.deactivate",
+        description: "Clear the active-orbit anchor for this project \u2014 removes <project>/.launchsecure/orbit/current and active.json so no orbit is active. Use when you're done working in an orbit and want subsequent work to target the main checkout. No-op if nothing is active.",
+        inputSchema: { type: "object", properties: {} }
+      },
       {
         name: "orbit.drop",
-        description: "Tear down an orbit: backup the database (default true), drop the database, terminate any process holding files inside the worktree (chart/beacon MCPs, dev servers \u2014 via lsof+SIGTERM), remove the worktree, sweep any leftover on-disk dir, deregister. Idempotent: safe to retry on a partial state (e.g. git already removed the worktree but the registry still claims it). Returns { slug, backups, freed }.",
+        description: "Tear down an orbit: backup the database (default true), drop the database, terminate any process holding files inside the worktree (chart/beacon MCPs, dev servers \u2014 via lsof+SIGTERM), remove the worktree, sweep any leftover on-disk dir, deregister. Idempotent: safe to retry on a partial state (e.g. git already removed the worktree but the registry still claims it).\n\nDrop-safety guard: by default this runs the drop-safety checks first and THROWS if the orbit still has uncommitted/unmerged work or orbit-only DB data \u2014 pass `force: true` to override (work will be lost). Returns { slug, backups, freed }.",
         inputSchema: {
           type: "object",
           properties: {
             branch: { type: "string", description: "Branch name to drop." },
-            backup: { type: "boolean", description: "Whether to pg_dump first (default true)." }
+            backup: { type: "boolean", description: "Whether to pg_dump first (default true)." },
+            force: { type: "boolean", description: "Bypass the drop-safety guard (default false)." },
+            base: { type: "string", description: "Base branch for the guard's merged-check (default: detected base)." }
           },
           required: ["branch"]
         }
@@ -2299,6 +3020,19 @@ var init_orbit_mcp = __esm({
           required: ["branch", "target"]
         }
       },
+      {
+        name: "orbit.check",
+        description: "Cleanliness report for a registered orbit \u2014 two verdicts in one pass:\n  \u2022 DROP-SAFE: can this orbit be deleted without losing work? (working tree clean, branch merged into base, no orbit-only DB rows vs source, no applied-but-uncommitted migrations, fork snapshot present)\n  \u2022 HEALTHY: is it in a sane state to keep working in? (registry consistent, env parity with the main repo, forked DB reachable + version match, ports free, no leftover _backup_ tables; with `deep:true` also a prisma schema-drift check).\n\nAll checks are read-only. Pass `all: true` (omit branch) to sweep every orbit registered for this repo. `base` overrides the branch the merged-check measures against (default: detected base branch). DB checks use the orbit's recorded sourceUrl \u2014 no env needed; they skip gracefully if the DB is unreachable.\n\nReturns one report (or an array with all:true): { slug, branch, base, dropSafe, healthy, checks: [{ id, label, section, status: pass|warn|fail|skip, summary, detail }], durationMs }.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            branch: { type: "string", description: "Orbit branch to check. Omit when all=true." },
+            all: { type: "boolean", description: "Check every orbit registered for this repo instead of one branch." },
+            base: { type: "string", description: "Branch the merged-check measures against (default: detected base)." },
+            deep: { type: "boolean", description: "Also run the prisma schema-drift check (slower)." }
+          }
+        }
+      },
       {
         name: "orbit.merge",
         description: 'Run gates, and if all pass, perform the merge into the target branch. Default cleanup behavior is `full` \u2014 after a successful merge, the orbit is dropped (DB pg_dump\'d, then DROP DATABASE; worktree removed; branch deleted). Use cleanup="none" to keep the orbit around post-merge.\n\nPass `skipGates: ["builtin/build-lint"]` to bypass specific gates by adapter id. Gates marked `required: true` in orbit.json reject skipping and throw.\n\nReturns: { slug, branch, target, merged, mergeSha, gates, cleanedUp, backupPath, durationMs, blockedBy }. If merged is false, blockedBy lists what stopped the merge (gate failures or git errors).',
@@ -2326,18 +3060,23 @@ var init_orbit_mcp = __esm({
 });
 
 // src/server/orbit-entry.ts
-var import_node_fs11 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_fs13 = require("node:fs");
+var import_node_path10 = require("node:path");
 init_orchestrator();
 init_logger();
 function parseFlags(argv) {
   const positional = [];
-  const flags = { emitCd: false, noBackup: false, skipGates: [] };
+  const flags = { emitCd: false, noBackup: false, skipGates: [], deep: false, all: false, json: false, force: false };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === "--emit-cd") flags.emitCd = true;
     else if (a === "--no-backup") flags.noBackup = true;
+    else if (a === "--force") flags.force = true;
     else if (a === "--base-ref") flags.baseRef = argv[++i];
+    else if (a === "--base") flags.base = argv[++i];
+    else if (a === "--deep") flags.deep = true;
+    else if (a === "--all") flags.all = true;
+    else if (a === "--json") flags.json = true;
     else if (a === "--profile") flags.profile = argv[++i];
     else if (a === "--skip-gate") {
       const id = argv[++i];
@@ -2413,20 +3152,30 @@ ${JSON.stringify(result, null, 2)}
         if (!branch) die("usage: launch-orbit switch <branch> [--emit-cd]");
         const result = switchTo({ branch, projectRoot });
         if (flags.emitCd) {
-          process.stdout.write(`cd ${result.path}
+          process.stdout.write(`cd ${result.anchor}
 `);
         } else {
-          process.stdout.write(`${JSON.stringify({ path: result.path, envFile: result.envFile, nextAction: `cd ${result.path}` }, null, 2)}
-`);
+          process.stdout.write(
+            `${JSON.stringify({ anchor: result.anchor, path: result.path, envFile: result.envFile, nextAction: result.nextAction }, null, 2)}
+`
+          );
         }
         return;
       }
+      case "deactivate": {
+        const result = deactivate({ projectRoot });
+        process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+        return;
+      }
       case "drop": {
         const branch = positional[0];
-        if (!branch) die("usage: launch-orbit drop <branch> [--no-backup]");
+        if (!branch) die("usage: launch-orbit drop <branch> [--no-backup] [--force]");
         const result = await drop({
           branch,
           backup: !flags.noBackup,
+          force: flags.force,
+          base: flags.base,
           projectRoot,
           logger
         });
@@ -2486,6 +3235,23 @@ ${JSON.stringify(result, null, 2)}
         if (!result.merged) process.exit(1);
         return;
       }
+      case "check": {
+        const reports = flags.all ? await checkAll({ projectRoot, logger, base: flags.base, deep: flags.deep }) : await (async () => {
+          const branch = positional[0];
+          if (!branch) die("usage: launch-orbit check <branch> [--base <ref>] [--deep] [--json]  (or --all)");
+          return [await check({ branch, projectRoot, logger, base: flags.base, deep: flags.deep })];
+        })();
+        if (flags.json) {
+          process.stdout.write(`${JSON.stringify(flags.all ? reports : reports[0], null, 2)}
+`);
+        } else {
+          if (reports.length === 0) process.stdout.write("(no orbits registered for this repo)\n");
+          for (const r of reports) process.stdout.write(formatReport(r));
+          if (flags.all && reports.length > 1) process.stdout.write(formatRollup(reports));
+        }
+        if (reports.some((r) => !r.healthy)) process.exit(1);
+        return;
+      }
       default:
         die(`unknown subcommand: ${subcommand}`);
     }
@@ -2494,9 +3260,76 @@ ${JSON.stringify(result, null, 2)}
     process.exit(1);
   }
 }
+var USE_COLOR = !!process.stdout.isTTY && process.env.NO_COLOR === void 0 && process.env.TERM !== "dumb";
+var paint = (codes) => (s) => USE_COLOR ? `\x1B[${codes}m${s}\x1B[0m` : s;
+var C = {
+  green: paint("32"),
+  red: paint("31"),
+  yellow: paint("33"),
+  cyan: paint("36"),
+  dim: paint("2"),
+  bold: paint("1"),
+  greenBadge: (s) => USE_COLOR ? `\x1B[1;37;42m ${s} \x1B[0m` : `[ ${s} ]`,
+  redBadge: (s) => USE_COLOR ? `\x1B[1;37;41m ${s} \x1B[0m` : `[ ${s} ]`
+};
+var STATUS = {
+  pass: { glyph: "\u2713", color: C.green },
+  warn: { glyph: "\u26A0", color: C.yellow },
+  fail: { glyph: "\u2717", color: C.red },
+  skip: { glyph: "\u25CB", color: C.dim }
+};
+var SECTION_BLURB = {
+  "drop-safety": { title: "Drop-safety", sub: "can this orbit be deleted without losing work?" },
+  "working-health": { title: "Working-health", sub: "is it in a sane state to keep working in?" }
+};
+function formatReport(r) {
+  const out = [];
+  const badge = (label, ok) => ok ? C.greenBadge(`${label}: YES`) : C.redBadge(`${label}: NO`);
+  out.push("");
+  out.push(`  ${C.cyan("\u25C6")} ${C.bold(`orbit ${r.slug}`)}  ${C.dim(`[${r.branch}]`)}`);
+  out.push(`    ${C.dim(`base ${r.base} \xB7 ${r.durationMs}ms`)}`);
+  out.push("");
+  out.push(`    ${badge("DROP-SAFE", r.dropSafe)}   ${badge("HEALTHY", r.healthy)}`);
+  out.push(`    ${(r.dropSafe ? C.green : C.yellow)(r.recommendation)}`);
+  for (const key of ["drop-safety", "working-health"]) {
+    const blurb = SECTION_BLURB[key];
+    out.push("");
+    out.push(`  ${C.bold(blurb.title)} ${C.dim("\u2014 " + blurb.sub)}`);
+    for (const c of r.checks.filter((c2) => c2.section === key)) {
+      const s = STATUS[c.status];
+      out.push(`    ${s.color(s.glyph)} ${c.label}  ${C.dim("\xB7")} ${s.color(c.summary)}`);
+      for (const d of c.detail ?? []) out.push(`        ${C.dim("\u2022")} ${C.dim(d.trim())}`);
+    }
+  }
+  if (r.actions.length > 0) {
+    out.push("");
+    out.push(`  ${C.bold("Actions")}`);
+    for (const a of r.actions) out.push(`    ${C.cyan("\u2192")} ${a}`);
+  }
+  out.push("");
+  out.push(`  ${C.dim(countLine(r))}`);
+  out.push("");
+  return out.join("\n") + "\n";
+}
+function countLine(r) {
+  const n = (st) => r.checks.filter((c) => c.status === st).length;
+  return `${n("pass")} passed \xB7 ${n("warn")} warning \xB7 ${n("fail")} failed \xB7 ${n("skip")} skipped`;
+}
+function formatRollup(reports) {
+  const out = [];
+  out.push(`  ${C.bold("Summary")} ${C.dim(`\u2014 ${reports.length} orbit${reports.length === 1 ? "" : "s"}`)}`);
+  const w = Math.max(...reports.map((r) => r.slug.length), 4);
+  for (const r of reports) {
+    const drop2 = r.dropSafe ? C.green("drop-safe") : C.red("keep     ");
+    const health = r.healthy ? C.green("healthy ") : C.yellow("issues  ");
+    out.push(`    ${r.slug.padEnd(w)}  ${drop2}  ${health}  ${C.dim(r.branch)}`);
+  }
+  out.push("");
+  return out.join("\n") + "\n";
+}
 function runInit(projectRoot) {
-  const path = (0, import_node_path8.join)(projectRoot, "orbit.json");
-  if ((0, import_node_fs11.existsSync)(path)) {
+  const path = (0, import_node_path10.join)(projectRoot, "orbit.json");
+  if ((0, import_node_fs13.existsSync)(path)) {
     process.stderr.write(`[launch-orbit] orbit.json already exists at ${path}
 `);
     process.exit(1);
@@ -2551,7 +3384,7 @@ function runInit(projectRoot) {
       full: { resources: ["db", "ports"] }
     }
   };
-  (0, import_node_fs11.writeFileSync)(path, JSON.stringify(starter, null, 2) + "\n", "utf-8");
+  (0, import_node_fs13.writeFileSync)(path, JSON.stringify(starter, null, 2) + "\n", "utf-8");
   process.stdout.write(`\u2713 wrote ${path}
 `);
 }