@byh3071/vhk 1.6.1 → 1.6.3

package/dist/{chunk-O3A6SO7G.js → chunk-53RJHPP6.js}

@@ -323,7 +323,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path3, checkUnignored, mode) {
+      test(path7, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -332,7 +332,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path3);
+          const matched = rule[mode].test(path7);
           if (!matched) {
             return;
           }
@@ -353,17 +353,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path3, originalPath, doThrow) => {
-      if (!isString(path3)) {
+    var checkPath = (path7, originalPath, doThrow) => {
+      if (!isString(path7)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path3) {
+      if (!path7) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path3)) {
+      if (checkPath.isNotRelative(path7)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -372,7 +372,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path3) => REGEX_TEST_INVALID_PATH.test(path3);
+    var isNotRelative = (path7) => REGEX_TEST_INVALID_PATH.test(path7);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -402,19 +402,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path3 = originalPath && checkPath.convert(originalPath);
+        const path7 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path3,
+          path7,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path3, cache, checkUnignored, slices);
+        return this._t(path7, cache, checkUnignored, slices);
       }
-      checkIgnore(path3) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path3)) {
-          return this.test(path3);
+      checkIgnore(path7) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path7)) {
+          return this.test(path7);
         }
-        const slices = path3.split(SLASH).filter(Boolean);
+        const slices = path7.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -427,18 +427,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path3, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path7, false, MODE_CHECK_IGNORE);
       }
-      _t(path3, cache, checkUnignored, slices) {
-        if (path3 in cache) {
-          return cache[path3];
+      _t(path7, cache, checkUnignored, slices) {
+        if (path7 in cache) {
+          return cache[path7];
         }
         if (!slices) {
-          slices = path3.split(SLASH).filter(Boolean);
+          slices = path7.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path3] = this._rules.test(path3, checkUnignored, MODE_IGNORE);
+          return cache[path7] = this._rules.test(path7, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -446,29 +446,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path3] = parent.ignored ? parent : this._rules.test(path3, checkUnignored, MODE_IGNORE);
+        return cache[path7] = parent.ignored ? parent : this._rules.test(path7, checkUnignored, MODE_IGNORE);
       }
-      ignores(path3) {
-        return this._test(path3, this._ignoreCache, false).ignored;
+      ignores(path7) {
+        return this._test(path7, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path3) => !this.ignores(path3);
+        return (path7) => !this.ignores(path7);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path3) {
-        return this._test(path3, this._testCache, true);
+      test(path7) {
+        return this._test(path7, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path3) => checkPath(path3 && checkPath.convert(path3), path3, RETURN_FALSE);
+    var isPathValid = (path7) => checkPath(path7 && checkPath.convert(path7), path7, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path3) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path3) || isNotRelative(path3);
+      checkPath.isNotRelative = (path7) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path7) || isNotRelative(path7);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -483,76 +483,15 @@ var require_ignore = __commonJS({
   }
 });
 
-// src/commands/deploy.ts
-import { existsSync } from "fs";
+// src/commands/sync.ts
 import chalk2 from "chalk";
+import fs4 from "fs";
+import path4 from "path";
 import inquirer from "inquirer";
 
-// src/lib/exec.ts
-import { execFileSync } from "child_process";
-var SHIM_BINARIES = /* @__PURE__ */ new Set(["pnpm", "npm", "npx", "yarn"]);
-function platformCmd(cmd) {
-  if (process.platform === "win32" && SHIM_BINARIES.has(cmd)) {
-    return `${cmd}.cmd`;
-  }
-  return cmd;
-}
-function resolveCmd(cmd, args) {
-  if (process.platform === "win32" && SHIM_BINARIES.has(cmd)) {
-    return { bin: "cmd.exe", argv: ["/d", "/s", "/c", `${cmd}.cmd`, ...args] };
-  }
-  return { bin: platformCmd(cmd), argv: args };
-}
-var DEFAULT_EXEC_TIMEOUT_MS = 6e5;
-var NETWORK_EXEC_TIMEOUT_MS = 3e4;
-function resolveTimeout(timeoutMs, fallback) {
-  const v = timeoutMs === void 0 ? fallback : timeoutMs;
-  return v > 0 ? v : void 0;
-}
-function isTimeoutError(e, timeout) {
-  if (!timeout) return false;
-  return e.code === "ETIMEDOUT";
-}
-function safeExecFile(cmd, args, opts = {}) {
-  const { bin, argv } = resolveCmd(cmd, args);
-  const env2 = opts.env ? { ...process.env, ...opts.env } : void 0;
-  const timeout = resolveTimeout(opts.timeoutMs, DEFAULT_EXEC_TIMEOUT_MS);
-  try {
-    const out = execFileSync(bin, argv, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      env: env2,
-      ...timeout ? { timeout, killSignal: "SIGTERM" } : {}
-    }).toString();
-    return { ok: true, out: out.trim() };
-  } catch (err) {
-    const e = err;
-    const stdout = e.stdout ? e.stdout.toString() : "";
-    let msg = e.message ?? String(err);
-    if (isTimeoutError(e, timeout)) {
-      msg = `\uBA85\uB839 \uC2DC\uAC04 \uCD08\uACFC (timeout ${timeout}ms): ${cmd} ${args.join(" ")}`.trim();
-    }
-    return { ok: false, err: msg, out: stdout.trim() };
-  }
-}
-function safeExecFileStream(cmd, args, opts = {}) {
-  const { bin, argv } = resolveCmd(cmd, args);
-  const timeout = opts.timeoutMs && opts.timeoutMs > 0 ? opts.timeoutMs : void 0;
-  try {
-    execFileSync(bin, argv, {
-      encoding: "utf-8",
-      stdio: "inherit",
-      ...timeout ? { timeout, killSignal: "SIGTERM" } : {}
-    });
-    return { ok: true };
-  } catch (err) {
-    const e = err;
-    let msg = err instanceof Error ? err.message : String(err);
-    if (isTimeoutError(e, timeout)) {
-      msg = `\uBA85\uB839 \uC2DC\uAC04 \uCD08\uACFC (timeout ${timeout}ms): ${cmd} ${args.join(" ")}`.trim();
-    }
-    return { ok: false, err: msg };
-  }
+// src/lib/date.ts
+function localDate(d = /* @__PURE__ */ new Date()) {
+  return d.toLocaleDateString("sv-SE");
 }
 
 // src/i18n/ko.ts
@@ -562,7 +501,7 @@ var ko = {
     notGitRepo: "Git \uC800\uC7A5\uC18C\uAC00 \uC544\uB2C8\uC5D0\uC694. \uBA3C\uC800 git init\uC744 \uC2E4\uD589\uD558\uC138\uC694.",
     branch: "\uBE0C\uB79C\uCE58:",
     changes: "\uBCC0\uACBD:",
-    recentCommits: "\uCD5C\uADFC \uCEE4\uBC0B (3):",
+    recentCommits: (n) => `\uCD5C\uADFC \uCEE4\uBC0B (${n}):`,
     noCommits: "\uCEE4\uBC0B \uC5C6\uC74C",
     remote: "\uC6D0\uACA9:",
     noUpstream: "upstream \uC5C6\uC74C",
@@ -573,8 +512,9 @@ var ko = {
     noPackage: "package.json \uC5C6\uC74C",
     detached: "(detached HEAD)",
     unknownBranch: "(\uC54C \uC218 \uC5C6\uC74C)",
-    nextWithChangesMessage: "\uBCC0\uACBD\uC0AC\uD56D\uC774 \uC788\uC5B4\uC694. \uCEE4\uBC0B\xB7\uD478\uC2DC\uB97C \uC9C4\uD589\uD558\uC138\uC694.",
-    nextWithChangesCursor: "\uC800\uC7A5\uD574\uC918",
+    nextWithChangesMessage: "\uBCC0\uACBD\uC0AC\uD56D\uC774 \uC788\uC5B4\uC694. \uBA3C\uC800 \uBB34\uC5C7\uC774 \uBC14\uB00C\uC5C8\uB294\uC9C0 \uD655\uC778\uD558\uC138\uC694.",
+    nextWithChangesCursor: "\uBB50 \uBC14\uB00C\uC5C8\uC5B4?",
+    nextWithChangesAlt: "\uD655\uC778\uD588\uC73C\uBA74 vhk save \uB85C \uC800\uC7A5\uD558\uC138\uC694",
     nextCleanMessage: "\uD074\uB9B0 \uC0C1\uD0DC! \uB2E4\uC74C \uBBF8\uC158\uC73C\uB85C \uB118\uC5B4\uAC00\uC138\uC694.",
     nextCleanCursor: "\uB2E4\uC74C \uBAA9\uD45C \uC54C\uB824\uC918"
   },
@@ -719,7 +659,10 @@ var ko = {
     commandsMdDone: "\u{1F4CB} COMMANDS.md \uC0DD\uC131",
     scriptsDone: "\u{1F4E6} package.json scripts \uCD94\uAC00",
     gitignoreCreated: "\u{1F512} .gitignore \uC0DD\uC131 (.env\xB7node_modules\xB7dist \uC81C\uC678)",
-    gitignoreUpdated: "\u{1F512} .gitignore \uBCF4\uAC15 (\uB204\uB77D \uD56D\uBAA9 \uCD94\uAC00)"
+    gitignoreUpdated: "\u{1F512} .gitignore \uBCF4\uAC15 (\uB204\uB77D \uD56D\uBAA9 \uCD94\uAC00)",
+    adoptPrompt: (n, list) => `\u{1F4E5} \uAE30\uC874 \uADDC\uCE59 \uD30C\uC77C ${n}\uAC1C \uBC1C\uACAC (${list}). RULES.md\uB85C \uAC00\uC838\uC62C\uAE4C\uC694?`,
+    adoptPreview: (n) => `\uAE30\uC874 \uADDC\uCE59 ${n}\uAC1C\uB97C RULES.md \uD45C\uC900 \uC139\uC158\uC73C\uB85C \uBCD1\uD569\uD588\uC5B4\uC694 (\uCD9C\uCC98 \uC8FC\uC11D \uD3EC\uD568).`,
+    adoptDone: "\u{1F4E5} RULES.md \u2014 \uAE30\uC874 \uADDC\uCE59 adopt \uC644\uB8CC"
   },
   recap: {
     title: "\u{1F4DD} \uC624\uB298 \uD55C \uC77C \uC815\uB9AC",
@@ -783,8 +726,29 @@ var ko = {
     windsurfDone: "\u2705 .windsurfrules \uB9DE\uCDA4 \uC644\uB8CC",
     copilotDone: "\u2705 .github/copilot-instructions.md \uB9DE\uCDA4 \uC644\uB8CC",
     antigravityDone: "\u2705 .agents/rules/vhk-rules.md \uB9DE\uCDA4 \uC644\uB8CC",
+    agentsDone: "\u2705 AGENTS.md \uB9DE\uCDA4 \uC644\uB8CC",
     antigravityTruncated: "Antigravity 12,000\uC790 \uC81C\uD55C\uC73C\uB85C \uC77C\uBD80 \uC808\uC0AD\uB428 \u2014 \uC804\uCCB4\uB294 RULES.md \uCC38\uC870",
-    done: "\u{1F504} \uB9DE\uCD94\uAE30 \uC644\uB8CC!"
+    done: "\u{1F504} \uB9DE\uCD94\uAE30 \uC644\uB8CC!",
+    // 안전 가드 (배치 0) — 덮어쓰기 전 백업·드리프트 확인·미리보기
+    backupSaved: (n, id) => `\u{1F6DF} \uB36E\uC5B4\uC4F0\uAE30 \uC804 ${n}\uAC1C \uD30C\uC77C \uBC31\uC5C5\uD568 \u2192 .vhk/backups/${id} (\uBCF5\uC6D0: vhk restore)`,
+    firstSync: "\u{1F6DF} \uCCAB sync \u2014 \uAE30\uC874 \uD30C\uC77C\uC744 \uBC31\uC5C5\uD55C \uB4A4 \uC0DD\uC131\uD569\uB2C8\uB2E4.",
+    driftWarn: (p) => `\u26A0\uFE0F ${p} \uAC00 RULES.md \uC0DD\uC131\uBCF8\uACFC \uB2E4\uB985\uB2C8\uB2E4 (\uC9C1\uC811 \uC218\uC815\uD588\uC744 \uC218 \uC788\uC5B4\uC694).`,
+    driftConfirm: (n) => `\uC704 ${n}\uAC1C \uD30C\uC77C\uC758 \uAE30\uC874 \uB0B4\uC6A9\uC744 \uB36E\uC5B4\uC4F8\uAE4C\uC694? (\uBC31\uC5C5\uC740 \uC774\uBBF8 \uC800\uC7A5\uB428)`,
+    skipped: (p) => `\u23ED\uFE0F  \uAC74\uB108\uB700: ${p} (\uB36E\uC5B4\uC4F0\uAE30 \uAC70\uBD80 \u2014 \uBC31\uC5C5\uB9CC \uBCF4\uAD00)`,
+    dryRunHeader: "\u{1F50E} \uBBF8\uB9AC\uBCF4\uAE30 (--dry-run) \u2014 \uC2E4\uC81C \uD30C\uC77C \uBCC0\uACBD \uC5C6\uC74C",
+    dryRunWouldWrite: (p, drift) => `  ${drift ? "\u270F\uFE0F  \uBCC0\uACBD\uB428" : "\xB7  \uB3D9\uC77C"} : ${p}`,
+    nonTtyAuto: (n, id) => `\u{1F916} \uBE44\uB300\uD654\uD615(CI/\uC5D0\uC774\uC804\uD2B8) \u2014 ${n}\uAC1C \uBC31\uC5C5 \uD6C4 \uC9C4\uD589. \uBCF5\uC6D0: vhk restore ${id}`
+  },
+  restore: {
+    title: "\u{1F6DF} \uBC31\uC5C5 \uBCF5\uC6D0",
+    notGitNote: "\uBC31\uC5C5\uC740 .vhk/backups/ \uC758 \uB85C\uCEEC \uBCF5\uC0AC\uBCF8\uC5D0\uC11C \uBCF5\uC6D0\uB429\uB2C8\uB2E4 (git \uBB34\uAD00).",
+    noBackups: "\uBCF5\uC6D0\uD560 \uBC31\uC5C5\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. (vhk sync \uAC00 \uB36E\uC5B4\uC4F0\uAE30 \uC804 \uC790\uB3D9 \uC0DD\uC131)",
+    selectPrompt: "\uBCF5\uC6D0\uD560 \uBC31\uC5C5\uC744 \uC120\uD0DD\uD558\uC138\uC694:",
+    listHeader: "\u{1F4CB} \uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uBC31\uC5C5 (\uCD5C\uC2E0\uC21C):",
+    restored: (n, id) => `\u2705 ${n}\uAC1C \uD30C\uC77C \uBCF5\uC6D0 \uC644\uB8CC (\uBC31\uC5C5 ${id})`,
+    notFound: (id) => `\u274C \uBC31\uC5C5\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${id}`,
+    nonTtyHint: "\uBE44\uB300\uD654\uD615 \uBAA8\uB4DC \u2014 \uBCF5\uC6D0\uD560 \uBC31\uC5C5 id \uB97C \uC778\uC790\uB85C \uC9C0\uC815\uD558\uC138\uC694: vhk restore <id>",
+    cancelled: "\uBCF5\uC6D0 \uCDE8\uC18C\uB428"
   },
   cloud: {
     pushTitle: "\u2601\uFE0F .vhk \uD074\uB77C\uC6B0\uB4DC \uBC31\uC5C5 (gist \uC62C\uB9AC\uAE30)",
@@ -901,7 +865,10 @@ var ko = {
   },
   context: {
     title: "\uD504\uB85C\uC81D\uD2B8 \uCEE8\uD14D\uC2A4\uD2B8 \uC0DD\uC131",
-    showTitle: "\uCEE8\uD14D\uC2A4\uD2B8 \uD30C\uC77C"
+    showTitle: "\uCEE8\uD14D\uC2A4\uD2B8 \uD30C\uC77C",
+    resumeMissing: "\u{1F9ED} AI \uC138\uC158 \uBCF5\uC6D0 \uCEE8\uD14D\uC2A4\uD2B8 \uC5C6\uC74C \u2192 \uC0DD\uC131: vhk context",
+    resumeExists: "\u{1F9ED} \uC0C8 \uC138\uC158\uC774\uBA74 AI \uCEE8\uD14D\uC2A4\uD2B8 \uBCF5\uC6D0: vhk context-show (\uAC31\uC2E0: vhk context)",
+    resumeStale: "\u{1F9ED} \uCEE8\uD14D\uC2A4\uD2B8\uAC00 \uC624\uB798\uB428(\uCF54\uB4DC \uBCC0\uACBD \uC774\uD6C4) \u2192 \uAC31\uC2E0: vhk context"
   },
   brief: {
     title: "\uD504\uB85C\uC81D\uD2B8 \uBE0C\uB9AC\uD551"
@@ -912,7 +879,9 @@ var ko = {
     initTitle: "\u{1F3D7}\uFE0F  goals/ \uAD6C\uC870 \uC2A4\uCE90\uD3F4\uB529",
     checkTitle: "\u2705 Goal \uAC8C\uC774\uD2B8 \uAC80\uC99D",
     doneTitle: "\u{1F3C1} Goal \uC644\uB8CC \uCC98\uB9AC",
+    syncTitle: "\u{1F504} Goal \uAC8C\uC774\uD2B8 \uC2A4\uD06C\uB9BD\uD2B8 \uB3D9\uAE30\uD654",
     duplicateId: (ids) => `\u26A0 \uC911\uBCF5\uB41C goal id: ${ids} \u2014 \uAC19\uC740 id \uD30C\uC77C\uC774 \uC5EC\uB7EC \uAC1C\uBA74 \uCCAB \uB9E4\uCE58\uB9CC \uC0AC\uC6A9\uB429\uB2C8\uB2E4. id \uB97C \uC720\uC77C\uD558\uAC8C \uACE0\uCE58\uC138\uC694.`,
+    skippedFiles: (n) => `\u26A0 \uC2A4\uD0A4\uB9C8 \uBD88\uC77C\uCE58\uB85C \uBB34\uC2DC\uB41C \uD30C\uC77C ${n}\uAC1C (goal \uB85C \uC548 \uC7A1\uD798 \u2014 silent skip):`,
     notFound: (id) => `goal id ${id} \uC5C6\uC74C \u2014 vhk goal list \uB85C \uD655\uC778\uD558\uC138\uC694.`
   },
   agent: {
@@ -921,8 +890,8 @@ var ko = {
     resumeTitle: "\u25B6\uFE0F  HARD_STOP \uD574\uC81C"
   }
 };
-function lookup(path3) {
-  const parts = path3.split(".");
+function lookup(path7) {
+  const parts = path7.split(".");
   let cur = ko;
   for (const part of parts) {
     if (cur === null || typeof cur !== "object") return void 0;
@@ -940,7 +909,124 @@ function t(key, ...args) {
 }
 
 // src/lib/next-step.ts
+import fs2 from "fs";
+import path2 from "path";
 import chalk from "chalk";
+
+// src/lib/drift.ts
+import fs from "fs";
+import path from "path";
+
+// src/lib/git-repo.ts
+import { execFileSync } from "child_process";
+function getGitRoot(cwd = process.cwd()) {
+  return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+    encoding: "utf-8",
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function gitOut(args, cwd) {
+  return execFileSync("git", args, {
+    encoding: "utf-8",
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+}
+function gitRun(args, cwd) {
+  execFileSync("git", args, { stdio: "pipe", cwd });
+}
+function getExecErrorMessage(err) {
+  if (err && typeof err === "object" && "stderr" in err) {
+    const stderr = err.stderr;
+    if (Buffer.isBuffer(stderr)) return stderr.toString("utf-8").trim();
+    if (typeof stderr === "string") return stderr.trim();
+  }
+  return err instanceof Error ? err.message : String(err);
+}
+function hasGitRemote(cwd) {
+  try {
+    return gitOut(["remote"], cwd).trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function countLocalCommits(cwd) {
+  try {
+    const out = gitOut(["rev-list", "--count", "HEAD"], cwd).trim();
+    return parseInt(out, 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+// src/lib/drift.ts
+function normalizeForCompare(s) {
+  return s.replace(/\r\n/g, "\n").replace(/[ \t]+$/gm, "").replace(/\n+$/, "\n");
+}
+function checkRuleDrift(rootDir) {
+  const rulesPath = path.join(rootDir, "RULES.md");
+  if (!fs.existsSync(rulesPath)) return { checked: false, results: [] };
+  const rulesContent = fs.readFileSync(rulesPath, "utf-8");
+  const sections = parseRulesMd(rulesContent);
+  const projectName = deriveProjectName(rulesContent);
+  const results = [];
+  for (const target of SYNC_TARGETS) {
+    const fullPath = path.join(rootDir, target.path);
+    if (!fs.existsSync(fullPath)) {
+      results.push({ path: target.path, status: "missing" });
+      continue;
+    }
+    const expected = normalizeForCompare(target.generate(sections, projectName));
+    const actual = normalizeForCompare(fs.readFileSync(fullPath, "utf-8"));
+    results.push({ path: target.path, status: expected === actual ? "ok" : "drifted" });
+  }
+  return { checked: true, results };
+}
+var CONTEXT_GIT_MARKER = "vhk-context-git";
+var CONTEXT_PATH = ".vhk/context.md";
+function extractContextSha(content) {
+  const m = content.match(new RegExp(`${CONTEXT_GIT_MARKER}:\\s*([0-9a-f]{7,40})`));
+  return m ? m[1] : null;
+}
+var CONTEXT_SOURCE_PATHS = ["package.json", "goals", "docs/state/learnings.md"];
+function contextSourcesChanged(generatedSha, rootDir) {
+  const content = gitOut(
+    ["diff", "--name-only", generatedSha, "HEAD", "--", ...CONTEXT_SOURCE_PATHS],
+    rootDir
+  ).trim();
+  if (content) return true;
+  const structural = gitOut(
+    ["diff", "--name-only", "--diff-filter=ADR", generatedSha, "HEAD"],
+    rootDir
+  ).trim();
+  return structural.length > 0;
+}
+function checkContextDrift(rootDir) {
+  const ctxPath = path.join(rootDir, CONTEXT_PATH);
+  if (!fs.existsSync(ctxPath)) return { checked: false, stale: false };
+  const generatedSha = extractContextSha(fs.readFileSync(ctxPath, "utf-8"));
+  if (!generatedSha) return { checked: false, stale: false };
+  let currentSha;
+  try {
+    currentSha = gitOut(["rev-parse", "HEAD"], rootDir).trim();
+  } catch {
+    return { checked: false, stale: false };
+  }
+  if (!currentSha) return { checked: false, stale: false };
+  if (currentSha.startsWith(generatedSha) || generatedSha.startsWith(currentSha)) {
+    return { checked: true, stale: false, generatedSha, currentSha };
+  }
+  let stale;
+  try {
+    stale = contextSourcesChanged(generatedSha, rootDir);
+  } catch {
+    return { checked: false, stale: false };
+  }
+  return { checked: true, stale, generatedSha, currentSha };
+}
+
+// src/lib/next-step.ts
 function printNextStep(step) {
   console.log("");
   console.log(chalk.cyan.bold("\u2501\u2501\u2501 \uB2E4\uC74C\uC5D0 \uC774\uAC83\uB9CC \uD558\uC138\uC694 \u2501\u2501\u2501"));
@@ -964,6 +1050,580 @@ function printNextStep(step) {
   console.log(chalk.cyan.bold("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
   console.log("");
 }
+function printContextResumeHint(cwd = process.cwd()) {
+  const ctxPath = path2.join(cwd, ".vhk", "context.md");
+  if (!fs2.existsSync(ctxPath)) {
+    console.log(chalk.dim(`  ${t("context.resumeMissing")}`));
+    return;
+  }
+  const drift = checkContextDrift(cwd);
+  if (drift.checked && drift.stale) {
+    console.log(chalk.dim(`  ${t("context.resumeStale")}`));
+    return;
+  }
+  console.log(chalk.dim(`  ${t("context.resumeExists")}`));
+}
+
+// src/lib/backup.ts
+import fs3 from "fs";
+import path3 from "path";
+var BACKUPS_REL = path3.join(".vhk", "backups");
+var VHK_GITIGNORE_REL = path3.join(".vhk", ".gitignore");
+function fsSafeStamp(d) {
+  return d.toISOString().replace(/[:.]/g, "-");
+}
+function ensureVhkIgnored(rootDir, ...entries) {
+  const giPath = path3.join(rootDir, VHK_GITIGNORE_REL);
+  fs3.mkdirSync(path3.dirname(giPath), { recursive: true });
+  let content = fs3.existsSync(giPath) ? fs3.readFileSync(giPath, "utf-8") : "";
+  const present = new Set(content.split("\n").map((l) => l.trim().replace(/\/$/, "")));
+  const missing = entries.filter((e) => !present.has(e.trim().replace(/\/$/, "")));
+  if (missing.length === 0) return;
+  if (content.length > 0 && !content.endsWith("\n")) content += "\n";
+  content += missing.join("\n") + "\n";
+  fs3.writeFileSync(giPath, content, "utf-8");
+}
+function walkRelFiles(baseDir, cur = baseDir) {
+  const out = [];
+  for (const entry of fs3.readdirSync(cur)) {
+    const full = path3.join(cur, entry);
+    if (fs3.statSync(full).isDirectory()) {
+      out.push(...walkRelFiles(baseDir, full));
+    } else {
+      out.push(path3.relative(baseDir, full).split(path3.sep).join("/"));
+    }
+  }
+  return out;
+}
+function saveBackup(files, rootDir, stamp) {
+  const baseId = stamp ?? fsSafeStamp(/* @__PURE__ */ new Date());
+  let id = baseId;
+  let n = 1;
+  while (fs3.existsSync(path3.join(rootDir, BACKUPS_REL, id))) {
+    id = `${baseId}-${String(n++).padStart(3, "0")}`;
+  }
+  const backupDir = path3.join(rootDir, BACKUPS_REL, id);
+  const saved = [];
+  for (const rel of files) {
+    const src = path3.join(rootDir, rel);
+    if (!fs3.existsSync(src)) continue;
+    const dest = path3.join(backupDir, rel);
+    fs3.mkdirSync(path3.dirname(dest), { recursive: true });
+    fs3.copyFileSync(src, dest);
+    saved.push(rel);
+  }
+  ensureVhkIgnored(rootDir, "backups/");
+  return { id, dir: backupDir, files: saved };
+}
+function backupOrderKey(id) {
+  const m = /^(.*Z)(?:-(\d+))?$/.exec(id);
+  return m ? [m[1], m[2] ? parseInt(m[2], 10) : 0] : [id, 0];
+}
+function listBackups(rootDir) {
+  const root = path3.join(rootDir, BACKUPS_REL);
+  if (!fs3.existsSync(root)) return [];
+  return fs3.readdirSync(root).filter((e) => fs3.statSync(path3.join(root, e)).isDirectory()).sort((a, b) => {
+    const [ba, na] = backupOrderKey(a);
+    const [bb, nb] = backupOrderKey(b);
+    if (ba !== bb) return ba < bb ? 1 : -1;
+    return nb - na;
+  }).map((id) => {
+    const dir = path3.join(root, id);
+    return { id, dir, files: walkRelFiles(dir) };
+  });
+}
+function restoreBackup(id, rootDir) {
+  const backupDir = path3.join(rootDir, BACKUPS_REL, id);
+  if (!fs3.existsSync(backupDir)) {
+    throw new Error(`\uBC31\uC5C5 \uC5C6\uC74C: ${id}`);
+  }
+  const rels = walkRelFiles(backupDir);
+  for (const rel of rels) {
+    const src = path3.join(backupDir, rel);
+    const dest = path3.join(rootDir, rel);
+    fs3.mkdirSync(path3.dirname(dest), { recursive: true });
+    fs3.copyFileSync(src, dest);
+  }
+  return rels;
+}
+function pruneBackups(keepN, rootDir) {
+  const all = listBackups(rootDir);
+  const toDelete = all.slice(Math.max(0, keepN));
+  for (const b of toDelete) {
+    fs3.rmSync(b.dir, { recursive: true, force: true });
+  }
+  return toDelete.map((b) => b.id);
+}
+
+// src/lib/rules-import.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var ADOPT_SOURCES = [
+  ".cursorrules",
+  "CLAUDE.md",
+  "AGENTS.md",
+  ".windsurfrules",
+  ".github/copilot-instructions.md"
+];
+var PREAMBLE_TITLE = "\uC11C\uBB38";
+function detectExistingRuleFiles(cwd) {
+  const found = [];
+  for (const rel of ADOPT_SOURCES) {
+    const full = join(cwd, rel);
+    if (existsSync(full)) {
+      try {
+        found.push({ path: rel, content: readFileSync(full, "utf-8") });
+      } catch {
+      }
+    }
+  }
+  return found;
+}
+function splitSections(content) {
+  const sections = [];
+  let title = "";
+  let buf = [];
+  const preamble = [];
+  let sawHeading = false;
+  for (const line of content.split("\n")) {
+    if (line.startsWith("## ")) {
+      sawHeading = true;
+      if (title) sections.push({ title, content: buf.join("\n").trim() });
+      title = line.replace("## ", "").trim();
+      buf = [];
+    } else if (title) {
+      buf.push(line);
+    } else if (!sawHeading) {
+      preamble.push(line);
+    }
+  }
+  if (title) sections.push({ title, content: buf.join("\n").trim() });
+  const pre = preamble.join("\n").trim();
+  if (pre) sections.unshift({ title: PREAMBLE_TITLE, content: pre });
+  return sections;
+}
+function buildAdoptedRules(files, projectName) {
+  const order = [];
+  const byTitle = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    for (const sec of splitSections(file.content)) {
+      let merged = byTitle.get(sec.title);
+      if (!merged) {
+        merged = { title: sec.title, parts: [] };
+        byTitle.set(sec.title, merged);
+        order.push(sec.title);
+      }
+      merged.parts.push({ source: file.path, content: sec.content });
+    }
+  }
+  const lines = [
+    `# ${projectName} \u2014 Rules`,
+    "",
+    "> \uD504\uB85C\uC81D\uD2B8 \uADDC\uCE59\uC758 \uB2E8\uC77C \uC18C\uC2A4(SoT). \uAE30\uC874 \uADDC\uCE59\uC744 `vhk init` adopt \uB85C \uAC00\uC838\uC654\uC2B5\uB2C8\uB2E4.",
+    "> \uADDC\uCE59 \uBCC0\uACBD\uC740 \uD56D\uC0C1 \uC774 \uD30C\uC77C\uC5D0\uC11C\uB9CC \u2014 `vhk sync` \uB85C \uAC01 \uB3C4\uAD6C\uC5D0 \uC804\uD30C\uB429\uB2C8\uB2E4.",
+    ""
+  ];
+  for (const title of order) {
+    const merged = byTitle.get(title);
+    const nonEmpty = merged.parts.filter((p) => p.content.trim());
+    if (!nonEmpty.length) continue;
+    lines.push(`## ${title}`);
+    for (const part of nonEmpty) {
+      lines.push(`<!-- \uCD9C\uCC98: ${part.source} -->`);
+      lines.push(part.content);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/commands/sync.ts
+var CURSORRULES_KEYS = ["\uCF54\uB529 \uADDC\uCE59", "\uAE30\uC220 \uC2A4\uD0DD", "\uC544\uD0A4\uD14D\uCC98", "\uB514\uC790\uC778", "Anti-patterns", "\uCEE4\uBC0B"];
+var CLAUDE_MD_KEYS = ["\uAE30\uB85D", "\uB85C\uADF8", "ADR", "\uD2B8\uB7EC\uBE14\uC288\uD305", "TIL", "/done", "\uCCB4\uD06C\uB9AC\uC2A4\uD2B8"];
+function findUnmappedSections(sections) {
+  const allKeys = [...CURSORRULES_KEYS, ...CLAUDE_MD_KEYS];
+  return sections.filter((s) => s.title !== PREAMBLE_TITLE && !allKeys.some((k) => s.title.includes(k))).map((s) => s.title);
+}
+function parseRulesMd(content) {
+  const sections = [];
+  const lines = content.split("\n");
+  let currentTitle = "";
+  let currentContent = [];
+  for (const line of lines) {
+    if (line.startsWith("## ")) {
+      if (currentTitle) {
+        sections.push({ title: currentTitle, content: currentContent.join("\n").trim() });
+      }
+      currentTitle = line.replace("## ", "").trim();
+      currentContent = [];
+    } else {
+      currentContent.push(line);
+    }
+  }
+  if (currentTitle) {
+    sections.push({ title: currentTitle, content: currentContent.join("\n").trim() });
+  }
+  return sections;
+}
+function buildCodingDoc(headerTitle, sections, projectName) {
+  const codingSections = sections.filter(
+    (s) => CURSORRULES_KEYS.some((k) => s.title.includes(k))
+  );
+  const lines = [
+    `# ${projectName} \u2014 ${headerTitle}`,
+    "",
+    "> \uCF54\uB529/\uB514\uC790\uC778 \uC804\uC6A9. \uAE30\uB85D/\uC6B4\uC601 \u2192 CLAUDE.md \uCC38\uC870.",
+    "> \u26A1 \uC774 \uD30C\uC77C\uC740 RULES.md\uC5D0\uC11C \uC790\uB3D9 \uC0DD\uC131\uB428 (vhk sync). \uC9C1\uC811 \uC218\uC815 \uAE08\uC9C0.",
+    "",
+    "## \uD544\uC218 \uCC38\uC870",
+    "- docs/PRD.md \xB7 docs/ARCHITECTURE.md \xB7 CLAUDE.md \xB7 RULES.md",
+    ""
+  ];
+  for (const section of codingSections) {
+    lines.push(`## ${section.title}`);
+    lines.push(section.content);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function toCursorrules(sections, projectName) {
+  return buildCodingDoc("Cursor Rules", sections, projectName);
+}
+function toWindsurfrules(sections, projectName) {
+  return buildCodingDoc("Windsurf Rules", sections, projectName);
+}
+function toCopilotInstructions(sections, projectName) {
+  return buildCodingDoc("GitHub Copilot Instructions", sections, projectName);
+}
+var ANTIGRAVITY_CHAR_LIMIT = 12e3;
+var ANTIGRAVITY_TRUNCATE_MARKER = "\n\n<!-- \u26A0\uFE0F Antigravity 12,000\uC790 \uC81C\uD55C\uC73C\uB85C \uC808\uC0AD\uB428 \u2014 \uC804\uCCB4 \uADDC\uCE59\uC740 RULES.md \uCC38\uC870 -->\n";
+function truncateForAntigravity(content, limit = ANTIGRAVITY_CHAR_LIMIT) {
+  if (Buffer.byteLength(content, "utf8") <= limit) return content;
+  const SAFETY = 200;
+  const budget = limit - Buffer.byteLength(ANTIGRAVITY_TRUNCATE_MARKER, "utf8") - SAFETY;
+  let lo = 0;
+  let hi = content.length;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (Buffer.byteLength(content.slice(0, mid), "utf8") <= budget) lo = mid;
+    else hi = mid - 1;
+  }
+  const charCut = lo;
+  let cut = content.lastIndexOf("\n## ", charCut);
+  if (cut < charCut * 0.5) {
+    const nl = content.lastIndexOf("\n", charCut);
+    cut = nl > 0 ? nl : charCut;
+  }
+  return content.slice(0, cut).trimEnd() + ANTIGRAVITY_TRUNCATE_MARKER;
+}
+function toAntigravityRules(sections, projectName) {
+  return truncateForAntigravity(buildCodingDoc("Antigravity Rules", sections, projectName));
+}
+var CLAUDE_AUTOGEN_BANNER = "> \u26A1 \uC544\uB798 \uADDC\uCE59 \uC139\uC158\uC740 RULES.md\uC5D0\uC11C \uC790\uB3D9 \uC0DD\uC131\uB428 (vhk sync). \uC9C1\uC811 \uC218\uC815 \uAE08\uC9C0.";
+function toClaudeMd(sections, existing) {
+  const recordSections = sections.filter(
+    (s) => CLAUDE_MD_KEYS.some((k) => s.title.includes(k))
+  );
+  const cleaned = existing.split("\n").filter((line) => line.trim() !== CLAUDE_AUTOGEN_BANNER).join("\n");
+  const statusMatch = cleaned.match(/## 현재 상태[\s\S]*?(?=\n## |$)/);
+  const statusSection = statusMatch ? statusMatch[0].trimEnd() : "";
+  const header = cleaned.split("## ")[0].trim();
+  const lines = [
+    header,
+    "",
+    statusSection,
+    "",
+    CLAUDE_AUTOGEN_BANNER,
+    ""
+  ];
+  for (const section of recordSections) {
+    lines.push(`## ${section.title}`);
+    lines.push(section.content);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function toAgentsMd(sections, projectName) {
+  const codingSections = sections.filter((s) => CURSORRULES_KEYS.some((k) => s.title.includes(k)));
+  const recordSections = sections.filter((s) => CLAUDE_MD_KEYS.some((k) => s.title.includes(k)));
+  const lines = [
+    `# ${projectName} \u2014 AGENTS.md (\uC5D0\uC774\uC804\uD2B8 \uC791\uB3D9 \uADDC\uC57D)`,
+    "",
+    "> \u26A1 \uC774 \uD30C\uC77C\uC740 RULES.md\uC5D0\uC11C \uC790\uB3D9 \uC0DD\uC131\uB428 (vhk sync). \uC9C1\uC811 \uC218\uC815 \uAE08\uC9C0.",
+    "> \uBE60\uB978 \uC2DC\uC791(\uD1A0\uD070 \uC808\uAC10): `docs/context/agent-compact.md` \uB97C \uBA3C\uC800 \uC77D\uC73C\uC138\uC694.",
+    "",
+    "## Loop Protocol",
+    "- \uB8E8\uD504: `context \u2192 goal next \u2192 \uC791\uC5C5 \u2192 goal check \u2192 goal done`",
+    "- \uC791\uC5C5 \uC2DC\uC791 \uC2DC `.vhk/HARD_STOP` \uD655\uC778 \u2014 \uC788\uC73C\uBA74 \uBAA8\uB4E0 \uC790\uB3D9\uD654 \uC989\uC2DC \uC911\uB2E8.",
+    "- active goal \uB9CC \uC791\uC5C5. `docs/state`(next-task/blockers/learnings)\uB294 SoT, append-only.",
+    "- \uAC8C\uC774\uD2B8(tsc / test:run / build) \uD1B5\uACFC\uD574\uC57C\uB9CC `vhk goal done`.",
+    ""
+  ];
+  for (const section of codingSections) {
+    lines.push(`## ${section.title}`);
+    lines.push(section.content);
+    lines.push("");
+  }
+  for (const section of recordSections) {
+    lines.push(`## ${section.title}`);
+    lines.push(section.content);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function deriveProjectName(rulesContent) {
+  const firstLine = rulesContent.split("\n")[0];
+  return firstLine.replace(/^#\s*/, "").replace(/\s*—.*/, "").trim() || "Project";
+}
+var SYNC_TARGETS = [
+  { path: ".cursorrules", generate: toCursorrules, doneMessage: ko.sync.cursorrulesDone },
+  { path: ".windsurfrules", generate: toWindsurfrules, doneMessage: ko.sync.windsurfDone },
+  { path: ".github/copilot-instructions.md", generate: toCopilotInstructions, doneMessage: ko.sync.copilotDone },
+  { path: ".agents/rules/vhk-rules.md", generate: toAntigravityRules, doneMessage: ko.sync.antigravityDone },
+  // AGENTS.md — 6번째 타겟. 항목 1개 추가로 sync·드리프트·백업 가드가 자동 반영된다.
+  { path: "AGENTS.md", generate: toAgentsMd, doneMessage: ko.sync.agentsDone }
+];
+var BACKUP_KEEP = 10;
+var SYNCED_MARKER_REL = path4.join(".vhk", ".synced");
+function buildSyncPlan(rootDir, sections, projectName) {
+  const plan = [];
+  for (const target of SYNC_TARGETS) {
+    const fullPath = path4.join(rootDir, target.path);
+    const exists = fs4.existsSync(fullPath);
+    const newContent = target.generate(sections, projectName);
+    const drift = exists ? normalizeForCompare(fs4.readFileSync(fullPath, "utf-8")) !== normalizeForCompare(newContent) : false;
+    plan.push({ path: target.path, newContent, doneMessage: target.doneMessage, exists, drift });
+  }
+  const claudePath = path4.join(rootDir, "CLAUDE.md");
+  const claudeExists = fs4.existsSync(claudePath);
+  const existingClaude = claudeExists ? fs4.readFileSync(claudePath, "utf-8") : `# \uAE30\uB85D \uADDC\uCE59 (${projectName})
+
+## \uD604\uC7AC \uC0C1\uD0DC
+- **Phase:** **FILL**
+- **\uBE14\uB85C\uCEE4:** \uC5C6\uC74C
+- **\uB2E4\uC74C \uC561\uC158:** **FILL**
+- **\uB9C8\uC9C0\uB9C9 \uC5C5\uB370\uC774\uD2B8:** ${localDate()}`;
+  const claudeNew = toClaudeMd(sections, existingClaude);
+  const claudeDrift = claudeExists ? normalizeForCompare(existingClaude) !== normalizeForCompare(claudeNew) : false;
+  plan.push({
+    path: "CLAUDE.md",
+    newContent: claudeNew,
+    doneMessage: ko.sync.claudeDone,
+    exists: claudeExists,
+    drift: claudeDrift
+  });
+  return plan;
+}
+async function syncCore(rootDir, opts, confirmOverwrite) {
+  const rulesContent = fs4.readFileSync(path4.join(rootDir, "RULES.md"), "utf-8");
+  const sections = parseRulesMd(rulesContent);
+  const projectName = deriveProjectName(rulesContent);
+  const plan = buildSyncPlan(rootDir, sections, projectName);
+  const firstSync = !fs4.existsSync(path4.join(rootDir, SYNCED_MARKER_REL));
+  const unmapped = findUnmappedSections(sections);
+  if (opts.dryRun) {
+    return {
+      dryRun: true,
+      firstSync,
+      backupId: null,
+      backedUp: [],
+      written: [],
+      skipped: [],
+      truncated: [],
+      plan,
+      unmapped
+    };
+  }
+  const toBackup = plan.filter((p) => p.exists && (p.drift || firstSync)).map((p) => p.path);
+  let backupId = null;
+  let backedUp = [];
+  if (toBackup.length) {
+    const info = saveBackup(toBackup, rootDir);
+    pruneBackups(BACKUP_KEEP, rootDir);
+    backupId = info.id;
+    backedUp = info.files;
+  }
+  const drifted = plan.filter((p) => p.drift);
+  const overwriteDrift = drifted.length ? await confirmOverwrite(drifted) : true;
+  const written = [];
+  const skipped = [];
+  const truncated = [];
+  for (const item of plan) {
+    if (item.drift && !overwriteDrift) {
+      skipped.push(item.path);
+      continue;
+    }
+    const fullPath = path4.join(rootDir, item.path);
+    fs4.mkdirSync(path4.dirname(fullPath), { recursive: true });
+    fs4.writeFileSync(fullPath, item.newContent, "utf-8");
+    written.push(item.path);
+    if (item.newContent.includes("Antigravity 12,000\uC790 \uC81C\uD55C\uC73C\uB85C \uC808\uC0AD\uB428")) {
+      truncated.push(item.path);
+    }
+  }
+  fs4.mkdirSync(path4.join(rootDir, ".vhk"), { recursive: true });
+  fs4.writeFileSync(path4.join(rootDir, SYNCED_MARKER_REL), (/* @__PURE__ */ new Date()).toISOString() + "\n", "utf-8");
+  ensureVhkIgnored(rootDir, ".synced");
+  return { dryRun: false, firstSync, backupId, backedUp, written, skipped, truncated, plan, unmapped };
+}
+async function sync(opts = {}) {
+  console.log(chalk2.bold(`
+${ko.sync.title}
+`));
+  const cwd = process.cwd();
+  const rulesPath = path4.join(cwd, "RULES.md");
+  if (!fs4.existsSync(rulesPath)) {
+    console.log(chalk2.yellow(ko.sync.noRules));
+    console.log(chalk2.dim("  RULES.md\uB294 \uD504\uB85C\uC81D\uD2B8 \uADDC\uCE59\uC758 Single Source of Truth\uC785\uB2C8\uB2E4."));
+    console.log(chalk2.dim("  \uC0DD\uC131\uD558\uB824\uBA74: vhk init \uC2E4\uD589 \uD6C4 RULES.md\uB97C \uC791\uC131\uD558\uC138\uC694."));
+    console.log("");
+    console.log(chalk2.dim("  RULES.md \uAE30\uBCF8 \uAD6C\uC870:"));
+    console.log(chalk2.dim("  ## \uD504\uB85C\uC81D\uD2B8 \uC815\uCCB4\uC131"));
+    console.log(chalk2.dim("  ## \uAE30\uC220 \uC2A4\uD0DD"));
+    console.log(chalk2.dim("  ## \uCF54\uB529 \uADDC\uCE59"));
+    console.log(chalk2.dim("  ## \uAE30\uB85D \uADDC\uCE59"));
+    console.log(chalk2.dim("  ## \uCEE4\uBC0B \uCEE8\uBCA4\uC158"));
+    return;
+  }
+  const sections = parseRulesMd(fs4.readFileSync(rulesPath, "utf-8"));
+  console.log(chalk2.dim(`  \u{1F4C4} RULES.md \uD30C\uC2F1 \uC644\uB8CC \u2014 ${sections.length}\uAC1C \uC139\uC158`));
+  const interactive = !!process.stdout.isTTY && !opts.yes;
+  const confirmOverwrite = async (drifted) => {
+    if (!interactive) return true;
+    for (const d of drifted) console.log(chalk2.yellow(`  ${ko.sync.driftWarn(d.path)}`));
+    const { confirm } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: ko.sync.driftConfirm(drifted.length),
+        default: false
+      }
+    ]);
+    return confirm;
+  };
+  const result = await syncCore(cwd, opts, confirmOverwrite);
+  if (result.unmapped.length) {
+    console.error(
+      chalk2.yellow(
+        `  \u26A0\uFE0F  ${result.unmapped.length}\uAC1C \uC139\uC158\uC774 \uC5B4\uB290 \uD0C0\uAE43\uC5D0\uB3C4 \uB9E4\uD551 \uC548 \uB3FC \uC0B0\uCD9C\uBB3C\uC5D0\uC11C \uC81C\uC678\uB428: ${result.unmapped.join(", ")}
+     (\uCF54\uB529 \uADDC\uCE59/\uAE30\uC220 \uC2A4\uD0DD/\uCEE4\uBC0B/\uAE30\uB85D \uB4F1 \uD45C\uC900 \uC81C\uBAA9\uC744 \uC4F0\uAC70\uB098, \uC774 \uC139\uC158\uC740 RULES.md \uC5D0\uB9CC \uBCF4\uC874\uB429\uB2C8\uB2E4.)`
+      )
+    );
+  }
+  if (result.dryRun) {
+    console.log(chalk2.cyan(`
+${ko.sync.dryRunHeader}`));
+    for (const item of result.plan) {
+      console.log(ko.sync.dryRunWouldWrite(item.path, item.exists && item.drift));
+    }
+    const wouldBackup = result.plan.filter((p) => p.exists && (p.drift || result.firstSync)).map((p) => p.path);
+    if (wouldBackup.length) {
+      console.log(chalk2.dim(`
+  \uBC31\uC5C5 \uC608\uC815(${wouldBackup.length}): ${wouldBackup.join(", ")}`));
+    }
+    return;
+  }
+  if (result.backupId) {
+    if (result.firstSync) console.log(chalk2.cyan(`  ${ko.sync.firstSync}`));
+    if (!process.stdout.isTTY) {
+      console.log(chalk2.yellow(`  ${ko.sync.nonTtyAuto(result.backedUp.length, result.backupId)}`));
+    } else {
+      console.log(chalk2.cyan(`  ${ko.sync.backupSaved(result.backedUp.length, result.backupId)}`));
+    }
+  }
+  for (const p of result.written) {
+    const item = result.plan.find((i) => i.path === p);
+    if (item) console.log(chalk2.green(`  ${item.doneMessage}`));
+  }
+  for (const _ of result.truncated) {
+    console.log(chalk2.yellow(`    \u26A0\uFE0F  ${ko.sync.antigravityTruncated}`));
+  }
+  for (const p of result.skipped) {
+    console.log(chalk2.gray(`  ${ko.sync.skipped(p)}`));
+  }
+  console.log(chalk2.bold.green(`
+${ko.sync.done}`));
+  console.log(chalk2.dim("  RULES.md (\uC6D0\uBCF8) \u2192 .cursorrules + CLAUDE.md + .windsurfrules"));
+  console.log(chalk2.dim("             + .github/copilot-instructions.md + .agents/rules/vhk-rules.md (\uC790\uB3D9 \uC0DD\uC131)"));
+  console.log(chalk2.dim("  \uADDC\uCE59 \uBCC0\uACBD\uC740 \uD56D\uC0C1 RULES.md\uC5D0\uC11C\uB9CC \uD558\uC138\uC694."));
+  printNextStep({
+    message: "\uADDC\uCE59 \uB3D9\uAE30\uD654 \uC644\uB8CC! \uC774\uC81C Cursor\uAC00 \uC0C8 \uADDC\uCE59\uC744 \uB530\uB985\uB2C8\uB2E4.",
+    command: "vhk \uC810\uAC80",
+    cursorHint: "\uADDC\uCE59 \uC810\uAC80\uD574\uC918"
+  });
+}
+
+// src/commands/deploy.ts
+import { existsSync as existsSync2 } from "fs";
+import chalk3 from "chalk";
+import inquirer2 from "inquirer";
+
+// src/lib/exec.ts
+import { execFileSync as execFileSync2 } from "child_process";
+var SHIM_BINARIES = /* @__PURE__ */ new Set(["pnpm", "npm", "npx", "yarn"]);
+function platformCmd(cmd) {
+  if (process.platform === "win32" && SHIM_BINARIES.has(cmd)) {
+    return `${cmd}.cmd`;
+  }
+  return cmd;
+}
+function resolveCmd(cmd, args) {
+  if (process.platform === "win32" && SHIM_BINARIES.has(cmd)) {
+    return { bin: "cmd.exe", argv: ["/d", "/s", "/c", `${cmd}.cmd`, ...args] };
+  }
+  return { bin: platformCmd(cmd), argv: args };
+}
+var DEFAULT_EXEC_TIMEOUT_MS = 6e5;
+var NETWORK_EXEC_TIMEOUT_MS = 3e4;
+function resolveTimeout(timeoutMs, fallback) {
+  const v = timeoutMs === void 0 ? fallback : timeoutMs;
+  return v > 0 ? v : void 0;
+}
+function isTimeoutError(e, timeout) {
+  if (!timeout) return false;
+  return e.code === "ETIMEDOUT";
+}
+function safeExecFile(cmd, args, opts = {}) {
+  const { bin, argv } = resolveCmd(cmd, args);
+  const env2 = opts.env ? { ...process.env, ...opts.env } : void 0;
+  const timeout = resolveTimeout(opts.timeoutMs, DEFAULT_EXEC_TIMEOUT_MS);
+  try {
+    const out = execFileSync2(bin, argv, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      env: env2,
+      ...timeout ? { timeout, killSignal: "SIGTERM" } : {}
+    }).toString();
+    return { ok: true, out: out.trim() };
+  } catch (err) {
+    const e = err;
+    const stdout = e.stdout ? e.stdout.toString() : "";
+    let msg = e.message ?? String(err);
+    if (isTimeoutError(e, timeout)) {
+      msg = `\uBA85\uB839 \uC2DC\uAC04 \uCD08\uACFC (timeout ${timeout}ms): ${cmd} ${args.join(" ")}`.trim();
+    }
+    return { ok: false, err: msg, out: stdout.trim() };
+  }
+}
+function safeExecFileStream(cmd, args, opts = {}) {
+  const { bin, argv } = resolveCmd(cmd, args);
+  const timeout = opts.timeoutMs && opts.timeoutMs > 0 ? opts.timeoutMs : void 0;
+  try {
+    execFileSync2(bin, argv, {
+      encoding: "utf-8",
+      stdio: "inherit",
+      ...timeout ? { timeout, killSignal: "SIGTERM" } : {}
+    });
+    return { ok: true };
+  } catch (err) {
+    const e = err;
+    let msg = err instanceof Error ? err.message : String(err);
+    if (isTimeoutError(e, timeout)) {
+      msg = `\uBA85\uB839 \uC2DC\uAC04 \uCD08\uACFC (timeout ${timeout}ms): ${cmd} ${args.join(" ")}`.trim();
+    }
+    return { ok: false, err: msg };
+  }
+}
 
 // src/commands/deploy.ts
 var PLATFORMS = {
@@ -995,7 +1655,7 @@ var PLATFORMS = {
 function detectPlatform() {
   for (const [key, config] of Object.entries(PLATFORMS)) {
     for (const file of config.detectFiles) {
-      if (existsSync(file)) return key;
+      if (existsSync2(file)) return key;
     }
   }
   return null;
@@ -1004,14 +1664,14 @@ function isCLIAvailable(cmd, checkArgs) {
   return safeExecFile(cmd, checkArgs).ok;
 }
 async function deploy() {
-  console.log(chalk2.bold("\n\u{1F680} " + t("deploy.title")));
-  console.log(chalk2.gray("\u2500".repeat(40)));
+  console.log(chalk3.bold("\n\u{1F680} " + t("deploy.title")));
+  console.log(chalk3.gray("\u2500".repeat(40)));
   let platform = detectPlatform();
   if (platform) {
-    console.log(chalk2.cyan(`
+    console.log(chalk3.cyan(`
 \u{1F50D} \uAC10\uC9C0\uB41C \uD50C\uB7AB\uD3FC: ${PLATFORMS[platform].name}`));
   } else {
-    const { selected } = await inquirer.prompt([
+    const { selected } = await inquirer2.prompt([
       {
         type: "list",
         name: "selected",
@@ -1027,12 +1687,12 @@ async function deploy() {
   }
   const config = PLATFORMS[platform];
   if (!isCLIAvailable(config.command, config.checkArgs)) {
-    console.log(chalk2.red(`
+    console.log(chalk3.red(`
 \u274C ${config.name} CLI\uAC00 \uC124\uCE58\uB418\uC5B4 \uC788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.`));
-    console.log(chalk2.yellow(`   \u2192 ${config.installHint}`));
+    console.log(chalk3.yellow(`   \u2192 ${config.installHint}`));
     return;
   }
-  const { confirm } = await inquirer.prompt([
+  const { confirm } = await inquirer2.prompt([
     {
       type: "confirm",
       name: "confirm",
@@ -1041,15 +1701,15 @@ async function deploy() {
     }
   ]);
   if (!confirm) {
-    console.log(chalk2.gray("\uCDE8\uC18C\uB428"));
+    console.log(chalk3.gray("\uCDE8\uC18C\uB428"));
     return;
   }
-  console.log(chalk2.cyan(`
+  console.log(chalk3.cyan(`
 ${t("deploy.deploying")}
 `));
   const result = safeExecFileStream(config.command, config.commandArgs);
   if (result.ok) {
-    console.log(chalk2.green(`
+    console.log(chalk3.green(`
 \u2705 ${t("deploy.success")}`));
     printNextStep({
       message: "\uBC30\uD3EC \uC644\uB8CC! \uC0AC\uC774\uD2B8\uB97C \uD655\uC778\uD558\uC138\uC694.",
@@ -1057,50 +1717,69 @@ ${t("deploy.deploying")}
       cursorHint: "\uC0C1\uD0DC \uD655\uC778\uD574\uC918"
     });
   } else {
-    console.log(chalk2.red(`
+    console.log(chalk3.red(`
 \u274C ${t("deploy.failed")}`));
-    console.log(chalk2.red(result.err));
+    console.log(chalk3.red(result.err));
   }
 }
 
 // src/commands/env.ts
-import { existsSync as existsSync2, readFileSync, writeFileSync, appendFileSync } from "fs";
-import chalk3 from "chalk";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync, appendFileSync, readdirSync } from "fs";
+import { join as join2 } from "path";
+import chalk4 from "chalk";
 function parseEnvKeys(content) {
   return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((line) => line.split("=")[0].trim()).filter(Boolean);
 }
+function loadDefinedEnvKeys(dir = ".") {
+  const keys = /* @__PURE__ */ new Set();
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  for (const name of entries) {
+    if (!name.startsWith(".env")) continue;
+    if (name.endsWith(".example") || name.endsWith(".sample")) continue;
+    try {
+      for (const k of parseEnvKeys(readFileSync2(join2(dir, name), "utf-8"))) keys.add(k);
+    } catch {
+    }
+  }
+  return [...keys];
+}
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (existsSync2(gitignorePath)) {
-    const content = readFileSync(gitignorePath, "utf-8");
+  if (existsSync3(gitignorePath)) {
+    const content = readFileSync2(gitignorePath, "utf-8");
     if (!content.split("\n").some((l) => l.trim() === ".env")) {
       appendFileSync(gitignorePath, "\n.env\n");
-      console.log(chalk3.green("\n\u{1F512} .gitignore\uC5D0 .env \uCD94\uAC00\uB428"));
+      console.log(chalk4.green("\n\u{1F512} .gitignore\uC5D0 .env \uCD94\uAC00\uB428"));
     }
   } else {
     writeFileSync(gitignorePath, ".env\nnode_modules/\ndist/\n");
-    console.log(chalk3.green("\n\u{1F512} .gitignore \uC0DD\uC131 (.env \uD3EC\uD568)"));
+    console.log(chalk4.green("\n\u{1F512} .gitignore \uC0DD\uC131 (.env \uD3EC\uD568)"));
   }
 }
 async function env() {
-  console.log(chalk3.bold("\n\u{1F510} " + t("env.title")));
-  console.log(chalk3.gray("\u2500".repeat(40)));
-  if (!existsSync2(".env")) {
-    console.log(chalk3.yellow("\n\u26A0\uFE0F  .env \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."));
-    console.log(chalk3.gray("   .env \uD30C\uC77C\uC744 \uBA3C\uC800 \uB9CC\uB4E4\uC5B4\uC8FC\uC138\uC694."));
+  console.log(chalk4.bold("\n\u{1F510} " + t("env.title")));
+  console.log(chalk4.gray("\u2500".repeat(40)));
+  if (!existsSync3(".env")) {
+    console.log(chalk4.yellow("\n\u26A0\uFE0F  .env \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."));
+    console.log(chalk4.gray("   .env \uD30C\uC77C\uC744 \uBA3C\uC800 \uB9CC\uB4E4\uC5B4\uC8FC\uC138\uC694."));
     return;
   }
-  const envContent = readFileSync(".env", "utf-8");
+  const envContent = readFileSync2(".env", "utf-8");
   const keys = parseEnvKeys(envContent);
   if (keys.length === 0) {
-    console.log(chalk3.yellow("\n\u{1F4ED} .env\uC5D0 \uD658\uACBD\uBCC0\uC218\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4."));
+    console.log(chalk4.yellow("\n\u{1F4ED} .env\uC5D0 \uD658\uACBD\uBCC0\uC218\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4."));
     return;
   }
   const exampleContent = keys.map((k) => `${k}=`).join("\n") + "\n";
   writeFileSync(".env.example", exampleContent, "utf-8");
-  console.log(chalk3.green(`
+  console.log(chalk4.green(`
 \u2705 .env.example \uC0DD\uC131 (${keys.length}\uAC1C \uD0A4)`));
-  keys.forEach((k) => console.log(chalk3.gray(`   ${k}`)));
+  keys.forEach((k) => console.log(chalk4.gray(`   ${k}`)));
   ensureGitignore();
   printNextStep({
     message: ".env.example \uC0DD\uC131 \uC644\uB8CC!",
@@ -1109,46 +1788,47 @@ async function env() {
   });
 }
 async function envCheck() {
-  console.log(chalk3.bold("\n\u{1F50D} " + t("env.checkTitle")));
-  console.log(chalk3.gray("\u2500".repeat(40)));
-  if (!existsSync2(".env.example")) {
-    console.log(chalk3.yellow("\n\u26A0\uFE0F  .env.example\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 vhk env\uB97C \uC2E4\uD589\uD558\uC138\uC694."));
+  console.log(chalk4.bold("\n\u{1F50D} " + t("env.checkTitle")));
+  console.log(chalk4.gray("\u2500".repeat(40)));
+  if (!existsSync3(".env.example")) {
+    console.log(chalk4.yellow("\n\u26A0\uFE0F  .env.example\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 vhk env\uB97C \uC2E4\uD589\uD558\uC138\uC694."));
     return;
   }
-  const requiredKeys = parseEnvKeys(readFileSync(".env.example", "utf-8"));
-  const currentKeys = existsSync2(".env") ? parseEnvKeys(readFileSync(".env", "utf-8")) : [];
+  const requiredKeys = parseEnvKeys(readFileSync2(".env.example", "utf-8"));
+  const currentKeys = loadDefinedEnvKeys();
   const missing = requiredKeys.filter((k) => !currentKeys.includes(k));
   const extra = currentKeys.filter((k) => !requiredKeys.includes(k));
-  console.log(chalk3.cyan(`
+  console.log(chalk4.cyan(`
 \u{1F4CB} \uD544\uC218 \uD658\uACBD\uBCC0\uC218: ${requiredKeys.length}\uAC1C`));
   if (missing.length === 0) {
-    console.log(chalk3.green("\n\u2705 \uBAA8\uB4E0 \uD544\uC218 \uD658\uACBD\uBCC0\uC218\uAC00 \uC124\uC815\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4!"));
+    console.log(chalk4.green("\n\u2705 \uBAA8\uB4E0 \uD544\uC218 \uD658\uACBD\uBCC0\uC218\uAC00 \uC124\uC815\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4!"));
   } else {
-    console.log(chalk3.red(`
+    console.log(chalk4.red(`
 \u274C \uB204\uB77D\uB41C \uD658\uACBD\uBCC0\uC218 (${missing.length}\uAC1C):`));
-    missing.forEach((k) => console.log(chalk3.red(`   \u2022 ${k}`)));
+    missing.forEach((k) => console.log(chalk4.red(`   \u2022 ${k}`)));
+    process.exitCode = 1;
   }
   if (extra.length > 0) {
-    console.log(chalk3.yellow(`
+    console.log(chalk4.yellow(`
 \u{1F4A1} .env.example\uC5D0 \uC5C6\uB294 \uCD94\uAC00 \uBCC0\uC218 (${extra.length}\uAC1C):`));
-    extra.forEach((k) => console.log(chalk3.yellow(`   \u2022 ${k}`)));
+    extra.forEach((k) => console.log(chalk4.yellow(`   \u2022 ${k}`)));
   }
   ensureGitignore();
 }
 
 // src/commands/publish.ts
-import { existsSync as existsSync3, writeFileSync as writeFileSync2 } from "fs";
-import chalk4 from "chalk";
-import inquirer2 from "inquirer";
+import { existsSync as existsSync4, writeFileSync as writeFileSync2 } from "fs";
+import chalk5 from "chalk";
+import inquirer3 from "inquirer";
 import ora from "ora";
 
 // src/lib/read-json.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 function stripBom(text) {
   return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
 }
 function readJsonFile(filePath) {
-  const raw = stripBom(readFileSync2(filePath, "utf-8"));
+  const raw = stripBom(readFileSync3(filePath, "utf-8"));
   return JSON.parse(raw);
 }
 
@@ -1207,23 +1887,23 @@ function gitPostRelease(newVersion) {
   };
 }
 async function publish() {
-  console.log(chalk4.bold("\n\u{1F4E6} " + t("publish.title")));
-  console.log(chalk4.gray("\u2500".repeat(40)));
-  if (!existsSync3("package.json")) {
-    console.log(chalk4.red("\u274C package.json\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
+  console.log(chalk5.bold("\n\u{1F4E6} " + t("publish.title")));
+  console.log(chalk5.gray("\u2500".repeat(40)));
+  if (!existsSync4("package.json")) {
+    console.log(chalk5.red("\u274C package.json\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
     return;
   }
   let pkg;
   try {
     pkg = readJsonFile("package.json");
   } catch {
-    console.log(chalk4.red("\u274C package.json \uD30C\uC2F1 \uC2E4\uD328"));
+    console.log(chalk5.red("\u274C package.json \uD30C\uC2F1 \uC2E4\uD328"));
     return;
   }
   const currentVersion = pkg.version || "0.0.0";
-  console.log(chalk4.cyan(`
+  console.log(chalk5.cyan(`
 \u{1F4CC} \uD604\uC7AC \uBC84\uC804: v${currentVersion}`));
-  const { bumpType } = await inquirer2.prompt([
+  const { bumpType } = await inquirer3.prompt([
     {
       type: "list",
       name: "bumpType",
@@ -1236,16 +1916,16 @@ async function publish() {
     }
   ]);
   const newVersion = bumpVersion(currentVersion, bumpType);
-  console.log(chalk4.cyan(`
+  console.log(chalk5.cyan(`
 \u{1F195} \uC0C8 \uBC84\uC804: v${newVersion}`));
   pkg.version = newVersion;
   writeFileSync2("package.json", JSON.stringify(pkg, null, 2) + "\n", "utf-8");
-  console.log(chalk4.green("\u2705 package.json \uBC84\uC804 \uC5C5\uB370\uC774\uD2B8"));
+  console.log(chalk5.green("\u2705 package.json \uBC84\uC804 \uC5C5\uB370\uC774\uD2B8"));
   const buildSpinner = ora(t("publish.building")).start();
   const buildResult = safeExecFile("pnpm", ["build"]);
   if (!buildResult.ok) {
     buildSpinner.fail(t("publish.buildFailed"));
-    console.log(chalk4.red(buildResult.err.slice(0, 500)));
+    console.log(chalk5.red(buildResult.err.slice(0, 500)));
     pkg.version = currentVersion;
     writeFileSync2("package.json", JSON.stringify(pkg, null, 2) + "\n", "utf-8");
     return;
@@ -1255,13 +1935,13 @@ async function publish() {
   const testResult = safeExecFile("pnpm", ["test", "--run"]);
   if (!testResult.ok) {
     testSpinner.fail(t("publish.testFailed"));
-    console.log(chalk4.red(testResult.err.slice(0, 500)));
+    console.log(chalk5.red(testResult.err.slice(0, 500)));
     pkg.version = currentVersion;
     writeFileSync2("package.json", JSON.stringify(pkg, null, 2) + "\n", "utf-8");
     return;
   }
   testSpinner.succeed(t("publish.testSuccess"));
-  const { confirm } = await inquirer2.prompt([
+  const { confirm } = await inquirer3.prompt([
     {
       type: "confirm",
       name: "confirm",
@@ -1272,37 +1952,37 @@ async function publish() {
   if (!confirm) {
     pkg.version = currentVersion;
     writeFileSync2("package.json", JSON.stringify(pkg, null, 2) + "\n", "utf-8");
-    console.log(chalk4.gray("\uCDE8\uC18C\uB428. \uBC84\uC804\uC774 \uC6D0\uB798\uB300\uB85C \uBCF5\uAD6C\uB429\uB2C8\uB2E4."));
+    console.log(chalk5.gray("\uCDE8\uC18C\uB428. \uBC84\uC804\uC774 \uC6D0\uB798\uB300\uB85C \uBCF5\uAD6C\uB429\uB2C8\uB2E4."));
     return;
   }
-  console.log(chalk4.cyan(`
+  console.log(chalk5.cyan(`
 \u{1F4E4} ${t("publish.publishing")}`));
-  console.log(chalk4.gray("   2FA \uD65C\uC131\uD654 \uC2DC: OTP 6\uC790\uB9AC \uC785\uB825 \uB610\uB294 \uBE0C\uB77C\uC6B0\uC800 \uC778\uC99D URL \uD074\uB9AD (Windows Hello / PIN \uC9C0\uC6D0)"));
+  console.log(chalk5.gray("   2FA \uD65C\uC131\uD654 \uC2DC: OTP 6\uC790\uB9AC \uC785\uB825 \uB610\uB294 \uBE0C\uB77C\uC6B0\uC800 \uC778\uC99D URL \uD074\uB9AD (Windows Hello / PIN \uC9C0\uC6D0)"));
   const pubResult = safeExecFileStream("npm", ["publish", "--access", "public"]);
   if (!pubResult.ok) {
-    console.log(chalk4.red(`
+    console.log(chalk5.red(`
 \u2716 ${t("publish.publishFailed")}`));
-    console.log(chalk4.red(pubResult.err.slice(0, 500)));
+    console.log(chalk5.red(pubResult.err.slice(0, 500)));
     pkg.version = currentVersion;
     writeFileSync2("package.json", JSON.stringify(pkg, null, 2) + "\n", "utf-8");
-    console.log(chalk4.gray(`\u{1F4E6} package.json \uBC84\uC804\uC744 v${currentVersion}\uB85C \uBCF5\uAD6C\uD588\uC2B5\uB2C8\uB2E4.`));
+    console.log(chalk5.gray(`\u{1F4E6} package.json \uBC84\uC804\uC744 v${currentVersion}\uB85C \uBCF5\uAD6C\uD588\uC2B5\uB2C8\uB2E4.`));
     return;
   }
-  console.log(chalk4.green(`
+  console.log(chalk5.green(`
 \u2714 ${t("publish.publishSuccess")}`));
   const git = gitPostRelease(newVersion);
   if (git.warning) {
-    console.log(chalk4.yellow(`
+    console.log(chalk5.yellow(`
 \u26A0\uFE0F  ${git.warning}`));
-    console.log(chalk4.dim(`    npm \uBC30\uD3EC\uB294 \uC774\uBBF8 \uC131\uACF5\uD588\uC2B5\uB2C8\uB2E4 (v${newVersion}).`));
+    console.log(chalk5.dim(`    npm \uBC30\uD3EC\uB294 \uC774\uBBF8 \uC131\uACF5\uD588\uC2B5\uB2C8\uB2E4 (v${newVersion}).`));
   } else if (git.tagged && git.pushed) {
-    console.log(chalk4.green(`
+    console.log(chalk5.green(`
 \u{1F3F7}\uFE0F  git tag v${newVersion} \uC0DD\uC131 + push \uC644\uB8CC`));
   } else if (git.tagged) {
-    console.log(chalk4.yellow(`
+    console.log(chalk5.yellow(`
 \u{1F3F7}\uFE0F  git tag v${newVersion} \uC0DD\uC131\uB428 (push\uB294 \uC218\uB3D9\uC73C\uB85C)`));
   }
-  console.log(chalk4.green.bold(`
+  console.log(chalk5.green.bold(`
 \u{1F389} v${newVersion} \uBC30\uD3EC \uC644\uB8CC!`));
   printNextStep({
     message: "npm \uBC30\uD3EC \uC644\uB8CC!",
@@ -1312,13 +1992,13 @@ async function publish() {
 }
 
 // src/commands/audit.ts
-import { existsSync as existsSync4 } from "fs";
-import chalk5 from "chalk";
-import inquirer3 from "inquirer";
+import { existsSync as existsSync5 } from "fs";
+import chalk6 from "chalk";
+import inquirer4 from "inquirer";
 import ora2 from "ora";
 function detectCurrentPM() {
-  if (existsSync4("pnpm-lock.yaml")) return "pnpm";
-  if (existsSync4("yarn.lock")) return "yarn";
+  if (existsSync5("pnpm-lock.yaml")) return "pnpm";
+  if (existsSync5("yarn.lock")) return "yarn";
   return "npm";
 }
 function parseAuditOutput(output, pm) {
@@ -1358,26 +2038,26 @@ function runAuditFix(pm) {
   return result.ok ? { ok: true } : { ok: false, err: result.err };
 }
 async function audit(autoFix = false) {
-  console.log(chalk5.bold("\n\u{1F6E1}\uFE0F  " + t("audit.title")));
-  console.log(chalk5.gray("\u2500".repeat(40)));
+  console.log(chalk6.bold("\n\u{1F6E1}\uFE0F  " + t("audit.title")));
+  console.log(chalk6.gray("\u2500".repeat(40)));
   const pm = detectCurrentPM();
-  console.log(chalk5.cyan(`\u{1F4E6} \uD328\uD0A4\uC9C0 \uB9E4\uB2C8\uC800: ${pm}`));
+  console.log(chalk6.cyan(`\u{1F4E6} \uD328\uD0A4\uC9C0 \uB9E4\uB2C8\uC800: ${pm}`));
   const spinner = ora2("\uBCF4\uC548 \uAC10\uC0AC \uC2E4\uD589 \uC911...").start();
   const output = runAuditJson(pm);
   spinner.stop();
   const summary = parseAuditOutput(output, pm);
   if (summary.total === 0) {
-    console.log(chalk5.green.bold("\n\u{1F389} \uCDE8\uC57D\uC810\uC774 \uBC1C\uACAC\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4!"));
+    console.log(chalk6.green.bold("\n\u{1F389} \uCDE8\uC57D\uC810\uC774 \uBC1C\uACAC\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4!"));
     return;
   }
-  console.log(chalk5.bold("\n\u{1F4CA} \uCDE8\uC57D\uC810 \uC694\uC57D:"));
-  if (summary.critical > 0) console.log(chalk5.red(`  \u{1F534} Critical: ${summary.critical}`));
-  if (summary.high > 0) console.log(chalk5.red(`  \u{1F7E0} High: ${summary.high}`));
-  if (summary.moderate > 0) console.log(chalk5.yellow(`  \u{1F7E1} Moderate: ${summary.moderate}`));
-  if (summary.low > 0) console.log(chalk5.gray(`  \u26AA Low: ${summary.low}`));
-  console.log(chalk5.bold(`
+  console.log(chalk6.bold("\n\u{1F4CA} \uCDE8\uC57D\uC810 \uC694\uC57D:"));
+  if (summary.critical > 0) console.log(chalk6.red(`  \u{1F534} Critical: ${summary.critical}`));
+  if (summary.high > 0) console.log(chalk6.red(`  \u{1F7E0} High: ${summary.high}`));
+  if (summary.moderate > 0) console.log(chalk6.yellow(`  \u{1F7E1} Moderate: ${summary.moderate}`));
+  if (summary.low > 0) console.log(chalk6.gray(`  \u26AA Low: ${summary.low}`));
+  console.log(chalk6.bold(`
   \uCD1D ${summary.total}\uAC1C\uC758 \uCDE8\uC57D\uC810`));
-  const shouldRunFix = autoFix ? true : summary.critical > 0 || summary.high > 0 ? (await inquirer3.prompt([
+  const shouldRunFix = autoFix ? true : summary.critical > 0 || summary.high > 0 ? (await inquirer4.prompt([
     {
       type: "confirm",
       name: "shouldFix",
@@ -1402,17 +2082,17 @@ async function audit(autoFix = false) {
 }
 
 // src/lib/version.ts
-import { existsSync as existsSync5 } from "fs";
-import { dirname, join } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { dirname, join as join3 } from "path";
 import { fileURLToPath } from "url";
 function getVhkVersion() {
   const dir = dirname(fileURLToPath(import.meta.url));
   for (const pkgPath of [
-    join(dir, "../../package.json"),
-    join(dir, "../package.json")
+    join3(dir, "../../package.json"),
+    join3(dir, "../package.json")
   ]) {
     try {
-      if (existsSync5(pkgPath)) {
+      if (existsSync6(pkgPath)) {
         const pkg = readJsonFile(pkgPath);
         if (pkg.version) return pkg.version;
       }
@@ -1423,14 +2103,36 @@ function getVhkVersion() {
   return "0.0.0";
 }
 
+// src/mcp/cli-path.ts
+import { existsSync as existsSync7 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, resolve } from "path";
+function pickCliInvocation(globalAvailable, localCli, localExists) {
+  if (globalAvailable) return { bin: "vhk", prefixArgs: [], fallback: false };
+  if (localExists) return { bin: process.execPath, prefixArgs: [localCli], fallback: true };
+  return { bin: "vhk", prefixArgs: [], fallback: false };
+}
+function composeInvocation(cli, args) {
+  return { bin: cli.bin, args: [...cli.prefixArgs, ...args] };
+}
+function localCliPath() {
+  const here = dirname2(fileURLToPath2(import.meta.url));
+  return resolve(here, "..", "index.js");
+}
+function resolveVhkCliInvocation() {
+  const globalAvailable = safeExecFile("vhk", ["--version"]).ok;
+  const local = localCliPath();
+  return pickCliInvocation(globalAvailable, local, existsSync7(local));
+}
+
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync3, appendFileSync as appendFileSync2 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync3, appendFileSync as appendFileSync2 } from "fs";
 
 // src/lib/scan-secrets.ts
-import fs3 from "fs";
+import fs7 from "fs";
 
 // src/lib/secret-patterns.ts
 var SECRET_PATTERNS = [
@@ -1496,19 +2198,19 @@ function maskSecret(value) {
 }
 
 // src/lib/scan-files.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs6 from "fs";
+import path6 from "path";
 
 // src/lib/check-secure.ts
 var import_ignore = __toESM(require_ignore(), 1);
-import fs from "fs";
-import path from "path";
-import chalk6 from "chalk";
+import fs5 from "fs";
+import path5 from "path";
+import chalk7 from "chalk";
 function loadGitignore(rootDir) {
   const ig = (0, import_ignore.default)();
-  const gitignorePath = path.join(rootDir, ".gitignore");
-  if (fs.existsSync(gitignorePath)) {
-    const content = fs.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path5.join(rootDir, ".gitignore");
+  if (fs5.existsSync(gitignorePath)) {
+    const content = fs5.readFileSync(gitignorePath, "utf-8");
     ig.add(content);
   }
   return ig;
@@ -1523,14 +2225,14 @@ function findExposedSensitiveFiles(rootDir, ig = loadGitignore(rootDir), maxDept
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
+      entries = fs5.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const fullPath = path.join(dir, entry.name);
-      const rel = path.relative(rootDir, fullPath).replace(/\\/g, "/");
+      const fullPath = path5.join(dir, entry.name);
+      const rel = path5.relative(rootDir, fullPath).replace(/\\/g, "/");
       if (entry.isDirectory()) {
         if (!isPathIgnored(ig, rel + "/")) walk(fullPath, depth + 1);
         continue;
@@ -1545,6 +2247,7 @@ function findExposedSensitiveFiles(rootDir, ig = loadGitignore(rootDir), maxDept
 }
 function isSensitiveName(name) {
   const lower = name.toLowerCase();
+  if (lower.endsWith(".example") || lower.endsWith(".sample")) return false;
   if (lower === ".env" || lower.startsWith(".env.")) return true;
   if (lower.endsWith(".pem") || lower.endsWith(".key")) return true;
   if (lower === "credentials.json" || lower === "secrets.json") return true;
@@ -1552,8 +2255,8 @@ function isSensitiveName(name) {
   return false;
 }
 function checkProjectSecurity(rootDir = process.cwd()) {
-  const gitignorePath = path.join(rootDir, ".gitignore");
-  const missingGitignore = !fs.existsSync(gitignorePath);
+  const gitignorePath = path5.join(rootDir, ".gitignore");
+  const missingGitignore = !fs5.existsSync(gitignorePath);
   const ig = loadGitignore(rootDir);
   const exposedPaths = findExposedSensitiveFiles(rootDir, ig);
   const warnings = [];
@@ -1576,7 +2279,7 @@ function printSecurityWarnings(rootDir = process.cwd()) {
   const result = checkProjectSecurity(rootDir);
   if (result.ok) return true;
   for (const w of result.warnings) {
-    console.log(chalk6.yellow(`   \u26A0\uFE0F  ${w}`));
+    console.log(chalk7.yellow(`   \u26A0\uFE0F  ${w}`));
   }
   return false;
 }
@@ -1624,19 +2327,19 @@ var MAX_SCAN_FILE_BYTES = 512 * 1024;
 function isScannableFileName(fileName) {
   if (SKIP_FILE_NAMES.has(fileName)) return false;
   if (fileName.startsWith(".env")) return true;
-  return SCAN_EXTENSIONS.has(path2.extname(fileName).toLowerCase());
+  return SCAN_EXTENSIONS.has(path6.extname(fileName).toLowerCase());
 }
 function walkProjectFiles(rootDir, onFile, ig = loadGitignore(rootDir)) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs2.readdirSync(dir, { withFileTypes: true });
+      entries = fs6.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path2.join(dir, entry.name);
-      const rel = path2.relative(rootDir, fullPath).replace(/\\/g, "/");
+      const fullPath = path6.join(dir, entry.name);
+      const rel = path6.relative(rootDir, fullPath).replace(/\\/g, "/");
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.has(entry.name)) continue;
         if (isPathIgnored(ig, `${rel}/`)) continue;
@@ -1647,7 +2350,7 @@ function walkProjectFiles(rootDir, onFile, ig = loadGitignore(rootDir)) {
       if (isPathIgnored(ig, rel)) continue;
       let size = 0;
       try {
-        size = fs2.statSync(fullPath).size;
+        size = fs6.statSync(fullPath).size;
       } catch {
         continue;
       }
@@ -1692,7 +2395,7 @@ function scanProjectForSecrets(cwd) {
   let truncated = false;
   walkProjectFiles(cwd, (filePath, relPath) => {
     scannedFiles++;
-    const content = fs3.readFileSync(filePath, "utf-8");
+    const content = fs7.readFileSync(filePath, "utf-8");
     const lines = content.split("\n");
     lines.forEach((line, idx) => {
       if (truncated) return;
@@ -1721,8 +2424,15 @@ var ANSI_RE = /\x1B\[[0-9;?]*[ -/]*[@-~]/g;
 function stripAnsi(s) {
   return s.replace(ANSI_RE, "");
 }
+var cachedCli = null;
+function getVhkCli() {
+  return cachedCli ??= resolveVhkCliInvocation();
+}
 function runVhkCli(args, headline) {
-  const result = safeExecFile("vhk", args, { env: { FORCE_COLOR: "0", NO_COLOR: "1" } });
+  const { bin, args: fullArgs } = composeInvocation(getVhkCli(), args);
+  const result = safeExecFile(bin, fullArgs, {
+    env: { FORCE_COLOR: "0", NO_COLOR: "1" }
+  });
   const body = stripAnsi(result.out || (result.ok ? "" : `(stdout \uC5C6\uC74C)
 ${result.err}`));
   const prefix = result.ok ? `\u2705 ${headline}` : `\u274C ${headline} \uC2E4\uD328`;
@@ -1795,32 +2505,56 @@ ${preview}${more}
       };
     }
   );
-  server.registerTool("undo", { description: "\uCD5C\uADFC \uCEE4\uBC0B \uB418\uB3CC\uB9AC\uAE30 (soft reset, \uBCC0\uACBD\uC0AC\uD56D\uC740 \uC720\uC9C0)" }, async () => {
-    if (!isGitRepo()) {
-      return { content: [{ type: "text", text: "\u274C git \uC800\uC7A5\uC18C\uAC00 \uC544\uB2D9\uB2C8\uB2E4." }] };
-    }
-    const last = safeExecFile("git", ["log", "--oneline", "-1"]);
-    if (!last.ok || !last.out) {
-      return { content: [{ type: "text", text: "\u{1F4ED} \uB418\uB3CC\uB9B4 \uCEE4\uBC0B\uC774 \uC5C6\uC2B5\uB2C8\uB2E4." }] };
-    }
-    const reset = safeExecFile("git", ["reset", "--soft", "HEAD~1"]);
-    if (!reset.ok) {
-      return { content: [{ type: "text", text: `\u274C reset \uC2E4\uD328: ${reset.err}` }] };
-    }
-    return {
-      content: [
-        {
-          type: "text",
-          text: `\u2705 \uB418\uB3CC\uB9AC\uAE30 \uC644\uB8CC!
+  server.registerTool(
+    "undo",
+    {
+      description: "\uCD5C\uADFC \uCEE4\uBC0B \uB418\uB3CC\uB9AC\uAE30 (soft reset). \uAE30\uBCF8\uC740 \uBBF8\uB9AC\uBCF4\uAE30 \u2014 confirm:true \uC77C \uB54C\uB9CC \uC2E4\uC81C \uC2E4\uD589.",
+      inputSchema: {
+        confirm: z.boolean().optional().describe("true \uC77C \uB54C\uB9CC \uC2E4\uC81C git reset \uC2E4\uD589 (\uAE30\uBCF8 false = \uBBF8\uB9AC\uBCF4\uAE30\uB9CC)")
+      }
+    },
+    async ({ confirm }) => {
+      if (!isGitRepo()) {
+        return { content: [{ type: "text", text: "\u274C git \uC800\uC7A5\uC18C\uAC00 \uC544\uB2D9\uB2C8\uB2E4." }] };
+      }
+      const last = safeExecFile("git", ["log", "--oneline", "-1"]);
+      if (!last.ok || !last.out) {
+        return { content: [{ type: "text", text: "\u{1F4ED} \uB418\uB3CC\uB9B4 \uCEE4\uBC0B\uC774 \uC5C6\uC2B5\uB2C8\uB2E4." }] };
+      }
+      if (!confirm) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `\u{1F50E} \uBBF8\uB9AC\uBCF4\uAE30 \u2014 \uB418\uB3CC\uB9B4 \uCEE4\uBC0B:
+${last.out}
+
+\uC2E4\uC81C\uB85C \uB418\uB3CC\uB9AC\uB824\uBA74 confirm: true \uB85C \uB2E4\uC2DC \uD638\uCD9C\uD558\uC138\uC694.
+(soft reset \u2014 \uBCC0\uACBD\uC0AC\uD56D\uC740 \uC2A4\uD14C\uC774\uC9D5 \uC601\uC5ED\uC5D0 \uBCF4\uC874\uB429\uB2C8\uB2E4.)
+\uB610\uB294 \uD130\uBBF8\uB110\uC5D0\uC11C \`vhk undo\` (\uB300\uD654\uD615 \uD655\uC778).`
+            }
+          ]
+        };
+      }
+      const reset = safeExecFile("git", ["reset", "--soft", "HEAD~1"]);
+      if (!reset.ok) {
+        return { content: [{ type: "text", text: `\u274C reset \uC2E4\uD328: ${reset.err}` }] };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u2705 \uB418\uB3CC\uB9AC\uAE30 \uC644\uB8CC!
 \uCDE8\uC18C\uB41C \uCEE4\uBC0B: ${last.out}
 \u{1F4A1} \uBCC0\uACBD\uC0AC\uD56D\uC740 \uC2A4\uD14C\uC774\uC9D5 \uC601\uC5ED\uC5D0 \uB0A8\uC544\uC788\uC2B5\uB2C8\uB2E4.`
-        }
-      ]
-    };
-  });
+          }
+        ]
+      };
+    }
+  );
   server.registerTool("status", { description: "\uD504\uB85C\uC81D\uD2B8 \uC0C1\uD0DC \uB300\uC2DC\uBCF4\uB4DC (\uBE0C\uB79C\uCE58/\uBCC0\uACBD\uC0AC\uD56D/\uCD5C\uADFC \uCEE4\uBC0B)" }, async () => {
     const lines = [];
-    if (existsSync6("package.json")) {
+    if (existsSync8("package.json")) {
       try {
         const pkg = readJsonFile("package.json");
         lines.push(`\u{1F4E6} \uD504\uB85C\uC81D\uD2B8: ${pkg.name ?? "(\uC774\uB984 \uC5C6\uC74C)"} v${pkg.version ?? "?"}`);
@@ -1905,7 +2639,7 @@ ${preview}${more}
     checks.push(build.ok ? "\u2705 \uBE4C\uB4DC \uC131\uACF5" : "\u274C \uBE4C\uB4DC \uC2E4\uD328");
     const test = safeExecFile("pnpm", ["test", "--run"]);
     checks.push(test.ok ? "\u2705 \uD14C\uC2A4\uD2B8 \uD1B5\uACFC" : "\u274C \uD14C\uC2A4\uD2B8 \uC2E4\uD328");
-    if (existsSync6("package.json")) {
+    if (existsSync8("package.json")) {
       try {
         const pkg = readJsonFile("package.json");
         checks.push(`\u{1F4E6} \uBC84\uC804: ${pkg.version}`);
@@ -1943,11 +2677,11 @@ ${preview}${more}
     const recommended = ["CLAUDE.md", ".cursorrules", "docs/PRD.md", "docs/ARCHITECTURE.md"];
     const lines = ["\u{1F50D} \uD504\uB85C\uC81D\uD2B8 \uC810\uAC80", "", "\uD544\uC218:"];
     required.forEach((f) => {
-      lines.push(`  ${existsSync6(f) ? "\u2705" : "\u274C"} ${f}`);
+      lines.push(`  ${existsSync8(f) ? "\u2705" : "\u274C"} ${f}`);
     });
     lines.push("", "\uAD8C\uC7A5 (VHK \uD558\uB124\uC2A4):");
     recommended.forEach((f) => {
-      lines.push(`  ${existsSync6(f) ? "\u2705" : "\u26A0\uFE0F"} ${f}`);
+      lines.push(`  ${existsSync8(f) ? "\u2705" : "\u26A0\uFE0F"} ${f}`);
     });
     return { content: [{ type: "text", text: lines.join("\n") }] };
   });
@@ -1981,18 +2715,18 @@ ${log.out}` }] };
       description: ".env \u2192 .env.example \uB3D9\uAE30\uD654 + .gitignore\uC5D0 .env \uC790\uB3D9 \uCD94\uAC00"
     },
     async () => {
-      if (!existsSync6(".env")) {
+      if (!existsSync8(".env")) {
         return { content: [{ type: "text", text: "\u26A0\uFE0F  .env \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 .env\uB97C \uB9CC\uB4E4\uC5B4\uC8FC\uC138\uC694." }] };
       }
-      const keys = parseEnvKeys(readFileSync4(".env", "utf-8"));
+      const keys = parseEnvKeys(readFileSync5(".env", "utf-8"));
       if (keys.length === 0) {
         return { content: [{ type: "text", text: "\u{1F4ED} .env\uC5D0 \uD658\uACBD\uBCC0\uC218\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4." }] };
       }
       const exampleContent = keys.map((k) => `${k}=`).join("\n") + "\n";
       writeFileSync3(".env.example", exampleContent, "utf-8");
       const gitignoreLines = [];
-      if (existsSync6(".gitignore")) {
-        const content = readFileSync4(".gitignore", "utf-8");
+      if (existsSync8(".gitignore")) {
+        const content = readFileSync5(".gitignore", "utf-8");
         if (!content.split("\n").some((l) => l.trim() === ".env")) {
           appendFileSync2(".gitignore", "\n.env\n");
           gitignoreLines.push("\u{1F512} .gitignore\uC5D0 .env \uCD94\uAC00\uB428");
@@ -2012,11 +2746,11 @@ ${log.out}` }] };
       description: "\uD544\uC218 \uD658\uACBD\uBCC0\uC218 \uB204\uB77D \uAC80\uC0AC (.env.example \uAE30\uC900)"
     },
     async () => {
-      if (!existsSync6(".env.example")) {
+      if (!existsSync8(".env.example")) {
         return { content: [{ type: "text", text: "\u26A0\uFE0F  .env.example\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 env \uB3C4\uAD6C\uB97C \uC2E4\uD589\uD558\uC138\uC694." }] };
       }
-      const requiredKeys = parseEnvKeys(readFileSync4(".env.example", "utf-8"));
-      const currentKeys = existsSync6(".env") ? parseEnvKeys(readFileSync4(".env", "utf-8")) : [];
+      const requiredKeys = parseEnvKeys(readFileSync5(".env.example", "utf-8"));
+      const currentKeys = existsSync8(".env") ? parseEnvKeys(readFileSync5(".env", "utf-8")) : [];
       const missing = requiredKeys.filter((k) => !currentKeys.includes(k));
       const extra = currentKeys.filter((k) => !requiredKeys.includes(k));
       const lines = [`\u{1F4CB} \uD544\uC218 \uD658\uACBD\uBCC0\uC218: ${requiredKeys.length}\uAC1C`];
@@ -2035,7 +2769,9 @@ ${log.out}` }] };
   );
   server.registerTool(
     "sync",
-    { description: "RULES.md \u2192 .cursorrules + CLAUDE.md \uC790\uB3D9 \uB3D9\uAE30\uD654" },
+    {
+      description: "RULES.md \u2192 Cursor\xB7Claude\xB7Windsurf\xB7Copilot\xB7Antigravity\xB7AGENTS.md \uADDC\uCE59 \uB3D9\uAE30\uD654. \uB36E\uC5B4\uC4F0\uAE30 \uC804 \uAE30\uC874 \uD30C\uC77C\uC744 \uC790\uB3D9 \uBC31\uC5C5\uD558\uBBC0\uB85C \uC548\uC804\uD558\uBA70, \uB418\uB3CC\uB9AC\uB824\uBA74 \uC0AC\uC6A9\uC790\uC5D0\uAC8C `vhk restore` \uB97C \uC548\uB0B4\uD558\uC138\uC694."
+    },
     async () => runVhkCli(["sync"], "sync")
   );
   server.registerTool(
@@ -2130,7 +2866,7 @@ ${cliStatus}
       description: "\uD604\uC7AC \uBC84\uC804 + bump \uD6C4\uBCF4 \uD45C\uC2DC (MCP \uBAA8\uB4DC: \uC2E4\uC81C npm publish \uBBF8\uC218\uD589 \u2014 `vhk publish` \uC548\uB0B4)"
     },
     async () => {
-      if (!existsSync6("package.json")) {
+      if (!existsSync8("package.json")) {
         return { content: [{ type: "text", text: "\u274C package.json \uC5C6\uC74C." }] };
       }
       try {
@@ -2158,7 +2894,7 @@ ${cliStatus}
       description: "\uD328\uD0A4\uC9C0 \uB9E4\uB2C8\uC800 \uAC10\uC9C0 + \uC804\uD658 \uD6C4\uBCF4 \uAC00\uC6A9\uC131 (MCP \uBAA8\uB4DC: \uC2E4\uC81C \uC804\uD658 \uBBF8\uC218\uD589 \u2014 `vhk migrate <target>` \uC548\uB0B4)"
     },
     async () => {
-      const current = existsSync6("pnpm-lock.yaml") ? "pnpm" : existsSync6("yarn.lock") ? "yarn" : existsSync6("package-lock.json") ? "npm" : null;
+      const current = existsSync8("pnpm-lock.yaml") ? "pnpm" : existsSync8("yarn.lock") ? "yarn" : existsSync8("package-lock.json") ? "npm" : null;
       const candidates = ["npm", "yarn", "pnpm"].filter((pm) => pm !== current);
       const lines = [`\uD604\uC7AC PM: ${current ?? "\uAC10\uC9C0 \uBD88\uAC00 (lock \uD30C\uC77C \uC5C6\uC74C)"}`];
       for (const pm of candidates) {
@@ -2224,7 +2960,23 @@ export {
   __toESM,
   ko,
   t,
+  localDate,
+  listBackups,
+  restoreBackup,
+  detectExistingRuleFiles,
+  buildAdoptedRules,
+  sync,
+  getGitRoot,
+  gitOut,
+  gitRun,
+  getExecErrorMessage,
+  hasGitRemote,
+  countLocalCommits,
+  checkRuleDrift,
+  CONTEXT_GIT_MARKER,
+  checkContextDrift,
   printNextStep,
+  printContextResumeHint,
   require_ignore,
   printSecurityWarnings,
   filterTrackedPaths,
@@ -2241,5 +2993,6 @@ export {
   publish,
   audit,
   getVhkVersion,
+  resolveVhkCliInvocation,
   startMcpServer
 };