rootr-cli 0.17.1 → 0.17.3

package/bin/rootr.js

@@ -7,11 +7,12 @@ import { loadConfig, saveConfig, keyForWorkspace, maskKey, upsertKey, CONFIG_PAT
 import { candidateClients, rememberWorkspace, resolveWorkspaceSwitch, surveyWorkspaces } from '../lib/credentials.js';
 import { RootrClient, RootrApiError } from '../lib/client.js';
 import { resolveTarget, requireResolved, resolveMoveDestination } from '../lib/resolve.js';
+import { t as tr, lang } from '../lib/i18n.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
 
-const USAGE = `Rootr CLI v${pkg.version}
+const USAGE_KO = `Rootr CLI v${pkg.version}
 
 사용법:
   rootr ls [path]                                  워크스페이스 트리 조회
@@ -98,8 +99,108 @@ const USAGE = `Rootr CLI v${pkg.version}
 설정 우선순위: 환경변수(ROOTR_API_KEY, ROOTR_WORKSPACE, ROOTR_BASE_URL) > ~/.rootr/config.json
 
 경로 인자는 '/'로 시작해야 합니다 (예: /notes/todo.md). 그 외 값은 노드 id로 취급됩니다.
+
+출력 언어: 로케일을 따릅니다. 영어로 보려면 ROOTR_LANG=en, 한국어로 고정하려면 ROOTR_LANG=ko.
+`;
+
+const USAGE_EN = `Rootr CLI v${pkg.version}
+
+usage:
+  rootr ls [path]                                  list the workspace tree
+  rootr read <path|id> [--json]                    read a document (markdown, or JSON)
+  rootr write <path|id> [--file <f>] [--if-match <etag>]   replace a document (creates it if missing)
+  rootr append <path|id> [<text>] [--heading "## X"] [--file <f>]  append safely to the end (or under a heading)
+  rootr edit <path|id> --find <text> --replace <text> [--all]      replace text inside the body
+  rootr comments <path|id> [--block <id>] [--json]  read comments (including ones left on the public page)
+  rootr search <query>                             search the workspace
+  rootr mv <path|id> <new path|folder id>          move and/or rename a document or folder
+  rootr rm <path|id> [--yes]                       move to the trash (recoverable)
+  rootr restore <id>                               undo a delete (same as Ctrl+Z in the app — id, not path)
+  rootr attach <file> [--doc <path|id>] [--heading "## X"] [--alt <text>]  upload a file (+ insert it into a document)
+  rootr ws                                         my workspaces (id\tname; unreachable ones are marked)
+  rootr use <id|name|url>                          switch the active workspace (remembers its key too)
+  rootr ask <question> [--workspace <w>]           GraphRAG question answering (RCA), prints citations
+  rootr db create [--file <spec.json>] [--parent <path|id>]  create a DATABASE — columns in order, rows included
+  rootr db rows <path|id> [--body] [--backlinks] [--json]        list rows (--body: row bodies, --backlinks: rows pointing here)
+  rootr db lock <path|id> [--schema managers] [--rows own] [--locked "Approved,Score"]  view/set table locks
+  rootr db notify <path|id> [--file rules.json] [--clear]  view/save notification rules
+  rootr db buttons <path|id> [--file buttons.json] [--clear]  view/save buttons that do work when pressed
+  rootr db button-run <path|id> <buttonId> [--rows id,id]     press a button once (create rows, fill values, AI fill)
+  rootr db view <path|id> [view name] [--scale week|month|year] [--name <new name>]  list views; calendar week/month/year
+  rootr db row-add <path|id> --values '<json>' [--body <md>|--body-file <f>]  add a row (with its body)
+  rootr db row-body <path|id> <rowId> [--file <f>] write a row's body — reads stdin if no file
+  rootr db rows-new <path|id> --json '[{…},…]' | --file <file>   insert many rows at once (one bad row cancels all)
+  rootr db rows-set <path|id> --ids <id,id> --values '<json>'  same value on every chosen row (bulk date changes, …)
+  rootr db rows-each <path|id> --json '[{"rowId":…,"values":{…}},…]'  a different value per row, in one call
+  rootr db rows-rm <path|id> --ids <id,id> [--yes]  delete chosen rows at once — one blocked row rejects all
+  rootr db row-page <rowId> [--type RECORDING]     give this row a typed detail page (recording, spreadsheet, signed doc…)
+  rootr db row-page <rowId> --node <path|id>       attach an existing document to this row (points at it, does not move it)
+  rootr db row-page <rowId> --unlink               unlink only — the document stays
+  rootr db row-page-type <path|id> <TYPE>          default type for new rows — existing rows are untouched
+  rootr publish <path|id> [--children] [--view <id>]  publish — works for every node type
+  rootr publish <path|id> --off                    stop publishing (children that came along are closed too)
+  rootr publish <path|id> --status                 is it public, at what URL, children included?
+  rootr publish <table> --layout board --skin paper   how a published table looks (9 layouts × 6 skins)
+  rootr publish <doc> --comments [false] [--expires <ISO>] [--skin <skin>]  documents only — comments, expiry, 16 skins
+  rootr readreq <path|id> [--json]                 read receipts — who has read it, completion rate
+  rootr readreq <path|id> --users <id,id> [--due <ISO>] [--ack]  set who must read it (replaces the whole list)
+  rootr readreq <path|id> --clear                  clear the read requirement
+  rootr access <path|id> [--json]                  view visibility and permissions (needs MANAGE)
+  rootr access <path|id> --private|--public|--inherit   change visibility
+  rootr access <path|id> --grant <userId> --level READ|WRITE|MANAGE   grant a permission
+  rootr access <path|id> --revoke <userId>          revoke a permission
+  rootr form new <path> --fields '<json>' [--collect db|sheet]  create a form (18 question types: text·email·phone·url·rating·scale·time·file·matrix·ranking·csat·nps…)
+  rootr form show <path|id> [--json]               read questions and settings (do this before changing them)
+  rootr form set <path|id> --fields '<json>' | --config '<json>'  change questions/settings (settings merge)
+  rootr form collect <path|id> --to db|sheet             create and wire a destination (a table gets a column per question)
+  rootr form responses <path|id> [--latest] [--json]  read responses (--latest: newest one per person)
+  rootr form response-edit <responseId> --values '<json>'  edit a submitted response (revalidated against the form)
+  rootr form response-rm <responseId> [--yes]       delete one response (cannot be undone)
+  rootr sign new <path> [--file <f>] [--reviewer <userId>] [--line <line.json>]  create a signed document (body + approval line)
+  rootr sign show <path|id> [--json]               approval-line progress and signatures
+  rootr sign line <path|id> --file <line.json>     rebuild the approval line (before submitting only)
+                                                   signers are {"userId"} or {"email","displayName"} — an email can sign without an account
+  rootr sign code <path|id> | --bulk               email a confirmation code to yourself (required before signing)
+  rootr sign submit <path|id> [--code <6 digits>]   submit — the body freezes. --code is needed if you are the first signer
+  rootr sign approve <path|id> --code <6 digits>    sign when it is your turn
+  rootr sign reject <path|id> --comment <reason> [--code <6 digits>]  reject (reason required)
+  rootr sign reopen <path|id>                      reopen a draft nobody has signed yet
+  rootr sign revise <path|id> --note <reason>       issue a revision (the original stays)
+  rootr sign verify <path|id> [--json]             prove it is untampered (signatures, hashes, timestamps)
+  rootr sign list [--pending] [--status <S>] [--mode <M>] [--json]  list signed documents (--pending: waiting on you)
+  rootr sign bulk <id…> --code <6 digits>           submit+sign many at once (one code, drafts included)
+  rootr sign ledger [--json]                       verify the whole workspace ledger (hash chain)
+  rootr config [--api-key <k>] [--workspace <w>] [--base-url <u>]  read/save configuration
+  rootr config --add-key <k> [--label <name>] [--workspace <w>]     register an extra per-workspace key
+  rootr feedback "<what is not working>" [--kind bug|friction|idea|praise] [--email <address>]
+                                                   send feedback — no login, no key, and it never hits usage limits
+  rootr scaffold plan "<what the workspace is for>"   build step 1 — what to ask, and the design rules
+  rootr scaffold review --file tree.json [--json]  build step 2 — get graded before anything is created
+  rootr scaffold apply --file tree.json [--root /path]  build step 3 — actually create it (grades come along)
+  rootr scaffold built [--root /path] [--json]     after building — inspect the **shape** of what exists
+  rootr scaffold test [--root /path] [--json]      after building — actually **exercise** it (relations, rollups, formulas, forms, sheets). Exits 1 on failure
+  rootr memory [--query <q>] [--kind <k>] [--json]  recall team memory — the same list AI agents read
+  rootr memory add "<content>" [--kind instruction|person|project|reference] [--source <path|id>] [--related a,b]  save a memory
+  rootr memory edit <id> [--content "<content>"] [--kind …] [--source …] [--related a,b]  edit a memory (only the fields you pass)
+  rootr memory forget <id> [--hard]                 retire a memory (--hard deletes the row)
+  rootr mcp                                        run the MCP stdio server (167 tools — see the README)
+  rootr --help                                     this help
+  rootr --version                                  print the version
+
+Configuration precedence: env vars (ROOTR_API_KEY, ROOTR_WORKSPACE, ROOTR_BASE_URL) > ~/.rootr/config.json
+
+Path arguments must start with '/' (e.g. /notes/todo.md). Anything else is treated as a node id.
+
+Language: this help follows your locale. Set ROOTR_LANG=ko for Korean, ROOTR_LANG=en for English.
 `;
 
+const USAGE = lang() === 'ko' ? USAGE_KO : USAGE_EN;
+
+/** 앞머리만 언어를 타고, 뒤의 명령 문법은 양쪽이 같다. */
+function usage(syntax) {
+  return tr('\uC0AC\uC6A9\uBC95: ' + syntax, 'usage: ' + syntax);
+}
+
 function parseArgs(argv) {
   const args = { _: [] };
   for (let i = 0; i < argv.length; i++) {
@@ -144,11 +245,11 @@ function makeClient() {
 
 function printErrorAndExit(err) {
   if (err instanceof RootrApiError) {
-    console.error(`오류: ${err.message}`);
+    console.error(tr(`오류: ${err.message}`, `error: ${err.message}`));
     if (err.status) console.error(`(HTTP ${err.status})`);
-    if (err.hint) console.error(`힌트: ${err.hint}`);
+    if (err.hint) console.error(tr(`힌트: ${err.hint}`, `hint: ${err.hint}`));
   } else {
-    console.error(`오류: ${err.message || err}`);
+    console.error(tr(`오류: ${err.message || err}`, `error: ${err.message || err}`));
   }
   process.exit(1);
 }
@@ -183,7 +284,7 @@ async function cmdLs(args) {
  */
 async function cmdComments(args) {
   const target = args._[0];
-  if (!target) throw new Error('사용법: rootr comments <path|id> [--block <blockId>] [--json]');
+  if (!target) throw new Error(usage(`rootr comments <path|id> [--block <blockId>] [--json]`));
 
   const client = makeClient();
   const id = requireResolved(await resolveTarget(client, target));
@@ -194,16 +295,16 @@ async function cmdComments(args) {
     return;
   }
   if (!threads.length) {
-    console.log('댓글이 없습니다.');
+    console.log(tr('댓글이 없습니다.', `No comments.`));
     return;
   }
   for (const t of threads) {
     const when = String(t.createdAt ?? '').slice(0, 16).replace('T', ' ');
-    console.log(`- ${t.author?.name ?? '(알 수 없음)'} · ${when}`);
+    console.log(tr(`- ${t.author?.name ?? '(알 수 없음)'} · ${when}`, `- ${t.author?.name ?? '(unknown)'} · ${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(tr(`    ↳ ${r.author?.name ?? '(알 수 없음)'} · ${rWhen}`, `    ↳ ${r.author?.name ?? '(unknown)'} · ${rWhen}`));
       console.log(`      ${String(r.body ?? '').replace(/\n/g, '\n      ')}`);
     }
   }
@@ -211,7 +312,7 @@ async function cmdComments(args) {
 
 async function cmdRead(args) {
   const target = args._[0];
-  if (!target) throw new Error('사용법: rootr read <path|id> [--json]');
+  if (!target) throw new Error(usage(`rootr read <path|id> [--json]`));
 
   const client = makeClient();
   const resolved = await resolveTarget(client, target);
@@ -228,7 +329,7 @@ async function cmdRead(args) {
 
 async function cmdWrite(args) {
   const target = args._[0];
-  if (!target) throw new Error('사용법: rootr write <path|id> [--file <f>] [--if-match <etag>]');
+  if (!target) throw new Error(usage(`rootr write <path|id> [--file <f>] [--if-match <etag>]`));
 
   let content;
   if (typeof args.file === 'string') {
@@ -242,7 +343,7 @@ async function cmdWrite(args) {
 
   if (!resolved.existed) {
     if (!resolved.path) {
-      throw new Error(`대상을 찾을 수 없습니다: ${target}`);
+      throw new Error(tr(`대상을 찾을 수 없습니다: ${target}`, `Target not found: ${target}`));
     }
     // 생성 자체가 쓰기 — 곧바로 PUT을 또 하면 버전/추출만 이중으로 쌓인다
     const created = await client.createNode({
@@ -263,7 +364,7 @@ async function cmdWrite(args) {
 
 async function cmdAppend(args) {
   const target = args._[0];
-  if (!target) throw new Error('사용법: rootr append <path|id> [<text>] [--heading "## X"] [--file <f>]');
+  if (!target) throw new Error(usage(`rootr append <path|id> [<text>] [--heading "## X"] [--file <f>]`));
 
   let content;
   if (typeof args._[1] === 'string') {
@@ -275,7 +376,7 @@ async function cmdAppend(args) {
   }
 
   if (!content) {
-    throw new Error('추가할 내용이 없습니다 (텍스트 인자, --file, 또는 stdin 필요).');
+    throw new Error(tr('추가할 내용이 없습니다 (텍스트 인자, --file, 또는 stdin 필요).', `Nothing to append (needs a text argument, --file, or stdin).`));
   }
 
   const client = makeClient();
@@ -292,9 +393,9 @@ async function cmdAppend(args) {
 
 async function cmdEdit(args) {
   const target = args._[0];
-  if (!target) throw new Error('사용법: rootr edit <path|id> --find <text> --replace <text> [--all]');
+  if (!target) throw new Error(usage(`rootr edit <path|id> --find <text> --replace <text> [--all]`));
   if (typeof args.find !== 'string' || typeof args.replace !== 'string') {
-    throw new Error('--find와 --replace가 모두 필요합니다.');
+    throw new Error(tr('--find와 --replace가 모두 필요합니다.', `Both --find and --replace are required.`));
   }
 
   const client = makeClient();
@@ -312,7 +413,7 @@ async function cmdEdit(args) {
 
 async function cmdSearch(args) {
   const query = args._[0];
-  if (!query) throw new Error('사용법: rootr search <query>');
+  if (!query) throw new Error(usage(`rootr search <query>`));
 
   const client = makeClient();
   const results = await client.search(query);
@@ -325,7 +426,7 @@ async function cmdSearch(args) {
 async function cmdMv(args) {
   const source = args._[0];
   const dest = args._[1];
-  if (!source || !dest) throw new Error('사용법: rootr mv <path|id> <새 경로|폴더 id>');
+  if (!source || !dest) throw new Error(usage(tr(`rootr mv <path|id> <새 경로|폴더 id>`, `rootr mv <path|id> <new path|folder id>`)));
 
   const client = makeClient();
   const resolved = await resolveTarget(client, source);
@@ -334,12 +435,12 @@ async function cmdMv(args) {
   const { parentId, name } = await resolveMoveDestination(client, dest);
   const updated = await client.updateNode(id, { parentId, name });
 
-  console.log(`이동했습니다: ${resolved.path || id} → ${updated.path || dest}`);
+  console.log(tr(`이동했습니다: ${resolved.path || id} → ${updated.path || dest}`, `Moved: ${resolved.path || id} → ${updated.path || dest}`));
 }
 
 async function cmdRm(args) {
   const target = args._[0];
-  if (!target) throw new Error('사용법: rootr rm <path|id> [--yes]');
+  if (!target) throw new Error(usage(`rootr rm <path|id> [--yes]`));
 
   const client = makeClient();
   const resolved = await resolveTarget(client, target);
@@ -349,17 +450,17 @@ async function cmdRm(args) {
   // teammate's tree — confirm unless the caller opted out for scripting.
   if (!args.yes) {
     const label = resolved.path || resolved.name || id;
-    const ok = await confirmPrompt(`"${label}" 을(를) 휴지통으로 옮깁니다. 계속할까요? [y/N] `);
+    const ok = await confirmPrompt(tr(`"${label}" 을(를) 휴지통으로 옮깁니다. 계속할까요? [y/N] `, `Move "${label}" to the trash. Continue? [y/N] `));
     if (!ok) {
-      console.log('취소했습니다.');
+      console.log(tr('취소했습니다.', `Cancelled.`));
       return;
     }
   }
 
   await client.deleteNode(id);
-  console.log(`휴지통으로 옮겼습니다: ${resolved.path || id}`);
+  console.log(tr(`휴지통으로 옮겼습니다: ${resolved.path || id}`, `Moved to the trash: ${resolved.path || id}`));
   // 되돌리려면 id 가 있어야 한다 — 휴지통에 든 것은 경로로는 못 찾는다.
-  console.log(`되돌리려면: rootr restore ${id}   (30일 뒤 자동 삭제)`);
+  console.log(tr(`되돌리려면: rootr restore ${id}   (30일 뒤 자동 삭제)`, `To undo: rootr restore ${id}   (deleted for good after 30 days)`));
 }
 
 /**
@@ -373,8 +474,8 @@ async function cmdRestore(args) {
   const id = args._[0];
   if (!id) {
     throw new Error(
-      '사용법: rootr restore <id>\n' +
-        '  (경로가 아니라 id 입니다 — 휴지통에 든 것은 경로로 못 찾습니다. rootr rm 이 찍어 준 id 를 쓰세요.)',
+      usage(`rootr restore <id>\n`) +
+        tr('  (경로가 아니라 id 입니다 — 휴지통에 든 것은 경로로 못 찾습니다. rootr rm 이 찍어 준 id 를 쓰세요.)', `  (that is an id, not a path — items in the trash cannot be found by path. Use the id rootr rm printed.)`),
     );
   }
   const client = makeClient();
@@ -383,7 +484,7 @@ async function cmdRestore(args) {
     console.log(JSON.stringify(node, null, 2));
     return;
   }
-  console.log(`되돌렸습니다: ${node.path ?? node.name ?? id}`);
+  console.log(tr(`되돌렸습니다: ${node.path ?? node.name ?? id}`, `Restored: ${node.path ?? node.name ?? id}`));
 }
 
 /** Minimal y/N prompt. Non-interactive stdin (pipes, CI) answers "no". */
@@ -411,13 +512,13 @@ const MIME_BY_EXT = {
 
 async function cmdAttach(args) {
   const filePath = args._[0];
-  if (!filePath) throw new Error('사용법: rootr attach <file> [--doc <path|id>] [--heading "## X"] [--alt <text>]');
+  if (!filePath) throw new Error(usage(`rootr attach <file> [--doc <path|id>] [--heading "## X"] [--alt <text>]`));
 
   const cfg = loadConfig();
   const workspace = args.workspace || cfg.workspace;
   if (!workspace) {
-    throw new RootrApiError('워크스페이스가 설정되지 않았습니다.', {
-      hint: '--workspace <id>로 넘기거나 rootr config --workspace <id> 또는 ROOTR_WORKSPACE 환경변수를 지정하세요.',
+    throw new RootrApiError(tr('워크스페이스가 설정되지 않았습니다.', `No workspace is configured.`), {
+      hint: tr('--workspace <id>로 넘기거나 rootr config --workspace <id> 또는 ROOTR_WORKSPACE 환경변수를 지정하세요.', `Pass --workspace <id>, or set it with rootr config --workspace <id> or the ROOTR_WORKSPACE environment variable.`),
     });
   }
 
@@ -449,8 +550,8 @@ async function cmdWs() {
   const cfg = loadConfig();
   const candidates = candidateClients(cfg);
   if (!candidates.length) {
-    throw new RootrApiError('이 컴퓨터에 등록된 Rootr 키가 없습니다.', {
-      hint: 'rootr.io > 설정 > API 키에서 계정 키(PAT)를 발급해 `rootr config --api-key <키>` 로 등록하세요.',
+    throw new RootrApiError(tr('이 컴퓨터에 등록된 Rootr 키가 없습니다.', `No Rootr key is registered on this machine.`), {
+      hint: tr('rootr.io > 설정 > API 키에서 계정 키(PAT)를 발급해 `rootr config --api-key <키>` 로 등록하세요.', 'Create an account key (PAT) under rootr.io > Settings > API keys and register it with `rootr config --api-key <key>`.'),
     });
   }
   // Probing costs an API call per workspace, so only when it diagnoses something:
@@ -459,8 +560,8 @@ async function cmdWs() {
   const { workspaces, reachable, failures } = await surveyWorkspaces(candidates, { probe });
   if (!workspaces.length) {
     throw new RootrApiError(
-      failures ? '등록된 키로 워크스페이스 목록을 조회하지 못했습니다 (키 만료/취소 가능성).' : '보이는 워크스페이스가 없습니다.',
-      { hint: 'rootr.io > 설정 > API 키에서 계정 키(PAT)를 발급해 `rootr config --api-key <키>` 로 등록하세요.' },
+      failures ? tr('등록된 키로 워크스페이스 목록을 조회하지 못했습니다 (키 만료/취소 가능성).', `Could not list workspaces with the registered keys (they may be expired or revoked).`) : tr('보이는 워크스페이스가 없습니다.', `No workspaces are visible.`),
+      { hint: tr('rootr.io > 설정 > API 키에서 계정 키(PAT)를 발급해 `rootr config --api-key <키>` 로 등록하세요.', 'Create an account key (PAT) under rootr.io > Settings > API keys and register it with `rootr config --api-key <key>`.') },
     );
   }
   let blocked = false;
@@ -468,42 +569,45 @@ async function cmdWs() {
     const unreachable = probe && !reachable.has(w.id);
     blocked = blocked || unreachable;
     console.log(
-      `${w.id === cfg.workspace ? '* ' : '  '}${w.id}\t${w.name || w.slug || ''}${unreachable ? '\t[등록된 키로는 접근 불가]' : ''}`,
+      tr(`${w.id === cfg.workspace ? '* ' : '  '}${w.id}\t${w.name || w.slug || ''}${unreachable ? '\t[등록된 키로는 접근 불가]' : ''}`, `${w.id === cfg.workspace ? '* ' : '  '}${w.id}\t${w.name || w.slug || ''}${unreachable ? '\t[not reachable with the registered keys]' : ''}`),
     );
   }
   if (blocked) {
     console.error(
-      '\n"접근 불가" = 내 소속 워크스페이스지만 등록된 키가 워크스페이스 전용이라 못 엽니다.\n' +
-        '계정 키(PAT)를 등록하면 전부 열립니다: rootr.io > 설정 > API 키 → `rootr config --api-key <키>`',
+      tr('\n"접근 불가" = 내 소속 워크스페이스지만 등록된 키가 워크스페이스 전용이라 못 엽니다.\n', `\n"not reachable" = a workspace you belong to, but the registered key is scoped to another one.\n`) +
+        tr(
+          '계정 키(PAT)를 등록하면 전부 열립니다: rootr.io > 설정 > API 키 → `rootr config --api-key <키>`',
+          'Register an account key (PAT) and they all open: rootr.io > Settings > API keys → `rootr config --api-key <key>`',
+        ),
     );
   }
 }
 
 async function cmdUse(args) {
   const wanted = args._.join(' ').trim();
-  if (!wanted) throw new Error('사용법: rootr use <워크스페이스 id | 이름 | rootr.io 주소>');
+  if (!wanted) throw new Error(usage(tr(`rootr use <워크스페이스 id | 이름 | rootr.io 주소>`, `rootr use <workspace id | name | rootr.io URL>`)));
   const cfg = loadConfig();
   const match = await resolveWorkspaceSwitch(wanted, cfg);
   if (match.error) throw new RootrApiError(match.error);
   rememberWorkspace(match, cfg);
-  console.log(`활성 워크스페이스: "${match.workspace.name || match.workspace.slug || ''}" (${match.workspace.id})`);
+  console.log(tr(`활성 워크스페이스: "${match.workspace.name || match.workspace.slug || ''}" (${match.workspace.id})`, `Active workspace: "${match.workspace.name || match.workspace.slug || ''}" (${match.workspace.id})`));
 }
 
 async function cmdAsk(args) {
   const question = args._.join(' ');
-  if (!question) throw new Error('사용법: rootr ask <question> [--workspace <w>]');
+  if (!question) throw new Error(usage(`rootr ask <question> [--workspace <w>]`));
 
   const cfg = loadConfig();
   const workspace = args.workspace || cfg.workspace;
   if (!workspace) {
-    throw new RootrApiError('워크스페이스가 설정되지 않았습니다.', {
-      hint: '--workspace <id>로 넘기거나 rootr config --workspace <id> 또는 ROOTR_WORKSPACE 환경변수를 지정하세요.',
+    throw new RootrApiError(tr('워크스페이스가 설정되지 않았습니다.', `No workspace is configured.`), {
+      hint: tr('--workspace <id>로 넘기거나 rootr config --workspace <id> 또는 ROOTR_WORKSPACE 환경변수를 지정하세요.', `Pass --workspace <id>, or set it with rootr config --workspace <id> or the ROOTR_WORKSPACE environment variable.`),
     });
   }
 
   const client = new RootrClient({ ...cfg, workspace });
   const result = await client.ask(workspace, question);
-  console.log(result.text || '(응답 없음)');
+  console.log(result.text || tr('(응답 없음)', `(no response)`));
   const citations = Array.isArray(result.citations) ? result.citations : [];
   if (citations.length) {
     console.log('\nCitations:');
@@ -525,7 +629,7 @@ async function cmdFeedback(args) {
   if (!body) body = (await readStdin()).trim();
   if (!body) {
     throw new Error(
-      '사용법: rootr feedback "무엇을 하려다 무엇이 일어났는지" [--kind bug|friction|idea|praise]\n' +
+      usage(tr(`rootr feedback "무엇을 하려다 무엇이 일어났는지" [--kind bug|friction|idea|praise]\n`, `rootr feedback "what you tried and what happened" [--kind bug|friction|idea|praise]\n`)) +
         '       rootr feedback --file report.md   /   cat log | rootr feedback --kind bug',
     );
   }
@@ -534,7 +638,7 @@ async function cmdFeedback(args) {
   if (args.kind) {
     kind = KIND_MAP[String(args.kind).toLowerCase()];
     if (!kind) {
-      throw new Error(`--kind 는 ${Object.keys(KIND_MAP).join('|')} 중 하나입니다.`);
+      throw new Error(tr(`--kind 는 ${Object.keys(KIND_MAP).join('|')} 중 하나입니다.`, `--kind must be one of ${Object.keys(KIND_MAP).join('|')}.`));
     }
   }
 
@@ -551,12 +655,12 @@ async function cmdFeedback(args) {
     client: 'cli',
   });
   if (result.deduped) {
-    console.log(`이미 같은 제보가 접수돼 있어 합쳤습니다. (id: ${result.id})`);
+    console.log(tr(`이미 같은 제보가 접수돼 있어 합쳤습니다. (id: ${result.id})`, `The same report already exists, so it was merged. (id: ${result.id})`));
     return;
   }
-  console.log(`제보를 보냈습니다. 고맙습니다. (id: ${result.id})`);
+  console.log(tr(`제보를 보냈습니다. 고맙습니다. (id: ${result.id})`, `Feedback sent. Thank you. (id: ${result.id})`));
   if (!args.email) {
-    console.log('답을 받고 싶으면 --email <주소>를 함께 주세요.');
+    console.log(tr('답을 받고 싶으면 --email <주소>를 함께 주세요.', `Pass --email <address> if you want a reply.`));
   }
 }
 
@@ -570,7 +674,7 @@ async function cmdConfig(args) {
       workspace: typeof args.workspace === 'string' ? args.workspace : undefined,
       label: typeof args.label === 'string' ? args.label : undefined,
     });
-    console.log(`키를 등록했습니다 (총 ${keys.length}개): ${CONFIG_PATH}`);
+    console.log(tr(`키를 등록했습니다 (총 ${keys.length}개): ${CONFIG_PATH}`, `Key registered (${keys.length} total): ${CONFIG_PATH}`));
     return;
   }
 
@@ -593,7 +697,7 @@ async function cmdConfig(args) {
   if (typeof args['base-url'] === 'string') partial.baseUrl = args['base-url'];
 
   saveConfig(partial);
-  console.log(`설정을 저장했습니다: ${CONFIG_PATH}`);
+  console.log(tr(`설정을 저장했습니다: ${CONFIG_PATH}`, `Configuration saved: ${CONFIG_PATH}`));
 }
 
 async function cmdMcp() {
@@ -608,6 +712,28 @@ async function cmdMcp() {
 
 const MEMORY_KINDS = ['지시', '사람', '프로젝트', '참고'];
 
+/**
+ * 저장되는 값은 한국어 네 가지로 고정이다 — 화면·MCP·이미 쌓인 행이 전부 그 값을 쓴다.
+ * 영어로 치는 사람을 위해 입력만 받아 준다(출력·저장은 그대로).
+ */
+const MEMORY_KIND_ALIASES = {
+  instruction: '지시',
+  person: '사람',
+  people: '사람',
+  project: '프로젝트',
+  reference: '참고',
+  ref: '참고',
+};
+
+function normalizeMemoryKind(value) {
+  if (!value || typeof value !== 'string') return value;
+  return MEMORY_KIND_ALIASES[value.trim().toLowerCase()] ?? value;
+}
+
+function memoryKindChoices() {
+  return tr(MEMORY_KINDS.join('/'), Object.keys(MEMORY_KIND_ALIASES).filter((k) => k !== 'people' && k !== 'ref').join('/'));
+}
+
 function parseRelated(val) {
   if (!val) return undefined;
   if (Array.isArray(val)) return val;
@@ -628,7 +754,7 @@ async function cmdMemory(args) {
       return;
     }
     if (!result.memories.length) {
-      console.log('아직 기억이 없습니다. rootr memory add "한 줄 사실" 으로 남겨 보세요.');
+      console.log(tr('아직 기억이 없습니다. rootr memory add "한 줄 사실" 으로 남겨 보세요.', `No memories yet. Try: rootr memory add "a one-line fact"`));
       return;
     }
     for (const m of result.memories) {
@@ -641,9 +767,15 @@ async function cmdMemory(args) {
 
   if (sub === 'add') {
     const content = args._.join(' ');
-    if (!content) throw new Error('사용법: rootr memory add "<내용>" [--kind 지시|사람|프로젝트|참고] [--source <경로|id>] [--related a,b]');
+    if (!content) throw new Error(usage(tr(`rootr memory add "<내용>" [--kind 지시|사람|프로젝트|참고] [--source <경로|id>] [--related a,b]`, `rootr memory add "<content>" [--kind instruction|person|project|reference] [--source <path|id>] [--related a,b]`)));
+    args.kind = normalizeMemoryKind(args.kind);
     if (args.kind && !MEMORY_KINDS.includes(args.kind)) {
-      throw new Error(`종류는 ${MEMORY_KINDS.join('/')} 중 하나여야 합니다: ${args.kind}`);
+      throw new Error(
+        tr(
+          tr(`종류는 ${memoryKindChoices()} 중 하나여야 합니다: ${args.kind}`, `--kind must be one of ${memoryKindChoices()}: ${args.kind}`),
+          `--kind must be one of ${memoryKindChoices()}: ${args.kind}`,
+        ),
+      );
     }
     const result = await client.remember({
       content,
@@ -651,20 +783,26 @@ async function cmdMemory(args) {
       source: args.source,
       related: parseRelated(args.related),
     });
-    console.log(`${result.replaced ? '기억을 갈아끼웠습니다' : '기억했습니다'}: ${result.memory.content}`);
-    console.log(`id: ${result.memory.id} · 상태: ${result.memory.status}`);
+    console.log(tr(`${result.replaced ? '기억을 갈아끼웠습니다' : '기억했습니다'}: ${result.memory.content}`, `${result.replaced ? 'Memory replaced' : 'Remembered'}: ${result.memory.content}`));
+    console.log(tr(`id: ${result.memory.id} · 상태: ${result.memory.status}`, `id: ${result.memory.id} · status: ${result.memory.status}`));
     return;
   }
 
   if (sub === 'edit') {
     const id = args._[0];
-    if (!id) throw new Error('사용법: rootr memory edit <id> [--content "<내용>"] [--kind …] [--source …] [--related a,b]');
+    if (!id) throw new Error(usage(tr(`rootr memory edit <id> [--content "<내용>"] [--kind …] [--source …] [--related a,b]`, `rootr memory edit <id> [--content "<content>"] [--kind …] [--source …] [--related a,b]`)));
     const content = args._.slice(1).join(' ') || args.content;
     if (!content && !args.kind && !args.source && !args.related) {
-      throw new Error('고칠 칸이 하나도 없습니다 — --content/--kind/--source/--related 중 하나는 주어야 합니다.');
+      throw new Error(tr('고칠 칸이 하나도 없습니다 — --content/--kind/--source/--related 중 하나는 주어야 합니다.', `Nothing to change — pass at least one of --content/--kind/--source/--related.`));
     }
+    args.kind = normalizeMemoryKind(args.kind);
     if (args.kind && !MEMORY_KINDS.includes(args.kind)) {
-      throw new Error(`종류는 ${MEMORY_KINDS.join('/')} 중 하나여야 합니다: ${args.kind}`);
+      throw new Error(
+        tr(
+          tr(`종류는 ${memoryKindChoices()} 중 하나여야 합니다: ${args.kind}`, `--kind must be one of ${memoryKindChoices()}: ${args.kind}`),
+          `--kind must be one of ${memoryKindChoices()}: ${args.kind}`,
+        ),
+      );
     }
     const result = await client.revise(id, {
       ...(content ? { content } : {}),
@@ -672,20 +810,25 @@ async function cmdMemory(args) {
       ...(args.source !== undefined ? { source: args.source } : {}),
       ...(args.related !== undefined ? { related: parseRelated(args.related) } : {}),
     });
-    console.log(`고쳤습니다: ${result.content}`);
-    console.log(`상태: ${result.status}${result.mergedIds?.length ? ` · 같은 사실 ${result.mergedIds.length}건을 폐기로 내렸습니다` : ''}`);
+    console.log(tr(`고쳤습니다: ${result.content}`, `Updated: ${result.content}`));
+    console.log(
+      tr(
+        `상태: ${result.status}${result.mergedIds?.length ? ` · 같은 사실 ${result.mergedIds.length}건을 폐기로 내렸습니다` : ''}`,
+        `status: ${result.status}${result.mergedIds?.length ? ` · retired ${result.mergedIds.length} duplicate facts` : ''}`,
+      ),
+    );
     return;
   }
 
   if (sub === 'forget') {
     const id = args._[0];
-    if (!id) throw new Error('사용법: rootr memory forget <id> [--hard]');
+    if (!id) throw new Error(usage(`rootr memory forget <id> [--hard]`));
     await client.forget(id, { hard: args.hard === true });
-    console.log(args.hard ? '기억을 지웠습니다.' : '기억을 폐기 상태로 내렸습니다.');
+    console.log(args.hard ? tr('기억을 지웠습니다.', `Memory deleted.`) : tr('기억을 폐기 상태로 내렸습니다.', `Memory retired.`));
     return;
   }
 
-  throw new Error(`알 수 없는 하위명령: ${sub}\n사용법: rootr memory [ls|add|edit|forget] …`);
+  throw new Error(tr(`알 수 없는 하위명령: ${sub}\n사용법: rootr memory [ls|add|edit|forget] …`, `Unknown subcommand: ${sub}\nusage: rootr memory [ls|add|edit|forget] …`));
 }
 
 // ---- entry ------------------------------------------------------------
@@ -708,7 +851,7 @@ 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>]',
+      usage(`rootr access <path|id> [--private|--public|--inherit] [--grant <userId> --level READ|WRITE|MANAGE] [--revoke <userId>]`),
     );
   }
   const client = makeClient();
@@ -720,22 +863,22 @@ async function cmdAccess(args) {
     const visibility = args.private ? 'PRIVATE' : args.public ? 'PUBLIC' : null;
     await client.setNodeVisibility(id, visibility);
     console.log(
-      `공개범위: ${visibility === 'PRIVATE' ? '비공개(만든 사람·관리자·따로 준 사람만)' : visibility === 'PUBLIC' ? '워크스페이스 전체' : '상위 폴더/워크스페이스 기본값을 따름'}`,
+      tr(`공개범위: ${visibility === 'PRIVATE' ? '비공개(만든 사람·관리자·따로 준 사람만)' : visibility === 'PUBLIC' ? '워크스페이스 전체' : '상위 폴더/워크스페이스 기본값을 따름'}`, `Visibility: ${visibility === 'PRIVATE' ? 'private (creator, managers, and people granted access)' : visibility === 'PUBLIC' ? 'the whole workspace' : 'inherits from the parent folder/workspace'}`),
     );
     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 를 함께 주세요.');
+      throw new Error(tr('--grant 에는 --level READ|WRITE|MANAGE 를 함께 주세요.', `Pass --level READ|WRITE|MANAGE together with --grant.`));
     }
     await client.grantNodePermission(id, { subjectType: group, subjectId: args.grant, level });
-    console.log(`권한 부여: ${args.grant} → ${level}`);
+    console.log(tr(`권한 부여: ${args.grant} → ${level}`, `Granted: ${args.grant} → ${level}`));
     changed = true;
   }
   if (typeof args.revoke === 'string') {
     await client.revokeNodePermission(id, { subjectType: group, subjectId: args.revoke });
-    console.log(`권한 회수: ${args.revoke}`);
+    console.log(tr(`권한 회수: ${args.revoke}`, `Revoked: ${args.revoke}`));
     changed = true;
   }
 
@@ -746,10 +889,10 @@ async function cmdAccess(args) {
   }
   if (!changed) {
     const eff = info.effectiveVisibility ?? info.visibility;
-    console.log(`공개범위: ${eff === 'PRIVATE' ? '비공개' : '워크스페이스 전체'}${info.visibility === null ? ' (상속받음)' : ''}`);
+    console.log(tr(`공개범위: ${eff === 'PRIVATE' ? '비공개' : '워크스페이스 전체'}${info.visibility === null ? ' (상속받음)' : ''}`, `Visibility: ${eff === 'PRIVATE' ? 'private' : 'the whole workspace'}${info.visibility === null ? ' (inherited)' : ''}`));
   }
   const direct = info.direct ?? [];
-  console.log(`따로 준 권한: ${direct.length ? '' : '없음'}`);
+  console.log(tr(`따로 준 권한: ${direct.length ? '' : '없음'}`, `Direct grants: ${direct.length ? '' : 'none'}`));
   for (const p of direct) console.log(`  - ${p.subjectType} ${p.subjectId} → ${p.level}`);
 }
 
@@ -769,7 +912,7 @@ async function cmdForm(args) {
   if (sub === 'response-edit') return cmdFormResponseEdit(args);
   if (sub === 'response-rm') return cmdFormResponseRm(args);
   throw new Error(
-    '사용법: rootr form new|show|set|collect|responses|response-edit|response-rm … (자세한 건 rootr --help)',
+    usage(tr(`rootr form new|show|set|collect|responses|response-edit|response-rm … (자세한 건 rootr --help)`, `rootr form new|show|set|collect|responses|response-edit|response-rm … (see rootr --help)`)),
   );
 }
 
@@ -792,13 +935,13 @@ function parseFieldsArg(args) {
   try {
     parsed = JSON.parse(args.fields);
   } catch {
-    throw new Error('--fields 는 JSON 배열이어야 합니다. 예: [{"name":"이메일","type":"email","required":true}]');
+    throw new Error(tr('--fields 는 JSON 배열이어야 합니다. 예: [{"name":"이메일","type":"email","required":true}]', `--fields must be a JSON array. Example: [{"name":"Email","type":"email","required":true}]`));
   }
-  if (!Array.isArray(parsed)) throw new Error('--fields 는 배열이어야 합니다.');
+  if (!Array.isArray(parsed)) throw new Error(tr('--fields 는 배열이어야 합니다.', `--fields must be an array.`));
   for (const [i, f] of parsed.entries()) {
-    if (!f || typeof f.name !== 'string') throw new Error(`fields[${i}].name 이 필요합니다.`);
+    if (!f || typeof f.name !== 'string') throw new Error(tr(`fields[${i}].name 이 필요합니다.`, `fields[${i}].name is required.`));
     if (!FORM_FIELD_TYPES.includes(f.type)) {
-      throw new Error(`fields[${i}].type 은 다음 중 하나여야 합니다: ${FORM_FIELD_TYPES.join(', ')}`);
+      throw new Error(tr(`fields[${i}].type 은 다음 중 하나여야 합니다: ${FORM_FIELD_TYPES.join(', ')}`, `fields[${i}].type must be one of: ${FORM_FIELD_TYPES.join(', ')}`));
     }
   }
   return parsed;
@@ -809,14 +952,14 @@ function parseConfigArg(args) {
   try {
     return JSON.parse(args.config);
   } catch {
-    throw new Error('--config 는 JSON 객체여야 합니다.');
+    throw new Error(tr('--config 는 JSON 객체여야 합니다.', `--config must be a JSON object.`));
   }
 }
 
 async function cmdFormNew(args) {
   const target = args._[1];
   if (!target) {
-    throw new Error("사용법: rootr form new <경로> --fields '<json>' [--config '<json>'] [--collect db|sheet]");
+    throw new Error(usage(tr("rootr form new <경로> --fields '<json>' [--config '<json>'] [--collect db|sheet]", "rootr form new <path> --fields '<json>' [--config '<json>'] [--collect db|sheet]")));
   }
   const client = makeClient();
   const created = await client.createForm(client.workspace, {
@@ -826,19 +969,19 @@ async function cmdFormNew(args) {
     config: parseConfigArg(args),
   });
   const id = created.id ?? created.nodeId;
-  console.log(`폼을 만들었습니다: ${target}`);
+  console.log(tr(`폼을 만들었습니다: ${target}`, `Form created: ${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' ? '표' : '스프레드시트'} 생성됨`);
+    console.log(tr(`  응답 모을 곳: ${args.collect === 'db' ? '표' : '스프레드시트'} 생성됨`, `  Responses collected into: a ${args.collect === 'db' ? 'table' : 'spreadsheet'} was created`));
   }
 }
 
 /** `rootr form show <path|id>` — 질문·설정을 그대로 본다(고치기 전에 읽으라고 있는 것). */
 async function cmdFormShow(args) {
   const target = args._[1];
-  if (!target) throw new Error('사용법: rootr form show <path|id> [--json]');
+  if (!target) throw new Error(usage(`rootr form show <path|id> [--json]`));
   const client = makeClient();
   // 경로도 id도 받는다(이 저장소의 다른 명령과 같은 규칙).
   const id = await resolveDatabaseId(client, target);
@@ -847,32 +990,32 @@ async function cmdFormShow(args) {
     console.log(JSON.stringify(form, null, 2));
     return;
   }
-  console.log(`${form.name}  (응답 ${form.responseCount ?? 0}건, 방문 ${form.viewCount ?? 0}회)`);
+  console.log(tr(`${form.name}  (응답 ${form.responseCount ?? 0}건, 방문 ${form.viewCount ?? 0}회)`, `${form.name}  (${form.responseCount ?? 0} responses, ${form.viewCount ?? 0} views)`));
   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,
+      f.required ? tr('필수', `required`) : null,
+      f.hidden ? tr('숨김', `hidden`) : null,
+      f.page && f.page > 1 ? tr(`${f.page}쪽`, `page ${f.page}`) : null,
+      f.showIf ? tr('조건부', `conditional`) : 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.publicSubmit && cfg.publicSubmit !== 'off') bits.push(tr(`공개 제출: ${cfg.publicSubmit}`, `public submission: ${cfg.publicSubmit}`));
+  if (cfg.closesAt) bits.push(tr(`마감: ${cfg.closesAt}`, `closes: ${cfg.closesAt}`));
+  if (cfg.maxResponses) bits.push(tr(`정원: ${cfg.maxResponses}`, `capacity: ${cfg.maxResponses}`));
+  if (Array.isArray(cfg.notifyEmails) && cfg.notifyEmails.length) bits.push(tr(`알림: ${cfg.notifyEmails.join(', ')}`, `notify: ${cfg.notifyEmails.join(', ')}`));
+  if (cfg.webhookUrl) bits.push(tr('웹훅 있음', `has a webhook`));
+  if (cfg.theme) bits.push(tr(`분위기: ${cfg.theme}`, `theme: ${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(' · ')}`);
+  if (cfg.oncePerPerson) bits.push(tr('한 사람 한 번만', `one response per person`));
+  if (cfg.confirmEmailField) bits.push(tr('확인 메일 보냄', `sends a confirmation email`));
+  if (cfg.intro) bits.push(tr('안내문 있음', `has an intro`));
+  if (cfg.thankYou) bits.push(tr('인사말 있음', `has a greeting`));
+  if (cfg.redirectUrl) bits.push(tr(`낸 뒤 이동: ${cfg.redirectUrl}`, `after submit, go to: ${cfg.redirectUrl}`));
+  if (bits.length) console.log(tr(`  설정 — ${bits.join(' · ')}`, `  settings — ${bits.join(' · ')}`));
 }
 
 /**
@@ -886,15 +1029,15 @@ async function cmdFormSet(args) {
   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>'");
+    throw new Error(usage("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(', ')}`);
+  console.log(tr('폼을 고쳤습니다.', `Form updated.`));
+  if (fields) console.log(tr(`  질문 ${fields.length}개`, `  ${fields.length} questions`));
+  if (config) console.log(tr(`  바꾼 설정: ${Object.keys(config).join(', ')}`, `  settings changed: ${Object.keys(config).join(', ')}`));
 }
 
 /**
@@ -905,10 +1048,10 @@ async function cmdFormSet(args) {
  */
 async function cmdFormCollect(args) {
   const target = args._[1];
-  if (!target) throw new Error('사용법: rootr form collect <path|id> --to db|sheet');
+  if (!target) throw new Error(usage(`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 를 주세요.');
+  if (!map[to]) throw new Error(tr('--to 에 db 또는 sheet 를 주세요.', `Pass db or sheet to --to.`));
 
   const client = makeClient();
   const id = requireResolved(await resolveTarget(client, target));
@@ -919,14 +1062,14 @@ async function cmdFormCollect(args) {
   }
   console.log(
     made.kind === 'database'
-      ? `표를 만들어 연결했습니다: ${made.nodeId}  (폼 질문 그대로 칸이 생겼습니다)`
-      : `스프레드시트를 만들어 연결했습니다: ${made.nodeId}`,
+      ? tr(`표를 만들어 연결했습니다: ${made.nodeId}  (폼 질문 그대로 칸이 생겼습니다)`, `Created and wired a table: ${made.nodeId}  (one column per question)`)
+      : tr(`스프레드시트를 만들어 연결했습니다: ${made.nodeId}`, `Created and wired a spreadsheet: ${made.nodeId}`),
   );
 }
 
 async function cmdFormResponses(args) {
   const target = args._[1];
-  if (!target) throw new Error('사용법: rootr form responses <path|id> [--latest] [--json]');
+  if (!target) throw new Error(usage(`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) });
@@ -936,26 +1079,26 @@ async function cmdFormResponses(args) {
     return;
   }
   if (!rows.length) {
-    console.log('아직 들어온 응답이 없습니다.');
+    console.log(tr('아직 들어온 응답이 없습니다.', `No responses yet.`));
     return;
   }
-  console.log(`응답 ${rows.length}건${args.latest ? ' (사람마다 최신 1건만)' : ''}`);
+  console.log(tr(`응답 ${rows.length}건${args.latest ? ' (사람마다 최신 1건만)' : ''}`, `${rows.length} responses${args.latest ? ' (newest one per person)' : ''}`));
   for (const r of rows) {
-    const who = r.submitterUserId ? r.submitterUserId : '익명';
-    console.log(`- ${r.id}  ${new Date(r.createdAt).toISOString()}  제출자:${who}`);
+    const who = r.submitterUserId ? r.submitterUserId : tr('익명', `anonymous`);
+    console.log(tr(`- ${r.id}  ${new Date(r.createdAt).toISOString()}  제출자:${who}`, `- ${r.id}  ${new Date(r.createdAt).toISOString()}  by:${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>'");
+  if (!responseId) throw new Error(usage(tr("rootr form response-edit <응답id> --values '<json>'", "rootr form response-edit <responseId> --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":"값"} 형태여야 합니다.');
+    throw new Error(tr('--values 를 JSON으로 읽을 수 없습니다. {"필드id":"값"} 형태여야 합니다.', `Could not read --values as JSON. It must look like {"fieldId":"value"}.`));
   }
   // 통째로 바뀐다 — 남기고 싶은 답도 같이 보내야 한다.
   const result = await makeClient().updateFormResponse(responseId, values);
@@ -963,18 +1106,18 @@ async function cmdFormResponseEdit(args) {
     console.log(JSON.stringify(result, null, 2));
     return;
   }
-  console.log(`응답 수정됨: ${result.id ?? responseId}`);
+  console.log(tr(`응답 수정됨: ${result.id ?? responseId}`, `Response updated: ${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 (!responseId) throw new Error(usage(tr(`rootr form response-rm <응답id> [--yes]`, `rootr form response-rm <responseId> [--yes]`)));
   if (!args.yes) {
-    throw new Error('응답 삭제는 되돌릴 수 없습니다. 정말 지우려면 --yes 를 붙이세요.');
+    throw new Error(tr('응답 삭제는 되돌릴 수 없습니다. 정말 지우려면 --yes 를 붙이세요.', `Deleting a response cannot be undone. Add --yes if you really mean it.`));
   }
   await makeClient().deleteFormResponse(responseId);
-  console.log(`응답 삭제됨: ${responseId}`);
+  console.log(tr(`응답 삭제됨: ${responseId}`, `Response deleted: ${responseId}`));
 }
 
 /**
@@ -987,13 +1130,18 @@ 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>'");
+    throw new Error(usage("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"}}\'');
+    throw new Error(
+      tr(
+        '--values 를 JSON으로 읽을 수 없습니다. 예: \'{"작성일":{"start":"2026-08-01"}}\'',
+        '--values could not be read as JSON. Example: \'{"Created":{"start":"2026-08-01"}}\'',
+      ),
+    );
   }
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
@@ -1004,7 +1152,7 @@ async function cmdDbRowsSet(args) {
     Object.entries(values).map(([k, v]) => [byName.get(k) ?? k, v]),
   );
   const res = await client.bulkUpdateRows(id, ids, resolved);
-  console.log(`${res.updated}개 행을 바꿨습니다.`);
+  console.log(tr(`${res.updated}개 행을 바꿨습니다.`, `${res.updated} rows changed.`));
 }
 
 /**
@@ -1016,13 +1164,13 @@ async function cmdDbRowsSet(args) {
 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 <파일>");
+  if (!target) throw new Error(usage(tr("rootr db rows-new <path|id> --json '<[{…},…]>' | --file <파일>", "rootr db rows-new <path|id> --json '<[{…},…]>' | --file <file>")));
   const rows = Array.isArray(raw) ? raw : [raw];
-  if (!rows.length) throw new Error('넣을 행이 없습니다.');
+  if (!rows.length) throw new Error(tr('넣을 행이 없습니다.', `No rows to insert.`));
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
   const res = await client.bulkCreateRows(id, rows);
-  console.log(`${res.created}개 행을 넣었습니다.`);
+  console.log(tr(`${res.created}개 행을 넣었습니다.`, `${res.created} rows inserted.`));
 }
 
 /**
@@ -1033,17 +1181,17 @@ async function cmdDbRowsNew(args) {
 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 <파일>");
+  if (!target) throw new Error(usage(tr("rootr db rows-each <path|id> --json '<[{rowId,values},…]>' | --file <파일>", "rootr db rows-each <path|id> --json '<[{rowId,values},…]>' | --file <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": { … } } 형태여야 합니다.');
+      throw new Error(tr('각 항목은 { "rowId": "…", "values": { … } } 형태여야 합니다.', `Each item must look like { "rowId": "…", "values": { … } }.`));
     }
   }
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
   const res = await client.bulkUpdateRowsEach(id, updates);
-  console.log(`${res.updated}개 행을 바꿨습니다.`);
+  console.log(tr(`${res.updated}개 행을 바꿨습니다.`, `${res.updated} rows changed.`));
 }
 
 /** `--json '<...>'` 또는 `--file <파일>` 중 하나를 읽는다. 행이 많으면 파일이 편하다. */
@@ -1061,7 +1209,7 @@ async function cmdScaffold(args) {
   const client = makeClient();
   if (sub === 'plan') {
     const intent = args._.slice(1).join(' ').trim();
-    if (!intent) throw new Error('사용법: rootr scaffold plan "무엇을 위한 워크스페이스인지"');
+    if (!intent) throw new Error(usage(tr(`rootr scaffold plan "무엇을 위한 워크스페이스인지"`, `rootr scaffold plan "what the workspace is for"`)));
     console.log(JSON.stringify(await client.scaffoldPlan(intent), null, 2));
     return;
   }
@@ -1074,14 +1222,14 @@ async function cmdScaffold(args) {
     }
     console.log(r.summary);
     for (const f of r.findings) {
-      const mark = f.level === 'error' ? '고쳐야 함' : f.level === 'warn' ? '약함' : '더 나아짐';
+      const mark = f.level === 'error' ? tr('고쳐야 함', `needs work`) : f.level === 'warn' ? tr('약함', `weak`) : tr('더 나아짐', `improved`);
       console.log(`  [${mark}] ${f.at}  ${f.message}`);
     }
     return;
   }
   if (sub === 'built') {
     const ws = args.workspace || loadConfig().workspace;
-    if (!ws) throw new Error('워크스페이스가 없습니다: --workspace <id>');
+    if (!ws) throw new Error(tr('워크스페이스가 없습니다: --workspace <id>', `No workspace: --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));
@@ -1089,14 +1237,14 @@ async function cmdScaffold(args) {
     }
     console.log(r.summary);
     for (const f of r.findings) {
-      const mark = f.level === 'error' ? '고쳐야 함' : f.level === 'warn' ? '약함' : '더 나아짐';
+      const mark = f.level === 'error' ? tr('고쳐야 함', `needs work`) : f.level === 'warn' ? tr('약함', `weak`) : tr('더 나아짐', `improved`);
       console.log(`  [${mark}] ${f.at}  ${f.message}`);
     }
     return;
   }
   if (sub === 'test') {
     const ws = args.workspace || loadConfig().workspace;
-    if (!ws) throw new Error('워크스페이스가 없습니다: --workspace <id>');
+    if (!ws) throw new Error(tr('워크스페이스가 없습니다: --workspace <id>', `No workspace: --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));
@@ -1104,7 +1252,7 @@ async function cmdScaffold(args) {
     }
     console.log(r.summary);
     for (const c of r.checks) {
-      console.log(`  [${c.level === 'fail' ? '실패' : '경고'}] ${c.at}  (${c.check}) ${c.message}`);
+      console.log(tr(`  [${c.level === 'fail' ? '실패' : '경고'}] ${c.at}  (${c.check}) ${c.message}`, `  [${c.level === 'fail' ? 'FAIL' : 'WARN'}] ${c.at}  (${c.check}) ${c.message}`));
     }
     if (r.failed) process.exitCode = 1;
     return;
@@ -1112,27 +1260,27 @@ async function cmdScaffold(args) {
   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>');
+    if (!ws) throw new Error(tr('워크스페이스가 없습니다: --workspace <id> 또는 rootr config --workspace <id>', `No workspace: --workspace <id>, or 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}`);
+    console.log(tr(`${r.created.length}개를 ${r.rootPath || '/'} 아래에 만들었습니다.`, `Created ${r.created.length} items under ${r.rootPath || '/'}.`));
+    if (r.review) console.log(tr(`검사: ${r.review.summary}`, `Review: ${r.review.summary}`));
     return;
   }
-  throw new Error('사용법: rootr scaffold plan|review|apply  (review/apply 는 --file tree.json)');
+  throw new Error(usage(tr(`rootr scaffold plan|review|apply  (review/apply 는 --file tree.json)`, `rootr scaffold plan|review|apply  (review/apply take --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 이 필요합니다.`);
+  if (text == null) throw new Error(tr(`${cmd}: --json 또는 --file 이 필요합니다.`, `${cmd}: --json or --file is required.`));
   try {
     return JSON.parse(text);
   } catch {
-    throw new Error(`${cmd}: JSON으로 읽을 수 없습니다.`);
+    throw new Error(tr(`${cmd}: JSON으로 읽을 수 없습니다.`, `${cmd}: could not read it as JSON.`));
   }
 }
 
@@ -1141,15 +1289,15 @@ 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]');
+    throw new Error(usage(`rootr db rows-rm <path|id> --ids <id,id> [--yes]`));
   }
   if (!args.yes) {
-    throw new Error(`${ids.length}개 행을 지웁니다. 되돌릴 수 없으니 정말 지우려면 --yes 를 붙이세요.`);
+    throw new Error(tr(`${ids.length}개 행을 지웁니다. 되돌릴 수 없으니 정말 지우려면 --yes 를 붙이세요.`, `This deletes ${ids.length} rows and cannot be undone. Add --yes if you really mean it.`));
   }
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
   const res = await client.bulkDeleteRows(id, ids);
-  console.log(`${res.deleted}개 행을 지웠습니다.`);
+  console.log(tr(`${res.deleted}개 행을 지웠습니다.`, `${res.deleted} rows deleted.`));
 }
 
 /**
@@ -1177,7 +1325,7 @@ async function cmdPublish(args) {
   const target = args._[0];
   if (!target) {
     throw new Error(
-      '사용법: rootr publish <path|id> [--children] [--view <id>] [--layout <배치>] [--skin <분위기>] ' +
+      usage(tr(`rootr publish <path|id> [--children] [--view <id>] [--layout <배치>] [--skin <분위기>] `, `rootr publish <path|id> [--children] [--view <id>] [--layout <layout>] [--skin <skin>] `)) +
         '[--comments] [--expires <ISO>] | --off | --status',
     );
   }
@@ -1190,24 +1338,24 @@ async function cmdPublish(args) {
   if (args.status) {
     const st = isDocument ? await client.getDocumentPublicStatus(id) : await client.nodePublicStatus(id);
     if (!isDocument && !st.publishable) {
-      console.log('이 종류는 공개할 수 없습니다(폴더).');
+      console.log(tr('이 종류는 공개할 수 없습니다(폴더).', `This node type cannot be published (folder).`));
       return;
     }
     if (!st.isPublic) {
-      console.log(st.slug ? `닫혀 있습니다(주소는 남아 있음: /p/${st.slug})` : '아직 공개한 적이 없습니다.');
+      console.log(st.slug ? tr(`닫혀 있습니다(주소는 남아 있음: /p/${st.slug})`, `Closed (the address is still reserved: /p/${st.slug})`) : tr('아직 공개한 적이 없습니다.', `Never published.`));
       return;
     }
-    console.log(`공개 중: /p/${st.slug}`);
-    if (st.expiresAt) console.log(`  만료: ${st.expiresAt}`);
+    console.log(tr(`공개 중: /p/${st.slug}`, `Public: /p/${st.slug}`));
+    if (st.expiresAt) console.log(tr(`  만료: ${st.expiresAt}`, `  expires: ${st.expiresAt}`));
     if (isDocument) {
-      console.log(`  댓글(편집 제안) 허용: ${st.allowCommits ? '예' : '아니오'}`);
-      if (st.publicConfig?.skin) console.log(`  스킨: ${st.publicConfig.skin}`);
+      console.log(tr(`  댓글(편집 제안) 허용: ${st.allowCommits ? '예' : '아니오'}`, `  comments (edit suggestions) allowed: ${st.allowCommits ? 'yes' : 'no'}`));
+      if (st.publicConfig?.skin) console.log(tr(`  스킨: ${st.publicConfig.skin}`, `  skin: ${st.publicConfig.skin}`));
     } else {
-      if (st.hasPassword) console.log('  비밀번호 걸려 있음');
-      console.log(`  하위 문서도 공개: ${st.includeChildren ? '예' : '아니오'}`);
-      console.log(`  복제 허용: ${st.allowClone === false ? '아니오' : '예'}`);
+      if (st.hasPassword) console.log(tr('  비밀번호 걸려 있음', `  password protected`));
+      console.log(tr(`  하위 문서도 공개: ${st.includeChildren ? '예' : '아니오'}`, `  children published too: ${st.includeChildren ? 'yes' : 'no'}`));
+      console.log(tr(`  복제 허용: ${st.allowClone === false ? '아니오' : '예'}`, `  cloning allowed: ${st.allowClone === false ? 'no' : 'yes'}`));
       if (st.design && (st.design.layout || st.design.skin)) {
-        console.log(`  보이는 방식: ${st.design.layout ?? 'table'} / ${st.design.skin ?? 'clean'}`);
+        console.log(tr(`  보이는 방식: ${st.design.layout ?? 'table'} / ${st.design.skin ?? 'clean'}`, `  looks like: ${st.design.layout ?? 'table'} / ${st.design.skin ?? 'clean'}`));
       }
     }
     return;
@@ -1216,18 +1364,18 @@ async function cmdPublish(args) {
   if (args.off) {
     if (isDocument) await client.setDocumentPublic(id, { isPublic: false });
     else await client.setNodePublic(id, { isPublic: false });
-    console.log('공개를 닫았습니다. 딸려 나갔던 하위 문서도 같이 닫혔습니다(주소는 남아 있습니다).');
+    console.log(tr('공개를 닫았습니다. 딸려 나갔던 하위 문서도 같이 닫혔습니다(주소는 남아 있습니다).', `Publishing stopped. Children that came along were closed too (the addresses stay reserved).`));
     return;
   }
 
   if (isDocument) {
     if (args.skin !== undefined && !DOC_SKINS.includes(args.skin)) {
-      throw new Error(`--skin 은 다음 중 하나여야 합니다: ${DOC_SKINS.join(', ')}`);
+      throw new Error(tr(`--skin 은 다음 중 하나여야 합니다: ${DOC_SKINS.join(', ')}`, `--skin must be one of: ${DOC_SKINS.join(', ')}`));
     }
     const cur = await client.getDocumentPublicStatus(id);
     if (!cur.isPublic) {
       const res = await client.publishDocument(id);
-      console.log(`공개했습니다: /p/${res.slug}`);
+      console.log(tr(`공개했습니다: /p/${res.slug}`, `Published: /p/${res.slug}`));
     }
     const patch = {};
     const comments = flagToBool(args.comments);
@@ -1237,10 +1385,10 @@ async function cmdPublish(args) {
     if (Object.keys(patch).length) {
       await client.setDocumentPublic(id, patch);
       if (patch.allowCommits !== undefined) {
-        console.log(`  댓글(편집 제안) 허용: ${patch.allowCommits ? '예' : '아니오'}`);
+        console.log(tr(`  댓글(편집 제안) 허용: ${patch.allowCommits ? '예' : '아니오'}`, `  comments (edit suggestions) allowed: ${patch.allowCommits ? 'yes' : 'no'}`));
       }
-      if (patch.expiresAt !== undefined) console.log(`  만료: ${patch.expiresAt}`);
-      if (patch.skin !== undefined) console.log(`  스킨: ${patch.skin}`);
+      if (patch.expiresAt !== undefined) console.log(tr(`  만료: ${patch.expiresAt}`, `  expires: ${patch.expiresAt}`));
+      if (patch.skin !== undefined) console.log(tr(`  스킨: ${patch.skin}`, `  skin: ${patch.skin}`));
     }
     return;
   }
@@ -1251,20 +1399,20 @@ async function cmdPublish(args) {
     ...(typeof args.skin === 'string' ? { skin: args.skin } : {}),
   };
   if (design.layout && !DB_LAYOUTS.includes(design.layout)) {
-    throw new Error(`--layout 은 다음 중 하나여야 합니다: ${DB_LAYOUTS.join(', ')}`);
+    throw new Error(tr(`--layout 은 다음 중 하나여야 합니다: ${DB_LAYOUTS.join(', ')}`, `--layout must be one of: ${DB_LAYOUTS.join(', ')}`));
   }
   if (design.skin && !DB_SKINS.includes(design.skin)) {
-    throw new Error(`--skin 은 다음 중 하나여야 합니다: ${DB_SKINS.join(', ')}`);
+    throw new Error(tr(`--skin 은 다음 중 하나여야 합니다: ${DB_SKINS.join(', ')}`, `--skin must be one of: ${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('  이 문서 아래 전부(손자·증손자 포함)도 각자 주소로 공개됩니다.');
+  console.log(tr(`공개했습니다: /p/${res.slug}`, `Published: /p/${res.slug}`));
+  if (args.children) console.log(tr('  이 문서 아래 전부(손자·증손자 포함)도 각자 주소로 공개됩니다.', `  Everything under this document (grandchildren included) gets its own public address.`));
   if (Object.keys(design).length) {
-    console.log(`  보이는 방식: ${res.design?.layout ?? 'table'} / ${res.design?.skin ?? 'clean'}`);
+    console.log(tr(`  보이는 방식: ${res.design?.layout ?? 'table'} / ${res.design?.skin ?? 'clean'}`, `  looks like: ${res.design?.layout ?? 'table'} / ${res.design?.skin ?? 'clean'}`));
   }
 }
 
@@ -1278,7 +1426,7 @@ 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',
+      usage(`rootr readreq <path|id> [--json] | --users <id,id> [--due <ISO>] [--ack] | --clear`),
     );
   }
   const client = makeClient();
@@ -1286,19 +1434,19 @@ async function cmdReadReq(args) {
 
   if (args.clear) {
     await client.clearReadRequirement(id);
-    console.log('읽음 확인 해제됨');
+    console.log(tr('읽음 확인 해제됨', `Read requirement cleared`));
     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를 쉼표로 주세요.');
+    if (!userIds.length) throw new Error(tr('--users 에 사람 id를 쉼표로 주세요.', `Pass user ids to --users, comma separated.`));
     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 ? ' (확인 버튼까지 눌러야 함)' : ''}`);
+    console.log(tr(`읽어야 할 사람 ${userIds.length}명 지정됨${args.ack ? ' (확인 버튼까지 눌러야 함)' : ''}`, `${userIds.length} people must read it${args.ack ? ' (they must press the acknowledge button too)' : ''}`));
     if (args.json) console.log(JSON.stringify(res, null, 2));
     return;
   }
@@ -1311,19 +1459,19 @@ async function cmdReadReq(args) {
   if (!res.requirement) {
     console.log(
       res.ancestorRequirementId
-        ? `이 문서 자체에는 없고, 위쪽(${res.ancestorRequirementId})에 걸려 있습니다.`
-        : '읽음 확인이 걸려 있지 않습니다.',
+        ? tr(`이 문서 자체에는 없고, 위쪽(${res.ancestorRequirementId})에 걸려 있습니다.`, `Not on this document — it is set higher up (${res.ancestorRequirementId}).`)
+        : tr('읽음 확인이 걸려 있지 않습니다.', `No read requirement is set.`),
     );
     return;
   }
   const r = res.requirement;
   console.log(
-    `${r.done}/${r.total}명 완료` +
-      ` · 마감: ${r.dueAt ?? '없음'}${r.overdue ? ' (지남)' : ''}` +
-      `${r.requireExplicitAck ? ' · 확인 버튼 필요' : ''}`,
+    tr(`${r.done}/${r.total}명 완료`, `${r.done}/${r.total} done`) +
+      tr(` · 마감: ${r.dueAt ?? '없음'}${r.overdue ? ' (지남)' : ''}`, ` · due: ${r.dueAt ?? 'none'}${r.overdue ? ' (overdue)' : ''}`) +
+      tr(`${r.requireExplicitAck ? ' · 확인 버튼 필요' : ''}`, `${r.requireExplicitAck ? ' · acknowledge button required' : ''}`),
   );
   for (const target of r.targets ?? []) {
-    const mark = target.ackedAt ? '확인' : target.firstViewedAt ? '읽음' : '아직';
+    const mark = target.ackedAt ? tr('확인', `acknowledged`) : target.firstViewedAt ? tr('읽음', `read`) : tr('아직', `not yet`);
     // 표·폴더에 걸었으면 "안의 문서를 몇 개 읽었나"가 진짜 진도다.
     const progress =
       r.childTotal > 0 ? ` ${target.readCount ?? 0}/${r.childTotal}` : '';
@@ -1355,7 +1503,7 @@ async function cmdDb(args) {
   if (sub === 'view') return cmdDbView(args);
   if (sub !== 'create') {
     throw new Error(
-      '사용법: rootr db create|rows|row-add|rows-new|row-body|rows-set|rows-each|rows-rm|row-page|row-page-type|lock|notify|buttons|button-run|view … (자세한 건 rootr --help)',
+      usage(tr(`rootr db create|rows|row-add|rows-new|row-body|rows-set|rows-each|rows-rm|row-page|row-page-type|lock|notify|buttons|button-run|view … (자세한 건 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|buttons|button-run|view … (see rootr --help)`)),
     );
   }
   const raw = typeof args.file === 'string' ? readFileSync(args.file, 'utf8') : await readStdin();
@@ -1363,25 +1511,25 @@ async function cmdDb(args) {
   try {
     spec = JSON.parse(raw);
   } catch {
-    throw new Error('스펙을 JSON으로 읽을 수 없습니다. { "name": "...", "properties": [...] } 형태여야 합니다.');
+    throw new Error(tr('스펙을 JSON으로 읽을 수 없습니다. { "name": "...", "properties": [...] } 형태여야 합니다.', `Could not read the spec as JSON. It must look like { "name": "...", "properties": [...] }.`));
   }
-  if (!spec.name && !spec.path) throw new Error('스펙에 name 또는 path가 있어야 합니다.');
+  if (!spec.name && !spec.path) throw new Error(tr('스펙에 name 또는 path가 있어야 합니다.', `The spec needs a name or a path.`));
 
   const client = makeClient();
   let parentId = spec.parentId;
   if (typeof args.parent === 'string') {
     const resolved = await resolveTarget(client, args.parent);
-    if (!resolved.existed) throw new Error(`부모를 찾을 수 없습니다: ${args.parent}`);
+    if (!resolved.existed) throw new Error(tr(`부모를 찾을 수 없습니다: ${args.parent}`, `Parent not found: ${args.parent}`));
     parentId = resolved.id;
   }
   const ws = args.ws || client.workspace;
-  if (!ws) throw new Error('워크스페이스를 알 수 없습니다. --ws 를 주거나 rootr use 로 정하세요.');
+  if (!ws) throw new Error(tr('워크스페이스를 알 수 없습니다. --ws 를 주거나 rootr use 로 정하세요.', `No workspace. Pass --ws, or pick one with rootr use.`));
 
   const db = await client.createDatabase(ws, { ...spec, parentId });
   const cols = (db.properties || []).map((p) => p.name).join(', ');
-  console.log(`표 생성: ${db.path ?? db.name}  (${db.id})`);
-  if (cols) console.log(`컬럼 순서: ${cols}`);
-  if (typeof db.rowCount === 'number') console.log(`행: ${db.rowCount}개`);
+  console.log(tr(`표 생성: ${db.path ?? db.name}  (${db.id})`, `Table created: ${db.path ?? db.name}  (${db.id})`));
+  if (cols) console.log(tr(`컬럼 순서: ${cols}`, `Column order: ${cols}`));
+  if (typeof db.rowCount === 'number') console.log(tr(`행: ${db.rowCount}개`, `Rows: ${db.rowCount}`));
 }
 
 /** 표의 행 목록. --body 를 주면 행마다 상세 내용(본문 메모)까지 가져온다. */
@@ -1392,7 +1540,7 @@ async function cmdDb(args) {
  */
 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 "승인,점수"]');
+  if (!target) throw new Error(usage(tr(`rootr db lock <path|id> [--schema managers|open] [--rows own|all] [--locked "승인,점수"]`, `rootr db lock <path|id> [--schema managers|open] [--rows own|all] [--locked "Approved,Score"]`)));
 
   const client = makeClient();
   const id = requireResolved(await resolveTarget(client, target));
@@ -1415,9 +1563,9 @@ async function cmdDbLock(args) {
     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(', ') : '없음'}`);
+  console.log(tr(`칸·뷰 잠금: ${result.schemaLock === 'managers' ? '관리자만' : '누구나'}`, `Columns & views locked: ${result.schemaLock === 'managers' ? 'managers only' : 'anyone'}`));
+  console.log(tr(`행 보기   : ${result.rowScope === 'own' ? '본인이 만든 행만' : '전부'}`, `Row visibility : ${result.rowScope === 'own' ? 'only rows you created' : 'all'}`));
+  console.log(tr(`잠긴 칸   : ${(result.lockedProps ?? []).length ? result.lockedProps.join(', ') : '없음'}`, `Locked columns : ${(result.lockedProps ?? []).length ? result.lockedProps.join(', ') : 'none'}`));
 }
 
 /**
@@ -1428,21 +1576,21 @@ async function cmdDbLock(args) {
  */
 async function cmdDbNotify(args) {
   const target = args._[1];
-  if (!target) throw new Error('사용법: rootr db notify <path|id> [--file rules.json] [--clear] [--json]');
+  if (!target) throw new Error(usage(`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('알림 규칙을 모두 지웠습니다.');
+    console.log(tr('알림 규칙을 모두 지웠습니다.', `All notification rules cleared.`));
     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}개를 저장했습니다.`);
+    console.log(tr(`알림 규칙 ${saved.watchers.length}개를 저장했습니다.`, `Saved ${saved.watchers.length} notification rules.`));
     if (args.json) console.log(JSON.stringify(saved, null, 2));
     return;
   }
@@ -1453,19 +1601,19 @@ async function cmdDbNotify(args) {
     return;
   }
   if (!watchers.length) {
-    console.log('알림 규칙이 없습니다.');
+    console.log(tr('알림 규칙이 없습니다.', `No notification rules.`));
     return;
   }
-  const WHEN = { created: '행 추가', updated: '행 수정', deleted: '행 삭제' };
+  const WHEN = { created: tr('행 추가', `row added`), updated: tr('행 수정', `row changed`), deleted: tr('행 삭제', `row 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} 칸이 바뀌었을 때만)`
+        ? tr(` (${f.propId} 칸이 바뀌었을 때만)`, ` (only when the ${f.propId} column changes)`)
         : ` (${f.propId} ${f.op === 'is' ? '=' : '⊃'} ${f.value})`
       : '';
-    console.log(`- ${when}${only} → ${(w.userIds ?? []).length}명`);
+    console.log(tr(`- ${when}${only} → ${(w.userIds ?? []).length}명`, `- ${when}${only} → ${(w.userIds ?? []).length} people`));
   }
 }
 
@@ -1478,7 +1626,7 @@ async function cmdDbNotify(args) {
  */
 async function cmdDbView(args) {
   const target = args._[1];
-  if (!target) throw new Error('사용법: rootr db view <path|id> [뷰이름] [--scale week|month|year] [--name 새이름] [--json]');
+  if (!target) throw new Error(usage(tr(`rootr db view <path|id> [뷰이름] [--scale week|month|year] [--name 새이름] [--json]`, `rootr db view <path|id> [view name] [--scale week|month|year] [--name <new name>] [--json]`)));
 
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
@@ -1492,12 +1640,12 @@ async function cmdDbView(args) {
       return;
     }
     if (!views.length) {
-      console.log('뷰가 없습니다.');
+      console.log(tr('뷰가 없습니다.', `No views.`));
       return;
     }
-    const SPAN = { week: '주', month: '달', year: '해' };
+    const SPAN = { week: tr('주', `week`), month: tr('달', `month`), year: tr('해', `year`) };
     for (const v of views) {
-      const span = v.type === 'calendar' ? ` · ${SPAN[v.config?.calendarScale] ?? '달'} 단위` : '';
+      const span = v.type === 'calendar' ? ` · ${SPAN[v.config?.calendarScale] ?? tr('달', `month`)} 단위` : '';
       console.log(`- ${v.name} (${v.type})${span}  ${v.id}`);
     }
     return;
@@ -1507,13 +1655,13 @@ async function cmdDbView(args) {
   if (args.scale !== undefined) {
     const scale = String(args.scale);
     if (!['week', 'month', 'year'].includes(scale)) {
-      throw new Error('--scale 은 week · month · year 중 하나여야 합니다.');
+      throw new Error(tr('--scale 은 week · month · year 중 하나여야 합니다.', `--scale must be one of week · month · year.`));
     }
     patch.calendarScale = scale;
   }
   if (typeof args.name === 'string') patch.name = args.name;
   if (!Object.keys(patch).length) {
-    throw new Error('바꿀 것을 주세요: --scale week|month|year 또는 --name 새이름');
+    throw new Error(tr('바꿀 것을 주세요: --scale week|month|year 또는 --name 새이름', `Give something to change: --scale week|month|year, or --name <new name>`));
   }
 
   const view = await client.updateDatabaseView(id, viewRef, patch);
@@ -1521,9 +1669,9 @@ async function cmdDbView(args) {
     console.log(JSON.stringify(view, null, 2));
     return;
   }
-  const SPAN = { week: '주', month: '달', year: '해' };
-  const span = view.type === 'calendar' ? ` · ${SPAN[view.config?.calendarScale] ?? '달'} 단위` : '';
-  console.log(`뷰를 고쳤습니다: ${view.name} (${view.type})${span}`);
+  const SPAN = { week: tr('주', `week`), month: tr('달', `month`), year: tr('해', `year`) };
+  const span = view.type === 'calendar' ? ` · ${SPAN[view.config?.calendarScale] ?? tr('달', `month`)} 단위` : '';
+  console.log(tr(`뷰를 고쳤습니다: ${view.name} (${view.type})${span}`, `View updated: ${view.name} (${view.type})${span}`));
 }
 
 
@@ -1540,14 +1688,14 @@ async function cmdDbView(args) {
  */
 async function cmdDbButtons(args) {
   const target = args._[1];
-  if (!target) throw new Error('사용법: rootr db buttons <path|id> [--file buttons.json] [--clear] [--json]');
+  if (!target) throw new Error(usage(`rootr db buttons <path|id> [--file buttons.json] [--clear] [--json]`));
 
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
 
   if (args.clear) {
     const cleared = await client.setDatabaseButtons(id, []);
-    console.log('버튼을 모두 지웠습니다.');
+    console.log(tr('버튼을 모두 지웠습니다.', `All buttons cleared.`));
     if (args.json) console.log(JSON.stringify(cleared, null, 2));
     return;
   }
@@ -1557,11 +1705,11 @@ async function cmdDbButtons(args) {
     try {
       buttons = JSON.parse(raw);
     } catch {
-      throw new Error('버튼 파일을 JSON으로 읽을 수 없습니다. [{ "label": "...", "steps": [...] }] 형태여야 합니다.');
+      throw new Error(tr('버튼 파일을 JSON으로 읽을 수 없습니다. [{ "label": "...", "steps": [...] }] 형태여야 합니다.', `Could not read the button file as JSON. It must look like [{ "label": "...", "steps": [...] }].`));
     }
-    if (!Array.isArray(buttons)) throw new Error('버튼 파일은 배열이어야 합니다(버튼 목록 전체).');
+    if (!Array.isArray(buttons)) throw new Error(tr('버튼 파일은 배열이어야 합니다(버튼 목록 전체).', `The button file must be an array (the whole button list).`));
     const saved = await client.setDatabaseButtons(id, buttons);
-    console.log(`버튼 ${saved.buttons.length}개를 저장했습니다.`);
+    console.log(tr(`버튼 ${saved.buttons.length}개를 저장했습니다.`, `Saved ${saved.buttons.length} buttons.`));
     if (args.json) console.log(JSON.stringify(saved, null, 2));
     return;
   }
@@ -1572,16 +1720,16 @@ async function cmdDbButtons(args) {
     return;
   }
   if (!buttons.length) {
-    console.log('버튼이 없습니다.');
+    console.log(tr('버튼이 없습니다.', `No buttons.`));
     return;
   }
   const WHAT = {
-    add_row: '행 만들기',
-    update_rows: '값 바꾸기',
-    ai_fill: 'AI로 칸 채우기',
-    open_row: '만든 행 열기',
+    add_row: tr('행 만들기', `create rows`),
+    update_rows: tr('값 바꾸기', `change values`),
+    ai_fill: tr('AI로 칸 채우기', `fill a column with AI`),
+    open_row: tr('만든 행 열기', `open the created row`),
   };
-  const WHERE = { created: '방금 만든 행', selected: '고른 행' };
+  const WHERE = { created: tr('방금 만든 행', `the row just created`), selected: tr('고른 행', `the chosen rows`) };
   for (const b of buttons) {
     console.log(`${b.icon ? b.icon + ' ' : ''}${b.label}  (${b.id})`);
     for (const [i, st] of (b.steps ?? []).entries()) {
@@ -1589,7 +1737,7 @@ async function cmdDbButtons(args) {
       const where = st.target ? ` · ${WHERE[st.target] ?? st.target}` : '';
       const detail =
         st.kind === 'ai_fill'
-          ? ` · ${st.propId} 칸 ← "${st.prompt}"`
+          ? tr(` · ${st.propId} 칸 ← "${st.prompt}"`, ` · column ${st.propId} ← "${st.prompt}"`)
           : st.values
             ? ' · ' + Object.entries(st.values).map(([k, v]) => `${k}=${v}`).join(', ')
             : '';
@@ -1597,7 +1745,7 @@ async function cmdDbButtons(args) {
     }
   }
   if (myLevel && myLevel !== 'MANAGE' && myLevel !== 'FULL') {
-    console.log('\n(버튼을 고치려면 이 표의 관리 권한이 필요합니다. 누르는 것은 지금 권한으로도 됩니다.)');
+    console.log(tr('\n(버튼을 고치려면 이 표의 관리 권한이 필요합니다. 누르는 것은 지금 권한으로도 됩니다.)', `\n(Changing buttons needs MANAGE on this table. Pressing them works with your current permission.)`));
   }
 }
 
@@ -1611,7 +1759,7 @@ async function cmdDbButtonRun(args) {
   const target = args._[1];
   const buttonId = args._[2];
   if (!target || !buttonId) {
-    throw new Error('사용법: rootr db button-run <path|id> <buttonId> [--rows id1,id2] [--json]');
+    throw new Error(usage(`rootr db button-run <path|id> <buttonId> [--rows id1,id2] [--json]`));
   }
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
@@ -1628,19 +1776,25 @@ async function cmdDbButtonRun(args) {
   // created 는 **만든 행의 id 목록**이다(개수가 아니다) — 세어서 보여 준다.
   const madeCount = Array.isArray(r.created) ? r.created.length : (r.created ?? 0);
   const parts = [];
-  if (madeCount) parts.push(`행 ${madeCount}개 만듦`);
-  if (r.updated) parts.push(`행 ${r.updated}개 고침`);
-  if (r.filled) parts.push(`AI로 칸 ${r.filled}개 채움`);
-  console.log(parts.length ? parts.join(' · ') : '바뀐 것이 없습니다.');
-  if (r.openRowId) console.log(`열 행: ${r.openRowId}`);
+  if (madeCount) parts.push(tr(`행 ${madeCount}개 만듦`, `${madeCount} rows created`));
+  if (r.updated) parts.push(tr(`행 ${r.updated}개 고침`, `${r.updated} rows changed`));
+  if (r.filled) parts.push(tr(`AI로 칸 ${r.filled}개 채움`, `${r.filled} columns filled by AI`));
+  console.log(parts.length ? parts.join(' · ') : tr('바뀐 것이 없습니다.', `Nothing changed.`));
+  if (r.openRowId) console.log(tr(`열 행: ${r.openRowId}`, `Row to open: ${r.openRowId}`));
   // AI가 못 채워도 버튼은 계속 돈다 — 조용히 넘어가면 사람이 왜 빈칸인지 모른다.
-  if (r.aiFailed) console.log(`AI가 못 채운 칸 ${r.aiFailed}개${r.aiError ? ` — ${r.aiError}` : ''}`);
+  if (r.aiFailed)
+    console.log(
+      tr(
+        `AI가 못 채운 칸 ${r.aiFailed}개${r.aiError ? ` — ${r.aiError}` : ''}`,
+        `${r.aiFailed} columns the AI could not fill${r.aiError ? ` — ${r.aiError}` : ''}`,
+      ),
+    );
 }
 
 
 async function cmdDbRows(args) {
   const target = args._[1];
-  if (!target) throw new Error('사용법: rootr db rows <path|id> [--body] [--backlinks] [--json]');
+  if (!target) throw new Error(usage(`rootr db rows <path|id> [--body] [--backlinks] [--json]`));
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
   const rows = await client.listRows(id, { withBody: !!args.body, backlinks: !!args.backlinks });
@@ -1669,13 +1823,13 @@ async function cmdDbRows(args) {
 async function cmdDbRowAdd(args) {
   const target = args._[1];
   if (!target || typeof args.values !== 'string') {
-    throw new Error("사용법: rootr db row-add <path|id> --values '{\"제목\":\"...\"}' [--body <md>|--body-file <f>]");
+    throw new Error("사용법: rootr db row-add <path|id> --values tr('{\"제목\":\"...\"}', `{\"Title\":\"...\"}`) [--body <md>|--body-file <f>]");
   }
   let values;
   try {
     values = JSON.parse(args.values);
   } catch {
-    throw new Error('--values 는 JSON이어야 합니다. 예: --values \'{"제목":"킥오프"}\'');
+    throw new Error(tr('--values 는 JSON이어야 합니다. 예: --values \'{"제목":"킥오프"}\'', `--values must be JSON. Example: --values '{"Title":"Kickoff"}'`));
   }
   const body =
     typeof args['body-file'] === 'string'
@@ -1686,8 +1840,8 @@ async function cmdDbRowAdd(args) {
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
   const row = await client.createRow(id, { values, body });
-  console.log(`행 추가: ${row.id}`);
-  if (row.pageNodeId) console.log(`상세 내용 문서: ${row.pageNodeId}`);
+  console.log(tr(`행 추가: ${row.id}`, `Row added: ${row.id}`));
+  if (row.pageNodeId) console.log(tr(`상세 내용 문서: ${row.pageNodeId}`, `Row body document: ${row.pageNodeId}`));
 }
 
 /** 행의 상세 내용(본문 메모)을 통째로 쓴다. 내용은 인자·--file·표준입력 순으로 받는다. */
@@ -1695,7 +1849,7 @@ async function cmdDbRowBody(args) {
   const target = args._[1];
   const rowId = args._[2];
   if (!target || !rowId) {
-    throw new Error('사용법: rootr db row-body <path|id> <rowId> [<본문>] [--file <f>]');
+    throw new Error(usage(tr(`rootr db row-body <path|id> <rowId> [<본문>] [--file <f>]`, `rootr db row-body <path|id> <rowId> [<body>] [--file <f>]`)));
   }
   const body =
     typeof args.file === 'string'
@@ -1703,11 +1857,16 @@ async function cmdDbRowBody(args) {
       : args._[3] !== undefined
         ? String(args._[3])
         : await readStdin();
-  if (!body) throw new Error('쓸 내용이 없습니다 (본문 인자, --file, 또는 표준입력 필요).');
+  if (!body) throw new Error(tr('쓸 내용이 없습니다 (본문 인자, --file, 또는 표준입력 필요).', `Nothing to write (needs a body argument, --file, or stdin).`));
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
   const row = await client.updateRow(id, rowId, { body });
-  console.log(`상세 내용 저장: 행 ${rowId}${row.pageNodeId ? ` → 문서 ${row.pageNodeId}` : ''}`);
+  console.log(
+    tr(
+      `상세 내용 저장: 행 ${rowId}${row.pageNodeId ? ` → 문서 ${row.pageNodeId}` : ''}`,
+      `Row body saved: row ${rowId}${row.pageNodeId ? ` → document ${row.pageNodeId}` : ''}`,
+    ),
+  );
 }
 
 /**
@@ -1720,7 +1879,7 @@ async function cmdDbRowPage(args) {
   const rowId = args._[1];
   if (!rowId) {
     throw new Error(
-      '사용법: rootr db row-page <rowId> [--type RECORDING | --node <path|id> | --unlink]',
+      usage(`rootr db row-page <rowId> [--type RECORDING | --node <path|id> | --unlink]`),
     );
   }
   const client = makeClient();
@@ -1728,28 +1887,28 @@ async function cmdDbRowPage(args) {
   // ROW-PAGE-LINK — 연결만 끊는다. 문서는 그대로 남는다.
   if (args.unlink) {
     const res = await client.unlinkRowPage(rowId);
-    console.log(res.unlinked ? `연결을 끊었습니다(문서 ${res.unlinked}는 그대로 있습니다).` : '붙어 있는 문서가 없습니다.');
+    console.log(res.unlinked ? tr(`연결을 끊었습니다(문서 ${res.unlinked}는 그대로 있습니다).`, `Unlinked (document ${res.unlinked} is still there).`) : tr('붙어 있는 문서가 없습니다.', `No document is attached.`));
     return;
   }
 
   // ROW-PAGE-LINK — 이미 있는 문서를 잇는다. 경로로 줘도 된다.
   if (typeof args.node === 'string') {
     if (typeof args.type === 'string') {
-      throw new Error('--type 과 --node 는 같이 못 씁니다. 새로 만들려면 --type, 있는 문서를 이으려면 --node 하나만 주세요.');
+      throw new Error(tr('--type 과 --node 는 같이 못 씁니다. 새로 만들려면 --type, 있는 문서를 이으려면 --node 하나만 주세요.', `--type and --node cannot be used together. Use --type to create one, or --node to attach an existing document.`));
     }
     const resolved = await resolveTarget(client, args.node);
-    if (!resolved.existed) throw new Error(`이을 문서를 찾을 수 없습니다: ${args.node}`);
+    if (!resolved.existed) throw new Error(tr(`이을 문서를 찾을 수 없습니다: ${args.node}`, `Could not find the document to attach: ${args.node}`));
     const linked = await client.linkRowPage(rowId, resolved.id);
-    console.log(`행 ${rowId}에 이었습니다: ${linked.type ?? ''} ${linked.nodeId}`.trim());
+    console.log(tr(`행 ${rowId}에 이었습니다: ${linked.type ?? ''} ${linked.nodeId}`, `Attached to row ${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(' · ')} 중 하나여야 합니다.`);
+    throw new Error(tr(`--type 은 ${ROW_PAGE_TYPES.join(' · ')} 중 하나여야 합니다.`, `--type must be one of ${ROW_PAGE_TYPES.join(' · ')}.`));
   }
   const page = await client.createRowPage(rowId, type);
-  console.log(`행 ${rowId} 상세: ${page.type ?? ''} ${page.nodeId}`.trim());
+  console.log(tr(`행 ${rowId} 상세: ${page.type ?? ''} ${page.nodeId}`, `Row ${rowId} detail: ${page.type ?? ''} ${page.nodeId}`).trim());
 }
 
 /** `rootr db row-page-type <path|id> <TYPE>` — 새 행의 기본값을 바꾼다. */
@@ -1757,22 +1916,22 @@ 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('|')}>`);
+    throw new Error(usage(`rootr db row-page-type <path|id> <${ROW_PAGE_TYPES.join('|')}>`));
   }
   if (!ROW_PAGE_TYPES.includes(type)) {
-    throw new Error(`타입은 ${ROW_PAGE_TYPES.join(' · ')} 중 하나여야 합니다.`);
+    throw new Error(tr(`타입은 ${ROW_PAGE_TYPES.join(' · ')} 중 하나여야 합니다.`, `The type must be one of ${ROW_PAGE_TYPES.join(' · ')}.`));
   }
   const client = makeClient();
   const id = await resolveDatabaseId(client, target);
   await client.setDatabaseRowPageType(id, type);
-  console.log(`새 행 기본값: ${type} — 이미 만들어진 행은 그대로입니다.`);
+  console.log(tr(`새 행 기본값: ${type} — 이미 만들어진 행은 그대로입니다.`, `Default for new rows: ${type} — existing rows are untouched.`));
 }
 
 /** 경로로 줘도 되게 — 표 인자도 문서 도구들과 같은 규칙을 따른다. */
 async function resolveDatabaseId(client, target) {
   if (typeof target === 'string' && target.startsWith('/')) {
     const resolved = await resolveTarget(client, target);
-    if (!resolved.existed) throw new Error(`표를 찾을 수 없습니다: ${target}`);
+    if (!resolved.existed) throw new Error(tr(`표를 찾을 수 없습니다: ${target}`, `Table not found: ${target}`));
     return resolved.id;
   }
   return target;
@@ -1786,12 +1945,12 @@ async function resolveDatabaseId(client, target) {
 // 읽은 값을 `--code`로 넘긴다.
 
 const SIGN_USAGE =
-  '사용법: rootr sign new|show|line|code|submit|approve|reject|reopen|revise|verify|list|bulk|ledger …\n' +
-  '       (자세한 건 rootr --help)';
+  usage(`rootr sign new|show|line|code|submit|approve|reject|reopen|revise|verify|list|bulk|ledger …\n`) +
+  tr('       (자세한 건 rootr --help)', `       (see rootr --help)`);
 
 function signWorkspace(client, args) {
   const ws = args.ws || client.workspace;
-  if (!ws) throw new Error('워크스페이스를 알 수 없습니다. --ws 를 주거나 rootr use 로 정하세요.');
+  if (!ws) throw new Error(tr('워크스페이스를 알 수 없습니다. --ws 를 주거나 rootr use 로 정하세요.', `No workspace. Pass --ws, or pick one with rootr use.`));
   return ws;
 }
 
@@ -1804,49 +1963,60 @@ async function resolveSignedId(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자리> 로 넘기세요.`,
+      tr(`${what}에는 확인 코드가 필요합니다: 먼저 rootr sign code <path|id> 로 메일을 받고 --code <6자리> 로 넘기세요.`, `${what} needs a confirmation code: run rootr sign code <path|id> to get one by email, then pass --code <6 digits>.`),
     );
   }
   return args.code.trim();
 }
 
 const SIGN_STATUS_KO = {
-  DRAFT: '작성 중',
-  IN_PROGRESS: '서명 진행 중',
-  COMPLETED: '완료',
-  REJECTED: '반려됨',
-  SUPERSEDED: '개정되어 대체됨',
-  VOIDED: '무효',
+  DRAFT: tr('작성 중', `draft`),
+  IN_PROGRESS: tr('서명 진행 중', `signing in progress`),
+  COMPLETED: tr('완료', `complete`),
+  REJECTED: tr('반려됨', `rejected`),
+  SUPERSEDED: tr('개정되어 대체됨', `superseded by a revision`),
+  VOIDED: tr('무효', `void`),
 };
 
 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 로 확인하세요.');
+  console.log(tr(`${st.name}  [${SIGN_STATUS_KO[st.status] ?? st.status}]${st.mode === 'RESEARCH_NOTE' ? '  (연구노트)' : ''}`, `${st.name}  [${SIGN_STATUS_KO[st.status] ?? st.status}]${st.mode === 'RESEARCH_NOTE' ? '  (research note)' : ''}`));
+  if (st.revisionNo)
+    console.log(
+      tr(
+        `개정 ${st.revisionNo}판${st.revisionNote ? ` — ${st.revisionNote}` : ''}`,
+        `revision ${st.revisionNo}${st.revisionNote ? ` — ${st.revisionNote}` : ''}`,
+      ),
+    );
+  if (st.latestRevisionId) console.log(tr(`※ 더 최신 판이 있습니다: ${st.latestRevisionId} (${st.latestRevisionNo}판)`, `※ A newer revision exists: ${st.latestRevisionId} (rev ${st.latestRevisionNo})`));
+  console.log(st.lockedAt ? tr(`잠김: ${st.lockedAt} (본문·결재라인 수정 불가)`, `Frozen: ${st.lockedAt} (body and approval line can no longer change)`) : tr('잠기지 않음 (아직 고칠 수 있음)', `Not frozen (still editable)`));
+  if (!st.contentIntact) console.log(tr('⚠️ 본문이 서명 당시와 다릅니다 — rootr sign verify 로 확인하세요.', `⚠️ The body differs from what was signed — check it with 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}명` : '전원';
+    const here = step.order === st.currentStepOrder ? tr(' ← 지금 이 차례', ` ← your turn`) : '';
+    const rule = step.rule === 'ANY' ? tr('아무나 1명', `any 1 person`) : step.rule === 'N_OF_M' ? tr(`${step.requiredCount}명`, `${step.requiredCount} people`) : tr('전원', `everyone`);
     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' ? '  [요청 메일 아직 안 감]' : '';
+      const who =
+        m.userId ??
+        tr(
+          `${m.displayName ? `${m.displayName} <${m.email}>` : m.email} (메일 서명)`,
+          `${m.displayName ? `${m.displayName} <${m.email}>` : m.email} (signs by email)`,
+        );
+      const sent = !m.userId && !m.invitedAt && m.state === 'PENDING' ? tr('  [요청 메일 아직 안 감]', `  [request email not sent yet]`) : '';
       console.log(`   - ${who}  ${m.role}  ${m.state}${m.actedAt ? `  ${m.actedAt}` : ''}${sent}${m.comment ? `  "${m.comment}"` : ''}`);
     }
   }
   if (st.signatures?.length) {
-    console.log('\n서명:');
+    console.log(tr('\n서명:', `\nSignatures:`));
     for (const sig of st.signatures) {
       console.log(
         `   #${sig.seq} ${sig.signerName} <${sig.signerEmail}> ${sig.role}  ${sig.signedAt}` +
-          (sig.timestampPending ? '  [시점확인 대기중]' : `  [시점확인 ${sig.tsTime} · ${sig.tsaName}]`),
+          (sig.timestampPending ? tr('  [시점확인 대기중]', `  [timestamp pending]`) : tr(`  [시점확인 ${sig.tsTime} · ${sig.tsaName}]`, `  [timestamped ${sig.tsTime} · ${sig.tsaName}]`)),
       );
     }
   }
-  if (st.canSign) console.log('\n→ 지금 서명할 수 있습니다: rootr sign code <id> 후 rootr sign approve <id> --code <6자리>');
+  if (st.canSign) console.log(tr('\n→ 지금 서명할 수 있습니다: rootr sign code <id> 후 rootr sign approve <id> --code <6자리>', `\n→ You can sign now: rootr sign code <id>, then rootr sign approve <id> --code <6 digits>`));
 }
 
 async function cmdSign(args) {
@@ -1856,7 +2026,7 @@ async function cmdSign(args) {
   switch (sub) {
     case 'new': {
       const target = args._[1];
-      if (!target) throw new Error('사용법: rootr sign new <경로> [--file <본문.md>] [--reviewer <userId>] [--line <line.json>]');
+      if (!target) throw new Error(usage(tr(`rootr sign new <경로> [--file <본문.md>] [--reviewer <userId>] [--line <line.json>]`, `rootr sign new <path> [--file <body.md>] [--reviewer <userId>] [--line <line.json>]`)));
       const ws = signWorkspace(client, args);
       const content =
         typeof args.file === 'string'
@@ -1878,9 +2048,9 @@ async function cmdSign(args) {
       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})`);
+      console.log(tr(`서명문서 생성: ${st.path ?? st.name}  (${st.nodeId})`, `Signed document created: ${st.path ?? st.name}  (${st.nodeId})`));
       if (!st.steps?.length) {
-        console.log('결재라인이 아직 없습니다 — rootr sign line <id> --file <line.json> 으로 짜세요.');
+        console.log(tr('결재라인이 아직 없습니다 — rootr sign line <id> --file <line.json> 으로 짜세요.', `No approval line yet — build one with rootr sign line <id> --file <line.json>.`));
       } else {
         printSignedState(st);
       }
@@ -1894,22 +2064,22 @@ async function cmdSign(args) {
     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 또는 표준입력).');
+      if (!raw) throw new Error(tr('결재라인 JSON이 없습니다 (--file 또는 표준입력).', `No approval-line JSON (use --file or stdin).`));
       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}단계 저장됨.`);
+      console.log(tr(`결재라인 ${st.steps.length}단계 저장됨.`, `Approval line saved: ${st.steps.length} steps.`));
       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 로 넘기세요.`);
+        console.log(tr(`묶음 서명용 확인 코드를 ${out.sentTo ?? '메일'}로 보냈습니다. 10분 안에 --code 로 넘기세요.`, `A confirmation code for bulk signing was sent to ${out.sentTo ?? 'your email'}. Pass it with --code within 10 minutes.`));
         return;
       }
       const out = await client.requestSigningCode(await resolveSignedId(client, args._[1]));
-      console.log(`확인 코드를 ${out.sentTo ?? '메일'}로 보냈습니다. 10분 안에 --code 로 넘기세요.`);
+      console.log(tr(`확인 코드를 ${out.sentTo ?? '메일'}로 보냈습니다. 10분 안에 --code 로 넘기세요.`, `A confirmation code was sent to ${out.sentTo ?? 'your email'}. Pass it with --code within 10 minutes.`));
       return;
     }
     case 'submit': {
@@ -1925,47 +2095,47 @@ async function cmdSign(args) {
       } catch (err) {
         if (String(err?.body?.code ?? '') === 'REAUTH_REQUIRED') {
           throw new Error(
-            '올리는 분이 1단계 서명자라 첫 서명이 함께 찍힙니다. ' +
-              `먼저 "rootr sign code ${args._[1]}" 로 메일을 받고 --code <6자리> 로 다시 넘기세요.`,
+            tr('올리는 분이 1단계 서명자라 첫 서명이 함께 찍힙니다. ', `You are the first signer, so your signature is applied together with the submission. `) +
+              tr(`먼저 "rootr sign code ${args._[1]}" 로 메일을 받고 --code <6자리> 로 다시 넘기세요.`, `Run "rootr sign code ${args._[1]}" first to get the email, then pass --code <6 digits>.`),
           );
         }
         throw err;
       }
       console.log(
         code
-          ? '올렸습니다 — 본문이 얼었고 기안자 서명이 찍혔습니다.'
-          : '올렸습니다 — 본문이 얼었고 첫 단계 서명자에게 차례가 넘어갔습니다.',
+          ? tr('올렸습니다 — 본문이 얼었고 기안자 서명이 찍혔습니다.', `Submitted — the body is frozen and the author's signature is on it.`)
+          : tr('올렸습니다 — 본문이 얼었고 첫 단계 서명자에게 차례가 넘어갔습니다.', `Submitted — the body is frozen and it is now the first signer's turn.`),
       );
       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('서명했습니다.');
+      const st = await client.signSignedDoc(id, { code: requireCode(args, tr('서명', `signing`)) });
+      console.log(tr('서명했습니다.', `Signed.`));
       return printSignedState(st);
     }
     case 'reject': {
       const id = await resolveSignedId(client, args._[1]);
       if (typeof args.comment !== 'string' || !args.comment.trim()) {
-        throw new Error('반려에는 사유가 필요합니다: --comment "근거 자료가 빠졌습니다"');
+        throw new Error(tr('반려에는 사유가 필요합니다: --comment "근거 자료가 빠졌습니다"', `Rejecting needs a reason: --comment "supporting data is missing"`));
       }
       const st = await client.rejectSignedDoc(id, { comment: args.comment, code: args.code });
-      console.log('반려했습니다 — 작성자가 다시 고칠 수 있습니다.');
+      console.log(tr('반려했습니다 — 작성자가 다시 고칠 수 있습니다.', `Rejected — the author can revise it.`));
       return printSignedState(st);
     }
     case 'reopen': {
       const st = await client.reopenSignedDoc(await resolveSignedId(client, args._[1]));
-      console.log('다시 열었습니다 — 본문과 결재라인을 고칠 수 있습니다.');
+      console.log(tr('다시 열었습니다 — 본문과 결재라인을 고칠 수 있습니다.', `Reopened — the body and approval line can be changed again.`));
       return printSignedState(st);
     }
     case 'revise': {
       const id = await resolveSignedId(client, args._[1]);
       if (typeof args.note !== 'string' || !args.note.trim()) {
-        throw new Error('개정에는 사유가 필요합니다: --note "측정값 단위 정정"');
+        throw new Error(tr('개정에는 사유가 필요합니다: --note "측정값 단위 정정"', `A revision needs a reason: --note "corrected the measurement unit"`));
       }
       const out = await client.reviseSignedDoc(id, args.note);
-      console.log(`개정본을 만들었습니다: ${out.nodeId} (${out.revisionNo}판). 원본은 그대로 남습니다.`);
+      console.log(tr(`개정본을 만들었습니다: ${out.nodeId} (${out.revisionNo}판). 원본은 그대로 남습니다.`, `Revision created: ${out.nodeId} (rev ${out.revisionNo}). The original stays.`));
       return printSignedState(await client.getSignedDoc(out.nodeId));
     }
     case 'verify': {
@@ -1973,15 +2143,20 @@ async function cmdSign(args) {
       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})` : ''}`);
+      console.log(tr(`${mark(v.contentIntact)} 본문이 서명 당시 그대로다`, `${mark(v.contentIntact)} the body is exactly what was signed`));
+      console.log(tr(`${mark(v.allSignaturesValid)} 서명이 전부 유효하고 체인이 이어진다`, `${mark(v.allSignaturesValid)} every signature is valid and the chain is unbroken`));
+      console.log(tr(`${mark(v.allTimestamped)} 서명마다 공인시점확인이 붙어 있다`, `${mark(v.allTimestamped)} every signature carries a trusted timestamp`));
+      console.log(
+        tr(
+          `${mark(v.ledgerIntact)} 워크스페이스 원장이 성하다${v.ledgerBrokenAtSeq ? ` (끊긴 지점 #${v.ledgerBrokenAtSeq})` : ''}`,
+          `${mark(v.ledgerIntact)} the workspace ledger is intact${v.ledgerBrokenAtSeq ? ` (breaks at #${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 ? ' [시점확인 대기중]' : ''),
+            tr(`${mark(sig.signatureValid)}서명 ${mark(sig.chainLinkValid)}체인 ${mark(sig.matchesCurrentContent)}현재본문`, `${mark(sig.signatureValid)}signature ${mark(sig.chainLinkValid)}chain ${mark(sig.matchesCurrentContent)}current body`) +
+            (sig.timestampPending ? tr(' [시점확인 대기중]', ` [timestamp pending]`) : ''),
         );
       }
       return;
@@ -1994,18 +2169,18 @@ async function cmdSign(args) {
         pendingMine: !!args.pending,
       });
       if (args.json) return console.log(JSON.stringify(rows, null, 2));
-      if (!rows.length) return console.log(args.pending ? '내 차례인 서명문서가 없습니다.' : '서명문서가 없습니다.');
+      if (!rows.length) return console.log(args.pending ? tr('내 차례인 서명문서가 없습니다.', `No signed documents are waiting on you.`) : tr('서명문서가 없습니다.', `No signed documents.`));
       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 ? '  ← 내 차례' : ''}`);
+        const waiting = r.waitingOn?.length ? tr(`  대기: ${r.waitingOn.join(', ')}`, `  waiting on: ${r.waitingOn.join(', ')}`) : '';
+        console.log(tr(`${r.nodeId}\t${SIGN_STATUS_KO[r.status] ?? r.status}\t${r.path}${waiting}${r.canSign ? '  ← 내 차례' : ''}`, `${r.nodeId}\t${SIGN_STATUS_KO[r.status] ?? r.status}\t${r.path}${waiting}${r.canSign ? '  ← your turn' : ''}`));
       }
       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, '묶음 서명');
+      if (!targets.length) throw new Error(usage(tr(`rootr sign bulk <id|경로 …> --code <6자리>`, `rootr sign bulk <id|path …> --code <6 digits>`)));
+      const code = requireCode(args, tr('묶음 서명', `bulk signing`));
       const nodeIds = [];
       for (const t of targets) nodeIds.push(await resolveSignedId(client, t));
       const out = await client.bulkSignSignedDocs(ws, { nodeIds, code });
@@ -2015,20 +2190,28 @@ async function cmdSign(args) {
       // 얼리는 것은 되돌릴 수 없으니 "몇 건"이 아니라 "무엇을 했는지"를 보여준다.
       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}`);
+      if (n('submitted+signed')) parts.push(tr(`올리고 서명 ${n('submitted+signed')}건`, `${n('submitted+signed')} submitted and signed`));
+      if (n('submitted')) parts.push(tr(`올리기만 ${n('submitted')}건`, `${n('submitted')} submitted only`));
+      if (n('signed')) parts.push(tr(`서명 ${n('signed')}건`, `${n('signed')} signed`));
+      console.log(
+        tr(
+          `${parts.join(', ') || '처리 0건'}${failed.length ? `, 건너뜀 ${failed.length}건` : ''}`,
+          `${parts.join(', ') || 'nothing processed'}${failed.length ? `, ${failed.length} skipped` : ''}`,
+        ),
+      );
+      for (const f of failed) console.log(tr(`  건너뜀 ${f.nodeId}: ${f.error}`, `  skipped ${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})` : ''}`);
+      console.log(tr(`${v.ok ? '✅ 원장이 성합니다' : '❌ 원장이 끊겼습니다'} — 서명 ${v.count}건`, `${v.ok ? '✅ the ledger is intact' : '❌ the ledger is broken'} — ${v.count} signatures`));
+      if (v.headHash) console.log(tr(`머리 해시: ${v.headHash}`, `Head hash: ${v.headHash}`));
+      if (!v.ok)
+        console.log(
+          tr(`끊긴 지점: #${v.brokenAtSeq}${v.reason ? ` (${v.reason})` : ''}`, `Breaks at: #${v.brokenAtSeq}${v.reason ? ` (${v.reason})` : ''}`),
+        );
       return;
     }
     default:
@@ -2102,7 +2285,7 @@ async function main() {
     case 'mcp':
       return cmdMcp(args);
     default:
-      console.error(`알 수 없는 명령: ${cmd}\n`);
+      console.error(tr(`알 수 없는 명령: ${cmd}\n`, `Unknown command: ${cmd}\n`));
       console.log(USAGE);
       process.exit(1);
   }