comitia 0.3.0 → 0.4.0

package/index.js

@@ -98,11 +98,11 @@ async function rpc(method, params, { token: override } = {}) {
   // `login` 은 **아직 저장하지 않은** 토큰으로 확인해야 한다 — 그래서 넘겨받는 길을 둔다.
   const token = override || saved;
   if (!token) {
-    die('아직 연결 안 됐어요.\n  `comitia login` 을 하면 브라우저에서 「허용」 한 번으로 연결됩니다.');
+    die('Not connected yet.\n  Run `comitia login` and approve once in the browser.');
   }
 
   if (token && !TOKEN_RE.test(token)) {
-    die('토큰에 이상한 글자가 섞여 있어요. 따옴표나 줄바꿈이 딸려 오지 않았는지 확인해 주세요.');
+    die('That token has unexpected characters in it. Check for stray quotes or line breaks.');
   }
 
   let res;
@@ -111,27 +111,27 @@ async function rpc(method, params, { token: override } = {}) {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
-        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        ...(token ? { Authorization: `Bearer ${token}`, 'X-Comitia-Token': token } : {}),
       },
       body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
     });
   } catch (e) {
-    die(`서버에 닿지 못했어요 (${api}).\n  ${e.message}\n  회사망·VPN·보안 프로그램이 막는 경우가 많아요 — 다른 망(휴대폰 핫스팟)에서 한 번 해 보세요.`);
+    die(`Couldn't reach the server (${api}).\n  ${e.message}\n  A corporate network, VPN or security software is often the cause — try another network (your phone's hotspot).`);
   }
 
-  if (res.status === 401) die('연결이 끊겼어요(토큰이 끊겼거나 틀림). `comitia login` 으로 다시 연결해 주세요.');
+  if (res.status === 401) die('The connection was lost (the token was revoked or is wrong). Reconnect with `comitia login`.');
   if (res.status === 403) {
     // 읽기 전용 토큰으로 쓰기를 시도한 경우. 서버 문구를 그대로 전한다.
     let detail = '';
     try {
       detail = (await res.json())?.detail || '';
     } catch { /* 본문이 JSON 이 아닐 수 있다 */ }
-    die(detail || '이 토큰으로는 할 수 없는 일이에요. 쓰기 토큰이 필요합니다.');
+    die(detail || "This token can't do that. You need a write token.");
   }
-  if (!res.ok) die(`서버가 ${res.status} 로 답했어요.`);
+  if (!res.ok) die(`The server replied ${res.status}.`);
 
   const body = await res.json();
-  if (body.error) die(`요청이 거절됐어요: ${body.error.message || body.error.code}`);
+  if (body.error) die(`Request rejected: ${body.error.message || body.error.code}`);
   return body.result || {};
 }
 
@@ -144,7 +144,7 @@ async function callTool(name, args, opts) {
     .join('\n');
   // 🔑 **도구가 「안 됐다」고 답한 것도 종료 코드로 옮긴다.** 셸에서 `&&` 로 이어
   //    쓰는 사람이 성공/실패를 알아야 한다 — 글만 보고는 스크립트가 못 가린다.
-  if (result.isError) die(text || '요청을 처리하지 못했어요.');
+  if (result.isError) die(text || 'Could not complete the request.');
   return text;
 }
 
@@ -184,7 +184,7 @@ function openBrowser(url) {
 const DONE_HTML = (msg) => `<!doctype html><meta charset="utf-8"><title>Comitia</title>
 <body style="font-family:-apple-system,system-ui,sans-serif;background:#f6f6f2;display:grid;place-items:center;height:100vh;margin:0">
 <div style="text-align:center;color:#34322e"><div style="font-size:18px;font-weight:600">${msg}</div>
-<div style="margin-top:8px;font-size:13px;opacity:.55">이 창은 닫아도 돼요.</div></div></body>`;
+<div style="margin-top:8px;font-size:13px;opacity:.55">You can close this window.</div></div></body>`;
 
 /** 브라우저에서 허용받아 토큰을 저장한다. 워크스페이스를 매었으면 그것도 정해 둔다. */
 async function browserLogin({ paste = false } = {}) {
@@ -199,9 +199,9 @@ async function browserLogin({ paste = false } = {}) {
   if (paste) {
     // 브라우저가 다른 기기에 있다(원격 서버·SSH). 여기로 돌아올 길이 없으니 코드를 옮겨 적는다.
     q.set('mode', 'paste');
-    console.log(`이 주소를 브라우저에서 열고 「허용」을 누르세요:\n\n  ${web}/cli-login?${q}\n`);
+    console.log(`Open this in your browser and click Approve:\n\n  ${web}/cli-login?${q}\n`);
     const rl = createInterface({ input: process.stdin, output: process.stdout });
-    code = (await rl.question('화면에 뜬 연결 코드를 붙여 넣으세요: ')).trim();
+    code = (await rl.question('Paste the connection code shown on screen: ')).trim();
     rl.close();
   } else {
     code = await new Promise((resolve, reject) => {
@@ -215,7 +215,7 @@ async function browserLogin({ paste = false } = {}) {
         // ⚠️ `state` 가 다르면 이 창에서 시작한 요청이 아니다 — 받지 않는다.
         const got = u.searchParams.get('state') === state ? u.searchParams.get('code') : null;
         res.writeHead(got ? 200 : 400, { 'Content-Type': 'text/html; charset=utf-8', Connection: 'close' });
-        res.end(DONE_HTML(got ? '연결됐어요. 터미널로 돌아가세요.' : '요청이 맞지 않아요. 터미널에서 comitia login 을 다시 해 주세요.'));
+        res.end(DONE_HTML(got ? 'Connected. Head back to your terminal.' : 'That request did not match. Run comitia login again in your terminal.'));
         if (!got) return;
         clearTimeout(timer);
         server.close();
@@ -223,21 +223,21 @@ async function browserLogin({ paste = false } = {}) {
       });
       const timer = setTimeout(() => {
         server.close();
-        reject(new Error('5분 안에 허용하지 않아 멈췄어요. `comitia login` 을 다시 해 주세요.'));
+        reject(new Error('Stopped — not approved within 5 minutes. Run `comitia login` again.'));
       }, 5 * 60 * 1000);
       server.on('error', reject);
       server.listen(0, '127.0.0.1', () => {
         q.set('port', String(server.address().port));
         const url = `${web}/cli-login?${q}`;
         console.log(openBrowser(url)
-          ? '브라우저에서 Comitia 를 열었어요. 「허용」을 누르면 여기로 돌아옵니다.'
-          : '브라우저를 열지 못했어요.');
-        console.log(`\n안 열리면 이 주소를 직접 여세요:\n  ${url}\n`);
-        console.log('(브라우저가 다른 기기에 있으면 Ctrl+C 로 멈추고 `comitia login --paste`)\n');
+          ? "Opened Comitia in your browser. Click Approve and you'll come back here."
+          : 'Could not open a browser.');
+        console.log(`\nIf it didn't open, go to this address yourself:\n  ${url}\n`);
+        console.log('(If your browser is on another device, press Ctrl+C and run `comitia login --paste`)\n');
       });
     });
   }
-  if (!code) die('연결 코드가 비었어요.');
+  if (!code) die('The connection code is empty.');
 
   let res;
   try {
@@ -247,16 +247,16 @@ async function browserLogin({ paste = false } = {}) {
       body: JSON.stringify({ code, code_verifier: verifier }),
     });
   } catch (e) {
-    die(`서버에 닿지 못했어요 (${api}).\n  ${e.message}\n  회사망·VPN·보안 프로그램이 막는 경우가 많아요 — 다른 망(휴대폰 핫스팟)에서 한 번 해 보세요.`);
+    die(`Couldn't reach the server (${api}).\n  ${e.message}\n  A corporate network, VPN or security software is often the cause — try another network (your phone's hotspot).`);
   }
   const body = await res.json().catch(() => ({}));
-  if (!res.ok || !body.token) die(body.detail || `서버가 ${res.status} 로 답했어요.`);
+  if (!res.ok || !body.token) die(body.detail || `The server replied ${res.status}.`);
 
   // 워크스페이스에 매인 토큰이면 그걸 기본으로 — `comitia use` 를 따로 안 해도 된다.
   saveConf({ ...loadConf(), token: body.token, ...(body.company_id ? { companyId: body.company_id } : {}) });
   console.log(
-    `연결했어요 — ${body.company_name || '내가 볼 수 있는 워크스페이스 전부'} · ` +
-      `${body.scope === 'write' ? '자료·정리까지' : '읽기만'}`,
+    `Connected — ${body.company_name || 'every workspace you can see'} · ` +
+      `${body.scope === 'write' ? 'sources and organizing' : 'read only'}`,
   );
   return body;
 }
@@ -265,7 +265,7 @@ async function browserLogin({ paste = false } = {}) {
 function needCompany(flags) {
   const id = flags.c || settings().companyId;
   if (!id) {
-    die('워크스페이스를 안 정했어요.\n  `comitia companies` 로 목록을 보고 `comitia use <id>` 하세요.');
+    die('No workspace selected.\n  Run `comitia companies` to list them, then `comitia use <id>`.');
   }
   return id;
 }
@@ -278,7 +278,7 @@ function needCompany(flags) {
 
 // 🌍 **도구마다 「모든 폴더에 적용되는」 규칙 파일 자리가 따로 있다.**
 //    여기 한 번 심으면 폴더마다 `init` 을 돌릴 필요가 없다.
-// 🧩 **Claude Code 에는 스킬로도 심는다** — `/comitia:read` · `/comitia:ingest` · `/comitia:slack` · `/comitia:sync`.
+// 🧩 **Claude Code 에는 스킬로도 심는다** — `/comitia:read` · `/comitia:ingest` · `/comitia:problem` · `/comitia:slack` · `/comitia:sync`.
 //    규칙 파일 블록은 **모든 대화에 항상** 실리지만, 스킬은 한 줄 설명(~90토큰)만 늘 들고
 //    본문은 **부를 때만** 읽힌다. 그래서 절차를 길고 정확하게 적을 수 있다.
 //    `~/.claude/skills/<이름>/` 에 두면 마켓플레이스 없이 다음 세션부터 `comitia@skills-dir` 로 뜬다.
@@ -312,19 +312,19 @@ function installPlugin() {
   }
   if (existsSync(dest)) {
     // 같은 이름의 **남의 것**은 덮지 않는다.
-    if (pluginName(dest) !== 'comitia') return { dest, removed, state: '건너뜀 — 같은 이름의 다른 폴더가 있어요' };
+    if (pluginName(dest) !== 'comitia') return { dest, removed, state: 'skipped - a different folder with the same name exists' };
     rmSync(dest, { recursive: true, force: true });   // 옛 판의 지운 스킬이 남지 않게
   }
   mkdirSync(join(home, 'skills'), { recursive: true });
   cpSync(PLUGIN_SRC, dest, { recursive: true });
-  return { dest, removed, state: '설치' };
+  return { dest, removed, state: 'installed' };
 }
 
 function reportPlugin(r = installPlugin()) {
   if (!r) return;
-  for (const old of r.removed || []) console.log(`~/.claude/skills/${old} — 옛 이름이라 지움 (/${old}:* → /comitia:*)`);
+  for (const old of r.removed || []) console.log(`~/.claude/skills/${old} - removed (old name: /${old}:* → /comitia:*)`);
   console.log(`~/.claude/skills/comitia — ${r.state}`);
-  if (r.state === '설치') console.log('  Claude Code 스킬 /comitia:read · /comitia:ingest · /comitia:slack · /comitia:sync (다음 세션부터, 지금은 /reload-plugins)');
+  if (r.state === 'installed') console.log('  Claude Code skills /comitia:read · /comitia:ingest · /comitia:problem · /comitia:slack · /comitia:sync (from the next session, or run /reload-plugins now)');
 }
 
 const GLOBAL_RULES = [
@@ -343,28 +343,38 @@ const OLD_MARKS = [
 ];
 
 const BLOCK = `${MARK_START}
-## 회사 맥락 (comitia)
 
-슬랙·회의록·위키를 \`comitia\` 명령으로 꺼낸다. **사람에게 복사해 달라고 하지 않는다.**
+## Company context (comitia)
 
-| 정리 전 원본 | | 정리된 위키 | |
+Pull Slack, meetings and the wiki with the \`comitia\` command. **Never ask the person to paste it in.**
+
+| Raw, not yet organized | | The organized wiki | |
 |---|---|---|---|
-| \`comitia recent\` | 최근 들어온 것 | \`comitia search <낱말>\` | 본문 검색 |
-| \`comitia find <낱말>\` | 원본에서 찾기 | \`comitia read <경로>\` | 문서 본문 |
-| \`comitia raw <id>\` | 원본 본문 | \`comitia list [접두어]\` | 문서 목록 |
-| \`comitia forget <id> <낱말>\` | 원본에서 낱말 지우기(남을 이유 없는 제3자 이름 등) | | |
+| \`comitia recent\` | what came in lately | \`comitia search <word>\` | full-text search |
+| \`comitia find <word>\` | search the raw items | \`comitia read <path>\` | a page's body |
+| \`comitia raw <id>\` | a raw item's body | \`comitia list [prefix]\` | list pages |
+| \`comitia forget <id> <word>\` | scrub a word from a raw item (a third-party name with no reason to be there, etc.) | | |
+
+**When asked to organize, do it yourself** — don't hand it to Comitia's own AI.
+
+🔑 **Before writing anything to the wiki, read \`comitia rules\` first and follow it.**
+The axes, the page format, the places you must not touch and the sequence are all there.
+**It differs per company and the person may have edited it, so never rely on your memory of this block.**
 
-**정리를 부탁받으면 내가 한다** — Comitia 의 AI 에게 맡기지 않는다.
+⚠️ **Posting to Slack (\`comitia slack\`) is something the whole team sees** — show the channel and the text and get approval before posting.
+**Editing and deleting (\`--edit\` · \`--delete\`) too** — only the bot's own messages, and always show what you're changing or deleting and get approval. Deleting cannot be undone.
 
-🔑 **위키에 무엇을 쓰기 전에 \`comitia rules\` 를 먼저 읽고 그대로 따른다.**
-축 구성·문서 형식·건드리지 않을 곳·정리 순서가 거기 있다. **회사마다 다르고
-사용자가 고쳐 두었을 수 있으므로, 이 블록의 기억에 의존하지 않는다.**
+In Claude Code, the skills carry this sequence.
 
-⚠️ **슬랙에 올리는 것(\`comitia slack\`)은 팀 전체가 보는 일이다** — 채널과 문구를 먼저 보여 주고 허락받은 뒤에만 올린다.
-**고치기·지우기(\`--edit\` · \`--delete\`)도 마찬가지다** — 봇이 올린 글만 되고, 무엇을 고치거나 지우는지 보여 주고 허락받는다. 지우기는 되돌릴 수 없다.
+| | |
+|---|---|
+| \`/comitia:read\` | find company context and answer from it |
+| \`/comitia:ingest\` | push originals in and organize them into the wiki |
+| \`/comitia:problem\` | surface the things you only learn by changing something, onto the lab board |
+| \`/comitia:slack\` | post to Slack (with approval) |
+| \`/comitia:sync\` | pull connected sources in right now |
 
-Claude Code 에서는 스킬 \`/comitia:read\` · \`/comitia:ingest\` · \`/comitia:slack\` · \`/comitia:sync\` 이 순서를 담고 있다.
-자세한 명령은 \`comitia --help\`.
+For the full command list, run \`comitia --help\`.
 ${MARK_END}`;
 
 /** 규칙 파일에 블록을 심는다. **두 번 해도 하나만 남는다.** */
@@ -398,13 +408,13 @@ function writeRules(file) {
       at = j;
     });
     after += before.slice(at);
-    if (after === before) return { file, state: '그대로' };
+    if (after === before) return { file, state: 'unchanged' };
     writeFileSync(file, after);
-    return { file, state: '갱신' };
+    return { file, state: 'updated' };
   }
   after = before.trimEnd() + (before.trim() ? '\n\n' : '') + BLOCK + '\n';
   writeFileSync(file, after);
-  return { file, state: had ? '추가' : '새로 만듦' };
+  return { file, state: had ? 'appended' : 'created' };
 }
 
 // ── 인자 파싱 ────────────────────────────────────────────
@@ -430,52 +440,52 @@ function parseArgs(argv) {
   return { flags, rest };
 }
 
-const HELP = `comitia — 회사 온톨로지를 내가 쓰는 AI에서 꺼내 쓴다
-
-  comitia init                한 번에 붙이기 — 브라우저 로그인 + 워크스페이스 + AI 규칙파일
-  comitia init -g             규칙을 **모든 폴더**에 (~/.claude 등). 폴더마다 안 해도 됨
-  comitia login               브라우저에서 「허용」 한 번으로 연결 (토큰을 볼 일이 없다)
-  comitia login --paste       브라우저가 다른 기기에 있을 때 — 화면의 코드를 붙여 넣는다
-  comitia login <토큰>        발급받은 토큰을 직접 넣기
-  comitia logout              저장한 토큰 지우기
-  comitia whoami              지금 어떻게 붙어 있나
-
-  comitia companies           워크스페이스 목록
-  comitia use <id 또는 이름>   기본 워크스페이스 정하기
-
-  ── 정리된 문서 ──
-  comitia list [접두어]        문서 목록 (예: comitia list ledger/)
-  comitia search <낱말>        본문 검색
-  comitia read <경로...>       문서 본문
-  comitia graph               문서가 서로 어떻게 이어져 있는지
-
-  ── 정리 전 원본 ──  슬랙·메일이 들어온 그대로
-  comitia recent [개수]        최근 들어온 원본
-  comitia find <낱말>          원본에서 찾기
-  comitia raw <id...>          원본 본문 (id 는 recent·find 가 준 것)
-  comitia forget <id> <낱말...>    원본에서 낱말 지우기 — 다시 수집돼도 안 돌아옴 (쓰기 토큰)
-  comitia sync [slack|tiro|...]    지금 당겨오기 — 매시 자동 수집을 기다리지 않고 (쓰기 토큰)
-  comitia slack <채널> <파일|->    연결된 봇으로 슬랙에 올리기 (쓰기 토큰 · 봇에 chat:write 필요)
-  comitia slack <채널> --delete <ts>   봇이 올린 그 글 지우기 (되돌릴 수 없음)
-      --thread <ts>            그 글의 스레드에 답글로 (부모 ts)
-      --thread-of "<검색어>"    부모 글을 본문으로 찾아 그 스레드에 (최근 100건 중 최신)
-      --edit <ts>              새 글 대신 봇이 올린 그 글을 통째로 바꾸기 (봇 글만)
-      --edit-of "<검색어>"      고칠 봇 글을 본문으로 찾아서 (최근 100건 중 최신)
-
-  ── 정리를 내 AI 가 한다 ──  (쓰기 토큰 필요)
-  comitia rules               이 워크스페이스의 위키 규칙 — **쓰기 전에 먼저**
-  comitia skills              Claude Code 스킬 설치·갱신 (/comitia:read · /comitia:ingest · /comitia:slack · /comitia:sync)
-  comitia push <제목> <파일|->     원본 넣기
-  comitia build               원문·장부·표 만들기 (코드만, 0원)
-  comitia pending             요약이 필요한 원본
-  comitia write <경로> <파일|->    요약을 위키에 남기기 (예: topics/물류.md)
-  comitia organize            Comitia 의 AI 에게 정리를 맡긴다 (직접 안 쓸 때)
-
-  -c, --company <id>          이번만 다른 워크스페이스로
-  -g, --global                init 을 모든 폴더에 적용
-      --paste                 login·init 을 코드 붙여넣기로
-
-환경 변수: COMITIA_API · COMITIA_TOKEN · COMITIA_COMPANY (설정 파일보다 우선. 옛 이름 Z2O_* 도 읽는다)`;
+const HELP = `comitia — pull your company's ontology into the AI you already use
+
+  comitia init                set it all up — browser login + workspace + AI rules file
+  comitia init -g             put the rules in **every folder** (~/.claude etc). No need to repeat per folder
+  comitia login               connect by approving once in the browser (you never see a token)
+  comitia login --paste       when your browser is on another device — paste the code from the screen
+  comitia login <token>       enter a token you were issued
+  comitia logout              delete the stored token
+  comitia whoami              how you're connected right now
+
+  comitia companies           list workspaces
+  comitia use <id or name>    set the default workspace
+
+  ── Organized pages ──
+  comitia list [prefix]        list pages (e.g. comitia list ledger/)
+  comitia search <word>        full-text search
+  comitia read <path...>       a page's body
+  comitia graph                how pages link to each other
+
+  ── Raw, not yet organized ──  Slack and email exactly as they arrived
+  comitia recent [n]           raw items that came in lately
+  comitia find <word>          search the raw items
+  comitia raw <id...>          a raw item's body (ids come from recent / find)
+  comitia forget <id> <word...>    scrub a word from a raw item — it won't come back on re-collection (write token)
+  comitia sync [slack|tiro|...]    pull right now, without waiting for the hourly collection (write token)
+  comitia slack <channel> <file|->    post to Slack via the connected bot (write token · bot needs chat:write)
+  comitia slack <channel> --delete <ts>   delete that bot message (cannot be undone)
+      --thread <ts>            reply in that message's thread (parent ts)
+      --thread-of "<query>"    find the parent by its text and reply there (latest of the last 100)
+      --edit <ts>              replace that bot message wholesale instead of posting a new one (bot messages only)
+      --edit-of "<query>"      find the bot message to edit by its text (latest of the last 100)
+
+  ── Your own AI does the organizing ──  (write token required)
+  comitia rules               this workspace's wiki rules — **read before writing**
+  comitia skills              install / update the Claude Code skills (/comitia:read · /comitia:ingest · /comitia:problem · /comitia:slack · /comitia:sync)
+  comitia push <title> <file|->    push an original in
+  comitia build               build the originals, ledger and tables (code only, costs nothing)
+  comitia pending             originals that still need a summary
+  comitia write <path> <file|->    leave a summary in the wiki (e.g. topics/logistics.md)
+  comitia organize            hand the organizing to Comitia's AI (when you're not doing it yourself)
+
+  -c, --company <id>          use a different workspace just this once
+  -g, --global                apply init to every folder
+      --paste                 do login / init by pasting a code
+
+Environment variables: COMITIA_API · COMITIA_TOKEN · COMITIA_COMPANY (they win over the config file. The old names Z2O_* are also read)`;
 
 // ── 명령 ────────────────────────────────────────────────
 
@@ -486,21 +496,21 @@ const COMMANDS = {
       await browserLogin({ paste: flags.paste });
       if (!settings().companyId) {
         console.log('\n' + (await callTool('list_companies', {})));
-        console.log('\n`comitia use <id 또는 이름>` 으로 기본 워크스페이스를 정해 두세요.');
+        console.log('\nSet a default workspace with `comitia use <id or name>`.');
       }
       return;
     }
     if (!TOKEN_RE.test(token)) {
-      die('토큰 모양이 아니에요. `z2o_live_` 로 시작하는 한 줄이어야 합니다.');
+      die('That is not a token. It should be a single line starting with `z2o_live_`.');
     }
     // 🔑 **저장하기 전에 한 번 써 본다.** 틀린 토큰을 저장해 두면 나중에 엉뚱한
     // 명령에서 실패하고, 사람은 그게 토큰 탓인 줄 모른다. 확인에 실패하면
     // `callTool` 이 여기서 끝내므로 **잘못된 토큰이 파일에 남지 않는다.**
     const text = await callTool('list_companies', {}, { token });
     saveConf({ ...loadConf(), token });
-    console.log('연결했어요.\n');
+    console.log('Connected.\n');
     console.log(text);
-    if (!settings().companyId) console.log('\n`comitia use <id>` 로 기본 워크스페이스를 정해 두세요.');
+    if (!settings().companyId) console.log('\nSet a default workspace with `comitia use <id>`.');
   },
 
   /** 한 번에 다 붙인다 — 설치 뒤 이것만 하면 된다.
@@ -519,7 +529,7 @@ const COMMANDS = {
       await browserLogin({ paste: flags.paste });
       console.log('');
     } else {
-      console.log('이미 연결돼 있어요.\n');
+      console.log('Already connected.\n');
     }
 
     // ② 워크스페이스 — 하나뿐이면 묻지 않고 정한다.
@@ -527,20 +537,20 @@ const COMMANDS = {
     if (!settings().companyId) {
       const rows = (await callTool('list_companies', {}))
         .split('\n')
-        .map((l) => l.match(/^- (\S+) — (.+?)(?: \(초대받음.*\))?$/))
+        .map((l) => l.match(/^- (\S+) — (.+?)(?: \((?:초대받음|invited).*\))?$/))
         .filter(Boolean);
       if (rows.length === 1) {
         saveConf({ ...loadConf(), companyId: rows[0][1] });
-        console.log(`워크스페이스: ${rows[0][2]}`);
+        console.log(`Workspace: ${rows[0][2]}`);
       } else if (rows.length > 1) {
         // ⚠️ **여럿이면 고르지 않는다.** 엉뚱한 회사에 자료를 넣게 되는 쪽이 훨씬 나쁘다.
         needPick = true;
-        console.log('워크스페이스가 여럿이에요. 하나 고르세요:\n');
+        console.log('You have several workspaces. Pick one:\n');
         for (const r of rows) console.log(`  ${r[1]} — ${r[2]}`);
         console.log('');
       } else {
         needPick = true;
-        console.log('쓸 수 있는 워크스페이스가 없어요. z2o.kr 에서 만들거나 초대받으세요.\n');
+        console.log('No workspace available. Create one at z2o.kr or get invited to one.\n');
       }
     }
 
@@ -555,13 +565,13 @@ const COMMANDS = {
         const r = writeRules(join(dir, f));
         console.log(`~/${d}/${f} — ${r.state}`);
       }
-      console.log('  (모든 폴더에서 통합니다)');
+      console.log('  (works in every folder)');
       reportPlugin();
-      console.log('\n이제 AI 에게 그냥 물어보세요:');
-      console.log('  "최근 슬랙에서 나온 얘기 정리해줘"');
+      console.log('\nNow just ask your AI:');
+      console.log('  "catch me up on recent Slack"');
       if (needPick) {
-        console.log('\n🔴 아직 한 걸음 남았어요:');
-        console.log('  comitia use <id 또는 이름>');
+        console.log('\n🔴 One step left:');
+        console.log('  comitia use <id or name>');
       }
       return;
     }
@@ -578,19 +588,19 @@ const COMMANDS = {
       console.log(`${r.file} — ${r.state}`);
     }
     console.log(
-      '  (다른 도구를 쓰면 그 도구의 규칙 파일을 만들어 두고 `comitia init` 을 다시 돌리세요)',
+      '  (Using another tool? Create its rules file first, then run `comitia init` again)',
     );
     reportPlugin();
 
     // ⚠️ **다 된 것처럼 끝내지 않는다.** 워크스페이스를 못 정했으면 아직 아무것도 안 된다 —
     //    여기서 "이제 물어보세요" 라고 하면 사람은 됐다고 믿고 넘어간다.
     if (needPick) {
-      console.log('\n🔴 아직 한 걸음 남았어요:');
-      console.log('  comitia use <id 또는 이름>      (예: comitia use 린디)');
+      console.log('\n🔴 One step left:');
+      console.log('  comitia use <id or name>      (e.g. comitia use lindy)');
     } else {
-      console.log('\n이제 AI 에게 그냥 물어보세요:');
-      console.log('  "최근 슬랙에서 나온 얘기 정리해줘"');
-      console.log('  "지난주 회의 내용 찾아서 할 일 뽑아줘"');
+      console.log('\nNow just ask your AI:');
+      console.log('  "catch me up on recent Slack"');
+      console.log('  "find last week\'s meeting and pull out the action items"');
     }
     void flags;
   },
@@ -598,7 +608,7 @@ const COMMANDS = {
   // 스킬만 깔거나 새 판으로 바꾼다 — 토큰이 없어도 된다. `npm i -g comitia` 로 올린 뒤에 한 번.
   async skills() {
     const r = installPlugin();
-    if (!r) die('Claude Code 가 안 보여요(~/.claude 없음). Claude Code 를 한 번 실행한 뒤 다시 해 주세요.');
+    if (!r) die("Can't find Claude Code (no ~/.claude). Run Claude Code once, then try again.");
     reportPlugin(r);
   },
 
@@ -606,14 +616,14 @@ const COMMANDS = {
     const conf = loadConf();
     delete conf.token;
     saveConf(conf);
-    console.log('저장한 토큰을 지웠어요. (서버 쪽에서 끊으려면 프로필 → 「연결 토큰」에서 끊으세요.)');
+    console.log('Removed the stored token. (To revoke it server-side, go to your profile → Connection tokens.)');
   },
 
   async whoami() {
     const { api, token, companyId } = settings();
-    console.log(`서버        ${api}`);
-    console.log(`토큰        ${token ? token.slice(0, 17) + '…' : '(없음)'}`);
-    console.log(`워크스페이스  ${companyId || '(안 정함)'}`);
+    console.log(`Server       ${api}`);
+    console.log(`Token        ${token ? token.slice(0, 17) + '…' : '(none)'}`);
+    console.log(`Workspace    ${companyId || '(not set)'}`);
     if (!token) return;
     console.log('');
     console.log(await callTool('list_companies', {}));
@@ -624,12 +634,12 @@ const COMMANDS = {
   },
 
   async use([q]) {
-    if (!q) die('워크스페이스 id 나 이름 일부를 적어 주세요.');
+    if (!q) die('Give a workspace id or part of its name.');
     const text = await callTool('list_companies', {});
     // 목록 줄은 `- <id> — <이름>` 모양이다.
     const rows = text
       .split('\n')
-      .map((l) => l.match(/^- (\S+) — (.+?)(?: \(초대받음.*\))?$/))
+      .map((l) => l.match(/^- (\S+) — (.+?)(?: \((?:초대받음|invited).*\))?$/))
       .filter(Boolean)
       .map((m) => ({ id: m[1], name: m[2] }));
     const hit = rows.filter((r) => r.id === q || r.name.includes(q));
@@ -637,16 +647,16 @@ const COMMANDS = {
       // 🔑 **매인 토큰이면 목록에 하나만 나온다.** 그걸 모르면 "왜 내 회사가 없지" 가 된다.
       const why =
         rows.length === 1
-          ? '\n\n이 열쇠는 위 워크스페이스에만 매여 있어요. 다른 곳도 쓰려면 「전부」로 새로 발급하세요.'
+          ? '\n\nThis key is tied to the workspace above. To use others, issue a new key scoped to all of them.'
           : '';
-      die(`「${q}」 에 해당하는 워크스페이스가 없어요.\n\n${text}${why}`);
+      die(`No workspace matches "${q}".\n\n${text}${why}`);
     }
     // ⚠️ 여럿이면 고르지 않는다 — 엉뚱한 회사에 자료를 넣게 되는 쪽이 훨씬 나쁘다.
     if (hit.length > 1) {
-      die(`「${q}」 가 여럿에 걸려요. id 로 정확히 골라 주세요.\n` + hit.map((r) => `- ${r.id} — ${r.name}`).join('\n'));
+      die(`"${q}" matches several. Pick one by id.\n` + hit.map((r) => `- ${r.id} — ${r.name}`).join('\n'));
     }
     saveConf({ ...loadConf(), companyId: hit[0].id });
-    console.log(`기본 워크스페이스를 「${hit[0].name}」 로 정했어요.`);
+    console.log(`Default workspace set to "${hit[0].name}".`);
   },
 
   async list(args, flags) {
@@ -655,12 +665,12 @@ const COMMANDS = {
 
   async search(args, flags) {
     const q = args.join(' ').trim();
-    if (!q) die('찾을 낱말을 적어 주세요.');
+    if (!q) die('Give a word to search for.');
     console.log(await callTool('search_pages', { company_id: needCompany(flags), query: q }));
   },
 
   async read(args, flags) {
-    if (args.length === 0) die('읽을 문서 경로를 적어 주세요. (`comitia list` 로 확인)');
+    if (args.length === 0) die('Give the page path to read. (`comitia list` shows them)');
     console.log(await callTool('read_pages', { company_id: needCompany(flags), paths: args }));
   },
 
@@ -686,28 +696,28 @@ const COMMANDS = {
 
   async find(args, flags) {
     const q = args.join(' ').trim();
-    if (!q) die('찾을 낱말을 적어 주세요.');
+    if (!q) die('Give a word to search for.');
     console.log(await callTool('search_raw', { company_id: needCompany(flags), query: q }));
   },
 
   async raw(args, flags) {
-    if (args.length === 0) die('읽을 원본 id 를 적어 주세요. (`comitia recent` 로 확인)');
+    if (args.length === 0) die('Give the raw id to read. (`comitia recent` shows them)');
     console.log(await callTool('read_raw', { company_id: needCompany(flags), ids: args }));
   },
 
   /** 원본에서 낱말을 지운다. 통째로 지우면 다음 수집에 되살아나지만 이건 안 돌아온다. */
   async forget(args, flags) {
     const [id, ...terms] = args;
-    if (!id || terms.length === 0) die('원본 id 와 지울 낱말을 적어 주세요.\n  z2o forget af1c6e9f "홍길동"');
+    if (!id || terms.length === 0) die('Give a raw id and the word to remove.\n  comitia forget af1c6e9f "Jane Doe"');
     console.log(await callTool('forget_raw', { company_id: needCompany(flags), id, terms }));
   },
 
   async push(args, flags) {
     const [title, path] = args;
-    if (!title || !path) die('제목과 파일을 적어 주세요.\n  comitia push "회의록" note.md\n  cat x.md | comitia push "제목" -');
+    if (!title || !path) die('Give a title and a file.\n  comitia push "Meeting notes" note.md\n  cat x.md | comitia push "Title" -');
     // `-` 면 표준입력. 파이프로 이어 쓰는 게 이 명령의 주된 쓰임새다.
     const content = path === '-' ? readFileSync(0, 'utf8') : readFileSync(path, 'utf8');
-    if (!content.trim()) die('본문이 비어 있어요.');
+    if (!content.trim()) die('The body is empty.');
     console.log(await callTool('ingest_text', { company_id: needCompany(flags), title, content }));
   },
 
@@ -730,10 +740,10 @@ const COMMANDS = {
   async write(args, flags) {
     const [path, file] = args;
     if (!path || !file) {
-      die('경로와 파일을 적어 주세요.\n  comitia write topics/물류.md 요약.md\n  ... | comitia write topics/물류.md -');
+      die('Give a path and a file.\n  comitia write topics/logistics.md summary.md\n  ... | comitia write topics/logistics.md -');
     }
     const content = file === '-' ? readFileSync(0, 'utf8') : readFileSync(file, 'utf8');
-    if (!content.trim()) die('본문이 비어 있어요.');
+    if (!content.trim()) die('The body is empty.');
     console.log(
       await callTool('write_pages', {
         company_id: needCompany(flags),
@@ -768,22 +778,22 @@ const COMMANDS = {
   async slack([channel, file], flags) {
     // 🗑️ 지우기는 올릴 글이 없다 — 채널과 ts(또는 검색어)만 받는다. 되돌릴 수 없어 스킬이 먼저 허락받는다.
     if (flags.delete || flags.deleteOf) {
-      if (!channel) die('지울 글이 있는 채널을 적어 주세요.\n  comitia slack project_0to1 --delete 1757769600.123456\n  comitia slack project_0to1 --delete-of "z2o → Comitia 이름 변경"');
-      if (flags.delete && !/^\d{10}\.\d{6}$/.test(flags.delete)) die(`--delete 는 슬랙 ts 모양이어야 해요 (예: 1757769600.123456). 검색어로 찾으려면 --delete-of "<글의 일부>"`);
-      if (flags.edit || flags.editOf || flags.thread || flags.threadOf) die('--delete 는 --edit·--thread 와 같이 못 써요.');
+      if (!channel) die('Give the channel the message is in.\n  comitia slack project_0to1 --delete 1757769600.123456\n  comitia slack project_0to1 --delete-of "renamed z2o to Comitia"');
+      if (flags.delete && !/^\d{10}\.\d{6}$/.test(flags.delete)) die(`--delete needs a Slack ts (e.g. 1757769600.123456). To find it by text, use --delete-of "<part of the message>"`);
+      if (flags.edit || flags.editOf || flags.thread || flags.threadOf) die('--delete cannot be combined with --edit or --thread.');
       const args = { company_id: needCompany(flags), channel };
       if (flags.delete) args.ts = flags.delete;
       else args.of = flags.deleteOf;
       console.log(await callTool('delete_slack', args));
       return;
     }
-    if (!channel || !file) die('채널과 파일을 적어 주세요.\n  comitia slack project_0to1 글.txt\n  ... | comitia slack project_0to1 -\n  comitia slack weekly-meeting 글.txt --thread-of "0913 위클리"   # 그 글의 스레드에 답글로');
+    if (!channel || !file) die('Give a channel and a file.\n  comitia slack project_0to1 message.txt\n  ... | comitia slack project_0to1 -\n  comitia slack weekly-meeting message.txt --thread-of "0913 weekly"   # reply in that message\'s thread');
     const text = file === '-' ? readFileSync(0, 'utf8') : readFileSync(file, 'utf8');
-    if (!text.trim()) die('올릴 글이 비었어요.');
+    if (!text.trim()) die('The message is empty.');
     const tsShape = /^\d{10}\.\d{6}$/;
-    if (flags.thread && !tsShape.test(flags.thread)) die(`--thread 는 슬랙 ts 모양이어야 해요 (예: 1757769600.123456). 검색어로 찾으려면 --thread-of "<글의 일부>"`);
-    if (flags.edit && !tsShape.test(flags.edit)) die(`--edit 는 슬랙 ts 모양이어야 해요 (예: 1757769600.123456). 검색어로 찾으려면 --edit-of "<글의 일부>"`);
-    if ((flags.edit || flags.editOf) && (flags.thread || flags.threadOf)) die('--edit 와 --thread 는 같이 못 써요. 고치기는 새 글이 아니에요.');
+    if (flags.thread && !tsShape.test(flags.thread)) die(`--thread needs a Slack ts (e.g. 1757769600.123456). To find it by text, use --thread-of "<part of the message>"`);
+    if (flags.edit && !tsShape.test(flags.edit)) die(`--edit needs a Slack ts (e.g. 1757769600.123456). To find it by text, use --edit-of "<part of the message>"`);
+    if ((flags.edit || flags.editOf) && (flags.thread || flags.threadOf)) die('--edit and --thread cannot be combined. An edit is not a new message.');
     const args = { company_id: needCompany(flags), channel, text };
     if (flags.edit) args.edit_ts = flags.edit;
     else if (flags.editOf) args.edit_of = flags.editOf;
@@ -795,7 +805,7 @@ const COMMANDS = {
   /** 지금 당겨오기. 자동 수집(매시 정각)을 기다리지 않고 방금 것을 가져온다. */
   async sync([source], flags) {
     const ok = ['slack', 'tiro', 'notion', 'calendar'];
-    if (source && !ok.includes(source)) die(`고를 수 있는 것: ${ok.join(' · ')} (비우면 전부)`);
+    if (source && !ok.includes(source)) die(`Choose one of: ${ok.join(' · ')} (leave empty for all)`);
     console.log(await callTool('sync_sources', { company_id: needCompany(flags), ...(source ? { source } : {}) }));
   },
 };
@@ -817,6 +827,6 @@ if (!cmd || flags.help || cmd === 'help') {
 }
 
 const run = COMMANDS[cmd];
-if (!run) die(`모르는 명령이에요: ${cmd}\n\n${HELP}`);
+if (!run) die(`Unknown command: ${cmd}\n\n${HELP}`);
 
-run(args, flags).catch((e) => die(`문제가 생겼어요: ${e.message}`));
+run(args, flags).catch((e) => die(`Something went wrong: ${e.message}`));