@shanepadgett/tau-agent 0.7.2 → 0.9.1

package/extensions/appshot/index.ts

@@ -116,11 +116,7 @@ function registerAppshotTools(pi: ExtensionAPI, runHelper: RunHelper): void {
 			name: "list_windows",
 			label: "List Windows",
 			description:
-				"List visible normal macOS windows as compact TOON with window IDs, titles, application identity, process IDs, and bounds. Requires macOS 14 or newer and Screen & System Audio Recording permission.",
-			promptSnippet: "Discover visible macOS application windows and their IDs",
-			promptGuidelines: [
-				"Use list_windows to discover graphical applications and select an exact window before calling screenshot_window.",
-			],
+				"List visible normal macOS windows as compact TOON with window IDs, titles, application identity, process IDs, and bounds. Use list_windows to discover exact window IDs and application PIDs before screenshot_window or activate_app. Requires macOS 14 or newer and Screen & System Audio Recording permission.",
 			parameters: listWindowsSchema,
 			async execute(_toolCallId, _params, signal) {
 				if (process.platform !== "darwin") throw new Error("list_windows is only available on macOS");
@@ -158,9 +154,7 @@ function registerAppshotTools(pi: ExtensionAPI, runHelper: RunHelper): void {
 			name: "screenshot_window",
 			label: "Screenshot Window",
 			description:
-				"Capture one visible macOS window by its list_windows ID, resize it to fit within 1568×1568 pixels, save it as PNG, and inspect the image.",
-			promptSnippet: "Capture and inspect an exact visible macOS window by window ID",
-			promptGuidelines: ["Call list_windows before screenshot_window; pass its exact window_id and a PNG path."],
+				"Capture one visible macOS window by an exact ID returned by list_windows, resize it to fit within 1568×1568 pixels, save it to the required PNG path, and inspect the image. Call list_windows first.",
 			parameters: screenshotWindowSchema,
 			async execute(_toolCallId, params: ScreenshotWindowParams, signal, onUpdate, ctx) {
 				if (process.platform !== "darwin") throw new Error("screenshot_window is only available on macOS");
@@ -219,11 +213,7 @@ function registerAppshotTools(pi: ExtensionAPI, runHelper: RunHelper): void {
 			name: "activate_app",
 			label: "Activate App",
 			description:
-				"Bring a running macOS application and its windows to the foreground by process ID. Use a PID returned by list_windows.",
-			promptSnippet: "Bring a listed macOS application to the foreground by process ID",
-			promptGuidelines: [
-				"Use activate_app only when foregrounding a listed application is needed for visual validation because it changes user focus.",
-			],
+				"Bring a running macOS application and its windows to the foreground by a process ID returned by list_windows. Use only when foregrounding is required for visual validation because activate_app changes user focus.",
 			parameters: activateAppSchema,
 			async execute(_toolCallId, params, signal) {
 				if (process.platform !== "darwin") throw new Error("activate_app is only available on macOS");

package/extensions/context/README.md

@@ -2,7 +2,22 @@
 
 Context stores reusable repository work scopes in `.pi/contexts`. Folder names become selector tabs, TOML files become concepts, and TOML sections become selectable entries.
 
-Use `/context` to select entries and inject their files through Tau autoread. Use `/context-sync` to reconcile affected scopes from the current Git changes. Sync is automatic, constrained to the changed scope, and may report `no-change` when existing mappings already fit.
+Use `/context` to select entries and inject their files through Tau autoread. Use `/context-sync` to reconcile affected scopes from the current Git changes. Tau validates context membership after agent turns and asks the agent to sync uncovered changed files or stale references automatically.
+
+Validation is enabled by default. Configure it globally or per project in Tau settings:
+
+```json
+{
+  "extensions": {
+    "context": {
+      "validation": {
+        "enabled": true,
+        "ignoreGlobs": ["generated/**"]
+      }
+    }
+  }
+}
+```
 
 ```toml
 name = "Player"

package/extensions/context/definitions.ts

@@ -2,6 +2,7 @@ import { access, readFile, readdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
 import { parse } from "smol-toml";
+import { matchGlob } from "../../shared/glob.ts";
 
 export interface ContextEntry {
 	id: string;
@@ -15,6 +16,46 @@ export interface ContextEntry {
 	path: string;
 }
 
+const CONTEXT_IGNORED_FILENAMES = new Set([
+	"bun.lock",
+	"bun.lockb",
+	"Cargo.lock",
+	"composer.lock",
+	"flake.lock",
+	"Gemfile.lock",
+	"go.sum",
+	"mix.lock",
+	"npm-shrinkwrap.json",
+	"package-lock.json",
+	"Package.resolved",
+	"Pipfile.lock",
+	"pnpm-lock.yaml",
+	"Podfile.lock",
+	"poetry.lock",
+	"pubspec.lock",
+	"uv.lock",
+	"yarn.lock",
+]);
+
+export function isContextEligiblePath(path: string, ignoreGlobs: readonly string[] = []): boolean {
+	return (
+		path !== "LICENSE" &&
+		!CONTEXT_IGNORED_FILENAMES.has(basename(path)) &&
+		!ignoreGlobs.some((glob) => matchGlob(glob, path)) &&
+		path !== ".pi/tau/ideas.jsonl" &&
+		path !== ".working" &&
+		!path.startsWith(".working/") &&
+		path !== ".pi/contexts" &&
+		!path.startsWith(".pi/contexts/")
+	);
+}
+
+export function isSensitiveContextPath(path: string): boolean {
+	const name = basename(path);
+	if (name === ".env.example" || name === ".env.sample") return false;
+	return name === ".env" || name.startsWith(".env.") || /\.(?:pem|key|crt|p12|pfx)$/i.test(name);
+}
+
 export async function pathExists(path: string): Promise<boolean> {
 	try {
 		await access(path);

package/extensions/context/index.ts

@@ -4,10 +4,14 @@ import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { emitTauEvent } from "../../shared/events.ts";
+import { createGitRunner, loadRepoStatus } from "../../shared/git.ts";
 import { createInjectedContext } from "../../shared/injected-context.ts";
+import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
 import { ContextPanel } from "./panel.ts";
 import { findProjectRoot, loadContextEntries, type ContextEntry } from "./definitions.ts";
+import contextSettings from "./settings.ts";
 import { runContextSync, type ContextSyncDetails } from "./sync.ts";
+import { formatContextValidationFailure, validateContextCatalog } from "./validation.ts";
 
 const contextSyncParams = Type.Object({}, { additionalProperties: false });
 
@@ -15,13 +19,16 @@ function compactResult(details: ContextSyncDetails) {
 	const value = {
 		outcome: details.outcome,
 		summary: details.summary,
+		reason: details.reason,
 		changedContextFiles: details.changedContextFiles,
 	};
 	return { content: [{ type: "text" as const, text: JSON.stringify(value) }], details };
 }
 
 export default function contextExtension(pi: ExtensionAPI): void {
-	let active: ContextEntry[] = [];
+	let validationSettings = contextSettings.defaults.validation;
+	let lastValidationFailure: string | undefined;
+	const activeToolExecutions = new Map<string, { toolName: string; done: Promise<void>; complete: () => void }>();
 
 	pi.registerCommand("context", {
 		description: "Select repository context entries and inject their files",
@@ -45,8 +52,6 @@ export default function contextExtension(pi: ExtensionAPI): void {
 				},
 			);
 			if (!selected?.length) return;
-			active = selected;
-			pi.appendEntry("tau.context-selection", { ids: selected.map((entry) => entry.id) });
 			const files = [...new Set(selected.flatMap((entry) => entry.files))].sort();
 			pi.sendMessage(
 				createInjectedContext(
@@ -92,9 +97,15 @@ export default function contextExtension(pi: ExtensionAPI): void {
 		defineTool<typeof contextSyncParams, ContextSyncDetails | undefined>({
 			name: "context_sync",
 			label: "context_sync",
-			description: "Synchronize repository context from current Git changes.",
+			description:
+				"Synchronize repository context membership after context validation reports changed, stale, or unassigned files.",
 			parameters: contextSyncParams,
-			async execute(_id, _params, _signal, onUpdate, ctx) {
+			async execute(id, _params, _signal, onUpdate, ctx) {
+				await Promise.all(
+					[...activeToolExecutions]
+						.filter(([toolCallId, execution]) => toolCallId !== id && execution.toolName !== "context_sync")
+						.map(([, execution]) => execution.done),
+				);
 				return compactResult(
 					await runContextSync(pi, ctx, (status) =>
 						onUpdate?.({ content: [{ type: "text", text: status }], details: undefined }),
@@ -131,26 +142,67 @@ export default function contextExtension(pi: ExtensionAPI): void {
 		}),
 	);
 
+	pi.on("tool_execution_start", (event) => {
+		let complete = () => {};
+		const done = new Promise<void>((resolve) => {
+			complete = resolve;
+		});
+		activeToolExecutions.set(event.toolCallId, { toolName: event.toolName, done, complete });
+	});
+
+	pi.on("tool_execution_end", (event) => {
+		const execution = activeToolExecutions.get(event.toolCallId);
+		activeToolExecutions.delete(event.toolCallId);
+		execution?.complete();
+	});
+
 	pi.on("session_start", async (_event, ctx) => {
-		const root = await findProjectRoot(ctx.cwd);
-		const entries = await loadContextEntries(root);
-		let selectionData: unknown;
-		for (const entry of ctx.sessionManager.getBranch())
-			if (entry.type === "custom" && entry.customType === "tau.context-selection") selectionData = entry.data;
-		const ids =
-			typeof selectionData === "object" &&
-			selectionData !== null &&
-			"ids" in selectionData &&
-			Array.isArray(selectionData.ids)
-				? selectionData.ids.filter((id: unknown): id is string => typeof id === "string")
-				: [];
-		active = entries.filter((entry) => ids.includes(entry.id));
+		validationSettings = (await loadTauExtensionSettings(ctx, contextSettings)).validation;
+	});
+	pi.on("agent_start", async (_event, ctx) => {
+		validationSettings = (await loadTauExtensionSettings(ctx, contextSettings)).validation;
+	});
+	pi.on("agent_end", async (event, ctx) => {
+		if (
+			event.messages.some(
+				(message) =>
+					typeof message === "object" &&
+					message !== null &&
+					"role" in message &&
+					message.role === "assistant" &&
+					"stopReason" in message &&
+					message.stopReason === "aborted",
+			)
+		)
+			return;
+		if (!validationSettings.enabled || !ctx.isProjectTrusted()) {
+			lastValidationFailure = undefined;
+			return;
+		}
+		try {
+			const root = await findProjectRoot(ctx.cwd);
+			const git = createGitRunner(pi, ctx);
+			if (!(await loadRepoStatus(git))) return;
+			const failure = formatContextValidationFailure(
+				await validateContextCatalog(git, root, validationSettings.ignoreGlobs),
+			);
+			if (!failure) {
+				lastValidationFailure = undefined;
+				return;
+			}
+			if (failure === lastValidationFailure) return;
+			lastValidationFailure = failure;
+			ctx.ui.notify("Context catalog validation failed", "error");
+			pi.sendMessage(
+				{ customType: "tau.context-validation", content: failure, display: false },
+				{ triggerTurn: true },
+			);
+		} catch (error) {
+			ctx.ui.notify(`Context validation failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+		}
+	});
+	pi.on("session_shutdown", () => {
+		for (const execution of activeToolExecutions.values()) execution.complete();
+		activeToolExecutions.clear();
 	});
-	pi.on("before_agent_start", (event) =>
-		active.length
-			? {
-					systemPrompt: `${event.systemPrompt}\n\nTreat the autoread files as the authoritative project context and current snapshots. Do not reread them or search for coverage around them. Start work from them immediately. Explore outside them only when the user's request or concrete evidence in those files requires missing code or information.`,
-				}
-			: undefined,
-	);
 }

package/extensions/context/settings.ts

@@ -0,0 +1,33 @@
+import { Type } from "typebox";
+import { defineTauExtensionSettings } from "../../shared/settings/define.ts";
+
+export default defineTauExtensionSettings({
+	key: "context",
+	defaults: {
+		validation: {
+			enabled: true as boolean,
+			ignoreGlobs: [] as string[],
+		},
+	},
+	schema: Type.Object(
+		{
+			validation: Type.Optional(
+				Type.Object(
+					{
+						enabled: Type.Optional(
+							Type.Boolean({ default: true, description: "Validate context membership after agent turns." }),
+						),
+						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

@@ -6,9 +6,12 @@ import { withFileMutationQueue, type ExtensionAPI, type ExtensionContext } from
 import { parse, stringify } from "smol-toml";
 import { createGitRunner, loadRepoStatus, type GitRunner } from "../../shared/git.ts";
 import { generateToolValidated, resolveCandidates } from "../../shared/model-fallback/index.ts";
+import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
 import { truncAt } from "../../shared/text.ts";
 import { XAI_CHAT_MODEL, XAI_PROVIDER } from "../xai/constants.ts";
 import {
+	isContextEligiblePath,
+	isSensitiveContextPath,
 	loadContextEntries,
 	normalizeProjectPath,
 	pathExists,
@@ -16,6 +19,7 @@ import {
 	validSlug,
 	type ContextEntry,
 } from "./definitions.ts";
+import contextSettings from "./settings.ts";
 
 const MAX_DIRTY_EVIDENCE = 4_000;
 const MAX_STRUCTURAL_PREVIEW = 1_500;
@@ -130,14 +134,24 @@ export async function runContextSync(
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
 	onStatus?: (status: string) => void | Promise<void>,
+): Promise<ContextSyncDetails> {
+	return withSyncLock(() => runContextSyncLocked(pi, ctx, onStatus));
+}
+
+async function runContextSyncLocked(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	onStatus?: (status: string) => void | Promise<void>,
 ): Promise<ContextSyncDetails> {
 	if (!ctx.isProjectTrusted()) throw new Error("Context sync requires a trusted project");
 	await onStatus?.("Inspecting repository context");
 	const git = createGitRunner(pi, ctx);
 	const status = await loadRepoStatus(git);
 	if (!status) throw new Error("No Git repository found");
-	if (status.fileCount === 0) return noChange("Existing context mappings already fit the changed scope.");
-	const evidence = await collectSyncEvidence(git, status.root);
+	const settings = await loadTauExtensionSettings(ctx, contextSettings);
+	const evidence = await collectSyncEvidence(git, status.root, settings.validation.ignoreGlobs);
+	if (evidence.files.length === 0 && evidence.missingPaths.size === 0)
+		return noChange("Changed files are outside context catalog scope.");
 	const prompt = buildContextSyncPrompt(evidence);
 	const plan = await generateToolValidated(
 		ctx,
@@ -150,15 +164,13 @@ export async function runContextSync(
 	);
 	if (plan.outcome === "no-change") return noChange(plan.reason);
 	await onStatus?.("Applying context catalog changes");
-	return withSyncLock(async () => {
-		return applyContextSyncPlan(evidence.root, plan, evidence.entries, async () => {
-			const currentEntries = await loadContextEntries(evidence.root);
-			const currentFiles = await collectDirtyFiles(git, evidence.root, currentEntries);
-			if ((await computeWorktreeSignature(git, evidence.root, currentFiles)) !== evidence.worktreeSignature)
-				throw new Error("Repository changed during context sync. Rerun context sync.");
-			if ((await computeCatalogSignature(evidence.root)) !== evidence.catalogSignature)
-				throw new Error("Context catalog changed during context sync. Rerun context sync.");
-		});
+	return applyContextSyncPlan(evidence.root, plan, evidence.entries, async () => {
+		const currentEntries = await loadContextEntries(evidence.root);
+		const currentFiles = await collectDirtyFiles(git, evidence.root, currentEntries, settings.validation.ignoreGlobs);
+		if ((await computeWorktreeSignature(git, evidence.root, currentFiles)) !== evidence.worktreeSignature)
+			throw new Error("Repository changed during context sync. Rerun context sync.");
+		if ((await computeCatalogSignature(evidence.root)) !== evidence.catalogSignature)
+			throw new Error("Context catalog changed during context sync. Rerun context sync.");
 	});
 }
 
@@ -187,9 +199,13 @@ async function withSyncLock<T>(task: () => Promise<T>): Promise<T> {
 	}
 }
 
-async function collectSyncEvidence(git: GitRunner, root: string): Promise<SyncEvidence> {
+async function collectSyncEvidence(
+	git: GitRunner,
+	root: string,
+	ignoreGlobs: readonly string[],
+): Promise<SyncEvidence> {
 	const entries = await loadContextEntries(root);
-	const files = await collectDirtyFiles(git, root, entries);
+	const files = await collectDirtyFiles(git, root, entries, ignoreGlobs);
 	const dirtyExisting = new Set<string>();
 	for (const file of files)
 		if (file.kind !== "deleted" && (await isFile(join(root, file.path)))) dirtyExisting.add(file.path);
@@ -197,9 +213,15 @@ async function collectSyncEvidence(git: GitRunner, root: string): Promise<SyncEv
 		root,
 		files.filter((file) => dirtyExisting.has(file.path)),
 	);
+	for (const path of dependencies) if (!isContextEligiblePath(path, ignoreGlobs)) dependencies.delete(path);
+	const missingPaths = new Set<string>();
+	for (const entry of entries)
+		for (const path of entry.files)
+			if (isContextEligiblePath(path, ignoreGlobs) && !(await isFile(join(root, path)))) missingPaths.add(path);
 	const affectedIds = new Set<string>();
 	for (const entry of entries) {
 		if (
+			entry.files.some((path) => missingPaths.has(path)) ||
 			entry.files.some(
 				(path) => files.some((file) => file.path === path || file.oldPath === path) || dependencies.has(path),
 			)
@@ -208,10 +230,9 @@ async function collectSyncEvidence(git: GitRunner, root: string): Promise<SyncEv
 	}
 	const affectedConcepts = new Set([...affectedIds].map((id) => id.split("/").slice(0, 2).join("/")));
 	const siblingEntries = entries.filter((entry) => affectedConcepts.has(`${entry.tab}/${entry.concept}`));
-	const missingPaths = new Set<string>();
-	for (const entry of entries)
-		for (const path of entry.files) if (!(await isFile(join(root, path)))) missingPaths.add(path);
-	const siblingFiles = siblingEntries.flatMap((entry) => entry.files).filter((path) => !missingPaths.has(path));
+	const siblingFiles = siblingEntries
+		.flatMap((entry) => entry.files)
+		.filter((path) => !missingPaths.has(path) && isContextEligiblePath(path, ignoreGlobs));
 	const eligibleFiles = new Set([...dirtyExisting, ...dependencies, ...siblingFiles]);
 	const structuralPreviews = new Map<string, string>();
 	for (const path of [...new Set(siblingFiles)].sort()) {
@@ -247,6 +268,7 @@ async function collectDirtyFiles(
 	git: GitRunner,
 	root: string,
 	entries: readonly ContextEntry[],
+	ignoreGlobs: readonly string[],
 ): Promise<SyncDirtyFile[]> {
 	const raw = await git.run(["status", "--porcelain=v2", "-z", "--untracked-files=all"], { cwd: root });
 	const parts = raw.split("\0").filter(Boolean);
@@ -282,7 +304,22 @@ async function collectDirtyFiles(
 			index++;
 		}
 	}
-	const sorted = parsed.sort((a, b) => a.path.localeCompare(b.path));
+	const sensitive = parsed.filter(
+		(file) =>
+			file.kind !== "deleted" &&
+			(isSensitiveContextPath(file.path) || (file.oldPath !== undefined && isSensitiveContextPath(file.oldPath))),
+	);
+	if (sensitive.length > 0)
+		throw new Error(
+			`Sensitive files cannot be inspected by context sync:\n${sensitive.map((file) => `- ${file.path}`).join("\n")}`,
+		);
+	const sorted = parsed
+		.filter(
+			(file) =>
+				isContextEligiblePath(file.path, ignoreGlobs) ||
+				(file.oldPath !== undefined && isContextEligiblePath(file.oldPath, ignoreGlobs)),
+		)
+		.sort((a, b) => a.path.localeCompare(b.path));
 	const result: SyncDirtyFile[] = [];
 	for (let offset = 0; offset < sorted.length; offset += EVIDENCE_CONCURRENCY) {
 		result.push(
@@ -394,13 +431,7 @@ async function isFile(path: string): Promise<boolean> {
 
 function buildContextSyncPrompt(evidence: SyncEvidence): string {
 	const stale = evidence.entries.flatMap((entry) =>
-		entry.files
-			.filter(
-				(path) =>
-					evidence.missingPaths.has(path) &&
-					!evidence.files.some((file) => file.path === path || file.oldPath === path),
-			)
-			.map((path) => `${entry.id}: ${path}`),
+		entry.files.filter((path) => evidence.missingPaths.has(path)).map((path) => `${entry.id}: ${path}`),
 	);
 	const affected = evidence.entries.filter((entry) => evidence.affectedIds.has(entry.id));
 	const previews = [...evidence.structuralPreviews].map(([path, preview]) => `${path}\n${preview}`);
@@ -408,11 +439,11 @@ function buildContextSyncPrompt(evidence: SyncEvidence): string {
 		[
 			"Synchronize reusable repository context scopes from the supplied Git and catalog evidence.",
 			"Call submit_context_sync exactly once and produce no prose response.",
-			"Return no-change when existing mappings already support likely future work.",
+			"Return no-change only when every eligible changed file has context membership and no stale catalog paths remain.",
 			"Context entries are reusable work scopes, not inventories of every touched file. Prefer updating an existing entry over creating a near-duplicate. Do not create one entry per file.",
 			"Follow direct local dependency candidates only when needed. Do not add package dependencies, generated files, incidental imports, or recursive dependencies.",
 			"Reconsider granularity only inside affected concepts. Preserve broad entries when splitting would duplicate files without improving future work.",
-			"New or unmapped changed files may remain unmapped. Do not clean unrelated stale paths. Use only supplied candidate paths.",
+			"Every eligible changed file must belong to at least one entry. Remove every stale catalog path. Use only supplied candidate paths.",
 			"Example: replace gameplay/player/all with gameplay/player/movement and gameplay/player/input only when every still-useful file from all remains in the final entries.",
 			"Changed-file catalog and current memberships:",
 			...evidence.files.map(
@@ -432,7 +463,7 @@ function buildContextSyncPrompt(evidence: SyncEvidence): string {
 			),
 			"Changed files with no membership:",
 			evidence.files
-				.filter((file) => file.memberships.length === 0 && file.oldMemberships.length === 0)
+				.filter((file) => file.kind !== "deleted" && file.memberships.length === 0)
 				.map((file) => file.path)
 				.join("\n") || "(none)",
 			"Affected entries:",
@@ -441,7 +472,7 @@ function buildContextSyncPrompt(evidence: SyncEvidence): string {
 			[...evidence.affectedConcepts].sort().join("\n") || "(none)",
 			"Resolved direct dependency candidates:",
 			[...evidence.dependencies].sort().join("\n") || "(none)",
-			"Unrelated stale catalog paths (evidence only; do not modify):",
+			"Stale catalog paths that must be removed:",
 			stale.join("\n") || "(none)",
 			"Dirty files:",
 			...evidence.files.map(
@@ -462,6 +493,9 @@ export function normalizeContextSyncPlan(input: unknown, evidence: SyncEvidence)
 	if (!reason) throw new Error("Context sync reason is required.");
 	if (input.outcome === "no-change") {
 		if ("changes" in input) throw new Error("no-change must not include changes.");
+		const uncovered = evidence.files.filter((file) => file.kind !== "deleted" && file.memberships.length === 0);
+		if (uncovered.length > 0 || evidence.missingPaths.size > 0)
+			throw new Error("no-change cannot leave uncovered changed files or stale catalog paths.");
 		return { outcome: "no-change", reason };
 	}
 	if (!Array.isArray(input.changes) || input.changes.length === 0)
@@ -541,6 +575,12 @@ export function normalizeContextSyncPlan(input: unknown, evidence: SyncEvidence)
 			if (evidence.eligibleFiles.has(path) && ![...final.values()].some((files) => files.includes(path)))
 				throw new Error(`Deleting entry would orphan surviving file: ${path}`);
 	}
+	for (const path of evidence.dirtyExisting)
+		if (![...final.values()].some((files) => files.includes(path)))
+			throw new Error(`Context sync would leave changed file uncovered: ${path}`);
+	for (const files of final.values())
+		for (const path of files)
+			if (evidence.missingPaths.has(path)) throw new Error(`Context sync would leave stale path: ${path}`);
 	return { outcome: "apply", reason, changes };
 }
 
@@ -627,16 +667,16 @@ export async function applyContextSyncPlan(
 	for (const path of paths) originals.set(path, (await pathExists(path)) ? await readFile(path) : undefined);
 	const temporaryFiles = new Map<string, string>();
 	try {
-		for (const path of paths) {
-			const output = outputs.get(path);
-			if (output === undefined) continue;
-			await mkdir(dirname(path), { recursive: true });
-			const temporary = `${path}.${process.pid}.${Date.now()}.${temporaryFiles.size}.tmp`;
-			await writeFile(temporary, output, "utf8");
-			temporaryFiles.set(path, temporary);
-		}
 		await acquireMutationQueues(lockPaths, async () => {
 			await verifyFreshness?.();
+			for (const path of paths) {
+				const output = outputs.get(path);
+				if (output === undefined) continue;
+				await mkdir(dirname(path), { recursive: true });
+				const temporary = `${path}.${process.pid}.${Date.now()}.${temporaryFiles.size}.tmp`;
+				await writeFile(temporary, output, "utf8");
+				temporaryFiles.set(path, temporary);
+			}
 			const changed: string[] = [];
 			try {
 				for (const path of paths) {

package/extensions/context/validation.ts

@@ -0,0 +1,73 @@
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import type { GitRunner } from "../../shared/git.ts";
+import { isContextEligiblePath, isSensitiveContextPath, loadContextEntries } from "./definitions.ts";
+
+export interface ContextValidationResult {
+	stale: Array<{ path: string; ids: string[] }>;
+	uncovered: string[];
+}
+
+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 entry.files) 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 status = await git.run(["status", "--porcelain=v2", "-z", "--untracked-files=all"], { cwd: root });
+	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("\\", "/"));
+		}
+	}
+	const uncovered = [...dirty]
+		.filter(
+			(path) => !isSensitiveContextPath(path) && isContextEligiblePath(path, ignoreGlobs) && !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("", "Run context_sync to reconcile the context catalog.");
+	return output.join("\n");
+}

package/extensions/image-gen/index.ts

@@ -41,14 +41,7 @@ export default function imageGenExtension(pi: ExtensionAPI): void {
 			name: "image_gen",
 			label: "Image Generation",
 			description:
-				"Generate a new raster image from a prompt, or edit one to three local raster images. Uses the xAI Grok subscription OAuth login, saves the result under Tau's external image store unless an explicit path is provided, and returns the image for inspection.",
-			promptSnippet: "Generate or edit raster images with Grok Imagine",
-			promptGuidelines: [
-				"Use image_gen when the user asks for a generated raster image or an AI edit of local raster images.",
-				"Omit referenced_image_paths when image_gen should create a new image.",
-				"Pass one to three local paths in referenced_image_paths when image_gen should edit or compose existing images.",
-				"Omit path for temporary external storage. Pass path only when the user wants the generated image saved in their repository or another explicit location.",
-			],
+				"Generate a requested raster image or AI-edit existing images with the xAI Grok subscription OAuth login. Omit referenced_image_paths to generate; pass one to three local paths to edit or compose. Omit path to use Tau's external image store; pass path only when the user explicitly requests a repository file or other destination. Returns the image for inspection.",
 			parameters: imageGenSchema,
 			async execute(_toolCallId, params: ImageGenParams, signal, onUpdate, ctx) {
 				signal?.throwIfAborted();

package/extensions/publish/README.md

@@ -8,4 +8,4 @@ Create a tagged Tau release and monitor its GitHub Actions npm publish run.
 /publish
 ```
 
-`/publish` requires a clean Git working tree and authenticated GitHub CLI. It recommends a semantic version bump from commits since the previous release tag, asks for confirmation, then pushes a release tag. GitHub Actions publishes the TUI package before the agent package through npm trusted publishing.
+`/publish` requires a clean Git working tree, authenticated GitHub CLI, and public approved npm package sources. It recommends a semantic version bump from commits since the previous release tag, asks for confirmation, then pushes a release tag. GitHub Actions publishes the TUI package before the agent package through npm trusted publishing.

package/extensions/publish/index.ts

@@ -55,6 +55,7 @@ async function publish(pi: ExtensionAPI, ctx: ExtensionCommandContext): Promise<
 	if (repo.fileCount > 0)
 		throw new Error("Working tree is not clean. Commit or stash every change before publishing.");
 	await run(pi, ctx, "gh", ["auth", "status"], repo.root);
+	await run(pi, ctx, "npm", ["run", "check:package-sources"], repo.root);
 
 	const manifests = await loadManifests(repo.root);
 	const currentVersion = sharedVersion(manifests);

package/extensions/runtime-context/README.md

@@ -0,0 +1,5 @@
+# Runtime Context
+
+Supplies Tau with the current local date and an initial root directory snapshot as hidden session context. The snapshot remains fixed until the extension runtime restarts, while the date updates when the local day changes.
+
+After changing this extension, run `/reload` before testing the new behavior.