@dungle-scrubs/tallow 0.8.7 → 0.8.8

package/extensions/debug/analysis.ts

@@ -20,6 +20,9 @@ interface ToolTimingStats {
 	avgMs: number;
 	p50Ms: number;
 	p95Ms: number;
+	totalPayloadBytes: number;
+	avgPayloadBytes: number;
+	summarizedCount: number;
 }
 
 /**
@@ -35,6 +38,18 @@ function percentile(sorted: number[], p: number): number {
 	return sorted[Math.max(0, idx)];
 }
 
+/**
+ * Format bytes with compact units for table output.
+ *
+ * @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`;
+}
+
 /**
  * Computes per-tool timing statistics from tool result log entries.
  *
@@ -45,35 +60,53 @@ function percentile(sorted: number[], p: number): number {
  * @returns Array of timing stats sorted by total time descending
  */
 export function summarizeToolTimings(entries: LogEntry[]): ToolTimingStats[] {
-	const timingsByTool = new Map<string, number[]>();
+	const timingsByTool = new Map<
+		string,
+		{ durations: number[]; payloadBytes: number; summarizedCount: number }
+	>();
 
 	for (const entry of entries) {
 		if (entry.cat !== "tool" || entry.evt !== "result") continue;
-		const { name, durationMs } = entry.data as { name?: string; durationMs?: number };
+		const { durationMs, name, payloadBytes, summarizedByRetention } = entry.data as {
+			durationMs?: number;
+			name?: string;
+			payloadBytes?: number;
+			summarizedByRetention?: boolean;
+		};
 		if (!name || durationMs == null) continue;
 
 		const existing = timingsByTool.get(name);
 		if (existing) {
-			existing.push(durationMs);
+			existing.durations.push(durationMs);
+			existing.payloadBytes += typeof payloadBytes === "number" ? Math.max(0, payloadBytes) : 0;
+			existing.summarizedCount += summarizedByRetention ? 1 : 0;
 		} else {
-			timingsByTool.set(name, [durationMs]);
+			timingsByTool.set(name, {
+				durations: [durationMs],
+				payloadBytes: typeof payloadBytes === "number" ? Math.max(0, payloadBytes) : 0,
+				summarizedCount: summarizedByRetention ? 1 : 0,
+			});
 		}
 	}
 
 	const stats: ToolTimingStats[] = [];
-	for (const [name, durations] of timingsByTool) {
-		durations.sort((a, b) => a - b);
-		const totalMs = durations.reduce((sum, d) => sum + d, 0);
+	for (const [name, values] of timingsByTool) {
+		values.durations.sort((a, b) => a - b);
+		const totalMs = values.durations.reduce((sum, d) => sum + d, 0);
 
 		stats.push({
 			name,
-			callCount: durations.length,
+			callCount: values.durations.length,
 			totalMs,
-			minMs: durations[0],
-			maxMs: durations[durations.length - 1],
-			avgMs: Math.round(totalMs / durations.length),
-			p50Ms: percentile(durations, 50),
-			p95Ms: percentile(durations, 95),
+			minMs: values.durations[0],
+			maxMs: values.durations[values.durations.length - 1],
+			avgMs: Math.round(totalMs / values.durations.length),
+			p50Ms: percentile(values.durations, 50),
+			p95Ms: percentile(values.durations, 95),
+			totalPayloadBytes: values.payloadBytes,
+			avgPayloadBytes:
+				values.durations.length > 0 ? Math.round(values.payloadBytes / values.durations.length) : 0,
+			summarizedCount: values.summarizedCount,
 		});
 	}
 
@@ -92,13 +125,13 @@ export function formatToolTimings(stats: ToolTimingStats[]): string {
 	if (stats.length === 0) return "No tool timing data found.";
 
 	const lines = [
-		"| Tool | Calls | Total (ms) | Avg (ms) | p50 (ms) | p95 (ms) | Max (ms) |",
-		"|------|-------|------------|----------|----------|----------|----------|",
+		"| Tool | Calls | Total (ms) | Avg (ms) | p50 (ms) | p95 (ms) | Max (ms) | Avg payload | Summarized |",
+		"|------|-------|------------|----------|----------|----------|----------|-------------|------------|",
 	];
 
 	for (const s of stats) {
 		lines.push(
-			`| ${s.name} | ${s.callCount} | ${s.totalMs} | ${s.avgMs} | ${s.p50Ms} | ${s.p95Ms} | ${s.maxMs} |`
+			`| ${s.name} | ${s.callCount} | ${s.totalMs} | ${s.avgMs} | ${s.p50Ms} | ${s.p95Ms} | ${s.maxMs} | ${formatBytes(s.avgPayloadBytes)} | ${s.summarizedCount} |`
 		);
 	}
 
@@ -281,7 +314,11 @@ export function formatEntries(entries: LogEntry[]): string {
 		const highlights: string[] = [];
 		if (data.name) highlights.push(`name=${data.name}`);
 		if (data.durationMs != null) highlights.push(`${data.durationMs}ms`);
+		if (typeof data.payloadBytes === "number") {
+			highlights.push(`payload=${formatBytes(Math.max(0, data.payloadBytes))}`);
+		}
 		if (data.ok !== undefined) highlights.push(data.ok ? "ok" : "FAILED");
+		if (data.summarizedByRetention === true) highlights.push("summarized");
 		if (data.message) highlights.push(`"${String(data.message).slice(0, 80)}"`);
 		if (data.agentId) highlights.push(`agent=${data.agentId}`);
 		if (data.exitCode !== undefined) highlights.push(`exit=${data.exitCode}`);

package/extensions/debug/index.ts

@@ -16,6 +16,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
+import { getTallowPath } from "../_shared/tallow-paths.js";
 import {
 	calculateTurnMetrics,
 	formatEntries,
@@ -35,19 +36,81 @@ let totalToolCalls = 0;
 let totalTurns = 0;
 let sessionStartTime = 0;
 
+/** Marker key set by sdk retention when historical results are summarized. */
+const TOOL_RESULT_RETENTION_MARKER = "__tallow_summarized_tool_result__";
+
+/** Payload metrics captured for each tool_result event. */
+interface ToolResultPayloadMetrics {
+	readonly contentLength: number;
+	readonly contentBytes: number;
+	readonly detailsBytes: number;
+	readonly imageBlocks: number;
+	readonly payloadBytes: number;
+	readonly summarizedByRetention: boolean;
+	readonly textBlocks: number;
+}
+
 /**
- * Safely extracts text content length from a tool result's content array.
- * @param content - Array of text/image content blocks
- * @returns Total character count of text blocks
+ * Estimate UTF-8 bytes for JSON-serializable data.
+ *
+ * @param value - Arbitrary data payload
+ * @returns Byte length of serialized data, or 0 on serialization failure
  */
-function contentLength(content: Array<{ type: string; text?: string }>): number {
-	let len = 0;
+function safeJsonBytes(value: unknown): number {
+	if (value == null) return 0;
+	try {
+		return Buffer.byteLength(JSON.stringify(value), "utf-8");
+	} catch {
+		return 0;
+	}
+}
+
+/**
+ * Measure text/image/details payload characteristics for a tool result.
+ *
+ * @param content - Tool result content blocks
+ * @param details - Tool result details payload
+ * @returns Structured payload metrics for debug logging
+ */
+function measureToolResultPayload(
+	content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>,
+	details: unknown
+): ToolResultPayloadMetrics {
+	let contentLength = 0;
+	let contentBytes = 0;
+	let imageBlocks = 0;
+	let textBlocks = 0;
+
 	for (const block of content) {
-		if (block.type === "text" && block.text) {
-			len += block.text.length;
+		if (block.type === "text") {
+			const text = block.text ?? "";
+			contentLength += text.length;
+			contentBytes += Buffer.byteLength(text, "utf-8");
+			textBlocks += 1;
+			continue;
+		}
+		if (block.type === "image") {
+			contentBytes += Buffer.byteLength(block.data ?? "", "utf-8");
+			contentBytes += Buffer.byteLength(block.mimeType ?? "", "utf-8");
+			imageBlocks += 1;
 		}
 	}
-	return len;
+
+	const detailsBytes = safeJsonBytes(details);
+	const summarizedByRetention =
+		typeof details === "object" &&
+		details !== null &&
+		(details as Record<string, unknown>)[TOOL_RESULT_RETENTION_MARKER] === true;
+
+	return {
+		contentLength,
+		contentBytes,
+		detailsBytes,
+		imageBlocks,
+		payloadBytes: contentBytes + detailsBytes,
+		summarizedByRetention,
+		textBlocks,
+	};
 }
 
 /**
@@ -256,12 +319,23 @@ export default function (pi: ExtensionAPI) {
 		const durationMs = startTime !== undefined ? Math.round(performance.now() - startTime) : null;
 		toolTimings.delete(event.toolCallId);
 
+		const payload = measureToolResultPayload(
+			event.content as Array<{ type: string; text?: string; data?: string; mimeType?: string }>,
+			event.details
+		);
+
 		logger.log("tool", "result", {
 			toolCallId: event.toolCallId,
 			name: event.toolName,
 			durationMs,
 			ok: !event.isError,
-			contentLength: contentLength(event.content as Array<{ type: string; text?: string }>),
+			contentLength: payload.contentLength,
+			contentBytes: payload.contentBytes,
+			detailsBytes: payload.detailsBytes,
+			payloadBytes: payload.payloadBytes,
+			textBlocks: payload.textBlocks,
+			imageBlocks: payload.imageBlocks,
+			summarizedByRetention: payload.summarizedByRetention,
 		});
 	});
 
@@ -501,7 +575,7 @@ export default function (pi: ExtensionAPI) {
 	 * @returns Absolute path to the debug log
 	 */
 	function getLogPath(): string {
-		return logger?.logPath ?? `${process.env.HOME}/.tallow/debug.log`;
+		return logger?.logPath ?? getTallowPath("debug.log");
 	}
 
 	/**

package/extensions/debug/logger.ts

@@ -18,8 +18,8 @@ import {
 	truncateSync,
 	writeFileSync,
 } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { getTallowHomeDir } from "../_shared/tallow-paths.js";
 
 /** Log entry categories that partition diagnostic output. */
 export type LogCategory =
@@ -238,7 +238,7 @@ export class DebugLogger {
 		logDir?: string
 	) {
 		this.useStderr = process.env.TALLOW_DEBUG === "stderr";
-		const dir = logDir ?? join(homedir(), ".tallow");
+		const dir = logDir ?? getTallowHomeDir();
 		this.logPath = join(dir, "debug.log");
 
 		if (!this.useStderr) {

package/extensions/health/index.ts

@@ -7,7 +7,6 @@
  */
 
 import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import type {
 	ContextUsage,
@@ -16,6 +15,7 @@ import type {
 	Theme,
 } from "@mariozechner/pi-coding-agent";
 import { BorderedBox, ROUNDED, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { getTallowHomeDir } from "../_shared/tallow-paths.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -580,7 +580,7 @@ export default function healthExtension(pi: ExtensionAPI): void {
 	const piVersion = readPackageVersion(
 		join(packageDir, "node_modules", "@mariozechner", "pi-coding-agent", "package.json")
 	);
-	const tallowHome = process.env.TALLOW_CODING_AGENT_DIR ?? join(homedir(), ".tallow");
+	const tallowHome = getTallowHomeDir();
 
 	// ── Message renderer ─────────────────────────────────────────────────
 

package/extensions/hooks/__tests__/claude-compat.test.ts

@@ -42,6 +42,35 @@ describe("translateClaudeHooks", () => {
 		expect(handler?._claudeEventName).toBe("PreToolUse");
 	});
 
+	it("translates worktree aliases and preserves scope matchers", () => {
+		const translated = translateClaudeHooks({
+			WorktreeCreate: [
+				{ matcher: "project|feature", hooks: [{ type: "command", command: "echo create" }] },
+			],
+			WorktreeRemove: [
+				{ matcher: "project", hooks: [{ type: "command", command: "echo remove" }] },
+			],
+		});
+
+		expect(translated.worktree_create).toHaveLength(1);
+		expect(translated.worktree_remove).toHaveLength(1);
+		expect(translated.worktree_create[0]?.matcher).toBe("project|feature");
+		expect(translated.worktree_remove[0]?.matcher).toBe("project");
+		expect(translated.worktree_remove[0]?.hooks[0]?._claudeEventName).toBe("WorktreeRemove");
+	});
+
+	it("translates worktree lifecycle aliases", () => {
+		const translated = translateClaudeHooks({
+			WorktreeCreate: [{ hooks: [{ type: "command", command: "echo create" }] }],
+			WorktreeRemove: [{ hooks: [{ type: "command", command: "echo remove" }] }],
+		});
+
+		expect(translated.worktree_create).toHaveLength(1);
+		expect(translated.worktree_remove).toHaveLength(1);
+		expect(translated.worktree_create[0]?.hooks[0]?._claudeEventName).toBe("WorktreeCreate");
+		expect(translated.worktree_remove[0]?.hooks[0]?._claudeEventName).toBe("WorktreeRemove");
+	});
+
 	it("skips PermissionRequest with a warning", () => {
 		const warnings: string[] = [];
 		const originalWarn = console.warn;
@@ -98,6 +127,8 @@ describe("translateClaudeHooks", () => {
 			Notification: "notification",
 			SubagentStart: "subagent_start",
 			SubagentStop: "subagent_stop",
+			WorktreeCreate: "worktree_create",
+			WorktreeRemove: "worktree_remove",
 			Stop: "agent_end",
 			TeammateIdle: "teammate_idle",
 			TaskCompleted: "task_completed",

package/extensions/hooks/extension.json

@@ -31,7 +31,9 @@
 			"tool_result",
 			"turn_end",
 			"turn_start",
-			"user_bash"
+			"user_bash",
+			"worktree_create",
+			"worktree_remove"
 		]
 	},
 	"permissionSurface": {

package/extensions/hooks/hooks.schema.json

@@ -107,6 +107,14 @@
 					"$ref": "#/$defs/eventHooks",
 					"description": "When a subagent completes. Matcher filters on agent_type."
 				},
+				"worktree_create": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "When a managed worktree is created. Matcher filters on scope (session/subagent)."
+				},
+				"worktree_remove": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "When a managed worktree is removed. Matcher filters on scope (session/subagent)."
+				},
 				"notification": {
 					"$ref": "#/$defs/eventHooks",
 					"description": "When a notification is emitted via the event bus. Matcher filters on type."
@@ -155,6 +163,14 @@
 					"$ref": "#/$defs/eventHooks",
 					"description": "Claude Code alias for subagent_stop."
 				},
+				"WorktreeCreate": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for worktree_create."
+				},
+				"WorktreeRemove": {
+					"$ref": "#/$defs/eventHooks",
+					"description": "Claude Code alias for worktree_remove."
+				},
 				"Stop": {
 					"$ref": "#/$defs/eventHooks",
 					"description": "Claude Code alias for agent_end."
@@ -196,7 +212,7 @@
 			"properties": {
 				"matcher": {
 					"type": "string",
-					"description": "Regex pattern to filter events. Empty or '*' matches all. For tool_call/tool_result, matches toolName."
+					"description": "Regex pattern to filter events. Empty or '*' matches all. Uses event-specific fields (for example: tool_call/tool_result=toolName, task_completed=assignee, teammate_idle=teammate, worktree_create/worktree_remove=scope)."
 				},
 				"hooks": {
 					"type": "array",

package/extensions/hooks/index.ts

@@ -37,6 +37,7 @@ import {
 } from "../../src/agent-runner.js";
 import { isProjectTrusted } from "../_shared/project-trust.js";
 import { evaluateCommand } from "../_shared/shell-policy.js";
+import { getTallowHomeDir, getTallowPath } from "../_shared/tallow-paths.js";
 import { createHookStateManager, type HookStateManager } from "./state-manager.js";
 
 /** Hook execution strategy: shell command, LLM prompt, or agent subprocess. */
@@ -304,6 +305,8 @@ const MATCHER_FIELDS: Record<string, string> = {
 	tool_result: "toolName",
 	teammate_idle: "teammate",
 	task_completed: "assignee",
+	worktree_create: "scope",
+	worktree_remove: "scope",
 	setup: "trigger",
 	subagent_start: "agent_type",
 	subagent_stop: "agent_type",
@@ -323,6 +326,8 @@ export const CLAUDE_EVENT_MAP: Readonly<Record<string, string>> = {
 	Notification: "notification",
 	SubagentStart: "subagent_start",
 	SubagentStop: "subagent_stop",
+	WorktreeCreate: "worktree_create",
+	WorktreeRemove: "worktree_remove",
 	Stop: "agent_end",
 	TeammateIdle: "teammate_idle",
 	TaskCompleted: "task_completed",
@@ -1129,10 +1134,24 @@ export default function (pi: ExtensionAPI) {
 		}
 	};
 
+	/**
+	 * Dispatches EventBus hook execution without blocking the publisher.
+	 *
+	 * @param eventName - Hook event name to execute
+	 * @param eventData - Event payload forwarded to hook matchers/handlers
+	 * @returns Nothing
+	 */
+	const dispatchEventBusHooks = (eventName: string, eventData: Record<string, unknown>): void => {
+		void runHooks(eventName, eventData).catch((error: unknown) => {
+			const message = error instanceof Error ? error.message : String(error);
+			console.error(`[hooks] EventBus dispatch failed for ${eventName}: ${message}`);
+		});
+	};
+
 	/** Forward teammate_idle events to hook handlers. */
 	const onTeammateIdle = (data: unknown) => {
 		const event = data as { team: string; teammate: string; role: string };
-		runHooks("teammate_idle", event);
+		dispatchEventBusHooks("teammate_idle", event);
 	};
 
 	/** Forward task_completed events to hook handlers. */
@@ -1144,7 +1163,7 @@ export default function (pi: ExtensionAPI) {
 			assignee: string;
 			result: string;
 		};
-		runHooks("task_completed", event);
+		dispatchEventBusHooks("task_completed", event);
 	};
 
 	/** Forward subagent_start events from EventBus to hook handlers. */
@@ -1156,7 +1175,7 @@ export default function (pi: ExtensionAPI) {
 			cwd: string;
 			background: boolean;
 		};
-		runHooks("subagent_start", event);
+		dispatchEventBusHooks("subagent_start", event);
 	};
 
 	/** Forward subagent_stop events from EventBus to hook handlers. */
@@ -1169,7 +1188,7 @@ export default function (pi: ExtensionAPI) {
 			result: string;
 			background: boolean;
 		};
-		runHooks("subagent_stop", event);
+		dispatchEventBusHooks("subagent_stop", event);
 	};
 
 	/** Forward notification events from EventBus to hook handlers. */
@@ -1179,7 +1198,29 @@ export default function (pi: ExtensionAPI) {
 			type: string;
 			source?: string;
 		};
-		runHooks("notification", event);
+		dispatchEventBusHooks("notification", event);
+	};
+
+	/**
+	 * Forward worktree_create events from EventBus to hook handlers.
+	 *
+	 * @param data - Event payload from EventBus
+	 * @returns Nothing
+	 */
+	const onWorktreeCreate = (data: unknown) => {
+		const event = data as Record<string, unknown>;
+		dispatchEventBusHooks("worktree_create", event);
+	};
+
+	/**
+	 * Forward worktree_remove events from EventBus to hook handlers without blocking.
+	 *
+	 * @param data - Event payload from EventBus
+	 * @returns Nothing
+	 */
+	const onWorktreeRemove = (data: unknown) => {
+		const event = data as Record<string, unknown>;
+		dispatchEventBusHooks("worktree_remove", event);
 	};
 
 	// ── Session lifecycle ────────────────────────────────────────
@@ -1188,10 +1229,10 @@ export default function (pi: ExtensionAPI) {
 		ctx = context;
 		currentCwd = context.cwd;
 		hooksConfig = loadHooksConfig(currentCwd);
-		agentsDir = path.join(process.env.HOME || "", ".tallow", "agents");
+		agentsDir = getTallowPath("agents");
 
 		// Initialize once-hook state manager
-		const tallowHome = path.join(process.env.HOME || "", ".tallow");
+		const tallowHome = getTallowHomeDir();
 		stateManager = createHookStateManager(tallowHome);
 
 		// Check for project-local agents dir
@@ -1215,6 +1256,8 @@ export default function (pi: ExtensionAPI) {
 		const unsub4 = pi.events.on("subagent_start", onSubagentStart);
 		const unsub5 = pi.events.on("subagent_stop", onSubagentStop);
 		const unsub6 = pi.events.on("notification", onNotification);
+		const unsub7 = pi.events.on("worktree_create", onWorktreeCreate);
+		const unsub8 = pi.events.on("worktree_remove", onWorktreeRemove);
 		G.__hooksEventCleanup = () => {
 			unsub1();
 			unsub2();
@@ -1222,6 +1265,8 @@ export default function (pi: ExtensionAPI) {
 			unsub4();
 			unsub5();
 			unsub6();
+			unsub7();
+			unsub8();
 		};
 
 		// Run setup hooks if triggered by --init, --init-only, or --maintenance CLI flags.

package/extensions/lsp/index.ts

@@ -13,7 +13,6 @@
 
 import { type ChildProcess, spawn } from "node:child_process";
 import * as fs from "node:fs";
-import { homedir } from "node:os";
 import * as path from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
@@ -41,6 +40,7 @@ import {
 	WorkspaceSymbolRequest,
 } from "vscode-languageserver-protocol";
 import { getIcon } from "../_icons/index.js";
+import { getTallowSettingsPath } from "../_shared/tallow-paths.js";
 
 /** Language server binary configuration and project detection markers. */
 interface ServerConfig {
@@ -280,12 +280,7 @@ function readStartupTimeoutFromSettings(settings: Record<string, unknown>): numb
  * @returns Absolute path to the user-level settings file
  */
 function getGlobalSettingsPath(): string {
-	const configuredAgentDir = process.env.TALLOW_CODING_AGENT_DIR ?? process.env.PI_CODING_AGENT_DIR;
-	if (typeof configuredAgentDir === "string" && configuredAgentDir.trim().length > 0) {
-		return path.join(configuredAgentDir, "settings.json");
-	}
-
-	return path.join(homedir(), ".tallow", "settings.json");
+	return getTallowSettingsPath();
 }
 
 /**

package/extensions/output-styles-tool/index.ts

@@ -18,6 +18,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { atomicWriteFileSync } from "../_shared/atomic-write.js";
+import { getTallowPath } from "../_shared/tallow-paths.js";
 import {
 	buildReminderContent,
 	buildStyledPrompt,
@@ -29,10 +30,7 @@ import {
 // ── Discovery ───────────────────────────────────────
 
 /** Standard locations for output style files */
-const USER_STYLES_DIR = path.join(
-	process.env.PI_CODING_AGENT_DIR || path.join(process.env.HOME || "", ".tallow"),
-	"output-styles"
-);
+const USER_STYLES_DIR = getTallowPath("output-styles");
 const PROJECT_STYLES_DIR = path.join(process.cwd(), ".tallow", "output-styles");
 
 /**

package/extensions/plan-mode-tool/extension.json

@@ -12,6 +12,7 @@
 			"context",
 			"session_start",
 			"tool_call",
+			"tool_result",
 			"turn_end"
 		]
 	},