pybao-cli 1.4.89 → 1.4.91

package/dist/{chunk-HVJRX43N.js → chunk-MNVUFKYB.js}

@@ -2,11 +2,11 @@ import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
 import {
   listPybAgentSessions
-} from "./chunk-3JTP3A2Y.js";
+} from "./chunk-3JJGOOVV.js";
 import {
   formatValidationResult,
   validatePluginOrMarketplacePath
-} from "./chunk-JQBOODVQ.js";
+} from "./chunk-Z7TKBN4K.js";
 import {
   ConversationTracker,
   appendFinishState,
@@ -14,18 +14,18 @@ import {
   getConversationTrackerForContext,
   isFinishComplete,
   mapFinishReason
-} from "./chunk-JDMIFTZT.js";
+} from "./chunk-FZAPDUPC.js";
 import {
   beginReplSessionScope
 } from "./chunk-F4AXICO7.js";
 import {
   loadPybAgentSessionMessages
-} from "./chunk-JJSCNIBA.js";
+} from "./chunk-4IZGIKGU.js";
 import {
   appendSessionCustomTitleRecord,
   appendSessionJsonlFromMessage,
   appendSessionTagRecord
-} from "./chunk-4CTXCXJV.js";
+} from "./chunk-KSWPVLIN.js";
 import {
   drainHookSystemPromptAdditions,
   getHookTranscriptPath,
@@ -37,7 +37,7 @@ import {
   runStopHooks,
   runUserPromptSubmitHooks,
   updateHookTranscriptForMessages
-} from "./chunk-LV4FISWZ.js";
+} from "./chunk-5Z6IMMMW.js";
 import {
   DEFAULT_OUTPUT_STYLE,
   getAvailableOutputStyles,
@@ -46,11 +46,11 @@ import {
   getOutputStyleSystemPromptAdditions,
   resolveOutputStyleName,
   setCurrentOutputStyle
-} from "./chunk-CSP6P6NO.js";
+} from "./chunk-2NGXOHGX.js";
 import {
   fetchCustomModels,
   getModelFeatures
-} from "./chunk-5DKBPIUY.js";
+} from "./chunk-UULWYB2S.js";
 import {
   getSessionState
 } from "./chunk-XKYHFZEC.js";
@@ -58,7 +58,7 @@ import {
   queryLLM,
   queryQuick,
   verifyApiKey
-} from "./chunk-XAABWNGX.js";
+} from "./chunk-U3LLCIIX.js";
 import {
   DEFAULT_TIMEOUT_MS,
   FallbackToolUseRejectedMessage,
@@ -72,7 +72,7 @@ import {
   listMCPServers,
   loadMergedSettings,
   normalizeSandboxRuntimeConfigFromSettings
-} from "./chunk-KHSTNHZE.js";
+} from "./chunk-CHTGXWNW.js";
 import {
   addMarketplace,
   disableSkillPlugin,
@@ -85,11 +85,11 @@ import {
   refreshMarketplaceAsync,
   removeMarketplace,
   uninstallSkillPlugin
-} from "./chunk-NZPUVS6K.js";
+} from "./chunk-IRVS47LS.js";
 import {
   loadToolPermissionContextFromDisk,
   persistToolPermissionUpdateToDisk
-} from "./chunk-THQLFNKQ.js";
+} from "./chunk-B7YI7BZU.js";
 import {
   applyToolPermissionContextUpdate,
   applyToolPermissionContextUpdates,
@@ -100,13 +100,13 @@ import {
   generateSystemReminders,
   resetReminderSession,
   systemReminderService
-} from "./chunk-YAC4ZESX.js";
+} from "./chunk-L5FMWVFJ.js";
 import {
   clearAgentCache,
   getActiveAgents,
   getAgentByType,
   getAllAgents
-} from "./chunk-5DBEI4U3.js";
+} from "./chunk-KLFTZBHM.js";
 import {
   API_ERROR_MESSAGE_PREFIX,
   CANCEL_MESSAGE,
@@ -137,7 +137,7 @@ import {
   processUserInput,
   reorderMessages,
   stripSystemMessages
-} from "./chunk-A5255NE3.js";
+} from "./chunk-7VNU2ZKH.js";
 import {
   getRequestStatus,
   setRequestStatus,
@@ -167,7 +167,7 @@ import {
   normalizeFilePath,
   readTextContent,
   writeTextContent
-} from "./chunk-UAMS53ZK.js";
+} from "./chunk-OM7XZWUN.js";
 import {
   parseBlockEdits
 } from "./chunk-QWIBSCDN.js";
@@ -177,18 +177,18 @@ import {
   ParserRegistry,
   initParser,
   loadLanguage
-} from "./chunk-I72YSEMN.js";
+} from "./chunk-6FUTCMZK.js";
 import {
   getSettingsFileCandidates,
   loadSettingsWithLegacyFallback,
   readSettingsFile
-} from "./chunk-RLD57RVF.js";
+} from "./chunk-GZ3J3MB7.js";
 import {
   getCustomCommandDirectories,
   hasCustomCommands,
   loadCustomCommands,
   reloadCustomCommands
-} from "./chunk-YNDZ73R7.js";
+} from "./chunk-35DF6XKC.js";
 import {
   getSessionPlugins
 } from "./chunk-BJSWTHRM.js";
@@ -196,7 +196,7 @@ import {
   ModelManager,
   getModelManager,
   isDefaultSlowAndCapableModel
-} from "./chunk-UNDLA4M4.js";
+} from "./chunk-7KPYOLFD.js";
 import {
   getCodeStyle,
   getContext,
@@ -204,13 +204,16 @@ import {
   getIsGit,
   getProjectDocs,
   getProjectStructureStatisticsBlock
-} from "./chunk-FYLGTG5A.js";
+} from "./chunk-KXCSPC5I.js";
 import {
+  getRipgrepPath,
+  getRipgrepPolicyMode,
+  resolveRipgrepPolicy,
   ripGrep
-} from "./chunk-3WX6M33B.js";
+} from "./chunk-W3Z3A6JG.js";
 import {
   getTheme
-} from "./chunk-R2BVICE2.js";
+} from "./chunk-LMF7SSDW.js";
 import {
   DEFAULT_GLOBAL_CONFIG,
   enableConfigs,
@@ -223,7 +226,7 @@ import {
   saveGlobalConfig,
   setAllPointersToModel,
   setModelPointer
-} from "./chunk-5N4LX65G.js";
+} from "./chunk-XUPHN5RT.js";
 import {
   AbortError
 } from "./chunk-RQVLBMP7.js";
@@ -232,7 +235,7 @@ import {
   getCurrentRequest,
   logUserFriendly,
   markPhase
-} from "./chunk-UIGWD3MR.js";
+} from "./chunk-PAW3JPND.js";
 import {
   ASCII_LOGO,
   BunShell,
@@ -272,16 +275,16 @@ import {
   setCwd,
   shouldApplyToolOutputTruncation,
   truncateToolOutput
-} from "./chunk-DRHWOS44.js";
+} from "./chunk-FSSXF2YS.js";
 import {
   MACRO
-} from "./chunk-67D6QME2.js";
+} from "./chunk-B5AO2OEN.js";
 import {
   __export
 } from "./chunk-I3J4JYES.js";
 
 // src/tools/system/BashTool/BashTool.tsx
-import { statSync as statSync13 } from "fs";
+import { statSync as statSync14 } from "fs";
 import { EOL as EOL3 } from "os";
 import { isAbsolute as isAbsolute8, relative as relative12, resolve as resolve11 } from "path";
 import * as React106 from "react";
@@ -456,7 +459,7 @@ var getCommandSubcommandPrefix = memoize(
 var getCommandPrefix = memoize(
   async (command4, abortSignal) => {
     const { systemPrompt, userPrompt } = buildBashCommandPrefixDetectionPrompt(command4);
-    const { API_ERROR_MESSAGE_PREFIX: API_ERROR_MESSAGE_PREFIX2, queryQuick: queryQuick2 } = await import("./llm-UGJYESRH.js");
+    const { API_ERROR_MESSAGE_PREFIX: API_ERROR_MESSAGE_PREFIX2, queryQuick: queryQuick2 } = await import("./llm-VY6QQH5B.js");
     const response = await queryQuick2({
       systemPrompt,
       userPrompt,
@@ -939,9 +942,9 @@ async function startHttpProxy() {
           writeHttpErrorResponse(clientSocket, "502 Bad Gateway");
         });
         upstream.once("connect", () => {
-          const path5 = `${targetUrl.pathname}${targetUrl.search}`;
+          const path6 = `${targetUrl.pathname}${targetUrl.search}`;
           try {
-            upstream.write(`${method} ${path5} ${version}\r
+            upstream.write(`${method} ${path6} ${version}\r
 `);
             for (const [k, v] of Object.entries(headers)) {
               upstream.write(`${k}: ${v}\r
@@ -4258,7 +4261,7 @@ function formatParseError(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function defaultGateQuery(args) {
-  const { API_ERROR_MESSAGE_PREFIX: API_ERROR_MESSAGE_PREFIX2, queryLLM: queryLLM2 } = await import("./llm-UGJYESRH.js");
+  const { API_ERROR_MESSAGE_PREFIX: API_ERROR_MESSAGE_PREFIX2, queryLLM: queryLLM2 } = await import("./llm-VY6QQH5B.js");
   const queryLLMFn = args.queryLLMOverride ?? queryLLM2;
   const messages = [
     {
@@ -4337,7 +4340,7 @@ function writeGateFailureDump(args) {
     const dir = join2(CACHE_PATHS.errors(), "bash-llm-gate");
     mkdirSync(dir, { recursive: true });
     const filename = `${dateToFilename(/* @__PURE__ */ new Date())}-${randomUUID()}.txt`;
-    const path5 = join2(dir, filename);
+    const path6 = join2(dir, filename);
     const body = [
       "=== Bash LLM gate failure ===",
       "",
@@ -4364,7 +4367,7 @@ function writeGateFailureDump(args) {
       args.output ?? "",
       ""
     ].filter(Boolean).join("\n");
-    writeFileSync(path5, body, "utf8");
+    writeFileSync(path6, body, "utf8");
   } catch {
   }
 }
@@ -6049,8 +6052,8 @@ var FileFreshnessService = class {
     return this.state.readTimestamps.has(filePath);
   }
   getImportantFiles(maxFiles = 5) {
-    return Array.from(this.state.readTimestamps.entries()).map(([path5, info]) => ({
-      path: path5,
+    return Array.from(this.state.readTimestamps.entries()).map(([path6, info]) => ({
+      path: path6,
       timestamp: info.lastRead,
       size: info.size
     })).filter((file) => this.isValidForRecovery(file.path)).sort((a, b) => b.timestamp - a.timestamp).slice(0, maxFiles);
@@ -6108,8 +6111,8 @@ import { dirname, isAbsolute, resolve, relative as relative2 } from "path";
 import { statSync as statSync3 } from "fs";
 var readFileAllowedDirectories = /* @__PURE__ */ new Set();
 var writeFileAllowedDirectories = /* @__PURE__ */ new Set();
-function toAbsolutePath(path5) {
-  const abs = isAbsolute(path5) ? resolve(path5) : resolve(getCwd(), path5);
+function toAbsolutePath(path6) {
+  const abs = isAbsolute(path6) ? resolve(path6) : resolve(getCwd(), path6);
   return normalizeForCompare(abs);
 }
 function normalizeForCompare(p) {
@@ -6123,13 +6126,13 @@ function isSubpath(base, target) {
   if (isAbsolute(rel)) return false;
   return true;
 }
-function pathToPermissionDirectory(path5) {
+function pathToPermissionDirectory(path6) {
   try {
-    const stats = statSync3(path5);
-    if (stats.isDirectory()) return path5;
+    const stats = statSync3(path6);
+    if (stats.isDirectory()) return path6;
   } catch {
   }
-  return dirname(path5);
+  return dirname(path6);
 }
 function hasReadPermission(directory) {
   if (isMainPlanFilePathForActiveConversation(directory)) return true;
@@ -6169,8 +6172,8 @@ function saveWritePermission(directory) {
   }
   writeFileAllowedDirectories.add(absolutePath);
 }
-function grantWritePermissionForPath(path5) {
-  const absolutePath = toAbsolutePath(path5);
+function grantWritePermissionForPath(path6) {
+  const absolutePath = toAbsolutePath(path6);
   saveWritePermission(pathToPermissionDirectory(absolutePath));
 }
 
@@ -6655,7 +6658,7 @@ var FileEditTool = {
     const originalFileContent = currentFileContent;
     let totalPatch = [];
     const { SmartEdit } = await import("./smart-edit-AWHJDSU6.js");
-    const { findLspAnchor } = await import("./lspAnchor-J4GMFONT.js");
+    const { findLspAnchor } = await import("./lspAnchor-KQ2FF4JY.js");
     for (const op of editOperations) {
       const normalizedSearch = normalizeLineEndings(op.search);
       const normalizedReplace = normalizeLineEndings(op.replace);
@@ -6756,13 +6759,24 @@ Suggestion: fix errors or rerun with verify=false.`);
 };
 
 // src/tools/filesystem/FileReadTool/FileReadTool.tsx
-import { statSync as statSync6 } from "fs";
+import { statSync as statSync7 } from "fs";
 import { Box as Box12, Text as Text13 } from "ink";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import { extname as extname4, relative as relative6 } from "node:path";
 import * as React13 from "react";
 import { z as z4 } from "zod";
 
+// src/services/telemetry/eventBus.ts
+var listeners2 = /* @__PURE__ */ new Map();
+function registerTelemetryListener(listenerId, listener) {
+  listeners2.set(listenerId, listener);
+}
+function emitTelemetryEvent(event) {
+  for (const listener of listeners2.values()) {
+    listener(event);
+  }
+}
+
 // src/tools/filesystem/FileReadTool/prompt.ts
 var MAX_LINES_TO_READ = 2e3;
 var MAX_LINE_LENGTH = 2e3;
@@ -7265,6 +7279,165 @@ var SmartTruncator = class _SmartTruncator {
   }
 };
 
+// src/services/stability/runtimeAssetHealth/checks/treeSitter.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3, statSync as statSync6 } from "node:fs";
+import { createHash } from "node:crypto";
+import path4 from "node:path";
+import { fileURLToPath } from "node:url";
+function getDirname() {
+  try {
+    return __dirname;
+  } catch {
+    return path4.dirname(fileURLToPath(import.meta.url));
+  }
+}
+function resolveTreeSitterResourceDir() {
+  const envDir = process.env.PYB_RESOURCE_DIR?.trim();
+  if (envDir) return envDir;
+  const dirname11 = getDirname();
+  if (dirname11.includes("dist") || dirname11.includes("node_modules")) {
+    return path4.resolve(dirname11, "../../../../resources/tree-sitter");
+  }
+  return path4.resolve(dirname11, "../../../../../resources/tree-sitter");
+}
+var REQUIRED_TREE_SITTER_FILES = [
+  "tree-sitter.wasm",
+  "tree-sitter-typescript.wasm",
+  "tree-sitter-bash.wasm"
+];
+function isTreeSitterVerifyEnabled() {
+  const raw = process.env.PYB_TREE_SITTER_VERIFY?.trim().toLowerCase();
+  return raw === "1" || raw === "true" || raw === "yes";
+}
+function verifyTreeSitterManifestIntegrity(input) {
+  if (!input.verifyEnabled) {
+    return;
+  }
+  const manifestPath = path4.join(input.resourcesDir, "manifest.json");
+  const hasExplicitResourceDir = Boolean(process.env.PYB_RESOURCE_DIR?.trim());
+  if (!existsSync5(manifestPath)) {
+    if (hasExplicitResourceDir) {
+      throw new Error(
+        `resource path drift: PYB_RESOURCE_DIR points to directory without manifest: ${input.resourcesDir}`
+      );
+    }
+    throw new Error(`tree-sitter manifest missing: ${manifestPath}`);
+  }
+  const manifestRaw = readFileSync3(manifestPath, "utf8");
+  const manifest = JSON.parse(manifestRaw);
+  if (!manifest.files) {
+    throw new Error(`tree-sitter manifest invalid: files field missing`);
+  }
+  for (const fileName of REQUIRED_TREE_SITTER_FILES) {
+    const filePath = path4.join(input.resourcesDir, fileName);
+    const expectedSha256 = manifest.files[fileName]?.sha256;
+    if (!expectedSha256) {
+      throw new Error(`tree-sitter manifest invalid: checksum missing for ${fileName}`);
+    }
+    const actualSha256 = createHash("sha256").update(readFileSync3(filePath)).digest("hex");
+    if (actualSha256 !== expectedSha256) {
+      throw new Error(
+        `tree-sitter checksum mismatch for ${fileName}: expected ${expectedSha256}, got ${actualSha256}`
+      );
+    }
+  }
+}
+async function checkTreeSitterCoreLoadable() {
+  const resourcesDir = resolveTreeSitterResourceDir();
+  verifyTreeSitterManifestIntegrity({
+    resourcesDir,
+    verifyEnabled: isTreeSitterVerifyEnabled()
+  });
+  const corePath = path4.join(resourcesDir, "tree-sitter.wasm");
+  const stat2 = statSync6(corePath);
+  if (!stat2.isFile() || stat2.size <= 0) {
+    throw new Error(`tree-sitter core wasm is missing or empty: ${corePath}`);
+  }
+  const { Parser } = await import("web-tree-sitter");
+  await Parser.init({
+    locateFile: () => corePath
+  });
+}
+async function checkTreeSitterGrammarLoadable(lang) {
+  emitTelemetryEvent({
+    channel: "runtime_assets",
+    phase: "TREE_SITTER_LANGUAGE_LOAD",
+    timestamp: Date.now(),
+    data: {
+      lang,
+      stage: "before",
+      status: "start"
+    }
+  });
+  try {
+    await loadLanguage(lang);
+    emitTelemetryEvent({
+      channel: "runtime_assets",
+      phase: "TREE_SITTER_LANGUAGE_LOAD",
+      timestamp: Date.now(),
+      data: {
+        lang,
+        stage: "after",
+        status: "ok"
+      }
+    });
+  } catch (error) {
+    emitTelemetryEvent({
+      channel: "runtime_assets",
+      phase: "TREE_SITTER_LANGUAGE_LOAD",
+      timestamp: Date.now(),
+      data: {
+        lang,
+        stage: "error",
+        status: "error",
+        message: String(error instanceof Error ? error.message : error)
+      }
+    });
+    throw error;
+  }
+}
+function classifyTreeSitterHealthError(error) {
+  const message = String(error ?? "").toLowerCase();
+  if ((message.includes("checksum") || message.includes("sha256")) && message.includes("mismatch")) {
+    return "TS_CHECKSUM_MISMATCH";
+  }
+  if (message.includes("manifest") && message.includes("tree-sitter")) {
+    return "TS_CHECKSUM_MISMATCH";
+  }
+  if (message.includes("resource path drift") || message.includes("pyb_resource_dir") && (message.includes("stale") || message.includes("drift"))) {
+    return "TS_RESOURCE_PATH_DRIFT";
+  }
+  if (message.includes("incompatible language version") || message.includes("compatibility range")) {
+    return "TS_VERSION_INCOMPATIBLE";
+  }
+  if (message.includes("tree-sitter.wasm") && (message.includes("enoent") || message.includes("missing"))) {
+    return "TS_WASM_MISSING";
+  }
+  if (message.includes("tree-sitter-") && message.includes(".wasm")) {
+    return "TS_GRAMMAR_MISSING";
+  }
+  if (message.includes("enoent") && message.includes("wasm")) {
+    return "TS_GRAMMAR_MISSING";
+  }
+  return "TS_LOAD_UNKNOWN";
+}
+
+// src/services/stability/runtimeAssetHealth/fallback.ts
+function toSmartTruncationFallbackEvent(input) {
+  const code = classifyTreeSitterHealthError(input.error);
+  const message = String(input.error instanceof Error ? input.error.message : input.error);
+  return {
+    channel: "runtime_assets",
+    phase: "TREE_SITTER_SMART_TRUNCATION_FALLBACK",
+    timestamp: input.timestamp ?? Date.now(),
+    data: {
+      code,
+      filePath: input.filePath,
+      message
+    }
+  };
+}
+
 // src/tools/filesystem/FileReadTool/FileReadTool.tsx
 var MAX_LINES_TO_RENDER = 5;
 var MAX_LINE_LENGTH2 = 2e3;
@@ -7448,7 +7621,7 @@ var FileReadTool = {
         message
       };
     }
-    const ext = path4.extname(fullFilePath).toLowerCase();
+    const ext = path5.extname(fullFilePath).toLowerCase();
     const fileSize = fileCheck.stats?.size ?? 0;
     if (BINARY_EXTENSIONS.has(ext)) {
       return {
@@ -7476,7 +7649,7 @@ var FileReadTool = {
     return { result: true };
   },
   async *call({ file_path, offset = 1, limit = void 0, symbol_name }, { readFileTimestamps }) {
-    const ext = path4.extname(file_path).toLowerCase();
+    const ext = path5.extname(file_path).toLowerCase();
     const fullFilePath = normalizeFilePath(file_path);
     let startLine = offset;
     let finalLimit = limit;
@@ -7515,7 +7688,7 @@ var FileReadTool = {
       extension: ext,
       timestamp: Date.now()
     });
-    readFileTimestamps[fullFilePath] = statSync6(fullFilePath).mtimeMs;
+    readFileTimestamps[fullFilePath] = statSync7(fullFilePath).mtimeMs;
     const modificationReminder = generateFileModificationReminder(fullFilePath);
     if (modificationReminder) {
       emitReminderEvent("file:modified", {
@@ -7591,6 +7764,12 @@ var FileReadTool = {
           finalLimit = range.end - range.start + 1;
         }
       } catch (e) {
+        emitTelemetryEvent(
+          toSmartTruncationFallbackEvent({
+            filePath: fullFilePath,
+            error: e
+          })
+        );
       }
     }
     const { content, lineCount, totalLines } = readTextContent(
@@ -7690,7 +7869,7 @@ function createImageResponse(buffer, ext, originalSize) {
 }
 async function readImage(filePath, ext) {
   try {
-    const stats = statSync6(filePath);
+    const stats = statSync7(filePath);
     const sharpModule = await import("sharp");
     const sharp = sharpModule.default || sharpModule;
     const fileReadResult = secureFileService.safeReadFile(filePath, {
@@ -7743,7 +7922,7 @@ async function readImage(filePath, ext) {
     return createImageResponse(resizedImageBuffer, ext, stats.size);
   } catch (e) {
     logError(e);
-    const stats = statSync6(filePath);
+    const stats = statSync7(filePath);
     const fileReadResult = secureFileService.safeReadFile(filePath, {
       encoding: "buffer",
       maxFileSize: MAX_IMAGE_SIZE
@@ -7760,7 +7939,7 @@ async function readImage(filePath, ext) {
 }
 
 // src/tools/filesystem/FileWriteTool/FileWriteTool.tsx
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, statSync as statSync7 } from "fs";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync4, statSync as statSync8 } from "fs";
 import { Box as Box13, Text as Text14 } from "ink";
 import { EOL } from "os";
 import { dirname as dirname4, extname as extname5, isAbsolute as isAbsolute5, relative as relative7, resolve as resolve5 } from "path";
@@ -7820,7 +7999,7 @@ var FileWriteTool = {
       const fullFilePath = isAbsolute5(file_path) ? file_path : resolve5(getCwd(), file_path);
       const oldFileExists = fileExistsBun(fullFilePath);
       const enc = oldFileExists ? detectFileEncoding(fullFilePath) : "utf-8";
-      const oldContent = oldFileExists ? readFileSync3(fullFilePath, enc) : null;
+      const oldContent = oldFileExists ? readFileSync4(fullFilePath, enc) : null;
       const type3 = oldContent ? "update" : "create";
       const patch = getPatch({
         filePath: file_path,
@@ -7880,7 +8059,7 @@ var FileWriteTool = {
         message: "File has not been read yet. Read it first before writing to it."
       };
     }
-    const stats = statSync7(fullFilePath);
+    const stats = statSync8(fullFilePath);
     const lastWriteTime = stats.mtimeMs;
     if (lastWriteTime > readTimestamp) {
       return {
@@ -7896,7 +8075,7 @@ var FileWriteTool = {
     const oldFileExists = fileExistsBun(fullFilePath);
     if (oldFileExists) {
       const readTimestamp = readFileTimestamps[fullFilePath];
-      const lastWriteTime = statSync7(fullFilePath).mtimeMs;
+      const lastWriteTime = statSync8(fullFilePath).mtimeMs;
       if (!readTimestamp || lastWriteTime > readTimestamp) {
         throw new Error(
           "File has been unexpectedly modified. Read it again before attempting to write it."
@@ -7909,7 +8088,7 @@ var FileWriteTool = {
     mkdirSync4(dir, { recursive: true });
     writeTextContent(fullFilePath, content, enc, endings);
     recordFileEdit(fullFilePath, content);
-    readFileTimestamps[fullFilePath] = statSync7(fullFilePath).mtimeMs;
+    readFileTimestamps[fullFilePath] = statSync8(fullFilePath).mtimeMs;
     emitReminderEvent("file:edited", {
       filePath: fullFilePath,
       content,
@@ -8004,9 +8183,9 @@ var DESCRIPTION4 = `- Fast file pattern matching tool that works with any codeba
   - If LSP is unavailable, it falls back to standard glob results without impacting the main file-finding flow.`;
 
 // src/tools/filesystem/GlobTool/GlobTool.tsx
-import { existsSync as existsSync5, statSync as statSync8 } from "fs";
+import { existsSync as existsSync6, statSync as statSync9 } from "fs";
 import { isAbsolute as isAbsolute6, join as join4, relative as relative8, resolve as resolve6 } from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var inputSchema6 = z6.strictObject({
   pattern: z6.string().describe("The glob pattern to match files against"),
   path: z6.string().optional().describe(
@@ -8035,36 +8214,36 @@ var GlobTool = {
   isConcurrencySafe() {
     return true;
   },
-  needsPermissions({ path: path5 }) {
-    return !hasReadPermission(path5 || getCwd());
+  needsPermissions({ path: path6 }) {
+    return !hasReadPermission(path6 || getCwd());
   },
   async prompt() {
     return DESCRIPTION4;
   },
-  async validateInput({ path: path5 }) {
-    if (!path5) return { result: true };
-    const absolute = isAbsolute6(path5) ? path5 : resolve6(getCwd(), path5);
-    if (!existsSync5(absolute)) {
+  async validateInput({ path: path6 }) {
+    if (!path6) return { result: true };
+    const absolute = isAbsolute6(path6) ? path6 : resolve6(getCwd(), path6);
+    if (!existsSync6(absolute)) {
       return {
         result: false,
-        message: `Directory does not exist: ${path5}`,
+        message: `Directory does not exist: ${path6}`,
         errorCode: 1
       };
     }
-    if (!statSync8(absolute).isDirectory()) {
+    if (!statSync9(absolute).isDirectory()) {
       return {
         result: false,
-        message: `Path is not a directory: ${path5}`,
+        message: `Path is not a directory: ${path6}`,
         errorCode: 2
       };
     }
     return { result: true };
   },
-  renderToolUseMessage({ pattern, path: path5, semantic }, { verbose }) {
-    const absolutePath = path5 ? isAbsolute6(path5) ? path5 : resolve6(getCwd(), path5) : void 0;
+  renderToolUseMessage({ pattern, path: path6, semantic }, { verbose }) {
+    const absolutePath = path6 ? isAbsolute6(path6) ? path6 : resolve6(getCwd(), path6) : void 0;
     const relativePath = absolutePath ? relative8(getCwd(), absolutePath) : void 0;
     const parts = [`pattern: "${pattern}"`];
-    if (path5) parts.push(`path: "${verbose ? absolutePath : relativePath}"`);
+    if (path6) parts.push(`path: "${verbose ? absolutePath : relativePath}"`);
     if (semantic) parts.push("semantic: true");
     return parts.join(", ");
   },
@@ -8077,9 +8256,9 @@ var GlobTool = {
     }
     return /* @__PURE__ */ React15.createElement(Box14, { justifyContent: "space-between", width: "100%" }, /* @__PURE__ */ React15.createElement(Box14, { flexDirection: "row" }, /* @__PURE__ */ React15.createElement(Text15, null, "\xA0\xA0\u23BF \xA0Found "), /* @__PURE__ */ React15.createElement(Text15, { bold: true }, output.numFiles, " "), /* @__PURE__ */ React15.createElement(Text15, null, output.numFiles === 0 || output.numFiles > 1 ? "files" : "file")), /* @__PURE__ */ React15.createElement(Cost, { costUSD: 0, durationMs: output.durationMs, debug: false }));
   },
-  async *call({ pattern, path: path5, semantic }, { abortController }) {
+  async *call({ pattern, path: path6, semantic }, { abortController }) {
     const start = Date.now();
-    const searchPath = path5 ? isAbsolute6(path5) ? path5 : resolve6(getCwd(), path5) : getCwd();
+    const searchPath = path6 ? isAbsolute6(path6) ? path6 : resolve6(getCwd(), path6) : getCwd();
     const raw = await ripGrep(
       [
         "--files",
@@ -8104,7 +8283,7 @@ var GlobTool = {
           let filePath = s.location?.uri || "";
           if (filePath.startsWith("file://")) {
             try {
-              filePath = fileURLToPath(filePath);
+              filePath = fileURLToPath2(filePath);
             } catch (e) {
               filePath = filePath.replace("file://", "");
             }
@@ -8155,7 +8334,7 @@ ${output.semanticNotice}`;
 // src/tools/search/GrepTool/GrepTool.tsx
 import { Box as Box15, Text as Text16 } from "ink";
 import React16 from "react";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { stat as statAsync } from "fs/promises";
 import { z as z7 } from "zod";
 
@@ -8206,7 +8385,7 @@ var DESCRIPTION5 = `A powerful search tool built on ripgrep
 
 // src/tools/search/GrepTool/GrepTool.tsx
 import { isAbsolute as isAbsolute7, relative as relative9, resolve as resolve7 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var inputSchema7 = z7.strictObject({
   pattern: z7.string().describe("The regular expression pattern to search for in file contents"),
   path: z7.string().optional().describe(
@@ -8311,8 +8490,8 @@ var GrepTool = {
   async isEnabled() {
     return true;
   },
-  needsPermissions({ path: path5 }) {
-    return !hasReadPermission(path5 || getCwd());
+  needsPermissions({ path: path6 }) {
+    return !hasReadPermission(path6 || getCwd());
   },
   async prompt() {
     return DESCRIPTION5;
@@ -8320,7 +8499,7 @@ var GrepTool = {
   renderToolUseMessage(input, { verbose }) {
     const {
       pattern,
-      path: path5,
+      path: path6,
       glob,
       type: type3,
       output_mode = "files_with_matches",
@@ -8328,8 +8507,8 @@ var GrepTool = {
     } = input;
     if (!pattern) return null;
     const parts = [`pattern: "${pattern}"`];
-    if (path5) {
-      const { absolutePath, relativePath } = getAbsoluteAndRelativePaths(path5);
+    if (path6) {
+      const { absolutePath, relativePath } = getAbsoluteAndRelativePaths(path6);
       parts.push(`path: "${verbose ? absolutePath : relativePath}"`);
     }
     if (glob) parts.push(`glob: "${glob}"`);
@@ -8382,7 +8561,7 @@ Found ${numMatches} total ${numMatches === 1 ? "occurrence" : "occurrences"} acr
 ${result.filenames.join("\n")}`;
     return appendNotice(truncateToCharBudget(header));
   },
-  async validateInput({ path: path5, semantic, symbol_type }) {
+  async validateInput({ path: path6, semantic, symbol_type }) {
     if (symbol_type && !semantic) {
       return {
         result: false,
@@ -8390,12 +8569,12 @@ ${result.filenames.join("\n")}`;
         errorCode: 5
       };
     }
-    if (path5) {
-      const abs = getAbsolutePath(path5);
-      if (!abs || !existsSync6(abs)) {
+    if (path6) {
+      const abs = getAbsolutePath(path6);
+      if (!abs || !existsSync7(abs)) {
         return {
           result: false,
-          message: `Path does not exist: ${path5}`,
+          message: `Path does not exist: ${path6}`,
           errorCode: 1
         };
       }
@@ -8404,7 +8583,7 @@ ${result.filenames.join("\n")}`;
   },
   async *call({
     pattern,
-    path: path5,
+    path: path6,
     glob,
     type: type3,
     output_mode = "files_with_matches",
@@ -8421,7 +8600,7 @@ ${result.filenames.join("\n")}`;
   }, toolUseContext) {
     const { abortController } = toolUseContext;
     const start = Date.now();
-    const absolutePath = getAbsolutePath(path5) || getCwd();
+    const absolutePath = getAbsolutePath(path6) || getCwd();
     const baseArgs = ["--hidden"];
     for (const dir of EXCLUDED_DIRS) {
       baseArgs.push("--glob", `!${dir}`);
@@ -8514,7 +8693,7 @@ ${result.filenames.join("\n")}`;
             let filePath = s.location?.uri || "";
             if (filePath.startsWith("file://")) {
               try {
-                filePath = fileURLToPath2(filePath);
+                filePath = fileURLToPath3(filePath);
               } catch {
                 filePath = filePath.replace("file://", "");
               }
@@ -9372,7 +9551,7 @@ var MeasuredText = class {
 
 // src/utils/terminal/imagePaste.ts
 import { execSync } from "child_process";
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 var SCREENSHOT_PATH = "/tmp/pyb_cli_latest_screenshot.png";
 var CLIPBOARD_ERROR_MESSAGE = "No image found in clipboard. Use Cmd + Ctrl + Shift + 4 to copy a screenshot to clipboard.";
 function getImageFromClipboard() {
@@ -9387,7 +9566,7 @@ function getImageFromClipboard() {
       `osascript -e 'set png_data to (the clipboard as \xABclass PNGf\xBB)' -e 'set fp to open for access POSIX file "${SCREENSHOT_PATH}" with write permission' -e 'write png_data to fp' -e 'close access fp'`,
       { stdio: "ignore" }
     );
-    const imageBuffer = readFileSync4(SCREENSHOT_PATH);
+    const imageBuffer = readFileSync5(SCREENSHOT_PATH);
     const base64Image = imageBuffer.toString("base64");
     execSync(`rm -f "${SCREENSHOT_PATH}"`, { stdio: "ignore" });
     return base64Image;
@@ -10637,12 +10816,389 @@ function PressEnterToContinue() {
   return /* @__PURE__ */ React23.createElement(Text21, { color: getTheme().permission }, "Press ", /* @__PURE__ */ React23.createElement(Text21, { bold: true }, "Enter"), " to continue\u2026");
 }
 
+// src/services/stability/runtimeAssetHealth/checks/ripgrep.ts
+import { join as join5, sep as sep3 } from "node:path";
+import envPaths from "env-paths";
+async function resolveRipgrepPath() {
+  return getRipgrepPath();
+}
+async function execRipgrepVersion(path6) {
+  return execFileNoThrow(path6, ["--version"]);
+}
+function detectRipgrepSource(resolvedPath) {
+  const explicit = process.env.PYB_RIPGREP_PATH?.trim();
+  if (explicit && normalizePath(explicit) === normalizePath(resolvedPath)) {
+    return "explicit";
+  }
+  if (resolvedPath.includes(`${sep3}resources${sep3}ripgrep${sep3}`)) {
+    return "vendor";
+  }
+  const cacheRoot = getRipgrepCacheRoot();
+  if (normalizePath(resolvedPath).startsWith(normalizePath(cacheRoot))) {
+    return "cache";
+  }
+  if (isLikelyPathResolved(resolvedPath)) {
+    return "path";
+  }
+  return "unknown";
+}
+function classifyRipgrepHealthError(error) {
+  const message = String(error ?? "").toLowerCase();
+  if (message.includes("pyb_ripgrep_path") && (message.includes("missing") || message.includes("not found"))) {
+    return "RG_EXPLICIT_PATH_MISSING";
+  }
+  if (message.includes("download failed") || message.includes("network timeout") || message.includes("failed to download")) {
+    return "RG_DOWNLOAD_FAILED";
+  }
+  if ((message.includes("checksum") || message.includes("sha256")) && message.includes("mismatch")) {
+    return "RG_CHECKSUM_MISMATCH";
+  }
+  if (message.includes("vendor") && (message.includes("missing") || message.includes("not found"))) {
+    return "RG_VENDOR_MISSING";
+  }
+  if (message.includes("not executable") || message.includes("eacces") || message.includes("permission denied")) {
+    return "RG_NOT_EXECUTABLE";
+  }
+  if (message.includes("enoent") || message.includes("path not found") || message.includes("not found")) {
+    return "RG_PATH_NOT_FOUND";
+  }
+  return "RG_LOAD_UNKNOWN";
+}
+function resolveRipgrepPolicyVisibility() {
+  const policy = resolveRipgrepPolicy();
+  return {
+    vendorFirst: policy.vendorFirst,
+    offlineStrict: policy.offlineStrict,
+    networkFallbackAllowed: policy.allowNetworkFallback,
+    policyMode: getRipgrepPolicyMode(policy)
+  };
+}
+function getRipgrepCacheRoot() {
+  const override = process.env.PYB_RIPGREP_CACHE_DIR?.trim();
+  if (override) return override;
+  return join5(envPaths("pyb").cache, "ripgrep");
+}
+function normalizePath(value) {
+  return value.replaceAll("/", sep3).replaceAll("\\", sep3).toLowerCase();
+}
+function isLikelyPathResolved(value) {
+  const normalized = normalizePath(value);
+  return normalized.includes(`${sep3}bin${sep3}`) || normalized.endsWith(`${sep3}rg`);
+}
+
+// src/services/stability/runtimeAssetHealth/diagnostics.ts
+function toRuntimeAssetHealthEvent(report) {
+  return {
+    channel: "runtime_assets",
+    phase: "RUNTIME_ASSET_HEALTH_CHECK",
+    timestamp: Date.now(),
+    data: report
+  };
+}
+
+// src/services/stability/runtimeAssetHealth/index.ts
+var defaultChecks = {
+  checkTreeSitterCore: checkTreeSitterCoreLoadable,
+  checkTreeSitterGrammar: checkTreeSitterGrammarLoadable,
+  resolveRipgrepPath,
+  execRipgrepVersion
+};
+async function runRuntimeAssetHealthCheck(options = {}) {
+  const checks = { ...defaultChecks, ...options.checks ?? {} };
+  const now = options.now ?? (() => Date.now());
+  const errors = [];
+  const report = {
+    status: "ok",
+    checks: {
+      treeSitterCore: { status: "ok" },
+      treeSitterGrammarTypescript: { status: "ok" },
+      treeSitterGrammarBash: { status: "ok" },
+      ripgrep: { status: "ok" }
+    },
+    errors,
+    timestamp: now()
+  };
+  await runTreeSitterChecks(report, checks, errors);
+  await runRipgrepCheck(report, checks, errors);
+  report.status = errors.length > 0 ? "error" : "ok";
+  const event = toRuntimeAssetHealthEvent(report);
+  if (options.emitEvent) {
+    options.emitEvent(event);
+  } else {
+    emitTelemetryEvent(event);
+  }
+  return report;
+}
+async function runTreeSitterChecks(report, checks, errors) {
+  await runSingleCheck({
+    execute: () => checks.checkTreeSitterCore(),
+    onError: (error) => {
+      const code = classifyTreeSitterHealthError2(error);
+      report.checks.treeSitterCore = {
+        status: "error",
+        code,
+        message: String(error instanceof Error ? error.message : error)
+      };
+      errors.push({
+        code,
+        check: "treeSitterCore",
+        message: report.checks.treeSitterCore.message ?? ""
+      });
+    }
+  });
+  await runSingleCheck({
+    execute: () => checks.checkTreeSitterGrammar("typescript"),
+    onError: (error) => {
+      const code = classifyTreeSitterHealthError2(error);
+      report.checks.treeSitterGrammarTypescript = {
+        status: "error",
+        code,
+        message: String(error instanceof Error ? error.message : error)
+      };
+      errors.push({
+        code,
+        check: "treeSitterGrammarTypescript",
+        message: report.checks.treeSitterGrammarTypescript.message ?? ""
+      });
+    }
+  });
+  await runSingleCheck({
+    execute: () => checks.checkTreeSitterGrammar("bash"),
+    onError: (error) => {
+      const code = classifyTreeSitterHealthError2(error);
+      report.checks.treeSitterGrammarBash = {
+        status: "error",
+        code,
+        message: String(error instanceof Error ? error.message : error)
+      };
+      errors.push({
+        code,
+        check: "treeSitterGrammarBash",
+        message: report.checks.treeSitterGrammarBash.message ?? ""
+      });
+    }
+  });
+}
+async function runRipgrepCheck(report, checks, errors) {
+  let resolvedPath = "";
+  const policy = resolveRipgrepPolicyVisibility();
+  report.checks.ripgrep.vendorFirst = policy.vendorFirst;
+  report.checks.ripgrep.offlineStrict = policy.offlineStrict;
+  report.checks.ripgrep.networkFallbackAllowed = policy.networkFallbackAllowed;
+  report.checks.ripgrep.policyMode = policy.policyMode;
+  await runSingleCheck({
+    execute: async () => {
+      resolvedPath = await checks.resolveRipgrepPath();
+      report.checks.ripgrep.path = resolvedPath;
+      report.checks.ripgrep.source = detectRipgrepSource(resolvedPath);
+      const versionResult = await checks.execRipgrepVersion(resolvedPath);
+      if (versionResult.code !== 0) {
+        throw new Error(versionResult.stderr || versionResult.stdout || "rg --version failed");
+      }
+      const firstLine = versionResult.stdout.split(/\r?\n/).find(Boolean);
+      report.checks.ripgrep.version = firstLine ?? "";
+    },
+    onError: (error) => {
+      const code = classifyRipgrepHealthError2(error);
+      report.checks.ripgrep = {
+        ...report.checks.ripgrep,
+        status: "error",
+        code,
+        message: String(error instanceof Error ? error.message : error)
+      };
+      errors.push({
+        code,
+        check: "ripgrep",
+        message: report.checks.ripgrep.message ?? ""
+      });
+    }
+  });
+}
+async function runSingleCheck(input) {
+  try {
+    await input.execute();
+  } catch (error) {
+    input.onError(error);
+  }
+}
+function classifyTreeSitterHealthError2(error) {
+  return classifyTreeSitterHealthError(error);
+}
+function classifyRipgrepHealthError2(error) {
+  return classifyRipgrepHealthError(error);
+}
+
+// src/services/stability/runtimeAssetHealth/suggestions.ts
+function getRuntimeAssetHealthSuggestions(code) {
+  const mapped = suggestionsMap[code];
+  if (mapped) return mapped;
+  return [
+    "\u8BF7\u8FD0\u884C doctor \u5E76\u67E5\u770B runtime assets \u8BE6\u60C5\u3002",
+    "\u8BF7\u68C0\u67E5\u8D44\u6E90\u76EE\u5F55\u4E0E\u53EF\u6267\u884C\u6587\u4EF6\u8DEF\u5F84\u914D\u7F6E\u662F\u5426\u6B63\u786E\u3002"
+  ];
+}
+var suggestionsMap = {
+  TS_WASM_MISSING: [
+    "\u8BF7\u91CD\u88C5 pyb \u4EE5\u6062\u590D tree-sitter core \u8D44\u6E90\u3002",
+    "\u8BF7\u68C0\u67E5 PYB_RESOURCE_DIR \u662F\u5426\u6307\u5411\u6709\u6548\u8D44\u6E90\u76EE\u5F55\u3002"
+  ],
+  TS_GRAMMAR_MISSING: [
+    "\u8BF7\u786E\u8BA4 tree-sitter grammar wasm \u6587\u4EF6\u5B58\u5728\u3002",
+    "\u8BF7\u68C0\u67E5 PYB_RESOURCE_DIR \u662F\u5426\u4E0E\u5F53\u524D\u5B89\u88C5\u7248\u672C\u4E00\u81F4\u3002"
+  ],
+  TS_VERSION_INCOMPATIBLE: [
+    "\u8BF7\u66F4\u65B0\u6216\u91CD\u88C5 pyb \u4EE5\u5339\u914D tree-sitter runtime \u4E0E grammar \u7248\u672C\u3002",
+    "\u8BF7\u907F\u514D\u6DF7\u7528\u65E7\u7F13\u5B58\u4E0E\u65B0\u7248\u672C\u8D44\u6E90\u76EE\u5F55\u3002"
+  ],
+  TS_CHECKSUM_MISMATCH: [
+    "\u8BF7\u91CD\u65B0\u5B89\u88C5\u8D44\u6E90\u6587\u4EF6\u5E76\u6821\u9A8C\u6765\u6E90\u5B8C\u6574\u6027\u3002",
+    "\u8BF7\u6E05\u7406\u5F02\u5E38\u7F13\u5B58\u540E\u91CD\u8BD5\u3002"
+  ],
+  TS_RESOURCE_PATH_DRIFT: [
+    "\u8BF7\u68C0\u67E5 PYB_RESOURCE_DIR \u662F\u5426\u6F02\u79FB\u5230\u65E7\u76EE\u5F55\u3002",
+    "\u8BF7\u79FB\u9664\u8FC7\u671F\u73AF\u5883\u53D8\u91CF\u8986\u76D6\u540E\u91CD\u8BD5\u3002"
+  ],
+  TS_LOAD_UNKNOWN: [
+    "\u8BF7\u8FD0\u884C doctor \u6536\u96C6 tree-sitter \u8BCA\u65AD\u4FE1\u606F\u3002",
+    "\u8BF7\u9644\u5E26\u9519\u8BEF\u7801\u4E0E\u8D44\u6E90\u8DEF\u5F84\u63D0\u4EA4\u95EE\u9898\u3002"
+  ],
+  RG_EXPLICIT_PATH_MISSING: [
+    "\u8BF7\u4FEE\u6B63 PYB_RIPGREP_PATH \u6307\u5411\u53EF\u6267\u884C\u6587\u4EF6\u3002",
+    "\u8BF7\u79FB\u9664\u65E0\u6548 PYB_RIPGREP_PATH \u540E\u91CD\u8BD5\u3002"
+  ],
+  RG_PATH_NOT_FOUND: [
+    "\u8BF7\u786E\u8BA4 ripgrep \u5DF2\u5B89\u88C5\u6216\u53EF\u4ECE\u7F13\u5B58\u76EE\u5F55\u8BFB\u53D6\u3002",
+    "\u8BF7\u68C0\u67E5 PATH \u6216\u7F13\u5B58\u76EE\u5F55\u914D\u7F6E\u3002"
+  ],
+  RG_DOWNLOAD_FAILED: [
+    "\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u901A\u6027\u6216\u955C\u50CF\u5730\u5740\u914D\u7F6E\u3002",
+    "\u8BF7\u786E\u8BA4 PYB_RIPGREP_DOWNLOAD_BASE_URL \u53EF\u8BBF\u95EE\u3002"
+  ],
+  RG_CHECKSUM_MISMATCH: [
+    "\u8BF7\u6E05\u7406\u635F\u574F\u7684 ripgrep \u7F13\u5B58\u5E76\u91CD\u65B0\u4E0B\u8F7D\u3002",
+    "\u8BF7\u786E\u8BA4\u4E0B\u8F7D\u6E90\u672A\u88AB\u7BE1\u6539\u3002"
+  ],
+  RG_VENDOR_MISSING: [
+    "\u8BF7\u786E\u8BA4\u5F53\u524D\u5E73\u53F0 vendor ripgrep \u8D44\u4EA7\u5DF2\u6253\u5305\u3002",
+    "\u8BF7\u5207\u6362\u5230\u7F13\u5B58\u4E0B\u8F7D\u8DEF\u5F84\u6216\u8865\u9F50 vendor \u8D44\u6E90\u3002"
+  ],
+  RG_NOT_EXECUTABLE: [
+    "\u8BF7\u68C0\u67E5\u6587\u4EF6\u6267\u884C\u6743\u9650\u5E76\u786E\u8BA4\u4E8C\u8FDB\u5236\u53EF\u8FD0\u884C\u3002",
+    "\u8BF7\u66F4\u6362\u5230\u6709\u6548 ripgrep \u53EF\u6267\u884C\u8DEF\u5F84\u3002"
+  ],
+  RG_LOAD_UNKNOWN: [
+    "\u8BF7\u8FD0\u884C doctor \u5E76\u6536\u96C6 ripgrep \u8BCA\u65AD\u8F93\u51FA\u3002",
+    "\u8BF7\u9644\u5E26\u9519\u8BEF\u7801\u4E0E\u8DEF\u5F84\u4FE1\u606F\u63D0\u4EA4\u95EE\u9898\u3002"
+  ]
+};
+
+// src/services/stability/runtimeAssetHealth/view.ts
+var suggestionPriorityByCode = {
+  TS_WASM_MISSING: 10,
+  TS_GRAMMAR_MISSING: 20,
+  TS_VERSION_INCOMPATIBLE: 30,
+  TS_CHECKSUM_MISMATCH: 40,
+  TS_RESOURCE_PATH_DRIFT: 50,
+  TS_LOAD_UNKNOWN: 60,
+  RG_EXPLICIT_PATH_MISSING: 70,
+  RG_NOT_EXECUTABLE: 80,
+  RG_PATH_NOT_FOUND: 90,
+  RG_VENDOR_MISSING: 100,
+  RG_DOWNLOAD_FAILED: 110,
+  RG_CHECKSUM_MISMATCH: 120,
+  RG_LOAD_UNKNOWN: 130
+};
+function buildRuntimeAssetHealthViewLines(report) {
+  if (!report) {
+    return ["Runtime assets: unavailable"];
+  }
+  const lines = [];
+  lines.push(`Runtime assets: ${report.status === "ok" ? "OK" : "ERROR"}`);
+  lines.push(`Tree-sitter core: ${formatCheck(report.checks.treeSitterCore)}`);
+  lines.push(
+    `Tree-sitter typescript: ${formatCheck(report.checks.treeSitterGrammarTypescript)}`
+  );
+  lines.push(`Tree-sitter bash: ${formatCheck(report.checks.treeSitterGrammarBash)}`);
+  const ripgrepTail = [];
+  if (report.checks.ripgrep.source) {
+    ripgrepTail.push(`source=${report.checks.ripgrep.source}`);
+  }
+  if (report.checks.ripgrep.version) {
+    ripgrepTail.push(report.checks.ripgrep.version);
+  }
+  if (report.checks.ripgrep.policyMode) {
+    ripgrepTail.push(`policy=${report.checks.ripgrep.policyMode}`);
+  }
+  if (typeof report.checks.ripgrep.offlineStrict === "boolean") {
+    ripgrepTail.push(`strict=${report.checks.ripgrep.offlineStrict ? "on" : "off"}`);
+  }
+  if (typeof report.checks.ripgrep.networkFallbackAllowed === "boolean") {
+    ripgrepTail.push(
+      `network_fallback=${report.checks.ripgrep.networkFallbackAllowed ? "on" : "off"}`
+    );
+  }
+  const ripgrepSuffix = ripgrepTail.length > 0 ? ` (${ripgrepTail.join(", ")})` : "";
+  lines.push(`Ripgrep: ${formatCheck(report.checks.ripgrep)}${ripgrepSuffix}`);
+  return lines;
+}
+function buildRuntimeAssetHealthSuggestionLines(report) {
+  if (!report || report.status !== "error") {
+    return [];
+  }
+  const seenCodes = /* @__PURE__ */ new Set();
+  const lines = [];
+  for (const error of report.errors) {
+    if (seenCodes.has(error.code)) {
+      continue;
+    }
+    seenCodes.add(error.code);
+  }
+  const sortedCodes = [...seenCodes].sort((left, right) => {
+    const leftPriority = suggestionPriorityByCode[left] ?? 999;
+    const rightPriority = suggestionPriorityByCode[right] ?? 999;
+    if (leftPriority !== rightPriority) {
+      return leftPriority - rightPriority;
+    }
+    return left.localeCompare(right);
+  });
+  for (const code of sortedCodes) {
+    const suggestions = getRuntimeAssetHealthSuggestions(code);
+    for (const suggestion of suggestions) {
+      lines.push(`Suggestion: ${suggestion}`);
+    }
+  }
+  return lines;
+}
+function formatCheck(check) {
+  if (check.status === "ok") {
+    return "OK";
+  }
+  return check.code ? `ERROR (${check.code})` : "ERROR";
+}
+
 // src/ui/screens/Doctor.tsx
-function Doctor({ onDone, doctorMode = false }) {
+function Doctor({
+  onDone,
+  doctorMode = false,
+  runtimeHealthChecker = runRuntimeAssetHealthCheck
+}) {
   const [checked, setChecked] = useState8(false);
+  const [runtimeHealth, setRuntimeHealth] = useState8(
+    null
+  );
   const theme = getTheme();
   useEffect5(() => {
-    setChecked(true);
+    ;
+    (async () => {
+      try {
+        const report = await runtimeHealthChecker();
+        setRuntimeHealth(report);
+      } catch {
+        setRuntimeHealth(null);
+      } finally {
+        setChecked(true);
+      }
+    })();
   }, []);
   useInput7((_input, key) => {
     if (key.return) onDone();
@@ -10650,7 +11206,7 @@ function Doctor({ onDone, doctorMode = false }) {
   if (!checked) {
     return /* @__PURE__ */ React24.createElement(Box19, { paddingX: 1, paddingTop: 1 }, /* @__PURE__ */ React24.createElement(Text22, { color: theme.secondaryText }, "Running checks\u2026"));
   }
-  return /* @__PURE__ */ React24.createElement(Box19, { flexDirection: "column", gap: 1, paddingX: 1, paddingTop: 1 }, /* @__PURE__ */ React24.createElement(Text22, { color: theme.success }, "\u2713 Installation checks passed"), /* @__PURE__ */ React24.createElement(Text22, { dimColor: true }, "Note: Auto-update is disabled by design. Use npm/bun to update."), /* @__PURE__ */ React24.createElement(PressEnterToContinue, null));
+  return /* @__PURE__ */ React24.createElement(Box19, { flexDirection: "column", gap: 1, paddingX: 1, paddingTop: 1 }, /* @__PURE__ */ React24.createElement(Text22, { color: runtimeHealth?.status === "error" ? theme.warning : theme.success }, runtimeHealth?.status === "error" ? "\u26A0 Installation checks completed with warnings" : "\u2713 Installation checks passed"), buildRuntimeAssetHealthViewLines(runtimeHealth).map((line) => /* @__PURE__ */ React24.createElement(React24.Fragment, { key: line }, /* @__PURE__ */ React24.createElement(Text22, { dimColor: true }, line))), buildRuntimeAssetHealthSuggestionLines(runtimeHealth).map((line) => /* @__PURE__ */ React24.createElement(React24.Fragment, { key: line }, /* @__PURE__ */ React24.createElement(Text22, { color: theme.warning }, line))), /* @__PURE__ */ React24.createElement(Text22, { dimColor: true }, "Note: Auto-update is disabled by design. Use npm/bun to update."), /* @__PURE__ */ React24.createElement(PressEnterToContinue, null));
 }
 
 // src/commands/doctor.ts
@@ -10663,7 +11219,23 @@ var doctor = {
     return "doctor";
   },
   type: "local-jsx",
-  call(onDone) {
+  async call(onDone, context, args) {
+    if (isRuntimeJsonMode(args)) {
+      const report = await getRuntimeHealthChecker(context)();
+      const suggestions = buildRuntimeAssetHealthSuggestionLines(report).map(
+        (line) => line.replace(/^Suggestion:\s*/, "")
+      );
+      onDone(
+        JSON.stringify({
+          status: report.status,
+          checks: report.checks,
+          errors: report.errors,
+          suggestions,
+          timestamp: report.timestamp
+        })
+      );
+      return null;
+    }
     const element = React25.createElement(Doctor, {
       onDone,
       doctorMode: true
@@ -10671,6 +11243,15 @@ var doctor = {
     return Promise.resolve(element);
   }
 };
+function getRuntimeHealthChecker(context) {
+  const checker = context?.runtimeHealthChecker;
+  return typeof checker === "function" ? checker : runRuntimeAssetHealthCheck;
+}
+function isRuntimeJsonMode(args) {
+  const normalized = String(args ?? "").trim().toLowerCase().split(/\s+/).filter(Boolean);
+  if (normalized.length < 2) return false;
+  return normalized[0] === "runtime" && normalized.includes("--json");
+}
 var doctor_default = doctor;
 
 // src/ui/components/Help.tsx
@@ -10724,8 +11305,8 @@ var help_default = help;
 // src/ui/components/ProjectOnboarding.tsx
 import * as React28 from "react";
 import { Box as Box21, Text as Text24 } from "ink";
-import { existsSync as existsSync7 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join6 } from "path";
 import { homedir as homedir6 } from "os";
 
 // src/constants/releaseNotes.ts
@@ -10773,7 +11354,7 @@ function ProjectOnboarding({
   if (!showOnboarding && !hasReleaseNotes) {
     return null;
   }
-  const workspaceHasProjectGuide = existsSync7(join5(workspaceDir, PROJECT_FILE));
+  const workspaceHasProjectGuide = existsSync8(join6(workspaceDir, PROJECT_FILE));
   const isWorkspaceDirEmpty = isDirEmpty(workspaceDir);
   const shouldRecommendProjectGuide = !workspaceHasProjectGuide && !isWorkspaceDirEmpty;
   const theme = getTheme();
@@ -10928,8 +11509,8 @@ function getReplStaticPrefixLength(orderedMessages, allMessages, unresolvedToolU
 }
 
 // src/commands/messages-debug.ts
-import { existsSync as existsSync8, readdirSync, readFileSync as readFileSync5, statSync as statSync9 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync9, readdirSync, readFileSync as readFileSync6, statSync as statSync10 } from "fs";
+import { join as join7 } from "path";
 function isDebugMode() {
   return process.argv.includes("--debug") || process.argv.includes("--debug-verbose");
 }
@@ -10960,15 +11541,15 @@ function getProgressText(message) {
 }
 function getLatestMessagesLogFile() {
   const dir = CACHE_PATHS.messages();
-  if (!existsSync8(dir)) return null;
+  if (!existsSync9(dir)) return null;
   const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
   if (files.length === 0) return null;
   let best = null;
   for (const file of files) {
-    const fullPath = join6(dir, file);
+    const fullPath = join7(dir, file);
     let mtimeMs = 0;
     try {
-      mtimeMs = statSync9(fullPath).mtimeMs;
+      mtimeMs = statSync10(fullPath).mtimeMs;
     } catch {
       continue;
     }
@@ -11079,9 +11660,9 @@ var command3 = {
     );
     const { toolUseIDs, duplicates, byID } = summarizeToolUses(normalized);
     const latestLog = getLatestMessagesLogFile();
-    const latestLogContent = latestLog && existsSync8(latestLog.path) ? (() => {
+    const latestLogContent = latestLog && existsSync9(latestLog.path) ? (() => {
       try {
-        return JSON.parse(readFileSync5(latestLog.path, "utf8"));
+        return JSON.parse(readFileSync6(latestLog.path, "utf8"));
       } catch {
         return null;
       }
@@ -11359,7 +11940,7 @@ async function createAndStoreApiKey(accessToken) {
       }
       saveGlobalConfig(config2);
       try {
-        const { resetAnthropicClient } = await import("./llm-UGJYESRH.js");
+        const { resetAnthropicClient } = await import("./llm-VY6QQH5B.js");
         resetAnthropicClient();
       } catch {
       }
@@ -15726,7 +16307,7 @@ async function refreshPluginRuntimeFromInstalls() {
   const existingRoots = getSessionPlugins().map((p) => p.rootDir);
   const dirs = Array.from(/* @__PURE__ */ new Set([...existingRoots, ...installedRoots]));
   if (dirs.length === 0) return [];
-  const { configureSessionPlugins } = await import("./pluginRuntime-GQDZD5BX.js");
+  const { configureSessionPlugins } = await import("./pluginRuntime-R57OZ4VU.js");
   const { errors } = await configureSessionPlugins({ pluginDirs: dirs });
   return errors;
 }
@@ -16395,7 +16976,7 @@ async function call(onDone, context) {
     ModelConfig,
     {
       onClose: () => {
-        import("./model-7P6UKMPN.js").then(({ reloadModelManager: reloadModelManager2 }) => {
+        import("./model-3NZZUFFU.js").then(({ reloadModelManager: reloadModelManager2 }) => {
           reloadModelManager2();
           triggerModelConfigChange();
           onDone();
@@ -19025,17 +19606,17 @@ import { Box as Box54, Text as Text59 } from "ink";
 
 // src/utils/session/taskStore.ts
 import {
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   closeSync,
   mkdirSync as mkdirSync5,
   openSync,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   readdirSync as readdirSync2,
   renameSync as renameSync2,
   rmSync,
   writeFileSync as writeFileSync3
 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { homedir as homedir7 } from "os";
 import { randomUUID as randomUUID4 } from "crypto";
 import { AsyncLocalStorage } from "async_hooks";
@@ -19203,15 +19784,15 @@ function resolveGlobalTaskRootDir() {
   const override = process.env.PYB_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR;
   if (override) return override;
   const home = homedir7();
-  const pybDir = join7(home, ".pyb");
-  if (existsSync9(pybDir)) return pybDir;
-  const claudeDir = join7(home, ".claude");
-  if (existsSync9(claudeDir)) return claudeDir;
+  const pybDir = join8(home, ".pyb");
+  if (existsSync10(pybDir)) return pybDir;
+  const claudeDir = join8(home, ".claude");
+  if (existsSync10(claudeDir)) return claudeDir;
   return pybDir;
 }
 function findBaseDirWithList(listId, candidates) {
   for (const candidate of candidates) {
-    if (existsSync9(join7(candidate, listId))) return candidate;
+    if (existsSync10(join8(candidate, listId))) return candidate;
   }
   return null;
 }
@@ -19248,39 +19829,39 @@ function getTaskListId(options) {
 }
 function resolveTaskBaseDir(context, cwd) {
   if (context.scope === "project") {
-    const pybDir = join7(cwd, ".pyb");
-    const claudeDir = join7(cwd, ".claude");
-    const hasProjectPyb = existsSync9(pybDir);
-    const hasProjectClaude = existsSync9(claudeDir);
+    const pybDir = join8(cwd, ".pyb");
+    const claudeDir = join8(cwd, ".claude");
+    const hasProjectPyb = existsSync10(pybDir);
+    const hasProjectClaude = existsSync10(claudeDir);
     const projectRoot = hasProjectPyb ? pybDir : hasProjectClaude ? claudeDir : pybDir;
     const override2 = process.env.PYB_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR;
-    const defaultBaseDir2 = !hasProjectPyb && !hasProjectClaude && override2 ? join7(override2, "tasks") : join7(projectRoot, "tasks");
+    const defaultBaseDir2 = !hasProjectPyb && !hasProjectClaude && override2 ? join8(override2, "tasks") : join8(projectRoot, "tasks");
     const candidates2 = [
-      join7(cwd, ".pyb", "tasks"),
-      join7(cwd, ".claude", "tasks"),
-      ...override2 ? [join7(override2, "tasks")] : [],
+      join8(cwd, ".pyb", "tasks"),
+      join8(cwd, ".claude", "tasks"),
+      ...override2 ? [join8(override2, "tasks")] : [],
       resolveXdgDataPath("tasks")
     ];
     return findBaseDirWithList(context.listId, candidates2) ?? defaultBaseDir2;
   }
   const override = process.env.PYB_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR;
-  const globalCandidates = override ? [join7(override, "tasks")] : [
-    join7(homedir7(), ".pyb", "tasks"),
-    join7(homedir7(), ".claude", "tasks")
+  const globalCandidates = override ? [join8(override, "tasks")] : [
+    join8(homedir7(), ".pyb", "tasks"),
+    join8(homedir7(), ".claude", "tasks")
   ];
-  const defaultBaseDir = join7(resolveGlobalTaskRootDir(), "tasks");
+  const defaultBaseDir = join8(resolveGlobalTaskRootDir(), "tasks");
   const candidates = [...globalCandidates, resolveXdgDataPath("tasks")];
   return findBaseDirWithList(context.listId, candidates) ?? defaultBaseDir;
 }
 function buildTaskListPaths(baseDir, listId) {
-  const listDir = join7(baseDir, listId);
+  const listDir = join8(baseDir, listId);
   return {
     listId,
     baseDir,
     listDir,
     tasksDir: listDir,
-    lockPath: join7(listDir, ".lock"),
-    highwatermarkPath: join7(listDir, ".highwatermark")
+    lockPath: join8(listDir, ".lock"),
+    highwatermarkPath: join8(listDir, ".highwatermark")
   };
 }
 function getTaskListPaths(listId) {
@@ -19294,26 +19875,26 @@ function sortReadPaths(paths) {
   return [...paths].sort((a, b) => priority[a.source] - priority[b.source]);
 }
 function resolveSourceForBaseDir(baseDir) {
-  if (baseDir.includes(`${join7(".pyb", "tasks")}`)) return "pyb";
-  if (baseDir.includes(`${join7(".claude", "tasks")}`)) return "claude";
-  if (baseDir.includes(`${join7(".pyb")}`)) return "pyb";
-  if (baseDir.includes(`${join7(".claude")}`)) return "claude";
+  if (baseDir.includes(`${join8(".pyb", "tasks")}`)) return "pyb";
+  if (baseDir.includes(`${join8(".claude", "tasks")}`)) return "claude";
+  if (baseDir.includes(`${join8(".pyb")}`)) return "pyb";
+  if (baseDir.includes(`${join8(".claude")}`)) return "claude";
   return "other";
 }
 function getTaskListReadPaths(listId) {
   const context = getTaskListContext({ listId });
   const cwd = getCwd();
-  const projectPyb = join7(cwd, ".pyb", "tasks");
-  const projectClaude = join7(cwd, ".claude", "tasks");
+  const projectPyb = join8(cwd, ".pyb", "tasks");
+  const projectClaude = join8(cwd, ".claude", "tasks");
   if (context.scope === "project") {
     const existing2 = [];
-    if (existsSync9(join7(projectPyb, context.listId))) {
+    if (existsSync10(join8(projectPyb, context.listId))) {
       existing2.push({
         ...buildTaskListPaths(projectPyb, context.listId),
         source: "pyb"
       });
     }
-    if (existsSync9(join7(projectClaude, context.listId))) {
+    if (existsSync10(join8(projectClaude, context.listId))) {
       existing2.push({
         ...buildTaskListPaths(projectClaude, context.listId),
         source: "claude"
@@ -19324,18 +19905,18 @@ function getTaskListReadPaths(listId) {
   const override = process.env.PYB_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR;
   const globalCandidates = override ? [
     {
-      baseDir: join7(override, "tasks"),
-      source: resolveSourceForBaseDir(join7(override, "tasks"))
+      baseDir: join8(override, "tasks"),
+      source: resolveSourceForBaseDir(join8(override, "tasks"))
     }
   ] : [
-    { baseDir: join7(homedir7(), ".pyb", "tasks"), source: "pyb" },
-    { baseDir: join7(homedir7(), ".claude", "tasks"), source: "claude" }
+    { baseDir: join8(homedir7(), ".pyb", "tasks"), source: "pyb" },
+    { baseDir: join8(homedir7(), ".claude", "tasks"), source: "claude" }
   ];
   const candidates = [
     ...globalCandidates,
     { baseDir: resolveXdgDataPath("tasks"), source: "other" }
   ];
-  const existing = candidates.filter((candidate) => existsSync9(join7(candidate.baseDir, context.listId))).map((candidate) => ({
+  const existing = candidates.filter((candidate) => existsSync10(join8(candidate.baseDir, context.listId))).map((candidate) => ({
     ...buildTaskListPaths(candidate.baseDir, context.listId),
     source: candidate.source
   }));
@@ -19350,27 +19931,27 @@ function getTaskListReadPaths(listId) {
 }
 function ensureTaskListDirs(paths) {
   mkdirSync5(paths.listDir, { recursive: true });
-  if (!existsSync9(paths.lockPath)) {
+  if (!existsSync10(paths.lockPath)) {
     writeFileSync3(paths.lockPath, "");
   }
   cleanupLegacyFiles(paths);
 }
-function readJson(path5) {
-  if (!existsSync9(path5)) return null;
+function readJson(path6) {
+  if (!existsSync10(path6)) return null;
   try {
-    const raw = readFileSync6(path5, "utf8");
+    const raw = readFileSync7(path6, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
-function writeJson(path5, value) {
-  writeFileSync3(path5, JSON.stringify(value, null, 2), "utf8");
+function writeJson(path6, value) {
+  writeFileSync3(path6, JSON.stringify(value, null, 2), "utf8");
 }
-function writeJsonAtomic(path5, value) {
-  const tempPath = `${path5}.${randomUUID4()}.tmp`;
+function writeJsonAtomic(path6, value) {
+  const tempPath = `${path6}.${randomUUID4()}.tmp`;
   writeFileSync3(tempPath, JSON.stringify(value, null, 2), "utf8");
-  renameSync2(tempPath, path5);
+  renameSync2(tempPath, path6);
 }
 function serializeTaskRecord(task) {
   const serialized = {
@@ -19386,8 +19967,8 @@ function serializeTaskRecord(task) {
   return serialized;
 }
 function readHighwatermark(paths) {
-  if (!existsSync9(paths.highwatermarkPath)) return null;
-  const raw = readFileSync6(paths.highwatermarkPath, "utf8").trim();
+  if (!existsSync10(paths.highwatermarkPath)) return null;
+  const raw = readFileSync7(paths.highwatermarkPath, "utf8").trim();
   const value = Number(raw);
   if (!Number.isFinite(value) || value < 0) return null;
   return value;
@@ -19402,8 +19983,8 @@ function updateHighwatermark(paths, value) {
   const next = current !== null ? Math.max(current, value) : value;
   writeHighwatermark(paths, next);
 }
-function readTaskFile(path5) {
-  const data = readJson(path5);
+function readTaskFile(path6) {
+  const data = readJson(path6);
   if (!data || !data.id || !data.subject && !data.title || !data.status) {
     return null;
   }
@@ -19478,7 +20059,7 @@ function persistBlocksForPaths(paths) {
     const prevBlockedBy = normalizeIds(existing?.blockedBy);
     const nextBlockedBy = normalizeIds(task.blockedBy);
     const raw = readJson(
-      join7(paths.tasksDir, `${task.id}.json`)
+      join8(paths.tasksDir, `${task.id}.json`)
     );
     const missingBlocks = !raw || !("blocks" in raw);
     const missingBlockedBy = !raw || !("blockedBy" in raw);
@@ -19487,7 +20068,7 @@ function persistBlocksForPaths(paths) {
     if (!blocksChanged && !blockedByChanged && !missingBlocks && !missingBlockedBy)
       continue;
     updated += 1;
-    writeJsonAtomic(join7(paths.tasksDir, `${task.id}.json`), serializeTaskRecord(task));
+    writeJsonAtomic(join8(paths.tasksDir, `${task.id}.json`), serializeTaskRecord(task));
   }
   return { updated, total: rebuilt.length };
 }
@@ -19519,9 +20100,9 @@ function applyLegacyBlocks(tasks) {
   }));
 }
 function readTasksFromDisk(paths) {
-  if (!existsSync9(paths.tasksDir)) return [];
+  if (!existsSync10(paths.tasksDir)) return [];
   const files = readdirSync2(paths.tasksDir).filter((file) => file.endsWith(".json"));
-  return files.map((file) => readTaskFile(join7(paths.tasksDir, file))).filter(Boolean);
+  return files.map((file) => readTaskFile(join8(paths.tasksDir, file))).filter(Boolean);
 }
 function applyBlocksMap(tasks, map) {
   return tasks.map((task) => ({
@@ -19536,14 +20117,14 @@ function buildTaskListForPaths(paths) {
 var legacyFiles = ["index.json", "meta.json", "events.jsonl"];
 function cleanupLegacyFiles(paths) {
   for (const file of legacyFiles) {
-    const path5 = join7(paths.listDir, file);
-    if (existsSync9(path5)) {
-      rmSync(path5, { force: true });
+    const path6 = join8(paths.listDir, file);
+    if (existsSync10(path6)) {
+      rmSync(path6, { force: true });
     }
   }
 }
 function getMaxIdFromTasksDir(paths) {
-  if (!existsSync9(paths.tasksDir)) return 0;
+  if (!existsSync10(paths.tasksDir)) return 0;
   const files = readdirSync2(paths.tasksDir).filter((file) => file.endsWith(".json"));
   let maxId = 0;
   for (const file of files) {
@@ -19718,7 +20299,7 @@ function createTask(input, options) {
       blocks: [],
       blockedBy: input.blockedBy ?? []
     };
-    writeJson(join7(paths.tasksDir, `${id}.json`), serializeTaskRecord(record));
+    writeJson(join8(paths.tasksDir, `${id}.json`), serializeTaskRecord(record));
     if ((record.blockedBy ?? []).length > 0) {
       persistBlocksForPaths(paths);
     }
@@ -19730,8 +20311,8 @@ function createTask(input, options) {
 function getTask(id, options) {
   const pathsList = getTaskListReadPaths(options?.listId);
   for (const paths of pathsList) {
-    const taskPath = join7(paths.tasksDir, `${id}.json`);
-    if (!existsSync9(taskPath)) continue;
+    const taskPath = join8(paths.tasksDir, `${id}.json`);
+    if (!existsSync10(taskPath)) continue;
     const task = readTaskFile(taskPath);
     if (task) return task;
   }
@@ -19756,18 +20337,18 @@ function updateTask(id, updates, options) {
   }
   const pathsList = getTaskListReadPaths(options?.listId);
   const target = pathsList.find(
-    (paths) => existsSync9(join7(paths.tasksDir, `${id}.json`))
+    (paths) => existsSync10(join8(paths.tasksDir, `${id}.json`))
   );
   if (!target) {
     throw new Error(`Task ${id} not found`);
   }
   return withTaskListLock(target, () => {
-    const existing = readTaskFile(join7(target.tasksDir, `${id}.json`));
+    const existing = readTaskFile(join8(target.tasksDir, `${id}.json`));
     if (!existing) {
       throw new Error(`Task ${id} not found`);
     }
     const updated = applyTaskUpdates(existing, updates);
-    writeJsonAtomic(join7(target.tasksDir, `${id}.json`), serializeTaskRecord(updated));
+    writeJsonAtomic(join8(target.tasksDir, `${id}.json`), serializeTaskRecord(updated));
     const depsChanged = normalizeIds(existing.blockedBy).join(",") !== normalizeIds(updated.blockedBy).join(",") || normalizeIds(existing.blocks).join(",") !== normalizeIds(updated.blocks).join(",");
     if (depsChanged) {
       persistBlocksForPaths(target);
@@ -19922,7 +20503,7 @@ function PermissionRequestTitle({
 
 // src/ui/components/permissions/file-edit-permission-request/FileEditToolDiff.tsx
 import * as React76 from "react";
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
 import { useMemo as useMemo14 } from "react";
 import { Box as Box56, Text as Text61 } from "ink";
 import { relative as relative10 } from "path";
@@ -19935,7 +20516,7 @@ function FileEditToolDiff({
   width
 }) {
   const file = useMemo14(
-    () => existsSync10(file_path) ? readFileSync7(file_path, "utf8") : "",
+    () => existsSync11(file_path) ? readFileSync8(file_path, "utf8") : "",
     [file_path]
   );
   const patch = useMemo14(
@@ -20560,12 +21141,12 @@ function useNotifyAfterTimeout(message, timeout = DEFAULT_INTERACTION_THRESHOLD_
 import { Box as Box61, Text as Text66, useInput as useInput20 } from "ink";
 import React81, { useCallback as useCallback9, useMemo as useMemo19 } from "react";
 import { basename as basename2, dirname as dirname6, extname as extname8 } from "path";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import chalk10 from "chalk";
 
 // src/ui/components/permissions/file-write-permission-request/FileWriteToolDiff.tsx
 import * as React80 from "react";
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
 import { useMemo as useMemo18 } from "react";
 import { Box as Box60, Text as Text65 } from "ink";
 import { extname as extname7, relative as relative11 } from "path";
@@ -20575,13 +21156,13 @@ function FileWriteToolDiff({
   verbose,
   width
 }) {
-  const fileExists = useMemo18(() => existsSync11(file_path), [file_path]);
+  const fileExists = useMemo18(() => existsSync12(file_path), [file_path]);
   const oldContent = useMemo18(() => {
     if (!fileExists) {
       return "";
     }
     const enc = detectFileEncoding(file_path);
-    return readFileSync8(file_path, enc);
+    return readFileSync9(file_path, enc);
   }, [file_path, fileExists]);
   const hunks = useMemo18(() => {
     if (!fileExists) {
@@ -20664,7 +21245,7 @@ function FileWritePermissionRequest({
     );
     return isInWorkingDir ? `Yes, allow all edits during this session ${shortcutHint}` : `Yes, allow all edits in ${chalk10.bold(`${dirName}/`)} during this session ${shortcutHint}`;
   }, [file_path, isInWorkingDir, modeCycleShortcut.displayText]);
-  const fileExists = useMemo19(() => existsSync12(file_path), [file_path]);
+  const fileExists = useMemo19(() => existsSync13(file_path), [file_path]);
   const unaryEvent = useMemo19(
     () => ({
       completion_type: "write_file_single",
@@ -20814,7 +21395,7 @@ import { Box as Box62, Text as Text67, useInput as useInput21 } from "ink";
 import React82, { useCallback as useCallback10, useMemo as useMemo20 } from "react";
 import chalk11 from "chalk";
 import { basename as basename3, dirname as dirname7 } from "path";
-import { statSync as statSync10 } from "fs";
+import { statSync as statSync11 } from "fs";
 function pathArgNameForToolUse(toolUseConfirm) {
   switch (toolUseConfirm.tool) {
     case FileWriteTool:
@@ -20841,13 +21422,13 @@ function isMultiFile(toolUseConfirm) {
   }
   return false;
 }
-function pathToPermissionDirectory2(path5) {
+function pathToPermissionDirectory2(path6) {
   try {
-    const stats = statSync10(path5);
-    if (stats.isDirectory()) return path5;
+    const stats = statSync11(path6);
+    if (stats.isDirectory()) return path6;
   } catch {
   }
-  return dirname7(path5);
+  return dirname7(path6);
 }
 function pathFromToolUse(toolUseConfirm) {
   const pathArgName = pathArgNameForToolUse(toolUseConfirm);
@@ -20866,8 +21447,8 @@ function FilesystemPermissionRequest({
   onDone,
   verbose
 }) {
-  const path5 = pathFromToolUse(toolUseConfirm);
-  if (!path5) {
+  const path6 = pathFromToolUse(toolUseConfirm);
+  if (!path6) {
     return /* @__PURE__ */ React82.createElement(
       FallbackPermissionRequest,
       {
@@ -20881,15 +21462,15 @@ function FilesystemPermissionRequest({
     FilesystemPermissionRequestImpl,
     {
       toolUseConfirm,
-      path: path5,
+      path: path6,
       onDone,
       verbose
     }
   );
 }
-function getDontAskAgainOptions(toolUseConfirm, path5, modeCycleShortcut, isInWorkingDir, hasSessionSuggestion) {
+function getDontAskAgainOptions(toolUseConfirm, path6, modeCycleShortcut, isInWorkingDir, hasSessionSuggestion) {
   if (!hasSessionSuggestion) return [];
-  const permissionDirPath = pathToPermissionDirectory2(path5);
+  const permissionDirPath = pathToPermissionDirectory2(path6);
   const permissionDirName = basename3(permissionDirPath) || "this directory";
   if (toolUseConfirm.tool.isReadOnly(toolUseConfirm.input)) {
     const label2 = isInWorkingDir ? "Yes, during this session" : `Yes, allow reading from ${chalk11.bold(`${permissionDirName}/`)} during this session`;
@@ -20921,7 +21502,7 @@ function applySessionPermissionUpdates3(args) {
 }
 function FilesystemPermissionRequestImpl({
   toolUseConfirm,
-  path: path5,
+  path: path6,
   onDone,
   verbose
 }) {
@@ -20956,8 +21537,8 @@ function FilesystemPermissionRequestImpl({
     toolUseConfirm
   ]);
   const permissionDirPath = useMemo20(
-    () => pathToPermissionDirectory2(path5),
-    [path5]
+    () => pathToPermissionDirectory2(path6),
+    [path6]
   );
   const isInWorkingDir = useMemo20(
     () => isPathInWorkingDirectories(permissionDirPath, toolPermissionContext),
@@ -21051,7 +21632,7 @@ function FilesystemPermissionRequestImpl({
           },
           ...getDontAskAgainOptions(
             toolUseConfirm,
-            path5,
+            path6,
             modeCycleShortcut.displayText,
             isInWorkingDir,
             hasSessionSuggestion
@@ -22289,8 +22870,8 @@ function getCompletionContext(args) {
 }
 
 // src/utils/completion/fileSuggestions.ts
-import { existsSync as existsSync13, readdirSync as readdirSync3, statSync as statSync11 } from "fs";
-import { basename as basename4, dirname as dirname8, join as join8, resolve as resolve8 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync3, statSync as statSync12 } from "fs";
+import { basename as basename4, dirname as dirname8, join as join9, resolve as resolve8 } from "path";
 function generateFileSuggestions(args) {
   const { prefix, cwd } = args;
   try {
@@ -22306,7 +22887,7 @@ function generateFileSuggestions(args) {
       searchPath = resolve8(cwd, userPath);
     }
     const endsWithSlash = userPath.endsWith("/");
-    const searchStat = existsSync13(searchPath) ? statSync11(searchPath) : null;
+    const searchStat = existsSync14(searchPath) ? statSync12(searchPath) : null;
     let searchDir;
     let nameFilter;
     if (endsWithSlash || searchStat?.isDirectory()) {
@@ -22316,7 +22897,7 @@ function generateFileSuggestions(args) {
       searchDir = dirname8(searchPath);
       nameFilter = basename4(searchPath);
     }
-    if (!existsSync13(searchDir)) return [];
+    if (!existsSync14(searchDir)) return [];
     const showHidden = nameFilter.startsWith(".") || userPath.includes("/.");
     const entries = readdirSync3(searchDir).filter((entry) => {
       if (!showHidden && entry.startsWith(".")) return false;
@@ -22324,17 +22905,17 @@ function generateFileSuggestions(args) {
         return false;
       return true;
     }).sort((a, b) => {
-      const aPath = join8(searchDir, a);
-      const bPath = join8(searchDir, b);
-      const aIsDir = statSync11(aPath).isDirectory();
-      const bIsDir = statSync11(bPath).isDirectory();
+      const aPath = join9(searchDir, a);
+      const bPath = join9(searchDir, b);
+      const aIsDir = statSync12(aPath).isDirectory();
+      const bIsDir = statSync12(bPath).isDirectory();
       if (aIsDir && !bIsDir) return -1;
       if (!aIsDir && bIsDir) return 1;
       return a.toLowerCase().localeCompare(b.toLowerCase());
     }).slice(0, 25);
     return entries.map((entry) => {
-      const entryPath = join8(searchDir, entry);
-      const isDir = statSync11(entryPath).isDirectory();
+      const entryPath = join9(searchDir, entry);
+      const isDir = statSync12(entryPath).isDirectory();
       const icon = isDir ? "\u{1F4C1}" : "\u{1F4C4}";
       let value;
       if (userPath.includes("/")) {
@@ -23667,19 +24248,19 @@ function useUnifiedCompletion({
     if (systemCommands.length > 0 || isLoadingCommands) return;
     setIsLoadingCommands(true);
     try {
-      const { readdirSync: readdirSync4, statSync: statSync14 } = await import("fs");
+      const { readdirSync: readdirSync4, statSync: statSync15 } = await import("fs");
       const pathDirs = (process.env.PATH || "").split(":").filter(Boolean);
       const commandSet = /* @__PURE__ */ new Set();
       const essentialCommands = getEssentialCommands();
       essentialCommands.forEach((cmd) => commandSet.add(cmd));
       for (const dir of pathDirs) {
         try {
-          if (readdirSync4 && statSync14) {
+          if (readdirSync4 && statSync15) {
             const entries = readdirSync4(dir);
             for (const entry of entries) {
               try {
                 const fullPath = `${dir}/${entry}`;
-                const stats = statSync14(fullPath);
+                const stats = statSync15(fullPath);
                 if (stats.isFile() && (stats.mode & 73) !== 0) {
                   commandSet.add(entry);
                 }
@@ -24222,9 +24803,9 @@ function TokenWarning({ tokenUsage }) {
 
 // src/utils/system/externalEditor.ts
 import { spawn, spawnSync } from "child_process";
-import { mkdtempSync, readFileSync as readFileSync9, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { mkdtempSync, readFileSync as readFileSync10, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
 import { tmpdir } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var isWindows = process.platform === "win32";
 function isCommandAvailable(command4) {
   const checker = isWindows ? "where" : "which";
@@ -24300,8 +24881,8 @@ async function launchExternalEditor(initialText) {
       )
     };
   }
-  const dir = mkdtempSync(join9(tmpdir(), "pyb-edit-"));
-  const filePath = join9(dir, "message.txt");
+  const dir = mkdtempSync(join10(tmpdir(), "pyb-edit-"));
+  const filePath = join10(dir, "message.txt");
   writeFileSync4(filePath, initialText, "utf-8");
   const wasRaw = Boolean(process.stdin.isTTY && process.stdin.isRaw);
   if (process.stdin.isTTY) {
@@ -24344,7 +24925,7 @@ async function launchExternalEditor(initialText) {
   }
   restoreStdinState(wasRaw);
   try {
-    const edited = normalizeNewlines(readFileSync9(filePath, "utf-8"));
+    const edited = normalizeNewlines(readFileSync10(filePath, "utf-8"));
     rmSync2(dir, { recursive: true, force: true });
     return { text: edited, editorLabel: editorCommand.displayName };
   } catch (error) {
@@ -24358,17 +24939,17 @@ async function launchExternalEditor(initialText) {
 }
 
 // src/utils/commands/hashCommand.ts
-import { join as join10 } from "path";
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
+import { join as join11 } from "path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
 function handleHashCommand(interpreted) {
   try {
     const cwd = process.cwd();
-    const agentsPath = join10(cwd, "AGENTS.md");
-    const legacyPath = join10(cwd, "CLAUDE.md");
+    const agentsPath = join11(cwd, "AGENTS.md");
+    const legacyPath = join11(cwd, "CLAUDE.md");
     const filesToUpdate = [];
     filesToUpdate.push({ path: agentsPath, name: "AGENTS.md" });
     try {
-      readFileSync10(legacyPath, "utf-8");
+      readFileSync11(legacyPath, "utf-8");
       filesToUpdate.push({ path: legacyPath, name: "CLAUDE.md" });
     } catch {
     }
@@ -24383,7 +24964,7 @@ _Added on ${now.toLocaleString()} ${timezone}_`;
       try {
         let existingContent = "";
         try {
-          existingContent = readFileSync10(file.path, "utf-8").trim();
+          existingContent = readFileSync11(file.path, "utf-8").trim();
         } catch {
         }
         const separator = existingContent ? "\n\n" : "";
@@ -24512,7 +25093,7 @@ function logStartupProfile(event) {
 import { useEffect as useEffect21, useRef as useRef10, useState as useState24 } from "react";
 
 // src/services/ui/statusline.ts
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function normalizeString(value) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
@@ -24531,7 +25112,7 @@ function getStatusLineCommand(options) {
   const configDir = normalizeString(options?.configDir);
   if (configDir) {
     const settings2 = readSettingsFile(
-      join11(configDir, "settings.json")
+      join12(configDir, "settings.json")
     );
     const command4 = getCommandFromSettings(settings2 ?? {});
     if (command4) return command4;
@@ -24599,7 +25180,7 @@ function useStatusLine() {
 // src/ui/components/PromptInput.tsx
 async function interpretHashCommand(input) {
   try {
-    const { queryQuick: queryQuick2 } = await import("./llm-UGJYESRH.js");
+    const { queryQuick: queryQuick2 } = await import("./llm-VY6QQH5B.js");
     const systemPrompt = [
       "You're helping the user structure notes that will be added to their PYB.md file.",
       "Format the user's input into a well-structured note that will be useful for later reference.",
@@ -24912,7 +25493,7 @@ function PromptInput({
     if (messages2.length) {
       if (mode === "bash") {
         onQuery(messages2, newAbortController).then(async () => {
-          const { getCwd: getCwd2 } = await import("./state-QPNSGH4C.js");
+          const { getCwd: getCwd2 } = await import("./state-35W4BKTE.js");
           setCurrentPwd(getCwd2());
         });
       } else {
@@ -25679,7 +26260,7 @@ As you answer the user's questions, you can use the following context:
 }
 
 // src/services/system/taskWatcher.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync6, statSync as statSync12, watch } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync6, statSync as statSync13, watch } from "fs";
 
 // src/utils/session/taskGraph.ts
 function buildTaskGraph(tasks) {
@@ -25779,8 +26360,8 @@ function ensureDirs(paths) {
 }
 function getLatestMtime(dir) {
   try {
-    if (!existsSync14(dir)) return 0;
-    const entries = statSync12(dir);
+    if (!existsSync15(dir)) return 0;
+    const entries = statSync13(dir);
     if (!entries.isDirectory()) return 0;
     return entries.mtimeMs;
   } catch {
@@ -25929,17 +26510,6 @@ async function selectAndReadFiles() {
   return results;
 }
 
-// src/services/telemetry/eventBus.ts
-var listeners2 = /* @__PURE__ */ new Map();
-function registerTelemetryListener(listenerId, listener) {
-  listeners2.set(listenerId, listener);
-}
-function emitTelemetryEvent(event) {
-  for (const listener of listeners2.values()) {
-    listener(event);
-  }
-}
-
 // src/utils/session/autoCompactMetrics.ts
 function safeDivide(numerator, denominator) {
   if (denominator <= 0) return 0;
@@ -26270,8 +26840,8 @@ function getModelCapabilities(modelName) {
 }
 
 // src/services/ai/policyDispatch/policyConfigLoader.ts
-import { existsSync as existsSync15, readFileSync as readFileSync11 } from "fs";
-import { join as join12, resolve as resolve9 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync12 } from "fs";
+import { join as join13, resolve as resolve9 } from "path";
 
 // src/services/ai/policyDispatch/policyConfigSchema.ts
 import { z as z11 } from "zod";
@@ -26313,13 +26883,13 @@ function getModelFamily(model) {
   return segments.length >= 2 ? `${segments[0]}-${segments[1]}` : normalized;
 }
 function getDefaultPolicyConfigPath() {
-  return resolve9(join12(process.cwd(), "config/auto-compact-policy.config.json"));
+  return resolve9(join13(process.cwd(), "config/auto-compact-policy.config.json"));
 }
 function loadAutoCompactPolicyConfig(options) {
   const filePath = resolve9(options?.filePath ?? getDefaultPolicyConfigPath());
-  if (!existsSync15(filePath)) return null;
+  if (!existsSync16(filePath)) return null;
   try {
-    const raw = readFileSync11(filePath, "utf8");
+    const raw = readFileSync12(filePath, "utf8");
     const parsed = JSON.parse(raw);
     return policyConfigSchema.parse(parsed);
   } catch {
@@ -26552,7 +27122,7 @@ function flushTypedParts(state) {
 }
 
 // src/services/ai/streamTyped/partStore.ts
-import { appendFileSync, existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync12 } from "fs";
+import { appendFileSync, existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync13 } from "fs";
 import { dirname as dirname9 } from "path";
 function getStreamTypedOutputFilePath() {
   return resolveXdgCachePath("telemetry/stream-typed-parts.jsonl");
@@ -26561,8 +27131,8 @@ function validateTypedPartRecord(record) {
   return streamTypedPartSchema.safeParse(record).success;
 }
 function readAllValidParts(outputFilePath) {
-  if (!existsSync16(outputFilePath)) return [];
-  const raw = readFileSync12(outputFilePath, "utf8");
+  if (!existsSync17(outputFilePath)) return [];
+  const raw = readFileSync13(outputFilePath, "utf8");
   const lines = raw.split("\n").map((line) => line.trim()).filter(Boolean);
   const parts = [];
   for (const line of lines) {
@@ -26581,7 +27151,7 @@ function appendTypedParts(options) {
     return { appended: 0 };
   }
   const outputFilePath = options.outputFilePath ?? getStreamTypedOutputFilePath();
-  if (!existsSync16(dirname9(outputFilePath))) {
+  if (!existsSync17(dirname9(outputFilePath))) {
     mkdirSync7(dirname9(outputFilePath), { recursive: true });
   }
   const existingIds = new Set(readAllValidParts(outputFilePath).map((item) => item.id));
@@ -27240,7 +27810,7 @@ ${contentWithLines}
 }
 
 // src/services/telemetry/autoCompactTelemetryPersistence.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync17, mkdirSync as mkdirSync8 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync18, mkdirSync as mkdirSync8 } from "fs";
 import { dirname as dirname10 } from "path";
 function getAutoCompactTelemetryOutputFilePath() {
   return resolveXdgCachePath("telemetry/auto-compact-metrics.jsonl");
@@ -27256,7 +27826,7 @@ function flushAutoCompactTelemetrySnapshot(options = {}) {
     eventCount: snapshot.eventCount,
     metrics: snapshot.metrics
   };
-  if (!existsSync17(dirname10(outputFilePath))) {
+  if (!existsSync18(dirname10(outputFilePath))) {
     mkdirSync8(dirname10(outputFilePath), { recursive: true });
   }
   appendFileSync2(outputFilePath, JSON.stringify(record) + "\n");
@@ -29311,7 +29881,7 @@ import React101, { useCallback as useCallback17, useEffect as useEffect26, useMe
 import { Box as Box74, Text as Text78, useInput as useInput28 } from "ink";
 import figures9 from "figures";
 import chalk15 from "chalk";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { spawn as spawn2 } from "child_process";
 
 // src/commands/agents/tooling.ts
@@ -29366,19 +29936,19 @@ async function getAvailableTools() {
 
 // src/commands/agents/storage.ts
 import {
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync9,
   renameSync as renameSync3,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync6
 } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 import { homedir as homedir8 } from "os";
 
 // src/commands/agents/generation.ts
 import { randomUUID as randomUUID6 } from "crypto";
 async function generateAgentWithClaude(prompt) {
-  const { queryModel } = await import("./llm-UGJYESRH.js");
+  const { queryModel } = await import("./llm-VY6QQH5B.js");
   const systemPrompt = `You are an expert at creating AI agent configurations. Based on the user's description, generate a specialized agent configuration.
 
 Return your response as a JSON object with exactly these fields:
@@ -29562,25 +30132,25 @@ var LEGACY_FOLDER = ".claude";
 var AGENTS_DIR = "agents";
 function getAgentDirectory(location) {
   if (location === "user") {
-    return join13(homedir8(), PRIMARY_FOLDER, AGENTS_DIR);
+    return join14(homedir8(), PRIMARY_FOLDER, AGENTS_DIR);
   }
-  return join13(getCwd(), PRIMARY_FOLDER, AGENTS_DIR);
+  return join14(getCwd(), PRIMARY_FOLDER, AGENTS_DIR);
 }
 function getLegacyAgentDirectory(location) {
   if (location === "user") {
-    return join13(homedir8(), LEGACY_FOLDER, AGENTS_DIR);
+    return join14(homedir8(), LEGACY_FOLDER, AGENTS_DIR);
   }
-  return join13(getCwd(), LEGACY_FOLDER, AGENTS_DIR);
+  return join14(getCwd(), LEGACY_FOLDER, AGENTS_DIR);
 }
 function getPrimaryAgentFilePath(location, agentType) {
-  return join13(getAgentDirectory(location), `${agentType}.md`);
+  return join14(getAgentDirectory(location), `${agentType}.md`);
 }
 function getLegacyAgentFilePath(location, agentType) {
-  return join13(getLegacyAgentDirectory(location), `${agentType}.md`);
+  return join14(getLegacyAgentDirectory(location), `${agentType}.md`);
 }
 function ensureDirectoryExists(location) {
   const dir = getAgentDirectory(location);
-  if (!existsSync18(dir)) {
+  if (!existsSync19(dir)) {
     mkdirSync9(dir, { recursive: true });
   }
   return dir;
@@ -29589,7 +30159,7 @@ async function saveAgent(location, agentType, description3, tools, systemPrompt,
   ensureDirectoryExists(location);
   const filePath = getPrimaryAgentFilePath(location, agentType);
   const legacyPath = getLegacyAgentFilePath(location, agentType);
-  if (throwIfExists && (existsSync18(filePath) || existsSync18(legacyPath))) {
+  if (throwIfExists && (existsSync19(filePath) || existsSync19(legacyPath))) {
     throw new Error(`Agent file already exists: ${filePath}`);
   }
   const tempFile = `${filePath}.tmp.${Date.now()}.${Math.random().toString(36).substr(2, 9)}`;
@@ -29604,7 +30174,7 @@ async function saveAgent(location, agentType, description3, tools, systemPrompt,
   );
   try {
     writeFileSync6(tempFile, content, { encoding: "utf-8", flag: "wx" });
-    if (throwIfExists && (existsSync18(filePath) || existsSync18(legacyPath))) {
+    if (throwIfExists && (existsSync19(filePath) || existsSync19(legacyPath))) {
       try {
         unlinkSync2(tempFile);
       } catch {
@@ -29614,7 +30184,7 @@ async function saveAgent(location, agentType, description3, tools, systemPrompt,
     renameSync3(tempFile, filePath);
   } catch (error) {
     try {
-      if (existsSync18(tempFile)) {
+      if (existsSync19(tempFile)) {
         unlinkSync2(tempFile);
       }
     } catch (cleanupError) {
@@ -29642,7 +30212,7 @@ async function updateAgent(agent, description3, tools, systemPrompt, color, mode
   const location = agent.location;
   const primaryPath = getPrimaryAgentFilePath(location, agent.agentType);
   const legacyPath = getLegacyAgentFilePath(location, agent.agentType);
-  const filePath = existsSync18(primaryPath) ? primaryPath : existsSync18(legacyPath) ? legacyPath : primaryPath;
+  const filePath = existsSync19(primaryPath) ? primaryPath : existsSync19(legacyPath) ? legacyPath : primaryPath;
   ensureDirectoryExists(location);
   writeFileSync6(filePath, content, { encoding: "utf-8", flag: "w" });
 }
@@ -29653,10 +30223,10 @@ async function deleteAgent(agent) {
   const location = agent.location;
   const primaryPath = getPrimaryAgentFilePath(location, agent.agentType);
   const legacyPath = getLegacyAgentFilePath(location, agent.agentType);
-  if (existsSync18(primaryPath)) {
+  if (existsSync19(primaryPath)) {
     unlinkSync2(primaryPath);
   }
-  if (existsSync18(legacyPath)) {
+  if (existsSync19(legacyPath)) {
     unlinkSync2(legacyPath);
   }
 }
@@ -30603,8 +31173,8 @@ function CreateAgentWizard(props) {
               true
             );
             if (openEditor) {
-              const path5 = getPrimaryAgentFilePath(location, finalAgent.agentType);
-              await openInEditor(path5);
+              const path6 = getPrimaryAgentFilePath(location, finalAgent.agentType);
+              await openInEditor(path6);
               props.onComplete(
                 `Created agent: ${chalk15.bold(finalAgent.agentType)} and opened in editor. If you made edits, restart to load the latest version.`
               );
@@ -30674,8 +31244,8 @@ function ViewAgent(props) {
     if (props.agent.source === "plugin") return `Plugin: ${props.agent.baseDir ?? "Unknown"}`;
     const baseDir = props.agent.baseDir;
     const file = `${props.agent.filename ?? props.agent.agentType}.md`;
-    if (props.agent.source === "projectSettings") return join14(".claude", "agents", file);
-    if (baseDir) return join14(baseDir, file);
+    if (props.agent.source === "projectSettings") return join15(".claude", "agents", file);
+    if (baseDir) return join15(baseDir, file);
     return props.agent.source;
   })();
   const toolsSummary = () => {
@@ -32885,7 +33455,7 @@ ${footerParts.join(" ")}`;
               for (const filePath of filePaths) {
                 const fullFilePath = isAbsolute8(filePath) ? filePath : resolve11(getCwd(), filePath);
                 try {
-                  readFileTimestamps[fullFilePath] = statSync13(fullFilePath).mtimeMs;
+                  readFileTimestamps[fullFilePath] = statSync14(fullFilePath).mtimeMs;
                 } catch (e) {
                   logError(e);
                 }
@@ -32985,7 +33555,7 @@ Single-task work does not require a dependency chain. When dependencies are read
 Task records use subject as the single primary name, with activeForm provided by the caller to describe the in-progress action. Keep description and blockedBy independent in JSON; any joining is only for terminal rendering. blockedBy should always be present as an array (empty when not used). Ordering is by task id; do not use priority fields.
 
 It is critical that you mark tasks as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.
-For non-trivial reasoning, planning under uncertainty, debugging, or multi-step tradeoff decisions, proactively use ThinkTool to externalize step-by-step thinking before and during tool execution.
+For non-trivial reasoning, planning under uncertainty, debugging, or multi-step tradeoff decisions, proactively use Ultra-Think to externalize step-by-step thinking before and during tool execution.
 
 # Cognitive Safety & Sensing
 1. **Modification Check**: Before editing, you MUST verify if the change is already present (e.g. use \`grep\` or \`read\`). Do not rely on memory from previous turns.
@@ -33176,6 +33746,7 @@ export {
   grantReadPermissionForOriginalDir,
   NotebookEditTool,
   FileEditTool,
+  emitTelemetryEvent,
   FileReadTool,
   FileWriteTool,
   GlobTool,
@@ -33195,7 +33766,6 @@ export {
   getReasoningEffort,
   generatePybContext,
   refreshPybContext,
-  emitTelemetryEvent,
   resolveModelResponsePolicy,
   formatSystemPromptWithContext,
   useExitOnCtrlCD,
@@ -33204,7 +33774,6 @@ export {
   Onboarding,
   review_default,
   applyMarkdown,
-  MessageResponse,
   generateTaskListId,
   runWithTaskListId,
   runWithTaskListEnv,