pybao-cli 1.5.13 → 1.5.15

package/dist/{chunk-EN3EFAIN.js → chunk-CGCRCAEE.js}

@@ -2,18 +2,18 @@ import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
 import {
   loadPybAgentSessionMessages
-} from "./chunk-SQZQF7FX.js";
+} from "./chunk-LVDHERSS.js";
 import {
   listPybAgentSessions
-} from "./chunk-2YIYRACC.js";
+} from "./chunk-DPGWN2AL.js";
 import {
   appendSessionCustomTitleRecord,
   appendSessionTagRecord
-} from "./chunk-5SB6YYVT.js";
+} from "./chunk-CM2BHPBS.js";
 import {
   formatValidationResult,
   validatePluginOrMarketplacePath
-} from "./chunk-VLE3RIPA.js";
+} from "./chunk-US3AHG74.js";
 import {
   ConversationTracker,
   appendFinishState,
@@ -21,10 +21,10 @@ import {
   getConversationTrackerForContext,
   isFinishComplete,
   mapFinishReason
-} from "./chunk-R5KHOF4Q.js";
+} from "./chunk-Q3UL5UMX.js";
 import {
   FileSystemConversationPersistence
-} from "./chunk-KHCVAV26.js";
+} from "./chunk-NBSAKUNJ.js";
 import {
   beginReplSessionScope
 } from "./chunk-F4AXICO7.js";
@@ -39,7 +39,7 @@ import {
   runStopHooks,
   runUserPromptSubmitHooks,
   updateHookTranscriptForMessages
-} from "./chunk-CLDFSJRX.js";
+} from "./chunk-A5GK77ZR.js";
 import {
   DEFAULT_OUTPUT_STYLE,
   getAvailableOutputStyles,
@@ -48,11 +48,11 @@ import {
   getOutputStyleSystemPromptAdditions,
   resolveOutputStyleName,
   setCurrentOutputStyle
-} from "./chunk-KDWAOC2Y.js";
+} from "./chunk-M3G65CDD.js";
 import {
   fetchCustomModels,
   getModelFeatures
-} from "./chunk-PMBP2S7T.js";
+} from "./chunk-E44XXHEZ.js";
 import {
   getSessionState
 } from "./chunk-XKYHFZEC.js";
@@ -60,7 +60,7 @@ import {
   queryLLM,
   queryQuick,
   verifyApiKey
-} from "./chunk-GKLF5SMX.js";
+} from "./chunk-PLI6YIVF.js";
 import {
   DEFAULT_TIMEOUT_MS,
   FallbackToolUseRejectedMessage,
@@ -74,7 +74,7 @@ import {
   listMCPServers,
   loadMergedSettings,
   normalizeSandboxRuntimeConfigFromSettings
-} from "./chunk-IZKGIVR5.js";
+} from "./chunk-H5VJCPBX.js";
 import {
   addMarketplace,
   disableSkillPlugin,
@@ -87,11 +87,11 @@ import {
   refreshMarketplaceAsync,
   removeMarketplace,
   uninstallSkillPlugin
-} from "./chunk-USAN2W2G.js";
+} from "./chunk-ZI6YQH7N.js";
 import {
   loadToolPermissionContextFromDisk,
   persistToolPermissionUpdateToDisk
-} from "./chunk-DYRNDVME.js";
+} from "./chunk-6O5YLDUZ.js";
 import {
   applyToolPermissionContextUpdate,
   applyToolPermissionContextUpdates,
@@ -102,13 +102,13 @@ import {
   generateSystemReminders,
   resetReminderSession,
   systemReminderService
-} from "./chunk-NMV2Y2OE.js";
+} from "./chunk-BJF6GJWS.js";
 import {
   clearAgentCache,
   getActiveAgents,
   getAgentByType,
   getAllAgents
-} from "./chunk-LHETO2A7.js";
+} from "./chunk-O6WNHWNP.js";
 import {
   API_ERROR_MESSAGE_PREFIX,
   CANCEL_MESSAGE,
@@ -145,7 +145,7 @@ import {
   reorderMessages,
   resetAutoCompactTelemetry,
   stripSystemMessages
-} from "./chunk-UYEP4HDV.js";
+} from "./chunk-CM5VV5YR.js";
 import {
   getRequestStatus,
   setRequestStatus,
@@ -175,7 +175,7 @@ import {
   normalizeFilePath,
   readTextContent,
   writeTextContent
-} from "./chunk-6Z7VRZE3.js";
+} from "./chunk-W56DNT4T.js";
 import {
   parseBlockEdits
 } from "./chunk-QWIBSCDN.js";
@@ -185,18 +185,18 @@ import {
   ParserRegistry,
   initParser,
   loadLanguage
-} from "./chunk-V6HDC2AS.js";
+} from "./chunk-OGAO5B2G.js";
 import {
   getSettingsFileCandidates,
   loadSettingsWithLegacyFallback,
   readSettingsFile
-} from "./chunk-LXKU7CVC.js";
+} from "./chunk-WO2262XL.js";
 import {
   getCustomCommandDirectories,
   hasCustomCommands,
   loadCustomCommands,
   reloadCustomCommands
-} from "./chunk-FEEOL2BF.js";
+} from "./chunk-6RRWB5RJ.js";
 import {
   getSessionPlugins
 } from "./chunk-BJSWTHRM.js";
@@ -205,7 +205,7 @@ import {
   buildModelProfileKey,
   getModelManager,
   isDefaultSlowAndCapableModel
-} from "./chunk-5AZPIB3O.js";
+} from "./chunk-UZSZ5W4A.js";
 import {
   getCodeStyle,
   getContext,
@@ -213,16 +213,16 @@ import {
   getIsGit,
   getProjectDocs,
   getProjectStructureStatisticsBlock
-} from "./chunk-62DRY4WE.js";
+} from "./chunk-PTYPEDJX.js";
 import {
   getRipgrepPath,
   getRipgrepPolicyMode,
   resolveRipgrepPolicy,
   ripGrep
-} from "./chunk-4CTIJSGF.js";
+} from "./chunk-K75MU5KH.js";
 import {
   getTheme
-} from "./chunk-PH2OZGKF.js";
+} from "./chunk-6T2A6453.js";
 import {
   DEFAULT_GLOBAL_CONFIG,
   enableConfigs,
@@ -235,7 +235,7 @@ import {
   saveGlobalConfig,
   setAllPointersToModel,
   setModelPointer
-} from "./chunk-IKZOQVSC.js";
+} from "./chunk-QQKZSWNE.js";
 import {
   AbortError
 } from "./chunk-RQVLBMP7.js";
@@ -244,7 +244,7 @@ import {
   getCurrentRequest,
   logUserFriendly,
   markPhase
-} from "./chunk-HBFOODQT.js";
+} from "./chunk-HMOYVZZY.js";
 import {
   ASCII_LOGO,
   BunShell,
@@ -285,10 +285,10 @@ import {
   setCwd,
   shouldApplyToolOutputTruncation,
   truncateToolOutput
-} from "./chunk-DFQUXY7J.js";
+} from "./chunk-NQNZKPC7.js";
 import {
   MACRO
-} from "./chunk-2L7XKUEG.js";
+} from "./chunk-H4CJDGI2.js";
 import {
   __export
 } from "./chunk-I3J4JYES.js";
@@ -469,7 +469,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-VL7SVIXR.js");
+    const { API_ERROR_MESSAGE_PREFIX: API_ERROR_MESSAGE_PREFIX2, queryQuick: queryQuick2 } = await import("./llm-MASKGBQQ.js");
     const response = await queryQuick2({
       systemPrompt,
       userPrompt,
@@ -4271,7 +4271,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-VL7SVIXR.js");
+  const { API_ERROR_MESSAGE_PREFIX: API_ERROR_MESSAGE_PREFIX2, queryLLM: queryLLM2 } = await import("./llm-MASKGBQQ.js");
   const queryLLMFn = args.queryLLMOverride ?? queryLLM2;
   const messages = [
     {
@@ -6664,7 +6664,7 @@ var FileEditTool = {
     const originalFileContent = currentFileContent;
     let totalPatch = [];
     const { SmartEdit } = await import("./smart-edit-AWHJDSU6.js");
-    const { findLspAnchor } = await import("./lspAnchor-56RDVJJK.js");
+    const { findLspAnchor } = await import("./lspAnchor-ED7WVFHC.js");
     for (const op of editOperations) {
       const normalizedSearch = normalizeLineEndings(op.search);
       const normalizedReplace = normalizeLineEndings(op.replace);
@@ -12149,7 +12149,7 @@ async function createAndStoreApiKey(accessToken) {
       }
       saveGlobalConfig(config2);
       try {
-        const { resetAnthropicClient } = await import("./llm-VL7SVIXR.js");
+        const { resetAnthropicClient } = await import("./llm-MASKGBQQ.js");
         resetAnthropicClient();
       } catch {
       }
@@ -16573,7 +16573,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-5ZYXGIUZ.js");
+  const { configureSessionPlugins } = await import("./pluginRuntime-5STYKO5H.js");
   const { errors } = await configureSessionPlugins({ pluginDirs: dirs });
   return errors;
 }
@@ -17248,7 +17248,7 @@ async function call(onDone, context) {
     ModelConfig,
     {
       onClose: () => {
-        import("./model-JVW7GWZF.js").then(({ reloadModelManager: reloadModelManager2 }) => {
+        import("./model-7PWK4YWQ.js").then(({ reloadModelManager: reloadModelManager2 }) => {
           reloadModelManager2();
           triggerModelConfigChange();
           onDone();
@@ -25557,7 +25557,7 @@ function useStatusLine() {
 // src/ui/components/PromptInput.tsx
 async function interpretHashCommand(input) {
   try {
-    const { queryQuick: queryQuick2 } = await import("./llm-VL7SVIXR.js");
+    const { queryQuick: queryQuick2 } = await import("./llm-MASKGBQQ.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.",
@@ -25870,7 +25870,7 @@ function PromptInput({
     if (messages2.length) {
       if (mode === "bash") {
         onQuery(messages2, newAbortController).then(async () => {
-          const { getCwd: getCwd2 } = await import("./state-IB4ZDFMG.js");
+          const { getCwd: getCwd2 } = await import("./state-66WENTAD.js");
           setCurrentPwd(getCwd2());
         });
       } else {
@@ -30040,6 +30040,271 @@ function flushConversationTrackerTelemetrySnapshot(options = {}) {
   return record;
 }
 
+// src/services/ai/streamTyped/projector.ts
+function supportsRichToolResultByProvider(provider) {
+  return String(provider ?? "").trim().toLowerCase() === "anthropic";
+}
+function extractToolResultText2(content) {
+  if (typeof content === "string") return { text: content, hasNonTextBlock: false };
+  if (!Array.isArray(content)) return { text: "", hasNonTextBlock: false };
+  let hasNonTextBlock = false;
+  const text = content.filter((block) => {
+    if (!block || typeof block !== "object") return false;
+    if (block.type === "text") return true;
+    hasNonTextBlock = true;
+    return false;
+  }).map((block) => String(block.text ?? "")).join("\n");
+  return { text, hasNonTextBlock };
+}
+function extractTaggedText(text, tagName) {
+  const normalized = String(text ?? "").trim();
+  if (!normalized.startsWith(`<${tagName}>`)) return null;
+  const pattern = new RegExp(`<${tagName}>([\\s\\S]*?)<\\/${tagName}>`, "i");
+  const match = normalized.match(pattern);
+  const content = String(match?.[1] ?? "").trim();
+  return content.length > 0 ? content : null;
+}
+function projectAssistantMessage(state, message) {
+  const content = message?.message?.content;
+  if (!Array.isArray(content)) return;
+  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 ?? "");
+      const toolProgressText = extractTaggedText(text, "tool-progress");
+      if (toolProgressText) {
+        state.parts.push(
+          createSystemEventPart({
+            requestId: state.requestId,
+            eventType: "tool_progress",
+            text: toolProgressText,
+            source: state.source
+          })
+        );
+      }
+      const localStdoutText = extractTaggedText(text, "local-command-stdout");
+      if (localStdoutText) {
+        state.parts.push(
+          createSystemEventPart({
+            requestId: state.requestId,
+            eventType: "local_command_stdout",
+            text: localStdoutText,
+            source: state.source
+          })
+        );
+      }
+      const localStderrText = extractTaggedText(text, "local-command-stderr");
+      if (localStderrText) {
+        state.parts.push(
+          createSystemEventPart({
+            requestId: state.requestId,
+            eventType: "local_command_stderr",
+            text: localStderrText,
+            source: state.source
+          })
+        );
+      }
+      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" || type3 === "server_tool_use" || type3 === "mcp_tool_use") {
+      const toolCallId = String(block.id ?? `tool-${i}`);
+      const toolName = String(block.name ?? "unknown");
+      onToolCall({ toolCallId, toolName }, state);
+    }
+  }
+}
+function projectUserToolResult(projector, message) {
+  const state = projector.state;
+  const content = message?.message?.content;
+  if (!Array.isArray(content)) return;
+  for (let i = 0; i < content.length; i += 1) {
+    const block = content[i];
+    if (!block || typeof block !== "object") continue;
+    if (block.type !== "tool_result") continue;
+    const toolCallId = String(block.tool_use_id ?? `tool-${i}`);
+    const extracted = extractToolResultText2(block.content);
+    if (extracted.hasNonTextBlock) {
+      projector.richToolResultBlockCount += 1;
+      if (!projector.supportsRichToolResult) {
+        projector.downgradedToolResultCount += 1;
+      }
+    }
+    onToolResult(
+      {
+        toolCallId,
+        status: block.is_error ? "failed" : "completed",
+        outputText: extracted.text
+      },
+      state
+    );
+  }
+}
+function projectProgressMessage(state, message) {
+  const toolCallId = String(message?.toolUseID ?? "").trim();
+  if (!toolCallId) return;
+  const content = String(
+    message?.content?.message?.content?.find?.((block) => block?.type === "text")?.text ?? ""
+  );
+  const extractedProgressText = extractTaggedText(content, "tool-progress");
+  const normalizedContent = content.trim();
+  const toolProgressText = extractedProgressText ?? (normalizedContent.length > 0 ? normalizedContent : void 0);
+  if (toolProgressText) {
+    state.parts.push(
+      createSystemEventPart({
+        requestId: state.requestId,
+        eventType: "tool_progress",
+        text: toolProgressText,
+        toolCallId,
+        source: state.source
+      })
+    );
+  }
+  onToolResult(
+    {
+      toolCallId,
+      status: "running",
+      outputText: content || void 0
+    },
+    state
+  );
+}
+function createStreamTypedProjector(options) {
+  const provider = String(options.provider ?? "").trim().toLowerCase();
+  return {
+    state: createAssemblerState(options.requestId, options.source ?? "query_main"),
+    provider,
+    supportsRichToolResult: typeof options.supportsRichToolResult === "boolean" ? options.supportsRichToolResult : supportsRichToolResultByProvider(provider),
+    richToolResultBlockCount: 0,
+    downgradedToolResultCount: 0
+  };
+}
+function consumeProjectorCompatibilityMetrics(projector) {
+  const snapshot = {
+    provider: projector.provider || "unknown",
+    supportsRichToolResult: projector.supportsRichToolResult,
+    richToolResultBlockCount: projector.richToolResultBlockCount,
+    downgradedToolResultCount: projector.downgradedToolResultCount
+  };
+  projector.richToolResultBlockCount = 0;
+  projector.downgradedToolResultCount = 0;
+  return snapshot;
+}
+function projectMessageToTypedParts(projector, message) {
+  if (!message || typeof message !== "object") return [];
+  if (message.type === "assistant") {
+    projectAssistantMessage(projector.state, message);
+  } else if (message.type === "user") {
+    projectUserToolResult(projector, message);
+  } else if (message.type === "progress") {
+    projectProgressMessage(projector.state, message);
+  }
+  return flushTypedParts(projector.state);
+}
+function projectLifecycleEventsToTypedParts(projector, events) {
+  if (!Array.isArray(events) || events.length === 0) return [];
+  const parts = [];
+  for (const event of events) {
+    if (!event || typeof event !== "object") continue;
+    if (event.eventType === "start-step") {
+      parts.push(
+        createStepStartPart({
+          requestId: projector.state.requestId,
+          stepId: event.stepId,
+          timeStart: event.timestamp,
+          source: projector.state.source
+        })
+      );
+      continue;
+    }
+    if (event.eventType === "finish-step") {
+      parts.push(
+        createStepFinishPart({
+          requestId: projector.state.requestId,
+          stepId: event.stepId,
+          reason: event.reason,
+          completedAt: event.completedAt,
+          costUSD: event.costUSD,
+          ...event.tokens ? { tokens: event.tokens } : {},
+          source: projector.state.source
+        })
+      );
+    }
+  }
+  return parts;
+}
+
+// src/services/ai/streamTyped/skeletonReader.ts
+function pushText(parts, value) {
+  const text = String(value ?? "").trim();
+  if (!text) return;
+  parts.push({ type: "text", text });
+}
+function getToolState(part) {
+  if (part.partType !== "tool") return null;
+  const payload = part.payload;
+  return payload?.state ?? null;
+}
+function buildSkeletonBlocksFromTypedParts(input) {
+  const result = [];
+  for (const part of input.parts) {
+    if (!part || typeof part !== "object") continue;
+    if (part.partType === "text") {
+      pushText(result, part.payload?.text);
+      continue;
+    }
+    if (part.partType === "reasoning" && input.role === "assistant") {
+      const reasoning = String(part.payload?.text ?? "").trim();
+      if (!reasoning) continue;
+      result.push({ type: "reasoning", reasoning });
+      continue;
+    }
+    if (part.partType !== "tool") continue;
+    const payload = part.payload;
+    const state = getToolState(part);
+    const status = String(
+      state?.status ?? payload?.status ?? ""
+    ).toLowerCase();
+    const toolName = String(payload?.toolName ?? "").trim();
+    const toolCallId = String(payload?.toolCallId ?? "").trim();
+    if (!toolCallId) continue;
+    if (input.role === "assistant") {
+      if (status !== "pending") continue;
+      result.push({
+        type: "tool_use",
+        id: toolCallId,
+        name: toolName || "unknown",
+        input: state?.input && typeof state.input === "object" ? state.input : payload?.input && typeof payload.input === "object" ? payload.input : {}
+      });
+      continue;
+    }
+    if (status !== "completed" && status !== "failed" && status !== "interrupted") {
+      continue;
+    }
+    const content = String(
+      state?.output ?? state?.error ?? state?.reason ?? payload?.outputText ?? ""
+    ).trim();
+    result.push({
+      type: "tool_result",
+      tool_use_id: toolCallId,
+      content,
+      ...status === "failed" ? { is_error: true } : {}
+    });
+  }
+  return result;
+}
+
 // src/app/queryLifecycleEvents.ts
 function createStepId(input) {
   const base = (input.queryId || input.requestId || "unknown").replace(/[^a-zA-Z0-9_-]/g, "_");
@@ -30274,13 +30539,6 @@ function resolveQuerySessionFeatureFlags() {
     rolloutReason: "rollout_disabled"
   };
 }
-function buildQueryTypedRequestId(args) {
-  if (args.currentRequestId) return `query_${args.currentRequestId}`;
-  if (args.fallbackQueryId) return `query_${args.fallbackQueryId}`;
-  const now = args.now ?? Date.now();
-  const randomSuffix = args.randomSuffix ?? Math.random().toString(36).slice(2, 10);
-  return `query_${now}_${randomSuffix}`;
-}
 function prepareQueryTypedProjector(args) {
   const modelPointer = args.modelPointer || "main";
   const modelResolution = args.resolveModelWithInfo(modelPointer);
@@ -30290,16 +30548,7 @@ function prepareQueryTypedProjector(args) {
     source: "query_main",
     provider: typedProvider
   });
-  return { typedProvider, typedProjector };
-}
-function findLatestValue(args) {
-  for (let index = args.items.length - 1; index >= 0; index -= 1) {
-    const value = args.selectValue(args.items[index]);
-    if (value !== void 0 && value !== null) {
-      return value;
-    }
-  }
-  return void 0;
+  return { typedProjector };
 }
 function prepareQuerySessionExecution(args) {
   args.onRolloutApplied(args.featureFlags);
@@ -30321,14 +30570,15 @@ function prepareQuerySessionExecution(args) {
 }
 function prepareQuerySessionPrimaryPlan(args) {
   const shouldPersistSession = args.toolUseContext.options?.persistSession !== false && !args.isTestEnv;
-  const fallbackQueryId = findLatestValue({
-    items: args.messages,
-    selectValue: args.extractUserQueryId
-  });
-  const typedRequestId = buildQueryTypedRequestId({
-    currentRequestId: args.currentRequestId,
-    fallbackQueryId
-  });
+  let fallbackQueryId;
+  for (let index = args.messages.length - 1; index >= 0; index -= 1) {
+    const value = args.extractUserQueryId(args.messages[index]);
+    if (value !== void 0 && value !== null) {
+      fallbackQueryId = value;
+      break;
+    }
+  }
+  const typedRequestId = args.currentRequestId ? `query_${args.currentRequestId}` : fallbackQueryId ? `query_${fallbackQueryId}` : `query_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
   args.policyCoordinator?.setRequestId(typedRequestId);
   const { typedProjector } = prepareQueryTypedProjector({
     requestId: typedRequestId,
@@ -30466,28 +30716,19 @@ async function* runQuerySessionPrimaryAdapter(args) {
     runner: runQuerySessionPrimary
   });
 }
-async function* runQuerySessionCompatAdapter(args) {
+async function* runQuerySessionLegacyCompatAdapter(args) {
   const primaryInput = createQuerySessionPrimaryAdapterInput(args);
   yield* runSessionCompatStreams({
-    routingContext: args.routingContext,
-    primaryInput,
-    primaryRunner: runQuerySessionPrimaryAdapter,
-    fallbackInput: args.fallbackInput,
-    fallbackRunner: args.fallbackRunner,
-    toolUseContext: args.toolUseContext
-  });
-}
-async function* runQuerySessionLegacyCompatAdapter(args) {
-  const streamRunner = args.stream;
-  yield* runQuerySessionCompatAdapter({
-    ...args,
     routingContext: {
       sessionId: args.toolUseContext.sessionId,
       agentId: args.toolUseContext.agentId,
       requestId: args.requestId
     },
+    primaryInput,
+    primaryRunner: runQuerySessionPrimaryAdapter,
     fallbackInput: args.messages,
-    fallbackRunner: streamRunner
+    fallbackRunner: args.stream,
+    toolUseContext: args.toolUseContext
   });
 }
 function processQuerySessionTypedOutput(args) {
@@ -30577,38 +30818,16 @@ async function* runSessionOrchestrator(args) {
     runner: selectedRunner
   });
 }
-function createSessionReplaySeed(context) {
-  return `${context.sessionId ?? ""}:${context.agentId ?? ""}:${context.requestId ?? ""}`;
-}
-async function* runSessionOrchestratorWithContext(args) {
-  const replaySeed = createSessionReplaySeed(args.routingContext);
+async function* runSessionCompatStreams(args) {
+  const sessionContext = ensureSessionContext(args.toolUseContext);
+  const replaySeed = `${args.routingContext.sessionId ?? ""}:${args.routingContext.agentId ?? ""}:${args.routingContext.requestId ?? ""}`;
   yield* runSessionOrchestrator({
-    input: args.input,
-    replaySeed,
-    sessionRunner: args.sessionRunner,
-    fallbackRunner: args.fallbackRunner
-  });
-}
-async function* runSessionOrchestratorStreams(args) {
-  yield* runSessionOrchestratorWithContext({
     input: void 0,
-    routingContext: args.routingContext,
+    replaySeed,
     sessionRunner: async function* () {
-      yield* args.sessionStream();
-    },
-    fallbackRunner: async function* () {
-      yield* args.fallbackStream();
-    }
-  });
-}
-async function* runSessionCompatStreams(args) {
-  const sessionContext = ensureSessionContext(args.toolUseContext);
-  yield* runSessionOrchestratorStreams({
-    routingContext: args.routingContext,
-    sessionStream: async function* () {
       yield* args.primaryRunner(args.primaryInput);
     },
-    fallbackStream: async function* () {
+    fallbackRunner: async function* () {
       yield* runSessionWithEngine({
         input: args.fallbackInput,
         sessionContext,
@@ -30653,75 +30872,81 @@ function resolveSessionEngineReplaySample(replaySeed) {
   return hash % 100;
 }
 
-// src/app/queryRuntime/errorMapping.ts
-var ERROR_CLASS_BY_CODE = {
-  ENOENT: "soft",
-  EISDIR: "soft",
-  EACCES: "retryable",
-  EPERM: "retryable",
-  EMFILE: "retryable",
-  ENFILE: "retryable",
-  EIO: "fatal",
-  ENODEV: "fatal",
-  EBUSY: "fatal"
-};
-function formatError(error) {
-  if (!(error instanceof Error)) {
-    return String(error);
+// src/app/queryRuntime/lifecycle.ts
+var TOOL_PROGRESS_OPEN_TAG = ["<tool", "-progress>"].join("");
+var TOOL_PROGRESS_CLOSE_TAG = ["</tool", "-progress>"].join("");
+function isTextBlock(block) {
+  return Boolean(
+    block && typeof block === "object" && block.type === "text"
+  );
+}
+function isToolResultBlock(block) {
+  return Boolean(
+    block && typeof block === "object" && block.type === "tool_result"
+  );
+}
+function inferIsNewSessionForAutoCompact(messages) {
+  const naturalMessages = messages.filter(
+    (message) => message?.type === "user" || message?.type === "assistant"
+  );
+  const hasCompactionMarker = naturalMessages.some(
+    (message) => message?.compaction?.type === "compaction"
+  );
+  return !hasCompactionMarker && naturalMessages.length <= 2;
+}
+function extractUserPromptTextFromMessages(messages) {
+  const last2 = messages[messages.length - 1];
+  if (!last2 || typeof last2 !== "object" || last2.type !== "user") {
+    return null;
   }
-  const parts = [error.message];
-  if ("stderr" in error && typeof error.stderr === "string") {
-    parts.push(error.stderr);
+  const content = last2.message?.content;
+  if (typeof content === "string") {
+    return content;
   }
-  if ("stdout" in error && typeof error.stdout === "string") {
-    parts.push(error.stdout);
+  if (!Array.isArray(content)) {
+    return null;
   }
-  const fullMessage = parts.filter(Boolean).join("\n");
-  if (fullMessage.length <= 1e4) {
-    return fullMessage;
+  const hasToolResult = content.some((block) => isToolResultBlock(block));
+  if (hasToolResult) {
+    return null;
   }
-  const halfLength = 5e3;
-  const start = fullMessage.slice(0, halfLength);
-  const end = fullMessage.slice(-halfLength);
-  return `${start}
-
-... [${fullMessage.length - 1e4} characters truncated] ...
-
-${end}`;
+  return content.filter(isTextBlock).map((block) => String(block.text ?? "")).join("");
 }
-function extractErrorCode(error) {
-  if (!error || typeof error !== "object") {
+function resolveLifecycleTokensFromUsage(usage) {
+  if (!usage || typeof usage !== "object") {
     return void 0;
   }
-  if ("code" in error && typeof error.code === "string") {
-    return error.code;
+  const usageLike = usage;
+  const input = Number.isFinite(Number(usageLike.input_tokens)) ? Number(usageLike.input_tokens) : void 0;
+  const output = Number.isFinite(Number(usageLike.output_tokens)) ? Number(usageLike.output_tokens) : void 0;
+  if (input === void 0 && output === void 0) {
+    return void 0;
   }
-  return void 0;
-}
-function summarizeError(detail) {
-  const line = detail.split("\n").map((part) => part.trim()).find((part) => part.length > 0);
-  const summary = line ?? detail.trim();
-  return summary.length > 200 ? summary.slice(0, 200) : summary;
+  return {
+    ...input === void 0 ? {} : { input },
+    ...output === void 0 ? {} : { output },
+    total: (input ?? 0) + (output ?? 0)
+  };
 }
-function getErrorClassFromCode(errorCode) {
-  if (!errorCode) return "soft";
-  return ERROR_CLASS_BY_CODE[errorCode] ?? "soft";
+function resolveLifecycleTokensFromAssistantMessage(assistantMessage) {
+  if (!assistantMessage || typeof assistantMessage !== "object") {
+    return void 0;
+  }
+  const message = assistantMessage.message;
+  if (!message || typeof message !== "object") {
+    return void 0;
+  }
+  return resolveLifecycleTokensFromUsage(
+    message.usage
+  );
 }
-function createErrorToolResultBlock(args) {
-  const detail = typeof args.errorDetail === "string" ? args.errorDetail : typeof args.content === "string" ? args.content : JSON.stringify(args.content);
-  const errorCode = args.errorCode;
-  const errorClass = args.errorClass ?? getErrorClassFromCode(errorCode);
-  const summary = detail ? summarizeError(detail) : "";
+function resolveStopHookSignal(args) {
+  const hookEvent = args.agentId && args.agentId !== "main" ? "SubagentStop" : "Stop";
+  const rawStopReason = args.assistantMessage && typeof args.assistantMessage === "object" && args.assistantMessage.message ? args.assistantMessage.message?.stop_reason ?? args.assistantMessage.message?.stopReason : void 0;
+  const stopReason = rawStopReason ?? "end_turn";
   return {
-    type: "tool_result",
-    content: args.content,
-    is_error: true,
-    tool_use_id: args.toolUseId,
-    error_class: errorClass,
-    ...errorCode ? { error_code: errorCode } : {},
-    ...summary ? { error_summary: summary } : {},
-    ...detail ? { error_detail: detail } : {},
-    ...args.rootToolUseId ? { root_tool_use_id: args.rootToolUseId } : {}
+    hookEvent,
+    stopReason: String(stopReason ?? "")
   };
 }
 
@@ -30766,282 +30991,101 @@ function preprocessToolInput(tool, input) {
   return input;
 }
 
-// src/app/queryRuntime/lifecycle.ts
-var TOOL_PROGRESS_OPEN_TAG = ["<tool", "-progress>"].join("");
-var TOOL_PROGRESS_CLOSE_TAG = ["</tool", "-progress>"].join("");
-function inferIsNewSessionForAutoCompact(messages) {
-  const naturalMessages = messages.filter(
-    (message) => message?.type === "user" || message?.type === "assistant"
-  );
-  const hasCompactionMarker = naturalMessages.some(
-    (message) => message?.compaction?.type === "compaction"
-  );
-  return !hasCompactionMarker && naturalMessages.length <= 2;
-}
-
-// src/services/ai/streamTyped/projector.ts
-function supportsRichToolResultByProvider(provider) {
-  return String(provider ?? "").trim().toLowerCase() === "anthropic";
-}
-function extractToolResultText2(content) {
-  if (typeof content === "string") return { text: content, hasNonTextBlock: false };
-  if (!Array.isArray(content)) return { text: "", hasNonTextBlock: false };
-  let hasNonTextBlock = false;
-  const text = content.filter((block) => {
-    if (!block || typeof block !== "object") return false;
-    if (block.type === "text") return true;
-    hasNonTextBlock = true;
-    return false;
-  }).map((block) => String(block.text ?? "")).join("\n");
-  return { text, hasNonTextBlock };
-}
-function extractTaggedText(text, tagName) {
-  const normalized = String(text ?? "").trim();
-  if (!normalized.startsWith(`<${tagName}>`)) return null;
-  const pattern = new RegExp(`<${tagName}>([\\s\\S]*?)<\\/${tagName}>`, "i");
-  const match = normalized.match(pattern);
-  const content = String(match?.[1] ?? "").trim();
-  return content.length > 0 ? content : null;
-}
-function projectAssistantMessage(state, message) {
-  const content = message?.message?.content;
-  if (!Array.isArray(content)) return;
-  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 ?? "");
-      const toolProgressText = extractTaggedText(text, "tool-progress");
-      if (toolProgressText) {
-        state.parts.push(
-          createSystemEventPart({
-            requestId: state.requestId,
-            eventType: "tool_progress",
-            text: toolProgressText,
-            source: state.source
-          })
-        );
-      }
-      const localStdoutText = extractTaggedText(text, "local-command-stdout");
-      if (localStdoutText) {
-        state.parts.push(
-          createSystemEventPart({
-            requestId: state.requestId,
-            eventType: "local_command_stdout",
-            text: localStdoutText,
-            source: state.source
-          })
-        );
-      }
-      const localStderrText = extractTaggedText(text, "local-command-stderr");
-      if (localStderrText) {
-        state.parts.push(
-          createSystemEventPart({
-            requestId: state.requestId,
-            eventType: "local_command_stderr",
-            text: localStderrText,
-            source: state.source
-          })
-        );
-      }
-      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" || type3 === "server_tool_use" || type3 === "mcp_tool_use") {
-      const toolCallId = String(block.id ?? `tool-${i}`);
-      const toolName = String(block.name ?? "unknown");
-      onToolCall({ toolCallId, toolName }, state);
-    }
+// src/app/queryRuntime/stopHooks.ts
+async function runStopHookAttempt(args) {
+  const stopOutcome = await runStopHooks({
+    hookEvent: args.hookEvent,
+    reason: args.stopReason,
+    retryEntryKey: buildRetryEntryKey([
+      args.context.sessionId,
+      args.context.parentSessionId,
+      args.context.childSessionId,
+      args.context.agentId,
+      args.stopReason
+    ]),
+    retryAttempt: args.stopHookAttempts,
+    sessionId: args.context.sessionId,
+    parentSessionId: args.context.parentSessionId,
+    childSessionId: args.context.childSessionId,
+    agentId: args.context.agentId,
+    permissionMode: args.context.options?.toolPermissionContext?.mode,
+    cwd: getCwd(),
+    transcriptPath: getHookTranscriptPath(args.context),
+    safeMode: args.context.options?.safeMode ?? false,
+    stopHookActive: args.stopHookActive,
+    signal: args.context.abortController.signal
+  });
+  if (stopOutcome.systemMessages.length > 0) {
+    queueHookSystemMessages(args.context, stopOutcome.systemMessages);
   }
-}
-function projectUserToolResult(projector, message) {
-  const state = projector.state;
-  const content = message?.message?.content;
-  if (!Array.isArray(content)) return;
-  for (let i = 0; i < content.length; i += 1) {
-    const block = content[i];
-    if (!block || typeof block !== "object") continue;
-    if (block.type !== "tool_result") continue;
-    const toolCallId = String(block.tool_use_id ?? `tool-${i}`);
-    const extracted = extractToolResultText2(block.content);
-    if (extracted.hasNonTextBlock) {
-      projector.richToolResultBlockCount += 1;
-      if (!projector.supportsRichToolResult) {
-        projector.downgradedToolResultCount += 1;
-      }
-    }
-    onToolResult(
-      {
-        toolCallId,
-        status: block.is_error ? "failed" : "completed",
-        outputText: extracted.text
-      },
-      state
-    );
+  if (stopOutcome.additionalContexts.length > 0) {
+    queueHookAdditionalContexts(args.context, stopOutcome.additionalContexts);
   }
-}
-function projectProgressMessage(state, message) {
-  const toolCallId = String(message?.toolUseID ?? "").trim();
-  if (!toolCallId) return;
-  const content = String(
-    message?.content?.message?.content?.find?.((block) => block?.type === "text")?.text ?? ""
-  );
-  const extractedProgressText = extractTaggedText(content, "tool-progress");
-  const normalizedContent = content.trim();
-  const toolProgressText = extractedProgressText ?? (normalizedContent.length > 0 ? normalizedContent : void 0);
-  if (toolProgressText) {
-    state.parts.push(
-      createSystemEventPart({
-        requestId: state.requestId,
-        eventType: "tool_progress",
-        text: toolProgressText,
-        toolCallId,
-        source: state.source
-      })
-    );
+  if (stopOutcome.decision !== "block") {
+    return {
+      shouldRetry: false,
+      nextStopHookAttempts: args.stopHookAttempts
+    };
+  }
+  queueHookSystemMessages(args.context, [stopOutcome.message]);
+  const maxStopHookAttempts = args.maxStopHookAttempts ?? 5;
+  if (args.stopHookAttempts < maxStopHookAttempts) {
+    return {
+      shouldRetry: true,
+      nextStopHookAttempts: args.stopHookAttempts + 1
+    };
   }
-  onToolResult(
-    {
-      toolCallId,
-      status: "running",
-      outputText: content || void 0
-    },
-    state
-  );
-}
-function createStreamTypedProjector(options) {
-  const provider = String(options.provider ?? "").trim().toLowerCase();
   return {
-    state: createAssemblerState(options.requestId, options.source ?? "query_main"),
-    provider,
-    supportsRichToolResult: typeof options.supportsRichToolResult === "boolean" ? options.supportsRichToolResult : supportsRichToolResultByProvider(provider),
-    richToolResultBlockCount: 0,
-    downgradedToolResultCount: 0
+    shouldRetry: false,
+    nextStopHookAttempts: args.stopHookAttempts
   };
 }
-function consumeProjectorCompatibilityMetrics(projector) {
-  const snapshot = {
-    provider: projector.provider || "unknown",
-    supportsRichToolResult: projector.supportsRichToolResult,
-    richToolResultBlockCount: projector.richToolResultBlockCount,
-    downgradedToolResultCount: projector.downgradedToolResultCount
-  };
-  projector.richToolResultBlockCount = 0;
-  projector.downgradedToolResultCount = 0;
-  return snapshot;
+
+// src/app/queryRuntime/toolQueue.ts
+function isToolResultErrorBlock(block) {
+  return Boolean(
+    block && typeof block === "object" && block.type === "tool_result" && block.is_error === true
+  );
 }
-function projectMessageToTypedParts(projector, message) {
-  if (!message || typeof message !== "object") return [];
-  if (message.type === "assistant") {
-    projectAssistantMessage(projector.state, message);
-  } else if (message.type === "user") {
-    projectUserToolResult(projector, message);
-  } else if (message.type === "progress") {
-    projectProgressMessage(projector.state, message);
-  }
-  return flushTypedParts(projector.state);
+function createQueuedWaitingProgressMessage(args) {
+  return createProgressMessage(
+    args.toolUseId,
+    args.siblingToolUseIDs,
+    createAssistantMessage(`${args.openTag}Waiting\u2026${args.closeTag}`),
+    [],
+    args.tools,
+    { progressState: "queued_waiting" }
+  );
 }
-function projectLifecycleEventsToTypedParts(projector, events) {
-  if (!Array.isArray(events) || events.length === 0) return [];
-  const parts = [];
-  for (const event of events) {
-    if (!event || typeof event !== "object") continue;
-    if (event.eventType === "start-step") {
-      parts.push(
-        createStepStartPart({
-          requestId: projector.state.requestId,
-          stepId: event.stepId,
-          timeStart: event.timestamp,
-          source: projector.state.source
-        })
-      );
-      continue;
-    }
-    if (event.eventType === "finish-step") {
-      parts.push(
-        createStepFinishPart({
-          requestId: projector.state.requestId,
-          stepId: event.stepId,
-          reason: event.reason,
-          completedAt: event.completedAt,
-          costUSD: event.costUSD,
-          ...event.tokens ? { tokens: event.tokens } : {},
-          source: projector.state.source
-        })
-      );
-    }
+function resolveToolQueueContextModifier(message) {
+  if (message.type !== "user") {
+    return void 0;
   }
-  return parts;
+  const modifyContext = message.toolUseResult?.contextModifier?.modifyContext;
+  return typeof modifyContext === "function" ? modifyContext : void 0;
 }
-
-// src/services/ai/streamTyped/skeletonReader.ts
-function pushText(parts, value) {
-  const text = String(value ?? "").trim();
-  if (!text) return;
-  parts.push({ type: "text", text });
+function isToolQueueNextTurnMessage(message) {
+  return message.type === "user" || message.type === "assistant";
 }
-function getToolState(part) {
-  if (part.partType !== "tool") return null;
-  const payload = part.payload;
-  return payload?.state ?? null;
-}
-function buildSkeletonBlocksFromTypedParts(input) {
-  const result = [];
-  for (const part of input.parts) {
-    if (!part || typeof part !== "object") continue;
-    if (part.partType === "text") {
-      pushText(result, part.payload?.text);
-      continue;
-    }
-    if (part.partType === "reasoning" && input.role === "assistant") {
-      const reasoning = String(part.payload?.text ?? "").trim();
-      if (!reasoning) continue;
-      result.push({ type: "reasoning", reasoning });
-      continue;
-    }
-    if (part.partType !== "tool") continue;
-    const payload = part.payload;
-    const state = getToolState(part);
-    const status = String(
-      state?.status ?? payload?.status ?? ""
-    ).toLowerCase();
-    const toolName = String(payload?.toolName ?? "").trim();
-    const toolCallId = String(payload?.toolCallId ?? "").trim();
-    if (!toolCallId) continue;
-    if (input.role === "assistant") {
-      if (status !== "pending") continue;
-      result.push({
-        type: "tool_use",
-        id: toolCallId,
-        name: toolName || "unknown",
-        input: state?.input && typeof state.input === "object" ? state.input : payload?.input && typeof payload.input === "object" ? payload.input : {}
-      });
-      continue;
-    }
-    if (status !== "completed" && status !== "failed" && status !== "interrupted") {
-      continue;
-    }
-    const content = String(
-      state?.output ?? state?.error ?? state?.reason ?? payload?.outputText ?? ""
-    ).trim();
-    result.push({
-      type: "tool_result",
-      tool_use_id: toolCallId,
-      content,
-      ...status === "failed" ? { is_error: true } : {}
-    });
+function resolveToolQueueUserMessageErrorState(message) {
+  if (message.type !== "user") {
+    return { toolErrored: false };
   }
-  return result;
+  const content = message.message?.content;
+  if (!Array.isArray(content)) {
+    return { toolErrored: false };
+  }
+  const errorBlocks = content.filter(
+    (block) => isToolResultErrorBlock(block)
+  );
+  if (errorBlocks.length === 0) {
+    return { toolErrored: false };
+  }
+  const fatalBlock = errorBlocks.find((block) => block.error_class === "fatal");
+  if (fatalBlock && typeof fatalBlock.tool_use_id === "string") {
+    return { toolErrored: true, fatalToolUseId: fatalBlock.tool_use_id };
+  }
+  return { toolErrored: true };
 }
 
 // src/utils/session/singleFactLayer.ts
@@ -31080,18 +31124,77 @@ function normalizeMessagesForSingleFactLayer(messages) {
   });
 }
 
-// src/app/queryRuntime/sessionAdapterHooks.ts
-var querySessionPrimaryAdapterHooksInline = {
-  resolveModelWithInfo: (modelPointer) => getModelManager().resolveModelWithInfo(modelPointer),
-  createStreamTypedProjector,
-  normalizeMessagesForSingleFactLayer,
-  projectLifecycleEventsToTypedParts,
-  projectMessageToTypedParts,
-  emitTypedPart,
-  buildSkeletonBlocksFromTypedParts,
-  flushTypedPartBuffer,
-  consumeProjectorCompatibilityMetrics
+// src/app/queryRuntime/errorMapping.ts
+var ERROR_CLASS_BY_CODE = {
+  ENOENT: "soft",
+  EISDIR: "soft",
+  EACCES: "retryable",
+  EPERM: "retryable",
+  EMFILE: "retryable",
+  ENFILE: "retryable",
+  EIO: "fatal",
+  ENODEV: "fatal",
+  EBUSY: "fatal"
 };
+function formatError(error) {
+  if (!(error instanceof Error)) {
+    return String(error);
+  }
+  const parts = [error.message];
+  if ("stderr" in error && typeof error.stderr === "string") {
+    parts.push(error.stderr);
+  }
+  if ("stdout" in error && typeof error.stdout === "string") {
+    parts.push(error.stdout);
+  }
+  const fullMessage = parts.filter(Boolean).join("\n");
+  if (fullMessage.length <= 1e4) {
+    return fullMessage;
+  }
+  const halfLength = 5e3;
+  const start = fullMessage.slice(0, halfLength);
+  const end = fullMessage.slice(-halfLength);
+  return `${start}
+
+... [${fullMessage.length - 1e4} characters truncated] ...
+
+${end}`;
+}
+function extractErrorCode(error) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  if ("code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  return void 0;
+}
+function summarizeError(detail) {
+  const line = detail.split("\n").map((part) => part.trim()).find((part) => part.length > 0);
+  const summary = line ?? detail.trim();
+  return summary.length > 200 ? summary.slice(0, 200) : summary;
+}
+function getErrorClassFromCode(errorCode) {
+  if (!errorCode) return "soft";
+  return ERROR_CLASS_BY_CODE[errorCode] ?? "soft";
+}
+function createErrorToolResultBlock(args) {
+  const detail = typeof args.errorDetail === "string" ? args.errorDetail : typeof args.content === "string" ? args.content : JSON.stringify(args.content);
+  const errorCode = args.errorCode;
+  const errorClass = args.errorClass ?? getErrorClassFromCode(errorCode);
+  const summary = detail ? summarizeError(detail) : "";
+  return {
+    type: "tool_result",
+    content: args.content,
+    is_error: true,
+    tool_use_id: args.toolUseId,
+    error_class: errorClass,
+    ...errorCode ? { error_code: errorCode } : {},
+    ...summary ? { error_summary: summary } : {},
+    ...detail ? { error_detail: detail } : {},
+    ...args.rootToolUseId ? { root_tool_use_id: args.rootToolUseId } : {}
+  };
+}
 
 // src/app/queryRuntime/toolExecution.ts
 function buildToolHookBaseArgs(context, toolUseId) {
@@ -31123,23 +31226,6 @@ function applyHookOutcomeSideEffects(context, hookOutcome) {
     queueHookAdditionalContexts(context, hookOutcome.additionalContexts);
   }
 }
-function resolvePermissionExecutionPlan(args) {
-  const effectiveShouldSkipPermissionCheck = args.hookPermissionDecision === "allow" ? true : args.hookPermissionDecision === "ask" ? false : args.shouldSkipPermissionCheck;
-  const permissionContextForCall = args.hookPermissionDecision === "ask" && args.context.options?.toolPermissionContext && args.context.options.toolPermissionContext.mode !== "default" ? {
-    ...args.context,
-    options: {
-      ...args.context.options,
-      toolPermissionContext: {
-        ...args.context.options.toolPermissionContext,
-        mode: "default"
-      }
-    }
-  } : args.context;
-  return {
-    effectiveShouldSkipPermissionCheck,
-    permissionContextForCall
-  };
-}
 function resolveToolResultAssistantContent(args) {
   const rawContent = args.resultForAssistant ?? args.renderResultForAssistant(args.resultData);
   const shouldTruncate = typeof rawContent === "string" && shouldApplyToolOutputTruncation(args.resultData);
@@ -31147,31 +31233,6 @@ function resolveToolResultAssistantContent(args) {
     permissionMode: args.permissionMode
   }).content : rawContent;
 }
-function toStructuredToolResultMessages(newMessages) {
-  if (!Array.isArray(newMessages)) {
-    return [];
-  }
-  return newMessages.filter(
-    (message) => Boolean(message) && typeof message === "object" && "type" in message
-  );
-}
-function buildToolResultEnvelope(args) {
-  return {
-    blocks: [
-      {
-        type: "tool_result",
-        content: args.content,
-        tool_use_id: args.toolUseId
-      }
-    ],
-    toolUseResult: {
-      data: args.resultData,
-      resultForAssistant: args.content,
-      ...Array.isArray(args.newMessages) ? { newMessages: args.newMessages } : {},
-      ...args.contextModifier ? { contextModifier: args.contextModifier } : {}
-    }
-  };
-}
 function createToolExecutionErrorBlock(args) {
   const content = args.mode === "full" ? formatError(args.error) : `Tool execution failed: ${args.error instanceof Error ? args.error.message : String(args.error)}`;
   return createErrorToolResultBlock({
@@ -31180,6 +31241,37 @@ function createToolExecutionErrorBlock(args) {
     errorCode: extractErrorCode(args.error)
   });
 }
+function createToolNotFoundErrorMessage(args) {
+  return createUserMessageFromBlocks([
+    createErrorToolResultBlock({
+      toolUseId: args.toolUseId,
+      content: `Error: No such tool available: ${args.toolName}`,
+      errorCode: "TOOL_NOT_FOUND",
+      errorClass: "soft"
+    })
+  ]);
+}
+function createSyntheticToolUseErrorMessage(args) {
+  if (args.reason === "user_interrupted") {
+    return createUserMessageFromBlocks([
+      createErrorToolResultBlock({
+        toolUseId: args.toolUseId,
+        content: REJECT_MESSAGE,
+        errorCode: "USER_INTERRUPTED",
+        errorClass: "fatal"
+      })
+    ]);
+  }
+  return createUserMessageFromBlocks([
+    createErrorToolResultBlock({
+      toolUseId: args.toolUseId,
+      content: "<tool_use_error>Sibling tool call errored</tool_use_error>",
+      errorCode: "SIBLING_ERROR",
+      errorClass: "fatal",
+      rootToolUseId: args.rootToolUseId
+    })
+  ]);
+}
 function resolveWarningText(warnings) {
   if (!Array.isArray(warnings) || warnings.length === 0) {
     return void 0;
@@ -31258,19 +31350,25 @@ function buildResultDispatchItems(args) {
       tools: args.defaultTools
     });
   }
-  const userMessage = buildToolResultEnvelope({
-    toolUseId: args.toolUseId,
-    content: args.content,
-    resultData: args.resultData,
-    newMessages: args.newMessages,
-    contextModifier: args.contextModifier
-  });
   items.push({
     kind: "user_message",
-    blocks: userMessage.blocks,
-    toolUseResult: userMessage.toolUseResult
+    blocks: [
+      {
+        type: "tool_result",
+        content: args.content,
+        tool_use_id: args.toolUseId
+      }
+    ],
+    toolUseResult: {
+      data: args.resultData,
+      resultForAssistant: args.content,
+      ...Array.isArray(args.newMessages) ? { newMessages: args.newMessages } : {},
+      ...args.contextModifier ? { contextModifier: args.contextModifier } : {}
+    }
   });
-  const structuredMessages = toStructuredToolResultMessages(args.newMessages);
+  const structuredMessages = Array.isArray(args.newMessages) ? args.newMessages.filter(
+    (message) => Boolean(message) && typeof message === "object" && "type" in message
+  ) : [];
   for (const message of structuredMessages) {
     items.push({
       kind: "structured_message",
@@ -31303,37 +31401,207 @@ function buildWarningDispatchItems(args) {
     }
   ];
 }
-async function resolvePermissionResult(args) {
-  if (args.effectiveShouldSkipPermissionCheck) {
-    return { result: true };
-  }
-  return args.canUseTool(
+async function resolvePermissionCheckOutcome(args) {
+  const effectiveShouldSkipPermissionCheck = args.hookPermissionDecision === "allow" ? true : args.hookPermissionDecision === "ask" ? false : args.shouldSkipPermissionCheck;
+  const permissionContextForCall = args.hookPermissionDecision === "ask" && args.context.options?.toolPermissionContext && args.context.options.toolPermissionContext.mode !== "default" ? {
+    ...args.context,
+    options: {
+      ...args.context.options,
+      toolPermissionContext: {
+        ...args.context.options.toolPermissionContext,
+        mode: "default"
+      }
+    }
+  } : args.context;
+  const permissionResult = effectiveShouldSkipPermissionCheck ? { result: true } : await args.canUseTool(
     args.tool,
     args.normalizedInput,
-    { ...args.permissionContextForCall, toolUseId: args.toolUseId },
+    { ...permissionContextForCall, toolUseId: args.toolUseId },
     args.assistantMessage
   );
+  return { permissionResult };
 }
-async function resolvePermissionCheckOutcome(args) {
-  const { effectiveShouldSkipPermissionCheck, permissionContextForCall } = resolvePermissionExecutionPlan({
-    context: args.context,
-    hookPermissionDecision: args.hookPermissionDecision,
-    shouldSkipPermissionCheck: args.shouldSkipPermissionCheck
+async function* checkPermissionsAndCallTool(args) {
+  const preprocessedInput = preprocessToolInput(args.tool, args.input);
+  const isValidInput = args.tool.inputSchema.safeParse(preprocessedInput);
+  if (!isValidInput.success) {
+    const errorMessage = resolveInitialInputValidationMessage({
+      toolName: args.tool.name,
+      preprocessedInput,
+      validationMessage: isValidInput.error.message
+    });
+    yield createUserMessageFromBlocks([
+      createInputValidationErrorBlock({
+        toolUseId: args.toolUseID,
+        content: errorMessage
+      })
+    ]);
+    return;
+  }
+  let normalizedInput = normalizeToolInput(args.tool, isValidInput.data);
+  const isValidCall = await args.tool.validateInput?.(
+    normalizedInput,
+    args.context
+  );
+  if (isValidCall?.result === false) {
+    yield createUserMessageFromBlocks([
+      createInputValidationErrorBlock({
+        toolUseId: args.toolUseID,
+        content: isValidCall.message
+      })
+    ]);
+    return;
+  }
+  const hookOutcome = await runPreToolUseHooks({
+    toolName: args.tool.name,
+    toolInput: normalizedInput,
+    toolUseId: args.toolUseID,
+    ...buildToolHookBaseArgs(args.context, args.toolUseID)
   });
-  const permissionResult = await resolvePermissionResult({
-    effectiveShouldSkipPermissionCheck,
+  if (hookOutcome.kind === "block") {
+    yield createUserMessageFromBlocks([
+      createHookBlockedErrorBlock({
+        toolUseId: args.toolUseID,
+        content: hookOutcome.message
+      })
+    ]);
+    return;
+  }
+  const preWarningDispatchItems = buildWarningDispatchItems({
+    warnings: hookOutcome.warnings,
+    defaultTools: args.context.options?.tools ?? []
+  });
+  for (const dispatchItem of preWarningDispatchItems) {
+    yield createProgressMessage(
+      args.toolUseID,
+      args.siblingToolUseIDs,
+      createAssistantMessage(dispatchItem.warningText),
+      [],
+      dispatchItem.tools,
+      { progressState: "running" }
+    );
+  }
+  applyHookOutcomeSideEffects(args.context, hookOutcome);
+  const updatedInputResult = await resolveHookUpdatedInput({
+    tool: args.tool,
+    normalizedInput,
+    updatedInput: hookOutcome.updatedInput,
+    context: args.context
+  });
+  if (updatedInputResult.kind === "invalid") {
+    yield createUserMessageFromBlocks([
+      createInputValidationErrorBlock({
+        toolUseId: args.toolUseID,
+        content: updatedInputResult.message
+      })
+    ]);
+    return;
+  }
+  if (updatedInputResult.kind === "updated") {
+    normalizedInput = normalizeToolInput(args.tool, updatedInputResult.normalizedInput);
+  }
+  const { permissionResult } = await resolvePermissionCheckOutcome({
+    context: args.context,
+    hookPermissionDecision: hookOutcome.kind === "allow" ? hookOutcome.permissionDecision : void 0,
+    shouldSkipPermissionCheck: args.shouldSkipPermissionCheck,
     canUseTool: args.canUseTool,
     tool: args.tool,
-    normalizedInput: args.normalizedInput,
-    permissionContextForCall,
-    toolUseId: args.toolUseId,
+    normalizedInput,
+    toolUseId: args.toolUseID,
     assistantMessage: args.assistantMessage
   });
-  return {
-    effectiveShouldSkipPermissionCheck,
-    permissionContextForCall,
-    permissionResult
-  };
+  if (permissionResult.result === false) {
+    yield createUserMessageFromBlocks([
+      createPermissionDeniedErrorBlock({
+        toolUseId: args.toolUseID,
+        content: permissionResult.message
+      })
+    ]);
+    return;
+  }
+  try {
+    const generator = args.tool.call(normalizedInput, {
+      ...args.context,
+      toolUseId: args.toolUseID
+    });
+    for await (const result of generator) {
+      switch (result.type) {
+        case "result": {
+          const content = resolveToolResultAssistantContent({
+            resultForAssistant: result.resultForAssistant,
+            resultData: result.data,
+            renderResultForAssistant: (data) => args.tool.renderResultForAssistant(data),
+            permissionMode: args.context.options?.toolPermissionContext?.mode
+          });
+          const postOutcome = await runPostToolUseHooks({
+            toolName: args.tool.name,
+            toolInput: normalizedInput,
+            toolResult: result.data,
+            toolUseId: args.toolUseID,
+            ...buildToolHookBaseArgs(args.context, args.toolUseID)
+          });
+          applyHookOutcomeSideEffects(args.context, postOutcome);
+          const dispatchItems = buildResultDispatchItems({
+            toolUseId: args.toolUseID,
+            content,
+            resultData: result.data,
+            newMessages: result.newMessages,
+            contextModifier: result.contextModifier,
+            defaultTools: args.context.options?.tools ?? [],
+            postWarnings: postOutcome.warnings
+          });
+          for (const dispatchItem of dispatchItems) {
+            if (dispatchItem.kind === "warning_progress") {
+              yield createProgressMessage(
+                args.toolUseID,
+                args.siblingToolUseIDs,
+                createAssistantMessage(dispatchItem.warningText),
+                [],
+                dispatchItem.tools,
+                { progressState: "running" }
+              );
+              continue;
+            }
+            if (dispatchItem.kind === "user_message") {
+              yield createUserMessageFromBlocks(
+                dispatchItem.blocks,
+                dispatchItem.toolUseResult
+              );
+              continue;
+            }
+            yield dispatchItem.message;
+          }
+          return;
+        }
+        case "progress": {
+          const progressPayload = buildRunningProgressPayload({
+            content: result.content,
+            normalizedMessages: result.normalizedMessages,
+            tools: result.tools,
+            defaultTools: args.context.options?.tools ?? []
+          });
+          yield createProgressMessage(
+            args.toolUseID,
+            args.siblingToolUseIDs,
+            progressPayload.content,
+            progressPayload.normalizedMessages,
+            progressPayload.tools,
+            { progressState: "running" }
+          );
+          break;
+        }
+      }
+    }
+  } catch (error) {
+    logError(error);
+    yield createUserMessageFromBlocks([
+      createToolExecutionErrorBlock({
+        toolUseId: args.toolUseID,
+        error,
+        mode: "full"
+      })
+    ]);
+  }
 }
 
 // src/app/query.ts
@@ -31342,28 +31610,6 @@ function isToolUseLikeBlock(block) {
 }
 var __isToolUseLikeBlockForTests = isToolUseLikeBlock;
 var reminderChannelRounds = [];
-function createSyntheticToolUseErrorMessage(args) {
-  const { toolUseId, reason, rootToolUseId } = args;
-  if (reason === "user_interrupted") {
-    return createUserMessageFromBlocks([
-      createErrorToolResultBlock({
-        toolUseId,
-        content: REJECT_MESSAGE,
-        errorCode: "USER_INTERRUPTED",
-        errorClass: "fatal"
-      })
-    ]);
-  }
-  return createUserMessageFromBlocks([
-    createErrorToolResultBlock({
-      toolUseId,
-      content: "<tool_use_error>Sibling tool call errored</tool_use_error>",
-      errorCode: "SIBLING_ERROR",
-      errorClass: "fatal",
-      rootToolUseId
-    })
-  ]);
-}
 var ToolUseQueue = class {
   toolDefinitions;
   canUseTool;
@@ -31412,16 +31658,13 @@ var ToolUseQueue = class {
         if (!entry.queuedProgressEmitted) {
           entry.queuedProgressEmitted = true;
           entry.pendingProgress.push(
-            createProgressMessage(
-              entry.id,
-              this.siblingToolUseIDs,
-              createAssistantMessage(
-                `${TOOL_PROGRESS_OPEN_TAG}Waiting\u2026${TOOL_PROGRESS_CLOSE_TAG}`
-              ),
-              [],
-              this.toolUseContext.options.tools,
-              { progressState: "queued_waiting" }
-            )
+            createQueuedWaitingProgressMessage({
+              toolUseId: entry.id,
+              siblingToolUseIDs: this.siblingToolUseIDs,
+              tools: this.toolUseContext.options.tools,
+              openTag: TOOL_PROGRESS_OPEN_TAG,
+              closeTag: TOOL_PROGRESS_CLOSE_TAG
+            })
           );
           if (this.progressAvailableResolve) {
             this.progressAvailableResolve();
@@ -31480,21 +31723,12 @@ var ToolUseQueue = class {
           );
           break;
         }
-        if (message.type === "user" && Array.isArray(message.message.content) && message.message.content.some(
-          (block) => block.type === "tool_result" && block.is_error === true
-        )) {
-          const fatal = message.message.content.some(
-            (block) => block.type === "tool_result" && block.is_error === true && block.error_class === "fatal"
-          );
-          if (fatal) {
+        const errorState = resolveToolQueueUserMessageErrorState(message);
+        if (errorState.toolErrored) {
+          if (errorState.fatalToolUseId) {
             this.hasFatalErrored = true;
             if (!this.fatalToolUseId) {
-              const fatalBlock = message.message.content.find(
-                (block) => block.type === "tool_result" && block.is_error === true && block.error_class === "fatal" && typeof block.tool_use_id === "string"
-              );
-              if (fatalBlock) {
-                this.fatalToolUseId = fatalBlock.tool_use_id;
-              }
+              this.fatalToolUseId = errorState.fatalToolUseId;
             }
           }
           toolErrored = true;
@@ -31507,10 +31741,9 @@ var ToolUseQueue = class {
           }
         } else {
           results.push(message);
-          if (message.type === "user" && message.toolUseResult?.contextModifier) {
-            contextModifiers.push(
-              message.toolUseResult.contextModifier.modifyContext
-            );
+          const modifyContext = resolveToolQueueContextModifier(message);
+          if (modifyContext) {
+            contextModifiers.push(modifyContext);
           }
         }
       }
@@ -31616,7 +31849,17 @@ async function* query(messages, systemPrompt, context, canUseTool, toolUseContex
     requestId: context.requestId,
     currentRequestId: getCurrentRequest()?.id,
     isTestEnv: process.env.NODE_ENV === "test",
-    hooks: querySessionPrimaryAdapterHooksInline,
+    hooks: {
+      resolveModelWithInfo: (modelPointer) => getModelManager().resolveModelWithInfo(modelPointer),
+      createStreamTypedProjector,
+      normalizeMessagesForSingleFactLayer,
+      projectLifecycleEventsToTypedParts,
+      projectMessageToTypedParts,
+      emitTypedPart,
+      buildSkeletonBlocksFromTypedParts,
+      flushTypedPartBuffer,
+      consumeProjectorCompatibilityMetrics
+    },
     logUserFriendly,
     stream: async function* (preparedMessages) {
       yield* queryCore(
@@ -31833,23 +32076,7 @@ async function* queryCore(messages, systemPrompt, context, canUseTool, toolUseCo
     }
     updateHookTranscriptForMessages(toolUseContext, messages);
     {
-      const last2 = messages[messages.length - 1];
-      let userPromptText = null;
-      if (last2 && typeof last2 === "object" && last2.type === "user") {
-        const content = last2.message?.content;
-        if (typeof content === "string") {
-          userPromptText = content;
-        } else if (Array.isArray(content)) {
-          const hasToolResult = content.some(
-            (b) => b && typeof b === "object" && b.type === "tool_result"
-          );
-          if (!hasToolResult) {
-            userPromptText = content.filter(
-              (b) => b && typeof b === "object" && b.type === "text"
-            ).map((b) => String(b.text ?? "")).join("");
-          }
-        }
-      }
+      const userPromptText = extractUserPromptTextFromMessages(messages);
       if (userPromptText !== null) {
         toolUseContext.options.lastUserPrompt = userPromptText;
         const promptOutcome = await runUserPromptSubmitHooks({
@@ -31897,10 +32124,7 @@ async function* queryCore(messages, systemPrompt, context, canUseTool, toolUseCo
       fullSystemPrompt.push(effectiveSystemReminders);
       fullSystemPrompt.push("\n---\n");
     }
-    const planModeAdditions = getPlanModeSystemPromptAdditions(
-      messages,
-      toolUseContext
-    );
+    const planModeAdditions = getPlanModeSystemPromptAdditions(messages, toolUseContext);
     if (planModeAdditions.length > 0) {
       fullSystemPrompt.push(...planModeAdditions);
     }
@@ -32032,17 +32256,12 @@ async function* queryCore(messages, systemPrompt, context, canUseTool, toolUseCo
     const shouldSkipPermissionCheck = result.shouldSkipPermissionCheck;
     const parentUserMessage = findNaturalUserMessageForParent(messages);
     const toolUseMessages = assistantMessage.message.content.filter(isToolUseLikeBlock);
-    const usage = assistantMessage.message?.usage;
-    const lifecycleTokens = usage && typeof usage === "object" ? {
-      ...Number.isFinite(Number(usage.input_tokens)) ? { input: Number(usage.input_tokens) } : {},
-      ...Number.isFinite(Number(usage.output_tokens)) ? { output: Number(usage.output_tokens) } : {},
-      ...Number.isFinite(Number(usage.input_tokens)) || Number.isFinite(Number(usage.output_tokens)) ? {
-        total: Number(usage.input_tokens ?? 0) + Number(usage.output_tokens ?? 0)
-      } : {}
-    } : void 0;
+    const lifecycleTokens = resolveLifecycleTokensFromAssistantMessage(assistantMessage);
     if (!toolUseMessages.length) {
-      const stopHookEvent = toolUseContext.agentId && toolUseContext.agentId !== "main" ? "SubagentStop" : "Stop";
-      const stopReason = assistantMessage.message?.stop_reason || assistantMessage.message?.stopReason || "end_turn";
+      const { hookEvent: stopHookEvent, stopReason } = resolveStopHookSignal({
+        agentId: toolUseContext.agentId,
+        assistantMessage
+      });
       const finish = mapFinishReason(stopReason);
       lifecycleEvents.finishStep({
         stepId,
@@ -32053,56 +32272,28 @@ async function* queryCore(messages, systemPrompt, context, canUseTool, toolUseCo
         costUSD: assistantMessage.costUSD,
         ...lifecycleTokens ? { tokens: lifecycleTokens } : {}
       });
-      const stopOutcome = await runStopHooks({
+      const stopHookResult = await runStopHookAttempt({
+        context: toolUseContext,
         hookEvent: stopHookEvent,
-        reason: String(stopReason ?? ""),
-        retryEntryKey: buildRetryEntryKey([
-          toolUseContext.sessionId,
-          toolUseContext.parentSessionId,
-          toolUseContext.childSessionId,
-          toolUseContext.agentId,
-          String(stopReason ?? "")
-        ]),
-        retryAttempt: stopHookAttempts,
-        sessionId: toolUseContext.sessionId,
-        parentSessionId: toolUseContext.parentSessionId,
-        childSessionId: toolUseContext.childSessionId,
-        agentId: toolUseContext.agentId,
-        permissionMode: toolUseContext.options?.toolPermissionContext?.mode,
-        cwd: getCwd(),
-        transcriptPath: getHookTranscriptPath(toolUseContext),
-        safeMode: toolUseContext.options?.safeMode ?? false,
+        stopReason,
         stopHookActive,
-        signal: toolUseContext.abortController.signal
+        stopHookAttempts
       });
-      if (stopOutcome.systemMessages.length > 0) {
-        queueHookSystemMessages(toolUseContext, stopOutcome.systemMessages);
-      }
-      if (stopOutcome.additionalContexts.length > 0) {
-        queueHookAdditionalContexts(
+      if (stopHookResult.shouldRetry) {
+        yield* await queryCore(
+          [...messages, assistantMessage],
+          systemPrompt,
+          context,
+          canUseTool,
           toolUseContext,
-          stopOutcome.additionalContexts
+          getBinaryFeedbackResponse,
+          {
+            stopHookActive: true,
+            stopHookAttempts: stopHookResult.nextStopHookAttempts,
+            startupEmitted: true
+          }
         );
-      }
-      if (stopOutcome.decision === "block") {
-        queueHookSystemMessages(toolUseContext, [stopOutcome.message]);
-        const MAX_STOP_HOOK_ATTEMPTS = 5;
-        if (stopHookAttempts < MAX_STOP_HOOK_ATTEMPTS) {
-          yield* await queryCore(
-            [...messages, assistantMessage],
-            systemPrompt,
-            context,
-            canUseTool,
-            toolUseContext,
-            getBinaryFeedbackResponse,
-            {
-              stopHookActive: true,
-              stopHookAttempts: stopHookAttempts + 1,
-              startupEmitted: true
-            }
-          );
-          return;
-        }
+        return;
       }
       if (!parentUserMessage?.uuid) {
         sessionContext?.setIdle();
@@ -32161,7 +32352,7 @@ async function* queryCore(messages, systemPrompt, context, canUseTool, toolUseCo
     const toolMessagesForNextTurn = [];
     for await (const message of toolQueue.getRemainingResults()) {
       yield message;
-      if (message.type !== "progress") {
+      if (isToolQueueNextTurnMessage(message)) {
         toolMessagesForNextTurn.push(message);
       }
     }
@@ -32171,22 +32362,18 @@ async function* queryCore(messages, systemPrompt, context, canUseTool, toolUseCo
       yield createAssistantMessage(INTERRUPT_MESSAGE_FOR_TOOL_USE);
       return;
     }
-    try {
-      yield* await queryCore(
-        [...messages, assistantMessage, ...toolMessagesForNextTurn],
-        systemPrompt,
-        context,
-        canUseTool,
-        toolUseContext,
-        getBinaryFeedbackResponse,
-        {
-          ...hookState ?? {},
-          startupEmitted: true
-        }
-      );
-    } catch (error) {
-      throw error;
-    }
+    yield* await queryCore(
+      [...messages, assistantMessage, ...toolMessagesForNextTurn],
+      systemPrompt,
+      context,
+      canUseTool,
+      toolUseContext,
+      getBinaryFeedbackResponse,
+      {
+        ...hookState ?? {},
+        startupEmitted: true
+      }
+    );
   } catch (error) {
     sessionContext?.setErrored();
     throw error;
@@ -32244,14 +32431,10 @@ async function* runToolUse(toolUse, siblingToolUseIDs, assistantMessage, canUseT
       toolUseID: toolUse.id,
       requestId: currentRequest?.id
     });
-    yield createUserMessageFromBlocks([
-      createErrorToolResultBlock({
-        toolUseId: toolUse.id,
-        content: `Error: No such tool available: ${toolName}`,
-        errorCode: "TOOL_NOT_FOUND",
-        errorClass: "soft"
-      })
-    ]);
+    yield createToolNotFoundErrorMessage({
+      toolUseId: toolUse.id,
+      toolName
+    });
     sessionContext?.finishTool(toolUse.id);
     return;
   }
@@ -32263,215 +32446,22 @@ async function* runToolUse(toolUse, siblingToolUseIDs, assistantMessage, canUseT
     requestId: currentRequest?.id
   });
   try {
-    for await (const message of checkPermissionsAndCallTool(
+    for await (const message of checkPermissionsAndCallTool({
       tool,
-      toolUse.id,
+      toolUseID: toolUse.id,
       siblingToolUseIDs,
-      toolInput,
-      toolUseContext,
+      input: toolInput,
+      context: toolUseContext,
       canUseTool,
       assistantMessage,
       shouldSkipPermissionCheck
-    )) {
+    })) {
       yield message;
     }
-  } catch (e) {
-    logError(e);
-    const errorMessage = createUserMessageFromBlocks([
-      createToolExecutionErrorBlock({
-        toolUseId: toolUse.id,
-        error: e,
-        mode: "summary"
-      })
-    ]);
-    yield errorMessage;
   } finally {
     sessionContext?.finishTool(toolUse.id);
   }
 }
-async function* checkPermissionsAndCallTool(tool, toolUseID, siblingToolUseIDs, input, context, canUseTool, assistantMessage, shouldSkipPermissionCheck) {
-  const preprocessedInput = preprocessToolInput(tool, input);
-  const isValidInput = tool.inputSchema.safeParse(preprocessedInput);
-  if (!isValidInput.success) {
-    const errorMessage = resolveInitialInputValidationMessage({
-      toolName: tool.name,
-      preprocessedInput,
-      validationMessage: isValidInput.error.message
-    });
-    yield createUserMessageFromBlocks([
-      createInputValidationErrorBlock({
-        toolUseId: toolUseID,
-        content: errorMessage
-      })
-    ]);
-    return;
-  }
-  let normalizedInput = normalizeToolInput(tool, isValidInput.data);
-  const isValidCall = await tool.validateInput?.(
-    normalizedInput,
-    context
-  );
-  if (isValidCall?.result === false) {
-    yield createUserMessageFromBlocks([
-      createInputValidationErrorBlock({
-        toolUseId: toolUseID,
-        content: isValidCall.message
-      })
-    ]);
-    return;
-  }
-  const hookOutcome = await runPreToolUseHooks({
-    toolName: tool.name,
-    toolInput: normalizedInput,
-    toolUseId: toolUseID,
-    ...buildToolHookBaseArgs(context, toolUseID)
-  });
-  if (hookOutcome.kind === "block") {
-    yield createUserMessageFromBlocks([
-      createHookBlockedErrorBlock({
-        toolUseId: toolUseID,
-        content: hookOutcome.message
-      })
-    ]);
-    return;
-  }
-  const preWarningDispatchItems = buildWarningDispatchItems({
-    warnings: hookOutcome.warnings,
-    defaultTools: context.options?.tools ?? []
-  });
-  for (const dispatchItem of preWarningDispatchItems) {
-    yield createProgressMessage(
-      toolUseID,
-      siblingToolUseIDs,
-      createAssistantMessage(dispatchItem.warningText),
-      [],
-      dispatchItem.tools,
-      { progressState: "running" }
-    );
-  }
-  applyHookOutcomeSideEffects(context, hookOutcome);
-  const updatedInputResult = await resolveHookUpdatedInput({
-    tool,
-    normalizedInput,
-    updatedInput: hookOutcome.updatedInput,
-    context
-  });
-  if (updatedInputResult.kind === "invalid") {
-    yield createUserMessageFromBlocks([
-      createInputValidationErrorBlock({
-        toolUseId: toolUseID,
-        content: updatedInputResult.message
-      })
-    ]);
-    return;
-  }
-  if (updatedInputResult.kind === "updated") {
-    normalizedInput = normalizeToolInput(tool, updatedInputResult.normalizedInput);
-  }
-  const hookPermissionDecision = hookOutcome.kind === "allow" ? hookOutcome.permissionDecision : void 0;
-  const { permissionResult } = await resolvePermissionCheckOutcome({
-    context,
-    hookPermissionDecision,
-    shouldSkipPermissionCheck,
-    canUseTool,
-    tool,
-    normalizedInput,
-    toolUseId: toolUseID,
-    assistantMessage
-  });
-  if (permissionResult.result === false) {
-    yield createUserMessageFromBlocks([
-      createPermissionDeniedErrorBlock({
-        toolUseId: toolUseID,
-        content: permissionResult.message
-      })
-    ]);
-    return;
-  }
-  try {
-    const generator = tool.call(normalizedInput, {
-      ...context,
-      toolUseId: toolUseID
-    });
-    for await (const result of generator) {
-      switch (result.type) {
-        case "result":
-          {
-            const content = resolveToolResultAssistantContent({
-              resultForAssistant: result.resultForAssistant,
-              resultData: result.data,
-              renderResultForAssistant: (data) => tool.renderResultForAssistant(data),
-              permissionMode: context.options?.toolPermissionContext?.mode
-            });
-            const postOutcome = await runPostToolUseHooks({
-              toolName: tool.name,
-              toolInput: normalizedInput,
-              toolResult: result.data,
-              toolUseId: toolUseID,
-              ...buildToolHookBaseArgs(context, toolUseID)
-            });
-            applyHookOutcomeSideEffects(context, postOutcome);
-            const dispatchItems = buildResultDispatchItems({
-              toolUseId: toolUseID,
-              content,
-              resultData: result.data,
-              newMessages: result.newMessages,
-              contextModifier: result.contextModifier,
-              defaultTools: context.options?.tools ?? [],
-              postWarnings: postOutcome.warnings
-            });
-            for (const dispatchItem of dispatchItems) {
-              if (dispatchItem.kind === "warning_progress") {
-                yield createProgressMessage(
-                  toolUseID,
-                  siblingToolUseIDs,
-                  createAssistantMessage(dispatchItem.warningText),
-                  [],
-                  dispatchItem.tools,
-                  { progressState: "running" }
-                );
-                continue;
-              }
-              if (dispatchItem.kind === "user_message") {
-                yield createUserMessageFromBlocks(
-                  dispatchItem.blocks,
-                  dispatchItem.toolUseResult
-                );
-                continue;
-              }
-              yield dispatchItem.message;
-            }
-          }
-          return;
-        case "progress":
-          const progressPayload = buildRunningProgressPayload({
-            content: result.content,
-            normalizedMessages: result.normalizedMessages,
-            tools: result.tools,
-            defaultTools: context.options?.tools ?? []
-          });
-          yield createProgressMessage(
-            toolUseID,
-            siblingToolUseIDs,
-            progressPayload.content,
-            progressPayload.normalizedMessages,
-            progressPayload.tools,
-            { progressState: "running" }
-          );
-          break;
-      }
-    }
-  } catch (error) {
-    logError(error);
-    yield createUserMessageFromBlocks([
-      createToolExecutionErrorBlock({
-        toolUseId: toolUseID,
-        error,
-        mode: "full"
-      })
-    ]);
-  }
-}
 
 // src/ui/components/binary-feedback/BinaryFeedback.tsx
 import { default as React96, useCallback as useCallback15 } from "react";
@@ -33647,7 +33637,7 @@ 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-VL7SVIXR.js");
+  const { queryModel } = await import("./llm-MASKGBQQ.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: