@dungle-scrubs/tallow 0.8.7 → 0.8.8

package/extensions/bash-tool-enhanced/index.ts

@@ -18,8 +18,6 @@
  */
 import { execSync } from "node:child_process";
 import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
 import {
 	type AgentToolResult,
 	type BashToolDetails,
@@ -30,6 +28,7 @@ import { Text } from "@mariozechner/pi-tui";
 import { getIcon } from "../_icons/index.js";
 import { INTEROP_API_CHANNELS } from "../_shared/interop-events.js";
 import { enforceExplicitPolicy, recordAudit } from "../_shared/shell-policy.js";
+import { getTallowSettingsPath } from "../_shared/tallow-paths.js";
 import type { PromotedTaskHandle } from "../background-task-tool/index.js";
 import {
 	appendSection,
@@ -54,7 +53,7 @@ const DEFAULT_AUTO_BG_TIMEOUT_MS = 30_000;
  */
 function readAutoBackgroundTimeout(): number {
 	try {
-		const settingsPath = path.join(os.homedir(), ".tallow", "settings.json");
+		const settingsPath = getTallowSettingsPath();
 		const raw = fs.readFileSync(settingsPath, "utf-8");
 		const settings = JSON.parse(raw) as { bashAutoBackgroundTimeout?: number };
 		if (typeof settings.bashAutoBackgroundTimeout === "number") {
@@ -73,7 +72,7 @@ function readAutoBackgroundTimeout(): number {
  */
 function readMaintainProjectDir(): boolean {
 	try {
-		const settingsPath = path.join(os.homedir(), ".tallow", "settings.json");
+		const settingsPath = getTallowSettingsPath();
 		const raw = fs.readFileSync(settingsPath, "utf-8");
 		const settings = JSON.parse(raw) as { BASH_MAINTAIN_PROJECT_WORKING_DIR?: boolean };
 		return settings.BASH_MAINTAIN_PROJECT_WORKING_DIR === true;

package/extensions/cd-tool/index.ts

@@ -7,10 +7,10 @@
  */
 
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { resolve } from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
+import { getTallowSettingsPath } from "../_shared/tallow-paths.js";
 
 /**
  * Check if BASH_MAINTAIN_PROJECT_WORKING_DIR is enabled in settings.
@@ -19,7 +19,7 @@ import { Type } from "@sinclair/typebox";
  */
 function isMaintainProjectDirEnabled(): boolean {
 	try {
-		const raw = readFileSync(join(homedir(), ".tallow", "settings.json"), "utf-8");
+		const raw = readFileSync(getTallowSettingsPath(), "utf-8");
 		return (
 			(JSON.parse(raw) as { BASH_MAINTAIN_PROJECT_WORKING_DIR?: boolean })
 				.BASH_MAINTAIN_PROJECT_WORKING_DIR === true

package/extensions/claude-bridge/index.ts

@@ -14,6 +14,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { getTallowHomeDir } from "../_shared/tallow-paths.js";
 
 const CLAUDE_DIR = ".claude";
 /** Project-level config directories (current + legacy) */
@@ -165,7 +166,7 @@ export function getNonCollidingSkillPaths(
  */
 export default function (pi: ExtensionAPI): void {
 	pi.on("resources_discover", async (event) => {
-		const agentDir = process.env.PI_CODING_AGENT_DIR ?? path.join(os.homedir(), ".tallow");
+		const agentDir = getTallowHomeDir();
 		const cwd = (event as { cwd: string }).cwd;
 		const knownNames = collectKnownSkillNames(agentDir, cwd);
 

package/extensions/command-prompt/__tests__/plugin-sources.test.ts

@@ -0,0 +1,49 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { delimiter, join, resolve } from "node:path";
+import { discoverPluginPromptSourcesFromEnv } from "../index.js";
+
+let tmpRoot: string | null = null;
+
+afterEach(() => {
+	if (tmpRoot) {
+		rmSync(tmpRoot, { recursive: true, force: true });
+		tmpRoot = null;
+	}
+});
+
+describe("discoverPluginPromptSourcesFromEnv", () => {
+	it("returns empty list for empty env input", () => {
+		expect(discoverPluginPromptSourcesFromEnv("")).toEqual([]);
+		expect(discoverPluginPromptSourcesFromEnv(undefined)).toEqual([]);
+	});
+
+	it("parses plugin commands dirs and infers namespaces", () => {
+		tmpRoot = mkdtempSync(join(tmpdir(), "command-prompt-plugin-sources-"));
+		const a = join(tmpRoot, "plugin-a", "commands");
+		const b = join(tmpRoot, "plugin-b", "commands");
+		mkdirSync(a, { recursive: true });
+		mkdirSync(b, { recursive: true });
+
+		const value = `${a}${delimiter}${b}`;
+		const sources = discoverPluginPromptSourcesFromEnv(value);
+
+		expect(sources).toHaveLength(2);
+		expect(sources[0]).toEqual({ namespace: "plugin-a", promptsDirs: [resolve(a)] });
+		expect(sources[1]).toEqual({ namespace: "plugin-b", promptsDirs: [resolve(b)] });
+	});
+
+	it("deduplicates and skips missing directories", () => {
+		tmpRoot = mkdtempSync(join(tmpdir(), "command-prompt-plugin-sources-"));
+		const a = join(tmpRoot, "plugin-a", "commands");
+		const missing = join(tmpRoot, "missing", "commands");
+		mkdirSync(a, { recursive: true });
+
+		const value = `${a}${delimiter}${missing}${delimiter}${a}`;
+		const sources = discoverPluginPromptSourcesFromEnv(value);
+
+		expect(sources).toHaveLength(1);
+		expect(sources[0]).toEqual({ namespace: "plugin-a", promptsDirs: [resolve(a)] });
+	});
+});

package/extensions/command-prompt/index.ts

@@ -29,6 +29,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { delimiter } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { getAgentDir } from "@mariozechner/pi-coding-agent";
 import { Key } from "@mariozechner/pi-tui";
@@ -327,6 +328,40 @@ function discoverPackagePromptSources(settingsPath: string): PackagePromptSource
 	return results;
 }
 
+/**
+ * Discover plugin command sources from a path-list environment variable.
+ *
+ * SDK populates `TALLOW_PLUGIN_COMMANDS_DIRS` with absolute `commands/`
+ * directories from resolved Claude-style plugins.
+ *
+ * @param envValue - Optional env value override for tests
+ * @returns Namespaced prompt sources inferred from plugin command dirs
+ */
+export function discoverPluginPromptSourcesFromEnv(envValue?: string): PackagePromptSource[] {
+	const raw = (envValue ?? process.env.TALLOW_PLUGIN_COMMANDS_DIRS ?? "").trim();
+	if (!raw) return [];
+
+	const seen = new Set<string>();
+	const sources: PackagePromptSource[] = [];
+
+	for (const dir of raw
+		.split(delimiter)
+		.map((v) => v.trim())
+		.filter(Boolean)) {
+		if (!fs.existsSync(dir)) continue;
+		const normalized = path.resolve(dir);
+		if (seen.has(normalized)) continue;
+		seen.add(normalized);
+
+		// commands/ lives at pluginRoot/commands → namespace = pluginRoot basename
+		const pluginRoot = path.dirname(normalized);
+		const namespace = path.basename(pluginRoot);
+		sources.push({ namespace, promptsDirs: [normalized] });
+	}
+
+	return sources;
+}
+
 /**
  * Discovers ALL prompts across multiple package directories (top-level +
  * one-deep subdirs). Merges results from all dirs, deduplicating by name
@@ -575,6 +610,7 @@ export default function (pi: ExtensionAPI): void {
 	const packageSources = [
 		...discoverPackagePromptSources(projectSettings),
 		...discoverPackagePromptSources(globalSettings),
+		...discoverPluginPromptSourcesFromEnv(),
 	];
 
 	for (const { namespace, promptsDirs } of packageSources) {

package/extensions/context-files/index.ts

@@ -18,6 +18,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { createLazyInitializer } from "../_shared/lazy-init.js";
+import { getTallowHomeDir } from "../_shared/tallow-paths.js";
 
 const CONTEXT_FILENAMES = ["CLAUDE.md", "AGENTS.md"] as const;
 
@@ -166,7 +167,7 @@ function findSubdirRuleFiles(baseDir: string, maxDepth: number = 5): string[] {
  */
 function collectMissingFiles(cwd: string): ContextFile[] {
 	const files: ContextFile[] = [];
-	const globalDir = path.join(os.homedir(), ".tallow");
+	const globalDir = getTallowHomeDir();
 
 	// --- Global level ---
 	// If pi loaded ~/.tallow/AGENTS.md, we pick up CLAUDE.md (and vice versa)

package/extensions/context-fork/index.ts

@@ -25,6 +25,7 @@ import { stripFrontmatter } from "@mariozechner/pi-coding-agent";
 import { Text } from "@mariozechner/pi-tui";
 import { createLazyInitializer } from "../_shared/lazy-init.js";
 import { isShellInterpolationEnabled } from "../_shared/shell-policy.js";
+import { getTallowHomeDir } from "../_shared/tallow-paths.js";
 import { expandShellCommands } from "../shell-interpolation/index.js";
 import type { FrontmatterIndex } from "./frontmatter-index.js";
 import { buildFrontmatterIndex } from "./frontmatter-index.js";
@@ -197,7 +198,7 @@ function getPackageAgentDirs(settingsPath: string): string[] {
  * @returns Map of agent name → config
  */
 function loadAllAgents(): Map<string, AgentConfig> {
-	const agentDir = process.env.PI_CODING_AGENT_DIR ?? path.join(os.homedir(), ".tallow");
+	const agentDir = getTallowHomeDir();
 	const userDir = path.join(agentDir, "agents");
 	const userClaudeDir = path.join(os.homedir(), ".claude", "agents");
 	const projectDir = path.join(process.cwd(), ".tallow", "agents");

package/extensions/context-usage/__tests__/tool-result-memory.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+import { computeToolResultMemoryStats } from "../index.js";
+
+const RETENTION_MARKER = "__tallow_summarized_tool_result__";
+
+/**
+ * Build a branch entry with a toolResult message payload.
+ *
+ * @param id - Tool call id
+ * @param text - Text payload
+ * @param details - Optional details payload
+ * @returns Session branch entry-like object
+ */
+function toolResultEntry(
+	id: string,
+	text: string,
+	details?: Record<string, unknown>
+): { message: Record<string, unknown>; type: string } {
+	return {
+		type: "message",
+		message: {
+			role: "toolResult",
+			toolCallId: id,
+			toolName: "bash",
+			content: [{ type: "text", text }],
+			details,
+			isError: false,
+			timestamp: Date.now(),
+		},
+	};
+}
+
+describe("computeToolResultMemoryStats", () => {
+	test("returns zero stats for empty branches", () => {
+		const stats = computeToolResultMemoryStats([]);
+		expect(stats.totalResults).toBe(0);
+		expect(stats.summarizedResults).toBe(0);
+		expect(stats.retainedBytes).toBe(0);
+		expect(stats.reclaimedBytes).toBe(0);
+	});
+
+	test("counts retained and reclaimed bytes for summarized historical results", () => {
+		const summarized = toolResultEntry("tc_1", "short summary", {
+			[RETENTION_MARKER]: true,
+			originalBytes: 20_000,
+		});
+		const full = toolResultEntry("tc_2", "x".repeat(2_000), { foo: "bar" });
+		const nonToolMessage = {
+			type: "message",
+			message: {
+				role: "assistant",
+				content: [{ type: "text", text: "ok" }],
+			},
+		};
+
+		const stats = computeToolResultMemoryStats([summarized, full, nonToolMessage]);
+		expect(stats.totalResults).toBe(2);
+		expect(stats.summarizedResults).toBe(1);
+		expect(stats.retainedBytes).toBeGreaterThan(0);
+		expect(stats.reclaimedBytes).toBeGreaterThan(0);
+	});
+});

package/extensions/context-usage/index.ts

@@ -15,11 +15,10 @@
  */
 
 import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
 import type { ContextUsage, ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { DEFAULT_COMPACTION_SETTINGS } from "@mariozechner/pi-coding-agent";
 import { getIcon } from "../_icons/index.js";
+import { getTallowSettingsPath } from "../_shared/tallow-paths.js";
 
 // ── Constants ────────────────────────────────────────────────────────────────
 
@@ -29,6 +28,9 @@ const GRID_COLS = 10;
 /** Chars/4 heuristic for token estimation */
 const CHARS_PER_TOKEN = 4;
 
+/** Marker key attached by sdk tool-result retention summarization. */
+const TOOL_RESULT_RETENTION_MARKER = "__tallow_summarized_tool_result__";
+
 // ── Settings ─────────────────────────────────────────────────────────────────
 
 interface CompactionConfig {
@@ -36,12 +38,28 @@ interface CompactionConfig {
 	readonly reserveTokens: number;
 }
 
+/** Tool-result payload memory summary for the active branch. */
+export interface ToolResultMemoryStats {
+	readonly reclaimedBytes: number;
+	readonly retainedBytes: number;
+	readonly summarizedResults: number;
+	readonly totalResults: number;
+}
+
+/** Zero-value fallback for tool-result memory stats. */
+const EMPTY_TOOL_RESULT_MEMORY_STATS: ToolResultMemoryStats = {
+	reclaimedBytes: 0,
+	retainedBytes: 0,
+	summarizedResults: 0,
+	totalResults: 0,
+};
+
 /**
  * Reads compaction settings from ~/.tallow/settings.json.
  * Falls back to DEFAULT_COMPACTION_SETTINGS if unreadable.
  */
 function readCompactionConfig(): CompactionConfig {
-	const settingsPath = path.join(os.homedir(), ".tallow", "settings.json");
+	const settingsPath = getTallowSettingsPath();
 	try {
 		const raw = fs.readFileSync(settingsPath, "utf-8");
 		const settings = JSON.parse(raw) as {
@@ -172,6 +190,102 @@ function estimateToolTokens(
 	return total;
 }
 
+/**
+ * Estimate UTF-8 bytes for a JSON-serializable value.
+ *
+ * @param value - Any serializable value
+ * @returns Byte length of JSON representation, or 0 when unavailable
+ */
+function safeJsonBytes(value: unknown): number {
+	if (value == null) return 0;
+	try {
+		return Buffer.byteLength(JSON.stringify(value), "utf-8");
+	} catch {
+		return 0;
+	}
+}
+
+/**
+ * Type guard for plain object records.
+ *
+ * @param value - Unknown value
+ * @returns True when value is a non-null object and not an array
+ */
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Estimate current in-memory payload bytes for a tool-result message.
+ *
+ * @param message - Candidate message object
+ * @returns Estimated payload bytes for content + details
+ */
+function estimateToolResultMessageBytes(message: Record<string, unknown>): number {
+	const content = Array.isArray(message.content) ? message.content : [];
+	let contentBytes = 0;
+
+	for (const block of content) {
+		if (!isRecord(block)) continue;
+		if (block.type === "text") {
+			contentBytes += Buffer.byteLength(typeof block.text === "string" ? block.text : "", "utf-8");
+			continue;
+		}
+		if (block.type === "image") {
+			contentBytes += Buffer.byteLength(typeof block.data === "string" ? block.data : "", "utf-8");
+			contentBytes += Buffer.byteLength(
+				typeof block.mimeType === "string" ? block.mimeType : "",
+				"utf-8"
+			);
+		}
+	}
+
+	const detailsBytes = safeJsonBytes(message.details);
+	return contentBytes + detailsBytes;
+}
+
+/**
+ * Compute tool-result payload memory stats from branch entries.
+ *
+ * @param branchEntries - Session branch entries from `sessionManager.getBranch()`
+ * @returns Aggregated tool-result memory stats
+ */
+export function computeToolResultMemoryStats(
+	branchEntries: Array<{ type: string; message?: unknown }>
+): ToolResultMemoryStats {
+	if (branchEntries.length === 0) return EMPTY_TOOL_RESULT_MEMORY_STATS;
+
+	let reclaimedBytes = 0;
+	let retainedBytes = 0;
+	let summarizedResults = 0;
+	let totalResults = 0;
+
+	for (const entry of branchEntries) {
+		if (entry.type !== "message" || !isRecord(entry.message)) continue;
+		if (entry.message.role !== "toolResult") continue;
+
+		totalResults += 1;
+		const currentBytes = estimateToolResultMessageBytes(entry.message);
+		retainedBytes += currentBytes;
+
+		const details = entry.message.details;
+		if (!isRecord(details) || details[TOOL_RESULT_RETENTION_MARKER] !== true) continue;
+		summarizedResults += 1;
+		const originalBytes =
+			typeof details.originalBytes === "number" && Number.isFinite(details.originalBytes)
+				? Math.max(0, details.originalBytes)
+				: 0;
+		reclaimedBytes += Math.max(0, originalBytes - currentBytes);
+	}
+
+	return {
+		reclaimedBytes,
+		retainedBytes,
+		summarizedResults,
+		totalResults,
+	};
+}
+
 // ── System prompt parsing ────────────────────────────────────────────────────
 
 /** @internal */
@@ -247,6 +361,18 @@ export function formatTokens(count: number): string {
 	return `${(count / 1_000_000).toFixed(1)}M`;
 }
 
+/**
+ * Formats byte counts with compact units.
+ *
+ * @param count - Byte count
+ * @returns Human-readable byte string
+ */
+function formatBytes(count: number): string {
+	if (count < 1024) return `${count}B`;
+	if (count < 1024 * 1024) return `${(count / 1024).toFixed(1)}KB`;
+	return `${(count / (1024 * 1024)).toFixed(1)}MB`;
+}
+
 /**
  * Renders the waffle chart grid.
  * Each cell represents a proportional slice of the context window.
@@ -302,7 +428,8 @@ function buildLegend(
 	contextWindow: number,
 	modelId: string,
 	usedTokens: number,
-	usedPercent: number
+	usedPercent: number,
+	toolResultMemory: ToolResultMemoryStats
 ): string[] {
 	const lines: string[] = [];
 
@@ -323,6 +450,23 @@ function buildLegend(
 		);
 	}
 
+	if (toolResultMemory.totalResults > 0) {
+		lines.push("");
+		lines.push(`${DIM}Historical tool-result payloads${RESET}`);
+		lines.push(
+			`${getIcon("in_progress")} results: ${toolResultMemory.totalResults} total, ` +
+				`${toolResultMemory.summarizedResults} summarized`
+		);
+		lines.push(
+			`${getIcon("in_progress")} retained bytes: ${formatBytes(toolResultMemory.retainedBytes)}`
+		);
+		if (toolResultMemory.reclaimedBytes > 0) {
+			lines.push(
+				`${getIcon("success")} reclaimed bytes: ${formatBytes(toolResultMemory.reclaimedBytes)}`
+			);
+		}
+	}
+
 	return lines;
 }
 
@@ -342,6 +486,7 @@ interface ContextUsageDetails {
 		readonly emptyChar: string;
 		readonly tokens: number;
 	}>;
+	readonly toolResultMemory: ToolResultMemoryStats;
 }
 
 /**
@@ -386,8 +531,12 @@ export default function contextUsageExtension(pi: ExtensionAPI): void {
 			const systemPrompt = ctx.getSystemPrompt();
 			const tools = pi.getAllTools();
 			const modelId = ctx.model?.id ?? "unknown-model";
+			const branchEntries = ctx.sessionManager.getBranch() as Array<{
+				type: string;
+				message?: unknown;
+			}>;
 
-			const details = buildDetails(usage, systemPrompt, tools, modelId);
+			const details = buildDetails(usage, systemPrompt, tools, modelId, branchEntries);
 
 			pi.sendMessage({
 				customType: "context-usage",
@@ -405,13 +554,15 @@ export default function contextUsageExtension(pi: ExtensionAPI): void {
  * @param systemPrompt - Current system prompt
  * @param tools - Registered tools
  * @param modelId - Current model identifier
+ * @param branchEntries - Current session branch entries
  * @returns Details object for the message renderer
  */
 function buildDetails(
 	usage: ContextUsage,
 	systemPrompt: string,
 	tools: Array<{ name: string; description: string; parameters: unknown }>,
-	modelId: string
+	modelId: string,
+	branchEntries: Array<{ type: string; message?: unknown }>
 ): ContextUsageDetails {
 	const compaction = readCompactionConfig();
 	const includeAutocompact = compaction.enabled;
@@ -440,6 +591,8 @@ function buildDetails(
 	const freeTokens = Math.max(0, contextWindow - usedTokens - reserveTokens);
 	categories[5].tokens = freeTokens;
 
+	const toolResultMemory = computeToolResultMemoryStats(branchEntries);
+
 	return {
 		modelId,
 		contextWindow,
@@ -452,6 +605,7 @@ function buildDetails(
 			emptyChar: c.emptyChar,
 			tokens: c.tokens,
 		})),
+		toolResultMemory,
 	};
 }
 
@@ -461,7 +615,7 @@ function buildDetails(
  * @returns Array of rendered lines
  */
 function renderFromDetails(details: ContextUsageDetails): string[] {
-	const { categories, contextWindow, modelId, usedTokens } = details;
+	const { categories, contextWindow, modelId, toolResultMemory, usedTokens } = details;
 	const usedPercent = contextWindow > 0 ? (usedTokens / contextWindow) * 100 : 0;
 
 	const lines: string[] = [];
@@ -469,7 +623,14 @@ function renderFromDetails(details: ContextUsageDetails): string[] {
 	lines.push(`  ${BOLD}Context Usage${RESET}`);
 
 	const chartLines = renderWaffleChart(categories, contextWindow);
-	const legendLines = buildLegend(categories, contextWindow, modelId, usedTokens, usedPercent);
+	const legendLines = buildLegend(
+		categories,
+		contextWindow,
+		modelId,
+		usedTokens,
+		usedPercent,
+		toolResultMemory
+	);
 
 	const maxLines = Math.max(chartLines.length, legendLines.length);
 	for (let i = 0; i < maxLines; i++) {

package/extensions/debug/__tests__/analysis.test.ts

@@ -19,12 +19,23 @@ import type { LogEntry } from "../logger.js";
  * @param ok - Whether the call succeeded
  * @returns A LogEntry for a tool result
  */
-function toolResult(name: string, durationMs: number, ok = true): LogEntry {
+function toolResult(
+	name: string,
+	durationMs: number,
+	ok = true,
+	extra: Record<string, unknown> = {}
+): LogEntry {
 	return {
 		ts: new Date().toISOString(),
 		cat: "tool",
 		evt: "result",
-		data: { name, durationMs, ok, toolCallId: `tc_${Math.random().toString(36).slice(2, 6)}` },
+		data: {
+			name,
+			durationMs,
+			ok,
+			toolCallId: `tc_${Math.random().toString(36).slice(2, 6)}`,
+			...extra,
+		},
 	};
 }
 
@@ -166,6 +177,17 @@ describe("formatToolTimings()", () => {
 		expect(output).toContain("| Tool |");
 		expect(output).toContain("| bash |");
 	});
+
+	it("includes payload and summarized columns", () => {
+		const stats = summarizeToolTimings([
+			toolResult("bash", 100, true, { payloadBytes: 2_048, summarizedByRetention: true }),
+		]);
+		const output = formatToolTimings(stats);
+
+		expect(output).toContain("Avg payload");
+		expect(output).toContain("2.0KB");
+		expect(output).toContain("| 1 |");
+	});
 });
 
 // ── groupErrors() ────────────────────────────────────────────
@@ -350,4 +372,15 @@ describe("formatEntries()", () => {
 		expect(output).toContain("agent=sub_1");
 		expect(output).toContain("exit=1");
 	});
+
+	it("highlights payload bytes and retention summaries", () => {
+		const entry = toolResult("bash", 12, true, {
+			payloadBytes: 2_048,
+			summarizedByRetention: true,
+		});
+		const output = formatEntries([entry]);
+
+		expect(output).toContain("payload=2.0KB");
+		expect(output).toContain("summarized");
+	});
 });

package/extensions/debug/__tests__/diagnostics-commands.test.ts

@@ -20,11 +20,14 @@ interface CommandContextOptions {
 let harness: ExtensionHarness;
 let tmpHome: string;
 let savedHome: string | undefined;
+let savedTallowHome: string | undefined;
 
 beforeEach(async () => {
 	tmpHome = mkdtempSync(join(tmpdir(), "tallow-debug-diag-cmd-test-"));
 	savedHome = process.env.HOME;
+	savedTallowHome = process.env.TALLOW_CODING_AGENT_DIR;
 	process.env.HOME = tmpHome;
+	process.env.TALLOW_CODING_AGENT_DIR = join(tmpHome, ".tallow");
 	(globalThis as Record<string, unknown>).__piDebugLogger = undefined;
 
 	harness = ExtensionHarness.create();
@@ -37,6 +40,11 @@ afterEach(() => {
 	} else {
 		delete process.env.HOME;
 	}
+	if (savedTallowHome !== undefined) {
+		process.env.TALLOW_CODING_AGENT_DIR = savedTallowHome;
+	} else {
+		delete process.env.TALLOW_CODING_AGENT_DIR;
+	}
 	(globalThis as Record<string, unknown>).__piDebugLogger = undefined;
 	rmSync(tmpHome, { recursive: true, force: true });
 });
@@ -59,8 +67,9 @@ function getCommand(name: string): Omit<RegisteredCommand, "name"> {
  * @returns Absolute path to the seeded debug log
  */
 function seedDebugLog(): string {
-	const logPath = join(tmpHome, ".tallow", "debug.log");
-	mkdirSync(join(tmpHome, ".tallow"), { recursive: true });
+	const tallowHome = process.env.TALLOW_CODING_AGENT_DIR ?? join(tmpHome, ".tallow");
+	const logPath = join(tallowHome, "debug.log");
+	mkdirSync(tallowHome, { recursive: true });
 	writeFileSync(
 		logPath,
 		[