rootr-cli 0.9.0 → 0.13.0

package/bin/rootr.js

@@ -33,17 +33,56 @@ const USAGE = `Rootr CLI v${pkg.version}
   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 db rows-new <path|id> --json '[{…},…]' | --file <파일>   여러 행 한 번에 넣기 (하나라도 틀리면 전부 취소)
+  rootr db rows-set <path|id> --ids <id,id> --values '<json>'  고른 행 전부에 같은 값 (날짜 일괄 변경 등)
+  rootr db rows-each <path|id> --json '[{"rowId":…,"values":{…}},…]'  행마다 다른 값으로 한 번에 수정
+  rootr db rows-rm <path|id> --ids <id,id> [--yes]  고른 행 한 번에 삭제 — 하나라도 막히면 통째로 거절
+  rootr db row-page <rowId> [--type RECORDING]     이 행만 원하는 타입으로 상세 붙이기(녹음·스프레드시트·서명문서…)
+  rootr db row-page <rowId> --node <path|id>       이미 있는 문서를 이 행에 잇기 (옮기지 않고 가리킴)
+  rootr db row-page <rowId> --unlink               연결만 끊기 — 문서는 그대로 남음
+  rootr db row-page-type <path|id> <TYPE>          새 행의 기본 타입 — 이미 만든 행은 그대로
+  rootr publish <path|id> [--children] [--view <id>]  공개 발행 — 표·시트·화이트보드·폼 등 전 타입
+  rootr publish <path|id> --off                    공개 닫기 (딸려 나간 하위도 같이 닫힘)
+  rootr publish <path|id> --status                 지금 공개인지·주소·하위 포함 여부
+  rootr publish <표> --layout board --skin paper   공개한 표를 무슨 꼴로 보일지 (배치 9종 × 분위기 6종)
+  rootr readreq <path|id> [--json]                 읽음 확인 현황 — 누가 읽었나·완료율
+  rootr readreq <path|id> --users <id,id> [--due <ISO>] [--ack]  읽어야 할 사람 지정(명단 통째로 교체)
+  rootr readreq <path|id> --clear                  읽음 확인 해제
   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 new <경로> --fields '<json>' [--collect db|sheet]  폼 만들기 (질문 18종: text·email·phone·url·rating·scale·time·file·matrix·ranking·csat·nps…)
+  rootr form show <path|id> [--json]               질문·설정 보기 (고치기 전에 먼저)
+  rootr form set <path|id> --fields '<json>' | --config '<json>'  질문·설정 고치기 (설정은 준 칸만 바뀜)
   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>     결재라인 다시 짜기 (올리기 전에만)
+                                                   결재자는 {"userId"} 또는 {"email","displayName"} — 메일이면 계정 없이 서명
+  rootr sign code <path|id> | --bulk               확인 코드를 내 메일로 보내기 (서명 전 필수)
+  rootr sign submit <path|id> [--code <6자리>]      올리기 — 본문이 언다. 내가 1단계 서명자면 --code 필요
+  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 feedback "<무엇이 안 되는지>" [--kind bug|friction|idea|praise] [--email <주소>]
+                                                   제보 보내기 — 오류·불편·제안. 로그인·키 없어도 되고 한도에 안 걸립니다
+  rootr scaffold plan "<무엇을 위한 워크스페이스인지>"   짓기 1단계 — 물어볼 것·설계 규칙 받기
+  rootr scaffold review --file tree.json [--json]  짓기 2단계 — 만들기 전에 검사받기(점수·고칠 곳)
+  rootr scaffold apply --file tree.json [--root /경로]  짓기 3단계 — 실제로 만들기(검사 결과도 같이 나옴)
+  rootr scaffold built [--root /경로] [--json]      짓고 나서 — 실제로 만들어진 것의 **모양**을 검사
+  rootr scaffold test [--root /경로] [--json]       짓고 나서 — 실제로 **돌려 본다**(관계·롤업·수식·폼·시트). 실패 시 exit 1
+  rootr mcp                                        MCP stdio 서버 구동 (도구 151종 — README 참고)
   rootr --help                                     도움말
   rootr --version                                  버전 출력
 
@@ -440,6 +479,53 @@ async function cmdAsk(args) {
   }
 }
 
+/**
+ * FEEDBACK — "이게 안 돼요"를 보내는 명령. 일부러 워크스페이스도 API 키도 요구하지
+ * 않는다: 키 설정이 안 돼서 아무것도 못 하는 사람의 제보가 우리가 제일 받고 싶은
+ * 제보다. 요금·한도에도 걸리지 않는다.
+ */
+async function cmdFeedback(args) {
+  const KIND_MAP = { bug: 'BUG', friction: 'FRICTION', idea: 'IDEA', praise: 'PRAISE', other: 'OTHER' };
+  let body = args._.join(' ').trim();
+  if (args.file) body = readFileSync(args.file, 'utf8').trim();
+  if (!body) body = (await readStdin()).trim();
+  if (!body) {
+    throw new Error(
+      '사용법: rootr feedback "무엇을 하려다 무엇이 일어났는지" [--kind bug|friction|idea|praise]\n' +
+        '       rootr feedback --file report.md   /   cat log | rootr feedback --kind bug',
+    );
+  }
+
+  let kind;
+  if (args.kind) {
+    kind = KIND_MAP[String(args.kind).toLowerCase()];
+    if (!kind) {
+      throw new Error(`--kind 는 ${Object.keys(KIND_MAP).join('|')} 중 하나입니다.`);
+    }
+  }
+
+  const cfg = loadConfig();
+  const workspace = args.workspace || cfg.workspace;
+  const client = new RootrClient({ ...cfg, workspace, apiKey: keyForWorkspace(cfg, workspace) });
+  const result = await client.sendFeedback({
+    body,
+    title: args.title,
+    kind,
+    contactEmail: args.email,
+    reporter: args.from,
+    workspaceId: workspace || undefined,
+    client: 'cli',
+  });
+  if (result.deduped) {
+    console.log(`이미 같은 제보가 접수돼 있어 합쳤습니다. (id: ${result.id})`);
+    return;
+  }
+  console.log(`제보를 보냈습니다. 고맙습니다. (id: ${result.id})`);
+  if (!args.email) {
+    console.log('답을 받고 싶으면 --email <주소>를 함께 주세요.');
+  }
+}
+
 async function cmdConfig(args) {
   // Registering an extra credential is its own action — several keys can live
   // side by side, each bound to the workspace it can reach, so `rootr mcp` (and
@@ -554,11 +640,140 @@ async function cmdAccess(args) {
  */
 async function cmdForm(args) {
   const sub = args._[0];
+  if (sub === 'new') return cmdFormNew(args);
+  if (sub === 'show') return cmdFormShow(args);
+  if (sub === 'set') return cmdFormSet(args);
   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)');
+  throw new Error(
+    '사용법: rootr form new|show|set|collect|responses|response-edit|response-rm … (자세한 건 rootr --help)',
+  );
+}
+
+/**
+ * FORM-TALLY — `rootr form new <경로> --fields '<json>'`
+ *
+ * 폼을 만들 수 있는 곳이 API·MCP뿐이고 CLI만 빠져 있었다(창업자 지적 2026-08-28:
+ * "MCP api cli scaffold도 다 구현했어?"). 질문 종류는 백엔드와 **같은 목록**을 쓴다 —
+ * 한쪽만 늘리면 만들 수 있는 것과 받아 주는 것이 어긋난다.
+ */
+const FORM_FIELD_TYPES = [
+  'text', 'textarea', 'number', 'select', 'multi_select', 'checkbox', 'date',
+  'email', 'phone', 'url', 'rating', 'scale', 'time', 'file',
+  'matrix', 'ranking', 'csat', 'nps',
+];
+
+function parseFieldsArg(args) {
+  if (typeof args.fields !== 'string') return undefined;
+  let parsed;
+  try {
+    parsed = JSON.parse(args.fields);
+  } catch {
+    throw new Error('--fields 는 JSON 배열이어야 합니다. 예: [{"name":"이메일","type":"email","required":true}]');
+  }
+  if (!Array.isArray(parsed)) throw new Error('--fields 는 배열이어야 합니다.');
+  for (const [i, f] of parsed.entries()) {
+    if (!f || typeof f.name !== 'string') throw new Error(`fields[${i}].name 이 필요합니다.`);
+    if (!FORM_FIELD_TYPES.includes(f.type)) {
+      throw new Error(`fields[${i}].type 은 다음 중 하나여야 합니다: ${FORM_FIELD_TYPES.join(', ')}`);
+    }
+  }
+  return parsed;
+}
+
+function parseConfigArg(args) {
+  if (typeof args.config !== 'string') return undefined;
+  try {
+    return JSON.parse(args.config);
+  } catch {
+    throw new Error('--config 는 JSON 객체여야 합니다.');
+  }
+}
+
+async function cmdFormNew(args) {
+  const target = args._[1];
+  if (!target) {
+    throw new Error("사용법: rootr form new <경로> --fields '<json>' [--config '<json>'] [--collect db|sheet]");
+  }
+  const client = makeClient();
+  const created = await client.createForm(client.workspace, {
+    path: target,
+    createParents: true,
+    fields: parseFieldsArg(args) ?? [],
+    config: parseConfigArg(args),
+  });
+  const id = created.id ?? created.nodeId;
+  console.log(`폼을 만들었습니다: ${target}`);
+  console.log(`  id: ${id}`);
+  if (args.collect === 'db' || args.collect === 'sheet') {
+    const to = args.collect === 'db' ? 'database' : 'spreadsheet';
+    await client.request(`/forms/${encodeURIComponent(id)}/collect`, { method: 'POST', body: { to } });
+    console.log(`  응답 모을 곳: ${args.collect === 'db' ? '표' : '스프레드시트'} 생성됨`);
+  }
+}
+
+/** `rootr form show <path|id>` — 질문·설정을 그대로 본다(고치기 전에 읽으라고 있는 것). */
+async function cmdFormShow(args) {
+  const target = args._[1];
+  if (!target) throw new Error('사용법: rootr form show <path|id> [--json]');
+  const client = makeClient();
+  // 경로도 id도 받는다(이 저장소의 다른 명령과 같은 규칙).
+  const id = await resolveDatabaseId(client, target);
+  const form = await client.getForm(id);
+  if (args.json) {
+    console.log(JSON.stringify(form, null, 2));
+    return;
+  }
+  console.log(`${form.name}  (응답 ${form.responseCount ?? 0}건, 방문 ${form.viewCount ?? 0}회)`);
+  for (const [i, f] of (form.fields ?? []).entries()) {
+    const marks = [
+      f.required ? '필수' : null,
+      f.hidden ? '숨김' : null,
+      f.page && f.page > 1 ? `${f.page}쪽` : null,
+      f.showIf ? '조건부' : null,
+    ].filter(Boolean);
+    console.log(`  ${i + 1}. ${f.name} [${f.type}]${marks.length ? ' · ' + marks.join('·') : ''}`);
+    if (f.help) console.log(`     ${f.help}`);
+  }
+  const cfg = form.config ?? {};
+  const bits = [];
+  if (cfg.publicSubmit && cfg.publicSubmit !== 'off') bits.push(`공개 제출: ${cfg.publicSubmit}`);
+  if (cfg.closesAt) bits.push(`마감: ${cfg.closesAt}`);
+  if (cfg.maxResponses) bits.push(`정원: ${cfg.maxResponses}`);
+  if (Array.isArray(cfg.notifyEmails) && cfg.notifyEmails.length) bits.push(`알림: ${cfg.notifyEmails.join(', ')}`);
+  if (cfg.webhookUrl) bits.push('웹훅 있음');
+  if (cfg.theme) bits.push(`분위기: ${cfg.theme}`);
+  // 켜 놓고 잊기 쉬운 것들 — 안 보이면 "왜 두 번 못 내지?" 하고 한참 찾는다.
+  if (cfg.oncePerPerson) bits.push('한 사람 한 번만');
+  if (cfg.confirmEmailField) bits.push('확인 메일 보냄');
+  if (cfg.intro) bits.push('안내문 있음');
+  if (cfg.thankYou) bits.push('인사말 있음');
+  if (cfg.redirectUrl) bits.push(`낸 뒤 이동: ${cfg.redirectUrl}`);
+  if (bits.length) console.log(`  설정 — ${bits.join(' · ')}`);
+}
+
+/**
+ * `rootr form set <path|id> --fields '<json>' | --config '<json>'`
+ *
+ * 설정은 **준 칸만** 바꾼다. 통째로 덮으면 응답 표 연결이나 공개 제출 방식 같은
+ * 남의 칸이 지워진다.
+ */
+async function cmdFormSet(args) {
+  const target = args._[1];
+  const fields = parseFieldsArg(args);
+  const config = parseConfigArg(args);
+  if (!target || (fields === undefined && config === undefined)) {
+    throw new Error("사용법: rootr form set <path|id> --fields '<json>' | --config '<json>'");
+  }
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  // 설정은 **보낸 것만** 바뀐다(서버가 합쳐 준다) — 지우려면 그 항목에 null.
+  await client.updateForm(id, { ...(fields ? { fields } : {}), ...(config ? { config } : {}) });
+  console.log('폼을 고쳤습니다.');
+  if (fields) console.log(`  질문 ${fields.length}개`);
+  if (config) console.log(`  바꾼 설정: ${Object.keys(config).join(', ')}`);
 }
 
 /**
@@ -641,16 +856,336 @@ async function cmdFormResponseRm(args) {
   console.log(`응답 삭제됨: ${responseId}`);
 }
 
+/**
+ * DB-BULK — `rootr db rows-set <표> --ids a,b --values '{"작성일":{"start":"2026-08-01"}}'`
+ *
+ * 고른 행 전부에 같은 값을 덮어쓴다. 에이랩스 요청(2026-08-27)의 "한 번에 날짜
+ * 변경"이 이것이다. 칸은 **이름으로** 적어도 된다.
+ */
+async function cmdDbRowsSet(args) {
+  const target = args._[1];
+  const ids = typeof args.ids === 'string' ? args.ids.split(',').map((i) => i.trim()).filter(Boolean) : [];
+  if (!target || !ids.length || typeof args.values !== 'string') {
+    throw new Error("사용법: rootr db rows-set <path|id> --ids <id,id> --values '<json>'");
+  }
+  let values;
+  try {
+    values = JSON.parse(args.values);
+  } catch {
+    throw new Error('--values 를 JSON으로 읽을 수 없습니다. 예: \'{"작성일":{"start":"2026-08-01"}}\'');
+  }
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  // 칸 이름으로 적어도 되게 — 화면에서 보는 이름 그대로 쓰는 것이 자연스럽다.
+  const database = await client.getDatabase(id);
+  const byName = new Map((database.properties || []).map((p) => [p.name, p.id]));
+  const resolved = Object.fromEntries(
+    Object.entries(values).map(([k, v]) => [byName.get(k) ?? k, v]),
+  );
+  const res = await client.bulkUpdateRows(id, ids, resolved);
+  console.log(`${res.updated}개 행을 바꿨습니다.`);
+}
+
+/**
+ * DB-BULK — `rootr db rows-new <표> --json '[{"이름":"홍길동"},…]'` (또는 `--file rows.json`)
+ *
+ * 여러 행을 **한 번에** 넣는다. 하나라도 형식이 틀리면 아무것도 안 들어간다 —
+ * 반쯤 채워진 표가 남는 게 제일 나쁘다. 칸은 이름으로 적어도 된다.
+ */
+async function cmdDbRowsNew(args) {
+  const target = args._[1];
+  const raw = readJsonArg(args, 'rows-new');
+  if (!target) throw new Error("사용법: rootr db rows-new <path|id> --json '<[{…},…]>' | --file <파일>");
+  const rows = Array.isArray(raw) ? raw : [raw];
+  if (!rows.length) throw new Error('넣을 행이 없습니다.');
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  const res = await client.bulkCreateRows(id, rows);
+  console.log(`${res.created}개 행을 넣었습니다.`);
+}
+
+/**
+ * DB-BULK — `rootr db rows-each <표> --json '[{"rowId":"…","values":{…}},…]'`
+ *
+ * rows-set은 고른 행 **전부에 같은 값**을 넣는다. 이건 **행마다 다른 값**이다.
+ */
+async function cmdDbRowsEach(args) {
+  const target = args._[1];
+  const raw = readJsonArg(args, 'rows-each');
+  if (!target) throw new Error("사용법: rootr db rows-each <path|id> --json '<[{rowId,values},…]>' | --file <파일>");
+  const updates = Array.isArray(raw) ? raw : [raw];
+  for (const u of updates) {
+    if (!u || typeof u.rowId !== 'string' || typeof u.values !== 'object' || !u.values) {
+      throw new Error('각 항목은 { "rowId": "…", "values": { … } } 형태여야 합니다.');
+    }
+  }
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  const res = await client.bulkUpdateRowsEach(id, updates);
+  console.log(`${res.updated}개 행을 바꿨습니다.`);
+}
+
+/** `--json '<...>'` 또는 `--file <파일>` 중 하나를 읽는다. 행이 많으면 파일이 편하다. */
+/**
+ * SCAFFOLD-CLI — 워크스페이스 짓기의 세 단계를 사람도 스크립트도 쓸 수 있게.
+ * 예전에는 MCP 도구로만 있었다: `curl` 로 REST를 직접 두드리거나 MCP를 붙이지
+ * 않으면 스캐폴딩에 손댈 수가 없었다.
+ *
+ *   rootr scaffold plan "동네 빵집 운영 관리"
+ *   rootr scaffold review --file tree.json
+ *   rootr scaffold apply  --file tree.json [--root /경영관리]
+ */
+async function cmdScaffold(args) {
+  const sub = args._[0];
+  const client = makeClient();
+  if (sub === 'plan') {
+    const intent = args._.slice(1).join(' ').trim();
+    if (!intent) throw new Error('사용법: rootr scaffold plan "무엇을 위한 워크스페이스인지"');
+    console.log(JSON.stringify(await client.scaffoldPlan(intent), null, 2));
+    return;
+  }
+  if (sub === 'review') {
+    const tree = readJsonArg(args, 'scaffold review');
+    const r = await client.scaffoldReview(Array.isArray(tree) ? tree : tree.tree);
+    if (args.json) {
+      console.log(JSON.stringify(r, null, 2));
+      return;
+    }
+    console.log(r.summary);
+    for (const f of r.findings) {
+      const mark = f.level === 'error' ? '고쳐야 함' : f.level === 'warn' ? '약함' : '더 나아짐';
+      console.log(`  [${mark}] ${f.at}  ${f.message}`);
+    }
+    return;
+  }
+  if (sub === 'built') {
+    const ws = args.workspace || loadConfig().workspace;
+    if (!ws) throw new Error('워크스페이스가 없습니다: --workspace <id>');
+    const r = await client.scaffoldReviewBuilt(ws, typeof args.root === 'string' ? args.root : undefined);
+    if (args.json) {
+      console.log(JSON.stringify(r, null, 2));
+      return;
+    }
+    console.log(r.summary);
+    for (const f of r.findings) {
+      const mark = f.level === 'error' ? '고쳐야 함' : f.level === 'warn' ? '약함' : '더 나아짐';
+      console.log(`  [${mark}] ${f.at}  ${f.message}`);
+    }
+    return;
+  }
+  if (sub === 'test') {
+    const ws = args.workspace || loadConfig().workspace;
+    if (!ws) throw new Error('워크스페이스가 없습니다: --workspace <id>');
+    const r = await client.scaffoldSelfTest(ws, typeof args.root === 'string' ? args.root : undefined);
+    if (args.json) {
+      console.log(JSON.stringify(r, null, 2));
+      return;
+    }
+    console.log(r.summary);
+    for (const c of r.checks) {
+      console.log(`  [${c.level === 'fail' ? '실패' : '경고'}] ${c.at}  (${c.check}) ${c.message}`);
+    }
+    if (r.failed) process.exitCode = 1;
+    return;
+  }
+  if (sub === 'apply') {
+    const tree = readJsonArg(args, 'scaffold apply');
+    const ws = args.workspace || loadConfig().workspace;
+    if (!ws) throw new Error('워크스페이스가 없습니다: --workspace <id> 또는 rootr config --workspace <id>');
+    const r = await client.scaffoldApply(ws, {
+      rootPath: typeof args.root === 'string' ? args.root : undefined,
+      tree: Array.isArray(tree) ? tree : tree.tree,
+    });
+    console.log(`${r.created.length}개를 ${r.rootPath || '/'} 아래에 만들었습니다.`);
+    if (r.review) console.log(`검사: ${r.review.summary}`);
+    return;
+  }
+  throw new Error('사용법: rootr scaffold plan|review|apply  (review/apply 는 --file tree.json)');
+}
+
+function readJsonArg(args, cmd) {
+  let text = null;
+  if (typeof args.file === 'string') text = readFileSync(args.file, 'utf8');
+  else if (typeof args.json === 'string') text = args.json;
+  if (text == null) throw new Error(`${cmd}: --json 또는 --file 이 필요합니다.`);
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`${cmd}: JSON으로 읽을 수 없습니다.`);
+  }
+}
+
+/** DB-BULK — `rootr db rows-rm <표> --ids a,b --yes` */
+async function cmdDbRowsRm(args) {
+  const target = args._[1];
+  const ids = typeof args.ids === 'string' ? args.ids.split(',').map((i) => i.trim()).filter(Boolean) : [];
+  if (!target || !ids.length) {
+    throw new Error('사용법: rootr db rows-rm <path|id> --ids <id,id> [--yes]');
+  }
+  if (!args.yes) {
+    throw new Error(`${ids.length}개 행을 지웁니다. 되돌릴 수 없으니 정말 지우려면 --yes 를 붙이세요.`);
+  }
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  const res = await client.bulkDeleteRows(id, ids);
+  console.log(`${res.deleted}개 행을 지웠습니다.`);
+}
+
+/**
+ * PUBLIC-ANY — `rootr publish <노드> [--children|--off|--status]`
+ *
+ * 문서·덱만 되던 공개 발행을 전 타입으로 연 것(창업자 지시 2026-08-27).
+ * `--children`을 주면 **그 아래 전부**(손자·증손자 포함)가 각자 주소를 받는다.
+ */
+/** PUBLIC-DB-DESIGN — 서버가 받는 값과 **같은 목록**이어야 한다. */
+const DB_LAYOUTS = ['table', 'cards', 'gallery', 'list', 'board', 'timeline', 'calendar', 'chart', 'ranking'];
+const DB_SKINS = ['clean', 'paper', 'dark', 'vivid', 'bento', 'brutal'];
+
+async function cmdPublish(args) {
+  const target = args._[0];
+  if (!target) {
+    throw new Error(
+      '사용법: rootr publish <path|id> [--children] [--view <id>] [--layout <배치>] [--skin <분위기>] | --off | --status',
+    );
+  }
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+
+  if (args.status) {
+    const st = await client.nodePublicStatus(id);
+    if (!st.publishable) {
+      console.log('이 종류는 공개할 수 없습니다(폴더).');
+      return;
+    }
+    if (!st.isPublic) {
+      console.log(st.slug ? `닫혀 있습니다(주소는 남아 있음: /p/${st.slug})` : '아직 공개한 적이 없습니다.');
+      return;
+    }
+    console.log(`공개 중: /p/${st.slug}`);
+    if (st.expiresAt) console.log(`  만료: ${st.expiresAt}`);
+    if (st.hasPassword) console.log('  비밀번호 걸려 있음');
+    console.log(`  하위 문서도 공개: ${st.includeChildren ? '예' : '아니오'}`);
+    console.log(`  복제 허용: ${st.allowClone === false ? '아니오' : '예'}`);
+    if (st.design && (st.design.layout || st.design.skin)) {
+      console.log(`  보이는 방식: ${st.design.layout ?? 'table'} / ${st.design.skin ?? 'clean'}`);
+    }
+    return;
+  }
+
+  if (args.off) {
+    await client.setNodePublic(id, { isPublic: false });
+    console.log('공개를 닫았습니다. 딸려 나갔던 하위 문서도 같이 닫혔습니다(주소는 남아 있습니다).');
+    return;
+  }
+
+  // PUBLIC-DB-DESIGN — 표는 표 모양으로만 보일 이유가 없다. 준 것만 바뀐다.
+  const design = {
+    ...(typeof args.layout === 'string' ? { layout: args.layout } : {}),
+    ...(typeof args.skin === 'string' ? { skin: args.skin } : {}),
+  };
+  if (design.layout && !DB_LAYOUTS.includes(design.layout)) {
+    throw new Error(`--layout 은 다음 중 하나여야 합니다: ${DB_LAYOUTS.join(', ')}`);
+  }
+  if (design.skin && !DB_SKINS.includes(design.skin)) {
+    throw new Error(`--skin 은 다음 중 하나여야 합니다: ${DB_SKINS.join(', ')}`);
+  }
+  const res = await client.publishNode(id, {
+    ...(args.children ? { includeChildren: true } : {}),
+    ...(typeof args.view === 'string' ? { view: args.view } : {}),
+    ...(Object.keys(design).length ? { design } : {}),
+  });
+  console.log(`공개했습니다: /p/${res.slug}`);
+  if (args.children) console.log('  이 문서 아래 전부(손자·증손자 포함)도 각자 주소로 공개됩니다.');
+  if (Object.keys(design).length) {
+    console.log(`  보이는 방식: ${res.design?.layout ?? 'table'} / ${res.design?.skin ?? 'clean'}`);
+  }
+}
+
+/**
+ * READ-ACK — 읽고 확인해야 하는 문서.
+ *
+ * 표·폴더에 걸면 그 안의 문서 전부에 걸린다(완료율은 사람마다 굴러 올라온다).
+ * 읽음 기록은 사람의 것이라, 사람이 붙지 않은 열쇠로는 걸 수 없다.
+ */
+async function cmdReadReq(args) {
+  const target = args._[0];
+  if (!target) {
+    throw new Error(
+      '사용법: rootr readreq <path|id> [--json] | --users <id,id> [--due <ISO>] [--ack] | --clear',
+    );
+  }
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+
+  if (args.clear) {
+    await client.clearReadRequirement(id);
+    console.log('읽음 확인 해제됨');
+    return;
+  }
+
+  if (typeof args.users === 'string') {
+    const userIds = args.users.split(',').map((u) => u.trim()).filter(Boolean);
+    if (!userIds.length) throw new Error('--users 에 사람 id를 쉼표로 주세요.');
+    const res = await client.setReadRequirement(id, {
+      userIds,
+      dueAt: typeof args.due === 'string' ? args.due : null,
+      requireExplicitAck: Boolean(args.ack),
+    });
+    console.log(`읽어야 할 사람 ${userIds.length}명 지정됨${args.ack ? ' (확인 버튼까지 눌러야 함)' : ''}`);
+    if (args.json) console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+
+  const res = await client.readRequirement(id);
+  if (args.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  if (!res.requirement) {
+    console.log(
+      res.ancestorRequirementId
+        ? `이 문서 자체에는 없고, 위쪽(${res.ancestorRequirementId})에 걸려 있습니다.`
+        : '읽음 확인이 걸려 있지 않습니다.',
+    );
+    return;
+  }
+  const r = res.requirement;
+  console.log(
+    `${r.done}/${r.total}명 완료` +
+      ` · 마감: ${r.dueAt ?? '없음'}${r.overdue ? ' (지남)' : ''}` +
+      `${r.requireExplicitAck ? ' · 확인 버튼 필요' : ''}`,
+  );
+  for (const target of r.targets ?? []) {
+    const mark = target.ackedAt ? '확인' : target.firstViewedAt ? '읽음' : '아직';
+    // 표·폴더에 걸었으면 "안의 문서를 몇 개 읽었나"가 진짜 진도다.
+    const progress =
+      r.childTotal > 0 ? ` ${target.readCount ?? 0}/${r.childTotal}` : '';
+    console.log(`  ${mark}${progress}  ${target.name || target.email}`);
+  }
+}
+
+/** ROW-PAGE-PICK — 행에 붙일 수 있는 것(표·폴더는 뺀다). */
+const ROW_PAGE_TYPES = [
+  'DOCUMENT', 'SIGNED', 'SPREADSHEET', 'WHITEBOARD', 'PRESENTATION',
+  'RECORDING', 'FORM', 'ISSUE_TRACKER',
+];
+
 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 === 'rows-new') return cmdDbRowsNew(args);
+  if (sub === 'rows-each') return cmdDbRowsEach(args);
+  if (sub === 'rows-set') return cmdDbRowsSet(args);
+  if (sub === 'rows-rm') return cmdDbRowsRm(args);
+  if (sub === 'row-page') return cmdDbRowPage(args);
+  if (sub === 'row-page-type') return cmdDbRowPageType(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|lock|notify … (자세한 건 rootr --help)',
+      '사용법: rootr db create|rows|row-add|rows-new|row-body|rows-set|rows-each|rows-rm|row-page|row-page-type|lock|notify … (자세한 건 rootr --help)',
     );
   }
   const raw = typeof args.file === 'string' ? readFileSync(args.file, 'utf8') : await readStdin();
@@ -830,6 +1365,64 @@ async function cmdDbRowBody(args) {
   console.log(`상세 내용 저장: 행 ${rowId}${row.pageNodeId ? ` → 문서 ${row.pageNodeId}` : ''}`);
 }
 
+/**
+ * ROW-PAGE-PICK — `rootr db row-page <rowId> [--type RECORDING]`
+ *
+ * 행 하나에 상세를 붙인다. `--type`을 주면 **이 행만** 그 타입으로 태어난다
+ * (표의 기본값과 달라도 된다). 이미 붙어 있으면 그대로 알려 준다.
+ */
+async function cmdDbRowPage(args) {
+  const rowId = args._[1];
+  if (!rowId) {
+    throw new Error(
+      '사용법: rootr db row-page <rowId> [--type RECORDING | --node <path|id> | --unlink]',
+    );
+  }
+  const client = makeClient();
+
+  // ROW-PAGE-LINK — 연결만 끊는다. 문서는 그대로 남는다.
+  if (args.unlink) {
+    const res = await client.unlinkRowPage(rowId);
+    console.log(res.unlinked ? `연결을 끊었습니다(문서 ${res.unlinked}는 그대로 있습니다).` : '붙어 있는 문서가 없습니다.');
+    return;
+  }
+
+  // ROW-PAGE-LINK — 이미 있는 문서를 잇는다. 경로로 줘도 된다.
+  if (typeof args.node === 'string') {
+    if (typeof args.type === 'string') {
+      throw new Error('--type 과 --node 는 같이 못 씁니다. 새로 만들려면 --type, 있는 문서를 이으려면 --node 하나만 주세요.');
+    }
+    const resolved = await resolveTarget(client, args.node);
+    if (!resolved.existed) throw new Error(`이을 문서를 찾을 수 없습니다: ${args.node}`);
+    const linked = await client.linkRowPage(rowId, resolved.id);
+    console.log(`행 ${rowId}에 이었습니다: ${linked.type ?? ''} ${linked.nodeId}`.trim());
+    return;
+  }
+
+  const type = typeof args.type === 'string' ? args.type.toUpperCase() : undefined;
+  if (type && !ROW_PAGE_TYPES.includes(type)) {
+    throw new Error(`--type 은 ${ROW_PAGE_TYPES.join(' · ')} 중 하나여야 합니다.`);
+  }
+  const page = await client.createRowPage(rowId, type);
+  console.log(`행 ${rowId} 상세: ${page.type ?? ''} ${page.nodeId}`.trim());
+}
+
+/** `rootr db row-page-type <path|id> <TYPE>` — 새 행의 기본값을 바꾼다. */
+async function cmdDbRowPageType(args) {
+  const target = args._[1];
+  const type = typeof args._[2] === 'string' ? String(args._[2]).toUpperCase() : undefined;
+  if (!target || !type) {
+    throw new Error(`사용법: rootr db row-page-type <path|id> <${ROW_PAGE_TYPES.join('|')}>`);
+  }
+  if (!ROW_PAGE_TYPES.includes(type)) {
+    throw new Error(`타입은 ${ROW_PAGE_TYPES.join(' · ')} 중 하나여야 합니다.`);
+  }
+  const client = makeClient();
+  const id = await resolveDatabaseId(client, target);
+  await client.setDatabaseRowPageType(id, type);
+  console.log(`새 행 기본값: ${type} — 이미 만들어진 행은 그대로입니다.`);
+}
+
 /** 경로로 줘도 되게 — 표 인자도 문서 도구들과 같은 규칙을 따른다. */
 async function resolveDatabaseId(client, target) {
   if (typeof target === 'string' && target.startsWith('/')) {
@@ -840,6 +1433,264 @@ 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 ?? []) {
+      // 메일 결재자(SIGN-002)는 userId가 없다. 누구인지 화면에 보여야 하므로
+      // 이름·주소로 대신 적고, 밖의 사람이라는 표시를 붙인다.
+      const who = m.userId ?? `${m.displayName ? `${m.displayName} <${m.email}>` : m.email} (메일 서명)`;
+      const sent = !m.userId && !m.invitedAt && m.state === 'PENDING' ? '  [요청 메일 아직 안 감]' : '';
+      console.log(`   - ${who}  ${m.role}  ${m.state}${m.actedAt ? `  ${m.actedAt}` : ''}${sent}${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': {
+      // 올리기와 서명은 다른 일이다. 1단계에 내가 있으면 그 자리에서 첫 서명까지
+      // 찍히므로 코드가 필요하고, 1단계가 밖의 사람(메일 결재자)뿐이면 서명하지
+      // 않으므로 코드 없이 올라간다. 어느 쪽인지는 서버가 안다 — 여기서 미리
+      // 막지 말고, 코드가 필요하면 서버가 시키는 대로 안내한다.
+      const id = await resolveSignedId(client, args._[1]);
+      const code = typeof args.code === 'string' ? args.code.trim() : undefined;
+      let st;
+      try {
+        st = await client.submitSignedDoc(id, code ? { code } : {});
+      } catch (err) {
+        if (String(err?.body?.code ?? '') === 'REAUTH_REQUIRED') {
+          throw new Error(
+            '올리는 분이 1단계 서명자라 첫 서명이 함께 찍힙니다. ' +
+              `먼저 "rootr sign code ${args._[1]}" 로 메일을 받고 --code <6자리> 로 다시 넘기세요.`,
+          );
+        }
+        throw err;
+      }
+      console.log(
+        code
+          ? '올렸습니다 — 본문이 얼었고 기안자 서명이 찍혔습니다.'
+          : '올렸습니다 — 본문이 얼었고 첫 단계 서명자에게 차례가 넘어갔습니다.',
+      );
+      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 results = out.results ?? [];
+      const failed = results.filter((r) => !r.ok);
+      // 얼리는 것은 되돌릴 수 없으니 "몇 건"이 아니라 "무엇을 했는지"를 보여준다.
+      const n = (kind) => results.filter((r) => r.did === kind).length;
+      const parts = [];
+      if (n('submitted+signed')) parts.push(`올리고 서명 ${n('submitted+signed')}건`);
+      if (n('submitted')) parts.push(`올리기만 ${n('submitted')}건`);
+      if (n('signed')) parts.push(`서명 ${n('signed')}건`);
+      console.log(`${parts.join(', ') || '처리 0건'}${failed.length ? `, 건너뜀 ${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);
@@ -887,8 +1738,18 @@ async function main() {
       return cmdDb(args);
     case 'form':
       return cmdForm(args);
+    case 'publish':
+      return cmdPublish(args);
+    case 'readreq':
+      return cmdReadReq(args);
     case 'access':
       return cmdAccess(args);
+    case 'sign':
+      return cmdSign(args);
+    case 'feedback':
+      return cmdFeedback(args);
+    case 'scaffold':
+      return cmdScaffold(args);
     case 'mcp':
       return cmdMcp(args);
     default: