devez-vibe 1.9.33 → 1.9.35

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Devez Vibe 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.
+MIT License
+
+Copyright (c) 2026 Devez Vibe 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/README.md

@@ -1,73 +1,73 @@
-# Devez Vibe
-
-공식 `codex app-server`와 Claude Agent SDK를 위한 차분한 터미널 클라이언트입니다.
-각 공식 런타임이 인증·도구·스킬·프로젝트 지침을 담당하고, 이 프로젝트는 공통 화면과
-입력 계층을 소유합니다.
-
-## 설치
-
-```powershell
-npm install -g devez-vibe
-```
-
-설치하면 `dvz` 명령을 사용할 수 있습니다.
-
-| 요건 | 값 |
-| --- | --- |
-| OS | Windows x64 |
-| Node.js | 18 이상 (Claude Agent SDK 런타임 포함) |
-| Codex 전제 | Codex CLI 설치 및 로그인 완료 |
-| Claude 전제 | Claude Code 설치 후 `claude` 구독 로그인 완료 |
-
-현재 Windows x64 빌드만 배포합니다. 다른 플랫폼에서는 `EBADPLATFORM`으로 설치가 거부됩니다.
-
-## 사용
-
-Codex CLI가 설치되고 로그인된 환경에서:
-
-```powershell
-dvz
-```
-
-개인 Claude 구독 로그인 재사용:
-
-```powershell
-dvz --model claude
-dvz --model sonnet --effort high
-```
-
-Claude SDK 자식 프로세스는 API 키 환경변수를 제거하고 설치된 Claude Code 로그인만 사용합니다.
-본인 계정의 로컬 개인 사용만 대상으로 하며 로그인 공유나 제3자 인증은 제공하지 않습니다.
-
-주요 옵션:
-
-```text
-dvz [--resume [SESSION] | --continue] [--model MODEL] [--effort EFFORT]
-    [--cwd PATH] [--codex PATH] [--claude PATH] [--theme THEME]
-```
-
-`--resume`만 입력하면 검색 가능한 세션 피커를 열고, `--continue`는 현재 폴더의 가장 최근
-세션을 바로 이어갑니다. 실행 중 전체 명령은 `/help`에서 확인합니다.
-
-설치 상태와 제공자 연결 준비 상태는 다음 명령으로 점검합니다.
-
-```powershell
-dvz doctor
-```
-
-## 업데이트
-
-새 버전이 배포되면 시작 시 안내 배너가 표시됩니다. 배너의 안내대로 실행하면 됩니다.
-
-```powershell
-dvz update
-```
-
-새 버전을 별도 경로에 내려받아 실행 파일을 검증한 뒤 다음 실행 버전으로 전환합니다.
-실행 중인 `dvz` 세션은 이전 버전을 유지하고, 새로 시작하는 세션부터 새 버전을 사용합니다.
-
-업데이트 확인을 끄려면 `DEVEZ_VIBE_NO_UPDATE_CHECK` 환경변수를 설정합니다.
-
-## 라이선스
-
-MIT. 자세한 내용은 [저장소](https://github.com/MrHoje/Devez-vibe)를 참고하세요.
+# Devez Vibe
+
+공식 `codex app-server`와 Claude Agent SDK를 위한 차분한 터미널 클라이언트입니다.
+각 공식 런타임이 인증·도구·스킬·프로젝트 지침을 담당하고, 이 프로젝트는 공통 화면과
+입력 계층을 소유합니다.
+
+## 설치
+
+```powershell
+npm install -g devez-vibe
+```
+
+설치하면 `dvz` 명령을 사용할 수 있습니다.
+
+| 요건 | 값 |
+| --- | --- |
+| OS | Windows x64 |
+| Node.js | 18 이상 (Claude Agent SDK 런타임 포함) |
+| Codex 전제 | Codex CLI 설치 및 로그인 완료 |
+| Claude 전제 | Claude Code 설치 후 `claude` 구독 로그인 완료 |
+
+현재 Windows x64 빌드만 배포합니다. 다른 플랫폼에서는 `EBADPLATFORM`으로 설치가 거부됩니다.
+
+## 사용
+
+Codex CLI가 설치되고 로그인된 환경에서:
+
+```powershell
+dvz
+```
+
+개인 Claude 구독 로그인 재사용:
+
+```powershell
+dvz --model claude
+dvz --model sonnet --effort high
+```
+
+Claude SDK 자식 프로세스는 API 키 환경변수를 제거하고 설치된 Claude Code 로그인만 사용합니다.
+본인 계정의 로컬 개인 사용만 대상으로 하며 로그인 공유나 제3자 인증은 제공하지 않습니다.
+
+주요 옵션:
+
+```text
+dvz [--resume [SESSION] | --continue] [--model MODEL] [--effort EFFORT]
+    [--cwd PATH] [--codex PATH] [--claude PATH] [--theme THEME]
+```
+
+`--resume`만 입력하면 검색 가능한 세션 피커를 열고, `--continue`는 현재 폴더의 가장 최근
+세션을 바로 이어갑니다. 실행 중 전체 명령은 `/help`에서 확인합니다.
+
+설치 상태와 제공자 연결 준비 상태는 다음 명령으로 점검합니다.
+
+```powershell
+dvz doctor
+```
+
+## 업데이트
+
+새 버전이 배포되면 시작 시 안내 배너가 표시됩니다. 배너의 안내대로 실행하면 됩니다.
+
+```powershell
+dvz update
+```
+
+새 버전을 별도 경로에 내려받아 실행 파일을 검증한 뒤 다음 실행 버전으로 전환합니다.
+실행 중인 `dvz` 세션은 이전 버전을 유지하고, 새로 시작하는 세션부터 새 버전을 사용합니다.
+
+업데이트 확인을 끄려면 `DEVEZ_VIBE_NO_UPDATE_CHECK` 환경변수를 설정합니다.
+
+## 라이선스
+
+MIT. 자세한 내용은 [저장소](https://github.com/MrHoje/Devez-vibe)를 참고하세요.

package/bin/dvz.js

@@ -1,35 +1,35 @@
-#!/usr/bin/env node
-
-import { existsSync, readFileSync } from "node:fs";
-import { spawn } from "node:child_process";
-import { dirname, isAbsolute, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const packageExecutable = join(dirname(fileURLToPath(import.meta.url)), "dvz.exe");
-const pointer = process.env.LOCALAPPDATA
-  ? join(process.env.LOCALAPPDATA, "DevezVibe", "current-executable.txt")
-  : "";
-
-let executable = packageExecutable;
-try {
-  const candidate = pointer ? readFileSync(pointer, "utf8").trim() : "";
-  if (isAbsolute(candidate) && existsSync(candidate)) executable = candidate;
-} catch {
-  // A missing or incomplete pointer falls back to the npm-packaged executable.
-}
-
-const child = spawn(executable, process.argv.slice(2), { stdio: "inherit" });
-child.on("error", (error) => {
-  console.error(`Devez Vibe 실행 실패: ${error.message}`);
-  process.exit(1);
-});
-child.on("exit", (code, signal) => {
-  if (signal) process.kill(process.pid, signal);
-  else process.exit(code ?? 1);
-});
-
-for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
-  process.on(signal, () => {
-    if (!child.killed) child.kill(signal);
-  });
-}
+#!/usr/bin/env node
+
+import { existsSync, readFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { dirname, isAbsolute, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageExecutable = join(dirname(fileURLToPath(import.meta.url)), "dvz.exe");
+const pointer = process.env.LOCALAPPDATA
+  ? join(process.env.LOCALAPPDATA, "DevezVibe", "current-executable.txt")
+  : "";
+
+let executable = packageExecutable;
+try {
+  const candidate = pointer ? readFileSync(pointer, "utf8").trim() : "";
+  if (isAbsolute(candidate) && existsSync(candidate)) executable = candidate;
+} catch {
+  // A missing or incomplete pointer falls back to the npm-packaged executable.
+}
+
+const child = spawn(executable, process.argv.slice(2), { stdio: "inherit" });
+child.on("error", (error) => {
+  console.error(`Devez Vibe 실행 실패: ${error.message}`);
+  process.exit(1);
+});
+child.on("exit", (code, signal) => {
+  if (signal) process.kill(process.pid, signal);
+  else process.exit(code ?? 1);
+});
+
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+  process.on(signal, () => {
+    if (!child.killed) child.kill(signal);
+  });
+}

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

@@ -330,10 +330,40 @@ function catalogEntry(model, defaultResolvedModel) {
   };
 }
 
+function compareVersions(left, right) {
+  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+    const difference = (left[index] ?? 0) - (right[index] ?? 0);
+    if (difference) return difference;
+  }
+  return 0;
+}
+
+/** Each family's newest model in CLAUDE_MODEL_ORDER first, then older ones by family and version. */
+function sortClaudeModels(models) {
+  const ranked = models.map((model) => {
+    const [family = "", version = ""] = compactClaudeModelName(model).toLowerCase().split(" ");
+    return { model, family, version: version.match(/\d+/g)?.map(Number) ?? [] };
+  });
+  const newest = new Map();
+  for (const { family, version } of ranked) {
+    if (!newest.has(family) || compareVersions(version, newest.get(family)) > 0) newest.set(family, version);
+  }
+  const tier = (entry) => (compareVersions(entry.version, newest.get(entry.family)) === 0 ? 0 : 1);
+  const familyOrder = ({ family }) => {
+    const index = CLAUDE_MODEL_ORDER.indexOf(family);
+    return index < 0 ? CLAUDE_MODEL_ORDER.length : index;
+  };
+  return ranked
+    .sort((left, right) => tier(left) - tier(right)
+      || familyOrder(left) - familyOrder(right)
+      || compareVersions(right.version, left.version))
+    .map(({ model }) => model);
+}
+
 function claudeCatalogEntries(models, defaultResolvedModel) {
-  const catalogModels = models.filter((model) => model.value && model.value !== "default"
+  const catalogModels = sortClaudeModels(models.filter((model) => model.value && model.value !== "default"
     && ![model.value, model.resolvedModel]
-      .some((name) => stripClaudeModel(String(name || "")).startsWith(RETIRED_OPUS_MODEL)));
+      .some((name) => stripClaudeModel(String(name || "")).startsWith(RETIRED_OPUS_MODEL))));
   const entries = catalogModels.map((model) => catalogEntry(model, defaultResolvedModel));
   const existingIndex = entries.findIndex((entry) =>
     stripClaudeModel(entry.model) === PREVIOUS_OPUS_MODEL
@@ -401,14 +431,6 @@ async function loadModelCatalog(params) {
       const defaultResolvedModel = String(
         models.find((model) => model.value === "default")?.resolvedModel || "",
       );
-      models.sort((left, right) => {
-        const leftFamily = String(left.value || "").match(/(fable|opus|sonnet|haiku)/i)?.[1]?.toLowerCase();
-        const rightFamily = String(right.value || "").match(/(fable|opus|sonnet|haiku)/i)?.[1]?.toLowerCase();
-        const leftOrder = CLAUDE_MODEL_ORDER.indexOf(leftFamily);
-        const rightOrder = CLAUDE_MODEL_ORDER.indexOf(rightFamily);
-        return (leftOrder < 0 ? CLAUDE_MODEL_ORDER.length : leftOrder)
-          - (rightOrder < 0 ? CLAUDE_MODEL_ORDER.length : rightOrder);
-      });
       return {
         data: claudeCatalogEntries(models, defaultResolvedModel),
       };
@@ -902,14 +924,14 @@ async function requestToolPermission(toolName, input, permission) {
   // 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 = permission.suppressAlwaysAllowRule
-    ? "" : permissionSuggestionLabel(permission.suggestions);
-  const common = {
-    claudePermission: true,
-    title: permission.title || permission.displayName,
-    persistentApprovalLabel,
-    defaultToNo: Boolean(permission.defaultToNo),
-    suppressAlwaysAllowRule: Boolean(permission.suppressAlwaysAllowRule),
+  const persistentApprovalLabel = permission.suppressAlwaysAllowRule
+    ? "" : permissionSuggestionLabel(permission.suggestions);
+  const common = {
+    claudePermission: true,
+    title: permission.title || permission.displayName,
+    persistentApprovalLabel,
+    defaultToNo: Boolean(permission.defaultToNo),
+    suppressAlwaysAllowRule: Boolean(permission.suppressAlwaysAllowRule),
   };
 
   let method = "item/permissions/requestApproval";
@@ -947,10 +969,10 @@ async function requestToolPermission(toolName, input, permission) {
   return {
     behavior: "allow",
     updatedInput: input,
-    ...(!permission.suppressAlwaysAllowRule
-      && (response?.decision === "acceptForSession" || response?.scope === "session")
-      ? { updatedPermissions: permission.suggestions }
-      : {}),
+    ...(!permission.suppressAlwaysAllowRule
+      && (response?.decision === "acceptForSession" || response?.scope === "session")
+      ? { updatedPermissions: permission.suggestions }
+      : {}),
   };
 }
 
@@ -2627,6 +2649,12 @@ function processUser(session, message) {
         path: String(message.tool_use_result.path || pending.input?.file_path || ""),
       });
     }
+    // Worktree tools move the session's folder; reuse Codex's settings notice so the branch badge follows.
+    const worktreeCwd = pending.name === "EnterWorktree" ? message.tool_use_result?.worktreePath
+      : pending.name === "ExitWorktree" ? message.tool_use_result?.originalCwd : null;
+    if (!block.is_error && typeof worktreeCwd === "string") {
+      notify("thread/settings/updated", { threadId: session.id, threadSettings: { cwd: worktreeCwd } });
+    }
     pending.toolUseId = block.tool_use_id;
     if (pending.suppressed) {
       updatePlanFromToolResult(session, pending, message);
@@ -3895,7 +3923,7 @@ async function dispatch(method, params = {}) {
   throw new Error(`지원하지 않는 Claude 브리지 메서드: ${method}`);
 }
 
-async function runPermissionModeSelfTest() {
+async function runPermissionModeSelfTest() {
   const fakeSession = (setPermissionMode) => ({
     id: "permission-mode-self-test",
     permissionMode: BOOTSTRAP_PERMISSION_MODE,
@@ -3927,35 +3955,35 @@ async function runPermissionModeSelfTest() {
       || rejectedCalls.join(",") !== "auto" || rejected.permissionModeVerified) {
     throw new Error(`Claude permission double rejection self-test failed: ${doubleRejection}`);
   }
-}
-
-async function runGuardedPermissionSelfTest() {
-  const captured = [];
-  const originalWrite = process.stdout.write;
-  process.stdout.write = (chunk) => { captured.push(JSON.parse(String(chunk))); return true; };
-  try {
-    const pending = requestToolPermission("Bash", { command: "npm test" }, {
-      defaultToNo: true,
-      suppressAlwaysAllowRule: true,
-      suggestions: [{ destination: "projectSettings", rules: [{ toolName: "Bash" }] }],
-    });
-    const request = captured[0];
-    if (request.params.defaultToNo !== true
-        || request.params.suppressAlwaysAllowRule !== true
-        || request.params.persistentApprovalLabel) {
-      throw new Error("Claude guarded permission request self-test failed");
-    }
-    const reply = pendingHostRequests.get(request.id);
-    pendingHostRequests.delete(request.id);
-    reply.resolve({ decision: "acceptForSession" });
-    const result = await pending;
-    if (result.behavior !== "allow" || "updatedPermissions" in result) {
-      throw new Error("Claude guarded permission response self-test failed");
-    }
-  } finally {
-    process.stdout.write = originalWrite;
-  }
-}
+}
+
+async function runGuardedPermissionSelfTest() {
+  const captured = [];
+  const originalWrite = process.stdout.write;
+  process.stdout.write = (chunk) => { captured.push(JSON.parse(String(chunk))); return true; };
+  try {
+    const pending = requestToolPermission("Bash", { command: "npm test" }, {
+      defaultToNo: true,
+      suppressAlwaysAllowRule: true,
+      suggestions: [{ destination: "projectSettings", rules: [{ toolName: "Bash" }] }],
+    });
+    const request = captured[0];
+    if (request.params.defaultToNo !== true
+        || request.params.suppressAlwaysAllowRule !== true
+        || request.params.persistentApprovalLabel) {
+      throw new Error("Claude guarded permission request self-test failed");
+    }
+    const reply = pendingHostRequests.get(request.id);
+    pendingHostRequests.delete(request.id);
+    reply.resolve({ decision: "acceptForSession" });
+    const result = await pending;
+    if (result.behavior !== "allow" || "updatedPermissions" in result) {
+      throw new Error("Claude guarded permission response self-test failed");
+    }
+  } finally {
+    process.stdout.write = originalWrite;
+  }
+}
 
 function runToolPolicySelfTest() {
   const cwd = process.platform === "win32" ? "C:\\repo" : "/repo";
@@ -4051,8 +4079,8 @@ async function runSelfTest() {
   if (startupGaps.length) {
     throw new Error(`Claude 기동 실패 안내 누락: ${startupGaps.join(", ")}`);
   }
-  await runPermissionModeSelfTest();
-  await runGuardedPermissionSelfTest();
+  await runPermissionModeSelfTest();
+  await runGuardedPermissionSelfTest();
   runToolPolicySelfTest();
   await runCommandTimeoutSelfTest();
   // A turn that ends with no answer must reach the user: refusal as an error
@@ -4569,6 +4597,19 @@ async function runSelfTest() {
     ) !== "max") {
     throw new Error(`Claude pinned model self-test failed: ${JSON.stringify(catalog)}`);
   }
+  const orderedNames = claudeCatalogEntries([
+    { value: "haiku", displayName: "Haiku 4.5" },
+    { value: "claude-sonnet-4-6", displayName: "Sonnet 4.6" },
+    { value: "fable", displayName: "Fable 5" },
+    { value: "opus", resolvedModel: "claude-opus-5-5", displayName: "Opus" },
+    { value: "sonnet", displayName: "Sonnet 5" },
+    { value: "claude-opus-6", displayName: "Opus 6" },
+    { value: "claude-fable-5-1", displayName: "Fable 5.1" },
+    { value: "nova", displayName: "Nova 1" },
+  ].map((model) => ({ resolvedModel: model.value, ...model })), "").filter((entry) => !entry.hidden).map((entry) => entry.displayName).join(",");
+  if (orderedNames !== "Fable 5.1,Opus 6,Sonnet 5,Haiku 4.5,Nova 1,Fable 5,Opus 5.5,Sonnet 4.6") {
+    throw new Error(`Claude model order self-test failed: ${orderedNames}`);
+  }
   const inheritedFork = forkSessionSelection(
     { model: "claude:sonnet", effort: "high" },
     { model: "claude:opus", effort: "max" },
@@ -4988,6 +5029,27 @@ async function runSelfTest() {
     }
     finishTurn(lifecycleSession, null, 1);
 
+    beginTurn(lifecycleSession);
+    const beforeWorktree = captured.length;
+    for (const [id, name, result] of [
+      ["toolu_wt1", "EnterWorktree", { worktreePath: "D:\\repo\\.claude\\worktrees\\task", message: "" }],
+      ["toolu_wt2", "ExitWorktree", { action: "keep", originalCwd: "D:\\repo", worktreePath: "D:\\repo\\.claude\\worktrees\\task", message: "" }],
+    ]) {
+      processToolUse(lifecycleSession, { type: "tool_use", id, name, input: {} });
+      processUser(lifecycleSession, {
+        message: { content: [{ type: "tool_result", tool_use_id: id, content: "" }] },
+        tool_use_result: result,
+      });
+    }
+    const worktreeCwds = captured.slice(beforeWorktree).join("").trim().split("\n")
+      .map((line) => JSON.parse(line))
+      .filter((line) => line.method === "thread/settings/updated")
+      .map((line) => line.params.threadSettings.cwd);
+    if (JSON.stringify(worktreeCwds) !== JSON.stringify(["D:\\repo\\.claude\\worktrees\\task", "D:\\repo"])) {
+      throw new Error(`Claude worktree folder self-test failed: ${JSON.stringify(worktreeCwds)}`);
+    }
+    finishTurn(lifecycleSession, null, 1);
+
     const structuredSession = {
       id: "structured-self-test",
       turn: null,

package/install-skills.mjs

@@ -1,18 +1,18 @@
 import {
   copyFileSync,
   existsSync,
-  mkdirSync,
-  readdirSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
+  mkdirSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const packageRoot = dirname(fileURLToPath(import.meta.url));
-const skillNames = ["luna-loop", "insane-search"];
-const bundledMarker = ".devez-vibe-bundled-skill";
+const skillNames = ["luna-loop", "insane-search"];
+const bundledMarker = ".devez-vibe-bundled-skill";
 const userHome = homedir();
 const codexHome = process.env.CODEX_HOME?.trim() || join(userHome, ".codex");
 const claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join(userHome, ".claude");
@@ -61,10 +61,10 @@ for (const skill of skillNames) {
   for (const home of homes) {
     const target = join(home.root, skill);
     try {
-      copyTree(sourceRoot, target);
-      pruneTree(sourceRoot, target);
-      writeFileSync(join(target, bundledMarker), `${skill}\n`, "utf8");
-      console.log(`스킬 설치 완료 (${home.name}/${skill}): ${target}`);
+      copyTree(sourceRoot, target);
+      pruneTree(sourceRoot, target);
+      writeFileSync(join(target, bundledMarker), `${skill}\n`, "utf8");
+      console.log(`스킬 설치 완료 (${home.name}/${skill}): ${target}`);
     } catch (error) {
       failed = true;
       console.error(`스킬 설치 실패 (${home.name}/${skill}): ${error instanceof Error ? error.message : error}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devez-vibe",
-  "version": "1.9.33",
+  "version": "1.9.35",
   "type": "module",
   "description": "Stable terminal UI for Codex and Claude Agent SDK",
   "keywords": [

package/prepare-search-deps.mjs

@@ -1,42 +1,42 @@
-// insane-search 스킬이 첫 호출에서 받는 파이썬 패키지를 설치 시점에 미리 깔아 둔다.
-// 준비는 어디까지나 선택적이다. 파이썬이 없거나 설치가 실패해도 안내만 남기고 정상 종료해서
-// devezVibe 설치 자체가 깨지지 않게 한다. 스킬은 첫 사용 때 다시 설치를 시도하므로 손해가 없다.
-import { spawnSync } from "node:child_process";
-
-// SKILL.md의 의존성 가드와 같은 조합이다. 한쪽만 바뀌면 첫 호출에서 다시 설치가 돈다.
-const guard = 'import curl_cffi,bs4,yaml,pypdf,markdownify; v=curl_cffi.__version__.split("."); assert (int(v[0]),int(v[1]))>=(0,15)';
-const packages = ["curl_cffi>=0.15.0", "beautifulsoup4", "pyyaml", "pypdf", "markdownify"];
-
-function run(command, args) {
-  return spawnSync(command, args, { encoding: "utf8", windowsHide: true, timeout: 300000 });
-}
-
-// Windows에는 python3가 없는 대신 실행하면 스토어를 여는 별칭이 잡혀 있을 수 있다.
-// 버전 출력을 실제로 확인해서 쓸 수 있는 실행기만 고른다.
-function findPython() {
-  for (const candidate of ["python3", "python", "py"]) {
-    const probe = run(candidate, ["-c", "import sys; print(sys.version_info[0])"]);
-    if (probe.status === 0 && probe.stdout.trim() === "3") return candidate;
-  }
-  return null;
-}
-
-const python = findPython();
-if (!python) {
-  console.log("insane-search 준비 건너뜀: 파이썬 3을 찾지 못했습니다. 설치하면 첫 사용 때 자동으로 준비됩니다.");
-  process.exit(0);
-}
-
-if (run(python, ["-c", guard]).status === 0) {
-  console.log("insane-search 의존성 준비 완료: 이미 설치되어 있습니다.");
-  process.exit(0);
-}
-
-// --user는 관리자 권한 없이도 설치되게 하고, 가상환경에서는 pip가 알아서 무시한다.
-const install = run(python, ["-m", "pip", "install", "-U", "--user", "-q", ...packages]);
-if (install.status === 0 && run(python, ["-c", guard]).status === 0) {
-  console.log("insane-search 의존성 준비 완료");
-} else {
-  const detail = (install.stderr || install.stdout || "").trim().split("\n").pop() || "원인 미상";
-  console.log(`insane-search 준비 건너뜀 (${detail}). 첫 사용 때 다시 시도합니다.`);
-}
+// insane-search 스킬이 첫 호출에서 받는 파이썬 패키지를 설치 시점에 미리 깔아 둔다.
+// 준비는 어디까지나 선택적이다. 파이썬이 없거나 설치가 실패해도 안내만 남기고 정상 종료해서
+// devezVibe 설치 자체가 깨지지 않게 한다. 스킬은 첫 사용 때 다시 설치를 시도하므로 손해가 없다.
+import { spawnSync } from "node:child_process";
+
+// SKILL.md의 의존성 가드와 같은 조합이다. 한쪽만 바뀌면 첫 호출에서 다시 설치가 돈다.
+const guard = 'import curl_cffi,bs4,yaml,pypdf,markdownify; v=curl_cffi.__version__.split("."); assert (int(v[0]),int(v[1]))>=(0,15)';
+const packages = ["curl_cffi>=0.15.0", "beautifulsoup4", "pyyaml", "pypdf", "markdownify"];
+
+function run(command, args) {
+  return spawnSync(command, args, { encoding: "utf8", windowsHide: true, timeout: 300000 });
+}
+
+// Windows에는 python3가 없는 대신 실행하면 스토어를 여는 별칭이 잡혀 있을 수 있다.
+// 버전 출력을 실제로 확인해서 쓸 수 있는 실행기만 고른다.
+function findPython() {
+  for (const candidate of ["python3", "python", "py"]) {
+    const probe = run(candidate, ["-c", "import sys; print(sys.version_info[0])"]);
+    if (probe.status === 0 && probe.stdout.trim() === "3") return candidate;
+  }
+  return null;
+}
+
+const python = findPython();
+if (!python) {
+  console.log("insane-search 준비 건너뜀: 파이썬 3을 찾지 못했습니다. 설치하면 첫 사용 때 자동으로 준비됩니다.");
+  process.exit(0);
+}
+
+if (run(python, ["-c", guard]).status === 0) {
+  console.log("insane-search 의존성 준비 완료: 이미 설치되어 있습니다.");
+  process.exit(0);
+}
+
+// --user는 관리자 권한 없이도 설치되게 하고, 가상환경에서는 pip가 알아서 무시한다.
+const install = run(python, ["-m", "pip", "install", "-U", "--user", "-q", ...packages]);
+if (install.status === 0 && run(python, ["-c", guard]).status === 0) {
+  console.log("insane-search 의존성 준비 완료");
+} else {
+  const detail = (install.stderr || install.stdout || "").trim().split("\n").pop() || "원인 미상";
+  console.log(`insane-search 준비 건너뜀 (${detail}). 첫 사용 때 다시 시도합니다.`);
+}