rootr-cli 0.8.1 → 0.10.0

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-tools/workspaces.js

@@ -14,7 +14,14 @@ import { parseRootrUrl } from '../resolve.js';
  * branch plus parseTree() keeps any client that still stringifies working.
  * Mirrors the typed-array pattern already used in logs.js.
  */
-const treeArg = (desc) => z.array(z.record(z.any())).or(z.string()).describe(desc);
+const ACCESS_HINT =
+  ' Any node may also carry `visibility: "PRIVATE"` (only its creator, workspace admins, and people listed in ' +
+  '`access` can see it and everything under it) plus `access: [{ subjectId: "<userId>", level: "READ"|"WRITE"|' +
+  '"MANAGE" }]` — that pair is how "make a folder these three people can see" happens in one call instead of ' +
+  'leaving the locking to the user afterwards. A DATABASE node may also carry `database.permissions` (칸/행 ' +
+  'lock) and `database.notifications` (who to notify on row changes).';
+
+const treeArg = (desc) => z.array(z.record(z.any())).or(z.string()).describe(desc + ACCESS_HINT);
 
 /** Accept either a real array (typed clients) or a JSON string (clients that stringify structured args). */
 function parseTree(tree) {

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.8.1",
+  "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": {