pleumrouter 0.5.45 → 0.5.47

package/src/wire.mjs

@@ -1,9 +1,22 @@
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readlinkSync,
+  realpathSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { ROOT, V1, authFetch, getActiveContext } from "./config.mjs";
 import { tomlBasicString, RECIPES } from "./recipes.mjs";
 import { t } from "./i18n.mjs";
+import { selectAndBindWorkspace, workspaceLabel } from "./workspace.mjs";
 
 export const WIRE_DEFAULT_TOOLS = ["claude", "codex"];
 export const WIRE_TOOLS = [
@@ -99,6 +112,35 @@ function readText(path) {
   }
 }
 
+// 파싱이 깨진 설정 파일은 덮어쓰지 않고 멈춘다(사용자 설정을 {}로 날리지 않게).
+class InvalidConfigError extends Error {}
+
+function parseJsonObject(text) {
+  if (!text || !text.trim()) return {};
+  let obj;
+  try {
+    obj = JSON.parse(text);
+  } catch {
+    throw new InvalidConfigError("invalid JSON");
+  }
+  if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
+    throw new InvalidConfigError("not a JSON object");
+  }
+  return obj;
+}
+
+// 설정 파일을 읽어 변환한다. 깨졌으면 경로를 붙여 던지고, 호출자는 백업·쓰기 전에 이것을 쓴다.
+function transformConfig(path, transform) {
+  try {
+    return transform(readText(path));
+  } catch (e) {
+    if (e instanceof InvalidConfigError) {
+      throw new Error(t("{path}: not valid JSON — fix or remove it, nothing was written", { path }));
+    }
+    throw e;
+  }
+}
+
 export function writeSecretFile(path, contents, mode = 0o600) {
   mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
   const tmp = `${path}.pleum-tmp-${process.pid}`;
@@ -154,15 +196,52 @@ function removeRootValue(toml, name) {
   return root.replace(new RegExp(`^${name}\\s*=\\s*.+\\n?`, "m"), "") + rest;
 }
 
+const isPlainObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+
+// 블록을 지운 뒤 남는 구분 빈 줄(wire가 붙인 것)을 정리한다: 끝의 연속 줄바꿈은 하나로, 남은 게 없으면 "".
+function tidyUnwired(text) {
+  const out = text.trimStart().replace(/\n{2,}$/, "\n");
+  return out.trim() ? out : "";
+}
+
+// 키 순서를 order에 맞춰 되살린다. 사라진 키는 건너뛰고, 그 뒤에 생긴 키는 현재 순서로 뒤에 붙는다.
+function reorder(obj, order = []) {
+  const out = {};
+  for (const key of order) if (Object.hasOwn(obj, key)) out[key] = obj[key];
+  return Object.assign(out, obj);
+}
+
+// pleum이 배선한 Claude env인가: 게이트웨이가 우리 ROOT이거나 토큰이 plm_ 키.
+function claudeEnvWired(env) {
+  const base = String(env?.ANTHROPIC_BASE_URL ?? "").replace(/\/+$/, "");
+  return base === ROOT || String(env?.ANTHROPIC_AUTH_TOKEN ?? "").startsWith("plm_");
+}
+
+// wire가 덮어쓰기 전의 사용자 값(claude·agy). 이미 pleum이 배선한 텍스트는 pleum 값을 원본으로 오인하므로 null.
+// agy의 "gemini" provider는 launch.mjs와 같이 pleum 잔재로 본다.
+function pickPrevious(tool, text) {
+  let obj;
+  try {
+    obj = parseJsonObject(text);
+  } catch {
+    return null;
+  }
+  if (tool === "agy") {
+    return obj.modelProvider === "gemini" ? null : { model: obj.model, modelProvider: obj.modelProvider };
+  }
+  if (claudeEnvWired(obj.env)) return null;
+  const env = isPlainObject(obj.env) ? obj.env : undefined;
+  return {
+    env: Object.fromEntries(CLAUDE_ENV_KEYS.filter((k) => env?.[k] !== undefined).map((k) => [k, env[k]])),
+    model: obj.model,
+    order: Object.keys(obj),
+    envOrder: env && Object.keys(env),
+  };
+}
+
 // ── Claude settings.json ──────────────────────────────────────────
 export function wireClaudeSettings(existingJson, { root, key, model } = {}) {
-  let obj = {};
-  if (existingJson && existingJson.trim()) {
-    try {
-      obj = JSON.parse(existingJson);
-    } catch {}
-    if (obj === null || typeof obj !== "object" || Array.isArray(obj)) obj = {};
-  }
+  const obj = parseJsonObject(existingJson);
   obj.env = {
     ...(obj.env && typeof obj.env === "object" && !Array.isArray(obj.env) ? obj.env : {}),
     ANTHROPIC_BASE_URL: root,
@@ -192,23 +271,28 @@ export function wireClaudeSettings(existingJson, { root, key, model } = {}) {
   return `${JSON.stringify(obj, null, 2)}\n`;
 }
 
-export function unwireClaudeSettings(existingJson) {
-  if (!existingJson || !existingJson.trim()) return `${JSON.stringify({}, null, 2)}\n`;
-  let obj = {};
-  try {
-    obj = JSON.parse(existingJson);
-  } catch {}
-  if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
-    return `${JSON.stringify({}, null, 2)}\n`;
-  }
-  if (obj.env && typeof obj.env === "object" && !Array.isArray(obj.env)) {
+// previous: wire 전 사용자 값(pickPrevious). 없으면 pleum 키만 지운다.
+export function unwireClaudeSettings(existingJson, previous = {}) {
+  const obj = parseJsonObject(existingJson);
+  // wire는 obj.model과 같은 값을 ANTHROPIC_CUSTOM_MODEL_OPTION에도 쓴다 — claude- 접두사가 없는 모델도 이걸로 알아본다.
+  const customModel = isPlainObject(obj.env) ? obj.env.ANTHROPIC_CUSTOM_MODEL_OPTION : undefined;
+  if (isPlainObject(obj.env)) {
     for (const envKey of CLAUDE_ENV_KEYS) delete obj.env[envKey];
-    if (Object.keys(obj.env).length === 0) delete obj.env;
   }
-  if (obj.model && typeof obj.model === "string" && (obj.model.startsWith("anthropic/") || obj.model.startsWith("pleum/"))) {
-    delete obj.model;
+  if (previous.env && Object.keys(previous.env).length > 0) {
+    obj.env = { ...(isPlainObject(obj.env) ? obj.env : {}), ...previous.env };
   }
-  return `${JSON.stringify(obj, null, 2)}\n`;
+  if (isPlainObject(obj.env)) {
+    obj.env = reorder(obj.env, previous.envOrder);
+    if (Object.keys(obj.env).length === 0 && !previous.envOrder) delete obj.env;
+  }
+  // model은 pleum이 넣은 값이거나 billing wire가 지워 비어 있을 때만 되돌린다 — 그 뒤 사용자가 바꾼 값은 둔다.
+  const pleumModel = typeof obj.model === "string" && (obj.model.startsWith("anthropic/") || obj.model.startsWith("pleum/") || obj.model === customModel);
+  if (pleumModel || obj.model === undefined) {
+    if (previous.model === undefined) delete obj.model;
+    else obj.model = previous.model;
+  }
+  return `${JSON.stringify(reorder(obj, previous.order), null, 2)}\n`;
 }
 
 // ── Codex config.toml ─────────────────────────────────────────────
@@ -216,18 +300,21 @@ export function wireCodexToml(existingToml, { v1, key, model = "gpt-6.1-sol", bi
   const src = existingToml ?? "";
   const previousProvider = previousValue(src, "model_provider");
   const previousModel = previousValue(src, "model");
-  const targetModel = billingOnly && previousModel ? previousModel : model;
 
   let body = stripWireBlock(src);
   body = removeTomlTable(body, "model_providers.pleum.http_headers");
   body = removeTomlTable(body, "model_providers.pleum");
   body = removeRootValue(removeRootValue(body, "model_provider"), "model");
 
+  // billing-only는 사용자 모델을 유지한다. previousModel은 이미 TOML 값("...")이라 따옴표를 다시 씌우지 않고,
+  // 원래 모델이 없었으면 model 줄을 생략해 Codex 기본값을 쓴다.
+  const modelLine = billingOnly
+    ? (previousModel ? `model = ${previousModel}\n` : "")
+    : `model = ${tomlBasicString(model)}\n`;
   const rootBlock = `${WIRE_MARKER_START}
 # previous_model_provider = ${previousProvider}
 # previous_model = ${previousModel}
-model = ${tomlBasicString(targetModel)}
-model_provider = "pleum"
+${modelLine}model_provider = "pleum"
 ${WIRE_MARKER_END}
 `;
   const providerBlock = `[model_providers.pleum]
@@ -255,18 +342,15 @@ export function unwireCodexToml(existingToml) {
     previousModel ? `model = ${previousModel}` : "",
     previousProvider ? `model_provider = ${previousProvider}` : "",
   ].filter(Boolean).join("\n");
-  return `${restored ? `${restored}\n\n` : ""}${body.trim()}`.replace(/\n{3,}/g, "\n\n").trimStart() + "\n";
+  // 복원한 root 줄 바로 뒤가 root 키면 붙이고(원래 모양), 테이블이면 빈 줄 하나를 둔다.
+  const rest = body.trim();
+  const gap = !restored || !rest ? "" : rest.startsWith("[") ? "\n\n" : "\n";
+  return `${restored}${gap}${rest}`.replace(/\n{3,}/g, "\n\n").trimStart() + "\n";
 }
 
 // ── OpenCode (opencode.json & auth.json) ──────────────────────────
 export function wireOpenCodeJson(existingJson, { v1, models = [], defaultModel } = {}) {
-  let obj = {};
-  if (existingJson && existingJson.trim()) {
-    try {
-      obj = JSON.parse(existingJson);
-    } catch {}
-  }
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) obj = {};
+  const obj = parseJsonObject(existingJson);
 
   obj.provider = obj.provider || {};
   const modelEntries = Object.fromEntries(models.map((id) => [id, {}]));
@@ -292,12 +376,7 @@ export function wireOpenCodeJson(existingJson, { v1, models = [], defaultModel }
 }
 
 export function unwireOpenCodeJson(existingJson) {
-  if (!existingJson || !existingJson.trim()) return `${JSON.stringify({}, null, 2)}\n`;
-  let obj = {};
-  try {
-    obj = JSON.parse(existingJson);
-  } catch {}
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return `${JSON.stringify({}, null, 2)}\n`;
+  const obj = parseJsonObject(existingJson);
 
   if (obj.provider && obj.provider.pleum) {
     delete obj.provider.pleum;
@@ -315,24 +394,13 @@ export function unwireOpenCodeJson(existingJson) {
 }
 
 export function wireOpenCodeAuth(existingJson, key) {
-  let obj = {};
-  if (existingJson && existingJson.trim()) {
-    try {
-      obj = JSON.parse(existingJson);
-    } catch {}
-  }
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) obj = {};
+  const obj = parseJsonObject(existingJson);
   obj.pleum = { type: "api", key };
   return `${JSON.stringify(obj, null, 2)}\n`;
 }
 
 export function unwireOpenCodeAuth(existingJson) {
-  if (!existingJson || !existingJson.trim()) return `${JSON.stringify({}, null, 2)}\n`;
-  let obj = {};
-  try {
-    obj = JSON.parse(existingJson);
-  } catch {}
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return `${JSON.stringify({}, null, 2)}\n`;
+  const obj = parseJsonObject(existingJson);
   delete obj.pleum;
   return `${JSON.stringify(obj, null, 2)}\n`;
 }
@@ -359,20 +427,12 @@ export function wireAiderYaml(existingYaml = "", { v1, key, model } = {}) {
 }
 
 export function unwireAiderYaml(existingYaml = "") {
-  return (existingYaml || "")
-    .replace(new RegExp(`${WIRE_MARKER_START}[\\s\\S]*?${WIRE_MARKER_END}\\n?`, "g"), "")
-    .trimStart();
+  return tidyUnwired((existingYaml || "").replace(new RegExp(`${WIRE_MARKER_START}[\\s\\S]*?${WIRE_MARKER_END}\\n?`, "g"), ""));
 }
 
 // ── Crush ~/.config/crush/crush.json ──────────────────────────────
 export function wireCrushConfig(existingJson, { v1, key, models = [] } = {}) {
-  let obj = {};
-  if (existingJson && existingJson.trim()) {
-    try {
-      obj = JSON.parse(existingJson);
-    } catch {}
-  }
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) obj = {};
+  const obj = parseJsonObject(existingJson);
   obj.providers = obj.providers || {};
   obj.providers.pleum = {
     type: "openai-compat",
@@ -384,12 +444,7 @@ export function wireCrushConfig(existingJson, { v1, key, models = [] } = {}) {
 }
 
 export function unwireCrushConfig(existingJson) {
-  if (!existingJson || !existingJson.trim()) return `${JSON.stringify({}, null, 2)}\n`;
-  let obj = {};
-  try {
-    obj = JSON.parse(existingJson);
-  } catch {}
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return `${JSON.stringify({}, null, 2)}\n`;
+  const obj = parseJsonObject(existingJson);
   if (obj.providers && obj.providers.pleum) {
     delete obj.providers.pleum;
     if (Object.keys(obj.providers).length === 0) delete obj.providers;
@@ -399,13 +454,7 @@ export function unwireCrushConfig(existingJson) {
 
 // ── Pi ~/.pi/agent/models.json ────────────────────────────────────
 export function wirePiConfig(existingJson, { v1, key, models = [] } = {}) {
-  let obj = {};
-  if (existingJson && existingJson.trim()) {
-    try {
-      obj = JSON.parse(existingJson);
-    } catch {}
-  }
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) obj = {};
+  const obj = parseJsonObject(existingJson);
   obj.providers = obj.providers || {};
   obj.providers.pleum = {
     baseUrl: v1,
@@ -417,12 +466,7 @@ export function wirePiConfig(existingJson, { v1, key, models = [] } = {}) {
 }
 
 export function unwirePiConfig(existingJson) {
-  if (!existingJson || !existingJson.trim()) return `${JSON.stringify({}, null, 2)}\n`;
-  let obj = {};
-  try {
-    obj = JSON.parse(existingJson);
-  } catch {}
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return `${JSON.stringify({}, null, 2)}\n`;
+  const obj = parseJsonObject(existingJson);
   if (obj.providers && obj.providers.pleum) {
     delete obj.providers.pleum;
     if (Object.keys(obj.providers).length === 0) delete obj.providers;
@@ -432,45 +476,114 @@ export function unwirePiConfig(existingJson) {
 
 // ── Antigravity ~/.gemini/antigravity-cli/settings.json ────────────
 export function wireAgySettings(existingJson, { model } = {}) {
-  let obj = {};
-  if (existingJson && existingJson.trim()) {
-    try {
-      obj = JSON.parse(existingJson);
-    } catch {}
-  }
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) obj = {};
+  const obj = parseJsonObject(existingJson);
   obj.modelProvider = "gemini";
   if (model) obj.model = model;
   return `${JSON.stringify(obj, null, 2)}\n`;
 }
 
-export function unwireAgySettings(existingJson) {
-  if (!existingJson || !existingJson.trim()) return `${JSON.stringify({}, null, 2)}\n`;
-  let obj = {};
-  try {
-    obj = JSON.parse(existingJson);
-  } catch {}
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return `${JSON.stringify({}, null, 2)}\n`;
-  if (obj.modelProvider === "gemini") delete obj.modelProvider;
-  delete obj.model;
+// previous: wire 전 사용자 값. wiredModel: undefined=모름(옛 호출, model을 지운다), null=pleum이 model을 쓰지 않음, 문자열=pleum이 쓴 값.
+// model은 pleum이 쓴 값일 때만 되돌린다.
+export function unwireAgySettings(existingJson, previous = {}, wiredModel) {
+  const obj = parseJsonObject(existingJson);
+  if (obj.modelProvider === "gemini") {
+    if (previous.modelProvider === undefined) delete obj.modelProvider;
+    else obj.modelProvider = previous.modelProvider;
+  }
+  if (wiredModel === undefined || obj.model === wiredModel) {
+    if (previous.model === undefined) delete obj.model;
+    else obj.model = previous.model;
+  }
   return `${JSON.stringify(obj, null, 2)}\n`;
 }
 
 // ── Shell function wrapper (rc files) ─────────────────────────────
-export function wireShellWrapper(existingRc = "", { tool, bin, envMap = {} } = {}) {
+// POSIX single quotes. `'\''` ends the quote, inserts a literal quote, and reopens it.
+export function posixSingleQuote(value) {
+  return "'" + String(value).replace(/'/g, "'\\''") + "'";
+}
+
+export function formatShellEnv(envMap = {}) {
+  const lines = Object.entries(envMap).map(
+    ([key, value]) => `export ${key}=${posixSingleQuote(value)}`,
+  );
+  return lines.length ? `${lines.join("\n")}\n` : "";
+}
+
+function shellEnvFile(paths, tool) {
+  const safe = String(tool).replace(/[^A-Za-z0-9._-]/g, "_");
+  return join(paths.home, ".pleum", "wire-env", `${safe}.env`);
+}
+
+function shellRcTarget(path) {
+  let st;
+  try {
+    st = lstatSync(path);
+  } catch {
+    return { dest: path, mode: 0o600, present: false };
+  }
+  if (!st.isSymbolicLink()) {
+    return { dest: path, mode: st.mode & 0o777, present: true };
+  }
+  let dest;
+  try {
+    dest = realpathSync(path);
+  } catch {
+    const link = readlinkSync(path);
+    dest = isAbsolute(link) ? link : resolve(dirname(path), link);
+  }
+  let mode = 0o600;
+  try {
+    mode = statSync(dest).mode & 0o777;
+  } catch {
+    // Dangling link: the file we create is new, so it gets the new-file mode.
+  }
+  return { dest, mode, present: true };
+}
+
+function readShellRc(path) {
+  const { dest, present } = shellRcTarget(path);
+  if (!present) return "";
+  return readText(dest) || "";
+}
+
+function writeShellRc(path, contents) {
+  // Rename onto the symlink path would replace the link. Write the target.
+  const { dest, mode } = shellRcTarget(path);
+  writeSecretFile(dest, contents, mode);
+}
+
+function wireShellTool(paths, tool, { bin, envMap }) {
+  const envFile = shellEnvFile(paths, tool);
+  writeSecretFile(envFile, formatShellEnv(envMap));
+  const nextRc = wireShellWrapper(readShellRc(paths.shellRc), { tool, bin, envFile });
+  writeShellRc(paths.shellRc, nextRc);
+}
+
+function unwireShellTool(paths, tool) {
+  if (shellRcTarget(paths.shellRc).present) {
+    writeShellRc(paths.shellRc, unwireShellWrapper(readShellRc(paths.shellRc), tool));
+  }
+  try {
+    unlinkSync(shellEnvFile(paths, tool));
+  } catch {
+    // Already removed.
+  }
+}
+
+export function wireShellWrapper(existingRc = "", { tool, bin, envFile } = {}) {
   const startMarker = `# pleum-wire:${tool}-start`;
   const endMarker = `# pleum-wire:${tool}-end`;
   const clean = (existingRc || "")
     .replace(new RegExp(`${startMarker}[\\s\\S]*?${endMarker}\\n?`, "g"), "")
     .trim();
 
-  const envAssignments = Object.entries(envMap)
-    .map(([k, v]) => `${k}=${JSON.stringify(String(v))}`)
-    .join(" ");
-
+  const source = envFile ? `. ${posixSingleQuote(envFile)}\n    ` : "";
   const block = `${startMarker}
 ${tool}() {
-  ${envAssignments} command ${bin || tool} "$@"
+  (
+    ${source}command ${bin || tool} "$@"
+  )
 }
 ${endMarker}`;
 
@@ -480,9 +593,7 @@ ${endMarker}`;
 export function unwireShellWrapper(existingRc = "", tool) {
   const startMarker = `# pleum-wire:${tool}-start`;
   const endMarker = `# pleum-wire:${tool}-end`;
-  return (existingRc || "")
-    .replace(new RegExp(`${startMarker}[\\s\\S]*?${endMarker}\\n?`, "g"), "")
-    .trimStart();
+  return tidyUnwired((existingRc || "").replace(new RegExp(`${startMarker}[\\s\\S]*?${endMarker}\\n?`, "g"), ""));
 }
 
 // ── Wired State Metadata (~/.pleum/wired-agents.json) ─────────────
@@ -501,13 +612,24 @@ export function writeWiredState(paths, state) {
 
 // ── Wire Status Check ─────────────────────────────────────────────
 export function getWireStatus(home = homedir()) {
-  const paths = wirePaths(home);
+  return wireStatusOf(wirePaths(home));
+}
+
+// paths를 그대로 받아, revert가 쓰는 rc 경로와 같은 기준으로 판정한다.
+function wireStatusOf(paths) {
   const state = readWiredState(paths);
   const status = {};
 
-  // 1. Claude
+  // 1. Claude — 게이트웨이/토큰이 pleum 것일 때만(사용자 본인 게이트웨이는 배선 아님). 파싱 불가(JSONC 등)는 예전 텍스트 검사.
   const claudeText = readText(paths.claude);
-  const claudeWired = Boolean(claudeText && claudeText.includes("ANTHROPIC_BASE_URL"));
+  const claudeWired = (() => {
+    if (!claudeText) return false;
+    try {
+      return claudeEnvWired(parseJsonObject(claudeText).env);
+    } catch {
+      return claudeText.includes("ANTHROPIC_BASE_URL");
+    }
+  })();
   status.claude = {
     tool: "claude",
     label: "Claude Code",
@@ -578,9 +700,10 @@ export function getWireStatus(home = homedir()) {
   };
 
   // 7. Antigravity (agy)
+  // settings의 gemini provider만으로는 사용자 본인 설정·launch 임시값과 구분이 안 되므로, rc 블록이나 배선 기록이 함께 있어야 한다.
   const agyText = readText(paths.agy);
   const rcText = readText(paths.shellRc) || "";
-  const agyWired = Boolean((agyText && agyText.includes('"modelProvider": "gemini"')) || rcText.includes("# pleum-wire:agy-start"));
+  const agyWired = Boolean(rcText.includes("# pleum-wire:agy-start") || (state.agy && agyText?.includes('"modelProvider": "gemini"')));
   status.agy = {
     tool: "agy",
     label: "Antigravity CLI",
@@ -612,13 +735,34 @@ function parseJsonBody(res) {
   return res.json().catch(() => ({}));
 }
 
+// 개인 과금은 소유자의 기본 공간이다. 조회가 실패하거나 없으면 null.
+async function findDefaultWorkspaceId(auth) {
+  try {
+    const res = await auth("/workspaces");
+    if (!res.ok) return null;
+    const data = await parseJsonBody(res);
+    const items = Array.isArray(data) ? data : [];
+    return items.find((w) => w.is_default === true && w.role === "owner")?.id ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// 개인 키 레코드에는 workspace_id 필드를 두지 않는다(공유 공간일 때만 남긴다).
+function withWorkspace(record, workspaceId) {
+  const next = { ...record };
+  delete next.workspace_id;
+  if (workspaceId) next.workspace_id = workspaceId;
+  return next;
+}
+
 export async function ensureWireKey({
   auth = authFetch,
   paths = wirePaths(),
   activeContext = getActiveContext(),
 } = {}) {
-  const targetWorkspaceId =
-    activeContext?.type === "workspace" ? activeContext.workspace_id : null;
+  // 과금 귀속은 키의 workspace_id가 정한다. 공유 공간이면 그 공간, 개인이면 소유자의 기본 공간.
+  const shared = activeContext?.type === "workspace" ? activeContext.workspace_id : null;
   const stored = (() => {
     try {
       return JSON.parse(readText(paths.wire) ?? "");
@@ -633,23 +777,23 @@ export async function ensureWireKey({
       const items = Array.isArray(data.items) ? data.items : [];
       const found = items.find((item) => String(item.id) === String(stored.id));
       if (found && found.is_active !== false) {
-        if (
-          targetWorkspaceId &&
-          String(found.workspace_id ?? "") !== String(targetWorkspaceId)
-        ) {
+        const target = shared ?? (await findDefaultWorkspaceId(auth));
+        const current = String(found.workspace_id ?? "");
+        if (target && current !== String(target)) {
           const moved = await auth(`/workspaces/keys/${stored.id}/move`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ target_workspace_id: targetWorkspaceId }),
+            body: JSON.stringify({ target_workspace_id: target }),
           });
           if (moved.ok) {
-            const movedRecord = { ...stored, workspace_id: targetWorkspaceId };
+            const movedRecord = withWorkspace(stored, shared);
             writeSecretFile(paths.wire, `${JSON.stringify(movedRecord, null, 2)}\n`);
             return movedRecord;
           }
-        } else {
+        } else if (target || !current) {
           return stored;
         }
+        // 그 밖(개인인데 기본 공간을 못 찾았고 키가 공유 공간에 묶인 경우)은 아래에서 새로 발급한다.
       }
     } else if (listed.status !== 404) {
       return stored;
@@ -659,9 +803,10 @@ export async function ensureWireKey({
   const created = await auth("/keys", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
+    // workspace_id를 생략하면 서버가 소유자의 기본 공간에 키를 만든다.
     body: JSON.stringify({
       name: WIRE_KEY_NAME,
-      ...(targetWorkspaceId ? { workspace_id: targetWorkspaceId } : {}),
+      ...(shared ? { workspace_id: shared } : {}),
     }),
   });
   if (!created.ok) {
@@ -675,7 +820,7 @@ export async function ensureWireKey({
     id: data.id,
     key: data.key,
     name: data.name ?? WIRE_KEY_NAME,
-    ...(targetWorkspaceId ? { workspace_id: targetWorkspaceId } : {}),
+    ...(shared ? { workspace_id: shared } : {}),
   };
   writeSecretFile(paths.wire, `${JSON.stringify(record, null, 2)}\n`);
   return record;
@@ -714,7 +859,8 @@ export function wireHelp() {
 }
 
 export function unwireHelp() {
-  console.log(t("Usage: pleum unwire [claude|codex] [--revoke-key]\n"));
+  console.log(t("Usage: pleum unwire [tool...] [--revoke-key]\n"));
+  console.log(`  ${t("Omit the tool name to unwire every wired tool.")}`);
 }
 
 function printDesktopHints(record) {
@@ -736,14 +882,32 @@ function printDesktopHints(record) {
   console.log(t("kept the desktop key on this machine (logout does not delete it)"));
 }
 
+// 이 기록의 wire가 agy settings에 쓴 model: 문자열, 안 썼으면 null(billing·모델 없음), 기록이 없으면 undefined.
+function agyWiredModel(record) {
+  return record ? (record.mode === "billing" ? null : (record.model ?? null)) : undefined;
+}
+
+// 이미 배선 기록이 있으면 그 원본을 그대로 쓴다(재배선이 pleum 값을 원본으로 덮지 않게). 0.5.45~46 기록(previous 없음)은
+// 현재 파일이 이미 배선된 상태라 .pleum.bak에서, 기록이 없으면 현재 파일에서 뽑는다(배선된 파일이면 .pleum.bak).
+function originalValues(tool, paths, state, text) {
+  if (state[tool]?.previous) return state[tool].previous;
+  const fromText = state[tool] ? null : pickPrevious(tool, text);
+  return fromText ?? pickPrevious(tool, readText(paths[`${tool}Bak`])) ?? {};
+}
+
 export function applyToolWiring(tool, paths, { key, model, models = [], billingOnly = false, activeContext } = {}) {
   const state = readWiredState(paths);
   const mode = billingOnly ? "billing" : (models.length > 0 ? "list" : (model ? "custom" : "billing"));
+  let previous; // claude·agy가 덮어쓰는 사용자 원래 값 — unwire가 복원한다
 
   switch (tool) {
     case "claude": {
+      // 파싱이 끝나야 백업·쓰기로 간다 — 깨진 파일이면 .pleum.bak도 남기지 않는다.
+      const next = transformConfig(paths.claude, (text) => {
+        previous = originalValues(tool, paths, state, text);
+        return wireClaudeSettings(text, { root: ROOT, key, model: billingOnly ? undefined : model });
+      });
       backupOnce(paths.claude, paths.claudeBak);
-      const next = wireClaudeSettings(readText(paths.claude), { root: ROOT, key, model: billingOnly ? undefined : model });
       writeSecretFile(paths.claude, next);
       console.log(t("Wrote {path}", { path: paths.claude }));
       break;
@@ -756,10 +920,10 @@ export function applyToolWiring(tool, paths, { key, model, models = [], billingO
       break;
     }
     case "opencode": {
+      const nextJson = transformConfig(paths.opencode, (text) => wireOpenCodeJson(text, { v1: V1, models, defaultModel: model }));
+      const nextAuth = transformConfig(paths.opencodeAuth, (text) => wireOpenCodeAuth(text, key));
       backupOnce(paths.opencode, paths.opencodeBak);
-      const nextJson = wireOpenCodeJson(readText(paths.opencode), { v1: V1, models, defaultModel: model });
       writeSecretFile(paths.opencode, nextJson);
-      const nextAuth = wireOpenCodeAuth(readText(paths.opencodeAuth), key);
       writeSecretFile(paths.opencodeAuth, nextAuth);
       console.log(t("Wrote {path}", { path: paths.opencode }));
       break;
@@ -772,26 +936,30 @@ export function applyToolWiring(tool, paths, { key, model, models = [], billingO
       break;
     }
     case "crush": {
+      const next = transformConfig(paths.crush, (text) => wireCrushConfig(text, { v1: V1, key, models }));
       backupOnce(paths.crush, paths.crushBak);
-      const next = wireCrushConfig(readText(paths.crush), { v1: V1, key, models });
       writeSecretFile(paths.crush, next);
       console.log(t("Wrote {path}", { path: paths.crush }));
       break;
     }
     case "pi": {
+      const next = transformConfig(paths.pi, (text) => wirePiConfig(text, { v1: V1, key, models }));
       backupOnce(paths.pi, paths.piBak);
-      const next = wirePiConfig(readText(paths.pi), { v1: V1, key, models });
       writeSecretFile(paths.pi, next);
       console.log(t("Wrote {path}", { path: paths.pi }));
       break;
     }
     case "agy": {
+      const writes = billingOnly ? undefined : model;
+      const nextAgy = transformConfig(paths.agy, (text) => {
+        previous = originalValues(tool, paths, state, text);
+        // model 없이 재배선하면 이전 wire가 쓴 pleum model을 걷어낸다(파일이 마지막 wire 기록과 어긋나지 않게).
+        const stale = agyWiredModel(state.agy);
+        return wireAgySettings(!writes && stale ? unwireAgySettings(text, previous, stale) : text, { model: writes });
+      });
       backupOnce(paths.agy, paths.agyBak);
-      const nextAgy = wireAgySettings(readText(paths.agy), { model: billingOnly ? undefined : model });
       writeSecretFile(paths.agy, nextAgy);
-      const rcContent = readText(paths.shellRc) || "";
-      const nextRc = wireShellWrapper(rcContent, {
-        tool: "agy",
+      wireShellTool(paths, "agy", {
         bin: "agy",
         envMap: {
           GOOGLE_GEMINI_BASE_URL: ROOT,
@@ -799,17 +967,13 @@ export function applyToolWiring(tool, paths, { key, model, models = [], billingO
           GOOGLE_API_KEY: key,
         },
       });
-      writeSecretFile(paths.shellRc, nextRc, 0o644);
       console.log(t("Wrote {path}", { path: paths.agy }));
       break;
     }
     default: {
       const r = RECIPES[tool];
       if (r) {
-        const rcContent = readText(paths.shellRc) || "";
-        const envMap = r.env(key, model);
-        const nextRc = wireShellWrapper(rcContent, { tool, bin: r.bin, envMap });
-        writeSecretFile(paths.shellRc, nextRc, 0o644);
+        wireShellTool(paths, tool, { bin: r.bin, envMap: r.env(key, model) });
         console.log(t("Wrote {path}", { path: paths.shellRc }));
       }
       break;
@@ -823,17 +987,25 @@ export function applyToolWiring(tool, paths, { key, model, models = [], billingO
     models,
     workspace_id: activeContext?.workspace_id,
     workspace_name: activeContext?.workspace_name,
+    ...(previous && { previous }),
   };
   writeWiredState(paths, state);
 }
 
 export function revertToolWiring(tool, paths) {
   const state = readWiredState(paths);
+  // 기록도 없고 pleum이 배선한 흔적도 없으면 사용자 본인 설정이다 — 한 글자도 쓰지 않는다.
+  if (!state[tool] && !wireStatusOf(paths)[tool]?.wired) {
+    console.log(t("{tool} is not wired by PleumRouter; left unchanged.", { tool }));
+    return;
+  }
 
   switch (tool) {
     case "claude": {
       if (existsSync(paths.claude)) {
-        writeSecretFile(paths.claude, unwireClaudeSettings(readText(paths.claude)));
+        // 기록이 없으면(0.5.45~46) .pleum.bak에서 원래 값을 뽑는다.
+        const previous = state.claude?.previous ?? pickPrevious("claude", readText(paths.claudeBak)) ?? {};
+        writeSecretFile(paths.claude, transformConfig(paths.claude, (text) => unwireClaudeSettings(text, previous)));
         console.log(t("Removed PleumRouter settings from {path}.", { path: paths.claude }));
       }
       break;
@@ -846,12 +1018,11 @@ export function revertToolWiring(tool, paths) {
       break;
     }
     case "opencode": {
-      if (existsSync(paths.opencode)) {
-        writeSecretFile(paths.opencode, unwireOpenCodeJson(readText(paths.opencode)));
-      }
-      if (existsSync(paths.opencodeAuth)) {
-        writeSecretFile(paths.opencodeAuth, unwireOpenCodeAuth(readText(paths.opencodeAuth)));
-      }
+      // 두 파일 모두 파싱이 끝난 뒤에 쓴다(하나만 깨졌을 때 반쪽만 바뀌지 않게).
+      const nextJson = existsSync(paths.opencode) ? transformConfig(paths.opencode, unwireOpenCodeJson) : null;
+      const nextAuth = existsSync(paths.opencodeAuth) ? transformConfig(paths.opencodeAuth, unwireOpenCodeAuth) : null;
+      if (nextJson !== null) writeSecretFile(paths.opencode, nextJson);
+      if (nextAuth !== null) writeSecretFile(paths.opencodeAuth, nextAuth);
       console.log(t("Removed PleumRouter settings from {path}.", { path: paths.opencode }));
       break;
     }
@@ -864,31 +1035,31 @@ export function revertToolWiring(tool, paths) {
     }
     case "crush": {
       if (existsSync(paths.crush)) {
-        writeSecretFile(paths.crush, unwireCrushConfig(readText(paths.crush)));
+        writeSecretFile(paths.crush, transformConfig(paths.crush, unwireCrushConfig));
         console.log(t("Removed PleumRouter settings from {path}.", { path: paths.crush }));
       }
       break;
     }
     case "pi": {
       if (existsSync(paths.pi)) {
-        writeSecretFile(paths.pi, unwirePiConfig(readText(paths.pi)));
+        writeSecretFile(paths.pi, transformConfig(paths.pi, unwirePiConfig));
         console.log(t("Removed PleumRouter settings from {path}.", { path: paths.pi }));
       }
       break;
     }
     case "agy": {
       if (existsSync(paths.agy)) {
-        writeSecretFile(paths.agy, unwireAgySettings(readText(paths.agy)));
-      }
-      if (existsSync(paths.shellRc)) {
-        writeSecretFile(paths.shellRc, unwireShellWrapper(readText(paths.shellRc), "agy"), 0o644);
+        const previous = state.agy?.previous ?? pickPrevious("agy", readText(paths.agyBak)) ?? {};
+        writeSecretFile(paths.agy, transformConfig(paths.agy, (text) => unwireAgySettings(text, previous, agyWiredModel(state.agy))));
       }
+      unwireShellTool(paths, "agy");
       console.log(t("Removed PleumRouter settings from {path}.", { path: paths.agy }));
       break;
     }
     default: {
-      if (existsSync(paths.shellRc)) {
-        writeSecretFile(paths.shellRc, unwireShellWrapper(readText(paths.shellRc), tool), 0o644);
+      const hadRc = shellRcTarget(paths.shellRc).present;
+      unwireShellTool(paths, tool);
+      if (hadRc) {
         console.log(t("Removed PleumRouter settings from {path}.", { path: paths.shellRc }));
       }
       break;
@@ -899,45 +1070,85 @@ export function revertToolWiring(tool, paths) {
   writeWiredState(paths, state);
 }
 
+// 과금 공간은 wire 때 고른다. 대화형 터미널이면 묻고, 파이프·CI에서는 저장된 값을 쓴다.
+async function pickBillingContext(auth) {
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY && typeof process.stdin.setRawMode === "function");
+  return interactive ? selectAndBindWorkspace({ auth }) : getActiveContext();
+}
+
 export async function wire(args = [], {
   auth = authFetch,
   home = homedir(),
   model,
   models,
   billingOnly = false,
-  activeContext = getActiveContext(),
+  activeContext,
 } = {}) {
   const parsed = parseWireArgs(args);
   const tools = parsed.tools;
   const isBilling = billingOnly || parsed.billingOnly;
   const targetModel = model || parsed.model;
   const paths = wirePaths(home);
-  const record = await ensureWireKey({ auth, paths, activeContext });
+  // 메뉴 경로는 호출자가 이미 고른 값을 넘긴다(중복 질문 방지).
+  const billing = activeContext ?? (await pickBillingContext(auth));
+  const record = await ensureWireKey({ auth, paths, activeContext: billing });
 
+  // 한 도구가 깨져도 나머지는 배선한다. 실패 목록은 마지막에 한 번에 던져 exit 1이 되게 한다.
+  const failures = [];
   for (const tool of tools) {
-    applyToolWiring(tool, paths, {
-      key: record.key,
-      model: targetModel,
-      models,
-      billingOnly: isBilling,
-      activeContext,
-    });
-    console.log(t("Wired {tool}.", { tool }));
+    try {
+      applyToolWiring(tool, paths, {
+        key: record.key,
+        model: targetModel,
+        models,
+        billingOnly: isBilling,
+        activeContext: billing,
+      });
+      console.log(t("Wired {tool}.", { tool }));
+    } catch (e) {
+      failures.push(e.message);
+    }
   }
 
+  console.log(`ℹ ${t("Credit workspace")}: ${workspaceLabel(billing)}`);
+  console.log(t("The wire key is shared by all wired tools and launch, so a billing workspace change applies to all of them."));
   printDesktopHints(record);
+  if (failures.length) throw new Error(failures.join("\n"));
+}
+
+// 배선된 도구: 감지된 것 ∪ 배선 기록(state)에 있는 것(WIRE_TOOLS 순).
+function wiredTools(paths) {
+  const state = readWiredState(paths);
+  const status = wireStatusOf(paths);
+  return WIRE_TOOLS.filter((tool) => state[tool] || status[tool]?.wired);
 }
 
 export async function unwire(args = [], { auth = authFetch, home = homedir() } = {}) {
-  const { tools, revoke } = parseWireArgs(args);
+  const { tools: named, revoke } = parseWireArgs(args);
   const paths = wirePaths(home);
+  // 도구를 안 적으면 wire 기본값(claude·codex)이 아니라 배선된 도구 전부 — 키를 같이 쓰기 때문이다.
+  const tools = args.some((a) => WIRE_TOOLS.includes(a)) ? named : wiredTools(paths);
+  if (tools.length === 0) console.log(t("No tools are wired by PleumRouter."));
 
+  const failures = [];
   for (const tool of tools) {
-    revertToolWiring(tool, paths);
+    try {
+      revertToolWiring(tool, paths);
+    } catch (e) {
+      failures.push(e.message);
+    }
   }
+  // 실패가 있으면 키는 폐기하지 않는다(고친 뒤 다시 unwire할 수 있게).
+  if (failures.length) throw new Error(failures.join("\n"));
 
   if (!revoke) return;
 
+  // 키는 모든 배선 도구가 공유한다 — 다른 도구가 남아 있으면 폐기하지 않는다(그 도구들이 죽은 키로 실패한다).
+  const others = wiredTools(paths).filter((tool) => !tools.includes(tool));
+  if (others.length) {
+    throw new Error(t("Other tools still use this key: {tools}. Run `pleum unwire --revoke-key` to unwire all of them first.", { tools: others.join(", ") }));
+  }
+
   const stored = (() => {
     try {
       return JSON.parse(readText(paths.wire) ?? "");