@cydm/pie 2.6.10 → 2.6.12

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   createCliWebResearchHealthStore,
   formatSize,
   truncateHeadTail
-} from "./chunks/chunk-YUVGEY6X.js";
+} from "./chunks/chunk-AAEBH6KX.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -63,8 +63,8 @@ import {
   setExtensionEnabledInSettings,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-DFWWHVJL.js";
-import "./chunks/chunk-PAC62XU4.js";
+} from "./chunks/chunk-PPEWRUMQ.js";
+import "./chunks/chunk-HHNOENEH.js";
 import {
   Deref,
   EMPTY_ASSISTANT_CONTENT_ERROR,
@@ -63980,7 +63980,24 @@ var ProcessTerminal = class {
       process.stdout.write(sequence);
     }
   }
+  /** Bounce the dock icon once (iTerm2's OSC 1337 extension; verified live
+   *  on iTerm2 — its docs list "Post a notification"-adjacent attention as
+   *  OSC 1337 ; RequestAttention). WezTerm documents OSC 1337 only for file
+   *  upload, not attention; other terminals ignore unknown OSC per the
+   *  xterm spec, so emitting unconditionally is safe and future-proof.
+   *  Value 1 bounces exactly once; 2 would bounce until the user activates
+   *  the app, which is too pushy for a per-turn attention signal. No
+   *  Notification Center permission is involved, so this works even when
+   *  the host app's notifications are muted — the banner channel's
+   *  fallback for "I just need a dot". */
+  requestAttention() {
+    if (!process.stdout.isTTY) return;
+    process.stdout.write(buildDockAttentionSequence());
+  }
 };
+function buildDockAttentionSequence() {
+  return "\x1B]1337;RequestAttention=1\x07";
+}
 var NOTIFICATION_UNSAFE_CHARS = /[\x00-\x1f\x7f-\x9f;]/g;
 function sanitizeNotificationText(text) {
   return text.replace(NOTIFICATION_UNSAFE_CHARS, "");
@@ -70154,6 +70171,68 @@ 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 previous = signalMemories.get(hostKey);
+  const prefixHashChanged = previous !== void 0 && previous.hash !== prefixHash;
+  if (previous?.hash !== prefixHash) {
+    signalMemories.set(hostKey, { hash: prefixHash });
+  }
+  const signals = {
+    prefixHash,
+    prefixHashChanged,
+    cacheHitRate: calculateCumulativeCacheHitRate(messages)
+  };
+  lastSignals.set(hostKey, signals);
+  return signals;
+}
+
 // src/commands/interactive-session-commands.ts
 import * as os6 from "os";
 
@@ -70342,6 +70421,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";
@@ -70812,12 +71272,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));
@@ -72156,6 +72617,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";
@@ -72178,6 +72662,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) {
@@ -72309,6 +72826,7 @@ async function loadSession(host, sessionId) {
       contextPercent,
       contextWindow
     });
+    applyContextSignalsToFooter(host);
     host.ui.requestRender();
     setTimeout(() => host.ui.requestRender(), 100);
   } catch (error) {
@@ -73086,8 +73604,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)" },
@@ -73345,6 +73864,7 @@ function bindInteractiveRuntimeEvents(host) {
           contextPercent,
           contextWindow
         });
+        applyContextSignalsToFooter(host);
         host.safeRequestRender();
         host.sessionManager.save().catch((err) => {
           console.error("[Session] Auto-save failed:", err);
@@ -73793,7 +74313,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);
 }
@@ -73831,7 +74351,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) => ({
@@ -73940,126 +74460,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";
@@ -74636,6 +75036,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) => {
@@ -75060,6 +76398,7 @@ async function handleClearCommand(host) {
     contextPercent: contextWindow > 0 && contextUsage.tokens !== null ? contextUsage.tokens / contextWindow * 100 : 0,
     contextWindow
   });
+  applyContextSignalsToFooter(host);
   host.updateTerminalTitle();
   host.chatContainer.clear();
   host.streamingComponent = void 0;
@@ -75106,6 +76445,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));
@@ -75339,12 +76679,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", "package"], {
-    description: "Append a package summary to ~/.pie/logs/pie-cli.log",
-    handler: () => host.handleDebugPackageCommand()
+  commandTree.register(["debugs", "trace"], {
+    description: "Session trace: timeline, tool stats, runtime events",
+    handler: () => host.handleDebugReportCommand("trace")
+  });
+  commandTree.register(["debugs", "boot"], {
+    description: "Boot composition pipeline: how the runtime was assembled",
+    handler: () => host.handleDebugReportCommand("boot")
   });
   commandTree.register(["settings", "quit"], {
     description: "Exit Pie",
@@ -75355,6 +76699,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) {
@@ -75373,6 +76747,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) {
@@ -75415,8 +76790,10 @@ async function handleCompactCommand(host) {
     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;
@@ -75431,6 +76808,7 @@ async function handleCompactCommand(host) {
       contextPercent,
       contextWindow
     });
+    applyContextSignalsToFooter(host);
     await host.sessionManager.save();
     host.safeRequestRender();
   } catch (error) {
@@ -77807,6 +79185,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;
@@ -77879,27 +79265,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;
@@ -78658,6 +80030,22 @@ function showStatus(host, message) {
   host.lastStatusText = text;
   host.ui.requestRender();
 }
+function clearStatusLine(host) {
+  const spacer = host.lastStatusSpacer;
+  const text = host.lastStatusText;
+  host.lastStatusSpacer = void 0;
+  host.lastStatusText = void 0;
+  let removed = false;
+  if (spacer && host.chatContainer.children.includes(spacer)) {
+    host.chatContainer.removeChild(spacer);
+    removed = true;
+  }
+  if (text && host.chatContainer.children.includes(text)) {
+    host.chatContainer.removeChild(text);
+    removed = true;
+  }
+  if (removed) host.ui.requestRender();
+}
 function showError(host, errorMessage4) {
   host.chatContainer.addChild(new Spacer(1));
   host.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage4}`), 1, 0));
@@ -78874,6 +80262,7 @@ function createInteractiveAgentSessionController(host) {
   }
   let retryElapsedTicker;
   let retryElapsedStartedAt = 0;
+  let autoCompactBeforeStats = null;
   const attention = cliAttention(host);
   const stopRetryElapsedTicker = () => {
     if (retryElapsedTicker !== void 0) {
@@ -78939,6 +80328,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,
@@ -79107,6 +80497,7 @@ function createInteractiveAgentSessionController(host) {
           host.showError(`${prefix}: ${event.errorMessage}`);
           host.footer.setState({ status: "ready" });
           host.setControllerBusy(false);
+          autoCompactBeforeStats = null;
           return;
         }
         host.resetFileObservationState();
@@ -79132,10 +80523,20 @@ function createInteractiveAgentSessionController(host) {
           contextPercent,
           contextWindow
         });
+        applyContextSignalsToFooter(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") {
@@ -79382,6 +80783,7 @@ function sendDesktopNotification(reason, options = {}) {
   lastNotificationAtMs = atMs;
   const { title, body } = attentionMessage(reason);
   terminal.notify(title, body);
+  terminal.requestAttention?.();
   return true;
 }
 
@@ -79567,13 +80969,17 @@ function installInteractiveInteractionHandler(host) {
       host.footer.setState({ lifecycleEvent: "\u25B6 resuming" });
       host.safeRequestRender();
     };
-    const withTimeout2 = async (promise) => {
+    const withTimeout2 = async (createPromise) => {
+      const controller = new AbortController();
       if (!("timeoutMs" in request) || !request.timeoutMs || request.timeoutMs <= 0) {
-        return { value: await promise, timedOut: false };
+        return { value: await createPromise(controller.signal), timedOut: false };
       }
       return await new Promise((resolve7, reject) => {
-        const timer = setTimeout(() => resolve7({ timedOut: true }), request.timeoutMs);
-        promise.then((value) => {
+        const timer = setTimeout(() => {
+          controller.abort();
+          resolve7({ timedOut: true });
+        }, request.timeoutMs);
+        createPromise(controller.signal).then((value) => {
           clearTimeout(timer);
           resolve7({ value, timedOut: false });
         }).catch((error) => {
@@ -79586,7 +80992,7 @@ function installInteractiveInteractionHandler(host) {
       beginWaitingForUser();
       let resolution = "cancelled";
       try {
-        const result = await withTimeout2(createPromise());
+        const result = await withTimeout2(createPromise);
         resolution = interactionAttentionResolution(result);
         return result;
       } finally {
@@ -79609,7 +81015,8 @@ function installInteractiveInteractionHandler(host) {
           optionCount: request.options.length
         });
         const { value: selection, timedOut } = await waitForUser(
-          () => showExtensionSelector2(host, request.prompt, request.options, {
+          (signal) => showExtensionSelector2(host, request.prompt, request.options, {
+            signal,
             shortcuts: { left: request.leftShortcut, right: request.rightShortcut }
           })
         );
@@ -79628,7 +81035,7 @@ function installInteractiveInteractionHandler(host) {
           detail: request.detail
         });
         const { value: confirmed, timedOut } = await waitForUser(
-          () => showExtensionConfirm(host, request.prompt, request.detail ?? "")
+          (signal) => showExtensionConfirm(host, request.prompt, request.detail ?? "", { signal })
         );
         host.logDebug("interaction:confirm:end", {
           id: request.id,
@@ -79644,7 +81051,7 @@ function installInteractiveInteractionHandler(host) {
           placeholder: request.placeholder
         });
         const { value, timedOut } = await waitForUser(
-          () => showExtensionInput(host, request.prompt, request.placeholder)
+          (signal) => showExtensionInput(host, request.prompt, request.placeholder, { signal })
         );
         host.logDebug("interaction:text_input:end", {
           id: request.id,
@@ -79661,7 +81068,7 @@ function installInteractiveInteractionHandler(host) {
           prefillLength: request.prefill?.length ?? 0
         });
         const { value, timedOut } = await waitForUser(
-          () => showExtensionEditor(host, request.prompt, request.prefill)
+          (signal) => showExtensionEditor(host, request.prompt, request.prefill, { signal })
         );
         host.logDebug("interaction:multiline_input:end", {
           id: request.id,
@@ -79682,12 +81089,24 @@ function showExtensionNotification(host, message, type = "info") {
 }
 function showExtensionSelector2(host, title, options, opts) {
   return new Promise((resolve7) => {
-    host.showStatus(`Waiting for selection: ${title}`);
+    const promptLine = title.split("\n")[0].trim() || title.trim();
+    host.showStatus(`Waiting for selection: ${promptLine}`);
     if (opts?.signal?.aborted) {
+      host.clearStatusLine?.();
       resolve7(void 0);
       return;
     }
+    const settle = (option) => {
+      if (option === void 0) {
+        host.clearStatusLine?.();
+      } else {
+        host.showStatus(`${promptLine} \u2192 ${option}`);
+      }
+      host.restoreEditor();
+      resolve7(option);
+    };
     const onAbort = () => {
+      host.clearStatusLine?.();
       host.restoreEditor();
       resolve7(void 0);
     };
@@ -79697,13 +81116,11 @@ function showExtensionSelector2(host, title, options, opts) {
       options,
       (option) => {
         opts?.signal?.removeEventListener("abort", onAbort);
-        host.restoreEditor();
-        resolve7(option);
+        settle(option);
       },
       () => {
         opts?.signal?.removeEventListener("abort", onAbort);
-        host.restoreEditor();
-        resolve7(void 0);
+        settle(void 0);
       },
       opts?.shortcuts
     );
@@ -79723,26 +81140,27 @@ function showExtensionInput(host, title, placeholder, opts) {
   return new Promise((resolve7) => {
     host.showStatus(`Waiting for input: ${title}`);
     if (opts?.signal?.aborted) {
+      host.clearStatusLine?.();
       resolve7(void 0);
       return;
     }
-    const onAbort = () => {
+    const settle = (value) => {
+      host.clearStatusLine?.();
       host.restoreEditor();
-      resolve7(void 0);
+      resolve7(value);
     };
+    const onAbort = () => settle(void 0);
     opts?.signal?.addEventListener("abort", onAbort, { once: true });
     const input = new ExtensionInputComponent(
       title,
       placeholder,
       (value) => {
         opts?.signal?.removeEventListener("abort", onAbort);
-        host.restoreEditor();
-        resolve7(value);
+        settle(value);
       },
       () => {
         opts?.signal?.removeEventListener("abort", onAbort);
-        host.restoreEditor();
-        resolve7(void 0);
+        settle(void 0);
       }
     );
     host.editorContainer.clear();
@@ -79752,9 +81170,20 @@ function showExtensionInput(host, title, placeholder, opts) {
     host.ui.requestRender();
   });
 }
-function showExtensionEditor(host, title, prefill) {
+function showExtensionEditor(host, title, prefill, opts) {
   return new Promise((resolve7) => {
     host.showStatus(`Waiting for input: ${title}`);
+    const settle = (value) => {
+      host.clearStatusLine?.();
+      host.restoreEditor();
+      resolve7(value);
+    };
+    const onAbort = () => settle(void 0);
+    opts?.signal?.addEventListener("abort", onAbort, { once: true });
+    if (opts?.signal?.aborted) {
+      onAbort();
+      return;
+    }
     const container = new Container();
     container.addChild(new Text(theme.bold(theme.fg("accent", title)), 0, 0));
     container.addChild(new Spacer(1));
@@ -79774,13 +81203,13 @@ function showExtensionEditor(host, title, prefill) {
         valueLength: value.length,
         preview: value.slice(0, 120)
       });
-      host.restoreEditor();
-      resolve7(value);
+      opts?.signal?.removeEventListener("abort", onAbort);
+      settle(value);
     };
     editor.onEscape = () => {
       host.logDebug("extension:editor:cancel", { title });
-      host.restoreEditor();
-      resolve7(void 0);
+      opts?.signal?.removeEventListener("abort", onAbort);
+      settle(void 0);
     };
     container.addChild(editor);
     container.addChild(new Spacer(1));
@@ -80545,7 +81974,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-OWQI5M6W.js");
     this.agent = new Agent({
       initialState: {
         systemPrompt: this.buildSystemPrompt(),
@@ -80771,7 +82200,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);
@@ -80809,11 +82237,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);
@@ -80833,9 +82261,6 @@ var InteractiveMode = class {
   setWaitingForUser(waiting) {
     return setWaitingForUser(this, waiting);
   }
-  async handleTreeCommand() {
-    return handleTreeCommand(this);
-  }
   async forkAtEntry(entryId) {
     return forkAtEntry(this, entryId);
   }
@@ -80909,6 +82334,9 @@ var InteractiveMode = class {
   showStatus(message) {
     return showStatus(this.uiHelperHost, message);
   }
+  clearStatusLine() {
+    return clearStatusLine(this.uiHelperHost);
+  }
   showError(errorMessage4) {
     return showError(this.uiHelperHost, errorMessage4);
   }
@@ -81377,7 +82805,7 @@ async function runPrintMode(params) {
 `);
     console.log("Assistant: ");
   }
-  const { Agent: AgentClass } = await import("./chunks/src-HPIBCE2I.js");
+  const { Agent: AgentClass } = await import("./chunks/src-OWQI5M6W.js");
   let agent;
   const printModeExtensions = await loadPrintModeExtensions({
     cwd: runtime.cwd,
@@ -82238,7 +83666,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-OWQI5M6W.js");
       const sideAgent = new AgentClass({
         initialState: {
           systemPrompt: parent.state.systemPrompt,
@@ -82582,7 +84010,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-OWQI5M6W.js");
     const jsonModeExtensions = await loadJsonModeExtensions({ runtime, getAgent: () => agent });
     extensionRunner = jsonModeExtensions.runner;
     const tools = [...runtime.tools, ...jsonModeExtensions.extensionTools];