@mrclrchtr/supi-context 2.6.1 → 2.8.0

package/src/analysis.ts

@@ -5,13 +5,18 @@ import {
   buildSessionContext,
   type ExtensionAPI,
   type ExtensionContext,
-  type estimateTokens,
+  estimateTokens,
   formatSkillsForPrompt,
   getLatestCompactionEntry,
   SettingsManager,
 } from "@earendil-works/pi-coding-agent";
 import { getRegisteredContextProviders } from "@mrclrchtr/supi-core/context";
 
+import {
+  analyzeContextCapacity,
+  type ContextPressureSnapshot,
+  createContextPressureSnapshot,
+} from "./capacity.ts";
 import { deriveOptionsFromSystemPrompt, extractGuidelinesSection } from "./prompt-inference.ts";
 
 type AgentMessage = Parameters<typeof estimateTokens>[0];
@@ -69,17 +74,9 @@ export interface ContextProviderSection {
   data: Record<string, string | number>;
 }
 
-export interface ContextAnalysis {
-  modelName: string;
-  contextWindow: number;
-  totalTokens: number | null;
+export interface ContextAnalysis extends ContextPressureSnapshot {
   scaled: boolean;
-  approximationNote: string | null;
-  full: boolean;
-  categories: CategoryTokens & {
-    autocompactBuffer: number;
-    freeSpace: number;
-  };
+  categories: CategoryTokens;
   systemPromptBreakdown: {
     base: number;
     instructionFiles: ContextFileInfo[];
@@ -98,7 +95,6 @@ export interface ContextAnalysis {
   guidelineSources: GuidelineSourceInfo[];
   toolSnippetDetails: ToolSnippetInfo[];
   toolDefinitions: { count: number; tokens: number; tools: ToolInfo[] };
-  compaction: { summarizedTurns: number } | null;
   providerSections: ContextProviderSection[];
 }
 
@@ -106,39 +102,6 @@ export function estimateTextTokens(text: string): number {
   return Math.ceil(text.length / 4);
 }
 
-function estimateGenericContent(content: unknown): number {
-  if (typeof content === "string") {
-    return estimateTextTokens(content);
-  }
-  if (Array.isArray(content)) {
-    let chars = 0;
-    for (const block of content as Array<{ type?: string; text?: string }>) {
-      if (block.type === "text" && block.text) {
-        chars += block.text.length;
-      }
-    }
-    return Math.ceil(chars / 4);
-  }
-  return 0;
-}
-
-function estimateUserMessage(msg: Extract<AgentMessage, { role: "user" }>): number {
-  const content = msg.content;
-  if (typeof content === "string") {
-    return estimateTextTokens(content);
-  }
-  if (Array.isArray(content)) {
-    let chars = 0;
-    for (const block of content) {
-      if (block.type === "text" && block.text) {
-        chars += block.text.length;
-      }
-    }
-    return Math.ceil(chars / 4);
-  }
-  return 0;
-}
-
 function estimateAssistantMessage(msg: Extract<AgentMessage, { role: "assistant" }>): {
   text: number;
   toolCalls: number;
@@ -169,7 +132,7 @@ function estimateMessageByCategory(msg: AgentMessage): {
 } {
   if (msg.role === "user") {
     return {
-      user: estimateUserMessage(msg),
+      user: estimateTokens(msg),
       assistantText: 0,
       toolCalls: 0,
       toolResult: 0,
@@ -185,7 +148,7 @@ function estimateMessageByCategory(msg: AgentMessage): {
       user: 0,
       assistantText: 0,
       toolCalls: 0,
-      toolResult: estimateGenericContent(msg.content),
+      toolResult: estimateTokens(msg),
       other: 0,
     };
   }
@@ -194,10 +157,14 @@ function estimateMessageByCategory(msg: AgentMessage): {
     assistantText: 0,
     toolCalls: 0,
     toolResult: 0,
-    other: estimateGenericContent((msg as unknown as Record<string, unknown>).content),
+    other: estimateTokens(msg),
   };
 }
 
+function estimateMessageTokens(msg: AgentMessage): number {
+  return estimateTokens(msg);
+}
+
 function computeMessageCategories(messages: AgentMessage[]): CategoryTokens {
   const categories: CategoryTokens = {
     systemPrompt: 0,
@@ -220,6 +187,26 @@ function computeMessageCategories(messages: AgentMessage[]): CategoryTokens {
   return categories;
 }
 
+interface ScalingResult {
+  categories: CategoryTokens;
+  scaled: boolean;
+  approximationNote: string | null;
+  usedTokens: number;
+}
+
+type CurrentContextUsage = ReturnType<ExtensionContext["getContextUsage"]>;
+
+function hasMeasuredTokens(tokens: number | null | undefined): tokens is number {
+  return typeof tokens === "number" && tokens > 0;
+}
+
+function getApproximationNote(contextUsage: CurrentContextUsage): string | null {
+  if (contextUsage === undefined) return "Approximate (no usage data available)";
+  return hasMeasuredTokens(contextUsage.tokens)
+    ? null
+    : "Token count pending — send a message to refresh";
+}
+
 function applyScaling(
   categories: CategoryTokens,
   actualTokens: number | null,
@@ -227,20 +214,13 @@ function applyScaling(
   contextUsage:
     | { tokens: number | null; contextWindow: number; percent: number | null }
     | undefined,
-): {
-  categories: CategoryTokens;
-  scaled: boolean;
-  approximationNote: string | null;
-  totalTokens: number;
-} {
+): ScalingResult {
   let scaled = false;
-  let approximationNote: string | null = null;
-  const hasActualTotal = actualTokens !== null && actualTokens > 0;
-  const totalTokens = hasActualTotal ? actualTokens : rawTotal;
+  const hasActualTotal = hasMeasuredTokens(actualTokens);
+  const usedTokens = hasActualTotal ? actualTokens : rawTotal;
+  const approximationNote = getApproximationNote(contextUsage);
 
-  if (contextUsage === undefined) {
-    approximationNote = "Approximate (no usage data available)";
-  } else if (hasActualTotal && rawTotal > 0) {
+  if (hasActualTotal && rawTotal > 0) {
     const scale = actualTokens / rawTotal;
     categories.systemPrompt = Math.round(categories.systemPrompt * scale);
     categories.userMessages = Math.round(categories.userMessages * scale);
@@ -249,11 +229,9 @@ function applyScaling(
     categories.toolResults = Math.round(categories.toolResults * scale);
     categories.other = Math.round(categories.other * scale);
     scaled = true;
-  } else if (actualTokens === null || actualTokens === 0) {
-    approximationNote = "Token count pending — send a message to refresh";
   }
 
-  return { categories, scaled, approximationNote, totalTokens };
+  return { categories, scaled, approximationNote, usedTokens };
 }
 
 /**
@@ -508,18 +486,10 @@ function computeToolDefinitions(pi: ExtensionAPI): {
   };
 }
 
-function detectCompaction(branch: ReturnType<ExtensionContext["sessionManager"]["getBranch"]>): {
-  summarizedTurns: number;
-} | null {
-  const compactionEntry = getLatestCompactionEntry(branch);
-  if (!compactionEntry) return null;
-
-  const index = branch.findIndex((e) => e.id === compactionEntry.id);
-  const messagesBefore = branch
-    .slice(0, Math.max(0, index))
-    .filter((e) => e.type === "message").length;
-  const summarizedTurns = Math.floor(messagesBefore / 2);
-  return { summarizedTurns };
+function hasCompactionOnActiveBranch(
+  branch: ReturnType<ExtensionContext["sessionManager"]["getBranch"]>,
+): boolean {
+  return getLatestCompactionEntry(branch) !== null;
 }
 
 export function extractInjectedContextFiles(messages: AgentMessage[]): InjectedFileInfo[] {
@@ -556,22 +526,93 @@ export function extractInjectedContextFiles(messages: AgentMessage[]): InjectedF
   return Array.from(seen.values()).sort((a, b) => a.turn - b.turn || a.file.localeCompare(b.file));
 }
 
-export function analyzeContext(
+interface ContextFallback {
+  messages: AgentMessage[];
+  systemPromptText: string;
+}
+
+interface CapacityObservation {
+  branch: ReturnType<ExtensionContext["sessionManager"]["getBranch"]>;
+  contextUsage: CurrentContextUsage;
+  snapshot: ContextPressureSnapshot;
+  fallback?: ContextFallback;
+}
+
+interface ContextObservation extends ContextFallback {
+  scaling: ScalingResult;
+  snapshot: ContextPressureSnapshot;
+}
+
+function estimateContextTokens(fallback: ContextFallback): number {
+  return (
+    estimateTextTokens(fallback.systemPromptText) +
+    fallback.messages.reduce((total, message) => total + estimateMessageTokens(message), 0)
+  );
+}
+
+function collectContextFallback(
   ctx: ExtensionContext,
-  pi: ExtensionAPI,
-  cachedOptions: BuildSystemPromptOptions | undefined,
-  full = false,
-): ContextAnalysis {
+  branch: ReturnType<ExtensionContext["sessionManager"]["getBranch"]>,
+): ContextFallback {
+  return {
+    messages: buildSessionContext(branch).messages,
+    systemPromptText: ctx.getSystemPrompt(),
+  };
+}
+
+/**
+ * Observe the small shared capacity seam. It only walks messages when Pi has
+ * no measured usage total and an aggregate estimate is genuinely necessary.
+ */
+function observeCapacity(ctx: ExtensionContext): CapacityObservation {
   const branch = ctx.sessionManager.getBranch();
-  const apiView = buildSessionContext(branch);
   const contextUsage = ctx.getContextUsage();
-  const contextWindow = contextUsage?.contextWindow ?? 0;
-  const actualTokens = contextUsage?.tokens ?? null;
+  let fallback: ContextFallback | undefined;
+  let usedTokens: number;
+  if (hasMeasuredTokens(contextUsage?.tokens)) {
+    usedTokens = contextUsage.tokens;
+  } else {
+    fallback = collectContextFallback(ctx, branch);
+    usedTokens = estimateContextTokens(fallback);
+  }
+  const settings = SettingsManager.create(ctx.cwd, undefined, {
+    projectTrusted: ctx.isProjectTrusted(),
+  });
+  const capacity = analyzeContextCapacity({
+    contextWindow: contextUsage?.contextWindow ?? null,
+    usedTokens,
+    compactionEnabled: settings.getCompactionEnabled(),
+    configuredReserveTokens: settings.getCompactionReserveTokens(),
+    compacted: hasCompactionOnActiveBranch(branch),
+    approximationNote: getApproximationNote(contextUsage),
+  });
 
-  const systemPromptText = ctx.getSystemPrompt();
-  const categories = computeMessageCategories(apiView.messages);
-  categories.systemPrompt = estimateTextTokens(systemPromptText);
+  return {
+    branch,
+    contextUsage,
+    fallback,
+    snapshot: createContextPressureSnapshot(
+      ctx.model?.name ?? ctx.model?.id ?? "No model selected",
+      capacity,
+    ),
+  };
+}
+
+/** Return a constant-shape Context Pressure Snapshot without diagnostic attribution. */
+export function analyzeContextPressure(ctx: ExtensionContext): ContextPressureSnapshot {
+  return observeCapacity(ctx).snapshot;
+}
 
+/** Compose a full Context Usage Report from shared capacity and diagnostic attribution. */
+export function analyzeContext(
+  ctx: ExtensionContext,
+  pi: ExtensionAPI,
+  cachedOptions: BuildSystemPromptOptions | undefined,
+): ContextAnalysis {
+  const capacity = observeCapacity(ctx);
+  const fallback = capacity.fallback ?? collectContextFallback(ctx, capacity.branch);
+  const categories = computeMessageCategories(fallback.messages);
+  categories.systemPrompt = estimateTextTokens(fallback.systemPromptText);
   const rawTotal =
     categories.systemPrompt +
     categories.userMessages +
@@ -579,45 +620,33 @@ export function analyzeContext(
     categories.toolCalls +
     categories.toolResults +
     categories.other;
-
-  const scaling = applyScaling(categories, actualTokens, rawTotal, contextUsage);
-
-  const autocompactBuffer =
-    contextWindow > 0 ? SettingsManager.create(ctx.cwd).getCompactionReserveTokens() : 0;
-  const used =
-    scaling.categories.systemPrompt +
-    scaling.categories.userMessages +
-    scaling.categories.assistantMessages +
-    scaling.categories.toolCalls +
-    scaling.categories.toolResults +
-    scaling.categories.other;
-  const freeSpace = Math.max(0, contextWindow - used - autocompactBuffer);
-
+  const observation: ContextObservation = {
+    ...fallback,
+    scaling: applyScaling(
+      categories,
+      capacity.contextUsage?.tokens ?? null,
+      rawTotal,
+      capacity.contextUsage,
+    ),
+    snapshot: capacity.snapshot,
+  };
   const promptOptions = deriveOptionsFromSystemPrompt(ctx, cachedOptions);
   const breakdown = computeSystemPromptBreakdown(
     promptOptions,
-    systemPromptText,
-    scaling.categories.systemPrompt,
+    observation.systemPromptText,
+    observation.scaling.categories.systemPrompt,
     ctx.cwd,
   );
-  const injectedFiles = extractInjectedContextFiles(apiView.messages);
+  const injectedFiles = extractInjectedContextFiles(observation.messages);
   const toolDefinitions = computeToolDefinitions(pi);
-  const compaction = detectCompaction(branch);
-
-  const guidelineBullets = extractGuidelineBullets(extractGuidelinesSection(systemPromptText));
+  const guidelineBullets = extractGuidelineBullets(
+    extractGuidelinesSection(observation.systemPromptText),
+  );
 
   return {
-    modelName: ctx.model?.name ?? ctx.model?.id ?? "No model selected",
-    contextWindow,
-    totalTokens: scaling.totalTokens,
-    scaled: scaling.scaled,
-    approximationNote: scaling.approximationNote,
-    full,
-    categories: {
-      ...scaling.categories,
-      autocompactBuffer,
-      freeSpace,
-    },
+    ...observation.snapshot,
+    scaled: observation.scaling.scaled,
+    categories: observation.scaling.categories,
     systemPromptBreakdown: breakdown,
     injectedFiles,
     skills: breakdown.skills,
@@ -626,7 +655,6 @@ export function analyzeContext(
     guidelineSources: breakdown.guidelineSources,
     toolSnippetDetails: breakdown.toolSnippetDetails,
     toolDefinitions,
-    compaction,
     providerSections: collectProviderData(),
   };
 }

package/src/capacity.ts

@@ -0,0 +1,81 @@
+/**
+ * A small, point-in-time capacity reading without diagnostic attribution.
+ */
+export interface ContextCapacity {
+  contextWindow: number | null;
+  usedTokens: number;
+  usagePercent: number | null;
+  compactionEnabled: boolean;
+  reserveTokens: number;
+  headroomTokens: number | null;
+  pressurePercent: number | null;
+  compacted: boolean;
+  approximationNote: string | null;
+}
+
+/** Agent-facing, constant-shape reading of current context pressure. */
+export interface ContextPressureSnapshot extends ContextCapacity {
+  modelName: string;
+}
+
+/** Inputs that the shared capacity analysis derives from session state. */
+export interface ContextCapacityInput {
+  contextWindow: number | null;
+  usedTokens: number;
+  compactionEnabled: boolean;
+  configuredReserveTokens: number;
+  compacted: boolean;
+  approximationNote: string | null;
+}
+
+function roundPercentage(value: number): number {
+  return Math.round(value * 10) / 10;
+}
+
+/**
+ * Derive reserve-adjusted capacity without inspecting diagnostic inventories.
+ *
+ * The configured reserve affects capacity only while auto-compaction is enabled.
+ * This lets report and snapshot callers share exactly the same Active Context
+ * Limit, Headroom, and Pressure Percentage semantics.
+ */
+export function analyzeContextCapacity(input: ContextCapacityInput): ContextCapacity {
+  const contextWindow = input.contextWindow && input.contextWindow > 0 ? input.contextWindow : null;
+  const reserveTokens = input.compactionEnabled ? Math.max(0, input.configuredReserveTokens) : 0;
+  const activeLimit = contextWindow === null ? null : contextWindow - reserveTokens;
+  const hasUsableActiveLimit = activeLimit !== null && activeLimit > 0;
+
+  return {
+    contextWindow,
+    usedTokens: input.usedTokens,
+    usagePercent:
+      contextWindow === null ? null : roundPercentage((input.usedTokens / contextWindow) * 100),
+    compactionEnabled: input.compactionEnabled,
+    reserveTokens,
+    headroomTokens: activeLimit === null ? null : Math.max(0, activeLimit - input.usedTokens),
+    pressurePercent: hasUsableActiveLimit
+      ? roundPercentage((input.usedTokens / activeLimit) * 100)
+      : null,
+    compacted: input.compacted,
+    approximationNote: input.approximationNote,
+  };
+}
+
+/** Create the exact agent-facing Context Pressure Snapshot shape. */
+export function createContextPressureSnapshot(
+  modelName: string,
+  capacity: ContextCapacity,
+): ContextPressureSnapshot {
+  return {
+    modelName,
+    contextWindow: capacity.contextWindow,
+    usedTokens: capacity.usedTokens,
+    usagePercent: capacity.usagePercent,
+    compactionEnabled: capacity.compactionEnabled,
+    reserveTokens: capacity.reserveTokens,
+    headroomTokens: capacity.headroomTokens,
+    pressurePercent: capacity.pressurePercent,
+    compacted: capacity.compacted,
+    approximationNote: capacity.approximationNote,
+  };
+}

package/src/context.ts

@@ -1,49 +1,53 @@
+import { StringEnum } from "@earendil-works/pi-ai";
 import type { BuildSystemPromptOptions, ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { analyzeContext } from "./analysis.ts";
+import { analyzeContext, analyzeContextPressure } from "./analysis.ts";
 import { loadContextConfig } from "./config.ts";
-import { registerContextRenderer } from "./renderer.ts";
+import { type ContextReportEntryData, registerContextEntryRenderer } from "./entry-renderer.ts";
 import { registerContextSettings } from "./settings-registration.ts";
 import { promptGuidelines, promptSnippet, toolDescription } from "./tool/guidance.ts";
+import { serializeFullContextAnalysis } from "./tool/output.ts";
 import {
   type ContextToolDetails,
   renderContextToolCall,
   renderContextToolResult,
 } from "./tool/render.ts";
-import { formatTokens } from "./utils.ts";
+
+const contextToolParameters = Type.Object({
+  mode: Type.Optional(
+    StringEnum(["concise", "full"] as const, {
+      description: "Omit for concise capacity data, or use full for the diagnostic report.",
+    }),
+  ),
+});
 
 export default function contextExtension(pi: ExtensionAPI) {
   let cachedOptions: BuildSystemPromptOptions | undefined;
+  let commandRegistered = false;
 
-  // Register settings synchronously during factory
+  // Register settings synchronously during factory.
   registerContextSettings(pi);
+  registerContextEntryRenderer(pi);
 
   pi.on("before_agent_start", async (event) => {
     cachedOptions = event.systemPromptOptions;
   });
 
-  pi.on("session_start", async () => {
+  pi.on("session_start", async (_event, ctx) => {
     cachedOptions = undefined;
-  });
+    if (ctx.mode !== "tui" || commandRegistered) return;
 
-  pi.registerCommand("supi-context", {
-    description: "Show detailed context usage. Pass 'full' to show all guideline bullets.",
-    handler: async (args, ctx) => {
-      const full = args.trim() === "full";
-      const analysis = analyzeContext(ctx, pi, cachedOptions, full);
-      const shortContent = `${formatTokens(analysis.totalTokens ?? 0)} / ${formatTokens(analysis.contextWindow)} tokens`;
-
-      pi.sendMessage({
-        customType: "supi-context",
-        content: shortContent,
-        display: true,
-        details: { analysis },
-      });
-    },
+    commandRegistered = true;
+    pi.registerCommand("supi-context", {
+      description: "Show detailed context usage. Pass 'full' to show all guideline bullets.",
+      handler: async (args, commandCtx) => {
+        const mode = args.trim() === "full" ? "full" : "preview";
+        const analysis = analyzeContext(commandCtx, pi, cachedOptions);
+        pi.appendEntry<ContextReportEntryData>("supi-context", { mode, analysis });
+      },
+    });
   });
 
-  registerContextRenderer(pi);
-
   // ── supi_context agent tool (gated on config) ────────────
 
   if (loadContextConfig(process.cwd()).agentToolEnabled) {
@@ -52,16 +56,24 @@ export default function contextExtension(pi: ExtensionAPI) {
       label: "Context Usage",
       description: toolDescription,
       promptSnippet,
-      parameters: Type.Object({}),
+      parameters: contextToolParameters,
       promptGuidelines,
       renderCall: renderContextToolCall,
       renderResult: renderContextToolResult,
       // biome-ignore lint/complexity/useMaxParams: pi tool execute signature
-      async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
-        const analysis = analyzeContext(ctx, pi, cachedOptions, true);
+      async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+        if (params.mode !== "full") {
+          const snapshot = analyzeContextPressure(ctx);
+          return {
+            content: [{ type: "text", text: JSON.stringify(snapshot) }],
+            details: { mode: "concise", snapshot } satisfies ContextToolDetails,
+          };
+        }
+
+        const analysis = analyzeContext(ctx, pi, cachedOptions);
         return {
-          content: [{ type: "text", text: JSON.stringify(analysis, null, 2) }],
-          details: { analysis } satisfies ContextToolDetails,
+          content: [{ type: "text", text: await serializeFullContextAnalysis(analysis) }],
+          details: { mode: "full", analysis } satisfies ContextToolDetails,
         };
       },
     });

package/src/entry-renderer.ts

@@ -0,0 +1,23 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import type { ContextAnalysis } from "./analysis.ts";
+import type { ContextReportMode } from "./format.ts";
+import { ContextReportComponent } from "./report-component.ts";
+
+/** Durable, TUI-only payload appended by the `/supi-context` command. */
+export interface ContextReportEntryData {
+  analysis: ContextAnalysis;
+  mode: ContextReportMode;
+}
+
+/** Register the TUI renderer for new Context Usage Report custom entries. */
+export function registerContextEntryRenderer(pi: ExtensionAPI): void {
+  pi.registerEntryRenderer<ContextReportEntryData>("supi-context", (entry, _options, theme) => {
+    const data = entry.data;
+    if (!data) {
+      return new Text(theme.fg("dim", "No context analysis data"), 1, 0);
+    }
+
+    return new ContextReportComponent(data.analysis, theme, data.mode);
+  });
+}

package/src/format-helpers.ts

@@ -74,11 +74,9 @@ export function allocateBlocks(values: number[], totalBlocks: number): number[]
   return counts;
 }
 
-export function healthColor(analysis: ContextAnalysis): ReportColor {
-  if (analysis.contextWindow <= 0) return "dim";
-  const reserved = analysis.totalTokens ?? 0;
-  const pressure =
-    ((reserved + analysis.categories.autocompactBuffer) / analysis.contextWindow) * 100;
+export function healthColor(analysis: Pick<ContextAnalysis, "pressurePercent">): ReportColor {
+  const pressure = analysis.pressurePercent;
+  if (pressure === null) return "dim";
   if (pressure >= 90) return "error";
   if (pressure >= 70) return "warning";
   return "success";

package/src/format-sections.ts

@@ -112,7 +112,7 @@ export function renderInjectedFilesSection(
       lines: file.lines,
       extra: `turn ${file.turn}`,
     })),
-    total: analysis.totalTokens ?? 0,
+    total: analysis.usedTokens,
     theme,
     width,
   });
@@ -196,6 +196,7 @@ export function renderGuidelinesSection(
   analysis: ContextAnalysis,
   theme: Theme,
   width: number,
+  full: boolean,
 ): string[] {
   const sourceSummary = renderSourceSummaryBar(analysis.guidelineSources);
 
@@ -217,7 +218,7 @@ export function renderGuidelinesSection(
     return lines;
   }
 
-  lines.push(...renderBulletLines(bullets, analysis.full, theme, width));
+  lines.push(...renderBulletLines(bullets, full, theme, width));
   return lines;
 }
 
@@ -225,6 +226,7 @@ export function renderToolDefinitionsSection(
   analysis: ContextAnalysis,
   theme: Theme,
   width: number,
+  full: boolean,
 ): string[] {
   const tools = [...analysis.toolDefinitions.tools].sort((a, b) => b.tokens - a.tokens);
   if (tools.length === 0) return [];
@@ -241,7 +243,7 @@ export function renderToolDefinitionsSection(
     ),
   );
 
-  const previewLimit = analysis.full ? tools.length : Math.min(5, tools.length);
+  const previewLimit = full ? tools.length : Math.min(5, tools.length);
   const nameWidth = Math.max(12, Math.min(18, Math.max(...tools.map((tool) => tool.name.length))));
   const defTokenWidth = 8;
   const snippetTokenWidth = hasSnippetDetails ? 10 : 0;
@@ -253,7 +255,7 @@ export function renderToolDefinitionsSection(
     const tool = tools[i];
     const name = padRight(tool.name, nameWidth);
     const previewDescription =
-      analysis.full || tool.description.length <= 50
+      full || tool.description.length <= 50
         ? tool.description
         : `${tool.description.slice(0, 50)}…`;
     const description = truncateToWidth(previewDescription, descWidth);
@@ -270,7 +272,7 @@ export function renderToolDefinitionsSection(
     );
   }
 
-  if (!analysis.full && tools.length > previewLimit) {
+  if (!full && tools.length > previewLimit) {
     lines.push(
       formatOverflowHint(tools.length - previewLimit, theme, width, {
         hint: "run /supi-context full",
@@ -293,14 +295,8 @@ export function renderCompactionNote(
   theme: Theme,
   width: number,
 ): string[] {
-  if (!analysis.compaction) return [];
-  return [
-    formatDimLine(
-      `↳ ${pluralize(analysis.compaction.summarizedTurns, "older turn", "older turns")} summarized (compaction)`,
-      theme,
-      width,
-    ),
-  ];
+  if (!analysis.compacted) return [];
+  return [formatDimLine("↳ Compaction present on the active branch", theme, width)];
 }
 
 export function renderProviderSections(