@rhseung/claude-mv 0.1.0

package/dist/index.js

@@ -0,0 +1,2801 @@
+#!/usr/bin/env node
+import {
+  PlainReporter
+} from "./chunk-JJSX2UL6.js";
+
+// src/index.ts
+import { existsSync as existsSync8, readdirSync as readdirSync5 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join12 } from "path";
+
+// package.json
+var package_default = {
+  name: "@rhseung/claude-mv",
+  version: "0.1.0",
+  description: "\uD504\uB85C\uC81D\uD2B8 \uB514\uB809\uD130\uB9AC\uB97C \uC62E\uAE30\uBA74\uC11C Claude Code \uD504\uB85C\uC81D\uD2B8 \uC0C1\uD0DC\uAE4C\uC9C0 \uAC19\uC774 \uC62E\uAE41\uB2C8\uB2E4",
+  type: "module",
+  license: "MIT",
+  author: "rhseung <ryu@rhseung.me>",
+  homepage: "https://github.com/rhseung/claude-mv#readme",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/rhseung/claude-mv.git"
+  },
+  bugs: {
+    url: "https://github.com/rhseung/claude-mv/issues"
+  },
+  keywords: [
+    "claude",
+    "claude-code",
+    "cli",
+    "mv",
+    "rename",
+    "migration"
+  ],
+  bin: {
+    "claude-mv": "dist/index.js"
+  },
+  files: [
+    "dist",
+    "LICENSE"
+  ],
+  engines: {
+    node: ">=20"
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    format: "prettier --check .",
+    check: "prettier --write . && eslint . --fix",
+    lint: "eslint .",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:watch": "vitest",
+    "sync:version": "bun scripts/sync-version.ts",
+    verify: "bun run format && bun run lint && bun run typecheck && bun run test",
+    version: "bun run sync:version && bun run build && git add plugin",
+    prepublishOnly: "bun run build",
+    prepare: "husky"
+  },
+  dependencies: {
+    "@inkjs/ui": "^2.0.0",
+    "env-paths": "^3.0.0",
+    execa: "^9.6.0",
+    "fastest-levenshtein": "^1.0.16",
+    "fs-extra": "^11.3.2",
+    fzf: "^0.5.2",
+    ink: "^5.2.1",
+    "jsonc-parser": "^3.3.1",
+    "p-limit": "^7.3.3",
+    "pretty-bytes": "^7.1.3",
+    "pretty-ms": "^9.3.1",
+    "proper-lockfile": "^4.1.2",
+    "ps-list": "^9.0.0",
+    react: "^18.3.1",
+    "string-width": "^8.2.2",
+    tar: "^7.5.7",
+    ulid: "^3.0.2",
+    "write-file-atomic": "^8.0.0"
+  },
+  devDependencies: {
+    "@eslint/js": "^10.0.1",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^26.2.0",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/react": "^18.3.12",
+    "@types/write-file-atomic": "^4.0.3",
+    eslint: "^10.8.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-check-file": "^3.3.2",
+    "eslint-plugin-import-x": "^4.17.1",
+    "eslint-plugin-unused-imports": "^4.4.1",
+    globals: "^17.9.0",
+    husky: "^9.1.7",
+    "ink-testing-library": "^4.0.0",
+    prettier: "^3.9.6",
+    tempy: "^3.1.0",
+    tsup: "^8.5.0",
+    typescript: "^6.0.3",
+    "typescript-eslint": "^8.66.0",
+    vitest: "^4.1.10"
+  }
+};
+
+// src/cli/commands.ts
+var MUTATING_ARGS = {
+  "dry-run": { kind: "boolean", alias: "n", description: "\uACC4\uD68D\uB9CC \uBCF4\uC5EC\uC8FC\uACE0 \uC544\uBB34\uAC83\uB3C4 \uC4F0\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4" },
+  yes: { kind: "boolean", alias: "y", description: "\uD655\uC778 \uD504\uB86C\uD504\uD2B8\uB97C \uAC74\uB108\uB701\uB2C8\uB2E4" },
+  force: { kind: "boolean", alias: "f", description: "lock \uACFC \uC0C1\uD0DC \uCDA9\uB3CC\uC744 \uACBD\uACE0\uB85C \uB0AE\uCDA5\uB2C8\uB2E4" },
+  "no-backup": { kind: "boolean", description: "\uBC31\uC5C5\uC744 \uB9CC\uB4E4\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4 (rollback \uBD88\uAC00)" }
+};
+var COMMON_ARGS = {
+  json: { kind: "boolean", description: "\uAE30\uACC4\uC6A9 JSON \uC73C\uB85C \uCD9C\uB825\uD569\uB2C8\uB2E4" },
+  quiet: { kind: "boolean", alias: "q", description: "\uC624\uB958\uB9CC \uCD9C\uB825\uD569\uB2C8\uB2E4" },
+  "claude-home": { kind: "string", description: "~/.claude \uC704\uCE58\uB97C \uC7AC\uC815\uC758\uD569\uB2C8\uB2E4" }
+};
+var COMMANDS = [
+  {
+    name: "mv",
+    summary: "\uB514\uB809\uD130\uB9AC\uB97C \uC62E\uAE30\uACE0 Claude \uC0C1\uD0DC\uB97C \uB530\uB77C \uC62E\uAE41\uB2C8\uB2E4",
+    positionals: [
+      { name: "src", complete: "project", required: true },
+      { name: "dst", complete: "directory", required: true }
+    ],
+    args: {
+      ...MUTATING_ARGS,
+      ...COMMON_ARGS,
+      "state-only": { kind: "boolean", description: "\uB514\uB809\uD130\uB9AC\uB294 \uB450\uACE0 \uC0C1\uD0DC\uB9CC \uC62E\uAE41\uB2C8\uB2E4" },
+      "rewrite-prose": { kind: "boolean", description: "\uB300\uD654 \uBCF8\uBB38\uC758 \uACBD\uB85C\uAE4C\uC9C0 \uBC14\uAFC9\uB2C8\uB2E4" },
+      "allow-ancestors": { kind: "boolean", description: "\uC0C1\uC704\uC5D0\uC11C \uB3C4\uB294 \uC138\uC158\uC744 \uD5C8\uC6A9\uD569\uB2C8\uB2E4" },
+      "skip-live": {
+        kind: "boolean",
+        description: "\uC0B4\uC544 \uC788\uB294 \uC138\uC158\uC758 \uD2B8\uB79C\uC2A4\uD06C\uB9BD\uD2B8\uB294 \uAC74\uB4DC\uB9AC\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4"
+      }
+    }
+  },
+  {
+    name: "ls",
+    summary: "Claude \uAC00 \uC544\uB294 \uD504\uB85C\uC81D\uD2B8\uB97C \uBAA8\uB450 \uBCF4\uC5EC\uC90D\uB2C8\uB2E4",
+    positionals: [],
+    args: {
+      ...COMMON_ARGS,
+      orphans: { kind: "boolean", description: "\uC5F0\uACB0\uC774 \uB04A\uAE34 \uC0C1\uD0DC\uB9CC \uBCF4\uC5EC\uC90D\uB2C8\uB2E4" },
+      sort: {
+        kind: "string",
+        description: "\uC815\uB82C \uAE30\uC900",
+        values: ["activity", "size", "path"],
+        default: "activity"
+      }
+    }
+  },
+  {
+    name: "info",
+    summary: "\uD55C \uD504\uB85C\uC81D\uD2B8\uC758 \uC0C1\uD0DC\uB97C \uC790\uC138\uD788 \uBCF4\uC5EC\uC90D\uB2C8\uB2E4",
+    positionals: [{ name: "target", complete: "project", required: false }],
+    args: COMMON_ARGS
+  },
+  {
+    name: "doctor",
+    summary: "\uC5F0\uACB0\uC774 \uB04A\uAE34 \uC0C1\uD0DC\uB97C \uCC3E\uC544\uB0B4\uACE0 \uC5B4\uB514\uB85C \uC62E\uACA8\uC84C\uB294\uC9C0 \uCD94\uC815\uD569\uB2C8\uB2E4",
+    positionals: [],
+    args: COMMON_ARGS
+  },
+  {
+    name: "rm",
+    summary: "\uD55C \uD504\uB85C\uC81D\uD2B8\uC758 Claude \uC0C1\uD0DC\uB97C \uC9C0\uC6C1\uB2C8\uB2E4",
+    positionals: [{ name: "target", complete: "project", required: false }],
+    args: { ...MUTATING_ARGS, ...COMMON_ARGS }
+  },
+  {
+    name: "merge",
+    summary: "\uB450 \uD504\uB85C\uC81D\uD2B8 \uB514\uB809\uD130\uB9AC\uB97C \uD569\uCE69\uB2C8\uB2E4",
+    positionals: [
+      { name: "from", complete: "project", required: true },
+      { name: "to", complete: "project", required: true }
+    ],
+    args: { ...MUTATING_ARGS, ...COMMON_ARGS }
+  },
+  {
+    name: "backup",
+    summary: "\uC774\uB3D9 \uC5C6\uC774 \uD604\uC7AC \uC0C1\uD0DC\uC758 \uC2A4\uB0C5\uC0F7\uB9CC \uB9CC\uB4ED\uB2C8\uB2E4",
+    positionals: [{ name: "target", complete: "project", required: false }],
+    args: COMMON_ARGS
+  },
+  {
+    name: "rollback",
+    summary: "\uBC31\uC5C5 \uBAA9\uB85D\uC744 \uBCF4\uAC70\uB098 \uC9C0\uC815\uD55C \uBC31\uC5C5\uC73C\uB85C \uB418\uB3CC\uB9BD\uB2C8\uB2E4",
+    positionals: [{ name: "id", complete: "backup", required: false }],
+    args: COMMON_ARGS
+  },
+  {
+    name: "export",
+    summary: "\uD504\uB85C\uC81D\uD2B8 \uC0C1\uD0DC\uB97C tarball \uB85C \uB0B4\uBCF4\uB0C5\uB2C8\uB2E4",
+    positionals: [{ name: "target", complete: "project", required: false }],
+    args: { ...COMMON_ARGS, out: { kind: "string", alias: "o", description: "\uCD9C\uB825 \uD30C\uC77C" } }
+  },
+  {
+    name: "import",
+    summary: "tarball \uC5D0\uC11C \uC0C1\uD0DC\uB97C \uB4E4\uC5EC\uC635\uB2C8\uB2E4",
+    positionals: [{ name: "file", complete: "bundle", required: true }],
+    args: {
+      ...COMMON_ARGS,
+      to: { kind: "string", description: "\uB4E4\uC5EC\uC624\uBA74\uC11C \uC774 \uACBD\uB85C\uB85C \uC774\uAD00\uD569\uB2C8\uB2E4" }
+    }
+  },
+  {
+    name: "completion",
+    summary: "\uC178 \uC790\uB3D9\uC644\uC131 \uC2A4\uD06C\uB9BD\uD2B8\uB97C \uCD9C\uB825\uD569\uB2C8\uB2E4",
+    positionals: [{ name: "shell", complete: "shell", required: true }],
+    args: {}
+  }
+];
+var COMMAND_NAMES = COMMANDS.map((c) => c.name);
+function findCommand(name) {
+  return COMMANDS.find((c) => c.name === name);
+}
+var VALUE_FLAGS = new Set(
+  COMMANDS.flatMap(
+    (command) => Object.entries(command.args).filter(([, arg]) => arg.kind === "string").flatMap(([name, arg]) => arg.alias ? [`--${name}`, `-${arg.alias}`] : [`--${name}`])
+  )
+);
+function dispatch(argv) {
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--") return { command: "mv", rest: argv.slice(i + 1) };
+    if (token === "__complete") return { command: "__complete", rest: argv.slice(i + 1) };
+    if (token.startsWith("-")) {
+      if (!token.includes("=") && VALUE_FLAGS.has(token)) i++;
+      continue;
+    }
+    if (COMMAND_NAMES.includes(token)) {
+      return { command: token, rest: [...argv.slice(0, i), ...argv.slice(i + 1)] };
+    }
+    break;
+  }
+  return { command: "mv", rest: argv };
+}
+
+// src/cli/complete.ts
+function complete(argv, sources) {
+  const [commandName, ...rest] = argv;
+  if (rest.length === 0 && !COMMANDS.some((c) => c.name === commandName)) {
+    return COMMANDS.filter((c) => c.name.startsWith(commandName ?? "")).map((c) => ({
+      value: c.name,
+      description: c.summary
+    }));
+  }
+  const spec = findCommand(commandName ?? "") ?? findCommand("mv");
+  const current = rest.at(-1) ?? "";
+  if (current.startsWith("-")) {
+    const [flagName, inlineValue] = current.split("=");
+    const arg = spec.args[flagName?.replace(/^--?/, "") ?? ""];
+    if (arg?.values && inlineValue !== void 0) {
+      return arg.values.filter((v) => v.startsWith(inlineValue)).map((v) => ({ value: `${flagName}=${v}` }));
+    }
+    return Object.entries(spec.args).map(([name, meta]) => ({ value: `--${name}`, description: meta.description })).filter((c) => c.value.startsWith(current));
+  }
+  const consumed = rest.filter((token) => !token.startsWith("-"));
+  const index = Math.max(0, consumed.length - 1);
+  const positional = spec.positionals[index];
+  return filterByPrefix(candidatesFor(positional?.complete ?? "none", current, sources), current);
+}
+function candidatesFor(source, prefix, sources) {
+  switch (source) {
+    case "project":
+      return sources.projects();
+    case "backup":
+      return sources.backups();
+    case "directory":
+      return sources.directories(prefix);
+    case "bundle":
+      return sources.bundles(prefix);
+    case "shell":
+      return [{ value: "zsh" }, { value: "bash" }, { value: "fish" }];
+    case "none":
+      return [];
+  }
+}
+function filterByPrefix(candidates, prefix) {
+  return prefix ? candidates.filter((c) => c.value.startsWith(prefix)) : candidates;
+}
+function formatCandidates(candidates) {
+  return candidates.map((c) => c.description ? `${c.value}	${c.description}` : c.value).join("\n");
+}
+
+// src/cli/completion/index.ts
+function completionScript(shell, bin = "claude-mv") {
+  switch (shell) {
+    case "zsh":
+      return zsh(bin);
+    case "bash":
+      return bash(bin);
+    case "fish":
+      return fish(bin);
+  }
+}
+function zsh(bin) {
+  return `#compdef ${bin}
+
+_${bin.replace(/-/g, "_")}() {
+  local -a lines values descriptions
+  local line value
+
+  lines=(\${(f)"$(${bin} __complete "\${(@)words[2,$CURRENT]}" 2>/dev/null)"})
+
+  for line in $lines; do
+    [[ -z "$line" ]] && continue
+    value=\${line%%$'\\t'*}
+    values+=("$value")
+    if [[ "$line" == *$'\\t'* ]]; then
+      descriptions+=("\${value} -- \${line#*$'\\t'}")
+    else
+      descriptions+=("$value")
+    fi
+  done
+
+  (( \${#values} )) || return 1
+  compadd -Q -d descriptions -a values
+}
+
+compdef _${bin.replace(/-/g, "_")} ${bin}
+`;
+}
+function bash(bin) {
+  return `_${bin.replace(/-/g, "_")}() {
+  local IFS=$'\\n'
+  local candidates
+  candidates=( $(${bin} __complete "\${COMP_WORDS[@]:1:COMP_CWORD}" 2>/dev/null | cut -f1) )
+  COMPREPLY=( $(compgen -W "\${candidates[*]}" -- "\${COMP_WORDS[COMP_CWORD]}") )
+}
+
+complete -o default -F _${bin.replace(/-/g, "_")} ${bin}
+`;
+}
+function fish(bin) {
+  return `function __${bin.replace(/-/g, "_")}_complete
+  set -l tokens (commandline -opc) (commandline -ct)
+  ${bin} __complete $tokens[2..-1] 2>/dev/null
+end
+
+complete -c ${bin} -f -a '(__${bin.replace(/-/g, "_")}_complete)'
+`;
+}
+
+// src/cli/exit.ts
+var EXITS = {
+  ok: [0, "\uC131\uACF5"],
+  internal: [1, "\uC608\uAE30\uCE58 \uBABB\uD55C \uC624\uB958"],
+  usage: [2, "\uC0AC\uC6A9\uBC95 \uC624\uB958"],
+  planned: [10, "\uACC4\uD68D \uC0DD\uC131 \uC644\uB8CC. \uC2E4\uD328\uAC00 \uC544\uB2D8"],
+  orphans: [11, "\uC5F0\uACB0\uC774 \uB04A\uAE34 \uC0C1\uD0DC \uBC1C\uACAC"],
+  nothingToDo: [12, "\uC774\uAD00 \uB300\uC0C1 \uC5C6\uC74C"],
+  locked: [20, "\uC61B \uACBD\uB85C\uC5D0\uC11C \uC138\uC158 \uC2E4\uD589 \uC911"],
+  conflict: [21, "\uB300\uC0C1 \uACBD\uB85C\uC5D0 \uC0C1\uD0DC\uAC00 \uC774\uBBF8 \uC874\uC7AC"],
+  precondition: [22, "\uC804\uC81C \uC870\uAC74 \uC704\uBC18"],
+  failedRolledBack: [30, "\uC2E4\uD328 \uD6C4 \uC804\uCCB4 \uBCF5\uAD6C \uC644\uB8CC"],
+  failedDirty: [31, "\uC2E4\uD328 \uD6C4 \uBCF5\uAD6C\uB3C4 \uC2E4\uD328. \uC218\uB3D9 \uBCF5\uAD6C \uD544\uC694"],
+  io: [40, "\uD30C\uC77C\uC2DC\uC2A4\uD15C \uC624\uB958"],
+  interrupted: [130, "\uC0AC\uC6A9\uC790 \uC911\uB2E8"]
+};
+var ExitCode = Object.fromEntries(
+  Object.entries(EXITS).map(([name, [code]]) => [name, code])
+);
+var exitCodeTable = Object.values(EXITS);
+var CliError = class extends Error {
+  constructor(message, code = "usage", hint) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+    this.name = "CliError";
+  }
+  code;
+  hint;
+};
+
+// src/cli/help.ts
+function helpText(commandName) {
+  const spec = commandName ? findCommand(commandName) : void 0;
+  if (!spec) return rootHelp();
+  const lines = [
+    `claude-mv ${spec.name} - ${spec.summary}`,
+    "",
+    `\uC0AC\uC6A9\uBC95  claude-mv ${spec.name} ${spec.positionals.map((p) => p.required ? `<${p.name}>` : `[${p.name}]`).join(" ")} [\uC635\uC158]`
+  ];
+  const args = Object.entries(spec.args);
+  if (args.length > 0) {
+    lines.push("", "\uC635\uC158");
+    const width = Math.max(...args.map(([n, a]) => n.length + (a.alias ? 4 : 0)));
+    for (const [name, arg] of args) {
+      const flag = `${arg.alias ? `-${arg.alias}, ` : ""}--${name}`;
+      lines.push(`  ${flag.padEnd(width + 6)}${arg.description}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function rootHelp() {
+  const width = Math.max(...COMMANDS.map((c) => c.name.length));
+  return [
+    "claude-mv - \uD504\uB85C\uC81D\uD2B8 \uB514\uB809\uD130\uB9AC\uB97C \uC62E\uAE30\uBA74\uC11C Claude Code \uC0C1\uD0DC\uAE4C\uC9C0 \uAC19\uC774 \uC62E\uAE41\uB2C8\uB2E4",
+    "",
+    "\uC0AC\uC6A9\uBC95  claude-mv <src> <dst>        \uB514\uB809\uD130\uB9AC\uC640 \uC0C1\uD0DC\uB97C \uD568\uAED8 \uC62E\uAE41\uB2C8\uB2E4",
+    "        claude-mv <\uBA85\uB839> [\uC778\uC790]",
+    "",
+    "\uBA85\uB839",
+    ...COMMANDS.map((c) => `  ${c.name.padEnd(width + 2)}${c.summary}`),
+    "",
+    "\uC885\uB8CC \uCF54\uB4DC",
+    ...exitCodeTable.map(([code, why]) => `  ${String(code).padStart(3)}  ${why}`),
+    "",
+    '\uC790\uB3D9\uC644\uC131  eval "$(claude-mv completion zsh)"',
+    ""
+  ].join("\n");
+}
+
+// src/cli/parse.ts
+function parseArgs(spec, argv) {
+  const positionals = [];
+  const flags = {};
+  const byAlias = /* @__PURE__ */ new Map();
+  for (const [name, arg] of Object.entries(spec.args)) {
+    if (arg.alias) byAlias.set(arg.alias, name);
+  }
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--") {
+      positionals.push(...argv.slice(i + 1));
+      break;
+    }
+    if (!token.startsWith("-")) {
+      positionals.push(token);
+      continue;
+    }
+    const isLong = token.startsWith("--");
+    const body = isLong ? token.slice(2) : token.slice(1);
+    const [rawName, inlineValue] = splitOnce(body, "=");
+    const name = isLong ? rawName : byAlias.get(rawName) ?? rawName;
+    const arg = spec.args[name];
+    if (!arg && isLong && name.startsWith("no-")) {
+      const positive = name.slice(3);
+      if (spec.args[positive]?.kind === "boolean") {
+        flags[positive] = false;
+        continue;
+      }
+    }
+    if (!arg) throw new CliError(`\uC54C \uC218 \uC5C6\uB294 \uC635\uC158\uC785\uB2C8\uB2E4: ${token}`, "usage");
+    if (arg.kind === "boolean") {
+      flags[name] = inlineValue === void 0 ? true : inlineValue !== "false";
+      continue;
+    }
+    const value = inlineValue ?? argv[++i];
+    if (value === void 0) throw new CliError(`${token}\uC5D0 \uAC12\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.`, "usage");
+    if (arg.values && !arg.values.includes(value)) {
+      throw new CliError(`${token}\uC740 ${arg.values.join(" | ")} \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4.`, "usage");
+    }
+    flags[name] = value;
+  }
+  for (const [name, arg] of Object.entries(spec.args)) {
+    if (arg.default !== void 0 && flags[name] === void 0) flags[name] = arg.default;
+  }
+  return { positionals, flags };
+}
+function splitOnce(value, separator) {
+  const index = value.indexOf(separator);
+  return index === -1 ? [value, void 0] : [value.slice(0, index), value.slice(index + 1)];
+}
+function requirePositionals(spec, parsed) {
+  const required = spec.positionals.filter((p) => p.required);
+  if (parsed.positionals.length < required.length) {
+    throw new CliError(
+      `${spec.name}\uC5D0\uB294 ${required.map((p) => `<${p.name}>`).join(" ")}\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.`,
+      "usage"
+    );
+  }
+  return parsed.positionals;
+}
+var bool = (parsed, name) => parsed.flags[name] === true;
+var str = (parsed, name) => typeof parsed.flags[name] === "string" ? parsed.flags[name] : void 0;
+
+// src/cli/picker.ts
+import { execa } from "execa";
+function resolvePickerMode(env) {
+  if (!env.isTTY) return "none";
+  if (env.override === "none") return "none";
+  if (env.override === "ink") return "ink";
+  if (env.override === "fzf") return "fzf";
+  return env.hasFzf ? "fzf" : "ink";
+}
+async function hasFzf() {
+  try {
+    await execa("fzf", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pickWithFzf(candidates, opts) {
+  if (candidates.length === 0) return null;
+  const args = ["--height=40%", "--reverse", `--prompt=${opts.prompt} `, "--with-nth=1.."];
+  if (opts.preview) args.push("--preview", opts.preview, "--preview-window=right,60%");
+  try {
+    const { stdout } = await execa("fzf", args, {
+      input: candidates.map((c) => c.description ? `${c.value}	${c.description}` : c.value).join("\n"),
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "inherit"
+    });
+    const picked = stdout.trim().split("	")[0];
+    return picked || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/manage.ts
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync5,
+  readdirSync as readdirSync4,
+  renameSync as renameSync3,
+  rmSync as rmSync3,
+  statSync as statSync5
+} from "fs";
+import { join as join7 } from "path";
+import { ulid } from "ulid";
+import writeFileAtomic2 from "write-file-atomic";
+
+// src/core/doctor.ts
+import { distance } from "fastest-levenshtein";
+
+// src/core/mangle.ts
+var MANGLE_MAX = 200;
+function mangleHash(input) {
+  let h = 0;
+  for (let i = 0; i < input.length; i++) {
+    h = (h << 5) - h + input.charCodeAt(i) | 0;
+  }
+  return h;
+}
+function mangle(absolutePath) {
+  const replaced = absolutePath.replace(/[^a-zA-Z0-9]/g, "-");
+  if (replaced.length <= MANGLE_MAX) return replaced;
+  return `${replaced.slice(0, MANGLE_MAX)}-${Math.abs(mangleHash(absolutePath)).toString(36)}`;
+}
+
+// src/core/paths.ts
+import { realpathSync, statSync } from "fs";
+import path from "path";
+function defaultCasePolicy(platform) {
+  if (platform === "win32") return "insensitive";
+  if (platform === "darwin") return "insensitive";
+  return "sensitive";
+}
+function probeCasePolicy(dir, fallback) {
+  const flipped = flipCase(dir);
+  if (flipped === dir) return fallback;
+  try {
+    const a = statSync(dir);
+    const b = statSync(flipped);
+    return a.ino === b.ino && a.dev === b.dev ? "insensitive" : "sensitive";
+  } catch {
+    return "sensitive";
+  }
+}
+function flipCase(input) {
+  return input.replace(
+    /[a-zA-Z]/,
+    (c) => c === c.toLowerCase() ? c.toUpperCase() : c.toLowerCase()
+  );
+}
+function normalizePath(input, opts) {
+  const p = opts.platform === "win32" ? path.win32 : path.posix;
+  let out = input;
+  if (out === "~") out = opts.home;
+  else if (out.startsWith("~/") || opts.platform === "win32" && out.startsWith("~\\")) {
+    out = p.join(opts.home, out.slice(2));
+  }
+  if (opts.platform === "win32") {
+    out = stripLongPathPrefix(out);
+  }
+  out = p.resolve(out);
+  if (opts.realpath !== false) {
+    try {
+      out = realpathSync.native(out);
+      if (opts.platform === "win32") out = stripLongPathPrefix(out);
+    } catch {
+    }
+  }
+  out = stripTrailingSeparator(out, p);
+  if (opts.platform === "win32") out = upperDriveLetter(out);
+  return out;
+}
+function stripLongPathPrefix(input) {
+  if (input.startsWith("\\\\?\\UNC\\")) return `\\\\${input.slice(8)}`;
+  if (input.startsWith("\\\\?\\")) return input.slice(4);
+  return input;
+}
+function upperDriveLetter(input) {
+  return /^[a-z]:/.test(input) ? input[0].toUpperCase() + input.slice(1) : input;
+}
+function stripTrailingSeparator(input, p) {
+  if (input === p.parse(input).root) return input;
+  let out = input;
+  while (out.length > 1 && (out.endsWith(p.sep) || out.endsWith("/"))) out = out.slice(0, -1);
+  return out;
+}
+function fold(input, policy) {
+  return policy === "insensitive" ? input.replace(/[A-Z]/g, (c) => c.toLowerCase()) : input;
+}
+function pathEquals(a, b, policy) {
+  return fold(a, policy) === fold(b, policy);
+}
+function isUnder(child, parent, policy, platform = "linux") {
+  const p = platform === "win32" ? path.win32 : path.posix;
+  const a = fold(child, policy);
+  const b = fold(parent, policy);
+  const rel = p.relative(b, a);
+  return Boolean(rel && rel !== ".." && !rel.startsWith(`..${p.sep}`) && !p.isAbsolute(rel));
+}
+function reparent(value, from, to, policy, platform) {
+  const p = platform === "win32" ? path.win32 : path.posix;
+  if (!p.isAbsolute(value)) return void 0;
+  if (pathEquals(value, from, policy)) return to;
+  if (!isUnder(value, from, policy, platform)) return void 0;
+  return p.join(to, value.slice(from.length));
+}
+
+// src/core/doctor.ts
+function doctor(opts) {
+  const { index } = opts;
+  const orphans = [];
+  const healthy = [];
+  const other = [];
+  for (const project of index.projects) {
+    if (project.health === "healthy") {
+      healthy.push(project);
+      continue;
+    }
+    const entry = {
+      project,
+      alsoIn: locateElsewhere(index, project, opts.policy),
+      suggestions: project.primaryCwd ? suggest(project.primaryCwd, opts) : []
+    };
+    if (project.health === "orphaned") orphans.push(entry);
+    else other.push(entry);
+  }
+  return {
+    orphans: orphans.sort((a, b) => b.project.bytes - a.project.bytes),
+    healthy,
+    other,
+    collisions: findCollisions(index)
+  };
+}
+function locateElsewhere(index, project, policy) {
+  const path3 = project.primaryCwd;
+  if (!path3) return [];
+  const out = [];
+  if (index.configProjectKeys.some((k) => pathEquals(k, path3, policy))) out.push("config");
+  if ([...index.historyProjects.keys()].some((p) => pathEquals(p, path3, policy))) {
+    out.push("history");
+  }
+  if (index.cacheDirs.includes(project.dirName)) out.push("cache");
+  return out;
+}
+function findCollisions(index) {
+  const out = [];
+  for (const project of index.projects) {
+    const distinct = [...project.cwdCensus.keys()].filter((p) => mangle(p) === project.dirName);
+    if (distinct.length > 1) out.push({ dirName: project.dirName, paths: distinct });
+  }
+  return out;
+}
+function suggest(missing, opts) {
+  const name = opts.basename(missing);
+  const parent = opts.dirname(missing);
+  const found = /* @__PURE__ */ new Map();
+  const consider = (candidate, weight, evidence) => {
+    if (!opts.exists(candidate) || pathEquals(candidate, missing, opts.policy)) return;
+    const prev = found.get(candidate);
+    if (prev) {
+      prev.confidence = Math.min(1, prev.confidence + weight);
+      prev.evidence.push(evidence);
+      return;
+    }
+    found.set(candidate, { candidate, confidence: weight, evidence: [evidence] });
+  };
+  for (const root of /* @__PURE__ */ new Set([parent, ...opts.searchRoots])) {
+    for (const child of opts.listDirs(root)) {
+      const candidate = opts.join(root, child);
+      if (child === name) consider(candidate, 0.45, "\uC774\uB984\uC774 \uAC19\uC2B5\uB2C8\uB2E4");
+      else if (distance(child, name) <= Math.max(2, Math.floor(name.length / 3))) {
+        consider(candidate, 0.2, "\uC774\uB984\uC774 \uBE44\uC2B7\uD569\uB2C8\uB2E4");
+      }
+      if (root === parent && opts.exists(parent)) consider(candidate, 0.15, "\uAC19\uC740 \uBD80\uBAA8 \uC548\uC785\uB2C8\uB2E4");
+    }
+  }
+  return [...found.values()].filter((s) => s.confidence >= 0.4).sort((a, b) => b.confidence - a.confidence).slice(0, 3);
+}
+
+// src/shared/context.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { basename, dirname, join as join3 } from "path";
+
+// src/shared/env.ts
+import { existsSync, readdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import envPaths from "env-paths";
+function readRawEnv() {
+  return { env: process.env, home: homedir(), platform: process.platform };
+}
+function resolveClaudeHome(raw) {
+  return (raw.env.CLAUDE_CONFIG_DIR ?? join(raw.home, ".claude")).normalize("NFC");
+}
+function resolveConfigPath(raw, claudeHome) {
+  const preferred = join(claudeHome, ".config.json");
+  if (existsSync(preferred)) return preferred;
+  const base = raw.env.CLAUDE_CONFIG_DIR ?? raw.home;
+  const plain = join(base, ".claude.json");
+  if (existsSync(plain)) return plain;
+  const variant = safeReaddir(base).find(
+    (name) => name.startsWith(".claude-") && name.endsWith("-oauth.json")
+  );
+  return variant ? join(base, variant) : plain;
+}
+function safeReaddir(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+function resolveCacheRoot() {
+  const root = envPaths("claude-cli").cache;
+  return existsSync(root) ? root : null;
+}
+function resolveClaudeEnv(overrides) {
+  const raw = readRawEnv();
+  const claudeHome = overrides?.claudeHome ? overrides.claudeHome.normalize("NFC") : resolveClaudeHome(raw);
+  return {
+    claudeHome,
+    configPath: resolveConfigPath(raw, claudeHome),
+    projectsDir: join(claudeHome, "projects"),
+    historyPath: join(claudeHome, "history.jsonl"),
+    sessionsDir: join(claudeHome, "sessions"),
+    plansDir: join(claudeHome, "plans"),
+    cacheRoot: resolveCacheRoot(),
+    toolDir: join(claudeHome, ".claude-mv"),
+    platform: raw.platform
+  };
+}
+function readCliEnv() {
+  return {
+    ci: Boolean(process.env.CI),
+    term: process.env.TERM,
+    picker: process.env.CLAUDE_MV_PICKER,
+    isStdoutTTY: Boolean(process.stdout.isTTY),
+    isStdinTTY: Boolean(process.stdin.isTTY)
+  };
+}
+
+// src/shared/process.ts
+import { execa as execa2 } from "execa";
+async function startedAt(pid, platform) {
+  try {
+    if (platform === "win32") {
+      const { stdout: stdout2 } = await execa2("powershell.exe", [
+        "-NoProfile",
+        "-Command",
+        `(Get-Process -Id ${pid}).StartTime.ToUniversalTime().ToString('o')`
+      ]);
+      const parsed2 = Date.parse(stdout2.trim());
+      return Number.isNaN(parsed2) ? null : parsed2;
+    }
+    const { stdout } = await execa2("ps", ["-o", "lstart=", "-p", String(pid)]);
+    const parsed = Date.parse(stdout.trim());
+    return Number.isNaN(parsed) ? null : parsed;
+  } catch {
+    return null;
+  }
+}
+function createProcessProbe(platform) {
+  return {
+    async exists(pid) {
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch (error) {
+        return error.code === "EPERM";
+      }
+    },
+    startedAt: (pid) => startedAt(pid, platform),
+    self: process.pid
+  };
+}
+
+// src/core/scan.ts
+import { readFile, readdir, stat as stat2 } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/core/jsonl.ts
+import { createHash } from "crypto";
+import { createReadStream, createWriteStream } from "fs";
+import { chmod, open, rename, stat, unlink } from "fs/promises";
+import path2 from "path";
+
+// src/core/fields.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function visitField(holder, key, visit) {
+  if (!isRecord(holder)) return false;
+  const current = holder[key];
+  if (typeof current !== "string") return false;
+  const next = visit(current);
+  if (next === void 0 || next === current) return false;
+  holder[key] = next;
+  return true;
+}
+function visitArray(holder, key, visit) {
+  if (!isRecord(holder)) return false;
+  const arr = holder[key];
+  if (!Array.isArray(arr)) return false;
+  let changed = false;
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    if (typeof item !== "string") continue;
+    const next = visit(item);
+    if (next !== void 0 && next !== item) {
+      arr[i] = next;
+      changed = true;
+    }
+  }
+  return changed;
+}
+function visitCwdFields(record, visit) {
+  if (!isRecord(record)) return false;
+  let changed = false;
+  changed = visitField(record, "cwd", visit) || changed;
+  const wire = record.wireIngestContext;
+  if (isRecord(wire)) {
+    for (const key of Object.keys(wire)) {
+      changed = visitField(wire[key], "cwd", visit) || changed;
+    }
+  }
+  const snapshot = isRecord(record.attachment) ? record.attachment.snapshot : void 0;
+  if (isRecord(snapshot)) {
+    changed = visitField(snapshot, "workingDirectory", visit) || changed;
+    changed = visitArray(snapshot, "additionalWorkingDirectories", visit) || changed;
+  }
+  return changed;
+}
+function visitOtherStructuralFields(record, visit) {
+  if (!isRecord(record)) return false;
+  let changed = false;
+  changed = visitField(record, "trackingPath", visit) || changed;
+  const attachment = record.attachment;
+  if (isRecord(attachment)) {
+    changed = visitField(attachment, "path", visit) || changed;
+    changed = visitField(attachment, "planFilePath", visit) || changed;
+    if (Array.isArray(attachment.changes)) {
+      for (const change of attachment.changes) {
+        changed = visitField(change, "from", visit) || changed;
+      }
+    }
+  }
+  const message = record.message;
+  if (isRecord(message) && Array.isArray(message.content)) {
+    for (const block of message.content) {
+      if (!isRecord(block)) continue;
+      changed = visitField(block.input, "planFilePath", visit) || changed;
+    }
+  }
+  return changed;
+}
+function visitStructuralPaths(record, visit) {
+  const cwds = visitCwdFields(record, visit);
+  const others = visitOtherStructuralFields(record, visit);
+  return cwds || others;
+}
+function visitProsePaths(record, visit) {
+  if (!isRecord(record)) return false;
+  let changed = false;
+  changed = visitField(record.toolUseResult, "stdout", visit) || changed;
+  changed = visitField(record.toolUseResult, "stderr", visit) || changed;
+  const message = record.message;
+  if (isRecord(message) && Array.isArray(message.content)) {
+    for (const block of message.content) {
+      if (!isRecord(block)) continue;
+      changed = visitField(block, "text", visit) || changed;
+      changed = visitField(block, "content", visit) || changed;
+      changed = visitField(block.input, "command", visit) || changed;
+      changed = visitField(block.input, "file_path", visit) || changed;
+    }
+  }
+  if (Array.isArray(record.rendered)) {
+    for (const item of record.rendered) {
+      changed = visitField(item, "content", visit) || changed;
+    }
+  }
+  const wire = record.wireToolInputs;
+  if (isRecord(wire)) {
+    for (const key of Object.keys(wire)) {
+      changed = visitField(wire[key], "command", visit) || changed;
+      changed = visitField(wire[key], "file_path", visit) || changed;
+    }
+  }
+  const attachment = record.attachment;
+  if (isRecord(attachment)) {
+    changed = visitField(attachment, "filename", visit) || changed;
+    if (Array.isArray(attachment.files)) {
+      for (const file of attachment.files) {
+        changed = visitField(file, "path", visit) || changed;
+      }
+    }
+  }
+  return changed;
+}
+function visitPaths(record, visit, opts) {
+  const structural = visitStructuralPaths(record, visit);
+  const prose = opts?.includeProse ? visitProsePaths(record, visit) : false;
+  return structural || prose;
+}
+var PATH_LIKE = /(?:[A-Za-z]:[\\/]|\/|\\\\)[^\s"'`,;:()[\]{}]*/g;
+function extractPaths(value) {
+  return value.match(PATH_LIKE) ?? [];
+}
+function replacePathIn(value, from, to) {
+  let out = "";
+  let index = 0;
+  for (; ; ) {
+    const found = value.indexOf(from, index);
+    if (found === -1) {
+      out += value.slice(index);
+      return out;
+    }
+    const after = value[found + from.length];
+    const isBoundary = after === void 0 || after === "/" || after === "\\" || !/[\w.-]/.test(after);
+    out += value.slice(index, found) + (isBoundary ? to : from);
+    index = found + from.length;
+  }
+}
+
+// src/core/jsonl.ts
+var LF = 10;
+function isAbsolutePathish(value) {
+  return value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
+}
+async function* readLines(filePath) {
+  const stream = createReadStream(filePath);
+  let carry = Buffer.alloc(0);
+  let index = 0;
+  for await (const chunk of stream) {
+    carry = carry.length === 0 ? chunk : Buffer.concat([carry, chunk]);
+    let start = 0;
+    for (; ; ) {
+      const nl = carry.indexOf(LF, start);
+      if (nl === -1) break;
+      const hasCr = nl > start && carry[nl - 1] === 13;
+      yield {
+        raw: carry.subarray(start, hasCr ? nl - 1 : nl),
+        terminator: carry.subarray(hasCr ? nl - 1 : nl, nl + 1),
+        index: index++
+      };
+      start = nl + 1;
+    }
+    carry = carry.subarray(start);
+  }
+  if (carry.length > 0) {
+    yield { raw: carry, terminator: Buffer.alloc(0), index };
+  }
+}
+async function censusTranscript(filePath, opts) {
+  const census = {
+    file: filePath,
+    lines: 0,
+    bytes: (await stat(filePath)).size,
+    paths: /* @__PURE__ */ new Map(),
+    cwds: /* @__PURE__ */ new Map(),
+    prose: /* @__PURE__ */ new Map(),
+    pathless: 0,
+    malformed: []
+  };
+  for await (const line of readLines(filePath)) {
+    census.lines++;
+    if (line.raw.length === 0) continue;
+    let record;
+    try {
+      record = JSON.parse(line.raw.toString("utf8"));
+    } catch {
+      census.malformed.push(line.index);
+      continue;
+    }
+    const onThisLine = /* @__PURE__ */ new Set();
+    const cwdsOnThisLine = /* @__PURE__ */ new Set();
+    const collect = (into) => (value) => {
+      if (isAbsolutePathish(value)) into.add(value);
+      return void 0;
+    };
+    const proseOnThisLine = /* @__PURE__ */ new Set();
+    visitPaths(record, collect(onThisLine), opts);
+    visitCwdFields(record, collect(cwdsOnThisLine));
+    visitProsePaths(record, (value) => {
+      for (const path3 of extractPaths(value)) proseOnThisLine.add(path3);
+      return void 0;
+    });
+    for (const value of onThisLine) {
+      census.paths.set(value, (census.paths.get(value) ?? 0) + 1);
+    }
+    for (const value of cwdsOnThisLine) {
+      census.cwds.set(value, (census.cwds.get(value) ?? 0) + 1);
+    }
+    for (const value of proseOnThisLine) {
+      census.prose.set(value, (census.prose.get(value) ?? 0) + 1);
+    }
+    if (onThisLine.size === 0) census.pathless++;
+  }
+  return census;
+}
+function stagingPathFor(filePath, suffix = "tmp", impl = path2) {
+  return impl.join(impl.dirname(filePath), `${impl.basename(filePath)}.claude-mv-${suffix}`);
+}
+var ConcurrentModificationError = class extends Error {
+  constructor(file) {
+    super(`\uC7AC\uC791\uC131\uD558\uB294 \uB3D9\uC548 \uD30C\uC77C\uC774 \uBC14\uB00C\uC5C8\uC2B5\uB2C8\uB2E4: ${file}`);
+    this.file = file;
+    this.name = "ConcurrentModificationError";
+  }
+  file;
+};
+async function rewriteTranscript(filePath, visit, opts) {
+  return rewriteJsonl(filePath, (record) => visitPaths(record, visit, opts), opts);
+}
+async function rewriteJsonl(filePath, mutate, opts) {
+  const staging = stagingPathFor(filePath, opts?.stagingSuffix);
+  const before = await stat(filePath);
+  const hashIn = createHash("sha256");
+  const hashOut = createHash("sha256");
+  const out = createWriteStream(staging);
+  const result = {
+    linesTotal: 0,
+    linesChanged: 0,
+    linesMalformed: 0,
+    sha256In: "",
+    sha256Out: "",
+    staged: staging
+  };
+  const write = (buf) => new Promise((resolve, reject) => {
+    out.write(buf, (err) => err ? reject(err) : resolve());
+  });
+  try {
+    for await (const line of readLines(filePath)) {
+      result.linesTotal++;
+      hashIn.update(line.raw).update(line.terminator);
+      const emit = async (buf) => {
+        hashOut.update(buf);
+        await write(buf);
+      };
+      if (line.raw.length === 0) {
+        await emit(line.raw);
+        await emit(line.terminator);
+        continue;
+      }
+      let record;
+      try {
+        record = JSON.parse(line.raw.toString("utf8"));
+      } catch {
+        result.linesMalformed++;
+        await emit(line.raw);
+        await emit(line.terminator);
+        continue;
+      }
+      if (!mutate(record)) {
+        await emit(line.raw);
+        await emit(line.terminator);
+        continue;
+      }
+      result.linesChanged++;
+      await emit(Buffer.from(JSON.stringify(record), "utf8"));
+      await emit(line.terminator);
+    }
+    const after = await stat(filePath);
+    if (after.size !== before.size || after.ino !== before.ino) {
+      throw new ConcurrentModificationError(filePath);
+    }
+    await new Promise((resolve, reject) => {
+      out.end((err) => err ? reject(err) : resolve());
+    });
+    const handle = await open(staging, "r+");
+    try {
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await chmod(staging, (await stat(filePath)).mode);
+  } catch (error) {
+    out.destroy();
+    await unlink(staging).catch(() => {
+    });
+    result.staged = null;
+    throw error;
+  }
+  result.sha256In = hashIn.digest("hex");
+  result.sha256Out = hashOut.digest("hex");
+  if (result.linesChanged === 0) {
+    await unlink(staging).catch(() => {
+    });
+    result.staged = null;
+  }
+  return result;
+}
+async function commitStaged(staging, target) {
+  await rename(staging, target);
+}
+
+// src/core/scan.ts
+function pickPrimaryCwd(dirName, census) {
+  const byCount = [...census].sort((a, b) => b[1] - a[1]);
+  const matching = byCount.find(([path3]) => mangle(path3) === dirName);
+  if (matching) return { cwd: matching[0], matchedKey: true };
+  return { cwd: byCount[0]?.[0] ?? null, matchedKey: false };
+}
+function classify(primaryCwd, matchedKey, hasTranscripts, exists2) {
+  if (!hasTranscripts) return "empty";
+  if (primaryCwd === null) return "undeterminable";
+  if (!matchedKey) return "key-mismatch";
+  return exists2 ? "healthy" : "orphaned";
+}
+async function exists(path3) {
+  try {
+    return (await stat2(path3)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function collectTranscripts(dirPath) {
+  const transcripts = [];
+  const otherFiles = [];
+  const walk = async (dir, kind, sessionId) => {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "subagents") await walk(full, "subagent", sessionId);
+        else if (kind === "session") await walk(join2(full), "session", entry.name);
+        else otherFiles.push(full);
+        continue;
+      }
+      if (!entry.name.endsWith(".jsonl")) {
+        otherFiles.push(full);
+        continue;
+      }
+      const census = await censusTranscript(full);
+      transcripts.push({
+        ...census,
+        kind,
+        sessionId: sessionId ?? entry.name.replace(/\.jsonl$/, ""),
+        agentId: kind === "subagent" ? entry.name.replace(/\.jsonl$/, "") : void 0,
+        mtimeMs: (await stat2(full)).mtimeMs
+      });
+    }
+  };
+  await walk(dirPath, "session");
+  return { transcripts, otherFiles };
+}
+async function scanProjectDir(projectsDir, dirName) {
+  const dirPath = join2(projectsDir, dirName);
+  const { transcripts, otherFiles } = await collectTranscripts(dirPath);
+  const census = /* @__PURE__ */ new Map();
+  const cwdCensus = /* @__PURE__ */ new Map();
+  for (const t of transcripts) {
+    for (const [path3, count] of t.paths) census.set(path3, (census.get(path3) ?? 0) + count);
+    for (const [path3, count] of t.cwds) cwdCensus.set(path3, (cwdCensus.get(path3) ?? 0) + count);
+  }
+  const { cwd, matchedKey } = pickPrimaryCwd(dirName, cwdCensus);
+  const health = classify(cwd, matchedKey, transcripts.length > 0, cwd ? await exists(cwd) : false);
+  return {
+    dirName,
+    dirPath,
+    census,
+    cwdCensus,
+    primaryCwd: cwd,
+    health,
+    transcripts,
+    otherFiles,
+    bytes: transcripts.reduce((sum, t) => sum + t.bytes, 0),
+    lastActivityMs: transcripts.length ? Math.max(...transcripts.map((t) => t.mtimeMs)) : null
+  };
+}
+var PROC_START_IS_UTC = " UTC";
+function parseProcStart(value) {
+  if (!value) return null;
+  const parsed = Date.parse(value + PROC_START_IS_UTC);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+async function readConfig(configPath) {
+  try {
+    const parsed = JSON.parse(await readFile(configPath, "utf8"));
+    return {
+      keys: Object.keys(parsed.projects ?? {}),
+      githubRepoPaths: parsed.githubRepoPaths ?? {}
+    };
+  } catch {
+    return { keys: [], githubRepoPaths: {} };
+  }
+}
+async function readHistory(historyPath) {
+  const counts = /* @__PURE__ */ new Map();
+  try {
+    for await (const line of readLines(historyPath)) {
+      if (line.raw.length === 0) continue;
+      try {
+        const rec = JSON.parse(line.raw.toString("utf8"));
+        if (typeof rec.project === "string") {
+          counts.set(rec.project, (counts.get(rec.project) ?? 0) + 1);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return counts;
+}
+async function readSessions(sessionsDir) {
+  const out = [];
+  let names;
+  try {
+    names = await readdir(sessionsDir);
+  } catch {
+    return out;
+  }
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    try {
+      const raw = JSON.parse(await readFile(join2(sessionsDir, name), "utf8"));
+      if (typeof raw.pid !== "number" || typeof raw.cwd !== "string") continue;
+      const { procStart, ...rest } = raw;
+      out.push({ ...rest, startedAtMs: parseProcStart(procStart) });
+    } catch {
+    }
+  }
+  return out;
+}
+async function listDirs(dir) {
+  try {
+    return (await readdir(dir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function scan(target) {
+  const dirNames = await listDirs(target.projectsDir);
+  const config = await readConfig(target.configPath);
+  return {
+    projects: await Promise.all(dirNames.map((name) => scanProjectDir(target.projectsDir, name))),
+    configProjectKeys: config.keys,
+    githubRepoPaths: config.githubRepoPaths,
+    historyProjects: await readHistory(target.historyPath),
+    cacheDirs: target.cacheRoot ? await listDirs(target.cacheRoot) : [],
+    sessions: await readSessions(target.sessionsDir)
+  };
+}
+
+// src/shared/context.ts
+async function createContext(opts) {
+  const env = resolveClaudeEnv(opts);
+  const platform = env.platform;
+  return {
+    env,
+    platform,
+    policy: probeCasePolicy(env.claudeHome, defaultCasePolicy(platform)),
+    probe: createProcessProbe(platform),
+    index: await scan(env),
+    exists: existsSync2,
+    listDirs: listDirs2
+  };
+}
+function listDirs2(dir) {
+  try {
+    return readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function searchRoots(index, home) {
+  const roots = /* @__PURE__ */ new Set([
+    join3(home, "Developer"),
+    join3(home, "Projects"),
+    join3(home, "src"),
+    join3(home, "code")
+  ]);
+  for (const project of index.projects) {
+    if (project.health === "healthy" && project.primaryCwd) roots.add(dirname(project.primaryCwd));
+  }
+  return [...roots].filter((r) => {
+    try {
+      return statSync2(r).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+var pathHelpers = { basename, dirname, join: join3, exists: existsSync2 };
+
+// src/commands/query.ts
+function runList(ctx, reporter, opts) {
+  let projects = ctx.index.projects;
+  if (opts.orphansOnly) projects = projects.filter((p) => p.health !== "healthy");
+  const sorted = [...projects].sort((a, b) => {
+    if (opts.sort === "size") return b.bytes - a.bytes;
+    if (opts.sort === "activity") return (b.lastActivityMs ?? 0) - (a.lastActivityMs ?? 0);
+    return (a.primaryCwd ?? a.dirName).localeCompare(b.primaryCwd ?? b.dirName);
+  });
+  reporter.list(sorted);
+  return sorted.some((p) => p.health === "orphaned") ? "orphans" : "ok";
+}
+function findProject(ctx, needle, home) {
+  const byDirName = ctx.index.projects.find((p) => p.dirName === needle);
+  if (byDirName) return byDirName;
+  const normalized = normalizePath(needle, { platform: ctx.platform, home, realpath: false });
+  return ctx.index.projects.find(
+    (p) => p.primaryCwd && pathEquals(p.primaryCwd, normalized, ctx.policy)
+  ) ?? ctx.index.projects.find((p) => p.dirName === mangle(normalized));
+}
+function runInfo(ctx, reporter, opts) {
+  const project = findProject(ctx, opts.target, opts.home);
+  if (!project) throw new CliError(`\uB4F1\uB85D\uB41C \uD504\uB85C\uC81D\uD2B8\uAC00 \uC544\uB2D9\uB2C8\uB2E4: ${opts.target}`, "usage");
+  reporter.info(project);
+  return project.health === "orphaned" ? "orphans" : "ok";
+}
+function runDoctor(ctx, reporter) {
+  const report = doctor({
+    index: ctx.index,
+    policy: ctx.policy,
+    searchRoots: searchRoots(ctx.index, ctx.env.claudeHome.replace(/\/\.claude$/, "")),
+    listDirs: ctx.listDirs,
+    ...pathHelpers
+  });
+  reporter.doctor(report);
+  return report.orphans.length > 0 ? "orphans" : "ok";
+}
+
+// src/core/apply.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, rmSync, statSync as statSync4 } from "fs";
+import { dirname as dirname3, join as join5 } from "path";
+import fsExtra from "fs-extra";
+import writeFileAtomic from "write-file-atomic";
+
+// src/core/backup.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  copyFileSync,
+  existsSync as existsSync3,
+  linkSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync as readdirSync3,
+  statSync as statSync3,
+  writeFileSync
+} from "fs";
+import { dirname as dirname2, join as join4, relative } from "path";
+function sha256(path3) {
+  return createHash2("sha256").update(readFileSync(path3)).digest("hex");
+}
+function stash(original, storedAbs) {
+  mkdirSync(dirname2(storedAbs), { recursive: true });
+  try {
+    linkSync(original, storedAbs);
+  } catch {
+    copyFileSync(original, storedAbs);
+  }
+}
+function collectFiles(dir, out = []) {
+  for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+    const full = join4(dir, entry.name);
+    if (entry.isDirectory()) collectFiles(full, out);
+    else out.push(full);
+  }
+  return out;
+}
+function createBackup(input) {
+  const dir = join4(input.root, input.backupId);
+  const filesDir = join4(dir, "files");
+  mkdirSync(filesDir, { recursive: true });
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addFile = (path3) => {
+    if (seen.has(path3) || !existsSync3(path3)) return;
+    seen.add(path3);
+    const stats = statSync3(path3);
+    const stored = join4("files", path3.replace(/^[/\\]/, "").replace(/:/g, "_"));
+    stash(path3, join4(dir, stored));
+    entries.push({
+      type: "file",
+      original: path3,
+      stored,
+      sha256: sha256(path3),
+      size: stats.size,
+      mode: stats.mode
+    });
+  };
+  for (const step of input.plan.steps) {
+    switch (step.kind) {
+      case "rewrite-transcript":
+      case "rewrite-plan":
+        addFile(step.file);
+        break;
+      case "edit-config":
+      case "rewrite-history":
+        addFile(step.file);
+        break;
+      case "move-project-dir":
+        entries.push({ type: "dir-move", from: step.from, to: step.to });
+        entries.push({ type: "absent", original: step.to });
+        break;
+      case "move-cache-dir":
+        entries.push({ type: "dir-move", from: step.from, to: step.to });
+        entries.push({ type: "absent", original: step.to });
+        break;
+      case "move-directory":
+        entries.push({ type: "dir-move", from: step.from, to: step.to });
+        entries.push({ type: "absent", original: step.to });
+        break;
+      case "repair-worktrees":
+        for (const file of collectFiles(join4(step.repoRoot, ".git", "worktrees")).filter(
+          (f) => f.endsWith("gitdir")
+        )) {
+          addFile(file);
+        }
+        break;
+    }
+  }
+  const manifest = {
+    version: 1,
+    backupId: input.backupId,
+    createdAt: Date.now(),
+    tool: { name: "claude-mv", version: input.version },
+    src: input.plan.request.src,
+    dst: input.plan.request.dst,
+    entries,
+    sealed: false
+  };
+  const manifestPath = join4(dir, "manifest.json");
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  return {
+    id: input.backupId,
+    dir,
+    manifestPath,
+    journalPath: join4(dir, "journal.jsonl"),
+    entries
+  };
+}
+function seal(handle) {
+  const manifest = readManifest(handle.manifestPath);
+  manifest.sealed = true;
+  writeFileSync(handle.manifestPath, JSON.stringify(manifest, null, 2));
+}
+function readManifest(path3) {
+  return JSON.parse(readFileSync(path3, "utf8"));
+}
+function listBackups(root) {
+  let names;
+  try {
+    names = readdirSync3(root);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    try {
+      out.push(readManifest(join4(root, name, "manifest.json")));
+    } catch {
+    }
+  }
+  return out.sort((a, b) => b.createdAt - a.createdAt);
+}
+
+// src/core/config-edit.ts
+import { modify, parseTree } from "jsonc-parser";
+function findProperty(node, key) {
+  if (node?.type !== "object") return void 0;
+  return node.children?.find((child) => child.children?.[0]?.value === key);
+}
+function planConfigEdits(text, opts) {
+  const root = parseTree(text);
+  if (!root) return [];
+  const edits = [];
+  const projects = findProperty(root, "projects");
+  const projectsValue = projects?.children?.[1];
+  if (projectsValue?.type === "object") {
+    for (const property of projectsValue.children ?? []) {
+      const keyNode = property.children?.[0];
+      if (typeof keyNode?.value !== "string") continue;
+      const next = reparent(keyNode.value, opts.src, opts.dst, opts.policy, opts.platform);
+      if (next === void 0) continue;
+      edits.push({
+        offset: keyNode.offset,
+        length: keyNode.length,
+        replacement: JSON.stringify(next)
+      });
+    }
+  }
+  const github = findProperty(root, "githubRepoPaths");
+  const githubValue = github?.children?.[1];
+  if (githubValue?.type === "object") {
+    for (const property of githubValue.children ?? []) {
+      const list = property.children?.[1];
+      if (list?.type !== "array") continue;
+      for (const item of list.children ?? []) {
+        if (typeof item.value !== "string") continue;
+        const next = reparent(item.value, opts.src, opts.dst, opts.policy, opts.platform);
+        if (next === void 0) continue;
+        edits.push({ offset: item.offset, length: item.length, replacement: JSON.stringify(next) });
+      }
+    }
+  }
+  return edits;
+}
+function applyEdits(text, edits) {
+  let out = text;
+  for (const edit of [...edits].sort((a, b) => b.offset - a.offset)) {
+    out = out.slice(0, edit.offset) + edit.replacement + out.slice(edit.offset + edit.length);
+  }
+  return out;
+}
+function planConfigRemoval(text, key) {
+  return modify(text, ["projects", key], void 0, {}).map((edit) => ({
+    offset: edit.offset,
+    length: edit.length,
+    replacement: edit.content
+  }));
+}
+
+// src/core/journal.ts
+import { appendFileSync, closeSync, fsyncSync, openSync, readFileSync as readFileSync2, writeSync } from "fs";
+var Journal = class _Journal {
+  constructor(path3) {
+    this.path = path3;
+  }
+  path;
+  seq = 0;
+  append(entry) {
+    const line = `${JSON.stringify({ seq: this.seq++, t: Date.now(), ...entry })}
+`;
+    const fd = openSync(this.path, "a");
+    try {
+      writeSync(fd, line);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+  }
+  static read(path3) {
+    let raw;
+    try {
+      raw = readFileSync2(path3, "utf8");
+    } catch {
+      return [];
+    }
+    const entries = [];
+    for (const line of raw.split("\n")) {
+      if (!line) continue;
+      try {
+        entries.push(JSON.parse(line));
+      } catch {
+        break;
+      }
+    }
+    return entries;
+  }
+  static resume(path3) {
+    const journal = new _Journal(path3);
+    const entries = _Journal.read(path3);
+    journal.seq = (entries.at(-1)?.seq ?? -1) + 1;
+    return journal;
+  }
+};
+
+// src/core/apply.ts
+async function apply(opts) {
+  const { plan, journal, onEvent } = opts;
+  const emit = (event) => onEvent?.(event);
+  const completed = [];
+  const commitOrder = [
+    "move-cache-dir",
+    "rewrite-transcript",
+    "rewrite-plan",
+    "move-project-dir",
+    "rewrite-history",
+    "edit-config",
+    "move-directory",
+    "repair-worktrees"
+  ];
+  const ordered = [...plan.steps].sort(
+    (a, b) => commitOrder.indexOf(a.kind) - commitOrder.indexOf(b.kind)
+  );
+  emit({ kind: "phase", phase: "backup" });
+  if (opts.backup && !opts.dryRun) {
+    journal.append({ kind: "backup-sealed" });
+    seal(opts.backup);
+  }
+  emit({ kind: "phase", phase: "stage" });
+  const staged = [];
+  try {
+    for (const step of ordered) {
+      if (!needsStaging(step)) continue;
+      emit({ kind: "step-start", step });
+      const result = await stage(step, plan, opts.dryRun ?? false);
+      if (result) {
+        staged.push(result);
+        if (!opts.dryRun) {
+          journal.append({
+            kind: "staged",
+            stepId: step.id,
+            staged: result.staged,
+            target: result.target
+          });
+        }
+      }
+      emit({ kind: "step-done", step, detail: result?.detail });
+    }
+  } catch (error) {
+    for (const s of staged) rmSync(s.staged, { force: true });
+    emit({ kind: "step-failed", step: ordered[0], error });
+    return { completed, failed: { step: ordered[0], error } };
+  }
+  if (opts.dryRun) return { completed: ordered, failed: null };
+  journal.append({ kind: "commit-barrier" });
+  emit({ kind: "phase", phase: "commit" });
+  for (const step of ordered) {
+    journal.append({ kind: "step-begin", stepId: step.id, step });
+    try {
+      emit({ kind: "step-start", step });
+      const entry = staged.find((s) => s.step.id === step.id);
+      if (entry) {
+        await commitStaged(entry.staged, entry.target);
+        journal.append({
+          kind: "committed",
+          stepId: step.id,
+          target: entry.target,
+          previousState: "existed"
+        });
+      } else {
+        commitMove(step, journal);
+      }
+      completed.push(step);
+      emit({ kind: "step-done", step });
+    } catch (error) {
+      journal.append({ kind: "step-failed", stepId: step.id, error: String(error) });
+      emit({ kind: "step-failed", step, error });
+      return { completed, failed: { step, error } };
+    }
+  }
+  journal.append({ kind: "end", ok: true });
+  return { completed, failed: null };
+}
+function needsStaging(step) {
+  return step.kind === "rewrite-transcript" || step.kind === "rewrite-history" || step.kind === "edit-config" || step.kind === "rewrite-plan";
+}
+async function stage(step, plan, dryRun) {
+  const { src, dst, policy, platform, rewriteProse } = plan.request;
+  const map = (value) => {
+    const whole = reparent(value, src, dst, policy, platform);
+    if (whole !== void 0) return whole;
+    if (!rewriteProse || !value.includes(src)) return void 0;
+    const replaced = replacePathIn(value, src, dst);
+    return replaced === value ? void 0 : replaced;
+  };
+  switch (step.kind) {
+    case "rewrite-transcript": {
+      if (dryRun) return null;
+      const result = await rewriteTranscript(step.file, map, {
+        includeProse: rewriteProse,
+        stagingSuffix: "stage"
+      });
+      if (!result.staged) return null;
+      return {
+        step,
+        staged: result.staged,
+        target: step.file,
+        detail: `${result.linesChanged}/${result.linesTotal} \uC904`
+      };
+    }
+    case "rewrite-history": {
+      if (dryRun) return null;
+      const result = await rewriteJsonl(
+        step.file,
+        (record) => {
+          if (typeof record !== "object" || record === null) return false;
+          const holder = record;
+          if (typeof holder.project !== "string") return false;
+          const next = map(holder.project);
+          if (next === void 0) return false;
+          holder.project = next;
+          return true;
+        },
+        { stagingSuffix: "stage" }
+      );
+      if (!result.staged) return null;
+      return {
+        step,
+        staged: result.staged,
+        target: step.file,
+        detail: `${result.linesChanged} \uC904`
+      };
+    }
+    case "edit-config": {
+      if (dryRun) return null;
+      const text = readFileSync3(step.file, "utf8");
+      const edits = planConfigEdits(text, { src, dst, policy, platform });
+      if (edits.length === 0) return null;
+      const staging = `${step.file}.claude-mv-stage`;
+      await writeFileAtomic(staging, applyEdits(text, edits));
+      return { step, staged: staging, target: step.file, detail: `${edits.length}\uACF3` };
+    }
+    case "rewrite-plan": {
+      if (dryRun) return null;
+      const text = readFileSync3(step.file, "utf8");
+      const next = text.split(src).join(dst);
+      if (next === text) return null;
+      const staging = `${step.file}.claude-mv-stage`;
+      await writeFileAtomic(staging, next);
+      return { step, staged: staging, target: step.file, detail: "\uACBD\uB85C \uCE58\uD658" };
+    }
+    default:
+      return null;
+  }
+}
+function commitMove(step, journal) {
+  switch (step.kind) {
+    case "move-project-dir":
+    case "move-cache-dir":
+    case "move-directory": {
+      if (!existsSync4(step.from)) return;
+      mkdirSync2(dirname3(step.to), { recursive: true });
+      moveDirectory(step.from, step.to);
+      journal.append({
+        kind: "committed",
+        stepId: step.id,
+        target: step.to,
+        previousState: "absent",
+        movedFrom: step.from
+      });
+      return;
+    }
+    default:
+      return;
+  }
+}
+function moveDirectory(from, to) {
+  try {
+    renameSync(from, to);
+  } catch (error) {
+    if (error.code !== "EXDEV") throw error;
+    fsExtra.moveSync(from, to, { overwrite: false });
+  }
+}
+function backupRoot(toolDir) {
+  return join5(toolDir, "backups");
+}
+
+// src/core/rollback.ts
+import { createHash as createHash3 } from "crypto";
+import { copyFileSync as copyFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, rmSync as rmSync2 } from "fs";
+import { dirname as dirname4, join as join6 } from "path";
+function rollback(input) {
+  const manifestPath = join6(input.backupDir, "manifest.json");
+  const manifest = readManifest(manifestPath);
+  const journalPath = join6(input.backupDir, "journal.jsonl");
+  const entries = Journal.read(journalPath);
+  const result = {
+    backupId: manifest.backupId,
+    restored: [],
+    reverted: [],
+    removed: [],
+    residue: [],
+    ok: true
+  };
+  if (!manifest.sealed) {
+    cleanStaging(entries, result);
+    return result;
+  }
+  const journal = Journal.resume(journalPath);
+  journal.append({ kind: "rollback-begin" });
+  for (const entry of [...entries].reverse()) {
+    if (entry.kind !== "committed") continue;
+    try {
+      if (entry.movedFrom) {
+        if (!existsSync5(entry.target)) continue;
+        if (existsSync5(entry.movedFrom)) {
+          result.residue.push({
+            path: entry.movedFrom,
+            why: "\uB418\uB3CC\uB9B4 \uC790\uB9AC\uC5D0 \uC774\uBBF8 \uBB54\uAC00 \uC788\uC2B5\uB2C8\uB2E4. \uB36E\uC5B4\uC4F0\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4."
+          });
+          result.ok = false;
+          continue;
+        }
+        mkdirSync3(dirname4(entry.movedFrom), { recursive: true });
+        renameSync2(entry.target, entry.movedFrom);
+        result.reverted.push(entry.target);
+        continue;
+      }
+      if (entry.previousState === "absent") {
+        rmSync2(entry.target, { recursive: true, force: true });
+        result.removed.push(entry.target);
+        continue;
+      }
+      const stored = manifest.entries.find((e) => e.type === "file" && e.original === entry.target);
+      if (!stored || stored.type !== "file") {
+        result.residue.push({ path: entry.target, why: "\uBC31\uC5C5\uC5D0 \uC6D0\uBCF8\uC774 \uC5C6\uC2B5\uB2C8\uB2E4." });
+        result.ok = false;
+        continue;
+      }
+      const source = join6(input.backupDir, stored.stored);
+      const actual = createHash3("sha256").update(readFileSync4(source)).digest("hex");
+      if (actual !== stored.sha256) {
+        result.residue.push({ path: entry.target, why: "\uBC31\uC5C5 \uD30C\uC77C\uC758 \uCCB4\uD06C\uC12C\uC774 \uB2E4\uB985\uB2C8\uB2E4." });
+        result.ok = false;
+        continue;
+      }
+      const staging = `${entry.target}.claude-mv-restore`;
+      copyFileSync2(source, staging);
+      renameSync2(staging, entry.target);
+      result.restored.push(entry.target);
+    } catch (error) {
+      result.residue.push({ path: entry.target, why: String(error) });
+      result.ok = false;
+    }
+  }
+  cleanStaging(entries, result);
+  journal.append({
+    kind: "rollback-end",
+    ok: result.ok,
+    residue: result.residue.map((r) => r.path)
+  });
+  return result;
+}
+function cleanStaging(entries, result) {
+  for (const entry of entries) {
+    if (entry.kind !== "staged") continue;
+    if (!existsSync5(entry.staged)) continue;
+    try {
+      rmSync2(entry.staged, { force: true });
+      result.removed.push(entry.staged);
+    } catch {
+      result.residue.push({ path: entry.staged, why: "\uC784\uC2DC \uD30C\uC77C\uC744 \uC9C0\uC6B0\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4." });
+    }
+  }
+}
+
+// src/commands/manage.ts
+function newBackupId() {
+  return `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/[-:T]/g, "")}-${ulid().slice(-6)}`;
+}
+function dirBytes(dir) {
+  let total = 0;
+  const walk = (path3) => {
+    for (const entry of readdirSync4(path3, { withFileTypes: true })) {
+      const full = join7(path3, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else total += statSync5(full).size;
+    }
+  };
+  try {
+    walk(dir);
+  } catch {
+    return total;
+  }
+  return total;
+}
+function runBackups(ctx, reporter) {
+  const root = backupRoot(ctx.env.toolDir);
+  const items = listBackups(root).map((manifest) => ({
+    id: manifest.backupId,
+    createdAt: manifest.createdAt,
+    src: manifest.src,
+    dst: manifest.dst,
+    bytes: dirBytes(join7(root, manifest.backupId)),
+    restorable: manifest.sealed && !existsSync6(manifest.src)
+  }));
+  reporter.backups(items);
+  return "ok";
+}
+function runRollback(ctx, reporter, opts) {
+  const root = backupRoot(ctx.env.toolDir);
+  const all = listBackups(root);
+  const manifest = opts.id === "last" ? all[0] : all.find((m) => m.backupId === opts.id);
+  if (!manifest) throw new CliError(`\uADF8\uB7F0 \uBC31\uC5C5\uC774 \uC5C6\uC2B5\uB2C8\uB2E4: ${opts.id}`, "usage");
+  const result = rollback({ backupDir: join7(root, manifest.backupId) });
+  for (const path3 of result.reverted) reporter.note(`\uB418\uB3CC\uB9BC  ${path3}`);
+  for (const path3 of result.restored) reporter.note(`\uBCF5\uC6D0    ${path3}`);
+  for (const residue of result.residue) reporter.warn(`${residue.path}: ${residue.why}`);
+  return result.ok ? "ok" : "failedDirty";
+}
+function runBackupOnly(ctx, reporter, opts) {
+  const project = findProject(ctx, opts.target, opts.home);
+  if (!project) throw new CliError(`\uB4F1\uB85D\uB41C \uD504\uB85C\uC81D\uD2B8\uAC00 \uC544\uB2D9\uB2C8\uB2E4: ${opts.target}`, "usage");
+  const root = backupRoot(ctx.env.toolDir);
+  mkdirSync4(root, { recursive: true });
+  const backupId = newBackupId();
+  const path3 = project.primaryCwd ?? project.dirPath;
+  const handle = createBackup({
+    root,
+    backupId,
+    version: opts.version,
+    plan: {
+      request: {
+        src: path3,
+        dst: path3,
+        stateOnly: true,
+        rewriteProse: false,
+        policy: ctx.policy,
+        platform: ctx.platform
+      },
+      steps: [
+        ...project.transcripts.map((t, i) => ({
+          kind: "rewrite-transcript",
+          id: `t${i}`,
+          file: t.file,
+          movesWithDir: false,
+          affected: 0,
+          total: t.lines
+        })),
+        {
+          kind: "edit-config",
+          id: "config",
+          file: ctx.env.configPath,
+          renameKey: false,
+          githubRepos: []
+        },
+        {
+          kind: "rewrite-history",
+          id: "history",
+          file: ctx.env.historyPath,
+          affected: 0
+        }
+      ],
+      blockers: [],
+      warnings: [],
+      proseLeftBehind: 0
+    }
+  });
+  seal(handle);
+  reporter.note(`\uBC31\uC5C5 ${backupId}`);
+  reporter.note(`\uBCF5\uAD6C\uD558\uB824\uBA74  claude-mv rollback ${backupId}`);
+  return "ok";
+}
+async function runRemove(ctx, reporter, opts) {
+  const project = findProject(ctx, opts.target, opts.home);
+  if (!project) throw new CliError(`\uB4F1\uB85D\uB41C \uD504\uB85C\uC81D\uD2B8\uAC00 \uC544\uB2D9\uB2C8\uB2E4: ${opts.target}`, "usage");
+  const path3 = project.primaryCwd;
+  if (path3 && ctx.exists(path3) && !opts.force) {
+    throw new CliError(
+      `${path3}\uB294 \uC544\uC9C1 \uC874\uC7AC\uD569\uB2C8\uB2E4. \uC0C1\uD0DC\uB9CC \uC0AD\uC81C\uD558\uB824\uBA74 --force\uB97C \uC0AC\uC6A9\uD558\uC138\uC694.`,
+      "precondition"
+    );
+  }
+  reporter.info(project);
+  if (!opts.yes && !await reporter.confirm("\uC774 \uD504\uB85C\uC81D\uD2B8\uC758 Claude \uC0C1\uD0DC\uB97C \uC9C0\uC6B8\uAE4C\uC694?")) {
+    reporter.note("\uCDE8\uC18C\uD588\uC2B5\uB2C8\uB2E4.");
+    return "ok";
+  }
+  const root = backupRoot(ctx.env.toolDir);
+  mkdirSync4(root, { recursive: true });
+  const backupId = newBackupId();
+  runBackupOnly(ctx, { ...reporter, note: () => {
+  }, info: () => {
+  } }, opts);
+  const journal = Journal.resume(join7(root, `${backupId}.journal.jsonl`));
+  rmSync3(project.dirPath, { recursive: true, force: true });
+  journal.append({
+    kind: "committed",
+    stepId: "remove-project-dir",
+    target: project.dirPath,
+    previousState: "existed"
+  });
+  if (path3 && ctx.index.configProjectKeys.includes(path3)) {
+    const text = readFileSync5(ctx.env.configPath, "utf8");
+    const edits = planConfigRemoval(text, path3);
+    if (edits.length > 0) {
+      await writeFileAtomic2(ctx.env.configPath, applyEdits(text, edits));
+      journal.append({
+        kind: "committed",
+        stepId: "remove-config-key",
+        target: ctx.env.configPath,
+        previousState: "existed"
+      });
+    }
+  }
+  if (ctx.env.cacheRoot && ctx.index.cacheDirs.includes(project.dirName)) {
+    rmSync3(join7(ctx.env.cacheRoot, project.dirName), { recursive: true, force: true });
+  }
+  reporter.note(`\uC0AD\uC81C\uD588\uC2B5\uB2C8\uB2E4. \uBCF5\uAD6C\uD558\uB824\uBA74  claude-mv rollback ${backupId}`);
+  return "ok";
+}
+function runMerge(ctx, reporter, opts) {
+  const from = findProject(ctx, opts.from, opts.home);
+  const to = findProject(ctx, opts.to, opts.home);
+  if (!from) throw new CliError(`\uB4F1\uB85D\uB41C \uD504\uB85C\uC81D\uD2B8\uAC00 \uC544\uB2D9\uB2C8\uB2E4: ${opts.from}`, "usage");
+  if (!to) throw new CliError(`\uB4F1\uB85D\uB41C \uD504\uB85C\uC81D\uD2B8\uAC00 \uC544\uB2D9\uB2C8\uB2E4: ${opts.to}`, "usage");
+  let moved = 0;
+  for (const entry of readdirSync4(from.dirPath, { withFileTypes: true })) {
+    const source = join7(from.dirPath, entry.name);
+    const target = join7(to.dirPath, entry.name);
+    if (existsSync6(target)) {
+      reporter.warn(`\uC774\uBBF8 \uC874\uC7AC\uD574\uC11C \uAC74\uB108\uB701\uB2C8\uB2E4: ${entry.name}`);
+      continue;
+    }
+    renameSync3(source, target);
+    moved++;
+  }
+  reporter.note(`${moved}\uAC1C \uD56D\uBAA9\uC744 \uC62E\uACBC\uC2B5\uB2C8\uB2E4.`);
+  if (readdirSync4(from.dirPath).length === 0) rmSync3(from.dirPath, { recursive: true });
+  else reporter.warn(`${from.dirPath}\uAC00 \uBE44\uC5B4 \uC788\uC9C0 \uC54A\uC544 \uADF8\uB300\uB85C \uB461\uB2C8\uB2E4.`);
+  return "ok";
+}
+
+// src/commands/mv.ts
+import { mkdirSync as mkdirSync6 } from "fs";
+import { join as join10 } from "path";
+import { ulid as ulid3 } from "ulid";
+
+// src/core/lock.ts
+var START_TOLERANCE_MS = 2e3;
+async function checkLocks(sessions, opts) {
+  const findings = [];
+  for (const session of sessions) {
+    const atOrUnder = pathEquals(session.cwd, opts.src, opts.policy) || isUnder(session.cwd, opts.src, opts.policy, opts.platform);
+    const ancestor = !atOrUnder && isUnder(opts.src, session.cwd, opts.policy, opts.platform);
+    if (!atOrUnder && !ancestor) continue;
+    const relation = atOrUnder ? "at-or-under" : "ancestor";
+    findings.push({ session, relation, ...await judge(session, opts.probe, opts.platform) });
+  }
+  const blocking = findings.filter((f) => {
+    if (f.verdict === "stale") return false;
+    if (f.relation === "ancestor" && opts.allowAncestors) return false;
+    return true;
+  });
+  return { findings, blocking };
+}
+async function judge(session, probe, platform) {
+  if (session.pidDomain && session.pidDomain !== platform) {
+    return { verdict: "unknown", why: `\uB2E4\uB978 OS(${session.pidDomain})\uC5D0\uC11C \uAE30\uB85D\uB41C \uC138\uC158\uC785\uB2C8\uB2E4.` };
+  }
+  if (!await probe.exists(session.pid)) {
+    return { verdict: "stale", why: "\uD504\uB85C\uC138\uC2A4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4." };
+  }
+  const recorded = session.startedAtMs;
+  const actual = await probe.startedAt(session.pid);
+  if (recorded === null || actual === null) {
+    return { verdict: "unknown", why: "\uC2DC\uC791 \uC2DC\uAC01\uC744 \uD655\uC778\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4." };
+  }
+  if (Math.abs(recorded - actual) > START_TOLERANCE_MS) {
+    return { verdict: "stale", why: "pid \uAC00 \uC7AC\uC0AC\uC6A9\uB418\uC5C8\uC2B5\uB2C8\uB2E4." };
+  }
+  return { verdict: "live", why: "\uC2E4\uD589 \uC911\uC785\uB2C8\uB2E4." };
+}
+
+// src/core/migration.ts
+import { mkdirSync as mkdirSync5 } from "fs";
+import { join as join9 } from "path";
+import { ulid as ulid2 } from "ulid";
+
+// src/core/plan.ts
+import { join as join8 } from "path";
+function affectedCount(t, req) {
+  let n = 0;
+  for (const [path3, lines] of t.paths) {
+    if (reparent(path3, req.src, req.dst, req.policy, req.platform) !== void 0) n += lines;
+  }
+  return Math.min(n, t.lines);
+}
+function isMixed(t, req) {
+  const inside = [];
+  const outside = [];
+  for (const path3 of t.cwds.keys()) {
+    if (reparent(path3, req.src, req.dst, req.policy, req.platform) !== void 0) inside.push(path3);
+    else outside.push(path3);
+  }
+  return inside.length > 0 && outside.length > 0 ? [...inside, ...outside] : [];
+}
+function buildPlan(req, ctx) {
+  const steps = [];
+  const blockers = [];
+  const warnings = [];
+  const srcMangled = mangle(req.src);
+  const dstMangled = mangle(req.dst);
+  if (isUnder(req.dst, req.src, req.policy, req.platform)) {
+    blockers.push({ kind: "dst-inside-src" });
+  }
+  if (srcMangled === dstMangled && !pathEquals(req.src, req.dst, req.policy)) {
+    warnings.push({ kind: "mangle-collision", other: req.dst });
+  }
+  if (!req.stateOnly && !ctx.srcExists) blockers.push({ kind: "src-missing" });
+  const blocking = ctx.locks.blocking.map((finding) => finding.session);
+  if (blocking.length > 0) blockers.push({ kind: "locked", sessions: blocking });
+  const planFiles = /* @__PURE__ */ new Set();
+  for (const project of ctx.index.projects) {
+    const owns = project.dirName === srcMangled;
+    const touched = project.transcripts.filter((t) => affectedCount(t, req) > 0);
+    if (!owns && touched.length === 0) continue;
+    if (owns) {
+      if (ctx.index.projects.some((p) => p.dirName === dstMangled)) {
+        blockers.push({ kind: "dst-project-dir-exists", dirName: dstMangled });
+      }
+      steps.push({
+        kind: "move-project-dir",
+        id: "project-dir",
+        from: project.dirPath,
+        to: join8(ctx.projectsDir, dstMangled),
+        files: project.transcripts.length + project.otherFiles.length
+      });
+    } else if (touched.length > 0) {
+      warnings.push({
+        kind: "rewritten-in-parent-dir",
+        dirName: project.dirName,
+        files: touched.length
+      });
+    }
+    const liveSessionIds = new Set(
+      ctx.locks.findings.filter((f) => f.verdict !== "stale").map((f) => f.session.sessionId)
+    );
+    for (const t of touched) {
+      for (const path3 of t.paths.keys()) {
+        if (isUnder(path3, ctx.plansDir, req.policy, req.platform)) planFiles.add(path3);
+      }
+      if (ctx.skipLiveTranscripts && t.kind === "session" && liveSessionIds.has(t.sessionId)) {
+        warnings.push({ kind: "skipped-live", sessionId: t.sessionId });
+        continue;
+      }
+      const mixed = isMixed(t, req);
+      if (mixed.length > 0) warnings.push({ kind: "mixed-cwd", file: t.file, paths: mixed });
+      steps.push({
+        kind: "rewrite-transcript",
+        id: `transcript:${t.sessionId}${t.agentId ? `/${t.agentId}` : ""}`,
+        file: t.file,
+        movesWithDir: owns,
+        affected: affectedCount(t, req),
+        total: t.lines
+      });
+    }
+  }
+  for (const file of planFiles) {
+    if (!ctx.fileExists(file)) continue;
+    steps.push({ kind: "rewrite-plan", id: `plan:${file}`, file });
+  }
+  const located = locateInConfig(ctx.index, req);
+  if (located.renameKey || located.githubRepos.length > 0) {
+    if (located.dstKeyExists) blockers.push({ kind: "dst-config-key-exists", key: req.dst });
+    steps.push({
+      kind: "edit-config",
+      id: "claude-json",
+      file: ctx.configPath,
+      renameKey: located.renameKey,
+      githubRepos: located.githubRepos
+    });
+  }
+  const historyAffected = [...ctx.index.historyProjects].filter(([p]) => reparent(p, req.src, req.dst, req.policy, req.platform) !== void 0).reduce((sum, [, n]) => sum + n, 0);
+  if (historyAffected > 0) {
+    steps.push({
+      kind: "rewrite-history",
+      id: "history",
+      file: ctx.historyPath,
+      affected: historyAffected
+    });
+  }
+  if (ctx.cacheRoot && ctx.index.cacheDirs.includes(srcMangled)) {
+    steps.push({
+      kind: "move-cache-dir",
+      id: "mcp-logs",
+      from: join8(ctx.cacheRoot, srcMangled),
+      to: join8(ctx.cacheRoot, dstMangled)
+    });
+  }
+  if (!req.stateOnly && ctx.srcExists) {
+    steps.push({ kind: "move-directory", id: "working-tree", from: req.src, to: req.dst });
+  }
+  if (steps.length === 0) warnings.push({ kind: "nothing-to-do" });
+  const proseLeftBehind = req.rewriteProse ? 0 : countProse(ctx.index, req);
+  return { request: req, steps, blockers, warnings, proseLeftBehind };
+}
+function locateInConfig(index, req) {
+  return {
+    renameKey: index.configProjectKeys.some((k) => pathEquals(k, req.src, req.policy)),
+    dstKeyExists: index.configProjectKeys.some((k) => pathEquals(k, req.dst, req.policy)),
+    githubRepos: Object.entries(index.githubRepoPaths).filter(
+      ([, paths]) => paths.some((p) => reparent(p, req.src, req.dst, req.policy, req.platform) !== void 0)
+    ).map(([repo]) => repo)
+  };
+}
+function countProse(index, req) {
+  let n = 0;
+  for (const project of index.projects) {
+    for (const t of project.transcripts) {
+      for (const [path3, lines] of t.prose) {
+        if (reparent(path3, req.src, req.dst, req.policy, req.platform) !== void 0) n += lines;
+      }
+    }
+  }
+  return n;
+}
+
+// src/core/migration.ts
+function newBackupId2() {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/[-:T]/g, "");
+  return `${stamp}-${ulid2().slice(-6)}`;
+}
+var Migration = class _Migration {
+  constructor(plan, toolDir) {
+    this.plan = plan;
+    this.toolDir = toolDir;
+  }
+  plan;
+  toolDir;
+  static prepare(request, context) {
+    return new _Migration(buildPlan(request, context), context.toolDir);
+  }
+  get blocked() {
+    return this.plan.blockers.length > 0;
+  }
+  get empty() {
+    return this.plan.steps.length === 0;
+  }
+  async run(opts) {
+    const { plan } = this;
+    if (this.blocked) return { status: "blocked", plan };
+    const root = backupRoot(this.toolDir);
+    mkdirSync5(root, { recursive: true });
+    const backupId = newBackupId2();
+    const backup = opts.backup ? createBackup({ root, backupId, version: "runtime", plan }) : null;
+    const journal = Journal.resume(
+      backup ? backup.journalPath : join9(root, `${backupId}.journal.jsonl`)
+    );
+    journal.append({ kind: "begin", backupId, plan });
+    const startedAt2 = Date.now();
+    const result = await apply({ plan, backup, journal, onEvent: opts.onEvent });
+    if (!result.failed) {
+      return {
+        status: "applied",
+        plan,
+        backupId: backup?.id ?? null,
+        durationMs: Date.now() - startedAt2
+      };
+    }
+    if (!backup) {
+      return { status: "dirty", plan, backupId: null, error: result.failed.error };
+    }
+    const reverted = rollback({ backupDir: backup.dir });
+    return reverted.ok ? {
+      status: "rolled-back",
+      plan,
+      backupId: backup.id,
+      error: result.failed.error,
+      rollback: reverted
+    } : { status: "dirty", plan, backupId: backup.id, error: result.failed.error };
+  }
+};
+
+// src/commands/mv.ts
+async function runMove(ctx, reporter, opts) {
+  const norm = (value, realpath = true) => normalizePath(value, { platform: ctx.platform, home: opts.home, realpath });
+  const src = pickKnown(ctx, [norm(opts.src), norm(opts.src, false)]);
+  const dst = norm(opts.dst, false);
+  if (src === dst) throw new CliError("src\uC640 dst\uAC00 \uAC19\uC2B5\uB2C8\uB2E4.", "usage");
+  const request = {
+    src,
+    dst,
+    stateOnly: opts.stateOnly || !ctx.exists(src) && ctx.exists(dst),
+    rewriteProse: opts.rewriteProse,
+    policy: ctx.policy,
+    platform: ctx.platform
+  };
+  const locks = await checkLocks(ctx.index.sessions, {
+    src,
+    policy: ctx.policy,
+    platform: ctx.platform,
+    probe: ctx.probe,
+    allowAncestors: opts.allowAncestors
+  });
+  const migration = Migration.prepare(request, {
+    index: ctx.index,
+    configPath: ctx.env.configPath,
+    historyPath: ctx.env.historyPath,
+    projectsDir: ctx.env.projectsDir,
+    plansDir: ctx.env.plansDir,
+    cacheRoot: ctx.env.cacheRoot,
+    toolDir: ctx.env.toolDir,
+    fileExists: ctx.exists,
+    srcExists: ctx.exists(src),
+    dstExists: ctx.exists(dst),
+    locks: opts.force ? { findings: locks.findings, blocking: [] } : locks,
+    skipLiveTranscripts: opts.skipLive
+  });
+  const plan = migration.plan;
+  const informational = locks.findings.filter((finding) => !locks.blocking.includes(finding));
+  if (informational.length > 0) reporter.locks({ findings: informational, blocking: [] });
+  if (plan.warnings.some((w) => w.kind === "nothing-to-do")) {
+    reporter.plan(plan, { backupId: null, dryRun: true });
+    reporter.note("\uC62E\uAE38 \uC0C1\uD0DC\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.");
+    return "nothingToDo";
+  }
+  if (opts.dryRun || plan.blockers.length > 0) {
+    reporter.plan(plan, { backupId: null, dryRun: true });
+    for (const blocker of plan.blockers) reporter.warn(describeBlocker(blocker));
+    if (plan.blockers.length > 0) return blockerExit(plan);
+    return "planned";
+  }
+  const backupId = `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/[-:T]/g, "")}-${ulid3().slice(-6)}`;
+  reporter.plan(plan, { backupId: opts.noBackup ? null : backupId, dryRun: false });
+  if (!opts.yes && !await reporter.confirm(`${plan.steps.length}\uAC1C \uD56D\uBAA9\uC744 \uC62E\uAE41\uB2C8\uB2E4. \uC9C4\uD589\uD560\uAE4C\uC694?`)) {
+    reporter.note("\uCDE8\uC18C\uD588\uC2B5\uB2C8\uB2E4.");
+    return "ok";
+  }
+  const root = backupRoot(ctx.env.toolDir);
+  mkdirSync6(root, { recursive: true });
+  const backup = opts.noBackup ? null : createBackup({ root, backupId, version: opts.version, plan });
+  const journal = Journal.resume(
+    backup ? backup.journalPath : join10(root, `${backupId}.journal.jsonl`)
+  );
+  journal.append({ kind: "begin", backupId, plan });
+  const startedAt2 = Date.now();
+  const result = await apply({
+    plan,
+    backup,
+    journal,
+    onEvent: (event) => reporter.progress(event)
+  });
+  if (!result.failed) {
+    reporter.applied(plan, {
+      backupId: backup?.id ?? null,
+      durationMs: Date.now() - startedAt2
+    });
+    return "ok";
+  }
+  if (!backup) {
+    reporter.failed(plan, { error: result.failed.error, rolledBack: false, backupId: null });
+    return "failedDirty";
+  }
+  const reverted = rollback({ backupDir: backup.dir });
+  reporter.failed(plan, {
+    error: result.failed.error,
+    rolledBack: reverted.ok,
+    backupId: backup.id
+  });
+  for (const residue of reverted.residue) reporter.warn(`${residue.path}: ${residue.why}`);
+  return reverted.ok ? "failedRolledBack" : "failedDirty";
+}
+function pickKnown(ctx, candidates) {
+  for (const candidate of candidates) {
+    const known = ctx.index.projects.some(
+      (p) => p.primaryCwd && pathEquals(p.primaryCwd, candidate, ctx.policy) || [...p.cwdCensus.keys()].some((c) => pathEquals(c, candidate, ctx.policy))
+    ) || ctx.index.configProjectKeys.some((k) => pathEquals(k, candidate, ctx.policy));
+    if (known) return candidate;
+  }
+  return candidates[0];
+}
+function blockerExit(plan) {
+  if (plan.blockers.some((b) => b.kind === "locked")) return "locked";
+  if (plan.blockers.some((b) => b.kind === "src-missing" || b.kind === "dst-inside-src")) {
+    return "precondition";
+  }
+  return "conflict";
+}
+function describeBlocker(blocker) {
+  switch (blocker.kind) {
+    case "locked":
+      return `claude \uC138\uC158\uC774 \uC774 \uACBD\uB85C\uB97C \uC0AC\uC6A9\uD558\uACE0 \uC788\uC2B5\uB2C8\uB2E4 (pid ${blocker.sessions.map((s) => s.pid).join(", ")}). \uC138\uC158\uC744 \uC885\uB8CC\uD55C \uB4A4 \uB2E4\uC2DC \uC2E4\uD589\uD558\uC138\uC694.`;
+    case "dst-project-dir-exists":
+      return `\uB300\uC0C1 \uACBD\uB85C\uC758 project \uB514\uB809\uD130\uB9AC\uAC00 \uC774\uBBF8 \uC788\uC2B5\uB2C8\uB2E4: ${blocker.dirName}`;
+    case "dst-config-key-exists":
+      return `claude.json\uC5D0 \uB300\uC0C1 \uACBD\uB85C \uD0A4\uAC00 \uC774\uBBF8 \uC788\uC2B5\uB2C8\uB2E4: ${blocker.key}`;
+    case "src-missing":
+      return "\uC6D0\uBCF8 \uB514\uB809\uD130\uB9AC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uC774\uBBF8 \uC62E\uACBC\uB2E4\uBA74 --state-only\uB97C \uC0AC\uC6A9\uD558\uC138\uC694.";
+    case "dst-inside-src":
+      return "\uB300\uC0C1 \uACBD\uB85C\uAC00 \uC6D0\uBCF8 \uC548\uC5D0 \uC788\uC2B5\uB2C8\uB2E4.";
+  }
+}
+
+// src/commands/transfer.ts
+import {
+  cpSync,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync7,
+  mkdtempSync,
+  readFileSync as readFileSync6,
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { tmpdir } from "os";
+import { basename as basename2, join as join11 } from "path";
+import * as tar from "tar";
+var MANIFEST = "claude-mv-bundle.json";
+function runExport(ctx, reporter, opts) {
+  const project = findProject(ctx, opts.target, opts.home);
+  if (!project) throw new CliError(`\uB4F1\uB85D\uB41C \uD504\uB85C\uC81D\uD2B8\uAC00 \uC544\uB2D9\uB2C8\uB2E4: ${opts.target}`, "usage");
+  const bundle = {
+    version: 1,
+    tool: "claude-mv",
+    originalPath: project.primaryCwd ?? project.dirPath,
+    dirName: project.dirName,
+    exportedAt: Date.now(),
+    platform: ctx.platform
+  };
+  const staging = mkdtempSync(join11(tmpdir(), "claude-mv-export-"));
+  writeFileSync2(join11(staging, MANIFEST), JSON.stringify(bundle, null, 2));
+  cpSync(project.dirPath, join11(staging, "projects", project.dirName), { recursive: true });
+  const out = opts.out ?? `${basename2(bundle.originalPath)}-claude-state.tgz`;
+  tar.create({ gzip: true, file: out, sync: true, cwd: staging }, [MANIFEST, "projects"]);
+  rmSync4(staging, { recursive: true, force: true });
+  reporter.note(`${out}\uC5D0 \uC800\uC7A5\uD588\uC2B5\uB2C8\uB2E4.`);
+  return "ok";
+}
+function readBundle(file) {
+  const staging = mkdtempSync(join11(tmpdir(), "claude-mv-peek-"));
+  tar.extract({ file, sync: true, cwd: staging }, [MANIFEST]);
+  const manifestPath = join11(staging, MANIFEST);
+  if (!existsSync7(manifestPath)) {
+    throw new CliError("claude-mv\uB85C \uB9CC\uB4E0 \uBC88\uB4E4\uC774 \uC544\uB2D9\uB2C8\uB2E4.", "usage");
+  }
+  return JSON.parse(readFileSync6(manifestPath, "utf8"));
+}
+function runImport(ctx, reporter, opts) {
+  const bundle = readBundle(opts.file);
+  const staging = mkdtempSync(join11(tmpdir(), "claude-mv-import-"));
+  tar.extract({ file: opts.file, sync: true, cwd: staging });
+  const source = join11(staging, "projects", bundle.dirName);
+  if (!existsSync7(source)) throw new CliError("\uBC88\uB4E4\uC5D0 project \uB514\uB809\uD130\uB9AC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.", "usage");
+  const destination = join11(ctx.env.projectsDir, bundle.dirName);
+  if (existsSync7(destination)) {
+    throw new CliError(
+      `\uC774\uBBF8 \uC874\uC7AC\uD558\uB294 \uC0C1\uD0DC\uB97C \uB36E\uC5B4\uC4F0\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4: ${bundle.dirName}. merge\uB97C \uC0AC\uC6A9\uD558\uC138\uC694.`,
+      "conflict"
+    );
+  }
+  mkdirSync7(ctx.env.projectsDir, { recursive: true });
+  cpSync(source, destination, { recursive: true });
+  rmSync4(staging, { recursive: true, force: true });
+  reporter.note(`${bundle.originalPath}\uC758 \uC0C1\uD0DC\uB97C \uB4E4\uC5EC\uC654\uC2B5\uB2C8\uB2E4.`);
+  if (!opts.to) return { code: "ok" };
+  const to = normalizePath(opts.to, { platform: ctx.platform, home: opts.home, realpath: false });
+  reporter.note(`\uC774\uC5B4\uC11C ${bundle.originalPath}\uC5D0\uC11C ${to}\uB85C \uC774\uAD00\uD569\uB2C8\uB2E4.`);
+  return { code: "ok", migrateFrom: bundle.originalPath, migrateTo: to };
+}
+
+// src/render/json/reporter.ts
+var SCHEMA_VERSION = 1;
+var JsonReporter = class {
+  constructor(out = process.stdout, err = process.stderr, version = "0.0.0") {
+    this.out = out;
+    this.err = err;
+    this.version = version;
+  }
+  out;
+  err;
+  version;
+  result = null;
+  envelope(kind, body) {
+    return { tool: "claude-mv", version: this.version, schema: SCHEMA_VERSION, kind, ...body };
+  }
+  event(body) {
+    this.err.write(`${JSON.stringify(body)}
+`);
+  }
+  plan(plan, opts) {
+    this.result = this.envelope(opts.dryRun ? "plan" : "pending", {
+      src: plan.request.src,
+      dst: plan.request.dst,
+      options: {
+        stateOnly: plan.request.stateOnly,
+        rewriteProse: plan.request.rewriteProse
+      },
+      steps: plan.steps,
+      blockers: plan.blockers,
+      warnings: plan.warnings,
+      proseLeftBehind: plan.proseLeftBehind,
+      backup: opts.backupId ? { id: opts.backupId } : null
+    });
+  }
+  async confirm() {
+    return false;
+  }
+  progress(event) {
+    this.event({
+      kind: "progress",
+      event: event.kind,
+      step: "step" in event ? event.step.id : void 0,
+      phase: "phase" in event ? event.phase : void 0,
+      detail: "detail" in event ? event.detail : void 0
+    });
+  }
+  applied(plan, opts) {
+    this.result = this.envelope("result", {
+      src: plan.request.src,
+      dst: plan.request.dst,
+      steps: plan.steps.map((s) => ({ ...s, status: "done" })),
+      backup: opts.backupId ? { id: opts.backupId } : null,
+      durationMs: opts.durationMs,
+      ok: true
+    });
+  }
+  failed(plan, opts) {
+    this.result = this.envelope("result", {
+      src: plan.request.src,
+      dst: plan.request.dst,
+      ok: false,
+      error: opts.error.message,
+      rollback: { attempted: true, ok: opts.rolledBack },
+      backup: opts.backupId ? { id: opts.backupId } : null
+    });
+  }
+  locks(report) {
+    this.event({ kind: "locks", findings: report.findings });
+  }
+  doctor(report) {
+    this.result = this.envelope("doctor", {
+      orphans: report.orphans.map((entry) => ({
+        encoded: entry.project.dirName,
+        path: entry.project.primaryCwd,
+        pathSource: entry.project.primaryCwd ? "transcript" : "unknown",
+        health: entry.project.health,
+        sizeBytes: entry.project.bytes,
+        lastActivity: entry.project.lastActivityMs,
+        transcripts: entry.project.transcripts.length,
+        alsoIn: entry.alsoIn,
+        suggestions: entry.suggestions
+      })),
+      healthy: report.healthy.map((p) => ({ path: p.primaryCwd, encoded: p.dirName })),
+      collisions: report.collisions
+    });
+  }
+  list(projects) {
+    this.result = this.envelope("list", {
+      projects: projects.map((p) => ({
+        path: p.primaryCwd,
+        encoded: p.dirName,
+        health: p.health,
+        sizeBytes: p.bytes,
+        transcripts: p.transcripts.length,
+        lastActivity: p.lastActivityMs
+      }))
+    });
+  }
+  info(project) {
+    this.result = this.envelope("info", {
+      path: project.primaryCwd,
+      encoded: project.dirName,
+      dir: project.dirPath,
+      health: project.health,
+      sizeBytes: project.bytes,
+      transcripts: project.transcripts.map((t) => ({
+        kind: t.kind,
+        sessionId: t.sessionId,
+        agentId: t.agentId,
+        lines: t.lines,
+        bytes: t.bytes,
+        malformed: t.malformed.length
+      })),
+      cwdCensus: Object.fromEntries(project.cwdCensus)
+    });
+  }
+  backups(items) {
+    this.result = this.envelope("backups", { backups: items });
+  }
+  note(message) {
+    this.event({ kind: "note", message });
+  }
+  warn(message) {
+    this.event({ kind: "warn", message });
+  }
+  async close() {
+    if (this.result) this.out.write(`${JSON.stringify(this.result, null, 2)}
+`);
+  }
+};
+
+// src/render/reporter.ts
+function resolveRenderMode(opts) {
+  if (opts.json) return "json";
+  if (!opts.isTTY) return "plain";
+  if (opts.ci) return "plain";
+  if (opts.term === "dumb") return "plain";
+  if (opts.quiet) return "plain";
+  return "ink";
+}
+
+// src/index.ts
+async function main(argv) {
+  if (argv.includes("--version") || argv.includes("-v")) {
+    process.stdout.write(`${package_default.version}
+`);
+    return ExitCode.ok;
+  }
+  const { command, rest } = dispatch(argv);
+  if (command === "__complete") return await runComplete(rest);
+  if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+    process.stdout.write(helpText());
+    return ExitCode.ok;
+  }
+  if (rest.includes("--help") || rest.includes("-h")) {
+    process.stdout.write(helpText(command));
+    return ExitCode.ok;
+  }
+  const spec = findCommand(command);
+  if (!spec) throw new CliError(`\uC54C \uC218 \uC5C6\uB294 \uBA85\uB839\uC785\uB2C8\uB2E4: ${command}`, "usage");
+  const parsed = parseArgs(spec, rest);
+  if (command === "completion") {
+    const [shell] = requirePositionals(spec, parsed);
+    if (!["zsh", "bash", "fish"].includes(shell)) {
+      throw new CliError("zsh, bash, fish \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4.", "usage");
+    }
+    process.stdout.write(completionScript(shell));
+    return ExitCode.ok;
+  }
+  const cliEnv = readCliEnv();
+  const ctx = await createContext({ claudeHome: str(parsed, "claude-home") });
+  const mode = resolveRenderMode({
+    json: bool(parsed, "json"),
+    quiet: bool(parsed, "quiet"),
+    isTTY: cliEnv.isStdoutTTY,
+    ci: cliEnv.ci,
+    term: cliEnv.term
+  });
+  if (mode === "json" && isMutating(command) && !bool(parsed, "yes")) {
+    throw new CliError(
+      "--json\uC73C\uB85C \uC2E4\uD589\uD560 \uB54C\uB294 --yes\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4. \uD655\uC778\uC744 \uBB3C\uC744 \uC218 \uC5C6\uAE30 \uB54C\uBB38\uC785\uB2C8\uB2E4.",
+      "usage"
+    );
+  }
+  const reporter = mode === "json" ? new JsonReporter(process.stdout, process.stderr, package_default.version) : mode === "ink" ? (await import("./reporter-4S4IPLQW.js")).createInkReporter() : new PlainReporter();
+  try {
+    return ExitCode[await run(command, ctx, reporter, parsed, mode, cliEnv)];
+  } finally {
+    await reporter.close();
+  }
+}
+function isMutating(command) {
+  return ["mv", "rm", "merge", "import", "rollback"].includes(command);
+}
+async function run(command, ctx, reporter, parsed, mode, cliEnv) {
+  const home = homedir2();
+  const spec = findCommand(command);
+  switch (command) {
+    case "mv": {
+      const [src, dst] = requirePositionals(spec, parsed);
+      return await runMove(ctx, reporter, {
+        src,
+        dst,
+        stateOnly: bool(parsed, "state-only"),
+        rewriteProse: bool(parsed, "rewrite-prose"),
+        dryRun: bool(parsed, "dry-run"),
+        yes: bool(parsed, "yes"),
+        force: bool(parsed, "force"),
+        noBackup: bool(parsed, "no-backup"),
+        allowAncestors: bool(parsed, "allow-ancestors"),
+        skipLive: bool(parsed, "skip-live"),
+        home,
+        version: package_default.version
+      });
+    }
+    case "ls":
+      return runList(ctx, reporter, {
+        orphansOnly: bool(parsed, "orphans"),
+        sort: str(parsed, "sort") ?? "activity"
+      });
+    case "info":
+      return runInfo(ctx, reporter, {
+        target: await needTarget(ctx, parsed, mode, "info", cliEnv),
+        home
+      });
+    case "doctor":
+      return runDoctor(ctx, reporter);
+    case "rm":
+      return await runRemove(ctx, reporter, {
+        target: await needTarget(ctx, parsed, mode, "rm", cliEnv),
+        home,
+        version: package_default.version,
+        yes: bool(parsed, "yes"),
+        force: bool(parsed, "force")
+      });
+    case "merge": {
+      const [from, to] = requirePositionals(spec, parsed);
+      return runMerge(ctx, reporter, { from, to, home, yes: bool(parsed, "yes") });
+    }
+    case "backup":
+      return runBackupOnly(ctx, reporter, {
+        target: await needTarget(ctx, parsed, mode, "backup", cliEnv),
+        home,
+        version: package_default.version
+      });
+    case "rollback": {
+      const [id] = parsed.positionals;
+      if (!id) return runBackups(ctx, reporter);
+      return runRollback(ctx, reporter, { id });
+    }
+    case "export":
+      return runExport(ctx, reporter, {
+        target: await needTarget(ctx, parsed, mode, "export", cliEnv),
+        out: str(parsed, "out"),
+        home
+      });
+    case "import": {
+      const [file] = requirePositionals(spec, parsed);
+      const result = runImport(ctx, reporter, { file, to: str(parsed, "to"), home });
+      if (!result.migrateFrom || !result.migrateTo) return result.code;
+      const fresh = await createContext({ claudeHome: str(parsed, "claude-home") });
+      return await runMove(fresh, reporter, {
+        src: result.migrateFrom,
+        dst: result.migrateTo,
+        stateOnly: true,
+        rewriteProse: false,
+        dryRun: false,
+        yes: true,
+        force: false,
+        noBackup: false,
+        allowAncestors: false,
+        skipLive: false,
+        home,
+        version: package_default.version
+      });
+    }
+    default:
+      throw new CliError(`\uC544\uC9C1 \uAD6C\uD604\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4: ${command}`, "internal");
+  }
+}
+async function needTarget(ctx, parsed, mode, command, cliEnv) {
+  const [given] = parsed.positionals;
+  if (given) return given;
+  const picker = resolvePickerMode({
+    override: cliEnv.picker,
+    isTTY: cliEnv.isStdinTTY && mode !== "json",
+    hasFzf: await hasFzf()
+  });
+  if (picker === "none") {
+    throw new CliError(`claude-mv ${command} <\uD504\uB85C\uC81D\uD2B8>\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.`, "usage");
+  }
+  const candidates = projectCandidates(ctx);
+  const picked = picker === "fzf" ? await pickWithFzf(candidates, {
+    prompt: `${command}>`,
+    preview: "claude-mv info {1} 2>/dev/null"
+  }) : null;
+  if (!picked) throw new CliError("\uB300\uC0C1\uC744 \uC120\uD0DD\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.", "usage");
+  return picked;
+}
+function projectCandidates(ctx) {
+  return ctx.index.projects.map((p) => ({
+    value: p.primaryCwd ?? p.dirName,
+    description: p.health === "healthy" ? void 0 : p.health
+  }));
+}
+async function runComplete(words) {
+  try {
+    const ctx = await createContext();
+    const root = backupRoot(ctx.env.toolDir);
+    process.stdout.write(
+      `${formatCandidates(
+        complete(words, {
+          projects: () => projectCandidates(ctx),
+          backups: () => listBackups(root).map((b) => ({ value: b.backupId, description: b.dst })),
+          directories: (prefix) => directoryCandidates(prefix),
+          bundles: (prefix) => fileCandidates(prefix, ".tgz")
+        })
+      )}
+`
+    );
+  } catch {
+  }
+  return ExitCode.ok;
+}
+function directoryCandidates(prefix) {
+  const base = prefix.endsWith("/") ? prefix : join12(prefix, "..");
+  try {
+    return readdirSync5(base, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => ({ value: join12(base, e.name) }));
+  } catch {
+    return [];
+  }
+}
+function fileCandidates(prefix, suffix) {
+  const base = prefix.includes("/") ? join12(prefix, "..") : ".";
+  try {
+    return readdirSync5(base).filter((name) => name.endsWith(suffix)).map((name) => ({ value: join12(base, name) })).filter((c) => existsSync8(c.value));
+  } catch {
+    return [];
+  }
+}
+main(process.argv.slice(2)).then((code) => process.exit(code)).catch((error) => {
+  if (error instanceof CliError) {
+    process.stderr.write(`${error.message}
+`);
+    if (error.hint) process.stderr.write(`${error.hint}
+`);
+    process.exit(ExitCode[error.code]);
+  }
+  process.stderr.write(`${error.stack ?? String(error)}
+`);
+  process.exit(ExitCode.internal);
+});