@shanepadgett/tau-agent 0.39.1 → 0.39.2

package/extensions/auto-compact/README.md

@@ -6,4 +6,4 @@ Set `extensions.autoCompact.tokenLimit` to change the limit. It defaults to 175,
 
 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.
+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. It also pauses silent post-edit checks across the compact so they do not run on incomplete work.

package/extensions/auto-compact/index.ts

@@ -14,6 +14,7 @@ export default function autoCompactExtension(pi: ExtensionAPI): void {
 	let sessionVersion = 0;
 	let attentionHoldSequence = 0;
 	let attentionHoldId: string | undefined;
+	let silentCheckPauseId: string | undefined;
 	let continuationPending = false;
 
 	function releaseAttentionHold(disposition: "notify" | "discard"): void {
@@ -22,6 +23,18 @@ export default function autoCompactExtension(pi: ExtensionAPI): void {
 		if (holdId) emitTauEvent(pi, "tau:attention.hold.release", { id: holdId, disposition });
 	}
 
+	function pauseSilentChecks(): void {
+		if (silentCheckPauseId) return;
+		silentCheckPauseId = `auto-compact:${++attentionHoldSequence}`;
+		emitTauEvent(pi, "tau:silent-command-runner.pause", { id: silentCheckPauseId });
+	}
+
+	function resumeSilentChecks(disposition: "continue" | "settle"): void {
+		const pauseId = silentCheckPauseId;
+		silentCheckPauseId = undefined;
+		if (pauseId) emitTauEvent(pi, "tau:silent-command-runner.resume", { id: pauseId, disposition });
+	}
+
 	pi.on("session_start", async (_event, ctx) => {
 		const version = ++sessionVersion;
 		const settings = await loadTauExtensionSettings(ctx, autoCompactSettings);
@@ -31,6 +44,7 @@ export default function autoCompactExtension(pi: ExtensionAPI): void {
 		compacting = false;
 		attentionHoldSequence = 0;
 		attentionHoldId = undefined;
+		silentCheckPauseId = undefined;
 		continuationPending = false;
 	});
 	pi.on("session_shutdown", () => {
@@ -38,6 +52,7 @@ export default function autoCompactExtension(pi: ExtensionAPI): void {
 		armed = true;
 		compacting = false;
 		attentionHoldId = undefined;
+		silentCheckPauseId = undefined;
 		continuationPending = false;
 	});
 	pi.on("session_tree", () => {
@@ -64,6 +79,8 @@ export default function autoCompactExtension(pi: ExtensionAPI): void {
 
 		armed = false;
 		compacting = true;
+		// Pause before compact: compact aborts the agent, and that agent_end must not run checks.
+		pauseSilentChecks();
 		if (ctx.mode !== "print") {
 			attentionHoldId = `auto-compact:${++attentionHoldSequence}`;
 			emitTauEvent(pi, "tau:attention.hold.acquire", { id: attentionHoldId });
@@ -72,6 +89,8 @@ export default function autoCompactExtension(pi: ExtensionAPI): void {
 		const continueWork = (): void => {
 			if (version !== sessionVersion) return;
 			compacting = false;
+			// Keep the silent-check baseline across the new agent run started below.
+			resumeSilentChecks("continue");
 			continuationPending = true;
 			pi.sendMessage(
 				{
@@ -90,6 +109,7 @@ export default function autoCompactExtension(pi: ExtensionAPI): void {
 				if (version !== sessionVersion) return;
 				compacting = false;
 				if (error.name === "AbortError" || error.message === "Compaction cancelled") {
+					resumeSilentChecks("settle");
 					releaseAttentionHold("notify");
 					return;
 				}

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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shanepadgett/tau-agent",
-	"version": "0.39.1",
+	"version": "0.39.2",
 	"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.39.2",
 		"@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;