@shanepadgett/tau-agent 0.42.3 → 0.43.0

package/extensions/auto-compact/index.ts

@@ -1,122 +0,0 @@
-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 enabled = true;
-	let tokenLimit = DEFAULT_AUTO_COMPACT_TOKEN_LIMIT;
-	let armed = true;
-	let compacting = false;
-	let sessionVersion = 0;
-	let attentionHoldSequence = 0;
-	let attentionHoldId: string | undefined;
-	let silentCheckPauseId: 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 });
-	}
-
-	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);
-		if (version !== sessionVersion) return;
-		enabled = settings.enabled;
-		tokenLimit = settings.tokenLimit;
-		armed = true;
-		compacting = false;
-		attentionHoldSequence = 0;
-		attentionHoldId = undefined;
-		silentCheckPauseId = undefined;
-		continuationPending = false;
-	});
-	pi.on("session_shutdown", () => {
-		sessionVersion++;
-		armed = true;
-		compacting = false;
-		attentionHoldId = undefined;
-		silentCheckPauseId = 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 (!enabled || 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;
-		// 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 });
-		}
-		const version = sessionVersion;
-		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(
-				{
-					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") {
-					resumeSilentChecks("settle");
-					releaseAttentionHold("notify");
-					return;
-				}
-				continueWork();
-			},
-		});
-	});
-}

package/extensions/auto-compact/settings.ts

@@ -1,30 +0,0 @@
-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: {
-		enabled: true as boolean,
-		tokenLimit: DEFAULT_AUTO_COMPACT_TOKEN_LIMIT,
-	},
-	schema: Type.Object(
-		{
-			enabled: Type.Optional(
-				Type.Boolean({
-					default: true,
-					description: "Enable automatic compaction when context reaches the token limit.",
-				}),
-			),
-			tokenLimit: Type.Optional(
-				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/context/settings.ts

@@ -1,62 +0,0 @@
-import { Type } from "typebox";
-import { defineTauExtensionSettings } from "../../shared/settings/define.ts";
-
-export default defineTauExtensionSettings({
-	key: "context",
-	defaults: {
-		sync: {
-			enabled: true as boolean,
-			automation: true as boolean,
-		},
-		validation: {
-			enabled: false as boolean,
-			ignoreGlobs: [] as string[],
-		},
-	},
-	schema: Type.Object(
-		{
-			sync: Type.Optional(
-				Type.Object(
-					{
-						enabled: Type.Optional(
-							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.Optional(
-							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.Optional(
-				Type.Object(
-					{
-						enabled: Type.Optional(
-							Type.Boolean({
-								default: false,
-								description:
-									"Validate context membership after agent turns and auto-run context-sync on failure (requires sync.enabled).",
-							}),
-						),
-						ignoreGlobs: Type.Optional(
-							Type.Array(Type.String(), {
-								default: [],
-								description: "Project-relative files excluded from context membership validation and sync.",
-							}),
-						),
-					},
-					{ additionalProperties: false },
-				),
-			),
-		},
-		{ additionalProperties: false },
-	),
-});

package/extensions/context/sync.ts

@@ -1,276 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFile, readdir } from "node:fs/promises";
-import { extname, join, relative, sep } from "node:path";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { createGitRunner, loadRepoStatus } from "../../shared/git.ts";
-import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
-import { discoverAgents } from "../subagent/agents.ts";
-import {
-	createSubagentThread,
-	disposeSubagentThread,
-	extensionPathsForTools,
-	runSubagentTurn,
-} from "../subagent/run.ts";
-import { pathExists } from "./definitions.ts";
-import contextSettings from "./settings.ts";
-import { formatContextValidationFailure, listEligibleDirtyPaths, validateContextCatalog } from "./validation.ts";
-
-const CONTEXT_SYNC_AGENT = "context-sync";
-
-export interface ContextSyncDetails {
-	outcome: "applied" | "no-change" | "failed" | "cancelled";
-	summary: string;
-	reason: string;
-	changedContextFiles: string[];
-	agentResponse?: string;
-	validationFailure?: string;
-}
-
-type SyncStatus = (status: string) => void | Promise<void>;
-type GitRunner = ReturnType<typeof createGitRunner>;
-
-let syncQueue = Promise.resolve();
-
-export async function runContextSync(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-	options: { nudge?: string; signal?: AbortSignal; onStatus?: SyncStatus } = {},
-): Promise<ContextSyncDetails> {
-	return withSyncLock(() => runContextSyncLocked(pi, ctx, options));
-}
-
-function noChangeResult(reason: string, agentResponse?: string): ContextSyncDetails {
-	return {
-		outcome: "no-change",
-		summary: "Existing context mappings already fit the changed scope.",
-		reason,
-		changedContextFiles: [],
-		agentResponse,
-	};
-}
-
-async function inspectSyncNeed(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-	nudge: string | undefined,
-	onStatus?: SyncStatus,
-): Promise<
-	| { kind: "done"; result: ContextSyncDetails }
-	| { kind: "run"; git: GitRunner; root: string; ignoreGlobs: readonly string[] }
-> {
-	await onStatus?.("Inspecting repository context");
-	const git = createGitRunner(pi, ctx);
-	const status = await loadRepoStatus(git);
-	if (!status) throw new Error("No Git repository found");
-	const settings = await loadTauExtensionSettings(ctx, contextSettings);
-	const ignoreGlobs = settings.validation.ignoreGlobs;
-	const validation = await validateContextCatalog(git, status.root, ignoreGlobs);
-	const dirtyEligible = await listEligibleDirtyPaths(git, status.root, ignoreGlobs);
-	const force = Boolean(nudge?.trim());
-	if (!force && validation.stale.length === 0 && validation.uncovered.length === 0 && dirtyEligible.length === 0) {
-		return {
-			kind: "done",
-			result: noChangeResult("No eligible dirty files, stale catalog paths, or sync nudge."),
-		};
-	}
-	return { kind: "run", git, root: status.root, ignoreGlobs };
-}
-
-async function resolveContextSyncDefinition(ctx: ExtensionContext) {
-	const discovery = await discoverAgents(ctx.cwd, ctx.isProjectTrusted());
-	const definition = discovery.agents.get(CONTEXT_SYNC_AGENT);
-	if (definition) return definition;
-	const reason =
-		discovery.invalid
-			.get(CONTEXT_SYNC_AGENT)
-			?.map((item) => item.reason)
-			.join("; ") ?? "unknown agent";
-	throw new Error(`Context sync agent unavailable: ${reason}`);
-}
-
-async function runContextSyncAgent(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-	root: string,
-	nudge: string | undefined,
-	signal: AbortSignal,
-	onStatus: SyncStatus | undefined,
-	beforeCatalog: Map<string, string>,
-): Promise<ContextSyncDetails | { agentResponse: string }> {
-	const definition = await resolveContextSyncDefinition(ctx);
-	const task = buildContextSyncTask(root, nudge);
-	await onStatus?.("Running context-sync subagent");
-	const thread = await createSubagentThread({
-		id: `context-sync-${Date.now()}`,
-		displayName: definition.names[0] ?? definition.name,
-		definition,
-		extensionPaths: extensionPathsForTools(pi, definition.tools),
-		initialTask: task,
-		ctx,
-		thinkingLevel: pi.getThinkingLevel(),
-		signal,
-		onWarning: (warning) => {
-			ctx.ui.notify(`Context sync agent: ${warning}`, "warning");
-		},
-	});
-	try {
-		const result = await runSubagentTurn({
-			thread,
-			task,
-			initial: true,
-			signal,
-			onUpdate: async (details) => {
-				const activity = details.currentActivity ?? details.response;
-				if (activity) await onStatus?.(activity.slice(0, 160));
-			},
-		});
-		if (signal.aborted || result.details.status === "aborted") return cancelledResult(result.content);
-		if (result.details.status !== "completed") {
-			return {
-				outcome: "failed",
-				summary: "Context sync subagent failed.",
-				reason: result.details.error ?? result.content,
-				changedContextFiles: changedCatalogPaths(beforeCatalog, await catalogFileSnapshot(root)),
-				agentResponse: result.content,
-			};
-		}
-		return { agentResponse: result.content };
-	} finally {
-		await disposeSubagentThread(thread);
-	}
-}
-
-async function finalizeContextSync(
-	git: GitRunner,
-	root: string,
-	ignoreGlobs: readonly string[],
-	beforeCatalog: Map<string, string>,
-	agentResponse: string,
-	onStatus?: SyncStatus,
-): Promise<ContextSyncDetails> {
-	const changedContextFiles = changedCatalogPaths(beforeCatalog, await catalogFileSnapshot(root));
-	await onStatus?.("Verifying context catalog");
-	const validationFailure = formatContextValidationFailure(await validateContextCatalog(git, root, ignoreGlobs));
-	if (validationFailure) {
-		return {
-			outcome: "failed",
-			summary: "Context sync finished but catalog invariants still fail.",
-			reason: validationFailure,
-			changedContextFiles,
-			agentResponse,
-			validationFailure,
-		};
-	}
-	if (changedContextFiles.length === 0) {
-		return noChangeResult(agentResponse.trim() || "Context-sync subagent made no catalog edits.", agentResponse);
-	}
-	return {
-		outcome: "applied",
-		summary: `Updated context catalog (${changedContextFiles.length} file${changedContextFiles.length === 1 ? "" : "s"}).`,
-		reason: agentResponse.trim() || "Context-sync subagent updated the catalog.",
-		changedContextFiles,
-		agentResponse,
-	};
-}
-
-async function runContextSyncLocked(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-	options: { nudge?: string; signal?: AbortSignal; onStatus?: SyncStatus },
-): Promise<ContextSyncDetails> {
-	if (!ctx.isProjectTrusted()) throw new Error("Context sync requires a trusted project");
-	const signal = options.signal ?? ctx.signal ?? new AbortController().signal;
-	if (signal.aborted) return cancelledResult();
-
-	const need = await inspectSyncNeed(pi, ctx, options.nudge, options.onStatus);
-	if (need.kind === "done") return need.result;
-	if (signal.aborted) return cancelledResult();
-
-	const beforeCatalog = await catalogFileSnapshot(need.root);
-	const agentResult = await runContextSyncAgent(
-		pi,
-		ctx,
-		need.root,
-		options.nudge,
-		signal,
-		options.onStatus,
-		beforeCatalog,
-	);
-	if ("outcome" in agentResult) return agentResult;
-	if (signal.aborted) return cancelledResult(agentResult.agentResponse);
-	return finalizeContextSync(
-		need.git,
-		need.root,
-		need.ignoreGlobs,
-		beforeCatalog,
-		agentResult.agentResponse,
-		options.onStatus,
-	);
-}
-
-function cancelledResult(agentResponse?: string): ContextSyncDetails {
-	return {
-		outcome: "cancelled",
-		summary: "Context sync cancelled",
-		reason: agentResponse?.trim() || "Cancelled by user.",
-		changedContextFiles: [],
-		agentResponse,
-	};
-}
-
-function buildContextSyncTask(root: string, nudge?: string): string {
-	const trimmed = nudge?.trim();
-	return [
-		`Keep the repository context catalog at ${root} honest.`,
-		"Job: update `.pi/contexts` so work packs match the codebase.",
-		"Use normal repo tools. Prefer patch for catalog edits under `.pi/contexts`.",
-		"Walk domain → concept → job entry before placing paths. Harness verifies catalog coverage after you finish.",
-		trimmed ? `Human nudge (soft steer, does not skip the ladder or coverage):\n${trimmed}` : undefined,
-	]
-		.filter((line): line is string => Boolean(line))
-		.join("\n\n");
-}
-
-async function withSyncLock<T>(task: () => Promise<T>): Promise<T> {
-	const previous = syncQueue;
-	let release = () => {};
-	syncQueue = new Promise<void>((resolve) => {
-		release = resolve;
-	});
-	await previous;
-	try {
-		return await task();
-	} finally {
-		release();
-	}
-}
-
-async function catalogFileSnapshot(root: string): Promise<Map<string, string>> {
-	const snapshot = new Map<string, string>();
-	const base = join(root, ".pi", "contexts");
-	if (!(await pathExists(base))) return snapshot;
-	const stack = [base];
-	while (stack.length > 0) {
-		const directory = stack.pop();
-		if (!directory) continue;
-		for (const entry of await readdir(directory, { withFileTypes: true })) {
-			const fullPath = join(directory, entry.name);
-			if (entry.isDirectory()) {
-				stack.push(fullPath);
-				continue;
-			}
-			if (!entry.isFile() || extname(entry.name) !== ".toml") continue;
-			const relativePath = relative(root, fullPath).split(sep).join("/");
-			const content = await readFile(fullPath, "utf8");
-			snapshot.set(relativePath, createHash("sha256").update(content).digest("hex"));
-		}
-	}
-	return snapshot;
-}
-
-function changedCatalogPaths(before: Map<string, string>, after: Map<string, string>): string[] {
-	const paths = new Set([...before.keys(), ...after.keys()]);
-	return [...paths]
-		.filter((path) => before.get(path) !== after.get(path))
-		.sort((left, right) => left.localeCompare(right));
-}

package/extensions/context/validation.ts

@@ -1,88 +0,0 @@
-import { stat } from "node:fs/promises";
-import { join } from "node:path";
-import type { GitRunner } from "../../shared/git.ts";
-import { contextEntryPaths, isContextEligiblePath, isSensitiveContextPath, loadContextEntries } from "./definitions.ts";
-
-export interface ContextValidationResult {
-	stale: Array<{ path: string; ids: string[] }>;
-	uncovered: string[];
-}
-
-export async function listEligibleDirtyPaths(
-	git: GitRunner,
-	root: string,
-	ignoreGlobs: readonly string[],
-): Promise<string[]> {
-	const status = await git.run(["status", "--porcelain=v2", "-z", "--untracked-files=all"], { cwd: root });
-	return [...parseDirtyPaths(status)]
-		.filter((path) => !isSensitiveContextPath(path) && isContextEligiblePath(path, ignoreGlobs))
-		.sort((left, right) => left.localeCompare(right));
-}
-
-export async function validateContextCatalog(
-	git: GitRunner,
-	root: string,
-	ignoreGlobs: readonly string[],
-): Promise<ContextValidationResult> {
-	const entries = await loadContextEntries(root);
-	const memberships = new Map<string, string[]>();
-	for (const entry of entries)
-		for (const file of contextEntryPaths(entry)) memberships.set(file, [...(memberships.get(file) ?? []), entry.id]);
-
-	const stale: Array<{ path: string; ids: string[] }> = [];
-	for (const [path, ids] of memberships) {
-		if (!isContextEligiblePath(path, ignoreGlobs)) continue;
-		try {
-			if (!(await stat(join(root, path))).isFile()) stale.push({ path, ids });
-		} catch {
-			stale.push({ path, ids });
-		}
-	}
-
-	const uncovered = (await listEligibleDirtyPaths(git, root, ignoreGlobs))
-		.filter((path) => !memberships.has(path))
-		.sort((left, right) => left.localeCompare(right));
-	return { stale: stale.sort((left, right) => left.path.localeCompare(right.path)), uncovered };
-}
-
-export function formatContextValidationFailure(result: ContextValidationResult): string | undefined {
-	if (result.stale.length === 0 && result.uncovered.length === 0) return undefined;
-	const output = ["Context catalog validation failed."];
-	if (result.stale.length)
-		output.push(
-			"",
-			"Stale context file references:",
-			...result.stale.map((item) => `- ${item.path} (${item.ids.sort().join(", ")})`),
-		);
-	if (result.uncovered.length)
-		output.push("", "Changed files with no context membership:", ...result.uncovered.map((path) => `- ${path}`));
-	output.push(
-		"",
-		"With validation enabled, Tau runs context-sync automatically after agent turns. Manual: /context-sync or /context-sync <nudge>.",
-	);
-	return output.join("\n");
-}
-
-function parseDirtyPaths(status: string): Set<string> {
-	const records = status.split("\0");
-	const dirty = new Set<string>();
-	for (let index = 0; index < records.length; index++) {
-		const record = records[index];
-		if (!record) continue;
-		if (record.startsWith("? ")) {
-			dirty.add(record.slice(2).replaceAll("\\", "/"));
-			continue;
-		}
-		const fields = record.split(" ");
-		const state = fields[1] ?? "..";
-		if (record.startsWith("1 ") && !state.includes("D")) {
-			dirty.add(fields.slice(8).join(" ").replaceAll("\\", "/"));
-		} else if (record.startsWith("2 ")) {
-			if (!state.includes("D")) dirty.add(fields.slice(9).join(" ").replaceAll("\\", "/"));
-			index += 1;
-		} else if (record.startsWith("u ")) {
-			dirty.add(fields.slice(10).join(" ").replaceAll("\\", "/"));
-		}
-	}
-	return dirty;
-}

package/extensions/effort/README.md

@@ -1,7 +0,0 @@
-# Effort Extension
-
-Switches active chat model and thinking level as one effort tier. Available providers come from current logins, and each provider can fall back through its ranked models.
-
-Run `/effort` to choose a tier and provider. `/effort quick`, `/effort standard`, and `/effort deep` skip the tier prompt. Press `Ctrl+Shift+E` to cycle tiers on current provider.
-
-If selected provider has no usable model for tier, current model stays active. Footer shows an effort label whenever current provider, model, and thinking level match a configured tier; otherwise it shows no label.