rootr-cli 0.13.0 → 0.14.1

package/README.md

@@ -275,9 +275,25 @@ rootr ask "왜 결제 실패가 늘었지?" --workspace ws_123
 워크스페이스의 지식그래프(GraphRAG)에 질문하고 답변 본문 + 인용(문서 경로: 인용문)을 출력합니다.
 `ask` 스코프가 필요합니다. `--workspace`를 생략하면 설정된 기본 워크스페이스를 사용합니다.
 
+### 팀의 기억 (memory)
+
+```bash
+rootr memory                                     # 전체 회상 (상태·id·종류·출처)
+rootr memory --query 세미나 --kind 지시          # 걸러서 보기
+rootr memory add "보고 시각은 KST로만 표기한다" --kind 지시 --source /규칙.md
+rootr memory edit <id> --content "고친 문장"     # 그 기억만 고치기(준 칸만 바뀜)
+rootr memory edit <id> --kind 참고               # 종류만 고치기
+rootr memory forget <id>                         # 폐기(--hard면 행 삭제)
+```
+
+세션이 끝나도 남는, 워크스페이스 전체가 공유하는 한 줄 사실입니다. MCP의
+`rootr_remember`/`rootr_recall`/`rootr_forget`과 같은 길을 터미널에서 쓰는
+명령이고, 화면의 "기억" 메뉴와도 같은 데이터를 봅니다. **긴 건 문서로, 한 줄은
+기억으로** — 자세한 규칙은 MCP 도구 설명을 참고하세요.
+
 ## MCP 서버로 사용하기
 
-`rootr mcp`는 stdio로 MCP(Model Context Protocol) 서버를 구동합니다. 제공 도구 151종:
+`rootr mcp`는 stdio로 MCP(Model Context Protocol) 서버를 구동합니다. 제공 도구 152종:
 
 노드를 가리키는 인자(`target`, `databaseId`, `spreadsheetId`, `formId`, `crmId`, `trackerId`,
 `recordingId`, `presentationId`, `whiteboardId`, `logId`, `parentId` 등)는 **노드 id와 경로를 모두**
@@ -324,6 +340,7 @@ rootr ask "왜 결제 실패가 늘었지?" --workspace ws_123
 | `rootr_scaffold_review` | 워크스페이스 불필요 | 짓기 2단계 — **만들기 전에** 설계를 검사받는다(점수·고칠 곳). 컴파일러처럼 고쳐 가며 짓는다 |
 | `rootr_create_workspace` | **계정 키(PAT) + workspaces:create** | 짓기 3단계 — 계획된 트리로 새 워크스페이스 생성(검사 결과도 같이 돌려준다) |
 | `rootr_scaffold_apply` | docs:write | 짓기 3단계 — 기존 워크스페이스에 트리 적용(검사 결과도 같이 돌려준다) |
+| `rootr_delete_workspace` | **계정 키(PAT) + OWNER** | 짓다 실패해 남은 **빈 워크스페이스 치우기**. 이름을 그대로 다시 적어야 지워진다(되돌릴 수 없음) |
 
 스캐폴딩은 **plan → 물어보기 → 설계 → review → 고치기 → apply** 한 바퀴입니다.
 `review` 를 건너뛰면 "얇은 마크다운 파일 묶음"이 됩니다. CLI 로도 같은 세 단계를 쓸 수 있습니다:
@@ -369,7 +386,7 @@ rootr ask "왜 결제 실패가 늘었지?" --workspace ws_123
 | 도구 | 설명 |
 |---|---|
 | `rootr_read_database` | 스키마(열 정의)+행 전체 읽기 — **다른 표 도구를 쓰기 전에 먼저** (`includeBody: true` 면 행마다 상세 내용까지) |
-| `rootr_list_rows` | 행만 조회(스키마 제외, `includeBody` 지원) |
+| `rootr_list_rows` | 행만 조회(스키마 제외, `includeBody` 지원, `backlinks: true`면 "나를 가리키는 다른 표의 행"도 함께) |
 | `rootr_add_row` | 행 추가 (`values`는 열 이름 또는 id로 지정, `body`로 상세 내용까지) |
 | `rootr_update_row` | 행 수정 (칸반 카드 이동 = select 열 값 변경, `body`로 상세 내용 교체) |
 | `rootr_bulk_create_rows` | 행 여러 개를 한 번에 추가 |
@@ -526,6 +543,28 @@ rootr ask "왜 결제 실패가 늘었지?" --workspace ws_123
 | `rootr_save_as_template` | 지금 노드를(또는 즉석 정의를) 템플릿으로 저장 |
 | `rootr_update_template` | 템플릿 수정 |
 
+#### 기억 (docs:read / docs:write)
+
+| 도구 | 설명 |
+|---|---|
+| `rootr_remember` | 한 줄 사실을 기억시키기(같은 내용이면 갈아끼움). `memoryId`를 함께 주면 그 기억을 그 자리에서 고치기 |
+| `rootr_recall` | 이 워크스페이스가 아는 것 꺼내 오기 |
+| `rootr_forget` | 더 이상 맞지 않는 기억 폐기 |
+
+**에이전트에게**: 이건 세션이 끝나도 남는, **워크스페이스 전체가 공유하는** 기억입니다
+(개인 메모는 여기 두지 말고 자기 메모리에 두세요). **긴 건 문서로, 한 줄은
+기억으로, 그리고 기억은 반드시 문서를 가리키게** 하세요 — 이야기를 기억에 밀어
+넣으면 기억이 "짧은 문서 더미"가 되면서 둘 다 망합니다. 규칙·결정한 이유·한 번
+겪은 함정을 남기고, 그 근거가 된 문서 경로를 `source`로 같이 주세요(그래야 그
+문서가 바뀔 때 루터가 "확인 필요" 표시를 답니다).
+
+기억은 워크스페이스를 처음 만질 때 **도구 응답에 자동으로 딸려옵니다** — 굳이
+`rootr_recall`을 먼저 부르지 않아도 눈앞에 놓입니다. 이 자동 회상은 무료 조회
+한도를 쓰지 않습니다.
+
+사람이 직접 보고 고치려면 워크스페이스 왼쪽 메뉴의 **기억**에서 볼 수 있고,
+"표로 열기"를 누르면 평범한 표로 열려 권한·기록이 그대로 따라옵니다.
+
 #### 제보 (인증 불필요)
 
 | 도구 | 설명 |
@@ -579,6 +618,8 @@ rootr ask "왜 결제 실패가 늘었지?" --workspace ws_123
 | 도구 | 설명 |
 |---|---|
 | `rootr_document_versions` | 문서 버전 히스토리 조회 |
+| `rootr_read_document_version` | 그 시점 본문을 그대로 읽기(되돌리기 전에 확인용) |
+| `rootr_restore_document_version` | 문서를 예전 버전으로 되돌리기 |
 | `rootr_update_node` | 아무 노드나 이름·아이콘 변경 / 옮기기 |
 | `rootr_delete_node` | 노드를 휴지통으로 이동(복구 가능) |
 

package/bin/rootr.js

@@ -28,7 +28,7 @@ const USAGE = `Rootr CLI v${pkg.version}
   rootr use <id|이름|주소>                          활성 워크스페이스 전환 (그 워크스페이스용 키도 기억)
   rootr ask <question> [--workspace <w>]           GraphRAG 질의응답 (RCA), 인용 포함 출력
   rootr db create [--file <spec.json>] [--parent <path|id>]  표(DATABASE) 생성 — 컬럼 순서 그대로, 행까지 한 번에
-  rootr db rows <path|id> [--body] [--json]        표의 행 목록 (--body: 상세 내용까지)
+  rootr db rows <path|id> [--body] [--backlinks] [--json]        표의 행 목록 (--body: 상세 내용까지, --backlinks: 나를 가리키는 다른 표의 행까지)
   rootr db lock <path|id> [--schema managers] [--rows own] [--locked "승인,점수"]  표 자물쇠 보기·걸기
   rootr db notify <path|id> [--file rules.json] [--clear]  표 알림 규칙 보기·저장
   rootr db row-add <path|id> --values '<json>' [--body <md>|--body-file <f>]  행 추가(상세 내용 포함)
@@ -82,6 +82,10 @@ const USAGE = `Rootr CLI v${pkg.version}
   rootr scaffold apply --file tree.json [--root /경로]  짓기 3단계 — 실제로 만들기(검사 결과도 같이 나옴)
   rootr scaffold built [--root /경로] [--json]      짓고 나서 — 실제로 만들어진 것의 **모양**을 검사
   rootr scaffold test [--root /경로] [--json]       짓고 나서 — 실제로 **돌려 본다**(관계·롤업·수식·폼·시트). 실패 시 exit 1
+  rootr memory [--query <q>] [--kind <k>] [--json]  팀의 기억 회상 — AI 에이전트가 읽는 같은 목록
+  rootr memory add "<내용>" [--kind 지시|사람|프로젝트|참고] [--source <경로|id>] [--related a,b]  기억 저장
+  rootr memory edit <id> [--content "<내용>"] [--kind …] [--source …] [--related a,b]  기억 고치기(준 칸만)
+  rootr memory forget <id> [--hard]                 기억 폐기(--hard면 행 삭제)
   rootr mcp                                        MCP stdio 서버 구동 (도구 151종 — README 참고)
   rootr --help                                     도움말
   rootr --version                                  버전 출력
@@ -567,6 +571,93 @@ async function cmdMcp() {
   await startMcpServer({ name: 'rootr', version: pkg.version });
 }
 
+// ---- memory (MEM-001) ---------------------------------------------------
+//
+// 팀의 기억 — 저장·회상·고치기·잊기. MCP의 rootr_remember/recall/forget과 같은 길을
+// 터미널에서도 쓸 수 있게. 고치기(edit)는 2026-09-01에 붙었다.
+
+const MEMORY_KINDS = ['지시', '사람', '프로젝트', '참고'];
+
+function parseRelated(val) {
+  if (!val) return undefined;
+  if (Array.isArray(val)) return val;
+  return String(val)
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+async function cmdMemory(args) {
+  const sub = args._.shift();
+  const client = makeClient();
+
+  if (!sub || sub === 'ls' || sub === 'list') {
+    const result = await client.recall({ query: args.query, kind: args.kind, limit: args.limit });
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (!result.memories.length) {
+      console.log('아직 기억이 없습니다. rootr memory add "한 줄 사실" 으로 남겨 보세요.');
+      return;
+    }
+    for (const m of result.memories) {
+      const when = String(m.updatedAt ?? '').slice(0, 10);
+      console.log(`- [${m.status}] ${m.content}`);
+      console.log(`  ${m.id} · ${m.kind}${m.source ? ` · ${m.source}` : ''} · ${when}`);
+    }
+    return;
+  }
+
+  if (sub === 'add') {
+    const content = args._.join(' ');
+    if (!content) throw new Error('사용법: rootr memory add "<내용>" [--kind 지시|사람|프로젝트|참고] [--source <경로|id>] [--related a,b]');
+    if (args.kind && !MEMORY_KINDS.includes(args.kind)) {
+      throw new Error(`종류는 ${MEMORY_KINDS.join('/')} 중 하나여야 합니다: ${args.kind}`);
+    }
+    const result = await client.remember({
+      content,
+      kind: args.kind,
+      source: args.source,
+      related: parseRelated(args.related),
+    });
+    console.log(`${result.replaced ? '기억을 갈아끼웠습니다' : '기억했습니다'}: ${result.memory.content}`);
+    console.log(`id: ${result.memory.id} · 상태: ${result.memory.status}`);
+    return;
+  }
+
+  if (sub === 'edit') {
+    const id = args._[0];
+    if (!id) throw new Error('사용법: rootr memory edit <id> [--content "<내용>"] [--kind …] [--source …] [--related a,b]');
+    const content = args._.slice(1).join(' ') || args.content;
+    if (!content && !args.kind && !args.source && !args.related) {
+      throw new Error('고칠 칸이 하나도 없습니다 — --content/--kind/--source/--related 중 하나는 주어야 합니다.');
+    }
+    if (args.kind && !MEMORY_KINDS.includes(args.kind)) {
+      throw new Error(`종류는 ${MEMORY_KINDS.join('/')} 중 하나여야 합니다: ${args.kind}`);
+    }
+    const result = await client.revise(id, {
+      ...(content ? { content } : {}),
+      ...(args.kind ? { kind: args.kind } : {}),
+      ...(args.source !== undefined ? { source: args.source } : {}),
+      ...(args.related !== undefined ? { related: parseRelated(args.related) } : {}),
+    });
+    console.log(`고쳤습니다: ${result.content}`);
+    console.log(`상태: ${result.status}${result.mergedIds?.length ? ` · 같은 사실 ${result.mergedIds.length}건을 폐기로 내렸습니다` : ''}`);
+    return;
+  }
+
+  if (sub === 'forget') {
+    const id = args._[0];
+    if (!id) throw new Error('사용법: rootr memory forget <id> [--hard]');
+    await client.forget(id, { hard: args.hard === true });
+    console.log(args.hard ? '기억을 지웠습니다.' : '기억을 폐기 상태로 내렸습니다.');
+    return;
+  }
+
+  throw new Error(`알 수 없는 하위명령: ${sub}\n사용법: rootr memory [ls|add|edit|forget] …`);
+}
+
 // ---- entry ------------------------------------------------------------
 
 
@@ -1301,10 +1392,10 @@ async function cmdDbNotify(args) {
 
 async function cmdDbRows(args) {
   const target = args._[1];
-  if (!target) throw new Error('사용법: rootr db rows <path|id> [--body] [--json]');
+  if (!target) throw new Error('사용법: rootr db rows <path|id> [--body] [--backlinks] [--json]');
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
-  const rows = await client.listRows(id, { withBody: !!args.body });
+  const rows = await client.listRows(id, { withBody: !!args.body, backlinks: !!args.backlinks });
   if (args.json) {
     console.log(JSON.stringify(rows, null, 2));
     return;
@@ -1317,6 +1408,12 @@ async function cmdDbRows(args) {
     if (args.body && row.body) {
       for (const line of String(row.body).trimEnd().split('\n')) console.log(`    ${line}`);
     }
+    // BACKLINK — "나를 가리키는 다른 표의 행" 목록(있을 때만 표시).
+    if (args.backlinks && row.backlinks && Object.keys(row.backlinks).length) {
+      for (const [refDbId, group] of Object.entries(row.backlinks)) {
+        console.log(`    ← ${refDbId} (${group.propName}): ${group.rowIds.join(', ')}`);
+      }
+    }
   }
 }
 
@@ -1750,6 +1847,8 @@ async function main() {
       return cmdFeedback(args);
     case 'scaffold':
       return cmdScaffold(args);
+    case 'memory':
+      return cmdMemory(args);
     case 'mcp':
       return cmdMcp(args);
     default:

package/lib/client.js

@@ -322,6 +322,29 @@ export class RootrClient {
     return this.request(`/documents/${encodeURIComponent(id)}/versions${qs}`);
   }
 
+  /** 특정 버전의 본문을 그대로 읽는다(되돌리기 전에 무엇이 들었는지 확인용). */
+  async getDocumentVersion(id, versionId) {
+    return this.request(
+      `/documents/${encodeURIComponent(id)}/versions/${encodeURIComponent(versionId)}`,
+    );
+  }
+
+  /**
+   * DOC-RESTORE — **문서를 예전 버전으로 되돌린다.**
+   *
+   * 예전에는 목록 조회(getDocumentVersions)만 있고 되돌리는 문이 없었다. 그래서
+   * AI가 잘못 덮어써 내용이 통째로 날아가도 "되돌려 달라"는 부탁을 아무도 수행할
+   * 수 없었다 — 고객이 실제로 겪었다(2026-08-31 에이랩스 피드백: 일간 업무 일지
+   * 취합 문서의 대부분이 사라졌는데 AI가 복구하지 못함). 버전은 서버에 이미 다
+   * 쌓여 있었고, 부를 방법만 없었다.
+   */
+  async restoreDocumentVersion(id, versionId) {
+    return this.request(
+      `/documents/${encodeURIComponent(id)}/versions/${encodeURIComponent(versionId)}/restore`,
+      { method: 'POST' },
+    );
+  }
+
   /** Move a node to the trash (recoverable). */
   async deleteNode(id) {
     return this.request(`/nodes/${encodeURIComponent(id)}`, { method: 'DELETE' });
@@ -480,6 +503,23 @@ export class RootrClient {
     });
   }
 
+  /**
+   * WS-CLEANUP — **자기가 만든 잔해를 자기가 치울 수 있게.**
+   *
+   * 짓다가 실패하면 빈 워크스페이스가 남는데, 지우는 문이 없어서 에이전트가
+   * 치우지 못했다. 무료 한도가 5개라 몇 번 실패하면 사용자가 바로 막힌다
+   * (2026-08-30 실측: 치과 3개·아파트 4개가 잔해로 남음).
+   *
+   * 이름을 그대로 다시 적게 하는 것은 서버가 요구하는 안전장치다 — 지울 것을
+   * 정말 보고 있는지 확인한다.
+   */
+  async deleteWorkspace({ workspaceId, confirmName }) {
+    return this.request(`/workspaces/${workspaceId}`, {
+      method: 'DELETE',
+      body: { confirmName },
+    });
+  }
+
   /**
    * Check a designed tree BEFORE building it — the compiler pass of scaffolding.
    * Needs no workspace, creates nothing. Returns { score, counts, findings, summary }.
@@ -779,9 +819,15 @@ export class RootrClient {
   /**
    * All rows of a database, in position order. Returns the raw rows array.
    * DB-BODY — `withBody` 를 주면 행마다 상세 내용(본문 메모)까지 함께 온다.
+   * BACKLINK — `backlinks` 를 주면 각 행에 "나를 가리키는 다른 표의 행" 정보
+   * (`{ [referrerDatabaseId]: { propName, rowIds } }`)가 함께 붙는다. 기본은 꺼져
+   * 있다(필드 자체가 없다).
    */
-  async listRows(databaseId, { withBody = false } = {}) {
-    const query = withBody ? '?body=1' : '';
+  async listRows(databaseId, { withBody = false, backlinks = false } = {}) {
+    const params = [];
+    if (withBody) params.push('body=1');
+    if (backlinks) params.push('backlinks=1');
+    const query = params.length ? `?${params.join('&')}` : '';
     const data = await this.request(`/databases/${encodeURIComponent(databaseId)}/rows${query}`);
     if (Array.isArray(data)) return data;
     if (data && Array.isArray(data.rows)) return data.rows;
@@ -1627,4 +1673,48 @@ export class RootrClient {
     }
     return data;
   }
+
+  // ── MEM-001 에이전트 메모리 ────────────────────────────────────────────────
+  //
+  // 판단은 부르는 쪽 클로드가 한다. 저장·회상·고치기·잊기 네 문을 연다.
+
+  /** 기억한다(워크스페이스 공유). 같은 기억이 있으면 서버가 갈아끼운다(replaced=true). */
+  async remember(body) {
+    return this.request(`/workspaces/${encodeURIComponent(this.workspace)}/memories`, {
+      method: 'POST',
+      body,
+    });
+  }
+
+  /** 꺼내 온다. 인자가 없으면 이 워크스페이스의 기억 전부. */
+  async recall({ query, kind, limit } = {}) {
+    const qs = new URLSearchParams();
+    if (query) qs.set('query', query);
+    if (kind) qs.set('kind', kind);
+    if (limit) qs.set('limit', String(limit));
+    const tail = qs.toString() ? `?${qs}` : '';
+    return this.request(`/workspaces/${encodeURIComponent(this.workspace)}/memories${tail}`);
+  }
+
+  /**
+   * 고친다(2026-09-01) — id로 짚은 기억의 내용·종류·출처·관련을 바꾼다.
+   * 생략한 칸은 안 바뀌고, 내용이 바뀌면 상태가 '유효'로 되돌아온다.
+   * 화면이 같은 길을 쓴다.
+   */
+  async revise(memoryId, body) {
+    return this.request(
+      `/workspaces/${encodeURIComponent(this.workspace)}/memories/${encodeURIComponent(memoryId)}`,
+      { method: 'PATCH', body },
+    );
+  }
+
+  /** 잊는다. 기본은 `폐기`로 내리기 — `hard`면 행을 실제로 지운다. */
+  async forget(memoryId, { hard } = {}) {
+    const tail = hard ? '?hard=true' : '';
+    return this.request(
+      `/workspaces/${encodeURIComponent(this.workspace)}/memories/${encodeURIComponent(memoryId)}${tail}`,
+      { method: 'DELETE' },
+    );
+  }
+
 }

package/lib/mcp-tools/databases.js

@@ -430,13 +430,21 @@ export function registerDatabaseTools(server) {
           .boolean()
           .optional()
           .describe("true → also return each row's detail body (the note under a card). Off by default."),
+        backlinks: z
+          .boolean()
+          .optional()
+          .describe(
+            'true → also return each row\'s backlinks: other databases whose relation column points at ' +
+              'this row, as `{ [referrerDatabaseId]: { propName, rowIds } }`. Off by default (no field at all).',
+          ),
       },
     },
-    async ({ databaseId, includeBody }) => {
+    async ({ databaseId, includeBody, backlinks }) => {
       try {
         const client = makeClient();
         const rows = await client.listRows(await resolveNodeId(client, databaseId), {
           withBody: includeBody === true,
+          backlinks: backlinks === true,
         });
         return jsonResult({ rows });
       } catch (err) {

package/lib/mcp-tools/issues.js

@@ -148,8 +148,9 @@ export function registerIssueTools(server) {
     {
       title: 'Comment on an issue',
       description:
-        'Add a comment to a Rootr (루터) issue within its tracker. Comments carry a user identity, ' +
-        'so this requires an ACCOUNT key (PAT) as ROOTR_API_KEY — a workspace key gets a 403.',
+        'Add a comment to a Rootr (루터) issue within its tracker. Comments carry a user identity: ' +
+        'the comment is posted as the person the ROOTR_API_KEY belongs to. Both an account key (PAT) and a ' +
+        'workspace key work, since a workspace key is bound to the member who minted it.',
       annotations: { readOnlyHint: false, destructiveHint: false },
       inputSchema: {
         trackerId: z.string().describe(`Issue tracker node id${NODE_TARGET_HINT}`),

package/lib/mcp-tools/memory.js

@@ -0,0 +1,185 @@
+import { z } from 'zod';
+
+import { jsonResult, textResult, errorResult, makeClient } from './shared.js';
+
+/**
+ * MEM-001 — 에이전트 메모리.
+ *
+ * 기술적으로는 `rootr_add_row`/`rootr_list_rows`로도 되는 일이다. 그런데도 도구를
+ * 따로 파는 이유는 하나다 — **이름이 "기억하기"여야 클로드가 자기 메모리로 인식하고
+ * 쓴다.** "표에 행 추가"로는 아무도 안 부른다(계획서 §3.2).
+ *
+ * 경계 규칙을 도구 설명에 그대로 박아 둔다. 안 그러면 메모리가 "짧은 문서 더미"가
+ * 되면서 문서와 메모리 둘 다 망한다:
+ *
+ *   긴 건 문서로, 한 줄은 메모리로, 그리고 메모리는 반드시 문서를 가리킬 것.
+ */
+export function registerMemoryTools(server) {
+  server.registerTool(
+    'rootr_remember',
+    {
+      title: 'Remember a durable fact for this workspace',
+      description:
+        'Save ONE short, present-tense fact that should change how you act next time in this Rootr (루터) ' +
+        'workspace — a team convention, a decision and its reason, a gotcha you just hit, a person\'s ' +
+        'preference. Memories are SHARED WITH THE WHOLE WORKSPACE, so everyone\'s assistant learns it too. ' +
+        'Keep personal notes in your own memory, not here.\n\n' +
+        'THE RULE: long things go in documents, one-liners go in memory, and a memory should point at a ' +
+        'document. Save the lesson ("captures must run in the parent window with data URIs"), not the ' +
+        'story — write the story as a document and pass its path as `source`.\n\n' +
+        'Always pass `source` when the fact came from a document: that is what lets Rootr flag the memory ' +
+        'as "needs checking" when that document changes. A memory with no source can never notice it went ' +
+        'stale.\n\n' +
+        'Saving the same fact twice is safe — Rootr replaces it instead of piling up duplicates.\n\n' +
+        'EDITING: pass `memoryId` (the `id` from rootr_recall) to fix that exact memory in place — ' +
+        'omit it to save a new one. Editing marks the memory 유효 again (a person or their assistant ' +
+        'just re-confirmed it).',
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+      inputSchema: {
+        memoryId: z
+          .string()
+          .optional()
+          .describe(
+            'EDIT an existing memory instead of saving a new one — the `id` from rootr_recall. ' +
+              'Only the fields you pass change; content edits set the status back to 유효.',
+          ),
+        content: z
+          .string()
+          .max(500)
+          .optional()
+          .describe(
+            'The fact, as one present-tense line. Not a summary of a conversation — something that changes ' +
+              'what you do next time. Required for a new memory; may be omitted with `memoryId` to edit ' +
+              'only kind/source/related.',
+          ),
+        kind: z
+          .enum(['지시', '사람', '프로젝트', '참고'])
+          .optional()
+          .describe(
+            'What kind of fact: 지시 = how the team wants work done, 사람 = someone\'s role/preference, ' +
+              '프로젝트 = ongoing work or constraints, 참고 = a pointer to an external resource',
+          ),
+        source: z
+          .string()
+          .optional()
+          .describe(
+            'Where this came from: a document path starting with "/", or a node id. Strongly recommended — ' +
+              'this is what makes the memory notice when it goes stale.',
+          ),
+        related: z
+          .array(z.string())
+          .optional()
+          .describe('What this memory is about — people, systems, customers. Used to group memories later.'),
+        workspace: z
+          .string()
+          .optional()
+          .describe('Workspace id; defaults to ROOTR_WORKSPACE/config if omitted'),
+      },
+    },
+    async ({ memoryId, content, kind, source, related, workspace }) => {
+      try {
+        const client = makeClient(workspace);
+        // memoryId가 왔으면 고치기, 없으면 새로 저장 — 같은 도구의 두 문.
+        if (memoryId) {
+          const result = await client.revise(memoryId, { content, kind, source, related });
+          const merged = result.mergedIds?.length
+            ? `\n같은 사실이 다른 기억(${result.mergedIds.length}건)에도 있어 폐기로 내렸습니다 — 목록은 그 행 하나뿐입니다.`
+            : '';
+          return textResult(
+            `고쳤습니다: ${result.content}\n상태: ${result.status}` +
+              (result.source ? ` · 출처: ${result.source}` : '') +
+              merged,
+          );
+        }
+        const result = await client.remember({ content, kind, source, related });
+        return textResult(
+          `${result.replaced ? '기억을 갈아끼웠습니다' : '기억했습니다'}: ${result.memory.content}\n` +
+            `상태: ${result.memory.status}` +
+            (result.memory.source ? ` · 출처: ${result.memory.source}` : '') +
+            (result.memory.sourceId
+              ? ''
+              : '\n(출처가 연결되지 않았습니다 — 이 기억은 나중에 낡아도 스스로 알아채지 못합니다.)'),
+        );
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_recall',
+    {
+      title: 'Recall what this workspace already knows',
+      description:
+        'Read the durable facts this Rootr (루터) workspace has learned — team conventions, decisions and ' +
+        'their reasons, gotchas, people\'s preferences. Call this before you start real work in a ' +
+        'workspace, and whenever you are about to make an assumption someone may have already settled.\n\n' +
+        'Memories marked 확인필요 mean their source document changed — treat them as "was true, verify ' +
+        'before relying on it".',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        query: z
+          .string()
+          .optional()
+          .describe('Optional keyword filter. Omit to get everything — the list is meant to be read whole.'),
+        kind: z.enum(['지시', '사람', '프로젝트', '참고']).optional().describe('Only this kind'),
+        limit: z.number().optional().describe('Max memories to return'),
+        workspace: z
+          .string()
+          .optional()
+          .describe('Workspace id; defaults to ROOTR_WORKSPACE/config if omitted'),
+      },
+    },
+    async ({ query, kind, limit, workspace }) => {
+      try {
+        const client = makeClient(workspace);
+        const result = await client.recall({ query, kind, limit });
+        if (!result.memories?.length) {
+          return textResult(
+            '아직 기억이 없습니다.\n' +
+              'rootr_remember로 팀 규칙·결정·함정을 한 줄씩 남겨 두면, 다음 세션의 클로드가 그걸 읽고 시작합니다.',
+          );
+        }
+        return jsonResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_forget',
+    {
+      title: 'Retire a memory that is no longer true',
+      description:
+        'Mark a memory as 폐기 (retired) — use this when a fact stopped being true, not when you merely ' +
+        'disagree with it. Memory is meant to be pruned: a workspace with 500 stale memories is worse than ' +
+        'one with 50 true ones.\n\n' +
+        'Retiring keeps the row so the team can still see what used to be true and why it changed. Pass ' +
+        '`hard` only when the memory should never have been saved (wrong workspace, personal data that ' +
+        'does not belong in a shared workspace).\n\n' +
+        'If a fact merely CHANGED, call rootr_remember with the new wording instead — that replaces it.',
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
+      inputSchema: {
+        memoryId: z.string().describe('Memory id (the `id` from rootr_recall)'),
+        hard: z
+          .boolean()
+          .optional()
+          .describe('Delete the row outright instead of retiring it. Rarely right.'),
+        workspace: z
+          .string()
+          .optional()
+          .describe('Workspace id; defaults to ROOTR_WORKSPACE/config if omitted'),
+      },
+    },
+    async ({ memoryId, hard, workspace }) => {
+      try {
+        const client = makeClient(workspace);
+        const result = await client.forget(memoryId, { hard });
+        return textResult(result.removed ? '기억을 지웠습니다.' : '기억을 폐기 상태로 내렸습니다.');
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+}

package/lib/mcp-tools/misc.js

@@ -31,6 +31,65 @@ export function registerMiscTools(server) {
     },
   );
 
+  /**
+   * DOC-RESTORE — **되돌리기.** 목록만 있고 되돌리는 문이 없어서, AI가 잘못
+   * 덮어써 내용이 날아가도 아무도 복구할 수 없었다(2026-08-31 에이랩스 피드백:
+   * "AI에게 이전 버전으로 돌려달라고 했지만 불가능"). 버전은 서버에 이미 쌓여
+   * 있었고, 부를 방법만 없었다.
+   */
+  server.registerTool(
+    'rootr_read_document_version',
+    {
+      title: 'Read one saved version of a document',
+      description:
+        'Read the full saved body of ONE past version of a Rootr (루터) document. Use this before ' +
+        'rootr_restore_document_version to confirm the version actually holds the content the user wants back — ' +
+        'restoring is a write, so look first. Get version ids from rootr_document_versions.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        target: z.string().describe('Document path (starting with "/") or node id'),
+        versionId: z.string().describe('Version id from rootr_document_versions'),
+      },
+    },
+    async ({ target, versionId }) => {
+      try {
+        const client = makeClient();
+        const id = requireResolved(await resolveTarget(client, target));
+        return jsonResult(await client.getDocumentVersion(id, versionId));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_restore_document_version',
+    {
+      title: 'Restore a document to an earlier version',
+      description:
+        'Roll a Rootr (루터) document back to one of its saved versions — the recovery path when an edit ' +
+        '(yours or anyone else\'s) destroyed content. WORKFLOW: rootr_document_versions to list, ' +
+        'rootr_read_document_version to confirm the right one, then restore. The current body is itself saved ' +
+        'as a new version first, so restoring is reversible — but it DOES overwrite what is there now, so ' +
+        'never guess at the version id. If the user says "undo what you just did" or "bring back the old ' +
+        'content", this is the tool.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        target: z.string().describe('Document path (starting with "/") or node id'),
+        versionId: z.string().describe('Version id to restore, from rootr_document_versions'),
+      },
+    },
+    async ({ target, versionId }) => {
+      try {
+        const client = makeClient();
+        const id = requireResolved(await resolveTarget(client, target));
+        return jsonResult(await client.restoreDocumentVersion(id, versionId));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
   server.registerTool(
     'rootr_update_node',
     {

package/lib/mcp-tools/workspaces.js

@@ -223,6 +223,46 @@ export function registerWorkspaceTools(server) {
     },
   );
 
+  /**
+   * WS-CLEANUP — **짓다 실패해서 남은 빈 워크스페이스를 에이전트가 치울 수 있게.**
+   *
+   * 스캐폴딩이 중간에 실패하면 껍데기만 남는데 지우는 문이 없었다. 무료 한도가
+   * 5개라 몇 번 실패하면 사용자가 바로 막히고, 그 잔해를 사람이 화면에서 하나씩
+   * 지워야 했다(2026-08-30 실측: 치과 3개·아파트 4개).
+   *
+   * 이름을 그대로 다시 적게 한다 — 서버가 요구하는 안전장치이자, 모델이 엉뚱한
+   * 워크스페이스를 지목했을 때 걸리는 그물이다.
+   */
+  server.registerTool(
+    'rootr_delete_workspace',
+    {
+      title: 'Delete a workspace you created (cleanup after a failed scaffold)',
+      description:
+        'Permanently delete a Rootr (루터) workspace. Intended for cleaning up EMPTY leftovers from a scaffold ' +
+        'run that failed halfway — the free plan allows only a handful of workspaces, so abandoned shells block ' +
+        'the user from trying again. Requires OWNER on that workspace, and you must pass `confirmName` exactly ' +
+        'matching the workspace name (call rootr_workspaces first to read it). THIS CANNOT BE UNDONE: everything ' +
+        'inside is removed. Never call this on a workspace that holds the user\'s real work — if you did not ' +
+        'create it in this session, ask the user first.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        workspaceId: z.string().describe('Id of the workspace to delete'),
+        confirmName: z
+          .string()
+          .describe('The workspace name, typed again exactly — the server rejects the call if it does not match'),
+      },
+    },
+    async ({ workspaceId, confirmName }) => {
+      try {
+        const client = makeClient();
+        await client.deleteWorkspace({ workspaceId, confirmName });
+        return jsonResult({ deleted: true, workspaceId });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
   server.registerTool(
     'rootr_scaffold_review',
     {

package/lib/mcp.js

@@ -20,7 +20,9 @@ import { registerRecordingTools } from './mcp-tools/recordings.js';
 import { registerAttachmentTools } from './mcp-tools/attachments.js';
 import { registerSignedDocTools } from './mcp-tools/signed.js';
 import { registerFeedbackTools } from './mcp-tools/feedback.js';
+import { registerMemoryTools } from './mcp-tools/memory.js';
 import { withRateLimitSink } from './context.js';
+import { makeClient } from './mcp-tools/shared.js';
 
 /** Warn once the workspace has burned this share of its quota. */
 const QUOTA_WARN_AT = 0.8;
@@ -63,6 +65,88 @@ function withQuotaWarnings(server) {
   return server;
 }
 
+
+/**
+ * MEM-001 — **기억을 눈앞에 놓는다. 이 기능의 성패가 여기 달렸다.**
+ *
+ * 도구만 만들어 두면 클로드는 안 부른다. 이미 두 번 겪었다 — 고객센터에서
+ * 프롬프트로 "어려우면 넘겨라"라고 시켰는데 말만 하고 도구를 안 불러 티켓이 0건이던
+ * 일, 어시스턴트 답변 언어를 결국 코드로 강제해야 했던 일. **프롬프트로 시킨 건
+ * 안 지켜진다.**
+ *
+ * 그래서 회상을 클로드의 선의에 맡기지 않는다. 이 워크스페이스에서 **첫 도구를
+ * 부르는 순간** 응답 꼬리에 기억 목록을 통째로 실어 보낸다(무료 한도 안내를 얹는
+ * 바로 그 자리 — 클로드가 반드시 읽는 곳이다).
+ *
+ * 한 번만 얹는다. 매 응답마다 붙이면 대화가 길어질수록 같은 목록이 수십 번 쌓여
+ * 컨텍스트를 잡아먹고, 그러면 오히려 안 읽는다.
+ *
+ * ★ 이 자동 회상은 무료 하루 한도에 안 든다 — 서버 쪽 회상 엔드포인트에
+ * `@NotRateLimited()`가 걸려 있다(memory.controller.ts). 사용자가 시키지도 않은
+ * 호출로 한도가 닳으면 쓰지도 않았는데 막히는 꼴이 되기 때문이다.
+ */
+const memoryPrimed = new Set();
+
+/** 기억 목록을 클로드가 읽을 한 덩어리 글로 만든다. */
+function memoryBriefing(memories) {
+  if (!memories?.length) return null;
+  const live = memories.filter((m) => m.status !== '폐기');
+  if (!live.length) return null;
+  const line = (m) => {
+    const flags = [];
+    if (m.status === '확인필요') flags.push('확인필요');
+    const tail = flags.length ? ` [${flags.join('·')}]` : '';
+    const src = m.source ? ` (출처: ${m.source})` : '';
+    return `- ${m.content}${tail}${src}`;
+  };
+  return (
+    `\n\n---\n🧠 이 워크스페이스가 이미 아는 것 (${live.length}건) — 일을 시작하기 전에 읽으세요.\n` +
+    live.map(line).join('\n') +
+    `\n"확인필요"는 출처 문서가 바뀌었다는 뜻입니다 — 맞는지 확인하고 쓰세요.\n` +
+    `새로 알게 된 규칙·결정·함정이 있으면 rootr_remember로 한 줄 남겨 두세요.`
+  );
+}
+
+function withMemoryRecall(server) {
+  const original = server.registerTool.bind(server);
+  server.registerTool = (name, spec, handler) =>
+    original(name, spec, async (...args) => {
+      const result = await handler(...args);
+      // 기억 도구 자신에게 기억을 얹으면 같은 목록이 두 번 나온다.
+      if (name === 'rootr_recall' || name === 'rootr_remember' || name === 'rootr_forget') return result;
+      if (!result || result.isError || !Array.isArray(result.content)) return result;
+
+      let client;
+      try {
+        client = makeClient(args?.[0]?.workspace);
+      } catch {
+        return result; // 워크스페이스가 안 정해진 도구(설정·워크스페이스 목록 등)
+      }
+      const ws = client.workspace;
+      if (!ws || memoryPrimed.has(ws)) return result;
+      memoryPrimed.add(ws);
+
+      let briefing = null;
+      try {
+        // 한도 제외는 서버가 건다(@NotRateLimited). 여기서는 그냥 부르면 된다.
+        const recalled = await client.recall({ limit: 200 });
+        briefing = memoryBriefing(recalled?.memories);
+      } catch {
+        // 기억을 못 읽는다고 원래 하던 일이 실패하면 안 된다. 조용히 넘어간다.
+        return result;
+      }
+      if (!briefing) return result;
+
+      const last = [...result.content].reverse().find((c) => c && c.type === 'text');
+      if (!last) return result;
+      return {
+        ...result,
+        content: result.content.map((c) => (c === last ? { ...c, text: `${c.text}${briefing}` } : c)),
+      };
+    });
+  return server;
+}
+
 /**
  * Builds a fully-configured McpServer (all tool groups registered) without
  * connecting a transport. Shared by the local stdio CLI server below and by
@@ -160,6 +244,9 @@ export function buildMcpServer({ name, version }) {
     },
   );
 
+  // 순서가 중요하다. 나중에 감싼 쪽이 바깥이므로, 기억 브리핑을 먼저 붙이고
+  // 한도 경고가 그 뒤에 붙는다 — 경고는 언제나 맨 끝에 있어야 눈에 띈다.
+  withMemoryRecall(server);
   withQuotaWarnings(server);
 
   registerDocumentTools(server);
@@ -181,6 +268,7 @@ export function buildMcpServer({ name, version }) {
   registerAttachmentTools(server);
   registerSignedDocTools(server);
   registerFeedbackTools(server);
+  registerMemoryTools(server);
 
   return server;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rootr-cli",
-  "version": "0.13.0",
+  "version": "0.14.1",
   "description": "Official Rootr CLI + MCP server — read, write, edit and search Rootr documents from the shell or from an AI agent.",
   "type": "module",
   "bin": {