rootr-cli 0.8.1 → 0.10.0

package/bin/rootr.js

@@ -19,6 +19,7 @@ const USAGE = `Rootr CLI v${pkg.version}
   rootr write <path|id> [--file <f>] [--if-match <etag>]   문서 전체 교체(파일 없으면 생성)
   rootr append <path|id> [<text>] [--heading "## X"] [--file <f>]  문서 끝(또는 헤딩 아래)에 안전하게 추가
   rootr edit <path|id> --find <text> --replace <text> [--all]      본문 내 텍스트 치환
+  rootr comments <path|id> [--block <id>] [--json]  문서에 달린 댓글 읽기 (공개 페이지 댓글 포함)
   rootr search <query>                             워크스페이스 검색
   rootr mv <path|id> <새 경로|폴더 id>              문서/폴더 이동 및/또는 이름 변경
   rootr rm <path|id> [--yes]                       문서/폴더를 휴지통으로 이동 (복구 가능)
@@ -28,11 +29,34 @@ const USAGE = `Rootr CLI v${pkg.version}
   rootr ask <question> [--workspace <w>]           GraphRAG 질의응답 (RCA), 인용 포함 출력
   rootr db create [--file <spec.json>] [--parent <path|id>]  표(DATABASE) 생성 — 컬럼 순서 그대로, 행까지 한 번에
   rootr db rows <path|id> [--body] [--json]        표의 행 목록 (--body: 상세 내용까지)
+  rootr db lock <path|id> [--schema managers] [--rows own] [--locked "승인,점수"]  표 자물쇠 보기·걸기
+  rootr db notify <path|id> [--file rules.json] [--clear]  표 알림 규칙 보기·저장
   rootr db row-add <path|id> --values '<json>' [--body <md>|--body-file <f>]  행 추가(상세 내용 포함)
   rootr db row-body <path|id> <rowId> [--file <f>] 행의 상세 내용(본문 메모) 쓰기 — 없으면 표준입력
+  rootr access <path|id> [--json]                  공개범위·권한 보기 (관리 권한 필요)
+  rootr access <path|id> --private|--public|--inherit   공개범위 바꾸기
+  rootr access <path|id> --grant <userId> --level READ|WRITE|MANAGE   사람에게 권한 주기
+  rootr access <path|id> --revoke <userId>          준 권한 거두기
+  rootr form collect <path|id> --to db|sheet             응답 모을 곳을 새로 만들어 연결 (표는 질문 그대로 칸 생성)
+  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                                  버전 출력
 
@@ -115,6 +139,41 @@ async function cmdLs(args) {
   }
 }
 
+/**
+ * `rootr comments <path|id>` — 그 문서에 달린 댓글을 읽는다.
+ *
+ * 2026-08-23 창업자 확인 요청: "댓글 써진 거 mcp/api/cli로 읽어올 수 있는 거 맞는지."
+ * API와 MCP에는 있었고 CLI에만 없었다. 공개 페이지에 달린 댓글도 같은 곳에 쌓이므로
+ * 여기서 함께 나온다.
+ */
+async function cmdComments(args) {
+  const target = args._[0];
+  if (!target) throw new Error('사용법: rootr comments <path|id> [--block <blockId>] [--json]');
+
+  const client = makeClient();
+  const id = requireResolved(await resolveTarget(client, target));
+  const threads = await client.listComments(id, { blockId: args.block });
+
+  if (args.json) {
+    console.log(JSON.stringify(threads, null, 2));
+    return;
+  }
+  if (!threads.length) {
+    console.log('댓글이 없습니다.');
+    return;
+  }
+  for (const t of threads) {
+    const when = String(t.createdAt ?? '').slice(0, 16).replace('T', ' ');
+    console.log(`- ${t.author?.name ?? '(알 수 없음)'} · ${when}`);
+    console.log(`  ${String(t.body ?? '').replace(/\n/g, '\n  ')}`);
+    for (const r of t.replies ?? []) {
+      const rWhen = String(r.createdAt ?? '').slice(0, 16).replace('T', ' ');
+      console.log(`    ↳ ${r.author?.name ?? '(알 수 없음)'} · ${rWhen}`);
+      console.log(`      ${String(r.body ?? '').replace(/\n/g, '\n      ')}`);
+    }
+  }
+}
+
 async function cmdRead(args) {
   const target = args._[0];
   if (!target) throw new Error('사용법: rootr read <path|id> [--json]');
@@ -445,14 +504,166 @@ async function cmdMcp() {
  * 컬럼을 하나씩 붙이는 방식은 호출 순서가 곧 컬럼 순서가 되어 옮겨온 표가 뒤죽박죽이
  * 됐다 — 그래서 CLI도 "한 번에" 쪽만 제공한다.
  */
+/**
+ * `rootr access <path|id> [--private|--public|--inherit] [--grant <id> --level …] [--revoke <id>]`
+ *
+ * 화면의 "공개범위"·"권한" 창을 터미널에서. 인자 없이 부르면 지금 상태를 보여 준다.
+ * 관리 권한이 없으면 서버가 막는다(보기도 안 된다).
+ */
+async function cmdAccess(args) {
+  const target = args._[0];
+  if (!target) {
+    throw new Error(
+      '사용법: rootr access <path|id> [--private|--public|--inherit] [--grant <userId> --level READ|WRITE|MANAGE] [--revoke <userId>]',
+    );
+  }
+  const client = makeClient();
+  const id = requireResolved(await resolveTarget(client, target));
+  const group = args.group ? 'GROUP' : 'USER';
+
+  let changed = false;
+  if (args.private || args.public || args.inherit) {
+    const visibility = args.private ? 'PRIVATE' : args.public ? 'PUBLIC' : null;
+    await client.setNodeVisibility(id, visibility);
+    console.log(
+      `공개범위: ${visibility === 'PRIVATE' ? '비공개(만든 사람·관리자·따로 준 사람만)' : visibility === 'PUBLIC' ? '워크스페이스 전체' : '상위 폴더/워크스페이스 기본값을 따름'}`,
+    );
+    changed = true;
+  }
+  if (typeof args.grant === 'string') {
+    const level = String(args.level || '').toUpperCase();
+    if (!['READ', 'WRITE', 'MANAGE'].includes(level)) {
+      throw new Error('--grant 에는 --level READ|WRITE|MANAGE 를 함께 주세요.');
+    }
+    await client.grantNodePermission(id, { subjectType: group, subjectId: args.grant, level });
+    console.log(`권한 부여: ${args.grant} → ${level}`);
+    changed = true;
+  }
+  if (typeof args.revoke === 'string') {
+    await client.revokeNodePermission(id, { subjectType: group, subjectId: args.revoke });
+    console.log(`권한 회수: ${args.revoke}`);
+    changed = true;
+  }
+
+  const info = await client.getNodeAccess(id);
+  if (args.json) {
+    console.log(JSON.stringify(info, null, 2));
+    return;
+  }
+  if (!changed) {
+    const eff = info.effectiveVisibility ?? info.visibility;
+    console.log(`공개범위: ${eff === 'PRIVATE' ? '비공개' : '워크스페이스 전체'}${info.visibility === null ? ' (상속받음)' : ''}`);
+  }
+  const direct = info.direct ?? [];
+  console.log(`따로 준 권한: ${direct.length ? '' : '없음'}`);
+  for (const p of direct) console.log(`  - ${p.subjectType} ${p.subjectId} → ${p.level}`);
+}
+
+/**
+ * `rootr form responses|response-edit|response-rm`
+ *
+ * 폼에 들어온 응답을 터미널에서 보고 고치고 지운다. 화면에서만 되면
+ * 에이전트에게는 없는 기능이라 여기까지 열어 둔다.
+ */
+async function cmdForm(args) {
+  const sub = args._[0];
+  if (sub === 'collect') return cmdFormCollect(args);
+  if (sub === 'responses') return cmdFormResponses(args);
+  if (sub === 'response-edit') return cmdFormResponseEdit(args);
+  if (sub === 'response-rm') return cmdFormResponseRm(args);
+  throw new Error('사용법: rootr form collect|responses|response-edit|response-rm … (자세한 건 rootr --help)');
+}
+
+/**
+ * `rootr form collect <path|id> --to db|sheet`
+ *
+ * 응답 모을 곳을 새로 만들어 연결한다. 표로 만들면 폼 질문 그대로 칸이 생기므로,
+ * 표를 미리 만들고 칸 이름을 하나하나 맞출 필요가 없다.
+ */
+async function cmdFormCollect(args) {
+  const target = args._[1];
+  if (!target) throw new Error('사용법: rootr form collect <path|id> --to db|sheet');
+  const to = String(args.to || '').toLowerCase();
+  const map = { db: 'database', database: 'database', sheet: 'spreadsheet', spreadsheet: 'spreadsheet' };
+  if (!map[to]) throw new Error('--to 에 db 또는 sheet 를 주세요.');
+
+  const client = makeClient();
+  const id = requireResolved(await resolveTarget(client, target));
+  const made = await client.createFormCollector(id, map[to]);
+  if (args.json) {
+    console.log(JSON.stringify(made, null, 2));
+    return;
+  }
+  console.log(
+    made.kind === 'database'
+      ? `표를 만들어 연결했습니다: ${made.nodeId}  (폼 질문 그대로 칸이 생겼습니다)`
+      : `스프레드시트를 만들어 연결했습니다: ${made.nodeId}`,
+  );
+}
+
+async function cmdFormResponses(args) {
+  const target = args._[1];
+  if (!target) throw new Error('사용법: rootr form responses <path|id> [--latest] [--json]');
+  const client = makeClient();
+  const id = requireResolved(await resolveTarget(client, target));
+  const rows = await client.listFormResponses(id, { latestPerRespondent: Boolean(args.latest) });
+
+  if (args.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (!rows.length) {
+    console.log('아직 들어온 응답이 없습니다.');
+    return;
+  }
+  console.log(`응답 ${rows.length}건${args.latest ? ' (사람마다 최신 1건만)' : ''}`);
+  for (const r of rows) {
+    const who = r.submitterUserId ? r.submitterUserId : '익명';
+    console.log(`- ${r.id}  ${new Date(r.createdAt).toISOString()}  제출자:${who}`);
+    console.log(`  ${JSON.stringify(r.values)}`);
+  }
+}
+
+async function cmdFormResponseEdit(args) {
+  const responseId = args._[1];
+  if (!responseId) throw new Error("사용법: rootr form response-edit <응답id> --values '<json>'");
+  const raw = typeof args.values === 'string' ? args.values : await readStdin();
+  let values;
+  try {
+    values = JSON.parse(raw);
+  } catch {
+    throw new Error('--values 를 JSON으로 읽을 수 없습니다. {"필드id":"값"} 형태여야 합니다.');
+  }
+  // 통째로 바뀐다 — 남기고 싶은 답도 같이 보내야 한다.
+  const result = await makeClient().updateFormResponse(responseId, values);
+  if (args.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`응답 수정됨: ${result.id ?? responseId}`);
+  console.log(`  ${JSON.stringify(result.values ?? values)}`);
+}
+
+async function cmdFormResponseRm(args) {
+  const responseId = args._[1];
+  if (!responseId) throw new Error('사용법: rootr form response-rm <응답id> [--yes]');
+  if (!args.yes) {
+    throw new Error('응답 삭제는 되돌릴 수 없습니다. 정말 지우려면 --yes 를 붙이세요.');
+  }
+  await makeClient().deleteFormResponse(responseId);
+  console.log(`응답 삭제됨: ${responseId}`);
+}
+
 async function cmdDb(args) {
   const sub = args._[0];
   if (sub === 'rows') return cmdDbRows(args);
   if (sub === 'row-add') return cmdDbRowAdd(args);
   if (sub === 'row-body') return cmdDbRowBody(args);
+  if (sub === 'lock') return cmdDbLock(args);
+  if (sub === 'notify') return cmdDbNotify(args);
   if (sub !== 'create') {
     throw new Error(
-      '사용법: rootr db create|rows|row-add|row-body … (자세한 건 rootr --help)',
+      '사용법: rootr db create|rows|row-add|row-body|lock|notify … (자세한 건 rootr --help)',
     );
   }
   const raw = typeof args.file === 'string' ? readFileSync(args.file, 'utf8') : await readStdin();
@@ -482,6 +693,90 @@ async function cmdDb(args) {
 }
 
 /** 표의 행 목록. --body 를 주면 행마다 상세 내용(본문 메모)까지 가져온다. */
+/**
+ * `rootr db lock <path|id> [--schema managers|open] [--rows own|all] [--locked <칸,칸>]`
+ *
+ * 표에 거는 자물쇠 — 노션에 없는 것이다. 인자 없이 부르면 지금 상태를 보여 준다.
+ */
+async function cmdDbLock(args) {
+  const target = args._[1];
+  if (!target) throw new Error('사용법: rootr db lock <path|id> [--schema managers|open] [--rows own|all] [--locked "승인,점수"]');
+
+  const client = makeClient();
+  const id = requireResolved(await resolveTarget(client, target));
+
+  const patch = {};
+  if (args.schema !== undefined) patch.schemaLock = args.schema;
+  if (args.rows !== undefined) patch.rowScope = args.rows;
+  if (args.locked !== undefined) {
+    patch.lockedProps = String(args.locked)
+      .split(',')
+      .map((x) => x.trim())
+      .filter(Boolean);
+  }
+
+  const result = Object.keys(patch).length
+    ? await client.setDatabasePermissions(id, patch)
+    : await client.getDatabasePermissions(id);
+
+  if (args.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`칸·뷰 잠금: ${result.schemaLock === 'managers' ? '관리자만' : '누구나'}`);
+  console.log(`행 보기   : ${result.rowScope === 'own' ? '본인이 만든 행만' : '전부'}`);
+  console.log(`잠긴 칸   : ${(result.lockedProps ?? []).length ? result.lockedProps.join(', ') : '없음'}`);
+}
+
+/**
+ * `rootr db notify <path|id> [--file rules.json]`
+ *
+ * 표에 무슨 일이 생기면 누구에게 알릴지. 파일 없이 부르면 지금 규칙을 보여 준다.
+ * 규칙 모양: [{ "userIds": ["…"], "events": ["created"], "filter": {"propId":"p1","op":"is","value":"긴급"} }]
+ */
+async function cmdDbNotify(args) {
+  const target = args._[1];
+  if (!target) throw new Error('사용법: rootr db notify <path|id> [--file rules.json] [--clear] [--json]');
+
+  const client = makeClient();
+  const id = requireResolved(await resolveTarget(client, target));
+
+  if (args.clear) {
+    const cleared = await client.setDatabaseNotifications(id, []);
+    console.log('알림 규칙을 모두 지웠습니다.');
+    if (args.json) console.log(JSON.stringify(cleared, null, 2));
+    return;
+  }
+  if (args.file) {
+    const raw = readFileSync(args.file, 'utf8');
+    const saved = await client.setDatabaseNotifications(id, JSON.parse(raw));
+    console.log(`알림 규칙 ${saved.watchers.length}개를 저장했습니다.`);
+    if (args.json) console.log(JSON.stringify(saved, null, 2));
+    return;
+  }
+
+  const { watchers } = await client.getDatabaseNotifications(id);
+  if (args.json) {
+    console.log(JSON.stringify(watchers, null, 2));
+    return;
+  }
+  if (!watchers.length) {
+    console.log('알림 규칙이 없습니다.');
+    return;
+  }
+  const WHEN = { created: '행 추가', updated: '행 수정', deleted: '행 삭제' };
+  for (const w of watchers) {
+    const when = (w.events ?? []).map((e) => WHEN[e] ?? e).join(' · ');
+    const f = w.filter;
+    const only = f
+      ? f.op === 'changed'
+        ? ` (${f.propId} 칸이 바뀌었을 때만)`
+        : ` (${f.propId} ${f.op === 'is' ? '=' : '⊃'} ${f.value})`
+      : '';
+    console.log(`- ${when}${only} → ${(w.userIds ?? []).length}명`);
+  }
+}
+
 async function cmdDbRows(args) {
   const target = args._[1];
   if (!target) throw new Error('사용법: rootr db rows <path|id> [--body] [--json]');
@@ -558,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);
@@ -575,6 +1097,8 @@ async function main() {
   switch (cmd) {
     case 'ls':
       return cmdLs(args);
+    case 'comments':
+      return cmdComments(args);
     case 'read':
       return cmdRead(args);
     case 'write':
@@ -601,6 +1125,12 @@ async function main() {
       return cmdUse(args);
     case 'db':
       return cmdDb(args);
+    case 'form':
+      return cmdForm(args);
+    case 'access':
+      return cmdAccess(args);
+    case 'sign':
+      return cmdSign(args);
     case 'mcp':
       return cmdMcp(args);
     default: