rootr-cli 0.7.0 → 0.7.1

package/README.md

@@ -152,13 +152,16 @@ rootr rm /notes/todo.md --yes    # 확인 없이 (스크립트용)
 (파이프/CI처럼 입력이 없는 환경에서는 "아니오"로 처리되어 안전합니다).
 `docs:write` 스코프가 필요합니다.
 
-### 워크스페이스 목록
+### 워크스페이스 목록 · 전환
 
 ```bash
-rootr ws
+rootr ws                       # 목록 (현재 워크스페이스에 *, 못 여는 곳은 표시)
+rootr use "영업팀"              # 전환 — id · 이름 · rootr.io 주소 아무거나
 ```
 
-출력: `id\tname` 목록 (계정 키면 소속된 전체 워크스페이스, 워크스페이스 키면 그 워크스페이스만).
+`rootr ws` 출력은 `id\tname` 목록입니다. 등록된 키가 워크스페이스 전용 키뿐이면 목록에는
+보이지만 열 수 없는 워크스페이스에 `[등록된 키로는 접근 불가]`가 붙습니다 — 목록에 보이는
+것과 접근되는 것은 다릅니다. `rootr use`는 그 워크스페이스를 여는 키를 골라 함께 기억합니다.
 
 ### 워크스페이스 여러 개 쓰기 (키 등록 + 전환)
 

package/bin/rootr.js

@@ -3,7 +3,8 @@ import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join, basename, extname } from 'node:path';
 
-import { loadConfig, saveConfig, maskKey, upsertKey, CONFIG_PATH, DEFAULT_BASE_URL } from '../lib/config.js';
+import { loadConfig, saveConfig, keyForWorkspace, maskKey, upsertKey, CONFIG_PATH, DEFAULT_BASE_URL } from '../lib/config.js';
+import { candidateClients, rememberWorkspace, resolveWorkspaceSwitch, surveyWorkspaces } from '../lib/credentials.js';
 import { RootrClient, RootrApiError } from '../lib/client.js';
 import { resolveTarget, requireResolved, resolveMoveDestination } from '../lib/resolve.js';
 
@@ -22,7 +23,8 @@ const USAGE = `Rootr CLI v${pkg.version}
   rootr mv <path|id> <새 경로|폴더 id>              문서/폴더 이동 및/또는 이름 변경
   rootr rm <path|id> [--yes]                       문서/폴더를 휴지통으로 이동 (복구 가능)
   rootr attach <file> [--doc <path|id>] [--heading "## X"] [--alt <text>]  파일 업로드(+문서에 삽입)
-  rootr ws                                         내 워크스페이스 목록 (id\tname)
+  rootr ws                                         내 워크스페이스 목록 (id\tname, 열 수 없는 곳은 표시)
+  rootr use <id|이름|주소>                          활성 워크스페이스 전환 (그 워크스페이스용 키도 기억)
   rootr ask <question> [--workspace <w>]           GraphRAG 질의응답 (RCA), 인용 포함 출력
   rootr config [--api-key <k>] [--workspace <w>] [--base-url <u>]  설정 조회/저장
   rootr config --add-key <k> [--label <name>] [--workspace <w>]     워크스페이스별 키 추가 등록
@@ -71,7 +73,10 @@ function readStdin() {
 
 function makeClient() {
   const cfg = loadConfig();
-  return new RootrClient(cfg);
+  // Several keys can live side by side, each bound to the workspace it opens
+  // (config.js keys[]). Use the one that covers the active workspace instead of
+  // insisting on a single default key.
+  return new RootrClient({ ...cfg, apiKey: keyForWorkspace(cfg, cfg.workspace) });
 }
 
 function printErrorAndExit(err) {
@@ -318,11 +323,47 @@ async function cmdAttach(args) {
 }
 
 async function cmdWs() {
-  const client = makeClient();
-  const workspaces = await client.listWorkspaces();
+  const cfg = loadConfig();
+  const candidates = candidateClients(cfg);
+  if (!candidates.length) {
+    throw new RootrApiError('이 컴퓨터에 등록된 Rootr 키가 없습니다.', {
+      hint: 'rootr.io > 설정 > API 키에서 계정 키(PAT)를 발급해 `rootr config --api-key <키>` 로 등록하세요.',
+    });
+  }
+  // Probing costs an API call per workspace, so only when it diagnoses something:
+  // no account key means every key is scoped and most of the list is unusable.
+  const probe = !cfg.apiKey && (cfg.keys || []).length > 0;
+  const { workspaces, reachable, failures } = await surveyWorkspaces(candidates, { probe });
+  if (!workspaces.length) {
+    throw new RootrApiError(
+      failures ? '등록된 키로 워크스페이스 목록을 조회하지 못했습니다 (키 만료/취소 가능성).' : '보이는 워크스페이스가 없습니다.',
+      { hint: 'rootr.io > 설정 > API 키에서 계정 키(PAT)를 발급해 `rootr config --api-key <키>` 로 등록하세요.' },
+    );
+  }
+  let blocked = false;
   for (const w of workspaces) {
-    console.log(`${w.id}\t${w.name || w.slug || ''}`);
+    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[등록된 키로는 접근 불가]' : ''}`,
+    );
   }
+  if (blocked) {
+    console.error(
+      '\n"접근 불가" = 내 소속 워크스페이스지만 등록된 키가 워크스페이스 전용이라 못 엽니다.\n' +
+        '계정 키(PAT)를 등록하면 전부 열립니다: rootr.io > 설정 > API 키 → `rootr config --api-key <키>`',
+    );
+  }
+}
+
+async function cmdUse(args) {
+  const wanted = args._.join(' ').trim();
+  if (!wanted) throw new Error('사용법: rootr use <워크스페이스 id | 이름 | rootr.io 주소>');
+  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})`);
 }
 
 async function cmdAsk(args) {
@@ -431,6 +472,8 @@ async function main() {
       return cmdAsk(args);
     case 'config':
       return cmdConfig(args);
+    case 'use':
+      return cmdUse(args);
     case 'mcp':
       return cmdMcp(args);
     default:

package/lib/credentials.js

@@ -0,0 +1,169 @@
+import { loadConfig, saveConfig, upsertKey } from './config.js';
+import { RootrClient } from './client.js';
+import { parseRootrUrl } from './resolve.js';
+
+/**
+ * Every credential this machine can use, default key first. An account key
+ * (PAT) reaches every workspace its owner belongs to; a workspace key reaches
+ * one. Which one applies to a given workspace is discovered by asking the API
+ * (listWorkspaces / a workspace-scoped call), never guessed from the key.
+ *
+ * Shared by the CLI (`rootr ws`, `rootr use`) and the MCP tools so both answer
+ * "which workspaces can I actually open?" the same way.
+ */
+export function candidateClients(cfg = loadConfig()) {
+  const out = [];
+  const seen = new Set();
+  if (cfg.apiKey) {
+    seen.add(cfg.apiKey);
+    out.push({ apiKey: cfg.apiKey, label: 'default', client: new RootrClient({ ...cfg, apiKey: cfg.apiKey }) });
+  }
+  for (const k of cfg.keys || []) {
+    if (!k.apiKey || seen.has(k.apiKey)) continue;
+    seen.add(k.apiKey);
+    out.push({ apiKey: k.apiKey, label: k.label || k.workspace || 'key', client: new RootrClient({ ...cfg, apiKey: k.apiKey }) });
+  }
+  return out;
+}
+
+/**
+ * Collect every workspace the registered keys can see, and (when asked) which
+ * of them a key can actually open — listing is not a capability probe: a
+ * workspace key lists all of its owner's workspaces while being rejected by
+ * every one but its own.
+ */
+export async function surveyWorkspaces(candidates, { probe = false, probeLimit = 12 } = {}) {
+  const seen = new Map();
+  const reachable = new Set();
+  let listed = 0;
+  let failures = 0;
+  for (const { client } of candidates) {
+    let list = [];
+    try {
+      list = await client.listWorkspaces();
+      listed += 1;
+    } catch {
+      failures += 1;
+      continue; // a revoked/foreign key shouldn't hide the others
+    }
+    for (const w of list) if (!seen.has(w.id)) seen.set(w.id, w);
+    if (!probe) continue;
+    for (const w of list.slice(0, probeLimit)) {
+      if (reachable.has(w.id)) continue;
+      try {
+        await client.request(`/workspaces/${encodeURIComponent(w.id)}`);
+        reachable.add(w.id);
+      } catch {
+        // scoped key rejected here; another key may still cover it
+      }
+    }
+  }
+  return { workspaces: [...seen.values()], reachable, listed, failures };
+}
+
+/**
+ * Resolve "which workspace did the user mean, and which key opens it?" from an
+ * id, a name, or a rootr.io URL. Returns either { workspace, candidate } or a
+ * { error } describing the cause AND the next step — a bare "not found" is what
+ * used to send agents guessing at invitations for workspaces the user owns.
+ */
+export async function resolveWorkspaceSwitch(wantedRaw, cfg = loadConfig()) {
+  const url = parseRootrUrl(wantedRaw);
+  const wanted = (url ? url.workspaceId : wantedRaw).trim();
+  const wantedLower = wanted.toLowerCase();
+  const candidates = candidateClients(cfg);
+  if (!candidates.length) {
+    return {
+      error:
+        '이 컴퓨터에 등록된 Rootr 키가 없습니다.\n' +
+        '조치: rootr.io > 설정 > API 키에서 계정 키(PAT)를 발급받아 `rootr config --api-key <키>` 로 등록하세요.',
+    };
+  }
+
+  // Step 1 — resolve the name/id to a real workspace. /workspaces lists the
+  // KEY OWNER's workspaces, so any key can answer this.
+  let target = null;
+  const visible = [];
+  let listed = 0;
+  for (const candidate of candidates) {
+    let list = [];
+    try {
+      list = await candidate.client.listWorkspaces();
+      listed += 1;
+    } catch {
+      continue;
+    }
+    for (const w of list) if (!visible.some((v) => v.id === w.id)) visible.push(w);
+    const hit = list.find(
+      (w) => w.id === wanted || (w.name || '').toLowerCase() === wantedLower || (w.slug || '').toLowerCase() === wantedLower,
+    );
+    if (hit) {
+      target = hit;
+      break;
+    }
+  }
+
+  // Step 2 — find a key that can actually WORK in it.
+  let usable = null;
+  let lastRejection = null;
+  if (target) {
+    for (const candidate of candidates) {
+      try {
+        await candidate.client.request(`/workspaces/${encodeURIComponent(target.id)}`);
+        usable = candidate;
+        break;
+      } catch (err) {
+        lastRejection = err;
+      }
+    }
+  }
+
+  // Listing can be unavailable (a legacy key with no owner attached gets 403 on
+  // /workspaces) while that key still opens the very workspace being asked for.
+  if (!target) {
+    for (const candidate of candidates) {
+      try {
+        const ws = await candidate.client.request(`/workspaces/${encodeURIComponent(wanted)}`);
+        if (ws && ws.id) return { workspace: ws, candidate };
+      } catch (err) {
+        lastRejection = err;
+      }
+    }
+  }
+  if (target && usable) return { workspace: target, candidate: usable };
+
+  if (target) {
+    const scoped = lastRejection && lastRejection.status === 403;
+    return {
+      error:
+        `"${target.name || target.id}" (${target.id}) 는 접근 권한 목록에는 있지만, 등록된 키로는 열 수 없습니다` +
+        `${target.role ? ` (내 역할: ${target.role})` : ''}.\n` +
+        (scoped
+          ? '원인: 지금 등록된 키가 다른 워크스페이스 전용 키입니다 (워크스페이스 키는 자기 워크스페이스 밖에서 403).\n'
+          : `원인: ${lastRejection ? lastRejection.message : '알 수 없음'}\n`) +
+        '조치 (둘 중 하나, 사용자가 직접):\n' +
+        '1) rootr.io > 설정 > API 키에서 계정 키(PAT)를 발급 → `rootr config --api-key <키>` (모든 워크스페이스에 통함)\n' +
+        `2) 그 워크스페이스용 키를 발급 → \`rootr config --add-key <키> --workspace ${target.id}\``,
+    };
+  }
+  const seenList = visible.length
+    ? `\n지금 보이는 워크스페이스: ${visible.map((w) => `${w.name || w.slug || ''}(${w.id})`).join(', ')}`
+    : '';
+  return {
+    error:
+      listed === 0
+        ? '등록된 키로 워크스페이스 목록을 조회하지 못했습니다 (키가 만료/취소되었거나 목록 권한이 없음).\n' +
+          '조치: rootr.io > 설정 > API 키에서 계정 키(PAT)를 새로 발급해 `rootr config --api-key <키>` 로 등록하세요.'
+        : `"${wanted}" 워크스페이스가 내 소속 목록에 없습니다.${seenList}\n` +
+          '조치: 주소가 맞는지 확인하고, 다른 계정의 워크스페이스라면 그 계정으로 발급한 키를 ' +
+          '`rootr config --add-key <키>` 로 등록하세요.',
+  };
+}
+
+/** Persist the switch: remember the workspace and which key covers it. */
+export function rememberWorkspace({ workspace, candidate }, cfg = loadConfig()) {
+  saveConfig({ workspace: workspace.id });
+  if (candidate && candidate.apiKey !== cfg.apiKey) {
+    upsertKey({ apiKey: candidate.apiKey, workspace: workspace.id, label: candidate.label });
+  }
+}

package/lib/mcp-tools/workspaces.js

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 
 import { textResult, jsonResult, errorResult, makeClient, requireWorkspace } from './shared.js';
-import { loadConfig, saveConfig, keyForWorkspace, upsertKey } from '../config.js';
+import { loadConfig } from '../config.js';
 import { currentClientOverride } from '../context.js';
-import { RootrClient } from '../client.js';
+import { candidateClients, rememberWorkspace, resolveWorkspaceSwitch, surveyWorkspaces } from '../credentials.js';
 import { parseRootrUrl } from '../resolve.js';
 
 /**
@@ -26,28 +26,6 @@ function parseTree(tree) {
   }
 }
 
-/**
- * Every credential this machine can use, default key first. An account key
- * (PAT) reaches every workspace its owner belongs to; workspace keys reach one.
- * Which one applies to a given workspace is discovered by asking the API
- * (listWorkspaces), not guessed from the key string.
- */
-function candidateClients() {
-  const cfg = loadConfig();
-  const out = [];
-  const seen = new Set();
-  if (cfg.apiKey) {
-    seen.add(cfg.apiKey);
-    out.push({ apiKey: cfg.apiKey, label: 'default', client: new RootrClient({ ...cfg, apiKey: cfg.apiKey }) });
-  }
-  for (const k of cfg.keys || []) {
-    if (!k.apiKey || seen.has(k.apiKey)) continue;
-    seen.add(k.apiKey);
-    out.push({ apiKey: k.apiKey, label: k.label || k.workspace || 'key', client: new RootrClient({ ...cfg, apiKey: k.apiKey }) });
-  }
-  return out;
-}
-
 /** Workspace listing and scaffolding tools: rootr_workspaces, rootr_scaffold_plan, rootr_create_workspace, rootr_scaffold_apply. */
 export function registerWorkspaceTools(server) {
   server.registerTool(
@@ -69,12 +47,10 @@ export function registerWorkspaceTools(server) {
     },
     async ({ workspace }) => {
       try {
-        const wantedUrl = parseRootrUrl(workspace);
-        const wanted = (wantedUrl ? wantedUrl.workspaceId : workspace).trim();
-        const wantedLower = wanted.toLowerCase();
-
-        if (currentClientOverride()) {
-          const hosted = currentClientOverride();
+        const hosted = currentClientOverride();
+        if (hosted) {
+          const url = parseRootrUrl(workspace);
+          const wanted = (url ? url.workspaceId : workspace).trim();
           if (wanted === hosted.workspace) {
             return textResult(`이미 이 워크스페이스(${hosted.workspace})에 연결되어 있습니다. 그대로 진행하세요.`);
           }
@@ -86,117 +62,10 @@ export function registerWorkspaceTools(server) {
             ),
           );
         }
-        const candidates = candidateClients();
-        if (!candidates.length) {
-          return errorResult(
-            new Error(
-              '이 컴퓨터에 등록된 Rootr 키가 없습니다.\n' +
-                '조치: rootr.io > 설정 > API 키에서 계정 키(PAT)를 발급받아 `rootr config --api-key <키>` 로 등록하세요.',
-            ),
-          );
-        }
-
-        // Step 1 — resolve the name/id to a real workspace. /workspaces lists
-        // the KEY OWNER's workspaces, so any key can answer this.
-        let target = null;
-        let listed = 0;
-        const visible = [];
-        for (const candidate of candidates) {
-          let list = [];
-          try {
-            list = await candidate.client.listWorkspaces();
-            listed += 1;
-          } catch {
-            continue;
-          }
-          for (const w of list) if (!visible.some((v) => v.id === w.id)) visible.push(w);
-          const hit = list.find(
-            (w) => w.id === wanted || (w.name || '').toLowerCase() === wantedLower || (w.slug || '').toLowerCase() === wantedLower,
-          );
-          if (hit) {
-            target = hit;
-            break;
-          }
-        }
-
-        // Step 2 — find a key that can actually WORK in it. Listing is not a
-        // capability probe: a workspace-scoped key still lists all of its
-        // owner's workspaces while being rejected by every one but its own.
-        // Only a workspace-scoped call proves the binding.
-        let usable = null;
-        let lastRejection = null;
-        if (target) {
-          for (const candidate of candidates) {
-            try {
-              await candidate.client.request(`/workspaces/${encodeURIComponent(target.id)}`);
-              usable = candidate;
-              break;
-            } catch (err) {
-              lastRejection = err;
-              continue;
-            }
-          }
-        }
-        // Listing can be unavailable (a legacy key with no owner attached gets
-        // 403 on /workspaces) — but that key may still be able to open the very
-        // workspace being asked for. Ask the workspace directly before giving up.
-        let match = target && usable ? { workspace: target, candidate: usable } : null;
-        if (!match && !target) {
-          for (const candidate of candidates) {
-            try {
-              const ws = await candidate.client.request(`/workspaces/${encodeURIComponent(wanted)}`);
-              if (ws && ws.id) {
-                match = { workspace: ws, candidate };
-                break;
-              }
-            } catch (err) {
-              lastRejection = err;
-            }
-          }
-        }
-
-        // Listed-but-unreachable is the common real case: the workspace IS the
-        // user's, but every registered key is workspace-scoped to another one.
-        // Name that cause explicitly — a vague "no key" message makes the
-        // assistant invent permission problems (asking for an invite to the
-        // user's OWN workspace).
-        if (target && !usable) {
-          const scoped = lastRejection && lastRejection.status === 403;
-          return errorResult(
-            new Error(
-              `"${target.name || target.id}" (${target.id}) 는 접근 권한 목록에는 있지만, 등록된 키로는 열 수 없습니다` +
-                `${target.role ? ` (내 역할: ${target.role})` : ''}.\n` +
-                (scoped
-                  ? '원인: 지금 등록된 키가 다른 워크스페이스 전용 키입니다 (워크스페이스 키는 자기 워크스페이스 밖에서 403).\n'
-                  : `원인: ${lastRejection ? lastRejection.message : '알 수 없음'}\n`) +
-                '조치 (둘 중 하나, 사용자가 직접):\n' +
-                '1) rootr.io > 설정 > API 키에서 계정 키(PAT)를 발급 → `rootr config --api-key <키>` (모든 워크스페이스에 통함)\n' +
-                `2) 그 워크스페이스용 키를 발급 → \`rootr config --add-key <키> --workspace ${target.id}\``,
-            ),
-          );
-        }
-        if (!match) {
-          const seenList = visible.length
-            ? `\n지금 보이는 워크스페이스: ${visible.map((w) => `${w.name || w.slug || ''}(${w.id})`).join(', ')}`
-            : '';
-          return errorResult(
-            new Error(
-              listed === 0
-                ? '등록된 키로 워크스페이스 목록을 조회하지 못했습니다 (키가 만료/취소되었거나 목록 권한이 없음).\n' +
-                  '조치: rootr.io > 설정 > API 키에서 계정 키(PAT)를 새로 발급해 `rootr config --api-key <키>` 로 등록하세요.'
-                : `"${wanted}" 워크스페이스가 내 소속 목록에 없습니다.${seenList}\n` +
-                  '조치: 주소가 맞는지 확인하고, 다른 계정의 워크스페이스라면 그 계정으로 발급한 키를 ' +
-                  '`rootr config --add-key <키>` 로 등록하세요.',
-            ),
-          );
-        }
         const cfg = loadConfig();
-        saveConfig({ workspace: match.workspace.id });
-        // Remember which key covers this workspace so later calls resolve
-        // directly instead of probing every key again.
-        if (match.candidate.apiKey !== cfg.apiKey) {
-          upsertKey({ apiKey: match.candidate.apiKey, workspace: match.workspace.id, label: match.candidate.label });
-        }
+        const match = await resolveWorkspaceSwitch(workspace, cfg);
+        if (match.error) return errorResult(new Error(match.error));
+        rememberWorkspace(match, cfg);
         const name = match.workspace.name || match.workspace.slug || '';
         return textResult(`활성 워크스페이스를 "${name}" (${match.workspace.id}) 로 바꿨습니다. 이후 도구 호출은 여기에 적용됩니다.`);
       } catch (err) {
@@ -241,52 +110,25 @@ export function registerWorkspaceTools(server) {
           );
         }
         const cfg = loadConfig();
-        const active = cfg.workspace;
+        const candidates = candidateClients(cfg);
         // Probing costs one API call per workspace (they count against the
         // daily read quota), so only do it in the case it actually diagnoses:
         // no account key registered, i.e. every credential here is scoped to
         // one workspace and most of the list is unusable.
-        const probeReachability = !cfg.apiKey && (cfg.keys || []).length > 0;
-        const seen = new Map();
-        const reached = [];
-        let failures = 0;
-        for (const { client, label } of candidateClients()) {
-          let list = [];
-          try {
-            list = await client.listWorkspaces();
-          } catch {
-            failures += 1;
-            continue; // a revoked/foreign key shouldn't hide the others
-          }
-          for (const w of list) if (!seen.has(w.id)) seen.set(w.id, w);
-          // Which workspace each key can actually WRITE in is what decides
-          // whether rootr_use_workspace will succeed — listing does not.
-          for (const w of probeReachability ? list.slice(0, 12) : []) {
-            if (reached.includes(w.id)) continue;
-            try {
-              await client.request(`/workspaces/${encodeURIComponent(w.id)}`);
-              reached.push(w.id);
-            } catch {
-              // scoped key rejected here; another key may still cover it
-            }
-          }
-          void label;
-        }
-        const rows = [...seen.values()].map(
-          (w) =>
-            `${w.id === active ? '* ' : '  '}${w.id}\t${w.name || w.slug || ''}` +
-            (!probeReachability || reached.includes(w.id) ? '' : '\t[등록된 키로는 접근 불가]'),
-        );
-        if (!rows.length) {
+        const probe = !cfg.apiKey && (cfg.keys || []).length > 0;
+        const { workspaces, reachable, failures } = await surveyWorkspaces(candidates, { probe });
+        if (!workspaces.length) {
           return textResult(
-            failures
-              ? '등록된 키로 워크스페이스 목록을 조회하지 못했습니다 (키 만료/취소 가능성).\n' +
-                  '조치: rootr.io > 설정 > API 키에서 계정 키(PAT)를 발급해 `rootr config --api-key <키>` 로 등록하세요.'
-              : '이 컴퓨터에 등록된 Rootr 키가 없습니다.\n' +
-                  '조치: rootr.io > 설정 > API 키에서 계정 키(PAT)를 발급해 `rootr config --api-key <키>` 로 등록하세요.',
+            (failures ? '등록된 키로 워크스페이스 목록을 조회하지 못했습니다 (키 만료/취소 가능성).\n' : '이 컴퓨터에 등록된 Rootr 키가 없습니다.\n') +
+              '조치: rootr.io > 설정 > API 키에서 계정 키(PAT)를 발급해 `rootr config --api-key <키>` 로 등록하세요.',
           );
         }
-        const blocked = rows.some((r) => r.includes('접근 불가'));
+        const rows = workspaces.map(
+          (w) =>
+            `${w.id === cfg.workspace ? '* ' : '  '}${w.id}\t${w.name || w.slug || ''}` +
+            (!probe || reachable.has(w.id) ? '' : '\t[등록된 키로는 접근 불가]'),
+        );
+        const blocked = probe && workspaces.some((w) => !reachable.has(w.id));
         return textResult(
           `${rows.join('\n')}\n\n(* = 현재 워크스페이스, rootr_use_workspace 로 전환)` +
             (blocked

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rootr-cli",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Official Rootr CLI + MCP server — read, write, edit and search Rootr documents from the shell or from an AI agent.",
   "type": "module",
   "bin": {