rootr-cli 0.14.0 → 0.16.0

package/lib/client.js

@@ -350,11 +350,19 @@ export class RootrClient {
     return this.request(`/nodes/${encodeURIComponent(id)}`, { method: 'DELETE' });
   }
 
+  /**
+   * UNDO-DELETE — 휴지통에 든 것을 제자리로 되살린다.
+   * 화면의 Ctrl+Z 와 같은 일을 하는 자리다. 지운 사람이 아니어도 쓰기 권한이면 된다.
+   */
+  async restoreNode(id) {
+    return this.request(`/nodes/${encodeURIComponent(id)}/restore`, { method: 'POST' });
+  }
+
   /** Rename and/or move a node. `parentId: null` moves it to the workspace root. */
-  async updateNode(id, { name, icon, tags, parentId, position } = {}) {
+  async updateNode(id, { name, icon, tags, parentId, position, graphSyncOff } = {}) {
     return this.request(`/nodes/${encodeURIComponent(id)}`, {
       method: 'PATCH',
-      body: { name, icon, tags, parentId, position },
+      body: { name, icon, tags, parentId, position, graphSyncOff },
     });
   }
 
@@ -443,6 +451,32 @@ export class RootrClient {
     });
   }
 
+  // ── DB-BUTTON — 표 위에 두는 "누르면 일하는 버튼" ────────────────────────
+  //
+  // 화면에서만 만들 수 있으면, 에이전트는 표를 지어 놓고도 "접수 버튼 하나 달아
+  // 줘"를 못 한다. 만들 수 있으면 눌러 줄 수도 있어야 한다.
+
+  /** 이 표의 버튼 목록. `myLevel` 로 내가 고칠 수 있는지도 함께 온다. */
+  async listDatabaseButtons(databaseId) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/buttons`);
+  }
+
+  /** 버튼 목록을 **통째로** 갈아끼운다(MANAGE 필요). 남길 버튼도 같이 보내야 한다. */
+  async setDatabaseButtons(databaseId, buttons) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/buttons`, {
+      method: 'PUT',
+      body: { buttons },
+    });
+  }
+
+  /** 버튼 한 번 누르기. `rowIds` 는 "고른 행"을 대상으로 하는 단계가 있을 때만 쓴다. */
+  async runDatabaseButton(databaseId, buttonId, { rowIds } = {}) {
+    return this.request(
+      `/databases/${encodeURIComponent(databaseId)}/buttons/${encodeURIComponent(buttonId)}/run`,
+      { method: 'POST', body: { rowIds } },
+    );
+  }
+
   // ── PUBLIC-DOCS — 발행한 문서에 올라온 변경 제안 ────────────────────────
 
   async listDocumentCommits(documentId, status = 'OPEN') {
@@ -760,10 +794,13 @@ export class RootrClient {
    * building a table by adding columns one at a time made the order depend on
    * the order of the calls, which is how migrated tables came out scrambled.
    */
-  async createDatabase(workspace, { name, parentId, path, createParents, autoRename, icon, properties, views, rows, rowPageType } = {}) {
+  async createDatabase(
+    workspace,
+    { name, parentId, path, createParents, autoRename, icon, properties, views, rows, rowPageType, graphSync } = {},
+  ) {
     return this.request(`/workspaces/${encodeURIComponent(workspace)}/databases`, {
       method: 'POST',
-      body: { name, parentId, path, createParents, autoRename, icon, properties, views, rows, rowPageType },
+      body: { name, parentId, path, createParents, autoRename, icon, properties, views, rows, rowPageType, graphSync },
     });
   }
 
@@ -784,11 +821,11 @@ export class RootrClient {
    */
   async createDatabaseView(
     databaseId,
-    { name, type, groupBy, dateProp, endDateProp, filters, sort, colWidths } = {},
+    { name, type, groupBy, dateProp, endDateProp, filters, sort, colWidths, calendarScale } = {},
   ) {
     return this.request(`/databases/${encodeURIComponent(databaseId)}/views`, {
       method: 'POST',
-      body: { name, type, groupBy, dateProp, endDateProp, filters, sort, colWidths },
+      body: { name, type, groupBy, dateProp, endDateProp, filters, sort, colWidths, calendarScale },
     });
   }
 
@@ -1159,6 +1196,36 @@ export class RootrClient {
     });
   }
 
+  // ---- Pages (block-assembled web pages) ----------------------------------
+
+  /** PAGE 노드를 한 번에 만든다(자리 + 블록 + 테마). */
+  async createPage(workspaceId, { name, parentId, path, createParents, autoRename, icon, blocks, config } = {}) {
+    return this.request(`/workspaces/${encodeURIComponent(workspaceId)}/pages`, {
+      method: 'POST',
+      body: { name, parentId, path, createParents, autoRename, icon, blocks, config },
+    });
+  }
+
+  /** 페이지 정본: 블록 배열 + 설정(테마·강조색). */
+  async getPage(pageId) {
+    return this.request(`/pages/${encodeURIComponent(pageId)}`);
+  }
+
+  /** blocks를 주면 **통째로 교체**된다 — 남길 블록도 같이 보내야 한다. */
+  async updatePage(pageId, { blocks, config } = {}) {
+    return this.request(`/pages/${encodeURIComponent(pageId)}`, { method: 'PATCH', body: { blocks, config } });
+  }
+
+  /** 맨 뒤에 덧붙이기 — 있는 블록은 그대로 둔다. */
+  async appendPageBlocks(pageId, blocks) {
+    return this.request(`/pages/${encodeURIComponent(pageId)}/blocks`, { method: 'POST', body: { blocks } });
+  }
+
+  /** 라이브 블록이 지금 무엇을 보여 주는가(집계·행·차트 값). */
+  async getPageLiveData(pageId) {
+    return this.request(`/pages/${encodeURIComponent(pageId)}/live-data`);
+  }
+
   // ---- Presentations (slide decks) ----------------------------------------
 
   async createPresentation(workspaceId, { name, parentId, theme, slides, config, icon } = {}) {
@@ -1673,4 +1740,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

@@ -135,7 +135,11 @@ export function registerDatabaseTools(server) {
         'Views default to a single table view; view types are table | board | gallery | calendar | timeline | list — ' +
         'a "board" view needs config.groupBy (a select/status property id), a "timeline"/"calendar" view needs ' +
         'config.dateProp. Row `values` are keyed by column NAME (or id); date values are ' +
-        '{ start: "YYYY-MM-DDTHH:mm" or "YYYY-MM-DD", end? }, multi_select is string[], relation is an array of row ids.',
+        '{ start: "YYYY-MM-DDTHH:mm" or "YYYY-MM-DD", end? }, multi_select is string[], relation is an array of row ids. ' +
+        'COST NOTE: by default, every row added to this table (now or later) queues that table for graph extraction ' +
+        '(embeddings + LLM) — fine for a handful of rows, expensive for a bulk-loaded roster/log table. Pass ' +
+        'graphSync:false for tables you are about to bulk-load; flip it back with ' +
+        '`rootr_update_node({ graphSyncOff: true|false })` any time after.',
       annotations: { readOnlyHint: false, destructiveHint: false },
       inputSchema: {
         name: z.string().describe('Table name, e.g. "업무 목록"'),
@@ -215,10 +219,18 @@ export function registerDatabaseTools(server) {
             'calculation sheet, "FORM" a per-row intake. Default "DOCUMENT". This is only the default — a single ' +
             'row can be made something else with rootr_create_row_page.',
         ),
+        graphSync: z
+          .boolean()
+          .optional()
+          .describe(
+            'Default true. Set to false for tables you will bulk-load (rosters, logs, imports) — otherwise ' +
+              'every row added queues this table for graph extraction (embeddings + LLM), one job per row. ' +
+              'Flip it later with rootr_update_node({ graphSyncOff: true|false }).',
+          ),
         workspace: z.string().optional().describe('Workspace id; defaults to ROOTR_WORKSPACE/config if omitted'),
       },
     },
-    async ({ name, parentId, path, createParents, icon, properties, views, rows, rowPageType, workspace }) => {
+    async ({ name, parentId, path, createParents, icon, properties, views, rows, rowPageType, graphSync, workspace }) => {
       try {
         const ws = requireWorkspace(workspace);
         const client = makeClient(ws);
@@ -233,6 +245,7 @@ export function registerDatabaseTools(server) {
           views,
           rows,
           rowPageType,
+          graphSync,
         });
         return jsonResult(database);
       } catch (err) {
@@ -271,9 +284,17 @@ export function registerDatabaseTools(server) {
             'Column widths in px for this view, keyed by column NAME or id — e.g. {"공고명": 420}. ' +
               '40~1200. Use it when a column holds long text and is being cut off. {} resets every column to auto.',
           ),
+        calendarScale: z
+          .enum(['week', 'month', 'year'])
+          .optional()
+          .describe(
+            'calendar view only: which span the calendar opens on — week / month / year. ' +
+              'Default month. The year view shows twelve mini-months at once (darker = more rows that day). ' +
+              'Saved on the view, so everyone who opens it sees that span.',
+          ),
       },
     },
-    async ({ databaseId, name, type, groupBy, dateProp, endDateProp, filters, sort, colWidths }) => {
+    async ({ databaseId, name, type, groupBy, dateProp, endDateProp, filters, sort, colWidths, calendarScale }) => {
       try {
         const client = makeClient();
         const id = await resolveNodeId(client, databaseId);
@@ -286,6 +307,7 @@ export function registerDatabaseTools(server) {
           filters,
           sort,
           colWidths,
+          calendarScale,
         });
         return jsonResult(view);
       } catch (err) {
@@ -350,6 +372,14 @@ export function registerDatabaseTools(server) {
             'Column widths in px for this view, keyed by column NAME or id — e.g. {"공고명": 420}. ' +
               '40~1200. Use it when a column holds long text and is being cut off. {} resets every column to auto.',
           ),
+        calendarScale: z
+          .enum(['week', 'month', 'year'])
+          .optional()
+          .describe(
+            'calendar view only: which span the calendar opens on — week / month / year. ' +
+              'Default month. The year view shows twelve mini-months at once (darker = more rows that day). ' +
+              'Saved on the view, so everyone who opens it sees that span.',
+          ),
       },
     },
     async ({
@@ -363,6 +393,7 @@ export function registerDatabaseTools(server) {
       filters,
       sort,
       colWidths,
+      calendarScale,
     }) => {
       try {
         const client = makeClient();
@@ -376,6 +407,7 @@ export function registerDatabaseTools(server) {
           filters,
           sort,
           colWidths,
+          calendarScale,
         });
         return jsonResult({ view });
       } catch (err) {
@@ -1048,4 +1080,113 @@ export function registerDatabaseTools(server) {
       }
     },
   );
+
+  // ── DB-BUTTON — 표 위에 두는 "누르면 일하는 버튼" ──────────────────────────
+  //
+  // 사람은 화면에서 버튼을 만들 수 있는데 에이전트는 못 만들면, "이 표에 접수 버튼
+  // 하나 달아 줘"에서 멈춘다. 만들 수 있으면 눌러 줄 수도 있어야 한다.
+
+  server.registerTool(
+    'rootr_list_database_buttons',
+    {
+      title: 'List the action buttons on a database',
+      description:
+        'List the action buttons pinned to the top of a Rootr (루터) DATABASE. Each button is a named, ' +
+        'ordered list of steps (add a row / set values / let AI fill a cell / open the new row) that runs ' +
+        'when someone presses it — the repeated setup a table owner would otherwise do by hand every time. ' +
+        'Returns `myLevel` too: editing the buttons needs MANAGE, pressing one only needs WRITE.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+      },
+    },
+    async ({ databaseId }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.listDatabaseButtons(id));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_set_database_buttons',
+    {
+      title: 'Create or edit the action buttons on a database',
+      description:
+        'Replace the WHOLE button list of a Rootr (루터) DATABASE (needs MANAGE). This is a full replace, not a ' +
+        'merge — call rootr_list_database_buttons first and send back the buttons you want to KEEP, or they are ' +
+        'dropped. Up to 12 buttons, 8 steps each.\n' +
+        'Steps run in order and the row a step created is what the NEXT step works on, which is how ' +
+        '"add a row → have AI write its summary → open it" becomes one press:\n' +
+        '· {kind:"add_row", values?} — make a row, optionally pre-filled. Column keys may be NAMES or ids.\n' +
+        '· {kind:"update_rows", target:"created"|"selected", values} — set values on the rows this button just ' +
+        'made, or on the rows the person ticked in the table.\n' +
+        '· {kind:"ai_fill", target, propId, prompt} — let AI write ONE cell. The prompt may quote the row with ' +
+        '{칸이름}, e.g. "{제목}과 {메모}를 한 문장으로 요약해". If the AI fails the button keeps going.\n' +
+        '· {kind:"open_row"} — open the row this button made (UI only; over the API it just reports the id).\n' +
+        'Values accept @today, @today+7 and @me — the server fills them in at press time, not now.\n' +
+        'A button never grants permission: it runs as whoever presses it.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        buttons: z
+          .array(
+            z.object({
+              id: z.string().optional().describe('Keep an existing button by passing its id; omit to create one'),
+              label: z.string().describe('Button text, e.g. "접수"'),
+              icon: z.string().optional().describe('One emoji shown on the button'),
+              steps: z
+                .array(z.record(z.any()))
+                .describe('Ordered steps — see the tool description for each kind (max 8)'),
+            }),
+          )
+          .describe('The COMPLETE button list for this table. [] removes every button.'),
+      },
+    },
+    async ({ databaseId, buttons }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.setDatabaseButtons(id, buttons));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_run_database_button',
+    {
+      title: 'Press an action button on a database',
+      description:
+        'Press one button on a Rootr (루터) DATABASE and run its steps in order (needs WRITE). ' +
+        'Pass `rowIds` only when a step targets "selected" — that is the set of rows the person would have ' +
+        'ticked in the table; without it such a step reaches no rows and the server says so. ' +
+        'Returns `created` (the ARRAY of row ids it made, not a count), `updated` and `filled` counts, the ' +
+        '`openRowId` a final "open_row" step points at, and — if the AI could not write a cell — `aiFailed` ' +
+        'with the reason (the rest of the button still ran). ' +
+        'It runs with YOUR permissions: a button that writes a locked column stops there if you cannot edit it.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        buttonId: z.string().describe('Button id from rootr_list_database_buttons'),
+        rowIds: z
+          .array(z.string())
+          .optional()
+          .describe('Rows for steps whose target is "selected". Omit for buttons that only add rows.'),
+      },
+    },
+    async ({ databaseId, buttonId, rowIds }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.runDatabaseButton(id, buttonId, { rowIds }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
 }

package/lib/mcp-tools/documents.js

@@ -194,11 +194,17 @@ export function registerDocumentTools(server) {
       annotations: { readOnlyHint: true, destructiveHint: false },
       inputSchema: {
         query: z.string().describe('Search query text'),
+        // rootr_list와 같은 이유로 필요하다: 이것만 안 받으면 다중 워크스페이스
+        // 연결에서 정체 모를 오류가 난다(#99).
+        workspace: z
+          .string()
+          .optional()
+          .describe('Workspace id; defaults to ROOTR_WORKSPACE/config'),
       },
     },
-    async ({ query }) => {
+    async ({ query, workspace }) => {
       try {
-        const client = makeClient();
+        const client = makeClient(workspace);
         const results = await client.search(query);
         const rows = results.map((r) => {
           const label = r.path || r.name || r.nodeId;
@@ -218,13 +224,19 @@ export function registerDocumentTools(server) {
       title: 'Comment on a Rootr document',
       description:
         'Add a comment to a Rootr (루터) document (optionally anchored to a block, or as a reply via parentId). ' +
+        'DB-ROW-COMMENT — to comment on a **row of a table**, pass the DATABASE as `target` and the ROW id as `blockId`; that is exactly what the row screen does, and the row will show it above its body. ' +
+        'Mentioning someone with @[userId] notifies them, and their notification opens that row and ' +
+        'highlights this comment. ' +
         'Comments carry a user identity: the comment is attributed to the person who owns the key ' +
         '(account keys and workspace keys both carry an owner). A key with no owner cannot comment.',
       annotations: { readOnlyHint: false, destructiveHint: false },
       inputSchema: {
         target: z.string().describe('Document path (starting with "/") or node id, or a full rootr.io URL'),
         body: z.string().describe('Comment text (markdown)'),
-        blockId: z.string().optional().describe('Block id to anchor the comment to'),
+        blockId: z
+          .string()
+          .optional()
+          .describe('Block id to anchor the comment to — or a DATABASE ROW id to comment on that row'),
         parentId: z.string().optional().describe('Parent comment id, to reply in a thread'),
       },
     },
@@ -244,11 +256,16 @@ export function registerDocumentTools(server) {
     {
       title: 'List comments on a Rootr document',
       description:
-        'List the comment threads on a Rootr (루터) document, optionally filtered to one block. Works with any key.',
+        'List the comment threads on a Rootr (루터) document, optionally filtered to one block. ' +
+        'DB-ROW-COMMENT — for the comments on ONE ROW of a table, pass the DATABASE as `target` and the ' +
+        'ROW id as `blockId`. Works with any key.',
       annotations: { readOnlyHint: true, destructiveHint: false },
       inputSchema: {
         target: z.string().describe('Document path (starting with "/") or node id, or a full rootr.io URL'),
-        blockId: z.string().optional().describe('Only comments anchored to this block'),
+        blockId: z
+          .string()
+          .optional()
+          .describe('Only comments anchored to this block — or a DATABASE ROW id for that row\'s comments'),
       },
     },
     async ({ target, blockId }) => {

package/lib/mcp-tools/forms.js

@@ -148,7 +148,8 @@ export function registerFormTools(server) {
         'rootr_read_form first and resend fields you want to keep (with their existing ids) so past responses ' +
         'stay attributable. Pass `targetDatabaseId: null` to unlink the mirrored DATABASE. ' +
         FIELDS_GUIDE,
-      annotations: { readOnlyHint: false, destructiveHint: false },
+      // `fields`를 주면 필드 전체를 갈아끼운다 — 기존 id 를 안 보내면 응답 귀속이 끊긴다.
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
       inputSchema: {
         formId: z.string().describe(`FORM node id${NODE_TARGET_HINT}`),
         fields: z.array(fieldShape).optional().describe('COMPLETE fields array to set — omitted existing fields will be dropped'),

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);
+      }
+    },
+  );
+}