devez-vibe 1.3.20 → 1.3.22

package/LICENSE

@@ -1,33 +1,33 @@
-DevezCode source code license
-
-The MIT License below applies only to the DevezCode source code and to files
-that are not listed in the exception below.
-
-Exceptions:
-
-* `Resources/Images/FileTypes/` and `Resources/Licenses/` are Microsoft Visual
-  Studio Image Library materials, subject to the included Microsoft terms.
-* `Resources/Images/ShellPresets/` contains third-party brand assets, subject
-  to their respective owners' terms.
-
-MIT License
-
-Copyright (c) 2026 DevezCode contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+DevezCode source code license
+
+The MIT License below applies only to the DevezCode source code and to files
+that are not listed in the exception below.
+
+Exceptions:
+
+* `Resources/Images/FileTypes/` and `Resources/Licenses/` are Microsoft Visual
+  Studio Image Library materials, subject to the included Microsoft terms.
+* `Resources/Images/ShellPresets/` contains third-party brand assets, subject
+  to their respective owners' terms.
+
+MIT License
+
+Copyright (c) 2026 DevezCode contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bridge/claude-agent-sdk-bridge.mjs

@@ -3,20 +3,20 @@
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { createReadStream } from "node:fs";
-import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join } from "node:path";
 import { createInterface } from "node:readline";
 import {
   deleteSession,
   forkSession,
-  getSessionInfo,
-  getSessionMessages,
-  filterEscalatingDefaultMode,
-  listSessions,
-  resolveSettings,
-  startup,
-} from "@anthropic-ai/claude-agent-sdk";
+  getSessionInfo,
+  getSessionMessages,
+  filterEscalatingDefaultMode,
+  listSessions,
+  resolveSettings,
+  startup,
+} from "@anthropic-ai/claude-agent-sdk";
 
 const VERSION = process.env.DEVEZ_VIBE_VERSION || "dev";
 const sessions = new Map();
@@ -171,7 +171,7 @@ function compactClaudeModelName(model) {
   return fallback || clean(model.displayName || model.resolvedModel || model.value);
 }
 
-function catalogEntry(model, defaultResolvedModel) {
+function catalogEntry(model, defaultResolvedModel) {
   const value = String(model.value || "");
   const resolved = String(model.resolvedModel || value);
   const efforts = model.supportsEffort && Array.isArray(model.supportedEffortLevels)
@@ -183,9 +183,9 @@ function catalogEntry(model, defaultResolvedModel) {
     model: visibleModel(value),
     displayName: compactClaudeModelName(model),
     defaultReasoningEffort: efforts.includes("high") ? "high" : efforts.at(-1) || "",
-    supportedReasoningEfforts: efforts.map((reasoningEffort) => ({ reasoningEffort })),
-    supportsAutoMode: Boolean(model.supportsAutoMode),
-    isDefault: Boolean(defaultResolvedModel) && resolved === defaultResolvedModel,
+    supportedReasoningEfforts: efforts.map((reasoningEffort) => ({ reasoningEffort })),
+    supportsAutoMode: Boolean(model.supportsAutoMode),
+    isDefault: Boolean(defaultResolvedModel) && resolved === defaultResolvedModel,
     ...(contextWindow > 0 ? { contextWindow } : {}),
   };
 }
@@ -298,14 +298,14 @@ function adoptSessionId(session, incoming) {
   });
 }
 
-const PERMISSION_MODES = [
-  "default",
-  "acceptEdits",
-  "plan",
-  "auto",
-  "dontAsk",
-  "bypassPermissions",
-];
+const PERMISSION_MODES = [
+  "default",
+  "acceptEdits",
+  "plan",
+  "auto",
+  "dontAsk",
+  "bypassPermissions",
+];
 
 function permissionMode(requested, fallback = "default") {
   const mode = String(requested || "");
@@ -314,173 +314,173 @@ function permissionMode(requested, fallback = "default") {
 
 // Moves a live session onto a mode the badge picked. A rejected mode — policy
 // disables bypass, say — leaves the session on the one it already had.
-async function applyPermissionMode(session, requested) {
-  const mode = permissionMode(requested, session.permissionMode || "default");
-  if (mode === session.permissionMode) return null;
-  try {
-    await session.query.setPermissionMode(mode);
-    session.permissionMode = mode;
-    return null;
-  } catch (error) {
-    return error?.message || String(error);
-  }
-}
-
-async function claudePermissionStatus(params) {
-  const resolved = await resolveSettings({
-    cwd: params.cwd || process.cwd(),
-    settingSources: ["user", "project", "local"],
-  });
-  const effective = filterEscalatingDefaultMode(resolved);
-  const permissions = effective.permissions || {};
-  const bypassAccepted = effective.skipDangerousModePermissionPrompt === true
-    || effective.bypassPermissionsModeAccepted === true;
-  const bypassAvailable = permissions.disableBypassPermissionsMode !== "disable" && bypassAccepted;
-  const autoDisabled = effective.disableAutoMode === "disable";
-  let defaultMode = permissionMode(permissions.defaultMode);
-  if ((defaultMode === "bypassPermissions" && !bypassAvailable)
-      || (defaultMode === "auto" && autoDisabled)) defaultMode = "default";
-  const rules = [];
-  const directories = [];
-  for (const source of resolved.sources) {
-    const sourcePermissions = source.settings?.permissions || {};
-    for (const behavior of ["allow", "ask", "deny"]) {
-      for (const rule of Array.isArray(sourcePermissions[behavior])
-        ? sourcePermissions[behavior]
-        : []) {
-        rules.push({
-          behavior,
-          rule: String(rule),
-          source: source.source,
-          path: source.path || null,
-          mutable: ["user", "project", "local"].includes(source.source),
-        });
-      }
-    }
-    for (const directory of Array.isArray(sourcePermissions.additionalDirectories)
-      ? sourcePermissions.additionalDirectories
-      : []) {
-      directories.push({
-        directory: String(directory),
-        source: source.source,
-        path: source.path || null,
-        mutable: ["user", "project", "local"].includes(source.source),
-      });
-    }
-  }
-  const denials = [...sessions.values()]
-    .filter((session) => session.cwd === (params.cwd || process.cwd()))
-    .flatMap((session) => session.permissionDenials || [])
-    .slice(-20)
-    .reverse();
-  return {
-    defaultMode,
-    bypassAvailable,
-    autoDisabled,
-    rulesLocked: effective.allowManagedPermissionRulesOnly === true,
-    rules,
-    directories,
-    denials,
-  };
-}
-
-function permissionSettingsPath(cwd, destination) {
-  if (destination === "user") {
-    return join(process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude"), "settings.json");
-  }
-  if (destination === "project") return join(cwd, ".claude", "settings.json");
-  if (destination === "local") return join(cwd, ".claude", "settings.local.json");
-  throw new Error(`지원하지 않는 Claude 권한 설정 범위: ${destination}`);
-}
-
-async function updateClaudePermission(params) {
-  const cwd = params.cwd || process.cwd();
-  const status = await claudePermissionStatus({ cwd });
-  if (status.rulesLocked) {
-    throw new Error("관리 정책에서 사용자·프로젝트 권한 규칙 변경을 비활성화했습니다.");
-  }
-  const destination = String(params.destination || "project");
-  const path = permissionSettingsPath(cwd, destination);
-  let settings = {};
-  try {
-    settings = JSON.parse(await readFile(path, "utf8"));
-  } catch (error) {
-    if (error?.code !== "ENOENT") throw error;
-  }
-  if (!settings || typeof settings !== "object" || Array.isArray(settings)) settings = {};
-  if (!settings.permissions || typeof settings.permissions !== "object"
-      || Array.isArray(settings.permissions)) settings.permissions = {};
-
-  const action = String(params.action || "");
-  const behavior = String(params.behavior || "");
-  const key = behavior === "directory" ? "additionalDirectories" : behavior;
-  if (!["allow", "ask", "deny", "additionalDirectories"].includes(key)) {
-    throw new Error(`지원하지 않는 Claude 권한 규칙 종류: ${behavior}`);
-  }
-  const value = String(params.value || "").trim();
-  if (!value) throw new Error("빈 Claude 권한 규칙은 저장할 수 없습니다.");
-  const values = Array.isArray(settings.permissions[key])
-    ? settings.permissions[key].map(String)
-    : [];
-  if (action === "add" && !values.includes(value)) values.push(value);
-  else if (action === "remove") {
-    const index = values.indexOf(value);
-    if (index >= 0) values.splice(index, 1);
-  } else if (action !== "add") {
-    throw new Error(`지원하지 않는 Claude 권한 규칙 작업: ${action}`);
-  }
-  settings.permissions[key] = values;
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
-  return claudePermissionStatus({ cwd });
-}
-
-async function setClaudeAutoModeDisabled(params) {
-  const cwd = params.cwd || process.cwd();
-  const path = permissionSettingsPath(cwd, "user");
-  let settings = {};
-  try {
-    settings = JSON.parse(await readFile(path, "utf8"));
-  } catch (error) {
-    if (error?.code !== "ENOENT") throw error;
-  }
-  if (!settings || typeof settings !== "object" || Array.isArray(settings)) settings = {};
-  if (params.disabled === false) delete settings.disableAutoMode;
-  else settings.disableAutoMode = "disable";
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
-  return claudePermissionStatus({ cwd });
-}
-
-async function retryClaudePermission(params) {
-  const session = lookupSession(params.sessionId);
-  if (!session) throw new Error("재시도할 Claude 세션을 찾을 수 없습니다.");
-  const tool = String(params.tool || "tool");
-  const input = params.input && typeof params.input === "object" ? params.input : {};
-  const previousMode = session.permissionMode;
-  return startPrompt({
-    sessionId: session.id,
-    permissionMode: previousMode === "auto" ? "default" : previousMode,
-    restorePermissionMode: previousMode === "auto" ? "auto" : null,
-    input: [{
-      type: "text",
-      text: [
-        `The user selected the denied ${tool} action in /permissions and asked to retry it.`,
-        "Retry that action now. A manual permission prompt will be shown before it runs.",
-        `Original tool input: ${JSON.stringify(input)}`,
-      ].join("\n"),
-    }],
-  });
-}
+async function applyPermissionMode(session, requested) {
+  const mode = permissionMode(requested, session.permissionMode || "default");
+  if (mode === session.permissionMode) return null;
+  try {
+    await session.query.setPermissionMode(mode);
+    session.permissionMode = mode;
+    return null;
+  } catch (error) {
+    return error?.message || String(error);
+  }
+}
+
+async function claudePermissionStatus(params) {
+  const resolved = await resolveSettings({
+    cwd: params.cwd || process.cwd(),
+    settingSources: ["user", "project", "local"],
+  });
+  const effective = filterEscalatingDefaultMode(resolved);
+  const permissions = effective.permissions || {};
+  const bypassAccepted = effective.skipDangerousModePermissionPrompt === true
+    || effective.bypassPermissionsModeAccepted === true;
+  const bypassAvailable = permissions.disableBypassPermissionsMode !== "disable" && bypassAccepted;
+  const autoDisabled = effective.disableAutoMode === "disable";
+  let defaultMode = permissionMode(permissions.defaultMode);
+  if ((defaultMode === "bypassPermissions" && !bypassAvailable)
+      || (defaultMode === "auto" && autoDisabled)) defaultMode = "default";
+  const rules = [];
+  const directories = [];
+  for (const source of resolved.sources) {
+    const sourcePermissions = source.settings?.permissions || {};
+    for (const behavior of ["allow", "ask", "deny"]) {
+      for (const rule of Array.isArray(sourcePermissions[behavior])
+        ? sourcePermissions[behavior]
+        : []) {
+        rules.push({
+          behavior,
+          rule: String(rule),
+          source: source.source,
+          path: source.path || null,
+          mutable: ["user", "project", "local"].includes(source.source),
+        });
+      }
+    }
+    for (const directory of Array.isArray(sourcePermissions.additionalDirectories)
+      ? sourcePermissions.additionalDirectories
+      : []) {
+      directories.push({
+        directory: String(directory),
+        source: source.source,
+        path: source.path || null,
+        mutable: ["user", "project", "local"].includes(source.source),
+      });
+    }
+  }
+  const denials = [...sessions.values()]
+    .filter((session) => session.cwd === (params.cwd || process.cwd()))
+    .flatMap((session) => session.permissionDenials || [])
+    .slice(-20)
+    .reverse();
+  return {
+    defaultMode,
+    bypassAvailable,
+    autoDisabled,
+    rulesLocked: effective.allowManagedPermissionRulesOnly === true,
+    rules,
+    directories,
+    denials,
+  };
+}
+
+function permissionSettingsPath(cwd, destination) {
+  if (destination === "user") {
+    return join(process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude"), "settings.json");
+  }
+  if (destination === "project") return join(cwd, ".claude", "settings.json");
+  if (destination === "local") return join(cwd, ".claude", "settings.local.json");
+  throw new Error(`지원하지 않는 Claude 권한 설정 범위: ${destination}`);
+}
+
+async function updateClaudePermission(params) {
+  const cwd = params.cwd || process.cwd();
+  const status = await claudePermissionStatus({ cwd });
+  if (status.rulesLocked) {
+    throw new Error("관리 정책에서 사용자·프로젝트 권한 규칙 변경을 비활성화했습니다.");
+  }
+  const destination = String(params.destination || "project");
+  const path = permissionSettingsPath(cwd, destination);
+  let settings = {};
+  try {
+    settings = JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+  if (!settings || typeof settings !== "object" || Array.isArray(settings)) settings = {};
+  if (!settings.permissions || typeof settings.permissions !== "object"
+      || Array.isArray(settings.permissions)) settings.permissions = {};
+
+  const action = String(params.action || "");
+  const behavior = String(params.behavior || "");
+  const key = behavior === "directory" ? "additionalDirectories" : behavior;
+  if (!["allow", "ask", "deny", "additionalDirectories"].includes(key)) {
+    throw new Error(`지원하지 않는 Claude 권한 규칙 종류: ${behavior}`);
+  }
+  const value = String(params.value || "").trim();
+  if (!value) throw new Error("빈 Claude 권한 규칙은 저장할 수 없습니다.");
+  const values = Array.isArray(settings.permissions[key])
+    ? settings.permissions[key].map(String)
+    : [];
+  if (action === "add" && !values.includes(value)) values.push(value);
+  else if (action === "remove") {
+    const index = values.indexOf(value);
+    if (index >= 0) values.splice(index, 1);
+  } else if (action !== "add") {
+    throw new Error(`지원하지 않는 Claude 권한 규칙 작업: ${action}`);
+  }
+  settings.permissions[key] = values;
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+  return claudePermissionStatus({ cwd });
+}
+
+async function setClaudeAutoModeDisabled(params) {
+  const cwd = params.cwd || process.cwd();
+  const path = permissionSettingsPath(cwd, "user");
+  let settings = {};
+  try {
+    settings = JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+  if (!settings || typeof settings !== "object" || Array.isArray(settings)) settings = {};
+  if (params.disabled === false) delete settings.disableAutoMode;
+  else settings.disableAutoMode = "disable";
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+  return claudePermissionStatus({ cwd });
+}
+
+async function retryClaudePermission(params) {
+  const session = lookupSession(params.sessionId);
+  if (!session) throw new Error("재시도할 Claude 세션을 찾을 수 없습니다.");
+  const tool = String(params.tool || "tool");
+  const input = params.input && typeof params.input === "object" ? params.input : {};
+  const previousMode = session.permissionMode;
+  return startPrompt({
+    sessionId: session.id,
+    permissionMode: previousMode === "auto" ? "default" : previousMode,
+    restorePermissionMode: previousMode === "auto" ? "auto" : null,
+    input: [{
+      type: "text",
+      text: [
+        `The user selected the denied ${tool} action in /permissions and asked to retry it.`,
+        "Retry that action now. A manual permission prompt will be shown before it runs.",
+        `Original tool input: ${JSON.stringify(input)}`,
+      ].join("\n"),
+    }],
+  });
+}
 
 function makeOptions(params, sessionId, resume) {
   const options = {
     cwd: params.cwd || process.cwd(),
     includePartialMessages: true,
-    permissionMode: permissionMode(params.permissionMode),
-    // Not a mode, a capability: the SDK refuses `bypassPermissions` outright
-    // unless the session was started with this. The UI exposes it only after
-    // Claude's resolved settings and acknowledgement make the mode available.
+    permissionMode: permissionMode(params.permissionMode),
+    // Not a mode, a capability: the SDK refuses `bypassPermissions` outright
+    // unless the session was started with this. The UI exposes it only after
+    // Claude's resolved settings and acknowledgement make the mode available.
     allowDangerouslySkipPermissions: true,
     enableFileCheckpointing: true,
     persistSession: true,
@@ -506,7 +506,7 @@ function makeOptions(params, sessionId, resume) {
   return options;
 }
 
-async function startAgentQuery(prompt, options) {
+async function startAgentQuery(prompt, options) {
   const warm = await startup({ options });
   try {
     return warm.query(prompt);
@@ -514,29 +514,29 @@ async function startAgentQuery(prompt, options) {
     warm.close();
     throw error;
   }
-}
-
-function permissionSuggestionLabel(suggestions) {
-  if (!Array.isArray(suggestions) || !suggestions.length) return null;
-  const rules = suggestions.flatMap((suggestion) =>
-    Array.isArray(suggestion.rules)
-      ? suggestion.rules.map((rule) => rule.ruleContent
-        ? `${rule.toolName}(${rule.ruleContent})`
-        : String(rule.toolName || ""))
-      : []);
-  const directories = suggestions.flatMap((suggestion) =>
-    Array.isArray(suggestion.directories) ? suggestion.directories.map(String) : []);
-  const values = [...new Set([...rules, ...directories].filter(Boolean))];
-  const destinations = new Set(suggestions.map((suggestion) => suggestion.destination));
-  const scope = destinations.has("userSettings")
-    ? "모든 프로젝트에서"
-    : destinations.has("projectSettings") || destinations.has("localSettings")
-      ? "이 프로젝트에서"
-      : "이번 세션에서";
-  return values.length
-    ? `${scope} 항상 허용: ${values.join(", ")}`
-    : `${scope} 다시 묻지 않기`;
-}
+}
+
+function permissionSuggestionLabel(suggestions) {
+  if (!Array.isArray(suggestions) || !suggestions.length) return null;
+  const rules = suggestions.flatMap((suggestion) =>
+    Array.isArray(suggestion.rules)
+      ? suggestion.rules.map((rule) => rule.ruleContent
+        ? `${rule.toolName}(${rule.ruleContent})`
+        : String(rule.toolName || ""))
+      : []);
+  const directories = suggestions.flatMap((suggestion) =>
+    Array.isArray(suggestion.directories) ? suggestion.directories.map(String) : []);
+  const values = [...new Set([...rules, ...directories].filter(Boolean))];
+  const destinations = new Set(suggestions.map((suggestion) => suggestion.destination));
+  const scope = destinations.has("userSettings")
+    ? "모든 프로젝트에서"
+    : destinations.has("projectSettings") || destinations.has("localSettings")
+      ? "이 프로젝트에서"
+      : "이번 세션에서";
+  return values.length
+    ? `${scope} 항상 허용: ${values.join(", ")}`
+    : `${scope} 다시 묻지 않기`;
+}
 
 async function requestToolPermission(toolName, input, permission) {
   if (toolName === "AskUserQuestion") {
@@ -586,43 +586,43 @@ async function requestToolPermission(toolName, input, permission) {
     return { behavior: "allow", updatedInput: { ...input, answers } };
   }
 
-  // Claude calls this callback only after its selected mode and permission rules
-  // decide that a human answer is needed. Forward every such request to the host;
-  // auto-allowing the ordinary cases here would silently defeat default/auto mode.
-  const planApproval = toolName === "ExitPlanMode";
-  const persistentApprovalLabel = permissionSuggestionLabel(permission.suggestions);
-  const common = {
-    claudePermission: true,
-    title: permission.title || permission.displayName,
-    persistentApprovalLabel,
-  };
-
-  let method = "item/permissions/requestApproval";
-  let params = {
-    ...common,
-    reason: permission.decisionReason || permission.description || permission.title,
-    permissions: { tool: toolName, blockedPath: permission.blockedPath },
-  };
-  if (planApproval) {
-    params = {
-      ...common,
-      reason: input.plan || permission.description || "계획대로 진행할까요?",
-      permissions: { tool: toolName },
-    };
-  } else if (toolName === "Bash") {
-    method = "item/commandExecution/requestApproval";
-    params = {
-      ...common,
-      command: input.command || "command",
-      cwd: input.cwd,
-      reason: permission.decisionReason || permission.description,
+  // Claude calls this callback only after its selected mode and permission rules
+  // decide that a human answer is needed. Forward every such request to the host;
+  // auto-allowing the ordinary cases here would silently defeat default/auto mode.
+  const planApproval = toolName === "ExitPlanMode";
+  const persistentApprovalLabel = permissionSuggestionLabel(permission.suggestions);
+  const common = {
+    claudePermission: true,
+    title: permission.title || permission.displayName,
+    persistentApprovalLabel,
+  };
+
+  let method = "item/permissions/requestApproval";
+  let params = {
+    ...common,
+    reason: permission.decisionReason || permission.description || permission.title,
+    permissions: { tool: toolName, blockedPath: permission.blockedPath },
+  };
+  if (planApproval) {
+    params = {
+      ...common,
+      reason: input.plan || permission.description || "계획대로 진행할까요?",
+      permissions: { tool: toolName },
+    };
+  } else if (toolName === "Bash") {
+    method = "item/commandExecution/requestApproval";
+    params = {
+      ...common,
+      command: input.command || "command",
+      cwd: input.cwd,
+      reason: permission.decisionReason || permission.description,
     };
   } else if (["Edit", "Write", "NotebookEdit"].includes(toolName)) {
-    method = "item/fileChange/requestApproval";
-    params = {
-      ...common,
-      grantRoot: permission.blockedPath || input.file_path || input.notebook_path,
-      reason: permission.decisionReason || permission.description,
+    method = "item/fileChange/requestApproval";
+    params = {
+      ...common,
+      grantRoot: permission.blockedPath || input.file_path || input.notebook_path,
+      reason: permission.decisionReason || permission.description,
     };
   }
   const response = await hostRequest(method, params, permission.signal);
@@ -800,7 +800,7 @@ async function claudePluginDetail(params) {
   };
 }
 
-async function claudeSkills(params) {
+async function claudeSkills(params) {
   const installed = await runClaudeJson(params, ["plugin", "list", "--json"]);
   const skills = [];
   for (const plugin of Array.isArray(installed) ? installed : []) {
@@ -817,48 +817,48 @@ async function claudeSkills(params) {
       }
     } catch { /* Plugins do not have to provide skills. */ }
   }
-  return { data: [{ cwd: params.cwd || process.cwd(), skills }] };
-}
-
-function claudeMcpStatusValue(statuses) {
-  return {
-    data: (Array.isArray(statuses) ? statuses : []).map((server) => ({
-      name: String(server?.name || "MCP"),
-      serverInfo: server?.serverInfo
-        ? {
-            title: String(server.serverInfo.name || server.name || "MCP"),
-            version: String(server.serverInfo.version || ""),
-          }
-        : null,
-      tools: Object.fromEntries(
-        (Array.isArray(server?.tools) ? server.tools : [])
-          .filter((tool) => tool?.name)
-          .map((tool) => [String(tool.name), tool]),
-      ),
-      resources: [],
-      authStatus: server?.status === "needs-auth"
-        ? "notLoggedIn"
-        : server?.status === "connected"
-          ? "unsupported"
-          : String(server?.status || "unknown"),
-      status: String(server?.status || "unknown"),
-      ...(server?.error ? { error: String(server.error) } : {}),
-    })),
-  };
-}
-
-async function claudeMcpStatus(params) {
-  const session = lookupSession(params.threadId || params.sessionId);
-  if (!session) {
-    return {
-      data: [],
-      unavailableReason: "Claude 세션이 아직 시작되지 않았습니다.",
-    };
-  }
-  return claudeMcpStatusValue(await session.query.mcpServerStatus());
-}
-
-function isQuestionDeliveryError(error) {
+  return { data: [{ cwd: params.cwd || process.cwd(), skills }] };
+}
+
+function claudeMcpStatusValue(statuses) {
+  return {
+    data: (Array.isArray(statuses) ? statuses : []).map((server) => ({
+      name: String(server?.name || "MCP"),
+      serverInfo: server?.serverInfo
+        ? {
+            title: String(server.serverInfo.name || server.name || "MCP"),
+            version: String(server.serverInfo.version || ""),
+          }
+        : null,
+      tools: Object.fromEntries(
+        (Array.isArray(server?.tools) ? server.tools : [])
+          .filter((tool) => tool?.name)
+          .map((tool) => [String(tool.name), tool]),
+      ),
+      resources: [],
+      authStatus: server?.status === "needs-auth"
+        ? "notLoggedIn"
+        : server?.status === "connected"
+          ? "unsupported"
+          : String(server?.status || "unknown"),
+      status: String(server?.status || "unknown"),
+      ...(server?.error ? { error: String(server.error) } : {}),
+    })),
+  };
+}
+
+async function claudeMcpStatus(params) {
+  const session = lookupSession(params.threadId || params.sessionId);
+  if (!session) {
+    return {
+      data: [],
+      unavailableReason: "Claude 세션이 아직 시작되지 않았습니다.",
+    };
+  }
+  return claudeMcpStatusValue(await session.query.mcpServerStatus());
+}
+
+function isQuestionDeliveryError(error) {
   return error?.code === -32700
     || String(error?.message || error).includes("사용자 입력 화면에 전달하지 못했습니다");
 }
@@ -895,8 +895,8 @@ async function createSession(params, resumeId) {
     turnSequence: 1,
     itemSequence: 1,
     streamBlocks: new Map(),
-    tools: new Map(),
-    permissionDenials: [],
+    tools: new Map(),
+    permissionDenials: [],
     tasks: new Map(),
     planCreatePending: false,
     subagents: new Map(),
@@ -1802,16 +1802,16 @@ function toolOutput(content, structured) {
   return content == null ? "" : JSON.stringify(content, null, 2);
 }
 
-async function processResult(session, message) {
-  if (!session.turn) return;
-  for (const denial of Array.isArray(message.permission_denials) ? message.permission_denials : []) {
-    rememberPermissionDenial(session, {
-      tool: denial.tool_name,
-      toolUseId: denial.tool_use_id,
-      input: denial.tool_input,
-    });
-  }
-  const interrupted = session.turn.interruptRequested === true;
+async function processResult(session, message) {
+  if (!session.turn) return;
+  for (const denial of Array.isArray(message.permission_denials) ? message.permission_denials : []) {
+    rememberPermissionDenial(session, {
+      tool: denial.tool_name,
+      toolUseId: denial.tool_use_id,
+      input: denial.tool_input,
+    });
+  }
+  const interrupted = session.turn.interruptRequested === true;
   const totals = [...Object.values(message.modelUsage || {})].reduce((sum, usage) => ({
     inputTokens: sum.inputTokens + Number(usage.inputTokens || 0) + Number(usage.cacheReadInputTokens || 0) + Number(usage.cacheCreationInputTokens || 0),
     cachedInputTokens: sum.cachedInputTokens + Number(usage.cacheReadInputTokens || 0),
@@ -1830,42 +1830,42 @@ async function processResult(session, message) {
       modelContextWindow: totals.contextWindow || session.lastContextWindow || undefined,
     },
   });
-  const error = message.is_error && !interrupted
+  const error = message.is_error && !interrupted
     ? { message: message.errors?.join("\n") || message.stop_reason || "Claude 실행 실패" }
     : null;
-  finishTurn(session, error, message.duration_ms);
-  if (session.restorePermissionMode) {
-    const restore = session.restorePermissionMode;
-    session.restorePermissionMode = null;
-    await applyPermissionMode(session, restore);
-  }
+  finishTurn(session, error, message.duration_ms);
+  if (session.restorePermissionMode) {
+    const restore = session.restorePermissionMode;
+    session.restorePermissionMode = null;
+    await applyPermissionMode(session, restore);
+  }
   notify("claude/account/updated", {
     threadId: session.id,
     account: await safeAccount(session.query),
     usage: await safeUsage(session.query),
   });
-  await runPendingPrompt(session);
-}
-
-function rememberPermissionDenial(session, denial) {
-  const toolUseId = String(denial.toolUseId || "");
-  const existing = toolUseId
-    ? session.permissionDenials.find((candidate) => candidate.toolUseId === toolUseId)
-    : null;
-  if (existing) {
-    existing.tool = String(denial.tool || existing.tool || "Tool");
-    existing.reason = String(denial.reason || existing.reason || "");
-    if (denial.input && typeof denial.input === "object") existing.input = denial.input;
-    return;
-  }
-  session.permissionDenials.push({
-    tool: String(denial.tool || "Tool"),
-    toolUseId,
-    reason: String(denial.reason || ""),
-    input: denial.input && typeof denial.input === "object" ? denial.input : {},
-  });
-  if (session.permissionDenials.length > 20) session.permissionDenials.shift();
-}
+  await runPendingPrompt(session);
+}
+
+function rememberPermissionDenial(session, denial) {
+  const toolUseId = String(denial.toolUseId || "");
+  const existing = toolUseId
+    ? session.permissionDenials.find((candidate) => candidate.toolUseId === toolUseId)
+    : null;
+  if (existing) {
+    existing.tool = String(denial.tool || existing.tool || "Tool");
+    existing.reason = String(denial.reason || existing.reason || "");
+    if (denial.input && typeof denial.input === "object") existing.input = denial.input;
+    return;
+  }
+  session.permissionDenials.push({
+    tool: String(denial.tool || "Tool"),
+    toolUseId,
+    reason: String(denial.reason || ""),
+    input: denial.input && typeof denial.input === "object" ? denial.input : {},
+  });
+  if (session.permissionDenials.length > 20) session.permissionDenials.shift();
+}
 
 // The turn that was waiting starts on its own, so the host sees it exactly like a
 // prompt sent the moment the previous turn ended.
@@ -1908,16 +1908,16 @@ async function consume(session) {
       await processStreamEvent(session, message);
     } else if (message.type === "assistant") processAssistant(session, message);
     else if (message.type === "user") processUser(session, message);
-    else if (message.type === "result") await processResult(session, message);
-    else if (message.type === "system" && message.subtype === "compact_boundary") {
-      notify("thread/compacted", { threadId: session.id });
-    } else if (message.type === "system" && message.subtype === "permission_denied") {
-      rememberPermissionDenial(session, {
-        tool: message.tool_name,
-        toolUseId: message.tool_use_id,
-        reason: message.decision_reason || message.decision_reason_type,
-      });
-    } else if (message.type === "rate_limit_event") {
+    else if (message.type === "result") await processResult(session, message);
+    else if (message.type === "system" && message.subtype === "compact_boundary") {
+      notify("thread/compacted", { threadId: session.id });
+    } else if (message.type === "system" && message.subtype === "permission_denied") {
+      rememberPermissionDenial(session, {
+        tool: message.tool_name,
+        toolUseId: message.tool_use_id,
+        reason: message.decision_reason || message.decision_reason_type,
+      });
+    } else if (message.type === "rate_limit_event") {
       notify("claude/account/updated", { threadId: session.id, rateLimitInfo: message.rate_limit_info });
     } else if (message.type === "system" && message.subtype === "api_retry") {
       notify("warning", { threadId: session.id, provider: "Claude", message: `Claude API 재시도 ${message.attempt}/${message.max_retries}` });
@@ -1993,19 +1993,19 @@ async function runPrompt(session, params) {
     await session.query.applyFlagSettings({ effortLevel: effort });
   }
   session.effort = effort;
-  const permissionRejection = await applyPermissionMode(session, params.permissionMode);
-  if (permissionRejection) {
-    notify("claude/permissionMode/rejected", {
-      threadId: visibleSession(session.id),
-      permissionMode: params.permissionMode,
-      effectivePermissionMode: session.permissionMode,
-      message: permissionRejection,
-    });
-  }
-  if (params.restorePermissionMode) {
-    session.restorePermissionMode = permissionMode(params.restorePermissionMode);
-  }
-  const content = await inputContent(params.input, params.handoffContext);
+  const permissionRejection = await applyPermissionMode(session, params.permissionMode);
+  if (permissionRejection) {
+    notify("claude/permissionMode/rejected", {
+      threadId: visibleSession(session.id),
+      permissionMode: params.permissionMode,
+      effectivePermissionMode: session.permissionMode,
+      message: permissionRejection,
+    });
+  }
+  if (params.restorePermissionMode) {
+    session.restorePermissionMode = permissionMode(params.restorePermissionMode);
+  }
+  const content = await inputContent(params.input, params.handoffContext);
   const turnId = beginTurn(session, params.input);
   session.queue.push({
     type: "user",
@@ -2274,10 +2274,10 @@ async function readableCwd(id, cwd) {
   return await transcriptCwd(id) || cwd;
 }
 
-async function dispatch(method, params = {}) {
-  if (method === "model/list") return loadModelCatalog(params);
-  if (method === "mcpServerStatus/list") return claudeMcpStatus(params);
-  if (method === "plugin/list") return claudePluginCatalog(params);
+async function dispatch(method, params = {}) {
+  if (method === "model/list") return loadModelCatalog(params);
+  if (method === "mcpServerStatus/list") return claudeMcpStatus(params);
+  if (method === "plugin/list") return claudePluginCatalog(params);
   if (method === "plugin/installed") return claudePluginCatalog(params, true);
   if (method === "plugin/read") return claudePluginDetail(params);
   if (method === "plugin/install") {
@@ -2327,24 +2327,24 @@ async function dispatch(method, params = {}) {
   }
   if (method === "skills/list") return claudeSkills(params);
   if (method === "app/list") return { data: [] };
-  if (method === "plugin/reload") {
-    return { message: "Claude 플러그인 설정을 다시 읽었습니다. 새 대화부터 적용됩니다." };
-  }
-  if (method === "permissions/status") return claudePermissionStatus(params);
-  if (method === "permissions/update") return updateClaudePermission(params);
-  if (method === "permissions/auto-mode") return setClaudeAutoModeDisabled(params);
-  if (method === "permissions/retry") return retryClaudePermission(params);
-  if (method === "session/permissionMode") {
-    const session = lookupSession(params.sessionId);
-    // A session that has not started yet picks the mode up from its first turn.
-    if (!session) return { permissionMode: permissionMode(params.permissionMode) };
-    session.restorePermissionMode = null;
-    const rejection = await applyPermissionMode(session, params.permissionMode);
-    return {
-      permissionMode: session.permissionMode,
-      ...(rejection ? { rejection } : {}),
-    };
-  }
+  if (method === "plugin/reload") {
+    return { message: "Claude 플러그인 설정을 다시 읽었습니다. 새 대화부터 적용됩니다." };
+  }
+  if (method === "permissions/status") return claudePermissionStatus(params);
+  if (method === "permissions/update") return updateClaudePermission(params);
+  if (method === "permissions/auto-mode") return setClaudeAutoModeDisabled(params);
+  if (method === "permissions/retry") return retryClaudePermission(params);
+  if (method === "session/permissionMode") {
+    const session = lookupSession(params.sessionId);
+    // A session that has not started yet picks the mode up from its first turn.
+    if (!session) return { permissionMode: permissionMode(params.permissionMode) };
+    session.restorePermissionMode = null;
+    const rejection = await applyPermissionMode(session, params.permissionMode);
+    return {
+      permissionMode: session.permissionMode,
+      ...(rejection ? { rejection } : {}),
+    };
+  }
   if (method === "session/start") {
     const { session, account, usage } = await createSession(params);
     return {
@@ -2497,12 +2497,12 @@ async function dispatch(method, params = {}) {
   throw new Error(`지원하지 않는 Claude 브리지 메서드: ${method}`);
 }
 
-async function runSelfTest() {
-  if (permissionMode("dontAsk") !== "dontAsk"
-    || permissionMode("not-a-mode", "auto") !== "auto") {
-    throw new Error("Claude permission mode self-test failed");
-  }
-  const pluginCatalog = buildClaudePluginCatalog(
+async function runSelfTest() {
+  if (permissionMode("dontAsk") !== "dontAsk"
+    || permissionMode("not-a-mode", "auto") !== "auto") {
+    throw new Error("Claude permission mode self-test failed");
+  }
+  const pluginCatalog = buildClaudePluginCatalog(
     [{ id: "cloudflare@official", enabled: true, scope: "user" }],
     [{
       pluginId: "cloudflare@official",
@@ -2513,29 +2513,29 @@ async function runSelfTest() {
     [{ name: "official", installLocation: "/tmp/official" }],
   );
   const plugin = pluginCatalog.marketplaces[0]?.plugins[0];
-  if (plugin?.id !== "cloudflare@official"
+  if (plugin?.id !== "cloudflare@official"
     || plugin?.name !== "cloudflare@official"
     || plugin?.interface?.displayName !== "cloudflare"
     || plugin?.installed !== true
     || plugin?.enabled !== true) {
-    throw new Error(`Claude plugin catalogue self-test failed: ${JSON.stringify(pluginCatalog)}`);
-  }
-  const mcpStatus = claudeMcpStatusValue([
-    {
-      name: "context7",
-      status: "connected",
-      serverInfo: { name: "Context7", version: "1.0.0" },
-      tools: [{ name: "resolve" }, { name: "docs" }],
-    },
-    { name: "figma", status: "needs-auth", tools: [] },
-  ]).data;
-  if (mcpStatus[0]?.name !== "context7"
-    || Object.keys(mcpStatus[0]?.tools || {}).length !== 2
-    || mcpStatus[0]?.status !== "connected"
-    || mcpStatus[1]?.authStatus !== "notLoggedIn") {
-    throw new Error(`Claude MCP status self-test failed: ${JSON.stringify(mcpStatus)}`);
-  }
-  const user = (uuid, text) => ({
+    throw new Error(`Claude plugin catalogue self-test failed: ${JSON.stringify(pluginCatalog)}`);
+  }
+  const mcpStatus = claudeMcpStatusValue([
+    {
+      name: "context7",
+      status: "connected",
+      serverInfo: { name: "Context7", version: "1.0.0" },
+      tools: [{ name: "resolve" }, { name: "docs" }],
+    },
+    { name: "figma", status: "needs-auth", tools: [] },
+  ]).data;
+  if (mcpStatus[0]?.name !== "context7"
+    || Object.keys(mcpStatus[0]?.tools || {}).length !== 2
+    || mcpStatus[0]?.status !== "connected"
+    || mcpStatus[1]?.authStatus !== "notLoggedIn") {
+    throw new Error(`Claude MCP status self-test failed: ${JSON.stringify(mcpStatus)}`);
+  }
+  const user = (uuid, text) => ({
     type: "user",
     uuid,
     message: { role: "user", content: [{ type: "text", text }] },

package/package.json

@@ -1,41 +1,41 @@
-{
-  "name": "devez-vibe",
-  "version": "1.3.20",
-  "description": "Stable terminal UI for Codex and Claude Agent SDK",
-  "keywords": [
-    "codex",
-    "cli",
-    "tui",
-    "terminal",
-    "app-server",
-    "claude-agent-sdk"
-  ],
-  "homepage": "https://github.com/MrHoje/Devez-vibe#readme",
-  "bugs": "https://github.com/MrHoje/Devez-vibe/issues",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/MrHoje/Devez-vibe.git"
-  },
-  "license": "MIT",
-  "bin": {
-    "dvz": "bin/dvz.exe"
-  },
-  "files": [
-    "bin/dvz.exe",
-    "bridge/claude-agent-sdk-bridge.mjs",
-    "README.md",
-    "LICENSE"
-  ],
-  "os": [
-    "win32"
-  ],
-  "cpu": [
-    "x64"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.3.223"
-  }
-}
+{
+  "name": "devez-vibe",
+  "version": "1.3.22",
+  "description": "Stable terminal UI for Codex and Claude Agent SDK",
+  "keywords": [
+    "codex",
+    "cli",
+    "tui",
+    "terminal",
+    "app-server",
+    "claude-agent-sdk"
+  ],
+  "homepage": "https://github.com/MrHoje/Devez-vibe#readme",
+  "bugs": "https://github.com/MrHoje/Devez-vibe/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MrHoje/Devez-vibe.git"
+  },
+  "license": "MIT",
+  "bin": {
+    "dvz": "bin/dvz.exe"
+  },
+  "files": [
+    "bin/dvz.exe",
+    "bridge/claude-agent-sdk-bridge.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.3.223"
+  }
+}