@byh3071/vhk 1.9.0 → 2.0.2

package/README.md

@@ -76,7 +76,7 @@ vhk gate          # 퀵 5문항 — GO / 다듬기 / 다른 아이디어
 | 🎯 **Goals 체계** | 단계별 미션 + 게이트 스크립트로 AI가 목표를 스스로 추적 | `vhk goal init` |
 | ▶️ **자율 루프** | `goal next → 작업 → goal check → goal done`. FAIL 시 `vhk blocker` 수동 기록 → 블로커 3건 누적 시 HARD_STOP 자동 | `vhk goal next` |
 | 🚧 **HARD_STOP 안전장치** | 블로커 3건 누적 → `.vhk/HARD_STOP` 트립와이어. `vhk resume --confirm` 만 해제 | `vhk blocker "<증상>"` |
-| 🔌 **MCP 24 tool** | Cursor·Claude Desktop 등에서 vhk를 채팅으로 호출 | `vhk mcp-init` |
+| 🔌 **MCP 25 tool** | Cursor·Claude Desktop 등에서 vhk를 채팅으로 호출 | `vhk mcp-init` |
 | 📋 **컨텍스트 영속화** | `.vhk/context.md` + `memory.json` + `brief.md` 로 세션 간 맥락 유지 | `vhk context` |
 | 🔀 **드리프트 감지** | 규칙 파일이 RULES.md와 어긋나거나 context가 코드보다 낡으면 자동 경고 (읽기전용) | `vhk doctor` |
 
@@ -172,12 +172,12 @@ vhk 기획 끝났고 바로 시작
 | `vhk update` | `업데이트` | VHK CLI 최신 버전으로 셀프 업데이트 |
 | `vhk context` | `맥락` | 프로젝트 트리·스택·CLI 명령 목록을 `.vhk/context.md`로 자동 생성 (AI 어시스턴트용). `--compact` 로 토큰 절감형(Active Goal + 최근 blockers/learnings/memories + 참조 링크) 출력 |
 | `vhk context-show` | `맥락보기` | 현재 컨텍스트 파일 내용 출력 |
-| `vhk memory` | `기억` | 결정사항 기억 관리 (`add` / `list` / `remove`, `.vhk/memory.json` 기반, 태그 지원) |
+| `vhk memory` | `기억` | 기억 v2 4버킷(결정/실패/성공/패턴) 관리 (`add --type` / `list [--all]` / `remove` / `archive` / `resolve` / `unarchive` / `migrate`). 조회 명령(`memory list`·`context`·`brief`) 첫 실행 시 v1→v2 자동 마이그레이션 + `.v1.bak` 원본 백업. 손상 파일은 read 경로에서 보존(원자적 write) |
 | `vhk brief` | `브리핑` | 프로젝트 정보 + git 상태 + 결정사항 + 레퍼런스 통합 보고서 `.vhk/brief.md` |
 | `vhk goal` | `목표` | Goal 단계별 미션 관리 (`init` / `list` / `next` / `check` / `done`) — vspec/vooster 패턴 |
 | `vhk mission` | `미션` | 미션 계약(`set` / `check` / `clear`) — 작업 범위·금지선 선언·검증 (`.vhk/mission.json`, 경로 glob) |
 | `vhk blocker <설명>` | `블로커` | 블로커 1건 → `docs/state/blockers.md` append. 3건 누적 시 `.vhk/HARD_STOP` 자동 생성 |
-| `vhk learn <교훈>` | `교훈` | 교훈 1건 → `docs/state/learnings.md` append (memory.json 과 별도 SoT) |
+| `vhk learn <교훈>` | `교훈` | 교훈 1건 → `memory.json` `failures.lesson` 단일 SoT (v2.0 통합 — 구 learnings.md 분리 폐지) |
 | `vhk resume --confirm` | `재개` | `.vhk/HARD_STOP` 해제 (사람 확인 필요, 자동 호출 금지) |
 
 ### 자율 루프 (v1.3+)
@@ -228,12 +228,12 @@ vhk mcp-init           # .cursor/mcp.json 자동 생성
 # 예: "상태 알려줘" → Cursor가 vhk status 도구 호출
 ```
 
-노출되는 MCP 도구 **24개** (v1.1):
+노출되는 MCP 도구 **25개** (v2.0 — `learn` 추가):
 
 - **git 워크플로 (8)**: `save`, `undo`, `status`, `diff`, `ship`, `doctor`, `check`, `recap`
 - **환경/규칙 (4)**: `env`, `env-check`, `sync`, `secure`
 - **품질/감사 (3)**: `audit`, `harness`, `mcp-init`
-- **컨텍스트/기록 (4)**: `context`, `context-show`, `memory-list`, `brief`
+- **컨텍스트/기록 (5)**: `context`, `context-show`, `memory-list`, `brief`, `learn` (교훈 1줄 → memory v2 failures.lesson 기록, 유일한 쓰기 도구)
 - **dry-info (4)**: `deploy`, `publish`, `migrate`, `update` — 인터랙티브 본질이라 실제 실행 안 함, 진단/안내만
 - **레퍼런스 (1)**: `ref-list`
 
@@ -252,7 +252,7 @@ vhk mcp                # stdio 서버 시작 (Cursor가 자동으로 호출)
 | 기능 | 설명 |
 |------|------|
 | **context** | 프로젝트 디렉토리 트리(3-depth) + 기술 스택(Next/Nuxt/Vue/Svelte/TS/Tailwind/tsup/Vite/...) 자동 감지 + 29개+ VHK 명령어 목록을 `.vhk/context.md` 마크다운으로 생성. AI 어시스턴트가 프로젝트 맥락을 즉시 파악 |
-| **memory** | `.vhk/memory.json` 결정사항 기억 관리. `add <content> --tags X,Y` / `list` / `remove <번호>`. NL은 list만 (add/remove는 인자 필수 → commander 전용) |
+| **memory** | `.vhk/memory.json` 기억 v2 4버킷(결정/실패/성공/패턴) 관리. `add <content> --type decision\|failure\|success` / `list [--all]` / `remove` / `archive` / `resolve` / `unarchive` / `migrate`. 손상 파일은 read 경로에서 덮어쓰지 않고 보존(원자적 write + `.v1.bak`/`.bak` 백업). NL은 list·migrate (인자 필요한 add/remove/archive/resolve 는 commander 전용) |
 | **brief** | 프로젝트 정보 + git 상태(브랜치·마지막 커밋·미커밋 변경) + 최근 결정사항 + 레퍼런스를 한 화면에 + `.vhk/brief.md` 저장. `safeExecFile` 기반 (Windows .cmd shim 안전) |
 | **자연어 확장** | `"맥락 만들어줘"` → context · `"컨텍스트 보여줘"` → context-show · `"기억 목록"` → memory · `"프로젝트 브리핑 만들어줘"` / `"상태 요약"` → brief |
 
@@ -280,7 +280,7 @@ vhk brief               # 세션 종료 시 상태 보고서
 - **공개 API 안정성**: 명령어 이름, CLI 인자, `.vhk/` 파일 포맷은 v2.0까지 breaking change 없음
 - **deprecation 절차**: 명령어/옵션 제거 전 1개 마이너 버전(1.x.0)에서 deprecation 경고
 - **i18n 키**: `ko.ts`의 `t()` 키 이름은 안정. 신규 키 누적, 기존 키 미제거
-- **MCP 서버 도구**: v1.0 GA 의 8개 baseline 도구(save/undo/status/diff/ship/doctor/check/recap) 인터페이스 안정 — v1.1 에서 16개 추가되어 총 24개
+- **MCP 서버 도구**: v1.0 GA 의 8개 baseline 도구(save/undo/status/diff/ship/doctor/check/recap) 인터페이스 안정 — v1.1 에서 16개 추가(총 24개), v2.0 에서 `learn` 추가(총 25개)
 
 > **`vhk memory` vs Claude Code `auto memory`** — `vhk memory`는 **프로젝트 단위** 결정사항(`.vhk/memory.json`, 팀 공유). Claude Code의 `auto memory`는 **사용자 단위** (`~/.claude/projects/.../memory/`, 개인 컨텍스트). 둘은 별개.
 
@@ -331,7 +331,7 @@ vhk ref open 1          # 1번 레퍼런스를 브라우저로 열기
 
 | 기능 | 설명 |
 |------|------|
-| **MCP 서버** | `vhk mcp` — stdio MCP 서버 첫 도입 (v0.6.0 당시 8개 도구 — save/undo/status/diff/ship/doctor/check/recap). 현재 v1.6 기준 **24개** 로 확장 — 위 "Cursor와 MCP로 연동하기" 섹션 참조 |
+| **MCP 서버** | `vhk mcp` — stdio MCP 서버 첫 도입 (v0.6.0 당시 8개 도구 — save/undo/status/diff/ship/doctor/check/recap). 현재 v2.0 기준 **25개** 로 확장 (`learn` 포함) — 위 "Cursor와 MCP로 연동하기" 섹션 참조 |
 | **mcp-init** | `vhk mcp-init` — Cursor `.cursor/mcp.json` 자동 생성. 재시작 한 번으로 연동 완료 |
 | **자연어 라우팅 확장** | `vhk mcp설정` → `vhk mcp-init` 별칭 |
 | **보안** | MCP save 도구의 shell injection 차단 — 모든 git 호출에 shell 미경유 `safeExecFile` 사용 |

package/dist/{chunk-RXDOM4QT.js → chunk-HCNU6K7D.js}

@@ -1386,7 +1386,8 @@ function toAgentsMd(sections, projectName) {
     "## 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.",
+    "- active goal \uB9CC \uC791\uC5C5. `docs/state`(next-task/blockers)\uB294 append-only.",
+    "- \uAD50\uD6C8\xB7\uACB0\uC815\xB7\uC2E4\uD328\xB7\uC131\uACF5\uC740 `vhk memory`(memory v2 4\uBC84\uD0B7, \uB2E8\uC77C \uCD9C\uCC98).",
     "- \uAC8C\uC774\uD2B8(tsc / test:run / build) \uD1B5\uACFC\uD574\uC57C\uB9CC `vhk goal done`.",
     ""
   ];
@@ -2972,9 +2973,19 @@ ${cliStatus}
   );
   server.registerTool(
     "memory-list",
-    { description: "\uC800\uC7A5\uB41C \uACB0\uC815\uC0AC\uD56D(memory) \uBAA9\uB85D \uBCF4\uAE30 (add/remove \uB294 \uC778\uC790 \uD544\uC694 \u2192 CLI \uC804\uC6A9)" },
+    {
+      description: "memory v2 \uD65C\uC131 \uAE30\uC5B5 \uBAA9\uB85D (decisions/failures/successes \u2014 \uAE30\uBCF8 active \uB9CC). add/remove/archive/resolve/unarchive/migrate \uB294 \uC778\uC790\xB7\uC4F0\uAE30 \u2192 CLI \uC804\uC6A9"
+    },
     async () => runVhkCli(["memory", "list"], "memory list")
   );
+  server.registerTool(
+    "learn",
+    {
+      description: "\uAD50\uD6C8 1\uC904 \uAE30\uB85D \u2192 memory v2 failures.lesson (\uB2E8\uC77C SoT, Evolution Loop \uD3D0\uD68C\uB85C)",
+      inputSchema: { lesson: z.string().describe("\uAE30\uB85D\uD560 \uAD50\uD6C8 \uD55C \uC904") }
+    },
+    async ({ lesson }) => runVhkCli(["learn", lesson], "learn")
+  );
   server.registerTool(
     "context-show",
     { description: ".vhk/context.md \uD30C\uC77C \uB0B4\uC6A9 \uBCF4\uAE30 (\uC5C6\uC73C\uBA74 `vhk context` \uC548\uB0B4)" },

package/dist/index.js

@@ -43,11 +43,12 @@ import {
   stripBom,
   sync,
   t
-} from "./chunk-RXDOM4QT.js";
+} from "./chunk-HCNU6K7D.js";
 
 // src/index.ts
 import { Command, Help } from "commander";
-import { pathToFileURL } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import fs13 from "fs";
 import chalk35 from "chalk";
 import inquirer14 from "inquirer";
 
@@ -183,11 +184,20 @@ var RULES = [
     confidence: "high",
     test: (t2) => /감사|취약점|audit|vulnerability|보안\s*감사|보안\s*취약|의존성\s*취약/.test(t2)
   },
+  // memory 마이그레이션은 패키지매니저 migrate 보다 **먼저** 평가 — "기억/메모리 마이그레이트" 가
+  // pnpm 전환(vhk migrate)으로 새지 않도록. 기억/메모리/memory 한정이라 bare "마이그레이트"는 안 가로챔.
+  {
+    command: "memory",
+    args: ["migrate"],
+    explanation: "memory.json v1 \u2192 v2 \uB9C8\uC774\uADF8\uB808\uC774\uC158 (vhk memory migrate)",
+    confidence: "high",
+    test: (t2) => /(기억|메모리|memory)\s*(을|를)?\s*(마이그레이|migrat)/.test(t2)
+  },
   {
     command: "migrate",
     explanation: "\uD328\uD0A4\uC9C0 \uB9E4\uB2C8\uC800 \uC804\uD658 (vhk migrate)",
     confidence: "high",
-    test: (t2) => /전환|마이그레이트|migrate|패키지\s*매니저|npm.*pnpm|pnpm.*npm|yarn.*전환|npm.*전환|pnpm.*전환/.test(t2)
+    test: (t2) => /전환|마이그레이(트|션)|migrate|패키지\s*매니저|npm.*pnpm|pnpm.*npm|yarn.*전환|npm.*전환|pnpm.*전환/.test(t2) && !/(기억|메모리|memory)\s*(을|를)?\s*(마이그레이|migrat)/.test(t2)
   },
   {
     command: "update",
@@ -211,7 +221,9 @@ var RULES = [
     command: "memory",
     explanation: "\uAE30\uC5B5 \uBAA9\uB85D \uC870\uD68C (vhk memory list)",
     confidence: "high",
-    test: (t2) => /^기억$|기억\s*(목록|보|확인|뭐)|memory.*list|결정사항\s*(목록|확인|보여)/.test(t2) && !/(추가|add|삭제|remove|저장|기록해)/.test(t2)
+    // 보관(archive)/해결(resolve)/마이그레이션은 list 가 아니다 → **제외 토큰 한 곳**에서 오라우팅 차단.
+    // archive/resolve 는 <번호> 인자가 필요해 NL 미지원 → 매칭 안 되면 notMatched 가 정직(잘못된 list 실행 금지).
+    test: (t2) => /^기억$|기억\s*(목록|보|확인|뭐)|memory.*list|결정사항\s*(목록|확인|보여)/.test(t2) && !/(추가|add|삭제|remove|저장|기록해|보관|아카이브|archive|마이그레이|migrat|해결|복구)/.test(t2)
   },
   {
     command: "brief",
@@ -372,7 +384,7 @@ function extractNotionUrl(input) {
 var CONTAINER_SUBCOMMANDS = {
   goal: ["list", "next", "check", "init", "done", "sync"],
   ref: ["add", "list", "open"],
-  memory: ["add", "list", "remove"],
+  memory: ["add", "list", "remove", "archive", "resolve", "unarchive", "migrate"],
   cloud: ["push", "pull"],
   secure: ["scan"],
   design: ["palette"],
@@ -1705,32 +1717,6 @@ ${line}
   }
   return { count, hardStopTripped };
 }
-function appendLearning(lesson, goalId) {
-  ensureStateDir();
-  const tag = goalId !== void 0 ? `goal-${goalId}` : "no-goal";
-  const line = `- [${isoDate()} ${tag}] ${lesson.trim()}`;
-  if (!existsSync(LEARNINGS_PATH)) {
-    writeFileSync(
-      LEARNINGS_PATH,
-      `# Learnings
-
-_Append-only. \uD55C \uC904 = \uD55C \uAD50\uD6C8._
-
-${line}
-`,
-      "utf-8"
-    );
-  } else {
-    appendFileSync(LEARNINGS_PATH, `${line}
-`, "utf-8");
-  }
-}
-function getRecentLearnings(limit = 3) {
-  if (!existsSync(LEARNINGS_PATH)) return [];
-  const lines = readFileSync(LEARNINGS_PATH, "utf-8").split(/\r?\n/);
-  const entries = lines.filter((l) => l.startsWith("- ["));
-  return entries.slice(-limit);
-}
 function getActiveBlockers(limit = 3) {
   if (!existsSync(BLOCKERS_PATH)) return [];
   const lines = readFileSync(BLOCKERS_PATH, "utf-8").split(/\r?\n/);
@@ -4444,15 +4430,432 @@ async function update() {
 
 // src/commands/context.ts
 import {
-  existsSync as existsSync11,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync4,
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync5,
   readdirSync as readdirSync2,
   statSync as statSync2,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "fs";
+import { join as join8 } from "path";
+import chalk24 from "chalk";
+
+// src/commands/memory.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, writeFileSync as writeFileSync7, copyFileSync, readFileSync as readFileSync4, renameSync, rmSync as rmSync3 } from "fs";
 import { join as join7 } from "path";
 import chalk23 from "chalk";
+var MEMORY_PATH_REL = join7(".vhk", "memory.json");
+var MEMORY_SCHEMA_VERSION = 2;
+function emptyV2() {
+  return { schemaVersion: MEMORY_SCHEMA_VERSION, decisions: [], failures: [], successes: [], patterns: [] };
+}
+function isV2(raw) {
+  return !!raw && typeof raw === "object" && raw.schemaVersion === 2;
+}
+var BUCKET_PREFIX = { decision: "d", failure: "f", success: "s" };
+function arr(v) {
+  return Array.isArray(v) ? v : [];
+}
+function normalizeV2(raw) {
+  return {
+    schemaVersion: MEMORY_SCHEMA_VERSION,
+    decisions: arr(raw.decisions),
+    failures: arr(raw.failures),
+    successes: arr(raw.successes),
+    patterns: arr(raw.patterns)
+  };
+}
+function parseLearnings(rawLearnings) {
+  const out = [];
+  for (const line of rawLearnings.split(/\r?\n/)) {
+    const m = line.match(/^-\s*\[(\d{4}-\d{2}-\d{2})\s+([^\]]*)\]\s*(.+)$/);
+    if (m) out.push({ date: m[1], tag: m[2].trim(), lesson: m[3].trim() });
+  }
+  return out;
+}
+function migrateMemory(rawMemory, rawLearnings) {
+  if (isV2(rawMemory)) return normalizeV2(rawMemory);
+  const v2 = emptyV2();
+  if (Array.isArray(rawMemory)) {
+    rawMemory.forEach((m, i) => {
+      const item = m;
+      if (item && typeof item.content === "string") {
+        v2.decisions.push({
+          id: `d${i + 1}`,
+          content: item.content,
+          tags: arr(item.tags),
+          createdAt: typeof item.addedAt === "string" ? item.addedAt : "",
+          status: "active"
+        });
+      }
+    });
+  }
+  if (rawLearnings) {
+    parseLearnings(rawLearnings).forEach((l, i) => {
+      v2.failures.push({
+        id: `f${i + 1}`,
+        content: "",
+        tags: l.tag ? [l.tag] : [],
+        createdAt: l.date,
+        status: "active",
+        lesson: l.lesson
+      });
+    });
+  }
+  return v2;
+}
+function readRaw(cwd) {
+  const p = join7(cwd, MEMORY_PATH_REL);
+  if (!existsSync11(p)) return { kind: "missing" };
+  try {
+    return { kind: "parsed", value: readJsonFile(p) };
+  } catch {
+    return { kind: "error" };
+  }
+}
+function warnUnreadable(cwd) {
+  const p = join7(cwd, MEMORY_PATH_REL);
+  console.error(chalk23.red(`
+\u26A0\uFE0F  ${MEMORY_PATH_REL} \uB97C \uC77D\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 (\uC190\uC0C1/\uBD80\uBD84 \uC4F0\uAE30 \uC758\uC2EC).`));
+  console.error(chalk23.yellow(`   \uB36E\uC5B4\uC4F0\uC9C0 \uC54A\uACE0 \uBE48 \uBA54\uBAA8\uB9AC\uB85C \uC9C4\uD589\uD569\uB2C8\uB2E4 \u2014 \uC6D0\uBCF8 \uBCF4\uC874\uB428.`));
+  console.error(chalk23.dim(`   \uD655\uC778/\uBCF5\uAD6C: ${p}  (\uBC31\uC5C5: ${p}.bak / ${p}.v1.bak)`));
+}
+function warnUnrecognized(cwd) {
+  const p = join7(cwd, MEMORY_PATH_REL);
+  console.error(chalk23.red(`
+\u26A0\uFE0F  ${MEMORY_PATH_REL} \uAC00 \uC778\uC2DD \uAC00\uB2A5\uD55C \uD615\uC2DD\uC774 \uC544\uB2D9\uB2C8\uB2E4 (v1 \uBC30\uC5F4/v2 \uAC1D\uCCB4 \uC544\uB2D8).`));
+  console.error(chalk23.yellow(`   \uBBF8\uB798 \uC2A4\uD0A4\uB9C8/\uC218\uB3D9 \uD3B8\uC9D1 \uC758\uC2EC \u2014 \uB36E\uC5B4\uC4F0\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4(\uC6D0\uBCF8 \uBCF4\uC874). \uD655\uC778 \uD6C4 \uB2E4\uC2DC \uC2DC\uB3C4.`));
+  console.error(chalk23.dim(`   \uD655\uC778: ${p}`));
+}
+function readLearningsRaw(cwd) {
+  const p = join7(cwd, "docs", "state", "learnings.md");
+  if (!existsSync11(p)) return void 0;
+  try {
+    return stripBom(readFileSync4(p, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function readMemory(cwd = process.cwd()) {
+  const raw = readRaw(cwd);
+  if (raw.kind === "error") {
+    warnUnreadable(cwd);
+    return emptyV2();
+  }
+  if (raw.kind === "parsed") {
+    if (isV2(raw.value)) return normalizeV2(raw.value);
+    if (Array.isArray(raw.value)) {
+      const v2 = migrateMemory(raw.value, readLearningsRaw(cwd));
+      try {
+        writeMemory(cwd, v2);
+      } catch {
+        console.error(chalk23.yellow(`   (v2 \uC601\uAD6C\uD654 \uBCF4\uB958 \u2014 ${MEMORY_PATH_REL} \uC7A0\uAE08 \uC758\uC2EC. \uC774\uBC88\uC5D4 \uBA54\uBAA8\uB9AC\uC0C1\uC73C\uB85C\uB9CC \uC9C4\uD589)`));
+      }
+      return v2;
+    }
+    warnUnrecognized(cwd);
+    return emptyV2();
+  }
+  return migrateMemory(null, readLearningsRaw(cwd));
+}
+function loadForMutation(cwd) {
+  const raw = readRaw(cwd);
+  if (raw.kind === "error") {
+    warnUnreadable(cwd);
+    return { ok: false };
+  }
+  if (raw.kind === "parsed") {
+    if (isV2(raw.value)) return { ok: true, mem: normalizeV2(raw.value) };
+    if (Array.isArray(raw.value)) return { ok: true, mem: migrateMemory(raw.value, readLearningsRaw(cwd)) };
+    warnUnrecognized(cwd);
+    return { ok: false };
+  }
+  return { ok: true, mem: migrateMemory(null, readLearningsRaw(cwd)) };
+}
+function isActive(e) {
+  return e.status !== "archived" && e.status !== "resolved";
+}
+function writeMemory(cwd, mem) {
+  const p = join7(cwd, MEMORY_PATH_REL);
+  mkdirSync7(join7(cwd, ".vhk"), { recursive: true });
+  if (existsSync11(p)) {
+    const cur = readRaw(cwd);
+    const curIsV2 = cur.kind === "parsed" && isV2(cur.value);
+    if (cur.kind !== "error" && !curIsV2 && !existsSync11(p + ".v1.bak")) {
+      try {
+        copyFileSync(p, p + ".v1.bak");
+      } catch {
+      }
+    }
+    if (cur.kind !== "error") {
+      try {
+        copyFileSync(p, p + ".bak");
+      } catch {
+      }
+    }
+  }
+  const tmpPath = p + ".tmp";
+  writeFileSync7(tmpPath, JSON.stringify(mem, null, 2) + "\n", "utf-8");
+  try {
+    renameSync(tmpPath, p);
+  } catch (err) {
+    try {
+      rmSync3(tmpPath, { force: true });
+    } catch {
+    }
+    throw err;
+  }
+}
+function nextId(bucket, mem) {
+  const prefix = BUCKET_PREFIX[bucket];
+  const list = bucket === "decision" ? mem.decisions : bucket === "failure" ? mem.failures : mem.successes;
+  const idRe = new RegExp(`^${prefix}(\\d+)$`);
+  let max = 0;
+  for (const e of list) {
+    const m = e.id.match(idRe);
+    if (m) max = Math.max(max, Number(m[1]));
+  }
+  return `${prefix}${max + 1}`;
+}
+function orderedAll(mem) {
+  return [
+    ...mem.decisions.map((entry) => ({ bucket: "decision", entry })),
+    ...mem.failures.map((entry) => ({ bucket: "failure", entry })),
+    ...mem.successes.map((entry) => ({ bucket: "success", entry }))
+  ];
+}
+var VALID_BUCKETS = ["decision", "failure", "success"];
+async function memoryAdd(content, opts = {}) {
+  console.log(chalk23.bold("\n\u{1F9E0} " + t("memory.addTitle")));
+  console.log(chalk23.gray("\u2500".repeat(40)));
+  if (!content || !content.trim()) {
+    console.log(chalk23.red("\u274C \uAE30\uC5B5\uD560 \uB0B4\uC6A9\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694."));
+    console.log(chalk23.gray('   \uC608: vhk memory add "API\uB294 tRPC \uC0AC\uC6A9" --type decision'));
+    process.exitCode = 1;
+    return;
+  }
+  const typeRaw = opts.type ?? "decision";
+  if (!VALID_BUCKETS.includes(typeRaw)) {
+    console.log(chalk23.red(`\u274C --type \uC740 decision|failure|success \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4 (\uBC1B\uC740 \uAC12: ${typeRaw}).`));
+    process.exitCode = 1;
+    return;
+  }
+  const type = typeRaw;
+  if (type === "decision" && (opts.why || opts.lesson)) {
+    console.log(chalk23.yellow("\u26A0\uFE0F  --why/--lesson \uC740 --type failure|success \uC5D0\uC11C\uB9CC \uC800\uC7A5\uB429\uB2C8\uB2E4 \u2014 decision \uC5D0\uC11C\uB294 \uBB34\uC2DC\uB428."));
+  }
+  const cwd = process.cwd();
+  const loaded = loadForMutation(cwd);
+  if (!loaded.ok) {
+    console.log(chalk23.red("\u274C memory.json \uC190\uC0C1 \uC758\uC2EC \u2014 \uC800\uC7A5 \uC911\uB2E8 (\uC6D0\uBCF8 \uBCF4\uC874). \uBC31\uC5C5 \uD655\uC778 \uD6C4 \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uC138\uC694."));
+    process.exitCode = 1;
+    return;
+  }
+  const mem = loaded.mem;
+  const base = {
+    id: nextId(type, mem),
+    content: content.trim(),
+    tags: opts.tags && opts.tags.length > 0 ? opts.tags : [],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "active"
+  };
+  if (type === "failure") mem.failures.push({ ...base, why: opts.why, lesson: opts.lesson });
+  else if (type === "success") mem.successes.push({ ...base, why: opts.why });
+  else mem.decisions.push(base);
+  writeMemory(cwd, mem);
+  console.log(chalk23.green(`
+\u2705 \uAE30\uC5B5 \uC800\uC7A5\uB428 (${type} #${base.id})`));
+  console.log(chalk23.cyan(`   \u{1F4DD} ${base.content}`));
+  printNextStep({ message: "\uAE30\uC5B5 \uC800\uC7A5 \uC644\uB8CC!", command: "vhk memory list", cursorHint: "\uAE30\uC5B5 \uBAA9\uB85D \uBCF4\uC5EC\uC918" });
+}
+var STATUS_ICON2 = { active: "\u{1F7E2}", resolved: "\u2705", archived: "\u{1F4E6}" };
+var BUCKET_LABEL = { decision: "\uACB0\uC815", failure: "\uC2E4\uD328", success: "\uC131\uACF5" };
+async function memoryList(opts = {}) {
+  console.log(chalk23.bold("\n\u{1F9E0} " + t("memory.listTitle")));
+  console.log(chalk23.gray("\u2500".repeat(40)));
+  const mem = readMemory(process.cwd());
+  const all = orderedAll(mem);
+  const visible = all.map((x, i) => ({ ...x, n: i + 1 })).filter((x) => (opts.all || isActive(x.entry)) && (!opts.type || x.bucket === opts.type));
+  if (visible.length === 0) {
+    console.log(chalk23.yellow("\n\u{1F4ED} \uD45C\uC2DC\uD560 \uAE30\uC5B5\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."));
+    console.log(chalk23.gray('   vhk memory add "\uB0B4\uC6A9" --type decision|failure|success'));
+    return;
+  }
+  console.log(chalk23.cyan(`
+${visible.length}\uAC1C${opts.all ? " (\uBCF4\uAD00 \uD3EC\uD568)" : " (\uD65C\uC131)"}:
+`));
+  for (const x of visible) {
+    const e = x.entry;
+    const fail = e;
+    console.log(`  [${x.n}] ${STATUS_ICON2[e.status] ?? "\u{1F7E2}"} (${BUCKET_LABEL[x.bucket]}) ${e.content || (fail.lesson ? "\u{1F4A1} " + fail.lesson : "(\uB0B4\uC6A9 \uC5C6\uC74C)")}`);
+    if (fail.lesson && e.content) console.log(chalk23.dim(`      \u{1F4A1} \uAD50\uD6C8: ${fail.lesson}`));
+    if (fail.why) console.log(chalk23.dim(`      \u21B3 ${fail.why}`));
+    if (e.tags.length > 0) console.log(chalk23.blue(`      \u{1F3F7}\uFE0F  ${e.tags.join(", ")}`));
+  }
+}
+function resolveIndex(indexStr, len) {
+  const idx = parseInt(indexStr, 10) - 1;
+  if (Number.isNaN(idx) || idx < 0 || idx >= len) return null;
+  return idx;
+}
+async function memoryRemove(indexStr) {
+  const cwd = process.cwd();
+  const loaded = loadForMutation(cwd);
+  if (!loaded.ok) {
+    console.log(chalk23.red("\u274C memory.json \uC190\uC0C1 \uC758\uC2EC \u2014 \uC0AD\uC81C \uC911\uB2E8 (\uC6D0\uBCF8 \uBCF4\uC874)."));
+    process.exitCode = 1;
+    return;
+  }
+  const mem = loaded.mem;
+  const all = orderedAll(mem);
+  const idx = resolveIndex(indexStr, all.length);
+  if (idx === null) {
+    console.log(chalk23.red(`\u274C \uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uBC88\uD638\uC785\uB2C8\uB2E4. (1~${all.length || 0})`));
+    process.exitCode = 1;
+    return;
+  }
+  const { bucket, entry } = all[idx];
+  const list = bucket === "decision" ? mem.decisions : bucket === "failure" ? mem.failures : mem.successes;
+  const pos = list.findIndex((e) => e === entry);
+  if (pos >= 0) list.splice(pos, 1);
+  writeMemory(cwd, mem);
+  console.log(chalk23.green("\n\u2705 \uAE30\uC5B5 \uC0AD\uC81C\uB428:"));
+  console.log(chalk23.gray(`   ${entry.content || entry.lesson || entry.id}`));
+}
+function resolveEntryForMutation(indexStr) {
+  const cwd = process.cwd();
+  const loaded = loadForMutation(cwd);
+  if (!loaded.ok) {
+    console.log(chalk23.red("\u274C memory.json \uC190\uC0C1 \uC758\uC2EC \u2014 \uC791\uC5C5 \uC911\uB2E8 (\uC6D0\uBCF8 \uBCF4\uC874)."));
+    process.exitCode = 1;
+    return null;
+  }
+  const mem = loaded.mem;
+  const all = orderedAll(mem);
+  const idx = resolveIndex(indexStr, all.length);
+  if (idx === null) {
+    console.log(chalk23.red(`\u274C \uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uBC88\uD638\uC785\uB2C8\uB2E4. (1~${all.length || 0})`));
+    process.exitCode = 1;
+    return null;
+  }
+  return { cwd, mem, entry: all[idx].entry };
+}
+function entryLabel(entry) {
+  return entry.content || entry.lesson || entry.id;
+}
+async function memoryArchive(indexStr) {
+  const r = resolveEntryForMutation(indexStr);
+  if (!r) return;
+  r.entry.status = "archived";
+  r.entry.archivedAt = (/* @__PURE__ */ new Date()).toISOString();
+  delete r.entry.resolvedAt;
+  writeMemory(r.cwd, r.mem);
+  console.log(chalk23.green(`
+\u{1F4E6} \uBCF4\uAD00\uB428: ${entryLabel(r.entry)}`));
+  console.log(chalk23.dim("   (\uD328\uD134 \uAC10\uC9C0\xB7\uC9C4\uD654\uC5D0\uC11C \uC81C\uC678\uB429\uB2C8\uB2E4 \u2014 \uC120\uC21C\uD658). \uB418\uB3CC\uB9AC\uAE30: vhk memory unarchive <\uBC88\uD638>"));
+}
+async function memoryResolve(indexStr) {
+  const r = resolveEntryForMutation(indexStr);
+  if (!r) return;
+  r.entry.status = "resolved";
+  r.entry.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+  delete r.entry.archivedAt;
+  writeMemory(r.cwd, r.mem);
+  console.log(chalk23.green(`
+\u2705 \uD574\uACB0\uB428: ${entryLabel(r.entry)}`));
+  console.log(chalk23.dim("   (vhk memory list --all \uB85C \uD655\uC778. \uB418\uB3CC\uB9AC\uAE30: vhk memory unarchive <\uBC88\uD638>)"));
+}
+async function memoryUnarchive(indexStr) {
+  const r = resolveEntryForMutation(indexStr);
+  if (!r) return;
+  if (isActive(r.entry)) {
+    console.log(chalk23.dim(`  \uC774\uBBF8 \uD65C\uC131 \uD56D\uBAA9\uC785\uB2C8\uB2E4 \u2014 \uBCC0\uACBD \uC5C6\uC74C: ${entryLabel(r.entry)}`));
+    return;
+  }
+  r.entry.status = "active";
+  delete r.entry.archivedAt;
+  delete r.entry.resolvedAt;
+  writeMemory(r.cwd, r.mem);
+  console.log(chalk23.green(`
+\u{1F7E2} \uD65C\uC131\uC73C\uB85C \uBCF5\uAD6C\uB428: ${entryLabel(r.entry)}`));
+}
+async function memoryMigrate() {
+  const cwd = process.cwd();
+  const raw = readRaw(cwd);
+  if (raw.kind === "error") {
+    warnUnreadable(cwd);
+    console.log(chalk23.red("  \u274C \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uC911\uB2E8 (\uC190\uC0C1 \uC758\uC2EC). \uC6D0\uBCF8 \uD655\uC778 \uD6C4 \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uC138\uC694."));
+    process.exitCode = 1;
+    return;
+  }
+  if (raw.kind === "parsed" && isV2(raw.value)) {
+    console.log(chalk23.dim("  \uC774\uBBF8 memory schema v2 \uC785\uB2C8\uB2E4 \u2014 \uBCC0\uACBD \uC5C6\uC74C(\uBA71\uB4F1)."));
+    return;
+  }
+  if (raw.kind === "parsed" && !Array.isArray(raw.value)) {
+    warnUnrecognized(cwd);
+    console.log(chalk23.red("  \u274C v1(\uD3C9\uBA74 \uBC30\uC5F4) \uD615\uC2DD\uC774 \uC544\uB2C8\uB77C \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uB300\uC0C1\uC774 \uC544\uB2D9\uB2C8\uB2E4 \u2014 \uC911\uB2E8(\uC6D0\uBCF8 \uBCF4\uC874)."));
+    process.exitCode = 1;
+    return;
+  }
+  const learnings = readLearningsRaw(cwd);
+  const hadFile = raw.kind === "parsed";
+  if (raw.kind === "missing" && !learnings) {
+    console.log(chalk23.yellow("  \u2139\uFE0F  \uB9C8\uC774\uADF8\uB808\uC774\uC158\uD560 v1 memory.json / learnings.md \uAC00 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uBCC0\uACBD \uC5C6\uC74C."));
+    return;
+  }
+  const v2 = migrateMemory(raw.kind === "parsed" ? raw.value : null, learnings);
+  writeMemory(cwd, v2);
+  const backupNote = hadFile ? " (.v1.bak \uC6D0\uBCF8 \uC601\uAD6C \uBC31\uC5C5)" : " (\uC2E0\uADDC \uC0DD\uC131 \u2014 \uC6D0\uBCF8 \uC5C6\uC74C, \uBC31\uC5C5 \uC5C6\uC74C)";
+  console.log(chalk23.green(`
+\u2705 memory.json \u2192 v2 \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uC644\uB8CC${backupNote}`));
+  console.log(
+    chalk23.dim(
+      `   decisions ${v2.decisions.length} \xB7 failures ${v2.failures.length} \xB7 successes ${v2.successes.length}` + (learnings ? " (learnings.md \uAD50\uD6C8 \uD761\uC218 \u2014 \uC774\uD6C4 vhk learn \uC740 memory \uC5D0 \uAE30\uB85D)" : "")
+    )
+  );
+}
+function activeMemoryLines(mem, limit = 5) {
+  const lines = [];
+  const fmt = (e) => {
+    const f = e;
+    const base = e.content || (f.lesson ? `\u{1F4A1} ${f.lesson}` : e.id);
+    return e.content && f.lesson ? `${base} \u2014 \u{1F4A1} ${f.lesson}` : base;
+  };
+  const section = (label, list) => {
+    const act = list.filter(isActive);
+    if (act.length === 0) return;
+    lines.push(`**${label}** (${act.length})`);
+    for (const e of act.slice(-limit)) lines.push(`- ${fmt(e)}`);
+    if (act.length > limit) lines.push(`- \u2026 \uC678 ${act.length - limit}\uAC1C`);
+    lines.push("");
+  };
+  section("\uACB0\uC815 (decisions)", mem.decisions);
+  section("\uC2E4\uD328\xB7\uAD50\uD6C8 (failures)", mem.failures);
+  section("\uC131\uACF5 (successes)", mem.successes);
+  const pats = mem.patterns.length;
+  if (pats > 0) lines.push(`**\uD328\uD134 \uD6C4\uBCF4 (patterns)**: ${pats}\uAC1C \u2014 \`vhk pattern\``, "");
+  return lines;
+}
+function recordLesson(cwd, lesson, goalId) {
+  const loaded = loadForMutation(cwd);
+  if (!loaded.ok) return null;
+  const mem = loaded.mem;
+  const tag = goalId !== void 0 ? `goal-${goalId}` : "no-goal";
+  const entry = {
+    id: nextId("failure", mem),
+    content: "",
+    tags: [tag],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "active",
+    lesson: lesson.trim()
+  };
+  mem.failures.push(entry);
+  writeMemory(cwd, mem);
+  return entry;
+}
+
+// src/commands/context.ts
 var CONTEXT_PATH = ".vhk/context.md";
 var IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -4477,7 +4880,7 @@ function buildTree(dir, prefix = "", maxDepth = 3, depth = 0) {
     filtered.forEach((entry, index) => {
       const isLast = index === filtered.length - 1;
       const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-      const fullPath = join7(dir, entry);
+      const fullPath = join8(dir, entry);
       const stat = statSync2(fullPath);
       const isDir = stat.isDirectory();
       lines.push(`${prefix}${connector}${entry}${isDir ? "/" : ""}`);
@@ -4509,8 +4912,8 @@ function extractTechStack() {
     else if (all.jest) stack["\uD14C\uC2A4\uD2B8"] = "jest";
     if (all.commander) stack["CLI"] = "commander";
     if (all.inquirer) stack["\uC778\uD130\uB799\uD2F0\uBE0C"] = "inquirer";
-    if (existsSync11("pnpm-lock.yaml")) stack["\uD328\uD0A4\uC9C0 \uB9E4\uB2C8\uC800"] = "pnpm";
-    else if (existsSync11("yarn.lock")) stack["\uD328\uD0A4\uC9C0 \uB9E4\uB2C8\uC800"] = "yarn";
+    if (existsSync12("pnpm-lock.yaml")) stack["\uD328\uD0A4\uC9C0 \uB9E4\uB2C8\uC800"] = "pnpm";
+    else if (existsSync12("yarn.lock")) stack["\uD328\uD0A4\uC9C0 \uB9E4\uB2C8\uC800"] = "yarn";
     else stack["\uD328\uD0A4\uC9C0 \uB9E4\uB2C8\uC800"] = "npm";
     if (pkg.name) stack["\uD328\uD0A4\uC9C0 \uC774\uB984"] = pkg.name;
     if (pkg.version) stack["\uBC84\uC804"] = pkg.version;
@@ -4553,8 +4956,8 @@ function getVhkCommands() {
 }
 async function context(opts = {}) {
   const compact = opts.compact === true;
-  console.log(chalk23.bold("\n\u{1F9E0} " + t("context.title")));
-  console.log(chalk23.gray("\u2500".repeat(40)));
+  console.log(chalk24.bold("\n\u{1F9E0} " + t("context.title")));
+  console.log(chalk24.gray("\u2500".repeat(40)));
   const stack = extractTechStack();
   const tree = buildTree(".", "", compact ? 2 : 3).join("\n");
   const commands = getVhkCommands();
@@ -4589,27 +4992,14 @@ async function context(opts = {}) {
     }
     lines.push("");
   }
-  if (existsSync11(".vhk/memory.json")) {
-    try {
-      const memories = readJsonFile(
-        ".vhk/memory.json"
-      );
-      if (Array.isArray(memories) && memories.length > 0) {
-        const recentMemories = memories.slice(-5);
-        lines.push("## \uC800\uC7A5\uB41C \uACB0\uC815\uC0AC\uD56D");
-        lines.push("");
-        if (memories.length > recentMemories.length) {
-          lines.push(`_\uCD5C\uADFC ${recentMemories.length}\uAC1C\uB9CC \uD45C\uC2DC (\uC804\uCCB4 ${memories.length}\uAC1C)_`);
-          lines.push("");
-        }
-        for (const m of recentMemories) {
-          const date = new Date(m.addedAt).toLocaleDateString("ko-KR");
-          lines.push(`- ${m.content} _(${date})_`);
-        }
-        lines.push("");
-      }
-    } catch {
+  try {
+    const memLines = activeMemoryLines(readMemory(process.cwd()));
+    if (memLines.length > 0) {
+      lines.push("## \uC800\uC7A5\uB41C \uAE30\uC5B5 (memory v2)");
+      lines.push("");
+      lines.push(...memLines);
     }
+  } catch {
   }
   const goals = listGoals("goals");
   const activeId = selectActiveId(goals);
@@ -4626,13 +5016,6 @@ async function context(opts = {}) {
       lines.push("");
     }
   }
-  const recent = getRecentLearnings(3);
-  if (recent.length > 0) {
-    lines.push("## Recent Learnings");
-    lines.push("");
-    for (const r of recent) lines.push(r);
-    lines.push("");
-  }
   const activeBlockers = getActiveBlockers(3);
   if (activeBlockers.length > 0) {
     lines.push("## Active Blockers");
@@ -4667,12 +5050,12 @@ async function context(opts = {}) {
   } catch {
   }
   lines.push("");
-  mkdirSync7(".vhk", { recursive: true });
-  writeFileSync7(CONTEXT_PATH, lines.join("\n"), "utf-8");
-  console.log(chalk23.green(`
+  mkdirSync8(".vhk", { recursive: true });
+  writeFileSync8(CONTEXT_PATH, lines.join("\n"), "utf-8");
+  console.log(chalk24.green(`
 \u2705 ${CONTEXT_PATH} \uC0DD\uC131 \uC644\uB8CC!`));
-  console.log(chalk23.gray(`   \uAE30\uC220 \uC2A4\uD0DD ${Object.keys(stack).length}\uAC1C \uAC10\uC9C0`));
-  console.log(chalk23.gray("   AI \uC5B4\uC2DC\uC2A4\uD134\uD2B8\uC5D0\uAC8C \uC774 \uD30C\uC77C\uC744 \uCC38\uC870\uD558\uAC8C \uD558\uC138\uC694."));
+  console.log(chalk24.gray(`   \uAE30\uC220 \uC2A4\uD0DD ${Object.keys(stack).length}\uAC1C \uAC10\uC9C0`));
+  console.log(chalk24.gray("   AI \uC5B4\uC2DC\uC2A4\uD134\uD2B8\uC5D0\uAC8C \uC774 \uD30C\uC77C\uC744 \uCC38\uC870\uD558\uAC8C \uD558\uC138\uC694."));
   printNextStep({
     message: "\uCEE8\uD14D\uC2A4\uD2B8 \uD30C\uC77C \uC0DD\uC131 \uC644\uB8CC!",
     command: "vhk context-show",
@@ -4680,110 +5063,33 @@ async function context(opts = {}) {
   });
 }
 async function contextShow() {
-  console.log(chalk23.bold("\n\u{1F4C4} " + t("context.showTitle")));
-  console.log(chalk23.gray("\u2500".repeat(40)));
-  if (!existsSync11(CONTEXT_PATH)) {
-    console.log(chalk23.yellow("\n\u26A0\uFE0F  \uCEE8\uD14D\uC2A4\uD2B8 \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."));
-    console.log(chalk23.gray("   vhk context\uB97C \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694."));
-    return;
-  }
-  const content = readFileSync4(CONTEXT_PATH, "utf-8");
-  console.log("\n" + content);
-}
-
-// src/commands/memory.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "fs";
-import chalk24 from "chalk";
-var MEMORY_PATH = ".vhk/memory.json";
-function loadMemories() {
-  if (!existsSync12(MEMORY_PATH)) return [];
-  try {
-    const parsed = readJsonFile(MEMORY_PATH);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
-  }
-}
-function saveMemories(memories) {
-  mkdirSync8(".vhk", { recursive: true });
-  writeFileSync8(MEMORY_PATH, JSON.stringify(memories, null, 2) + "\n", "utf-8");
-}
-async function memoryAdd(content, tags) {
-  console.log(chalk24.bold("\n\u{1F9E0} " + t("memory.addTitle")));
+  console.log(chalk24.bold("\n\u{1F4C4} " + t("context.showTitle")));
   console.log(chalk24.gray("\u2500".repeat(40)));
-  if (!content) {
-    console.log(chalk24.red("\u274C \uAE30\uC5B5\uD560 \uB0B4\uC6A9\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694."));
-    console.log(chalk24.gray('   \uC608: vhk memory add "API\uB294 tRPC \uC0AC\uC6A9\uD558\uAE30\uB85C \uACB0\uC815"'));
-    process.exitCode = 1;
-    return;
-  }
-  const memories = loadMemories();
-  memories.push({
-    content,
-    addedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    tags: tags && tags.length > 0 ? tags : []
-  });
-  saveMemories(memories);
-  console.log(chalk24.green(`
-\u2705 \uAE30\uC5B5 \uC800\uC7A5\uB428 (#${memories.length})`));
-  console.log(chalk24.cyan(`   \u{1F4DD} ${content}`));
-  printNextStep({
-    message: "\uAE30\uC5B5 \uC800\uC7A5 \uC644\uB8CC!",
-    command: "vhk memory list",
-    cursorHint: "\uAE30\uC5B5 \uBAA9\uB85D \uBCF4\uC5EC\uC918"
-  });
-}
-async function memoryList() {
-  console.log(chalk24.bold("\n\u{1F9E0} " + t("memory.listTitle")));
-  console.log(chalk24.gray("\u2500".repeat(40)));
-  const memories = loadMemories();
-  if (memories.length === 0) {
-    console.log(chalk24.yellow("\n\u{1F4ED} \uC800\uC7A5\uB41C \uAE30\uC5B5\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."));
-    console.log(chalk24.gray('   vhk memory add "\uB0B4\uC6A9"\uC73C\uB85C \uCD94\uAC00\uD558\uC138\uC694.'));
-    return;
-  }
-  console.log(chalk24.cyan(`
-\uCD1D ${memories.length}\uAC1C\uC758 \uAE30\uC5B5:
-`));
-  memories.forEach((m, index) => {
-    const date = new Date(m.addedAt).toLocaleDateString("ko-KR");
-    console.log(chalk24.white(`  [${index + 1}] ${m.content}`));
-    if (m.tags && m.tags.length > 0) {
-      console.log(chalk24.blue(`      \u{1F3F7}\uFE0F  ${m.tags.join(", ")}`));
-    }
-    console.log(chalk24.gray(`      \u{1F4C5} ${date}`));
-    console.log("");
-  });
-}
-async function memoryRemove(indexStr) {
-  const memories = loadMemories();
-  const idx = parseInt(indexStr, 10) - 1;
-  if (Number.isNaN(idx) || idx < 0 || idx >= memories.length) {
-    console.log(chalk24.red(`\u274C \uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uBC88\uD638\uC785\uB2C8\uB2E4. (1~${memories.length || 0})`));
+  if (!existsSync12(CONTEXT_PATH)) {
+    console.log(chalk24.yellow("\n\u26A0\uFE0F  \uCEE8\uD14D\uC2A4\uD2B8 \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."));
+    console.log(chalk24.gray("   vhk context\uB97C \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694."));
     return;
   }
-  const removed = memories.splice(idx, 1)[0];
-  saveMemories(memories);
-  console.log(chalk24.green("\n\u2705 \uAE30\uC5B5 \uC0AD\uC81C\uB428:"));
-  console.log(chalk24.gray(`   ${removed.content}`));
+  const content = readFileSync5(CONTEXT_PATH, "utf-8");
+  console.log("\n" + content);
 }
 
 // src/commands/brief.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9, readFileSync as readFileSync6 } from "fs";
 import chalk25 from "chalk";
 var BRIEF_PATH = ".vhk/brief.md";
 function readProjectIdentity() {
   const out = {};
   try {
     if (existsSync13("RULES.md")) {
-      const r = readFileSync5("RULES.md", "utf-8");
+      const r = readFileSync6("RULES.md", "utf-8");
       const m = r.split("\n")[0].match(/^#\s*(.+?)(?:\s*—.*)?$/);
       if (m) out.name = m[1].trim();
       const d = r.match(/한 줄 설명:\s*(.+)/);
       if (d) out.description = d[1].trim();
     }
     if (!out.name && existsSync13("CLAUDE.md")) {
-      const m = readFileSync5("CLAUDE.md", "utf-8").match(/#\s*기록 규칙\s*\((.+?)\)/);
+      const m = readFileSync6("CLAUDE.md", "utf-8").match(/#\s*기록 규칙\s*\((.+?)\)/);
       if (m) out.name = m[1].trim();
     }
   } catch {
@@ -4833,22 +5139,14 @@ async function brief() {
     `- **\uBBF8\uCEE4\uBC0B \uBCC0\uACBD**: ${uncommitted ? `${uncommitted.split("\n").length}\uAC1C \uD30C\uC77C` : "\uC5C6\uC74C \u2705"}`
   );
   lines.push("");
-  if (existsSync13(".vhk/memory.json")) {
-    try {
-      const memories = readJsonFile(".vhk/memory.json");
-      if (Array.isArray(memories) && memories.length > 0) {
-        lines.push(`## \uC800\uC7A5\uB41C \uACB0\uC815\uC0AC\uD56D (${memories.length}\uAC1C)`);
-        lines.push("");
-        for (const m of memories.slice(-5)) {
-          lines.push(`- ${m.content}`);
-        }
-        if (memories.length > 5) {
-          lines.push(`- ... \uC678 ${memories.length - 5}\uAC1C`);
-        }
-        lines.push("");
-      }
-    } catch {
+  try {
+    const memLines = activeMemoryLines(readMemory(process.cwd()));
+    if (memLines.length > 0) {
+      lines.push("## \uC800\uC7A5\uB41C \uAE30\uC5B5 (memory v2)");
+      lines.push("");
+      lines.push(...memLines);
     }
+  } catch {
   }
   if (existsSync13(".vhk/refs.json")) {
     try {
@@ -4895,7 +5193,7 @@ import chalk26 from "chalk";
 import inquirer11 from "inquirer";
 import { simpleGit as simpleGit2 } from "simple-git";
 import { existsSync as existsSync14 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 var VHK_FOOTPRINT_FILES = [
   "CLAUDE.md",
   ".cursorrules",
@@ -4904,7 +5202,7 @@ var VHK_FOOTPRINT_FILES = [
   "docs/PRD.md"
 ];
 function detectExistingFootprint(cwd) {
-  return VHK_FOOTPRINT_FILES.filter((rel) => existsSync14(join8(cwd, rel)));
+  return VHK_FOOTPRINT_FILES.filter((rel) => existsSync14(join9(cwd, rel)));
 }
 async function runGitInit(cwd) {
   try {
@@ -5310,7 +5608,7 @@ import chalk29 from "chalk";
 
 // src/lib/config.ts
 import { existsSync as existsSync15, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // src/lib/safety-mode.ts
 var SAFETY_MODES = ["lite", "standard", "strict"];
@@ -5326,10 +5624,10 @@ function isSafetyMode(value) {
 
 // src/lib/config.ts
 var CONFIG_DIR = ".vhk";
-var CONFIG_PATH = join9(CONFIG_DIR, "config.json");
+var CONFIG_PATH = join10(CONFIG_DIR, "config.json");
 var DEFAULT_CONFIG = { safetyMode: DEFAULT_SAFETY_MODE };
 function readConfig(rootDir = process.cwd()) {
-  const full = join9(rootDir, CONFIG_PATH);
+  const full = join10(rootDir, CONFIG_PATH);
   if (!existsSync15(full)) return { ...DEFAULT_CONFIG };
   try {
     const raw = readJsonFile(full);
@@ -5341,8 +5639,8 @@ function readConfig(rootDir = process.cwd()) {
   }
 }
 function writeConfig(config, rootDir = process.cwd()) {
-  mkdirSync10(join9(rootDir, CONFIG_DIR), { recursive: true });
-  writeFileSync10(join9(rootDir, CONFIG_PATH), JSON.stringify(config, null, 2) + "\n", "utf-8");
+  mkdirSync10(join10(rootDir, CONFIG_DIR), { recursive: true });
+  writeFileSync10(join10(rootDir, CONFIG_PATH), JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 
 // src/commands/mode.ts
@@ -5382,7 +5680,7 @@ async function mode(target) {
 // src/commands/verify.ts
 import { execFileSync as execFileSync4 } from "child_process";
 import { existsSync as existsSync16, mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import chalk30 from "chalk";
 
 // src/commands/verify-report.ts
@@ -5491,13 +5789,13 @@ ${actions}
 
 // src/commands/verify.ts
 var REPORT_SCHEMA_VERSION = 1;
-var REPORT_DIR_REL = join10(".vhk", "reports");
-var REPORT_PATH_REL = join10(REPORT_DIR_REL, "latest.json");
-var REPORT_HTML_PATH_REL = join10(REPORT_DIR_REL, "latest.html");
+var REPORT_DIR_REL = join11(".vhk", "reports");
+var REPORT_PATH_REL = join11(REPORT_DIR_REL, "latest.json");
+var REPORT_HTML_PATH_REL = join11(REPORT_DIR_REL, "latest.html");
 var SHIM = /* @__PURE__ */ new Set(["pnpm", "npm", "npx", "yarn"]);
 function detectPm(cwd) {
-  if (existsSync16(join10(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync16(join10(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync16(join11(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync16(join11(cwd, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function execGate(cmd, args, cwd) {
@@ -5540,7 +5838,7 @@ function runScriptGate(id, label, cwd, pm, argvFor) {
   };
 }
 function readPackageScripts(cwd) {
-  const pkgPath = join10(cwd, "package.json");
+  const pkgPath = join11(cwd, "package.json");
   if (!existsSync16(pkgPath)) return {};
   try {
     const pkg = readJsonFile(pkgPath);
@@ -5556,7 +5854,7 @@ function runGates(cwd) {
   gates.push(
     runScriptGate("typecheck", "tsc --noEmit", cwd, pm, () => {
       if (scripts.typecheck) return ["run", "typecheck"];
-      if (existsSync16(join10(cwd, "tsconfig.json"))) return pm === "npm" ? ["exec", "--", "tsc", "--noEmit"] : ["exec", "tsc", "--noEmit"];
+      if (existsSync16(join11(cwd, "tsconfig.json"))) return pm === "npm" ? ["exec", "--", "tsc", "--noEmit"] : ["exec", "tsc", "--noEmit"];
       return null;
     })
   );
@@ -5635,9 +5933,9 @@ function buildReport(gates, generatedAt, date) {
 function verifyEvidence(cwd = process.cwd()) {
   const gates = runGates(cwd);
   const report = buildReport(gates, (/* @__PURE__ */ new Date()).toISOString(), localDate());
-  const dir = join10(cwd, REPORT_DIR_REL);
+  const dir = join11(cwd, REPORT_DIR_REL);
   mkdirSync11(dir, { recursive: true });
-  const path14 = join10(cwd, REPORT_PATH_REL);
+  const path14 = join11(cwd, REPORT_PATH_REL);
   writeFileSync11(path14, JSON.stringify(report, null, 2) + "\n", "utf-8");
   try {
     ensureVhkIgnored(cwd, "reports/");
@@ -5651,7 +5949,7 @@ var STATUS_BADGE = {
   FAIL: chalk30.red.bold("FAIL")
 };
 async function renderVerifyReport(cwd, opts) {
-  const jsonPath = join10(cwd, REPORT_PATH_REL);
+  const jsonPath = join11(cwd, REPORT_PATH_REL);
   let report;
   if (existsSync16(jsonPath)) {
     try {
@@ -5665,9 +5963,9 @@ async function renderVerifyReport(cwd, opts) {
     report = verifyEvidence(cwd).report;
   }
   const html = renderReportHtml(report);
-  const htmlPath = join10(cwd, REPORT_HTML_PATH_REL);
+  const htmlPath = join11(cwd, REPORT_HTML_PATH_REL);
   try {
-    mkdirSync11(join10(cwd, REPORT_DIR_REL), { recursive: true });
+    mkdirSync11(join11(cwd, REPORT_DIR_REL), { recursive: true });
     writeFileSync11(htmlPath, html, "utf-8");
   } catch (e) {
     console.error(
@@ -5751,7 +6049,7 @@ async function verify(opts = {}) {
 
 // src/commands/review.ts
 import { existsSync as existsSync17, writeFileSync as writeFileSync12 } from "fs";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 import chalk31 from "chalk";
 var GOALS_DIR2 = "goals";
 var COVERAGE_MIN = 0.5;
@@ -5909,7 +6207,7 @@ async function review(opts = {}) {
   if (opts.id === void 0 && goalStatus === "NOT_STARTED") {
     console.error(chalk31.yellow(`  \u26A0\uFE0F  active goal ${goalId} \uAC00 NOT_STARTED \u2014 \uC644\uB8CC \uC8FC\uC7A5\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uAC80\uC99D \uB300\uC0C1\uC740 --id \uB85C \uC9C0\uC815\uD558\uC138\uC694.`));
   }
-  const jsonPath = join11(cwd, REPORT_PATH_REL);
+  const jsonPath = join12(cwd, REPORT_PATH_REL);
   if (!existsSync17(jsonPath)) {
     console.error(chalk31.yellow(`  \u26A0\uFE0F  \uC99D\uAC70 \uBD80\uC7AC \u2014 ${REPORT_PATH_REL} \uC5C6\uC74C. review \uB97C \uC911\uB2E8\uD569\uB2C8\uB2E4(\uC0C8 \uC99D\uAC70 \uC548 \uB9CC\uB4E6).`));
     printNextStep({
@@ -6020,12 +6318,12 @@ ${result.disclaimer}`));
 }
 
 // src/commands/mission.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync12, writeFileSync as writeFileSync13, rmSync as rmSync3 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync12, writeFileSync as writeFileSync13, rmSync as rmSync4 } from "fs";
+import { join as join13 } from "path";
 import chalk32 from "chalk";
 import inquirer12 from "inquirer";
 import { simpleGit as simpleGit3 } from "simple-git";
-var MISSION_PATH_REL = join12(".vhk", "mission.json");
+var MISSION_PATH_REL = join13(".vhk", "mission.json");
 var MISSION_SCHEMA_VERSION = 1;
 var MISSION_DISCLAIMER = "\u26A0\uFE0F  mission check \uB294 \uACBD\uB85C glob \uAE30\uC900\uC785\uB2C8\uB2E4 \u2014 objective \uC758\uBBF8 \uBD80\uD569\uC740 \uAC80\uC99D\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4(\uC2E0\uB8B0\uB3C4 \uC2E0\uD638, \uBCF4\uC7A5 \uC544\uB2D8).";
 function globToRegExp(glob) {
@@ -6073,7 +6371,7 @@ function checkMission(changedFiles, mission) {
   return { violations, warnings, disclaimer: MISSION_DISCLAIMER };
 }
 function readMission(cwd = process.cwd()) {
-  const p = join12(cwd, MISSION_PATH_REL);
+  const p = join13(cwd, MISSION_PATH_REL);
   if (!existsSync18(p)) return null;
   try {
     const m = readJsonFile(p);
@@ -6084,8 +6382,8 @@ function readMission(cwd = process.cwd()) {
   }
 }
 function writeMission(cwd, mission) {
-  mkdirSync12(join12(cwd, ".vhk"), { recursive: true });
-  writeFileSync13(join12(cwd, MISSION_PATH_REL), JSON.stringify(mission, null, 2) + "\n", "utf-8");
+  mkdirSync12(join13(cwd, ".vhk"), { recursive: true });
+  writeFileSync13(join13(cwd, MISSION_PATH_REL), JSON.stringify(mission, null, 2) + "\n", "utf-8");
 }
 async function collectChangedFiles(cwd) {
   const status2 = await simpleGit3(cwd).status();
@@ -6182,13 +6480,13 @@ async function missionCheck() {
 }
 async function missionClear() {
   const cwd = process.cwd();
-  const p = join12(cwd, MISSION_PATH_REL);
+  const p = join13(cwd, MISSION_PATH_REL);
   if (!existsSync18(p)) {
     console.log(chalk32.dim("  \uBBF8\uC158 \uACC4\uC57D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uC9C0\uC6B8 \uAC83 \uC5C6\uC74C."));
     return;
   }
   try {
-    rmSync3(p);
+    rmSync4(p);
     console.log(chalk32.green("  \u2705 \uBBF8\uC158 \uACC4\uC57D \uC0AD\uC81C\uB428 (.vhk/mission.json)."));
   } catch (e) {
     console.error(chalk32.red(`  \u274C \uC0AD\uC81C \uC2E4\uD328: ${e instanceof Error ? e.message : String(e)}`));
@@ -6337,6 +6635,7 @@ async function dispatchNlpRoute(route, input) {
     case "context-show":
       return contextShow();
     case "memory":
+      if (route.args?.[0] === "migrate") return memoryMigrate();
       return memoryList();
     case "brief":
       return brief();
@@ -6448,11 +6747,14 @@ ${ko.agent.learnTitle}
     return;
   }
   const goalId = activeGoalId();
-  appendLearning(lesson, goalId);
-  console.log(chalk34.green("  \u2705 learnings.md append."));
-  console.log(
-    chalk34.dim("  \uACB0\uC815\uC0AC\uD56D(decision)\uC740 `vhk memory add` \uB85C \uBCC4\uB3C4 \uAE30\uB85D \u2014 SoT \uBD84\uB9AC.")
-  );
+  const entry = recordLesson(process.cwd(), lesson, goalId);
+  if (!entry) {
+    console.log(chalk34.red("  \u274C memory.json \uC190\uC0C1 \uC758\uC2EC \u2014 \uAD50\uD6C8 \uAE30\uB85D \uC911\uB2E8. \uC6D0\uBCF8/\uBC31\uC5C5 \uD655\uC778 \uD6C4 \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uC138\uC694."));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(chalk34.green(`  \u2705 \uAD50\uD6C8 \uAE30\uB85D \u2192 memory failures.lesson (${entry.id})`));
+  console.log(chalk34.dim("  \uAD50\uD6C8\xB7\uACB0\uC815\xB7\uC2E4\uD328\xB7\uC131\uACF5 \uBAA8\uB450 vhk memory (\uB2E8\uC77C SoT). vhk memory list \uB85C \uD655\uC778."));
 }
 async function resume(opts = {}) {
   console.log(chalk34.bold(`
@@ -6700,19 +7002,32 @@ missionCmd.command("clear").description("\uBBF8\uC158 \uACC4\uC57D \uC0AD\uC81C
 program.command("context-show").alias("\uB9E5\uB77D\uBCF4\uAE30").description("\uD604\uC7AC \uCEE8\uD14D\uC2A4\uD2B8 \uD30C\uC77C \uB0B4\uC6A9 \uCD9C\uB825").action(async () => {
   await contextShow();
 });
-var memoryCmd = program.command("memory").alias("\uAE30\uC5B5").description("\uACB0\uC815\uC0AC\uD56D \uAE30\uC5B5 \uAD00\uB9AC (add / list / remove)").action(async () => {
+var memoryCmd = program.command("memory").alias("\uAE30\uC5B5").description("\uAE30\uC5B5 \uAD00\uB9AC v2 (decisions/failures/successes 4\uBC84\uD0B7) \u2014 add/list/remove/archive/resolve/unarchive/migrate").action(async () => {
   await memoryList();
 });
-memoryCmd.command("add <content>").option("--tags <tags>", "\uD0DC\uADF8 (\uC27C\uD45C \uAD6C\uBD84)").description("\uACB0\uC815\uC0AC\uD56D \uAE30\uC5B5 \uC800\uC7A5").action(async (content, opts) => {
+memoryCmd.command("add <content>").option("--type <type>", "\uBC84\uD0B7: decision|failure|success (\uAE30\uBCF8 decision)").option("--tags <tags>", "\uD0DC\uADF8 (\uC27C\uD45C \uAD6C\uBD84)").option("--why <why>", "\uC6D0\uC778 (failure/success)").option("--lesson <lesson>", "\uAD50\uD6C8 (failure)").description("\uAE30\uC5B5 \uC800\uC7A5 (--type \uC73C\uB85C \uACB0\uC815/\uC2E4\uD328/\uC131\uACF5 \uAD6C\uBD84)").action(async (content, opts) => {
   const tags = opts.tags ? opts.tags.split(",").map((s) => s.trim()) : void 0;
-  await memoryAdd(content, tags);
+  await memoryAdd(content, { type: opts.type, tags, why: opts.why, lesson: opts.lesson });
 });
-memoryCmd.command("list").alias("\uBAA9\uB85D").description("\uC800\uC7A5\uB41C \uAE30\uC5B5 \uBAA9\uB85D").action(async () => {
-  await memoryList();
+memoryCmd.command("list").alias("\uBAA9\uB85D").option("--type <type>", "\uBC84\uD0B7 \uD544\uD130: decision|failure|success").option("--all", "\uBCF4\uAD00(archived)\xB7\uD574\uACB0(resolved) \uD3EC\uD568").description("\uC800\uC7A5\uB41C \uAE30\uC5B5 \uBAA9\uB85D (\uAE30\uBCF8 \uD65C\uC131\uB9CC)").action(async (opts) => {
+  const type = opts.type === "decision" || opts.type === "failure" || opts.type === "success" ? opts.type : void 0;
+  await memoryList({ type, all: opts.all });
 });
 memoryCmd.command("remove <index>").alias("\uC0AD\uC81C").description("\uAE30\uC5B5 \uC0AD\uC81C (1\uBD80\uD130 \uC2DC\uC791\uD558\uB294 \uBC88\uD638)").action(async (index) => {
   await memoryRemove(index);
 });
+memoryCmd.command("archive <index>").alias("\uBCF4\uAD00").description("\uAE30\uC5B5 \uBCF4\uAD00 (\uD65C\uC131\u2192archived, \uD328\uD134/\uC9C4\uD654\uC5D0\uC11C \uC81C\uC678)").action(async (index) => {
+  await memoryArchive(index);
+});
+memoryCmd.command("resolve <index>").alias("\uD574\uACB0").description("\uAE30\uC5B5 \uD574\uACB0 \uD45C\uC2DC (\uD65C\uC131\u2192resolved, \uD328\uD134/\uC9C4\uD654\uC5D0\uC11C \uC81C\uC678)").action(async (index) => {
+  await memoryResolve(index);
+});
+memoryCmd.command("unarchive <index>").alias("\uBCF5\uAD6C").description("\uBCF4\uAD00/\uD574\uACB0 \uD56D\uBAA9\uC744 \uB2E4\uC2DC \uD65C\uC131\uC73C\uB85C \uBCF5\uAD6C (archive/resolve \uC5ED\uC804)").action(async (index) => {
+  await memoryUnarchive(index);
+});
+memoryCmd.command("migrate").alias("\uB9C8\uC774\uADF8\uB808\uC774\uC158").description("memory.json v1 \u2192 v2 \uB9C8\uC774\uADF8\uB808\uC774\uC158 (\uAE30\uC874 v1 \uC788\uC73C\uBA74 .v1.bak \uC6D0\uBCF8 \uBC31\uC5C5, \uBA71\uB4F1)").action(async () => {
+  await memoryMigrate();
+});
 program.command("brief").alias("\uBE0C\uB9AC\uD551").description("\uD504\uB85C\uC81D\uD2B8 \uC0C1\uD0DC \uC694\uC57D \uBCF4\uACE0\uC11C \uC0DD\uC131 (.vhk/brief.md)").action(async () => {
   await brief();
 });
@@ -6740,7 +7055,7 @@ goalCmd.command("sync").alias("\uB3D9\uAE30\uD654").description("goals/*.md \uC2
 program.command("blocker <description>").alias("\uBE14\uB85C\uCEE4").description("\uBE14\uB85C\uCEE4 \uAE30\uB85D \u2192 docs/state/blockers.md append (3\uAC74 \uB204\uC801 \uC2DC HARD_STOP \uC790\uB3D9 \uC0DD\uC131)").action(async (description) => {
   await blocker(description);
 });
-program.command("learn <lesson>").alias("\uAD50\uD6C8").description("\uAD50\uD6C8 \uAE30\uB85D \u2192 docs/state/learnings.md append (memory.json \uACFC \uBCC4\uB3C4 SoT)").action(async (lesson) => {
+program.command("learn <lesson>").alias("\uAD50\uD6C8").description("\uAD50\uD6C8 \uAE30\uB85D \u2192 memory v2 failures.lesson \uB2E8\uC77C SoT (v2.0 \uD1B5\uD569 \u2014 vhk memory list \uB85C \uD655\uC778)").action(async (lesson) => {
   await learn(lesson);
 });
 program.command("resume").alias("\uC7AC\uAC1C").option("--confirm", "\uC0AC\uB78C \uD655\uC778 \u2014 \uC790\uB3D9 \uD638\uCD9C \uAE08\uC9C0 (Forbidden \uC704\uBC18)").description(".vhk/HARD_STOP \uD574\uC81C (\uC0AC\uC6A9\uC790\uAC00 \uC0AC\uC720 \uD655\uC778 \uD6C4 --confirm \uD544\uC694)").action(async (opts) => {
@@ -6800,7 +7115,14 @@ program.action(async () => {
       return diff();
   }
 });
-var isMainModule = !!process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+var getRealPath = (p) => {
+  try {
+    return fs13.realpathSync(p);
+  } catch {
+    return p;
+  }
+};
+var isMainModule = !!process.argv[1] && getRealPath(fileURLToPath4(import.meta.url)) === getRealPath(process.argv[1]);
 if (isMainModule) {
   try {
     const nlInput = detectNaturalLanguageInput(process.argv);

package/dist/mcp/index.js

@@ -2,7 +2,7 @@
 import {
   resolveVhkCliInvocation,
   startMcpServer
-} from "../chunk-RXDOM4QT.js";
+} from "../chunk-HCNU6K7D.js";
 
 // src/mcp/index.ts
 var cli = resolveVhkCliInvocation();

package/package.json

@@ -1,72 +1,72 @@
-{
-  "name": "@byh3071/vhk",
-  "version": "1.9.0",
-  "description": "Vibe Harness Kit — AI 코딩 도구·기기를 바꿔도 규칙·맥락이 따라가는 포터빌리티 CLI (sync: Cursor·Claude·Windsurf·Copilot·Antigravity / cloud 백업)",
-  "bin": {
-    "vhk": "dist/index.js",
-    "vhk-mcp": "dist/mcp/index.js"
-  },
-  "type": "module",
-  "scripts": {
-    "dev": "tsx src/index.ts",
-    "build": "tsup",
-    "test": "vitest",
-    "test:run": "vitest --run",
-    "prepublishOnly": "pnpm build && pnpm test:run",
-    "save": "vhk save",
-    "check": "vhk check",
-    "scan": "vhk secure scan",
-    "recap": "vhk recap",
-    "ship": "vhk ship",
-    "doctor": "vhk doctor"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "keywords": [
-    "vibe-coding",
-    "harness",
-    "cli",
-    "scaffold",
-    "session-log",
-    "rules-sync",
-    "portability",
-    "ai-coding",
-    "cursor",
-    "claude",
-    "windsurf",
-    "copilot",
-    "context-sync"
-  ],
-  "author": "byh3071 <byh3071@gmail.com>",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/byh3071-cpu/vhk.git"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@notionhq/client": "^5.22.0",
-    "chalk": "^5.6.2",
-    "commander": "^14.0.3",
-    "handlebars": "^4.7.9",
-    "inquirer": "^9.3.8",
-    "ora": "^9.4.0",
-    "simple-git": "^3.36.0",
-    "zod": "^4.4.3"
-  },
-  "devDependencies": {
-    "@types/inquirer": "^9.0.9",
-    "@types/node": "^25.9.1",
-    "ignore": "^7.0.5",
-    "tsup": "^8.5.1",
-    "tsx": "^4.22.3",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.7"
-  }
-}
+{
+  "name": "@byh3071/vhk",
+  "version": "2.0.2",
+  "description": "Vibe Harness Kit — AI 코딩 도구·기기를 바꿔도 규칙·맥락이 따라가는 포터빌리티 CLI (sync: Cursor·Claude·Windsurf·Copilot·Antigravity / cloud 백업)",
+  "bin": {
+    "vhk": "dist/index.js",
+    "vhk-mcp": "dist/mcp/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup",
+    "test": "vitest",
+    "test:run": "vitest --run",
+    "prepublishOnly": "pnpm build && pnpm test:run",
+    "save": "vhk save",
+    "check": "vhk check",
+    "scan": "vhk secure scan",
+    "recap": "vhk recap",
+    "ship": "vhk ship",
+    "doctor": "vhk doctor"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "vibe-coding",
+    "harness",
+    "cli",
+    "scaffold",
+    "session-log",
+    "rules-sync",
+    "portability",
+    "ai-coding",
+    "cursor",
+    "claude",
+    "windsurf",
+    "copilot",
+    "context-sync"
+  ],
+  "author": "byh3071 <byh3071@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/byh3071-cpu/vhk.git"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@notionhq/client": "^5.22.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "handlebars": "^4.7.9",
+    "inquirer": "^9.3.8",
+    "ora": "^9.4.0",
+    "simple-git": "^3.36.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.9.1",
+    "ignore": "^7.0.5",
+    "tsup": "^8.5.1",
+    "tsx": "^4.22.3",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7"
+  }
+}