pybao-cli 1.5.4 → 1.5.6

package/dist/{chunk-A3WIVAEQ.js → chunk-SIE7VHSI.js}

@@ -2,11 +2,11 @@ import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
 import {
   listPybAgentSessions
-} from "./chunk-PUBU44C2.js";
+} from "./chunk-MLZYATJX.js";
 import {
   formatValidationResult,
   validatePluginOrMarketplacePath
-} from "./chunk-HLFRL66T.js";
+} from "./chunk-KO6ENKTQ.js";
 import {
   ConversationTracker,
   appendFinishState,
@@ -14,18 +14,18 @@ import {
   getConversationTrackerForContext,
   isFinishComplete,
   mapFinishReason
-} from "./chunk-U76IVQIF.js";
+} from "./chunk-HV4AL2VG.js";
 import {
   beginReplSessionScope
 } from "./chunk-F4AXICO7.js";
 import {
   loadPybAgentSessionMessages
-} from "./chunk-U5AY65EA.js";
+} from "./chunk-FZEVFEDH.js";
 import {
   appendSessionCustomTitleRecord,
   appendSessionJsonlFromMessage,
   appendSessionTagRecord
-} from "./chunk-A3NFY5TV.js";
+} from "./chunk-DTWSIMGF.js";
 import {
   drainHookSystemPromptAdditions,
   getHookTranscriptPath,
@@ -37,7 +37,7 @@ import {
   runStopHooks,
   runUserPromptSubmitHooks,
   updateHookTranscriptForMessages
-} from "./chunk-H744C3MH.js";
+} from "./chunk-VDIUCVWJ.js";
 import {
   DEFAULT_OUTPUT_STYLE,
   getAvailableOutputStyles,
@@ -46,11 +46,11 @@ import {
   getOutputStyleSystemPromptAdditions,
   resolveOutputStyleName,
   setCurrentOutputStyle
-} from "./chunk-QJFAJORX.js";
+} from "./chunk-TN4TZY7G.js";
 import {
   fetchCustomModels,
   getModelFeatures
-} from "./chunk-XXDO6DFB.js";
+} from "./chunk-CXLPIXKP.js";
 import {
   getSessionState
 } from "./chunk-XKYHFZEC.js";
@@ -58,7 +58,7 @@ import {
   queryLLM,
   queryQuick,
   verifyApiKey
-} from "./chunk-RYALTDJI.js";
+} from "./chunk-RPIILAZ5.js";
 import {
   DEFAULT_TIMEOUT_MS,
   FallbackToolUseRejectedMessage,
@@ -72,7 +72,7 @@ import {
   listMCPServers,
   loadMergedSettings,
   normalizeSandboxRuntimeConfigFromSettings
-} from "./chunk-SNLXXBXP.js";
+} from "./chunk-ZXUQALBB.js";
 import {
   addMarketplace,
   disableSkillPlugin,
@@ -85,11 +85,11 @@ import {
   refreshMarketplaceAsync,
   removeMarketplace,
   uninstallSkillPlugin
-} from "./chunk-2HK2IYZU.js";
+} from "./chunk-GPSHYLDR.js";
 import {
   loadToolPermissionContextFromDisk,
   persistToolPermissionUpdateToDisk
-} from "./chunk-6KR5MXW4.js";
+} from "./chunk-L3QFTUHN.js";
 import {
   applyToolPermissionContextUpdate,
   applyToolPermissionContextUpdates,
@@ -100,13 +100,13 @@ import {
   generateSystemReminders,
   resetReminderSession,
   systemReminderService
-} from "./chunk-BJHBQUXH.js";
+} from "./chunk-LMTF4FXH.js";
 import {
   clearAgentCache,
   getActiveAgents,
   getAgentByType,
   getAllAgents
-} from "./chunk-KG3TWGBU.js";
+} from "./chunk-6MZDAIOV.js";
 import {
   API_ERROR_MESSAGE_PREFIX,
   CANCEL_MESSAGE,
@@ -137,7 +137,7 @@ import {
   processUserInput,
   reorderMessages,
   stripSystemMessages
-} from "./chunk-IQV3HS22.js";
+} from "./chunk-BKG4N5U7.js";
 import {
   getRequestStatus,
   setRequestStatus,
@@ -167,7 +167,7 @@ import {
   normalizeFilePath,
   readTextContent,
   writeTextContent
-} from "./chunk-MBM5WCIY.js";
+} from "./chunk-BRDQQ6DH.js";
 import {
   parseBlockEdits
 } from "./chunk-QWIBSCDN.js";
@@ -177,18 +177,18 @@ import {
   ParserRegistry,
   initParser,
   loadLanguage
-} from "./chunk-HCGBT46A.js";
+} from "./chunk-WTF7JOIQ.js";
 import {
   getSettingsFileCandidates,
   loadSettingsWithLegacyFallback,
   readSettingsFile
-} from "./chunk-LKJJGCDP.js";
+} from "./chunk-PCSIH35L.js";
 import {
   getCustomCommandDirectories,
   hasCustomCommands,
   loadCustomCommands,
   reloadCustomCommands
-} from "./chunk-GL5OH6V4.js";
+} from "./chunk-33HCNVDW.js";
 import {
   getSessionPlugins
 } from "./chunk-BJSWTHRM.js";
@@ -197,7 +197,7 @@ import {
   buildModelProfileKey,
   getModelManager,
   isDefaultSlowAndCapableModel
-} from "./chunk-BVJZ6435.js";
+} from "./chunk-QD4OU22C.js";
 import {
   getCodeStyle,
   getContext,
@@ -205,16 +205,16 @@ import {
   getIsGit,
   getProjectDocs,
   getProjectStructureStatisticsBlock
-} from "./chunk-MWSQEKK6.js";
+} from "./chunk-DM2LV6T7.js";
 import {
   getRipgrepPath,
   getRipgrepPolicyMode,
   resolveRipgrepPolicy,
   ripGrep
-} from "./chunk-QMQYRYOJ.js";
+} from "./chunk-ZUWPUBWZ.js";
 import {
   getTheme
-} from "./chunk-TI57KY6H.js";
+} from "./chunk-NM5GLMVH.js";
 import {
   DEFAULT_GLOBAL_CONFIG,
   enableConfigs,
@@ -227,7 +227,7 @@ import {
   saveGlobalConfig,
   setAllPointersToModel,
   setModelPointer
-} from "./chunk-GUBKR5CU.js";
+} from "./chunk-YSZEGC2L.js";
 import {
   AbortError
 } from "./chunk-RQVLBMP7.js";
@@ -236,7 +236,7 @@ import {
   getCurrentRequest,
   logUserFriendly,
   markPhase
-} from "./chunk-Q64XH2HD.js";
+} from "./chunk-X7PDG4FB.js";
 import {
   ASCII_LOGO,
   BunShell,
@@ -277,10 +277,10 @@ import {
   setCwd,
   shouldApplyToolOutputTruncation,
   truncateToolOutput
-} from "./chunk-RHLNLOZP.js";
+} from "./chunk-GKFPN3PD.js";
 import {
   MACRO
-} from "./chunk-M73XAOTH.js";
+} from "./chunk-63RVOHFS.js";
 import {
   __export
 } from "./chunk-I3J4JYES.js";
@@ -461,7 +461,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-NNPSCVNC.js");
+    const { API_ERROR_MESSAGE_PREFIX: API_ERROR_MESSAGE_PREFIX2, queryQuick: queryQuick2 } = await import("./llm-OW7QDXPZ.js");
     const response = await queryQuick2({
       systemPrompt,
       userPrompt,
@@ -4263,7 +4263,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-NNPSCVNC.js");
+  const { API_ERROR_MESSAGE_PREFIX: API_ERROR_MESSAGE_PREFIX2, queryLLM: queryLLM2 } = await import("./llm-OW7QDXPZ.js");
   const queryLLMFn = args.queryLLMOverride ?? queryLLM2;
   const messages = [
     {
@@ -6624,7 +6624,7 @@ var FileEditTool = {
     const originalFileContent = currentFileContent;
     let totalPatch = [];
     const { SmartEdit } = await import("./smart-edit-AWHJDSU6.js");
-    const { findLspAnchor } = await import("./lspAnchor-DRPDOTNI.js");
+    const { findLspAnchor } = await import("./lspAnchor-B5AR4FPG.js");
     for (const op of editOperations) {
       const normalizedSearch = normalizeLineEndings(op.search);
       const normalizedReplace = normalizeLineEndings(op.replace);
@@ -8107,7 +8107,7 @@ import { z as z6 } from "zod";
 
 // src/tools/filesystem/GlobTool/prompt.ts
 var TOOL_NAME_FOR_PROMPT2 = "Glob";
-var DESCRIPTION4 = `- Fast file pattern matching tool that works with any codebase size
+var DESCRIPTION4 = `Fast file pattern matching tool that works with any codebase size
 
   ## WhenToUse & Best Practice
   - If you have keywords or fuzzy paths, use Glob first to narrow candidates.
@@ -8134,11 +8134,70 @@ var DESCRIPTION4 = `- Fast file pattern matching tool that works with any codeba
 
   ## Usage Details
   - Supports glob patterns like "**/*.js" or "src/**/*.ts"
-  - Returns matching file paths sorted by modification time
+  - Returns absolute file paths sorted by modification time (most recent first)
   - Use this tool when you need to find files by name patterns
-  - **Semantic Search**: Set \`semantic: true\` to use LSP workspace symbols when file-name matching fails. The \`pattern\` is treated as the symbol name.
-  - Semantic search is explicit: enable it only when normal matching fails or semantic lookup is required.
-  - If LSP is unavailable, it falls back to standard glob results without impacting the main file-finding flow.`;
+  - Powered by ripgrep with \`--files\` mode for fast pattern matching
+  - \`path\` parameter: Specify the directory to search in. If omitted, uses the current working directory. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Supports both relative and absolute paths.
+  - Results are limited to 100 files by default. If truncated, use a more specific path or pattern to narrow results.
+  - Search ignores .gitignore rules and includes hidden files by default.
+  - **Semantic Search**: Set \`semantic: true\` to enable LSP workspace symbol search as fallback.
+    - Trigger condition: Semantic search only activates when normal glob returns zero results.
+    - In semantic mode, the \`pattern\` parameter is interpreted as a symbol name (e.g., class name, function name) for LSP workspace symbol lookup.
+    - Returns file paths where the symbol is defined, helping locate source files by symbol name rather than filename pattern.
+    - On success: returns notice "Semantic search: added X results. Next: use LspTool for details."
+    - If LSP is unavailable, returns empty results with notice "Semantic search: LSP unavailable."
+  - **Empty Results**: When no files are found, use LS to confirm directory structure, then try broader patterns (e.g., src/**/*) or enable semantic search.
+  - **Error Handling**: Returns error if \`path\` does not exist or is not a valid directory.
+
+  ## Typical Usage Examples
+
+  ### Example 1: Project Structure Discovery (Unknown Codebase)
+  <example>
+  user: I'm new to this project, what's the structure?       
+  assistant: [uses Glob tool with pattern="**/package.json" to find project roots]
+  [uses Glob tool with pattern="src/**/*.{ts,tsx}" to understand source layout]
+  [uses LS tool on key directories to see detailed structure]
+  </example>
+
+  ### Example 2: Find Files by Type in Specific Area
+  <example>
+  user: Find all test files in the auth module
+  assistant: [uses Glob tool with pattern="src/auth/**/*.test.ts"]
+  [uses Read tool to examine specific test files]
+  </example>
+
+  ### Example 3: Config File Location (Deterministic)        
+  <example>
+  user: Where is the webpack configuration?
+  assistant: [uses Glob tool with pattern="**/webpack*.{js,ts,json}"]
+  [uses Read tool on the matched config file]
+  </example>
+
+  ### Example 4: Semantic Fallback for Symbol-Based File Lookup
+  <example>
+  user: Find the file that defines \`UserRepository\`        
+  assistant: [uses Glob tool with pattern="*UserRepository*" - no results]
+  [uses Glob tool with pattern="UserRepository" semantic:true]
+  [uses LSP goToDefinition to confirm the symbol location]
+  </example>
+
+  ### Example 5: Parallel Discovery for Entry Points
+  <example>
+  user: What are the main entry points of this application?
+  assistant: [uses Glob tool with pattern="**/index.{ts,js}"]
+  [uses Glob tool with pattern="**/main.{ts,js}"]
+  [uses Glob tool with pattern="**/app.{ts,js}"]
+  [uses Read tool to examine the entry point files]
+  </example>
+
+  ### Example 6: Narrow Down After Broad Results
+  <example>
+  user: Find all TypeScript files in the project
+  assistant: [uses Glob tool with pattern="**/*.ts" - returns 500+ files, truncated]
+  [uses Glob tool with pattern="src/**/*.ts" to focus on source code]
+  [uses Glob tool with pattern="src/core/**/*.ts" to narrow further if needed]
+  </example>
+`;
 
 // src/tools/filesystem/GlobTool/GlobTool.tsx
 import { existsSync as existsSync6, statSync as statSync9 } from "fs";
@@ -8298,7 +8357,7 @@ import { z as z7 } from "zod";
 
 // src/tools/search/GrepTool/prompt.ts
 var TOOL_NAME_FOR_PROMPT3 = "Grep";
-var DESCRIPTION5 = `A powerful search tool built on ripgrep
+var DESCRIPTION5 = `A powerful fast content search tool that works with any codebase size
 
   ## Best Practice
   - Use Grep as a "Scout" to *find* entry points based on text patterns.
@@ -8329,17 +8388,90 @@ var DESCRIPTION5 = `A powerful search tool built on ripgrep
 
   ## Usage Details
   - ALWAYS use Grep for search tasks. NEVER invoke \`grep\` or \`rg\` as a Bash command. The Grep tool has been optimized for correct permissions and access.
-  - Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
-  - Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
-  - Path guidance: If the user provides a path, use it directly. If the path is uncertain or model-inferred, confirm with LS/Glob first; otherwise search from the current working directory.
-  - Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts
-  - Pattern syntax: Uses ripgrep (not grep) - literal braces need escaping (use \`interface\\{\\}\` to find \`interface{}\` in Go code)
-  - Multiline matching: By default patterns match within single lines only. For cross-line patterns like \`struct \\{[\\s\\S]*?field\`, use \`multiline: true\`
-  - Semantic search: Set \`semantic: true\` to use LSP workspace symbols when text search yields no results or when you explicitly need symbol-based lookup. The \`pattern\` is treated as the symbol name.
-  - Semantic search is explicit: enable only when normal search has no results or when symbol-level lookup is required
+  - Powered by ripgrep for fast text search with full regex support (e.g., "log.*Error", "function\\s+\\w+")
+  - Pattern syntax: Uses ripgrep - literal braces need escaping (use \`interface\\{\\}\` to find \`interface{}\` in Go code)
+  - Excludes version control directories (.git, .svn, .hg, .bzr) automatically
+  - Includes hidden files by default
+
+  **Path & Scope**:
+  - \`path\` parameter: File or directory to search in. Defaults to current working directory.
+  - \`glob\` parameter: Filter files by glob pattern (e.g., "*.js", "*.{ts,tsx}") - maps to rg --glob
+  - \`type\` parameter: Filter by file type (e.g., "js", "py", "rust", "go", "java") - more efficient than glob for standard types
+  - Path guidance: If user provides a path, use it directly. If uncertain, confirm with LS/Glob first.
+
+  **Output Modes**:
+  - \`files_with_matches\` (default): Returns file paths sorted by modification time
+  - \`content\`: Shows matching lines with line numbers (supports -A/-B/-C context)
+  - \`count\`: Shows match counts per file
+
+  **Context & Pagination**:
+  - \`-B\`, \`-A\`, \`-C\`: Context lines before/after/around matches (requires output_mode: "content")
+  - \`-n\`: Show line numbers (default: true, requires output_mode: "content")
+  - \`head_limit\`: Limit output to first N entries (works across all modes)
+  - \`offset\`: Skip first N entries before applying head_limit
+  - \`multiline\`: Enable multiline mode where . matches newlines (default: false)
+
+  **Case Sensitivity**:
+  - \`-i\`: Enable case-insensitive search
+
+  **Semantic Search**:
+  - \`semantic: true\`: Enable LSP workspace symbol search as fallback when text search yields no results.
+  - \`symbol_type\`: Filter semantic search by symbol type (e.g., "class", "function", "variable"). Requires semantic: true.
+    - When \`symbol_type\` is specified, LSP search replaces (not augments) text search results.
+    - Supported types: file, module, namespace, package, class, method, property, field, constructor, enum, interface, function, variable, constant, struct, event, operator, typeparameter
   - Semantic output format: \`file:line: name (Kind)\` for quick follow-up reads
-  - If LSP is unavailable, fall back to plain text search results
-  - Use Task tool for open-ended searches requiring multiple rounds`;
+  - On success: returns notice "Semantic search: added X results. Next: use LspTool for details."
+  - If LSP is unavailable: returns "Semantic search: LSP unavailable."
+
+  **Result Handling**:
+  - Results are truncated at 20,000 characters if too large
+  - Use Task tool for open-ended searches requiring multiple rounds
+
+  **Typical Usage Examples**:
+
+  Example 1: Exact Error Message Tracing (Deterministic)
+  <example>
+  user: Where does the error "Connection timeout after 30s" come from?
+  assistant: [uses Grep tool with pattern="Connection timeout after 30s"output_mode="content"]
+  [uses Read tool to examine the error source and surrounding context]
+  </example>
+
+  Example 2: Precise Function Definition Lookup (Deterministic)
+  <example>
+  user: Find the implementation of \`calculateCompoundInterest\` function
+  assistant: [uses Grep tool with pattern="calculateCompoundInterest" type="ts"output_mode="content"]
+  [uses Read tool on the matched file to read the full implementation]
+  </example>
+
+  Example 3: Concept Search with Semantic Fallback
+  <example>
+  user: Where is authentication logic implemented?
+  assistant: [uses Grep tool with pattern="auth" type="ts" semantic: true]
+  [uses Read tool to examine the most relevant matches]
+  [uses LSP goToDefinition to trace the core auth flow]
+  </example>
+
+  Example 4: Iterative Narrowing for Broad Patterns
+  <example>
+  user: Find all API route definitions
+  assistant: [uses Grep tool with pattern="router\\.(get|post|put|delete)" type="ts"]       
+  [if too many results: adds path="src/routes" to narrow scope]
+  [uses Read tool to inspect specific route handlers]
+  </example>
+
+  Example 5: Handoff to LSP After Entry Point Found
+  <example>
+  user: Find all usages of the \`PaymentService\` class
+  assistant: [uses Grep tool with pattern="class PaymentService" type="ts"output_mode="content"]
+  [uses LSP findReferences at the class definition location to get all references]
+  </example>
+
+  Example 6: Case-Insensitive Search for Config Values
+  <example>
+  user: Where is the database host configured?
+  assistant: [uses Grep tool with pattern="database.*host|db_host|DB_HOST" -i: true]        
+  [uses Read tool to examine configuration files]
+  </example>`;
 
 // src/tools/search/GrepTool/GrepTool.tsx
 import { isAbsolute as isAbsolute7, relative as relative9, resolve as resolve7 } from "path";
@@ -11926,7 +12058,7 @@ async function createAndStoreApiKey(accessToken) {
       }
       saveGlobalConfig(config2);
       try {
-        const { resetAnthropicClient } = await import("./llm-NNPSCVNC.js");
+        const { resetAnthropicClient } = await import("./llm-OW7QDXPZ.js");
         resetAnthropicClient();
       } catch {
       }
@@ -16350,7 +16482,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-S7J5ODQU.js");
+  const { configureSessionPlugins } = await import("./pluginRuntime-BFIRISID.js");
   const { errors } = await configureSessionPlugins({ pluginDirs: dirs });
   return errors;
 }
@@ -17025,7 +17157,7 @@ async function call(onDone, context) {
     ModelConfig,
     {
       onClose: () => {
-        import("./model-XRNLQZ4O.js").then(({ reloadModelManager: reloadModelManager2 }) => {
+        import("./model-XWJ23WCS.js").then(({ reloadModelManager: reloadModelManager2 }) => {
           reloadModelManager2();
           triggerModelConfigChange();
           onDone();
@@ -25229,7 +25361,7 @@ function useStatusLine() {
 // src/ui/components/PromptInput.tsx
 async function interpretHashCommand(input) {
   try {
-    const { queryQuick: queryQuick2 } = await import("./llm-NNPSCVNC.js");
+    const { queryQuick: queryQuick2 } = await import("./llm-OW7QDXPZ.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.",
@@ -25542,7 +25674,7 @@ function PromptInput({
     if (messages2.length) {
       if (mode === "bash") {
         onQuery(messages2, newAbortController).then(async () => {
-          const { getCwd: getCwd2 } = await import("./state-CVENJNIV.js");
+          const { getCwd: getCwd2 } = await import("./state-SP4W7M4L.js");
           setCurrentPwd(getCwd2());
         });
       } else {
@@ -26801,6 +26933,344 @@ function startWatchingTaskList(listId) {
   startFallbackWatcher(entry);
 }
 
+// src/services/ai/streamTyped/partStore.ts
+import { appendFileSync, existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync13 } from "fs";
+import { dirname as dirname9 } from "path";
+
+// src/services/ai/streamTyped/partTypes.ts
+import { z as z11 } from "zod";
+var SOURCE_VALUES = ["auto_compact", "query_main"];
+var TOOL_STATUS_VALUES = ["pending", "running", "completed", "failed", "interrupted"];
+var textPayloadSchema = z11.object({
+  text: z11.string().min(1)
+});
+var reasoningPayloadSchema = z11.object({
+  text: z11.string().min(1)
+});
+var toolPayloadSchema = z11.object({
+  toolName: z11.string().min(1),
+  toolCallId: z11.string().min(1),
+  status: z11.enum(TOOL_STATUS_VALUES),
+  outputText: z11.string().optional()
+});
+var streamTypedPartBaseSchema = z11.object({
+  id: z11.string().min(1),
+  requestId: z11.string().min(1),
+  source: z11.enum(SOURCE_VALUES),
+  timestamp: z11.number().int().positive()
+});
+var streamTypedPartSchema = z11.discriminatedUnion("partType", [
+  streamTypedPartBaseSchema.extend({
+    partType: z11.literal("text"),
+    payload: textPayloadSchema
+  }),
+  streamTypedPartBaseSchema.extend({
+    partType: z11.literal("reasoning"),
+    payload: reasoningPayloadSchema
+  }),
+  streamTypedPartBaseSchema.extend({
+    partType: z11.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: input.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/partStore.ts
+function getStreamTypedOutputFilePath() {
+  return resolveXdgCachePath("telemetry/stream-typed-parts.jsonl");
+}
+function validateTypedPartRecord(record) {
+  return streamTypedPartSchema.safeParse(record).success;
+}
+function readAllValidParts(outputFilePath) {
+  if (!existsSync17(outputFilePath)) return [];
+  const raw = readFileSync13(outputFilePath, "utf8");
+  const lines = raw.split("\n").map((line) => line.trim()).filter(Boolean);
+  const parts = [];
+  for (const line of lines) {
+    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 (!existsSync17(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/eventAssembler.ts
+function createAssemblerState(requestId, source = "auto_compact") {
+  return {
+    requestId,
+    parts: [],
+    textBuffer: {},
+    reasoningBuffer: {},
+    toolMap: {},
+    source
+  };
+}
+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,
+      source: state.source
+    })
+  );
+}
+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,
+      source: state.source
+    })
+  );
+}
+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,
+      source: state.source
+    })
+  );
+  if (event.status === "completed" || event.status === "failed" || event.status === "interrupted") {
+    delete state.toolMap[event.toolCallId];
+  }
+}
+function flushTypedParts(state) {
+  const parts = state.parts.slice();
+  state.parts.length = 0;
+  return parts;
+}
+
+// src/services/ai/streamTyped/projector.ts
+function supportsRichToolResultByProvider(provider) {
+  return String(provider ?? "").trim().toLowerCase() === "anthropic";
+}
+function extractToolResultText(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 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 ?? "");
+      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 = extractToolResultText(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 ?? ""
+  );
+  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);
+}
+
 // src/utils/session/fileRecoveryCore.ts
 var MAX_FILES_TO_RECOVER = 5;
 var MAX_TOKENS_PER_FILE = 1e4;
@@ -26889,6 +27359,34 @@ function computeAutoCompactMetrics(events) {
     crossReplayErrors,
     crossReplayTotal
   );
+  const sessionTypedPathEvents = events.filter(
+    (event) => event.phase === "SESSION_TYPED_PATH_APPLIED"
+  );
+  const sessionFallbackEvents = events.filter(
+    (event) => event.phase === "SESSION_CANONICAL_FALLBACK_APPLIED"
+  );
+  const typed_primary_path_rate = sessionTypedPathEvents.length + sessionFallbackEvents.length > 0 ? safeDivide(
+    sessionTypedPathEvents.length,
+    sessionTypedPathEvents.length + sessionFallbackEvents.length
+  ) : void 0;
+  const boundaryEvents = events.filter(
+    (event) => event.phase === "COMPACTION_BOUNDARY_APPLIED"
+  );
+  const compaction_boundary_hit_rate = boundaryEvents.length > 0 ? safeDivide(
+    boundaryEvents.filter((event) => event.data?.applied === true).length,
+    boundaryEvents.length
+  ) : void 0;
+  const replayOutcomeEvents = boundaryEvents.filter(
+    (event) => ["replayed_latest_user_task", "synthetic_continue_prompt"].includes(
+      String(event.data?.replayMode ?? "")
+    )
+  );
+  const overflow_replay_success_rate = replayOutcomeEvents.length > 0 ? safeDivide(
+    replayOutcomeEvents.filter(
+      (event) => event.data?.replayMode === "replayed_latest_user_task"
+    ).length,
+    replayOutcomeEvents.length
+  ) : void 0;
   const sanitizerEvents = events.filter(
     (event) => event.phase === "AUTO_COMPACT_SANITIZER_APPLIED"
   );
@@ -26940,6 +27438,9 @@ function computeAutoCompactMetrics(events) {
     compact_retry_success_rate,
     thinking_first_ratio,
     cross_model_replay_error_rate,
+    typed_primary_path_rate,
+    compaction_boundary_hit_rate,
+    overflow_replay_success_rate,
     noise_ratio_after_compaction,
     task_goal_retention_rate,
     result_fidelity_rate,
@@ -26975,7 +27476,13 @@ var AUTO_COMPACT_TELEMETRY_PHASES = /* @__PURE__ */ new Set([
   "MESSAGE_TRANSFORM_APPLIED",
   "AUTO_COMPACT_SANITIZER_APPLIED",
   "AUTO_COMPACT_SUMMARY_QUALITY",
-  "AUTO_COMPACT_BUDGET_APPLIED"
+  "AUTO_COMPACT_BUDGET_APPLIED",
+  "COMPACTION_BOUNDARY_APPLIED",
+  "SESSION_TYPED_PATH_APPLIED",
+  "SESSION_CANONICAL_FALLBACK_APPLIED",
+  "SESSION_TYPED_PATH_CONSISTENCY_FAILED",
+  "SESSION_TYPED_PATH_POLICY_APPLIED",
+  "SESSION_TYPED_PATH_AUTO_DEGRADED"
 ]);
 var AUTO_COMPACT_SINK_LISTENER_ID = "auto-compact-metrics-sink";
 var autoCompactSink = createAutoCompactMetricsSink();
@@ -27226,35 +27733,35 @@ function getModelCapabilities(modelName) {
 }
 
 // src/services/ai/policyDispatch/policyConfigLoader.ts
-import { existsSync as existsSync17, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync14 } from "fs";
 import { join as join14, resolve as resolve11 } 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([
+import { z as z12 } from "zod";
+var policyConfigSchema = z12.object({
+  version: z12.string().min(1),
+  defaults: z12.object({
+    reasoningPolicy: z12.enum([
       "preserve_reasoning_blocks",
       "map_to_provider_options",
       "flatten_to_text_fallback"
     ]).optional(),
-    normalizeProviderContent: z11.boolean().optional(),
-    trimCrossModelMetadata: z11.boolean().optional()
+    normalizeProviderContent: z12.boolean().optional(),
+    trimCrossModelMetadata: z12.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([
+  overrides: z12.array(
+    z12.object({
+      model: z12.string().min(1).optional(),
+      modelFamily: z12.string().min(1).optional(),
+      provider: z12.string().min(1).optional(),
+      scenario: z12.enum(["query", "auto_compact", "other"]).optional(),
+      reasoningPolicy: z12.enum([
         "preserve_reasoning_blocks",
         "map_to_provider_options",
         "flatten_to_text_fallback"
       ]).optional(),
-      normalizeProviderContent: z11.boolean().optional(),
-      trimCrossModelMetadata: z11.boolean().optional()
+      normalizeProviderContent: z12.boolean().optional(),
+      trimCrossModelMetadata: z12.boolean().optional()
     })
   ).optional().default([])
 });
@@ -27273,9 +27780,9 @@ function getDefaultPolicyConfigPath() {
 }
 function loadAutoCompactPolicyConfig(options) {
   const filePath = resolve11(options?.filePath ?? getDefaultPolicyConfigPath());
-  if (!existsSync17(filePath)) return null;
+  if (!existsSync18(filePath)) return null;
   try {
-    const raw = readFileSync13(filePath, "utf8");
+    const raw = readFileSync14(filePath, "utf8");
     const parsed = JSON.parse(raw);
     return policyConfigSchema.parse(parsed);
   } catch {
@@ -27361,218 +27868,6 @@ function resolveModelResponsePolicy(input) {
   };
 }
 
-// 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 existsSync18, mkdirSync as mkdirSync7, readFileSync as readFileSync14 } 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 (!existsSync18(outputFilePath)) return [];
-  const raw = readFileSync14(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 (!existsSync18(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();
@@ -28278,7 +28573,7 @@ function getSummaryContentDiagnostics(content) {
     value: content
   };
 }
-function extractToolResultText(content) {
+function extractToolResultText2(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");
@@ -28289,6 +28584,11 @@ function parseBooleanFlag(value) {
   if (["0", "false", "no", "off"].includes(raw)) return false;
   return null;
 }
+function parseNumberFlag(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return void 0;
+  return parsed;
+}
 function resolveTypedReadPathConfig(toolUseContext) {
   const envValue = parseBooleanFlag(
     process.env.PYB_AUTO_COMPACT_TYPED_READ_PATH_ENABLED
@@ -28310,6 +28610,49 @@ function resolveTypedReadPathConfig(toolUseContext) {
     source: "default"
   };
 }
+function resolveTypedPathPolicyConfig(toolUseContext) {
+  const policy = toolUseContext?.typedPathPolicy ?? {};
+  const envMinPrimaryPathRate = parseNumberFlag(
+    process.env.PYB_AUTO_COMPACT_TYPED_PATH_MIN_PRIMARY_RATE
+  );
+  const envMaxFallbackAnomalyStreak = parseNumberFlag(
+    process.env.PYB_AUTO_COMPACT_TYPED_PATH_MAX_FALLBACK_STREAK
+  );
+  const minPrimaryPathRate = Number.isFinite(envMinPrimaryPathRate) ? Math.min(1, Math.max(0, Number(envMinPrimaryPathRate))) : Number.isFinite(policy?.minPrimaryPathRate) ? Math.min(1, Math.max(0, Number(policy.minPrimaryPathRate))) : void 0;
+  const observedPrimaryPathRate = Number.isFinite(policy?.observedPrimaryPathRate) ? Math.min(1, Math.max(0, Number(policy.observedPrimaryPathRate))) : void 0;
+  const maxFallbackAnomalyStreak = Number.isFinite(envMaxFallbackAnomalyStreak) ? Math.max(1, Math.floor(Number(envMaxFallbackAnomalyStreak))) : Number.isFinite(policy?.maxFallbackAnomalyStreak) ? Math.max(1, Math.floor(Number(policy.maxFallbackAnomalyStreak))) : void 0;
+  const currentFallbackAnomalyStreak = Number.isFinite(
+    policy?.currentFallbackAnomalyStreak
+  ) ? Math.max(0, Math.floor(Number(policy.currentFallbackAnomalyStreak))) : 0;
+  return {
+    minPrimaryPathRate,
+    observedPrimaryPathRate,
+    maxFallbackAnomalyStreak,
+    currentFallbackAnomalyStreak
+  };
+}
+function evaluateTypedPathPolicyDecision(config2) {
+  if (Number.isFinite(config2.minPrimaryPathRate) && Number.isFinite(config2.observedPrimaryPathRate) && Number(config2.observedPrimaryPathRate) < Number(config2.minPrimaryPathRate)) {
+    return {
+      forceFallback: true,
+      reason: "promotion_threshold_not_met"
+    };
+  }
+  if (Number.isFinite(config2.maxFallbackAnomalyStreak) && config2.currentFallbackAnomalyStreak >= Number(config2.maxFallbackAnomalyStreak)) {
+    return {
+      forceFallback: true,
+      reason: "fallback_anomaly_streak"
+    };
+  }
+  return {
+    forceFallback: false,
+    reason: "policy_not_triggered"
+  };
+}
+function emitSessionReadPathEvent(phase, payload) {
+  debug.warn(phase, payload);
+  emitAutoCompactTelemetryEvent(phase, payload);
+}
 function emitStreamTypedPartsFromContent(content, requestId) {
   const state = createAssemblerState(requestId);
   if (typeof content === "string") {
@@ -28345,7 +28688,7 @@ function emitStreamTypedPartsFromContent(content, requestId) {
       }
       if (type3 === "tool_result") {
         const toolCallId = String(block.tool_use_id ?? `tool-${i}`);
-        const outputText = extractToolResultText(block.content);
+        const outputText = extractToolResultText2(block.content);
         onToolResult(
           {
             toolCallId,
@@ -28490,9 +28833,24 @@ ${COMPRESSION_PROMPT2}` : COMPRESSION_PROMPT2;
         enabled: typedPath.enabled,
         parts: emittedTypedParts
       });
+      const typedPathPolicyConfig = resolveTypedPathPolicyConfig(toolUseContext);
+      const typedPathPolicyDecision = evaluateTypedPathPolicyDecision(
+        typedPathPolicyConfig
+      );
+      const hasTypedPolicy = Number.isFinite(typedPathPolicyConfig.minPrimaryPathRate) || Number.isFinite(typedPathPolicyConfig.maxFallbackAnomalyStreak);
+      if (typedPath.enabled && hasTypedPolicy) {
+        emitSessionReadPathEvent("SESSION_TYPED_PATH_POLICY_APPLIED", {
+          forceFallback: typedPathPolicyDecision.forceFallback,
+          reason: typedPathPolicyDecision.reason,
+          minPrimaryPathRate: typedPathPolicyConfig.minPrimaryPathRate,
+          observedPrimaryPathRate: typedPathPolicyConfig.observedPrimaryPathRate,
+          maxFallbackAnomalyStreak: typedPathPolicyConfig.maxFallbackAnomalyStreak,
+          currentFallbackAnomalyStreak: typedPathPolicyConfig.currentFallbackAnomalyStreak
+        });
+      }
       let canonicalResult = null;
       let summary = null;
-      if (typedPath.enabled && typedReplay.isComplete && typedReplay.summaryText) {
+      if (typedPath.enabled && typedReplay.isComplete && typedReplay.summaryText && !typedPathPolicyDecision.forceFallback) {
         summary = typedReplay.summaryText;
         const typedAppliedPayload = {
           mode: "typed",
@@ -28506,7 +28864,30 @@ ${COMPRESSION_PROMPT2}` : COMPRESSION_PROMPT2;
           "AUTO_COMPACT_TYPED_PATH_APPLIED",
           typedAppliedPayload
         );
+        emitSessionReadPathEvent("SESSION_TYPED_PATH_APPLIED", typedAppliedPayload);
+        if (toolUseContext) {
+          toolUseContext.typedPathPolicy = {
+            ...toolUseContext.typedPathPolicy ?? {},
+            currentFallbackAnomalyStreak: 0
+          };
+        }
       } else {
+        if (typedPath.enabled && typedPathPolicyDecision.forceFallback && typedPathPolicyDecision.reason === "fallback_anomaly_streak") {
+          emitSessionReadPathEvent("SESSION_TYPED_PATH_AUTO_DEGRADED", {
+            reason: typedPathPolicyDecision.reason,
+            currentFallbackAnomalyStreak: typedPathPolicyConfig.currentFallbackAnomalyStreak,
+            maxFallbackAnomalyStreak: typedPathPolicyConfig.maxFallbackAnomalyStreak
+          });
+        }
+        if (typedPath.enabled && typedReplay.isComplete && !typedReplay.summaryText) {
+          emitSessionReadPathEvent("SESSION_TYPED_PATH_CONSISTENCY_FAILED", {
+            mode: "typed_incomplete_payload",
+            pathSource: typedPath.source,
+            reason: typedReplay.reason,
+            textPartCount: typedReplay.textPartCount,
+            reasoningPartCount: typedReplay.reasoningPartCount
+          });
+        }
         canonicalResult = normalizeModelResponseContent(content, {
           source: "auto_compact",
           model: activeModelName,
@@ -28519,7 +28900,7 @@ ${COMPRESSION_PROMPT2}` : COMPRESSION_PROMPT2;
           mode: typedPath.enabled ? "canonical_fallback" : "canonical_disabled",
           pathSource: typedPath.source,
           ...typedPath.enabled ? {
-            reason: typedReplay.reason,
+            reason: typedPathPolicyDecision.forceFallback ? typedPathPolicyDecision.reason : typedReplay.reason,
             textPartCount: typedReplay.textPartCount,
             reasoningPartCount: typedReplay.reasoningPartCount
           } : {}
@@ -28529,6 +28910,18 @@ ${COMPRESSION_PROMPT2}` : COMPRESSION_PROMPT2;
           "AUTO_COMPACT_TYPED_PATH_APPLIED",
           typedAppliedPayload
         );
+        if (typedPath.enabled) {
+          emitSessionReadPathEvent(
+            "SESSION_CANONICAL_FALLBACK_APPLIED",
+            typedAppliedPayload
+          );
+          if (toolUseContext) {
+            toolUseContext.typedPathPolicy = {
+              ...toolUseContext.typedPathPolicy ?? {},
+              currentFallbackAnomalyStreak: typedPathPolicyConfig.currentFallbackAnomalyStreak + 1
+            };
+          }
+        }
       }
       if (!summary) {
         debug.warn("AUTO_COMPACT_SUMMARY_CONTENT_INVALID", {
@@ -28708,6 +29101,637 @@ ${contentWithLines}
   return budgetApplied.messages;
 }
 
+// src/utils/session/compactionBoundary.ts
+function parseBooleanFlag2(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 resolveCompactionBoundaryConfig(toolUseContext) {
+  const envValue = parseBooleanFlag2(process.env.PYB_COMPACTION_BOUNDARY_ENABLED);
+  if (envValue !== null) {
+    return {
+      enabled: envValue,
+      source: "env"
+    };
+  }
+  if (typeof toolUseContext?.compactionBoundaryEnabled === "boolean") {
+    return {
+      enabled: toolUseContext.compactionBoundaryEnabled,
+      source: "context"
+    };
+  }
+  return {
+    enabled: false,
+    source: "default"
+  };
+}
+function findLastCompactionBoundaryIndex(messages) {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const message = messages[i];
+    if (message?.type === "assistant" && message?.compaction?.type === "compaction") {
+      return i;
+    }
+  }
+  return -1;
+}
+function filterAfterCompactionBoundary(messages, options) {
+  const getMessageText4 = (message) => {
+    if (message.type !== "user") return "";
+    const content = message?.message?.content;
+    if (typeof content === "string") return content.trim();
+    if (!Array.isArray(content)) return "";
+    return content.filter(
+      (block) => block && typeof block === "object" && block.type === "text"
+    ).map((block) => String(block.text ?? "")).join("\n").trim();
+  };
+  const isAutoCompactNotice2 = (message) => getMessageText4(message).includes("Context automatically compressed due to token limit.");
+  const isRecoveredFileMessage2 = (message) => getMessageText4(message).includes("**Recovered File:");
+  const isReplayableUserTask = (message) => {
+    const text = getMessageText4(message);
+    if (!text) return false;
+    if (isAutoCompactNotice2(message)) return false;
+    if (isRecoveredFileMessage2(message)) return false;
+    return true;
+  };
+  if (!options.enabled) {
+    return {
+      messages,
+      applied: false,
+      droppedMessageCount: 0,
+      preservedMessageCount: messages.length,
+      lastCompactionIndex: -1,
+      replayMode: "not_applied"
+    };
+  }
+  const lastCompactionIndex = findLastCompactionBoundaryIndex(messages);
+  if (lastCompactionIndex < 0) {
+    return {
+      messages,
+      applied: false,
+      droppedMessageCount: 0,
+      preservedMessageCount: messages.length,
+      lastCompactionIndex: -1,
+      replayMode: "not_applied"
+    };
+  }
+  const filtered = messages.slice(lastCompactionIndex);
+  const hasUserTask = filtered.some((item) => isReplayableUserTask(item));
+  if (hasUserTask) {
+    return {
+      messages: filtered,
+      applied: true,
+      droppedMessageCount: Math.max(0, messages.length - filtered.length),
+      preservedMessageCount: filtered.length,
+      lastCompactionIndex,
+      replayMode: "already_has_user_task"
+    };
+  }
+  let replayText = "";
+  for (let i = lastCompactionIndex - 1; i >= 0; i -= 1) {
+    const message = messages[i];
+    if (!isReplayableUserTask(message)) continue;
+    replayText = getMessageText4(message);
+    break;
+  }
+  const replayMessage = replayText ? createUserMessage(replayText) : createUserMessage(
+    "Continue from compressed context and ask a brief clarifying question if the task objective is missing."
+  );
+  const withReplay = [...filtered, replayMessage];
+  return {
+    messages: withReplay,
+    applied: true,
+    droppedMessageCount: Math.max(0, messages.length - withReplay.length),
+    preservedMessageCount: withReplay.length,
+    lastCompactionIndex,
+    replayMode: replayText ? "replayed_latest_user_task" : "synthetic_continue_prompt"
+  };
+}
+
+// src/utils/session/toolOutputLifecycle.ts
+function parseBooleanFlag3(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 resolveToolOutputLifecycleConfig(toolUseContext) {
+  const envValue = parseBooleanFlag3(process.env.PYB_TOOL_OUTPUT_LIFECYCLE_ENABLED);
+  const enabled = envValue !== null ? envValue : typeof toolUseContext?.toolOutputLifecycleEnabled === "boolean" ? toolUseContext.toolOutputLifecycleEnabled : false;
+  const source = envValue !== null ? "env" : typeof toolUseContext?.toolOutputLifecycleEnabled === "boolean" ? "context" : "default";
+  const maxAgeTurnsRaw = toolUseContext?.toolOutputLifecycleConfig?.maxAgeTurns ?? process.env.PYB_TOOL_OUTPUT_LIFECYCLE_MAX_AGE_TURNS;
+  const protectFailedRaw = toolUseContext?.toolOutputLifecycleConfig?.protectFailedResultTurns ?? process.env.PYB_TOOL_OUTPUT_LIFECYCLE_PROTECT_FAILED_TURNS;
+  const maxAgeTurns = Number.isFinite(Number(maxAgeTurnsRaw)) ? Math.max(1, Number(maxAgeTurnsRaw)) : 3;
+  const protectFailedResultTurns = Number.isFinite(Number(protectFailedRaw)) ? Math.max(1, Number(protectFailedRaw)) : 6;
+  const l3AgeTurnsRaw = toolUseContext?.toolOutputLifecycleConfig?.l3AgeTurns ?? process.env.PYB_TOOL_OUTPUT_LIFECYCLE_L3_AGE_TURNS;
+  const l1MinCharsRaw = toolUseContext?.toolOutputLifecycleConfig?.l1MinChars ?? process.env.PYB_TOOL_OUTPUT_LIFECYCLE_L1_MIN_CHARS;
+  const l3MinCharsRaw = toolUseContext?.toolOutputLifecycleConfig?.l3MinChars ?? process.env.PYB_TOOL_OUTPUT_LIFECYCLE_L3_MIN_CHARS;
+  const l3AgeTurns = Number.isFinite(Number(l3AgeTurnsRaw)) ? Math.max(maxAgeTurns + 1, Number(l3AgeTurnsRaw)) : Math.max(maxAgeTurns + 2, 6);
+  const l1MinChars = Number.isFinite(Number(l1MinCharsRaw)) ? Math.max(120, Number(l1MinCharsRaw)) : 500;
+  const l3MinChars = Number.isFinite(Number(l3MinCharsRaw)) ? Math.max(l1MinChars, Number(l3MinCharsRaw)) : 1800;
+  return {
+    enabled,
+    source,
+    maxAgeTurns,
+    protectFailedResultTurns,
+    l3AgeTurns,
+    l1MinChars,
+    l3MinChars
+  };
+}
+function getMessageText3(message) {
+  const content = message?.message?.content;
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content.filter((block) => block && typeof block === "object" && block.type === "text").map((block) => String(block.text ?? "")).join("\n").trim();
+}
+function isNaturalUserMessage(message) {
+  if (message.type !== "user") return false;
+  const content = message?.message?.content;
+  if (typeof content === "string") return content.trim().length > 0;
+  if (!Array.isArray(content)) return false;
+  const hasToolResultOnly = content.every(
+    (block) => block && typeof block === "object" && block.type === "tool_result"
+  );
+  if (hasToolResultOnly) return false;
+  const text = getMessageText3(message);
+  return text.length > 0;
+}
+function extractLifecycleSignals(text) {
+  const lines = text.split("\n").map((line) => line.trim()).filter(Boolean);
+  const fields = ["targets:", "keyfacts:", "errors:"];
+  return lines.filter(
+    (line) => fields.some((field) => line.toLowerCase().startsWith(field))
+  );
+}
+function extractStatusSignal(text) {
+  const line = text.split("\n").map((item) => item.trim()).find((item) => item.toLowerCase().startsWith("status:"));
+  return line || "status: unknown";
+}
+function estimateTokens2(text) {
+  return Math.max(1, Math.ceil(String(text ?? "").length * 0.25));
+}
+function estimateMessageTokens(message) {
+  const content = message?.message?.content;
+  if (typeof content === "string") {
+    return estimateTokens2(content);
+  }
+  if (Array.isArray(content)) {
+    const text = content.map((block) => {
+      if (!block || typeof block !== "object") return "";
+      if (typeof block.text === "string") return block.text;
+      if (typeof block.content === "string") return block.content;
+      return "";
+    }).filter(Boolean).join("\n");
+    return estimateTokens2(text);
+  }
+  return 1;
+}
+function estimateMessagesTokens(messages) {
+  return messages.reduce((sum, message) => sum + estimateMessageTokens(message), 0);
+}
+function countToolResultBlocks(messages) {
+  return messages.reduce((sum, message) => {
+    if (message.type !== "user") return sum;
+    const content = message?.message?.content;
+    if (!Array.isArray(content)) return sum;
+    return sum + content.filter(
+      (block) => block && typeof block === "object" && block.type === "tool_result"
+    ).length;
+  }, 0);
+}
+function buildDanglingClosureMessage(toolUseId) {
+  return {
+    type: "user",
+    uuid: `dangling_${toolUseId}_${Date.now()}`,
+    message: {
+      role: "user",
+      content: [
+        {
+          type: "tool_result",
+          tool_use_id: toolUseId,
+          is_error: true,
+          error_class: "fatal",
+          content: "status: interrupted\nerrors: dangling tool_use closed before replay\nkeyFacts: replay-safe closure applied\ntargets: none"
+        }
+      ]
+    }
+  };
+}
+function closeDanglingToolUseBeforeReplay(messages) {
+  const used = /* @__PURE__ */ new Set();
+  const resolved = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    if (message.type === "assistant") {
+      const content = message?.message?.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (!block || typeof block !== "object") continue;
+          if (block.type === "tool_use" || block.type === "server_tool_use" || block.type === "mcp_tool_use") {
+            const id = String(block.id ?? "").trim();
+            if (id) used.add(id);
+          }
+        }
+      }
+    } else if (message.type === "user") {
+      const content = message?.message?.content;
+      if (!Array.isArray(content)) continue;
+      for (const block of content) {
+        if (!block || typeof block !== "object" || block.type !== "tool_result") continue;
+        const id = String(block.tool_use_id ?? "").trim();
+        if (id) resolved.add(id);
+      }
+    }
+  }
+  const dangling = Array.from(used).filter((id) => !resolved.has(id));
+  if (dangling.length === 0) {
+    return { messages, detected: 0, closed: 0 };
+  }
+  const closures = dangling.map((id) => buildDanglingClosureMessage(id));
+  return {
+    messages: [...messages, ...closures],
+    detected: dangling.length,
+    closed: closures.length
+  };
+}
+function applyToolOutputLifecycle(messages, options) {
+  const l3AgeTurns = Math.max(
+    options.maxAgeTurns + 1,
+    options.l3AgeTurns ?? Math.max(options.maxAgeTurns + 2, 6)
+  );
+  const l1MinChars = Math.max(120, options.l1MinChars ?? 500);
+  const l3MinChars = Math.max(l1MinChars, options.l3MinChars ?? 1800);
+  const shouldCloseDangling = options.closeDanglingToolUseBeforeReplay ?? true;
+  const closureResult = shouldCloseDangling ? closeDanglingToolUseBeforeReplay(messages) : { messages, detected: 0, closed: 0 };
+  const messagesForAging = closureResult.messages;
+  const beforeTokens = estimateMessagesTokens(messagesForAging);
+  const totalToolResultBlocksBefore = countToolResultBlocks(messagesForAging);
+  if (!options.enabled) {
+    return {
+      messages: messagesForAging,
+      report: {
+        applied: false,
+        agedBlocks: 0,
+        skippedFailedBlocks: 0,
+        protectedBlocks: 0,
+        totalToolResultBlocksBefore,
+        totalToolResultBlocksAfter: totalToolResultBlocksBefore,
+        l1Blocks: 0,
+        l2Blocks: 0,
+        l3Blocks: 0,
+        danglingDetected: closureResult.detected,
+        danglingClosed: closureResult.closed,
+        beforeTokens,
+        afterTokens: beforeTokens,
+        tokenDelta: 0
+      }
+    };
+  }
+  const naturalTurnsAfter = new Array(messagesForAging.length).fill(0);
+  let runningTurns = 0;
+  for (let i = messagesForAging.length - 1; i >= 0; i -= 1) {
+    naturalTurnsAfter[i] = runningTurns;
+    if (isNaturalUserMessage(messagesForAging[i])) {
+      runningTurns += 1;
+    }
+  }
+  let agedBlocks = 0;
+  let skippedFailedBlocks = 0;
+  let protectedBlocks = 0;
+  let l1Blocks = 0;
+  let l2Blocks = 0;
+  let l3Blocks = 0;
+  const nextMessages = messagesForAging.map((message, index) => {
+    if (message.type !== "user") return message;
+    const content = message?.message?.content;
+    if (!Array.isArray(content)) return message;
+    let changed = false;
+    const nextContent = content.map((block) => {
+      if (!block || typeof block !== "object" || block.type !== "tool_result") {
+        return block;
+      }
+      const ageTurns = naturalTurnsAfter[index];
+      if (ageTurns <= options.maxAgeTurns) {
+        return block;
+      }
+      const isError = Boolean(block.is_error);
+      if (isError && ageTurns <= options.protectFailedResultTurns) {
+        skippedFailedBlocks += 1;
+        return block;
+      }
+      const rawText = typeof block.content === "string" ? block.content : Array.isArray(block.content) ? block.content.filter(
+        (item) => item && typeof item === "object" && item.type === "text"
+      ).map((item) => String(item.text ?? "")).join("\n") : "";
+      const signals = extractLifecycleSignals(rawText);
+      const status = extractStatusSignal(rawText);
+      const normalizedSignals = signals.length > 0 ? signals : ["targets: none", "keyFacts: none", "errors: none"];
+      let lifecycleLevel = "L2";
+      if (ageTurns >= l3AgeTurns && rawText.length >= l3MinChars) {
+        lifecycleLevel = "L3";
+      } else if (rawText.length >= l1MinChars) {
+        lifecycleLevel = "L1";
+      }
+      const placeholder = (lifecycleLevel === "L3" ? [
+        "[Tool output aged]",
+        "lifecycleLevel: L3",
+        `toolUseId: ${String(block.tool_use_id ?? "")}`,
+        `ageTurns: ${ageTurns}`,
+        status,
+        ...normalizedSignals,
+        "content: audit-index-only"
+      ] : lifecycleLevel === "L1" ? [
+        "[Tool output aged]",
+        "lifecycleLevel: L1",
+        `ageTurns: ${ageTurns}`,
+        status,
+        ...normalizedSignals,
+        "content: summarized"
+      ] : [
+        "[Tool output aged]",
+        "lifecycleLevel: L2",
+        `ageTurns: ${ageTurns}`,
+        status,
+        ...normalizedSignals,
+        "content: placeholder"
+      ]).join("\n");
+      changed = true;
+      agedBlocks += 1;
+      protectedBlocks += signals.length;
+      if (lifecycleLevel === "L1") l1Blocks += 1;
+      if (lifecycleLevel === "L2") l2Blocks += 1;
+      if (lifecycleLevel === "L3") l3Blocks += 1;
+      return {
+        ...block,
+        content: placeholder,
+        metadata: {
+          ...block.metadata && typeof block.metadata === "object" ? block.metadata : {},
+          lifecycleAged: true,
+          ageTurns,
+          lifecycleLevel
+        }
+      };
+    });
+    if (!changed) return message;
+    return {
+      ...message,
+      message: {
+        ...message.message,
+        content: nextContent
+      }
+    };
+  });
+  return {
+    messages: nextMessages,
+    report: {
+      applied: true,
+      agedBlocks,
+      skippedFailedBlocks,
+      protectedBlocks,
+      totalToolResultBlocksBefore,
+      totalToolResultBlocksAfter: countToolResultBlocks(nextMessages),
+      l1Blocks,
+      l2Blocks,
+      l3Blocks,
+      danglingDetected: closureResult.detected,
+      danglingClosed: closureResult.closed,
+      beforeTokens,
+      afterTokens: estimateMessagesTokens(nextMessages),
+      tokenDelta: Math.max(
+        0,
+        beforeTokens - estimateMessagesTokens(nextMessages)
+      )
+    }
+  };
+}
+
+// src/utils/session/threeLayerRollout.ts
+function parseBooleanFlag4(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 parsePercent(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return void 0;
+  return Math.min(100, Math.max(0, parsed));
+}
+function parsePositiveInteger(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return void 0;
+  return Math.max(1, Math.floor(parsed));
+}
+function parseNonNegativeInteger(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return void 0;
+  return Math.max(0, Math.floor(parsed));
+}
+function parseRolloutStage(value) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (normalized === "stage_10") return "stage_10";
+  if (normalized === "stage_30") return "stage_30";
+  if (normalized === "stage_100") return "stage_100";
+  return void 0;
+}
+function stageToPercent(stage) {
+  if (stage === "stage_10") return 10;
+  if (stage === "stage_30") return 30;
+  return 100;
+}
+function promoteStage(stage) {
+  if (stage === "stage_10") return "stage_30";
+  if (stage === "stage_30") return "stage_100";
+  return "stage_100";
+}
+function rollbackStage(stage) {
+  if (stage === "stage_100") return "stage_30";
+  if (stage === "stage_30") return "stage_10";
+  return "stage_10";
+}
+function evaluateThreeLayerRolloutStageDecision(input) {
+  if (!input.rolloutEnabled) {
+    return {
+      nextStage: input.currentStage,
+      decision: "keep",
+      reason: "rollout_disabled"
+    };
+  }
+  if (!input.autoControllerEnabled) {
+    return {
+      nextStage: input.currentStage,
+      decision: "keep",
+      reason: "threshold_not_met"
+    };
+  }
+  if (input.consecutiveUnhealthyWindows >= input.maxUnhealthyWindowsForRollback && input.currentStage !== "stage_10") {
+    return {
+      nextStage: rollbackStage(input.currentStage),
+      decision: "rollback",
+      reason: "unhealthy_window_rollback"
+    };
+  }
+  if (input.consecutiveHealthyWindows >= input.minHealthyWindowsForPromote && input.currentStage !== "stage_100") {
+    return {
+      nextStage: promoteStage(input.currentStage),
+      decision: "promote",
+      reason: "healthy_window_promote"
+    };
+  }
+  return {
+    nextStage: input.currentStage,
+    decision: "keep",
+    reason: "threshold_not_met"
+  };
+}
+function hashToBucket(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i += 1) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return Math.abs(hash >>> 0) % 100;
+}
+function resolveThreeLayerRolloutFlags(toolUseContext, options) {
+  const rolloutEnabledEnv = parseBooleanFlag4(
+    process.env.PYB_THREE_LAYER_ROLLOUT_ENABLED
+  );
+  const rolloutEnabledContext = typeof toolUseContext?.threeLayerRolloutEnabled === "boolean" ? toolUseContext.threeLayerRolloutEnabled : void 0;
+  const rolloutEnabled = rolloutEnabledEnv !== null ? rolloutEnabledEnv : rolloutEnabledContext ?? false;
+  const rolloutStageEnv = parseRolloutStage(process.env.PYB_THREE_LAYER_ROLLOUT_STAGE);
+  const rolloutStageContext = parseRolloutStage(toolUseContext?.threeLayerRolloutStage);
+  const rolloutStageInput = rolloutStageEnv ?? rolloutStageContext ?? "stage_100";
+  const autoControllerEnabledEnv = parseBooleanFlag4(
+    process.env.PYB_THREE_LAYER_ROLLOUT_AUTO_CONTROLLER_ENABLED
+  );
+  const autoControllerEnabledContext = typeof toolUseContext?.threeLayerRolloutAutoControllerEnabled === "boolean" ? toolUseContext.threeLayerRolloutAutoControllerEnabled : void 0;
+  const autoControllerEnabled = autoControllerEnabledEnv !== null ? autoControllerEnabledEnv : autoControllerEnabledContext ?? false;
+  const consecutiveHealthyWindows = parseNonNegativeInteger(
+    toolUseContext?.threeLayerRolloutConsecutiveHealthyWindows
+  ) ?? 0;
+  const consecutiveUnhealthyWindows = parseNonNegativeInteger(
+    toolUseContext?.threeLayerRolloutConsecutiveUnhealthyWindows
+  ) ?? 0;
+  const minHealthyWindowsForPromote = parsePositiveInteger(
+    toolUseContext?.threeLayerRolloutMinHealthyWindowsForPromote ?? process.env.PYB_THREE_LAYER_ROLLOUT_MIN_HEALTHY_WINDOWS
+  ) ?? 2;
+  const maxUnhealthyWindowsForRollback = parsePositiveInteger(
+    toolUseContext?.threeLayerRolloutMaxUnhealthyWindowsForRollback ?? process.env.PYB_THREE_LAYER_ROLLOUT_MAX_UNHEALTHY_WINDOWS
+  ) ?? 2;
+  const stageDecision = evaluateThreeLayerRolloutStageDecision({
+    rolloutEnabled,
+    currentStage: rolloutStageInput,
+    autoControllerEnabled,
+    consecutiveHealthyWindows,
+    consecutiveUnhealthyWindows,
+    minHealthyWindowsForPromote,
+    maxUnhealthyWindowsForRollback
+  });
+  const rolloutStage = stageDecision.nextStage;
+  const rolloutDecision = stageDecision.decision;
+  const rolloutReason = stageDecision.reason;
+  const rolloutPercent = parsePercent(process.env.PYB_THREE_LAYER_ROLLOUT_PERCENT) ?? parsePercent(toolUseContext?.threeLayerRolloutPercent) ?? stageToPercent(rolloutStage);
+  const rolloutKey = String(
+    options?.requestId || toolUseContext?.options?.messageLogName || toolUseContext?.agentId || "global"
+  );
+  const rolloutBucket = hashToBucket(rolloutKey);
+  const rolloutActive = rolloutEnabled && rolloutBucket < rolloutPercent;
+  const typedWriteExplicitEnv = parseBooleanFlag4(
+    process.env.PYB_TYPED_SESSION_WRITE_ENABLED
+  );
+  const typedWriteExplicitContext = typeof toolUseContext?.typedSessionWriteEnabled === "boolean" ? toolUseContext.typedSessionWriteEnabled : void 0;
+  const boundaryExplicitEnv = parseBooleanFlag4(
+    process.env.PYB_COMPACTION_BOUNDARY_ENABLED
+  );
+  const boundaryExplicitContext = typeof toolUseContext?.compactionBoundaryEnabled === "boolean" ? toolUseContext.compactionBoundaryEnabled : void 0;
+  const lifecycleExplicitEnv = parseBooleanFlag4(
+    process.env.PYB_TOOL_OUTPUT_LIFECYCLE_ENABLED
+  );
+  const lifecycleExplicitContext = typeof toolUseContext?.toolOutputLifecycleEnabled === "boolean" ? toolUseContext.toolOutputLifecycleEnabled : void 0;
+  const typedSessionWriteEnabled = typedWriteExplicitEnv !== null ? typedWriteExplicitEnv : typedWriteExplicitContext ?? (rolloutEnabled ? rolloutActive : true);
+  const compactionBoundaryEnabled = boundaryExplicitEnv !== null ? boundaryExplicitEnv : boundaryExplicitContext ?? (rolloutEnabled ? rolloutActive : false);
+  const toolOutputLifecycleEnabled = lifecycleExplicitEnv !== null ? lifecycleExplicitEnv : lifecycleExplicitContext ?? (rolloutEnabled ? rolloutActive : false);
+  return {
+    typedSessionWriteEnabled,
+    compactionBoundaryEnabled,
+    toolOutputLifecycleEnabled,
+    rolloutEnabled,
+    rolloutPercent,
+    rolloutBucket,
+    rolloutStage,
+    rolloutDecision,
+    rolloutReason
+  };
+}
+
+// src/utils/session/toolOutputLifecycleMetricsDraft.ts
+function safeRate(numerator, denominator) {
+  if (!Number.isFinite(numerator) || !Number.isFinite(denominator) || denominator <= 0) {
+    return 0;
+  }
+  return Math.max(0, Math.min(1, numerator / denominator));
+}
+function buildToolOutputLifecyclePreGateMetrics(samples) {
+  const normalized = Array.isArray(samples) ? samples : [];
+  let totalToolResultBlocksBefore = 0;
+  let totalAgedBlocks = 0;
+  let totalPlaceholderBlocks = 0;
+  let totalBeforeTokens = 0;
+  let totalTokenDelta = 0;
+  let totalDanglingDetected = 0;
+  let totalDanglingClosed = 0;
+  let w11Total = 0;
+  let w11Passed = 0;
+  let w14Total = 0;
+  let w14Passed = 0;
+  for (const sample2 of normalized) {
+    const report = sample2?.report ?? {};
+    const toolResultBefore = Number(report.totalToolResultBlocksBefore ?? 0);
+    const aged = Number(report.agedBlocks ?? 0);
+    const l2 = Number(report.l2Blocks ?? 0);
+    const l3 = Number(report.l3Blocks ?? 0);
+    const danglingDetected = Number(report.danglingDetected ?? 0);
+    const danglingClosed = Number(report.danglingClosed ?? 0);
+    const beforeTokens = Number(report.beforeTokens ?? 0);
+    const tokenDelta = Number(report.tokenDelta ?? 0);
+    totalToolResultBlocksBefore += Number.isFinite(toolResultBefore) ? toolResultBefore : 0;
+    totalAgedBlocks += Number.isFinite(aged) ? aged : 0;
+    totalPlaceholderBlocks += Number.isFinite(l2 + l3) ? l2 + l3 : 0;
+    totalBeforeTokens += Number.isFinite(beforeTokens) ? beforeTokens : 0;
+    totalTokenDelta += Number.isFinite(tokenDelta) ? tokenDelta : 0;
+    totalDanglingDetected += Number.isFinite(danglingDetected) ? danglingDetected : 0;
+    totalDanglingClosed += Number.isFinite(danglingClosed) ? danglingClosed : 0;
+    const sampleId = String(sample2?.sampleId ?? "").trim().toUpperCase();
+    if (sampleId === "W11") {
+      w11Total += 1;
+      if (aged > 0 && tokenDelta > 0) {
+        w11Passed += 1;
+      }
+    }
+    if (sampleId === "W14") {
+      w14Total += 1;
+      if (danglingDetected > 0 && danglingClosed >= danglingDetected) {
+        w14Passed += 1;
+      }
+    }
+  }
+  return {
+    samples: normalized.length,
+    tool_output_aging_hit_rate: safeRate(
+      totalAgedBlocks,
+      totalToolResultBlocksBefore
+    ),
+    tool_output_placeholder_hit_rate: safeRate(
+      totalPlaceholderBlocks,
+      totalAgedBlocks || 1
+    ),
+    tool_output_token_reduction_rate: safeRate(totalTokenDelta, totalBeforeTokens),
+    dangling_tool_closure_rate: safeRate(totalDanglingClosed, totalDanglingDetected || 1),
+    w11_sample_pass_rate: safeRate(w11Passed, w11Total || 1),
+    w14_sample_pass_rate: safeRate(w14Passed, w14Total || 1)
+  };
+}
+
 // src/services/telemetry/autoCompactTelemetryPersistence.ts
 import { appendFileSync as appendFileSync2, existsSync as existsSync19, mkdirSync as mkdirSync8 } from "fs";
 import { dirname as dirname10 } from "path";
@@ -29007,18 +30031,75 @@ async function queryWithBinaryFeedback(toolUseContext, getAssistantResponse, get
 }
 async function* query(messages, systemPrompt, context, canUseTool, toolUseContext, getBinaryFeedbackResponse) {
   const shouldPersistSession = toolUseContext.options?.persistSession !== false && process.env.NODE_ENV !== "test";
-  for await (const message of queryCore(
-    messages,
-    systemPrompt,
-    context,
-    canUseTool,
-    toolUseContext,
-    getBinaryFeedbackResponse
-  )) {
-    if (shouldPersistSession) {
-      appendSessionJsonlFromMessage({ message, toolUseContext });
+  const typedRequestId = (() => {
+    const currentRequestId = getCurrentRequest()?.id;
+    if (currentRequestId) return `query_${currentRequestId}`;
+    const lastUser = [...messages].reverse().find((item) => item?.type === "user" && item?.queryId);
+    const fallbackQueryId = lastUser?.queryId;
+    if (fallbackQueryId) return `query_${fallbackQueryId}`;
+    return `query_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+  })();
+  const modelPointer = toolUseContext.options.model || "main";
+  const modelResolution = getModelManager().resolveModelWithInfo(modelPointer);
+  const typedProvider = modelResolution.success ? String(modelResolution.profile?.provider ?? "").trim().toLowerCase() : "unknown";
+  const typedProjector = createStreamTypedProjector({
+    requestId: typedRequestId,
+    source: "query_main",
+    provider: typedProvider
+  });
+  const rolloutFlags = resolveThreeLayerRolloutFlags(toolUseContext, {
+    requestId: getCurrentRequest()?.id ?? typedRequestId
+  });
+  const shouldPersistTypedSession = shouldPersistSession && rolloutFlags.typedSessionWriteEnabled;
+  logUserFriendly("THREE_LAYER_ROLLOUT_APPLIED", {
+    enabled: rolloutFlags.rolloutEnabled,
+    stage: rolloutFlags.rolloutStage,
+    decision: rolloutFlags.rolloutDecision,
+    reason: rolloutFlags.rolloutReason,
+    percent: rolloutFlags.rolloutPercent,
+    bucket: rolloutFlags.rolloutBucket,
+    typedSessionWriteEnabled: rolloutFlags.typedSessionWriteEnabled,
+    compactionBoundaryEnabled: rolloutFlags.compactionBoundaryEnabled,
+    toolOutputLifecycleEnabled: rolloutFlags.toolOutputLifecycleEnabled
+  });
+  if (typeof toolUseContext.compactionBoundaryEnabled !== "boolean") {
+    toolUseContext.compactionBoundaryEnabled = rolloutFlags.compactionBoundaryEnabled;
+  }
+  if (typeof toolUseContext.toolOutputLifecycleEnabled !== "boolean") {
+    toolUseContext.toolOutputLifecycleEnabled = rolloutFlags.toolOutputLifecycleEnabled;
+  }
+  try {
+    for await (const message of queryCore(
+      messages,
+      systemPrompt,
+      context,
+      canUseTool,
+      toolUseContext,
+      getBinaryFeedbackResponse
+    )) {
+      if (shouldPersistSession) {
+        appendSessionJsonlFromMessage({ message, toolUseContext });
+      }
+      if (shouldPersistTypedSession) {
+        const parts = projectMessageToTypedParts(typedProjector, message);
+        for (const part of parts) {
+          emitTypedPart({ requestId: typedRequestId, part });
+        }
+      }
+      yield message;
+    }
+  } finally {
+    if (shouldPersistTypedSession) {
+      flushTypedPartBuffer({ requestId: typedRequestId });
+      const compatibilityMetrics = consumeProjectorCompatibilityMetrics(typedProjector);
+      logUserFriendly("STREAM_TYPED_PROVIDER_COMPATIBILITY", {
+        requestId: typedRequestId,
+        provider: compatibilityMetrics.provider,
+        supportsRichToolResult: compatibilityMetrics.supportsRichToolResult,
+        richToolResultBlockCount: compatibilityMetrics.richToolResultBlockCount,
+        downgradedToolResultCount: compatibilityMetrics.downgradedToolResultCount
+      });
     }
-    yield message;
   }
 }
 async function* queryCore(messages, systemPrompt, context, canUseTool, toolUseContext, getBinaryFeedbackResponse, hookState) {
@@ -29057,6 +30138,76 @@ async function* queryCore(messages, systemPrompt, context, canUseTool, toolUseCo
     if (wasCompacted) {
       messages = processedMessages;
     }
+    const boundaryConfig = resolveCompactionBoundaryConfig(toolUseContext);
+    const boundaryResult = filterAfterCompactionBoundary(messages, {
+      enabled: boundaryConfig.enabled
+    });
+    messages = boundaryResult.messages;
+    if (boundaryConfig.enabled) {
+      logUserFriendly("COMPACTION_BOUNDARY_APPLIED", {
+        source: boundaryConfig.source,
+        applied: boundaryResult.applied,
+        droppedMessageCount: boundaryResult.droppedMessageCount,
+        preservedMessageCount: boundaryResult.preservedMessageCount,
+        lastCompactionIndex: boundaryResult.lastCompactionIndex,
+        replayMode: boundaryResult.replayMode
+      });
+      emitAutoCompactTelemetryEvent("COMPACTION_BOUNDARY_APPLIED", {
+        source: boundaryConfig.source,
+        applied: boundaryResult.applied,
+        droppedMessageCount: boundaryResult.droppedMessageCount,
+        preservedMessageCount: boundaryResult.preservedMessageCount,
+        lastCompactionIndex: boundaryResult.lastCompactionIndex,
+        replayMode: boundaryResult.replayMode
+      });
+    }
+    const lifecycleConfig = resolveToolOutputLifecycleConfig(toolUseContext);
+    const lifecycleResult = applyToolOutputLifecycle(messages, {
+      enabled: lifecycleConfig.enabled,
+      maxAgeTurns: lifecycleConfig.maxAgeTurns,
+      protectFailedResultTurns: lifecycleConfig.protectFailedResultTurns,
+      l3AgeTurns: lifecycleConfig.l3AgeTurns,
+      l1MinChars: lifecycleConfig.l1MinChars,
+      l3MinChars: lifecycleConfig.l3MinChars
+    });
+    messages = lifecycleResult.messages;
+    if (lifecycleConfig.enabled) {
+      logUserFriendly("TOOL_OUTPUT_LIFECYCLE_APPLIED", {
+        source: lifecycleConfig.source,
+        applied: lifecycleResult.report.applied,
+        agedBlocks: lifecycleResult.report.agedBlocks,
+        skippedFailedBlocks: lifecycleResult.report.skippedFailedBlocks,
+        protectedBlocks: lifecycleResult.report.protectedBlocks,
+        l1Blocks: lifecycleResult.report.l1Blocks,
+        l2Blocks: lifecycleResult.report.l2Blocks,
+        l3Blocks: lifecycleResult.report.l3Blocks,
+        beforeTokens: lifecycleResult.report.beforeTokens,
+        afterTokens: lifecycleResult.report.afterTokens,
+        tokenDelta: lifecycleResult.report.tokenDelta
+      });
+      if (lifecycleResult.report.agedBlocks > 0) {
+        logUserFriendly("TOOL_OUTPUT_AGED", {
+          agedBlocks: lifecycleResult.report.agedBlocks,
+          l1Blocks: lifecycleResult.report.l1Blocks,
+          l2Blocks: lifecycleResult.report.l2Blocks,
+          l3Blocks: lifecycleResult.report.l3Blocks
+        });
+      }
+      if (lifecycleResult.report.l2Blocks > 0 || lifecycleResult.report.l3Blocks > 0) {
+        logUserFriendly("TOOL_OUTPUT_PLACEHOLDER_APPLIED", {
+          l2Blocks: lifecycleResult.report.l2Blocks,
+          l3Blocks: lifecycleResult.report.l3Blocks
+        });
+      }
+      const preGateMetrics = buildToolOutputLifecyclePreGateMetrics([
+        { sampleId: "W11", report: lifecycleResult.report },
+        { sampleId: "W14", report: lifecycleResult.report }
+      ]);
+      logUserFriendly("TOOL_OUTPUT_LIFECYCLE_PRE_GATE_METRICS_DRAFT", {
+        ...preGateMetrics,
+        source: lifecycleConfig.source
+      });
+    }
     const tracker = getConversationTrackerForContext(toolUseContext);
     const activeNaturalUserMessage = findNaturalUserMessageForParent(messages);
     const activeQueryId = activeNaturalUserMessage?.queryId || activeNaturalUserMessage?.uuid;
@@ -29371,10 +30522,16 @@ async function* queryCore(messages, systemPrompt, context, canUseTool, toolUseCo
     }
   } finally {
     const currentRequest = getCurrentRequest();
-    flushAutoCompactTelemetrySnapshot({
+    const telemetryRecord = flushAutoCompactTelemetrySnapshot({
       requestId: currentRequest?.id,
       agentId: toolUseContext?.agentId
     });
+    if (Number.isFinite(Number(telemetryRecord?.metrics?.typed_primary_path_rate))) {
+      logUserFriendly("SESSION_READ_PATH_METRICS", {
+        requestId: currentRequest?.id,
+        typed_primary_path_rate: telemetryRecord?.metrics?.typed_primary_path_rate
+      });
+    }
     setRequestStatus({ kind: "idle" });
   }
 }
@@ -30903,7 +32060,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-NNPSCVNC.js");
+  const { queryModel } = await import("./llm-OW7QDXPZ.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:
@@ -34556,7 +35713,7 @@ user: locate where auth token refresh is implemented in a large repo
 assistant: [uses the LS tool to scan top-level structure]
 [uses the Glob tool to find candidate auth-related files]
 [uses the Grep tool to search for token refresh patterns]
-[uses the Read tool to inspect the most likely file]
+[uses the Read tool to inspect the most likely file]  
 </example>
 
 <example>