@shanepadgett/tau-agent 0.39.1 → 0.40.0

package/extensions/cost-report/panel.ts

@@ -0,0 +1,64 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { getKeybindings, type Component, type TUI, truncateToWidth } from "@earendil-works/pi-tui";
+import { bindingHint, ToolPanel, type ToolPanelConfig } from "@shanepadgett/tau-tui";
+
+export class CostReportStatusPanel implements Component {
+	private readonly tui: TUI;
+	private readonly panel: ToolPanel;
+	private readonly config: ToolPanelConfig;
+	private readonly controller = new AbortController();
+	private readonly startedAt = Date.now();
+	private readonly timer: ReturnType<typeof setInterval>;
+	private status = "Starting…";
+	private readonly secondary: string;
+
+	constructor(tui: TUI, theme: Theme, secondary: string) {
+		this.tui = tui;
+		this.secondary = secondary;
+		this.config = {
+			title: "Cost report",
+			secondary,
+			body: {
+				render: (width) => [truncateToWidth(theme.fg("muted", this.status), width, "…")],
+				invalidate: () => {},
+			},
+			footer: { kind: "hints", hints: [bindingHint("tui.select.cancel", "cancel")] },
+			border: "box",
+		};
+		this.panel = new ToolPanel(theme, this.config);
+		this.timer = setInterval(() => this.tui.requestRender(), 1_000);
+		this.timer.unref();
+	}
+
+	get signal(): AbortSignal {
+		return this.controller.signal;
+	}
+
+	handleInput(data: string): void {
+		if (!getKeybindings().matches(data, "tui.select.cancel")) return;
+		if (this.controller.signal.aborted) return;
+		this.update("Cancelling…");
+		this.controller.abort();
+	}
+
+	update(status: string): void {
+		this.status = status.trim() || this.status;
+		this.tui.requestRender();
+	}
+
+	render(width: number): string[] {
+		const elapsed = Math.floor((Date.now() - this.startedAt) / 1_000);
+		const clock = elapsed < 60 ? `${elapsed}s` : `${Math.floor(elapsed / 60)}m ${elapsed % 60}s`;
+		this.config.title = `Cost report · ${clock}`;
+		this.config.secondary = this.secondary;
+		return this.panel.render(width);
+	}
+
+	invalidate(): void {
+		this.panel.invalidate();
+	}
+
+	dispose(): void {
+		clearInterval(this.timer);
+	}
+}

package/extensions/cost-report/range.ts

@@ -0,0 +1,145 @@
+import type { LiveRangeKind, ReportRange } from "./types.ts";
+
+const MONTH_LABELS = [
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December",
+] as const;
+
+export const LIVE_RANGE_CHOICES: ReadonlyArray<{ id: LiveRangeKind | "specific-month"; label: string }> = [
+	{ id: "past-7-days", label: "Past 7 days" },
+	{ id: "current-week", label: "Current week" },
+	{ id: "current-month", label: "Current month" },
+	{ id: "year-to-date", label: "Year to date" },
+	{ id: "specific-month", label: "Specific month…" },
+];
+
+export const MONTH_CHOICES: ReadonlyArray<{ month: number; label: string }> = MONTH_LABELS.map((label, month) => ({
+	month,
+	label,
+}));
+
+export function yearChoices(now = new Date()): number[] {
+	const current = now.getFullYear();
+	return Array.from({ length: 6 }, (_, index) => current - index);
+}
+
+export function liveRange(kind: LiveRangeKind, now = new Date()): ReportRange {
+	const endMs = now.getTime();
+	if (kind === "past-7-days") {
+		const start = startOfLocalDay(now);
+		start.setDate(start.getDate() - 6);
+		// Slides daily; slug pins the window end day so same-day reopens match.
+		return {
+			kind,
+			label: "Past 7 days",
+			slug: `7d-${localDateKey(endMs)}`,
+			startMs: start.getTime(),
+			endMs,
+			layout: "row",
+		};
+	}
+	if (kind === "current-week") {
+		const start = startOfLocalDay(now);
+		const day = start.getDay(); // 0 Sun … 6 Sat
+		const mondayOffset = day === 0 ? -6 : 1 - day;
+		start.setDate(start.getDate() + mondayOffset);
+		return {
+			kind,
+			label: "Current week",
+			slug: `week-${localDateKey(start.getTime())}`,
+			startMs: start.getTime(),
+			endMs,
+			layout: "row",
+		};
+	}
+	if (kind === "current-month") {
+		const start = new Date(now.getFullYear(), now.getMonth(), 1);
+		const ym = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+		return {
+			kind,
+			label: "Current month",
+			slug: `month-${ym}`,
+			startMs: start.getTime(),
+			endMs,
+			layout: "row",
+			year: now.getFullYear(),
+			month: now.getMonth(),
+		};
+	}
+	const start = new Date(now.getFullYear(), 0, 1);
+	return {
+		kind,
+		label: "Year to date",
+		slug: `ytd-${now.getFullYear()}`,
+		startMs: start.getTime(),
+		endMs,
+		layout: "ytd",
+		year: now.getFullYear(),
+	};
+}
+
+export function specificMonthRange(year: number, month: number, now = new Date()): ReportRange {
+	const start = new Date(year, month, 1);
+	const endExclusive = new Date(year, month + 1, 1);
+	const endMs = Math.min(now.getTime(), endExclusive.getTime() - 1);
+	const monthLabel = MONTH_LABELS[month] ?? `Month ${month + 1}`;
+	const ym = `${year}-${String(month + 1).padStart(2, "0")}`;
+	return {
+		kind: "specific-month",
+		label: `${monthLabel} ${year}`,
+		slug: ym,
+		startMs: start.getTime(),
+		endMs,
+		layout: "row",
+		year,
+		month,
+	};
+}
+
+export function startOfLocalDay(date: Date): Date {
+	return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+
+export function localDateKey(timestampMs: number): string {
+	const date = new Date(timestampMs);
+	const y = date.getFullYear();
+	const m = String(date.getMonth() + 1).padStart(2, "0");
+	const d = String(date.getDate()).padStart(2, "0");
+	return `${y}-${m}-${d}`;
+}
+
+export function shortDateLabel(timestampMs: number): string {
+	const date = new Date(timestampMs);
+	const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+	return `${date.getDate()} ${months[date.getMonth()]}`;
+}
+
+export function isWeekend(timestampMs: number): boolean {
+	const day = new Date(timestampMs).getDay();
+	return day === 0 || day === 6;
+}
+
+export function eachLocalDay(startMs: number, endMs: number): number[] {
+	const days: number[] = [];
+	const cursor = startOfLocalDay(new Date(startMs));
+	const end = startOfLocalDay(new Date(endMs));
+	while (cursor.getTime() <= end.getTime()) {
+		days.push(cursor.getTime());
+		cursor.setDate(cursor.getDate() + 1);
+	}
+	return days;
+}
+
+export function daysInMonth(year: number, month: number): number {
+	return new Date(year, month + 1, 0).getDate();
+}

package/extensions/cost-report/types.ts

@@ -0,0 +1,93 @@
+export type ReportScope = "project" | "all";
+
+export type LiveRangeKind = "past-7-days" | "current-week" | "current-month" | "year-to-date";
+
+export type RangeKind = LiveRangeKind | "specific-month";
+
+export interface ReportRange {
+	kind: RangeKind;
+	label: string;
+	slug: string;
+	startMs: number;
+	endMs: number;
+	/** Single full-width day row vs one row per month (YTD). */
+	layout: "row" | "ytd";
+	year?: number;
+	month?: number; // 0-11
+}
+
+export interface CostTotals {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	totalTokens: number;
+	cost: number;
+}
+
+export interface ModelCost {
+	key: string;
+	provider: string;
+	model: string;
+	cost: number;
+	tokens: number;
+	sessions: number;
+}
+
+export interface SubagentCost {
+	agent: string;
+	cost: number;
+	calls: number;
+}
+
+export interface ProjectCost {
+	key: string;
+	label: string;
+	cost: number;
+	sessions: number;
+	tokens: number;
+}
+
+export interface SessionModelCost {
+	key: string;
+	label: string;
+	cost: number;
+}
+
+export interface SessionCost {
+	id: string;
+	path: string;
+	name: string;
+	projectKey: string;
+	projectLabel: string;
+	startedAtMs: number;
+	cost: number;
+	tokens: number;
+	models: SessionModelCost[];
+}
+
+export interface DayCost {
+	dateKey: string; // YYYY-MM-DD local
+	label: string;
+	timestampMs: number;
+	cost: number;
+	weekend: boolean;
+}
+
+export interface CostReport {
+	generatedAtMs: number;
+	cwd: string;
+	scope: ReportScope;
+	range: ReportRange;
+	directCost: number;
+	subagentCost: number;
+	totalCost: number;
+	totalTokens: number;
+	sessionCount: number;
+	projectCount: number;
+	days: DayCost[];
+	models: ModelCost[];
+	subagents: SubagentCost[];
+	projects: ProjectCost[];
+	sessions: SessionCost[];
+}

package/extensions/silent-command-runner/README.md

@@ -23,3 +23,5 @@ Configure it in Tau settings under `extensions.silentCommandRunner`:
 ```
 
 Passes are notifications only. Failures are shown in chat and sent to the agent. Tau's ready-for-input notification waits for these checks and stays quiet when a failure starts another agent turn.
+
+When auto-compact pauses a long run to compact context, checks wait until that work chain finishes. They do not run on the compact abort, and file changes from before the compact still count.

package/extensions/silent-command-runner/index.ts

@@ -2,7 +2,7 @@ import { readdir, stat } from "node:fs/promises";
 import { resolve } from "node:path";
 import { type ExecResult, type ExtensionAPI, keyText, type Theme } from "@earendil-works/pi-coding-agent";
 import { Box, Text } from "@earendil-works/pi-tui";
-import { emitTauEvent } from "../../shared/events.ts";
+import { emitTauEvent, onTauEvent } from "../../shared/events.ts";
 import { matchGlob, posixPath } from "../../shared/glob.ts";
 import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
 import { resolveProjectRoot } from "../../shared/settings/paths.ts";
@@ -84,11 +84,40 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 	let chainActive = false;
 	let attentionHoldSequence = 0;
 	let attentionHoldId: string | undefined;
+	const checkPauses = new Set<string>();
+	let settleDeferred = false;
+
+	function checksPaused(): boolean {
+		return checkPauses.size > 0;
+	}
+
+	function finalizeChain(): void {
+		settleDeferred = false;
+		chainActive = false;
+		const holdId = attentionHoldId;
+		attentionHoldId = undefined;
+		if (holdId) emitTauEvent(pi, "tau:attention.hold.release", { id: holdId, disposition: "notify" });
+	}
 
 	pi.registerMessageRenderer<FailureDetails>(MESSAGE_TYPE, (message, { expanded }, theme) =>
 		renderFailure(asFailureDetails(message.details), expanded, theme),
 	);
 
+	onTauEvent(pi, "silent-command-runner.pause", "tau:silent-command-runner.pause", ({ id }) => {
+		checkPauses.add(id);
+	});
+
+	onTauEvent(pi, "silent-command-runner.resume", "tau:silent-command-runner.resume", ({ id, disposition }) => {
+		checkPauses.delete(id);
+		if (checksPaused()) return;
+		if (disposition === "continue") {
+			// Compact will start a new agent run on the same work chain; keep baseline + hold.
+			settleDeferred = false;
+			return;
+		}
+		if (settleDeferred || chainActive) finalizeChain();
+	});
+
 	pi.on("session_start", async (_event, ctx) => {
 		settings = normalizeSettings(await loadTauExtensionSettings(ctx, silentCommandRunnerSettings));
 		sessionActive = true;
@@ -97,6 +126,8 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 		chainActive = false;
 		attentionHoldSequence = 0;
 		attentionHoldId = undefined;
+		checkPauses.clear();
+		settleDeferred = false;
 	});
 
 	pi.on("before_agent_start", async (event, ctx) => {
@@ -108,20 +139,24 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 	pi.on("agent_start", async (_event, ctx) => {
 		const startingChain = !chainActive;
 		chainActive = true;
-		turnStart = Date.now();
+		settleDeferred = false;
 		if (!settings.enabled || settings.commands.length === 0) {
-			turnPaths = new Set();
+			if (startingChain) {
+				turnStart = Date.now();
+				turnPaths = new Set();
+			}
 			return;
 		}
-		if (startingChain) {
-			attentionHoldId = `silent-command-runner:${++attentionHoldSequence}`;
-			emitTauEvent(pi, "tau:attention.hold.acquire", { id: attentionHoldId });
-		}
+		if (!startingChain) return;
+		attentionHoldId = `silent-command-runner:${++attentionHoldSequence}`;
+		emitTauEvent(pi, "tau:attention.hold.acquire", { id: attentionHoldId });
+		turnStart = Date.now();
 		const projectRoot = await resolveProjectRoot(ctx.cwd);
 		turnPaths = new Set(await walkFiles(projectRoot));
 	});
 
 	pi.on("agent_end", async (event, ctx) => {
+		if (checksPaused()) return;
 		if (hasAbortedAssistantMessage(event.messages)) return;
 		try {
 			await runChangedCommands(ctx.cwd, turnStart, ctx.ui.notify);
@@ -131,10 +166,12 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 	});
 
 	pi.on("agent_settled", () => {
-		chainActive = false;
-		const holdId = attentionHoldId;
-		attentionHoldId = undefined;
-		if (holdId) emitTauEvent(pi, "tau:attention.hold.release", { id: holdId, disposition: "notify" });
+		if (checksPaused()) {
+			// Compact aborted this run; keep chain + file baseline until resume.
+			settleDeferred = true;
+			return;
+		}
+		finalizeChain();
 	});
 
 	pi.on("session_shutdown", () => {
@@ -144,6 +181,8 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 		turnPaths = new Set();
 		chainActive = false;
 		attentionHoldId = undefined;
+		checkPauses.clear();
+		settleDeferred = false;
 	});
 
 	async function collectCommandFailures(

package/extensions/tau-help/help.md

@@ -40,6 +40,10 @@ Adds `/clear-screen` to clear terminal output without changing the session.
 
 Adds `/commit` for semantic commit grouping, review, and committing selected repository changes.
 
+## cost-report
+
+Adds `/cost-report` to build an HTML spend report from local session usage. Pick a time frame (past 7 days, current week, current month, year to date, or a specific month) and scope (current project or all sessions). Tau scans sessions, writes under `~/.pi/tau/cost-reports/`, opens the file, and notifies with the path. Empty windows warn without writing a file.
+
 ## context
 
 Adds `/context` to inject reusable repository work scopes from `.pi/contexts`, and `/context-sync` or `/context-sync <nudge>` for human-driven catalog sync. Selecting entries injects them once into the conversation: `read` paths as complete files, `show` targets as current declaration slices, `outline` paths as Explore structures, and one hidden note listing `references` plus instructions to treat the injected material as current. Run `/context` again to inject more. Manual sync replaces the editor with a status panel; Escape or Ctrl+C cancels. When `sync.automation` is on, coding agent can also run `context-sync` after meaningful uncommitted work. Sync catalogs durable code and long-lived documentation; recurring scratch, planning, interview, and rough-idea paths belong in `validation.ignoreGlobs`. `sync.enabled` is master switch for command, automation, and validation auto-run. Context validation is off by default; when on (and sync enabled), Tau auto-runs context-sync on failure. Domain folders are `NN_slug` tabs (ordered by the two-digit prefix; UI shows the slug), TOML files are concepts, and TOML sections are selectable entries.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shanepadgett/tau-agent",
-	"version": "0.39.1",
+	"version": "0.40.0",
 	"description": "Tau is a custom agentic harness built with pi extensions",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -35,7 +35,7 @@
 	],
 	"dependencies": {
 		"@ast-grep/wasm": "0.45.1",
-		"@shanepadgett/tau-tui": "0.39.1",
+		"@shanepadgett/tau-tui": "0.40.0",
 		"@vscode/tree-sitter-wasm": "0.3.1",
 		"image-size": "2.0.2",
 		"smol-toml": "1.8.0",

package/shared/events.ts

@@ -16,6 +16,15 @@ export type TauAgentEvents = {
 		id: string;
 		disposition: "notify" | "discard";
 	};
+	/** Pause silent post-edit checks across a compact that will resume the same work chain. */
+	"tau:silent-command-runner.pause": {
+		id: string;
+	};
+	/** End a silent-check pause. continue keeps the chain open; settle finalizes a deferred settle. */
+	"tau:silent-command-runner.resume": {
+		id: string;
+		disposition: "continue" | "settle";
+	};
 	"tau:file-mutation.applied": {
 		source: "patch";
 		toolCallId: string;