rootr-cli 0.14.0 → 0.14.1

package/README.md

@@ -275,6 +275,22 @@ 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) 서버를 구동합니다. 제공 도구 152종:
@@ -527,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`을 먼저 부르지 않아도 눈앞에 놓입니다. 이 자동 회상은 무료 조회
+한도를 쓰지 않습니다.
+
+사람이 직접 보고 고치려면 워크스페이스 왼쪽 메뉴의 **기억**에서 볼 수 있고,
+"표로 열기"를 누르면 평범한 표로 열려 권한·기록이 그대로 따라옵니다.
+
 #### 제보 (인증 불필요)
 
 | 도구 | 설명 |

package/bin/rootr.js

@@ -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 ------------------------------------------------------------
 
 
@@ -1756,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

@@ -1673,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/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.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.14.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": {