@danypops/papyrus 0.13.1 → 0.13.3

package/extension/src/context-budget.ts

@@ -1,12 +1,11 @@
 import { homedir } from "node:os";
 import { readFileSync } from "node:fs";
-import { CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN } from "../../src/constants.ts";
+import { CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN, CONTEXT_TREE_MAX_DEPTH, CONTEXT_TREE_MAX_NODES } from "../../src/constants.ts";
 import type { Artifact } from "../../src/domain/artifact.ts";
+import type { TaskGraph } from "../../src/task-service.ts";
 import { discoverSkillDirectories, scanSkillCatalogFootprint, type SkillCatalogFootprint } from "./skill-catalog-footprint.ts";
 import { ruleInjectionPreview } from "./rules.ts";
 
-const REPORT_MAX_ROWS = 5;
-
 export interface RuleBudgetEntry {
 	id: string;
 	title: string;
@@ -68,6 +67,13 @@ export const DEFAULT_RESERVE_TOKENS = 16_384;
 export interface ContextSegmentItem {
 	label: string;
 	estimatedTokens: number;
+	/**
+	 * Recursive children, when this item has real hierarchy of its own -- conversation history
+	 * (Pi's session entries form a genuine tree via id/parentId, docs/session-format.md) and
+	 * Papyrus Tasks (containment via parentIds/childIds) both do; Rules and Skills don't, so
+	 * their items simply omit this field, degenerating to a flat one-level tree.
+	 */
+	children?: ContextSegmentItem[];
 }
 
 export interface ContextSegment {
@@ -76,18 +82,32 @@ export interface ContextSegment {
 	estimatedTokens: number;
 	/** Drill-down items, when this segment can be broken down further. Absent for "other" -- an opaque remainder, not a real category. */
 	items?: ContextSegmentItem[];
+	/**
+	 * True when this segment's size is genuinely unmeasured (not yet observed), as opposed to
+	 * measured-and-actually-zero. A display layer that hides zero-token rows to cut noise must
+	 * NOT hide an unknown segment just because its placeholder value happens to be zero --
+	 * that would silently misrepresent "we don't know" as "there is nothing here", the same
+	 * category of honesty problem overshootTokens exists to prevent for the unaccounted bucket.
+	 */
+	unknown?: boolean;
 }
 
 /**
- * Session branch entries as SessionManager exposes them (docs/session-format.md): a subset
- * covering only the fields this estimate reads, so this stays testable with plain object
- * literals instead of importing pi's own session types.
+ * Session entries and tree nodes as SessionManager exposes them (docs/session-format.md,
+ * SessionTreeNode from @earendil-works/pi-coding-agent): a subset covering only the fields
+ * this estimate reads, so this stays testable with plain object literals instead of
+ * importing pi's own session types.
  */
-export interface SessionBranchEntryLike {
+export interface SessionEntryLike {
+	id: string;
 	type: string;
 	message?: unknown;
 	summary?: string;
 }
+export interface SessionTreeNodeLike {
+	entry: SessionEntryLike;
+	children: SessionTreeNodeLike[];
+}
 
 function messageContentCharacters(message: unknown): number {
 	if (typeof message !== "object" || message === null) return 0;
@@ -114,22 +134,84 @@ function messageContentCharacters(message: unknown): number {
 	return characters;
 }
 
+function messageSnippet(message: unknown, maxLength = 48): string {
+	if (typeof message !== "object" || message === null) return "";
+	const record = message as Record<string, unknown>;
+	if (record["role"] === "bashExecution") return String(record["command"] ?? "");
+	const content = record["content"];
+	const text = typeof content === "string"
+		? content
+		: Array.isArray(content)
+			? content.map((block) => (typeof block === "object" && block !== null && (block as Record<string, unknown>)["type"] === "text" ? String((block as Record<string, unknown>)["text"] ?? "") : "")).join(" ")
+			: "";
+	const collapsed = text.replace(/\s+/g, " ").trim();
+	return collapsed.length > maxLength ? `${collapsed.slice(0, maxLength - 1)}…` : collapsed;
+}
+
+function entryLabel(entry: SessionEntryLike): string {
+	if (entry.type === "compaction") return "compaction summary";
+	if (entry.type === "branch_summary") return "branch summary";
+	const role = typeof entry.message === "object" && entry.message !== null ? (entry.message as Record<string, unknown>)["role"] : undefined;
+	const prefix = typeof role === "string" ? role : entry.type;
+	const snippet = messageSnippet(entry.message);
+	return snippet ? `${prefix}: ${snippet}` : prefix;
+}
+
+export interface MessageHistoryTree {
+	/** One item per real tree root (ordinarily one, the session's first entry). */
+	items: ContextSegmentItem[];
+	/** Sum of tokens for entries on the CURRENT active path only -- what actually feeds the LLM's context right now, unlike content sitting in an abandoned /tree branch. */
+	activeTokens: number;
+	/** True if the walk hit CONTEXT_TREE_MAX_DEPTH or CONTEXT_TREE_MAX_NODES, or found a cycle -- the tree shown is a bounded prefix, not necessarily the complete session. */
+	truncated: boolean;
+}
+
 /**
- * Estimates the conversation transcript's own context contribution by walking the actual
- * session branch (docs/session-format.md's buildSessionContext(): message/compaction/
- * branch_summary entries participate in context, plain "custom" entries do not). This is
- * character-count estimation like every other Papyrus segment here, not exact -- but it is
- * real session content, not a guess, and in a long-running session this is very likely the
- * dominant contributor to "the base prompt, message history, and tool definitions" bucket
- * that would otherwise stay fully opaque.
+ * Walks Pi's own real session tree (ctx.sessionManager.getTree(), docs/session-format.md --
+ * entries form a genuine tree via id/parentId, not just the linear current-branch path) to
+ * estimate the conversation's context contribution AND surface branches explored via /tree
+ * that are no longer on the active path -- content that cost real tokens to generate but is
+ * NOT currently part of the context window. Bounded and cycle-safe (CONTEXT_TREE_MAX_DEPTH /
+ * CONTEXT_TREE_MAX_NODES): a session file is external, mutable state, and this deliberately
+ * hardens past a confirmed real gap in Pi's own getBranch() (no cycle guard at all) rather
+ * than assuming the tree can never be malformed.
  */
-export function estimateMessageHistoryTokens(branch: ReadonlyArray<SessionBranchEntryLike>): number {
-	let characters = 0;
-	for (const entry of branch) {
-		if (entry.type === "message") characters += messageContentCharacters(entry.message);
-		else if (entry.type === "compaction" || entry.type === "branch_summary") characters += (entry.summary ?? "").length;
+export function buildMessageHistoryTree(roots: ReadonlyArray<SessionTreeNodeLike>, activeEntryIds: ReadonlySet<string>): MessageHistoryTree {
+	const visited = new Set<string>();
+	let truncated = false;
+	let activeTokens = 0;
+	let nodesVisited = 0;
+
+	function visit(node: SessionTreeNodeLike, depth: number): ContextSegmentItem | null {
+		if (nodesVisited >= CONTEXT_TREE_MAX_NODES || depth > CONTEXT_TREE_MAX_DEPTH) { truncated = true; return null; }
+		if (visited.has(node.entry.id)) { truncated = true; return null; } // cycle guard
+		visited.add(node.entry.id);
+		nodesVisited++;
+
+		const entry = node.entry;
+		const characters = entry.type === "message"
+			? messageContentCharacters(entry.message)
+			: entry.type === "compaction" || entry.type === "branch_summary"
+				? (entry.summary ?? "").length
+				: 0;
+		const tokens = Math.ceil(characters / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN);
+		const isActive = activeEntryIds.has(entry.id);
+		if (isActive) activeTokens += tokens;
+
+		const children = node.children
+			.map((child) => visit(child, depth + 1))
+			.filter((item): item is ContextSegmentItem => item !== null);
+		if (tokens === 0 && children.length === 0) return null; // no content, no descendants with content -- nothing to show
+
+		return {
+			label: isActive ? entryLabel(entry) : `${entryLabel(entry)} (inactive branch)`,
+			estimatedTokens: tokens,
+			...(children.length > 0 ? { children } : {}),
+		};
 	}
-	return Math.ceil(characters / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN);
+
+	const items = roots.map((root) => visit(root, 0)).filter((item): item is ContextSegmentItem => item !== null);
+	return { items, activeTokens, truncated };
 }
 
 export interface ContextBreakdown {
@@ -139,7 +221,16 @@ export interface ContextBreakdown {
 	contextWindow: number | null;
 	/** contextWindow - reserveTokens, mirroring Pi's own compaction-trigger formula. Null when contextWindow is unknown. */
 	effectiveBudget: number | null;
-	/** rules, tasks, skills, then "other" absorbing whatever real usage the first three don't account for. */
+	/**
+	 * How much the known/estimated segments (rules+tasks+skills+basePrompt+messageHistory)
+	 * exceed the real total, when they do. Zero means no overshoot. This must stay visible
+	 * rather than only being absorbed into "unaccounted" clamping to zero -- a clamped-to-zero
+	 * unaccounted segment does NOT mean tool definitions and framework overhead are actually
+	 * free; it means this estimate's other segments already consumed the entire real budget on
+	 * paper. Hiding that distinction would make a genuinely nonzero cost look like zero.
+	 */
+	overshootTokens: number;
+	/** rules, tasks, skills, basePrompt, messageHistory, then "other" absorbing whatever real usage the rest don't account for. */
 	segments: ContextSegment[];
 }
 
@@ -148,12 +239,58 @@ export interface BuildContextBreakdownInput {
 	contextWindow: number | null;
 	reserveTokens?: number;
 	ruleBudget: ContextBudget["rules"];
-	taskEstimatedTokens: number;
+	/** Open tasks contributing to the injected task-context summary, nested by containment (parentIds/childIds) so the Tasks segment reflects the real Task tree, not a flat list. */
+	taskItems: ContextSegmentItem[];
 	skills: SkillCatalogFootprint;
 	/** Pi's own base system prompt size, cached from the last observed before_agent_start turn. Null before any turn has run yet. */
 	basePromptEstimatedTokens: number | null;
-	/** From estimateMessageHistoryTokens() against the live session branch. */
-	messageHistoryEstimatedTokens: number;
+	/** From buildMessageHistoryTree() against the live session's real tree (ctx.sessionManager.getTree()). */
+	messageHistoryItems: ContextSegmentItem[];
+	/** buildMessageHistoryTree()'s activeTokens -- only entries on the current active path count toward the segment total; an abandoned /tree branch still appears in messageHistoryItems but contributes zero here. */
+	messageHistoryActiveTokens: number;
+}
+
+/** Sums a possibly-nested item tree's tokens recursively -- every node's own contribution, not just top-level items. */
+function sumItemTree(items: ContextSegmentItem[]): number {
+	return items.reduce((sum, item) => sum + item.estimatedTokens + sumItemTree(item.children ?? []), 0);
+}
+
+/**
+ * Builds the Tasks segment's items from Papyrus's own real containment tree (parentIds/
+ * childIds), not a flat list -- Tasks are a genuine DAG (a task may have more than one
+ * parent, a deliberate design decision, not a defect: see /tasks contain). Open tasks only
+ * (done/canceled tasks are filtered first, matching taskContext()'s own "only open work
+ * matters" rule); a task whose real parent is done/canceled or otherwise filtered out
+ * becomes a root in THIS projection rather than being silently dropped. A task reachable
+ * from more than one open parent is shown once, under whichever parent this bounded walk
+ * reaches first -- the same spanning-tree compromise already applied to the task widget
+ * (extension/src/task-widget.ts) for the identical multi-parent-DAG-in-a-bounded-view
+ * problem, not a new inconsistency.
+ */
+export function buildTaskItemTree(graph: TaskGraph): ContextSegmentItem[] {
+	const byId = new Map(graph.nodes.map((node) => [node.task.id, node]));
+	const openIds = new Set(graph.nodes.filter((node) => node.task.status !== "done" && node.task.status !== "canceled").map((node) => node.task.id));
+	const visited = new Set<string>();
+
+	function visit(id: string, depth: number): ContextSegmentItem | null {
+		if (depth > CONTEXT_TREE_MAX_DEPTH || visited.size >= CONTEXT_TREE_MAX_NODES || visited.has(id) || !openIds.has(id)) return null;
+		visited.add(id);
+		const node = byId.get(id);
+		if (!node) return null;
+		const characters = node.task.title.length + node.task.body.length;
+		const tokens = Math.ceil(characters / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN);
+		const children = node.childIds
+			.filter((childId) => openIds.has(childId))
+			.map((childId) => visit(childId, depth + 1))
+			.filter((item): item is ContextSegmentItem => item !== null);
+		return { label: node.task.title, estimatedTokens: tokens, ...(children.length > 0 ? { children } : {}) };
+	}
+
+	const rootIds = [...openIds].filter((id) => {
+		const node = byId.get(id)!;
+		return node.parentIds.length === 0 || !node.parentIds.some((parentId) => openIds.has(parentId));
+	});
+	return rootIds.map((id) => visit(id, 0)).filter((item): item is ContextSegmentItem => item !== null);
 }
 
 /**
@@ -161,11 +298,13 @@ export interface BuildContextBreakdownInput {
  * catalog, cached base-prompt size, and the live session's own message history) against the
  * real total Pi reports, deriving "unaccounted" (tool definitions and framework overhead --
  * genuinely invisible to any extension) as the remainder. The remainder is clamped to zero
- * rather than shown negative: char/4 token estimation is approximate, and a small overshoot
- * in the known segments must not display as a nonsensical negative bucket. When the real
- * total is unavailable, unaccounted is reported as zero and totalTokens surfaces as null so
- * callers can label the whole breakdown as estimate-only rather than silently treating a
- * partial sum as ground truth.
+ * rather than shown negative -- char/4 token estimation is approximate, and a small overshoot
+ * in the known segments must not display as a nonsensical negative bucket -- but the clamp
+ * amount itself is preserved as overshootTokens rather than silently discarded, so a
+ * consumer can tell "genuinely zero" apart from "our other estimates already exceeded the
+ * real total". When the real total is unavailable, unaccounted is reported as zero and
+ * totalTokens surfaces as null so callers can label the whole breakdown as estimate-only
+ * rather than silently treating a partial sum as ground truth.
  */
 export function buildContextBreakdown(input: BuildContextBreakdownInput): ContextBreakdown {
 	const reserveTokens = input.reserveTokens ?? DEFAULT_RESERVE_TOKENS;
@@ -175,7 +314,12 @@ export function buildContextBreakdown(input: BuildContextBreakdownInput): Contex
 		estimatedTokens: input.ruleBudget.totalEstimatedTokens,
 		items: input.ruleBudget.entries.map((entry) => ({ label: entry.title, estimatedTokens: entry.estimatedTokens })),
 	};
-	const tasks: ContextSegment = { key: "tasks", label: "Papyrus Tasks", estimatedTokens: input.taskEstimatedTokens };
+	const tasks: ContextSegment = {
+		key: "tasks",
+		label: "Papyrus Tasks",
+		estimatedTokens: sumItemTree(input.taskItems),
+		items: input.taskItems,
+	};
 	const skills: ContextSegment = {
 		key: "skills",
 		label: "Pi Skills catalog",
@@ -186,57 +330,30 @@ export function buildContextBreakdown(input: BuildContextBreakdownInput): Contex
 		key: "basePrompt",
 		label: input.basePromptEstimatedTokens === null ? "Base system prompt (not observed yet)" : "Base system prompt (Pi + host instructions)",
 		estimatedTokens: input.basePromptEstimatedTokens ?? 0,
+		...(input.basePromptEstimatedTokens === null ? { unknown: true } : {}),
 	};
 	const messageHistory: ContextSegment = {
 		key: "messageHistory",
 		label: "Conversation message history",
-		estimatedTokens: input.messageHistoryEstimatedTokens,
+		estimatedTokens: input.messageHistoryActiveTokens,
+		items: input.messageHistoryItems,
 	};
 	const knownTokens = rules.estimatedTokens + tasks.estimatedTokens + skills.estimatedTokens + basePrompt.estimatedTokens + messageHistory.estimatedTokens;
+	const overshootTokens = input.totalTokens === null ? 0 : Math.max(0, knownTokens - input.totalTokens);
 	const other: ContextSegment = {
 		key: "other",
-		label: "Unaccounted (tool definitions, framework overhead)",
+		label: overshootTokens > 0
+			? `Unaccounted (tool definitions, framework overhead) -- estimate overshoot: other segments' estimates already exceed the real total by ~${overshootTokens} tokens, so this is a floor, not a real zero`
+			: "Unaccounted (tool definitions, framework overhead)",
 		estimatedTokens: input.totalTokens === null ? 0 : Math.max(0, input.totalTokens - knownTokens),
 	};
 	return {
 		totalTokens: input.totalTokens,
 		contextWindow: input.contextWindow,
 		effectiveBudget: input.contextWindow === null ? null : Math.max(0, input.contextWindow - reserveTokens),
+		overshootTokens,
 		segments: [rules, tasks, skills, basePrompt, messageHistory, other],
 	};
 }
 
-function truncate(text: string, max: number): string {
-	return text.length > max ? `${text.slice(0, max - 1)}…` : text;
-}
-
-/** Pure text formatter, independent of live daemon/filesystem state, for direct unit testing. */
-export function formatContextBudgetReport(budget: ContextBudget): string {
-	const lines: string[] = ["Papyrus passive context budget", ""];
-
-	lines.push(`Rules (active, injected every relevant turn): ${budget.rules.entries.length} rules · ${budget.rules.totalCharacters} chars · ~${budget.rules.totalEstimatedTokens} tokens`);
-	if (budget.rules.entries.length > 0) {
-		lines.push("  Largest:");
-		for (const entry of budget.rules.entries.slice(0, REPORT_MAX_ROWS)) {
-			lines.push(`  ${entry.characters.toString().padStart(5)} chars (~${entry.estimatedTokens} tok)  ${truncate(entry.title, 60)}`);
-		}
-	}
-	lines.push("");
-
-	lines.push(`Skills (Pi-native catalog, injected at startup): ${budget.skills.entries.length} skills · ${budget.skills.totalCharacters} chars · ~${budget.skills.totalEstimatedTokens} tokens`);
-	if (budget.skills.entries.length > 0) {
-		lines.push("  Largest:");
-		for (const entry of budget.skills.entries.slice(0, REPORT_MAX_ROWS)) {
-			lines.push(`  ${entry.characters.toString().padStart(5)} chars (~${entry.estimatedTokens} tok)  ${truncate(entry.name, 40)}`);
-		}
-	}
-	if (budget.skills.scannedDirectories.length > 0) {
-		lines.push(`  Scanned: ${budget.skills.scannedDirectories.join(", ")}`);
-	} else {
-		lines.push("  No skill directories found (checked Pi's documented global/project locations and settings.json's skills array).");
-	}
-	lines.push("");
 
-	lines.push(`Total passive tax: ~${budget.totalEstimatedTokens} tokens across ${budget.rules.entries.length + budget.skills.entries.length} items, before a single user message or tool call.`);
-	return lines.join("\n");
-}

package/extension/src/context-view.ts

@@ -1,9 +1,8 @@
 import type { ExtensionCommandContext, Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
 import { matchesKey, truncateToWidth, type TUI } from "@earendil-works/pi-tui";
 import type { ContextBreakdown, ContextSegment, ContextSegmentItem } from "./context-budget.ts";
-import { formatContextBudgetReport, type ContextBudget } from "./context-budget.ts";
 
-const DRILLDOWN_VISIBLE_ROWS = 15;
+const VISIBLE_ROWS = 24;
 
 const SEGMENT_COLORS: Record<ContextSegment["key"], ThemeColor> = {
 	rules: "accent",
@@ -14,6 +13,20 @@ const SEGMENT_COLORS: Record<ContextSegment["key"], ThemeColor> = {
 	other: "muted",
 };
 
+/**
+ * One row in the unified scrollable view. Every segment that has any real (nonzero) content
+ * is fully expanded inline -- there is no separate "select a segment, then drill in" step.
+ * `key` drives this row's color; `isHeader` distinguishes a segment's own summary line from
+ * its item rows underneath it.
+ */
+export interface ContextRow {
+	key: ContextSegment["key"];
+	isHeader: boolean;
+	text: string;
+	/** Nesting depth for indentation -- 0 for a segment header or a top-level item, deeper for real tree children (message history branches, Task containment). */
+	depth: number;
+}
+
 function formatTokenCount(tokens: number): string {
 	return tokens >= 1000 ? `${(tokens / 1000).toFixed(1)}k` : String(tokens);
 }
@@ -23,35 +36,53 @@ function percentOf(part: number, whole: number): string {
 }
 
 /**
- * Renders the context window as one proportional stacked bar, one colored run of block
- * characters per segment, matching each row's own swatch color below it. A zero-token
- * breakdown (nothing observed yet) renders an empty dim track rather than a divide-by-zero.
+ * Flattens every segment with real content into one linear row list, filtering out anything
+ * that is genuinely zero rather than displaying a misleading "0 tok  0.0%" row -- a segment or
+ * item with literally nothing in it carries no information and is pure noise in a scrollable
+ * view meant to show where tokens actually go. A segment whose OWN total is zero but whose
+ * items are also all zero is dropped entirely; a segment with a nonzero total is always kept
+ * even if all its items individually round to zero (the total itself is real signal).
  */
-export function renderContextBar(theme: Theme, segments: ReadonlyArray<ContextSegment>, width: number): string {
-	const total = segments.reduce((sum, segment) => sum + segment.estimatedTokens, 0);
-	if (total <= 0 || width <= 0) return theme.fg("dim", "░".repeat(Math.max(0, width)));
-	let used = 0;
-	let output = "";
-	segments.forEach((segment, index) => {
-		const isLast = index === segments.length - 1;
-		const cells = isLast ? width - used : Math.round((segment.estimatedTokens / total) * width);
-		used += cells;
-		if (cells > 0) output += theme.fg(SEGMENT_COLORS[segment.key], "█".repeat(cells));
-	});
-	return output;
+/** Recursively flattens one item and its real tree children (message history branches, Task containment) into indented rows, sorted biggest-first at each level -- a parent always immediately precedes its own children, never scrambled by a global sort. */
+function flattenItem(item: ContextSegmentItem, key: ContextSegment["key"], depth: number, rows: ContextRow[]): void {
+	rows.push({ key, isHeader: false, depth, text: `${item.estimatedTokens.toString().padStart(6)} tok  ${item.label}` });
+	const children = (item.children ?? []).filter((child) => child.estimatedTokens > 0).sort((a, b) => b.estimatedTokens - a.estimatedTokens);
+	for (const child of children) flattenItem(child, key, depth + 1, rows);
+}
+
+export function buildContextRows(breakdown: ContextBreakdown): ContextRow[] {
+	const rows: ContextRow[] = [];
+	const denominator = breakdown.totalTokens ?? breakdown.segments.reduce((sum, segment) => sum + segment.estimatedTokens, 0);
+	for (const segment of breakdown.segments) {
+		const items = (segment.items ?? []).filter((item) => item.estimatedTokens > 0).sort((a, b) => b.estimatedTokens - a.estimatedTokens);
+		// A genuinely-unknown segment (basePrompt before the first observed turn) must stay
+		// visible even when its placeholder value is zero -- hiding it would misrepresent
+		// "not measured yet" as "measured and empty", the same honesty problem overshootTokens
+		// exists to prevent for the unaccounted bucket.
+		if (segment.estimatedTokens <= 0 && items.length === 0 && !segment.unknown) continue;
+		rows.push({
+			key: segment.key,
+			isHeader: true,
+			depth: 0,
+			text: `${segment.label} — ${segment.estimatedTokens} tok (${percentOf(segment.estimatedTokens, denominator)})`,
+		});
+		for (const item of items) flattenItem(item, segment.key, 1, rows);
+	}
+	return rows;
 }
 
 class ContextViewport {
-	private selectedIndex = 0;
-	private drillDown: ContextSegment | null = null;
-	private drillIndex = 0;
+	private offsetY = 0;
+	private readonly rows: ContextRow[];
 
 	constructor(
 		private readonly tui: TUI,
 		private readonly theme: Theme,
 		private readonly breakdown: ContextBreakdown,
 		private readonly close: () => void,
-	) {}
+	) {
+		this.rows = buildContextRows(breakdown);
+	}
 
 	invalidate(): void {}
 
@@ -71,106 +102,82 @@ class ContextViewport {
 		} else if (this.breakdown.totalTokens !== null) {
 			lines.push(truncateToWidth(`${formatTokenCount(this.breakdown.totalTokens)} tokens (model context window unknown)`, contentWidth, ""));
 		} else {
-			lines.push(theme.fg("dim", "No real usage reported yet — segment sizes below are Papyrus's own estimates only"));
+			lines.push(theme.fg("dim", "No real usage reported yet — sizes below are Papyrus's own estimates only"));
 		}
 		lines.push(renderContextBar(theme, this.breakdown.segments, contentWidth));
-		lines.push("");
-
-		if (this.drillDown) {
-			lines.push(...this.renderDrillDown(contentWidth));
-		} else {
-			lines.push(...this.renderSegments(contentWidth));
+		if (this.breakdown.overshootTokens > 0) {
+			lines.push(truncateToWidth(theme.fg("warning", `Estimates exceed real total by ~${this.breakdown.overshootTokens} tok — sizes below are approximate, not exact`), contentWidth, ""));
 		}
-		lines.push(border);
-		return lines;
-	}
+		lines.push("");
 
-	private renderSegments(width: number): string[] {
-		const theme = this.theme;
-		const lines: string[] = [];
-		const denominator = this.breakdown.totalTokens ?? this.breakdown.segments.reduce((sum, segment) => sum + segment.estimatedTokens, 0);
-		this.breakdown.segments.forEach((segment, index) => {
-			const selected = index === this.selectedIndex;
-			const cursor = selected ? theme.fg("accent", "❯") : " ";
-			const swatch = theme.fg(SEGMENT_COLORS[segment.key], "██");
-			const title = selected ? theme.bold(segment.label) : segment.label;
-			const percent = percentOf(segment.estimatedTokens, denominator);
-			const drillHint = segment.items && segment.items.length > 0 ? theme.fg("dim", ` (${segment.items.length} items — enter to expand)`) : "";
-			lines.push(truncateToWidth(`${cursor} ${swatch} ${segment.estimatedTokens.toString().padStart(6)} tok  ${percent.padStart(5)}  ${title}${drillHint}`, width, ""));
+		this.visibleWindow().forEach(({ row, index }) => {
+			const gutter = theme.fg(SEGMENT_COLORS[row.key], "▌");
+			const indent = "  ".repeat(row.depth);
+			const text = row.isHeader ? theme.bold(row.text) : `${indent}${row.text}`;
+			lines.push(truncateToWidth(`${gutter} ${text}`, contentWidth, ""));
+			void index;
 		});
+		if (this.rows.length === 0) lines.push(theme.fg("dim", "  (nothing observed yet)"));
+		else lines.push(theme.fg("muted", `  ${Math.min(this.offsetY + VISIBLE_ROWS, this.rows.length)}/${this.rows.length}`));
+
 		lines.push("");
-		lines.push(theme.fg("dim", "↑↓ select · enter expand · esc close"));
+		lines.push(theme.fg("dim", "↑↓ scroll · esc close"));
+		lines.push(border);
 		return lines;
 	}
 
-	private renderDrillDown(width: number): string[] {
-		const theme = this.theme;
-		const segment = this.drillDown!;
-		const items: ContextSegmentItem[] = segment.items ?? [];
-		const lines: string[] = [truncateToWidth(theme.fg("muted", `${segment.label} — largest first`), width, "")];
-		if (items.length === 0) {
-			lines.push(theme.fg("dim", "  (nothing to break down further)"));
-		} else {
-			const start = Math.max(0, Math.min(this.drillIndex - Math.floor(DRILLDOWN_VISIBLE_ROWS / 2), items.length - DRILLDOWN_VISIBLE_ROWS));
-			const end = Math.min(start + DRILLDOWN_VISIBLE_ROWS, items.length);
-			for (let index = start; index < end; index++) {
-				const item = items[index]!;
-				const selected = index === this.drillIndex;
-				const cursor = selected ? theme.fg("accent", "❯") : " ";
-				const title = selected ? theme.bold(item.label) : item.label;
-				lines.push(truncateToWidth(`${cursor} ${item.estimatedTokens.toString().padStart(6)} tok  ${title}`, width, ""));
-			}
-			lines.push(theme.fg("muted", `  ${this.drillIndex + 1}/${items.length}`));
-		}
-		lines.push("");
-		lines.push(theme.fg("dim", "↑↓ scroll · esc back"));
-		return lines;
+	private visibleWindow(): Array<{ row: ContextRow; index: number }> {
+		const end = Math.min(this.offsetY + VISIBLE_ROWS, this.rows.length);
+		const result: Array<{ row: ContextRow; index: number }> = [];
+		for (let index = this.offsetY; index < end; index++) result.push({ row: this.rows[index]!, index });
+		return result;
 	}
 
 	handleInput(data: string): void {
-		if (this.drillDown) {
-			const items = this.drillDown.items ?? [];
-			if (matchesKey(data, "escape")) this.drillDown = null;
-			else if (matchesKey(data, "up")) this.drillIndex = Math.max(0, this.drillIndex - 1);
-			else if (matchesKey(data, "down")) this.drillIndex = Math.min(Math.max(0, items.length - 1), this.drillIndex + 1);
-			else return;
-		} else {
-			if (matchesKey(data, "escape")) { this.close(); return; }
-			if (matchesKey(data, "up")) this.selectedIndex = Math.max(0, this.selectedIndex - 1);
-			else if (matchesKey(data, "down")) this.selectedIndex = Math.min(this.breakdown.segments.length - 1, this.selectedIndex + 1);
-			else if (matchesKey(data, "enter")) {
-				const segment = this.breakdown.segments[this.selectedIndex];
-				if (segment?.items && segment.items.length > 0) {
-					this.drillDown = segment;
-					this.drillIndex = 0;
-				}
-			} else return;
-		}
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) { this.close(); return; }
+		if (matchesKey(data, "up")) this.offsetY = Math.max(0, this.offsetY - 1);
+		else if (matchesKey(data, "down")) this.offsetY = Math.min(Math.max(0, this.rows.length - VISIBLE_ROWS), this.offsetY + 1);
+		else return;
 		this.tui.requestRender();
 	}
 }
 
-/** Non-interactive fallback (print mode, RPC, etc.): every segment listed plainly, plus the existing per-rule/per-skill breakdown for the two segments that support drill-down. */
-function fallbackReport(breakdown: ContextBreakdown, ruleBudget: ContextBudget["rules"]): string {
+/**
+ * Renders the context window as one proportional stacked bar, one colored run of block
+ * characters per segment, matching each row's own gutter color above/below it. A zero-token
+ * breakdown (nothing observed yet) renders an empty dim track rather than a divide-by-zero.
+ * Zero-token segments contribute no cells and are effectively invisible in the bar, matching
+ * their exclusion from the row list below it.
+ */
+export function renderContextBar(theme: Theme, segments: ReadonlyArray<ContextSegment>, width: number): string {
+	const total = segments.reduce((sum, segment) => sum + segment.estimatedTokens, 0);
+	if (total <= 0 || width <= 0) return theme.fg("dim", "░".repeat(Math.max(0, width)));
+	const nonZero = segments.filter((segment) => segment.estimatedTokens > 0);
+	let used = 0;
+	let output = "";
+	nonZero.forEach((segment, index) => {
+		const isLast = index === nonZero.length - 1;
+		const cells = isLast ? width - used : Math.round((segment.estimatedTokens / total) * width);
+		used += cells;
+		if (cells > 0) output += theme.fg(SEGMENT_COLORS[segment.key], "█".repeat(cells));
+	});
+	return output;
+}
+
+/** Non-interactive fallback (print mode, RPC, etc.): the same unified row list, as plain text lines. */
+function fallbackReport(breakdown: ContextBreakdown): string {
 	const totalLine = breakdown.totalTokens !== null
 		? `Real usage: ${breakdown.totalTokens} tokens${breakdown.effectiveBudget !== null ? ` / ${breakdown.effectiveBudget} usable budget (${percentOf(breakdown.totalTokens, breakdown.effectiveBudget)})` : ""}`
 		: "Real usage: not yet reported";
-	const denominator = breakdown.totalTokens ?? breakdown.segments.reduce((sum, segment) => sum + segment.estimatedTokens, 0);
-	const segmentLines = breakdown.segments.map((segment) => `  ${segment.estimatedTokens.toString().padStart(7)} tok  ${percentOf(segment.estimatedTokens, denominator).padStart(5)}  ${segment.label}`);
-	const skillsSegment = breakdown.segments.find((segment) => segment.key === "skills");
-	return [
-		totalLine,
-		"",
-		"Segments:",
-		...segmentLines,
-		"",
-		formatContextBudgetReport({ rules: ruleBudget, skills: { entries: [], totalCharacters: 0, totalEstimatedTokens: skillsSegment?.estimatedTokens ?? 0, scannedDirectories: [] }, totalEstimatedTokens: ruleBudget.totalEstimatedTokens }),
-	].join("\n");
+	const overshootLine = breakdown.overshootTokens > 0 ? [`Estimates exceed real total by ~${breakdown.overshootTokens} tok -- sizes below are approximate, not exact`] : [];
+	const rows = buildContextRows(breakdown);
+	const rowLines = rows.length > 0 ? rows.map((row) => (row.isHeader ? row.text : `${"  ".repeat(row.depth)}${row.text}`)) : ["(nothing observed yet)"];
+	return [totalLine, ...overshootLine, "", ...rowLines].join("\n");
 }
 
-export async function showContextView(ctx: ExtensionCommandContext, breakdown: ContextBreakdown, ruleBudget: ContextBudget["rules"]): Promise<void> {
+export async function showContextView(ctx: ExtensionCommandContext, breakdown: ContextBreakdown): Promise<void> {
 	if (ctx.mode !== "tui") {
-		ctx.ui.notify(fallbackReport(breakdown, ruleBudget), "info");
+		ctx.ui.notify(fallbackReport(breakdown), "info");
 		return;
 	}
 	await ctx.ui.custom<void>((tui, theme, _keybindings, done) => new ContextViewport(tui, theme, breakdown, done));

package/extension/src/index.ts

@@ -27,7 +27,7 @@ import { ActiveTaskContinuation, automaticPauseReason, shouldResumeFocusOnHumanI
 import { buildTaskWidgetProjection, type TaskWidgetProjection } from "./task-widget.ts";
 import { TASK_STATUS_PRESENTATION, taskTreeConnector } from "./task-presentation.ts";
 import { buildContextInjection } from "./context-injection-telemetry.ts";
-import { buildContextBreakdown, computeContextBudget, computeRuleBudget, estimateMessageHistoryTokens, type SessionBranchEntryLike } from "./context-budget.ts";
+import { buildContextBreakdown, buildMessageHistoryTree, buildTaskItemTree, computeContextBudget, computeRuleBudget, type SessionEntryLike, type SessionTreeNodeLike } from "./context-budget.ts";
 import { showContextView } from "./context-view.ts";
 import { emitTaskFocusEvent, setTaskFocusEventBus } from "./task-focus-events.ts";
 import { renderPapyrusToolCall, renderPapyrusToolResult } from "./tool-rendering/index.ts";
@@ -421,24 +421,29 @@ export default async function (pi: ExtensionAPI) {
 		handler: async (_args, ctx) => {
 			try {
 				const sessionId = ctx.sessionManager.getSessionId();
-				const [rules, taskSummary] = await Promise.all([
+				const [rules, taskGraph] = await Promise.all([
 					callService<Record<string, unknown>, Array<Pick<Artifact, "id" | "title" | "body" | "extra">>>("rules.injectable", { project_root: ctx.cwd, session_id: sessionId }),
-					callService<Record<string, unknown>, string | null>("tasks.context", { project_root: ctx.cwd, session_id: sessionId }),
+					callService<Record<string, unknown>, TaskGraph>("tasks.graph", { project_root: ctx.cwd, session_id: sessionId }),
 				]);
 				const { skills } = computeContextBudget(rules, ctx.cwd);
 				const ruleBudget = computeRuleBudget(rules);
 				const usage = ctx.getContextUsage?.();
-				const branch = ctx.sessionManager.getBranch() as unknown as SessionBranchEntryLike[];
+				// Real tree (not just the linear current-branch path): surfaces content sitting in an
+				// abandoned /tree branch, which cost real tokens to generate but isn't in context now.
+				const tree = ctx.sessionManager.getTree() as unknown as SessionTreeNodeLike[];
+				const activeEntryIds = new Set((ctx.sessionManager.getBranch() as unknown as SessionEntryLike[]).map((entry) => entry.id));
+				const messageHistory = buildMessageHistoryTree(tree, activeEntryIds);
 				const breakdown = buildContextBreakdown({
 					totalTokens: usage?.tokens ?? null,
 					contextWindow: ctx.model?.contextWindow ?? null,
 					ruleBudget,
-					taskEstimatedTokens: taskSummary ? Math.ceil(taskSummary.length / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN) : 0,
+					taskItems: buildTaskItemTree(taskGraph),
 					skills,
 					basePromptEstimatedTokens: lastObservedBasePromptTokens,
-					messageHistoryEstimatedTokens: estimateMessageHistoryTokens(branch),
+					messageHistoryItems: messageHistory.items,
+					messageHistoryActiveTokens: messageHistory.activeTokens,
 				});
-				await showContextView(ctx, breakdown, ruleBudget);
+				await showContextView(ctx, breakdown);
 			} catch (error) {
 				ctx.ui.notify(`Context breakdown failed: ${error instanceof Error ? error.message : error}`, "error");
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "keywords": ["pi-package"],

package/src/constants.ts

@@ -30,6 +30,18 @@ export const PAPYRUS_TASK_FOCUS_CHANNEL = "papyrus.task-focus.v1";
 export const PAPYRUS_TASK_FOCUS_SCHEMA = "papyrus.task-focus/v1";
 export const CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN = 4;
 
+/**
+ * Bounds for walking Pi's real session tree (getTree()) and Papyrus's own Task containment
+ * tree when estimating /context's message-history and task segments. Both are genuine trees
+ * built from external, mutable state (a session file; the live Task graph) -- depth and
+ * total-node bounds are a defensive measure against a corrupted/adversarial parentId chain
+ * forming an accidental cycle, matching the same cycle-safety discipline already applied to
+ * ConversationJournal traversal and deliberately hardening past a real, confirmed gap in
+ * Pi's own getBranch() (no cycle guard at all).
+ */
+export const CONTEXT_TREE_MAX_DEPTH = 200;
+export const CONTEXT_TREE_MAX_NODES = 2000;
+
 /**
  * A Papyrus Rule's condition+action+body is injected into EVERY relevant turn's system
  * prompt for the lifetime of the rule -- the same permanent, always-on-context role as an