@cydm/pie 2.6.11 → 2.7.0

package/dist/cli.js

@@ -1,13 +1,29 @@
 #!/usr/bin/env node
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
+  VERSION,
   cleanupBashOutputArtifacts,
   createBashTool,
   createCliHostCapabilities,
   createCliWebResearchHealthStore,
   formatSize,
+  getAgentDir,
+  getBuiltinDir,
+  getConfigDir,
+  getCustomThemesDir,
+  getLogsDir,
+  getPackageDir,
+  getProjectSettingsPath,
+  getRuntimeLogPath,
+  getSessionsDir,
+  getSettingsPath,
+  getThemesDir,
+  migrateConfigFromAgentDir,
   truncateHeadTail
-} from "./chunks/chunk-MA4CHFN4.js";
+} from "./chunks/chunk-IPNAFMOJ.js";
+import {
+  resolveCliProjectRoot
+} from "./chunks/chunk-WLFOBECN.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -30,6 +46,7 @@ import {
   createFileObservationState,
   createPolicyEnforcedTools,
   createReadFileUnderstandingHandler,
+  createSearchContextTool,
   createSessionManager,
   createSharedFileSystemTools,
   createSharedWebSearchTool,
@@ -51,6 +68,7 @@ import {
   interactionAttentionResolution,
   isCompactSummaryMessage,
   isExtensionEnabled,
+  isToolAllowedInPlanMode,
   maybeAdvanceTodoExecutionState,
   modalityForReadFileUnderstandingKind,
   pauseExecutionState,
@@ -58,13 +76,12 @@ import {
   requestInteraction,
   resolveExtensionIdentity,
   restoreExecutionState,
-  selectToolsForRuntimePolicy,
   setEnablementInMap,
   setExtensionEnabledInSettings,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-ZVM234WE.js";
-import "./chunks/chunk-PAC62XU4.js";
+} from "./chunks/chunk-6RBSTII7.js";
+import "./chunks/chunk-TWILEFLD.js";
 import {
   Deref,
   EMPTY_ASSISTANT_CONTENT_ERROR,
@@ -87,26 +104,9 @@ import {
   requiredCapabilityForToolPurpose,
   setLogger,
   sortToolModelCandidatesByCapability,
+  streamSimple,
   type_exports
-} from "./chunks/chunk-7B4IIBVS.js";
-import {
-  VERSION,
-  getAgentDir,
-  getBuiltinDir,
-  getConfigDir,
-  getCustomThemesDir,
-  getLogsDir,
-  getPackageDir,
-  getProjectSettingsPath,
-  getRuntimeLogPath,
-  getSessionsDir,
-  getSettingsPath,
-  getThemesDir,
-  migrateConfigFromAgentDir
-} from "./chunks/chunk-5353DEEC.js";
-import {
-  resolveCliProjectRoot
-} from "./chunks/chunk-WLFOBECN.js";
+} from "./chunks/chunk-R5I2QLF2.js";
 import {
   IsArray,
   IsBigInt,
@@ -51971,6 +51971,7 @@ var MODEL_OVERRIDE_KEYS = [
   "cost",
   "contextWindow",
   "maxTokens",
+  "transport",
   "headers",
   "compat",
   "cacheCapability",
@@ -51988,9 +51989,11 @@ function validateExtensionProviderConfig(provider, config) {
     throw new Error(`registerProvider("${provider}"): baseUrl must be an absolute URL`);
   }
   assertHeadersShape(config.headers, `registerProvider("${provider}")`);
+  validateTransport(config.transport, `registerProvider("${provider}")`);
   for (const model of config.models ?? []) {
     if (!model || typeof model.id !== "string" || !model.id.trim() || /\s/.test(model.id)) throw new Error(`registerProvider("${provider}"): invalid model id`);
     assertHeadersShape(model.headers, `registerProvider("${provider}") model "${model.id}"`);
+    validateTransport(model.transport, `Model "${model.id}"`);
     validateCompat(model.compat, `registerProvider("${provider}") model "${model.id}" compat`);
     validateCacheCapability(model.cacheCapability, `registerProvider("${provider}") model "${model.id}" cacheCapability`);
     validateWebSearchCapability(model.webSearch, `registerProvider("${provider}") model "${model.id}" webSearch`);
@@ -51998,7 +52001,7 @@ function validateExtensionProviderConfig(provider, config) {
   }
 }
 var REMOTE_CATALOG_CACHE_VERSION = 4;
-var SUPPORTED_REMOTE_APIS = /* @__PURE__ */ new Set(["openai-completions", "anthropic-messages"]);
+var SUPPORTED_REMOTE_APIS = /* @__PURE__ */ new Set(["openai-completions", "anthropic-messages", "openai-responses"]);
 var MAX_REMOTE_CATALOG_BYTES = 2 * 1024 * 1024;
 var OAUTH_RESTORE_LEEWAY_MS = 6e4;
 var OAUTH_REFRESH_TIMEOUT_MS = 3e4;
@@ -52495,11 +52498,17 @@ function validateFileCapabilities(value, label) {
     }
   }
 }
+function validateTransport(value, label) {
+  if (value !== void 0 && value !== "sse" && value !== "websocket" && value !== "auto") throw new Error(`${label}.transport is invalid`);
+}
 function validateCompat(value, label) {
   if (value === void 0) return;
   if (!isPlainRecord(value)) throw new Error(`${label} is invalid`);
   assertOnlyKeys(value, [
     "forcedReasoningEffort",
+    "store",
+    "supportsEncryptedReasoning",
+    "responsesContinuation",
     "supportsStore",
     "supportsDeveloperRole",
     "supportsReasoningEffort",
@@ -52517,6 +52526,9 @@ function validateCompat(value, label) {
     throw new Error(`${label}.forcedReasoningEffort must be "none"`);
   }
   for (const field of [
+    "store",
+    "supportsEncryptedReasoning",
+    "responsesContinuation",
     "supportsStore",
     "supportsDeveloperRole",
     "supportsReasoningEffort",
@@ -52537,12 +52549,14 @@ function validateRemoteModel(profileId, model) {
   if (!isPlainRecord(model) || typeof model.id !== "string" || !model.id.trim() || model.id !== model.id.trim() || /\s/.test(model.id)) throw new Error(`Remote profile "${profileId}" contains an invalid model id`);
   assertOnlyKeys(model, [
     "id",
+    "api",
     "name",
     "reasoning",
     "input",
     "cost",
     "contextWindow",
     "maxTokens",
+    "transport",
     "compat",
     "cacheCapability",
     "webSearch",
@@ -52556,6 +52570,7 @@ function validateRemoteModel(profileId, model) {
   for (const field of ["name", "displayName", "filePlatform", "attachmentPlatform", "apiKeyEnv"]) {
     assertOptionalString(model[field], `Remote profile "${profileId}" model "${model.id}" ${field}`);
   }
+  if (model.api !== void 0 && !SUPPORTED_REMOTE_APIS.has(model.api)) throw new Error(`Model "${model.id}" has unsupported api ${model.api}`);
   assertOptionalBoolean(model.reasoning, `Remote profile "${profileId}" model "${model.id}" reasoning`);
   if (!Array.isArray(model.input) || model.input.length === 0 || model.input.some((item) => !["text", "image", "audio", "video"].includes(item))) {
     throw new Error(`Remote profile "${profileId}" model "${model.id}" has invalid input capabilities`);
@@ -52569,6 +52584,7 @@ function validateRemoteModel(profileId, model) {
     throw new Error(`Remote profile "${profileId}" model "${model.id}" has invalid token limits`);
   }
   if (new Set(model.input).size !== model.input.length) throw new Error(`Remote profile "${profileId}" model "${model.id}" has duplicate input capabilities`);
+  validateTransport(model.transport, `Model "${model.id}"`);
   validateCompat(model.compat, `Remote profile "${profileId}" model "${model.id}" compat`);
   validateCacheCapability(model.cacheCapability, `Remote profile "${profileId}" model "${model.id}" cacheCapability`);
   validateWebSearchCapability(model.webSearch, `Remote profile "${profileId}" model "${model.id}" webSearch`);
@@ -52604,6 +52620,7 @@ function sanitizeRemotePayload(decoded, remote, catalogUrl, allowLocallyInjected
     if (!provider || provider !== provider.trim() || /\s/.test(provider) || !isPlainRecord(source)) throw new Error("catalog contains an invalid profile");
     assertOnlyKeys(source, [
       "baseUrl",
+      "endpoints",
       "api",
       "apiKey",
       "apiKeyEnv",
@@ -52611,6 +52628,7 @@ function sanitizeRemotePayload(decoded, remote, catalogUrl, allowLocallyInjected
       "displayName",
       "filePlatform",
       "attachmentPlatform",
+      "transport",
       "compat",
       "cacheCapability",
       "webSearch",
@@ -52626,8 +52644,13 @@ function sanitizeRemotePayload(decoded, remote, catalogUrl, allowLocallyInjected
       assertOptionalString(source[field], `Remote profile "${provider}" ${field}`);
     }
     validateRemoteEndpoint(source.baseUrl, catalogUrl, `Remote profile "${provider}"`);
+    validateProfileEndpoints(source, `Remote profile "${provider}"`);
+    for (const [api, endpoint] of Object.entries(source.endpoints ?? {})) {
+      validateRemoteEndpoint(endpoint, catalogUrl, `Remote profile "${provider}" endpoints.${api}`);
+    }
     if (!Array.isArray(source.models) || source.models.length === 0) throw new Error(`Remote profile "${provider}" has no models`);
     assertRemoteHeadersSafe(source.headers, `Remote profile "${provider}"`);
+    validateTransport(source.transport, `Remote profile "${provider}"`);
     validateCompat(source.compat, `Remote profile "${provider}" compat`);
     validateCacheCapability(source.cacheCapability, `Remote profile "${provider}" cacheCapability`);
     validateWebSearchCapability(source.webSearch, `Remote profile "${provider}" webSearch`);
@@ -52644,7 +52667,9 @@ function sanitizeRemotePayload(decoded, remote, catalogUrl, allowLocallyInjected
     }
     const sanitized = {
       baseUrl: source.baseUrl,
+      ...source.endpoints === void 0 ? {} : { endpoints: { ...source.endpoints } },
       api: source.api,
+      transport: source.transport,
       apiKeyEnv: remote.apiKeyEnv,
       ...source.headers === void 0 ? {} : { headers: { ...source.headers } },
       ...source.displayName === void 0 ? {} : { displayName: source.displayName },
@@ -52656,6 +52681,7 @@ function sanitizeRemotePayload(decoded, remote, catalogUrl, allowLocallyInjected
       ...source.fileCapabilities === void 0 ? {} : { fileCapabilities: { ...source.fileCapabilities } },
       models: source.models.map((model) => ({
         id: model.id,
+        ...model.api === void 0 ? {} : { api: model.api },
         ...model.name === void 0 ? {} : { name: model.name },
         ...model.reasoning === void 0 ? {} : { reasoning: model.reasoning },
         input: [...model.input],
@@ -52667,6 +52693,7 @@ function sanitizeRemotePayload(decoded, remote, catalogUrl, allowLocallyInjected
         },
         contextWindow: model.contextWindow,
         maxTokens: model.maxTokens,
+        ...model.transport === void 0 ? {} : { transport: model.transport },
         ...model.compat === void 0 ? {} : { compat: { ...model.compat } },
         ...model.cacheCapability === void 0 ? {} : { cacheCapability: { ...model.cacheCapability } },
         ...model.webSearch === void 0 ? {} : { webSearch: { ...model.webSearch } },
@@ -52739,16 +52766,41 @@ function validateModelOverrides(value) {
         if (typeof headerValue !== "string") throw new Error(`models.json modelOverrides["${key}"].headers.${headerName} must be a string`);
       }
     }
+    validateTransport(override.transport, `Model override "${key}"`);
     validateCompat(override.compat, `models.json modelOverrides["${key}"].compat`);
     validateCacheCapability(override.cacheCapability, `models.json modelOverrides["${key}"].cacheCapability`);
     validateWebSearchCapability(override.webSearch, `models.json modelOverrides["${key}"].webSearch`);
     validateFileCapabilities(override.fileCapabilities, `models.json modelOverrides["${key}"].fileCapabilities`);
   }
 }
+function validateProfileEndpoints(profile, label) {
+  if (profile.endpoints === void 0) return;
+  if (!isPlainRecord(profile.endpoints)) throw new Error(`${label} endpoints must be an object`);
+  for (const [api, value] of Object.entries(profile.endpoints)) {
+    if (!SUPPORTED_REMOTE_APIS.has(api)) throw new Error(`${label} endpoints has unsupported api ${api}`);
+    try {
+      if (typeof value !== "string") throw new Error("invalid URL");
+      const endpoint = new URL(value);
+      if (endpoint.protocol !== "http:" && endpoint.protocol !== "https:") throw new Error("unsupported protocol");
+    } catch {
+      throw new Error(`${label} endpoints.${api} must be an absolute HTTP(S) URL`);
+    }
+  }
+}
+function resolveProfileRoute(profile, model) {
+  const api = model.api ?? profile.api;
+  if (!SUPPORTED_REMOTE_APIS.has(api)) throw new Error(`Model "${model.id}" has unsupported api ${api}`);
+  const endpoint = profile.endpoints?.[api];
+  if (model.api !== void 0 && endpoint === void 0 && api !== profile.api) {
+    throw new Error(`Model "${model.id}" api ${api} requires profile endpoints.${api} (otherwise api must equal profile api)`);
+  }
+  return { api, baseUrl: endpoint ?? profile.baseUrl };
+}
 function validateProfileConfig(profileId, profileConfig) {
   if (!isPlainRecord(profileConfig)) throw new Error(`Profile "${profileId}" must be an object.`);
   assertOnlyKeys(profileConfig, [
     "baseUrl",
+    "endpoints",
     "api",
     "apiKey",
     "apiKeyEnv",
@@ -52756,6 +52808,7 @@ function validateProfileConfig(profileId, profileConfig) {
     "displayName",
     "filePlatform",
     "attachmentPlatform",
+    "transport",
     "compat",
     "cacheCapability",
     "webSearch",
@@ -52787,7 +52840,9 @@ function validateProfileConfig(profileId, profileConfig) {
   } catch {
     throw new Error(`Profile "${profileId}" baseUrl must be an absolute HTTP(S) URL`);
   }
+  validateProfileEndpoints(profileConfig, `Profile "${profileId}"`);
   assertHeadersShape(profileConfig.headers, `Profile "${profileId}"`);
+  validateTransport(profileConfig.transport, `Profile "${profileId}"`);
   validateCompat(profileConfig.compat, `Profile "${profileId}" compat`);
   validateCacheCapability(profileConfig.cacheCapability, `Profile "${profileId}" cacheCapability`);
   validateWebSearchCapability(profileConfig.webSearch, `Profile "${profileId}" webSearch`);
@@ -52797,12 +52852,14 @@ function validateProfileConfig(profileId, profileConfig) {
     if (!isPlainRecord(modelConfig)) throw new Error(`Profile "${profileId}" model #${index} must be an object.`);
     assertOnlyKeys(modelConfig, [
       "id",
+      "api",
       "name",
       "reasoning",
       "input",
       "cost",
       "contextWindow",
       "maxTokens",
+      "transport",
       "compat",
       "cacheCapability",
       "webSearch",
@@ -52826,6 +52883,7 @@ function validateProfileConfig(profileId, profileConfig) {
       );
     }
     validateRemoteModel(profileId, modelConfig);
+    resolveProfileRoute(profileConfig, modelConfig);
     assertHeadersShape(modelConfig.headers, `Profile "${profileId}" model "${modelConfig.id}"`);
     assertOptionalEnvName(modelConfig.apiKeyEnv, `Profile "${profileId}" model "${modelConfig.id}" apiKeyEnv`);
     if (seenModelIds.has(modelConfig.id)) throw new Error(`Profile "${profileId}" contains duplicate model "${modelConfig.id}".`);
@@ -52916,12 +52974,13 @@ var ModelRegistry = class {
           );
         }
         const existing = this.models.get(provider);
-        if (existing && (providerConfig.baseUrl || providerConfig.api || providerConfig.headers)) {
+        if (existing && (providerConfig.baseUrl || providerConfig.api || providerConfig.headers || providerConfig.transport)) {
           for (const model of existing.values()) {
             this.upsert({
               ...model,
               baseUrl: providerConfig.baseUrl || model.baseUrl,
               api: providerConfig.api || model.api,
+              transport: providerConfig.transport ?? model.transport,
               apiKeyEnv: providerConfig.apiKeyEnv || model.apiKeyEnv,
               displayName: providerConfig.displayName || model.displayName || provider,
               filePlatform: providerConfig.filePlatform || model.filePlatform,
@@ -52938,9 +52997,8 @@ var ModelRegistry = class {
           this.upsert({
             id: customModel.id,
             name: customModel.name || baseModel?.name || customModel.id,
-            api: providerConfig.api || baseModel?.api || "openai-completions",
+            ...resolveProfileRoute(providerConfig, customModel),
             provider,
-            baseUrl: providerConfig.baseUrl || baseModel?.baseUrl || "",
             reasoning: customModel.reasoning ?? baseModel?.reasoning ?? false,
             input: customModel.input || baseModel?.input || ["text"],
             cost: customModel.cost || baseModel?.cost || { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
@@ -52951,6 +53009,7 @@ var ModelRegistry = class {
             filePlatform: customModel.filePlatform || providerConfig.filePlatform || baseModel?.filePlatform,
             attachmentPlatform: customModel.attachmentPlatform || providerConfig.attachmentPlatform || baseModel?.attachmentPlatform,
             headers: providerConfig.headers ? { ...baseModel?.headers, ...providerConfig.headers, ...customModel.headers } : customModel.headers || baseModel?.headers,
+            transport: customModel.transport ?? providerConfig.transport ?? baseModel?.transport,
             compat: customModel.compat || providerConfig.compat || baseModel?.compat,
             cacheCapability: customModel.cacheCapability || providerConfig.cacheCapability || baseModel?.cacheCapability,
             webSearch: customModel.webSearch || providerConfig.webSearch || baseModel?.webSearch,
@@ -53003,6 +53062,7 @@ var ModelRegistry = class {
       if (override.maxTokens !== void 0) patched.maxTokens = override.maxTokens;
       if (override.cost !== void 0) patched.cost = { ...existing.cost, ...override.cost };
       if (override.headers !== void 0) patched.headers = { ...existing.headers, ...override.headers };
+      if (override.transport !== void 0) patched.transport = override.transport;
       if (override.compat !== void 0) patched.compat = deepMergePlainRecords(existing.compat, override.compat);
       if (override.cacheCapability !== void 0) patched.cacheCapability = { ...existing.cacheCapability, ...override.cacheCapability };
       if (override.webSearch !== void 0) patched.webSearch = { ...existing.webSearch, ...override.webSearch };
@@ -53024,9 +53084,8 @@ var ModelRegistry = class {
       this.upsert({
         id: customModel.id,
         name: customModel.name || customModel.id,
-        api: providerConfig.api || "openai-completions",
+        ...resolveProfileRoute(providerConfig, customModel),
         provider,
-        baseUrl: providerConfig.baseUrl || "",
         reasoning: customModel.reasoning ?? false,
         input: customModel.input || ["text"],
         cost: customModel.cost || { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
@@ -53037,6 +53096,7 @@ var ModelRegistry = class {
         filePlatform: customModel.filePlatform || providerConfig.filePlatform,
         attachmentPlatform: customModel.attachmentPlatform || providerConfig.attachmentPlatform,
         headers: { ...providerConfig.headers, ...customModel.headers },
+        transport: customModel.transport ?? providerConfig.transport,
         compat: customModel.compat || providerConfig.compat,
         cacheCapability: customModel.cacheCapability || providerConfig.cacheCapability,
         webSearch: customModel.webSearch || providerConfig.webSearch,
@@ -53476,12 +53536,13 @@ var ModelRegistry = class {
       this.authStorage.setProviderEnvVar(provider, config.apiKeyEnv);
     }
     const existing = this.models.get(provider);
-    if (existing && (config.baseUrl || config.api || config.headers)) {
+    if (existing && (config.baseUrl || config.api || config.headers || config.transport)) {
       for (const model of existing.values()) {
         this.upsert({
           ...model,
           baseUrl: config.baseUrl || model.baseUrl,
           api: config.api || model.api,
+          transport: config.transport ?? model.transport,
           headers: config.headers ? { ...model.headers, ...config.headers } : model.headers
         });
       }
@@ -53502,6 +53563,7 @@ var ModelRegistry = class {
         apiKeyEnv: config.apiKeyEnv || baseModel?.apiKeyEnv,
         displayName: customModel.displayName || baseModel?.displayName || provider,
         headers: config.headers ? { ...baseModel?.headers, ...config.headers, ...customModel.headers } : customModel.headers || baseModel?.headers,
+        transport: customModel.transport ?? config.transport ?? baseModel?.transport,
         compat: customModel.compat || baseModel?.compat,
         cacheCapability: customModel.cacheCapability || baseModel?.cacheCapability,
         webSearch: customModel.webSearch || baseModel?.webSearch,
@@ -54053,7 +54115,7 @@ function checkComputerUse() {
       id: "computer_use_helper",
       label: "computer-use helper",
       status: "warn",
-      message: `computer-use helper app is not installed yet; it installs on first tool use to ${appPath}. Afterwards grant Accessibility and Screen Recording to pie-computer-use.app in System Settings \u2192 Privacy & Security.`,
+      message: `computer-use helper app is not installed yet; it installs on first computer-use-axi use to ${appPath}. Afterwards grant Accessibility and Screen Recording to pie-computer-use.app in System Settings \u2192 Privacy & Security.`,
       details: { appPath }
     };
   }
@@ -54341,7 +54403,7 @@ var MODE_RULES = {
     "~/.pie is allowlisted for Pie configuration and session support.",
     "Shell commands run from the workspace and return structured output, timeout, and truncation details.",
     "web_research is read-only, uses provider-native web/search/fetch capabilities, and does not grant bash/curl web scraping permission.",
-    "computer-use observe tools only read the screen; act_ui synthesizes real desktop input and requires a first-use confirmation each session.",
+    "Desktop control runs through the computer-use-axi skill CLI via bash: observation commands only read the screen, while act synthesizes real desktop input and goes through normal shell permission prompts.",
     "Protected paths from extensions can block reads/writes even when tools are present."
   ],
   plan: [
@@ -54351,7 +54413,7 @@ var MODE_RULES = {
   yolo: [
     "/settings/yolo relaxes filesystem sandbox directory restrictions.",
     "It does not make destructive shell commands safe; use it only in trusted workspaces.",
-    "It also bypasses the computer-use act_ui first-use confirmation."
+    "It also auto-approves shell commands, including computer-use-axi desktop input."
   ],
   subagents: [
     "Subagents inherit the parent tool set, then runtime policy removes write and high-risk tools.",
@@ -56502,7 +56564,10 @@ function createExtensionContext(extension, cwd, uiContext, abortFn, isIdleFn, ha
     },
     get yoloMode() {
       return actions?.yoloMode ?? false;
-    }
+    },
+    // Only expose setYoloMode when the host can actually toggle it — plan-mode
+    // gates the option on typeof ctx.setYoloMode === "function".
+    ...actions?.setYoloMode ? { setYoloMode: (enabled) => actions.setYoloMode(enabled) } : {}
   };
   return context;
 }
@@ -60395,8 +60460,8 @@ var Editor = class {
     this.historyIndex = -1;
     this.lastAction = null;
     this.pushUndoSnapshot();
-    const cleanText2 = pastedText.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-    const tabExpandedText = cleanText2.replace(/\t/g, "    ");
+    const cleanText = pastedText.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const tabExpandedText = cleanText.replace(/\t/g, "    ");
     let filteredText = tabExpandedText.split("").filter((char) => char === "\n" || char.charCodeAt(0) >= 32).join("");
     if (/^[/~.]/.test(filteredText)) {
       const currentLine = this.state.lines[this.state.cursorLine] || "";
@@ -61480,9 +61545,9 @@ var Input = class {
   handlePaste(pastedText) {
     this.lastAction = null;
     this.pushUndo();
-    const cleanText2 = pastedText.replace(/\r\n/g, "").replace(/\r/g, "").replace(/\n/g, "");
-    this.value = this.value.slice(0, this.cursor) + cleanText2 + this.value.slice(this.cursor);
-    this.cursor += cleanText2.length;
+    const cleanText = pastedText.replace(/\r\n/g, "").replace(/\r/g, "").replace(/\n/g, "");
+    this.value = this.value.slice(0, this.cursor) + cleanText + this.value.slice(this.cursor);
+    this.cursor += cleanText.length;
   }
   invalidate() {
   }
@@ -64255,7 +64320,10 @@ var ExtensionRunner = class {
       },
       get yoloMode() {
         return runner.actions.yoloMode ?? false;
-      }
+      },
+      // Only expose setYoloMode when the host can actually toggle it — plan-mode
+      // gates the option on typeof ctx.setYoloMode === "function".
+      ...runner.actions.setYoloMode ? { setYoloMode: (enabled) => runner.actions.setYoloMode(enabled) } : {}
     };
     return createLoggedProxy(context, `ExtensionContext#${contextId}`);
   }
@@ -70171,6 +70239,100 @@ var SessionTraceWriter = class extends SessionTraceSnapshotWriter {
   sessionManager;
 };
 
+// src/runtime/context-signals.ts
+import { createHash as createHash4 } from "crypto";
+function applyContextSignalsToFooter(target) {
+  if (!target.agent?.state) return;
+  const signals = computeContextSignals(
+    target,
+    target.agent.state.systemPrompt ?? "",
+    target.agent.state.tools,
+    target.sessionManager.getMessages()
+  );
+  target.footer.setState({
+    prefixHash: signals.prefixHash,
+    prefixHashChanged: signals.prefixHashChanged,
+    cacheHitRate: signals.cacheHitRate
+  });
+}
+function computePromptPrefixHash(systemPrompt, tools) {
+  return createHash4("sha256").update(
+    JSON.stringify({
+      systemPrompt,
+      tools: tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description ?? "",
+        parameters: tool.parameters ?? null
+      }))
+    })
+  ).digest("hex").slice(0, 8);
+}
+function calculateCumulativeCacheHitRate(messages) {
+  let input = 0;
+  let cacheRead = 0;
+  for (const message of messages) {
+    if (message.role !== "assistant") continue;
+    const usage = message.usage;
+    if (!usage) continue;
+    input += usage.input;
+    cacheRead += usage.cacheRead;
+  }
+  const base = input + cacheRead;
+  return base > 0 ? cacheRead / base : null;
+}
+var signalMemories = /* @__PURE__ */ new WeakMap();
+var lastSignals = /* @__PURE__ */ new WeakMap();
+function getLastContextSignals(hostKey) {
+  return lastSignals.get(hostKey) ?? null;
+}
+function computeContextSignals(hostKey, systemPrompt, tools, messages) {
+  const prefixHash = computePromptPrefixHash(systemPrompt, tools);
+  const systemHash = computePromptPrefixHash(systemPrompt, []);
+  const toolsHash = computePromptPrefixHash("", tools);
+  const previous = signalMemories.get(hostKey);
+  const prefixHashChanged = previous !== void 0 && previous.hash !== prefixHash;
+  if (previous?.hash !== prefixHash) {
+    signalMemories.set(hostKey, { hash: prefixHash, systemHash, toolsHash });
+  }
+  const signals = {
+    prefixHash,
+    prefixHashChanged,
+    ...prefixHashChanged && previous ? { previousPrefixHash: previous.hash } : {},
+    systemPromptChanged: prefixHashChanged && previous !== void 0 && previous.systemHash !== systemHash,
+    toolsChanged: prefixHashChanged && previous !== void 0 && previous.toolsHash !== toolsHash,
+    cacheHitRate: calculateCumulativeCacheHitRate(messages)
+  };
+  lastSignals.set(hostKey, signals);
+  return signals;
+}
+
+// src/runtime/cache-invalidation-trace.ts
+function noteCacheInvalidationInChat(host, signals) {
+  if (!signals || !signals.prefixHashChanged) return;
+  const parts = [];
+  if (signals.systemPromptChanged && signals.toolsChanged) parts.push("system prompt + tools rebuilt");
+  else if (signals.toolsChanged) parts.push("tools rebuilt");
+  else if (signals.systemPromptChanged) parts.push("system prompt rebuilt");
+  else parts.push("prefix rebuilt");
+  const from = signals.previousPrefixHash ?? "?";
+  const line = `\u26A1 Prompt cache invalidated: \u2301${from} \u2192 \u2301${signals.prefixHash} (${parts.join(", ")})`;
+  if (host.chatContainer && host.ui) {
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new Text(theme.fg("warning", line), 1, 0));
+    host.ui.requestRender();
+  }
+  host.sessionTrace?.noteRuntimeEvent("cache_prefix_invalidated", {
+    from,
+    to: signals.prefixHash,
+    systemPromptChanged: signals.systemPromptChanged,
+    toolsChanged: signals.toolsChanged
+  });
+}
+function applyContextSignalsWithTrace(host) {
+  applyContextSignalsToFooter(host);
+  noteCacheInvalidationInChat(host, getLastContextSignals(host));
+}
+
 // src/commands/interactive-session-commands.ts
 import * as os6 from "os";
 
@@ -70359,6 +70521,387 @@ var SessionSelectorComponent = class extends Container {
   }
 };
 
+// src/core/context-report.ts
+var APPROX_BYTES_PER_TOKEN = 4;
+function estimateStringTokens(text) {
+  if (!text) return 0;
+  return Math.ceil(Buffer.byteLength(text, "utf8") / APPROX_BYTES_PER_TOKEN);
+}
+function formatReportTokens(count) {
+  if (count < 1e3) return String(count);
+  if (count < 1e4) return `${(count / 1e3).toFixed(1)}k`;
+  if (count < 1e6) return `${Math.round(count / 1e3)}k`;
+  if (count < 1e7) return `${(count / 1e6).toFixed(1)}M`;
+  return `${Math.round(count / 1e6)}M`;
+}
+function buildSystemPromptBlocks(systemPrompt, skillsSection, knowledgeSection) {
+  const totalTokens = estimateStringTokens(systemPrompt);
+  const skillsTokens = skillsSection && systemPrompt.includes(skillsSection.trim()) ? estimateStringTokens(skillsSection) : null;
+  const knowledgeTokens = knowledgeSection && systemPrompt.includes(knowledgeSection.trim()) ? estimateStringTokens(knowledgeSection) : null;
+  const accounted = (skillsTokens ?? 0) + (knowledgeTokens ?? 0);
+  return {
+    totalTokens,
+    baseTokens: Math.max(0, totalTokens - accounted),
+    skillsTokens,
+    knowledgeTokens
+  };
+}
+function escapeXmlName(name) {
+  return name.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function extractSkillBlocks(section) {
+  if (!section) return [];
+  return section.split(/(?=<skill>)/).map((block) => block.trim()).filter((block) => block.startsWith("<skill>"));
+}
+function buildSkillRows(skillsSection, skills) {
+  const blocks = extractSkillBlocks(skillsSection);
+  if (blocks.length === 0) {
+    return [
+      {
+        id: "skills:none",
+        label: "no skills in prompt",
+        estTokens: 0
+      }
+    ];
+  }
+  return blocks.map((block, index) => {
+    const escapedNameMatch = block.match(/<name>([\s\S]*?)<\/name>/);
+    const escapedName = escapedNameMatch?.[1] ?? "";
+    const skill = skills.find((candidate) => escapeXmlName(candidate.name) === escapedName) ?? skills.find((candidate) => block.includes(escapeXmlName(candidate.name)));
+    const estTokens = estimateStringTokens(block);
+    const source = skill?.source ? `source:${skill.source}` : void 0;
+    const detail = skill?.inlineContent !== void 0 ? "inline content (already loaded)" : skill?.filePath ?? void 0;
+    return {
+      id: `skill:${skill?.name ?? index}`,
+      label: skill?.name ?? `<skill #${index + 1}>`,
+      estTokens,
+      note: source,
+      detail,
+      drill: {
+        kind: "text",
+        title: `Skill \xB7 ${skill?.name ?? `#${index + 1}`}`,
+        text: block
+      }
+    };
+  }).sort((a, b2) => b2.estTokens - a.estTokens);
+}
+function parseProjectContextSection(section) {
+  const parts = section.split(/^### (.+)$/m);
+  const files = [];
+  for (let i = 1; i + 1 < parts.length + 1; i += 2) {
+    const path34 = (parts[i] ?? "").trim();
+    const content = (parts[i + 1] ?? "").trim();
+    if (!path34 || !content) continue;
+    files.push({ path: path34, content });
+  }
+  return files;
+}
+function buildKnowledgeRows(files) {
+  if (files.length === 0) {
+    return [
+      {
+        id: "knowledge:none",
+        label: "no AGENTS.md files found",
+        estTokens: 0
+      }
+    ];
+  }
+  return files.map((file) => {
+    const lineCount = file.content.split("\n").length;
+    return {
+      id: `knowledge:${file.path}`,
+      label: file.path,
+      estTokens: estimateStringTokens(file.content),
+      note: `${lineCount} lines`,
+      detail: `AGENTS.md`,
+      drill: {
+        kind: "text",
+        title: `Project Context \xB7 ${file.path}`,
+        text: file.content
+      }
+    };
+  });
+}
+function estimateToolTokens(tool) {
+  const parameters = tool.parameters === void 0 ? "" : JSON.stringify(tool.parameters);
+  return estimateStringTokens(`${tool.name}
+${tool.description ?? ""}
+${parameters}`);
+}
+var MAX_TOOL_DRILL_CHARS = 6e3;
+function buildToolRows(tools) {
+  if (tools.length === 0) {
+    return [{ id: "tools:none", label: "no tools registered", estTokens: 0 }];
+  }
+  return tools.map((tool) => {
+    const paramsJson = tool.parameters === void 0 ? "" : JSON.stringify(tool.parameters, null, 2);
+    const drillText = [
+      tool.description ? `# description
+${tool.description}` : "",
+      paramsJson ? `# parameters (schema)
+${paramsJson}` : ""
+    ].filter(Boolean).join("\n\n").slice(0, MAX_TOOL_DRILL_CHARS);
+    return {
+      id: `tool:${tool.name}`,
+      label: tool.name,
+      estTokens: estimateToolTokens(tool),
+      note: tool.label && tool.label !== tool.name ? tool.label : void 0,
+      detail: tool.description?.split("\n")[0]?.slice(0, 120),
+      drill: { kind: "text", title: `Tool \xB7 ${tool.name}`, text: drillText }
+    };
+  }).sort((a, b2) => b2.estTokens - a.estTokens);
+}
+function entryRoleTag(entry) {
+  return entry.role ?? entry.type;
+}
+function buildMessageRows(entries, compactionTokensBefore) {
+  if (entries.length === 0) {
+    return [{ id: "messages:none", label: "active context is empty", estTokens: 0 }];
+  }
+  return entries.map((entry) => {
+    const roleTag = entryRoleTag(entry);
+    const isCompaction = entry.type === "compaction";
+    const tokensBefore = isCompaction ? compactionTokensBefore?.(entry.id) : void 0;
+    return {
+      id: `entry:${entry.id}`,
+      label: `#${entry.seq} ${roleTag}`,
+      estTokens: entry.estTokens,
+      roleTag,
+      marker: isCompaction ? "\u2691" : void 0,
+      note: isCompaction ? tokensBefore !== void 0 ? `checkpoint \xB7 context was ~${formatReportTokens(tokensBefore)} before` : "checkpoint" : entry.bodyBytes > 0 ? `${formatReportTokens(entry.bodyBytes)}B body` : void 0,
+      detail: entry.preview,
+      drill: { kind: "entry", entryId: entry.id }
+    };
+  });
+}
+var MAX_PROMPT_DRILL_CHARS = 12e3;
+function buildContextReportData(inputs) {
+  const knowledgeSectionText = inputs.knowledgeFiles.map((file) => `### ${file.path}
+${file.content}`).join("\n\n");
+  const blocks = buildSystemPromptBlocks(
+    inputs.systemPrompt,
+    inputs.skillsSection,
+    knowledgeSectionText
+  );
+  const systemPromptRows = [
+    {
+      id: "prompt:base",
+      label: "base prompt (persona + tool guidance + guidelines + docs)",
+      estTokens: blocks.baseTokens,
+      drill: {
+        kind: "text",
+        title: "System Prompt",
+        text: inputs.systemPrompt.slice(0, MAX_PROMPT_DRILL_CHARS)
+      }
+    }
+  ];
+  if (blocks.skillsTokens !== null || inputs.skills.length > 0) {
+    systemPromptRows.push({
+      id: "prompt:skills",
+      label: "skills section",
+      estTokens: blocks.skillsTokens ?? 0,
+      note: `${inputs.skills.length} skills`,
+      drill: {
+        kind: "rows",
+        title: "System Prompt \u203A Skills",
+        rows: buildSkillRows(inputs.skillsSection, inputs.skills),
+        rowKind: "plain"
+      }
+    });
+  }
+  if (blocks.knowledgeTokens !== null || inputs.knowledgeFiles.length > 0) {
+    systemPromptRows.push({
+      id: "prompt:knowledge",
+      label: "project context (AGENTS.md)",
+      estTokens: blocks.knowledgeTokens ?? 0,
+      note: `${inputs.knowledgeFiles.length} files`,
+      drill: {
+        kind: "rows",
+        title: "System Prompt \u203A Project Context",
+        rows: buildKnowledgeRows(inputs.knowledgeFiles),
+        rowKind: "plain"
+      }
+    });
+  }
+  const systemPromptSection = {
+    id: "system-prompt",
+    title: "System prompt",
+    estTokens: blocks.totalTokens,
+    note: `base ~${formatReportTokens(blocks.baseTokens)}`,
+    rows: systemPromptRows
+  };
+  const toolRows = buildToolRows(inputs.tools);
+  const toolsTokens = toolRows.reduce((sum, row) => sum + row.estTokens, 0);
+  const toolsSection = {
+    id: "tools",
+    title: `Tools (${inputs.tools.length})`,
+    estTokens: toolsTokens,
+    note: toolRows[0] ? `largest: ${toolRows[0].label} ~${formatReportTokens(toolRows[0].estTokens)}` : void 0,
+    rows: toolRows
+  };
+  const messageRows = buildMessageRows(inputs.entries, inputs.compactionTokensBefore);
+  const messagesTokens = inputs.entries.reduce((sum, entry) => sum + entry.estTokens, 0);
+  const messagesSection = {
+    id: "messages",
+    title: `Messages (${inputs.entries.length})`,
+    estTokens: messagesTokens,
+    rows: messageRows
+  };
+  const dynamicContextSection = {
+    id: "dynamic-context",
+    title: "Dynamic context",
+    estTokens: 0,
+    note: "unmetered",
+    rows: [
+      {
+        id: "dynamic:runtime-mode",
+        label: "runtime-mode per-turn injections are not counted in these estimates",
+        estTokens: 0,
+        detail: "the host injects a <runtime-mode-context> block (mode flags, date, active tool names) on every request via transformContext; it is part of the est\u2212actual gap below"
+      }
+    ]
+  };
+  const roleCountsMap = /* @__PURE__ */ new Map();
+  for (const entry of inputs.entries) {
+    const tag = entryRoleTag(entry);
+    roleCountsMap.set(tag, (roleCountsMap.get(tag) ?? 0) + 1);
+  }
+  const roleCounts = [...roleCountsMap.entries()].map(([role, count]) => ({ role, count })).sort((a, b2) => b2.count - a.count || a.role.localeCompare(b2.role));
+  const topEntries = [...inputs.entries].sort((a, b2) => b2.estTokens - a.estTokens).slice(0, 5).map((entry) => ({
+    seq: entry.seq,
+    label: `${entryRoleTag(entry)} \xB7 ${entry.preview}`.trim(),
+    estTokens: entry.estTokens
+  }));
+  let latestCompaction = null;
+  for (const entry of inputs.entries) {
+    if (entry.type === "compaction") {
+      latestCompaction = {
+        seq: entry.seq,
+        tokensBefore: inputs.compactionTokensBefore?.(entry.id)
+      };
+    }
+  }
+  const estimatedTotalTokens = blocks.totalTokens + toolsTokens + messagesTokens;
+  return {
+    sections: [systemPromptSection, toolsSection, messagesSection, dynamicContextSection],
+    systemPromptTokens: blocks.totalTokens,
+    toolsTokens,
+    messagesTokens,
+    dynamicContextTokens: 0,
+    estimatedTotalTokens,
+    actualTokens: inputs.actualTokens,
+    contextWindow: inputs.contextWindow,
+    autoCompactLimitTokens: inputs.autoCompactLimitTokens,
+    reserveTokens: inputs.reserveTokens,
+    promptPrefixHash: inputs.promptPrefixHash,
+    promptPrefixChanged: inputs.promptPrefixChanged,
+    roleCounts,
+    topEntries,
+    latestCompaction,
+    entryCount: inputs.entries.length
+  };
+}
+var identityTheme = {
+  bold: (text) => text,
+  fg: (_token, text) => text
+};
+function padEndVisible(text, width) {
+  return text.length >= width ? text : text + " ".repeat(width - text.length);
+}
+function formatReportHeadline(data) {
+  const est = `~${formatReportTokens(data.estimatedTotalTokens)}`;
+  if (data.contextWindow > 0) {
+    const percent = (data.estimatedTotalTokens / data.contextWindow * 100).toFixed(1);
+    return `est ${est} / ${formatReportTokens(data.contextWindow)} (${percent}%)`;
+  }
+  return `est ${est} / window unknown`;
+}
+function buildContextOverviewText(data, themeInput) {
+  const theme2 = themeInput ?? identityTheme;
+  const lines = [];
+  const sections = data.sections;
+  lines.push(theme2.bold("Context Report") + theme2.fg("dim", `  \xB7  ${formatReportHeadline(data)}`));
+  const labelWidth = 20;
+  const branch = (index) => index === sections.length ? "\u2514" : "\u251C";
+  sections.forEach((section, index) => {
+    const label = padEndVisible(` ${branch(index)} ${section.title}`, labelWidth);
+    const tokens = `~${formatReportTokens(section.estTokens)}`;
+    const note = section.note ? theme2.fg("dim", `  ${section.note}`) : "";
+    lines.push(`${label}${theme2.fg("accent", tokens)}${note}`);
+    if (section.id === "messages") {
+      const counts = data.roleCounts.map((rc) => `${rc.role} ${rc.count}`).join(" \xB7 ");
+      if (counts) {
+        lines.push(`${" ".repeat(labelWidth + 1)}${theme2.fg("dim", counts)}`);
+      }
+      for (const top of data.topEntries.slice(0, 3)) {
+        const preview = top.label.length > 60 ? `${top.label.slice(0, 59)}\u2026` : top.label;
+        lines.push(
+          `${" ".repeat(labelWidth + 1)}${theme2.fg("dim", `top: #${top.seq} ${preview} (~${formatReportTokens(top.estTokens)})`)}`
+        );
+      }
+      if (data.latestCompaction) {
+        const before = data.latestCompaction.tokensBefore !== void 0 ? ` \xB7 context was ~${formatReportTokens(data.latestCompaction.tokensBefore)} before` : "";
+        lines.push(
+          `${" ".repeat(labelWidth + 1)}${theme2.fg("dim", `\u2691 compact checkpoint @#${data.latestCompaction.seq}${before}`)}`
+        );
+      }
+    }
+  });
+  const autoCompact = data.autoCompactLimitTokens ? `triggers > ~${formatReportTokens(data.autoCompactLimitTokens)} (reserve ${formatReportTokens(data.reserveTokens)})` : "disabled";
+  lines.push(
+    `${padEndVisible(` ${branch(sections.length)} auto-compact`, labelWidth)}${theme2.fg("dim", autoCompact)}`
+  );
+  const reconciliation = data.actualTokens !== null ? `actual ${formatReportTokens(data.actualTokens)} (last response) \xB7 est\u2212actual \u2248 ${formatReportTokens(
+    Math.abs(data.estimatedTotalTokens - data.actualTokens)
+  )}${data.estimatedTotalTokens >= data.actualTokens ? " overhead" : " undercount"}` : "actual unknown until the next model response";
+  lines.push(`  ${theme2.fg("dim", reconciliation)}`);
+  lines.push(theme2.fg("dim", "  /debugs/context \xB7 Enter to drill into a section, Esc to go back"));
+  return lines.join("\n");
+}
+function buildWindowRows(data) {
+  const rows = [
+    {
+      id: "window:window",
+      label: "context window",
+      estTokens: data.contextWindow,
+      valueText: data.contextWindow > 0 ? formatReportTokens(data.contextWindow) : "?",
+      note: data.contextWindow > 0 ? `${(data.estimatedTotalTokens / data.contextWindow * 100).toFixed(1)}% used (est)` : "unknown"
+    },
+    {
+      id: "window:estimated",
+      label: "estimated total (prompt + tools + messages)",
+      estTokens: data.estimatedTotalTokens,
+      note: `prompt ~${formatReportTokens(data.systemPromptTokens)} \xB7 tools ~${formatReportTokens(data.toolsTokens)} \xB7 messages ~${formatReportTokens(data.messagesTokens)}`
+    }
+  ];
+  if (data.actualTokens !== null) {
+    rows.push({
+      id: "window:actual",
+      label: "actual (last model response)",
+      estTokens: data.actualTokens,
+      valueText: formatReportTokens(data.actualTokens),
+      note: `gap \u2248 ${formatReportTokens(Math.abs(data.estimatedTotalTokens - data.actualTokens))}`
+    });
+  }
+  rows.push({
+    id: "window:auto-compact",
+    label: "auto-compact threshold",
+    estTokens: data.autoCompactLimitTokens ?? 0,
+    valueText: data.autoCompactLimitTokens ? `>${formatReportTokens(data.autoCompactLimitTokens)}` : "off",
+    note: data.autoCompactLimitTokens ? `reserve ${formatReportTokens(data.reserveTokens)}` : "disabled"
+  });
+  if (data.promptPrefixHash) {
+    rows.push({
+      id: "window:prefix-hash",
+      label: "prompt+tools hash (cache prefix)",
+      estTokens: 0,
+      valueText: data.promptPrefixHash,
+      note: data.promptPrefixChanged ? "changed since last turn \u2014 provider cache invalidated \u26A1" : "stable \u2014 cache-friendly"
+    });
+  }
+  return rows;
+}
+
 // src/components/tree-selector.ts
 var RESET = "\x1B[0m";
 var INVERSE = "\x1B[7m";
@@ -70728,6 +71271,9 @@ var TreeSelectorComponent = class {
   pageNext() {
     if (this.goToNextPage()) {
       this.statusMessage = null;
+    } else if (this.filteredRows.length > 0) {
+      this.selectedIndex = Math.max(0, this.filteredRows.length - 1);
+      this.statusMessage = "latest page - at newest entry";
     } else {
       this.statusMessage = this.pageSummaries.length === 0 ? "no entries" : "latest page";
     }
@@ -70735,10 +71281,58 @@ var TreeSelectorComponent = class {
   pagePrev() {
     if (this.goToPreviousPage()) {
       this.statusMessage = null;
+    } else if (this.filteredRows.length > 0) {
+      this.selectedIndex = 0;
+      this.statusMessage = "oldest page - at first entry";
     } else {
       this.statusMessage = this.pageSummaries.length === 0 ? "no entries" : "oldest page";
     }
   }
+  /** Jump to the oldest page (seqs start at 1; afterSeq 0 = from the start). */
+  jumpToFirstPage() {
+    if (this.pageSummaries.length > 0 && !this.hasPrev) {
+      this.selectedIndex = 0;
+      this.statusMessage = "oldest page - at first entry";
+      return;
+    }
+    if (this.fetchWindow(0, null)) {
+      this.selectedIndex = 0;
+      this.statusMessage = null;
+    }
+  }
+  /** Jump to the newest page. Seqs are 1..total (append-only journal), so the last window starts at total - pageSize. */
+  jumpToLastPage() {
+    if (this.pageSummaries.length > 0 && !this.hasNext) {
+      this.selectedIndex = Math.max(0, this.filteredRows.length - 1);
+      this.statusMessage = "latest page - at newest entry";
+      return;
+    }
+    let anchor = Math.max(0, this.totalEntries - this.pageSizeValue);
+    for (let attempt = 0; attempt < 4; attempt++) {
+      if (this.fetchWindow(anchor, null)) {
+        if (this.hasNext) {
+          anchor = this.pageSummaries[this.pageSummaries.length - 1].seq;
+          continue;
+        }
+        this.selectedIndex = Math.max(0, this.filteredRows.length - 1);
+        this.statusMessage = null;
+        return;
+      }
+      if (anchor === 0 || !this.hasNext) break;
+      anchor = Math.max(0, anchor - this.pageSizeValue);
+    }
+  }
+  /** Move the cursor one viewport within the resident page; ←/→ change pages. */
+  screenScroll(delta) {
+    if (this.filteredRows.length === 0) return;
+    const next = Math.max(0, Math.min(this.selectedIndex + delta, this.filteredRows.length - 1));
+    if (next === this.selectedIndex) {
+      this.statusMessage = delta > 0 ? "end of page - \u2192 for next page" : "start of page - \u2190 for previous page";
+      return;
+    }
+    this.selectedIndex = next;
+    this.statusMessage = null;
+  }
   /**
    * Bounded "next match": step to the next in-page match, otherwise scan
    * forward at most SEARCH_SCAN_PAGE_LIMIT pages per press. Never scans
@@ -70792,7 +71386,7 @@ var TreeSelectorComponent = class {
     lines.push(createLine("  Conversation Tree", width, false));
     lines.push(
       createLine(
-        "  \u2191\u2193:move  \u2190\u2192:page  e:collapse  tab:next match  F:fork  Enter:navigate  Esc:cancel",
+        "  \u2191\u2193:move  \u2190\u2192:page  PgUp/PgDn:screen  Home/End:jump  e:collapse  tab:match  F:fork  Enter:go  Esc:cancel",
         width,
         false
       )
@@ -70829,12 +71423,13 @@ var TreeSelectorComponent = class {
         const activeIndicator = this.options.activePathSeqs.has(row.summary.seq) ? theme.fg("success", TREE_CHARS.active) : DIM + TREE_CHARS.inactive + RESET;
         const expandIndicator = row.inWindowChildren ? theme.fg("dim", this.collapsed.has(row.summary.id) ? "\u25B6 " : "\u25BC ") : row.hasChildren ? theme.fg("dim", "\xB7\xB7") : "  ";
         const role = roleColor(roleName(row.summary));
+        const tokenNote = row.summary.estTokens > 0 ? theme.fg("dim", ` ~${formatReportTokens(row.summary.estTokens)}`) : "";
         const indicatorWidth = visibleWidth(activeIndicator) + visibleWidth(expandIndicator) + visibleWidth(role) + 2;
-        const prefixBudget = Math.max(0, Math.min(Math.floor(width * 0.35), width - indicatorWidth - MIN_BODY_WIDTH));
+        const prefixBudget = Math.max(0, Math.min(Math.floor(width * 0.35), width - indicatorWidth - MIN_BODY_WIDTH - visibleWidth(tokenNote)));
         const displayPrefix = clampPrefixForDisplay(row.prefix, prefixBudget);
-        const availableWidth = Math.max(0, width - visibleWidth(displayPrefix) - indicatorWidth);
+        const availableWidth = Math.max(0, width - visibleWidth(displayPrefix) - indicatorWidth - visibleWidth(tokenNote) - 2);
         const content = truncateToWidth(row.summary.preview ?? "", availableWidth);
-        lines.push(createLine(`${displayPrefix}${activeIndicator}${expandIndicator}${role}: ${content}`, width, i === this.selectedIndex));
+        lines.push(createLine(`${displayPrefix}${activeIndicator}${expandIndicator}${role}: ${content}${tokenNote}`, width, i === this.selectedIndex));
       }
       for (let i = endIndex - startIndex; i < this.maxVisibleLines; i++) {
         lines.push(createLine("", width, false));
@@ -70860,10 +71455,18 @@ var TreeSelectorComponent = class {
       this.moveUp();
     } else if (kb.matches(keyData, "selectDown")) {
       this.moveDown();
-    } else if (kb.matches(keyData, "cursorRight") || kb.matches(keyData, "selectPageDown")) {
+    } else if (kb.matches(keyData, "cursorRight")) {
       this.pageNext();
-    } else if (kb.matches(keyData, "cursorLeft") || kb.matches(keyData, "selectPageUp")) {
+    } else if (kb.matches(keyData, "cursorLeft")) {
       this.pagePrev();
+    } else if (kb.matches(keyData, "selectPageDown")) {
+      this.screenScroll(this.maxVisibleLines);
+    } else if (kb.matches(keyData, "selectPageUp")) {
+      this.screenScroll(-this.maxVisibleLines);
+    } else if (kb.matches(keyData, "cursorLineStart")) {
+      this.jumpToFirstPage();
+    } else if (kb.matches(keyData, "cursorLineEnd")) {
+      this.jumpToLastPage();
     } else if (keyData === "e" || keyData === "E") {
       this.toggleCollapse();
     } else if (kb.matches(keyData, "selectConfirm")) {
@@ -72173,6 +72776,29 @@ function deriveSessionTitle(options) {
   }
   return `S:${activeSession.id.slice(-6)}`;
 }
+function calculateSessionUsageTotals(messages) {
+  let input = 0;
+  let output = 0;
+  let cacheRead = 0;
+  let cacheWrite = 0;
+  let cost = 0;
+  for (const message of messages) {
+    if (message.role !== "assistant") continue;
+    const usage = message.usage;
+    if (!usage) continue;
+    input += usage.input;
+    output += usage.output;
+    cacheRead += usage.cacheRead;
+    cacheWrite += usage.cacheWrite;
+    cost += usage.cost?.total ?? 0;
+  }
+  return { input, output, cacheRead, cacheWrite, cost };
+}
+function formatTokensCompact(count) {
+  if (count < 1e3) return String(count);
+  if (count < 1e6) return `${(count / 1e3).toFixed(1)}k`;
+  return `${(count / 1e6).toFixed(2)}M`;
+}
 function buildSessionInfoText(options) {
   const displayCwd = options.homeDir && options.cwd.startsWith(options.homeDir) ? `~${options.cwd.slice(options.homeDir.length)}` : options.cwd;
   let info = options.theme.bold("Session Info") + "\n\n";
@@ -72195,6 +72821,39 @@ function buildSessionInfoText(options) {
 `;
   info += `${options.theme.fg("dim", "Thinking Level:")} ${options.thinkingLevel}
 `;
+  if (options.messages && options.messages.length > 0) {
+    const totals = calculateSessionUsageTotals(options.messages);
+    const turnCount = options.messages.filter((m2) => m2.role === "assistant").length;
+    if (turnCount > 0) {
+      info += `
+${options.theme.bold("Usage (active context)")}
+`;
+      info += `${options.theme.fg("dim", "Turns:")} ${turnCount}
+`;
+      info += `${options.theme.fg("dim", "Input:")} ${totals.input.toLocaleString()}
+`;
+      info += `${options.theme.fg("dim", "Output:")} ${totals.output.toLocaleString()}
+`;
+      if (totals.cacheRead > 0) {
+        info += `${options.theme.fg("dim", "Cache Read:")} ${totals.cacheRead.toLocaleString()}
+`;
+      }
+      if (totals.cacheWrite > 0) {
+        info += `${options.theme.fg("dim", "Cache Write:")} ${totals.cacheWrite.toLocaleString()}
+`;
+      }
+      if (totals.cost > 0) {
+        info += `${options.theme.fg("dim", "Cost:")} $${totals.cost.toFixed(4)}
+`;
+      }
+      const hitRateBase = totals.input + totals.cacheRead;
+      if (hitRateBase > 0 && totals.cacheRead > 0) {
+        const hitRate = (totals.cacheRead / hitRateBase * 100).toFixed(1);
+        info += `${options.theme.fg("dim", "Cache Hit Rate:")} ${hitRate}% (~${formatTokensCompact(hitRateBase)} served)
+`;
+      }
+    }
+  }
   return info;
 }
 function extractUserText(msg) {
@@ -72326,6 +72985,7 @@ async function loadSession(host, sessionId) {
       contextPercent,
       contextWindow
     });
+    applyContextSignalsWithTrace(host);
     host.ui.requestRender();
     setTimeout(() => host.ui.requestRender(), 100);
   } catch (error) {
@@ -73103,8 +73763,9 @@ var BUILTIN_SLASH_COMMANDS = [
   { name: "settings/calm", description: "Toggle calm mode: show only questions and final answers" },
   { name: "settings/yolo", description: "Toggle or set YOLO mode" },
   { name: "debugs/cache-test", description: "Run provider cache diagnostics with a dedicated 2-request probe" },
-  { name: "debugs/context", description: "Append a context summary to ~/.pie/logs/pie-cli.log" },
-  { name: "debugs/package", description: "Append a package summary to ~/.pie/logs/pie-cli.log" },
+  { name: "debugs/context", description: "Context composition report: sections, tokens, drill-down" },
+  { name: "debugs/trace", description: "Session trace: timeline, tool stats, runtime events" },
+  { name: "debugs/boot", description: "Boot composition pipeline: how the runtime was assembled" },
   { name: "settings/quit", description: "Exit Pie" },
   { name: "skills", description: "Manage skills: list, toggle enable/disable, invoke" },
   { name: "skills/list", description: "List available skills (plain text)" },
@@ -73362,6 +74023,7 @@ function bindInteractiveRuntimeEvents(host) {
           contextPercent,
           contextWindow
         });
+        applyContextSignalsWithTrace(host);
         host.safeRequestRender();
         host.sessionManager.save().catch((err) => {
           console.error("[Session] Auto-save failed:", err);
@@ -73810,7 +74472,7 @@ function assistantDisplayBlocks(content) {
 }
 
 // src/commands/interactive-debug-commands.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -73848,7 +74510,7 @@ async function handleCacheTest(host) {
       timestamp: fixedTimestamp
     }
   ];
-  const prefixHash = createHash4("sha256").update(
+  const prefixHash = createHash5("sha256").update(
     JSON.stringify({
       systemPrompt: stablePrefix,
       tools: toolDefs.map((tool) => ({
@@ -73957,126 +74619,6 @@ async function handleCacheTest(host) {
   host.chatContainer.addChild(new Spacer(1));
   host.ui.requestRender();
 }
-async function handleDebugContextCommand(host) {
-  host.chatContainer.addChild(new Spacer(1));
-  host.chatContainer.addChild(new Text(theme.bold("Debug Context"), 1, 0));
-  host.ui.requestRender();
-  try {
-    const state = host.agent.state;
-    const debugInfo = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      systemPrompt: state.systemPrompt,
-      model: state.model,
-      thinkingLevel: state.thinkingLevel,
-      tools: state.tools.map((t) => ({
-        name: t.name,
-        description: t.description,
-        label: t.label
-      })),
-      messageCount: state.messages.length,
-      messages: state.messages,
-      isStreaming: state.isStreaming,
-      pendingToolCalls: Array.from(state.pendingToolCalls)
-    };
-    getLogger().child({ module: "context_dump" }).info("Agent context snapshot", {
-      snapshot: {
-        timestamp: debugInfo.timestamp,
-        modelId: debugInfo.model?.id ?? "",
-        provider: debugInfo.model?.provider ?? "",
-        thinkingLevel: debugInfo.thinkingLevel,
-        toolCount: debugInfo.tools.length,
-        messageCount: debugInfo.messageCount,
-        isStreaming: debugInfo.isStreaming,
-        pendingToolCalls: debugInfo.pendingToolCalls.length
-      }
-    });
-    host.chatContainer.addChild(new Text(
-      theme.fg("success", "\u2713 Context summary appended to ~/.pie/logs/pie-cli.log"),
-      1,
-      0
-    ));
-    host.chatContainer.addChild(new Text(
-      theme.fg("dim", `  Messages: ${state.messages.length}, Tools: ${state.tools.length}`),
-      1,
-      0
-    ));
-  } catch (err) {
-    host.showError(`Failed to save context: ${errorMessage(err)}`);
-  }
-  host.chatContainer.addChild(new Spacer(1));
-  host.ui.requestRender();
-}
-async function handleDebugPackageCommand(host) {
-  host.chatContainer.addChild(new Spacer(1));
-  host.chatContainer.addChild(new Text(theme.bold("Debug Package"), 1, 0));
-  host.ui.requestRender();
-  try {
-    const messages = host.agent.state.messages;
-    const packageInfo = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      totalMessages: messages.length,
-      conversation: messages.map((msg, index) => {
-        const baseInfo = {
-          index,
-          role: msg.role
-        };
-        if (msg.role === "user") {
-          return {
-            ...baseInfo,
-            direction: "\u2192 SEND",
-            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content, null, 2)
-          };
-        } else if (msg.role === "assistant") {
-          const assistantMsg = msg;
-          const toolCalls = assistantMsg.content.filter((c) => c.type === "toolCall").map((c) => ({ name: c.name, arguments: c.arguments, id: c.id }));
-          return {
-            ...baseInfo,
-            direction: "\u2190 RECEIVE",
-            content: assistantMsg.content,
-            toolCalls,
-            usage: assistantMsg.usage
-          };
-        } else if (msg.role === "toolResult") {
-          const toolMsg = msg;
-          return {
-            ...baseInfo,
-            direction: "\u2192 TOOL RESULT",
-            toolCallId: toolMsg.toolCallId,
-            content: toolMsg.content
-          };
-        }
-        return baseInfo;
-      })
-    };
-    getLogger().child({ module: "package_dump" }).info("Agent package snapshot", {
-      snapshot: {
-        timestamp: packageInfo.timestamp,
-        totalMessages: packageInfo.totalMessages,
-        userMessages: packageInfo.conversation.filter((m2) => m2.role === "user").length,
-        assistantMessages: packageInfo.conversation.filter((m2) => m2.role === "assistant").length,
-        toolMessages: packageInfo.conversation.filter((m2) => m2.role === "toolResult").length,
-        lastMessageRole: packageInfo.conversation.length > 0 ? packageInfo.conversation[packageInfo.conversation.length - 1].role : ""
-      }
-    });
-    host.chatContainer.addChild(new Text(
-      theme.fg("success", "\u2713 Package summary appended to ~/.pie/logs/pie-cli.log"),
-      1,
-      0
-    ));
-    const userCount = messages.filter((m2) => m2.role === "user").length;
-    const assistantCount = messages.filter((m2) => m2.role === "assistant").length;
-    const toolCount = messages.filter((m2) => m2.role === "toolResult").length;
-    host.chatContainer.addChild(new Text(
-      theme.fg("dim", `  User: ${userCount}, Assistant: ${assistantCount}, Tool: ${toolCount}`),
-      1,
-      0
-    ));
-  } catch (err) {
-    host.showError(`Failed to save package log: ${errorMessage(err)}`);
-  }
-  host.chatContainer.addChild(new Spacer(1));
-  host.ui.requestRender();
-}
 
 // src/commands/interactive-skill-commands.ts
 import * as fs24 from "fs";
@@ -74530,9 +75072,9 @@ function collectKnownToolNames(host) {
 function describeToggleEffect(host, name, enabled) {
   const loaded = collectKnownToolNames(host).active.includes(name);
   if (enabled) {
-    return loaded ? `Tool "${name}" enabled (active now).` : `Tool "${name}" enabled in ~/.pie/settings.json (loads on next start \u2014 it was not loaded this session).`;
+    return loaded ? `Tool "${name}" enabled (saved to ~/.pie/settings.json; active now).` : `Tool "${name}" enabled in ~/.pie/settings.json (loads on next start \u2014 it was not loaded this session).`;
   }
-  return loaded ? `Tool "${name}" disabled (removed from this session).` : `Tool "${name}" disabled in ~/.pie/settings.json.`;
+  return loaded ? `Tool "${name}" disabled (saved to ~/.pie/settings.json; removed from this and future sessions).` : `Tool "${name}" disabled in ~/.pie/settings.json.`;
 }
 function showToolsManager(host) {
   host.showSelector((done) => {
@@ -74637,7 +75179,7 @@ function handleToolsCommand(host, args) {
       host.chatContainer.addChild(new Text(theme.fg("dim", "  No tools available."), 1, 0));
     }
     for (const name of active) {
-      const state = host.options.settingsManager.isToolEnabled(name) ? "enabled" : "disabled (removed from this session)";
+      const state = host.options.settingsManager.isToolEnabled(name) ? "enabled" : "disabled (saved to ~/.pie/settings.json; removed this session)";
       host.chatContainer.addChild(new Text(theme.fg("dim", `  \u2022 ${name}: ${state}`), 1, 0));
     }
     for (const name of disabled) {
@@ -74653,6 +75195,944 @@ function handleToolsCommand(host, args) {
   showToolsManager(host);
 }
 
+// src/components/context-report-selector.ts
+var RESET2 = "\x1B[0m";
+var INVERSE2 = "\x1B[7m";
+var ROLE_FILTER_CYCLE = ["all", "user", "assistant", "toolResult", "compaction"];
+function createLine2(content, width, isSelected) {
+  const normalized = content.replace(/[\r\n]+/g, " ");
+  const body = isSelected ? INVERSE2 + normalized : normalized;
+  return truncateToWidth(body + RESET2, width, "...", true);
+}
+function buildRootRows(sections, windowSection) {
+  const rows = sections.map((section) => ({
+    id: `section:${section.id}`,
+    label: section.title,
+    estTokens: section.estTokens,
+    note: section.note,
+    detail: section.id === "messages" ? "active context entries (Enter to list)" : void 0,
+    drill: {
+      kind: "rows",
+      title: `${section.title}`,
+      rows: section.rows,
+      rowKind: section.id === "messages" ? "messages" : "plain"
+    }
+  }));
+  if (windowSection) {
+    rows.push({
+      id: "section:window",
+      label: windowSection.label,
+      estTokens: windowSection.estTokens,
+      valueText: windowSection.valueText,
+      detail: windowSection.detail,
+      drill: {
+        kind: "rows",
+        title: windowSection.title ?? windowSection.label,
+        rows: windowSection.rows,
+        rowKind: "plain"
+      }
+    });
+  }
+  return rows;
+}
+var ContextReportSelectorComponent = class {
+  options;
+  maxVisibleLines;
+  views = [];
+  selectedIndex = 0;
+  searchQuery = "";
+  statusMessage = null;
+  _focused = false;
+  get focused() {
+    return this._focused;
+  }
+  set focused(value) {
+    this._focused = value;
+  }
+  constructor(options) {
+    this.options = options;
+    this.maxVisibleLines = Math.max(15, Math.floor(options.terminalHeight * 0.6));
+    this.views = [
+      {
+        kind: "list",
+        title: options.title,
+        rows: buildRootRows(options.sections, options.windowSection),
+        rowKind: "root",
+        roleFilter: "all",
+        sortBySize: false
+      }
+    ];
+  }
+  // ---------------------------------------------------------------------------
+  // Filtering / sorting
+  // ---------------------------------------------------------------------------
+  get currentView() {
+    return this.views[this.views.length - 1];
+  }
+  visibleListRows(view) {
+    let rows = view.rows;
+    if (view.roleFilter !== "all") {
+      rows = rows.filter((row) => row.roleTag === view.roleFilter);
+    }
+    if (view.rowKind === "messages" && view.sortBySize) {
+      rows = [...rows].sort((a, b2) => b2.estTokens - a.estTokens);
+    }
+    if (this.searchQuery) {
+      const query = this.searchQuery.toLowerCase();
+      rows = rows.filter(
+        (row) => `${row.label} ${row.detail ?? ""} ${row.note ?? ""} ${row.roleTag ?? ""}`.toLowerCase().includes(query)
+      );
+    }
+    return rows;
+  }
+  applyFilterChange() {
+    this.selectedIndex = 0;
+    this.statusMessage = null;
+  }
+  // ---------------------------------------------------------------------------
+  // Navigation
+  // ---------------------------------------------------------------------------
+  moveUp() {
+    const view = this.currentView;
+    if (view.kind === "list") {
+      const rows = this.visibleListRows(view);
+      if (rows.length > 0) {
+        this.selectedIndex = (this.selectedIndex - 1 + rows.length) % rows.length;
+      }
+    } else {
+      view.scroll = Math.max(0, view.scroll - 1);
+    }
+  }
+  moveDown() {
+    const view = this.currentView;
+    if (view.kind === "list") {
+      const rows = this.visibleListRows(view);
+      if (rows.length > 0) {
+        this.selectedIndex = (this.selectedIndex + 1) % rows.length;
+      }
+    } else {
+      view.scroll = Math.min(Math.max(0, view.lines.length - 1), view.scroll + 1);
+    }
+  }
+  pageUp() {
+    const view = this.currentView;
+    if (view.kind === "list") {
+      this.selectedIndex = Math.max(0, this.selectedIndex - this.maxVisibleLines);
+    } else {
+      view.scroll = Math.max(0, view.scroll - this.maxVisibleLines);
+    }
+  }
+  pageDown() {
+    const view = this.currentView;
+    if (view.kind === "list") {
+      const rows = this.visibleListRows(view);
+      this.selectedIndex = Math.min(Math.max(0, rows.length - 1), this.selectedIndex + this.maxVisibleLines);
+    } else {
+      view.scroll = Math.min(
+        Math.max(0, view.lines.length - 1),
+        view.scroll + this.maxVisibleLines
+      );
+    }
+  }
+  pushTextView(title, text) {
+    this.searchQuery = "";
+    this.views.push({
+      kind: "text",
+      title,
+      lines: text.replace(/\r\n/g, "\n").split("\n"),
+      scroll: 0
+    });
+    this.selectedIndex = 0;
+    this.statusMessage = null;
+  }
+  drillIntoSelected() {
+    const view = this.currentView;
+    if (view.kind !== "list") return;
+    const rows = this.visibleListRows(view);
+    const row = rows[this.selectedIndex];
+    if (!row) return;
+    if (!row.drill) {
+      this.statusMessage = "no further detail";
+      return;
+    }
+    switch (row.drill.kind) {
+      case "rows":
+        this.searchQuery = "";
+        this.views.push({
+          kind: "list",
+          title: row.drill.title,
+          rows: row.drill.rows,
+          rowKind: row.drill.rowKind,
+          roleFilter: "all",
+          sortBySize: false
+        });
+        this.selectedIndex = 0;
+        this.statusMessage = null;
+        break;
+      case "text":
+        this.pushTextView(row.drill.title, row.drill.text);
+        break;
+      case "entry": {
+        const text = this.options.getEntryText?.(row.drill.entryId) ?? null;
+        if (text === null) {
+          this.statusMessage = "entry body unavailable";
+        } else {
+          this.pushTextView(`Entry \xB7 ${row.label}`, text);
+        }
+        break;
+      }
+    }
+  }
+  popView() {
+    if (this.views.length > 1) {
+      this.views.pop();
+      this.selectedIndex = 0;
+      this.statusMessage = null;
+    } else {
+      this.options.onDone();
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Input
+  // ---------------------------------------------------------------------------
+  handleInput(keyData) {
+    const kb = getEditorKeybindings();
+    if (kb.matches(keyData, "selectUp")) {
+      this.moveUp();
+    } else if (kb.matches(keyData, "selectDown")) {
+      this.moveDown();
+    } else if (kb.matches(keyData, "selectPageUp")) {
+      this.pageUp();
+    } else if (kb.matches(keyData, "selectPageDown")) {
+      this.pageDown();
+    } else if (kb.matches(keyData, "selectConfirm")) {
+      this.drillIntoSelected();
+    } else if (kb.matches(keyData, "selectCancel")) {
+      if (this.searchQuery) {
+        this.searchQuery = "";
+        this.applyFilterChange();
+      } else {
+        this.popView();
+      }
+    } else if (matchesKey(keyData, "ctrl+u")) {
+      const view = this.currentView;
+      if (view.kind === "list" && view.rowKind === "messages") {
+        const next = ROLE_FILTER_CYCLE[(ROLE_FILTER_CYCLE.indexOf(view.roleFilter) + 1) % ROLE_FILTER_CYCLE.length];
+        view.roleFilter = next;
+        this.applyFilterChange();
+      }
+    } else if ((keyData === "s" || keyData === "S") && this.searchQuery === "") {
+      const view = this.currentView;
+      if (view.kind === "list" && view.rowKind === "messages") {
+        view.sortBySize = !view.sortBySize;
+        this.applyFilterChange();
+      }
+    } else if (kb.matches(keyData, "deleteCharBackward")) {
+      if (this.searchQuery.length > 0) {
+        this.searchQuery = this.searchQuery.slice(0, -1);
+        this.applyFilterChange();
+      }
+    } else {
+      const hasControlChars = [...keyData].some((ch) => {
+        const code = ch.charCodeAt(0);
+        return code < 32 || code === 127 || code >= 128 && code <= 159;
+      });
+      if (!hasControlChars && keyData.length > 0 && this.searchQuery.length < 100) {
+        this.searchQuery += keyData;
+        this.applyFilterChange();
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Rendering
+  // ---------------------------------------------------------------------------
+  invalidate() {
+  }
+  hintsLine(view) {
+    if (view.kind === "text") {
+      return "  \u2191\u2193:scroll  Esc:back";
+    }
+    const base = "  \u2191\u2193:move  Enter:drill  Esc:back  type:search  PgUp/PgDn:page";
+    if (view.rowKind === "messages") {
+      return `${base}  ctrl+u:role(${view.roleFilter})  s:sort(${view.sortBySize ? "size" : "seq"})`;
+    }
+    return base;
+  }
+  renderRowLine(row, width, selected) {
+    const valueText = row.valueText ?? `~${formatReportTokens(row.estTokens)}`;
+    const rightParts = [theme.fg("accent", valueText)];
+    if (row.note) {
+      rightParts.push(theme.fg("dim", row.note));
+    }
+    const right = rightParts.join(" ");
+    const rightWidth = visibleWidth(right);
+    const marker = row.marker ? theme.fg("warning", `${row.marker} `) : "";
+    const detail = row.detail ? theme.fg("dim", ` \xB7 ${row.detail}`) : "";
+    let left = `  ${marker}${row.label}${detail}`;
+    const leftBudget = Math.max(12, width - rightWidth - 3);
+    if (visibleWidth(left) > leftBudget) {
+      left = truncateToWidth(left, leftBudget, "\u2026");
+    }
+    const gap = Math.max(1, width - visibleWidth(left) - rightWidth - 1);
+    return createLine2(`${left}${" ".repeat(gap)}${right}`, width, selected);
+  }
+  render(width) {
+    const lines = [];
+    const totalLines = this.maxVisibleLines + 5;
+    const view = this.currentView;
+    const depthSuffix = this.views.length > 1 ? theme.fg("dim", `  (${this.views.length} levels)`) : "";
+    lines.push(createLine2(`  ${theme.bold(view.title)}${depthSuffix}`, width, false));
+    lines.push(createLine2(this.hintsLine(view), width, false));
+    const searchPart = this.searchQuery ? `Search: ${this.searchQuery}` : "";
+    const statusPart = this.statusMessage ? theme.fg("warning", this.statusMessage) : "";
+    const statusLine = [searchPart, statusPart].filter(Boolean).join("  \xB7  ");
+    lines.push(createLine2(statusLine, width, false));
+    lines.push(createLine2("", width, false));
+    if (view.kind === "list") {
+      const rows = this.visibleListRows(view);
+      if (rows.length === 0) {
+        const notice = this.searchQuery || view.roleFilter !== "all" ? "  (no matching rows)" : "  (empty)";
+        lines.push(createLine2(notice, width, false));
+        for (let i = 1; i < this.maxVisibleLines; i++) {
+          lines.push(createLine2("", width, false));
+        }
+      } else {
+        this.selectedIndex = Math.max(0, Math.min(this.selectedIndex, rows.length - 1));
+        let startIndex = Math.max(
+          0,
+          Math.min(
+            this.selectedIndex - Math.floor(this.maxVisibleLines / 2),
+            rows.length - this.maxVisibleLines
+          )
+        );
+        const endIndex = Math.min(startIndex + this.maxVisibleLines, rows.length);
+        if (endIndex - startIndex < this.maxVisibleLines && startIndex > 0) {
+          startIndex = Math.max(0, endIndex - this.maxVisibleLines);
+        }
+        for (let i = startIndex; i < endIndex; i++) {
+          lines.push(this.renderRowLine(rows[i], width, i === this.selectedIndex));
+        }
+        for (let i = endIndex - startIndex; i < this.maxVisibleLines; i++) {
+          lines.push(createLine2("", width, false));
+        }
+      }
+      const filterSuffix = view.roleFilter !== "all" ? ` [${view.roleFilter}]` : "";
+      const sortSuffix = view.rowKind === "messages" && view.sortBySize ? " [size]" : "";
+      lines.push(
+        createLine2(
+          `  (${this.selectedIndex + 1}/${this.visibleListRows(view).length})${filterSuffix}${sortSuffix}`,
+          width,
+          false
+        )
+      );
+    } else {
+      const total = view.lines.length;
+      const start = Math.min(view.scroll, Math.max(0, total - 1));
+      const end = Math.min(start + this.maxVisibleLines, total);
+      for (let i = start; i < end; i++) {
+        lines.push(createLine2(`  ${view.lines[i]}`, width, false));
+      }
+      for (let i = end - start; i < this.maxVisibleLines; i++) {
+        lines.push(createLine2("", width, false));
+      }
+      lines.push(
+        createLine2(`  (lines ${total > 0 ? start + 1 : 0}-${end} of ${total})`, width, false)
+      );
+    }
+    while (lines.length < totalLines) {
+      lines.push(createLine2("", width, false));
+    }
+    return lines.slice(0, totalLines);
+  }
+};
+
+// src/commands/interactive-context-command.ts
+var MAX_ENTRY_BODY_CHARS = 1e4;
+var MAX_ARCHIVED_ROWS = 200;
+function fetchArchivedSummaries(sessionManager, firstKeptSeq) {
+  const result = [];
+  let afterSeq;
+  while (result.length < MAX_ARCHIVED_ROWS) {
+    const page = sessionManager.getEntrySummariesPage({ limit: 100, afterSeq });
+    if (page.summaries.length === 0) break;
+    let crossedCutPoint = false;
+    for (const summary of page.summaries) {
+      if (summary.seq >= firstKeptSeq) {
+        crossedCutPoint = true;
+        break;
+      }
+      if (result.length >= MAX_ARCHIVED_ROWS) break;
+      result.push(summary);
+    }
+    if (crossedCutPoint || !page.hasMore) break;
+    afterSeq = page.summaries[page.summaries.length - 1].seq;
+  }
+  return result;
+}
+function enhanceCheckpointRowWithArchive(report, host, entries) {
+  const messagesSection = report.sections.find((section) => section.id === "messages");
+  const checkpoint = [...entries].reverse().find((entry) => entry.type === "compaction");
+  if (!messagesSection || !checkpoint) return;
+  const compactionEntry = host.sessionManager.getEntry(checkpoint.id);
+  const firstKeptEntryId = compactionEntry?.compactionData?.firstKeptEntryId;
+  if (!firstKeptEntryId) return;
+  const firstKeptSeq = host.sessionManager.getEntrySummary(firstKeptEntryId)?.seq;
+  if (firstKeptSeq === void 0) return;
+  const archived = fetchArchivedSummaries(host.sessionManager, firstKeptSeq);
+  if (archived.length === 0) return;
+  const row = messagesSection.rows.find((candidate) => candidate.id === `entry:${checkpoint.id}`);
+  if (!row) return;
+  const truncated = archived.length >= MAX_ARCHIVED_ROWS;
+  row.drill = {
+    kind: "rows",
+    title: `Archived @ checkpoint #${checkpoint.seq}`,
+    rowKind: "plain",
+    rows: [
+      {
+        id: "checkpoint-summary",
+        label: "checkpoint summary",
+        estTokens: checkpoint.estTokens,
+        drill: {
+          kind: "text",
+          title: "Checkpoint Summary",
+          text: compactionEntry?.compactionData?.summary ?? ""
+        }
+      },
+      ...archived.map((summary) => ({
+        id: `archived:${summary.id}`,
+        label: `#${summary.seq} ${summary.role ?? summary.type}`,
+        estTokens: summary.estTokens,
+        detail: summary.preview,
+        drill: { kind: "entry", entryId: summary.id }
+      })),
+      ...truncated ? [{
+        id: "archived:truncated",
+        label: `\u2026 archived list capped at ${MAX_ARCHIVED_ROWS} entries (oldest first)`,
+        estTokens: 0
+      }] : []
+    ]
+  };
+}
+function formatEntryBodyText(entry) {
+  if (!entry) return null;
+  if (entry.type === "compaction") {
+    const summary = entry.compactionData?.summary ?? "";
+    const before = entry.compactionData?.tokensBefore;
+    const header = before !== void 0 ? `# compaction checkpoint (context was ~${formatReportTokens(before)} before)
+` : "# compaction checkpoint\n";
+    return `${header}
+${summary}`.slice(0, MAX_ENTRY_BODY_CHARS) || null;
+  }
+  const message = entry.message;
+  if (!message) return null;
+  if (message.role === "user") {
+    const parts = ["# user message"];
+    const content = message.content;
+    if (typeof content === "string") {
+      parts.push(content);
+    } else if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block && block.type === "text" && typeof block.text === "string") {
+          parts.push(block.text);
+        } else if (block && "type" in block) {
+          parts.push(`[${block.type}]`);
+        }
+      }
+    }
+    return parts.join("\n").slice(0, MAX_ENTRY_BODY_CHARS) || null;
+  }
+  if (message.role === "assistant") {
+    const parts = ["# assistant message"];
+    const usage = message.usage;
+    if (usage) {
+      parts.push(
+        `usage: input ${usage.input} \xB7 output ${usage.output} \xB7 cacheRead ${usage.cacheRead} \xB7 cacheWrite ${usage.cacheWrite}`
+      );
+    }
+    if (Array.isArray(message.content)) {
+      for (const block of message.content) {
+        if (block.type === "text") {
+          parts.push(block.text);
+        } else if (block.type === "thinking") {
+          parts.push("[thinking omitted from context on most providers]");
+        } else if (block.type === "toolCall") {
+          parts.push(`\u2192 ${block.name}(${JSON.stringify(block.arguments)})`);
+        }
+      }
+    }
+    return parts.join("\n").slice(0, MAX_ENTRY_BODY_CHARS) || null;
+  }
+  if (message.role === "toolResult") {
+    const parts = [`# tool result (${message.toolCallId})`];
+    if (Array.isArray(message.content)) {
+      for (const block of message.content) {
+        if (block.type === "text") {
+          parts.push(block.text);
+        } else if (block.type === "image") {
+          parts.push("[image]");
+        } else if (block.type === "audio") {
+          parts.push("[audio]");
+        } else if (block.type === "video") {
+          parts.push("[video]");
+        } else {
+          parts.push(`[${block.type}]`);
+        }
+      }
+    }
+    return parts.join("\n").slice(0, MAX_ENTRY_BODY_CHARS) || null;
+  }
+  return JSON.stringify(message, null, 2).slice(0, MAX_ENTRY_BODY_CHARS) || null;
+}
+function handleContextReportCommand(host) {
+  const systemPrompt = host.agent.state.systemPrompt ?? "";
+  const knowledgeFiles = parseProjectContextSection(host.knowledgeSection);
+  const entries = host.sessionManager.getActiveContextSummaries();
+  const usage = host.calculateContextUsage();
+  const contextWindow = host.options.model?.contextWindow ?? 0;
+  const reserveTokens = host.options.settingsManager.getAutoCompactReserveTokens();
+  const autoCompactLimit = contextWindow > 0 ? getAutoCompactTokenLimit(contextWindow, reserveTokens) ?? null : null;
+  const prefixHash = computePromptPrefixHash(
+    systemPrompt,
+    host.agent.state.tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }))
+  );
+  const lastSignals2 = getLastContextSignals(host);
+  const promptPrefixChanged = lastSignals2 !== null && lastSignals2.prefixHash !== prefixHash;
+  const report = buildContextReportData({
+    systemPrompt,
+    skillsSection: host.skillsSection,
+    knowledgeFiles,
+    skills: host.skills.map((skill) => ({
+      name: skill.name,
+      description: skill.description,
+      filePath: skill.filePath,
+      baseDir: skill.baseDir,
+      source: skill.source
+    })),
+    tools: host.agent.state.tools.map((tool) => ({
+      name: tool.name,
+      label: tool.label,
+      description: tool.description,
+      parameters: tool.parameters
+    })),
+    entries,
+    compactionTokensBefore: (entryId) => host.sessionManager.getEntry(entryId)?.compactionData?.tokensBefore,
+    contextWindow,
+    actualTokens: usage.tokens,
+    autoCompactLimitTokens: autoCompactLimit,
+    reserveTokens,
+    promptPrefixHash: prefixHash,
+    promptPrefixChanged
+  });
+  enhanceCheckpointRowWithArchive(report, host, entries);
+  host.chatContainer.addChild(new Spacer(1));
+  host.chatContainer.addChild(new Text(buildContextOverviewText(report, theme), 1, 0));
+  host.ui.requestRender();
+  host.showSelector((done) => {
+    const selector = new ContextReportSelectorComponent({
+      title: "Context Report",
+      sections: report.sections,
+      windowSection: {
+        label: "window & thresholds",
+        estTokens: report.contextWindow,
+        valueText: report.contextWindow > 0 ? formatReportTokens(report.contextWindow) : "?",
+        title: "Window & Thresholds",
+        detail: "context window, estimate vs actual, auto-compact",
+        rows: buildWindowRows(report)
+      },
+      terminalHeight: host.ui.terminal.rows,
+      getEntryText: (entryId) => formatEntryBodyText(host.sessionManager.getEntry(entryId)),
+      onDone: done
+    });
+    return { component: selector, focus: selector };
+  });
+}
+
+// src/core/trace-report.ts
+var MAX_DRILL_CHARS = 8e3;
+function formatTime(at) {
+  return new Date(at).toLocaleTimeString([], { hour12: false });
+}
+function formatDurationMs(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${Math.floor(ms / 6e4)}m${Math.round(ms % 6e4 / 1e3)}s`;
+}
+function detailsToText(event) {
+  const header = [
+    `# ${event.type}`,
+    `at: ${new Date(event.at).toISOString()}`,
+    event.summary ? `summary: ${event.summary}` : "",
+    event.failure ? "failure: true" : ""
+  ].filter(Boolean).join("\n");
+  const details = event.details === void 0 ? "" : `
+
+# details
+${safeStringify(event.details).slice(0, MAX_DRILL_CHARS)}`;
+  return `${header}${details}`;
+}
+function safeStringify(value) {
+  try {
+    return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+function buildTimelineRows(timeline) {
+  if (timeline.length === 0) {
+    return [{ id: "timeline:none", label: "no runtime events recorded yet", estTokens: 0 }];
+  }
+  return [...timeline].sort((a, b2) => b2.at - a.at).map((event, index) => ({
+    id: `timeline:${event.at}:${index}`,
+    label: `${formatTime(event.at)} ${event.type}`,
+    estTokens: 0,
+    detail: event.summary || void 0,
+    marker: event.failure ? "\u2716" : void 0,
+    drill: {
+      kind: "text",
+      title: `Event \xB7 ${event.type}`,
+      text: detailsToText(event)
+    }
+  }));
+}
+function aggregateToolStats(turns) {
+  const stats = /* @__PURE__ */ new Map();
+  for (const turn of turns) {
+    for (const call of turn.toolCalls) {
+      const stat2 = stats.get(call.toolName) ?? {
+        name: call.toolName,
+        calls: 0,
+        errors: 0,
+        totalMs: 0
+      };
+      stat2.calls += 1;
+      if (call.status === "failed") stat2.errors += 1;
+      if (call.endedAt !== void 0 && call.endedAt >= call.startedAt) {
+        stat2.totalMs += call.endedAt - call.startedAt;
+      }
+      stats.set(call.toolName, stat2);
+    }
+  }
+  return [...stats.values()].sort((a, b2) => b2.totalMs - a.totalMs || b2.calls - a.calls);
+}
+function buildToolStatRows(turns) {
+  const stats = aggregateToolStats(turns);
+  if (stats.length === 0) {
+    return [{ id: "tools:none", label: "no tool calls in recent turns", estTokens: 0 }];
+  }
+  return stats.map((stat2) => ({
+    id: `toolstat:${stat2.name}`,
+    label: stat2.name,
+    estTokens: 0,
+    valueText: formatDurationMs(stat2.totalMs),
+    note: `${stat2.calls} calls${stat2.errors > 0 ? ` \xB7 ${stat2.errors} errors` : ""}`,
+    drill: {
+      kind: "rows",
+      title: `Tool Calls \xB7 ${stat2.name}`,
+      rowKind: "plain",
+      rows: collectCalls(turns, stat2.name)
+    }
+  }));
+}
+function collectCalls(turns, toolName) {
+  const rows = [];
+  for (const turn of turns) {
+    for (const call of turn.toolCalls) {
+      if (call.toolName !== toolName) continue;
+      const duration = call.endedAt !== void 0 && call.endedAt >= call.startedAt ? formatDurationMs(call.endedAt - call.startedAt) : "running";
+      rows.push({
+        id: `call:${call.toolCallId ?? `${call.startedAt}:${rows.length}`}`,
+        label: `${formatTime(call.startedAt)} ${call.status}`,
+        estTokens: 0,
+        valueText: duration,
+        detail: call.resultSummary || void 0,
+        marker: call.status === "failed" ? "\u2716" : void 0,
+        drill: {
+          kind: "text",
+          title: `Call \xB7 ${toolName}`,
+          text: [
+            `# ${toolName} (${call.status})`,
+            `started: ${new Date(call.startedAt).toISOString()}`,
+            call.endedAt !== void 0 ? `ended: ${new Date(call.endedAt).toISOString()}` : "",
+            call.outcome !== void 0 ? `
+# outcome
+${safeStringify(call.outcome)}` : ""
+          ].filter(Boolean).join("\n").slice(0, MAX_DRILL_CHARS)
+        }
+      });
+    }
+  }
+  return rows.sort((a, b2) => a.id.localeCompare(b2.id));
+}
+function buildTurnRows(turns) {
+  if (turns.length === 0) {
+    return [{ id: "turns:none", label: "no completed turns recorded yet", estTokens: 0 }];
+  }
+  return [...turns].sort((a, b2) => b2.turnIndex - a.turnIndex).map((turn) => {
+    const duration = turn.completedAt !== void 0 && turn.startedAt !== void 0 && turn.completedAt >= turn.startedAt ? formatDurationMs(turn.completedAt - turn.startedAt) : "\u2014";
+    return {
+      id: `turn:${turn.turnIndex}`,
+      label: `#${turn.turnIndex} ${turn.state}`,
+      estTokens: 0,
+      valueText: duration,
+      note: `${turn.toolCalls.length} tool calls`,
+      detail: turn.userText?.slice(0, 80) || void 0,
+      marker: turn.state === "failed" ? "\u2716" : void 0,
+      drill: {
+        kind: "text",
+        title: `Turn #${turn.turnIndex}`,
+        text: turnToText(turn)
+      }
+    };
+  });
+}
+function turnToText(turn) {
+  const parts = [
+    `# turn ${turn.turnIndex} (${turn.state})`,
+    turn.startedAt !== void 0 ? `started: ${new Date(turn.startedAt).toISOString()}` : "",
+    turn.completedAt !== void 0 ? `completed: ${new Date(turn.completedAt).toISOString()}` : ""
+  ];
+  if (turn.userText) parts.push(`
+# user
+${turn.userText.slice(0, 2e3)}`);
+  if (turn.assistantText) parts.push(`
+# assistant
+${turn.assistantText.slice(0, 2e3)}`);
+  if (turn.errorMessage) parts.push(`
+# error
+${turn.errorMessage}`);
+  if (turn.toolCalls.length > 0) {
+    parts.push(
+      `
+# tool calls
+${turn.toolCalls.map(
+        (call) => `- ${call.toolName} (${call.status})${call.endedAt !== void 0 && call.endedAt >= call.startedAt ? ` ${formatDurationMs(call.endedAt - call.startedAt)}` : ""}${call.resultSummary ? ` \u2014 ${call.resultSummary.slice(0, 200)}` : ""}`
+      ).join("\n")}`
+    );
+  }
+  return parts.filter(Boolean).join("\n").slice(0, MAX_DRILL_CHARS);
+}
+function buildRuntimeSummaryRows(snapshot) {
+  const summary = snapshot.runtimeSummary;
+  if (!summary) {
+    return [{ id: "runtime:none", label: "no runtime summary recorded yet", estTokens: 0 }];
+  }
+  const entries = [
+    ["tool results", summary.toolResults, "completed tool calls (recent turns)"],
+    ["tool errors", summary.toolErrors, "failed tool calls (recent turns)"],
+    ["retries", summary.retryEvents, "provider/overflow retries"],
+    ["auto-compactions", summary.autoCompactionEvents, "context checkpoints this session"],
+    ["runtime guard events", summary.runtimeGuardEvents, "guard advisories triggered"],
+    ["queued turn events", summary.queuedTurnEvents, "steer/followUp queue dispatches"],
+    ["subagent events", summary.subagentEvents, "subagent lifecycle events"]
+  ];
+  return entries.map(([label, count, detail]) => ({
+    id: `runtime:${label}`,
+    label,
+    estTokens: count,
+    valueText: String(count),
+    note: count > 0 ? void 0 : "none",
+    detail
+  }));
+}
+function buildSubagentRows(snapshot) {
+  const summaries = snapshot.subagentSummaries ?? [];
+  if (summaries.length === 0) {
+    return [{ id: "subagents:none", label: "no subagent tasks recorded yet", estTokens: 0 }];
+  }
+  return summaries.map((sub, index) => ({
+    id: `subagent:${sub.toolCallId ?? index}`,
+    label: sub.name,
+    estTokens: 0,
+    valueText: sub.status,
+    note: sub.modelId ? `${sub.modelClass ? `${sub.modelClass}/` : ""}${sub.modelId}` : void 0,
+    detail: [
+      sub.evidenceCount > 0 ? `${sub.evidenceCount} evidence` : "",
+      sub.failureReason ? `failed: ${sub.failureReason}` : "",
+      sub.modelFallbackReason ? `fallback: ${sub.modelFallbackReason}` : ""
+    ].filter(Boolean).join(" \xB7 ") || void 0,
+    marker: sub.status === "failed" || sub.failureReason ? "\u2716" : void 0,
+    drill: {
+      kind: "text",
+      title: `Subagent \xB7 ${sub.name}`,
+      text: safeStringify(sub).slice(0, MAX_DRILL_CHARS)
+    }
+  }));
+}
+function buildTraceSections(snapshot) {
+  const turns = [...snapshot.recentTurns];
+  if (snapshot.activeTurn) turns.push(snapshot.activeTurn);
+  const timeline = snapshot.recentTimeline ?? [];
+  return [
+    {
+      id: "trace-timeline",
+      title: `Timeline (${timeline.length})`,
+      estTokens: 0,
+      rows: buildTimelineRows(timeline)
+    },
+    {
+      id: "trace-tools",
+      title: "Tool stats (recent turns)",
+      estTokens: 0,
+      note: aggregateToolStats(turns)[0] ? `slowest: ${aggregateToolStats(turns)[0].name} ${formatDurationMs(aggregateToolStats(turns)[0].totalMs)}` : void 0,
+      rows: buildToolStatRows(turns)
+    },
+    {
+      id: "trace-turns",
+      title: `Recent turns (${snapshot.recentTurns.length}${snapshot.activeTurn ? " +1 active" : ""})`,
+      estTokens: 0,
+      rows: buildTurnRows(
+        snapshot.activeTurn ? [...snapshot.recentTurns, snapshot.activeTurn] : snapshot.recentTurns
+      )
+    },
+    {
+      id: "trace-runtime",
+      title: "Runtime summary",
+      estTokens: 0,
+      rows: buildRuntimeSummaryRows(snapshot)
+    },
+    {
+      id: "trace-subagents",
+      title: `Subagents (${(snapshot.subagentSummaries ?? []).length})`,
+      estTokens: 0,
+      rows: buildSubagentRows(snapshot)
+    }
+  ];
+}
+function buildTraceOverviewText(snapshot, theme2) {
+  const t = theme2 ?? { bold: (s) => s, fg: (_k, s) => s };
+  const lines = [];
+  const turns = snapshot.recentTurns.length + (snapshot.activeTurn ? 1 : 0);
+  const timeline = snapshot.recentTimeline ?? [];
+  lines.push(t.bold("Session Trace") + t.fg("dim", `  \xB7  ${turns} recent turns \xB7 ${timeline.length} events`));
+  const summary = snapshot.runtimeSummary;
+  if (summary) {
+    const notable = [];
+    if (summary.retryEvents > 0) notable.push(`retries ${summary.retryEvents}`);
+    if (summary.autoCompactionEvents > 0) notable.push(`compactions ${summary.autoCompactionEvents}`);
+    if (summary.runtimeGuardEvents > 0) notable.push(`guard ${summary.runtimeGuardEvents}`);
+    if (summary.toolErrors > 0) notable.push(`tool errors ${summary.toolErrors}`);
+    if (notable.length > 0) {
+      lines.push(t.fg("dim", `  events: ${notable.join(" \xB7 ")}`));
+    } else {
+      lines.push(t.fg("dim", "  no retries, compactions, or guard events"));
+    }
+  }
+  const stats = aggregateToolStats([...snapshot.recentTurns, ...snapshot.activeTurn ? [snapshot.activeTurn] : []]);
+  if (stats.length > 0) {
+    const top = stats.slice(0, 3).map((s) => `${s.name} ${formatDurationMs(s.totalMs)} (${s.calls})`);
+    lines.push(t.fg("dim", `  tools: ${top.join(" \xB7 ")}`));
+  }
+  lines.push(t.fg("dim", "  /debugs/trace \xB7 Enter to drill, Esc to go back"));
+  return lines.join("\n");
+}
+
+// src/commands/interactive-trace-command.ts
+function handleTraceCommand(host, snapshot) {
+  if (!snapshot) {
+    host.showStatus("No session trace yet \u2014 it starts with the first turn");
+    return;
+  }
+  const sections = buildTraceSections(snapshot);
+  host.chatContainer.addChild(new Spacer(1));
+  host.chatContainer.addChild(new Text(buildTraceOverviewText(snapshot, theme), 1, 0));
+  host.ui.requestRender();
+  host.showSelector((done) => {
+    const selector = new ContextReportSelectorComponent({
+      title: "Session Trace",
+      sections,
+      terminalHeight: host.ui.terminal.rows,
+      onDone: done
+    });
+    return { component: selector, focus: selector };
+  });
+}
+
+// src/core/boot-report.ts
+function stepToText(step) {
+  const lines = [
+    `# ${step.id}`,
+    `input:  ${step.inputSummary}`,
+    `output: ${step.outputSummary}`
+  ];
+  if (step.toolCount !== void 0) lines.push(`tools:   ${step.toolCount}`);
+  if (step.policyDecisions?.length) {
+    lines.push("", "# policy decisions", ...step.policyDecisions.map((decision) => `- ${decision}`));
+  }
+  if (step.extensionWrapping) {
+    lines.push(
+      "",
+      "# extension wrapping",
+      `extensions: ${step.extensionWrapping.extensionCount}`,
+      `extension tools: ${step.extensionWrapping.extensionToolCount}`,
+      `wrapped tools: ${step.extensionWrapping.wrappedToolCount}`
+    );
+  }
+  return lines.join("\n");
+}
+function buildBootRows(trace) {
+  if (trace.steps.length === 0) {
+    return [{ id: "boot:none", label: "no composition steps recorded", estTokens: 0 }];
+  }
+  return trace.steps.map((step, index) => ({
+    id: `boot:${step.id}`,
+    label: `${index + 1}. ${step.id}`,
+    estTokens: 0,
+    note: step.toolCount !== void 0 ? `${step.toolCount} tools` : void 0,
+    detail: step.outputSummary,
+    drill: {
+      kind: "text",
+      title: `Step \xB7 ${step.id}`,
+      text: stepToText(step)
+    }
+  }));
+}
+function buildBootSections(trace) {
+  return [
+    {
+      id: "boot-pipeline",
+      title: `Composition pipeline (${trace.steps.length} steps)`,
+      estTokens: 0,
+      rows: buildBootRows(trace)
+    }
+  ];
+}
+function buildBootOverviewText(trace, theme2) {
+  const t = theme2 ?? { bold: (s) => s, fg: (_k, s) => s };
+  const lines = [];
+  lines.push(t.bold("Boot Composition") + t.fg("dim", `  \xB7  ${trace.steps.length} steps`));
+  for (const step of trace.steps) {
+    lines.push(t.fg("dim", `  ${step.id} \u2014 ${step.outputSummary}`));
+  }
+  lines.push(t.fg("dim", "  /debugs/boot \xB7 Enter to drill into a step"));
+  return lines.join("\n");
+}
+
+// src/commands/interactive-boot-command.ts
+function handleBootCommand(host) {
+  const trace = host.options.compositionTrace;
+  if (!trace || trace.steps.length === 0) {
+    host.showStatus("No composition trace available for this runtime");
+    return;
+  }
+  const sections = buildBootSections(trace);
+  host.chatContainer.addChild(new Spacer(1));
+  host.chatContainer.addChild(new Text(buildBootOverviewText(trace, theme), 1, 0));
+  host.ui.requestRender();
+  host.showSelector((done) => {
+    const selector = new ContextReportSelectorComponent({
+      title: "Boot Composition",
+      sections,
+      terminalHeight: host.ui.terminal.rows,
+      onDone: done
+    });
+    return { component: selector, focus: selector };
+  });
+}
+
 // src/commands/interactive-command-handlers.ts
 function showSettingsSelector(host, focusItem) {
   host.showSelector((done) => {
@@ -75077,6 +76557,7 @@ async function handleClearCommand(host) {
     contextPercent: contextWindow > 0 && contextUsage.tokens !== null ? contextUsage.tokens / contextWindow * 100 : 0,
     contextWindow
   });
+  applyContextSignalsWithTrace(host);
   host.updateTerminalTitle();
   host.chatContainer.clear();
   host.streamingComponent = void 0;
@@ -75123,6 +76604,7 @@ function handleSessionCommand(host) {
     homeDir: process.env.HOME || process.env.USERPROFILE || "",
     modelId: host.options.model?.id,
     thinkingLevel: host.thinkingLevel,
+    messages: host.sessionManager.getMessages(),
     theme
   });
   host.chatContainer.addChild(new Spacer(1));
@@ -75164,7 +76646,10 @@ function createExtensionContextForCommands(host) {
         console.error(`[Extension] Tools restricted to: ${tools.join(", ")}`);
       }
     },
-    getActiveTools: () => host.agent.state.tools.map((tool) => tool.name),
+    getActiveTools: () => {
+      const tools = host.agent.state.tools;
+      return (host.planModeEnabled ? tools.filter((tool) => isToolAllowedInPlanMode(tool)) : tools).map((tool) => tool.name);
+    },
     sendUserMessage: (content) => {
       if (host.editor.onSubmit) {
         void host.editor.onSubmit(content);
@@ -75356,12 +76841,16 @@ function registerBuiltinCommands(host) {
     handler: () => host.handleCacheTest()
   });
   commandTree.register(["debugs", "context"], {
-    description: "Append a context summary to ~/.pie/logs/pie-cli.log",
-    handler: () => host.handleDebugContextCommand()
+    description: "Context composition report: sections, tokens, drill-down",
+    handler: () => host.handleDebugReportCommand("context")
+  });
+  commandTree.register(["debugs", "trace"], {
+    description: "Session trace: timeline, tool stats, runtime events",
+    handler: () => host.handleDebugReportCommand("trace")
   });
-  commandTree.register(["debugs", "package"], {
-    description: "Append a package summary to ~/.pie/logs/pie-cli.log",
-    handler: () => host.handleDebugPackageCommand()
+  commandTree.register(["debugs", "boot"], {
+    description: "Boot composition pipeline: how the runtime was assembled",
+    handler: () => host.handleDebugReportCommand("boot")
   });
   commandTree.register(["settings", "quit"], {
     description: "Exit Pie",
@@ -75372,6 +76861,36 @@ function registerBuiltinCommands(host) {
   });
 }
 
+// src/runtime/compaction-diff.ts
+function summarizeActiveContext(summaries) {
+  let tokens = 0;
+  for (const summary of summaries) {
+    tokens += summary.estTokens;
+  }
+  return { count: summaries.length, tokens };
+}
+function formatCompactionTokenLine(stats) {
+  const saved = Math.max(0, stats.before.tokens - stats.after.tokens);
+  const percent = stats.before.tokens > 0 ? Math.round(saved / stats.before.tokens * 100) : 0;
+  return `~${formatReportTokens(stats.before.tokens)} \u2192 ~${formatReportTokens(stats.after.tokens)} tokens (saved ~${formatReportTokens(saved)}, \u2212${percent}%)`;
+}
+function renderCompactionDiffPanel(target, stats) {
+  const archived = Math.max(0, stats.before.count - stats.after.count);
+  target.chatContainer.addChild(new Spacer(1));
+  target.chatContainer.addChild(new Text(theme.fg("accent", "\u2691 Context checkpoint"), 1, 0));
+  target.chatContainer.addChild(
+    new Text(
+      theme.fg(
+        "dim",
+        `  kept ${stats.after.count} entries \xB7 archived ${archived} entries \xB7 ${formatCompactionTokenLine(stats)}`
+      ),
+      1,
+      0
+    )
+  );
+  target.safeRequestRender();
+}
+
 // src/commands/interactive-compact-command.ts
 async function handleCompactCommand(host) {
   if (host.submitLock || host.isProcessing || host.isCompacting) {
@@ -75390,6 +76909,7 @@ async function handleCompactCommand(host) {
   host.chatContainer.addChild(new Spacer(1));
   host.chatContainer.addChild(new Text(theme.fg("dim", "[/sessions/compact]"), 1, 0));
   host.safeRequestRender();
+  const beforeStats = summarizeActiveContext(host.sessionManager.getActiveContextSummaries());
   try {
     const activeEntryId = host.sessionManager.getActiveEntryId();
     if (!activeEntryId) {
@@ -75426,14 +76946,17 @@ async function handleCompactCommand(host) {
     const compactedMessages = host.sessionManager.getMessages();
     host.replaceAgentMessagesAndMarkSynced(compactedMessages);
     host.resetFileObservationState();
+    host.resetRuntimeModeBlocks?.();
     host.streamingComponent = void 0;
     host.pendingTools.clear();
     host.chatContainer.clear();
     host.lastStatusSpacer = void 0;
     host.lastStatusText = void 0;
     host.renderMessageHistory(compactedMessages);
-    host.chatContainer.addChild(new Spacer(1));
-    host.chatContainer.addChild(new Text(theme.fg("accent", "Context compacted"), 1, 0));
+    renderCompactionDiffPanel(host, {
+      before: beforeStats,
+      after: summarizeActiveContext(host.sessionManager.getActiveContextSummaries())
+    });
     const contextUsage = host.calculateContextUsage();
     const contextWindow = host.options.model?.contextWindow ?? 0;
     const contextPercent = contextWindow > 0 && contextUsage.tokens !== null ? contextUsage.tokens / contextWindow * 100 : 0;
@@ -75448,6 +76971,7 @@ async function handleCompactCommand(host) {
       contextPercent,
       contextWindow
     });
+    applyContextSignalsWithTrace(host);
     await host.sessionManager.save();
     host.safeRequestRender();
   } catch (error) {
@@ -77566,8 +79090,12 @@ function queueMessage(host, text, mode, options = {}) {
   }
   const clearEditor = options.clearEditor ?? true;
   host.sessionTrace.notePendingUserText(text);
+  const runtimeBlock = host.runtimeModeBlockForNextMessage?.();
+  const content = runtimeBlock ? `${runtimeBlock}
+
+${text}` : text;
   void host.agentSessionController.prompt(
-    { role: "user", content: text, timestamp: Date.now() },
+    { role: "user", content, timestamp: Date.now() },
     {
       source: "interactive",
       streamingBehavior: mode,
@@ -77824,6 +79352,14 @@ var FooterComponent = class {
     if (state.cacheRead) statsParts.push(`R${formatTokens(state.cacheRead)}`);
     if (state.cacheWrite) statsParts.push(`W${formatTokens(state.cacheWrite)}`);
     if (state.cost) statsParts.push(`$${state.cost.toFixed(3)}`);
+    if (state.cacheHitRate != null) {
+      statsParts.push(theme.fg("dim", `ca ${(state.cacheHitRate * 100).toFixed(0)}%`));
+    }
+    if (state.prefixHash) {
+      statsParts.push(
+        state.prefixHashChanged ? theme.fg("warning", `\u26A1${state.prefixHash}`) : theme.fg("dim", `\u2301${state.prefixHash}`)
+      );
+    }
     if (state.contextWindow) {
       const autoIndicator = this.autoCompactEnabled ? " (auto)" : "";
       const percent = state.contextPercent ?? 0;
@@ -77896,27 +79432,13 @@ var FooterComponent = class {
 // src/components/todo-widget.ts
 var TodoWidgetComponent = class extends Container {
   state;
-  calmMode = false;
   constructor(state) {
     super();
     this.state = state;
     void this.refresh();
   }
-  /** Calm mode hides the progress widget (questions/answers only). */
-  setCalmMode(calm) {
-    if (this.calmMode === calm) return;
-    this.calmMode = calm;
-    if (calm) {
-      this.clear();
-    } else {
-      void this.refresh();
-    }
-  }
   async refresh() {
     this.clear();
-    if (this.calmMode) {
-      return;
-    }
     const lines = renderExecutionWidgetLines(this.state.getWidgetSteps());
     if (lines.length === 0) {
       return;
@@ -78907,6 +80429,7 @@ function createInteractiveAgentSessionController(host) {
   }
   let retryElapsedTicker;
   let retryElapsedStartedAt = 0;
+  let autoCompactBeforeStats = null;
   const attention = cliAttention(host);
   const stopRetryElapsedTicker = () => {
     if (retryElapsedTicker !== void 0) {
@@ -78972,6 +80495,7 @@ function createInteractiveAgentSessionController(host) {
           if (!firstKeptEntryId) return { aborted: true };
           return { summary: beforeCompact.summary, firstKeptEntryId };
         }
+        autoCompactBeforeStats = summarizeActiveContext(context.sessionManager.getActiveContextSummaries());
         return createCliAutoCompactionResult({
           context,
           model: host.options.model,
@@ -79140,9 +80664,11 @@ function createInteractiveAgentSessionController(host) {
           host.showError(`${prefix}: ${event.errorMessage}`);
           host.footer.setState({ status: "ready" });
           host.setControllerBusy(false);
+          autoCompactBeforeStats = null;
           return;
         }
         host.resetFileObservationState();
+        host.resetRuntimeModeBlocks?.();
         if (!event.result?.aborted) {
           host.streamingComponent = void 0;
           host.pendingTools.clear();
@@ -79165,10 +80691,20 @@ function createInteractiveAgentSessionController(host) {
           contextPercent,
           contextWindow
         });
+        applyContextSignalsWithTrace(host);
         host.safeRequestRender();
-        if (!event.willRetry && !event.result?.aborted) {
-          host.showStatus("Context auto-compacted");
+        if (!event.result?.aborted) {
+          if (autoCompactBeforeStats !== null) {
+            renderCompactionDiffPanel(host, {
+              before: autoCompactBeforeStats,
+              after: summarizeActiveContext(host.sessionManager.getActiveContextSummaries())
+            });
+          }
+          if (!event.willRetry) {
+            host.showStatus("Context auto-compacted");
+          }
         }
+        autoCompactBeforeStats = null;
       } else if (event.type === "auto_continue_scheduled") {
         host.setControllerBusy(true);
         if (event.reason === "todo_closure") {
@@ -79184,94 +80720,80 @@ function createInteractiveAgentSessionController(host) {
 }
 
 // src/runtime/runtime-mode-context.ts
-var RUNTIME_MODE_CONTEXT_MARKER = "<runtime-mode-context>";
-var RUNTIME_MODE_CONTEXT_END_MARKER = "</runtime-mode-context>";
-var STALE_SYSTEM_REMINDER_RE = /<system-reminder>\s*# Plan Mode[\s\S]*?<\/system-reminder>\s*/gi;
-var STALE_RUNTIME_CONTEXT_RE = /<runtime-mode-context>[\s\S]*?<\/runtime-mode-context>\s*/gi;
-function isRecord3(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
+function isAgentMessage(value) {
+  return !!value && typeof value === "object" && "role" in value;
 }
-function cleanText(text) {
-  let stripped = 0;
-  const withoutRuntime = text.replace(STALE_RUNTIME_CONTEXT_RE, () => {
-    stripped++;
-    return "";
-  });
-  const withoutPlanReminder = withoutRuntime.replace(STALE_SYSTEM_REMINDER_RE, () => {
-    stripped++;
-    return "";
-  });
-  return { text: withoutPlanReminder, stripped };
-}
-function stripUserMessage(message) {
-  if (!isRecord3(message) || message.role !== "user") {
-    return { message, stripped: 0 };
+function prependRuntimeModeBlockToPrompt(input, block) {
+  if (!block) return input;
+  if (typeof input === "string") {
+    return input.trim() ? `${block}
+
+${input}` : block;
   }
-  const content = message.content;
-  if (typeof content === "string") {
-    const cleaned = cleanText(content);
-    if (cleaned.stripped === 0) return { message, stripped: 0 };
-    return {
-      message: {
-        ...message,
-        content: cleaned.text
-      },
-      stripped: cleaned.stripped
-    };
+  if (Array.isArray(input)) {
+    if (input.length > 0 && isAgentMessage(input[0])) {
+      return prependBlockToMessages(input, block);
+    }
+    return [{ type: "text", text: block }, ...input];
   }
-  if (!Array.isArray(content)) {
-    return { message, stripped: 0 };
-  }
-  let stripped = 0;
-  const nextContent = content.map((block) => {
-    if (!isRecord3(block) || block.type !== "text" || typeof block.text !== "string") {
-      return block;
-    }
-    const cleaned = cleanText(block.text);
-    stripped += cleaned.stripped;
-    return { ...block, text: cleaned.text };
-  }).filter((block) => !(isRecord3(block) && block.type === "text" && String(block.text ?? "").length === 0));
-  if (stripped === 0) return { message, stripped: 0 };
-  return {
-    message: {
-      ...message,
-      content: nextContent
-    },
-    stripped
-  };
+  if (isAgentMessage(input)) {
+    return prependBlockToMessages([input], block)[0];
+  }
+  return [{ type: "text", text: block }, ...input];
 }
-function stripRuntimeModeContext(messages) {
-  let stripped = 0;
-  const nextMessages = [];
-  for (const message of messages) {
-    const result = stripUserMessage(message);
-    stripped += result.stripped;
-    if (isRecord3(result.message) && result.message.role === "user") {
-      const content = result.message.content;
-      if (typeof content === "string" && content.trim().length === 0) {
-        continue;
-      }
-      if (Array.isArray(content) && content.length === 0) {
-        continue;
-      }
+function prependBlockToMessages(messages, block) {
+  const next = [...messages];
+  let target = -1;
+  for (let index = next.length - 1; index >= 0; index--) {
+    if (next[index]?.role === "user") {
+      target = index;
+      break;
     }
-    nextMessages.push(result.message);
   }
-  return { messages: nextMessages, stripped };
+  if (target < 0) {
+    next.push({ role: "user", content: block, timestamp: Date.now() });
+    return next;
+  }
+  const message = next[target];
+  if (typeof message.content === "string") {
+    next[target] = { ...message, content: `${block}
+
+${message.content}` };
+  } else if (Array.isArray(message.content)) {
+    next[target] = { ...message, content: [{ type: "text", text: block }, ...message.content] };
+  } else {
+    next.splice(target, 0, { role: "user", content: block, timestamp: Date.now() });
+  }
+  return next;
 }
+var RUNTIME_MODE_CONTEXT_MARKER = "<runtime-mode-context>";
+var RUNTIME_MODE_CONTEXT_END_MARKER = "</runtime-mode-context>";
 function buildRuntimeModeContext(state) {
   const lines = [
     RUNTIME_MODE_CONTEXT_MARKER,
-    "Current runtime mode:",
-    `- Plan mode: ${state.planMode === "planning" ? "active (workspace read-only; plan_scratch permits session-local temporary drafts)" : "off"}.`,
+    "Current runtime mode:"
+  ];
+  if (state.planMode === "planning") {
+    lines.push(
+      "- Plan mode: active (workspace read-only; plan_scratch permits session-local temporary drafts; submit the finished plan by calling plan_submit with the ordered steps for user approval)."
+    );
+    if (state.planDisabledToolNames.length > 0) {
+      lines.push(
+        `- Disabled this turn by plan mode (calls are denied): ${state.planDisabledToolNames.join(", ")}. Do not call them while planning.`
+      );
+    }
+  } else {
+    lines.push("- Plan mode: off.");
+  }
+  lines.push(
     `- YOLO mode: ${state.yoloMode ? "on (filesystem sandbox directory restrictions are disabled)" : "off (workspace/protected-path restrictions apply)"}.`,
     `- Filesystem scope: ${state.filesystemScope === "all" ? "all local paths may be passed directly to file tools when permitted" : "workspace paths and configured safe roots only"}.`
-  ];
+  );
   if (state.pendingTransition) {
     const transitionText = {
       entered_yolo: "YOLO mode was just enabled for this turn.",
       exited_yolo: "YOLO mode was just disabled; do not assume previous absolute-path access still applies.",
-      entered_plan: "Plan mode was just enabled; analyze and plan without changing the workspace. Use plan_scratch for temporary drafts.",
+      entered_plan: "Plan mode was just enabled; analyze and plan without changing the workspace. Use plan_scratch for temporary drafts, then submit the finished plan by calling plan_submit with the ordered steps for user approval.",
       exited_plan: "Plan mode was just disabled; execution tools may be used when the task requires them."
     };
     lines.push(`- Transition: ${transitionText[state.pendingTransition]}`);
@@ -79285,46 +80807,108 @@ function buildRuntimeModeContext(state) {
   lines.push(RUNTIME_MODE_CONTEXT_END_MARKER);
   return lines.join("\n");
 }
-function findLatestUserIndex(messages) {
-  for (let index = messages.length - 1; index >= 0; index--) {
-    const message = messages[index];
-    if (isRecord3(message) && message.role === "user") {
-      return index;
-    }
-  }
-  return -1;
+function runtimeModeBlockKey(state) {
+  return JSON.stringify({
+    planMode: state.planMode,
+    yoloMode: state.yoloMode,
+    filesystemScope: state.filesystemScope,
+    currentDate: state.currentDate ?? null,
+    activeToolNames: state.activeToolNames,
+    planDisabledToolNames: state.planDisabledToolNames
+  });
 }
-function injectRuntimeModeContext(messages, state) {
-  const contextMessage = {
-    role: "user",
-    content: buildRuntimeModeContext(state),
-    timestamp: Date.now()
-  };
-  const latestUserIndex = findLatestUserIndex(messages);
-  if (latestUserIndex < 0) {
-    return [...messages, contextMessage];
-  }
-  return [
-    ...messages.slice(0, latestUserIndex),
-    contextMessage,
-    ...messages.slice(latestUserIndex)
-  ];
+function shouldInjectRuntimeModeBlock(lastKey, state) {
+  if (lastKey === null) return true;
+  return runtimeModeBlockKey(state) !== lastKey;
 }
-function createRuntimeModeTransformContext(options) {
-  return async (messages) => {
-    const stripped = stripRuntimeModeContext(messages);
-    if (stripped.stripped > 0) {
-      options.onStripped?.(stripped.stripped);
-    }
-    const state = options.getState();
-    const nextMessages = injectRuntimeModeContext(stripped.messages, state);
-    options.onInjected?.(state);
-    if (state.pendingTransition) {
-      options.consumeTransition?.();
-    }
-    return nextMessages;
+function runtimeModeTraceData(state) {
+  return {
+    yoloMode: state.yoloMode,
+    planMode: state.planMode,
+    filesystemScope: state.filesystemScope,
+    pendingTransition: state.pendingTransition,
+    currentDate: state.currentDate,
+    timeZone: state.timeZone,
+    activeToolCount: state.activeToolNames.length,
+    planDisabledToolCount: state.planDisabledToolNames.length
   };
 }
+function currentDateInZone(timeZone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    timeZone
+  }).formatToParts(/* @__PURE__ */ new Date());
+  const part = (type) => parts.find((p) => p.type === type)?.value ?? "00";
+  return `${part("year")}-${part("month")}-${part("day")}`;
+}
+var RUNTIME_MODE_BLOCK_PATTERN = /^[\t ]*<runtime-mode-context>[\s\S]*?<\/runtime-mode-context>[\t ]*(?:\r?\n){0,2}/;
+function refreshRuntimeModeBlockOnLastUserMessage(messages, block) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message?.role !== "user") continue;
+    const content = typeof message.content === "string" ? message.content : "";
+    const stripped = content.replace(RUNTIME_MODE_BLOCK_PATTERN, "");
+    const refreshed = stripped === content && content.includes("<runtime-mode-context>") ? content : `${block}
+
+${stripped}`;
+    if (refreshed === content) return messages;
+    const next = [...messages];
+    next[i] = { ...message, content: refreshed };
+    return next;
+  }
+  return messages;
+}
+var RuntimeModeBlockInjector = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  lastKey = null;
+  pendingRetryRefresh = false;
+  reset() {
+    this.lastKey = null;
+    this.pendingRetryRefresh = true;
+  }
+  /** Block to prepend to the next user message, or null when unchanged. */
+  nextBlock() {
+    const block = this.freshBlock();
+    this.pendingRetryRefresh = false;
+    return block;
+  }
+  /**
+   * Latest block for a request that reuses existing history (overflow retry
+   * after compaction, manual compaction continue): the last user message may
+   * carry a stale or evicted block, so the request-level transform refreshes
+   * it. Consumed once per reset; null when nothing is pending.
+   */
+  consumeRetryRefreshBlock() {
+    if (!this.pendingRetryRefresh) return null;
+    this.pendingRetryRefresh = false;
+    const state = this.options.getState();
+    return buildRuntimeModeContext(state);
+  }
+  freshBlock() {
+    const state = this.options.getState();
+    if (!shouldInjectRuntimeModeBlock(this.lastKey, state)) return null;
+    this.lastKey = runtimeModeBlockKey(state);
+    if (state.pendingTransition) this.options.consumeTransition();
+    this.options.noteTrace(state);
+    return buildRuntimeModeContext(state);
+  }
+};
+
+// src/runtime/cache-retention.ts
+function createCacheRetentionStreamFn(configured) {
+  const base = configured ?? ((model, context, options) => streamSimple(model, context, options));
+  return (model, context, options) => base(model, context, {
+    ...options,
+    // Default only: explicit none/short requests (tests, debug commands) win.
+    // Note: cost estimates still price cache writes at the short-TTL rate.
+    cacheRetention: model.api === "anthropic-messages" && options?.cacheRetention === void 0 ? "long" : options?.cacheRetention
+  });
+}
 
 // src/runtime/guard-advisory-context.ts
 var GUARD_ADVISORY_MARKER = "<runtime-guard-advisory>";
@@ -79338,12 +80922,19 @@ function isMarkerOnlyUserMessage(message) {
 function stripGuardAdvisories(messages) {
   return messages.filter((message) => !isMarkerOnlyUserMessage(message));
 }
-function findLatestUserIndex2(messages) {
+function findLatestUserIndex(messages) {
   for (let index = messages.length - 1; index >= 0; index -= 1) {
     if (messages[index].role === "user") return index;
   }
   return -1;
 }
+function applyRuntimeRequestTransform(messages, options) {
+  const advisory = options.takeAdvisory();
+  let next = advisory ? injectGuardAdvisory(messages, advisory) : stripGuardAdvisories(messages);
+  const retryBlock = options.takeRetryBlock();
+  if (retryBlock) next = refreshRuntimeModeBlockOnLastUserMessage(next, retryBlock);
+  return next;
+}
 function injectGuardAdvisory(messages, guidance) {
   const advisoryMessage = {
     role: "user",
@@ -79352,7 +80943,7 @@ ${guidance}
 ${GUARD_ADVISORY_END_MARKER}`,
     timestamp: Date.now()
   };
-  const latestUserIndex = findLatestUserIndex2(messages);
+  const latestUserIndex = findLatestUserIndex(messages);
   if (latestUserIndex < 0) {
     return [...messages, advisoryMessage];
   }
@@ -79363,11 +80954,6 @@ ${GUARD_ADVISORY_END_MARKER}`,
   ];
 }
 
-// src/runtime/tool-policy.ts
-function selectToolsForRuntimeMode(tools, mode) {
-  return selectToolsForRuntimePolicy(tools, mode);
-}
-
 // src/runtime/terminal-bell.ts
 var BEL = "\x07";
 var DEFAULT_MIN_INTERVAL_MS = 500;
@@ -79565,7 +81151,7 @@ function createInteractiveExtensionUIContext(host) {
     }
   };
   return {
-    notify: (message, type = "info") => showExtensionNotification(host, message, type),
+    notify: (message, type = "info", opts) => showExtensionNotification(host, message, type, opts),
     select: (title, options, opts) => interact(() => showExtensionSelector2(host, title, options, opts)),
     confirm: async (title, message, opts) => await interact(() => showExtensionConfirm(host, title, message, opts)) === true,
     input: (title, placeholder, opts) => interact(() => showExtensionInput(host, title, placeholder, opts)),
@@ -79713,10 +81299,14 @@ function installInteractiveInteractionHandler(host) {
     }
   });
 }
-function showExtensionNotification(host, message, type = "info") {
+function showExtensionNotification(host, message, type = "info", opts) {
   const prefix = type === "error" ? "Error: " : type === "warning" ? "Warning: " : "";
   host.chatContainer.addChild(new Spacer(1));
-  host.chatContainer.addChild(new Text(theme.fg(type === "error" ? "error" : type === "warning" ? "warning" : "dim", `${prefix}${message}`), 1, 0));
+  if (opts?.markdown) {
+    host.chatContainer.addChild(new Markdown(`${prefix}${message}`, 1, 0, getMarkdownTheme()));
+  } else {
+    host.chatContainer.addChild(new Text(theme.fg(type === "error" ? "error" : type === "warning" ? "warning" : "dim", `${prefix}${message}`), 1, 0));
+  }
   host.ui.requestRender();
 }
 function showExtensionSelector2(host, title, options, opts) {
@@ -80087,7 +81677,10 @@ async function loadInteractiveExtensions(host) {
         console.error(`[Extension] Tools set to: ${toolNames.join(", ")}`);
       }
     },
-    getActiveTools: () => host.agent.state.tools.map((t) => t.name),
+    getActiveTools: () => {
+      const tools = host.agent.state.tools;
+      return (host.planModeEnabled ? tools.filter((tool) => isToolAllowedInPlanMode(tool)) : tools).map((tool) => tool.name);
+    },
     sendUserMessage: (content) => {
       if (host.editor.onSubmit) {
         void host.editor.onSubmit(content);
@@ -80177,7 +81770,8 @@ async function loadInteractiveExtensions(host) {
     reload: () => host.reloadRuntime(),
     get yoloMode() {
       return host.yoloMode;
-    }
+    },
+    setYoloMode: host.setYoloMode ? (enabled) => host.setYoloMode?.(enabled) : void 0
   };
   const contextActions = {
     isIdle: () => !host.isProcessing,
@@ -80208,7 +81802,15 @@ async function loadInteractiveExtensions(host) {
       console.error(`[Extension] Failed to load ${path34}: ${error}`);
     }
   }
-  const extensionTools = filterEnabledTools(convertExtensionTools(extensions), host.options.settingsManager);
+  const policyContext = () => ({
+    mode: host.planModeEnabled ? "plan" : "normal",
+    yoloMode: host.yoloMode,
+    confirmationPolicy: "allow"
+  });
+  const extensionTools = filterEnabledTools(
+    createPolicyEnforcedTools(convertExtensionTools(extensions), { getContext: policyContext }),
+    host.options.settingsManager
+  );
   const activeTools = [...host.agent.state.tools, ...extensionTools];
   host.agent.state.tools = wrapToolsWithExtensions(activeTools, host.extensionRunner);
   const availableTools = [
@@ -80285,6 +81887,12 @@ var InteractiveMode = class {
   pendingYoloModeTransition = null;
   executionReminder = null;
   pendingRuntimeGuardAdvisory = null;
+  /** Freezes runtime mode blocks into user messages (cache-stable history). */
+  runtimeModeBlocks = new RuntimeModeBlockInjector({
+    getState: () => this.getRuntimeModeState(),
+    consumeTransition: () => this.consumeRuntimeModeTransition(),
+    noteTrace: (state) => this.sessionTrace.noteRuntimeEvent("runtime_context_injected", runtimeModeTraceData(state))
+  });
   fileManager;
   mentionHandler;
   mentionPickerComponent;
@@ -80447,6 +82055,11 @@ var InteractiveMode = class {
   get controllerSetupHost() {
     return this;
   }
+  getPolicyContext = () => ({
+    mode: this.planModeEnabled ? "plan" : "normal",
+    yoloMode: this.yoloMode,
+    confirmationPolicy: "allow"
+  });
   rebuildSkillAwareTools(sourceTools) {
     const preservedTools = sourceTools.filter(
       (tool) => !CLI_FILESYSTEM_TOOL_NAMES.includes(tool.name) && tool.name !== "bash"
@@ -80472,19 +82085,14 @@ var InteractiveMode = class {
     });
     const normalFsTools = createCliFileSystemTools(this.options.cwd, fileSystemToolOptions([this.options.configDir]));
     const currentFsTools = this.yoloMode ? createCliFileSystemTools(this.options.cwd, fileSystemToolOptions(["/"])) : normalFsTools;
-    const getPolicyContext = () => ({
-      mode: this.planModeEnabled ? "plan" : "normal",
-      yoloMode: this.yoloMode,
-      confirmationPolicy: "allow"
-    });
     return {
       currentTools: createPolicyEnforcedTools(
         [...currentFsTools, bashTool, ...preservedTools],
-        { getContext: getPolicyContext }
+        { getContext: this.getPolicyContext }
       ),
       originalTools: createPolicyEnforcedTools(
         [...normalFsTools, bashTool, ...preservedTools],
-        { getContext: getPolicyContext }
+        { getContext: this.getPolicyContext }
       )
     };
   }
@@ -80492,26 +82100,27 @@ var InteractiveMode = class {
     this.options.fileObservationState.clear();
   }
   getRuntimeModeState() {
-    const pendingTransition = this.getPendingRuntimeModeTransition();
     const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || "local";
-    const dateParts = new Intl.DateTimeFormat("en-US", {
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit",
-      timeZone
-    }).formatToParts(/* @__PURE__ */ new Date());
-    const datePart = (type) => dateParts.find((part) => part.type === type)?.value ?? "00";
-    const currentDate = `${datePart("year")}-${datePart("month")}-${datePart("day")}`;
+    const activeTools = this.agent?.state?.tools ?? [];
     return {
       yoloMode: this.yoloMode,
       planMode: this.planModeEnabled ? "planning" : "off",
       filesystemScope: this.yoloMode ? "all" : "workspace",
-      ...pendingTransition ? { pendingTransition } : {},
-      currentDate,
+      ...this.getPendingRuntimeModeTransition() ? { pendingTransition: this.getPendingRuntimeModeTransition() } : {},
+      currentDate: currentDateInZone(timeZone),
       timeZone,
-      activeToolNames: this.agent?.state?.tools?.map((tool) => tool.name) ?? []
+      activeToolNames: activeTools.map((tool) => tool.name),
+      planDisabledToolNames: this.planModeEnabled ? activeTools.filter((tool) => !isToolAllowedInPlanMode(tool)).map((tool) => tool.name) : []
     };
   }
+  /** Public reset for compaction flows (compaction may drop the latest block). */
+  resetRuntimeModeBlocks() {
+    this.runtimeModeBlocks.reset();
+  }
+  /** Runtime mode block for the next user message; frozen into it (append-only history, cache-stable prefixes). */
+  runtimeModeBlockForNextMessage() {
+    return this.runtimeModeBlocks.nextBlock();
+  }
   getPendingRuntimeModeTransition() {
     if (this.pendingYoloModeTransition === "enter") return "entered_yolo";
     if (this.pendingYoloModeTransition === "exit") return "exited_yolo";
@@ -80530,10 +82139,7 @@ var InteractiveMode = class {
     const currentTools = this.extensionRunner ? wrapToolsWithExtensions(rebuilt.currentTools, this.extensionRunner) : rebuilt.currentTools;
     const originalTools = this.extensionRunner ? wrapToolsWithExtensions(rebuilt.originalTools, this.extensionRunner) : rebuilt.originalTools;
     const activeTools = filterEnabledTools(
-      selectToolsForRuntimeMode(
-        currentTools,
-        this.planModeEnabled ? "plan" : "normal"
-      ),
+      currentTools,
       this.options.settingsManager
     );
     this.agent.setTools(activeTools);
@@ -80566,7 +82172,8 @@ var InteractiveMode = class {
     this.safeRequestRender();
   }
   promptAgent(input) {
-    return this.agentSessionController.prompt(input, { source: "interactive" });
+    const prompt = prependRuntimeModeBlockToPrompt(input, this.runtimeModeBlockForNextMessage());
+    return this.agentSessionController.prompt(prompt, { source: "interactive" });
   }
   continueAgent() {
     return this.agentSessionController.continue();
@@ -80596,6 +82203,7 @@ var InteractiveMode = class {
       this.persistExecutionState();
     }
     this.executionReminder = this.executionState.getReminder();
+    this.resetRuntimeModeBlocks();
     await this.refreshTodoWidget();
     await this.emitExtensionEvent({
       type: "session:changed",
@@ -80606,7 +82214,7 @@ var InteractiveMode = class {
   async init() {
     const activeSession = this.sessionManager.getActiveSession();
     this.thinkingLevel = resolveInitialThinkingLevel({ session: activeSession, settingsManager: this.options.settingsManager });
-    const { Agent } = await import("./chunks/src-HPIBCE2I.js");
+    const { Agent } = await import("./chunks/src-E7NCXMU5.js");
     this.agent = new Agent({
       initialState: {
         systemPrompt: this.buildSystemPrompt(),
@@ -80616,28 +82224,15 @@ var InteractiveMode = class {
       },
       apiKey: this.options.apiKey,
       sessionId: activeSession?.id,
-      streamFn: this.options.streamFn,
-      transformContext: async (messages) => {
-        const runtimeModeTransform = createRuntimeModeTransformContext({
-          getState: () => this.getRuntimeModeState(),
-          consumeTransition: () => this.consumeRuntimeModeTransition(),
-          onInjected: (state) => this.sessionTrace.noteRuntimeEvent("runtime_context_injected", {
-            yoloMode: state.yoloMode,
-            planMode: state.planMode,
-            filesystemScope: state.filesystemScope,
-            pendingTransition: state.pendingTransition,
-            currentDate: state.currentDate,
-            timeZone: state.timeZone,
-            activeToolCount: state.activeToolNames.length
-          }),
-          onStripped: (count) => this.sessionTrace.noteRuntimeEvent("stale_runtime_context_stripped", { count })
-        });
-        let transformed = await runtimeModeTransform(messages);
-        const advisory = this.pendingRuntimeGuardAdvisory;
-        this.pendingRuntimeGuardAdvisory = null;
-        transformed = advisory ? injectGuardAdvisory(transformed, advisory) : stripGuardAdvisories(transformed);
-        return transformed;
-      }
+      streamFn: createCacheRetentionStreamFn(this.options.streamFn),
+      transformContext: async (messages) => applyRuntimeRequestTransform(messages, {
+        takeAdvisory: () => {
+          const advisory = this.pendingRuntimeGuardAdvisory;
+          this.pendingRuntimeGuardAdvisory = null;
+          return advisory;
+        },
+        takeRetryBlock: () => this.runtimeModeBlocks.consumeRetryRefreshBlock()
+      })
     });
     this.agentSessionController = createInteractiveAgentSessionController(this.controllerSetupHost);
     this.updateTerminalTitle();
@@ -80821,6 +82416,9 @@ var InteractiveMode = class {
   async handleYoloCommand(args) {
     return handleYoloCommand(this, args);
   }
+  setYoloMode(enabled) {
+    void this.handleYoloCommand(enabled ? "on" : "off");
+  }
   /**
    * Toggle calm mode and rebuild the chat so already-rendered rows follow
    * the new mode. Delivery, tool execution, and session storage are
@@ -80832,7 +82430,6 @@ var InteractiveMode = class {
     this.options.settingsManager.setCalmModeEnabled(enabled);
     this.footer.setState({ calmMode: enabled });
     applyCalmMode(this, enabled);
-    this.todoWidget.setCalmMode(enabled);
     this.extensionWidgets.setCalmMode(enabled);
     this.showStatus(`Calm mode ${enabled ? "on \u2014 showing questions and final answers only" : "off"}`);
     this.safeRequestRender(true);
@@ -80870,11 +82467,11 @@ var InteractiveMode = class {
   async handleCacheTest() {
     return handleCacheTest(this);
   }
-  async handleDebugContextCommand() {
-    return handleDebugContextCommand(this);
+  async handleTreeCommand() {
+    return handleTreeCommand(this);
   }
-  async handleDebugPackageCommand() {
-    return handleDebugPackageCommand(this);
+  handleDebugReportCommand(kind) {
+    return kind === "context" ? handleContextReportCommand(this) : kind === "trace" ? handleTraceCommand(this, this.sessionTrace.getLiveSnapshot()) : handleBootCommand(this);
   }
   async handleResumeCommand() {
     return handleResumeCommand(this);
@@ -80894,9 +82491,6 @@ var InteractiveMode = class {
   setWaitingForUser(waiting) {
     return setWaitingForUser(this, waiting);
   }
-  async handleTreeCommand() {
-    return handleTreeCommand(this);
-  }
   async forkAtEntry(entryId) {
     return forkAtEntry(this, entryId);
   }
@@ -81196,6 +82790,7 @@ async function composeCliRuntime(params) {
     getPolicyContext: () => ({ mode: "normal", confirmationPolicy: "allow" })
   };
   const rawTools = [
+    createSearchContextTool(() => sessionManager),
     ...createCliFileSystemTools(cwd, fileSystemToolOptions),
     ...cliHostCapabilities.tools
   ];
@@ -81441,7 +83036,7 @@ async function runPrintMode(params) {
 `);
     console.log("Assistant: ");
   }
-  const { Agent: AgentClass } = await import("./chunks/src-HPIBCE2I.js");
+  const { Agent: AgentClass } = await import("./chunks/src-E7NCXMU5.js");
   let agent;
   const printModeExtensions = await loadPrintModeExtensions({
     cwd: runtime.cwd,
@@ -81681,7 +83276,7 @@ function toJsonValue(value, depth = 0, cap = MAX_EVENT_STRING_LENGTH) {
   }
   return result;
 }
-function isRecord4(value) {
+function isRecord3(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function truncateForEvent(text, cap) {
@@ -81707,7 +83302,7 @@ function parseInput(line) {
   } catch {
     return null;
   }
-  if (!isRecord4(parsed) || typeof parsed.type !== "string") return null;
+  if (!isRecord3(parsed) || typeof parsed.type !== "string") return null;
   if (parsed.type === "shutdown") {
     return { type: "shutdown", reason: typeof parsed.reason === "string" ? parsed.reason : void 0 };
   }
@@ -81758,7 +83353,7 @@ function parseInput(line) {
       prompt: parsed.prompt,
       streamingBehavior,
       cwd: typeof parsed.cwd === "string" ? parsed.cwd : void 0,
-      metadata: isRecord4(parsed.metadata) ? parsed.metadata : void 0
+      metadata: isRecord3(parsed.metadata) ? parsed.metadata : void 0
     };
   }
   return null;
@@ -81798,15 +83393,15 @@ function readProgressText(value) {
 function extractJsonEventsToolProgressText(partialResult) {
   const plainText = readProgressText(partialResult).trim();
   if (plainText) return plainText;
-  if (!isRecord4(partialResult)) return "";
+  if (!isRecord3(partialResult)) return "";
   const content = partialResult.content;
   if (Array.isArray(content)) {
-    return content.map((block) => isRecord4(block) && block.type === "text" ? readProgressText(block.text) : "").filter(Boolean).join("\n").trim();
+    return content.map((block) => isRecord3(block) && block.type === "text" ? readProgressText(block.text) : "").filter(Boolean).join("\n").trim();
   }
   const directText = readProgressText(partialResult.text) || readProgressText(partialResult.message);
   if (directText) return directText.trim();
   const details = partialResult.details;
-  if (isRecord4(details)) {
+  if (isRecord3(details)) {
     return (readProgressText(details.text) || readProgressText(details.message)).trim();
   }
   return "";
@@ -82302,7 +83897,7 @@ async function runJsonEventsMode(params) {
         return;
       }
       const parent = agent;
-      const { Agent: AgentClass } = await import("./chunks/src-HPIBCE2I.js");
+      const { Agent: AgentClass } = await import("./chunks/src-E7NCXMU5.js");
       const sideAgent = new AgentClass({
         initialState: {
           systemPrompt: parent.state.systemPrompt,
@@ -82646,7 +84241,7 @@ async function runJsonEventsMode(params) {
     if (runtime.initialModel.unconfigured || controller) {
       return;
     }
-    const { Agent: AgentClass } = await import("./chunks/src-HPIBCE2I.js");
+    const { Agent: AgentClass } = await import("./chunks/src-E7NCXMU5.js");
     const jsonModeExtensions = await loadJsonModeExtensions({ runtime, getAgent: () => agent });
     extensionRunner = jsonModeExtensions.runner;
     const tools = [...runtime.tools, ...jsonModeExtensions.extensionTools];
@@ -83240,7 +84835,7 @@ async function runWithJsonEventsConsoleIsolation(fn) {
 }
 async function createCliTestStreamFnFromEnv() {
   if (!process.env.PIE_TEST_MOCK_STREAM_SEQUENCE) return void 0;
-  return (await import("./chunks/test-stream-Y7WXELAJ.js")).createTestStreamFnFromSequenceEnv();
+  return (await import("./chunks/test-stream-BWBJTFNI.js")).createTestStreamFnFromSequenceEnv();
 }
 function resolveJsonEventsDetailFlag() {
   for (let index = 0; index < process.argv.length; index += 1) {