@shanepadgett/tau-agent 0.42.3 → 0.44.0

package/extensions/runtime-context/context.ts

@@ -9,7 +9,7 @@ interface SnapshotEntry {
 	path: string;
 }
 
-export interface RuntimeContext {
+interface RuntimeContext {
 	cwd: string;
 	rootSnapshot: readonly string[];
 }

package/extensions/runtime-context/index.ts

@@ -1,21 +1,15 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import {
-	formatLocalDisplayDate,
-	formatRuntimeContextMessage,
-	freezeRuntimeContext,
-	type RuntimeContext,
-} from "./context.ts";
+import { registerPromptSource } from "../../shared/prompt-contributions.ts";
+import { formatLocalDisplayDate, formatRuntimeContextMessage, freezeRuntimeContext } from "./context.ts";
 
 export default function runtimeContextExtension(pi: ExtensionAPI): void {
-	let runtimeContext: RuntimeContext | undefined;
-
-	pi.on("session_start", (_event, ctx) => {
-		runtimeContext = freezeRuntimeContext(ctx.cwd);
-	});
-
-	pi.on("before_agent_start", (event, ctx) => {
-		runtimeContext ??= freezeRuntimeContext(ctx.cwd);
-		const content = formatRuntimeContextMessage(formatLocalDisplayDate(new Date()), runtimeContext.rootSnapshot);
-		return { systemPrompt: `${event.systemPrompt}\n\n${content}` };
+	registerPromptSource(pi, {
+		key: "runtime/environment",
+		section: "environment",
+		refresh: "compaction",
+		async read(ctx) {
+			const snapshot = freezeRuntimeContext(ctx.cwd);
+			return formatRuntimeContextMessage(formatLocalDisplayDate(new Date()), snapshot.rootSnapshot);
+		},
 	});
 }

package/extensions/script-runner/index.ts

@@ -169,7 +169,6 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 	const langPhrase = formatLangList(detected);
 
 	const scripts = new Map<string, StoredScript>();
-	let tempDir: string | undefined;
 
 	function remember(scriptId: string, script: StoredScript): void {
 		scripts.set(scriptId, script);
@@ -190,12 +189,6 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 		throw new Error("Deno is not available on this machine.");
 	}
 
-	async function ensureTempDir(): Promise<string> {
-		if (tempDir) return tempDir;
-		tempDir = await mkdtemp(join(tmpdir(), "tau-script-runner-"));
-		return tempDir;
-	}
-
 	async function runScript(
 		language: Language,
 		command: string,
@@ -203,21 +196,27 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 		cwd: string,
 		signal: AbortSignal | undefined,
 	): Promise<ExecResult> {
-		const dir = await ensureTempDir();
-		const file = join(dir, language === "python3" ? "_run.py" : "_run.ts");
-		await writeFile(file, source, "utf8");
-		const args =
-			language === "python3"
-				? [file]
-				: language === "node"
-					? ["--experimental-strip-types", file]
-					: ["run", "-A", file];
-		const result = await pi.exec(command, args, { cwd, signal, timeout: TIMEOUT_MS });
-		return {
-			...result,
-			stdout: scrubPath(result.stdout, file, dir),
-			stderr: scrubPath(result.stderr, file, dir),
-		};
+		const dir = await mkdtemp(join(tmpdir(), "tau-script-runner-"));
+		try {
+			const file = join(dir, language === "python3" ? "_run.py" : "_run.ts");
+			await writeFile(file, source, "utf8");
+			const args =
+				language === "python3"
+					? [file]
+					: language === "node"
+						? ["--experimental-strip-types", file]
+						: ["run", "-A", file];
+			const result = await pi.exec(command, args, { cwd, signal, timeout: TIMEOUT_MS });
+			return {
+				...result,
+				stdout: scrubPath(result.stdout, file, dir),
+				stderr: scrubPath(result.stderr, file, dir),
+			};
+		} finally {
+			await rm(dir, { recursive: true, force: true }).catch(() => {
+				// best-effort cleanup
+			});
+		}
 	}
 
 	const paramsSchema = Type.Object(
@@ -315,12 +314,5 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 
 	pi.on("session_shutdown", () => {
 		scripts.clear();
-		const dir = tempDir;
-		tempDir = undefined;
-		if (dir) {
-			void rm(dir, { recursive: true, force: true }).catch(() => {
-				// best-effort cleanup
-			});
-		}
 	});
 }

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

@@ -23,5 +23,3 @@ 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,8 @@ 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, onTauEvent } from "../../shared/events.ts";
+import { emitTauEvent } from "../../shared/events.ts";
+import { registerPromptSource } from "../../shared/prompt-contributions.ts";
 import { matchGlob, posixPath } from "../../shared/glob.ts";
 import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
 import { resolveProjectRoot } from "../../shared/settings/paths.ts";
@@ -84,15 +85,8 @@ 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;
@@ -103,21 +97,6 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 		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;
@@ -126,20 +105,22 @@ 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) => {
-		settings = normalizeSettings(await loadTauExtensionSettings(ctx, silentCommandRunnerSettings));
-		if (!settings.enabled || settings.commands.length === 0) return undefined;
-		return { systemPrompt: `${event.systemPrompt}\n\n${formatSilentCheckPrompt(settings.commands)}` };
+	registerPromptSource(pi, {
+		key: "checks/instructions",
+		section: "automatic-checks",
+		refresh: "append",
+		async read(ctx) {
+			settings = normalizeSettings(await loadTauExtensionSettings(ctx, silentCommandRunnerSettings));
+			if (!settings.enabled || settings.commands.length === 0) return "";
+			return formatSilentCheckPrompt(settings.commands);
+		},
 	});
 
 	pi.on("agent_start", async (_event, ctx) => {
 		const startingChain = !chainActive;
 		chainActive = true;
-		settleDeferred = false;
 		if (!settings.enabled || settings.commands.length === 0) {
 			if (startingChain) {
 				turnStart = Date.now();
@@ -156,7 +137,6 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 	});
 
 	pi.on("agent_end", async (event, ctx) => {
-		if (checksPaused()) return;
 		if (hasAbortedAssistantMessage(event.messages)) return;
 		try {
 			await runChangedCommands(ctx.cwd, turnStart, ctx.ui.notify);
@@ -165,14 +145,7 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 		}
 	});
 
-	pi.on("agent_settled", () => {
-		if (checksPaused()) {
-			// Compact aborted this run; keep chain + file baseline until resume.
-			settleDeferred = true;
-			return;
-		}
-		finalizeChain();
-	});
+	pi.on("agent_settled", finalizeChain);
 
 	pi.on("session_shutdown", () => {
 		sessionActive = false;
@@ -181,8 +154,6 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 		turnPaths = new Set();
 		chainActive = false;
 		attentionHoldId = undefined;
-		checkPauses.clear();
-		settleDeferred = false;
 	});
 
 	async function collectCommandFailures(

package/extensions/soul/README.md

@@ -1,14 +1,11 @@
 # Soul
 
-Soul is the baseline Tau system prompt. It is always on.
+Soul supplies Tau's system prompt: communication, discussion, planning, execution, and coding guidance. It is always on.
 
-- **communication style** — short Slack-style replies, exact technical names, and a few worked examples.
-- **operating model** — answer questions before acting, keep research tight and documentation-first, plan in small steps, and stop when a fix needs unusual force.
-- **code style** — fast when the user is proving an idea, small and clean when the user wants real product code.
-- **primary-directive overseer** — after 20 tool calls, privately checks whether long-running work still follows the user's request and the normal supported path. Any guidance is applied silently on the next model turn.
+Soul captures tools, skills, project instructions, documentation, and environment context in a saved baseline. Reload and resume reuse it. Successful compaction captures a fresh baseline, including a new date and directory listing.
 
-Pi continues to own tool guidance, project instructions, skills, documentation paths, custom prompts, and working-directory context.
+Changes to available agents, automatic checks, approval guidance, and loaded tools are supplied as saved context updates. Earlier instructions and updates keep their positions instead of being rewritten each turn.
 
-Set `extensions.soul.overseer.enabled` to turn the overseer on or off. Set `extensions.soul.overseer.toolCallInterval` from 1 to 100 to change its review interval.
+Tools that cannot be loaded without changing the cached prefix wait for compaction. Tool execution permissions still take effect immediately. Soul reports incompatible prompt replacements or changes to previously sent history rather than silently replacing its baseline.
 
-After changing this extension, run `/reload` before testing the new behavior.
+Run `/reload` after changing this extension. The first request after installation captures the new Soul baseline; later instruction edits take effect after compaction.

package/extensions/soul/context.ts

@@ -0,0 +1,115 @@
+import {
+	formatSkillsForPrompt,
+	getDocsPath,
+	getExamplesPath,
+	getReadmePath,
+	type BuildSystemPromptOptions,
+	type ExtensionAPI,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { collectPromptSources, type PromptValue } from "../../shared/prompt-contributions.ts";
+import { FIXED_INSTRUCTIONS } from "./prompt.ts";
+
+export async function readPromptValues(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	inputs: BuildSystemPromptOptions,
+	capture: boolean,
+): Promise<PromptValue[]> {
+	const sources = collectPromptSources(pi).filter((source) => capture || source.refresh === "append");
+	const values = await Promise.all(
+		sources.map(async (source) => ({
+			key: source.key,
+			section: source.section,
+			refresh: source.refresh,
+			text: await source.read(ctx),
+		})),
+	);
+	const active = new Set(pi.getActiveTools());
+	const tools = pi.getAllTools().filter((tool) => active.has(tool.name));
+	values.push(
+		{
+			key: "pi/tools",
+			section: "tools",
+			refresh: "append",
+			text: tools
+				.map((tool) => `- ${tool.name}: ${inputs.toolSnippets?.[tool.name] ?? tool.description}`)
+				.join("\n"),
+		},
+		{
+			key: "pi/tool-guidance",
+			section: "tool-guidance",
+			refresh: "append",
+			text: [
+				...new Set([
+					...(active.has("bash") ? ["Use bash for file operations like ls, rg, find."] : []),
+					...tools.flatMap((tool) => tool.promptGuidelines ?? []),
+					...(inputs.promptGuidelines ?? []),
+				]),
+			]
+				.map((rule) => `- ${rule}`)
+				.join("\n"),
+		},
+	);
+	return values.sort((a, b) => a.key.localeCompare(b.key, "en"));
+}
+
+export function renderBaseline(inputs: BuildSystemPromptOptions, values: readonly PromptValue[]): string {
+	const sections = new Map<string, string[]>([
+		["tools", []],
+		["tool-guidance", []],
+		["skills", []],
+		["documentation", []],
+		["project-context", []],
+		["environment", []],
+		["additional-instructions", []],
+	]);
+	const skillTool = (["read", "bash"] as const).find((name) => inputs.selectedTools?.includes(name));
+	if (skillTool) sections.get("skills")?.push(formatSkillsForPrompt(inputs.skills ?? [], skillTool).trim());
+	sections.get("documentation")
+		?.push(`Consult Pi or Tau documentation when the request concerns their usage or extension APIs.
+Pi documentation:
+- Main documentation: ${getReadmePath()}
+- Additional docs: ${getDocsPath()}
+- Examples: ${getExamplesPath()}
+- Resolve docs/... and examples/... under those installed paths, not the working directory.
+- Extensions: docs/extensions.md and examples/extensions/; themes: docs/themes.md; skills: docs/skills.md; prompt templates: docs/prompt-templates.md; TUI: docs/tui.md; keybindings: docs/keybindings.md; SDK: docs/sdk.md; providers: docs/custom-provider.md; models: docs/models.md; packages: docs/packages.md; environment: docs/environment-variables.md.
+- Read the relevant documentation and follow related Markdown references before implementing Pi integrations.`);
+	sections
+		.get("project-context")
+		?.push(
+			...(inputs.contextFiles ?? []).map(
+				(file) =>
+					`<project_instructions path=${JSON.stringify(file.path)}>\n${file.content}\n</project_instructions>`,
+			),
+		);
+	sections.get("environment")?.push(`Working directory: ${inputs.cwd}`);
+	sections.get("additional-instructions")?.push(
+		inputs.customPrompt ?? "",
+		inputs.appendSystemPrompt ?? "",
+		...Object.entries(inputs.sections ?? {})
+			.sort(([a], [b]) => a.localeCompare(b, "en"))
+			.map(([key, text]) => `<${key}>\n${text}\n</${key}>`),
+	);
+	for (const value of values) {
+		const content = sections.get(value.section) ?? [];
+		content.push(value.text);
+		sections.set(value.section, content);
+	}
+	return [
+		FIXED_INSTRUCTIONS,
+		...[...sections].flatMap(([name, pieces]) => {
+			const text = pieces.filter((piece) => piece.trim()).join("\n\n");
+			return text ? [`<${name}>\n${text}\n</${name}>`] : [];
+		}),
+	].join("\n\n");
+}
+
+export function renderUpdate(values: readonly PromptValue[]): string {
+	return values
+		.map(
+			(value) =>
+				`<context-update source=${JSON.stringify(value.key)}>\nThis replaces the previous information for this source.\n${value.text || "This source no longer supplies instructions."}\n</context-update>`,
+		)
+		.join("\n\n");
+}

package/extensions/soul/index.ts

@@ -1,10 +1,144 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { registerPrimaryDirectiveOverseer } from "./overseer.ts";
-import { CODE_STYLE, COMMUNICATION_STYLE, OPERATING_MODEL } from "./prompt.ts";
+import { getCurrentTools, toToolDeclaration } from "@earendil-works/pi-ai";
+import { createHash } from "node:crypto";
+import type { BuildSystemPromptOptions, ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { emitTauEvent, onTauEventImmediately } from "../../shared/events.ts";
+import { readPromptValues, renderBaseline, renderUpdate } from "./context.ts";
+import {
+	admittedTools,
+	BASELINE_TYPE,
+	projectPrompt,
+	restorePrompt,
+	UPDATE_TYPE,
+	type SavedBaseline,
+	type SavedUpdate,
+} from "./state.ts";
+import { toolChangeReason } from "./tools.ts";
+
+const CHECKPOINT_TYPE = "tau.soul.prefix";
+interface PrefixCheckpoint {
+	baselineEntryId: string;
+	count: number;
+	hash: string;
+}
 
 export default function soulExtension(pi: ExtensionAPI): void {
-	registerPrimaryDirectiveOverseer(pi);
-	pi.on("before_agent_start", (event) => ({
-		systemPrompt: [event.systemPrompt, COMMUNICATION_STYLE, OPERATING_MODEL, CODE_STYLE].join("\n\n"),
-	}));
+	let inputs: BuildSystemPromptOptions | null = null;
+
+	pi.on("session_start", () => {
+		inputs = null;
+	});
+	pi.on("session_shutdown", () => {
+		inputs = null;
+	});
+	pi.on("before_agent_start", (event) => {
+		// Keep the shared options reference until all contributors have finished.
+		inputs = event.systemPromptOptions;
+	});
+
+	onTauEventImmediately(pi, "soul.tools", "tau:prompt.tools.check", ({ ctx, tools, reject }) => {
+		try {
+			const saved = restorePrompt(ctx.sessionManager.getBranch());
+			if (!saved || !ctx.model) return;
+			const previous = admittedTools(saved);
+			// getAllTools exposes schemas but not constrainedSampling. Preserve that
+			// metadata here; the request boundary checks the complete Pi declarations.
+			const reason = toolChangeReason(
+				ctx.model,
+				previous,
+				tools.map((tool) => ({
+					...previous.find((candidate) => candidate.name === tool.name),
+					...tool,
+				})),
+			);
+			if (reason) reject(reason);
+		} catch (error) {
+			reject(String(error));
+		}
+	});
+
+	pi.on("context_with_system", async (event, ctx) => {
+		try {
+			if (!inputs) throw new Error("Soul has no loaded prompt inputs.");
+			if (inputs.forceSystemPrompt !== undefined)
+				throw new Error(
+					"A forced system prompt conflicts with Soul. Remove the extension's systemPrompt replacement.",
+				);
+			const branch = ctx.sessionManager.getBranch();
+			const newestFirst = [...branch].reverse();
+			const projection = ctx.sessionManager.buildSessionProjection();
+			const anchor = [...projection.entries].reverse().find((entry) => entry.messages.length > 0);
+			if (!anchor) throw new Error("Soul has no conversation anchor.");
+			const saved = restorePrompt(branch);
+			const active = new Set(pi.getActiveTools());
+			const requested = getCurrentTools(event.messages)
+				.filter((tool) => active.has(tool.name))
+				.map(toToolDeclaration);
+			if (saved && ctx.model) {
+				const reason = toolChangeReason(ctx.model, admittedTools(saved), requested);
+				if (reason) throw new Error(reason);
+			}
+			const values = await readPromptValues(pi, ctx, inputs, saved === null);
+			if (!saved) {
+				pi.appendEntry<SavedBaseline>(BASELINE_TYPE, {
+					version: 1,
+					compactionId: newestFirst.find((entry) => entry.type === "compaction")?.id ?? null,
+					afterEntryId: anchor.sourceEntry.id,
+					text: renderBaseline(inputs, values),
+					values,
+					initialTools: getCurrentTools(event.messages),
+				});
+			} else {
+				const previous = new Map(saved.baseline.values.map((value) => [value.key, value]));
+				for (const update of saved.updates) for (const value of update.data.values) previous.set(value.key, value);
+				const currentKeys = new Set(values.map((value) => value.key));
+				for (const value of previous.values()) {
+					if (value.refresh === "append" && !currentKeys.has(value.key)) values.push({ ...value, text: "" });
+				}
+				const changed = values.filter((value) => previous.get(value.key)?.text !== value.text);
+				const tools = new Map(admittedTools(saved).map((tool) => [tool.name, tool]));
+				const added = requested.some((tool) => !tools.has(tool.name));
+				for (const tool of requested) tools.set(tool.name, tool);
+				if (changed.length > 0 || added)
+					pi.appendEntry<SavedUpdate>(UPDATE_TYPE, {
+						version: 1,
+						baselineEntryId: saved.entryId,
+						afterEntryId: anchor.sourceEntry.id,
+						text: renderUpdate(changed),
+						values: changed,
+						tools: [...tools.values()],
+					});
+			}
+			const admitted = restorePrompt(ctx.sessionManager.getBranch());
+			if (!admitted) throw new Error("Soul failed to save its baseline.");
+			const messages = projectPrompt(event.messages, admitted, ctx);
+			const checkpointEntry = newestFirst.find(
+				(entry) => entry.type === "custom" && entry.customType === CHECKPOINT_TYPE,
+			);
+			const checkpoint = checkpointEntry?.type === "custom" ? (checkpointEntry.data as PrefixCheckpoint) : null;
+			if (checkpoint?.baselineEntryId === admitted.entryId) {
+				const prefix = createHash("sha256")
+					.update(JSON.stringify(messages.slice(0, checkpoint.count)))
+					.digest("hex");
+				if (prefix !== checkpoint.hash)
+					throw new Error("Previously sent conversation content changed. Compact before continuing.");
+			}
+			const hash = createHash("sha256").update(JSON.stringify(messages)).digest("hex");
+			if (hash !== checkpoint?.hash)
+				pi.appendEntry<PrefixCheckpoint>(CHECKPOINT_TYPE, {
+					baselineEntryId: admitted.entryId,
+					count: messages.length,
+					hash,
+				});
+			emitTauEvent(pi, "tau:prompt.snapshot", {
+				text: [admitted.baseline.text, ...admitted.updates.map((update) => update.data.text)].join("\n\n"),
+			});
+			return { messages };
+		} catch (error) {
+			ctx.ui.notify(`Soul stopped this request: ${error instanceof Error ? error.message : String(error)}`, "error");
+			ctx.abort();
+			// Pi currently enters the provider with an aborted signal; do not weaken that
+			// cancellation into a fallback prompt. See soul-request-check-findings.md.
+			return undefined;
+		}
+	});
 }