pybao-cli 1.4.83 → 1.4.84

package/dist/{chunk-GKBRHNMB.js → chunk-ZTGVZNCE.js}

@@ -2,11 +2,11 @@ import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
 import {
   listPybAgentSessions
-} from "./chunk-EINLEUKA.js";
+} from "./chunk-SELNEWOV.js";
 import {
   formatValidationResult,
   validatePluginOrMarketplacePath
-} from "./chunk-WGGELTRR.js";
+} from "./chunk-UZE4M5OS.js";
 import {
   ConversationTracker,
   appendFinishState,
@@ -14,18 +14,18 @@ import {
   getConversationTrackerForContext,
   isFinishComplete,
   mapFinishReason
-} from "./chunk-RMZABYAD.js";
+} from "./chunk-APXMGUKA.js";
 import {
   beginReplSessionScope
 } from "./chunk-F4AXICO7.js";
 import {
   loadPybAgentSessionMessages
-} from "./chunk-FQL6V43W.js";
+} from "./chunk-NIIT2UQA.js";
 import {
   appendSessionCustomTitleRecord,
   appendSessionJsonlFromMessage,
   appendSessionTagRecord
-} from "./chunk-A5LLPMGS.js";
+} from "./chunk-4K65XDFQ.js";
 import {
   drainHookSystemPromptAdditions,
   getHookTranscriptPath,
@@ -37,7 +37,7 @@ import {
   runStopHooks,
   runUserPromptSubmitHooks,
   updateHookTranscriptForMessages
-} from "./chunk-5KEKIQVC.js";
+} from "./chunk-KXHMHPXD.js";
 import {
   DEFAULT_OUTPUT_STYLE,
   getAvailableOutputStyles,
@@ -46,11 +46,11 @@ import {
   getOutputStyleSystemPromptAdditions,
   resolveOutputStyleName,
   setCurrentOutputStyle
-} from "./chunk-IDJMJZP4.js";
+} from "./chunk-3JI37ZA6.js";
 import {
   fetchCustomModels,
   getModelFeatures
-} from "./chunk-53LVQG4V.js";
+} from "./chunk-KELCOTIO.js";
 import {
   getSessionState
 } from "./chunk-XKYHFZEC.js";
@@ -58,7 +58,7 @@ import {
   queryLLM,
   queryQuick,
   verifyApiKey
-} from "./chunk-OUOB2RBI.js";
+} from "./chunk-5LRFEGFP.js";
 import {
   DEFAULT_TIMEOUT_MS,
   FallbackToolUseRejectedMessage,
@@ -72,7 +72,7 @@ import {
   listMCPServers,
   loadMergedSettings,
   normalizeSandboxRuntimeConfigFromSettings
-} from "./chunk-7UTUKVKM.js";
+} from "./chunk-6IXLNIBX.js";
 import {
   addMarketplace,
   disableSkillPlugin,
@@ -85,11 +85,11 @@ import {
   refreshMarketplaceAsync,
   removeMarketplace,
   uninstallSkillPlugin
-} from "./chunk-SUHM4MYA.js";
+} from "./chunk-ZPTG6OYN.js";
 import {
   loadToolPermissionContextFromDisk,
   persistToolPermissionUpdateToDisk
-} from "./chunk-FVR53MZY.js";
+} from "./chunk-QUQAVKTY.js";
 import {
   applyToolPermissionContextUpdate,
   applyToolPermissionContextUpdates,
@@ -100,13 +100,13 @@ import {
   generateSystemReminders,
   resetReminderSession,
   systemReminderService
-} from "./chunk-5MZZCUQX.js";
+} from "./chunk-HS5IAPED.js";
 import {
   clearAgentCache,
   getActiveAgents,
   getAgentByType,
   getAllAgents
-} from "./chunk-DHJEENK5.js";
+} from "./chunk-RIKQVWEQ.js";
 import {
   API_ERROR_MESSAGE_PREFIX,
   CANCEL_MESSAGE,
@@ -137,7 +137,7 @@ import {
   processUserInput,
   reorderMessages,
   stripSystemMessages
-} from "./chunk-EUHKG6AJ.js";
+} from "./chunk-4T65Y47N.js";
 import {
   getRequestStatus,
   setRequestStatus,
@@ -167,7 +167,7 @@ import {
   normalizeFilePath,
   readTextContent,
   writeTextContent
-} from "./chunk-FPCH7C5K.js";
+} from "./chunk-2Y6RSLIK.js";
 import {
   parseBlockEdits
 } from "./chunk-QWIBSCDN.js";
@@ -177,18 +177,18 @@ import {
   ParserRegistry,
   initParser,
   loadLanguage
-} from "./chunk-XHQMUJIS.js";
+} from "./chunk-X2MOC5KR.js";
 import {
   getSettingsFileCandidates,
   loadSettingsWithLegacyFallback,
   readSettingsFile
-} from "./chunk-5MEGIDN7.js";
+} from "./chunk-UKCYPF74.js";
 import {
   getCustomCommandDirectories,
   hasCustomCommands,
   loadCustomCommands,
   reloadCustomCommands
-} from "./chunk-IIZXV4HL.js";
+} from "./chunk-5EJDTTBL.js";
 import {
   getSessionPlugins
 } from "./chunk-BJSWTHRM.js";
@@ -196,7 +196,7 @@ import {
   ModelManager,
   getModelManager,
   isDefaultSlowAndCapableModel
-} from "./chunk-OCIKBYQ4.js";
+} from "./chunk-X36JZMFM.js";
 import {
   getCodeStyle,
   getContext,
@@ -204,13 +204,13 @@ import {
   getIsGit,
   getProjectDocs,
   getProjectStructureStatisticsBlock
-} from "./chunk-MKSTJEGS.js";
+} from "./chunk-SRT3X6FV.js";
 import {
   ripGrep
-} from "./chunk-KSCBNFN7.js";
+} from "./chunk-TTMZXWQN.js";
 import {
   getTheme
-} from "./chunk-TKPY5LGF.js";
+} from "./chunk-5Z5ZS7IB.js";
 import {
   DEFAULT_GLOBAL_CONFIG,
   enableConfigs,
@@ -223,7 +223,7 @@ import {
   saveGlobalConfig,
   setAllPointersToModel,
   setModelPointer
-} from "./chunk-WSP4AYLZ.js";
+} from "./chunk-QTPKDLLB.js";
 import {
   AbortError
 } from "./chunk-RQVLBMP7.js";
@@ -232,7 +232,7 @@ import {
   getCurrentRequest,
   logUserFriendly,
   markPhase
-} from "./chunk-MBIKKOOW.js";
+} from "./chunk-2OQK4SGM.js";
 import {
   ASCII_LOGO,
   BunShell,
@@ -266,15 +266,16 @@ import {
   overwriteLog,
   renderBackgroundShellStatusAttachment,
   renderBashNotification,
+  resolveXdgCachePath,
   resolveXdgDataPath,
   setActivePlanConversationKey,
   setCwd,
   shouldApplyToolOutputTruncation,
   truncateToolOutput
-} from "./chunk-VRRJXBF3.js";
+} from "./chunk-BKU7DKGB.js";
 import {
   MACRO
-} from "./chunk-GRQ32HWG.js";
+} from "./chunk-LLNPRFDC.js";
 import {
   __export
 } from "./chunk-I3J4JYES.js";
@@ -282,9 +283,9 @@ import {
 // src/tools/system/BashTool/BashTool.tsx
 import { statSync as statSync13 } from "fs";
 import { EOL as EOL3 } from "os";
-import { isAbsolute as isAbsolute8, relative as relative12, resolve as resolve10 } from "path";
+import { isAbsolute as isAbsolute8, relative as relative12, resolve as resolve11 } from "path";
 import * as React106 from "react";
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 
 // src/utils/commands/index.ts
 import { memoize } from "lodash-es";
@@ -455,7 +456,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-VAN6WS52.js");
+    const { API_ERROR_MESSAGE_PREFIX: API_ERROR_MESSAGE_PREFIX2, queryQuick: queryQuick2 } = await import("./llm-WAAV3MBX.js");
     const response = await queryQuick2({
       systemPrompt,
       userPrompt,
@@ -740,8 +741,8 @@ async function shouldAllowNetworkRequest(query2) {
 }
 async function serializePermissionPrompt(task) {
   let release = null;
-  const next = new Promise((resolve11) => {
-    release = resolve11;
+  const next = new Promise((resolve12) => {
+    release = resolve12;
   });
   const prev = active.permissionPromptChain;
   active.permissionPromptChain = prev.then(() => next);
@@ -774,18 +775,18 @@ async function cleanupSandboxNetworkInfrastructure() {
   active.sessionDeniedHosts.clear();
   active.inflightPermissionRequests.clear();
   await Promise.allSettled([
-    httpServer ? new Promise((resolve11) => {
+    httpServer ? new Promise((resolve12) => {
       try {
-        httpServer.close(() => resolve11());
+        httpServer.close(() => resolve12());
       } catch {
-        resolve11();
+        resolve12();
       }
     }) : Promise.resolve(),
-    socksServer ? new Promise((resolve11) => {
+    socksServer ? new Promise((resolve12) => {
       try {
-        socksServer.close(() => resolve11());
+        socksServer.close(() => resolve12());
       } catch {
-        resolve11();
+        resolve12();
       }
     }) : Promise.resolve()
   ]);
@@ -975,7 +976,7 @@ async function startHttpProxy() {
     clientSocket.on("data", onData);
   });
   active.httpProxyServer = server;
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     server.once("error", reject);
     server.once("listening", () => {
       const addr = server.address();
@@ -984,7 +985,7 @@ async function startHttpProxy() {
         return;
       }
       server.unref();
-      resolve11(addr.port);
+      resolve12(addr.port);
     });
     server.listen(0, "127.0.0.1");
   });
@@ -1094,7 +1095,7 @@ async function startSocks5Proxy() {
     socket.on("data", onData);
   });
   active.socksProxyServer = server;
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     server.once("error", reject);
     server.once("listening", () => {
       const addr = server.address();
@@ -1103,7 +1104,7 @@ async function startSocks5Proxy() {
         return;
       }
       server.unref();
-      resolve11(addr.port);
+      resolve12(addr.port);
     });
     server.listen(0, "127.0.0.1");
   });
@@ -2571,7 +2572,7 @@ function findMatchingBashRules(args) {
     args.toolPermissionContext,
     args.behavior
   );
-  const matches = [];
+  const matches2 = [];
   for (const ruleString of rules) {
     const parsed = parseToolRuleString(ruleString);
     if (!parsed || parsed.toolName !== "Bash" || !parsed.ruleContent) continue;
@@ -2588,9 +2589,9 @@ function findMatchingBashRules(args) {
           return candidate.startsWith(`${ruleContent.prefix} `);
       }
     });
-    if (matched) matches.push(ruleString);
+    if (matched) matches2.push(ruleString);
   }
-  return matches;
+  return matches2;
 }
 function buildBashRuleSuggestionExact(command4) {
   return [
@@ -3071,14 +3072,14 @@ function RQ5(command4) {
   if (!HEREDOC_IN_SUBSTITUTION.test(command4)) return false;
   try {
     const re = /\$\(cat\s*<<-?\s*(?:'+([A-Za-z_]\w*)'+|\\([A-Za-z_]\w*))/g;
-    const matches = [];
+    const matches2 = [];
     let m;
     while ((m = re.exec(command4)) !== null) {
       const delimiter = m[1] || m[2];
-      if (delimiter) matches.push({ start: m.index, delimiter });
+      if (delimiter) matches2.push({ start: m.index, delimiter });
     }
-    if (matches.length === 0) return false;
-    for (const { start, delimiter } of matches) {
+    if (matches2.length === 0) return false;
+    for (const { start, delimiter } of matches2) {
       const tail = command4.substring(start);
       const escaped = delimiter.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\\\$&");
       if (!new RegExp(`(?:\\n|^[^\\\\n]*\\n)${escaped}\\\\s*\\\\)`).test(tail))
@@ -3089,7 +3090,7 @@ function RQ5(command4) {
       if (!tail.match(full)) return false;
     }
     let remaining = command4;
-    for (const { delimiter } of matches) {
+    for (const { delimiter } of matches2) {
       const escaped = delimiter.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\\\$&");
       const pattern = new RegExp(
         `\\\\$\\\\(cat\\\\s*<<-?\\\\s*(?:'+${escaped}'+|\\\\\\\\${escaped})[^\\\\n]*\\\\n(?:[\\\\s\\\\S]*?\\\\n)?${escaped}\\\\s*\\\\)`
@@ -4257,7 +4258,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-VAN6WS52.js");
+  const { API_ERROR_MESSAGE_PREFIX: API_ERROR_MESSAGE_PREFIX2, queryLLM: queryLLM2 } = await import("./llm-WAAV3MBX.js");
   const queryLLMFn = args.queryLLMOverride ?? queryLLM2;
   const messages = [
     {
@@ -6654,7 +6655,7 @@ var FileEditTool = {
     const originalFileContent = currentFileContent;
     let totalPatch = [];
     const { SmartEdit } = await import("./smart-edit-AWHJDSU6.js");
-    const { findLspAnchor } = await import("./lspAnchor-BLB7II5Y.js");
+    const { findLspAnchor } = await import("./lspAnchor-A3P4LT3X.js");
     for (const op of editOperations) {
       const normalizedSearch = normalizeLineEndings(op.search);
       const normalizedReplace = normalizeLineEndings(op.replace);
@@ -8988,7 +8989,7 @@ var WebSearchTool = {
 };
 
 // src/tools/interaction/SlashCommandTool/SlashCommandTool.tsx
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 import * as React103 from "react";
 
 // src/ui/components/Bug.tsx
@@ -10066,9 +10067,9 @@ function setTerminalTitle(title) {
   }
 }
 function clearTerminal() {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     process.stdout.write("\x1B[2J\x1B[3J\x1B[H", () => {
-      resolve11();
+      resolve12();
     });
   });
 }
@@ -11186,8 +11187,8 @@ var OAuthService = class {
       await authURLHandler(manualUrl);
       await openBrowser(autoUrl);
     };
-    const { authorizationCode, useManualRedirect } = await new Promise((resolve11, reject) => {
-      this.pendingCodePromise = { resolve: resolve11, reject };
+    const { authorizationCode, useManualRedirect } = await new Promise((resolve12, reject) => {
+      this.pendingCodePromise = { resolve: resolve12, reject };
       this.startLocalServer(state, onReady);
     });
     const {
@@ -11358,7 +11359,7 @@ async function createAndStoreApiKey(accessToken) {
       }
       saveGlobalConfig(config2);
       try {
-        const { resetAnthropicClient } = await import("./llm-VAN6WS52.js");
+        const { resetAnthropicClient } = await import("./llm-WAAV3MBX.js");
         resetAnthropicClient();
       } catch {
       }
@@ -13798,7 +13799,7 @@ function ModelSelector({
         setModelLoadError(
           `Attempt ${attempt}/${MAX_RETRIES}: Retrying model discovery...`
         );
-        await new Promise((resolve11) => setTimeout(resolve11, 1e3));
+        await new Promise((resolve12) => setTimeout(resolve12, 1e3));
       }
       try {
         const models = await fetchModels();
@@ -15725,7 +15726,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-JEJXUSFZ.js");
+  const { configureSessionPlugins } = await import("./pluginRuntime-BZ3RM5P7.js");
   const { errors } = await configureSessionPlugins({ pluginDirs: dirs });
   return errors;
 }
@@ -16394,7 +16395,7 @@ async function call(onDone, context) {
     ModelConfig,
     {
       onClose: () => {
-        import("./model-OUTGOGMR.js").then(({ reloadModelManager: reloadModelManager2 }) => {
+        import("./model-JCGDL77F.js").then(({ reloadModelManager: reloadModelManager2 }) => {
           reloadModelManager2();
           triggerModelConfigChange();
           onDone();
@@ -22764,8 +22765,8 @@ function generateMentionSuggestions(args) {
     });
   }
   const candidates = allSuggestions.map((s) => s.value);
-  const matches = matchCommands(candidates, prefix);
-  const fuzzyResults = matches.map((match) => {
+  const matches2 = matchCommands(candidates, prefix);
+  const fuzzyResults = matches2.map((match) => {
     const suggestion = allSuggestions.find((s) => s.value === match.command);
     return {
       ...suggestion,
@@ -23487,8 +23488,8 @@ function generateUnixCommandSuggestions(args) {
   }
   const commonCommands = getCommonSystemCommands(systemCommands);
   const uniqueCommands = Array.from(new Set(commonCommands));
-  const matches = matchCommands(uniqueCommands, prefix);
-  const boostedMatches = matches.map((match) => {
+  const matches2 = matchCommands(uniqueCommands, prefix);
+  const boostedMatches = matches2.map((match) => {
     const priority = getCommandPriority(match.command);
     return {
       ...match,
@@ -24140,13 +24141,13 @@ function useUnifiedCompletion({
       }
       if (context.type === "command") {
         const fullCommand = `/${suggestion.value}`;
-        const matches = currentInput === fullCommand;
-        return matches;
+        const matches2 = currentInput === fullCommand;
+        return matches2;
       }
       if (context.type === "agent") {
         const fullAgent = `@${suggestion.value}`;
-        const matches = currentInput === fullAgent;
-        return matches;
+        const matches2 = currentInput === fullAgent;
+        return matches2;
       }
       return false;
     },
@@ -24310,7 +24311,7 @@ async function launchExternalEditor(initialText) {
     }
   }
   try {
-    await new Promise((resolve11, reject) => {
+    await new Promise((resolve12, reject) => {
       const child = spawn(
         editorCommand.command,
         [...editorCommand.args, filePath],
@@ -24322,7 +24323,7 @@ async function launchExternalEditor(initialText) {
       child.on("error", reject);
       child.on("exit", (code, signal) => {
         if (code === 0 || code === null) {
-          resolve11();
+          resolve12();
         } else {
           reject(
             new Error(
@@ -24598,7 +24599,7 @@ function useStatusLine() {
 // src/ui/components/PromptInput.tsx
 async function interpretHashCommand(input) {
   try {
-    const { queryQuick: queryQuick2 } = await import("./llm-VAN6WS52.js");
+    const { queryQuick: queryQuick2 } = await import("./llm-WAAV3MBX.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.",
@@ -24803,7 +24804,7 @@ function PromptInput({
           abortController.abort();
         }
         setIsLoading(false);
-        await new Promise((resolve11) => setTimeout(resolve11, 0));
+        await new Promise((resolve12) => setTimeout(resolve12, 0));
         setIsLoading(true);
         let finalInput2 = cleanInput;
         for (const { placeholder: placeholder2, text } of pastedTexts) {
@@ -24911,7 +24912,7 @@ function PromptInput({
     if (messages2.length) {
       if (mode === "bash") {
         onQuery(messages2, newAbortController).then(async () => {
-          const { getCwd: getCwd2 } = await import("./state-WVRITIDZ.js");
+          const { getCwd: getCwd2 } = await import("./state-YJAFADHA.js");
           setCurrentPwd(getCwd2());
         });
       } else {
@@ -25271,11 +25272,11 @@ import { useCallback as useCallback14 } from "react";
 function useCanUseTool(setToolUseConfirm) {
   return useCallback14(
     async (tool, input, toolUseContext, assistantMessage) => {
-      return new Promise((resolve11) => {
+      return new Promise((resolve12) => {
         function logCancelledEvent() {
         }
         function resolveWithCancelledAndAbortAllToolCalls(message) {
-          resolve11({
+          resolve12({
             result: false,
             message: message ? `${REJECT_MESSAGE_WITH_FEEDBACK_PREFIX}${message}` : REJECT_MESSAGE
           });
@@ -25293,12 +25294,12 @@ function useCanUseTool(setToolUseConfirm) {
           assistantMessage
         ).then(async (result) => {
           if (result.result === true) {
-            resolve11({ result: true });
+            resolve12({ result: true });
             return;
           }
           const deniedResult = result;
           if (deniedResult.shouldPromptUser === false) {
-            resolve11({ result: false, message: deniedResult.message });
+            resolve12({ result: false, message: deniedResult.message });
             return;
           }
           const [description3, commandPrefix] = await Promise.all([
@@ -25330,7 +25331,7 @@ function useCanUseTool(setToolUseConfirm) {
               if (type3 === "permanent") {
               } else {
               }
-              resolve11({ result: true });
+              resolve12({ result: true });
             },
             onReject(rejectionMessage) {
               resolveWithCancelledAndAbortAllToolCalls(rejectionMessage);
@@ -25928,6 +25929,794 @@ 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;
+  return numerator / denominator;
+}
+function computeAutoCompactMetrics(events) {
+  const failedEvents = events.filter((event) => event.phase === "AUTO_COMPACT_FAILED");
+  const retryEvents = events.filter((event) => event.phase === "AUTO_COMPACT_RETRY");
+  const fallbackEvents = events.filter((event) => event.phase === "AUTO_COMPACT_FALLBACK");
+  const invalidShapeFailures = failedEvents.filter(
+    (event) => event.data?.failureType === "invalid_content_shape"
+  ).length;
+  const compact_invalid_shape_rate = safeDivide(
+    invalidShapeFailures,
+    failedEvents.length
+  );
+  const retrySuccessSignals = fallbackEvents.length;
+  const compact_retry_success_rate = safeDivide(
+    retrySuccessSignals,
+    retryEvents.length + fallbackEvents.length
+  );
+  const transformAppliedEvents = events.filter(
+    (event) => event.phase === "MESSAGE_TRANSFORM_APPLIED"
+  );
+  const thinkingFirstCount = transformAppliedEvents.filter((event) => {
+    const stats = event.data?.outputBlockStats || {};
+    const thinking = Number(stats.thinking ?? 0);
+    const text = Number(stats.text ?? 0);
+    return thinking > 0 && text > 0;
+  }).length;
+  const thinking_first_ratio = safeDivide(
+    thinkingFirstCount,
+    transformAppliedEvents.length
+  );
+  const crossReplayTagged = events.filter(
+    (event) => event.phase === "AUTO_COMPACT_FAILED" || event.phase === "AUTO_COMPACT_RETRY" || event.phase === "AUTO_COMPACT_FALLBACK"
+  );
+  const crossReplayErrors = crossReplayTagged.filter(
+    (event) => event.data?.crossModelReplay === true && event.phase === "AUTO_COMPACT_FAILED"
+  ).length;
+  const crossReplayTotal = crossReplayTagged.filter(
+    (event) => event.data?.crossModelReplay === true
+  ).length;
+  const cross_model_replay_error_rate = safeDivide(
+    crossReplayErrors,
+    crossReplayTotal
+  );
+  return {
+    compact_invalid_shape_rate,
+    compact_retry_success_rate,
+    thinking_first_ratio,
+    cross_model_replay_error_rate
+  };
+}
+
+// src/utils/session/autoCompactMetricsSink.ts
+function createAutoCompactMetricsSink() {
+  const events = [];
+  return {
+    push(event) {
+      events.push(event);
+    },
+    snapshot() {
+      return {
+        eventCount: events.length,
+        metrics: computeAutoCompactMetrics(events)
+      };
+    },
+    clear() {
+      events.length = 0;
+    }
+  };
+}
+
+// src/services/telemetry/autoCompactTelemetry.ts
+var AUTO_COMPACT_TELEMETRY_PHASES = /* @__PURE__ */ new Set([
+  "AUTO_COMPACT_FAILED",
+  "AUTO_COMPACT_RETRY",
+  "AUTO_COMPACT_FALLBACK",
+  "MESSAGE_TRANSFORM_APPLIED"
+]);
+var AUTO_COMPACT_SINK_LISTENER_ID = "auto-compact-metrics-sink";
+var autoCompactSink = createAutoCompactMetricsSink();
+var sinkRegistered = false;
+function ensureAutoCompactTelemetryRegistered() {
+  if (sinkRegistered) return;
+  registerTelemetryListener(AUTO_COMPACT_SINK_LISTENER_ID, (event) => {
+    if (!AUTO_COMPACT_TELEMETRY_PHASES.has(event.phase)) return;
+    autoCompactSink.push({
+      phase: event.phase,
+      data: event.data
+    });
+  });
+  sinkRegistered = true;
+}
+function emitAutoCompactTelemetryEvent(phase, data) {
+  ensureAutoCompactTelemetryRegistered();
+  emitTelemetryEvent({
+    channel: "auto_compact",
+    phase,
+    data,
+    timestamp: Date.now()
+  });
+}
+function getAutoCompactMetricsSnapshot() {
+  ensureAutoCompactTelemetryRegistered();
+  return autoCompactSink.snapshot();
+}
+function resetAutoCompactTelemetry() {
+  autoCompactSink.clear();
+}
+ensureAutoCompactTelemetryRegistered();
+
+// src/services/ai/canonicalResponse/index.ts
+function normalizeModelResponseContent(content, context) {
+  const textBlocks = [];
+  const reasoningBlocks = [];
+  const blockTypes = [];
+  if (typeof content === "string") {
+    const normalized = content.trim();
+    if (normalized.length > 0) {
+      textBlocks.push(normalized);
+      blockTypes.push("string");
+    }
+  } else if (Array.isArray(content)) {
+    for (const block of content) {
+      if (!block || typeof block !== "object") {
+        blockTypes.push(typeof block);
+        continue;
+      }
+      const type3 = String(block.type ?? "unknown");
+      blockTypes.push(type3);
+      if (type3 === "text") {
+        const text = String(block.text ?? "").trim();
+        if (text.length > 0) {
+          textBlocks.push(text);
+        }
+        continue;
+      }
+      if (type3 === "thinking" || type3 === "reasoning") {
+        const reasoning = String(
+          block.thinking ?? block.reasoning ?? ""
+        ).trim();
+        if (reasoning.length > 0) {
+          reasoningBlocks.push(reasoning);
+        }
+      }
+    }
+  } else {
+    blockTypes.push(typeof content);
+  }
+  const summaryText = textBlocks.length > 0 ? textBlocks.join("\n") : null;
+  const fallbackSummary = summaryText === null && context.reasoningPolicy === "flatten_to_text_fallback" && reasoningBlocks.length > 0 ? reasoningBlocks.join("\n") : null;
+  const finalSummaryText = summaryText ?? fallbackSummary;
+  const result = {
+    isValid: finalSummaryText !== null,
+    summaryText: finalSummaryText,
+    textBlocks,
+    reasoningBlocks,
+    blockTypes,
+    ...finalSummaryText === null ? { failureType: "invalid_content_shape" } : {}
+  };
+  const payload = {
+    source: context.source,
+    model: context.model,
+    provider: context.provider ?? "openai",
+    isValid: result.isValid,
+    failureType: result.failureType,
+    reasoningPolicy: context.reasoningPolicy,
+    policySource: context.policySource,
+    textBlockCount: textBlocks.length,
+    reasoningBlockCount: reasoningBlocks.length,
+    blockTypes
+  };
+  debug.state("CANONICAL_RESPONSE_APPLIED", payload);
+  emitTelemetryEvent({
+    channel: "canonical_response",
+    phase: "CANONICAL_RESPONSE_APPLIED",
+    data: payload,
+    timestamp: Date.now()
+  });
+  return result;
+}
+
+// src/constants/modelCapabilities.ts
+var GPT5_CAPABILITIES = {
+  apiArchitecture: {
+    primary: "responses_api",
+    fallback: "chat_completions"
+  },
+  parameters: {
+    maxTokensField: "max_output_tokens",
+    supportsReasoningEffort: true,
+    supportsVerbosity: true,
+    temperatureMode: "fixed_one"
+  },
+  toolCalling: {
+    mode: "custom_tools",
+    supportsFreeform: true,
+    supportsAllowedTools: true,
+    supportsParallelCalls: true
+  },
+  stateManagement: {
+    supportsResponseId: true,
+    supportsConversationChaining: true,
+    supportsPreviousResponseId: true
+  },
+  streaming: {
+    supported: true,
+    includesUsage: true
+  }
+};
+var CHAT_COMPLETIONS_CAPABILITIES = {
+  apiArchitecture: {
+    primary: "chat_completions"
+  },
+  parameters: {
+    maxTokensField: "max_tokens",
+    supportsReasoningEffort: false,
+    supportsVerbosity: false,
+    temperatureMode: "flexible"
+  },
+  toolCalling: {
+    mode: "function_calling",
+    supportsFreeform: false,
+    supportsAllowedTools: false,
+    supportsParallelCalls: true
+  },
+  stateManagement: {
+    supportsResponseId: false,
+    supportsConversationChaining: false,
+    supportsPreviousResponseId: false
+  },
+  streaming: {
+    supported: true,
+    includesUsage: true
+  }
+};
+var MODEL_CAPABILITIES_REGISTRY = {
+  "gpt-5": GPT5_CAPABILITIES,
+  "gpt-5-mini": GPT5_CAPABILITIES,
+  "gpt-5-nano": GPT5_CAPABILITIES,
+  "gpt-5-chat-latest": GPT5_CAPABILITIES,
+  "gpt-5-codex": GPT5_CAPABILITIES,
+  "gpt-4o": CHAT_COMPLETIONS_CAPABILITIES,
+  "gpt-4o-mini": CHAT_COMPLETIONS_CAPABILITIES,
+  "gpt-4-turbo": CHAT_COMPLETIONS_CAPABILITIES,
+  "gpt-4": CHAT_COMPLETIONS_CAPABILITIES,
+  "claude-3-5-sonnet-20241022": CHAT_COMPLETIONS_CAPABILITIES,
+  "claude-3-5-haiku-20241022": CHAT_COMPLETIONS_CAPABILITIES,
+  "claude-3-opus-20240229": CHAT_COMPLETIONS_CAPABILITIES,
+  o1: {
+    ...CHAT_COMPLETIONS_CAPABILITIES,
+    parameters: {
+      ...CHAT_COMPLETIONS_CAPABILITIES.parameters,
+      maxTokensField: "max_completion_tokens",
+      temperatureMode: "fixed_one"
+    }
+  },
+  "o1-mini": {
+    ...CHAT_COMPLETIONS_CAPABILITIES,
+    parameters: {
+      ...CHAT_COMPLETIONS_CAPABILITIES.parameters,
+      maxTokensField: "max_completion_tokens",
+      temperatureMode: "fixed_one"
+    }
+  },
+  "o1-preview": {
+    ...CHAT_COMPLETIONS_CAPABILITIES,
+    parameters: {
+      ...CHAT_COMPLETIONS_CAPABILITIES.parameters,
+      maxTokensField: "max_completion_tokens",
+      temperatureMode: "fixed_one"
+    }
+  }
+};
+function inferModelCapabilities(modelName) {
+  if (!modelName) return null;
+  const lowerName = modelName.toLowerCase();
+  if (lowerName.includes("gpt-5") || lowerName.includes("gpt5")) {
+    return GPT5_CAPABILITIES;
+  }
+  if (lowerName.includes("gpt-6") || lowerName.includes("gpt6")) {
+    return {
+      ...GPT5_CAPABILITIES,
+      streaming: { supported: true, includesUsage: true }
+    };
+  }
+  if (lowerName.includes("glm-5") || lowerName.includes("glm5")) {
+    return {
+      ...CHAT_COMPLETIONS_CAPABILITIES,
+      toolCalling: {
+        ...CHAT_COMPLETIONS_CAPABILITIES.toolCalling,
+        supportsAllowedTools: false
+      }
+    };
+  }
+  if (lowerName.startsWith("o1") || lowerName.includes("o1-")) {
+    return {
+      ...CHAT_COMPLETIONS_CAPABILITIES,
+      parameters: {
+        ...CHAT_COMPLETIONS_CAPABILITIES.parameters,
+        maxTokensField: "max_completion_tokens",
+        temperatureMode: "fixed_one"
+      }
+    };
+  }
+  return null;
+}
+var capabilityCache = /* @__PURE__ */ new Map();
+function getModelCapabilities(modelName) {
+  if (capabilityCache.has(modelName)) {
+    return capabilityCache.get(modelName);
+  }
+  if (MODEL_CAPABILITIES_REGISTRY[modelName]) {
+    const capabilities = MODEL_CAPABILITIES_REGISTRY[modelName];
+    capabilityCache.set(modelName, capabilities);
+    return capabilities;
+  }
+  const inferred = inferModelCapabilities(modelName);
+  if (inferred) {
+    capabilityCache.set(modelName, inferred);
+    return inferred;
+  }
+  const defaultCapabilities = CHAT_COMPLETIONS_CAPABILITIES;
+  capabilityCache.set(modelName, defaultCapabilities);
+  return defaultCapabilities;
+}
+
+// src/services/ai/policyDispatch/policyConfigLoader.ts
+import { existsSync as existsSync15, readFileSync as readFileSync11 } from "fs";
+import { join as join12, resolve as resolve9 } from "path";
+
+// src/services/ai/policyDispatch/policyConfigSchema.ts
+import { z as z11 } from "zod";
+var policyConfigSchema = z11.object({
+  version: z11.string().min(1),
+  defaults: z11.object({
+    reasoningPolicy: z11.enum([
+      "preserve_reasoning_blocks",
+      "map_to_provider_options",
+      "flatten_to_text_fallback"
+    ]).optional(),
+    normalizeProviderContent: z11.boolean().optional(),
+    trimCrossModelMetadata: z11.boolean().optional()
+  }).optional(),
+  overrides: z11.array(
+    z11.object({
+      model: z11.string().min(1).optional(),
+      modelFamily: z11.string().min(1).optional(),
+      provider: z11.string().min(1).optional(),
+      scenario: z11.enum(["query", "auto_compact", "other"]).optional(),
+      reasoningPolicy: z11.enum([
+        "preserve_reasoning_blocks",
+        "map_to_provider_options",
+        "flatten_to_text_fallback"
+      ]).optional(),
+      normalizeProviderContent: z11.boolean().optional(),
+      trimCrossModelMetadata: z11.boolean().optional()
+    })
+  ).optional().default([])
+});
+
+// src/services/ai/policyDispatch/policyConfigLoader.ts
+function getModelFamily(model) {
+  const normalized = String(model || "").toLowerCase();
+  if (normalized.startsWith("gpt-5")) return "gpt-5";
+  if (normalized.startsWith("gpt-4o")) return "gpt-4o";
+  if (!normalized) return "unknown";
+  const segments = normalized.split("-");
+  return segments.length >= 2 ? `${segments[0]}-${segments[1]}` : normalized;
+}
+function getDefaultPolicyConfigPath() {
+  return resolve9(join12(process.cwd(), "config/auto-compact-policy.config.json"));
+}
+function loadAutoCompactPolicyConfig(options) {
+  const filePath = resolve9(options?.filePath ?? getDefaultPolicyConfigPath());
+  if (!existsSync15(filePath)) return null;
+  try {
+    const raw = readFileSync11(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return policyConfigSchema.parse(parsed);
+  } catch {
+    return null;
+  }
+}
+function matches(input, override) {
+  if (override.model && override.model !== input.model) return false;
+  if (override.modelFamily && override.modelFamily !== getModelFamily(input.model))
+    return false;
+  if (override.provider && override.provider !== input.provider) return false;
+  if (override.scenario && override.scenario !== input.source) return false;
+  return true;
+}
+function selectPolicyOverride(input, config2) {
+  const matched = [...config2.overrides ?? []].reverse().find((item) => matches(input, item));
+  if (matched) {
+    return {
+      reasoningPolicy: matched.reasoningPolicy,
+      normalizeProviderContent: matched.normalizeProviderContent,
+      trimCrossModelMetadata: matched.trimCrossModelMetadata
+    };
+  }
+  if (config2.defaults) {
+    return {
+      reasoningPolicy: config2.defaults.reasoningPolicy,
+      normalizeProviderContent: config2.defaults.normalizeProviderContent,
+      trimCrossModelMetadata: config2.defaults.trimCrossModelMetadata
+    };
+  }
+  return null;
+}
+
+// src/services/ai/policyDispatch/index.ts
+function resolveDefaultReasoningPolicy(model) {
+  const capabilities = getModelCapabilities(model);
+  if (capabilities.apiArchitecture.primary === "responses_api") {
+    return "map_to_provider_options";
+  }
+  return "preserve_reasoning_blocks";
+}
+function resolveDefaultNormalizeProviderContent(model) {
+  const capabilities = getModelCapabilities(model);
+  return capabilities.apiArchitecture.primary === "responses_api";
+}
+function resolveDefaultTrimCrossModelMetadata(model) {
+  const capabilities = getModelCapabilities(model);
+  return capabilities.apiArchitecture.primary === "responses_api";
+}
+function resolveCapabilityDefaults(model) {
+  return {
+    reasoningPolicy: resolveDefaultReasoningPolicy(model),
+    normalizeProviderContent: resolveDefaultNormalizeProviderContent(model),
+    trimCrossModelMetadata: resolveDefaultTrimCrossModelMetadata(model)
+  };
+}
+function resolveModelResponsePolicy(input) {
+  const defaults = resolveCapabilityDefaults(input.model);
+  const hasOverride = input.reasoningPolicy !== void 0 || input.normalizeProviderContent !== void 0 || input.trimCrossModelMetadata !== void 0;
+  if (hasOverride) {
+    return {
+      reasoningPolicy: input.reasoningPolicy ?? defaults.reasoningPolicy,
+      normalizeProviderContent: input.normalizeProviderContent ?? defaults.normalizeProviderContent,
+      trimCrossModelMetadata: input.trimCrossModelMetadata ?? defaults.trimCrossModelMetadata,
+      policySource: "context_override"
+    };
+  }
+  const config2 = loadAutoCompactPolicyConfig();
+  const selection = config2 ? selectPolicyOverride(input, config2) : null;
+  if (selection && (selection.reasoningPolicy !== void 0 || selection.normalizeProviderContent !== void 0 || selection.trimCrossModelMetadata !== void 0)) {
+    return {
+      reasoningPolicy: selection.reasoningPolicy ?? defaults.reasoningPolicy,
+      normalizeProviderContent: selection.normalizeProviderContent ?? defaults.normalizeProviderContent,
+      trimCrossModelMetadata: selection.trimCrossModelMetadata ?? defaults.trimCrossModelMetadata,
+      policySource: "policy_config"
+    };
+  }
+  return {
+    reasoningPolicy: defaults.reasoningPolicy,
+    normalizeProviderContent: defaults.normalizeProviderContent,
+    trimCrossModelMetadata: defaults.trimCrossModelMetadata,
+    policySource: "model_capabilities"
+  };
+}
+
+// src/services/ai/streamTyped/partTypes.ts
+import { z as z12 } from "zod";
+var SOURCE_VALUES = ["auto_compact"];
+var TOOL_STATUS_VALUES = ["pending", "running", "completed", "failed", "interrupted"];
+var textPayloadSchema = z12.object({
+  text: z12.string().min(1)
+});
+var reasoningPayloadSchema = z12.object({
+  text: z12.string().min(1)
+});
+var toolPayloadSchema = z12.object({
+  toolName: z12.string().min(1),
+  toolCallId: z12.string().min(1),
+  status: z12.enum(TOOL_STATUS_VALUES),
+  outputText: z12.string().optional()
+});
+var streamTypedPartBaseSchema = z12.object({
+  id: z12.string().min(1),
+  requestId: z12.string().min(1),
+  source: z12.enum(SOURCE_VALUES),
+  timestamp: z12.number().int().positive()
+});
+var streamTypedPartSchema = z12.discriminatedUnion("partType", [
+  streamTypedPartBaseSchema.extend({
+    partType: z12.literal("text"),
+    payload: textPayloadSchema
+  }),
+  streamTypedPartBaseSchema.extend({
+    partType: z12.literal("reasoning"),
+    payload: reasoningPayloadSchema
+  }),
+  streamTypedPartBaseSchema.extend({
+    partType: z12.literal("tool"),
+    payload: toolPayloadSchema
+  })
+]);
+function createId() {
+  return `stp_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function createBase(input) {
+  return {
+    id: createId(),
+    requestId: input.requestId,
+    source: "auto_compact",
+    timestamp: Date.now()
+  };
+}
+function createTextPart(input) {
+  return streamTypedPartSchema.parse({
+    ...createBase(input),
+    partType: "text",
+    payload: {
+      text: input.text.trim()
+    }
+  });
+}
+function createReasoningPart(input) {
+  return streamTypedPartSchema.parse({
+    ...createBase(input),
+    partType: "reasoning",
+    payload: {
+      text: input.text.trim()
+    }
+  });
+}
+function createToolPart(input) {
+  return streamTypedPartSchema.parse({
+    ...createBase(input),
+    partType: "tool",
+    payload: {
+      toolName: input.toolName,
+      toolCallId: input.toolCallId,
+      status: input.status,
+      ...input.outputText ? { outputText: input.outputText } : {}
+    }
+  });
+}
+
+// src/services/ai/streamTyped/eventAssembler.ts
+function createAssemblerState(requestId) {
+  return {
+    requestId,
+    parts: [],
+    textBuffer: {},
+    reasoningBuffer: {},
+    toolMap: {}
+  };
+}
+function onTextStart(event, state) {
+  state.textBuffer[event.textId] = "";
+}
+function onTextDelta(event, state) {
+  const current = state.textBuffer[event.textId] ?? "";
+  state.textBuffer[event.textId] = `${current}${event.text}`;
+}
+function onTextEnd(event, state) {
+  const text = String(state.textBuffer[event.textId] ?? "").trim();
+  delete state.textBuffer[event.textId];
+  if (!text) return;
+  state.parts.push(
+    createTextPart({
+      requestId: state.requestId,
+      text
+    })
+  );
+}
+function onReasoningStart(event, state) {
+  state.reasoningBuffer[event.reasoningId] = "";
+}
+function onReasoningDelta(event, state) {
+  const current = state.reasoningBuffer[event.reasoningId] ?? "";
+  state.reasoningBuffer[event.reasoningId] = `${current}${event.text}`;
+}
+function onReasoningEnd(event, state) {
+  const text = String(state.reasoningBuffer[event.reasoningId] ?? "").trim();
+  delete state.reasoningBuffer[event.reasoningId];
+  if (!text) return;
+  state.parts.push(
+    createReasoningPart({
+      requestId: state.requestId,
+      text
+    })
+  );
+}
+function onToolCall(event, state) {
+  state.toolMap[event.toolCallId] = { toolName: event.toolName };
+}
+function onToolResult(event, state) {
+  const toolName = state.toolMap[event.toolCallId]?.toolName ?? "unknown";
+  state.parts.push(
+    createToolPart({
+      requestId: state.requestId,
+      toolName,
+      toolCallId: event.toolCallId,
+      status: event.status,
+      outputText: event.outputText
+    })
+  );
+  delete state.toolMap[event.toolCallId];
+}
+function flushTypedParts(state) {
+  const parts = state.parts.slice();
+  state.parts.length = 0;
+  return parts;
+}
+
+// src/services/ai/streamTyped/partStore.ts
+import { appendFileSync, existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync12 } from "fs";
+import { dirname as dirname9 } from "path";
+function getStreamTypedOutputFilePath() {
+  return resolveXdgCachePath("telemetry/stream-typed-parts.jsonl");
+}
+function validateTypedPartRecord(record) {
+  return streamTypedPartSchema.safeParse(record).success;
+}
+function readAllValidParts(outputFilePath) {
+  if (!existsSync16(outputFilePath)) return [];
+  const raw = readFileSync12(outputFilePath, "utf8");
+  const lines = raw.split("\n").map((line) => line.trim()).filter(Boolean);
+  const parts = [];
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      if (!validateTypedPartRecord(parsed)) continue;
+      parts.push(parsed);
+    } catch {
+      continue;
+    }
+  }
+  return parts;
+}
+function appendTypedParts(options) {
+  if (!Array.isArray(options.parts) || options.parts.length === 0) {
+    return { appended: 0 };
+  }
+  const outputFilePath = options.outputFilePath ?? getStreamTypedOutputFilePath();
+  if (!existsSync16(dirname9(outputFilePath))) {
+    mkdirSync7(dirname9(outputFilePath), { recursive: true });
+  }
+  const existingIds = new Set(readAllValidParts(outputFilePath).map((item) => item.id));
+  const toAppend = options.parts.filter(
+    (item) => validateTypedPartRecord(item) && !existingIds.has(item.id)
+  );
+  if (toAppend.length === 0) return { appended: 0 };
+  appendFileSync(
+    outputFilePath,
+    `${toAppend.map((item) => JSON.stringify(item)).join("\n")}
+`
+  );
+  return { appended: toAppend.length };
+}
+
+// src/services/ai/streamTyped/index.ts
+var streamTypedBuffer = /* @__PURE__ */ new Map();
+function emitTypedPart(event) {
+  const requestId = String(event.requestId || "").trim();
+  if (!requestId) return;
+  const current = streamTypedBuffer.get(requestId) ?? [];
+  current.push(event.part);
+  streamTypedBuffer.set(requestId, current);
+}
+function flushTypedPartBuffer(options) {
+  const requestId = String(options.requestId || "").trim();
+  if (!requestId) return { appended: 0 };
+  const parts = streamTypedBuffer.get(requestId) ?? [];
+  streamTypedBuffer.delete(requestId);
+  return appendTypedParts({
+    outputFilePath: options.outputFilePath,
+    parts
+  });
+}
+
+// src/services/ai/streamTyped/replay.ts
+function toNonEmptyText(value) {
+  const text = String(value ?? "").trim();
+  return text.length > 0 ? text : null;
+}
+function buildSummaryFromTypedParts(parts) {
+  const textBlocks = [];
+  let reasoningPartCount = 0;
+  for (const part of parts) {
+    if (!part || typeof part !== "object") continue;
+    if (part.partType === "reasoning") {
+      reasoningPartCount += 1;
+      continue;
+    }
+    if (part.partType !== "text") continue;
+    const text = toNonEmptyText(part.payload?.text);
+    if (text) textBlocks.push(text);
+  }
+  if (textBlocks.length === 0) {
+    return {
+      isComplete: false,
+      summaryText: null,
+      reason: "no_text_parts",
+      textPartCount: 0,
+      reasoningPartCount
+    };
+  }
+  return {
+    isComplete: true,
+    summaryText: textBlocks.join("\n"),
+    reason: "typed_text_joined",
+    textPartCount: textBlocks.length,
+    reasoningPartCount
+  };
+}
+function resolveTypedReplayResult(input) {
+  if (!input.enabled) {
+    return {
+      isComplete: false,
+      summaryText: null,
+      reason: "typed_read_disabled",
+      textPartCount: 0,
+      reasoningPartCount: 0
+    };
+  }
+  return buildSummaryFromTypedParts(input.parts ?? []);
+}
+
+// src/utils/session/autoCompactFailurePolicy.ts
+var AUTO_COMPACT_CLASSIFICATION_VERSION = "c1-v1";
+function getFailureStatus(error) {
+  const status = error?.status;
+  if (typeof status === "number") return status;
+  return void 0;
+}
+function classifyAutoCompactFailure(error) {
+  const message = error instanceof Error ? error.message : String(error ?? "Unknown error");
+  const status = getFailureStatus(error);
+  const lower = message.toLowerCase();
+  if (lower.includes("did not contain valid text content") || lower.includes("invalid content shape")) {
+    return { failureType: "invalid_content_shape", message, status };
+  }
+  if (typeof status === "number" && status >= 500 || /\bhttp\s+5\d\d\b/i.test(message)) {
+    return { failureType: "provider_5xx", message, status };
+  }
+  if (lower.includes("not configured") || lower.includes("misconfigured") || lower.includes("fallback failed")) {
+    return { failureType: "model_misconfigured", message, status };
+  }
+  return { failureType: "unknown", message, status };
+}
+function decideAutoCompactRecovery(params) {
+  const hasNextAttempt = params.attempt < params.maxAttempts;
+  if (!hasNextAttempt) return "abort";
+  if (params.failureType === "invalid_content_shape") return "retry_reextract";
+  if (params.failureType === "provider_5xx") return "retry_backoff";
+  if (params.failureType === "model_misconfigured" && params.activeModelPointer === "compact" && params.hasMainModelProfile) {
+    return "fallback_main";
+  }
+  return "abort";
+}
+function getStatusBucket(status) {
+  if (typeof status !== "number") return "none";
+  if (status >= 500 && status <= 599) return "5xx";
+  if (status >= 400 && status <= 499) return "4xx";
+  return "other";
+}
+function buildAutoCompactAggregationFields(params) {
+  const statusBucket = getStatusBucket(params.status);
+  const modelPointer = params.modelPointer ?? "unknown";
+  return {
+    source: "auto_compact",
+    classificationVersion: AUTO_COMPACT_CLASSIFICATION_VERSION,
+    failureType: params.failureType,
+    status: params.status,
+    statusBucket,
+    modelPointer,
+    aggregateKey: `auto_compact:${params.failureType}:${modelPointer}:${statusBucket}`
+  };
+}
+
 // src/utils/session/autoCompactCore.ts
 async function getMainConversationContextLimit() {
   try {
@@ -25977,6 +26766,10 @@ var CONVERSATION_SUMMARY_LIMITS = {
   maxTotalChars: 2e3
 };
 var MAX_COMPACTED_QUERY_IDS = 10;
+var AUTO_COMPACT_CHAIN_RETRY_DELAY_MS = 250;
+function wait(ms) {
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
+}
 function getMessageText(message) {
   if (!message || typeof message !== "object") return null;
   if (message.type !== "user" && message.type !== "assistant") return null;
@@ -26049,6 +26842,94 @@ function getSummaryContentDiagnostics(content) {
     value: content
   };
 }
+function extractToolResultText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((block) => block && typeof block === "object" && block.type === "text").map((block) => String(block.text ?? "")).join("\n");
+}
+function parseBooleanFlag(value) {
+  const raw = String(value ?? "").trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(raw)) return true;
+  if (["0", "false", "no", "off"].includes(raw)) return false;
+  return null;
+}
+function resolveTypedReadPathConfig(toolUseContext) {
+  const envValue = parseBooleanFlag(
+    process.env.PYB_AUTO_COMPACT_TYPED_READ_PATH_ENABLED
+  );
+  if (envValue !== null) {
+    return {
+      enabled: envValue,
+      source: "env"
+    };
+  }
+  if (typeof toolUseContext?.typedPathEnabled === "boolean") {
+    return {
+      enabled: toolUseContext.typedPathEnabled,
+      source: "context"
+    };
+  }
+  return {
+    enabled: false,
+    source: "default"
+  };
+}
+function normalizeSummaryForComparison(summary) {
+  return String(summary ?? "").replace(/\r\n/g, "\n").replace(/[ \t]+/g, " ").split("\n").map((line) => line.trim()).join("\n").trim();
+}
+function emitStreamTypedPartsFromContent(content, requestId) {
+  const state = createAssemblerState(requestId);
+  if (typeof content === "string") {
+    onTextStart({ textId: "text-0" }, state);
+    onTextDelta({ textId: "text-0", text: content }, state);
+    onTextEnd({ textId: "text-0" }, state);
+  } else if (Array.isArray(content)) {
+    for (let i = 0; i < content.length; i += 1) {
+      const block = content[i];
+      if (!block || typeof block !== "object") continue;
+      const type3 = String(block.type ?? "");
+      if (type3 === "text") {
+        const text = String(block.text ?? "");
+        onTextStart({ textId: `text-${i}` }, state);
+        onTextDelta({ textId: `text-${i}`, text }, state);
+        onTextEnd({ textId: `text-${i}` }, state);
+        continue;
+      }
+      if (type3 === "thinking" || type3 === "reasoning") {
+        const text = String(
+          block.thinking ?? block.reasoning ?? ""
+        );
+        onReasoningStart({ reasoningId: `reasoning-${i}` }, state);
+        onReasoningDelta({ reasoningId: `reasoning-${i}`, text }, state);
+        onReasoningEnd({ reasoningId: `reasoning-${i}` }, state);
+        continue;
+      }
+      if (type3 === "tool_use") {
+        const toolCallId = String(block.id ?? `tool-${i}`);
+        const toolName = String(block.name ?? "unknown");
+        onToolCall({ toolCallId, toolName }, state);
+        continue;
+      }
+      if (type3 === "tool_result") {
+        const toolCallId = String(block.tool_use_id ?? `tool-${i}`);
+        const outputText = extractToolResultText(block.content);
+        onToolResult(
+          {
+            toolCallId,
+            status: block.is_error ? "failed" : "completed",
+            outputText
+          },
+          state
+        );
+      }
+    }
+  }
+  const emittedParts = flushTypedParts(state);
+  for (const part of emittedParts) {
+    emitTypedPart({ requestId, part });
+  }
+  return emittedParts;
+}
 async function checkAutoCompact(messages, toolUseContext) {
   if (!await shouldAutoCompact(messages)) {
     return { messages, wasCompacted: false };
@@ -26070,14 +26951,28 @@ async function checkAutoCompact(messages, toolUseContext) {
       wasCompacted: true
     };
   } catch (error) {
-    logError(error);
-    debug.warn("AUTO_COMPACT_FAILED", {
-      error: error instanceof Error ? error.message : String(error)
+    const classified = classifyAutoCompactFailure(error);
+    const aggregation = buildAutoCompactAggregationFields({
+      failureType: classified.failureType,
+      status: classified.status,
+      modelPointer: error?.modelPointer
     });
+    const failurePayload = {
+      error: classified.message,
+      failureType: classified.failureType,
+      status: classified.status,
+      modelPointer: error?.modelPointer,
+      attempts: error?.attempts,
+      ...aggregation
+    };
+    logError(error);
+    debug.warn("AUTO_COMPACT_FAILED", failurePayload);
+    emitAutoCompactTelemetryEvent("AUTO_COMPACT_FAILED", failurePayload);
     return { messages, wasCompacted: false };
   }
 }
 async function executeAutoCompact(messages, toolUseContext, options) {
+  const typedRequestId = `auto_compact_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
   const previousSummary = findLatestAutoCompactSummary(messages);
   const summaryRequestContent = previousSummary ? `We already have an existing conversation summary:
 
@@ -26113,30 +27008,201 @@ ${COMPRESSION_PROMPT2}` : COMPRESSION_PROMPT2;
       mainResolution.error || "Compression fallback failed: model pointer 'main' is not configured."
     );
   }
-  const summaryResponse = await queryLLM(
-    normalizeMessagesForAPI([...messagesForSummary, summaryRequest]),
-    [
-      "You are a helpful AI assistant tasked with creating comprehensive conversation summaries that preserve all essential context for continuing development work."
-    ],
-    0,
-    [],
-    toolUseContext.abortController.signal,
-    {
-      safeMode: false,
-      model: compressionModelPointer,
-      prependCLISysprompt: true
+  let summaryResponse = null;
+  let attempts = 0;
+  let activeModelPointer = compressionModelPointer;
+  const typedPath = resolveTypedReadPathConfig(toolUseContext);
+  while (attempts < 2) {
+    attempts += 1;
+    try {
+      const summaryCandidate = await queryLLM(
+        normalizeMessagesForAPI([...messagesForSummary, summaryRequest]),
+        [
+          "You are a helpful AI assistant tasked with creating comprehensive conversation summaries that preserve all essential context for continuing development work."
+        ],
+        0,
+        [],
+        toolUseContext.abortController.signal,
+        {
+          safeMode: false,
+          model: activeModelPointer,
+          prependCLISysprompt: true,
+          firstMode: toolUseContext?.firstMode
+        }
+      );
+      const content = summaryCandidate.message.content;
+      const activeModelName = activeModelPointer === "compact" ? compactResolution.success && compactResolution.profile ? compactResolution.profile.name : "compact" : mainResolution.success && mainResolution.profile ? mainResolution.profile.name : "main";
+      const resolvedPolicy = resolveModelResponsePolicy({
+        source: "auto_compact",
+        model: activeModelName,
+        provider: "openai"
+      });
+      const canonicalResult = normalizeModelResponseContent(content, {
+        source: "auto_compact",
+        model: activeModelName,
+        provider: "openai",
+        reasoningPolicy: resolvedPolicy.reasoningPolicy,
+        policySource: resolvedPolicy.policySource
+      });
+      let emittedTypedParts = [];
+      try {
+        emittedTypedParts = emitStreamTypedPartsFromContent(content, typedRequestId);
+      } catch {
+      }
+      const typedReplay = resolveTypedReplayResult({
+        enabled: typedPath.enabled,
+        parts: emittedTypedParts
+      });
+      const canonicalSummary = canonicalResult.summaryText;
+      let summary = canonicalSummary;
+      if (typedPath.enabled && typedReplay.isComplete && typedReplay.summaryText) {
+        summary = typedReplay.summaryText;
+        const typedAppliedPayload = {
+          mode: "typed",
+          pathSource: typedPath.source,
+          reason: typedReplay.reason,
+          textPartCount: typedReplay.textPartCount,
+          reasoningPartCount: typedReplay.reasoningPartCount
+        };
+        debug.warn("AUTO_COMPACT_TYPED_PATH_APPLIED", typedAppliedPayload);
+        emitAutoCompactTelemetryEvent(
+          "AUTO_COMPACT_TYPED_PATH_APPLIED",
+          typedAppliedPayload
+        );
+        if (normalizeSummaryForComparison(canonicalSummary) !== normalizeSummaryForComparison(summary)) {
+          const divergencePayload = {
+            canonicalLength: String(canonicalSummary ?? "").length,
+            typedLength: String(summary ?? "").length
+          };
+          debug.warn(
+            "AUTO_COMPACT_TYPED_SUMMARY_DIVERGENCE",
+            divergencePayload
+          );
+          emitAutoCompactTelemetryEvent(
+            "AUTO_COMPACT_TYPED_SUMMARY_DIVERGENCE",
+            divergencePayload
+          );
+        }
+      } else if (typedPath.enabled) {
+        const typedAppliedPayload = {
+          mode: "canonical_fallback",
+          pathSource: typedPath.source,
+          reason: typedReplay.reason,
+          textPartCount: typedReplay.textPartCount,
+          reasoningPartCount: typedReplay.reasoningPartCount
+        };
+        debug.warn("AUTO_COMPACT_TYPED_PATH_APPLIED", typedAppliedPayload);
+        emitAutoCompactTelemetryEvent(
+          "AUTO_COMPACT_TYPED_PATH_APPLIED",
+          typedAppliedPayload
+        );
+      } else {
+        const typedAppliedPayload = {
+          mode: "canonical_disabled",
+          pathSource: typedPath.source
+        };
+        debug.warn("AUTO_COMPACT_TYPED_PATH_APPLIED", typedAppliedPayload);
+        emitAutoCompactTelemetryEvent(
+          "AUTO_COMPACT_TYPED_PATH_APPLIED",
+          typedAppliedPayload
+        );
+      }
+      if (!summary) {
+        debug.warn("AUTO_COMPACT_SUMMARY_CONTENT_INVALID", {
+          model: activeModelPointer,
+          diagnostics: getSummaryContentDiagnostics(content),
+          canonicalDiagnostics: {
+            textBlockCount: canonicalResult.textBlocks.length,
+            reasoningBlockCount: canonicalResult.reasoningBlocks.length,
+            blockTypes: canonicalResult.blockTypes,
+            failureType: canonicalResult.failureType
+          },
+          attempt: attempts
+        });
+        throw new Error(
+          "Failed to generate conversation summary - response did not contain valid text content"
+        );
+      }
+      summaryResponse = summaryCandidate;
+      break;
+    } catch (error) {
+      const classified = classifyAutoCompactFailure(error);
+      const recoveryAction = decideAutoCompactRecovery({
+        failureType: classified.failureType,
+        attempt: attempts,
+        maxAttempts: 2,
+        activeModelPointer,
+        hasMainModelProfile: Boolean(mainResolution.success && mainResolution.profile)
+      });
+      if (recoveryAction === "retry_reextract") {
+        const aggregation = buildAutoCompactAggregationFields({
+          failureType: classified.failureType,
+          status: classified.status,
+          modelPointer: activeModelPointer
+        });
+        const retryPayload = {
+          failureType: classified.failureType,
+          attempt: attempts,
+          strategy: "reextract_once",
+          ...aggregation
+        };
+        debug.warn("AUTO_COMPACT_RETRY", retryPayload);
+        emitAutoCompactTelemetryEvent("AUTO_COMPACT_RETRY", retryPayload);
+        continue;
+      }
+      if (recoveryAction === "retry_backoff") {
+        const aggregation = buildAutoCompactAggregationFields({
+          failureType: classified.failureType,
+          status: classified.status,
+          modelPointer: activeModelPointer
+        });
+        const retryPayload = {
+          failureType: classified.failureType,
+          attempt: attempts,
+          status: classified.status,
+          strategy: "retry_with_backoff",
+          ...aggregation
+        };
+        debug.warn("AUTO_COMPACT_RETRY", retryPayload);
+        emitAutoCompactTelemetryEvent("AUTO_COMPACT_RETRY", retryPayload);
+        await wait(AUTO_COMPACT_CHAIN_RETRY_DELAY_MS);
+        continue;
+      }
+      if (recoveryAction === "fallback_main") {
+        activeModelPointer = "main";
+        if (!compressionNotice) {
+          compressionNotice = "Compression fallback applied: compact model unavailable, switched to 'main'.";
+        }
+        const aggregation = buildAutoCompactAggregationFields({
+          failureType: classified.failureType,
+          status: classified.status,
+          modelPointer: "compact"
+        });
+        const fallbackPayload = {
+          failureType: classified.failureType,
+          attempt: attempts,
+          fromModel: "compact",
+          toModel: "main",
+          ...aggregation
+        };
+        debug.warn("AUTO_COMPACT_FALLBACK", fallbackPayload);
+        emitAutoCompactTelemetryEvent("AUTO_COMPACT_FALLBACK", fallbackPayload);
+        continue;
+      }
+      const toThrow = error instanceof Error ? error : new Error(String(error));
+      toThrow.failureType = classified.failureType;
+      toThrow.status = classified.status;
+      toThrow.attempts = attempts;
+      toThrow.modelPointer = activeModelPointer;
+      throw toThrow;
     }
-  );
-  const content = summaryResponse.message.content;
-  const summary = typeof content === "string" ? content : content.length > 0 && content[0]?.type === "text" ? content[0].text : null;
-  if (!summary) {
-    debug.warn("AUTO_COMPACT_SUMMARY_CONTENT_INVALID", {
-      model: compressionModelPointer,
-      diagnostics: getSummaryContentDiagnostics(content)
-    });
-    throw new Error(
-      "Failed to generate conversation summary - response did not contain valid text content"
-    );
+  }
+  if (!summaryResponse) {
+    const exhausted = new Error("Auto compact retries exhausted");
+    exhausted.failureType = "unknown";
+    exhausted.attempts = attempts;
+    exhausted.modelPointer = activeModelPointer;
+    throw exhausted;
   }
   summaryResponse.message.usage = {
     input_tokens: 0,
@@ -26147,7 +27213,7 @@ ${COMPRESSION_PROMPT2}` : COMPRESSION_PROMPT2;
   const recoveredFiles = await selectAndReadFiles();
   const compactedMessages = [
     createUserMessage(
-      compressionNotice ? `Context automatically compressed due to token limit. ${compressionNotice} Using '${compressionModelPointer}' for compression.` : `Context automatically compressed due to token limit. Using '${compressionModelPointer}' for compression.`
+      compressionNotice ? `Context automatically compressed due to token limit. ${compressionNotice} Using '${activeModelPointer}' for compression.` : `Context automatically compressed due to token limit. Using '${activeModelPointer}' for compression.`
     ),
     summaryResponse
   ];
@@ -26190,9 +27256,40 @@ ${contentWithLines}
   getContext.cache.clear?.();
   getCodeStyle.cache.clear?.();
   resetFileFreshnessSession();
+  try {
+    flushTypedPartBuffer({ requestId: typedRequestId });
+  } catch {
+  }
   return compactedMessages;
 }
 
+// src/services/telemetry/autoCompactTelemetryPersistence.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync17, mkdirSync as mkdirSync8 } from "fs";
+import { dirname as dirname10 } from "path";
+function getAutoCompactTelemetryOutputFilePath() {
+  return resolveXdgCachePath("telemetry/auto-compact-metrics.jsonl");
+}
+function flushAutoCompactTelemetrySnapshot(options = {}) {
+  const snapshot = getAutoCompactMetricsSnapshot();
+  if (snapshot.eventCount <= 0) return null;
+  const outputFilePath = options.outputFilePath ?? getAutoCompactTelemetryOutputFilePath();
+  const record = {
+    timestamp: Date.now(),
+    requestId: options.requestId,
+    agentId: options.agentId ?? "main",
+    eventCount: snapshot.eventCount,
+    metrics: snapshot.metrics
+  };
+  if (!existsSync17(dirname10(outputFilePath))) {
+    mkdirSync8(dirname10(outputFilePath), { recursive: true });
+  }
+  appendFileSync2(outputFilePath, JSON.stringify(record) + "\n");
+  if (options.resetAfterFlush !== false) {
+    resetAutoCompactTelemetry();
+  }
+  return record;
+}
+
 // src/app/query.ts
 function isToolUseLikeBlock(block) {
   return block && typeof block === "object" && (block.type === "tool_use" || block.type === "server_tool_use" || block.type === "mcp_tool_use");
@@ -26419,8 +27516,8 @@ var ToolUseQueue = class {
       }
       if (this.hasExecutingTools() && !this.hasCompletedResults() && !this.hasPendingProgress()) {
         const promises = this.tools.filter((t) => t.status === "executing" && t.promise).map((t) => t.promise);
-        const progressPromise = new Promise((resolve11) => {
-          this.progressAvailableResolve = resolve11;
+        const progressPromise = new Promise((resolve12) => {
+          this.progressAvailableResolve = resolve12;
         });
         if (promises.length > 0) {
           await Promise.race([...promises, progressPromise]);
@@ -26482,6 +27579,7 @@ async function* queryCore(messages, systemPrompt, context, canUseTool, toolUseCo
   setRequestStatus({ kind: "thinking" });
   try {
     let getAssistantResponse = function() {
+      const modelPointer = toolUseContext.options.model || "main";
       return queryLLM(
         normalizeMessagesForAPI(messages),
         fullSystemPrompt,
@@ -26490,7 +27588,7 @@ async function* queryCore(messages, systemPrompt, context, canUseTool, toolUseCo
         toolUseContext.abortController.signal,
         {
           safeMode: toolUseContext.options.safeMode ?? false,
-          model: toolUseContext.options.model || "main",
+          model: modelPointer,
           prependCLISysprompt: true,
           toolUseContext
         }
@@ -26771,6 +27869,11 @@ async function* queryCore(messages, systemPrompt, context, canUseTool, toolUseCo
       throw error;
     }
   } finally {
+    const currentRequest = getCurrentRequest();
+    flushAutoCompactTelemetrySnapshot({
+      requestId: currentRequest?.id,
+      agentId: toolUseContext?.agentId
+    });
     setRequestStatus({ kind: "idle" });
   }
 }
@@ -27404,7 +28507,7 @@ function BinaryFeedbackView({
 function BinaryFeedback({
   m1,
   m2,
-  resolve: resolve11,
+  resolve: resolve12,
   debug: debug2,
   erroredToolUseIDs,
   inProgressToolUseIDs,
@@ -27416,9 +28519,9 @@ function BinaryFeedback({
   const onChoose = useCallback15(
     (choice) => {
       logBinaryFeedbackEvent(m1, m2, choice);
-      resolve11(getBinaryFeedbackResultForChoice(m1, m2, choice));
+      resolve12(getBinaryFeedbackResultForChoice(m1, m2, choice));
     },
-    [m1, m2, resolve11]
+    [m1, m2, resolve12]
   );
   useNotifyAfterTimeout(
     `${PRODUCT_NAME} needs your input on a response comparison`
@@ -28232,7 +29335,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 join13 } from "path";
+import { join as join14 } from "path";
 import { spawn as spawn2 } from "child_process";
 
 // src/commands/agents/tooling.ts
@@ -28287,19 +29390,19 @@ async function getAvailableTools() {
 
 // src/commands/agents/storage.ts
 import {
-  existsSync as existsSync15,
-  mkdirSync as mkdirSync7,
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync9,
   renameSync as renameSync3,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync6
 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } 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-VAN6WS52.js");
+  const { queryModel } = await import("./llm-WAAV3MBX.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:
@@ -28483,26 +29586,26 @@ var LEGACY_FOLDER = ".claude";
 var AGENTS_DIR = "agents";
 function getAgentDirectory(location) {
   if (location === "user") {
-    return join12(homedir8(), PRIMARY_FOLDER, AGENTS_DIR);
+    return join13(homedir8(), PRIMARY_FOLDER, AGENTS_DIR);
   }
-  return join12(getCwd(), PRIMARY_FOLDER, AGENTS_DIR);
+  return join13(getCwd(), PRIMARY_FOLDER, AGENTS_DIR);
 }
 function getLegacyAgentDirectory(location) {
   if (location === "user") {
-    return join12(homedir8(), LEGACY_FOLDER, AGENTS_DIR);
+    return join13(homedir8(), LEGACY_FOLDER, AGENTS_DIR);
   }
-  return join12(getCwd(), LEGACY_FOLDER, AGENTS_DIR);
+  return join13(getCwd(), LEGACY_FOLDER, AGENTS_DIR);
 }
 function getPrimaryAgentFilePath(location, agentType) {
-  return join12(getAgentDirectory(location), `${agentType}.md`);
+  return join13(getAgentDirectory(location), `${agentType}.md`);
 }
 function getLegacyAgentFilePath(location, agentType) {
-  return join12(getLegacyAgentDirectory(location), `${agentType}.md`);
+  return join13(getLegacyAgentDirectory(location), `${agentType}.md`);
 }
 function ensureDirectoryExists(location) {
   const dir = getAgentDirectory(location);
-  if (!existsSync15(dir)) {
-    mkdirSync7(dir, { recursive: true });
+  if (!existsSync18(dir)) {
+    mkdirSync9(dir, { recursive: true });
   }
   return dir;
 }
@@ -28510,7 +29613,7 @@ async function saveAgent(location, agentType, description3, tools, systemPrompt,
   ensureDirectoryExists(location);
   const filePath = getPrimaryAgentFilePath(location, agentType);
   const legacyPath = getLegacyAgentFilePath(location, agentType);
-  if (throwIfExists && (existsSync15(filePath) || existsSync15(legacyPath))) {
+  if (throwIfExists && (existsSync18(filePath) || existsSync18(legacyPath))) {
     throw new Error(`Agent file already exists: ${filePath}`);
   }
   const tempFile = `${filePath}.tmp.${Date.now()}.${Math.random().toString(36).substr(2, 9)}`;
@@ -28525,7 +29628,7 @@ async function saveAgent(location, agentType, description3, tools, systemPrompt,
   );
   try {
     writeFileSync6(tempFile, content, { encoding: "utf-8", flag: "wx" });
-    if (throwIfExists && (existsSync15(filePath) || existsSync15(legacyPath))) {
+    if (throwIfExists && (existsSync18(filePath) || existsSync18(legacyPath))) {
       try {
         unlinkSync2(tempFile);
       } catch {
@@ -28535,7 +29638,7 @@ async function saveAgent(location, agentType, description3, tools, systemPrompt,
     renameSync3(tempFile, filePath);
   } catch (error) {
     try {
-      if (existsSync15(tempFile)) {
+      if (existsSync18(tempFile)) {
         unlinkSync2(tempFile);
       }
     } catch (cleanupError) {
@@ -28563,7 +29666,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 = existsSync15(primaryPath) ? primaryPath : existsSync15(legacyPath) ? legacyPath : primaryPath;
+  const filePath = existsSync18(primaryPath) ? primaryPath : existsSync18(legacyPath) ? legacyPath : primaryPath;
   ensureDirectoryExists(location);
   writeFileSync6(filePath, content, { encoding: "utf-8", flag: "w" });
 }
@@ -28574,10 +29677,10 @@ async function deleteAgent(agent) {
   const location = agent.location;
   const primaryPath = getPrimaryAgentFilePath(location, agent.agentType);
   const legacyPath = getLegacyAgentFilePath(location, agent.agentType);
-  if (existsSync15(primaryPath)) {
+  if (existsSync18(primaryPath)) {
     unlinkSync2(primaryPath);
   }
-  if (existsSync15(legacyPath)) {
+  if (existsSync18(legacyPath)) {
     unlinkSync2(legacyPath);
   }
 }
@@ -28596,7 +29699,7 @@ var COLOR_OPTIONS = [
   "cyan"
 ];
 function openInEditor(filePath) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const platform = process.platform;
     let command4;
     let args;
@@ -28619,7 +29722,7 @@ function openInEditor(filePath) {
     child.on("error", (err) => reject(err));
     child.on(
       "exit",
-      (code) => code === 0 ? resolve11() : reject(new Error(`Editor exited with ${code}`))
+      (code) => code === 0 ? resolve12() : reject(new Error(`Editor exited with ${code}`))
     );
   });
 }
@@ -29595,8 +30698,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 join13(".claude", "agents", file);
-    if (baseDir) return join13(baseDir, file);
+    if (props.agent.source === "projectSettings") return join14(".claude", "agents", file);
+    if (baseDir) return join14(baseDir, file);
     return props.agent.source;
   })();
   const toolsSummary = () => {
@@ -29981,8 +31084,8 @@ function getCommand(commandName, commands) {
 var TOOL_NAME_FOR_PROMPT7 = "SlashCommand";
 
 // src/tools/interaction/SlashCommandTool/SlashCommandTool.tsx
-var inputSchema12 = z11.strictObject({
-  command: z11.string().describe(
+var inputSchema12 = z13.strictObject({
+  command: z13.string().describe(
     'The slash command to execute with its arguments, e.g., "/review-pr 123"'
   )
 });
@@ -30228,7 +31331,7 @@ function parseMcpToolName2(name3) {
 // src/tools/system/KillShellTool/KillShellTool.tsx
 import { Box as Box75, Text as Text79 } from "ink";
 import React104 from "react";
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 
 // src/tools/system/KillShellTool/prompt.ts
 var TOOL_NAME_FOR_PROMPT8 = "KillShell";
@@ -30242,8 +31345,8 @@ var PROMPT7 = `
 `;
 
 // src/tools/system/KillShellTool/KillShellTool.tsx
-var inputSchema13 = z12.strictObject({
-  shell_id: z12.string().describe("The ID of the background shell to kill")
+var inputSchema13 = z14.strictObject({
+  shell_id: z14.string().describe("The ID of the background shell to kill")
 });
 var KillShellTool = {
   name: TOOL_NAME_FOR_PROMPT8,
@@ -31112,7 +32215,7 @@ var BashParser = class {
 };
 
 // src/utils/bash-parser/validator.ts
-import { resolve as resolve9 } from "path";
+import { resolve as resolve10 } from "path";
 async function validateSafety(script, cwd = process.cwd()) {
   const tree = await BashParser.parse(script);
   const root = tree.rootNode;
@@ -31163,7 +32266,7 @@ function checkCommand(node, script, cwd) {
     const targetsCritical = args.some((arg) => {
       if (arg.startsWith("-") || arg.startsWith("$")) return false;
       try {
-        const absPath = resolve9(cwd, arg).replace(/\\/g, "/");
+        const absPath = resolve10(cwd, arg).replace(/\\/g, "/");
         return criticalPaths.some((critical) => {
           const normalizedCritical = critical.endsWith("/") ? critical : critical + "/";
           if (absPath === critical || absPath === critical.replace(/\/$/, "")) return true;
@@ -31181,7 +32284,7 @@ function checkCommand(node, script, cwd) {
     const targetsRoot = args.some((arg) => {
       if (arg.startsWith("-") || arg.startsWith("$")) return false;
       try {
-        const absPath = resolve9(cwd, arg).replace(/\\/g, "/");
+        const absPath = resolve10(cwd, arg).replace(/\\/g, "/");
         return absPath === "/" || /^[a-z]:\/?$/i.test(absPath);
       } catch {
         return arg === "/" || /^[a-z]:\/?$/i.test(arg);
@@ -31225,13 +32328,13 @@ function countNewlines(text) {
   }
   return count;
 }
-var inputSchema11 = z13.strictObject({
-  command: z13.string().describe("The command to execute"),
-  cwd: z13.string().optional().describe(
+var inputSchema11 = z15.strictObject({
+  command: z15.string().describe("The command to execute"),
+  cwd: z15.string().optional().describe(
     "The directory to execute the command in. Use absolute path or path relative to the project root."
   ),
-  timeout: z13.number().optional().describe("Optional timeout in milliseconds (max 600000)"),
-  description: z13.string().optional().describe(
+  timeout: z15.number().optional().describe("Optional timeout in milliseconds (max 600000)"),
+  description: z15.string().optional().describe(
     `Clear, concise description of what this command does in 5-10 words, in active voice. Examples:
 Input: ls
 Output: List files in current directory
@@ -31245,10 +32348,10 @@ Output: Install package dependencies
 Input: mkdir foo
 Output: Create directory 'foo'`
   ),
-  run_in_background: z13.boolean().optional().describe(
+  run_in_background: z15.boolean().optional().describe(
     "Set to true to run this command in the background. Use TaskOutput to read the output later."
   ),
-  dangerouslyDisableSandbox: z13.boolean().optional().describe(
+  dangerouslyDisableSandbox: z15.boolean().optional().describe(
     "Set this to true to dangerously override sandbox mode and run commands without sandboxing."
   )
 });
@@ -31289,7 +32392,7 @@ var BashTool = {
   async validateInput({ command: command4, timeout, dangerouslyDisableSandbox, cwd }, context) {
     const trimmed = command4.trim();
     try {
-      await validateSafety(trimmed, cwd ? resolve10(getCwd(), cwd) : getCwd());
+      await validateSafety(trimmed, cwd ? resolve11(getCwd(), cwd) : getCwd());
     } catch (e) {
       return {
         result: false,
@@ -31329,7 +32432,7 @@ var BashTool = {
       };
     }
     if (cwd) {
-      const fullTargetDir = isAbsolute8(cwd) ? cwd : resolve10(getCwd(), cwd);
+      const fullTargetDir = isAbsolute8(cwd) ? cwd : resolve11(getCwd(), cwd);
       if (!isInDirectory(
         relative12(getOriginalCwd(), fullTargetDir),
         relative12(getCwd(), getOriginalCwd())
@@ -31349,7 +32452,7 @@ var BashTool = {
           continue;
         }
         const targetDir = parts[1].replace(/^['"]|['"]$/g, "");
-        const fullTargetDir = isAbsolute8(targetDir) ? targetDir : resolve10(getCwd(), targetDir);
+        const fullTargetDir = isAbsolute8(targetDir) ? targetDir : resolve11(getCwd(), targetDir);
         if (!isInDirectory(
           relative12(getOriginalCwd(), fullTargetDir),
           relative12(getCwd(), getOriginalCwd())
@@ -31460,7 +32563,7 @@ Did you mean "git ${cmdParts.slice(1).join(" ")}"?`;
     const safeMode = Boolean(context?.safeMode ?? context?.options?.safeMode);
     const userPrompt = typeof context?.options?.lastUserPrompt === "string" ? context.options.lastUserPrompt.trim() : "";
     const commandDescription = typeof description3 === "string" ? description3.trim() : "";
-    const effectiveCwd = cwd ? isAbsolute8(cwd) ? cwd : resolve10(getCwd(), cwd) : getCwd();
+    const effectiveCwd = cwd ? isAbsolute8(cwd) ? cwd : resolve11(getCwd(), cwd) : getCwd();
     try {
       await validateSafety(command4, effectiveCwd);
     } catch (error) {
@@ -31610,7 +32713,7 @@ Did you mean "git ${cmdParts.slice(1).join(" ")}"?`;
           if (abortController.signal.aborted) return false;
           const hostForUrl = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
           const url2 = `http://${hostForUrl}:${port}/`;
-          return await new Promise((resolve11) => {
+          return await new Promise((resolve12) => {
             const assistantMessage = createAssistantMessage("");
             if (context.messageId) {
               ;
@@ -31626,13 +32729,13 @@ Did you mean "git ${cmdParts.slice(1).join(" ")}"?`;
               suggestions: void 0,
               riskScore: null,
               onAbort() {
-                resolve11(false);
+                resolve12(false);
               },
               onAllow() {
-                resolve11(true);
+                resolve12(true);
               },
               onReject() {
-                resolve11(false);
+                resolve12(false);
               }
             };
             setToolJSX({
@@ -31726,8 +32829,8 @@ Did you mean "git ${cmdParts.slice(1).join(" ")}"?`;
       );
       let backgroundRequested = false;
       let resolveBackground = null;
-      const backgroundPromise = new Promise((resolve11) => {
-        resolveBackground = resolve11;
+      const backgroundPromise = new Promise((resolve12) => {
+        resolveBackground = resolve12;
       });
       const requestBackground = () => {
         if (backgroundRequested) return;
@@ -31770,7 +32873,7 @@ ${footerParts.join(" ")}`;
             bashId
           })),
           new Promise(
-            (resolve11) => setTimeout(() => resolve11({ kind: "tick" }), waitMs)
+            (resolve12) => setTimeout(() => resolve12({ kind: "tick" }), waitMs)
           )
         ]);
         if (race.kind === "background") {
@@ -31804,7 +32907,7 @@ ${footerParts.join(" ")}`;
           if (process.env.NODE_ENV !== "test") {
             getCommandFilePaths(command4, stdout).then((filePaths) => {
               for (const filePath of filePaths) {
-                const fullFilePath = isAbsolute8(filePath) ? filePath : resolve10(getCwd(), filePath);
+                const fullFilePath = isAbsolute8(filePath) ? filePath : resolve11(getCwd(), filePath);
                 try {
                   readFileTimestamps[fullFilePath] = statSync13(fullFilePath).mtimeMs;
                 } catch (e) {
@@ -32118,6 +33221,7 @@ export {
   KillShellTool,
   hasPermissionsToUseTool,
   BashTool,
+  getModelCapabilities,
   getCLISyspromptPrefix,
   getSystemPrompt,
   getEnvInfo,
@@ -32126,6 +33230,8 @@ export {
   getReasoningEffort,
   generatePybContext,
   refreshPybContext,
+  emitTelemetryEvent,
+  resolveModelResponsePolicy,
   formatSystemPromptWithContext,
   useExitOnCtrlCD,
   clearTerminal,