runcastle 1.6.1 → 1.6.3

package/bin/runcastle.js

@@ -2061,11 +2061,35 @@ var init_schema = __esm(() => {
 // src/db/client.ts
 var exports_client = {};
 __export(exports_client, {
+  openRawSqlite: () => openRawSqlite,
   createDb: () => createDb,
   BUSY_TIMEOUT_MS: () => BUSY_TIMEOUT_MS
 });
 import { Database } from "bun:sqlite";
 import { drizzle } from "drizzle-orm/bun-sqlite";
+function openRawSqlite(path, opts) {
+  const sqlite = new Database(path, opts.readonly ? { readonly: true } : { readwrite: true });
+  sqlite.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS};`);
+  return {
+    all: (sql, ...params) => {
+      const statement = sqlite.prepare(sql);
+      try {
+        return statement.all(...params);
+      } finally {
+        statement.finalize();
+      }
+    },
+    run: (sql, ...params) => {
+      const statement = sqlite.prepare(sql);
+      try {
+        statement.run(...params);
+      } finally {
+        statement.finalize();
+      }
+    },
+    close: () => sqlite.close()
+  };
+}
 function createDb(path) {
   const sqlite = new Database(path, { create: true });
   sqlite.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS};`);
@@ -2133,6 +2157,9 @@ var init_asset_paths = __esm(() => {
 import { readFileSync as readFileSync2, readdirSync } from "fs";
 import { join as join4 } from "path";
 import { sql } from "drizzle-orm";
+function bundledMigrations(dir = MIGRATIONS_DIR) {
+  return readdirSync(dir).filter((f) => f.endsWith(".sql")).sort();
+}
 function runMigrations(db, dir = MIGRATIONS_DIR) {
   db.run(sql.raw(`CREATE TABLE IF NOT EXISTS __migrations (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -2141,8 +2168,7 @@ function runMigrations(db, dir = MIGRATIONS_DIR) {
       )`));
   const appliedRows = db.all(sql.raw("SELECT name FROM __migrations"));
   const applied = new Set(appliedRows.map((r) => r.name));
-  const files = readdirSync(dir).filter((f) => f.endsWith(".sql")).sort();
-  for (const file of files) {
+  for (const file of bundledMigrations(dir)) {
     if (applied.has(file))
       continue;
     const contents = readFileSync2(join4(dir, file), "utf8");
@@ -75440,6 +75466,2113 @@ var init_setup3 = __esm(() => {
   AGENT_KEYS = { "2": "codex", "3": "both" };
 });
 
+// src/move/shell.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { lstatSync, readdirSync as readdirSync11, realpathSync as realpathSync3, statfsSync, statSync as statSync12 } from "fs";
+import { join as join48 } from "path";
+function run8(command, args2, opts = {}) {
+  const result = spawnSync3(command, args2, {
+    cwd: opts.cwd,
+    input: opts.input,
+    stdio: opts.stdio,
+    env: opts.env,
+    encoding: "utf8",
+    maxBuffer: HUGE_OUTPUT,
+    windowsHide: true
+  });
+  return {
+    ok: result.status === 0,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? (result.error?.message ?? "")
+  };
+}
+function git3(cwd, args2) {
+  return run8("git", ["-c", "core.quotepath=off", ...args2], { cwd, env: READ_ONLY_GIT });
+}
+function gitOrThrow(cwd, args2) {
+  const result = git3(cwd, args2);
+  if (!result.ok)
+    throw new Error(`git ${args2.join(" ")} failed in ${cwd}: ${result.stderr.trim()}`);
+  return result.stdout;
+}
+function nulList(output) {
+  return output.split("\x00").filter((entry) => entry.length > 0);
+}
+function systemTar() {
+  if (process.platform !== "win32")
+    return "tar";
+  return join48(process.env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe");
+}
+function walkFiles(dir, base = "", strict2 = false) {
+  let entries2;
+  try {
+    entries2 = readdirSync11(dir, { withFileTypes: true });
+  } catch (err) {
+    if (strict2)
+      throw err;
+    return [];
+  }
+  const files = [];
+  for (const entry of entries2) {
+    const rel = base ? `${base}/${entry.name}` : entry.name;
+    if (entry.isDirectory())
+      files.push(...walkFiles(join48(dir, entry.name), rel, strict2));
+    else if (entry.isFile())
+      files.push(rel);
+  }
+  return files;
+}
+function walkFollowing(path3, rel, broken, parents = []) {
+  let real2;
+  let isDirectory;
+  try {
+    real2 = realpathSync3(path3);
+    isDirectory = statSync12(path3).isDirectory();
+  } catch {
+    broken.push(rel);
+    return [];
+  }
+  if (!isDirectory)
+    return [rel];
+  if (parents.includes(real2)) {
+    broken.push(rel);
+    return [];
+  }
+  return readdirSync11(path3).filter((name) => name !== "node_modules" && name !== ".git").flatMap((name) => walkFollowing(join48(path3, name), `${rel}/${name}`, broken, [...parents, real2]));
+}
+function walkSymlinks(dir, base = "") {
+  let entries2;
+  try {
+    entries2 = readdirSync11(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const links = [];
+  for (const entry of entries2) {
+    const rel = base ? `${base}/${entry.name}` : entry.name;
+    if (entry.isSymbolicLink())
+      links.push(rel);
+    else if (entry.isDirectory())
+      links.push(...walkSymlinks(join48(dir, entry.name), rel));
+  }
+  return links;
+}
+function isSymlink(path3) {
+  try {
+    return lstatSync(path3).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function linkInPath(root, rel) {
+  const segments = rel.split("/");
+  for (let i = 1;i <= segments.length; i++) {
+    const prefix = segments.slice(0, i).join("/");
+    if (isSymlink(join48(root, prefix)))
+      return prefix;
+  }
+  return null;
+}
+function pathBytes(path3) {
+  try {
+    const stat3 = lstatSync(path3);
+    if (!stat3.isDirectory())
+      return stat3.isFile() ? stat3.size : 0;
+  } catch {
+    return 0;
+  }
+  return walkFiles(path3).reduce((total, rel) => total + pathBytes(join48(path3, rel)), 0);
+}
+function freeBytes(path3) {
+  try {
+    const stats = statfsSync(path3);
+    return Number(stats.bavail) * Number(stats.bsize);
+  } catch {
+    return null;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes >= 1024 ** 3)
+    return `${(bytes / 1024 ** 3).toFixed(1)} GB`;
+  if (bytes >= 1024 ** 2)
+    return `${Math.round(bytes / 1024 ** 2)} MB`;
+  return `${Math.round(bytes / 1024)} KB`;
+}
+function stamp(now2 = new Date) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now2.getFullYear()}${pad(now2.getMonth() + 1)}${pad(now2.getDate())}-` + `${pad(now2.getHours())}${pad(now2.getMinutes())}${pad(now2.getSeconds())}`;
+}
+var HUGE_OUTPUT, READ_ONLY_GIT;
+var init_shell = __esm(() => {
+  HUGE_OUTPUT = 512 * 1024 * 1024;
+  READ_ONLY_GIT = { ...process.env, GIT_OPTIONAL_LOCKS: "0" };
+});
+
+// src/move/destination.ts
+import { existsSync as existsSync41, readdirSync as readdirSync12, readFileSync as readFileSync28 } from "fs";
+import { isAbsolute as isAbsolute7, join as join49 } from "path";
+function reposDirOf(env, override) {
+  return override ?? join49(env.home, DEFAULT_REPOS_FOLDER);
+}
+function serverPort(env) {
+  const fromEnv2 = Number(process.env.RUNCASTLE_SERVER_PORT);
+  if (Number.isInteger(fromEnv2) && fromEnv2 > 0)
+    return fromEnv2;
+  try {
+    const config2 = JSON.parse(readFileSync28(join49(env.dataDir, "config.json"), "utf8"));
+    return config2.serverPort ?? 4512;
+  } catch {
+    return 4512;
+  }
+}
+async function serverRunning(env) {
+  try {
+    const reply = await fetch(`http://127.0.0.1:${serverPort(env)}/health`, {
+      signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS)
+    });
+    const body = await reply.json();
+    return !body.dataDir || sameDataDir(body.dataDir, env.dataDir);
+  } catch (err) {
+    return err instanceof SyntaxError || err.name === "TimeoutError";
+  }
+}
+function existingProjects(env, open4) {
+  const path3 = join49(env.dataDir, "runcastle.db");
+  if (!existsSync41(path3))
+    return [];
+  const sql5 = open4(path3, { readonly: true });
+  try {
+    return sql5.all("SELECT name FROM projects").map((row2) => row2.name);
+  } catch {
+    return [];
+  } finally {
+    sql5.close();
+  }
+}
+function bytesNeeded(question) {
+  return question.dataBytes * 2 + question.repoBytes * 4;
+}
+async function checkDestination(question, env, opts) {
+  const blockers = [];
+  const notes = [];
+  const reposDir = reposDirOf(env, opts.reposDir);
+  if (env.platform === "win32")
+    blockers.push("a Windows machine cannot be the destination of a move");
+  if (!isAbsolute7(reposDir))
+    blockers.push(`--repos-dir must be an absolute path on this machine, not ${reposDir}`);
+  if (await serverRunning(env))
+    blockers.push("this machine's runcastle server is running: stop it first");
+  const known = new Set(bundledMigrations());
+  const unknown2 = question.migrations.filter((name) => !known.has(name));
+  if (unknown2.length > 0) {
+    blockers.push(`the pack comes from a newer runcastle (${question.runcastleVersion}) than this one: update this machine first`);
+  }
+  const projects2 = existingProjects(env, opts.open);
+  if (projects2.length > 0) {
+    const named = `${projects2.length} ${projects2.length === 1 ? "project" : "projects"} (${projects2.join(", ")})`;
+    if (opts.replace)
+      notes.push(`${named} will be set aside, not merged`);
+    else
+      blockers.push(`this machine holds ${named}: add --replace to set them aside`);
+  }
+  for (const folder of question.targetFolders) {
+    const path3 = join49(reposDir, folder);
+    if (!folderHasContent(path3))
+      continue;
+    if (opts.replace)
+      notes.push(`${path3} will be set aside`);
+    else
+      blockers.push(`${path3} already exists: add --replace to set it aside, or choose --repos-dir`);
+  }
+  const free = freeBytes(existsSync41(env.home) ? env.home : "/");
+  const needed = bytesNeeded(question);
+  if (free !== null && free < needed) {
+    blockers.push(`not enough disk: about ${formatBytes(needed)} needed, ${formatBytes(free)} free`);
+  }
+  return { platform: env.platform, blockers, notes, freeBytes: free, reposDir };
+}
+function folderHasContent(path3) {
+  try {
+    return readdirSync12(path3).length > 0;
+  } catch {
+    return false;
+  }
+}
+var DEFAULT_REPOS_FOLDER = "projects", HEALTH_TIMEOUT_MS = 3000;
+var init_destination = __esm(() => {
+  init_paths();
+  init_migrate();
+  init_shell();
+});
+
+// src/move/paths.ts
+function canonicalSlashes(path3, sourcePlatform) {
+  const slashed = sourcePlatform === "win32" ? path3.replace(/\\/g, "/") : path3;
+  return slashed.length > 1 ? slashed.replace(/\/+$/, "") : slashed;
+}
+function foldForCompare(path3, sourcePlatform) {
+  const canonical = canonicalSlashes(path3, sourcePlatform);
+  return sourcePlatform === "win32" ? canonical.toLowerCase() : canonical;
+}
+function samePath2(a, b, sourcePlatform) {
+  return foldForCompare(a, sourcePlatform) === foldForCompare(b, sourcePlatform);
+}
+function mapSourcePath(path3, rules, sourcePlatform) {
+  const folded = foldForCompare(path3, sourcePlatform);
+  const canonical = canonicalSlashes(path3, sourcePlatform);
+  const ordered = [...rules].sort((a, b) => b.from.length - a.from.length);
+  for (const rule of ordered) {
+    const from = foldForCompare(rule.from, sourcePlatform);
+    if (folded !== from && !folded.startsWith(`${from}/`))
+      continue;
+    const sep5 = rule.to.includes("\\") ? "\\" : "/";
+    const rest = canonical.slice(from.length).split("/").join(sep5);
+    return rule.to + rest;
+  }
+  return null;
+}
+function escapeRegExp(text3) {
+  return text3.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function rewritePathsInText(text3, rules, sourcePlatform) {
+  const windows = sourcePlatform === "win32";
+  const ordered = [...rules].sort((a, b) => b.from.length - a.from.length);
+  if (ordered.length === 0)
+    return text3;
+  const places = ordered.map((rule) => canonicalSlashes(rule.from, sourcePlatform).split("/").map(escapeRegExp).join(windows ? "[\\\\/]+" : "/"));
+  const pattern = new RegExp(`(?<![\\w.-])(${places.join("|")})(?![\\w.-])((?:[\\\\/][^\\s"'\`<>|&;,()]*)?)`, windows ? "gi" : "g");
+  return text3.replace(pattern, (whole, place, rest) => {
+    const rule = ordered.find((candidate) => samePath2(place, candidate.from, sourcePlatform));
+    if (!rule)
+      return whole;
+    return rule.to + (windows ? rest.replace(/\\+/g, "/") : rest);
+  });
+}
+function looksWindowsOnly(text3) {
+  if (/(?<![\w])[A-Za-z]:[\\/]/.test(text3))
+    return true;
+  if (/%[A-Za-z_][A-Za-z0-9_]*%/.test(text3))
+    return true;
+  return /\b(if\s+(not\s+)?exist|del\s+\/|rd\s+\/|rmdir\s+\/|cmd(\.exe)?\s+\/|powershell|pwsh|taskkill)\b|\.(bat|cmd|exe|ps1)\b/i.test(text3);
+}
+function sourceBasename(path3, sourcePlatform) {
+  const canonical = canonicalSlashes(path3, sourcePlatform);
+  return canonical.slice(canonical.lastIndexOf("/") + 1);
+}
+function claudeHash(text3) {
+  let hash2 = 0;
+  for (let i = 0;i < text3.length; i++)
+    hash2 = (hash2 << 5) - hash2 + text3.charCodeAt(i) | 0;
+  return Math.abs(hash2).toString(36);
+}
+function encodeClaudeFolder(path3) {
+  const encoded = path3.replace(/[^a-zA-Z0-9]/g, "-");
+  if (encoded.length <= CLAUDE_FOLDER_MAX)
+    return encoded;
+  return `${encoded.slice(0, CLAUDE_FOLDER_MAX)}-${claudeHash(path3)}`;
+}
+function assignTargetFolders(projects2) {
+  const movers = new Map;
+  for (const project3 of projects2) {
+    if (project3.repoMoves)
+      movers.set(project3.folder, [...movers.get(project3.folder) ?? [], project3.id]);
+  }
+  const targets = new Map;
+  for (const project3 of projects2) {
+    const shared = projects2.filter((p) => p.folder === project3.folder).length > 1;
+    const taken = shared && !project3.repoMoves;
+    targets.set(project3.id, taken ? `${project3.folder}-${project3.id}` : project3.folder);
+  }
+  const clashes = [...movers].filter(([, ids3]) => ids3.length > 1).map(([folder]) => folder);
+  return { targets, clashes };
+}
+var CLAUDE_FOLDER_MAX = 200;
+
+// src/move/scan.ts
+import { existsSync as existsSync42, readdirSync as readdirSync13, readFileSync as readFileSync29, statSync as statSync13 } from "fs";
+import { join as join50 } from "path";
+function staysBehind(options) {
+  return [
+    options.withEnv ? "logins" : ".env files and logins",
+    "Codex auth copies",
+    "logs and caches",
+    "the install id",
+    "Claude's file undo checkpoints",
+    ...options.withClaudeSetup ? [] : ["global Claude rules, skills and settings"],
+    "Claude chats outside these repos"
+  ];
+}
+function count5(n, noun) {
+  return `${n} ${noun}${n === 1 ? "" : "s"}`;
+}
+function repoFacts(repoPath) {
+  const refs = {};
+  const listing = git3(repoPath, ["for-each-ref", "--format=%(objectname) %(refname)"]);
+  for (const line2 of listing.stdout.split(`
+`)) {
+    const space = line2.indexOf(" ");
+    if (space > 0)
+      refs[line2.slice(space + 1).trim()] = line2.slice(0, space);
+  }
+  const remotes = [];
+  for (const name of git3(repoPath, ["remote"]).stdout.split(`
+`).map((n) => n.trim()).filter(Boolean)) {
+    const url = git3(repoPath, ["remote", "get-url", name]);
+    if (url.ok)
+      remotes.push({ name, url: url.stdout.trim() });
+  }
+  const settings = git3(repoPath, ["config", "--local", "-z", "--get-regexp", "^(branch\\.|user\\.|core\\.hookspath)"]);
+  const config2 = nulList(settings.stdout).map((entry) => {
+    const newline = entry.indexOf(`
+`);
+    return newline < 0 ? { key: entry, value: "" } : { key: entry.slice(0, newline), value: entry.slice(newline + 1) };
+  });
+  return { refs, remotes, config: config2, ...headOf2(repoPath) };
+}
+function headOf2(path3) {
+  const branch = git3(path3, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+  const sha = git3(path3, ["rev-parse", "--verify", "--quiet", "HEAD"]);
+  return {
+    ...branch.ok ? { headBranch: branch.stdout.trim() } : {},
+    ...sha.ok ? { headSha: sha.stdout.trim() } : {}
+  };
+}
+function midOperation(path3) {
+  const gitDirResult = git3(path3, ["rev-parse", "--absolute-git-dir"]);
+  if (!gitDirResult.ok)
+    return null;
+  const gitDir = gitDirResult.stdout.trim();
+  const marks = [
+    ["MERGE_HEAD", "a merge"],
+    ["rebase-merge", "a rebase"],
+    ["rebase-apply", "a rebase"],
+    ["CHERRY_PICK_HEAD", "a cherry-pick"],
+    ["REVERT_HEAD", "a revert"]
+  ];
+  return marks.find(([file]) => existsSync42(join50(gitDir, file)))?.[1] ?? null;
+}
+function excludeRules(repoPath) {
+  try {
+    const rules = readFileSync29(join50(repoPath, ".git", "info", "exclude"), "utf8").replace(/\r\n/g, `
+`);
+    return rules.split(`
+`).some((line2) => line2.trim() && !line2.startsWith("#")) ? rules : null;
+  } catch {
+    return null;
+  }
+}
+function isEnvFile(rel) {
+  const name = rel.slice(rel.lastIndexOf("/") + 1);
+  return /^\.env(\..+)?$/.test(name) && !/\.(example|sample|template)$/.test(name);
+}
+function checkoutWip(key, path3) {
+  const { headBranch, headSha: headSha2 } = headOf2(path3);
+  const status3 = gitOrThrow(path3, ["status", "--porcelain=v1", "-z", "--no-renames", "--untracked-files=no"]);
+  const changed = nulList(status3).map((entry) => entry.slice(3));
+  const nested = [];
+  const loose = [];
+  for (const rel of nulList(gitOrThrow(path3, ["ls-files", "-o", "--exclude-standard", "-z"]))) {
+    if (isBurnerPath(rel))
+      continue;
+    const bare = rel.replace(/\/$/, "");
+    if (!rel.endsWith("/") || linkInPath(path3, bare)) {
+      loose.push(bare);
+      continue;
+    }
+    nested.push(bare);
+    loose.push(...nulList(gitOrThrow(join50(path3, rel), ["ls-files", "-co", "--exclude-standard", "-z"])).map((inner) => `${rel}${inner}`));
+  }
+  const candidates = headSha2 ? loose : [...changed, ...loose];
+  const links = candidates.map((rel) => linkInPath(path3, rel));
+  const untracked = candidates.filter((_, i) => links[i] === null);
+  return {
+    key,
+    path: path3,
+    ...headBranch ? { branch: headBranch } : {},
+    ...headSha2 ? { sha: headSha2 } : {},
+    tracked: headSha2 ? changed : [],
+    untracked: untracked.filter((rel) => !isEnvFile(rel)),
+    nested,
+    heldBack: untracked.filter(isEnvFile),
+    symlinks: [...new Set(links.filter((link3) => link3 !== null))]
+  };
+}
+function wipAttention(project3, wip) {
+  const where = wip.key === "main" ? "" : ` (${wip.key})`;
+  const lines2 = wip.nested.map((rel) => `${project3}${where}: ${rel} is a git repo of its own; its files travel, its history does not`);
+  if (wip.heldBack.length > 0)
+    lines2.push(`${project3}${where}: ${wip.heldBack.join(", ")} stays behind, though git does not ignore it`);
+  if (wip.symlinks.length > 0)
+    lines2.push(`${project3}${where}: untracked symlinks stay behind: ${wip.symlinks.join(", ")}`);
+  if (wip.untracked.length > 0) {
+    const shown2 = wip.untracked.slice(0, 3).join(", ");
+    const more = wip.untracked.length > 3 ? `, and ${wip.untracked.length - 3} more` : "";
+    lines2.push(`${project3}${where}: untracked files travel as they are: ${shown2}${more}`);
+  }
+  return lines2;
+}
+function hasWork(wip) {
+  return wip.tracked.length > 0 || wip.untracked.length > 0;
+}
+function ignoredEntries(repoPath, carried) {
+  const listing = git3(repoPath, ["ls-files", "-o", "-i", "--exclude-standard", "--directory", "-z"]);
+  return nulList(listing.stdout).map((rel) => rel.replace(/\/$/, "")).filter((rel) => !rel.split("/").includes("node_modules") && !isBurnerPath(rel) && !carried(rel)).sort().map((rel) => {
+    const bytes = pathBytes(join50(repoPath, rel));
+    return bytes >= 1024 * 1024 ? `${rel} (${formatBytes(bytes)})` : rel;
+  });
+}
+function ignoredEnvFiles(repoPath) {
+  const listing = git3(repoPath, ["ls-files", "-o", "-i", "--exclude-standard", "-z", "--", ":(glob)**/.env", ":(glob)**/.env.*"]);
+  return nulList(listing.stdout).filter((rel) => {
+    const folders = rel.split("/").slice(0, -1);
+    return isEnvFile(rel) && !folders.some((folder) => folder.startsWith(".") || folder === "node_modules");
+  });
+}
+function parseAlso(value) {
+  const colon = value.indexOf(":");
+  if (colon < 1)
+    return null;
+  const path3 = value.slice(colon + 1).replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+  if (!path3 || path3.startsWith("/") || /^[A-Za-z]:/.test(path3) || path3.split("/").includes(".."))
+    return null;
+  return { project: value.slice(0, colon), path: path3 };
+}
+function isBurnerPath(rel) {
+  return rel === ".sandcastle" || rel.startsWith(".sandcastle/");
+}
+function commitsOnNoRemote(repoPath) {
+  const count6 = git3(repoPath, ["rev-list", "--count", "--branches", "--not", "--remotes"]);
+  return count6.ok ? Number(count6.stdout.trim()) : 0;
+}
+function stashCount(repoPath) {
+  return git3(repoPath, ["stash", "list"]).stdout.split(`
+`).filter(Boolean).length;
+}
+function leftoverWorktrees(repoPath, talkRoot) {
+  const listing = git3(repoPath, ["worktree", "list", "--porcelain"]).stdout;
+  const paths = listing.split(`
+`).filter((line2) => line2.startsWith("worktree ")).map((line2) => line2.slice("worktree ".length).trim()).slice(1);
+  const talk = talkRoot.replace(/\\/g, "/").toLowerCase();
+  return paths.filter((path3) => {
+    if (path3.replace(/\\/g, "/").toLowerCase().startsWith(talk))
+      return false;
+    return existsSync42(path3) && git3(path3, ["status", "--porcelain"]).stdout.trim().length > 0;
+  });
+}
+function localHooks(project3, repoPath) {
+  try {
+    const hooks2 = readdirSync13(join50(repoPath, ".git", "hooks")).filter((name) => !name.endsWith(".sample"));
+    return hooks2.length > 0 ? [`${project3}: local git hooks stay behind: ${hooks2.join(", ")}`] : [];
+  } catch {
+    return [];
+  }
+}
+function usesLfsOrSubmodules(repoPath) {
+  const holds = (file, text3) => {
+    try {
+      return readFileSync29(join50(repoPath, file), "utf8").includes(text3);
+    } catch {
+      return false;
+    }
+  };
+  return holds(".gitmodules", "[submodule") || holds(".gitattributes", "filter=lfs");
+}
+function repoBytes(repoPath) {
+  return pathBytes(join50(repoPath, ".git", "objects"));
+}
+function isRepo(path3) {
+  return existsSync42(join50(path3, ".git")) && git3(path3, ["rev-parse", "--git-dir"]).ok;
+}
+function conversationFolders(projectsDir) {
+  const found = new Map;
+  let folders;
+  try {
+    folders = readdirSync13(projectsDir);
+  } catch {
+    return found;
+  }
+  for (const folder of folders) {
+    let names;
+    try {
+      names = readdirSync13(join50(projectsDir, folder));
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      if (name.endsWith(".jsonl"))
+        found.set(name.slice(0, -".jsonl".length), folder);
+    }
+  }
+  return found;
+}
+function findClaudeFolders(env, repoPaths, sessions2) {
+  const projectsDir = join50(env.claudeDir, "projects");
+  const owned = new Map;
+  const claim = (name, cwd) => {
+    if (!owned.has(name))
+      owned.set(name, cwd);
+  };
+  const cwds = new Set([...repoPaths, ...sessions2.map((s) => s.worktree_path)]);
+  const onDisk = new Map;
+  try {
+    for (const name of readdirSync13(projectsDir))
+      onDisk.set(fold(env, name), name);
+  } catch {
+    return { folders: [], conversations: [], missing: 0 };
+  }
+  for (const cwd of cwds) {
+    const name = onDisk.get(fold(env, encodeClaudeFolder(cwd)));
+    if (name)
+      claim(name, cwd);
+  }
+  const onDiskConversations = conversationFolders(projectsDir);
+  const conversations = new Map;
+  const missing = new Set;
+  for (const session of sessions2) {
+    const id3 = session.cc_session_id;
+    if (!id3 || (session.runtime ?? "claude-code") !== "claude-code")
+      continue;
+    const folder = onDiskConversations.get(id3);
+    if (!folder) {
+      missing.add(id3);
+      continue;
+    }
+    claim(folder, session.worktree_path);
+    conversations.set(id3, folder);
+  }
+  return {
+    folders: [...owned].map(([name, cwd]) => ({ name, cwd })),
+    conversations: [...conversations].map(([id3, folder]) => ({ id: id3, folder })),
+    missing: missing.size
+  };
+}
+function claudeJsonPath(env) {
+  return env.claudeDir === join50(env.home, ".claude") ? join50(env.home, ".claude.json") : join50(env.claudeDir, ".claude.json");
+}
+function readJsonObject(path3) {
+  try {
+    const parsed = JSON.parse(readFileSync29(path3, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function findClaudeSetup(env) {
+  const broken = [];
+  const files = CLAUDE_SETUP_ENTRIES.filter((entry) => existsSync42(join50(env.claudeDir, entry))).flatMap((entry) => walkFollowing(join50(env.claudeDir, entry), entry, broken));
+  const settings = readJsonObject(join50(env.claudeDir, "settings.json"));
+  const enabled2 = settings.enabledPlugins ?? {};
+  const plugins = Object.keys(enabled2).filter((id3) => enabled2[id3] === true);
+  const known = readJsonObject(join50(env.claudeDir, "plugins", "known_marketplaces.json"));
+  const needed = new Set(plugins.map((id3) => id3.slice(id3.lastIndexOf("@") + 1)));
+  const marketplaces = Object.keys(known).filter((name) => needed.has(name)).flatMap((name) => known[name].source?.repo ?? known[name].source?.url ?? []);
+  const mcpServers = readJsonObject(claudeJsonPath(env)).mcpServers ?? {};
+  return { setup: { files, marketplaces, plugins, mcpServers }, broken };
+}
+function fold(env, name) {
+  return env.platform === "win32" ? name.toLowerCase() : name;
+}
+function dataSymlinks(env, folders) {
+  const inData = DATA_ENTRIES.flatMap((entry) => {
+    const path3 = join50(env.dataDir, entry);
+    if (isSymlink(path3))
+      return [entry];
+    try {
+      if (!statSync13(path3).isDirectory())
+        return [];
+    } catch {
+      return [];
+    }
+    return walkSymlinks(path3).map((rel) => `${entry}/${rel}`);
+  });
+  const inClaude = folders.flatMap((folder) => walkSymlinks(join50(env.claudeDir, "projects", folder.name)).map((rel) => `claude/${folder.name}/${rel}`));
+  return [...inData, ...inClaude];
+}
+function wipBytes(projects2) {
+  let total = 0;
+  for (const project3 of projects2) {
+    for (const wip of project3.wip) {
+      for (const rel of [...wip.tracked, ...wip.untracked])
+        total += pathBytes(join50(wip.path, rel));
+    }
+    for (const rel of project3.carried)
+      total += pathBytes(join50(project3.repoPath, rel));
+  }
+  return total;
+}
+function dataBytes(env, folders) {
+  const data = DATA_ENTRIES.reduce((total, entry) => total + pathBytes(join50(env.dataDir, entry)), 0);
+  const claude = folders.reduce((total, folder) => total + pathBytes(join50(env.claudeDir, "projects", folder.name)), 0);
+  return data + claude + pathBytes(join50(env.dataDir, "runcastle.db"));
+}
+function scanTalkWorktrees(env, project3, features2) {
+  const root = join50(env.dataDir, "worktrees", project3.id);
+  const wips = [];
+  const stopped = [];
+  let names;
+  try {
+    names = readdirSync13(root);
+  } catch {
+    return { wips, stopped };
+  }
+  for (const name of names) {
+    const status3 = features2.find((f) => f.project_id === project3.id && f.slug === name)?.status;
+    if (status3 === "shipped")
+      continue;
+    const path3 = join50(root, name);
+    if (!git3(path3, ["rev-parse", "--git-dir"]).ok)
+      continue;
+    const operation = midOperation(path3);
+    if (operation)
+      stopped.push(`${project3.name}: the talk worktree ${name} is in the middle of ${operation}. Finish or abort it`);
+    const wip = checkoutWip(name, path3);
+    if (hasWork(wip))
+      wips.push(wip);
+  }
+  return { wips, stopped };
+}
+function scanMove(env, sql5, options) {
+  const projectRows = sql5.all("SELECT * FROM projects");
+  const sessionRows = sql5.all("SELECT project_id, feature_id, status, worktree_path, cc_session_id, runtime FROM sessions");
+  const featureRows = sql5.all("SELECT id, project_id, slug, title, branch, status FROM features");
+  const running3 = sql5.all("SELECT feature_id FROM runs WHERE status = 'running'");
+  const blockers = [];
+  const attention = [];
+  const also = (options.also ?? []).flatMap((value) => {
+    const request2 = parseAlso(value);
+    if (request2)
+      return [{ ...request2, used: false }];
+    blockers.push(`--also ${value}: write it as <project>:<path inside its repo>`);
+    return [];
+  });
+  for (const run7 of running3) {
+    const feature = featureRows.find((f) => f.id === run7.feature_id);
+    blockers.push(`a round of ${feature?.slug ?? run7.feature_id} is marked running: let it finish or press Stop, and if the server is already stopped, start it once so it can clean up`);
+  }
+  const placed = projectRows.map((row2) => {
+    const folder = sourceBasename(row2.repo_path, env.platform);
+    const skipped = options.noRepo.includes(row2.name) || options.noRepo.includes(folder);
+    const present = isRepo(row2.repo_path);
+    return { id: row2.id, row: row2, folder, skipped, present, repoMoves: present && !skipped };
+  });
+  const { targets, clashes } = assignTargetFolders(placed);
+  for (const folder of clashes) {
+    const names = placed.filter((p) => p.folder === folder && p.repoMoves).map((p) => p.row.repo_path);
+    blockers.push(`two projects want the folder ${folder}: ${names.join(" and ")}. Leave one out with --no-repo`);
+  }
+  const projects2 = [];
+  const lines2 = [];
+  let totalRepoBytes = 0;
+  for (const { row: row2, folder, skipped, repoMoves } of placed) {
+    const features2 = featureRows.filter((f) => f.project_id === row2.id);
+    const featureIds = new Set(features2.map((f) => f.id));
+    const chats = sessionRows.filter((s) => s.project_id === row2.id || s.feature_id !== null && featureIds.has(s.feature_id));
+    const targetFolder = targets.get(row2.id) ?? folder;
+    const project3 = {
+      id: row2.id,
+      name: row2.name,
+      repoPath: row2.repo_path,
+      targetFolder,
+      repoMoves,
+      refs: {},
+      remotes: [],
+      config: [],
+      wip: [],
+      carried: []
+    };
+    let bytes = 0;
+    if (!repoMoves) {
+      project3.repoLeftReason = skipped ? "--no-repo" : "its repo folder is gone";
+      attention.push(`${row2.name}: repo stays behind (${project3.repoLeftReason}); put it in the repos folder as ${targetFolder} to use the project`);
+    } else {
+      Object.assign(project3, repoFacts(row2.repo_path));
+      const main = checkoutWip("main", row2.repo_path);
+      const talk = scanTalkWorktrees(env, row2, featureRows);
+      project3.wip = [...hasWork(main) ? [main] : [], ...talk.wips];
+      blockers.push(...talk.stopped);
+      const envFiles = options.withEnv ? [...new Set([...ignoredEnvFiles(row2.repo_path), ...main.heldBack])] : [];
+      const requested = also.filter((request2) => request2.project === row2.name || request2.project === folder);
+      const asked = requested.flatMap((request2) => {
+        request2.used = true;
+        const path3 = join50(row2.repo_path, request2.path);
+        if (existsSync42(path3))
+          return statSync13(path3).isDirectory() ? walkFiles(path3, request2.path) : [request2.path];
+        blockers.push(`${row2.name}: --also ${request2.path} is not in the repo folder`);
+        return [];
+      });
+      project3.carried = [...new Set([...envFiles, ...asked])];
+      if (envFiles.length > 0)
+        attention.push(`${row2.name}: .env files travel: ${envFiles.join(", ")}`);
+      if (requested.length > 0) {
+        const paths = requested.map((request2) => request2.path).join(", ");
+        attention.push(`${row2.name}: travels at your request: ${paths}`);
+      }
+      const shownMain = options.withEnv ? { ...main, heldBack: [] } : main;
+      attention.push(...[shownMain, ...talk.wips].flatMap((wip) => wipAttention(row2.name, wip)));
+      const rules = excludeRules(row2.repo_path);
+      if (rules)
+        project3.excludeRules = rules;
+      if (git3(row2.repo_path, ["rev-parse", "--is-shallow-repository"]).stdout.trim() === "true") {
+        blockers.push(`${row2.name}: a shallow clone cannot be packed. Run git fetch --unshallow, or leave it out with --no-repo`);
+      }
+      if (project3.remotes.some((remote) => /^https?:\/\/[^/@]+@/.test(remote.url))) {
+        attention.push(`${row2.name}: a remote URL holds a credential, and it travels with the repo`);
+      }
+      bytes = repoBytes(row2.repo_path);
+      const mid = midOperation(row2.repo_path);
+      if (mid)
+        blockers.push(`${row2.name}: the main checkout is in the middle of ${mid}. Finish or abort it`);
+      const driving = features2.find((f) => f.status === "active" && f.branch === project3.headBranch);
+      if (driving) {
+        blockers.push(`${row2.name}: the main checkout is on ${driving.branch}, which a test drive leaves behind. Stop the drive or check out the base branch`);
+      }
+      if (project3.remotes.length === 0) {
+        attention.push(`${row2.name}: no remote, so the new machine and this one will be its only copies`);
+      } else {
+        const lonely = commitsOnNoRemote(row2.repo_path);
+        if (lonely > 0)
+          attention.push(`${row2.name}: ${count5(lonely, "commit")} on no remote; they travel in the pack, nothing is pushed`);
+      }
+      const carried = new Set(project3.carried);
+      const roots3 = requested.map((request2) => request2.path);
+      const ignored = ignoredEntries(row2.repo_path, (rel) => carried.has(rel) || roots3.some((root) => rel === root || rel.startsWith(`${root}/`)));
+      if (ignored.length > 0)
+        attention.push(`${row2.name}: ignored files stay behind: ${ignored.join(", ")}`);
+      const stashes = stashCount(row2.repo_path);
+      if (stashes > 1)
+        attention.push(`${row2.name}: ${stashes} stashes, only the newest travels`);
+      if (Object.keys(project3.refs).length > 0) {
+        attention.push(...localHooks(row2.name, row2.repo_path));
+      }
+      const leftovers = leftoverWorktrees(row2.repo_path, join50(env.dataDir, "worktrees"));
+      if (leftovers.length > 0)
+        attention.push(`${row2.name}: uncommitted changes in other worktrees stay behind: ${leftovers.join(", ")}`);
+      if (usesLfsOrSubmodules(row2.repo_path)) {
+        attention.push(`${row2.name}: uses LFS or submodules, which the pack does not carry; fetch them on the new machine`);
+      }
+    }
+    projects2.push(project3);
+    totalRepoBytes += bytes;
+    lines2.push({
+      name: row2.name,
+      branches: Object.keys(project3.refs).filter((ref) => ref.startsWith("refs/heads/")).length,
+      uncommitted: project3.wip.reduce((total, wip) => total + wip.tracked.length + wip.untracked.length, 0),
+      features: features2.length,
+      chats: chats.length,
+      repoBytes: bytes,
+      repoMoves,
+      repoPath: row2.repo_path,
+      targetFolder
+    });
+  }
+  for (const request2 of also.filter((item) => !item.used)) {
+    blockers.push(`--also ${request2.project}:${request2.path}: no moving repo is called ${request2.project}`);
+  }
+  const openChats = sessionRows.filter((s) => s.status === "live" || s.status === "launching").length;
+  if (openChats > 0)
+    attention.push(`${count5(openChats, "open chat")} will end at the new machine's first boot, and can be resumed`);
+  const claude = findClaudeFolders(env, projectRows.map((p) => p.repo_path), sessionRows);
+  if (claude.missing > 0) {
+    attention.push(`${count5(claude.missing, "chat")} already gone from this machine: Claude Code removes transcripts after cleanupPeriodDays, 30 by default`);
+  }
+  const links = dataSymlinks(env, claude.folders);
+  if (links.length > 0)
+    attention.push(`symlinks in runcastle's folders stay behind: ${links.join(", ")}`);
+  let claudeSetup;
+  let setupBytes = 0;
+  if (options.withClaudeSetup) {
+    const found = findClaudeSetup(env);
+    claudeSetup = found.setup;
+    setupBytes = found.setup.files.reduce((total, rel) => total + pathBytes(join50(env.claudeDir, rel)), 0);
+    attention.push(`Claude setup travels: ${count5(found.setup.files.length, "file")}, ${count5(found.setup.plugins.length, "plugin")} to install again, ${count5(Object.keys(found.setup.mcpServers).length, "MCP server")}. What the new machine has is set aside, and its login stays`);
+    if (found.broken.length > 0)
+      attention.push(`Claude setup links that lead nowhere stay behind: ${found.broken.join(", ")}`);
+  } else if (readJsonObject(join50(env.claudeDir, "settings.json")).cleanupPeriodDays === undefined) {
+    attention.push("Claude Code on the new machine deletes moved chats older than 30 days unless cleanupPeriodDays is raised; --with-claude-setup does that");
+  }
+  const report = {
+    blockers,
+    projects: lines2,
+    attention,
+    staysBehind: staysBehind(options),
+    dataBytes: dataBytes(env, claude.folders) + wipBytes(projects2) + setupBytes,
+    repoBytes: totalRepoBytes,
+    openChats
+  };
+  return {
+    report,
+    projects: projects2,
+    claudeFolders: claude.folders,
+    conversations: claude.conversations,
+    envCarried: options.withEnv === true,
+    ...claudeSetup ? { claudeSetup } : {}
+  };
+}
+function windowsCommandLines(sql5, projects2, env) {
+  const rules = [
+    ...projects2.map((project3) => ({ from: project3.repoPath, to: `/repos/${project3.targetFolder}` })),
+    { from: env.dataDir, to: "/data" },
+    { from: env.home, to: "/home" }
+  ];
+  return sql5.all("SELECT * FROM projects").flatMap((row2) => HOST_COMMANDS.flatMap(({ column, label }) => {
+    const value = row2[column];
+    if (!value || !looksWindowsOnly(rewritePathsInText(value, rules, env.platform)))
+      return [];
+    return [`${row2.name}, ${label}: only works on Windows; change it before the move or it will fail on the new machine`];
+  }));
+}
+var DATA_ENTRIES, HOST_COMMANDS, CLAUDE_SETUP_ENTRIES;
+var init_scan = __esm(() => {
+  init_shell();
+  DATA_ENTRIES = [
+    "config.json",
+    "sessions",
+    "reviews",
+    "annotations",
+    "project-notes",
+    "design-crops",
+    "stories"
+  ];
+  HOST_COMMANDS = [
+    { column: "dev_command", label: "dev command" },
+    { column: "setup_command", label: "setup command" },
+    { column: "verify_commands", label: "verify commands" },
+    { column: "drive_setup_command", label: "drive setup command" },
+    { column: "drive_stop_command", label: "drive stop command" },
+    { column: "db_reset_command", label: "database reset command" },
+    { column: "drive_instructions", label: "drive instructions" }
+  ];
+  CLAUDE_SETUP_ENTRIES = ["CLAUDE.md", "rules", "skills", "agents", "commands", "settings.json"];
+});
+
+// src/move/tar.ts
+import { createHash as createHash5 } from "crypto";
+import { createReadStream as createReadStream2, createWriteStream, statSync as statSync14 } from "fs";
+import { once as once5 } from "events";
+import { createGzip } from "zlib";
+function writeField(block, offset, length3, value) {
+  block.write(value.slice(0, length3), offset, length3, "utf8");
+}
+function octal(value, digits) {
+  return `${Math.trunc(value).toString(8).padStart(digits, "0")}\x00`;
+}
+function header(name, size6, mtimeSeconds, type) {
+  const block = Buffer.alloc(BLOCK);
+  writeField(block, 0, 100, name);
+  writeField(block, 100, 8, octal(type === "x" ? 420 : 384, 7));
+  writeField(block, 108, 8, octal(0, 7));
+  writeField(block, 116, 8, octal(0, 7));
+  writeField(block, 124, 12, octal(Math.min(size6, USTAR_MAX_SIZE), 11));
+  writeField(block, 136, 12, octal(mtimeSeconds, 11));
+  block.fill(" ", 148, 156);
+  writeField(block, 156, 1, type);
+  writeField(block, 257, 8, "ustar\x0000");
+  const sum2 = block.reduce((total, byte) => total + byte, 0);
+  writeField(block, 148, 8, `${sum2.toString(8).padStart(6, "0")}\x00 `);
+  return block;
+}
+function paxRecord(key, value) {
+  const body = ` ${key}=${value}
+`;
+  const bodyBytes = Buffer.byteLength(body);
+  let length3 = bodyBytes + 1;
+  while (String(length3).length + bodyBytes !== length3)
+    length3 = String(length3).length + bodyBytes;
+  return `${length3}${body}`;
+}
+function needsPaxName(name) {
+  return name.length > 100 || Buffer.byteLength(name) !== name.length;
+}
+
+class TarWriter {
+  gzip;
+  out;
+  failure;
+  paxCount = 0;
+  files = [];
+  constructor(path3) {
+    this.gzip = createGzip({ level: 6 });
+    this.out = createWriteStream(path3, { mode: 384 });
+    const fail9 = (err) => {
+      this.failure ??= err;
+      this.gzip.destroy(err);
+    };
+    this.gzip.on("error", fail9);
+    this.out.on("error", fail9);
+    this.gzip.pipe(this.out);
+  }
+  async write(chunk) {
+    if (this.failure)
+      throw this.failure;
+    if (!this.gzip.write(chunk))
+      await once5(this.gzip, "drain");
+  }
+  async writeHeaders(name, size6, mtimeSeconds) {
+    const records = (needsPaxName(name) ? paxRecord("path", name) : "") + (size6 > USTAR_MAX_SIZE ? paxRecord("size", String(size6)) : "");
+    if (records) {
+      const body = Buffer.from(records, "utf8");
+      await this.write(header(`PaxHeader/${this.paxCount++}`, body.length, mtimeSeconds, "x"));
+      await this.write(body);
+      await this.pad(body.length);
+    }
+    await this.write(header(needsPaxName(name) ? `long/${this.paxCount}` : name, size6, mtimeSeconds, "0"));
+  }
+  async pad(size6) {
+    const over = size6 % BLOCK;
+    if (over)
+      await this.write(Buffer.alloc(BLOCK - over));
+  }
+  async addFile(name, path3) {
+    const stat3 = statSync14(path3);
+    await this.writeHeaders(name, stat3.size, stat3.mtimeMs / 1000);
+    const hash2 = createHash5("sha256");
+    let read2 = 0;
+    for await (const chunk of createReadStream2(path3)) {
+      const buffer = chunk;
+      read2 += buffer.length;
+      hash2.update(buffer);
+      await this.write(buffer);
+    }
+    if (read2 !== stat3.size)
+      throw new Error(`${path3} changed while it was being packed`);
+    await this.pad(read2);
+    this.files.push({ path: name, size: read2, sha256: hash2.digest("hex") });
+  }
+  async addBuffer(name, body) {
+    await this.writeHeaders(name, body.length, Date.now() / 1000);
+    await this.write(body);
+    await this.pad(body.length);
+  }
+  abort() {
+    this.gzip.destroy();
+    this.out.destroy();
+  }
+  async finish() {
+    await this.write(Buffer.alloc(BLOCK * 2));
+    this.gzip.end();
+    if (!this.out.closed)
+      await once5(this.out, "close");
+    if (this.failure)
+      throw this.failure;
+  }
+}
+async function hashFile(path3) {
+  const hash2 = createHash5("sha256");
+  for await (const chunk of createReadStream2(path3))
+    hash2.update(chunk);
+  return hash2.digest("hex");
+}
+var BLOCK = 512, USTAR_MAX_SIZE = 8589934591;
+var init_tar = () => {};
+
+// src/move/pack.ts
+import { closeSync as closeSync6, copyFileSync as copyFileSync4, existsSync as existsSync43, mkdtempSync as mkdtempSync2, openSync as openSync6, rmSync as rmSync11, statSync as statSync15, utimesSync } from "fs";
+import { spawnSync as spawnSync4 } from "child_process";
+import { dirname as dirname23, join as join51, resolve as resolve16 } from "path";
+function isLeftOut(entry) {
+  return /^sessions\/[^/]+\/(system-prompt\.md|settings\.json|mcp\.json|agent-stderr\.log)$/.test(entry) || /^sessions\/[^/]+\/codex-home\/(?!sessions\/)/.test(entry);
+}
+async function addTree(tar, dir, prefix, skip) {
+  for (const rel of walkFiles(dir, "", true)) {
+    if (skip?.(rel))
+      continue;
+    await tar.addFile(`${prefix}/${rel}`, join51(dir, rel));
+  }
+}
+async function addDataEntries(tar, env) {
+  for (const entry of DATA_ENTRIES) {
+    const path3 = join51(env.dataDir, entry);
+    let isFile3 = false;
+    try {
+      isFile3 = statSync15(path3).isFile();
+    } catch {
+      continue;
+    }
+    if (isFile3)
+      await tar.addFile(`data/${entry}`, path3);
+    else
+      await addTree(tar, path3, `data/${entry}`, (rel) => isLeftOut(`${entry}/${rel}`));
+  }
+}
+function snapshotDatabase(env, open4, target) {
+  const source = open4(join51(env.dataDir, "runcastle.db"), { readonly: true });
+  try {
+    source.run(`VACUUM INTO '${target.replace(/'/g, "''")}'`);
+  } finally {
+    source.close();
+  }
+  const copy4 = open4(target, { readonly: true });
+  try {
+    return { rowCounts: countRows(copy4), migrations: copy4.all("SELECT name FROM __migrations ORDER BY name").map((r) => r.name) };
+  } finally {
+    copy4.close();
+  }
+}
+function countRows(sql5) {
+  const tables = sql5.all("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'");
+  const counts = {};
+  for (const { name } of tables) {
+    counts[name] = sql5.all(`SELECT COUNT(*) AS n FROM "${name}"`)[0].n;
+  }
+  return counts;
+}
+async function addRepo(tar, id3, repoPath, scratch) {
+  const bundle = join51(scratch, `${id3}.bundle`);
+  gitOrThrow(repoPath, ["bundle", "create", "-q", bundle, "--all"]);
+  await tar.addFile(`repos/${id3}.bundle`, bundle);
+  rmSync11(bundle, { force: true });
+}
+async function addWip(tar, projectId, wip, scratch) {
+  const prefix = `wip/${projectId}/${wip.key}`;
+  if (wip.sha && wip.tracked.length > 0) {
+    const patch9 = join51(scratch, "changes.patch");
+    const index2 = resolve16(wip.path, gitOrThrow(wip.path, ["rev-parse", "--git-path", "index"]).trim());
+    const indexCopy = join51(scratch, "index");
+    if (existsSync43(index2)) {
+      copyFileSync4(index2, indexCopy);
+      const { atime, mtime } = statSync15(index2);
+      utimesSync(indexCopy, atime, new Date(mtime.getTime() - 1000));
+    }
+    const fd = openSync6(patch9, "w");
+    try {
+      const diff8 = spawnSync4("git", ["-c", "core.quotepath=off", "diff", "--binary", "HEAD"], {
+        cwd: wip.path,
+        stdio: ["ignore", fd, "pipe"],
+        env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", GIT_INDEX_FILE: indexCopy },
+        windowsHide: true
+      });
+      if (diff8.status !== 0)
+        throw new Error(`git diff failed in ${wip.path}: ${String(diff8.stderr)}`);
+    } finally {
+      closeSync6(fd);
+    }
+    await tar.addFile(`${prefix}/changes.patch`, patch9);
+    rmSync11(patch9, { force: true });
+    rmSync11(indexCopy, { force: true });
+  }
+  for (const rel of [...wip.tracked, ...wip.untracked]) {
+    const path3 = join51(wip.path, rel);
+    try {
+      if (isSymlink(path3) || !statSync15(path3).isFile())
+        continue;
+    } catch {
+      continue;
+    }
+    await tar.addFile(`${prefix}/files/${rel}`, path3);
+  }
+}
+async function packMove(input) {
+  const { env, scan, open: open4, out } = input;
+  const log6 = input.log ?? (() => {});
+  const scratch = mkdtempSync2(join51(dirname23(out), "runcastle-move-"));
+  const tar = new TarWriter(out);
+  try {
+    log6("Copying the database");
+    const dbCopy = join51(scratch, "runcastle.db");
+    const { rowCounts, migrations } = snapshotDatabase(env, open4, dbCopy);
+    await tar.addFile("db/runcastle.db", dbCopy);
+    rmSync11(dbCopy, { force: true });
+    log6("Packing chats, reviews and notes");
+    await addDataEntries(tar, env);
+    for (const folder of scan.claudeFolders) {
+      await addTree(tar, join51(env.claudeDir, "projects", folder.name), `claude/${folder.name}`);
+    }
+    for (const project3 of scan.projects) {
+      if (!project3.repoMoves)
+        continue;
+      log6(`Packing ${project3.name}`);
+      if (Object.keys(project3.refs).length > 0)
+        await addRepo(tar, project3.id, project3.repoPath, scratch);
+      for (const wip of project3.wip)
+        await addWip(tar, project3.id, wip, scratch);
+      for (const rel of project3.carried)
+        await tar.addFile(`carried/${project3.id}/${rel}`, join51(project3.repoPath, rel));
+    }
+    if (scan.claudeSetup) {
+      log6("Packing your Claude setup");
+      for (const rel of scan.claudeSetup.files)
+        await tar.addFile(`claude-setup/${rel}`, join51(env.claudeDir, rel));
+    }
+    const manifest = {
+      formatVersion: 1,
+      runcastleVersion: runcastleVersion(),
+      createdAt: Date.now(),
+      source: env,
+      migrations,
+      projects: scan.projects,
+      claudeFolders: scan.claudeFolders,
+      conversations: scan.conversations,
+      envCarried: scan.envCarried,
+      ...scan.claudeSetup ? { claudeSetup: scan.claudeSetup } : {},
+      reportText: input.reportText ?? "",
+      rowCounts,
+      files: tar.files
+    };
+    await tar.addBuffer("manifest.json", Buffer.from(JSON.stringify(manifest), "utf8"));
+    await tar.finish();
+    return manifest;
+  } catch (err) {
+    tar.abort();
+    rmSync11(out, { force: true });
+    throw err;
+  } finally {
+    rmSync11(scratch, { recursive: true, force: true });
+  }
+}
+var init_pack = __esm(() => {
+  init_version();
+  init_scan();
+  init_shell();
+  init_tar();
+});
+
+// src/move/remote.ts
+import { basename as basename8, dirname as dirname24 } from "path";
+function remoteEnv() {
+  const extra = process.env.RUNCASTLE_MOVE_REMOTE_ENV?.trim();
+  return extra ? `${REMOTE_PATH} ${extra}` : REMOTE_PATH;
+}
+function flagWords(flags) {
+  return [
+    ...flags.replace ? ["--replace"] : [],
+    ...flags.reposDir ? ["--repos-dir", `"${flags.reposDir}"`] : []
+  ].join(" ");
+}
+function remoteMoveInCommand(packName, flags) {
+  return [remoteEnv(), `runcastle move-in "$HOME/${packName}"`, flagWords(flags)].filter(Boolean).join(" ");
+}
+function remoteCheckCommand(flags) {
+  return [remoteEnv(), "runcastle move-in --check", flagWords(flags)].filter(Boolean).join(" ");
+}
+function manualSteps(pack2, host, flags) {
+  const target = host ?? "<user@host>";
+  return [
+    `cd "${dirname24(pack2)}"`,
+    `scp "${basename8(pack2)}" ${target}:`,
+    `ssh ${target} '${remoteMoveInCommand(basename8(pack2), flags)}'`
+  ];
+}
+function failureMessage2(step4, detail, pack2, host, flags) {
+  return [
+    `${step4} failed: ${detail}`,
+    "",
+    `Nothing was lost. The pack is kept at ${pack2}, and this machine is unchanged.`,
+    "Finish by hand with:",
+    ...manualSteps(pack2, host, flags).map((line2) => `  ${line2}`)
+  ].join(`
+`);
+}
+function askDestination(host, question, flags) {
+  const result = run8("ssh", [host, remoteCheckCommand(flags)], {
+    input: JSON.stringify(question),
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const last2 = result.stdout.trim().split(`
+`).pop() ?? "";
+  try {
+    const parsed = JSON.parse(last2);
+    if (Array.isArray(parsed.blockers))
+      return { answer: parsed, detail: "" };
+  } catch {}
+  const detail = result.stderr.trim() || "it does not have a runcastle with move-in; install this version there";
+  return { answer: null, detail };
+}
+function copyPack(pack2, host) {
+  const result = run8("scp", [basename8(pack2), `${host}:`], { cwd: dirname24(pack2), stdio: "inherit" });
+  return { ok: result.ok, detail: result.ok ? "" : `scp to ${host} did not finish` };
+}
+function runRemoteMoveIn(pack2, host, flags) {
+  const result = run8("ssh", [host, remoteMoveInCommand(basename8(pack2), flags)], { stdio: "inherit" });
+  return { ok: result.ok, detail: result.ok ? "" : `move-in on ${host} did not finish` };
+}
+var REMOTE_PATH = 'PATH="$HOME/.bun/bin:$PATH"';
+var init_remote = __esm(() => {
+  init_shell();
+});
+
+// src/move/report.ts
+function formatReport2(report, destination, windowsCommands) {
+  const blockers = [
+    ...report.blockers,
+    ...destination?.answer?.blockers ?? [],
+    ...destination && !destination.answer ? [`the destination could not be checked: ${destination.detail}`] : []
+  ];
+  const out = [];
+  if (blockers.length > 0) {
+    out.push("Blocks", ...blockers.map((line2) => `  x ${line2}`), "");
+  }
+  const width = Math.max(10, ...report.projects.map((p) => p.name.length));
+  const reposDir = destination?.answer?.reposDir ?? "<repos folder>";
+  out.push(`Moves${" ".repeat(width - 2)}branches  uncommitted  features  chats  repo size`);
+  for (const p of report.projects) {
+    const row2 = `${String(p.branches).padStart(8)}  ${String(p.uncommitted).padStart(11)}  ${String(p.features).padStart(8)}  ${String(p.chats).padStart(5)}  ${formatBytes(p.repoBytes).padStart(9)}`;
+    out.push(`  + ${p.name.padEnd(width)} ${row2}${p.repoMoves ? "" : "  (repo stays)"}`);
+    out.push(`      ${p.repoPath} -> ${reposDir}/${p.targetFolder}`);
+  }
+  out.push("");
+  const attention = [...windowsCommands, ...report.attention, ...destination?.answer?.notes ?? []];
+  if (attention.length > 0) {
+    out.push("Worth a look", ...attention.map((line2) => `  ! ${line2}`), "");
+  }
+  out.push(`Stays behind  ${report.staysBehind.join(", ")}`, "");
+  const size6 = `Pack holds about ${formatBytes(report.dataBytes + report.repoBytes)} before compression.`;
+  const free = destination?.answer?.freeBytes;
+  const where = destination?.answer ? ` Repos land in ${destination.answer.reposDir}.` : "";
+  const room = free != null ? ` The destination has ${formatBytes(free)} free.` : "";
+  const unchecked = destination ? "" : " The destination was not checked; give a host to check it.";
+  out.push(`${size6}${where}${room}${unchecked}`);
+  return out.join(`
+`);
+}
+function isBlocked(report, destination) {
+  if (report.blockers.length > 0)
+    return true;
+  if (!destination)
+    return false;
+  return !destination.answer || destination.answer.blockers.length > 0;
+}
+function formatMoveInResult(result) {
+  const out = ["Moved in.", "", "Repos", ...result.repos.map((r) => `  ${r.name}: ${r.path}`)];
+  if (result.wipApplied.length > 0) {
+    out.push("", "Uncommitted work put back", ...result.wipApplied.map((w) => `  ${w}`));
+  }
+  if (result.wipKept.length > 0) {
+    out.push("", "Uncommitted work that would not apply, kept here", ...result.wipKept.map((w) => `  ${w.project} (${w.key}): ${w.folder}`));
+  }
+  if (result.wipStuck.length > 0) {
+    out.push("", `Uncommitted work that could not be placed. Copy it out of ${result.stagingKept}/wip before anything else`, ...result.wipStuck.map((w) => `  ${w}`));
+  }
+  if (result.commandsWindows.length > 0) {
+    out.push("", "Commands that only work on Windows; change these in the project settings");
+    out.push(...result.commandsWindows.map((c) => `  ${c.project}, ${c.field}: ${c.value}`));
+  }
+  if (result.commandsChanged.length > 0) {
+    out.push("", "Commands with their paths rewritten");
+    out.push(...result.commandsChanged.map((c) => `  ${c.project}, ${c.field}`));
+  }
+  if (result.claudeSetup) {
+    if (result.claudeSetup.chatsKept)
+      out.push("", "Claude Code now keeps chats for 10 years, so it will not delete moved ones.");
+    if (result.claudeSetup.failed.length > 0) {
+      out.push("", "Claude setup that did not go in", ...result.claudeSetup.failed.map((item) => `  ${item}`));
+    }
+  }
+  if (result.setAside.length > 0) {
+    out.push("", "Set aside", ...result.setAside.map((s) => `  ${s.to}`));
+  }
+  if (result.unmappedPaths > 0) {
+    out.push("", `${result.unmappedPaths} stored paths matched no known folder and were left as they were.`);
+  }
+  out.push("", `Full report: ${result.reportPath}`, "", result.envCarried ? "Next: start runcastle here." : "Next: start runcastle here, and recreate the .env files.", "This machine is now the only home. Do not work on the old one.");
+  return out.join(`
+`);
+}
+var init_report2 = __esm(() => {
+  init_shell();
+});
+
+// src/move/unpack.ts
+import {
+  chmodSync,
+  closeSync as closeSync7,
+  copyFileSync as copyFileSync5,
+  cpSync as cpSync3,
+  existsSync as existsSync44,
+  mkdirSync as mkdirSync28,
+  openSync as openSync7,
+  readdirSync as readdirSync14,
+  readFileSync as readFileSync30,
+  readSync as readSync4,
+  renameSync as renameSync2,
+  rmSync as rmSync12,
+  statSync as statSync16,
+  writeFileSync as writeFileSync22
+} from "fs";
+import { basename as basename9, dirname as dirname25, join as join52, resolve as resolve17 } from "path";
+function extract(pack2, into) {
+  const result = run8(systemTar(), ["-xzf", basename9(pack2), "-C", into], { cwd: dirname25(resolve17(pack2)) });
+  if (!result.ok)
+    throw new Error(`could not unpack ${pack2}: ${result.stderr.trim()}`);
+}
+async function verifyFiles(staging, manifest) {
+  for (const file of manifest.files) {
+    const path3 = join52(staging, file.path);
+    if (!existsSync44(path3))
+      throw new Error(`the pack is missing ${file.path}`);
+    if (await hashFile(path3) !== file.sha256)
+      throw new Error(`${file.path} did not arrive intact`);
+  }
+}
+function pathRules(manifest, env, reposDir) {
+  return [
+    ...manifest.projects.map((p) => ({ from: p.repoPath, to: join52(reposDir, p.targetFolder) })),
+    { from: manifest.source.dataDir, to: env.dataDir }
+  ];
+}
+function claudeRenames(manifest, rules) {
+  const platform = manifest.source.platform;
+  const renames = new Map;
+  for (const folder of manifest.claudeFolders) {
+    const mapped = mapSourcePath(folder.cwd, rules, platform);
+    renames.set(folder.name, mapped ? encodeClaudeFolder(mapped) : folder.name);
+  }
+  return renames;
+}
+function mapTranscript(path3, manifest, rules, renames, env) {
+  const platform = manifest.source.platform;
+  const projects2 = `${manifest.source.claudeDir}${platform === "win32" ? "\\" : "/"}projects`;
+  const rest = mapSourcePath(path3, [{ from: projects2, to: "" }], platform);
+  if (rest === null)
+    return mapSourcePath(path3, rules, platform);
+  const [, folder, ...tail] = rest.split("/");
+  const key = platform === "win32" ? folder.toLowerCase() : folder;
+  for (const [oldName, newName] of renames) {
+    if ((platform === "win32" ? oldName.toLowerCase() : oldName) === key) {
+      return join52(env.claudeDir, "projects", newName, ...tail);
+    }
+  }
+  return null;
+}
+function rewriteCommands(sql5, rules, platform) {
+  const result = { changed: [], windows: [] };
+  const projects2 = sql5.all("SELECT * FROM projects");
+  for (const project3 of projects2) {
+    for (const { column, label } of HOST_COMMANDS) {
+      const value = project3[column];
+      if (!value)
+        continue;
+      const next4 = rewritePathsInText(value, rules, platform);
+      if (next4 !== value) {
+        sql5.run(`UPDATE projects SET ${column} = ? WHERE id = ?`, next4, project3.id);
+        result.changed.push({ project: project3.name, field: label, from: value, to: next4 });
+      }
+      if (looksWindowsOnly(next4))
+        result.windows.push({ project: project3.name, field: label, value: next4 });
+    }
+  }
+  return result;
+}
+function rewriteDatabase(sql5, manifest, rules, renames, env) {
+  const platform = manifest.source.platform;
+  let unmapped = 0;
+  let commands;
+  sql5.run("BEGIN");
+  try {
+    for (const row2 of sql5.all("SELECT id, repo_path FROM projects")) {
+      const mapped = mapSourcePath(row2.repo_path, rules, platform);
+      if (mapped)
+        sql5.run("UPDATE projects SET repo_path = ? WHERE id = ?", mapped, row2.id);
+      else
+        unmapped++;
+    }
+    const sessions2 = sql5.all("SELECT id, worktree_path, transcript_path FROM sessions");
+    for (const row2 of sessions2) {
+      const worktree = mapSourcePath(row2.worktree_path, rules, platform);
+      if (worktree)
+        sql5.run("UPDATE sessions SET worktree_path = ? WHERE id = ?", worktree, row2.id);
+      else
+        unmapped++;
+      if (!row2.transcript_path)
+        continue;
+      const transcript = mapTranscript(row2.transcript_path, manifest, rules, renames, env);
+      if (transcript)
+        sql5.run("UPDATE sessions SET transcript_path = ? WHERE id = ?", transcript, row2.id);
+      else
+        unmapped++;
+    }
+    commands = rewriteCommands(sql5, [...rules, { from: manifest.source.home, to: env.home }], platform);
+    if (platform !== env.platform)
+      sql5.run("UPDATE project_findings SET verified_at = NULL, verified_sha = NULL");
+    sql5.run("COMMIT");
+  } catch (err) {
+    sql5.run("ROLLBACK");
+    throw err;
+  }
+  return { unmapped, commands };
+}
+function rebuildRepo(project3, staging, path3) {
+  mkdirSync28(path3, { recursive: true });
+  gitOrThrow(path3, ["init", "-q"]);
+  if (Object.keys(project3.refs).length > 0) {
+    const bundle = join52(staging, "repos", `${project3.id}.bundle`);
+    gitOrThrow(path3, ["fetch", "-q", "--no-tags", "--update-head-ok", bundle, "+refs/*:refs/*"]);
+  }
+  for (const remote of project3.remotes)
+    gitOrThrow(path3, ["remote", "add", remote.name, remote.url]);
+  for (const { key, value } of project3.config)
+    gitOrThrow(path3, ["config", "--local", "--add", key, value]);
+  if (project3.headBranch) {
+    gitOrThrow(path3, ["symbolic-ref", "HEAD", `refs/heads/${project3.headBranch}`]);
+    if (project3.headSha)
+      gitOrThrow(path3, ["reset", "-q", "--hard"]);
+  } else if (project3.headSha) {
+    gitOrThrow(path3, ["checkout", "-q", "-f", "--detach", project3.headSha]);
+  }
+  restoreStash(project3, path3);
+  if (project3.excludeRules) {
+    mkdirSync28(join52(path3, ".git", "info"), { recursive: true });
+    writeFileSync22(join52(path3, ".git", "info", "exclude"), project3.excludeRules);
+  }
+  for (const rel of project3.carried) {
+    mkdirSync28(dirname25(join52(path3, rel)), { recursive: true });
+    copyFileSync5(join52(staging, "carried", project3.id, rel), join52(path3, rel));
+  }
+}
+function restoreStash(project3, path3) {
+  const sha = project3.refs["refs/stash"];
+  if (!sha)
+    return;
+  gitOrThrow(path3, ["update-ref", "-d", "refs/stash"]);
+  gitOrThrow(path3, ["-c", "user.name=runcastle", "-c", "user.email=runcastle@localhost", "stash", "store", "-m", "moved from the old machine", sha]);
+}
+function verifyRefs(project3, path3) {
+  const listing = gitOrThrow(path3, ["for-each-ref", "--format=%(objectname) %(refname)"]);
+  const found = new Map(listing.split(`
+`).filter(Boolean).map((line2) => {
+    const space = line2.indexOf(" ");
+    return [line2.slice(space + 1).trim(), line2.slice(0, space)];
+  }));
+  for (const [ref, sha] of Object.entries(project3.refs)) {
+    if (found.get(ref) !== sha)
+      throw new Error(`${project3.name}: ${ref} did not arrive at ${sha}`);
+  }
+}
+function verifyConversations(staging, manifest) {
+  for (const { id: id3, folder } of manifest.conversations) {
+    if (!existsSync44(join52(staging, "claude", folder, `${id3}.jsonl`))) {
+      throw new Error(`the pack is missing the transcript of conversation ${id3}`);
+    }
+  }
+}
+function verifyRowCounts(sql5, manifest) {
+  const counts = countRows(sql5);
+  for (const [table, count6] of Object.entries(manifest.rowCounts)) {
+    if (counts[table] !== count6) {
+      throw new Error(`the database table ${table} has ${counts[table]} rows, the pack says ${count6}`);
+    }
+  }
+}
+function mergeSettings(staged, current2) {
+  if (!existsSync44(staged))
+    return;
+  const incoming = JSON.parse(readFileSync30(staged, "utf8"));
+  let own = {};
+  try {
+    own = JSON.parse(readFileSync30(current2, "utf8"));
+  } catch {}
+  for (const key of MACHINE_SETTINGS) {
+    if (key in own)
+      incoming[key] = own[key];
+    else
+      delete incoming[key];
+  }
+  writeFileSync22(staged, `${JSON.stringify(incoming, null, 2)}
+`);
+}
+
+class Swap {
+  made = [];
+  rename(from, to) {
+    mkdirSync28(dirname25(to), { recursive: true });
+    renameSync2(from, to);
+    this.made.push({ from, to });
+  }
+  undo() {
+    for (const { from, to } of this.made.reverse()) {
+      try {
+        renameSync2(to, from);
+      } catch {}
+    }
+  }
+}
+function placeClaudeFolder(from, to, swap2, when3) {
+  if (!existsSync44(to)) {
+    swap2.rename(from, to);
+    return;
+  }
+  if (statSync16(from).isDirectory() && statSync16(to).isDirectory()) {
+    for (const entry of readdirSync14(from))
+      placeClaudeFolder(join52(from, entry), join52(to, entry), swap2, when3);
+    return;
+  }
+  if (readFileSync30(from).equals(readFileSync30(to)))
+    return;
+  let aside = `${to}.moved-${when3}`;
+  for (let n = 2;existsSync44(aside); n++)
+    aside = `${to}.moved-${when3}-${n}`;
+  swap2.rename(from, aside);
+}
+function restoreScriptBits(dir) {
+  for (const rel of walkFiles(dir)) {
+    const path3 = join52(dir, rel);
+    const start3 = Buffer.alloc(2);
+    const fd = openSync7(path3, "r");
+    try {
+      readSync4(fd, start3, 0, 2, 0);
+    } finally {
+      closeSync7(fd);
+    }
+    if (start3.toString() === "#!")
+      chmodSync(path3, 448);
+  }
+}
+function settleClaudeSettings(staged, current2) {
+  if (!existsSync44(staged))
+    return false;
+  const incoming = JSON.parse(readFileSync30(staged, "utf8"));
+  let own = {};
+  try {
+    own = JSON.parse(readFileSync30(current2, "utf8"));
+  } catch {}
+  const keepChats = incoming.cleanupPeriodDays === undefined;
+  const settled = { ...own, ...incoming, ...keepChats ? { cleanupPeriodDays: CHAT_KEEP_DAYS } : {} };
+  writeFileSync22(staged, `${JSON.stringify(settled, null, 2)}
+`);
+  return keepChats;
+}
+function addMcpServers(env, servers2, aside) {
+  if (Object.keys(servers2).length === 0)
+    return true;
+  const path3 = claudeJsonPath(env);
+  let own = {};
+  if (existsSync44(path3)) {
+    try {
+      own = JSON.parse(readFileSync30(path3, "utf8"));
+    } catch {
+      return false;
+    }
+    copyFileSync5(path3, aside);
+  }
+  const mcpServers = { ...own.mcpServers, ...servers2 };
+  writeFileSync22(path3, `${JSON.stringify({ ...own, mcpServers }, null, 2)}
+`, { mode: 384 });
+  return true;
+}
+function installPlugins(setup, runClaude) {
+  const failed = [];
+  for (const marketplace of setup.marketplaces) {
+    if (!runClaude(["plugin", "marketplace", "add", marketplace]))
+      failed.push(`plugin marketplace ${marketplace}`);
+  }
+  for (const plugin of setup.plugins) {
+    if (!runClaude(["plugin", "install", plugin]))
+      failed.push(`plugin ${plugin}`);
+  }
+  return failed;
+}
+function claudeOn(env) {
+  const PATH = [join52(env.home, ".local", "bin"), process.env.PATH].filter(Boolean).join(":");
+  return (args2) => run8("claude", args2, { env: { ...process.env, PATH } }).ok;
+}
+function applyWip(project3, wip, repoPath, checkout, staging) {
+  const source = join52(staging, "wip", project3.id, wip.key);
+  const patch9 = join52(source, "changes.patch");
+  const applied = !existsSync44(patch9) || run8("git", ["apply", "--whitespace=nowarn", patch9], { cwd: checkout }).ok;
+  if (!applied) {
+    const kept = join52(`${repoPath}.uncommitted`, wip.key);
+    mkdirSync28(dirname25(kept), { recursive: true });
+    cpSync3(source, kept, { recursive: true });
+    return kept;
+  }
+  for (const rel of wip.untracked) {
+    const from = join52(source, "files", rel);
+    if (!existsSync44(from))
+      continue;
+    mkdirSync28(dirname25(join52(checkout, rel)), { recursive: true });
+    copyFileSync5(from, join52(checkout, rel));
+  }
+  return null;
+}
+function addTalkWorktree(repoPath, path3, wip) {
+  mkdirSync28(dirname25(path3), { recursive: true });
+  if (wip.branch && run8("git", ["worktree", "add", "-q", path3, wip.branch], { cwd: repoPath }).ok)
+    return;
+  gitOrThrow(repoPath, ["worktree", "add", "-q", "--detach", path3, wip.sha ?? "HEAD"]);
+}
+function renderReport(manifest, result) {
+  const lines2 = [
+    "# runcastle move report",
+    "",
+    `Moved ${new Date(manifest.createdAt).toISOString()} from ${manifest.source.platform} (${manifest.source.home}).`,
+    "",
+    "## Repos",
+    ...result.repos.map((r) => `- ${r.name}: ${r.path}`)
+  ];
+  if (result.wipStuck.length > 0) {
+    lines2.push("", `## Uncommitted work still in ${result.stagingKept}/wip`, "");
+    for (const w of result.wipStuck)
+      lines2.push(`- ${w}`);
+  }
+  if (result.commandsWindows.length > 0) {
+    lines2.push("", "## Commands that only work on Windows", "");
+    for (const c of result.commandsWindows)
+      lines2.push(`- ${c.project}, ${c.field}: \`${c.value}\``);
+  }
+  if (result.commandsChanged.length > 0) {
+    lines2.push("", "## Commands with their paths rewritten", "");
+    for (const c of result.commandsChanged)
+      lines2.push(`- ${c.project}, ${c.field}: \`${c.from}\` became \`${c.to}\``);
+  }
+  if (result.claudeSetup && result.claudeSetup.failed.length > 0) {
+    lines2.push("", "## Claude setup that did not go in", "");
+    for (const item of result.claudeSetup.failed)
+      lines2.push(`- ${item}`);
+  }
+  if (result.wipKept.length > 0) {
+    lines2.push("", "## Uncommitted work kept beside the repo", "");
+    for (const w of result.wipKept)
+      lines2.push(`- ${w.project} (${w.key}): ${w.folder}`);
+  }
+  if (result.setAside.length > 0) {
+    lines2.push("", "## Set aside", "");
+    for (const s of result.setAside)
+      lines2.push(`- ${s.from} is now ${s.to}`);
+  }
+  if (result.unmappedPaths > 0) {
+    lines2.push("", `${result.unmappedPaths} stored paths matched no known folder and were left as they were.`);
+  }
+  if (manifest.reportText)
+    lines2.push("", "## The report before the move", "", "```", manifest.reportText, "```");
+  return `${lines2.join(`
+`)}
+`;
+}
+async function moveIn(input) {
+  const { pack: pack2, env, open: open4, replace } = input;
+  const log6 = input.log ?? (() => {});
+  const reposDir = reposDirOf(env, input.reposDir);
+  const when3 = stamp();
+  const staging = `${env.dataDir}.incoming-${when3}`;
+  const stagedRepos = [];
+  let keepStaging = false;
+  try {
+    if (!existsSync44(pack2))
+      throw new Error(`no pack at ${pack2}`);
+    const free = freeBytes(dirname25(env.dataDir));
+    const unpackBytes = statSync16(pack2).size * 3;
+    if (free !== null && free < unpackBytes) {
+      throw new Error(`not enough disk to unpack: about ${formatBytes(unpackBytes)} needed, ${formatBytes(free)} free`);
+    }
+    mkdirSync28(staging, { recursive: true });
+    log6("Unpacking");
+    extract(pack2, staging);
+    const manifest = JSON.parse(readFileSync30(join52(staging, "manifest.json"), "utf8"));
+    if (manifest.formatVersion !== 1)
+      throw new Error("this pack was made by a newer runcastle");
+    const question = {
+      runcastleVersion: manifest.runcastleVersion,
+      sourcePlatform: manifest.source.platform,
+      migrations: manifest.migrations,
+      targetFolders: manifest.projects.filter((p) => p.repoMoves).map((p) => p.targetFolder),
+      dataBytes: 0,
+      repoBytes: manifest.files.filter((f) => f.path.startsWith("repos/")).reduce((total, f) => total + f.size, 0)
+    };
+    const answer = await checkDestination(question, env, { replace, reposDir, open: open4 });
+    if (answer.blockers.length > 0)
+      throw new Error(answer.blockers.join(`
+`));
+    log6("Checking every file");
+    await verifyFiles(staging, manifest);
+    verifyConversations(staging, manifest);
+    const rules = pathRules(manifest, env, reposDir);
+    const renames = claudeRenames(manifest, rules);
+    log6("Rewriting paths in the database");
+    const sql5 = open4(join52(staging, "db", "runcastle.db"), { readonly: false });
+    let rewritten;
+    try {
+      verifyRowCounts(sql5, manifest);
+      rewritten = rewriteDatabase(sql5, manifest, rules, renames, env);
+    } finally {
+      sql5.close();
+    }
+    const repoStages = new Map;
+    for (const project3 of manifest.projects) {
+      if (!project3.repoMoves)
+        continue;
+      log6(`Rebuilding ${project3.name}`);
+      const stage = join52(reposDir, `${project3.targetFolder}.incoming-${when3}`);
+      stagedRepos.push(stage);
+      rebuildRepo(project3, staging, stage);
+      verifyRefs(project3, stage);
+      repoStages.set(project3.id, stage);
+    }
+    const data = join52(staging, "data");
+    mkdirSync28(data, { recursive: true });
+    renameSync2(join52(staging, "db", "runcastle.db"), join52(data, "runcastle.db"));
+    mergeSettings(join52(data, "config.json"), join52(env.dataDir, "config.json"));
+    for (const file of KEPT_FILES) {
+      if (existsSync44(join52(env.dataDir, file)))
+        copyFileSync5(join52(env.dataDir, file), join52(data, file));
+    }
+    const stagedSetup = join52(staging, "claude-setup");
+    let chatsKept = false;
+    if (manifest.claudeSetup && existsSync44(stagedSetup)) {
+      restoreScriptBits(stagedSetup);
+      chatsKept = settleClaudeSettings(join52(stagedSetup, "settings.json"), join52(env.claudeDir, "settings.json"));
+    }
+    log6("Swapping into place");
+    const swap2 = new Swap;
+    const setAside = [];
+    const asideOf = (path3) => `${path3}.before-move-${when3}`;
+    try {
+      for (const project3 of manifest.projects) {
+        const stage = repoStages.get(project3.id);
+        if (!stage)
+          continue;
+        const target = join52(reposDir, project3.targetFolder);
+        if (existsSync44(target)) {
+          swap2.rename(target, asideOf(target));
+          setAside.push({ from: target, to: asideOf(target) });
+        }
+        swap2.rename(stage, target);
+      }
+      const claudeProjects = join52(env.claudeDir, "projects");
+      mkdirSync28(claudeProjects, { recursive: true });
+      const asideNames = new Set;
+      for (const folder of manifest.claudeFolders) {
+        const newName = renames.get(folder.name) ?? folder.name;
+        const target = join52(claudeProjects, newName);
+        if (existsSync44(target) && !asideNames.has(newName) && replace) {
+          swap2.rename(target, asideOf(target));
+          setAside.push({ from: target, to: asideOf(target) });
+        }
+        asideNames.add(newName);
+        const staged = join52(staging, "claude", folder.name);
+        if (existsSync44(staged))
+          placeClaudeFolder(staged, target, swap2, when3);
+      }
+      if (manifest.claudeSetup && existsSync44(stagedSetup)) {
+        for (const entry of readdirSync14(stagedSetup)) {
+          const target = join52(env.claudeDir, entry);
+          if (existsSync44(target)) {
+            swap2.rename(target, asideOf(target));
+            setAside.push({ from: target, to: asideOf(target) });
+          }
+          swap2.rename(join52(stagedSetup, entry), target);
+        }
+      }
+      if (existsSync44(env.dataDir)) {
+        swap2.rename(env.dataDir, asideOf(env.dataDir));
+        setAside.push({ from: env.dataDir, to: asideOf(env.dataDir) });
+      }
+      swap2.rename(data, env.dataDir);
+    } catch (err) {
+      swap2.undo();
+      throw err;
+    }
+    log6("Putting uncommitted work back");
+    const wipApplied = [];
+    const wipKept = [];
+    const wipStuck = [];
+    for (const project3 of manifest.projects) {
+      if (!project3.repoMoves)
+        continue;
+      const repoPath = join52(reposDir, project3.targetFolder);
+      for (const wip of project3.wip) {
+        const checkout = wip.key === "main" ? repoPath : join52(env.dataDir, "worktrees", project3.id, wip.key);
+        let kept;
+        try {
+          if (wip.key !== "main")
+            addTalkWorktree(repoPath, checkout, wip);
+          kept = applyWip(project3, wip, repoPath, checkout, staging);
+        } catch {
+          try {
+            kept = join52(`${repoPath}.uncommitted`, wip.key);
+            cpSync3(join52(staging, "wip", project3.id, wip.key), kept, { recursive: true });
+          } catch {
+            keepStaging = true;
+            wipStuck.push(`${project3.name} (${wip.key})`);
+            continue;
+          }
+        }
+        if (kept)
+          wipKept.push({ project: project3.name, key: wip.key, folder: kept });
+        else
+          wipApplied.push(`${project3.name} (${wip.key})`);
+      }
+    }
+    let claudeSetup;
+    if (manifest.claudeSetup) {
+      const failed = [];
+      if (!addMcpServers(env, manifest.claudeSetup.mcpServers, asideOf(claudeJsonPath(env)))) {
+        failed.push(`MCP servers: could not read ${claudeJsonPath(env)}`);
+      }
+      log6("Installing your Claude plugins again");
+      failed.push(...installPlugins(manifest.claudeSetup, input.runClaude ?? claudeOn(env)));
+      claudeSetup = { failed, chatsKept };
+    }
+    const partial = {
+      repos: manifest.projects.filter((p) => p.repoMoves).map((p) => ({ name: p.name, path: join52(reposDir, p.targetFolder) })),
+      commandsChanged: rewritten.commands.changed,
+      commandsWindows: rewritten.commands.windows,
+      envCarried: manifest.envCarried,
+      ...claudeSetup ? { claudeSetup } : {},
+      wipApplied,
+      wipKept,
+      wipStuck,
+      ...keepStaging ? { stagingKept: staging } : {},
+      unmappedPaths: rewritten.unmapped,
+      setAside
+    };
+    const reportPath = join52(env.dataDir, "move-report.md");
+    writeFileSync22(reportPath, renderReport(manifest, partial));
+    if (!keepStaging)
+      rmSync12(pack2, { force: true });
+    return { ...partial, reportPath };
+  } finally {
+    if (!keepStaging)
+      rmSync12(staging, { recursive: true, force: true });
+    for (const stage of stagedRepos)
+      rmSync12(stage, { recursive: true, force: true });
+  }
+}
+var MACHINE_SETTINGS, KEPT_FILES, CHAT_KEEP_DAYS = 3650;
+var init_unpack = __esm(() => {
+  init_destination();
+  init_pack();
+  init_scan();
+  init_shell();
+  init_tar();
+  MACHINE_SETTINGS = ["burnConcurrency", "burnCpus"];
+  KEPT_FILES = [".env", "install-id"];
+});
+
+// src/move/cli.ts
+var exports_cli2 = {};
+__export(exports_cli2, {
+  runMoveInCli: () => runMoveInCli,
+  runMoveCli: () => runMoveCli,
+  parseMoveInArgs: () => parseMoveInArgs,
+  parseMoveArgs: () => parseMoveArgs,
+  currentEnv: () => currentEnv
+});
+import { rmSync as rmSync13 } from "fs";
+import { homedir as homedir7, tmpdir as tmpdir7 } from "os";
+import { dirname as dirname26, join as join53 } from "path";
+import { createInterface as createInterface6 } from "readline/promises";
+function takeValue(args2, i, flag) {
+  const value = args2[i + 1];
+  if (value === undefined || value.startsWith("--"))
+    throw new Error(`${flag} needs a value`);
+  return value;
+}
+function parseMoveArgs(args2) {
+  const parsed = {
+    dryRun: false,
+    yes: false,
+    replace: false,
+    noRepo: [],
+    withEnv: false,
+    withClaudeSetup: false,
+    also: []
+  };
+  for (let i = 0;i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--dry-run")
+      parsed.dryRun = true;
+    else if (arg === "--yes")
+      parsed.yes = true;
+    else if (arg === "--replace")
+      parsed.replace = true;
+    else if (arg === "--with-env")
+      parsed.withEnv = true;
+    else if (arg === "--with-claude-setup")
+      parsed.withClaudeSetup = true;
+    else if (arg === "--also")
+      parsed.also.push(takeValue(args2, i++, arg));
+    else if (arg === "--repos-dir")
+      parsed.reposDir = takeValue(args2, i++, arg);
+    else if (arg === "--no-repo")
+      parsed.noRepo.push(takeValue(args2, i++, arg));
+    else if (arg === "--out")
+      parsed.out = takeValue(args2, i++, arg);
+    else if (arg.startsWith("--"))
+      throw new Error(`unknown flag ${arg}`);
+    else if (parsed.host)
+      throw new Error(`unexpected argument ${arg}`);
+    else
+      parsed.host = arg;
+  }
+  return parsed;
+}
+function parseMoveInArgs(args2) {
+  const parsed = { check: false, replace: false };
+  for (let i = 0;i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--check")
+      parsed.check = true;
+    else if (arg === "--replace")
+      parsed.replace = true;
+    else if (arg === "--repos-dir")
+      parsed.reposDir = takeValue(args2, i++, arg);
+    else if (arg.startsWith("--"))
+      throw new Error(`unknown flag ${arg}`);
+    else if (parsed.pack)
+      throw new Error(`unexpected argument ${arg}`);
+    else
+      parsed.pack = arg;
+  }
+  return parsed;
+}
+function currentEnv() {
+  return {
+    platform: process.platform,
+    home: homedir7(),
+    dataDir: dataDir(),
+    claudeDir: process.env.CLAUDE_CONFIG_DIR ?? join53(homedir7(), ".claude")
+  };
+}
+async function openSql() {
+  const { openRawSqlite: openRawSqlite2 } = await Promise.resolve().then(() => (init_client(), exports_client));
+  return openRawSqlite2;
+}
+function questionFor(scan, migrations, env) {
+  return {
+    runcastleVersion: runcastleVersion(),
+    sourcePlatform: env.platform,
+    migrations,
+    targetFolders: scan.projects.filter((p) => p.repoMoves).map((p) => p.targetFolder),
+    dataBytes: scan.report.dataBytes,
+    repoBytes: scan.report.repoBytes
+  };
+}
+async function confirmed() {
+  if (!process.stdin.isTTY) {
+    console.error("Run with --yes to go ahead without a terminal to answer in.");
+    return false;
+  }
+  const prompt = createInterface6({ input: process.stdin, output: process.stdout });
+  const answer = await prompt.question(`
+Go ahead? (y/N) `);
+  prompt.close();
+  return /^y(es)?$/i.test(answer.trim());
+}
+async function runMoveCli(argv) {
+  const args2 = parseMoveArgs(argv);
+  const env = currentEnv();
+  const open4 = await openSql();
+  const flags = { replace: args2.replace, ...args2.reposDir ? { reposDir: args2.reposDir } : {} };
+  let sql5;
+  try {
+    sql5 = open4(join53(env.dataDir, "runcastle.db"), { readonly: true });
+  } catch {
+    console.error(`No runcastle database at ${env.dataDir}.`);
+    return 1;
+  }
+  let scan;
+  let migrations;
+  let windowsCommands;
+  try {
+    scan = scanMove(env, sql5, {
+      noRepo: args2.noRepo,
+      withEnv: args2.withEnv,
+      withClaudeSetup: args2.withClaudeSetup,
+      also: args2.also
+    });
+    migrations = sql5.all("SELECT name FROM __migrations").map((r) => r.name);
+    windowsCommands = windowsCommandLines(sql5, scan.projects, env);
+  } finally {
+    sql5.close();
+  }
+  const running3 = await serverRunning(env);
+  if (running3)
+    scan.report.blockers.unshift("this machine's runcastle server is running: stop it for a real move");
+  const destination = args2.host ? askDestination(args2.host, questionFor(scan, migrations, env), flags) : undefined;
+  const pack2 = args2.out ?? join53(tmpdir7(), `runcastle-move-${stamp()}.tar.gz`);
+  const room = freeBytes(dirname26(pack2));
+  const packMax = scan.report.dataBytes + scan.report.repoBytes;
+  if (room !== null && room < packMax) {
+    scan.report.blockers.push(`not enough disk beside the pack: up to ${formatBytes(packMax)} needed, ${formatBytes(room)} free. Choose another place with --out`);
+  }
+  const reportText = formatReport2(scan.report, destination, windowsCommands);
+  console.log(reportText);
+  if (args2.dryRun) {
+    console.log(`
+Nothing was changed.`);
+    return 0;
+  }
+  if (isBlocked(scan.report, destination)) {
+    console.error(`
+Nothing was changed. Clear the blocks above, then run this again.`);
+    return 1;
+  }
+  if (!args2.yes && !await confirmed()) {
+    console.log("Nothing was changed.");
+    return 0;
+  }
+  await packMove({ env, scan, open: open4, out: pack2, reportText, log: (line2) => console.log(line2) });
+  console.log(`
+Packed: ${pack2}`);
+  if (!args2.host) {
+    console.log(`
+Finish on the new machine with:`);
+    for (const line2 of manualSteps(pack2, undefined, flags))
+      console.log(`  ${line2}`);
+    return 0;
+  }
+  const copy4 = copyPack(pack2, args2.host);
+  if (!copy4.ok) {
+    console.error(failureMessage2("The copy", copy4.detail, pack2, args2.host, flags));
+    return 1;
+  }
+  const remote = runRemoteMoveIn(pack2, args2.host, flags);
+  if (!remote.ok) {
+    console.error(failureMessage2("The move on the other machine", remote.detail, pack2, args2.host, flags));
+    return 1;
+  }
+  rmSync13(pack2, { force: true });
+  console.log(`
+The move is finished. This machine is unchanged and must not be used for work now.`);
+  return 0;
+}
+async function readStdin() {
+  let text3 = "";
+  for await (const chunk of process.stdin)
+    text3 += String(chunk);
+  return text3;
+}
+async function runMoveInCli(argv) {
+  const args2 = parseMoveInArgs(argv);
+  const env = currentEnv();
+  const open4 = await openSql();
+  if (args2.check) {
+    const question = JSON.parse(await readStdin());
+    const answer = await checkDestination(question, env, {
+      replace: args2.replace,
+      open: open4,
+      ...args2.reposDir ? { reposDir: args2.reposDir } : {}
+    });
+    console.log(JSON.stringify(answer));
+    return 0;
+  }
+  if (!args2.pack) {
+    console.error("Usage: runcastle move-in <pack> [--replace] [--repos-dir <dir>]");
+    return 1;
+  }
+  const result = await moveIn({
+    pack: args2.pack,
+    env,
+    open: open4,
+    replace: args2.replace,
+    log: (line2) => console.log(line2),
+    ...args2.reposDir ? { reposDir: args2.reposDir } : {}
+  });
+  console.log(`
+${formatMoveInResult(result)}`);
+  return 0;
+}
+var init_cli2 = __esm(() => {
+  init_paths();
+  init_version();
+  init_destination();
+  init_pack();
+  init_remote();
+  init_report2();
+  init_scan();
+  init_shell();
+  init_unpack();
+});
+
 // src/bin/token.ts
 var exports_token = {};
 __export(exports_token, {
@@ -75461,7 +77594,7 @@ async function readAllStdin() {
   return Buffer.concat(chunks).toString("utf8");
 }
 function readHiddenFromTerminal() {
-  return new Promise((resolve16, reject) => {
+  return new Promise((resolve18, reject) => {
     const stdin3 = process.stdin;
     let value = "";
     let timer;
@@ -75487,7 +77620,7 @@ function readHiddenFromTerminal() {
           value += ch;
       }
       if (/[\r\n]/.test(value))
-        timer = setTimeout(() => finish(() => resolve16(value)), PASTE_QUIET_MS);
+        timer = setTimeout(() => finish(() => resolve18(value)), PASTE_QUIET_MS);
     };
     stdin3.setRawMode(true);
     stdin3.resume();
@@ -75559,14 +77692,14 @@ __export(exports_service, {
   runService: () => runService,
   SERVICE_USAGE: () => SERVICE_USAGE
 });
-import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync41, mkdtempSync as mkdtempSync2, rmSync as rmSync11, writeFileSync as writeFileSync22 } from "fs";
-import { homedir as homedir7, hostname, tmpdir as tmpdir7, userInfo as userInfo3 } from "os";
-import { join as join48 } from "path";
+import { spawnSync as spawnSync5 } from "child_process";
+import { existsSync as existsSync45, mkdtempSync as mkdtempSync3, rmSync as rmSync14, writeFileSync as writeFileSync23 } from "fs";
+import { homedir as homedir8, hostname, tmpdir as tmpdir8, userInfo as userInfo3 } from "os";
+import { join as join54 } from "path";
 function writeTempFile(text3) {
-  const dir = mkdtempSync2(join48(tmpdir7(), "runcastle-service-"));
-  const file = join48(dir, "runcastle.service");
-  writeFileSync22(file, text3, "utf8");
+  const dir = mkdtempSync3(join54(tmpdir8(), "runcastle-service-"));
+  const file = join54(dir, "runcastle.service");
+  writeFileSync23(file, text3, "utf8");
   return file;
 }
 function runSteps(steps, run7, log6) {
@@ -75586,7 +77719,7 @@ async function runService(argv, deps2 = {}) {
     return 1;
   }
   const platform = deps2.platform ?? process.platform;
-  const systemdPresent = deps2.systemdPresent ?? existsSync41("/run/systemd/system");
+  const systemdPresent = deps2.systemdPresent ?? existsSync45("/run/systemd/system");
   if (platform !== "linux" || !systemdPresent) {
     log6("A background service is not supported here: it needs Linux with systemd.");
     return 1;
@@ -75596,7 +77729,7 @@ async function runService(argv, deps2 = {}) {
     return 1;
   }
   const run7 = deps2.runStep ?? inheritStdio;
-  const existed = deps2.serviceFileExists ?? existsSync41(SERVICE_FILE_PATH);
+  const existed = deps2.serviceFileExists ?? existsSync45(SERVICE_FILE_PATH);
   if (action === "remove") {
     if (!existed) {
       log6("No runcastle service is installed. Nothing to remove.");
@@ -75612,7 +77745,7 @@ async function runService(argv, deps2 = {}) {
     return ok3 ? 0 : 1;
   }
   const user = deps2.user ?? userInfo3().username;
-  const home = deps2.home ?? homedir7();
+  const home = deps2.home ?? homedir8();
   const text3 = renderServiceFile({
     user,
     home,
@@ -75631,14 +77764,14 @@ async function runService(argv, deps2 = {}) {
       return 1;
   } finally {
     if (!deps2.writeTemp)
-      rmSync11(join48(tmp, ".."), { recursive: true, force: true });
+      rmSync14(join54(tmp, ".."), { recursive: true, force: true });
   }
   log6(existed ? "Replaced the existing runcastle service." : "Installed the runcastle service.");
   log6("Check it with: systemctl status runcastle");
   log6(`Reach the app from your own machine with: ssh -L 4512:localhost:4512 ${user}@${deps2.host ?? hostname()}`);
   return 0;
 }
-var SERVICE_USAGE, inheritStdio = (command, args2) => spawnSync3(command, args2, { stdio: "inherit" }).status ?? 1;
+var SERVICE_USAGE, inheritStdio = (command, args2) => spawnSync5(command, args2, { stdio: "inherit" }).status ?? 1;
 var init_service = __esm(() => {
   init_service_file();
   init_resolve_executable();
@@ -75693,7 +77826,7 @@ var init_build_image = __esm(() => {
 // src/bin/runcastle.ts
 init_asset_paths();
 init_version();
-import { dirname as dirname23, resolve as resolve16 } from "path";
+import { dirname as dirname27, resolve as resolve18 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 function parseCommand(argv) {
   const [first, ...rest] = argv;
@@ -75707,6 +77840,10 @@ function parseCommand(argv) {
     return { command: "setup", args: rest };
   if (first === "doctor")
     return { command: "doctor", args: rest };
+  if (first === "move")
+    return { command: "move", args: rest };
+  if (first === "move-in")
+    return { command: "move-in", args: rest };
   if (first === "token")
     return { command: "token", args: rest };
   if (first === "service")
@@ -75724,6 +77861,12 @@ Usage:
   runcastle serve      The same, spelled out for scripts and services
   runcastle setup      List what this machine is missing and install it (--yes, --agent claude|codex|both)
   runcastle doctor     Check prerequisites (add --gate for the pre-boot gate)
+  runcastle move [user@host] [--dry-run] [--yes] [--replace] [--with-env]
+                       [--with-claude-setup] [--also <project>:<path>]
+                       [--repos-dir <dir>] [--no-repo <project>] [--out <file>]
+                       Move runcastle to another machine; only reads this one
+  runcastle move-in <pack> [--replace] [--repos-dir <dir>]
+                       Bring a move in on this machine
   runcastle token      Save the unattended Claude Code token (--stdin to read it from a pipe)
   runcastle service install
                        Keep runcastle running on this Linux machine (service remove undoes it)
@@ -75733,7 +77876,7 @@ Usage:
   runcastle --help     Show this help
 `;
 async function main(argv) {
-  applyInstalledAssetEnv(resolve16(dirname23(fileURLToPath7(import.meta.url)), ".."));
+  applyInstalledAssetEnv(resolve18(dirname27(fileURLToPath7(import.meta.url)), ".."));
   const { command, args: args2 } = parseCommand(argv);
   switch (command) {
     case "version":
@@ -75750,6 +77893,14 @@ async function main(argv) {
       const { runCli: runCli2 } = await Promise.resolve().then(() => (init_cli(), exports_cli));
       return runCli2(args2);
     }
+    case "move": {
+      const { runMoveCli: runMoveCli2 } = await Promise.resolve().then(() => (init_cli2(), exports_cli2));
+      return runMoveCli2(args2);
+    }
+    case "move-in": {
+      const { runMoveInCli: runMoveInCli2 } = await Promise.resolve().then(() => (init_cli2(), exports_cli2));
+      return runMoveInCli2(args2);
+    }
     case "token": {
       const { runToken: runToken2 } = await Promise.resolve().then(() => (init_token(), exports_token));
       return runToken2(args2);