rootr-cli 0.9.0 → 0.10.0

package/README.md

@@ -202,6 +202,50 @@ rootr config                       # 등록된 키 목록 확인
 업그레이드 링크가 담긴 안내가 나옵니다. 응답 헤더로도 확인할 수 있습니다
 (`X-RateLimit-Remaining`, `X-RateLimit-Reset`, `X-RateLimit-Window`).
 
+### 서명문서 · 연구노트 (sign)
+
+서명문서는 마크다운 문서인데 **올리는 순간 본문이 얼고**, 결재라인에 적힌 사람들이
+차례로 서명합니다. 서명마다 공인시점확인(TSA)과 해시 체이닝이 붙어 위·변조를
+증명할 수 있고, 서명된 문서는 삭제되지 않습니다(30년 보존).
+전자결재와 국가R&D 전자연구노트가 같은 기능 하나입니다.
+
+```bash
+# 만들기 — 본문·결재라인까지 한 번에. 연구노트는 점검자만 정하면 두 단계가 자동
+rootr sign new "/연구노트/2026-08-25 실험기록" --file note.md --reviewer <연구책임자 userId>
+
+# 결재라인을 직접 짜려면 (배열 순서 = 서명 순서)
+cat > line.json <<'EOF'
+[ { "label": "기재자", "members": [{ "userId": "u1", "role": "AUTHOR" }] },
+  { "label": "부서장", "rule": "ANY", "members": [{ "userId": "u2" }, { "userId": "u3" }] } ]
+EOF
+rootr sign line /연구노트/2026-08-25\ 실험기록 --file line.json
+
+# 올리기: 확인 코드를 메일로 받고 → 그 6자리를 넘긴다
+rootr sign code   /연구노트/2026-08-25\ 실험기록
+rootr sign submit /연구노트/2026-08-25\ 실험기록 --code 123456
+
+# 다음 사람: 내 차례인 것만 보고 → 서명 (또는 사유를 달아 반려)
+rootr sign list --pending
+rootr sign code <id> && rootr sign approve <id> --code 123456
+rootr sign reject <id> --comment "근거 자료가 빠졌습니다" --code 123456
+
+# 여러 건 한 번에 (코드 하나로 최대 100건)
+rootr sign code --bulk
+rootr sign bulk <id1> <id2> <id3> --code 123456
+
+# 증명
+rootr sign verify <id>     # 본문·서명·시점확인·원장이 성한지
+rootr sign ledger          # 워크스페이스 원장 전체 재계산
+```
+
+**확인 코드는 CLI가 대신 만들어 줄 수 없습니다.** 코드는 서명하는 사람 메일로만
+가고, 서버가 개인키를 보관하는 구조에서 그게 "본인이 눌렀다"의 유일한 증거입니다.
+10분 유효, 5회 틀리면 죽고, 30초 안에 다시 요청하면 거절됩니다.
+
+서명된 문서는 고치는 게 아니라 **개정본**을 냅니다(`rootr sign revise <id> --note "…"`).
+원본은 `SUPERSEDED`로 남습니다 — 지침이 "고친 흔적과 원본이 모두 보여야 한다"를
+요구하기 때문입니다.
+
 ### RCA 질의응답 (ask)
 
 ```bash
@@ -214,7 +258,7 @@ rootr ask "왜 결제 실패가 늘었지?" --workspace ws_123
 
 ## MCP 서버로 사용하기
 
-`rootr mcp`는 stdio로 MCP(Model Context Protocol) 서버를 구동합니다. 제공 도구 96종:
+`rootr mcp`는 stdio로 MCP(Model Context Protocol) 서버를 구동합니다. 제공 도구 134종:
 
 노드를 가리키는 인자(`target`, `databaseId`, `spreadsheetId`, `formId`, `crmId`, `trackerId`,
 `recordingId`, `presentationId`, `whiteboardId`, `logId`, `parentId` 등)는 **노드 id와 경로를 모두**
@@ -352,6 +396,34 @@ rootr ask "왜 결제 실패가 늘었지?" --workspace ws_123
 - `title` 열은 추가로 만들 수도, 삭제할 수도 없습니다.
 - 삭제한 열의 값은 행 안에 남아 있지만 화면에는 나오지 않습니다 — 사용자 확인 후 호출하세요.
 
+#### 서명문서 · 연구노트 (docs:read/docs:write)
+
+| 도구 | 설명 |
+|---|---|
+| `rootr_create_signed_document` | 서명문서 만들기 — 본문·모드·결재라인까지 한 번에 |
+| `rootr_read_signed_document` | 결재라인 진행·서명 목록·내 차례인지(`canSign`) |
+| `rootr_set_approval_line` | 결재라인 다시 짜기 (올리기 전에만) |
+| `rootr_apply_research_note_preset` | 연구노트로 전환 + 기재자→점검자 두 단계 자동 |
+| `rootr_request_signing_code` | 확인 코드를 서명자 메일로 발송 (서명 전 필수) |
+| `rootr_submit_signed_document` | 올리기 — 본문이 얼고 기안자가 첫 서명 |
+| `rootr_sign_document` | 내 차례에 서명 |
+| `rootr_reject_signed_document` | 반려 (사유 필수) |
+| `rootr_reopen_signed_document` | 아무도 서명 안 한 초안 다시 열기 |
+| `rootr_revise_signed_document` | 개정본 만들기 (원본은 남는다) |
+| `rootr_verify_signed_document` | 위변조 검증 — 본문·서명·시점확인·원장 |
+| `rootr_list_signed_documents` | 목록 (`pendingMine`: 내 차례인 것만) |
+| `rootr_bulk_sign_documents` | 코드 하나로 최대 100건 묶음 서명 |
+| `rootr_verify_ledger` | 워크스페이스 원장(해시 체인) 전체 재계산 |
+
+에이전트가 대신 눌러 줄 수 없는 자리가 하나 있습니다 — **서명**. 확인 코드는
+사람 메일로만 가므로 흐름은 항상 `rootr_request_signing_code` → 사람에게 6자리를
+물어봄 → `rootr_sign_document` 입니다. 코드를 지어내면 403이고, 5회 틀리면 코드가
+죽습니다.
+
+표의 행마다 서명문서를 붙이려면 `rootr_create_database`에 `rowPageType: "SIGNED"`를
+주세요 — 그 표는 행을 열 때마다 서명문서(연구노트)가 만들어집니다(실험 기록 대장,
+점검 대장).
+
 #### 문서 버전 / 삭제
 
 | 도구 | 설명 |

package/bin/rootr.js

@@ -41,9 +41,22 @@ const USAGE = `Rootr CLI v${pkg.version}
   rootr form responses <path|id> [--latest] [--json]  폼에 들어온 응답 보기 (--latest: 사람마다 최신 1건만)
   rootr form response-edit <응답id> --values '<json>'  이미 낸 응답 고치기 (폼 검사 규칙 다시 통과)
   rootr form response-rm <응답id> [--yes]           응답 한 건 삭제 (되돌릴 수 없음)
+  rootr sign new <경로> [--file <f>] [--reviewer <userId>] [--line <line.json>]  서명문서 만들기(본문·결재라인까지)
+  rootr sign show <path|id> [--json]               결재라인 진행·서명 목록 보기
+  rootr sign line <path|id> --file <line.json>     결재라인 다시 짜기 (올리기 전에만)
+  rootr sign code <path|id> | --bulk               확인 코드를 내 메일로 보내기 (서명 전 필수)
+  rootr sign submit <path|id> --code <6자리>        올리기 — 본문이 얼고 기안자가 첫 서명
+  rootr sign approve <path|id> --code <6자리>       내 차례에 서명
+  rootr sign reject <path|id> --comment <사유> [--code <6자리>]  반려 (사유 필수)
+  rootr sign reopen <path|id>                      아무도 서명 안 한 초안 다시 열기
+  rootr sign revise <path|id> --note <사유>         개정본 만들기 (원본은 그대로 남는다)
+  rootr sign verify <path|id> [--json]             위변조 검증 (서명·해시·시점확인)
+  rootr sign list [--pending] [--status <S>] [--mode <M>] [--json]  서명문서 목록 (--pending: 내 차례)
+  rootr sign bulk <id…> --code <6자리>              여러 건 한 번에 서명 (코드 하나로)
+  rootr sign ledger [--json]                       워크스페이스 원장(해시 체인) 전체 검증
   rootr config [--api-key <k>] [--workspace <w>] [--base-url <u>]  설정 조회/저장
   rootr config --add-key <k> [--label <name>] [--workspace <w>]     워크스페이스별 키 추가 등록
-  rootr mcp                                        MCP stdio 서버 구동 (도구 90종+ — README 참고)
+  rootr mcp                                        MCP stdio 서버 구동 (도구 130종+ — README 참고)
   rootr --help                                     도움말
   rootr --version                                  버전 출력
 
@@ -840,6 +853,233 @@ async function resolveDatabaseId(client, target) {
   return target;
 }
 
+// ── SIGN-001: 서명문서 · 연구노트 ────────────────────────────────────────
+//
+// 서명·올리기·반려는 메일로 받은 6자리 확인 코드를 함께 보내야 한다. 서버가
+// 개인키를 보관하는 구조에서 "본인이 눌렀다"의 유일한 증거라, CLI가 대신
+// 눌러 줄 수 있는 자리가 아니다 — `rootr sign code`로 코드를 받고, 메일에서
+// 읽은 값을 `--code`로 넘긴다.
+
+const SIGN_USAGE =
+  '사용법: rootr sign new|show|line|code|submit|approve|reject|reopen|revise|verify|list|bulk|ledger …\n' +
+  '       (자세한 건 rootr --help)';
+
+function signWorkspace(client, args) {
+  const ws = args.ws || client.workspace;
+  if (!ws) throw new Error('워크스페이스를 알 수 없습니다. --ws 를 주거나 rootr use 로 정하세요.');
+  return ws;
+}
+
+/** 서명 관련 인자도 문서 도구들과 같은 규칙 — 경로로 줘도 되게. */
+async function resolveSignedId(client, target) {
+  if (!target) throw new Error(SIGN_USAGE);
+  return requireResolved(await resolveTarget(client, target));
+}
+
+function requireCode(args, what) {
+  if (typeof args.code !== 'string' || !args.code.trim()) {
+    throw new Error(
+      `${what}에는 확인 코드가 필요합니다: 먼저 rootr sign code <path|id> 로 메일을 받고 --code <6자리> 로 넘기세요.`,
+    );
+  }
+  return args.code.trim();
+}
+
+const SIGN_STATUS_KO = {
+  DRAFT: '작성 중',
+  IN_PROGRESS: '서명 진행 중',
+  COMPLETED: '완료',
+  REJECTED: '반려됨',
+  SUPERSEDED: '개정되어 대체됨',
+  VOIDED: '무효',
+};
+
+function printSignedState(st) {
+  console.log(`${st.name}  [${SIGN_STATUS_KO[st.status] ?? st.status}]${st.mode === 'RESEARCH_NOTE' ? '  (연구노트)' : ''}`);
+  if (st.revisionNo) console.log(`개정 ${st.revisionNo}판${st.revisionNote ? ` — ${st.revisionNote}` : ''}`);
+  if (st.latestRevisionId) console.log(`※ 더 최신 판이 있습니다: ${st.latestRevisionId} (${st.latestRevisionNo}판)`);
+  console.log(st.lockedAt ? `잠김: ${st.lockedAt} (본문·결재라인 수정 불가)` : '잠기지 않음 (아직 고칠 수 있음)');
+  if (!st.contentIntact) console.log('⚠️ 본문이 서명 당시와 다릅니다 — rootr sign verify 로 확인하세요.');
+  for (const step of st.steps ?? []) {
+    const here = step.order === st.currentStepOrder ? ' ← 지금 이 차례' : '';
+    const rule = step.rule === 'ANY' ? '아무나 1명' : step.rule === 'N_OF_M' ? `${step.requiredCount}명` : '전원';
+    console.log(`\n${step.order}. ${step.label} (${rule})${here}`);
+    for (const m of step.members ?? []) {
+      console.log(`   - ${m.userId}  ${m.role}  ${m.state}${m.actedAt ? `  ${m.actedAt}` : ''}${m.comment ? `  "${m.comment}"` : ''}`);
+    }
+  }
+  if (st.signatures?.length) {
+    console.log('\n서명:');
+    for (const sig of st.signatures) {
+      console.log(
+        `   #${sig.seq} ${sig.signerName} <${sig.signerEmail}> ${sig.role}  ${sig.signedAt}` +
+          (sig.timestampPending ? '  [시점확인 대기중]' : `  [시점확인 ${sig.tsTime} · ${sig.tsaName}]`),
+      );
+    }
+  }
+  if (st.canSign) console.log('\n→ 지금 서명할 수 있습니다: rootr sign code <id> 후 rootr sign approve <id> --code <6자리>');
+}
+
+async function cmdSign(args) {
+  const sub = args._[0];
+  const client = makeClient();
+
+  switch (sub) {
+    case 'new': {
+      const target = args._[1];
+      if (!target) throw new Error('사용법: rootr sign new <경로> [--file <본문.md>] [--reviewer <userId>] [--line <line.json>]');
+      const ws = signWorkspace(client, args);
+      const content =
+        typeof args.file === 'string'
+          ? readFileSync(args.file, 'utf8')
+          : args._[2] !== undefined
+            ? String(args._[2])
+            : await readStdin();
+      const approvalLine =
+        typeof args.line === 'string' ? JSON.parse(readFileSync(args.line, 'utf8')) : undefined;
+      const noteMeta = typeof args.meta === 'string' ? JSON.parse(readFileSync(args.meta, 'utf8')) : undefined;
+      const body = {
+        content: content || '',
+        createParents: true,
+        approvalLine,
+        noteMeta,
+        reviewerUserId: typeof args.reviewer === 'string' ? args.reviewer : undefined,
+        mode: typeof args.mode === 'string' ? args.mode : args.reviewer ? 'RESEARCH_NOTE' : undefined,
+      };
+      if (target.startsWith('/')) body.path = target;
+      else body.name = target;
+      const st = await client.createSignedDoc(ws, body);
+      console.log(`서명문서 생성: ${st.path ?? st.name}  (${st.nodeId})`);
+      if (!st.steps?.length) {
+        console.log('결재라인이 아직 없습니다 — rootr sign line <id> --file <line.json> 으로 짜세요.');
+      } else {
+        printSignedState(st);
+      }
+      return;
+    }
+    case 'show': {
+      const st = await client.getSignedDoc(await resolveSignedId(client, args._[1]));
+      if (args.json) return console.log(JSON.stringify(st, null, 2));
+      return printSignedState(st);
+    }
+    case 'line': {
+      const id = await resolveSignedId(client, args._[1]);
+      const raw = typeof args.file === 'string' ? readFileSync(args.file, 'utf8') : await readStdin();
+      if (!raw) throw new Error('결재라인 JSON이 없습니다 (--file 또는 표준입력).');
+      const parsed = JSON.parse(raw);
+      const steps = Array.isArray(parsed) ? parsed : parsed.steps;
+      const st = await client.setApprovalLine(id, steps);
+      console.log(`결재라인 ${st.steps.length}단계 저장됨.`);
+      return printSignedState(st);
+    }
+    case 'code': {
+      if (args.bulk) {
+        const ws = signWorkspace(client, args);
+        const out = await client.requestBulkSigningCode(ws);
+        console.log(`묶음 서명용 확인 코드를 ${out.sentTo ?? '메일'}로 보냈습니다. 10분 안에 --code 로 넘기세요.`);
+        return;
+      }
+      const out = await client.requestSigningCode(await resolveSignedId(client, args._[1]));
+      console.log(`확인 코드를 ${out.sentTo ?? '메일'}로 보냈습니다. 10분 안에 --code 로 넘기세요.`);
+      return;
+    }
+    case 'submit': {
+      const id = await resolveSignedId(client, args._[1]);
+      const st = await client.submitSignedDoc(id, { code: requireCode(args, '올리기') });
+      console.log('올렸습니다 — 본문이 얼었고 기안자 서명이 찍혔습니다.');
+      return printSignedState(st);
+    }
+    case 'approve':
+    case 'sign': {
+      const id = await resolveSignedId(client, args._[1]);
+      const st = await client.signSignedDoc(id, { code: requireCode(args, '서명') });
+      console.log('서명했습니다.');
+      return printSignedState(st);
+    }
+    case 'reject': {
+      const id = await resolveSignedId(client, args._[1]);
+      if (typeof args.comment !== 'string' || !args.comment.trim()) {
+        throw new Error('반려에는 사유가 필요합니다: --comment "근거 자료가 빠졌습니다"');
+      }
+      const st = await client.rejectSignedDoc(id, { comment: args.comment, code: args.code });
+      console.log('반려했습니다 — 작성자가 다시 고칠 수 있습니다.');
+      return printSignedState(st);
+    }
+    case 'reopen': {
+      const st = await client.reopenSignedDoc(await resolveSignedId(client, args._[1]));
+      console.log('다시 열었습니다 — 본문과 결재라인을 고칠 수 있습니다.');
+      return printSignedState(st);
+    }
+    case 'revise': {
+      const id = await resolveSignedId(client, args._[1]);
+      if (typeof args.note !== 'string' || !args.note.trim()) {
+        throw new Error('개정에는 사유가 필요합니다: --note "측정값 단위 정정"');
+      }
+      const out = await client.reviseSignedDoc(id, args.note);
+      console.log(`개정본을 만들었습니다: ${out.nodeId} (${out.revisionNo}판). 원본은 그대로 남습니다.`);
+      return printSignedState(await client.getSignedDoc(out.nodeId));
+    }
+    case 'verify': {
+      const v = await client.verifySignedDoc(await resolveSignedId(client, args._[1]));
+      if (args.json) return console.log(JSON.stringify(v, null, 2));
+      const mark = (ok) => (ok ? '✅' : '❌');
+      console.log(`${v.name}  [${SIGN_STATUS_KO[v.status] ?? v.status}]`);
+      console.log(`${mark(v.contentIntact)} 본문이 서명 당시 그대로다`);
+      console.log(`${mark(v.allSignaturesValid)} 서명이 전부 유효하고 체인이 이어진다`);
+      console.log(`${mark(v.allTimestamped)} 서명마다 공인시점확인이 붙어 있다`);
+      console.log(`${mark(v.ledgerIntact)} 워크스페이스 원장이 성하다${v.ledgerBrokenAtSeq ? ` (끊긴 지점 #${v.ledgerBrokenAtSeq})` : ''}`);
+      for (const sig of v.signatures ?? []) {
+        console.log(
+          `   #${sig.seq} ${sig.signerName} ${sig.role} ${sig.signedAt} ` +
+            `${mark(sig.signatureValid)}서명 ${mark(sig.chainLinkValid)}체인 ${mark(sig.matchesCurrentContent)}현재본문` +
+            (sig.timestampPending ? ' [시점확인 대기중]' : ''),
+        );
+      }
+      return;
+    }
+    case 'list': {
+      const ws = signWorkspace(client, args);
+      const rows = await client.listSignedDocs(ws, {
+        status: typeof args.status === 'string' ? args.status : undefined,
+        mode: typeof args.mode === 'string' ? args.mode : undefined,
+        pendingMine: !!args.pending,
+      });
+      if (args.json) return console.log(JSON.stringify(rows, null, 2));
+      if (!rows.length) return console.log(args.pending ? '내 차례인 서명문서가 없습니다.' : '서명문서가 없습니다.');
+      for (const r of rows) {
+        const waiting = r.waitingOn?.length ? `  대기: ${r.waitingOn.join(', ')}` : '';
+        console.log(`${r.nodeId}\t${SIGN_STATUS_KO[r.status] ?? r.status}\t${r.path}${waiting}${r.canSign ? '  ← 내 차례' : ''}`);
+      }
+      return;
+    }
+    case 'bulk': {
+      const ws = signWorkspace(client, args);
+      const targets = args._.slice(1);
+      if (!targets.length) throw new Error('사용법: rootr sign bulk <id|경로 …> --code <6자리>');
+      const code = requireCode(args, '묶음 서명');
+      const nodeIds = [];
+      for (const t of targets) nodeIds.push(await resolveSignedId(client, t));
+      const out = await client.bulkSignSignedDocs(ws, { nodeIds, code });
+      if (args.json) return console.log(JSON.stringify(out, null, 2));
+      const failed = (out.results ?? []).filter((r) => !r.ok);
+      console.log(`서명 ${out.signed ?? 0}건, 건너뜀 ${failed.length}건`);
+      for (const f of failed) console.log(`  건너뜀 ${f.nodeId}: ${f.error}`);
+      return;
+    }
+    case 'ledger': {
+      const ws = signWorkspace(client, args);
+      const v = await client.verifyLedger(ws);
+      if (args.json) return console.log(JSON.stringify(v, null, 2));
+      console.log(`${v.ok ? '✅ 원장이 성합니다' : '❌ 원장이 끊겼습니다'} — 서명 ${v.count}건`);
+      if (v.headHash) console.log(`머리 해시: ${v.headHash}`);
+      if (!v.ok) console.log(`끊긴 지점: #${v.brokenAtSeq}${v.reason ? ` (${v.reason})` : ''}`);
+      return;
+    }
+    default:
+      throw new Error(SIGN_USAGE);
+  }
+}
+
 async function main() {
   const argv = process.argv.slice(2);
   const args = parseArgs(argv);
@@ -889,6 +1129,8 @@ async function main() {
       return cmdForm(args);
     case 'access':
       return cmdAccess(args);
+    case 'sign':
+      return cmdSign(args);
     case 'mcp':
       return cmdMcp(args);
     default:

package/lib/client.js

@@ -644,10 +644,21 @@ 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 } = {}) {
+  async createDatabase(workspace, { name, parentId, path, createParents, autoRename, icon, properties, views, rows, rowPageType } = {}) {
     return this.request(`/workspaces/${encodeURIComponent(workspace)}/databases`, {
       method: 'POST',
-      body: { name, parentId, path, createParents, autoRename, icon, properties, views, rows },
+      body: { name, parentId, path, createParents, autoRename, icon, properties, views, rows, rowPageType },
+    });
+  }
+
+  /**
+   * SIGN-001 — 이 표의 행을 열었을 때 나오는 상세 문서를 서명문서로 바꾼다.
+   * 그 뒤로 만들어지는 행마다 서명문서(연구노트)가 붙는다.
+   */
+  async setDatabaseRowPageType(databaseId, rowPageType) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}`, {
+      method: 'PATCH',
+      body: { rowPageType },
     });
   }
 
@@ -655,10 +666,13 @@ export class RootrClient {
    * 뷰를 하나 **덧붙인다**(기존 뷰는 그대로). 표를 만들 때만 뷰를 정할 수 있어서,
    * 노션에서 뷰가 넷인 표를 옮기면 하나밖에 못 두던 문제를 푼다.
    */
-  async createDatabaseView(databaseId, { name, type, groupBy, dateProp, endDateProp } = {}) {
+  async createDatabaseView(
+    databaseId,
+    { name, type, groupBy, dateProp, endDateProp, filters, sort, colWidths } = {},
+  ) {
     return this.request(`/databases/${encodeURIComponent(databaseId)}/views`, {
       method: 'POST',
-      body: { name, type, groupBy, dateProp, endDateProp },
+      body: { name, type, groupBy, dateProp, endDateProp, filters, sort, colWidths },
     });
   }
 
@@ -1291,4 +1305,123 @@ export class RootrClient {
     if (data && Array.isArray(data.links)) return data.links;
     return [];
   }
+
+  // ── SIGN-001: 서명문서 · 연구노트 ────────────────────────────────────
+  //
+  // 마크다운 문서인데 올리는 순간 본문이 얼고, 결재라인에 적힌 사람들이 차례로
+  // 서명하면 서명마다 시점확인(TSA)과 해시 체이닝이 붙는다. 서명·올리기·반려는
+  // 메일로 받은 6자리 확인 코드를 함께 보내야 한다 — 서버가 개인키를 보관하는
+  // 구조에서 "본인이 눌렀다"의 유일한 증거라, 코드 없이 대신 눌러 줄 수는 없다.
+
+  /** 서명문서 만들기 — 본문·모드·결재라인까지 한 번에. */
+  async createSignedDoc(workspaceId, body = {}) {
+    return this.request(`/workspaces/${encodeURIComponent(workspaceId)}/signed-docs`, {
+      method: 'POST',
+      body,
+    });
+  }
+
+  /** 지금 상태: 결재라인·단계별 진행·서명 목록·본문이 그대로인지. */
+  async getSignedDoc(nodeId) {
+    return this.request(`/signed-docs/${encodeURIComponent(nodeId)}`);
+  }
+
+  /** 결재라인 다시 짜기(올리기 전에만). steps 순서가 곧 서명 순서다. */
+  async setApprovalLine(nodeId, steps) {
+    return this.request(`/signed-docs/${encodeURIComponent(nodeId)}/approval-line`, {
+      method: 'PUT',
+      body: { steps },
+    });
+  }
+
+  /** 연구노트 프리셋: 기재자(나) → 점검자 두 단계. */
+  async applyResearchNotePreset(nodeId, { reviewerUserId, noteMeta } = {}) {
+    return this.request(`/signed-docs/${encodeURIComponent(nodeId)}/research-note-preset`, {
+      method: 'POST',
+      body: { reviewerUserId, noteMeta },
+    });
+  }
+
+  /** 확인 코드를 본인 메일로 보낸다. 문서 하나용. */
+  async requestSigningCode(nodeId) {
+    return this.request(`/signed-docs/${encodeURIComponent(nodeId)}/request-code`, {
+      method: 'POST',
+      body: {},
+    });
+  }
+
+  /** 확인 코드 — 묶음 서명용(워크스페이스 단위로 한 번). */
+  async requestBulkSigningCode(workspaceId) {
+    return this.request(`/workspaces/${encodeURIComponent(workspaceId)}/signed-docs/request-code`, {
+      method: 'POST',
+      body: {},
+    });
+  }
+
+  /** 올리기 = 본문을 얼리고 기안자가 첫 도장을 찍는다. */
+  async submitSignedDoc(nodeId, { code } = {}) {
+    return this.request(`/signed-docs/${encodeURIComponent(nodeId)}/submit`, {
+      method: 'POST',
+      body: { code },
+    });
+  }
+
+  /** 내 차례에 서명한다. */
+  async signSignedDoc(nodeId, { code } = {}) {
+    return this.request(`/signed-docs/${encodeURIComponent(nodeId)}/sign`, {
+      method: 'POST',
+      body: { code },
+    });
+  }
+
+  /** 반려 — 사유는 필수다. 반려되면 다시 고칠 수 있게 풀린다. */
+  async rejectSignedDoc(nodeId, { comment, code } = {}) {
+    return this.request(`/signed-docs/${encodeURIComponent(nodeId)}/reject`, {
+      method: 'POST',
+      body: { comment, code },
+    });
+  }
+
+  /** 아직 아무도 서명하지 않은 초안을 다시 열어 고칠 수 있게 한다. */
+  async reopenSignedDoc(nodeId) {
+    return this.request(`/signed-docs/${encodeURIComponent(nodeId)}/reopen`, { method: 'POST' });
+  }
+
+  /** 개정본 만들기 — 서명된 문서는 고치는 게 아니라 새 판을 낸다. */
+  async reviseSignedDoc(nodeId, note) {
+    return this.request(`/signed-docs/${encodeURIComponent(nodeId)}/revise`, {
+      method: 'POST',
+      body: { note },
+    });
+  }
+
+  /** 위변조 검증. 로그인 없이도 열려 있다(본문은 안 내려온다). */
+  async verifySignedDoc(nodeId) {
+    return this.request(`/signed-docs/${encodeURIComponent(nodeId)}/verify`);
+  }
+
+  /** 워크스페이스 서명문서 목록. pendingMine이면 "내 차례인 것"만. */
+  async listSignedDocs(workspaceId, { status, mode, pendingMine } = {}) {
+    const qs = new URLSearchParams();
+    if (status) qs.set('status', status);
+    if (mode) qs.set('mode', mode);
+    if (pendingMine) qs.set('pendingMine', 'true');
+    const q = qs.toString();
+    return this.request(
+      `/workspaces/${encodeURIComponent(workspaceId)}/signed-docs${q ? `?${q}` : ''}`,
+    );
+  }
+
+  /** 묶음 서명 — "이번 주 미점검 12건"을 한 번에. 코드 하나로 전부. */
+  async bulkSignSignedDocs(workspaceId, { nodeIds, code } = {}) {
+    return this.request(`/workspaces/${encodeURIComponent(workspaceId)}/signed-docs/bulk-sign`, {
+      method: 'POST',
+      body: { nodeIds, code },
+    });
+  }
+
+  /** 워크스페이스 원장(해시 체인) 전체 검증. */
+  async verifyLedger(workspaceId) {
+    return this.request(`/workspaces/${encodeURIComponent(workspaceId)}/ledger/verify`);
+  }
 }

package/lib/mcp-tools/databases.js

@@ -13,6 +13,61 @@ import {
 /** Human text for the `databaseId` param — accepts a path just like the document tools. */
 const DATABASE_TARGET_DESC = `DATABASE node id${NODE_TARGET_HINT} (e.g. "/제작 공정/칸반")`;
 
+/**
+ * VIEW-FILTER — 사람이 화면에서 거는 "이 조건만 보이게"를 에이전트도 걸 수 있게 한다.
+ * 조건은 전부 만족해야 하고(AND), 한 조건 안의 `values`는 그중 하나만 맞아도 된다(OR).
+ */
+const FILTER_SHAPE = z.array(
+  z.object({
+    propId: z.string().describe('Column NAME or id the condition applies to'),
+    op: z
+      .enum([
+        'is',
+        'is_not',
+        'contains',
+        'is_empty',
+        'is_not_empty',
+        'today',
+        'this_week',
+        'this_month',
+        'past',
+        'upcoming',
+        'before',
+        'after',
+        'on',
+        'between',
+        'eq',
+        'gt',
+        'lt',
+        'checked',
+        'unchecked',
+      ])
+      .describe('Comparison to apply'),
+    values: z
+      .array(z.string())
+      .optional()
+      .describe(
+        'Values the op needs. is/is_not/contains → one or more (OR between them). ' +
+          'before/after/on → one date "YYYY-MM-DD". between → two dates. eq/gt/lt → one number. ' +
+          'is_empty/is_not_empty/today/this_week/this_month/past/upcoming/checked/unchecked take none.',
+      ),
+  }),
+);
+
+const FILTER_DESC =
+  'Only rows matching EVERY condition are shown in this view (AND between conditions, OR inside one ' +
+  'condition\'s values). This is the same filter a person sets on screen, so "검토 대기인 것만 보이게 해줘" ' +
+  'is expressible: [{"propId":"구분","op":"is","values":["검토 대기"]}]. Rows are NOT deleted — other views ' +
+  'still show them. A new row added while a filter is on is seeded with the filtered values so it does not ' +
+  'vanish the moment it is created.';
+
+const SORT_SHAPE = z.object({
+  propId: z.string().describe('Column NAME or id to sort by'),
+  dir: z.enum(['asc', 'desc']).describe('asc = 오름차순, desc = 내림차순'),
+});
+
+const SORT_DESC = 'Row order in this view.';
+
 /**
  * DB-BODY — 행의 상세 내용(본문 메모). 화면에서 칸반 카드를 열면 속성 아래에 붙는 그 글이며,
  * 실체는 표 밑에 달리는 문서 하나다. 예전에는 REST 2단계로만 닿을 수 있어서 CLI·MCP에서는
@@ -143,10 +198,18 @@ export function registerDatabaseTools(server) {
           .array(z.object({ values: z.record(z.unknown()) }))
           .optional()
           .describe('Initial rows, e.g. [{ values: { "이름": "킥오프", "기한": { "start": "2026-08-01" } } }]'),
+        rowPageType: z
+          .enum(['DOCUMENT', 'SIGNED'])
+          .optional()
+          .describe(
+            'SIGN-001 — what a row\'s detail page is. "SIGNED" makes every row open as a 서명문서/연구노트 ' +
+              '(freezes on submit, ordered signatures + RFC 3161 timestamps, undeletable). Use it for 실험 기록 · ' +
+              '점검 대장 · 결재 대장 표. Default "DOCUMENT".',
+          ),
         workspace: z.string().optional().describe('Workspace id; defaults to ROOTR_WORKSPACE/config if omitted'),
       },
     },
-    async ({ name, parentId, path, createParents, icon, properties, views, rows, workspace }) => {
+    async ({ name, parentId, path, createParents, icon, properties, views, rows, rowPageType, workspace }) => {
       try {
         const ws = requireWorkspace(workspace);
         const client = makeClient(ws);
@@ -160,6 +223,7 @@ export function registerDatabaseTools(server) {
           properties,
           views,
           rows,
+          rowPageType,
         });
         return jsonResult(database);
       } catch (err) {
@@ -189,13 +253,31 @@ export function registerDatabaseTools(server) {
         groupBy: z.string().optional().describe('board view: the select column to group by (name or id)'),
         dateProp: z.string().optional().describe('calendar/timeline view: the date column (name or id)'),
         endDateProp: z.string().optional().describe('timeline view: the end-date column (name or id)'),
+        filters: FILTER_SHAPE.optional().describe(FILTER_DESC),
+        sort: SORT_SHAPE.optional().describe(SORT_DESC),
+        colWidths: z
+          .record(z.number())
+          .optional()
+          .describe(
+            '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.',
+          ),
       },
     },
-    async ({ databaseId, name, type, groupBy, dateProp, endDateProp }) => {
+    async ({ databaseId, name, type, groupBy, dateProp, endDateProp, filters, sort, colWidths }) => {
       try {
         const client = makeClient();
         const id = await resolveNodeId(client, databaseId);
-        const view = await client.createDatabaseView(id, { name, type, groupBy, dateProp, endDateProp });
+        const view = await client.createDatabaseView(id, {
+          name,
+          type,
+          groupBy,
+          dateProp,
+          endDateProp,
+          filters,
+          sort,
+          colWidths,
+        });
         return jsonResult(view);
       } catch (err) {
         return errorResult(err);
@@ -250,9 +332,29 @@ export function registerDatabaseTools(server) {
         groupBy: z.string().optional().describe('board view: the select column to group by (name or id)'),
         dateProp: z.string().optional().describe('calendar/timeline view: the date column (name or id)'),
         endDateProp: z.string().optional().describe('timeline view: the end-date column (name or id)'),
+        filters: FILTER_SHAPE.nullable().optional().describe(FILTER_DESC + ' null 또는 []을 주면 조건을 전부 없앤다.'),
+        sort: SORT_SHAPE.nullable().optional().describe(SORT_DESC + ' null을 주면 정렬을 끈다.'),
+        colWidths: z
+          .record(z.number())
+          .optional()
+          .describe(
+            '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.',
+          ),
       },
     },
-    async ({ databaseId, viewId, hiddenProps, name, groupBy, dateProp, endDateProp }) => {
+    async ({
+      databaseId,
+      viewId,
+      hiddenProps,
+      name,
+      groupBy,
+      dateProp,
+      endDateProp,
+      filters,
+      sort,
+      colWidths,
+    }) => {
       try {
         const client = makeClient();
         const id = await resolveNodeId(client, databaseId);
@@ -262,6 +364,9 @@ export function registerDatabaseTools(server) {
           groupBy,
           dateProp,
           endDateProp,
+          filters,
+          sort,
+          colWidths,
         });
         return jsonResult({ view });
       } catch (err) {

package/lib/mcp-tools/signed.js

@@ -0,0 +1,467 @@
+import { z } from 'zod';
+
+import {
+  jsonResult,
+  textResult,
+  errorResult,
+  makeClient,
+  requireWorkspace,
+  resolveNodeId,
+  resolveOptionalNodeId,
+  NODE_TARGET_HINT,
+} from './shared.js';
+
+/**
+ * SIGN-001 — 서명문서 · 연구노트.
+ *
+ * 마크다운 문서인데 **올리는 순간 본문이 얼고**, 결재라인에 적힌 사람들이 차례로
+ * 서명하면 서명마다 시점확인(RFC 3161 TSA)과 워크스페이스 원장 해시 체이닝이
+ * 붙는다. 국가R&D 전자연구노트 지침이 요구하는 ①전자서명 ②시점확인 ③위변조확인이
+ * 그대로 이 셋이다.
+ *
+ * 에이전트가 대신 눌러 줄 수 없는 자리가 하나 있다: **서명**. 확인 코드가 사람
+ * 메일로만 가고, 그게 "본인이 눌렀다"의 유일한 증거라서 그렇다. 그래서 흐름은
+ * 항상 rootr_request_signing_code → (사람이 메일에서 코드를 읽어 알려 준다) →
+ * rootr_sign_document 다. 코드를 지어내지 말고 사람에게 물어야 한다.
+ */
+
+const APPROVAL_STEP = z.object({
+  label: z.string().optional().describe('단계 이름, 예: "기재자" / "점검자" / "부서장"'),
+  rule: z
+    .enum(['ALL', 'ANY', 'N_OF_M'])
+    .optional()
+    .describe('ALL=이 단계 전원 서명(기본), ANY=아무나 한 명, N_OF_M=requiredCount 명'),
+  requiredCount: z.number().int().min(1).optional().describe('rule이 N_OF_M일 때 필요한 인원 수'),
+  members: z
+    .array(
+      z.object({
+        userId: z.string().describe('워크스페이스 멤버의 userId (외부인은 아직 결재자가 될 수 없다)'),
+        role: z
+          .enum(['AUTHOR', 'REVIEWER', 'APPROVER'])
+          .optional()
+          .describe('AUTHOR=기재자, REVIEWER=점검자, APPROVER=결재자. 생략하면 자리로 정해진다'),
+      }),
+    )
+    .min(1),
+});
+
+const CODE_HINT =
+  '메일로 받은 6자리 확인 코드. 먼저 rootr_request_signing_code 를 부르면 사용자 메일로 가고, ' +
+  '사용자가 알려 준 값을 그대로 넣는다. 절대 지어내지 말 것 — 틀리면 403이고 5회 틀리면 코드가 죽는다.';
+
+export function registerSignedDocTools(server) {
+  server.registerTool(
+    'rootr_create_signed_document',
+    {
+      title: 'Create a Rootr signed document',
+      description:
+        'Create a SIGNED document (서명문서 · 전자결재 · 국가R&D 전자연구노트) in a Rootr (루터) workspace. ' +
+        'A markdown document that FREEZES on submit: after that the body, attachments and approval line ' +
+        'cannot be edited, every signature carries an RFC 3161 timestamp, and the whole workspace keeps a ' +
+        'hash-chained ledger so tampering is detectable. Signed documents cannot be deleted (30-year ' +
+        'retention). Use this instead of a plain DOCUMENT whenever the content must be provable — 결재/승인 ' +
+        '문서, 연구노트, 점검 기록, 회의 확인서. ' +
+        'Flow: create (body + approval line) → edit the body freely with rootr_write/rootr_append → ' +
+        'rootr_request_signing_code → ask the human for the 6-digit code → rootr_submit_signed_document ' +
+        '(freezes + first signature) → each remaining signer does request-code + rootr_sign_document.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        name: z.string().optional().describe('문서 이름, 예: "2026-08-25 실험 기록"'),
+        path: z
+          .string()
+          .optional()
+          .describe('트리 경로로 만들 때, 예: "/연구노트/2026-08-25 실험기록" (parentId 대신)'),
+        parentId: z.string().optional().describe(`부모 폴더 id${NODE_TARGET_HINT}`),
+        createParents: z.boolean().optional().describe('path를 쓸 때 없는 상위 폴더까지 만든다'),
+        icon: z.string().optional().describe('이모지 아이콘'),
+        content: z.string().optional().describe('본문 마크다운. 올리기 전까지는 얼마든지 고칠 수 있다'),
+        mode: z
+          .enum(['APPROVAL', 'RESEARCH_NOTE'])
+          .optional()
+          .describe('APPROVAL=전자결재(기본), RESEARCH_NOTE=연구노트'),
+        reviewerUserId: z
+          .string()
+          .optional()
+          .describe(
+            '연구노트 프리셋용 점검자(연구책임자) userId. approvalLine 없이 이것만 주면 ' +
+              '"기재자(만든 사람) → 점검자" 두 단계가 자동으로 짜인다',
+          ),
+        noteMeta: z
+          .record(z.any())
+          .optional()
+          .describe('연구노트 표지 정보: 과제번호·과제명·연구책임자·기관 등'),
+        approvalLine: z
+          .array(APPROVAL_STEP)
+          .optional()
+          .describe('결재라인. 배열 순서가 곧 서명 순서다'),
+        workspace: z.string().optional().describe('워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ parentId, workspace, ...rest }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        const client = makeClient(ws);
+        parentId = await resolveOptionalNodeId(client, parentId);
+        return jsonResult(await client.createSignedDoc(ws, { ...rest, parentId }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_read_signed_document',
+    {
+      title: 'Read a Rootr signed document state',
+      description:
+        'Read a SIGNED document\'s signing state: mode, status (DRAFT/IN_PROGRESS/COMPLETED/REJECTED/' +
+        'SUPERSEDED), whether it is locked, the approval line with each step\'s progress, every signature so far ' +
+        '(signer, time, TSA timestamp), whether the body still matches the frozen hash, and whether YOU can ' +
+        'sign right now (canSign). Read the body itself with rootr_read.',
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        nodeId: z.string().describe(`서명문서 노드 id${NODE_TARGET_HINT}`),
+        workspace: z.string().optional().describe('워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ nodeId, workspace }) => {
+      try {
+        const client = makeClient(workspace);
+        return jsonResult(await client.getSignedDoc(await resolveNodeId(client, nodeId)));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_set_approval_line',
+    {
+      title: 'Set a signed document approval line',
+      description:
+        'Replace the approval line (결재라인) of a SIGNED document. The array order IS the signing order; ' +
+        'each step can require everyone (ALL), anyone (ANY) or N of M. Only possible BEFORE submit — once ' +
+        'the document is submitted the line is frozen with the body (409 SIGNED_DOC_LOCKED); reject it first ' +
+        'to reopen. All members must be workspace members.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        nodeId: z.string().describe(`서명문서 노드 id${NODE_TARGET_HINT}`),
+        steps: z.array(APPROVAL_STEP).min(1).describe('단계 배열. 순서가 곧 서명 순서다'),
+        workspace: z.string().optional().describe('워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ nodeId, steps, workspace }) => {
+      try {
+        const client = makeClient(workspace);
+        return jsonResult(await client.setApprovalLine(await resolveNodeId(client, nodeId), steps));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_apply_research_note_preset',
+    {
+      title: 'Turn a signed document into a research note',
+      description:
+        'Switch a SIGNED document to RESEARCH_NOTE mode and build the two-step line the Korean national R&D ' +
+        'guideline requires: 기재자(the caller) → 점검자(the reviewer/연구책임자). Optionally stores the cover ' +
+        'metadata (과제번호·과제명·기관). Use this instead of hand-building the approval line for 연구노트.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        nodeId: z.string().describe(`서명문서 노드 id${NODE_TARGET_HINT}`),
+        reviewerUserId: z.string().describe('점검자(연구책임자)의 userId'),
+        noteMeta: z.record(z.any()).optional().describe('표지 정보: 과제번호·과제명·연구책임자·기관 등'),
+        workspace: z.string().optional().describe('워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ nodeId, reviewerUserId, noteMeta, workspace }) => {
+      try {
+        const client = makeClient(workspace);
+        return jsonResult(
+          await client.applyResearchNotePreset(await resolveNodeId(client, nodeId), {
+            reviewerUserId,
+            noteMeta,
+          }),
+        );
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_request_signing_code',
+    {
+      title: 'Email a signing confirmation code',
+      description:
+        'Send the 6-digit signing confirmation code to the signer\'s own email. REQUIRED before ' +
+        'rootr_submit_signed_document / rootr_sign_document / rootr_reject_signed_document / ' +
+        'rootr_bulk_sign_documents — the code is the only evidence that a HUMAN pressed sign, so you cannot ' +
+        'read it and must ask the user for it. Valid 10 minutes, 5 wrong tries kill it, and re-requesting ' +
+        'within 30 seconds is refused. Pass `bulk: true` (with no nodeId) for one code that covers a bulk sign.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        nodeId: z
+          .string()
+          .optional()
+          .describe(`서명문서 노드 id${NODE_TARGET_HINT}. bulk가 true면 생략한다`),
+        bulk: z.boolean().optional().describe('묶음 서명용 코드를 받을 때 true'),
+        workspace: z.string().optional().describe('워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ nodeId, bulk, workspace }) => {
+      try {
+        if (bulk) {
+          const ws = requireWorkspace(workspace);
+          const client = makeClient(ws);
+          const out = await client.requestBulkSigningCode(ws);
+          return jsonResult({ ...out, next: '사용자에게 메일로 받은 6자리 코드를 물어보세요.' });
+        }
+        const client = makeClient(workspace);
+        if (!nodeId) throw new Error('nodeId 또는 bulk: true 중 하나가 필요합니다.');
+        const out = await client.requestSigningCode(await resolveNodeId(client, nodeId));
+        return jsonResult({ ...out, next: '사용자에게 메일로 받은 6자리 코드를 물어보세요.' });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_submit_signed_document',
+    {
+      title: 'Submit (freeze + first-sign) a signed document',
+      description:
+        'Submit a SIGNED document: the body and attachments FREEZE (their SHA-256 is recorded), the author ' +
+        'signs first, and the next step\'s signers are notified. IRREVERSIBLE except by rejection — after ' +
+        'this the only way to change the content is a revision (rootr_revise_signed_document). Needs the ' +
+        'emailed code from rootr_request_signing_code.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        nodeId: z.string().describe(`서명문서 노드 id${NODE_TARGET_HINT}`),
+        code: z.string().describe(CODE_HINT),
+        workspace: z.string().optional().describe('워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ nodeId, code, workspace }) => {
+      try {
+        const client = makeClient(workspace);
+        return jsonResult(await client.submitSignedDoc(await resolveNodeId(client, nodeId), { code }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_sign_document',
+    {
+      title: 'Sign a Rootr signed document',
+      description:
+        'Sign a SIGNED document as the current step\'s signer. Records an Ed25519 signature over the frozen ' +
+        'content hash, requests an RFC 3161 timestamp, and links the signature into the workspace hash ledger. ' +
+        'Only works when it is your turn (check canSign with rootr_read_signed_document). Needs the emailed ' +
+        'code from rootr_request_signing_code — ask the human for it, never invent it.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        nodeId: z.string().describe(`서명문서 노드 id${NODE_TARGET_HINT}`),
+        code: z.string().describe(CODE_HINT),
+        workspace: z.string().optional().describe('워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ nodeId, code, workspace }) => {
+      try {
+        const client = makeClient(workspace);
+        return jsonResult(await client.signSignedDoc(await resolveNodeId(client, nodeId), { code }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_reject_signed_document',
+    {
+      title: 'Reject a signed document',
+      description:
+        'Reject a SIGNED document with a reason. The document unlocks so the author can fix and resubmit; ' +
+        'signatures already collected are recorded as part of the history and the rejection itself is ' +
+        'notified to the author. The reason is required — "반려됨"만 남으면 고칠 수가 없다.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        nodeId: z.string().describe(`서명문서 노드 id${NODE_TARGET_HINT}`),
+        comment: z.string().describe('반려 사유 (필수)'),
+        code: z.string().optional().describe(CODE_HINT),
+        workspace: z.string().optional().describe('워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ nodeId, comment, code, workspace }) => {
+      try {
+        const client = makeClient(workspace);
+        return jsonResult(
+          await client.rejectSignedDoc(await resolveNodeId(client, nodeId), { comment, code }),
+        );
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_reopen_signed_document',
+    {
+      title: 'Reopen an unsigned signed-document draft',
+      description:
+        'Unlock a SIGNED document that was submitted but that NOBODY has signed yet, so the body and the ' +
+        'approval line can be edited again. Once any signature exists this refuses — make a revision instead ' +
+        '(rootr_revise_signed_document).',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        nodeId: z.string().describe(`서명문서 노드 id${NODE_TARGET_HINT}`),
+        workspace: z.string().optional().describe('워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ nodeId, workspace }) => {
+      try {
+        const client = makeClient(workspace);
+        return jsonResult(await client.reopenSignedDoc(await resolveNodeId(client, nodeId)));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_revise_signed_document',
+    {
+      title: 'Create a revision of a signed document',
+      description:
+        'Create a NEW revision of an already-signed document. Signed documents are never edited in place — ' +
+        'the guideline requires that both the original and the correction stay visible — so this copies the ' +
+        'body into a fresh SIGNED node (revisionNo + 1), marks the original SUPERSEDED, and returns the new ' +
+        'node id. The reason (note) is recorded on the revision.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        nodeId: z.string().describe(`원본 서명문서 노드 id${NODE_TARGET_HINT}`),
+        note: z.string().describe('무엇을 왜 고치는지 (필수, 개정본에 남는다)'),
+        workspace: z.string().optional().describe('워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ nodeId, note, workspace }) => {
+      try {
+        const client = makeClient(workspace);
+        return jsonResult(await client.reviseSignedDoc(await resolveNodeId(client, nodeId), note));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_verify_signed_document',
+    {
+      title: 'Verify a signed document (tamper check)',
+      description:
+        'Verify a SIGNED document end to end: every Ed25519 signature is re-checked against its payload, ' +
+        'every hash-chain link is recomputed, the current body is hashed and compared with the frozen hash, ' +
+        'and the workspace ledger is replayed. Returns contentIntact / allSignaturesValid / allTimestamped / ' +
+        'ledgerIntact plus per-signature detail. This is the answer to "이 문서가 위조되지 않았음을 증명해 봐".',
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        nodeId: z.string().describe(`서명문서 노드 id${NODE_TARGET_HINT}`),
+        workspace: z.string().optional().describe('워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ nodeId, workspace }) => {
+      try {
+        const client = makeClient(workspace);
+        return jsonResult(await client.verifySignedDoc(await resolveNodeId(client, nodeId)));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_list_signed_documents',
+    {
+      title: 'List Rootr signed documents',
+      description:
+        'List the SIGNED documents of a workspace with their status and who each one is waiting on. ' +
+        'Set pendingMine: true for "내 차례인 것만" — the list a 연구책임자 opens to see this week\'s ' +
+        'unchecked notes before bulk-signing them.',
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        status: z
+          .enum(['DRAFT', 'IN_PROGRESS', 'COMPLETED', 'REJECTED', 'SUPERSEDED', 'VOIDED'])
+          .optional(),
+        mode: z.enum(['APPROVAL', 'RESEARCH_NOTE']).optional(),
+        pendingMine: z.boolean().optional().describe('내 서명을 기다리는 것만'),
+        workspace: z.string().optional().describe('워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ status, mode, pendingMine, workspace }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        const client = makeClient(ws);
+        return jsonResult(await client.listSignedDocs(ws, { status, mode, pendingMine }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_bulk_sign_documents',
+    {
+      title: 'Sign many Rootr documents at once',
+      description:
+        'Sign up to 100 SIGNED documents in one call with ONE emailed code (get it with ' +
+        'rootr_request_signing_code + bulk: true). Documents where it is not your turn are skipped and ' +
+        'reported, not failed. This is what makes 연구노트 usable in practice — a 연구책임자 signing "이번 주 ' +
+        '미점검 12건" without opening each one.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        nodeIds: z.array(z.string()).min(1).max(100).describe('서명할 노드 id 목록 (경로도 됩니다)'),
+        code: z.string().describe(CODE_HINT + ' (bulk: true 로 받은 코드)'),
+        workspace: z.string().optional().describe('워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ nodeIds, code, workspace }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        const client = makeClient(ws);
+        const ids = [];
+        for (const t of nodeIds) ids.push(await resolveNodeId(client, t));
+        return jsonResult(await client.bulkSignSignedDocs(ws, { nodeIds: ids, code }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_verify_ledger',
+    {
+      title: 'Verify the workspace signature ledger',
+      description:
+        'Replay the whole workspace signature ledger (every signature ever made, hash-chained in order) and ' +
+        'report whether it is intact, how many links it holds, its head hash, and the first broken sequence ' +
+        'if any. A broken ledger means someone edited or deleted signature rows in the database.',
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        workspace: z.string().optional().describe('워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ workspace }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        return jsonResult(await makeClient(ws).verifyLedger(ws));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+}

package/lib/mcp.js

@@ -17,6 +17,7 @@ import { registerWhiteboardTools } from './mcp-tools/whiteboards.js';
 import { registerFormTools } from './mcp-tools/forms.js';
 import { registerRecordingTools } from './mcp-tools/recordings.js';
 import { registerAttachmentTools } from './mcp-tools/attachments.js';
+import { registerSignedDocTools } from './mcp-tools/signed.js';
 import { withRateLimitSink } from './context.js';
 
 /** Warn once the workspace has burned this share of its quota. */
@@ -64,7 +65,7 @@ function withQuotaWarnings(server) {
  * Builds a fully-configured McpServer (all tool groups registered) without
  * connecting a transport. Shared by the local stdio CLI server below and by
  * the backend's hosted Streamable HTTP transport (src/mcp/mcp-transport.controller.ts),
- * so the 89 tool definitions have exactly one implementation.
+ * so the 134 tool definitions have exactly one implementation.
  */
 export function buildMcpServer({ name, version }) {
   const server = new McpServer(
@@ -111,6 +112,16 @@ export function buildMcpServer({ name, version }) {
         'and spends AI credits) → poll rootr_read_recording until status READY → read the transcript, ' +
         'rename speakers with rootr_rename_recording_speakers, and write the minutes yourself with rootr_write ' +
         '(preferred — no AI credits) or call rootr_summarize_recording for Rootr\'s built-in summary document; ' +
+        'SIGNED = 서명문서 · 전자결재 · 국가R&D 전자연구노트 — a markdown document that FREEZES on submit, ' +
+        'collects ordered Ed25519 signatures with RFC 3161 timestamps, and is hash-chained into a workspace ' +
+        'ledger so tampering is provable; cannot be deleted (30-year retention). Use it whenever the content ' +
+        'must be provable — 결재/승인 문서, 연구노트, 점검 기록 — via rootr_create_signed_document, ' +
+        'rootr_read_signed_document, rootr_set_approval_line, rootr_apply_research_note_preset, ' +
+        'rootr_submit_signed_document, rootr_sign_document, rootr_reject_signed_document, ' +
+        'rootr_revise_signed_document, rootr_list_signed_documents, rootr_bulk_sign_documents, ' +
+        'rootr_verify_signed_document, rootr_verify_ledger. NEVER invent a signing code: always ' +
+        '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' +
         'Scaffolding discipline: ALWAYS rootr_scaffold_plan first, ask the user the 3-10 clarifying questions it ' +
         'prescribes, and only then design and create the tree — every answer must visibly shape the structure. ' +
@@ -138,6 +149,7 @@ export function buildMcpServer({ name, version }) {
   registerFormTools(server);
   registerRecordingTools(server);
   registerAttachmentTools(server);
+  registerSignedDocTools(server);
 
   return server;
 }

package/package.json

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