@shanepadgett/tau-agent 0.13.0 → 0.15.0

package/extensions/attention/README.md

@@ -4,7 +4,7 @@ Sends a terminal-driven attention notification when Tau is ready for input, fini
 
 ## Behavior
 
-- Emits an attention notification on `agent_end`.
+- Emits an attention notification after the agent settles with no automatic continuation pending.
 - Emits an attention notification on `session_compact`.
 - Emits an attention notification on `session_tree` when it includes a branch summary.
 - Listens for shared event `tau:agent.blocked` when Tau is waiting on user input.

package/extensions/attention/index.ts

@@ -66,7 +66,7 @@ export default function attentionExtension(pi: ExtensionAPI): void {
 
 	onTauEvent(pi, "attention.agent-blocked", "tau:agent.blocked", notify);
 
-	pi.on("agent_end", (_event, ctx) => {
+	pi.on("agent_settled", (_event, ctx) => {
 		if (ctx.mode === "print") return;
 		notify({ title: DEFAULT_TITLE, body: DEFAULT_BODY });
 	});

package/extensions/context/README.md

@@ -2,7 +2,7 @@
 
 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. Tau validates context membership after agent turns and asks the agent to sync uncovered changed files or stale references automatically.
+Use `/context` to select entries. Entry `files` are injected through Tau autoread. Entry `anchors` supply lazy navigation paths that the agent can grep or read in ranges when needed. Use `/context-sync` to reconcile affected scopes from the current Git changes. Tau validates both file classes as context membership after agent turns and asks the agent to sync uncovered changed files or stale references automatically.
 
 Validation is disabled by default. Enable it globally or per project in Tau settings:
 
@@ -30,6 +30,7 @@ files = ["src/player/input.ts"]
 [movement]
 description = "Player locomotion and collision"
 files = ["src/player/movement.ts"]
+anchors = ["src/runtime/fetch-handler.ts"]
 ```
 
-For example, `.pi/contexts/gameplay/player.toml` appears in the `gameplay` tab as the `Player` concept with `input` and `movement` entries.
+For example, `.pi/contexts/gameplay/player.toml` appears in the `gameplay` tab as the `Player` concept with `input` and `movement` entries. When `movement` is selected, Tau autoreads `src/player/movement.ts` and lists `src/runtime/fetch-handler.ts` as an unloaded anchor. If one selected entry marks a path as a file and another marks it as an anchor, autoread wins.

package/extensions/context/definitions.ts

@@ -13,6 +13,7 @@ export interface ContextEntry {
 	name: string;
 	description: string;
 	files: string[];
+	anchors: string[];
 	path: string;
 }
 
@@ -36,6 +37,7 @@ const CONTEXT_IGNORED_FILENAMES = new Set([
 	"uv.lock",
 	"yarn.lock",
 ]);
+const CONTEXT_ENTRY_FIELDS = new Set(["description", "files", "anchors"]);
 
 export function isContextEligiblePath(path: string, ignoreGlobs: readonly string[] = []): boolean {
 	return (
@@ -97,6 +99,10 @@ function sortedUnique(values: readonly string[]): string[] {
 	return [...new Set(values)].sort((a, b) => a.localeCompare(b));
 }
 
+export function contextEntryPaths(entry: Pick<ContextEntry, "files" | "anchors">): string[] {
+	return sortedUnique([...entry.files, ...entry.anchors]);
+}
+
 export async function requireFiles(root: string, inputs: readonly string[]): Promise<string[]> {
 	const files = sortedUnique(inputs.map((input) => normalizeProjectPath(root, input)));
 	for (const file of files) {
@@ -132,15 +138,24 @@ export async function loadContextEntries(root: string): Promise<ContextEntry[]>
 				if (!value || typeof value !== "object" || Array.isArray(value))
 					throw new Error(`Invalid context entry: ${path} [${name}]`);
 				const record = value as Record<string, unknown>;
+				const unknownField = Object.keys(record).find((field) => !CONTEXT_ENTRY_FIELDS.has(field));
+				if (unknownField) throw new Error(`Invalid context entry field: ${path} [${name}] ${unknownField}`);
+				const anchors = record.anchors ?? [];
 				if (
 					typeof record.description !== "string" ||
 					!record.description.trim() ||
 					!Array.isArray(record.files) ||
-					record.files.length === 0 ||
-					record.files.some((item) => typeof item !== "string")
+					record.files.some((item) => typeof item !== "string") ||
+					!Array.isArray(anchors) ||
+					anchors.some((item) => typeof item !== "string") ||
+					(record.files.length === 0 && anchors.length === 0)
 				)
 					throw new Error(`Invalid context entry: ${path} [${name}]`);
 				const entry = validSlug(name, "Context entry");
+				const entryFiles = sortedUnique((record.files as string[]).map((item) => normalizeProjectPath(root, item)));
+				const entryAnchors = sortedUnique((anchors as string[]).map((item) => normalizeProjectPath(root, item)));
+				const overlap = entryFiles.find((item) => entryAnchors.includes(item));
+				if (overlap) throw new Error(`Context path cannot be both file and anchor: ${path} [${name}] ${overlap}`);
 				result.push({
 					id: `${tab}/${concept}/${entry}`,
 					tab,
@@ -149,7 +164,8 @@ export async function loadContextEntries(root: string): Promise<ContextEntry[]>
 					conceptDescription,
 					name: entry,
 					description: record.description.trim(),
-					files: sortedUnique((record.files as string[]).map((item) => normalizeProjectPath(root, item))),
+					files: entryFiles,
+					anchors: entryAnchors,
 					path,
 				});
 			}

package/extensions/context/index.ts

@@ -53,19 +53,35 @@ export default function contextExtension(pi: ExtensionAPI): void {
 			);
 			if (!selected?.length) return;
 			const files = [...new Set(selected.flatMap((entry) => entry.files))].sort();
+			const fileSet = new Set(files);
+			const anchors = [...new Set(selected.flatMap((entry) => entry.anchors))]
+				.filter((path) => !fileSet.has(path))
+				.sort();
 			pi.sendMessage(
 				createInjectedContext(
-					"Treat 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.",
+					[
+						"Selected repository context:",
+						...selected.map((entry) => `- ${entry.id}: ${entry.description}`),
+						"",
+						"Eager snapshots supplied through autoread:",
+						...(files.length ? files.map((path) => `- ${path}`) : ["(none)"]),
+						"",
+						"Lazy navigation anchors whose contents have not been loaded:",
+						...(anchors.length ? anchors.map((path) => `- ${path}`) : ["(none)"]),
+						"",
+						"Treat eager snapshots as authoritative current project context. Do not reread them or search for coverage around them. Inspect only the anchors needed for the request, using grep or bounded reads. Explore elsewhere only when the request or concrete evidence requires missing information.",
+					].join("\n"),
 					{ source: "context", title: "Project context" },
 				),
 			);
-			emitTauEvent(pi, "tau:autoread.requested", {
-				source: "context",
-				title: "Project context",
-				cwd: root,
-				batchId: randomUUID(),
-				files: files.map((path) => ({ path })),
-			});
+			if (files.length)
+				emitTauEvent(pi, "tau:autoread.requested", {
+					source: "context",
+					title: "Project context",
+					cwd: root,
+					batchId: randomUUID(),
+					files: files.map((path) => ({ path })),
+				});
 		},
 	});
 

package/extensions/context/panel.ts

@@ -73,14 +73,15 @@ export class ContextPanel implements Component {
 		const list = this.activeList();
 		if (!list?.isFilterFocused()) {
 			const keys = getKeybindings();
-			const pageSize = this.filePageSize();
-			if (this.current.files.length > pageSize && matchesKey(data, Key.alt("up"))) {
+			const paths = this.currentPaths();
+			const pageSize = this.pathPageSize();
+			if (paths.length > pageSize && matchesKey(data, Key.alt("up"))) {
 				this.fileOffset = Math.max(0, this.fileOffset - pageSize);
 				this.sync();
 				return;
 			}
-			if (this.current.files.length > pageSize && matchesKey(data, Key.alt("down"))) {
-				this.fileOffset = Math.min(this.current.files.length - pageSize, this.fileOffset + pageSize);
+			if (paths.length > pageSize && matchesKey(data, Key.alt("down"))) {
+				this.fileOffset = Math.min(paths.length - pageSize, this.fileOffset + pageSize);
 				this.sync();
 				return;
 			}
@@ -122,35 +123,51 @@ export class ContextPanel implements Component {
 		return {
 			render: (width) => {
 				const tabs = this.tabs.render(width);
-				const pageSize = this.filePageSize(tabs.length);
-				const maxOffset = Math.max(0, this.current.files.length - pageSize);
+				const paths = this.currentPaths();
+				const pageSize = this.pathPageSize(tabs.length);
+				const maxOffset = Math.max(0, paths.length - pageSize);
 				this.fileOffset = Math.min(this.fileOffset, maxOffset);
-				const files = this.current.files.slice(this.fileOffset, this.fileOffset + pageSize);
+				const visible = paths.slice(this.fileOffset, this.fileOffset + pageSize);
 				const range =
-					this.current.files.length > pageSize
+					paths.length > pageSize
 						? this.theme.fg(
 								"dim",
-								`${this.fileOffset + 1}-${this.fileOffset + files.length} of ${this.current.files.length} files`,
+								`${this.fileOffset + 1}-${this.fileOffset + visible.length} of ${paths.length} paths`,
 							)
 						: undefined;
 				return [
 					...tabs,
 					"",
 					...(range ? [truncateToWidth(range, width, "…")] : []),
-					...files.map((file) => truncateToWidth(this.theme.fg("muted", `• ${file}`), width, "…")),
+					...visible.map(({ kind, path }) =>
+						truncateToWidth(
+							this.theme.fg(
+								kind === "read" ? "muted" : "dim",
+								`${kind === "read" ? "read" : "anchor"} • ${path}`,
+							),
+							width,
+							"…",
+						),
+					),
 				];
 			},
 			invalidate: () => this.tabs.invalidate(),
 		};
 	}
-	private filePageSize(tabLines = this.tabs.render(this.tui.terminal.columns).length): number {
+	private currentPaths(): Array<{ kind: "read" | "anchor"; path: string }> {
+		return [
+			...this.current.files.map((path) => ({ kind: "read" as const, path })),
+			...this.current.anchors.map((path) => ({ kind: "anchor" as const, path })),
+		];
+	}
+	private pathPageSize(tabLines = this.tabs.render(this.tui.terminal.columns).length): number {
 		const overlayHeight = Math.floor(this.tui.terminal.rows * 0.8);
 		const available = Math.max(1, overlayHeight - tabLines - 7);
 		const pageSize = Math.min(8, available);
-		return this.current.files.length > pageSize ? Math.max(1, pageSize - 1) : pageSize;
+		return this.currentPaths().length > pageSize ? Math.max(1, pageSize - 1) : pageSize;
 	}
 	private secondary(): string {
-		return `${[...this.selected.values()].reduce((sum, items) => sum + items.length, 0)} selected`;
+		return `${[...this.selected.values()].reduce((sum, items) => sum + items.length, 0)} selected · ${this.current.files.length} read · ${this.current.anchors.length} anchors`;
 	}
 	private hints() {
 		const list = this.activeList();
@@ -158,7 +175,7 @@ export class ContextPanel implements Component {
 			? list.getKeyHints()
 			: [
 					...this.tabs.getKeyHints(),
-					...(this.current.files.length > this.filePageSize() ? [rawHint("option+↑/↓", "scroll files")] : []),
+					...(this.currentPaths().length > this.pathPageSize() ? [rawHint("option+↑/↓", "scroll paths")] : []),
 					rawHint("ctrl+c", "clear all"),
 					bindingHint("tui.select.confirm", "inject"),
 					bindingHint("tui.select.cancel", "cancel"),

package/extensions/context/sync.ts

@@ -8,8 +8,8 @@ import { createGitRunner, loadRepoStatus, type GitRunner } from "../../shared/gi
 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 {
+	contextEntryPaths,
 	isContextEligiblePath,
 	isSensitiveContextPath,
 	loadContextEntries,
@@ -31,7 +31,7 @@ const CONTEXT_SYNC_MODELS: ReadonlyArray<{ provider: string; model: string; reas
 	{ provider: "openai-codex", model: "gpt-5.6-terra", reasoning: "medium" },
 	{ provider: "openai-codex", model: "gpt-5.6-sol", reasoning: "low" },
 	{ provider: "anthropic", model: "claude-sonnet-5", reasoning: "low" },
-	{ provider: XAI_PROVIDER, model: XAI_CHAT_MODEL, reasoning: "high" },
+	{ provider: "xai", model: "grok-4.5", reasoning: "high" },
 ];
 
 const SUBMIT_TOOL = {
@@ -216,13 +216,14 @@ async function collectSyncEvidence(
 	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)
+		for (const path of contextEntryPaths(entry))
 			if (isContextEligiblePath(path, ignoreGlobs) && !(await isFile(join(root, path)))) missingPaths.add(path);
 	const affectedIds = new Set<string>();
 	for (const entry of entries) {
+		const paths = contextEntryPaths(entry);
 		if (
-			entry.files.some((path) => missingPaths.has(path)) ||
-			entry.files.some(
+			paths.some((path) => missingPaths.has(path)) ||
+			paths.some(
 				(path) => files.some((file) => file.path === path || file.oldPath === path) || dependencies.has(path),
 			)
 		)
@@ -231,7 +232,7 @@ async function collectSyncEvidence(
 	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 siblingFiles = siblingEntries
-		.flatMap((entry) => entry.files)
+		.flatMap((entry) => contextEntryPaths(entry))
 		.filter((path) => !missingPaths.has(path) && isContextEligiblePath(path, ignoreGlobs));
 	const eligibleFiles = new Set([...dirtyExisting, ...dependencies, ...siblingFiles]);
 	const structuralPreviews = new Map<string, string>();
@@ -327,9 +328,13 @@ async function collectDirtyFiles(
 				sorted.slice(offset, offset + EVIDENCE_CONCURRENCY).map(async (file, inner) => ({
 					...file,
 					id: offset + inner + 1,
-					memberships: entries.filter((entry) => entry.files.includes(file.path)).map((entry) => entry.id),
+					memberships: entries
+						.filter((entry) => contextEntryPaths(entry).includes(file.path))
+						.map((entry) => entry.id),
 					oldMemberships: file.oldPath
-						? entries.filter((entry) => entry.files.includes(file.oldPath ?? "")).map((entry) => entry.id)
+						? entries
+								.filter((entry) => contextEntryPaths(entry).includes(file.oldPath ?? ""))
+								.map((entry) => entry.id)
 						: [],
 					evidence: await dirtyEvidence(git, root, file),
 				})),
@@ -431,7 +436,9 @@ 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)).map((path) => `${entry.id}: ${path}`),
+		contextEntryPaths(entry)
+			.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}`);
@@ -441,6 +448,7 @@ function buildContextSyncPrompt(evidence: SyncEvidence): string {
 			"Call submit_context_sync exactly once and produce no prose response.",
 			"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.",
+			"The files field in your changes is desired membership, including eager files and lazy anchors. Paths already classified anywhere in the catalog preserve their loading class; new paths become eager files. Do not change loading policy.",
 			"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.",
 			"Every eligible changed file must belong to at least one entry. Remove every stale catalog path. Use only supplied candidate paths.",
@@ -457,8 +465,9 @@ function buildContextSyncPrompt(evidence: SyncEvidence): string {
 					conceptName: entry.conceptName,
 					conceptDescription: entry.conceptDescription,
 					description: entry.description,
-					files: entry.files,
-					missingFiles: entry.files.filter((path) => evidence.missingPaths.has(path)),
+					eagerFiles: entry.files,
+					anchors: entry.anchors,
+					missingFiles: contextEntryPaths(entry).filter((path) => evidence.missingPaths.has(path)),
 				})),
 			),
 			"Changed files with no membership:",
@@ -540,7 +549,7 @@ export function normalizeContextSyncPlan(input: unknown, evidence: SyncEvidence)
 				throw new Error(`Entry is unrelated: ${id}`);
 			if (conceptName !== existing.conceptName || conceptDescription !== existing.conceptDescription)
 				throw new Error(`Existing concept metadata cannot change: ${conceptId}`);
-			if (description === existing.description && files.join("\0") === existing.files.join("\0"))
+			if (description === existing.description && files.join("\0") === contextEntryPaths(existing).join("\0"))
 				throw new Error(`Set-entry is identical: ${id}`);
 		} else {
 			const existingConcept = evidence.entries.find((item) => item.tab === tab && item.concept === concept);
@@ -560,7 +569,7 @@ export function normalizeContextSyncPlan(input: unknown, evidence: SyncEvidence)
 		}
 		changes.push({ action: "set-entry", tab, concept, conceptName, conceptDescription, entry, description, files });
 	}
-	const final = new Map(evidence.entries.map((entry) => [entry.id, [...entry.files]]));
+	const final = new Map(evidence.entries.map((entry) => [entry.id, contextEntryPaths(entry)]));
 	for (const change of changes) {
 		const id = `${change.tab}/${change.concept}/${change.entry}`;
 		if (change.action === "delete-entry") final.delete(id);
@@ -571,7 +580,7 @@ export function normalizeContextSyncPlan(input: unknown, evidence: SyncEvidence)
 	)) {
 		const old = current.get(`${change.tab}/${change.concept}/${change.entry}`);
 		if (!old) continue;
-		for (const path of old.files)
+		for (const path of contextEntryPaths(old))
 			if (evidence.eligibleFiles.has(path) && ![...final.values()].some((files) => files.includes(path)))
 				throw new Error(`Deleting entry would orphan surviving file: ${path}`);
 	}
@@ -640,6 +649,8 @@ export async function applyContextSyncPlan(
 ): Promise<ContextSyncDetails> {
 	for (const change of plan.changes) if (change.action === "set-entry") await requireFiles(root, change.files);
 	const concepts = [...new Set(plan.changes.map((change) => `${change.tab}/${change.concept}`))].sort();
+	const eagerPaths = new Set(entries.flatMap((entry) => entry.files));
+	const anchorPaths = new Set(entries.flatMap((entry) => entry.anchors).filter((path) => !eagerPaths.has(path)));
 	const outputs = new Map<string, string | undefined>();
 	for (const key of concepts) {
 		const [tab, concept] = key.split("/");
@@ -653,7 +664,12 @@ export async function applyContextSyncPlan(
 			else {
 				if (raw.name === undefined) raw.name = change.conceptName;
 				if (raw.description === undefined) raw.description = change.conceptDescription;
-				raw[change.entry] = { description: change.description, files: change.files };
+				const anchors = change.files.filter((path) => anchorPaths.has(path));
+				raw[change.entry] = {
+					description: change.description,
+					files: change.files.filter((path) => !anchors.includes(path)),
+					...(anchors.length ? { anchors } : {}),
+				};
 			}
 		}
 		outputs.set(

package/extensions/context/validation.ts

@@ -1,7 +1,7 @@
 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";
+import { contextEntryPaths, isContextEligiblePath, isSensitiveContextPath, loadContextEntries } from "./definitions.ts";
 
 export interface ContextValidationResult {
 	stale: Array<{ path: string; ids: string[] }>;
@@ -16,7 +16,7 @@ export async function validateContextCatalog(
 	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]);
+		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) {

package/extensions/image-gen/README.md

@@ -2,10 +2,10 @@
 
 `image_gen` generates raster images and edits up to three local raster images with Grok Imagine. It uses `grok-imagine-image-quality` and saves results under `~/.local/share/tau-agent/images/` by default. Pass an explicit path with the expected image extension when the image should be saved in the current repository or another chosen location.
 
-Use `/login` and select xAI (Grok subscription OAuth) before invoking the tool. No xAI API key is used.
+Run `/login xai` and choose either a subscription or API-key login before invoking the tool.
 
 Run `/reload` after installing or changing the extension.
 
 The model invokes `image_gen` with a prompt. For edits, it also supplies one to three local PNG, JPEG, or WebP paths. Successful images up to 12 MiB are returned inline for inspection; larger results remain available at the saved path.
 
-This extension uses xAI's undocumented subscription OAuth access. xAI may change its availability, entitlement rules, or protocol without notice.
+xAI controls model availability and subscription entitlements. A successful login does not guarantee that every account can use Grok Imagine.

package/extensions/image-gen/client.ts

@@ -1,4 +1,4 @@
-import { XAI_API_BASE_URL, XAI_IMAGE_MODEL } from "../xai/constants.ts";
+import { XAI_API_BASE_URL, XAI_IMAGE_MODEL } from "./constants.ts";
 
 const MAX_ERROR_BODY_BYTES = 8192;
 const MAX_ERROR_MESSAGE_LENGTH = 2000;

package/extensions/image-gen/constants.ts

@@ -0,0 +1,3 @@
+export const XAI_PROVIDER = "xai";
+export const XAI_IMAGE_MODEL = "grok-imagine-image-quality";
+export const XAI_API_BASE_URL = "https://api.x.ai/v1";

package/extensions/image-gen/index.ts

@@ -4,8 +4,8 @@ import { link, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { type Static, Type } from "typebox";
-import { XAI_IMAGE_MODEL, XAI_PROVIDER } from "../xai/constants.ts";
 import { detectImageMimeType, editImage, generateImage, type EditImage, type GeneratedImage } from "./client.ts";
+import { XAI_IMAGE_MODEL, XAI_PROVIDER } from "./constants.ts";
 
 const MAX_INPUT_BYTES = 50 * 1024 * 1024;
 const MAX_INLINE_BYTES = 12 * 1024 * 1024;
@@ -41,7 +41,7 @@ export default function imageGenExtension(pi: ExtensionAPI): void {
 			name: "image_gen",
 			label: "Image Generation",
 			description:
-				"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.",
+				"Generate a requested raster image or AI-edit existing images with configured xAI authentication. 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();
@@ -63,7 +63,7 @@ export default function imageGenExtension(pi: ExtensionAPI): void {
 
 				const token = await ctx.modelRegistry.getApiKeyForProvider(XAI_PROVIDER);
 				if (!token) {
-					throw new Error("xAI OAuth is unavailable. Run /login and select xAI (Grok subscription OAuth).");
+					throw new Error("xAI authentication is unavailable. Run /login xai and choose a login method.");
 				}
 				const images: EditImage[] = [];
 				for (const path of params.referenced_image_paths ?? []) {

package/extensions/run-summary/README.md

@@ -1,5 +1,5 @@
 # Run Summary
 
-Run Summary adds a compact marker after each agent run. It shows wall time, direct run cost, delegated subagent cost, and their combined total.
+Run Summary adds a compact marker after the agent settles with no automatic continuation pending. It shows wall time, direct run cost, delegated subagent cost, and their combined total across the full continuation chain.
 
 The marker is stored as a display-only session entry. It does not enter model context or trigger another agent turn.

package/extensions/run-summary/index.ts

@@ -13,6 +13,8 @@ interface RunSummary {
 
 export default function runSummaryExtension(pi: ExtensionAPI): void {
 	let startedAt: number | undefined;
+	let runCost = 0;
+	let subagentCost = 0;
 
 	pi.registerEntryRenderer<RunSummary>(ENTRY_TYPE, (entry, _options, theme) => {
 		const summary = readRunSummary(entry.data);
@@ -32,18 +34,15 @@ export default function runSummaryExtension(pi: ExtensionAPI): void {
 
 	pi.on("session_start", () => {
 		startedAt = undefined;
+		runCost = 0;
+		subagentCost = 0;
 	});
 
 	pi.on("agent_start", () => {
-		startedAt = performance.now();
+		startedAt ??= performance.now();
 	});
 
 	pi.on("agent_end", (event) => {
-		if (startedAt === undefined) return;
-		const wallMs = Math.max(0, performance.now() - startedAt);
-		startedAt = undefined;
-		let runCost = 0;
-		let subagentCost = 0;
 		for (const message of event.messages) {
 			if (message.role === "assistant") {
 				runCost += finiteNonNegative((message as AssistantMessage).usage.cost.total);
@@ -52,12 +51,20 @@ export default function runSummaryExtension(pi: ExtensionAPI): void {
 			if (message.role !== "toolResult" || message.toolName !== "subagent") continue;
 			subagentCost += readSubagentCost(message.details);
 		}
+	});
+
+	pi.on("agent_settled", () => {
+		if (startedAt === undefined) return;
+		const wallMs = Math.max(0, performance.now() - startedAt);
+		startedAt = undefined;
 		pi.appendEntry<RunSummary>(ENTRY_TYPE, {
 			wallMs,
 			runCost,
 			subagentCost,
 			totalCost: runCost + subagentCost,
 		});
+		runCost = 0;
+		subagentCost = 0;
 	});
 }
 

package/extensions/silent-command-runner/index.ts

@@ -80,6 +80,8 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 	let turnPaths = new Set<string>();
 	let run: Promise<void> | undefined;
 	let abortController: AbortController | undefined;
+	let lastRunAborted = false;
+	let chainActive = false;
 
 	pi.registerMessageRenderer<FailureDetails>(MESSAGE_TYPE, (message, { expanded }, theme) =>
 		renderFailure(asFailureDetails(message.details), expanded, theme),
@@ -89,6 +91,8 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 		settings = normalizeSettings(await loadTauExtensionSettings(ctx, silentCommandRunnerSettings));
 		turnStart = Date.now();
 		turnPaths = new Set();
+		lastRunAborted = false;
+		chainActive = false;
 	});
 
 	pi.on("before_agent_start", async (event, ctx) => {
@@ -98,6 +102,9 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 	});
 
 	pi.on("agent_start", async (_event, ctx) => {
+		lastRunAborted = false;
+		if (chainActive) return;
+		chainActive = true;
 		turnStart = Date.now();
 		if (!settings.enabled || settings.commands.length === 0) {
 			turnPaths = new Set();
@@ -107,8 +114,13 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 		turnPaths = new Set(await walkFiles(projectRoot));
 	});
 
-	pi.on("agent_end", async (event, ctx) => {
-		if (hasAbortedAssistantMessage(event.messages)) return;
+	pi.on("agent_end", (event) => {
+		lastRunAborted = hasAbortedAssistantMessage(event.messages);
+	});
+
+	pi.on("agent_settled", async (_event, ctx) => {
+		chainActive = false;
+		if (lastRunAborted) return;
 		if (run) return;
 		run = runChangedCommands(ctx.cwd, turnStart, ctx.ui.notify)
 			.catch((error: unknown) => {
@@ -125,6 +137,8 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 		abortController = undefined;
 		run = undefined;
 		turnPaths = new Set();
+		lastRunAborted = false;
+		chainActive = false;
 	});
 
 	async function runChangedCommands(

package/extensions/subagent/run.ts

@@ -232,7 +232,6 @@ export async function createSubagentThread(options: {
 			cwd: ctx.cwd,
 			model,
 			thinkingLevel: thinkingLevel as "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max",
-			modelRegistry: ctx.modelRegistry,
 			tools: definition.tools,
 			excludeTools: ["subagent"],
 			resourceLoader,

package/extensions/tau-help/help.md

@@ -28,7 +28,7 @@ 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. Context validation is disabled by default; when enabled, Tau checks 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` 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.
 
 ## explore
 
@@ -44,11 +44,7 @@ Adds `/ideas` to log rough ideas or open the ideas browser.
 
 ## image-gen
 
-Gives the agent an image-generation tool using the configured image service. Generated images are saved for inspection.
-
-## xai
-
-Adds Grok 4.5 and Grok Imagine through an xAI Grok subscription OAuth login. Run `/login` and select xAI before use.
+Gives the agent a Grok Imagine generation and editing tool. Run `/login xai` and choose a subscription or API-key login before use. Generated images are saved for inspection.
 
 ## manage-sessions
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shanepadgett/tau-agent",
-	"version": "0.13.0",
+	"version": "0.15.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.13.0",
+		"@shanepadgett/tau-tui": "0.15.0",
 		"@toon-format/toon": "2.3.0",
 		"smol-toml": "1.7.0"
 	},

package/extensions/xai/README.md

@@ -1,7 +0,0 @@
-# xAI OAuth
-
-Adds Grok 4.5 using an xAI Grok subscription login. Run `/login`, select **xAI (Grok subscription OAuth)**, then authorize xAI in the browser. An existing official Grok CLI login can also be reused.
-
-The same login powers Tau's `image_gen` tool through Grok Imagine. No xAI API key is used.
-
-This integration uses xAI's undocumented subscription OAuth access. xAI may change its availability, entitlement rules, or protocol without notice.

package/extensions/xai/auth.ts

@@ -1,40 +0,0 @@
-import type { OAuthCredentials } from "@earendil-works/pi-ai";
-import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { XAI_OAUTH_CLIENT_ID, XAI_OAUTH_ISSUER } from "./constants.ts";
-
-function expiry(value: unknown): number | undefined {
-	if (typeof value === "number" && Number.isInteger(value) && value >= 1_000_000_000_000) return value;
-	if (typeof value !== "string") return undefined;
-	const parsed = Date.parse(value);
-	return Number.isFinite(parsed) ? parsed : undefined;
-}
-
-export function parseGrokCredentials(value: unknown): OAuthCredentials | undefined {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
-	const entry = (value as Record<string, unknown>)[`${XAI_OAUTH_ISSUER}::${XAI_OAUTH_CLIENT_ID}`];
-	if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return undefined;
-	const record = entry as Record<string, unknown>;
-	const expires = expiry(record.expires_at);
-	if (
-		typeof record.key !== "string" ||
-		!record.key ||
-		typeof record.refresh_token !== "string" ||
-		!record.refresh_token ||
-		record.oidc_issuer !== XAI_OAUTH_ISSUER ||
-		record.oidc_client_id !== XAI_OAUTH_CLIENT_ID ||
-		expires === undefined
-	) {
-		return undefined;
-	}
-	return { access: record.key, refresh: record.refresh_token, expires };
-}
-
-export async function readGrokCredentials(): Promise<OAuthCredentials | undefined> {
-	try {
-		return parseGrokCredentials(JSON.parse(await readFile(join(homedir(), ".grok", "auth.json"), "utf8")));
-	} catch {
-		return undefined;
-	}
-}

package/extensions/xai/constants.ts

@@ -1,11 +0,0 @@
-export const XAI_PROVIDER = "xai-oauth";
-export const XAI_CHAT_MODEL = "grok-4.5";
-export const XAI_IMAGE_MODEL = "grok-imagine-image-quality";
-export const XAI_API_BASE_URL = "https://api.x.ai/v1";
-
-export const XAI_OAUTH_ISSUER = "https://auth.x.ai";
-export const XAI_OAUTH_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
-export const XAI_OAUTH_SCOPE = "openid profile email offline_access grok-cli:access api:access";
-export const XAI_OAUTH_CALLBACK_HOST = "127.0.0.1";
-export const XAI_OAUTH_CALLBACK_PORT = 56121;
-export const XAI_OAUTH_CALLBACK_PATH = "/callback";

package/extensions/xai/index.ts

@@ -1,38 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { XAI_API_BASE_URL, XAI_CHAT_MODEL, XAI_PROVIDER } from "./constants.ts";
-import { xaiOAuth } from "./oauth.ts";
-import { rewriteXaiPayload } from "./payload.ts";
-
-export default function xaiExtension(pi: ExtensionAPI): void {
-	pi.registerProvider(XAI_PROVIDER, {
-		name: "xAI (Grok subscription OAuth)",
-		baseUrl: XAI_API_BASE_URL,
-		api: "openai-responses",
-		authHeader: true,
-		oauth: xaiOAuth,
-		models: [
-			{
-				id: XAI_CHAT_MODEL,
-				name: "Grok 4.5",
-				reasoning: true,
-				input: ["text", "image"],
-				cost: { input: 2, output: 6, cacheRead: 0.5, cacheWrite: 0 },
-				contextWindow: 500_000,
-				maxTokens: 131_072,
-				thinkingLevelMap: {
-					off: null,
-					minimal: "low",
-					low: "low",
-					medium: "medium",
-					high: "high",
-					xhigh: null,
-					max: null,
-				},
-			},
-		],
-	});
-	pi.on("before_provider_request", (event, ctx) => {
-		if (ctx.model?.provider !== XAI_PROVIDER) return;
-		return rewriteXaiPayload(event.payload);
-	});
-}

package/extensions/xai/oauth.ts

@@ -1,342 +0,0 @@
-import type { OAuthCredentials, OAuthLoginCallbacks } from "@earendil-works/pi-ai";
-import { createHash, randomBytes } from "node:crypto";
-import { createServer, type Server } from "node:http";
-import { readGrokCredentials } from "./auth.ts";
-import {
-	XAI_OAUTH_CALLBACK_HOST,
-	XAI_OAUTH_CALLBACK_PATH,
-	XAI_OAUTH_CALLBACK_PORT,
-	XAI_OAUTH_CLIENT_ID,
-	XAI_OAUTH_ISSUER,
-	XAI_OAUTH_SCOPE,
-} from "./constants.ts";
-
-const DISCOVERY_URL = `${XAI_OAUTH_ISSUER}/.well-known/openid-configuration`;
-const REQUEST_TIMEOUT_MS = 30_000;
-const LOGIN_TIMEOUT_MS = 180_000;
-const REFRESH_SKEW_MS = 120_000;
-
-interface Discovery {
-	authorization_endpoint: string;
-	token_endpoint: string;
-}
-
-interface TokenPayload {
-	access_token?: unknown;
-	refresh_token?: unknown;
-	id_token?: unknown;
-	expires_in?: unknown;
-	token_type?: unknown;
-}
-
-interface HttpResponse {
-	ok: boolean;
-	status: number;
-	body: { cancel(): Promise<void> } | null;
-	json(): Promise<unknown>;
-}
-
-interface CallbackResult {
-	code?: string;
-	error?: string;
-	errorDescription?: string;
-}
-
-function validatedEndpoint(value: unknown, field: string): string {
-	if (typeof value !== "string") throw new Error(`xAI OAuth discovery omitted ${field}`);
-	const url = new URL(value);
-	const host = url.hostname.toLowerCase();
-	if (url.protocol !== "https:" || (host !== "x.ai" && !host.endsWith(".x.ai"))) {
-		throw new Error(`xAI OAuth discovery returned an unexpected ${field}`);
-	}
-	return url.toString();
-}
-
-function requestSignal(parent?: AbortSignal): AbortSignal {
-	const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
-	return parent ? AbortSignal.any([parent, timeout]) : timeout;
-}
-
-async function discover(signal?: AbortSignal): Promise<Discovery> {
-	const response = (await fetch(DISCOVERY_URL, {
-		headers: { Accept: "application/json" },
-		signal: requestSignal(signal),
-	})) as HttpResponse;
-	if (!response.ok) throw new Error(`xAI OAuth discovery failed with status ${response.status}`);
-	const value: unknown = await response.json();
-	if (typeof value !== "object" || value === null || Array.isArray(value)) {
-		throw new Error("xAI OAuth discovery returned invalid JSON");
-	}
-	const record = value as Record<string, unknown>;
-	return {
-		authorization_endpoint: validatedEndpoint(record.authorization_endpoint, "authorization_endpoint"),
-		token_endpoint: validatedEndpoint(record.token_endpoint, "token_endpoint"),
-	};
-}
-
-async function tokenRequest(endpoint: string, body: URLSearchParams, signal?: AbortSignal): Promise<TokenPayload> {
-	const response = (await fetch(validatedEndpoint(endpoint, "token_endpoint"), {
-		method: "POST",
-		headers: { Accept: "application/json", "Content-Type": "application/x-www-form-urlencoded" },
-		body,
-		signal: requestSignal(signal),
-	})) as HttpResponse;
-	if (!response.ok) {
-		await response.body?.cancel().catch(() => undefined);
-		throw new Error(`xAI OAuth token request failed with status ${response.status}`);
-	}
-	return (await response.json()) as TokenPayload;
-}
-
-function jwtClaims(token: string): Record<string, unknown> {
-	const segments = token.split(".");
-	if (segments.length !== 3 || !segments[1]) throw new Error("xAI OAuth returned an invalid ID token");
-	try {
-		const value: unknown = JSON.parse(Buffer.from(segments[1], "base64url").toString("utf8"));
-		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error();
-		return value as Record<string, unknown>;
-	} catch {
-		throw new Error("xAI OAuth returned an invalid ID token");
-	}
-}
-
-function credentials(payload: TokenPayload, endpoint: string, fallbackRefresh = "", nonce?: string): OAuthCredentials {
-	if (typeof payload.access_token !== "string" || !payload.access_token) {
-		throw new Error("xAI OAuth token response omitted the access token");
-	}
-	const refresh =
-		typeof payload.refresh_token === "string" && payload.refresh_token ? payload.refresh_token : fallbackRefresh;
-	if (!refresh) throw new Error("xAI OAuth token response omitted the refresh token");
-	if (nonce !== undefined) {
-		if (typeof payload.id_token !== "string" || !payload.id_token)
-			throw new Error("xAI OAuth token response omitted the ID token");
-		const claims = jwtClaims(payload.id_token);
-		const audience = claims.aud;
-		const validAudience =
-			audience === XAI_OAUTH_CLIENT_ID || (Array.isArray(audience) && audience.includes(XAI_OAUTH_CLIENT_ID));
-		if (claims.iss !== XAI_OAUTH_ISSUER || !validAudience || claims.nonce !== nonce) {
-			throw new Error("xAI OAuth ID token validation failed");
-		}
-		if (typeof claims.exp !== "number" || claims.exp * 1000 <= Date.now()) {
-			throw new Error("xAI OAuth returned an expired ID token");
-		}
-	}
-	const expiresIn = typeof payload.expires_in === "number" && payload.expires_in > 0 ? payload.expires_in : 3600;
-	return {
-		access: payload.access_token,
-		refresh,
-		expires: Date.now() + expiresIn * 1000 - REFRESH_SKEW_MS,
-		tokenEndpoint: endpoint,
-	};
-}
-
-async function closeServer(server: Server): Promise<void> {
-	if (!server.listening) return;
-	await new Promise<void>((resolve) => server.close(() => resolve()));
-}
-
-async function callbackServer(expectedState: string): Promise<{
-	redirectUri: string;
-	wait(signal?: AbortSignal): Promise<CallbackResult>;
-	acceptManual(input: string): string | undefined;
-	close(): Promise<void>;
-}> {
-	let settle: ((result: CallbackResult) => void) | undefined;
-	let reject: ((error: Error) => void) | undefined;
-	let settled = false;
-	const result = new Promise<CallbackResult>((resolve, rejectResult) => {
-		settle = resolve;
-		reject = rejectResult;
-	});
-	const accept = (value: CallbackResult) => {
-		if (settled) return;
-		settled = true;
-		settle?.(value);
-	};
-	const parse = (params: URLSearchParams): CallbackResult | undefined => {
-		if (params.get("state") !== expectedState) return undefined;
-		const code = params.get("code") || undefined;
-		const error = params.get("error") || undefined;
-		if (!code && !error) return undefined;
-		return { code, error, errorDescription: params.get("error_description") || undefined };
-	};
-	const server = createServer((request, response) => {
-		const origin = request.headers.origin;
-		if (origin === "https://accounts.x.ai" || origin === "https://auth.x.ai") {
-			response.setHeader("Access-Control-Allow-Origin", origin);
-			response.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
-			response.setHeader("Access-Control-Allow-Headers", "Content-Type");
-			response.setHeader("Access-Control-Allow-Private-Network", "true");
-			response.setHeader("Vary", "Origin");
-		}
-		if (request.method === "OPTIONS") {
-			response.writeHead(204).end();
-			return;
-		}
-		const url = new URL(request.url ?? "/", `http://${XAI_OAUTH_CALLBACK_HOST}`);
-		if (request.method !== "GET" || url.pathname !== XAI_OAUTH_CALLBACK_PATH) {
-			response.writeHead(404).end("Not found");
-			return;
-		}
-		const parsed = parse(url.searchParams);
-		if (!parsed) {
-			response.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" }).end("Invalid OAuth callback");
-			return;
-		}
-		response
-			.writeHead(parsed.error ? 400 : 200, { "Content-Type": "text/html; charset=utf-8" })
-			.end("<html><body><h1>xAI authorization received.</h1>You can close this tab.</body></html>", () =>
-				accept(parsed),
-			);
-	});
-	const listen = (port: number) =>
-		new Promise<number>((resolve, rejectListen) => {
-			server.once("error", rejectListen);
-			server.listen(port, XAI_OAUTH_CALLBACK_HOST, () => {
-				server.removeListener("error", rejectListen);
-				const address = server.address();
-				if (!address || typeof address === "string") rejectListen(new Error("Could not determine callback port"));
-				else resolve(address.port);
-			});
-		});
-	let port: number;
-	try {
-		port = await listen(XAI_OAUTH_CALLBACK_PORT);
-	} catch {
-		port = await listen(0);
-	}
-	return {
-		redirectUri: `http://${XAI_OAUTH_CALLBACK_HOST}:${port}${XAI_OAUTH_CALLBACK_PATH}`,
-		acceptManual(input) {
-			try {
-				const value = input.trim();
-				const url = value.startsWith("http")
-					? new URL(value)
-					: new URL(`http://${XAI_OAUTH_CALLBACK_HOST}${XAI_OAUTH_CALLBACK_PATH}?${value.replace(/^\?/, "")}`);
-				if (url.pathname !== XAI_OAUTH_CALLBACK_PATH) return "Callback URL path was not recognized";
-				const parsed = parse(url.searchParams);
-				if (!parsed) return "Callback state did not match";
-				accept(parsed);
-				return undefined;
-			} catch {
-				return "Callback URL was invalid";
-			}
-		},
-		async wait(signal) {
-			const timeout = setTimeout(() => {
-				if (!settled) {
-					settled = true;
-					reject?.(new Error("Timed out waiting for xAI OAuth callback"));
-				}
-			}, LOGIN_TIMEOUT_MS);
-			const onAbort = () => {
-				if (!settled) {
-					settled = true;
-					reject?.(new Error("xAI OAuth login was cancelled"));
-				}
-			};
-			signal?.addEventListener("abort", onAbort, { once: true });
-			try {
-				return await result;
-			} finally {
-				clearTimeout(timeout);
-				signal?.removeEventListener("abort", onAbort);
-				await closeServer(server);
-			}
-		},
-		close: () => closeServer(server),
-	};
-}
-
-async function refreshXaiCredentials(value: OAuthCredentials): Promise<OAuthCredentials> {
-	if (!value.refresh) throw new Error("xAI OAuth credential cannot be refreshed; run /login again");
-	const endpoint =
-		typeof value.tokenEndpoint === "string" && value.tokenEndpoint
-			? validatedEndpoint(value.tokenEndpoint, "token_endpoint")
-			: (await discover()).token_endpoint;
-	const payload = await tokenRequest(
-		endpoint,
-		new URLSearchParams({
-			grant_type: "refresh_token",
-			client_id: XAI_OAUTH_CLIENT_ID,
-			refresh_token: value.refresh,
-		}),
-	);
-	return credentials(payload, endpoint, value.refresh);
-}
-
-export const xaiOAuth = {
-	name: "xAI (Grok subscription)",
-	usesCallbackServer: true,
-	async login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials> {
-		const existing = await readGrokCredentials();
-		if (existing) {
-			const method = await callbacks.onSelect({
-				message: "Select xAI login method:",
-				options: [
-					{ id: "browser", label: "Browser login" },
-					{ id: "existing", label: "Use existing Grok CLI login" },
-				],
-			});
-			if (!method) throw new Error("Login cancelled");
-			if (method === "existing") {
-				if (existing.expires > Date.now()) return existing;
-				try {
-					return await refreshXaiCredentials(existing);
-				} catch {
-					callbacks.onProgress?.("The existing Grok CLI login could not be refreshed. Starting browser login.");
-				}
-			}
-		}
-		const discovery = await discover(callbacks.signal);
-		const verifier = randomBytes(32).toString("base64url");
-		const challenge = createHash("sha256").update(verifier).digest("base64url");
-		const state = randomBytes(24).toString("base64url");
-		const nonce = randomBytes(24).toString("base64url");
-		const callback = await callbackServer(state);
-		try {
-			const url = new URL(discovery.authorization_endpoint);
-			url.search = new URLSearchParams({
-				response_type: "code",
-				client_id: XAI_OAUTH_CLIENT_ID,
-				redirect_uri: callback.redirectUri,
-				scope: XAI_OAUTH_SCOPE,
-				code_challenge: challenge,
-				code_challenge_method: "S256",
-				state,
-				nonce,
-			}).toString();
-			callbacks.onAuth({ url: url.toString(), instructions: "Authorize xAI in your browser, then return to Tau." });
-			if (callbacks.onManualCodeInput) {
-				void callbacks
-					.onManualCodeInput()
-					.then((input) => {
-						const error = callback.acceptManual(input);
-						if (error) callbacks.onProgress?.(`Ignored pasted callback: ${error}`);
-					})
-					.catch(() => undefined);
-			}
-			const result = await callback.wait(callbacks.signal);
-			if (result.error) throw new Error(`xAI authorization failed: ${result.errorDescription ?? result.error}`);
-			if (!result.code) throw new Error("xAI authorization did not return a code");
-			const payload = await tokenRequest(
-				discovery.token_endpoint,
-				new URLSearchParams({
-					grant_type: "authorization_code",
-					client_id: XAI_OAUTH_CLIENT_ID,
-					code: result.code,
-					redirect_uri: callback.redirectUri,
-					code_verifier: verifier,
-				}),
-				callbacks.signal,
-			);
-			return credentials(payload, discovery.token_endpoint, "", nonce);
-		} finally {
-			await callback.close();
-		}
-	},
-	refreshToken: refreshXaiCredentials,
-	getApiKey(value: OAuthCredentials): string {
-		return value.access;
-	},
-};

package/extensions/xai/payload.ts

@@ -1,68 +0,0 @@
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function contentText(value: unknown): string {
-	if (typeof value === "string") return value;
-	if (!Array.isArray(value)) return "";
-	return value
-		.map((part) => {
-			if (!isRecord(part)) return "";
-			return typeof part.text === "string" ? part.text : "";
-		})
-		.filter(Boolean)
-		.join("\n");
-}
-
-function normalizeToolOutput(item: Record<string, unknown>): unknown[] {
-	if (item.type !== "function_call_output" || !Array.isArray(item.output)) return [item];
-	const images = item.output.filter((part) => isRecord(part) && part.type === "input_image");
-	if (images.length === 0) return [item];
-	const text = contentText(item.output) || "(tool returned image output)";
-	return [
-		{ ...item, output: text },
-		{
-			role: "user",
-			content: [
-				{ type: "input_text", text: "The previous tool result included image output. Use the attached image." },
-				...images,
-			],
-		},
-	];
-}
-
-export function rewriteXaiPayload(value: unknown): unknown {
-	if (!isRecord(value)) return value;
-	const body = { ...value };
-	delete body.prompt_cache_retention;
-	if (isRecord(body.reasoning)) {
-		const effort = body.reasoning.effort;
-		body.reasoning =
-			typeof effort === "string" && effort !== "none"
-				? { effort: effort === "minimal" ? "low" : effort }
-				: undefined;
-	}
-	if (Array.isArray(body.input)) {
-		const instructions: string[] = [];
-		const input: unknown[] = [];
-		for (const raw of body.input) {
-			if (!isRecord(raw)) {
-				input.push(raw);
-				continue;
-			}
-			if ((raw.role === "developer" || raw.role === "system") && input.length === 0) {
-				const text = contentText(raw.content).trim();
-				if (text) instructions.push(text);
-				continue;
-			}
-			input.push(...normalizeToolOutput(raw));
-		}
-		body.input = input;
-		if (instructions.length > 0) {
-			body.instructions = [typeof body.instructions === "string" ? body.instructions : "", ...instructions]
-				.filter(Boolean)
-				.join("\n\n");
-		}
-	}
-	return body;
-}