rootr-cli 0.14.1 → 0.16.0

package/README.md

@@ -6,7 +6,7 @@ Rootr(마크다운 지식협업 SaaS) 공식 CLI + MCP 서버. 에이전트나
 - `rootr` CLI: `ls`, `read`, `write`, `append`, `edit`, `search`, `rm`, `attach`, `ws`, `ask`, `config`
 - `rootr mcp`: stdio 기반 MCP 서버 (Claude Code / Claude Desktop 등에 등록해서 사용), 도구 90종+
   — 문서·워크스페이스/스캐폴딩·LOG 데이터스토어·RCA ask·이슈·웹훅·첨부파일에 더해
-  스프레드시트/화이트보드/폼/프레젠테이션/녹음/CRM/데이터베이스까지. 정확한 목록은 MCP `tools/list`로 확인하세요.
+  스프레드시트/화이트보드/폼/프레젠테이션/페이지/녹음/CRM/데이터베이스까지. 정확한 목록은 MCP `tools/list`로 확인하세요.
 
 순수 Node.js ESM, 빌드 과정 없음. Node 18 이상 필요(내장 `fetch` 사용).
 
@@ -147,8 +147,11 @@ rootr rm /notes/todo.md          # 확인 후 삭제
 rootr rm /notes/todo.md --yes    # 확인 없이 (스크립트용)
 ```
 
-휴지통으로 옮기는 **복구 가능한** 삭제입니다. 앱의 휴지통에서 되돌릴 수 있고,
-30일이 지나면 자동으로 완전 삭제됩니다. `--yes` 없이 실행하면 확인을 묻습니다
+휴지통으로 옮기는 **복구 가능한** 삭제입니다. 30일이 지나면 자동으로 완전 삭제됩니다.
+되돌리려면 `rootr restore <id>` — 화면에서 Ctrl+Z 를 누르는 것과 같은 일입니다.
+**경로가 아니라 id** 입니다(휴지통에 든 것은 이미 트리에 없어 경로로는 못 찾습니다).
+`rootr rm` 이 마지막 줄에 그 id 를 찍어 주니 그대로 쓰면 됩니다. MCP 로는
+`rootr_restore_node`. `--yes` 없이 실행하면 확인을 묻습니다
 (파이프/CI처럼 입력이 없는 환경에서는 "아니오"로 처리되어 안전합니다).
 `docs:write` 스코프가 필요합니다.
 
@@ -394,8 +397,8 @@ rootr memory forget <id>                         # 폐기(--hard면 행 삭제)
 | `rootr_bulk_update_rows_each` | 여러 행을 **행마다 다른 값**으로 한 번에 수정 |
 | `rootr_delete_row` | 행 삭제 |
 | `rootr_bulk_delete_rows` | 행 여러 개를 한 번에 삭제 |
-| `rootr_create_view` | 보기 추가 — 테이블/보드/캘린더/타임라인/갤러리 |
-| `rootr_update_view` | 보기 수정 — 열 숨기기·이름·그룹·필터·정렬·열 너비 |
+| `rootr_create_view` | 보기 추가 — 테이블/보드/캘린더/타임라인/갤러리 (달력은 `calendarScale`로 주·달·해) |
+| `rootr_update_view` | 보기 수정 — 열 숨기기·이름·그룹·필터·정렬·열 너비·달력 단위(`calendarScale`) |
 | `rootr_delete_view` | 보기 삭제 |
 | `rootr_create_row_page` | 행에 상세 페이지 붙이기(문서 또는 서명문서) |
 | `rootr_set_row_page_type` | 앞으로 만드는 행이 무엇으로 열릴지 정하기 |
@@ -407,6 +410,9 @@ rootr memory forget <id>                         # 폐기(--hard면 행 삭제)
 | `rootr_set_database_permissions` | 표 잠그기 — 칸·뷰 잠금 / 본인 행만 / 관리자만 고칠 칸 |
 | `rootr_read_database_notifications` | 표 알림 규칙 보기 |
 | `rootr_set_database_notifications` | 표 알림 규칙 저장 — 누구에게·언제·어떤 것만 |
+| `rootr_list_database_buttons` | 표 위 **버튼** 목록 보기(고칠 수 있는지 `myLevel`도 함께) |
+| `rootr_set_database_buttons` | 버튼 만들고 고치기 — **목록 통째로 교체**(남길 것도 같이 보내야 함) |
+| `rootr_run_database_button` | 버튼 누르기 — 행 만들기·값 채우기·AI로 칸 채우기가 순서대로 |
 | `rootr_list_document_commits` | 공개 문서에 온 변경 제안 목록 |
 | `rootr_merge_document_commit` | 변경 제안 반영(세 벌 병합 — 덮어쓰기 아님) |
 | `rootr_reject_document_commit` | 변경 제안 거절(사유는 제안자에게 전달) |
@@ -418,6 +424,35 @@ rootr memory forget <id>                         # 폐기(--hard면 행 삭제)
 | `rootr_delete_form_response` | 폼 응답 한 건 삭제 |
 | `rootr_create_form_collector` | 응답 모을 표·스프레드시트를 **만들어서** 연결(표는 질문 그대로 칸 생성) |
 
+**표 버튼 — 매번 하는 준비 동작을 한 번에.** 새 건이 생길 때마다 상태=접수, 담당=나,
+마감=오늘+7 을 손으로 다시 채우는 일을 버튼 하나로 만듭니다. 단계는 **적힌 순서대로**
+돌고 **앞 단계가 만든 행을 뒤 단계가 받으므로**, "행을 만들고 → 그 행의 요약을 AI가 쓰고
+→ 그 행을 연다"가 한 번 누름으로 끝납니다. 값에는 `@today` · `@today+7` · `@me` 를 쓸 수
+있고 누르는 그 시점에 채워집니다. 버튼은 권한을 늘리지 않습니다 — **누른 사람 권한 그대로**
+돕니다(만들기·고치기는 관리자, 누르기는 편집 권한).
+
+```bash
+rootr db buttons <표>                      # 지금 달린 버튼 보기
+rootr db buttons <표> --file buttons.json  # 목록 통째로 저장(남길 것도 같이)
+rootr db button-run <표> <버튼id>           # 한 번 누르기 (--rows id,id 로 고른 행 지정)
+rootr db view <표> <뷰> --scale year       # 달력 보기를 주·달·해 중에서
+```
+
+```json
+[{ "label": "접수", "icon": "📥", "steps": [
+    { "kind": "add_row", "values": { "상태": "접수", "담당": "@me", "마감": "@today+7" } },
+    { "kind": "ai_fill", "target": "created", "propId": "요약", "prompt": "{제목}을 한 문장으로 요약해." },
+    { "kind": "open_row" }
+] }]
+```
+
+스캐폴드로 표를 지을 때도 `database.buttons` 에 같은 모양을 넣으면 **표와 함께** 달립니다.
+
+**행에 댓글 달기.** 표의 한 행에 댓글을 달려면 `rootr_comment_document` 에 **표**를
+`target` 으로, **행 id**를 `blockId` 으로 줍니다(읽기는 `rootr_list_document_comments`,
+명령줄은 `rootr comments <표> --block <행id>`). 상세 문서가 없는 행에도 달립니다.
+`@[userId]` 로 사람을 부르면 알림이 가고, 그 알림은 **그 행**을 열면서 댓글을 짚어 줍니다.
+
 **사람 칸은 여러 명을 담습니다.** 회의 참석자·공동 담당처럼 여럿이 들어가는 자리가
 흔해서, 값은 이름 목록(`["김대표","이팀장"]`)입니다. 이름 하나만 보내도 받아 주고
 목록으로 맞춰 돌려줍니다. 새로 들어온 사람에게만 알림이 갑니다.
@@ -623,6 +658,44 @@ rootr memory forget <id>                         # 폐기(--hard면 행 삭제)
 | `rootr_update_node` | 아무 노드나 이름·아이콘 변경 / 옮기기 |
 | `rootr_delete_node` | 노드를 휴지통으로 이동(복구 가능) |
 
+#### 페이지 (웹페이지)
+
+페이지(PAGE)는 **바깥 사람이 볼 화면**입니다 — 행사 안내·제품 소개·신청 받기처럼
+링크 하나로 보여 줄 것. 전용 MCP 도구(`rootr_create_page`, `rootr_read_page`,
+`rootr_append_page_blocks`, `rootr_update_page`, `rootr_update_page_block`,
+`rootr_read_page_live_data`)로 저작합니다.
+
+HTML을 짜는 것이 아니라 **정해진 블록 14종을 골라 쌓습니다** — `hero` `text`
+`features` `gallery` `pricing` `testimonials` `faq` `timeline` `cta` `footer` +
+표에서 값을 끌어오는 `liveStats` `liveTable` `liveChart` + 신청을 받는 `form` + 자유 블록 `custom`.
+
+`custom`은 **격리된 방**입니다: HTML/CSS를 마음대로 쓰되 `sandbox` 아이프레임 안에서만
+그려집니다(스크립트 없음·같은 출처 아님·바깥 통신 차단). 그래서 대담한 CSS도 바깥 화면을
+못 덮습니다 — 저장할 때 `<script>`와 `on*=`는 지워집니다. 방 안에서는 페이지 분위기 색을
+`var(--pg-text)` `var(--pg-card)` `var(--pg-accent)` 처럼 쓸 수 있습니다.
+블록별 props는 **`/llms.txt`의 "Pages" 섹션**에 표로 정리돼 있습니다.
+
+```bash
+# 페이지 만들기 (블록을 생략하면 hero/text/footer 뼈대로 시작)
+curl -X POST "$BASE/workspaces/$WS/pages" -H "x-api-key: $KEY" \
+  -H 'Content-Type: application/json' \
+  -d '{"name":"가을 행사","config":{"theme":"midnight"},
+       "blocks":[{"type":"hero","props":{"title":"가을 개발자 밋업","subtitle":"10월 12일 · 서울"}}]}'
+
+# 블록 덧붙이기(있는 블록은 그대로) / 통째 교체 / 라이브 값 확인
+curl -X POST  "$BASE/pages/$ID/blocks" -d '{"blocks":[{"type":"faq","props":{"items":[...]}}]}' ...
+curl -X PATCH "$BASE/pages/$ID"        -d '{"config":{"theme":"warm"}}' ...
+curl        "$BASE/pages/$ID/live-data" -H "x-api-key: $KEY"
+```
+
+`liveStats`/`liveTable`/`liveChart`의 `source.nodeId`는 같은 워크스페이스의
+DATABASE·LOG 노드이고, 칸은 **이름**으로 가리킵니다(칸 id가 아닙니다).
+`form` 블록의 `formNodeId`에 폼 노드를 걸면 방문자가 **그 자리에서 신청**합니다 —
+폼을 따로 공개할 필요가 없습니다. 비공개(PRIVATE) 서브트리에 있는 표·폼은 공개
+페이지에서 조용히 빠집니다(일부러 그렇습니다).
+
+공개는 여느 노드와 같습니다: `POST /v1/nodes/:id/publish` → `rootr.io/p/{slug}`.
+
 #### 프레젠테이션
 
 프레젠테이션(PRESENTATION)은 전용 MCP 도구(`rootr_create_presentation`,

package/bin/rootr.js

@@ -23,6 +23,7 @@ const USAGE = `Rootr CLI v${pkg.version}
   rootr search <query>                             워크스페이스 검색
   rootr mv <path|id> <새 경로|폴더 id>              문서/폴더 이동 및/또는 이름 변경
   rootr rm <path|id> [--yes]                       문서/폴더를 휴지통으로 이동 (복구 가능)
+  rootr restore <id>                               지운 것 되돌리기 (화면의 Ctrl+Z 와 같은 일 — 경로 아닌 id)
   rootr attach <file> [--doc <path|id>] [--heading "## X"] [--alt <text>]  파일 업로드(+문서에 삽입)
   rootr ws                                         내 워크스페이스 목록 (id\tname, 열 수 없는 곳은 표시)
   rootr use <id|이름|주소>                          활성 워크스페이스 전환 (그 워크스페이스용 키도 기억)
@@ -31,6 +32,9 @@ const USAGE = `Rootr CLI v${pkg.version}
   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 buttons <path|id> [--file buttons.json] [--clear]  표 위 "누르면 일하는 버튼" 보기·저장
+  rootr db button-run <path|id> <buttonId> [--rows id,id]     버튼 한 번 누르기 (행 만들기·값 채우기·AI 채우기)
+  rootr db view <path|id> [뷰이름] [--scale week|month|year] [--name 새이름]  뷰 목록·달력 주/달/해 단위
   rootr db row-add <path|id> --values '<json>' [--body <md>|--body-file <f>]  행 추가(상세 내용 포함)
   rootr db row-body <path|id> <rowId> [--file <f>] 행의 상세 내용(본문 메모) 쓰기 — 없으면 표준입력
   rootr db rows-new <path|id> --json '[{…},…]' | --file <파일>   여러 행 한 번에 넣기 (하나라도 틀리면 전부 취소)
@@ -45,6 +49,7 @@ const USAGE = `Rootr CLI v${pkg.version}
   rootr publish <path|id> --off                    공개 닫기 (딸려 나간 하위도 같이 닫힘)
   rootr publish <path|id> --status                 지금 공개인지·주소·하위 포함 여부
   rootr publish <표> --layout board --skin paper   공개한 표를 무슨 꼴로 보일지 (배치 9종 × 분위기 6종)
+  rootr publish <문서> --comments [false] [--expires <ISO>] [--skin <분위기>]  문서 전용 — 댓글(편집 제안)·만료일·스킨 16종
   rootr readreq <path|id> [--json]                 읽음 확인 현황 — 누가 읽었나·완료율
   rootr readreq <path|id> --users <id,id> [--due <ISO>] [--ack]  읽어야 할 사람 지정(명단 통째로 교체)
   rootr readreq <path|id> --clear                  읽음 확인 해제
@@ -353,7 +358,32 @@ async function cmdRm(args) {
 
   await client.deleteNode(id);
   console.log(`휴지통으로 옮겼습니다: ${resolved.path || id}`);
-  console.log('복구하려면 앱의 휴지통에서 되돌리세요 (30일 뒤 자동 삭제).');
+  // 되돌리려면 id 가 있어야 한다 — 휴지통에 든 것은 경로로는 못 찾는다.
+  console.log(`되돌리려면: rootr restore ${id}   (30일 뒤 자동 삭제)`);
+}
+
+/**
+ * UNDO-DELETE — `rootr restore <id>`
+ *
+ * 지운 것을 제자리로 되살린다. 화면의 Ctrl+Z 와 같은 일이다.
+ * **경로가 아니라 id** 다 — 휴지통에 든 것은 이미 트리에 없어서 경로로는 못 찾는다.
+ * `rootr rm` 이 마지막 줄에 그 id 를 찍어 준다.
+ */
+async function cmdRestore(args) {
+  const id = args._[0];
+  if (!id) {
+    throw new Error(
+      '사용법: rootr restore <id>\n' +
+        '  (경로가 아니라 id 입니다 — 휴지통에 든 것은 경로로 못 찾습니다. rootr rm 이 찍어 준 id 를 쓰세요.)',
+    );
+  }
+  const client = makeClient();
+  const node = await client.restoreNode(id);
+  if (args.json) {
+    console.log(JSON.stringify(node, null, 2));
+    return;
+  }
+  console.log(`되돌렸습니다: ${node.path ?? node.name ?? id}`);
 }
 
 /** Minimal y/N prompt. Non-interactive stdin (pipes, CI) answers "no". */
@@ -1131,20 +1161,35 @@ async function cmdDbRowsRm(args) {
 /** PUBLIC-DB-DESIGN — 서버가 받는 값과 **같은 목록**이어야 한다. */
 const DB_LAYOUTS = ['table', 'cards', 'gallery', 'list', 'board', 'timeline', 'calendar', 'chart', 'ranking'];
 const DB_SKINS = ['clean', 'paper', 'dark', 'vivid', 'bento', 'brutal'];
+// DOCUMENT만 갖는 스킨 목록 — 서버(`public-config.ts`의 SKIN_IDS)와 같아야 한다.
+const DOC_SKINS = [
+  'classic', 'minimal', 'magazine', 'paper', 'tech-dark', 'vivid', 'manual', 'book',
+  'editorial', 'bento', 'glass', 'mesh', 'immersive', 'brutal', 'neumorph', 'y2k',
+];
+
+/** `--comments` 단독이면 true, `--comments false`면 false, 안 주면 undefined. */
+function flagToBool(v) {
+  if (v === undefined) return undefined;
+  return v !== 'false' && v !== '0';
+}
 
 async function cmdPublish(args) {
   const target = args._[0];
   if (!target) {
     throw new Error(
-      '사용법: rootr publish <path|id> [--children] [--view <id>] [--layout <배치>] [--skin <분위기>] | --off | --status',
+      '사용법: rootr publish <path|id> [--children] [--view <id>] [--layout <배치>] [--skin <분위기>] ' +
+        '[--comments] [--expires <ISO>] | --off | --status',
     );
   }
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
+  // DOCUMENT는 예전(더 풍부한) 경로를 쓴다 — 댓글(편집 제안) 허용, 문서 전용 스킨
+  // 16종, 만료일이 이쪽에만 있다. 노드 공통 공개 경로(표·시트 등)는 이 셋을 모른다.
+  const isDocument = (await client.nodePublicStatus(id)).nodeType === 'DOCUMENT';
 
   if (args.status) {
-    const st = await client.nodePublicStatus(id);
-    if (!st.publishable) {
+    const st = isDocument ? await client.getDocumentPublicStatus(id) : await client.nodePublicStatus(id);
+    if (!isDocument && !st.publishable) {
       console.log('이 종류는 공개할 수 없습니다(폴더).');
       return;
     }
@@ -1154,21 +1199,52 @@ async function cmdPublish(args) {
     }
     console.log(`공개 중: /p/${st.slug}`);
     if (st.expiresAt) console.log(`  만료: ${st.expiresAt}`);
-    if (st.hasPassword) console.log('  비밀번호 걸려 있음');
-    console.log(`  하위 문서도 공개: ${st.includeChildren ? '예' : '아니오'}`);
-    console.log(`  복제 허용: ${st.allowClone === false ? '아니오' : '예'}`);
-    if (st.design && (st.design.layout || st.design.skin)) {
-      console.log(`  보이는 방식: ${st.design.layout ?? 'table'} / ${st.design.skin ?? 'clean'}`);
+    if (isDocument) {
+      console.log(`  댓글(편집 제안) 허용: ${st.allowCommits ? '예' : '아니오'}`);
+      if (st.publicConfig?.skin) console.log(`  스킨: ${st.publicConfig.skin}`);
+    } else {
+      if (st.hasPassword) console.log('  비밀번호 걸려 있음');
+      console.log(`  하위 문서도 공개: ${st.includeChildren ? '예' : '아니오'}`);
+      console.log(`  복제 허용: ${st.allowClone === false ? '아니오' : '예'}`);
+      if (st.design && (st.design.layout || st.design.skin)) {
+        console.log(`  보이는 방식: ${st.design.layout ?? 'table'} / ${st.design.skin ?? 'clean'}`);
+      }
     }
     return;
   }
 
   if (args.off) {
-    await client.setNodePublic(id, { isPublic: false });
+    if (isDocument) await client.setDocumentPublic(id, { isPublic: false });
+    else await client.setNodePublic(id, { isPublic: false });
     console.log('공개를 닫았습니다. 딸려 나갔던 하위 문서도 같이 닫혔습니다(주소는 남아 있습니다).');
     return;
   }
 
+  if (isDocument) {
+    if (args.skin !== undefined && !DOC_SKINS.includes(args.skin)) {
+      throw new Error(`--skin 은 다음 중 하나여야 합니다: ${DOC_SKINS.join(', ')}`);
+    }
+    const cur = await client.getDocumentPublicStatus(id);
+    if (!cur.isPublic) {
+      const res = await client.publishDocument(id);
+      console.log(`공개했습니다: /p/${res.slug}`);
+    }
+    const patch = {};
+    const comments = flagToBool(args.comments);
+    if (comments !== undefined) patch.allowCommits = comments;
+    if (typeof args.expires === 'string') patch.expiresAt = args.expires;
+    if (typeof args.skin === 'string') patch.skin = args.skin;
+    if (Object.keys(patch).length) {
+      await client.setDocumentPublic(id, patch);
+      if (patch.allowCommits !== undefined) {
+        console.log(`  댓글(편집 제안) 허용: ${patch.allowCommits ? '예' : '아니오'}`);
+      }
+      if (patch.expiresAt !== undefined) console.log(`  만료: ${patch.expiresAt}`);
+      if (patch.skin !== undefined) console.log(`  스킨: ${patch.skin}`);
+    }
+    return;
+  }
+
   // PUBLIC-DB-DESIGN — 표는 표 모양으로만 보일 이유가 없다. 준 것만 바뀐다.
   const design = {
     ...(typeof args.layout === 'string' ? { layout: args.layout } : {}),
@@ -1274,9 +1350,12 @@ async function cmdDb(args) {
   if (sub === 'row-page-type') return cmdDbRowPageType(args);
   if (sub === 'lock') return cmdDbLock(args);
   if (sub === 'notify') return cmdDbNotify(args);
+  if (sub === 'buttons') return cmdDbButtons(args);
+  if (sub === 'button-run') return cmdDbButtonRun(args);
+  if (sub === 'view') return cmdDbView(args);
   if (sub !== 'create') {
     throw new Error(
-      '사용법: rootr db create|rows|row-add|rows-new|row-body|rows-set|rows-each|rows-rm|row-page|row-page-type|lock|notify … (자세한 건 rootr --help)',
+      '사용법: rootr db create|rows|row-add|rows-new|row-body|rows-set|rows-each|rows-rm|row-page|row-page-type|lock|notify|buttons|button-run|view … (자세한 건 rootr --help)',
     );
   }
   const raw = typeof args.file === 'string' ? readFileSync(args.file, 'utf8') : await readStdin();
@@ -1390,6 +1469,175 @@ async function cmdDbNotify(args) {
   }
 }
 
+/**
+ * `rootr db view <path|id> <뷰이름|뷰id> [--scale week|month|year] [--name 새이름]`
+ *
+ * 뷰 하나만 고친다. 인자 없이 부르면 이 표의 뷰 목록을 보여 준다.
+ * `--scale` 은 **달력 뷰**가 주·달·해 중 무엇으로 열릴지다(기본 달).
+ * 해 보기는 열두 달을 한 번에 보여 주고, 고른 단위는 뷰에 저장돼 모두에게 그대로 보인다.
+ */
+async function cmdDbView(args) {
+  const target = args._[1];
+  if (!target) throw new Error('사용법: rootr db view <path|id> [뷰이름] [--scale week|month|year] [--name 새이름] [--json]');
+
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  const viewRef = args._[2];
+
+  if (!viewRef) {
+    const db = await client.getDatabase(id);
+    const views = db.views ?? [];
+    if (args.json) {
+      console.log(JSON.stringify(views, null, 2));
+      return;
+    }
+    if (!views.length) {
+      console.log('뷰가 없습니다.');
+      return;
+    }
+    const SPAN = { week: '주', month: '달', year: '해' };
+    for (const v of views) {
+      const span = v.type === 'calendar' ? ` · ${SPAN[v.config?.calendarScale] ?? '달'} 단위` : '';
+      console.log(`- ${v.name} (${v.type})${span}  ${v.id}`);
+    }
+    return;
+  }
+
+  const patch = {};
+  if (args.scale !== undefined) {
+    const scale = String(args.scale);
+    if (!['week', 'month', 'year'].includes(scale)) {
+      throw new Error('--scale 은 week · month · year 중 하나여야 합니다.');
+    }
+    patch.calendarScale = scale;
+  }
+  if (typeof args.name === 'string') patch.name = args.name;
+  if (!Object.keys(patch).length) {
+    throw new Error('바꿀 것을 주세요: --scale week|month|year 또는 --name 새이름');
+  }
+
+  const view = await client.updateDatabaseView(id, viewRef, patch);
+  if (args.json) {
+    console.log(JSON.stringify(view, null, 2));
+    return;
+  }
+  const SPAN = { week: '주', month: '달', year: '해' };
+  const span = view.type === 'calendar' ? ` · ${SPAN[view.config?.calendarScale] ?? '달'} 단위` : '';
+  console.log(`뷰를 고쳤습니다: ${view.name} (${view.type})${span}`);
+}
+
+
+/**
+ * DB-BUTTON — 표 위의 "누르면 일하는 버튼".
+ *
+ *   rootr db buttons <path|id>                  지금 달린 버튼 보기
+ *   rootr db buttons <path|id> --file b.json    버튼 목록을 통째로 갈아끼우기
+ *   rootr db buttons <path|id> --clear          버튼 전부 없애기
+ *
+ * `--file` 은 **통째로 갈아끼운다** — 남길 버튼도 파일에 같이 있어야 한다.
+ * 파일 모양: [{ "label":"접수", "icon":"📥",
+ *              "steps":[{"kind":"add_row","values":{"상태":"접수","담당":"@me","마감":"@today+7"}}] }]
+ */
+async function cmdDbButtons(args) {
+  const target = args._[1];
+  if (!target) throw new Error('사용법: rootr db buttons <path|id> [--file buttons.json] [--clear] [--json]');
+
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+
+  if (args.clear) {
+    const cleared = await client.setDatabaseButtons(id, []);
+    console.log('버튼을 모두 지웠습니다.');
+    if (args.json) console.log(JSON.stringify(cleared, null, 2));
+    return;
+  }
+  if (args.file) {
+    const raw = readFileSync(args.file, 'utf8');
+    let buttons;
+    try {
+      buttons = JSON.parse(raw);
+    } catch {
+      throw new Error('버튼 파일을 JSON으로 읽을 수 없습니다. [{ "label": "...", "steps": [...] }] 형태여야 합니다.');
+    }
+    if (!Array.isArray(buttons)) throw new Error('버튼 파일은 배열이어야 합니다(버튼 목록 전체).');
+    const saved = await client.setDatabaseButtons(id, buttons);
+    console.log(`버튼 ${saved.buttons.length}개를 저장했습니다.`);
+    if (args.json) console.log(JSON.stringify(saved, null, 2));
+    return;
+  }
+
+  const { buttons, myLevel } = await client.listDatabaseButtons(id);
+  if (args.json) {
+    console.log(JSON.stringify(buttons, null, 2));
+    return;
+  }
+  if (!buttons.length) {
+    console.log('버튼이 없습니다.');
+    return;
+  }
+  const WHAT = {
+    add_row: '행 만들기',
+    update_rows: '값 바꾸기',
+    ai_fill: 'AI로 칸 채우기',
+    open_row: '만든 행 열기',
+  };
+  const WHERE = { created: '방금 만든 행', selected: '고른 행' };
+  for (const b of buttons) {
+    console.log(`${b.icon ? b.icon + ' ' : ''}${b.label}  (${b.id})`);
+    for (const [i, st] of (b.steps ?? []).entries()) {
+      const what = WHAT[st.kind] ?? st.kind;
+      const where = st.target ? ` · ${WHERE[st.target] ?? st.target}` : '';
+      const detail =
+        st.kind === 'ai_fill'
+          ? ` · ${st.propId} 칸 ← "${st.prompt}"`
+          : st.values
+            ? ' · ' + Object.entries(st.values).map(([k, v]) => `${k}=${v}`).join(', ')
+            : '';
+      console.log(`  ${i + 1}. ${what}${where}${detail}`);
+    }
+  }
+  if (myLevel && myLevel !== 'MANAGE' && myLevel !== 'FULL') {
+    console.log('\n(버튼을 고치려면 이 표의 관리 권한이 필요합니다. 누르는 것은 지금 권한으로도 됩니다.)');
+  }
+}
+
+/**
+ * `rootr db button-run <path|id> <buttonId> [--rows id1,id2]`
+ *
+ * 버튼을 한 번 누른다. `--rows` 는 "고른 행"을 대상으로 하는 단계가 있을 때만 쓴다.
+ * 누른 사람 권한 그대로 돈다 — 잠긴 칸을 건드리는 버튼은 거기서 막힌다.
+ */
+async function cmdDbButtonRun(args) {
+  const target = args._[1];
+  const buttonId = args._[2];
+  if (!target || !buttonId) {
+    throw new Error('사용법: rootr db button-run <path|id> <buttonId> [--rows id1,id2] [--json]');
+  }
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  const rowIds =
+    typeof args.rows === 'string'
+      ? args.rows.split(',').map((x) => x.trim()).filter(Boolean)
+      : undefined;
+
+  const r = await client.runDatabaseButton(id, buttonId, { rowIds });
+  if (args.json) {
+    console.log(JSON.stringify(r, null, 2));
+    return;
+  }
+  // created 는 **만든 행의 id 목록**이다(개수가 아니다) — 세어서 보여 준다.
+  const madeCount = Array.isArray(r.created) ? r.created.length : (r.created ?? 0);
+  const parts = [];
+  if (madeCount) parts.push(`행 ${madeCount}개 만듦`);
+  if (r.updated) parts.push(`행 ${r.updated}개 고침`);
+  if (r.filled) parts.push(`AI로 칸 ${r.filled}개 채움`);
+  console.log(parts.length ? parts.join(' · ') : '바뀐 것이 없습니다.');
+  if (r.openRowId) console.log(`열 행: ${r.openRowId}`);
+  // AI가 못 채워도 버튼은 계속 돈다 — 조용히 넘어가면 사람이 왜 빈칸인지 모른다.
+  if (r.aiFailed) console.log(`AI가 못 채운 칸 ${r.aiFailed}개${r.aiError ? ` — ${r.aiError}` : ''}`);
+}
+
+
 async function cmdDbRows(args) {
   const target = args._[1];
   if (!target) throw new Error('사용법: rootr db rows <path|id> [--body] [--backlinks] [--json]');
@@ -1823,6 +2071,8 @@ async function main() {
       return cmdMv(args);
     case 'rm':
       return cmdRm(args);
+    case 'restore':
+      return cmdRestore(args);
     case 'ws':
       return cmdWs(args);
     case 'ask':

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 } = {}) {

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/misc.js

@@ -95,11 +95,12 @@ export function registerMiscTools(server) {
     {
       title: 'Rename / re-icon / move any node',
       description:
-        'Change a Rootr (루터) node\'s NAME, ICON, TAGS, or PARENT — works for every node type ' +
-        '(DOCUMENT, FOLDER, DATABASE, SPREADSHEET, FORM, …). Until now icons could only be set when a node ' +
+        'Change a Rootr (루터) node\'s NAME, ICON, TAGS, PARENT, or graph auto-extraction setting — works for every ' +
+        'node type (DOCUMENT, FOLDER, DATABASE, SPREADSHEET, FORM, …). Until now icons could only be set when a node ' +
         'was CREATED, so matching a migrated tree to its Notion icons was impossible without recreating ' +
         'everything. Only the fields you pass change. `parentId: null` moves the node to the workspace root; ' +
-        'a node cannot be moved inside its own subtree.',
+        'a node cannot be moved inside its own subtree. `graphSyncOff: true` stops rows/edits from queuing this ' +
+        'node (and DATABASE tables especially) for graph extraction — useful right before a bulk load.',
       annotations: { readOnlyHint: false, destructiveHint: false },
       inputSchema: {
         target: z.string().describe('Node path (starting with "/") or node id'),
@@ -111,9 +112,16 @@ export function registerMiscTools(server) {
           .nullable()
           .optional()
           .describe('Move under this folder/document/database (id or path). null = workspace root.'),
+        graphSyncOff: z
+          .boolean()
+          .optional()
+          .describe(
+            'true = stop queuing this node for graph extraction (embeddings + LLM) on every edit; false = ' +
+              're-enable it (and backfill affected documents).',
+          ),
       },
     },
-    async ({ target, name, icon, tags, parentId }) => {
+    async ({ target, name, icon, tags, parentId, graphSyncOff }) => {
       try {
         const client = makeClient();
         const id = requireResolved(await resolveTarget(client, target));
@@ -122,7 +130,7 @@ export function registerMiscTools(server) {
         if (typeof parentId === 'string' && parentId) {
           parent = requireResolved(await resolveTarget(client, parentId));
         }
-        const node = await client.updateNode(id, { name, icon, tags, parentId: parent });
+        const node = await client.updateNode(id, { name, icon, tags, parentId: parent, graphSyncOff });
         return jsonResult(node);
       } catch (err) {
         return errorResult(err);
@@ -148,7 +156,36 @@ export function registerMiscTools(server) {
         const resolved = await resolveTarget(client, target);
         const id = requireResolved(resolved);
         await client.deleteNode(id);
-        return jsonResult({ deleted: id, note: 'moved to trash, recoverable' });
+        return jsonResult({
+          deleted: id,
+          note: 'moved to trash, recoverable — rootr_restore_node puts it back',
+        });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_restore_node',
+    {
+      title: 'Restore a deleted node from the trash',
+      description:
+        'Put a trashed Rootr (루터) document, folder or table back where it was — the undo for ' +
+        'rootr_delete_node, and the same thing Ctrl+Z does in the app. Pass the node id you got back ' +
+        'from the delete (a path will NOT find it: a trashed node is no longer on the tree). ' +
+        'Children that went to the trash with it come back too. Needs WRITE on the node.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        nodeId: z
+          .string()
+          .describe('Node id of the trashed item (from the rootr_delete_node result or a notification)'),
+      },
+    },
+    async ({ nodeId }) => {
+      try {
+        const client = makeClient();
+        return jsonResult(await client.restoreNode(nodeId));
       } catch (err) {
         return errorResult(err);
       }

package/lib/mcp-tools/pages.js

@@ -0,0 +1,239 @@
+import { z } from 'zod';
+
+import {
+  jsonResult,
+  errorResult,
+  makeClient,
+  requireWorkspace,
+  resolveNodeId,
+  resolveOptionalNodeId,
+  NODE_TARGET_HINT,
+} from './shared.js';
+
+/**
+ * PAGE (web page) tools.
+ *
+ * A Rootr page is an ordered list of typed blocks — that is the safety model:
+ * a published page cannot carry a script or a phishing overlay. The agent's job
+ * is to CHOOSE BLOCKS. The one escape hatch is the `custom` block, whose free
+ * HTML/CSS renders inside a locked-down sandboxed iframe (no scripts, opaque
+ * origin, no network), so even bold CSS stays inside its own box.
+ *
+ * The guide below is repeated (shortened) on every tool, so an agent that only
+ * sees one of these tools still knows the block vocabulary.
+ */
+const BLOCK_GUIDE =
+  'A page is `blocks[]` (ordered, max 200) + `config`. Each block is {id?, type, props}. ' +
+  'You assemble a page from these 15 block types:\n' +
+  '· hero {title, subtitle?, align?:"left"|"center", background?:{kind:"color",color}|{kind:"image",attachmentId}, button?:{label,target}} — the opening banner\n' +
+  '· text {body (markdown), title?} — prose section; markdown is sanitized when rendered\n' +
+  '· features {columns?:1|2|3, items:[{title, body, icon?(emoji)}]} — "what it does" grid\n' +
+  '· gallery {images:[{attachmentId, caption?}]} — images must be workspace attachments (no external image URLs)\n' +
+  '· pricing {plans:[{name, price, period?, features:[string], highlight?, buttonLabel?, target?}]}\n' +
+  '· testimonials {items:[{quote, name, affiliation?}]}\n' +
+  '· faq {items:[{q, a}]}\n' +
+  '· timeline {items:[{date, title, body?}]}\n' +
+  '· cta {title, buttonLabel, target, body?} — closing call to action\n' +
+  '· footer {links:[{label, target}], contact?, copyright?}\n' +
+  '· liveStats {cards:[{label, icon?, source:{nodeId(DATABASE/LOG node), agg:"count"|"sum"|"avg"|"min"|"max", column?}}]} — numbers read LIVE from a table\n' +
+  '· liveTable {source:{nodeId}, columns?:[name], rowLimit?(1-200), orderBy?:{column, dir:"asc"|"desc"}}\n' +
+  '· liveChart {source:{nodeId}, chart:"bar"|"line"|"donut", labelColumn, valueColumn, agg:"count"|"sum"|"avg"}\n' +
+  '· form {formNodeId(FORM node), headline?, submitLabel?} — visitors submit right on the page\n' +
+  '· custom {html, height?(40-4000, default 260)} — free HTML/CSS, rendered inside a locked-down sandboxed iframe ' +
+  '(no scripts, no same-origin, no network). Use it for a look the other blocks cannot make. Page theme colors are ' +
+  'available inside as var(--pg-bg|text|muted|faint|card|line|accent|on-accent) and var(--pg-font). Scripts and ' +
+  'on*= handlers are stripped on save — do not put behaviour here, only markup and CSS.\n' +
+  'LIVE/FORM BLOCKS: `source.nodeId` / `formNodeId` must be a node in the SAME workspace, and `column`/`labelColumn`/' +
+  '`valueColumn`/`orderBy.column` are the column NAMES as shown in the table (not column ids). A table or form that ' +
+  'sits in a PRIVATE subtree is silently skipped on the published page — that is deliberate, never a bug to work around.\n' +
+  'LINKS: every `target` is {kind:"url", href} (absolute http(s)://, mailto: or tel: only) or {kind:"node", nodeId} ' +
+  'for a document in the same workspace. Internal path strings are rejected. A node link renders as the in-app ' +
+  'document for members, as the public address on the published page, and is hidden entirely if that document is ' +
+  'not published — so link to nodes rather than pasting addresses.\n' +
+  'CONFIG: {theme, accentColor?, navEnabled?}. theme is one of classic | minimal | warm | pastel | editorial | mono | ' +
+  'dark | midnight. accentColor is a hex like "#1A4A7A"; leave it out and the theme picks a matching accent. ' +
+  'Every published page carries the Rootr signature at the bottom.\n' +
+  'Block ids are optional — omit them and they are generated. Keep the ids you get back if you want to edit one block later.';
+
+/** PAGE (block-assembled web page) node tools: create/read/update/append + live values. */
+export function registerPageTools(server) {
+  server.registerTool(
+    'rootr_create_page',
+    {
+      title: 'Create a Rootr page (block-assembled web page)',
+      description:
+        'Create a new PAGE node in a Rootr (루터) workspace — a web page assembled from safe typed blocks, which ' +
+        'can then be published to the web at a public address (see rootr_publish_node). Use this when someone asks ' +
+        'for a landing page, an announcement page, an event page, a product/pricing page or a signup page. ' +
+        'Omit `blocks` to start from a hero/text/footer skeleton. ' +
+        BLOCK_GUIDE,
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        name: z.string().optional().describe('Page name (also the browser tab title of the published page)'),
+        parentId: z.string().optional().describe(`Parent folder/node id${NODE_TARGET_HINT}`),
+        path: z.string().optional().describe('Full path including the name, e.g. "/마케팅/가을 행사" — wins over parentId+name'),
+        createParents: z.boolean().optional().describe('Create missing parent folders in `path`'),
+        autoRename: z.boolean().optional().describe('On a name clash, append " (2)" instead of failing with 409'),
+        icon: z.string().optional().describe('Emoji icon for the page node'),
+        blocks: z.array(z.record(z.unknown())).optional().describe('Ordered blocks — see the block vocabulary in this description'),
+        config: z
+          .record(z.unknown())
+          .optional()
+          .describe('{theme, accentColor?, navEnabled?} — theme: classic|minimal|warm|pastel|editorial|mono|dark|midnight'),
+        workspace: z.string().optional().describe('Workspace id; defaults to ROOTR_WORKSPACE/config if omitted'),
+      },
+    },
+    async ({ name, parentId, path, createParents, autoRename, icon, blocks, config, workspace }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        const client = makeClient(ws);
+        parentId = await resolveOptionalNodeId(client, parentId);
+        return jsonResult(
+          await client.createPage(ws, { name, parentId, path, createParents, autoRename, icon, blocks, config }),
+        );
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_read_page',
+    {
+      title: 'Read a Rootr page',
+      description:
+        'Read a Rootr (루터) PAGE node — its full blocks array and config. Read this before rootr_update_page or ' +
+        'rootr_update_page_block so you know the current block ids, order and contents.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        pageId: z.string().describe(`PAGE node id${NODE_TARGET_HINT}`),
+      },
+    },
+    async ({ pageId }) => {
+      try {
+        const client = makeClient();
+        pageId = await resolveNodeId(client, pageId);
+        return jsonResult(await client.getPage(pageId));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_append_page_blocks',
+    {
+      title: 'Append blocks to a Rootr page (preferred way to add sections)',
+      description:
+        'Append one or more blocks to the END of a Rootr (루터) PAGE, leaving existing blocks untouched. ' +
+        'PREFER this over rootr_update_page when you are only adding sections — update replaces the whole page. ' +
+        BLOCK_GUIDE,
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        pageId: z.string().describe(`PAGE node id${NODE_TARGET_HINT}`),
+        blocks: z.array(z.record(z.unknown())).describe('Blocks to append, in order'),
+      },
+    },
+    async ({ pageId, blocks }) => {
+      try {
+        const client = makeClient();
+        pageId = await resolveNodeId(client, pageId);
+        return jsonResult(await client.appendPageBlocks(pageId, blocks));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_update_page',
+    {
+      title: 'Update a Rootr page (blocks/theme)',
+      description:
+        'Update a Rootr (루터) PAGE. Passing `blocks` REPLACES THE WHOLE PAGE — call rootr_read_page first and ' +
+        'resend every block you want to keep, or use rootr_append_page_blocks / rootr_update_page_block for ' +
+        'incremental edits. Passing only `config` changes the theme/accent without touching content. ' +
+        BLOCK_GUIDE,
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        pageId: z.string().describe(`PAGE node id${NODE_TARGET_HINT}`),
+        blocks: z
+          .array(z.record(z.unknown()))
+          .optional()
+          .describe('COMPLETE blocks array to set — any block you omit is deleted'),
+        config: z.record(z.unknown()).optional().describe('{theme, accentColor?, navEnabled?}'),
+      },
+    },
+    async ({ pageId, blocks, config }) => {
+      try {
+        const client = makeClient();
+        pageId = await resolveNodeId(client, pageId);
+        return jsonResult(await client.updatePage(pageId, { blocks, config }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_update_page_block',
+    {
+      title: 'Edit one block of a Rootr page',
+      description:
+        'Replace the props of a SINGLE block on a Rootr (루터) PAGE, leaving every other block alone — the safe way ' +
+        'to fix one section (a headline, a price, a live table source). The block keeps its id and position. ' +
+        'Get block ids from rootr_read_page. ' +
+        BLOCK_GUIDE,
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        pageId: z.string().describe(`PAGE node id${NODE_TARGET_HINT}`),
+        blockId: z.string().describe('Block id, from rootr_read_page'),
+        props: z.record(z.unknown()).describe('COMPLETE props object for this block type (replaces the old props)'),
+        type: z.string().optional().describe('Change the block type too (rare) — props must then match the new type'),
+      },
+    },
+    async ({ pageId, blockId, props, type }) => {
+      try {
+        const client = makeClient();
+        pageId = await resolveNodeId(client, pageId);
+        const page = await client.getPage(pageId);
+        const blocks = Array.isArray(page.blocks) ? page.blocks : [];
+        const idx = blocks.findIndex((b) => b && b.id === blockId);
+        if (idx === -1) {
+          // 있는 id를 알려 준다 — 못 찾았다고만 하면 다음 시도도 똑같이 틀린다.
+          const ids = blocks.map((b) => `${b.id}(${b.type})`).join(', ') || '(none)';
+          return errorResult(new Error(`block "${blockId}" not found on this page. Blocks: ${ids}`));
+        }
+        const next = blocks.map((b, i) => (i === idx ? { ...b, ...(type ? { type } : {}), props } : b));
+        return jsonResult(await client.updatePage(pageId, { blocks: next }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_read_page_live_data',
+    {
+      title: 'Read what a page\'s live blocks currently show',
+      description:
+        'Read the values a Rootr (루터) PAGE\'s live blocks (liveStats/liveTable/liveChart) are showing right now — ' +
+        'the aggregates, rows and chart points computed from their source tables. Use it to check that a live block ' +
+        'points at the right table and column: an empty result usually means the source is missing, is in a PRIVATE ' +
+        'subtree, or the column name does not match.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        pageId: z.string().describe(`PAGE node id${NODE_TARGET_HINT}`),
+      },
+    },
+    async ({ pageId }) => {
+      try {
+        const client = makeClient();
+        pageId = await resolveNodeId(client, pageId);
+        return jsonResult(await client.getPageLiveData(pageId));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+}

package/lib/mcp-tools/recordings.js

@@ -208,6 +208,7 @@ export function registerRecordingTools(server) {
         'UPLOADED = audio stored but no transcript yet — call rootr_transcribe_recording to create one; ' +
         'TRANSCRIBING = speech-to-text still running (poll again later); ' +
         'READY = transcript available; FAILED = last transcription errored (see `error`).',
+      annotations: { readOnlyHint: true, destructiveHint: false },
       inputSchema: {
         recordingId: z.string().describe(`RECORDING node id${NODE_TARGET_HINT}`),
       },
@@ -242,6 +243,7 @@ export function registerRecordingTools(server) {
         'Assign display names to the diarized speaker labels of a Rootr (루터) RECORDING node, e.g. ' +
         '{"S1":"김대표","S2":"이팀장"}. Merge-patch: only the keys you send change. The names apply to the ' +
         'transcript everywhere (web UI, rootr_read_recording, knowledge graph).',
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
       inputSchema: {
         recordingId: z.string().describe(`RECORDING node id${NODE_TARGET_HINT}`),
         speakerNames: z

package/lib/mcp-tools/spreadsheets.js

@@ -88,7 +88,8 @@ export function registerSpreadsheetTools(server) {
         'Merge-patch a Rootr (루터) SPREADSHEET: update config/icon, or REPLACE THE WHOLE sheets array (if you ' +
         'pass `sheets`, it replaces every existing sheet — call rootr_read_spreadsheet first and resend sheets ' +
         'you want to keep, or prefer rootr_create_sheet / rootr_patch_spreadsheet_cells for incremental changes).',
-      annotations: { readOnlyHint: false, destructiveHint: false },
+      // `sheets`를 주면 시트 배열 전체를 갈아끼운다 — 안 보낸 시트는 사라진다.
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
       inputSchema: {
         spreadsheetId: z.string().describe(`SPREADSHEET node id${NODE_TARGET_HINT}`),
         sheets: z

package/lib/mcp-tools/templates.js

@@ -132,7 +132,8 @@ export function registerTemplateTools(server) {
         'Change a Rootr (루터) template — its name, emoji, description or `spec`. Editing a builtin transparently ' +
         'creates a workspace copy, so the builtin itself is never damaged. Use this for "change the standard format" ' +
         'requests instead of saving a second near-identical template.',
-      annotations: { readOnlyHint: false, destructiveHint: false },
+      // `spec`을 주면 템플릿 정의를 통째로 덮어쓴다(버전 기록 없음).
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
       inputSchema: {
         templateId: z.string().describe('Template id from rootr_list_templates'),
         name: z.string().optional().describe('New name'),

package/lib/mcp-tools/whiteboards.js

@@ -139,7 +139,8 @@ export function registerWhiteboardTools(server) {
         'content). merge=false/omitted REPLACES the whole scene — call rootr_read_whiteboard first and resend ' +
         'anything you want to keep. ' +
         AUTHORING_GUIDE,
-      annotations: { readOnlyHint: false, destructiveHint: false },
+      // merge=false 면 장면 전체를 갈아끼운다 — 사람이 손으로 그린 것까지 날아간다.
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
       inputSchema: {
         whiteboardId: z.string().describe(`WHITEBOARD node id${NODE_TARGET_HINT}`),
         scene: z

package/lib/mcp.js

@@ -13,6 +13,7 @@ import { registerMiscTools } from './mcp-tools/misc.js';
 import { registerPublicTools } from './mcp-tools/public.js';
 import { registerCrmTools } from './mcp-tools/crm.js';
 import { registerPresentationTools } from './mcp-tools/presentations.js';
+import { registerPageTools } from './mcp-tools/pages.js';
 import { registerSpreadsheetTools } from './mcp-tools/spreadsheets.js';
 import { registerWhiteboardTools } from './mcp-tools/whiteboards.js';
 import { registerFormTools } from './mcp-tools/forms.js';
@@ -261,6 +262,7 @@ export function buildMcpServer({ name, version }) {
   registerPublicTools(server);
   registerCrmTools(server);
   registerPresentationTools(server);
+  registerPageTools(server);
   registerSpreadsheetTools(server);
   registerWhiteboardTools(server);
   registerFormTools(server);

package/package.json

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