@shanepadgett/tau-agent 0.16.0 → 0.17.0

package/extensions/subagent/session-resource.ts

@@ -0,0 +1,169 @@
+import {
+	createAgentSession,
+	DefaultResourceLoader,
+	getAgentDir,
+	ModelRuntime,
+	SessionManager,
+	type AgentSession,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import type { AgentDefinition, ThinkingLevel } from "./agents.ts";
+
+const CHILD_UI_BLOCKED_METHODS = new Set([
+	"setEditorComponent",
+	"setFooter",
+	"setStatus",
+	"setTitle",
+	"setWidget",
+	"setWorkingIndicator",
+]);
+
+type SelectedModel = NonNullable<ExtensionContext["model"]>;
+type SelectedProvider = NonNullable<ReturnType<ExtensionContext["modelRegistry"]["getProvider"]>>;
+
+export interface SubagentSessionInputs {
+	definition: AgentDefinition;
+	extensionPaths: readonly string[];
+	cwd: string;
+	model: SelectedModel;
+	modelName: string;
+	provider: SelectedProvider;
+	runtimeApiKey: string | undefined;
+	thinkingLevel: ThinkingLevel;
+	bindTarget: { mode: "print" } | { mode: "tui"; uiContext: ExtensionContext["ui"] };
+}
+
+export interface SubagentSessionResource {
+	readonly inputs: SubagentSessionInputs;
+	readonly session: AgentSession;
+	dispose(): Promise<void>;
+}
+
+function childUiContext(ui: ExtensionContext["ui"]): ExtensionContext["ui"] {
+	return new Proxy(ui, {
+		get(target, property, receiver) {
+			if (typeof property === "string" && CHILD_UI_BLOCKED_METHODS.has(property)) return () => undefined;
+			const value = Reflect.get(target, property, receiver) as unknown;
+			return typeof value === "function" ? value.bind(target) : value;
+		},
+	});
+}
+
+export async function resolveSubagentSessionInputs(options: {
+	definition: AgentDefinition;
+	extensionPaths: readonly string[];
+	ctx: ExtensionContext;
+	parentThinkingLevel: string;
+	signal: AbortSignal;
+	onWarning?: (warning: string) => void;
+}): Promise<SubagentSessionInputs> {
+	const { definition, extensionPaths, ctx, signal, onWarning } = options;
+	let model = ctx.model;
+	let thinkingLevel = options.parentThinkingLevel as ThinkingLevel;
+	let selectedAuth: Awaited<ReturnType<ExtensionContext["modelRegistry"]["getApiKeyAndHeaders"]>> | undefined;
+	if (definition.model) {
+		const separator = definition.model.indexOf("/");
+		const configured = ctx.modelRegistry.find(
+			definition.model.slice(0, separator),
+			definition.model.slice(separator + 1),
+		);
+		if (!configured) onWarning?.(`model ${definition.model} is unavailable; using parent model`);
+		else {
+			const auth = await ctx.modelRegistry.getApiKeyAndHeaders(configured);
+			if (!auth.ok) onWarning?.(`model ${definition.model} is unavailable: ${auth.error}; using parent model`);
+			else {
+				model = configured;
+				selectedAuth = auth;
+			}
+		}
+	}
+	if (definition.thinking) {
+		const mapped = model?.thinkingLevelMap?.[definition.thinking];
+		const unsupported =
+			!model?.reasoning ||
+			mapped === null ||
+			((definition.thinking === "xhigh" || definition.thinking === "max") && mapped === undefined);
+		if (unsupported)
+			onWarning?.(`thinking ${definition.thinking} is unavailable for the selected model; using parent thinking`);
+		else thinkingLevel = definition.thinking;
+	}
+	if (!model) throw new Error(`Agent ${definition.name} startup failed: parent has no model`);
+	const auth = selectedAuth ?? (await ctx.modelRegistry.getApiKeyAndHeaders(model));
+	if (!auth.ok) throw new Error(`Agent ${definition.name} startup failed: ${auth.error}`);
+	const provider = ctx.modelRegistry.getProvider(model.provider);
+	if (!provider) throw new Error(`Agent ${definition.name} startup failed: provider ${model.provider} is unavailable`);
+	if (signal.aborted) throw new Error(`Agent ${definition.name} startup aborted`);
+	return {
+		definition,
+		extensionPaths: [...extensionPaths],
+		cwd: ctx.cwd,
+		model,
+		modelName: `${model.provider}/${model.id}`,
+		provider,
+		runtimeApiKey:
+			auth.apiKey && provider.auth.apiKey && !ctx.modelRegistry.isUsingOAuth(model) ? auth.apiKey : undefined,
+		thinkingLevel,
+		bindTarget:
+			ctx.mode === "tui" && ctx.hasUI ? { mode: "tui", uiContext: childUiContext(ctx.ui) } : { mode: "print" },
+	};
+}
+
+export async function createSubagentSessionResource(
+	inputs: SubagentSessionInputs,
+	signal: AbortSignal,
+): Promise<SubagentSessionResource> {
+	let session: AgentSession | undefined;
+	try {
+		if (signal.aborted) throw new Error(`Agent ${inputs.definition.name} startup aborted`);
+		const modelRuntime = await ModelRuntime.create();
+		modelRuntime.registerNativeProvider(inputs.provider);
+		if (inputs.runtimeApiKey !== undefined)
+			await modelRuntime.setRuntimeApiKey(inputs.model.provider, inputs.runtimeApiKey);
+		if (signal.aborted) throw new Error(`Agent ${inputs.definition.name} startup aborted`);
+		const resourceLoader = new DefaultResourceLoader({
+			cwd: inputs.cwd,
+			agentDir: getAgentDir(),
+			noExtensions: true,
+			additionalExtensionPaths: [...inputs.extensionPaths],
+		});
+		await resourceLoader.reload();
+		if (signal.aborted) throw new Error(`Agent ${inputs.definition.name} startup aborted`);
+		const created = await createAgentSession({
+			cwd: inputs.cwd,
+			model: inputs.model,
+			modelRuntime,
+			thinkingLevel: inputs.thinkingLevel,
+			tools: inputs.definition.tools,
+			excludeTools: ["subagent"],
+			resourceLoader,
+			sessionManager: SessionManager.inMemory(inputs.cwd),
+		});
+		session = created.session;
+		if (signal.aborted) throw new Error(`Agent ${inputs.definition.name} startup aborted`);
+		await session.bindExtensions(inputs.bindTarget);
+		if (signal.aborted) throw new Error(`Agent ${inputs.definition.name} startup aborted`);
+		const active = session.getActiveToolNames().sort();
+		const expected = [...inputs.definition.tools].sort();
+		if (active.join("\0") !== expected.join("\0") || active.includes("subagent")) {
+			const missing = expected.filter((tool) => !active.includes(tool));
+			throw new Error(
+				`Agent ${inputs.definition.name} startup failed: unavailable tools: ${missing.join(", ") || "active tool mismatch"}`,
+			);
+		}
+		let disposed = false;
+		return {
+			inputs,
+			session,
+			async dispose() {
+				if (disposed) return;
+				disposed = true;
+				if (session?.isStreaming) await session.abort().catch(() => undefined);
+				session?.dispose();
+			},
+		};
+	} catch (error) {
+		if (session?.isStreaming) await session.abort().catch(() => undefined);
+		session?.dispose();
+		throw error;
+	}
+}

package/extensions/tau-help/help.md

@@ -28,7 +28,11 @@ Adds `/commit` for semantic commit grouping, review, and committing selected rep
 
 ## context
 
-Adds `/context` to select reusable repository work scopes from `.pi/contexts`, and `/context-sync` to reconcile affected scopes from current Git changes. Entry `files` are autoread; entry `anchors` are unloaded navigation paths the agent can inspect when needed. Context validation is disabled by default; when enabled, Tau checks both classes for changed-file membership and stale references after agent turns. Folder names are tabs, TOML files are concepts, and TOML sections are selectable entries.
+Adds `/context` to select reusable repository work scopes from `.pi/contexts`, and `/context-sync` or `/context-sync <nudge>` for human-driven catalog sync (optional nudge). Escape cancels a running manual sync. When `sync.automation` is on, the coding agent can also run the `context-sync` subagent after meaningful uncommitted work. `sync.enabled` is the master switch for command, automation, and validation auto-run. Entry `files` are autoread; entry `anchors` are unloaded navigation paths. Context validation is off by default; when on (and sync enabled), Tau auto-runs context-sync on failure. Folder names are tabs, TOML files are concepts, and TOML sections are selectable entries.
+
+## context-pruning
+
+Gives the agent `context_prune` for removing substantial stale tool evidence after broad exploration converges. The agent records durable conclusions before creating an anchor, can retain exact exchanges or current file knowledge, and continues the task automatically. Context markers occasionally steer the agent after tool-heavy growth and become more direct under pressure. Run `/prune` with no arguments to request an anchor manually. Session history remains unchanged, and anchors, markers, and pruned-row state follow the active branch.
 
 ## explore
 
@@ -88,7 +92,7 @@ Adds `Alt+S` to stash the current prompt draft and `/pop` to browse stashed draf
 
 ## subagent
 
-Gives Tau a subagent delegation tool for isolated, focused work. Tau can continue a retained child thread when follow-up work depends on its prior reads and reasoning. You can also create your own subagents in the supported subagent directories. Ask Tau how to do it and have it consult the extension’s own documentation; the built-in agents show the pattern. Each subagent can register its own model and the tools it is allowed to use.
+Gives Tau a subagent delegation tool for isolated, focused work. The built-in `review` agent performs adversarial, read-only code reviews; `web-research` handles external research. Known files can be autoread as line-numbered snapshots into a fresh or retained child turn. Tau can continue a retained child thread when follow-up work depends on its prior reads and reasoning. You can also create your own subagents in the supported subagent directories. Ask Tau how to do it and have it consult the extension’s own documentation; the built-in agents show the pattern. Each subagent can register its own model, tools, and pool of display names. Reused pool names get numeric suffixes. In interactive cmux sessions, Tau opens one temporary Markdown dashboard for live subagent progress; it does not change how children run and closes shortly after the active cohort finishes.
 
 ## tau-help
 

package/extensions/turn-budget/index.ts

@@ -20,15 +20,12 @@ interface MarkerDetails {
 	used: number;
 	cap: number;
 	extended: boolean;
-	sequence: number;
 }
 
 export default function turnBudgetExtension(pi: ExtensionAPI): void {
 	let settings = normalizeSettings(turnBudgetSettings.defaults);
 	let turnCount = 0;
 	let softCap = settings.turnLimit;
-	let nextMarkerSequence = 1;
-	let activeMarkerSequence: number | undefined;
 
 	pi.registerMessageRenderer<MarkerDetails>(MARKER_TYPE, (message, _options, theme) => {
 		const details = readMarkerDetails(message.details);
@@ -48,7 +45,6 @@ export default function turnBudgetExtension(pi: ExtensionAPI): void {
 	pi.on("agent_start", () => {
 		turnCount = 0;
 		softCap = settings.turnLimit;
-		activeMarkerSequence = undefined;
 	});
 
 	pi.on("turn_end", (event) => {
@@ -62,46 +58,24 @@ export default function turnBudgetExtension(pi: ExtensionAPI): void {
 				previousCap: softCap,
 				newCap: turnCount + settings.softCapIncrement,
 			};
-			activeMarkerSequence = nextMarkerSequence;
-			sendTurnBudgetMessage(pi, hint, nextMarkerSequence);
-			nextMarkerSequence += 1;
+			sendTurnBudgetMessage(pi, hint);
 			softCap = hint.newCap;
 			return undefined;
 		}
 		if (turnCount % settings.nudgeEveryTurns === 0) {
 			const hint: Hint = { kind: "normal", used: turnCount, cap: softCap };
-			activeMarkerSequence = nextMarkerSequence;
-			sendTurnBudgetMessage(pi, hint, nextMarkerSequence);
-			nextMarkerSequence += 1;
+			sendTurnBudgetMessage(pi, hint);
 		}
 		return undefined;
 	});
-
-	pi.on("context", (event) => {
-		const messages = event.messages.filter(
-			(message) =>
-				message.role !== "custom" || message.customType !== MARKER_TYPE || markerIsActive(message.details),
-		);
-		if (messages.length === event.messages.length) return undefined;
-		return { messages };
-	});
-
-	pi.on("after_provider_response", () => {
-		activeMarkerSequence = undefined;
-	});
-	function markerIsActive(value: unknown): boolean {
-		if (activeMarkerSequence === undefined) return false;
-		const details = readMarkerDetails(value);
-		return details?.sequence === activeMarkerSequence;
-	}
 }
 
-function sendTurnBudgetMessage(pi: ExtensionAPI, hint: Hint, sequence: number): void {
+function sendTurnBudgetMessage(pi: ExtensionAPI, hint: Hint): void {
 	pi.sendMessage<MarkerDetails>({
 		customType: MARKER_TYPE,
 		content: formatSteeringMessage(hint),
 		display: true,
-		details: markerDetails(hint, sequence),
+		details: markerDetails(hint),
 	});
 }
 
@@ -124,10 +98,10 @@ function normalizeSettings(value: typeof turnBudgetSettings.defaults): Settings
 	};
 }
 
-function markerDetails(hint: Hint, sequence: number): MarkerDetails {
+function markerDetails(hint: Hint): MarkerDetails {
 	return hint.kind === "extended"
-		? { used: hint.used, cap: hint.newCap, extended: true, sequence }
-		: { used: hint.used, cap: hint.cap, extended: false, sequence };
+		? { used: hint.used, cap: hint.newCap, extended: true }
+		: { used: hint.used, cap: hint.cap, extended: false };
 }
 
 function readMarkerDetails(value: unknown): MarkerDetails | undefined {
@@ -135,10 +109,8 @@ function readMarkerDetails(value: unknown): MarkerDetails | undefined {
 	const record = value as Record<string, unknown>;
 	const used = record.used;
 	const cap = record.cap;
-	const sequence = record.sequence;
 	if (typeof used !== "number" || !Number.isInteger(used) || used < 0) return undefined;
 	if (typeof cap !== "number" || !Number.isInteger(cap) || cap < 1) return undefined;
-	if (typeof sequence !== "number" || !Number.isInteger(sequence) || sequence < 1) return undefined;
 	if (typeof record.extended !== "boolean") return undefined;
-	return { used, cap, extended: record.extended, sequence };
+	return { used, cap, extended: record.extended };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shanepadgett/tau-agent",
-	"version": "0.16.0",
+	"version": "0.17.0",
 	"description": "Tau is a custom agentic harness built with pi extensions",
 	"type": "module",
 	"license": "MIT",
@@ -28,7 +28,7 @@
 		"README.md"
 	],
 	"dependencies": {
-		"@shanepadgett/tau-tui": "0.16.0",
+		"@shanepadgett/tau-tui": "0.17.0",
 		"@toon-format/toon": "2.3.0",
 		"smol-toml": "1.7.0"
 	},

package/schemas/tau.schema.json

@@ -15,13 +15,29 @@
 				"context": {
 					"type": "object",
 					"properties": {
+						"sync": {
+							"type": "object",
+							"properties": {
+								"enabled": {
+									"type": "boolean",
+									"default": true,
+									"description": "Master switch for context-sync. When false: no /context-sync, parent cannot call the agent, validation does not auto-run sync."
+								},
+								"automation": {
+									"type": "boolean",
+									"default": true,
+									"description": "When true with sync.enabled, the coding agent may call context-sync. When false, only manual /context-sync (validation auto-run still allowed if validation.enabled)."
+								}
+							},
+							"additionalProperties": false
+						},
 						"validation": {
 							"type": "object",
 							"properties": {
 								"enabled": {
 									"type": "boolean",
 									"default": false,
-									"description": "Validate context membership after agent turns."
+									"description": "Validate context membership after agent turns and auto-run context-sync on failure (requires sync.enabled)."
 								},
 								"ignoreGlobs": {
 									"type": "array",
@@ -37,6 +53,37 @@
 					},
 					"additionalProperties": false
 				},
+				"contextPruning": {
+					"type": "object",
+					"properties": {
+						"enabled": {
+							"type": "boolean",
+							"default": true,
+							"description": "Enable context pruning."
+						},
+						"nudgeEveryPercent": {
+							"type": "integer",
+							"default": 20,
+							"minimum": 1,
+							"maximum": 100,
+							"description": "Context growth interval between automatic pruning hints."
+						},
+						"pressurePercent": {
+							"type": "integer",
+							"default": 50,
+							"minimum": 1,
+							"maximum": 99,
+							"description": "Context usage above which pruning hints become urgent."
+						},
+						"minimumReclaimTokens": {
+							"type": "integer",
+							"default": 8000,
+							"minimum": 1,
+							"description": "Minimum estimated tokens a prune must reclaim."
+						}
+					},
+					"additionalProperties": false
+				},
 				"footer": {
 					"type": "object",
 					"properties": {