@shanepadgett/tau-agent 0.37.0 → 0.39.0

package/docs/context.md

@@ -15,7 +15,7 @@ The catalog has three levels:
 - **Concept**: a coherent subsystem or capability inside a domain. Each concept is one TOML file.
 - **Entry**: a selectable work scope inside that concept. Each TOML section defines one entry.
 
-Domain slugs (after `NN_`), concept filenames, and entry section names use lowercase kebab-case. Orders are contiguous from `01` with no gaps or duplicate slugs. Entry ids use the slug (`extensions/checkpoint/checkpoint-tool`), not the folder prefix.
+Domain slugs (after `NN_`), concept filenames, and entry section names use lowercase kebab-case. Orders are contiguous from `01` with no gaps or duplicate slugs. Entry ids use the slug (`extensions/patch/parse`), not the folder prefix.
 
 ```toml
 name = "Checkout"
@@ -42,7 +42,7 @@ Saved as `.pi/contexts/01_commerce/checkout.toml`, these entries have the IDs `c
 
 ## Build a useful taxonomy
 
-Each entry is a **work pack**: enough primary material that selecting only that entry lets an agent start one recurring job with little search. Taxonomy groups packs; it is not a file index. Gold-standard example: `.pi/contexts/01_extensions/checkpoint.toml`.
+Each entry is a **work pack**: enough primary material that selecting only that entry lets an agent start one recurring job with little search. Taxonomy groups packs; it is not a file index. Gold-standard example: `.pi/contexts/01_extensions/patch.toml`.
 
 Classify from the top down:
 

package/extensions/attention/README.md

@@ -1,12 +1,13 @@
 # Attention
 
-Sends a terminal-driven attention notification when Tau is ready for input, finishes compacting a session, or summarizes an abandoned branch during tree navigation.
+Sends a terminal-driven attention notification when Tau is ready for input, finishes a compaction without an automatic continuation, or summarizes an abandoned branch during tree navigation.
 
 ## Behavior
 
 - Emits an attention notification after the agent settles with no automatic continuation pending.
 - Waits for automatic post-turn checks before deciding whether the agent is ready for input.
-- Emits an attention notification on `session_compact`.
+- Emits an attention notification on `session_compact` unless another extension has an active attention hold.
+- Defers settlement and compaction notifications while an attention hold is active.
 - Emits an attention notification on `session_tree` when it includes a branch summary.
 - Listens for shared event `tau:agent.blocked` when Tau is waiting on user input.
 - Uses the terminal or host OS notification path that best fits the current environment.

package/extensions/attention/index.ts

@@ -104,7 +104,7 @@ export default function attentionExtension(pi: ExtensionAPI): void {
 	});
 
 	pi.on("session_compact", (_event, ctx) => {
-		if (ctx.mode === "print") return;
+		if (ctx.mode === "print" || holds.size > 0) return;
 		notify({ title: DEFAULT_TITLE, body: COMPACTION_BODY });
 	});
 

package/extensions/auto-compact/README.md

@@ -0,0 +1,9 @@
+# Auto Compact
+
+Compacts long conversations before the next model turn when their context reaches an absolute token limit. Active work resumes through a hidden continuation message after Pi's native compaction finishes.
+
+Set `extensions.autoCompact.tokenLimit` to change the limit. It defaults to 175,000 context tokens for every model. Pi still shows its native collapsed compaction entry in the chat.
+
+After changing this extension, run `/reload` before testing it.
+
+Automatic compaction holds attention notifications while it runs and while the hidden continuation resumes the interrupted work. The notification is released only after that resumed work settles.

package/extensions/auto-compact/index.ts

@@ -0,0 +1,100 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
+import { emitTauEvent } from "../../shared/events.ts";
+import autoCompactSettings, { DEFAULT_AUTO_COMPACT_TOKEN_LIMIT } from "./settings.ts";
+
+const CONTINUATION_TYPE = "tau.auto-compact";
+const CONTINUATION_MESSAGE =
+	"Continue the current work directly from the compacted context. Do not mention compaction or wait for user input.";
+
+export default function autoCompactExtension(pi: ExtensionAPI): void {
+	let tokenLimit = DEFAULT_AUTO_COMPACT_TOKEN_LIMIT;
+	let armed = true;
+	let compacting = false;
+	let sessionVersion = 0;
+	let attentionHoldSequence = 0;
+	let attentionHoldId: string | undefined;
+	let continuationPending = false;
+
+	function releaseAttentionHold(disposition: "notify" | "discard"): void {
+		const holdId = attentionHoldId;
+		attentionHoldId = undefined;
+		if (holdId) emitTauEvent(pi, "tau:attention.hold.release", { id: holdId, disposition });
+	}
+
+	pi.on("session_start", async (_event, ctx) => {
+		const version = ++sessionVersion;
+		const settings = await loadTauExtensionSettings(ctx, autoCompactSettings);
+		if (version !== sessionVersion) return;
+		tokenLimit = settings.tokenLimit;
+		armed = true;
+		compacting = false;
+		attentionHoldSequence = 0;
+		attentionHoldId = undefined;
+		continuationPending = false;
+	});
+	pi.on("session_shutdown", () => {
+		sessionVersion++;
+		armed = true;
+		compacting = false;
+		attentionHoldId = undefined;
+		continuationPending = false;
+	});
+	pi.on("session_tree", () => {
+		armed = true;
+	});
+	pi.on("session_compact", () => {
+		armed = false;
+	});
+	pi.on("agent_settled", () => {
+		if (!continuationPending) return;
+		continuationPending = false;
+		releaseAttentionHold("notify");
+	});
+	pi.on("turn_start", (_event, ctx) => {
+		if (compacting) return;
+
+		const tokens = ctx.getContextUsage()?.tokens;
+		if (tokens === undefined || tokens === null) return;
+		if (tokens < tokenLimit) {
+			armed = true;
+			return;
+		}
+		if (!armed) return;
+
+		armed = false;
+		compacting = true;
+		if (ctx.mode !== "print") {
+			attentionHoldId = `auto-compact:${++attentionHoldSequence}`;
+			emitTauEvent(pi, "tau:attention.hold.acquire", { id: attentionHoldId });
+		}
+		const version = sessionVersion;
+		const continueWork = (): void => {
+			if (version !== sessionVersion) return;
+			compacting = false;
+			continuationPending = true;
+			pi.sendMessage(
+				{
+					customType: CONTINUATION_TYPE,
+					content: CONTINUATION_MESSAGE,
+					display: false,
+					details: { v: 1, kind: "auto-compact.continuation", source: "auto-compact" },
+				},
+				{ triggerTurn: true },
+			);
+		};
+
+		ctx.compact({
+			onComplete: continueWork,
+			onError: (error) => {
+				if (version !== sessionVersion) return;
+				compacting = false;
+				if (error.name === "AbortError" || error.message === "Compaction cancelled") {
+					releaseAttentionHold("notify");
+					return;
+				}
+				continueWork();
+			},
+		});
+	});
+}

package/extensions/auto-compact/settings.ts

@@ -0,0 +1,21 @@
+import { Type } from "typebox";
+import { defineTauExtensionSettings } from "../../shared/settings/define.ts";
+
+export const DEFAULT_AUTO_COMPACT_TOKEN_LIMIT = 175_000;
+
+export default defineTauExtensionSettings({
+	key: "autoCompact",
+	defaults: {
+		tokenLimit: DEFAULT_AUTO_COMPACT_TOKEN_LIMIT,
+	},
+	schema: Type.Object(
+		{
+			tokenLimit: Type.Integer({
+				minimum: 1,
+				default: DEFAULT_AUTO_COMPACT_TOKEN_LIMIT,
+				description: "Absolute context-token count that triggers compaction before the next model turn.",
+			}),
+		},
+		{ additionalProperties: false },
+	),
+});

package/extensions/cache-diagnostics/index.ts

@@ -483,7 +483,7 @@ export default function cacheDiagnosticsExtension(pi: ExtensionAPI): void {
 	);
 	pi.on("session_tree", () => addMarker("session-tree"));
 	pi.on("tool_execution_end", (event) => {
-		if (event.toolName !== "checkpoint" && event.toolName !== "load_tools") return;
+		if (event.toolName !== "load_tools") return;
 		return addMarker("cache-affecting-tool", { tool: event.toolName, isError: event.isError });
 	});
 }

package/extensions/commit/README.md

@@ -10,6 +10,6 @@ Generate a semantic commit plan from current repository changes, review it, then
 
 ## Overview
 
-`/commit` looks at staged, unstaged, and untracked files, gathers bounded change evidence, and asks a model for a small set of meaningful conventional commits. You can review the plan in the TUI, edit messages, move files between commits, regenerate messages, and then commit the approved groups.
+`/commit` takes over the editor for the full run. It gathers change evidence, asks a model for a small set of meaningful conventional commits, lets you review and edit the plan, commits the approved groups, then asks whether to run `git push`.
 
-Unassigned files are left uncommitted. After successful commits, Tau asks whether to run `git push`.
+Unassigned files are left uncommitted. Progress and prompts stay in the commit panel until the flow ends; success still uses the normal notify messages.

package/extensions/commit/commit-plan.ts

@@ -45,11 +45,16 @@ interface CommitPlanToolCommit {
 	files: readonly number[];
 }
 
+export interface CommitGenerationOptions {
+	onStatus?: (status: string) => void | Promise<void>;
+}
+
 export async function generatePlan(
 	ctx: ExtensionCommandContext,
 	evidence: CommitEvidence,
 	previousPlan: readonly CommitGroup[] = [],
 	regenerationNote = "",
+	options?: CommitGenerationOptions,
 ): Promise<CommitGroup[]> {
 	const prompt = buildPlanPrompt(evidence, previousPlan, regenerationNote);
 	return generateToolValidated(
@@ -68,7 +73,11 @@ export async function generatePlan(
 				"Previous response:",
 				text,
 			].join("\n"),
-		{ statusKey: "commit", notifyOnFallback: true },
+		{
+			statusKey: options?.onStatus ? undefined : "commit",
+			onStatus: options?.onStatus,
+			notifyOnFallback: true,
+		},
 	);
 }
 
@@ -79,6 +88,7 @@ export async function regenerateMessage(
 	previousPlan: readonly CommitGroup[] = [],
 	selectedGroupId: string | undefined = undefined,
 	regenerationNote = "",
+	options?: CommitGenerationOptions,
 ): Promise<string> {
 	const selected = evidence.files.filter((file) => files.includes(file.path));
 	const prompt = buildMessagePrompt(evidence, selected, previousPlan, selectedGroupId, regenerationNote);
@@ -89,7 +99,8 @@ export async function regenerateMessage(
 		requireCommitMessage,
 		undefined,
 		{
-			statusKey: "commit",
+			statusKey: options?.onStatus ? undefined : "commit",
+			onStatus: options?.onStatus,
 			notifyOnFallback: true,
 		},
 	);

package/extensions/commit/index.ts

@@ -1,40 +1,21 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { emitAgentBlocked } from "../../shared/agent-blocked.ts";
-import { createGitRunner, type GitRunner, loadRepoStatus } from "../../shared/git.ts";
+import { createGitRunner, loadRepoStatus } from "../../shared/git.ts";
 import { errorText } from "../../shared/text.ts";
 import { type CommitPlanState, generatePlan } from "./commit-plan.ts";
-import {
-	assertCommittableState,
-	commitStaged,
-	computeWorktreeSignature,
-	type DirtyFile,
-	loadChangeSet,
-	stageFilesOnly,
-} from "./git-change-set.ts";
-import { reviewPlan } from "./review-ui.ts";
+import { assertCommittableState, computeWorktreeSignature, loadChangeSet } from "./git-change-set.ts";
+import { executeCommitPlan, PartialCommitError, runCommitFlow } from "./review-ui.ts";
 
 const COMMIT_MARKER_TYPE = "tau.commit";
-const PUSH_TIMEOUT_MS = 120_000;
-
-interface CommitMarker {
-	hash: string;
-	subject: string;
-	timestamp: number;
-}
 
 export default function commitExtension(pi: ExtensionAPI): void {
 	pi.registerCommand("commit", {
 		description: "Generate semantic commit groups and commit selected repository changes",
 		handler: async (_args, ctx) => {
 			await ctx.waitForIdle();
-			ctx.ui.setStatus("commit", "preparing commit plan");
-
 			try {
 				await runCommit(pi, ctx);
 			} catch (error) {
 				ctx.ui.notify(`Commit failed: ${errorText(error)}`, "error");
-			} finally {
-				ctx.ui.setStatus("commit", undefined);
 			}
 		},
 	});
@@ -56,83 +37,35 @@ async function runCommit(pi: ExtensionAPI, ctx: ExtensionCommandContext): Promis
 		return;
 	}
 
+	if (ctx.hasUI) {
+		await runCommitFlow(pi, ctx, git, repo.root, COMMIT_MARKER_TYPE);
+		return;
+	}
+
 	const evidence = await loadChangeSet(git, repo.root, ctx.sessionManager.getBranch(), COMMIT_MARKER_TYPE);
 	assertCommittableState(evidence.files);
-	let state: CommitPlanState = {
+	const state: CommitPlanState = {
 		files: evidence.files,
 		worktreeSignature: await computeWorktreeSignature(git, repo.root, evidence.files),
 		groups: await generatePlan(ctx, evidence),
 	};
-
-	if (ctx.hasUI) {
-		emitAgentBlocked(pi, { body: "Waiting for commit plan review", source: "commit.review" });
-		const reviewed = await reviewPlan(ctx, git, repo.root, evidence, state, state.groups[0]?.id, COMMIT_MARKER_TYPE);
-		if (!reviewed) return;
-		state = reviewed;
-	}
-
-	const completed = await executePlan(pi, ctx, git, repo.root, state);
-	if (completed.length === 0) return;
-
-	if (ctx.hasUI && (await ctx.ui.confirm("Push after commits?", "Run `git push` after all commits succeeded?"))) {
-		ctx.ui.setStatus("commit", "pushing");
-		await git.run(["push"], { cwd: repo.root, timeout: PUSH_TIMEOUT_MS });
+	try {
+		const completed = await executeCommitPlan(pi, git, repo.root, state, COMMIT_MARKER_TYPE);
+		if (completed.length === 0) {
+			ctx.ui.notify("No commit groups to execute.", "info");
+			return;
+		}
 		ctx.ui.notify(
-			`Committed and pushed ${completed.length} commit(s): ${completed.map((item) => item.hash).join(", ")}`,
+			`Committed ${completed.length} commit(s): ${completed.map((item) => item.hash).join(", ")}`,
 			"info",
 		);
-		return;
-	}
-
-	ctx.ui.notify(`Committed ${completed.length} commit(s): ${completed.map((item) => item.hash).join(", ")}`, "info");
-}
-
-async function executePlan(
-	pi: ExtensionAPI,
-	ctx: ExtensionCommandContext,
-	git: GitRunner,
-	root: string,
-	state: CommitPlanState,
-): Promise<CommitMarker[]> {
-	const groups = state.groups.filter((group) => group.files.length > 0);
-	if (groups.length === 0) {
-		ctx.ui.notify("No commit groups to execute.", "info");
-		return [];
-	}
-
-	if ((await computeWorktreeSignature(git, root, state.files)) !== state.worktreeSignature) {
-		throw new Error("Working tree changed during commit review. Regenerate the commit plan and try again.");
-	}
-
-	const filesByPath = new Map(state.files.map((file) => [file.path, file]));
-	const completed: CommitMarker[] = [];
-	try {
-		for (const group of groups) {
-			const subject = group.message.split("\n")[0] ?? group.message;
-			ctx.ui.setStatus("commit", `committing ${subject}`);
-			await stageFilesOnly(
-				git,
-				root,
-				group.files.flatMap((path) => knownFile(filesByPath, path)),
-			);
-			const hash = await commitStaged(git, root, group.message);
-			const marker = { hash, subject, timestamp: Date.now() };
-			completed.push(marker);
-			pi.appendEntry<CommitMarker>(COMMIT_MARKER_TYPE, marker);
-		}
 	} catch (error) {
-		if (completed.length > 0) {
+		if (error instanceof PartialCommitError) {
 			ctx.ui.notify(
-				`Partially committed ${completed.length}: ${completed.map((item) => item.hash).join(", ")}; then failed: ${errorText(error)}`,
+				`Partially committed ${error.completed.length}: ${error.completed.map((item) => item.hash).join(", ")}; then failed: ${error.message}`,
 				"warning",
 			);
 		}
 		throw error;
 	}
-	return completed;
-}
-
-function knownFile(filesByPath: ReadonlyMap<string, DirtyFile>, path: string): DirtyFile[] {
-	const file = filesByPath.get(path);
-	return file ? [file] : [];
 }