rootr-cli 0.24.0 → 0.25.0

package/README.ko.md

@@ -307,20 +307,30 @@ rootr sign ledger          # 워크스페이스 원장 전체 재계산
 
 ### 문서 보내기 · 문서함 (send · mail)
 
-폴더만 빼고 어떤 노드든 이메일 1~20명에게 **보낼 때의 복사본**으로 보낼 수 있습니다. 담기는 내용은
-공개 페이지와 같아서 사람·첨부·관계 칸은 나가지 않습니다. 받는 사람은 메일 링크로 **루터 계정 없이**
-열고, 그 이메일에 루터 계정이 있거나 나중에 가입하면 받은 문서함에도 그대로 있습니다. 보낸 뒤 원본을
-고치거나 지워도 받은 문서는 그대로입니다. 보내려면 그 노드에 쓰기(WRITE) 권한이 있어야 합니다(공유와 같은 문턱).
+어떤 노드든(폴더 포함) 이메일 1~20명에게 보낼 수 있습니다. **복사본이 아니라 원본 그 문서**를 그 이메일에
+열어 주는 것입니다 — `--access read`(보기, 기본) · `comment`(댓글) · `write`(편집). 받는 사람은 언제나 최신
+내용을 보고, 편집을 받았으면 원본을 직접 고칩니다. 그 이메일(인증된)의 루터 계정은 우리 워크스페이스 구성원이
+아니어도 문서함에서 그 문서만 엽니다(트리·구성원·검색은 안 보임). 계정이 없으면 메일 링크에서 받은 이메일을
+넣어야 읽기 전용으로 보입니다. 보내려면 그 노드에 구성원으로서 쓰기(WRITE) 권한이 있어야 하고(공유와 같은
+문턱), 내 권한까지만 줄 수 있습니다.
 
 ```bash
-rootr send "/보고서/3분기 실적" --to partner@example.com,cfo@example.com --message "말씀드린 자료입니다"
+rootr send "/보고서/3분기 실적" --to partner@example.com,cfo@example.com --access comment --message "말씀드린 자료입니다"
 rootr mail                 # 받은 문서 (안 읽은 수 함께)
-rootr mail sent            # 보낸 문서 — 읽었는지, 메일 실패
-rootr mail show <id>       # 열기 (문서는 마크다운 본문, 그 밖은 --json 으로 전부)
-rootr mail revoke <id>     # 회수 — 받는 쪽에서 본문이 안 보이고 링크는 410
+rootr mail sent            # 보낸 문서 — 권한·읽었는지·메일 실패
+rootr mail show <id>       # 지금 내용 (문서는 마크다운 본문, 그 밖은 --json 으로 전부, 폴더 안은 --node <아래 id>)
+rootr mail access <id> write   # 받는 사람 권한 바꾸기
+rootr mail revoke <id>     # 회수 — 받는 사람이 바로 못 열고 링크는 410
 rootr mail hide <id>       # 내 문서함에서만 지우기
+rootr mail webhook add https://example.com/hooks/rootr   # 내 계정 웹훅: doc_mail.received / revoked / read
+rootr mail webhook list | rm <id> | test <id>
 ```
 
+다른 명령을 쓰고 나면 새로 받은 문서가 있을 때 stderr 로 한 줄이 나옵니다(`📬 받은 문서 2건 — … · rootr mail`).
+stdout 과 `--json` 출력은 그대로입니다. 끄려면 `ROOTR_MAIL_NOTICE=0`. MCP 서버는 같은 소식을 아무 도구 응답 끝에
+키마다 한 번 붙입니다. 웹훅 요청은 서명되어 있습니다 — `add` 때 한 번 보이는 비밀값으로
+`X-Rootr-Signature: sha256=HMAC_SHA256(secret, 원문)` 을 확인하세요. 몸통에는 문서 내용이 없습니다(`apiUrl` 을 부르세요).
+
 ### 제보 보내기 (feedback)
 
 ```bash
@@ -368,7 +378,7 @@ rootr memory forget <id>                         # 폐기(--hard면 행 삭제)
 
 ## MCP 서버로 사용하기
 
-`rootr mcp`는 stdio로 MCP(Model Context Protocol) 서버를 구동합니다. 제공 도구 197종:
+`rootr mcp`는 stdio로 MCP(Model Context Protocol) 서버를 구동합니다. 제공 도구 202종:
 
 노드를 가리키는 인자(`target`, `databaseId`, `spreadsheetId`, `formId`, `crmId`, `trackerId`,
 `recordingId`, `presentationId`, `whiteboardId`, `logId`, `parentId` 등)는 **노드 id와 경로를 모두**
@@ -651,7 +661,7 @@ rootr db view <표> <뷰> --scale year       # 달력 보기를 주·달·해
 
 | 도구 | 설명 |
 |---|---|
-| `rootr_publish_node` | **아무 노드나** 공개 — 문서·표·폼·시트·화이트보드·덱, 하위까지 |
+| `rootr_publish_node` | **아무 노드나** 공개 — 문서·표·폼·시트·화이트보드·덱·페이지, 하위까지. **페이지(PAGE)는 Team 플랜부터**(무료는 403 `PLAN_UPGRADE_REQUIRED`, 하위 포함 시 페이지는 건너뛰고 개수를 알려 줌) |
 | `rootr_set_node_public` | 이미 공개한 것의 설정 변경(하위 포함 여부·검색 노출·만료) |
 | `rootr_node_public_status` | 지금 공개돼 있는지, 주소는 무엇인지 |
 | `rootr_publish_document` | 문서 전용 발행(구형 — 새로 짤 때는 `rootr_publish_node`) |
@@ -819,10 +829,15 @@ rootr db view <표> <뷰> --scale year       # 달력 보기를 주·달·해
 
 | 도구 | 설명 |
 |---|---|
-| `rootr_send_document` | 노드 하나를 이메일 1~20명에게 보낼 때의 복사본으로 보내기 (계정 없어도 메일 링크로 열림) |
-| `rootr_list_doc_mail` | 내 문서함 — `box`: inbox(받은, 기본) / sent(보낸), 안 읽은 수 함께 |
-| `rootr_read_doc_mail` | 한 통 열기 — 본문(`payload`), 받은 것은 읽음 처리, 회수된 것은 본문 없음 |
-| `rootr_revoke_doc_mail` | 보낸 문서 회수 (보낸 사람만) |
+| `rootr_send_document` | 노드 하나를 이메일 1~20명에게 보내기 — 복사본이 아니라 원본을 `access`(read 보기·comment 댓글·write 편집)만큼 열어 줌 |
+| `rootr_list_doc_mail` | 내 문서함 — `box`: inbox(받은, 기본) / sent(보낸), 안 읽은 수·권한·원본 상태 함께 |
+| `rootr_read_doc_mail` | 한 통 열기 — 원본의 지금 내용(읽기 전용)·권한·원본 주소, 폴더면 `node` 로 아래 것, 받은 것은 읽음 처리 |
+| `rootr_set_doc_mail_access` | 보낸 문서의 받는 사람 권한 바꾸기 (보낸 사람만, 내 권한까지) |
+| `rootr_revoke_doc_mail` | 보낸 문서 회수 — 받는 사람이 바로 못 연다 (보낸 사람만) |
+| `rootr_add_doc_mail_webhook` | 내 계정 받은 문서 웹훅 만들기 — doc_mail.received·revoked·read, HMAC 서명, 비밀값은 한 번만 |
+| `rootr_list_doc_mail_webhooks` | 내 받은 문서 웹훅 목록(마지막 전달 상태) |
+| `rootr_remove_doc_mail_webhook` | 내 받은 문서 웹훅 지우기 |
+| `rootr_test_doc_mail_webhook` | 시험 전송(doc_mail.test) 후 전달 결과 |
 
 문서함은 워크스페이스가 아니라 **사람(이메일)**에 붙습니다. 사람 없는 워크스페이스 키(원격 커넥터)는
 그 키를 만든 구성원으로 동작합니다.
@@ -899,6 +914,10 @@ DATABASE·SPREADSHEET·LOG 노드이고, 칸은 **이름**으로 가리킵니다
 페이지에서 조용히 빠집니다(일부러 그렇습니다).
 
 공개는 여느 노드와 같습니다: `POST /v1/nodes/:id/publish` → `rootr.io/p/{slug}`.
+단 **페이지를 웹에 게시하는 것은 Team 플랜부터**입니다 — 무료 워크스페이스는 403 `PLAN_UPGRADE_REQUIRED`
+(아무것도 바뀌지 않음). 무료에서도 페이지를 만들고 편집하고 워크스페이스 안에서 보는 것은 그대로 됩니다.
+Team 에서 공개한 뒤 무료로 내려가면 공개 설정은 남아 있지만 방문자에게는 "게시되어 있지 않습니다" 화면이
+나가고, 다시 Team 으로 올리면 같은 주소가 다시 발행하지 않아도 열립니다.
 
 #### 프레젠테이션
 

package/README.md

@@ -11,7 +11,7 @@ citations back to the exact paragraph.
 *(한국어 문서: [README.ko.md](https://github.com/gwmage/rootr-cli/blob/main/README.ko.md))*
 
 - `rootr` CLI — documents, databases, forms, signed documents, publishing, permissions, memory
-- `rootr mcp` — stdio MCP server, **197 tools** (see [MCP tools](#mcp-tools))
+- `rootr mcp` — stdio MCP server, **202 tools** (see [MCP tools](#mcp-tools))
 
 Plain Node.js ESM, no build step. Node 18+ (uses the built-in `fetch`).
 
@@ -269,7 +269,15 @@ rootr publish /handbook --status                # is it public, at what URL, chi
 rootr publish /projects/tasks --layout board --skin paper   # 9 layouts × 6 skins
 rootr publish /handbook/policy.md --comments --expires 2026-12-31T00:00:00Z
 rootr publish /handbook --off
+```
+
+Every node type publishes on the Free plan **except PAGE** (the block-built web page): publishing a
+page to the web needs the **Team plan**. On Free, `rootr publish <page>` fails with
+`PLAN_UPGRADE_REQUIRED` and nothing changes; `--children` skips pages underneath and says how many.
+A page published on Team stays saved if the workspace later drops to Free — visitors see a
+"not published" screen until it is upgraded again, and `--status` says so.
 
+```bash
 rootr access /handbook --private                # or --public / --inherit
 rootr access /handbook --grant <userId> --level WRITE
 rootr access /handbook --revoke <userId>
@@ -329,21 +337,32 @@ regulations require both the original and the trace of the change to remain visi
 
 ### Sending a document to someone (mailbox)
 
-Any node except a folder can be emailed to 1–20 addresses as a **copy taken at send time** — the
-same content a public page shows, so person / attachment / relation columns never go out. The
-recipient opens it from the email link **without a Rootr account**; if that address has (or later
-gets) a Rootr account, it is also in their inbox. Editing or deleting the original afterwards does
-not change what they received. Sending needs WRITE on the node, the same bar as sharing.
+Any node — a folder too — can be sent to 1–20 email addresses. It is **not a copy**: the address
+gets access to the **original** at `--access read` (view, default) · `comment` · `write` (edit), so
+they always see the latest version and, with `write`, edit the original itself. A Rootr account on
+that (verified) email opens it from its inbox even if it is not in your workspace — it sees that
+node only, never your tree, members or search. Without an account the email link asks for the
+address and then shows it read-only. Sending needs WRITE on the node as a member (the same bar as
+sharing); you can give at most your own level.
 
 ```bash
-rootr send "/reports/Q3 numbers" --to partner@example.com,cfo@example.com --message "As discussed"
+rootr send "/reports/Q3 numbers" --to partner@example.com,cfo@example.com --access comment --message "As discussed"
 rootr mail                 # received (with the unread count)
-rootr mail sent            # what you sent — read or not, email failures
-rootr mail show <id>       # open it (a document prints its markdown; --json for any type)
-rootr mail revoke <id>     # withdraw: the recipient no longer sees the content, the link answers 410
+rootr mail sent            # what you sent — access, read or not, email failures
+rootr mail show <id>       # the current content (a document prints its markdown; --json for any type; --node <child> inside a folder)
+rootr mail access <id> write   # change what the recipient can do
+rootr mail revoke <id>     # withdraw: the recipient loses access at once, the link answers 410
 rootr mail hide <id>       # remove from your own mailbox only
+rootr mail webhook add https://example.com/hooks/rootr   # your own webhook: doc_mail.received / revoked / read
+rootr mail webhook list | rm <id> | test <id>
 ```
 
+After any other command, newly received documents print one line to stderr
+(`📬 2 new documents received — … · rootr mail`); stdout and `--json` stay clean. Turn it off with
+`ROOTR_MAIL_NOTICE=0`. The MCP server appends the same news to the end of any tool result, once
+per key. Webhook requests are signed: verify `X-Rootr-Signature: sha256=HMAC_SHA256(secret, raw body)`
+with the secret shown once at `add`. The body never contains the document — GET its `apiUrl`.
+
 ### Team memory
 
 ```bash
@@ -425,7 +444,7 @@ is refused and says when the grace was used.
 
 ## MCP tools
 
-`rootr mcp` speaks MCP over stdio. 197 tools:
+`rootr mcp` speaks MCP over stdio. 202 tools:
 
 | Group | Count | Tools |
 |---|---|---|
@@ -543,7 +562,8 @@ takes `width: half | third | twoThirds` so a page becomes a **live dashboard**
 published separately. Tables and forms that live under a PRIVATE subtree are silently dropped
 from a public page, on purpose.
 
-Publishing works like any other node: `POST /v1/nodes/:id/publish` → `rootr.io/p/{slug}`.
+Publishing works like any other node: `POST /v1/nodes/:id/publish` → `rootr.io/p/{slug}` —
+**Team plan and up** for pages (Free → `403 PLAN_UPGRADE_REQUIRED`; pages still work inside the workspace).
 
 ### Embedding a table inside a document
 

package/bin/rootr.js

@@ -6,6 +6,7 @@ import { dirname, join, basename, extname } from 'node:path';
 import { loadConfig, saveConfig, keyForWorkspace, maskKey, upsertKey, CONFIG_PATH, DEFAULT_BASE_URL } from '../lib/config.js';
 import { candidateClients, rememberWorkspace, resolveWorkspaceSwitch, surveyWorkspaces } from '../lib/credentials.js';
 import { RootrClient, RootrApiError, imageMarkdown } from '../lib/client.js';
+import { setGlobalDocMailSink } from '../lib/context.js';
 import { resolveTarget, requireResolved, resolveMoveDestination } from '../lib/resolve.js';
 import { t as tr, lang } from '../lib/i18n.js';
 
@@ -95,11 +96,16 @@ const USAGE_KO = `Rootr CLI v${pkg.version}
   rootr sign list [--pending] [--status <S>] [--mode <M>] [--json]  서명문서 목록 (--pending: 내 차례)
   rootr sign bulk <id…> --code <6자리>              여러 건 한 번에 올리기+서명 (코드 하나로, 초안 포함)
   rootr sign ledger [--json]                       워크스페이스 원장(해시 체인) 전체 검증
-  rootr send <path|id> --to a@x.com[,b@y.com] [--message "..."]  문서(어떤 타입이든)를 이메일로 보내기 — 보낼 때의 복사본, 계정 없어도 열림
+  rootr send <path|id> --to a@x.com[,b@y.com] [--access read|comment|write] [--message "..."]
+                                                   문서(어떤 타입이든)를 이메일로 보내기 — 복사본이 아니라 원본을 그 이메일에 열어 줌(기본 보기)
   rootr mail [inbox|sent] [--limit N] [--q <찾기>] [--json]  문서함 — 받은 문서(기본)·보낸 문서
-  rootr mail show <id> [--json]                    받은/보낸 문서 열기(문서면 본문, 그 밖은 요약) — 받은 것은 읽음 처리
-  rootr mail revoke <id>                           보낸 문서 회수 — 받는 쪽에서 본문이 안 보임
-  rootr mail hide <id> [--box inbox|sent]          내 문서함에서만 지우기(상대 화면은 그대로)
+  rootr mail show <id> [--node <아래 노드 id>] [--json]  받은/보낸 문서의 지금 내용(문서면 본문, 그 밖은 요약) — 받은 것은 읽음 처리
+  rootr mail access <id> read|comment|write        보낸 문서의 받는 사람 권한 바꾸기
+  rootr mail revoke <id>                           보낸 문서 회수 — 받는 사람이 원본을 더 못 연다
+  rootr mail hide <id> [--box inbox|sent]          내 문서함에서만 지우기(받은 것을 지우면 그 계정으로는 더 안 열린다)
+  rootr mail webhook add <url> [--events …] | list | rm <id> | test <id>
+                                                   받은 문서·회수·읽음을 내 주소로 알려 주는 웹훅(내 계정 것, HMAC 서명)
+                                                   ※ 다른 명령 뒤 새로 받은 문서가 있으면 stderr 로 한 줄 알림(끄기: ROOTR_MAIL_NOTICE=0)
   rootr config [--api-key <k>] [--workspace <w>] [--base-url <u>]  설정 조회/저장
   rootr config --add-key <k> [--label <name>] [--workspace <w>]     워크스페이스별 키 추가 등록
   rootr feedback "<무엇이 안 되는지>" [--kind bug|friction|idea|praise] [--email <주소>]
@@ -206,11 +212,13 @@ usage:
   rootr sign list [--pending] [--status <S>] [--mode <M>] [--json]  list signed documents (--pending: waiting on you)
   rootr sign bulk <id…> --code <6 digits>           submit+sign many at once (one code, drafts included)
   rootr sign ledger [--json]                       verify the whole workspace ledger (hash chain)
-  rootr send <path|id> --to a@x.com[,b@y.com] [--message "..."]  email any node as a frozen copy — opens without an account
+  rootr send <path|id> --to a@x.com[,b@y.com] [--access read|comment|write] [--message "..."]
+                                                   give email addresses access to any node — the original itself, not a copy (default: read)
   rootr mail [inbox|sent] [--limit N] [--q <text>] [--json]  your document mailbox — received (default) or sent
-  rootr mail show <id> [--json]                    open a received/sent document (body for docs, a summary otherwise); marks received ones read
-  rootr mail revoke <id>                           withdraw a document you sent — the recipient no longer sees the content
-  rootr mail hide <id> [--box inbox|sent]          remove from your own mailbox only (the other side keeps it)
+  rootr mail show <id> [--node <child id>] [--json]  the document's current content (body for docs, a summary otherwise); marks received ones read
+  rootr mail access <id> read|comment|write        change what the recipient of a document you sent can do
+  rootr mail revoke <id>                           withdraw a document you sent — the recipient can no longer open the original
+  rootr mail hide <id> [--box inbox|sent]          remove from your own mailbox (a received one then stops opening for your account)
   rootr config [--api-key <k>] [--workspace <w>] [--base-url <u>]  read/save configuration
   rootr config --add-key <k> [--label <name>] [--workspace <w>]     register an extra per-workspace key
   rootr feedback "<what is not working>" [--kind bug|friction|idea|praise] [--email <address>]
@@ -1749,6 +1757,18 @@ async function cmdPublish(args) {
       console.log(tr('이 종류는 공개할 수 없습니다(폴더).', `This node type cannot be published (folder).`));
       return;
     }
+    if (st.closed === 'PAGE_PUBLISH_REQUIRES_TEAM') {
+      // PAGE-PUBLISH-TEAM — 공개는 켜져 있지만 워크스페이스가 무료라 방문자에게 안 보인다. Team 으로 올리면 같은 주소가 다시 열린다.
+      console.log(tr(`공개가 켜져 있지만 지금은 방문자에게 보이지 않습니다(주소: /p/${st.slug}).`, `Publishing is on, but visitors cannot see it right now (address: /p/${st.slug}).`));
+      console.log(
+        '  ' +
+          tr(
+            '페이지를 웹에 게시하는 기능은 Team 플랜에서만 됩니다. Team 으로 올리면 다시 발행하지 않아도 같은 주소로 열립니다.',
+            'Publishing pages to the web needs the Team plan. Upgrade to Team and the same address opens again — no need to publish again.',
+          ),
+      );
+      return;
+    }
     if (st.closed) {
       // 공개를 끈 것과 다르다 — 설정은 켜져 있고, "본인이 만든 행만" 표의 행에서 나온 것이라 지금 닫혀 있다(서버 응답의 closed)
       console.log(tr(`공개가 켜져 있지만 지금은 닫혀 있습니다(주소: /p/${st.slug}).`, `Publishing is on, but it is closed right now (address: /p/${st.slug}).`));
@@ -1833,6 +1853,15 @@ async function cmdPublish(args) {
   });
   console.log(tr(`공개했습니다: /p/${res.slug}`, `Published: /p/${res.slug}`));
   if (args.children) console.log(tr('  이 문서 아래 전부(손자·증손자 포함)도 각자 주소로 공개됩니다.', `  Everything under this document (grandchildren included) gets its own public address.`));
+  if (res.skippedPagesRequireTeam) {
+    // PAGE-PUBLISH-TEAM — 무료 워크스페이스에서는 아래의 페이지(PAGE)는 따라 나가지 않는다.
+    console.log(
+      tr(
+        `  단, 아래의 페이지 ${res.skippedPagesRequireTeam}개는 공개하지 않았습니다 — 페이지를 웹에 게시하는 기능은 Team 플랜부터입니다.`,
+        `  ${res.skippedPagesRequireTeam} page(s) underneath were NOT published — publishing pages to the web needs the Team plan.`,
+      ),
+    );
+  }
   if (Object.keys(design).length) {
     console.log(tr(`  보이는 방식: ${res.design?.layout ?? 'table'} / ${res.design?.skin ?? 'clean'}`, `  looks like: ${res.design?.layout ?? 'table'} / ${res.design?.skin ?? 'clean'}`));
   }
@@ -3074,7 +3103,7 @@ async function cmdSign(args) {
 // ---- doc mail (DOC-MAIL — 문서 송수신) ------------------------------------
 
 const MAIL_USAGE =
-  usage(`rootr mail [inbox|sent] | show <id> | revoke <id> | hide <id>\n`) +
+  usage(`rootr mail [inbox|sent] | show <id> | access <id> <read|comment|write> | revoke <id> | hide <id> | webhook …\n`) +
   tr('       (자세한 건 rootr --help)', `       (see rootr --help)`);
 
 const NODE_TYPE_KO = {
@@ -3092,23 +3121,34 @@ const NODE_TYPE_KO = {
   SIGNED: tr('서명문서', 'signed document'),
 };
 
+const ACCESS_LABEL = {
+  READ: tr('보기', 'view'),
+  COMMENT: tr('댓글', 'comment'),
+  WRITE: tr('편집', 'edit'),
+};
+
 async function cmdSend(args) {
   const target = args._[0];
   const toArg = typeof args.to === 'string' ? args.to : '';
   const to = toArg.split(/[,;\s]+/).map((s) => s.trim()).filter(Boolean);
-  if (!target || !to.length) {
-    throw new Error(usage(tr(`rootr send <path|id> --to a@x.com[,b@y.com] [--message "..."]`, `rootr send <path|id> --to a@x.com[,b@y.com] [--message "..."]`)));
+  const SEND_USAGE = `rootr send <path|id> --to a@x.com[,b@y.com] [--access read|comment|write] [--message "..."]`;
+  if (!target || !to.length) throw new Error(usage(SEND_USAGE));
+  const access = typeof args.access === 'string' ? args.access.trim().toLowerCase() : undefined;
+  if (access && !['read', 'comment', 'write', 'view', 'edit'].includes(access)) {
+    throw new Error(tr(`--access 는 read(보기)·comment(댓글)·write(편집) 중 하나입니다.`, `--access must be read, comment or write.`));
   }
   const client = makeClient();
   const nodeId = requireResolved(await resolveTarget(client, target));
-  const out = await client.sendNode(nodeId, { to, message: typeof args.message === 'string' ? args.message : undefined });
+  const out = await client.sendNode(nodeId, { to, access, message: typeof args.message === 'string' ? args.message : undefined });
   if (args.json) return console.log(JSON.stringify(out, null, 2));
   const items = out.items ?? [];
-  console.log(tr(`${items.length}명에게 보냈습니다 (묶음 ${out.batchId})`, `Sent to ${items.length} ${items.length === 1 ? 'person' : 'people'} (batch ${out.batchId})`));
+  const lvl = ACCESS_LABEL[out.access] ?? out.access;
+  console.log(tr(`${items.length}명에게 보냈습니다 — 원본을 ${lvl} 권한으로 열어 줌 (묶음 ${out.batchId})`, `Sent to ${items.length} ${items.length === 1 ? 'person' : 'people'} — they can ${lvl} the original (batch ${out.batchId})`));
   for (const it of items) {
     console.log(
       `  ${it.to}\t${it.id}\t` +
-        (it.emailed ? tr('메일 보냄', 'emailed') : tr(`메일 실패${it.error ? `: ${it.error}` : ''} — 문서는 받은 문서함에 있습니다`, `email failed${it.error ? `: ${it.error}` : ''} — the copy is still in their inbox`)),
+        (it.emailed ? tr('메일 보냄', 'emailed') : tr(`메일 실패${it.error ? `: ${it.error}` : ''} — 권한은 그대로 있습니다(받은 문서함)`, `email failed${it.error ? `: ${it.error}` : ''} — the access still stands (their inbox)`)) +
+        (it.resent ? tr('  (다시 보냄 — 권한·메시지만 바꿈)', '  (re-sent — access/message updated)') : ''),
     );
   }
 }
@@ -3132,34 +3172,41 @@ async function cmdMail(args) {
       const type = NODE_TYPE_KO[m.nodeType] ?? m.nodeType;
       const state = m.revoked
         ? tr('[회수됨]', '[withdrawn]')
+        : m.originalDeleted
+          ? tr('[원본 삭제됨]', '[original deleted]')
         : box === 'inbox'
           ? m.readAt ? '' : tr('[새 문서]', '[new]')
           : m.readAt ? tr(`[읽음 ${mailWhen(m.readAt)}]`, `[read ${mailWhen(m.readAt)}]`) : tr('[안 읽음]', '[unread]');
       const who = box === 'inbox' ? `${m.senderName} <${m.senderEmail}>` : `→ ${m.recipientEmail}`;
       const mailFail = box === 'sent' && m.emailed === false ? tr('  [메일 실패]', '  [email failed]') : '';
-      console.log(`${m.id}\t${mailWhen(m.createdAt)}\t${type}\t${m.title}\t${who}${state ? `  ${state}` : ''}${mailFail}`);
+      const lvl = ACCESS_LABEL[m.access] ? ` (${ACCESS_LABEL[m.access]})` : '';
+      console.log(`${m.id}\t${mailWhen(m.createdAt)}\t${type}${lvl}\t${m.title}\t${who}${state ? `  ${state}` : ''}${mailFail}`);
       if (m.message) console.log(`    ${String(m.message).split('\n')[0].slice(0, 100)}`);
     }
     if (out.nextCursor) console.log(tr(`\n다음 쪽: rootr mail ${box} --cursor ${out.nextCursor}`, `\nNext page: rootr mail ${box} --cursor ${out.nextCursor}`));
     return;
   }
+  if (sub === 'webhook' || sub === 'webhooks') return cmdMailWebhook(client, args);
   const id = args._[1];
   if (!id) throw new Error(MAIL_USAGE);
   switch (sub) {
     case 'show':
     case 'read': {
-      const m = await client.getDocMail(id);
+      const m = await client.getDocMail(id, { node: typeof args.node === 'string' ? args.node : undefined });
       if (args.json) return console.log(JSON.stringify(m, null, 2));
-      console.log(`${m.title}  (${NODE_TYPE_KO[m.nodeType] ?? m.nodeType})`);
+      console.log(`${m.title}  (${NODE_TYPE_KO[m.nodeType] ?? m.nodeType} · ${tr('권한', 'access')} ${ACCESS_LABEL[m.access] ?? m.access})`);
       console.log(tr(`보낸 사람: ${m.senderName} <${m.senderEmail}> · ${m.workspaceName}`, `From: ${m.senderName} <${m.senderEmail}> · ${m.workspaceName}`));
       console.log(tr(`받는 사람: ${m.recipientEmail} · 보낸 때 ${mailWhen(m.createdAt)}${m.readAt ? ` · 읽음 ${mailWhen(m.readAt)}` : ''}`, `To: ${m.recipientEmail} · sent ${mailWhen(m.createdAt)}${m.readAt ? ` · read ${mailWhen(m.readAt)}` : ''}`));
       if (m.message) console.log(tr(`메시지: ${m.message}`, `Message: ${m.message}`));
-      if (m.revoked && !m.payload) return console.log(tr('\n보낸 사람이 이 문서를 회수했습니다.', '\nThe sender withdrew this document.'));
-      if (m.revoked) console.log(tr('(회수함 — 받는 쪽에서는 본문이 안 보입니다)', '(withdrawn — the recipient no longer sees the content)'));
+      if (m.revoked && m.viewer !== 'sender') return console.log(tr('\n보낸 사람이 이 문서를 회수했습니다.', '\nThe sender withdrew this document.'));
+      if (m.originalDeleted) return console.log(tr('\n원본이 삭제되었습니다.', '\nThe original has been deleted.'));
+      if (m.revoked) console.log(tr('(회수함 — 받는 사람은 더 못 엽니다)', '(withdrawn — the recipient can no longer open it)'));
+      if (m.openUrl) console.log(tr(`원본 열기(편집기): ${m.openUrl}`, `Open the original (editor): ${m.openUrl}`));
+      if (m.picked) console.log(tr(`보고 있는 것: ${m.picked.name} (${m.picked.id})`, `Showing: ${m.picked.name} (${m.picked.id})`));
       const p = m.payload ?? {};
       console.log('');
-      if (p.kind === 'doc') return console.log(p.content ?? '');
-      if (p.kind === 'database') {
+      if (typeof m.contentMd === 'string' || p.kind === 'doc') console.log(m.contentMd ?? p.content ?? '');
+      else if (p.kind === 'database') {
         const props = p.properties ?? [];
         const rows = p.rows ?? [];
         console.log(props.map((c) => c.name).join('\t'));
@@ -3169,30 +3216,107 @@ async function cmdMail(args) {
             return v === null || v === undefined ? '' : typeof v === 'object' ? JSON.stringify(v) : String(v);
           }).join('\t'));
         }
-        if (p.truncated) console.log(tr(`… ${p.truncated.total}행 중 ${p.truncated.shown}행만 담겼습니다`, `… ${p.truncated.shown} of ${p.truncated.total} rows were included`));
-        return;
+        if (p.truncated) console.log(tr(`… ${p.truncated.total}행 중 ${p.truncated.shown}행만 보입니다`, `… showing ${p.truncated.shown} of ${p.truncated.total} rows`));
+        if (p.rowsHidden === 'booking') console.log(tr('(예약을 받는 표라 행은 안 보입니다)', '(a booking table — rows are not shown)'));
+      } else if (p.kind) {
+        const keys = Object.keys(p).filter((k) => k !== 'kind');
+        console.log(tr(`[${p.kind}] 담긴 것: ${keys.join(', ')} — 전부 보려면 --json`, `[${p.kind}] contains: ${keys.join(', ')} — use --json for everything`));
+      }
+      if (m.children?.length) {
+        console.log(tr('\n안에 든 것 (rootr mail show <id> --node <아래 id>):', '\nInside (rootr mail show <id> --node <child id>):'));
+        for (const c of m.children) console.log(`  ${c.id}\t${NODE_TYPE_KO[c.type] ?? c.type}\t${c.name}`);
       }
-      const keys = Object.keys(p).filter((k) => k !== 'kind');
-      console.log(tr(`[${p.kind}] 담긴 것: ${keys.join(', ')} — 전부 보려면 --json`, `[${p.kind}] contains: ${keys.join(', ')} — use --json for everything`));
       return;
     }
+    case 'access': {
+      const level = args._[2];
+      if (!level || !['read', 'comment', 'write', 'view', 'edit'].includes(String(level).toLowerCase())) throw new Error(MAIL_USAGE);
+      const out = await client.setDocMailAccess(id, String(level).toLowerCase());
+      if (args.json) return console.log(JSON.stringify(out, null, 2));
+      return console.log(tr(`받는 사람 권한을 ${ACCESS_LABEL[out.access] ?? out.access}(으)로 바꿨습니다.`, `The recipient can now ${ACCESS_LABEL[out.access] ?? out.access}.`));
+    }
     case 'revoke': {
       const out = await client.revokeDocMail(id);
       if (args.json) return console.log(JSON.stringify(out, null, 2));
-      return console.log(tr(`회수했습니다 (${mailWhen(out.revokedAt)}) — 받는 쪽에서 본문이 안 보입니다.`, `Withdrawn (${mailWhen(out.revokedAt)}) — the recipient no longer sees the content.`));
+      return console.log(tr(`회수했습니다 (${mailWhen(out.revokedAt)}) — 받는 사람이 원본을 더 못 엽니다.`, `Withdrawn (${mailWhen(out.revokedAt)}) — the recipient can no longer open the original.`));
     }
     case 'hide':
     case 'rm': {
       const box = args.box === 'inbox' || args.box === 'sent' ? args.box : undefined;
       const out = await client.hideDocMail(id, { box });
       if (args.json) return console.log(JSON.stringify(out, null, 2));
-      return console.log(tr(`내 문서함에서 지웠습니다 (${out.hidden}). 상대 화면은 그대로입니다.`, `Removed from your mailbox (${out.hidden}). The other side still has it.`));
+      return console.log(tr(`내 문서함에서 지웠습니다 (${out.hidden}). 상대 화면은 그대로입니다(받은 것을 지웠으면 내 계정으로는 더 안 열립니다).`, `Removed from your mailbox (${out.hidden}). The other side still has it (a removed received document no longer opens for your account).`));
     }
     default:
       throw new Error(MAIL_USAGE);
   }
 }
 
+const WEBHOOK_USAGE = usage(
+  tr(
+    `rootr mail webhook add <url> [--events doc_mail.received,doc_mail.revoked,doc_mail.read] [--name <이름>]\n` +
+      `       rootr mail webhook list | rm <id> | test <id>`,
+    `rootr mail webhook add <url> [--events doc_mail.received,doc_mail.revoked,doc_mail.read] [--name <name>]\n` +
+      `       rootr mail webhook list | rm <id> | test <id>`,
+  ),
+);
+
+/** DOC-MAIL-HOOK — 내(계정) 받은 문서 웹훅. 워크스페이스 웹훅과 따로 — 받은 문서는 사람의 것이다. */
+async function cmdMailWebhook(client, args) {
+  const op = args._[1];
+  const arg = args._[2];
+  switch (op) {
+    case 'add': {
+      if (!arg) throw new Error(WEBHOOK_USAGE);
+      const events = typeof args.events === 'string' ? args.events.split(',').map((x) => x.trim()).filter(Boolean) : undefined;
+      const out = await client.addDocMailWebhook({ url: arg, events, name: typeof args.name === 'string' ? args.name : undefined });
+      if (args.json) return console.log(JSON.stringify(out, null, 2));
+      console.log(tr(`웹훅을 만들었습니다: ${out.id}`, `Webhook created: ${out.id}`));
+      console.log(`  url: ${out.url}`);
+      console.log(`  events: ${out.events.join(', ')}`);
+      console.log(tr(`  비밀값(지금 한 번만 보입니다 — 서명 X-Rootr-Signature 검증용): ${out.secret}`, `  secret (shown once — verify X-Rootr-Signature with it): ${out.secret}`));
+      return;
+    }
+    case 'list':
+    case 'ls':
+    case undefined: {
+      const out = await client.listDocMailWebhooks();
+      if (args.json) return console.log(JSON.stringify(out, null, 2));
+      if (!out.items?.length) return console.log(tr('웹훅이 없습니다. rootr mail webhook add <url>', 'No webhooks. rootr mail webhook add <url>'));
+      for (const h of out.items) {
+        const last = h.lastDelivery ? ` · ${h.lastDelivery.event} ${h.lastDelivery.status}${h.lastDelivery.responseCode ? ` ${h.lastDelivery.responseCode}` : ''}` : '';
+        console.log(`${h.id}\t${h.active ? 'on' : 'off'}\t${h.url}\t${h.events.join(',')}${last}`);
+      }
+      return;
+    }
+    case 'rm':
+    case 'remove':
+    case 'delete': {
+      if (!arg) throw new Error(WEBHOOK_USAGE);
+      const out = await client.removeDocMailWebhook(arg);
+      if (args.json) return console.log(JSON.stringify(out, null, 2));
+      return console.log(tr(`웹훅을 지웠습니다: ${arg}`, `Webhook removed: ${arg}`));
+    }
+    case 'test': {
+      if (!arg) throw new Error(WEBHOOK_USAGE);
+      const queued = await client.testDocMailWebhook(arg);
+      let d = null;
+      for (let i = 0; i < 10; i++) {
+        await new Promise((r) => setTimeout(r, 750));
+        d = (await client.docMailWebhookDeliveries(arg)).items?.find((x) => x.id === queued.deliveryId) ?? null;
+        if (d && d.status !== 'PENDING') break;
+      }
+      if (args.json) return console.log(JSON.stringify({ ...queued, delivery: d }, null, 2));
+      if (!d || d.status === 'PENDING') return console.log(tr(`시험 전송을 큐에 넣었습니다(${queued.deliveryId}) — 아직 결과가 없습니다.`, `Test queued (${queued.deliveryId}) — no result yet.`));
+      if (d.status === 'SUCCESS') return console.log(tr(`시험 전송 성공 (HTTP ${d.responseCode})`, `Test delivered (HTTP ${d.responseCode})`));
+      process.exitCode = 1;
+      return console.log(tr(`시험 전송 실패: ${d.error ?? d.responseCode} — 다시 시도합니다(최대 5번).`, `Test failed: ${d.error ?? d.responseCode} — it will be retried (up to 5 times).`));
+    }
+    default:
+      throw new Error(WEBHOOK_USAGE);
+  }
+}
+
 async function main() {
   const argv = process.argv.slice(2);
   const args = parseArgs(argv);
@@ -3277,4 +3401,31 @@ async function main() {
   }
 }
 
-main().catch(printErrorAndExit);
+/**
+ * DOC-MAIL-NOTIFY — 아무 명령이든 끝난 뒤, 그 명령이 부른 API 응답 머리줄에 **새로 받은 문서**가 있었으면 stderr 로 한 줄
+ * (stdout·--json 출력은 더럽히지 않는다). 따로 묻는 호출은 없다. 서버가 키마다 한 번만 알려 준다(channel 'cli').
+ * `rootr mail`·`rootr mcp` 에서는 안 낸다(이미 문서함을 보고 있다 / 표준 입출력이 MCP 통로다).
+ * 끄기: `ROOTR_MAIL_NOTICE=0`.
+ */
+const docMailSink = { channel: 'cli', items: [] };
+const firstArg = process.argv.slice(2).find((a) => !a.startsWith('-'));
+const docMailNoticeOn = process.env.ROOTR_MAIL_NOTICE !== '0' && firstArg !== 'mail' && firstArg !== 'mcp';
+if (docMailNoticeOn) setGlobalDocMailSink(docMailSink);
+function printDocMailNotice() {
+  if (!docMailNoticeOn || !docMailSink.items.length) return;
+  const n = Math.max(docMailSink.items.length, docMailSink.newCount || 0);
+  const first = docMailSink.items[0];
+  console.error(
+    tr(
+      `📬 받은 문서 ${n}건 — 「${first.title}」 ${first.sender}${n > 1 ? ' 외' : ''} · rootr mail`,
+      `📬 ${n} new document${n > 1 ? 's' : ''} received — "${first.title}" from ${first.sender}${n > 1 ? ' and more' : ''} · rootr mail`,
+    ),
+  );
+}
+
+main()
+  .then(printDocMailNotice)
+  .catch((err) => {
+    printDocMailNotice();
+    printErrorAndExit(err);
+  });

package/lib/client.js

@@ -6,7 +6,7 @@
  * can render consistent, helpful messages.
  */
 
-import { currentRateLimitSink } from './context.js';
+import { currentDocMailSink, currentRateLimitSink } from './context.js';
 import { t as tr } from './i18n.js';
 
 /** Copy the API's X-RateLimit-* headers into the ambient per-call sink, if any. */
@@ -23,6 +23,25 @@ function captureRateLimit(res) {
   sink.upgradeUrl = res.headers.get('x-ratelimit-upgrade-url') || undefined;
 }
 
+/** DOC-MAIL-NOTIFY — 응답의 안 읽은 받은 문서 머리줄을 그릇에 모은다(그릇이 없으면 아무 일도 안 한다). */
+function captureDocMail(res, sink) {
+  if (!sink) return;
+  const unread = Number(res.headers.get('x-rootr-doc-mail-unread'));
+  if (Number.isFinite(unread) && res.headers.get('x-rootr-doc-mail-unread') !== null) sink.unread = unread;
+  const raw = res.headers.get('x-rootr-doc-mail-new-items');
+  if (!raw) return;
+  try {
+    const items = JSON.parse(Buffer.from(raw, 'base64url').toString('utf8'));
+    sink.items = sink.items || [];
+    for (const it of Array.isArray(items) ? items : []) {
+      if (it && it.id && !sink.items.some((x) => x.id === it.id)) sink.items.push(it);
+    }
+    sink.newCount = Math.max(sink.newCount || 0, Number(res.headers.get('x-rootr-doc-mail-new')) || 0);
+  } catch {
+    /* 알림만 빠진다 */
+  }
+}
+
 export class RootrApiError extends Error {
   constructor(message, { status, body, hint } = {}) {
     super(message);
@@ -154,6 +173,8 @@ export class RootrClient {
       ...this.defaultHeaders,
       ...(opts.headers || {}),
     };
+    const docMailSink = currentDocMailSink();
+    if (docMailSink?.channel) headers['X-Rootr-Doc-Mail-Channel'] = docMailSink.channel;
 
     let body = opts.body;
     if (body !== undefined && typeof body !== 'string' && !(body instanceof Uint8Array)) {
@@ -173,6 +194,7 @@ export class RootrClient {
     }
 
     captureRateLimit(res);
+    if (res.ok) captureDocMail(res, docMailSink);
 
     if (opts.returnResponse) {
       if (!res.ok) {
@@ -2051,15 +2073,16 @@ export class RootrClient {
 
   // ---- Doc mail (DOC-MAIL — 문서 송수신) ---------------------------------
   //
-  // 노드 하나를 **보낼 때의 복사본**으로 이메일 1~20명에게 보낸다. 받은 문서는 받는 사람의
-  // 이메일에 붙는다 — 계정이 없어도 메일 링크로 열리고, 나중에 그 이메일로 가입하면 문서함에
-  // 그대로 있다. 문서함은 사람(이메일)에 붙으므로 워크스페이스 주소 밑이 아니다.
+  // 노드 하나를 이메일 1~20명에게 **보낸다 = 원본을 그 이메일에 열어 준다**(복사본이 아니다 — DOC-MAIL-LIVE).
+  // 받는 사람은 원본을 실시간으로 보고, 받은 권한(read 보기·comment 댓글·write 편집)만큼 쓴다. 계정이 없으면 메일 링크에서
+  // 받은 이메일을 넣어 읽기 전용으로 열고, 그 이메일로 가입하면 문서함에서 원본이 열린다. 문서함은 사람(이메일)에 붙으므로
+  // 워크스페이스 주소 밑이 아니다.
 
-  /** 보내기 — WRITE 이상. 응답 `{batchId, items:[{id,to,emailed}]}`. */
-  async sendNode(nodeId, { to, message } = {}) {
+  /** 보내기 — 구성원 규칙으로 WRITE 이상. access: read|comment|write(기본 read). 응답 `{batchId, access, items:[{id,to,emailed,resent}]}`. */
+  async sendNode(nodeId, { to, message, access } = {}) {
     return this.request(`/nodes/${encodeURIComponent(nodeId)}/send`, {
       method: 'POST',
-      body: { to, ...(message ? { message } : {}) },
+      body: { to, ...(message ? { message } : {}), ...(access ? { access } : {}) },
     });
   }
 
@@ -2074,16 +2097,47 @@ export class RootrClient {
     return this.request(`/doc-mail${s ? `?${s}` : ''}`);
   }
 
-  /** 한 통 열기(본문 payload 포함). 받는 사람이 열면 읽음으로 바뀐다. */
-  async getDocMail(id) {
-    return this.request(`/doc-mail/${encodeURIComponent(id)}`);
+  /**
+   * 한 통 열기 — 원본의 **지금** 내용(읽기 전용: 문서면 contentMd, 그 밖은 payload)·받은 권한(access)·원본 주소(openUrl).
+   * 폴더를 받았으면 children 이 오고, node 로 그 아래 것을 골라 읽는다. 받는 사람이 열면 읽음으로 바뀐다.
+   */
+  async getDocMail(id, { node } = {}) {
+    return this.request(`/doc-mail/${encodeURIComponent(id)}${node ? `?node=${encodeURIComponent(node)}` : ''}`);
   }
 
-  /** 회수 — 보낸 사람만. 이후 받는 쪽에서 본문이 안 보인다. */
+  /** 회수 — 보낸 사람만. 받는 사람의 원본 접근이 바로 닫힌다. */
   async revokeDocMail(id) {
     return this.request(`/doc-mail/${encodeURIComponent(id)}/revoke`, { method: 'POST', body: {} });
   }
 
+  // ---- Doc mail webhooks (DOC-MAIL-HOOK — 사람 단위) ---------------------
+  /** 내 받은 문서 웹훅 만들기 — events: doc_mail.received|doc_mail.revoked|doc_mail.read(안 주면 셋 다). 비밀값은 이 응답에만. */
+  async addDocMailWebhook({ url, events, name } = {}) {
+    return this.request('/doc-mail-webhooks', { method: 'POST', body: { url, ...(events?.length ? { events } : {}), ...(name ? { name } : {}) } });
+  }
+
+  async listDocMailWebhooks() {
+    return this.request('/doc-mail-webhooks');
+  }
+
+  async removeDocMailWebhook(id) {
+    return this.request(`/doc-mail-webhooks/${encodeURIComponent(id)}`, { method: 'DELETE' });
+  }
+
+  /** 시험 전송 한 통(doc_mail.test). 결과는 docMailWebhookDeliveries(id). */
+  async testDocMailWebhook(id) {
+    return this.request(`/doc-mail-webhooks/${encodeURIComponent(id)}/test`, { method: 'POST', body: {} });
+  }
+
+  async docMailWebhookDeliveries(id) {
+    return this.request(`/doc-mail-webhooks/${encodeURIComponent(id)}/deliveries`);
+  }
+
+  /** 받은 사람의 권한 바꾸기 — 보낸 사람만, 내 수준까지. */
+  async setDocMailAccess(id, access) {
+    return this.request(`/doc-mail/${encodeURIComponent(id)}`, { method: 'PATCH', body: { access } });
+  }
+
   /** 내 문서함에서만 지우기(상대 화면은 그대로). box 로 나에게 보낸 것의 한쪽만 고를 수 있다. */
   async hideDocMail(id, { box } = {}) {
     return this.request(`/doc-mail/${encodeURIComponent(id)}${box ? `?box=${encodeURIComponent(box)}` : ''}`, {

package/lib/context.js

@@ -36,3 +36,24 @@ export function withRateLimitSink(sink, fn) {
 export function currentRateLimitSink() {
   return rateLimitStorage.getStore();
 }
+
+/**
+ * DOC-MAIL-NOTIFY — 안 읽은 받은 문서 알림을 모으는 그릇. `RootrClient.request` 가 그릇이 있으면 요청에
+ * `X-Rootr-Doc-Mail-Channel: <channel>` 을 붙이고, 응답의 `X-Rootr-Doc-Mail-Unread/New/New-Items` 를 여기 모은다(서버가
+ * 그 채널에 한 번만 알린다). MCP 는 도구 호출마다 async-local 그릇(channel 'mcp'), CLI 명령은 프로세스 전체 그릇(channel 'cli').
+ * 원격 MCP(API 프로세스 안)는 async-local 만 쓴다 — 전역 그릇은 CLI 실행 파일만 놓는다(여러 사람이 한 프로세스를 나눠 쓴다).
+ */
+const docMailStorage = new AsyncLocalStorage();
+let globalDocMailSink = null;
+
+export function withDocMailSink(sink, fn) {
+  return docMailStorage.run(sink, fn);
+}
+
+export function setGlobalDocMailSink(sink) {
+  globalDocMailSink = sink;
+}
+
+export function currentDocMailSink() {
+  return docMailStorage.getStore() ?? globalDocMailSink;
+}

package/lib/mcp-tools/doc-mail.js

@@ -3,40 +3,44 @@ import { z } from 'zod';
 import { jsonResult, errorResult, makeClient, resolveNodeId, NODE_TARGET_HINT } from './shared.js';
 
 /**
- * DOC-MAIL — 문서 송수신(창업자 지시 2026-10-20).
+ * DOC-MAIL — 문서 송수신(창업자 지시 2026-10-20, 같은 날 정정 "문서자체를 보내란 뜻임").
  *
- * 어떤 타입이든(문서·표·시트·화이트보드·덱·폼·이슈·로그·CRM·녹음·페이지·서명문서) 노드 하나를
- * **보낼 때의 복사본**으로 특정 이메일에게 보낸다. 받은 문서는 받는 사람의 **이메일 주소**에 붙는다 —
- * 계정이 없어도 메일 링크로 열리고, 나중에 그 이메일로 가입하면 받은 문서함에 그대로 있다.
- * 보낸 뒤 원본을 고치거나 지워도 받은 문서는 그대로다(살아 있는 공유가 필요하면 권한/공개를 쓴다).
+ * 어떤 타입이든(문서·폴더·표·시트·화이트보드·덱·폼·이슈·로그·CRM·녹음·페이지·서명문서) 노드 하나를 특정 이메일에게
+ * **보낸다 = 원본 그 자체를 그 이메일에 열어 준다**(보기·댓글·편집). 복사본이 아니라서 보낸 사람이 고치면 받는 사람에게
+ * 바로 보이고, 편집을 받았으면 받는 사람이 고친 것이 원본에 남는다. 받은 문서는 받는 사람의 **이메일 주소**에 붙는다 —
+ * 계정이 없어도 메일 링크(받은 이메일을 넣어야 열림, 읽기 전용)로 열리고, 그 이메일로 가입하면 문서함에서 원본이 열린다.
  */
 export function registerDocMailTools(server) {
   server.registerTool(
     'rootr_send_document',
     {
-      title: 'Send a Rootr node to email addresses',
+      title: 'Send a Rootr node to email addresses (give them access to the original)',
       description:
-        'Send a SNAPSHOT of any Rootr node (document, table, spreadsheet, whiteboard, deck, form, issues, log, CRM, ' +
-        'recording, page, signed document — anything but a folder) to 1–20 email addresses. Each recipient gets an ' +
-        'email with a link that opens the copy WITHOUT a Rootr account; if they have (or later create) a Rootr account ' +
-        'with that email, it also sits in their inbox (rootr_list_doc_mail). The copy is frozen at send time — later ' +
-        'edits or deletion of the original do not change it; use permissions/publishing for a live share instead. ' +
-        'Needs WRITE on the node (the same bar as sharing). What never goes out: the same things a public page hides ' +
-        '(person/attachment/relation columns, row documents, form responses, signer emails). ' +
-        'The result lists each recipient with `emailed` (false = the notification email failed; the copy still exists). ' +
-        'Only send to addresses the user asked for — this emails real people.',
+        'Send any Rootr node (document, folder, table, spreadsheet, whiteboard, deck, form, issues, log, CRM, recording, ' +
+        'page, signed document) to 1–20 email addresses. This is NOT a copy: each address gets access to the ORIGINAL ' +
+        'node (and everything under it, if it is a folder) at `access` = read (view, default) | comment | write (edit). ' +
+        'They always see the latest version; with write their edits land in the original. People with a Rootr account ' +
+        'on that (verified) email open it from their inbox (rootr_list_doc_mail) with that access, even if they are not ' +
+        'members of your workspace — they never see your workspace tree, members or search. People without an account ' +
+        'get an email link where they must type their email address to read it (read-only). ' +
+        'Needs WRITE on the node as a workspace member (the same bar as sharing); you can give at most your own level, ' +
+        'never manage. Re-sending to the same address updates access/message instead of adding a second grant. ' +
+        'Withdraw with rootr_revoke_doc_mail; change access with rootr_set_doc_mail_access. ' +
+        'The result lists each recipient with `emailed` (false = the email failed; the access still stands). ' +
+        'Only send to addresses the user asked for — this emails real people and opens the document to them.',
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
       inputSchema: {
         node: z.string().describe(`보낼 노드 id${NODE_TARGET_HINT}`),
         to: z.array(z.string()).min(1).max(20).describe('받는 사람 이메일 주소들(1~20개). 대소문자만 다른 주소는 같은 사람'),
         message: z.string().max(2000).optional().describe('보내며 함께 적을 말(메일과 문서함에 보인다, 2000자까지)'),
+        access: z.enum(['read', 'comment', 'write']).optional().describe('받는 사람이 원본에서 할 수 있는 것: read=보기(기본) · comment=댓글 · write=편집. 내 권한까지만'),
         workspace: z.string().optional().describe('경로로 줄 때 찾을 워크스페이스 id (생략하면 설정값)'),
       },
     },
-    async ({ node, to, message, workspace }) => {
+    async ({ node, to, message, access, workspace }) => {
       try {
         const client = makeClient(workspace);
-        return jsonResult(await client.sendNode(await resolveNodeId(client, node), { to, message }));
+        return jsonResult(await client.sendNode(await resolveNodeId(client, node), { to, message, access }));
       } catch (err) {
         return errorResult(err);
       }
@@ -51,7 +55,9 @@ export function registerDocMailTools(server) {
         "List the caller's document mailbox: box=inbox (documents sent TO the caller's account email — default) or " +
         'box=sent (documents the caller sent). Summaries only (title, type, sender, recipient, message, sentAt, ' +
         'readAt, revoked); open one with rootr_read_doc_mail. `unread` is the number of unread received documents. ' +
-        'Page with `cursor` = the previous `nextCursor`. Belongs to the person (their email), not to a workspace.',
+        'Page with `cursor` = the previous `nextCursor`. Belongs to the person (their email), not to a workspace. ' +
+        'Each item has `access` (READ/COMMENT/WRITE), `original` (live | trashed | deleted) and, for live received ones, ' +
+        '`nodeId`/`workspaceId` of the original.',
       annotations: { readOnlyHint: true },
       inputSchema: {
         box: z.enum(['inbox', 'sent']).optional().describe('inbox=받은 문서(기본), sent=보낸 문서'),
@@ -74,18 +80,21 @@ export function registerDocMailTools(server) {
     {
       title: 'Read a received or sent Rootr document',
       description:
-        'Open one document from the mailbox (id from rootr_list_doc_mail). Returns the summary plus `payload` — the ' +
-        'snapshot taken at send time, in the same shape a public page uses: `kind` says what it is (doc → `content` ' +
-        'markdown; database → `properties` + `rows`; spreadsheet → `data`; …). Opening a received one marks it read. ' +
-        'If the sender withdrew it, `revoked` is true and `payload` is null.',
+        'Open one document from the mailbox (id from rootr_list_doc_mail). Returns the summary plus the CURRENT content ' +
+        'of the original, read-only, in the same shape a public page uses: `contentMd` for documents, `payload.kind` for ' +
+        'the rest (database → `properties` + `rows`; spreadsheet → `data`; …), `children` (items inside — pass one as ' +
+        '`node` to read it), `access` (what the recipient may do), `openUrl` (the original in the Rootr editor). ' +
+        'Opening a received one marks it read. Withdrawn → `revoked` true and no content; original deleted → ' +
+        '`originalDeleted` true. This works with any of the recipient\'s keys, even one bound to another workspace.',
       annotations: { readOnlyHint: false },
       inputSchema: {
         id: z.string().describe('문서함 항목 id (rootr_list_doc_mail 의 items[].id)'),
+        node: z.string().optional().describe('폴더(부모)를 받았을 때 그 아래 노드 id (앞 응답의 children[].id)'),
       },
     },
-    async ({ id }) => {
+    async ({ id, node }) => {
       try {
-        return jsonResult(await makeClient().getDocMail(id));
+        return jsonResult(await makeClient().getDocMail(id, { node }));
       } catch (err) {
         return errorResult(err);
       }
@@ -97,9 +106,9 @@ export function registerDocMailTools(server) {
     {
       title: 'Withdraw a sent Rootr document',
       description:
-        'Withdraw a document the caller sent (id from rootr_list_doc_mail box=sent). From then on the recipient sees ' +
-        'only the title and "withdrawn" — no content — and the email link answers 410. Only the sender can do this; ' +
-        'it cannot be undone (send it again instead). Copies the recipient already saved elsewhere are out of reach.',
+        'Withdraw a document the caller sent (id from rootr_list_doc_mail box=sent). The recipient loses access to the ' +
+        'original immediately (open editors are disconnected), sees only the title and "withdrawn", and the email link ' +
+        'answers 410. Only the sender can do this; it cannot be undone (send it again instead).',
       annotations: { readOnlyHint: false, destructiveHint: true },
       inputSchema: {
         id: z.string().describe('보낸 문서함 항목 id'),
@@ -113,4 +122,117 @@ export function registerDocMailTools(server) {
       }
     },
   );
+
+  server.registerTool(
+    'rootr_set_doc_mail_access',
+    {
+      title: 'Change what the recipient of a sent Rootr document can do',
+      description:
+        'Change the access of one recipient of a document the caller sent (id from rootr_list_doc_mail box=sent): ' +
+        'read (view) | comment | write (edit). Only the sender; at most the sender\'s own level on the node. Lowering it ' +
+        'takes effect immediately. No email is sent.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        id: z.string().describe('보낸 문서함 항목 id'),
+        access: z.enum(['read', 'comment', 'write']).describe('read=보기 · comment=댓글 · write=편집'),
+      },
+    },
+    async ({ id, access }) => {
+      try {
+        return jsonResult(await makeClient().setDocMailAccess(id, access));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  // ── DOC-MAIL-HOOK — 사람 단위 웹훅 ──────────────────────────────────────
+  server.registerTool(
+    'rootr_add_doc_mail_webhook',
+    {
+      title: 'Get a webhook when documents arrive for me',
+      description:
+        "Register a webhook on the caller's own account (not a workspace) for their document mailbox. Rootr POSTs JSON to " +
+        '`url` on doc_mail.received (a document was sent to the account\'s verified email), doc_mail.revoked (a received one ' +
+        'was withdrawn) and doc_mail.read (a recipient opened one the caller sent). The body has id, title, nodeType, sender, ' +
+        'message, access, apiUrl (GET it with your key for the content) and appUrl — never the document content. Each request ' +
+        'is signed: X-Rootr-Signature: sha256=HMAC_SHA256(secret, raw body). The `secret` is returned ONCE, here — store it. ' +
+        'Only public http(s) URLs (private/loopback addresses are refused). Max 5 per account.',
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      inputSchema: {
+        url: z.string().describe('받을 주소(공인 http/https)'),
+        events: z.array(z.enum(['doc_mail.received', 'doc_mail.revoked', 'doc_mail.read'])).optional().describe('받을 사건(안 주면 셋 다)'),
+        name: z.string().max(100).optional().describe('알아보기 쉬운 이름'),
+      },
+    },
+    async ({ url, events, name }) => {
+      try {
+        return jsonResult(await makeClient().addDocMailWebhook({ url, events, name }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_list_doc_mail_webhooks',
+    {
+      title: "List my document webhooks",
+      description: "List the caller's document-mailbox webhooks (url, events, active, last delivery status). Secrets are not shown.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {},
+    },
+    async () => {
+      try {
+        return jsonResult(await makeClient().listDocMailWebhooks());
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_remove_doc_mail_webhook',
+    {
+      title: 'Remove one of my document webhooks',
+      description: 'Delete a document-mailbox webhook of the caller (id from rootr_list_doc_mail_webhooks). Its delivery log goes with it.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: { id: z.string().describe('웹훅 id') },
+    },
+    async ({ id }) => {
+      try {
+        return jsonResult(await makeClient().removeDocMailWebhook(id));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_test_doc_mail_webhook',
+    {
+      title: 'Send a test event to one of my document webhooks',
+      description:
+        'Queue a signed doc_mail.test delivery to the webhook (re-enables it if it was turned off), then report the latest ' +
+        'deliveries a few seconds later (status, HTTP code, error).',
+      annotations: { readOnlyHint: false, openWorldHint: true },
+      inputSchema: { id: z.string().describe('웹훅 id') },
+    },
+    async ({ id }) => {
+      try {
+        const client = makeClient();
+        const queued = await client.testDocMailWebhook(id);
+        let deliveries = null;
+        for (let i = 0; i < 8; i++) {
+          await new Promise((r) => setTimeout(r, 750));
+          deliveries = await client.docMailWebhookDeliveries(id);
+          const d = deliveries?.items?.find((x) => x.id === queued.deliveryId);
+          if (d && d.status !== 'PENDING') break;
+        }
+        return jsonResult({ ...queued, deliveries: deliveries?.items?.slice(0, 5) ?? [] });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
 }

package/lib/mcp-tools/pages.js

@@ -109,7 +109,8 @@ export function registerPageTools(server) {
       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 ' +
+        'can then be published to the web at a public address (see rootr_publish_node — web publishing of pages needs ' +
+        'the Team plan; on Free the page still works inside the workspace). Use this when someone asks ' +
         'for a DASHBOARD / report / KPI board over their tables, spreadsheets or logs (46 live chart kinds, numbers stay ' +
         'current), or 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. ' +

package/lib/mcp-tools/public.js

@@ -29,9 +29,13 @@ export function registerPublicTools(server) {
       description:
         'Publish ANY Rootr (루터) node at a public read-only URL (rootr.io/p/{slug}) — a DATABASE (visitors get a ' +
         'searchable table and can clone it into their own workspace), SPREADSHEET, WHITEBOARD, FORM (questions only), ' +
-        'ISSUE_TRACKER, LOG, CRM, RECORDING (transcript only), SIGNED or DOCUMENT. Use this instead of ' +
+        'ISSUE_TRACKER, LOG, CRM, RECORDING (transcript only), SIGNED, DOCUMENT or PAGE. Use this instead of ' +
         'rootr_publish_document unless you specifically want the document-only extras (skins, edit proposals). ' +
         'FOLDER cannot be published. ' +
+        'PAGE (the block-assembled web page) can be published only on the Team plan and up — a Free workspace gets ' +
+        '403 PLAN_UPGRADE_REQUIRED (nothing is changed; tell the user to upgrade the workspace to Team). Every other type ' +
+        'publishes on Free as before. With `includeChildren` on Free, PAGE nodes underneath are skipped and the response ' +
+        'says how many (`skippedPagesRequireTeam`). ' +
         'Set `includeChildren: true` to publish everything underneath as well — the WHOLE subtree, grandchildren ' +
         'included, each getting its own URL and listed on the parent page. Leave it off and only this one node goes ' +
         'out (its sub-page names do not even appear). Turning it back off, closing the parent, moving a child out, ' +
@@ -90,6 +94,7 @@ export function registerPublicTools(server) {
         'PLAN_UPGRADE_REQUIRED; a password-locked page is always hidden and cannot be re-exposed until unlocked); ' +
         '`{"design": {"layout": "board", "skin": "paper"}}` changes how a published TABLE looks — it does not ' +
         'have to be a table (cards, gallery, list, board, timeline, calendar, chart, ranking). ' +
+        '`{"isPublic": true}` on a PAGE needs the Team plan (Free → 403 PLAN_UPGRADE_REQUIRED); closing it works on any plan. ' +
         'For DOCUMENT nodes use rootr_set_document_public instead — documents keep their own settings (skins, ' +
         'edit proposals) on the older path. Owner-level action (MANAGE): use an account key (PAT).',
       annotations: { readOnlyHint: false, destructiveHint: false },
@@ -132,6 +137,8 @@ export function registerPublicTools(server) {
         '`publishable: false` means this type cannot be published at all (FOLDER). ' +
         '`closed: "PUBLIC_OWN_ROW_PAGE"` (with `isPublic: false` and a `closedReason`) means publishing is switched on but the ' +
         'address is closed right now — do NOT hand that URL out; tell the user why and how to reopen it. ' +
+        '`closed: "PAGE_PUBLISH_REQUIRES_TEAM"` means a PAGE was published but its workspace is on the Free plan, so ' +
+        'visitors see a "not published" screen — upgrading to Team reopens the same URL without publishing again. ' +
         'Call this before publishing so you do not tell the user a page is new when it already had a URL.',
       annotations: { readOnlyHint: true, destructiveHint: false },
       inputSchema: {

package/lib/mcp.js

@@ -25,7 +25,7 @@ import { registerSignedDocTools } from './mcp-tools/signed.js';
 import { registerFeedbackTools } from './mcp-tools/feedback.js';
 import { registerMemoryTools } from './mcp-tools/memory.js';
 import { registerDocMailTools } from './mcp-tools/doc-mail.js';
-import { withRateLimitSink } from './context.js';
+import { withDocMailSink, withRateLimitSink } from './context.js';
 import { makeClient } from './mcp-tools/shared.js';
 import { t as tr } from './i18n.js';
 
@@ -77,6 +77,39 @@ function withQuotaWarnings(server) {
 }
 
 
+/**
+ * DOC-MAIL-NOTIFY — 어떤 루터 도구를 부르든, 아직 알리지 않은 **새 받은 문서**가 있으면 응답 끝에 한 줄을 붙인다(창업자 지시
+ * 2026-10-20 — 클라이언트와 상관없이 루터를 쓰는 순간 알게). 도구가 부른 API 응답의 머리줄(`X-Rootr-Doc-Mail-New-Items`)을
+ * 그릇에 모아 쓴다 — 따로 묻는 호출이 없다. 서버가 키마다·채널(mcp)마다 한 번만 알려 준다(같은 문서를 두 번 알리지 않는다).
+ * 문서함 도구 자신(`*doc_mail*`)의 응답에는 붙이지 않는다 — 이미 문서함을 보고 있다.
+ */
+function docMailNotice(items) {
+  if (!items?.length) return null;
+  const shown = items.slice(0, 5);
+  const list = shown.map((i) => tr(`「${i.title}」 — ${i.sender} (id: ${i.id})`, `"${i.title}" from ${i.sender} (id: ${i.id})`)).join(', ');
+  const more = items.length > shown.length ? tr(` 외 ${items.length - shown.length}건`, ` and ${items.length - shown.length} more`) : '';
+  return tr(
+    `\n\n📬 새로 받은 문서 (${items.length}): ${list}${more} — rootr_read_doc_mail {id} 로 읽으세요. 사용자에게 알려 주세요.`,
+    `\n\n📬 New documents received (${items.length}): ${list}${more} — read with rootr_read_doc_mail {id}. Tell the user.`,
+  );
+}
+
+function withDocMailNotices(server) {
+  const original = server.registerTool.bind(server);
+  server.registerTool = (name, spec, handler) =>
+    original(name, spec, async (...args) => {
+      const sink = { channel: 'mcp', items: [] };
+      const result = await withDocMailSink(sink, () => handler(...args));
+      if (/doc_mail/.test(name)) return result;
+      const notice = docMailNotice(sink.items);
+      if (!notice || !result || !Array.isArray(result.content)) return result;
+      const last = [...result.content].reverse().find((c) => c && c.type === 'text');
+      if (!last) return { ...result, content: [...result.content, { type: 'text', text: notice.trim() }] };
+      return { ...result, content: result.content.map((c) => (c === last ? { ...c, text: `${c.text}${notice}` } : c)) };
+    });
+  return server;
+}
+
 /**
  * MEM-001 — **기억을 눈앞에 놓는다. 이 기능의 성패가 여기 달렸다.**
  *
@@ -225,10 +258,14 @@ export function buildMcpServer({ name, version }) {
         'rootr_request_signing_code first and ASK THE HUMAN for the 6 digits that arrive in their mail — ' +
         'that code is the only evidence a person (not an agent) pressed sign; ' +
         'FOLDER = grouping; LOG store = typed event table whose relation fields auto-build a lineage graph (metrics, incidents, pipeline events — use the rootr_*_log_* tools).\n\n' +
-        'Sending a document to someone by email (문서 보내기 · 문서함): rootr_send_document mails a frozen COPY of any ' +
-        'node (not a folder) to 1-20 addresses — no Rootr account needed to open it, and it lands in their inbox if ' +
-        'that email has an account; rootr_list_doc_mail (box inbox|sent) / rootr_read_doc_mail / rootr_revoke_doc_mail ' +
-        'cover the mailbox. Only send to addresses the user gave you.\n\n' +
+        'Sending a document to someone by email (문서 보내기 · 문서함): rootr_send_document gives 1-20 email addresses ' +
+        'access to the ORIGINAL node (not a copy) at access read|comment|write — they see live edits, and with write ' +
+        'their edits land in the original; an account on that email opens it from its inbox, others read it via the ' +
+        'email link after typing their address; rootr_list_doc_mail (box inbox|sent) / rootr_read_doc_mail / ' +
+        'rootr_set_doc_mail_access / rootr_revoke_doc_mail cover the mailbox. Only send to addresses the user gave you. ' +
+        'When any tool result ends with "📬 New documents received", tell the user right away (title and sender) and offer to ' +
+        'open them with rootr_read_doc_mail. rootr_add_doc_mail_webhook makes Rootr POST doc_mail.received / revoked / read ' +
+        'to the user\'s own URL (for their automations).\n\n' +
         'Scaffolding discipline — treat "set up a workspace for X" exactly like "build me this app": you ask a ' +
         'few clarifying questions, write it, compile it, run the tests, leave a README, and report. The user ' +
         'should only have to type that one sentence; everything else finishes inside the conversation. Never ask ' +
@@ -268,6 +305,7 @@ export function buildMcpServer({ name, version }) {
   // 한도 경고가 그 뒤에 붙는다 — 경고는 언제나 맨 끝에 있어야 눈에 띈다.
   withMemoryRecall(server);
   withQuotaWarnings(server);
+  withDocMailNotices(server);
 
   registerDocumentTools(server);
   registerTemplateTools(server);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rootr-cli",
-  "version": "0.24.0",
+  "version": "0.25.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": {