@shanepadgett/tau-agent 0.31.1 → 0.33.0

package/extensions/commit/commit-effort.ts

@@ -0,0 +1,14 @@
+import type { ModelEffort } from "../../shared/model-effort.ts";
+import type { DirtyFile } from "./git-change-set.ts";
+
+const LOW_EFFORT_MAX_CHANGED_LINES = 500;
+
+export function commitEffort(files: readonly Pick<DirtyFile, "changeSize">[]): ModelEffort {
+	let changedLines = 0;
+	for (const file of files) {
+		if (file.changeSize === "binary") return "medium";
+		changedLines += file.changeSize;
+		if (changedLines > LOW_EFFORT_MAX_CHANGED_LINES) return "medium";
+	}
+	return "low";
+}

package/extensions/commit/commit-plan.ts

@@ -1,15 +1,14 @@
 import { randomUUID } from "node:crypto";
-import { type ThinkingLevel, type Tool, Type } from "@earendil-works/pi-ai";
+import { type Tool, Type } from "@earendil-works/pi-ai";
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { generateToolValidated, generateValidated, resolveCandidates } from "../../shared/model-fallback/index.ts";
+import { resolveEffortCandidates } from "../../shared/model-effort.ts";
+import { generateToolValidated, generateValidated } from "../../shared/model-fallback/index.ts";
 import { truncAt } from "../../shared/text.ts";
+import { commitEffort } from "./commit-effort.ts";
 import type { CommitEvidence, DirtyFile } from "./git-change-set.ts";
 
 const MAX_PLAN_EVIDENCE_CHARS = 48_000;
 const CONVENTIONAL_COMMIT_TYPES = ["feat", "fix", "docs", "refactor", "test", "chore", "perf", "ci", "build", "revert"];
-const COMMIT_MODELS: ReadonlyArray<{ provider: string; model: string; reasoning: ThinkingLevel }> = [
-	{ provider: "openai-codex", model: "gpt-5.6-terra", reasoning: "low" },
-];
 const COMMIT_PLAN_TOOL = {
 	name: "create_commit_plan",
 	description: "Submit the commit plan for the dirty repository files.",
@@ -55,7 +54,7 @@ export async function generatePlan(
 	const prompt = buildPlanPrompt(evidence, previousPlan, regenerationNote);
 	return generateToolValidated(
 		ctx,
-		await resolveCandidates(ctx, COMMIT_MODELS, true),
+		await resolveEffortCandidates(ctx, commitEffort(evidence.files), true),
 		prompt,
 		COMMIT_PLAN_TOOL,
 		(input) => commitGroupsFromToolInput(input, evidence.files),
@@ -85,7 +84,7 @@ export async function regenerateMessage(
 	const prompt = buildMessagePrompt(evidence, selected, previousPlan, selectedGroupId, regenerationNote);
 	return generateValidated(
 		ctx,
-		await resolveCandidates(ctx, COMMIT_MODELS, true),
+		await resolveEffortCandidates(ctx, commitEffort(selected), true),
 		prompt,
 		requireCommitMessage,
 		undefined,

package/extensions/commit/git-change-set.ts

@@ -26,6 +26,7 @@ export interface DirtyFile {
 	kind: "modified" | "added" | "deleted" | "renamed" | "untracked";
 	untracked: boolean;
 	evidence: string;
+	changeSize: number | "binary";
 	renamedFrom?: string;
 }
 
@@ -115,9 +116,11 @@ async function collectFileEvidence(
 	for (let index = 0; index < files.length; index += EVIDENCE_CONCURRENCY) {
 		withEvidence.push(
 			...(await Promise.all(
-				files
-					.slice(index, index + EVIDENCE_CONCURRENCY)
-					.map(async (file) => ({ ...file, evidence: await loadEvidenceForFile(git, root, file, hasHead) })),
+				files.slice(index, index + EVIDENCE_CONCURRENCY).map(async (file) => ({
+					...file,
+					evidence: await loadEvidenceForFile(git, root, file, hasHead),
+					changeSize: await loadChangeSize(git, root, file, hasHead),
+				})),
 			)),
 		);
 	}
@@ -155,7 +158,7 @@ function parsePorcelainV2Z(raw: string): DirtyFile[] {
 
 	return parsed
 		.sort((left, right) => left.path.localeCompare(right.path))
-		.map((file, index) => ({ ...file, id: index + 1, kind: changeKind(file), evidence: "" }));
+		.map((file, index) => ({ ...file, id: index + 1, kind: changeKind(file), evidence: "", changeSize: 0 }));
 }
 
 function statusText(fields: readonly string[]): string {
@@ -176,6 +179,35 @@ async function loadEvidenceForFile(git: GitRunner, root: string, file: DirtyFile
 	return truncAt(diff || "metadata-only change", MAX_FILE_EVIDENCE_CHARS);
 }
 
+async function loadChangeSize(
+	git: GitRunner,
+	root: string,
+	file: DirtyFile,
+	hasHead: boolean,
+): Promise<number | "binary"> {
+	if (file.renamedFrom && !/[MAD]/.test(file.status)) return 0;
+	const paths = file.renamedFrom ? [file.renamedFrom, file.path] : [file.path];
+	const output = file.untracked
+		? await git.run(["diff", "--no-index", "--numstat", "--", "/dev/null", file.path], { cwd: root, optional: true })
+		: hasHead
+			? await git.run(["diff", "--numstat", "HEAD", "--", ...paths], { cwd: root, optional: true })
+			: [
+					await git.run(["diff", "--cached", "--numstat", "--", ...paths], { cwd: root, optional: true }),
+					await git.run(["diff", "--numstat", "--", ...paths], { cwd: root, optional: true }),
+				].join("\n");
+
+	let total = 0;
+	for (const line of output.split("\n")) {
+		if (!line) continue;
+		const [added, deleted] = line.split("\t");
+		if (added === "-" || deleted === "-") return "binary";
+		const additions = Number(added);
+		const deletions = Number(deleted);
+		if (Number.isFinite(additions) && Number.isFinite(deletions)) total += additions + deletions;
+	}
+	return total;
+}
+
 async function diffFromIndexAndWorktree(git: GitRunner, root: string, paths: readonly string[]): Promise<string> {
 	const [staged, unstaged] = await Promise.all([
 		git.run(["diff", "--cached", "--stat", "--patch", "--no-color", "--no-ext-diff", "--", ...paths], {

package/extensions/context/index.ts

@@ -147,7 +147,7 @@ export default function contextExtension(pi: ExtensionAPI): void {
 				),
 			};
 		}
-		return { messages: [contextProjectionMessage(projectionCache.content), ...messages] };
+		return { messages: [...messages, contextProjectionMessage(projectionCache.content)] };
 	});
 	pi.on("agent_start", async (_event, ctx) => {
 		await refreshSettings(ctx);

package/extensions/effort/README.md

@@ -0,0 +1,7 @@
+# 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 low`, `/effort medium`, and `/effort high` 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.

package/extensions/effort/index.ts

@@ -0,0 +1,134 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Key, type AutocompleteItem } from "@earendil-works/pi-tui";
+import { emitTauEvent, onTauEvent } from "../../shared/events.ts";
+import {
+	effortForSelection,
+	type EffortProviderCandidates,
+	type ModelEffort,
+	resolveEffortProviders,
+} from "../../shared/model-effort.ts";
+import { EFFORT_STATE_TYPE, effortState, nextEffort } from "./state.ts";
+
+const EFFORTS: readonly ModelEffort[] = ["low", "medium", "high"];
+
+export default function effortExtension(pi: ExtensionAPI): void {
+	let activeEffort: ModelEffort | undefined;
+	let applying = false;
+
+	function publish(): void {
+		emitTauEvent(pi, "tau:model-effort.changed", { effort: activeEffort });
+	}
+
+	function setEffort(effort: ModelEffort | undefined): void {
+		if (activeEffort === effort) return;
+		activeEffort = effort;
+		pi.appendEntry(EFFORT_STATE_TYPE, effortState(effort));
+		publish();
+	}
+
+	async function apply(
+		ctx: ExtensionContext,
+		effort: ModelEffort,
+		provider: EffortProviderCandidates,
+	): Promise<boolean> {
+		applying = true;
+		try {
+			for (const candidate of provider.candidates) {
+				if (!(await pi.setModel(candidate.model))) continue;
+				pi.setThinkingLevel(candidate.reasoning);
+				setEffort(effortForSelection(provider.provider, candidate.model.id, pi.getThinkingLevel()));
+				ctx.ui.notify(`Effort: ${effort} · ${provider.label}/${candidate.model.id}`, "info");
+				return true;
+			}
+			return false;
+		} finally {
+			applying = false;
+		}
+	}
+
+	async function chooseProvider(ctx: ExtensionContext, effort: ModelEffort): Promise<void> {
+		const providers = resolveEffortProviders(ctx, effort);
+		if (providers.length === 0) {
+			ctx.ui.notify(`No logged-in provider has a ${effort} effort model. Current model kept.`, "warning");
+			return;
+		}
+		const labels = providers.map((provider) => `${provider.label} · ${provider.provider}`);
+		const selected = await ctx.ui.select(`Provider for ${effort} effort`, labels);
+		if (!selected) return;
+		const provider = providers[labels.indexOf(selected)];
+		if (!provider) return;
+		if (!(await apply(ctx, effort, provider))) {
+			ctx.ui.notify(`Could not select a ${effort} model from ${provider.label}. Current model kept.`, "warning");
+		}
+	}
+
+	pi.registerCommand("effort", {
+		description: "Select effort tier and logged-in provider",
+		getArgumentCompletions(prefix: string): AutocompleteItem[] | null {
+			const value = prefix.trimStart();
+			if (/\s/.test(value)) return null;
+			const items = EFFORTS.filter((effort) => effort.startsWith(value)).map((effort) => ({
+				value: effort,
+				label: effort,
+			}));
+			return items.length ? items : null;
+		},
+		handler: async (args, ctx) => {
+			await ctx.waitForIdle();
+			if (!ctx.hasUI) {
+				ctx.ui.notify("/effort requires interactive UI.", "error");
+				return;
+			}
+			const arg = args.trim().toLowerCase();
+			if (arg && !isModelEffort(arg)) {
+				ctx.ui.notify("Usage: /effort [low|medium|high]", "error");
+				return;
+			}
+			let effort: ModelEffort | undefined = isModelEffort(arg) ? arg : undefined;
+			if (!arg) {
+				const selected = await ctx.ui.select("Effort", [...EFFORTS]);
+				if (selected && isModelEffort(selected)) effort = selected;
+			}
+			if (!effort) return;
+			await chooseProvider(ctx, effort);
+		},
+	});
+
+	pi.registerShortcut(Key.ctrlShift("e"), {
+		description: "Cycle effort for current provider",
+		handler: async (ctx) => {
+			if (!ctx.isIdle()) {
+				ctx.ui.notify("Wait for the current run before changing effort.", "warning");
+				return;
+			}
+			const effort = nextEffort(activeEffort);
+			const provider = resolveEffortProviders(ctx, effort).find((item) => item.provider === ctx.model?.provider);
+			if (!provider || !(await apply(ctx, effort, provider))) {
+				ctx.ui.notify(`Current provider has no available ${effort} effort model. Current model kept.`, "warning");
+			}
+		},
+	});
+
+	onTauEvent(pi, "model-effort.snapshot", "tau:model-effort.snapshot.requested", publish);
+
+	pi.on("session_start", (_event, ctx) => {
+		activeEffort = effortForSelection(ctx.model?.provider, ctx.model?.id, pi.getThinkingLevel());
+		publish();
+	});
+	pi.on("session_tree", (_event, ctx) => {
+		activeEffort = effortForSelection(ctx.model?.provider, ctx.model?.id, pi.getThinkingLevel());
+		publish();
+	});
+	pi.on("model_select", (event) => {
+		if (!applying) setEffort(effortForSelection(event.model.provider, event.model.id, pi.getThinkingLevel()));
+	});
+	pi.on("thinking_level_select", (event, ctx) => {
+		if (!applying) {
+			setEffort(effortForSelection(ctx.model?.provider, ctx.model?.id, event.level));
+		}
+	});
+}
+
+function isModelEffort(value: string): value is ModelEffort {
+	return value === "low" || value === "medium" || value === "high";
+}

package/extensions/effort/state.ts

@@ -0,0 +1,33 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { ModelEffort } from "../../shared/model-effort.ts";
+
+export const EFFORT_STATE_TYPE = "tau.model-effort.state";
+
+export interface EffortStateV1 {
+	v: 1;
+	effort: ModelEffort | null;
+}
+
+export function effortState(effort: ModelEffort | undefined): EffortStateV1 {
+	return { v: 1, effort: effort ?? null };
+}
+
+export function replayEffortState(branch: readonly SessionEntry[]): ModelEffort | undefined {
+	for (let index = branch.length - 1; index >= 0; index -= 1) {
+		const entry = branch[index];
+		if (entry?.type !== "custom" || entry.customType !== EFFORT_STATE_TYPE) continue;
+		const data = entry.data;
+		if (!data || typeof data !== "object") continue;
+		const value = data as Record<string, unknown>;
+		if (value.v !== 1) continue;
+		if (value.effort === null) return undefined;
+		if (value.effort === "low" || value.effort === "medium" || value.effort === "high") return value.effort;
+	}
+	return undefined;
+}
+
+export function nextEffort(effort: ModelEffort | undefined): ModelEffort {
+	if (effort === "low") return "medium";
+	if (effort === "medium") return "high";
+	return "low";
+}

package/extensions/footer/README.md

@@ -14,7 +14,7 @@ Replaces Pi’s default footer with Tau’s compact two-line footer.
 ## Layout
 
 ```text
-git • model • thinking                         S $0.18 · D $2.43
+git • EFFORT • provider/model (thinking)       S $0.18 · D $2.43
 cwd • session                                  footer items
 ```
 

package/extensions/footer/index.ts

@@ -6,7 +6,8 @@ import { homedir } from "node:os";
 import { join, relative } from "node:path";
 import type { ExtensionAPI, ExtensionContext, Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
 import { type Component, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { onTauEvent } from "../../shared/events.ts";
+import { emitTauEvent, onTauEvent } from "../../shared/events.ts";
+import { effortForSelection, type ModelEffort } from "../../shared/model-effort.ts";
 import { loadTauExtensionSettings, updateTauExtensionSettings } from "../../shared/settings/load.ts";
 import footerSettings from "./settings.ts";
 
@@ -39,6 +40,8 @@ export default function footerExtension(pi: ExtensionAPI): void {
 	let footerInstalled = false;
 	let requestRender: (() => void) | undefined;
 	let unsubscribeFooterItems: (() => void) | undefined;
+	let unsubscribeModelEffort: (() => void) | undefined;
+	let activeEffort: ModelEffort | undefined;
 	const gitByCwd = new Map<string, GitSummary | undefined>();
 	let gitRefresh: Promise<void> | undefined;
 	let dailyCost: number | undefined;
@@ -76,7 +79,11 @@ export default function footerExtension(pi: ExtensionAPI): void {
 					const git = gitByCwd.get(currentCtx.cwd);
 					const model = currentCtx.model ? `${currentCtx.model.provider}/${currentCtx.model.id}` : "no-model";
 					const thinking = pi.getThinkingLevel();
-					const topLeft = [gitText(git), `${model} (${thinking})`].filter(Boolean).join(" • ");
+					const separator = theme.fg("dim", " • ");
+					const effort = effortText(theme, activeEffort);
+					const topLeft = [theme.fg("dim", gitText(git)), effort, theme.fg("dim", `${model} (${thinking})`)]
+						.filter(Boolean)
+						.join(separator);
 					const sessionUsage = sessionCost(currentCtx);
 					const session = formatCost(sessionUsage.cost);
 					const daily = dailyCost === undefined ? "$?" : formatCost(dailyCost);
@@ -87,7 +94,7 @@ export default function footerExtension(pi: ExtensionAPI): void {
 						.join(" • ");
 
 					return [
-						renderSplit(width, theme.fg("dim", topLeft), topRight),
+						renderSplit(width, topLeft, topRight),
 						renderSplit(width, theme.fg("dim", bottomLeft), theme.fg("dim", bottomRight)),
 					];
 				},
@@ -165,6 +172,10 @@ export default function footerExtension(pi: ExtensionAPI): void {
 		items.set(item.id, next);
 		render();
 	});
+	unsubscribeModelEffort = onTauEvent(pi, "footer.model-effort", "tau:model-effort.changed", (state) => {
+		activeEffort = state.effort;
+		render();
+	});
 
 	pi.registerCommand(COMMAND, {
 		description: "Toggle Tau footer",
@@ -202,11 +213,22 @@ export default function footerExtension(pi: ExtensionAPI): void {
 	pi.on("session_start", async (_event, ctx) => {
 		const settings = await loadTauExtensionSettings(ctx, footerSettings);
 		setEnabled(ctx, settings.enabled);
+		activeEffort = effortForSelection(ctx.model?.provider, ctx.model?.id, pi.getThinkingLevel());
 		onStateChange(ctx);
+		emitTauEvent(pi, "tau:model-effort.snapshot.requested", {});
+	});
+	pi.on("session_tree", (_event, ctx) => {
+		activeEffort = effortForSelection(ctx.model?.provider, ctx.model?.id, pi.getThinkingLevel());
+		onStateChange(ctx, false);
+	});
+	pi.on("model_select", (_event, ctx) => {
+		activeEffort = effortForSelection(ctx.model?.provider, ctx.model?.id, pi.getThinkingLevel());
+		rerender(ctx);
+	});
+	pi.on("thinking_level_select", (event, ctx) => {
+		activeEffort = effortForSelection(ctx.model?.provider, ctx.model?.id, event.level);
+		rerender(ctx);
 	});
-	pi.on("session_tree", (_event, ctx) => onStateChange(ctx, false));
-	pi.on("model_select", (_event, ctx) => rerender(ctx));
-	pi.on("thinking_level_select", (_event, ctx) => rerender(ctx));
 	pi.on("agent_start", (_event, ctx) => onStateChange(ctx, false));
 	pi.on("turn_end", (_event, ctx) => onStateChange(ctx));
 	pi.on("agent_end", (_event, ctx) => onStateChange(ctx));
@@ -214,6 +236,9 @@ export default function footerExtension(pi: ExtensionAPI): void {
 	pi.on("session_shutdown", (_event, ctx) => {
 		unsubscribeFooterItems?.();
 		unsubscribeFooterItems = undefined;
+		unsubscribeModelEffort?.();
+		unsubscribeModelEffort = undefined;
+		activeEffort = undefined;
 		requestRender = undefined;
 		activeCtx = undefined;
 		footerInstalled = false;
@@ -226,6 +251,11 @@ export default function footerExtension(pi: ExtensionAPI): void {
 	}
 }
 
+function effortText(theme: Theme, effort: ModelEffort | undefined): string {
+	if (!effort) return "";
+	return theme.fg("dim", theme.bold(effort.toUpperCase()));
+}
+
 async function saveEnabled(ctx: ExtensionContext, enabled: boolean): Promise<void> {
 	await updateTauExtensionSettings("global", ctx, footerSettings, (current) => ({ ...current, enabled }));
 }

package/extensions/reference/README.md

@@ -13,6 +13,7 @@ Select local reference repositories, add new ones, and send a prompt that points
 
 - Stores references in `~/.local/share/tau-agent/references/`.
 - `/reference` opens a TUI picker.
+- The picker shows each repository's name with its `origin` owner in muted parentheses when available, falling back to its local folder name.
 - `n` adds a new reference from a git URL, showing clone progress in the list as `↓ 37%`.
 - New references clone the remote default branch.
 - `b` switches the highlighted reference to another branch.

package/extensions/reference/panel.ts

@@ -27,6 +27,7 @@ const BRANCH_VISIBLE_ROWS = 5;
 
 export interface ReferenceItem {
 	name: string;
+	displayName: string;
 	path: string;
 	dirty: boolean;
 	branch: string;
@@ -190,7 +191,7 @@ class ReferencePanel implements Component {
 			items,
 			emptyMessage: "No references. Press ctrl+n for new.",
 			selection: { kind: "multi", primaryLabel: "attach" },
-			filter: { searchText: (item) => `${item.name} ${item.branch} ${item.path}` },
+			filter: { searchText: (item) => `${item.displayName} ${item.name} ${item.branch} ${item.path}` },
 			actions: [
 				{ id: "new", key: Key.ctrl("n"), hint: rawHint("ctrl+n", "new") },
 				{ id: "open", key: Key.ctrl("o"), hint: rawHint("ctrl+o", "open"), target: "current" },
@@ -303,13 +304,16 @@ class ReferencePanel implements Component {
 	}
 
 	private renderReferenceRow(item: ReferenceListItem, active: boolean, width: number): string[] {
-		const name = item.dirty ? `${item.name} *` : item.name;
+		const separator = item.displayName.lastIndexOf("/");
+		const repository = separator < 0 ? item.displayName : item.displayName.slice(separator + 1);
+		const owner = separator < 0 ? "" : this.theme.fg("muted", ` (${item.displayName.slice(0, separator)})`);
+		const name = item.dirty ? `${repository} *` : repository;
 		const label = active ? this.theme.fg("accent", name) : this.theme.fg(item.dirty ? "warning" : "text", name);
 		const branch = item.branch ? this.theme.fg("muted", ` (${item.branch})`) : "";
 		const status = item.state
 			? ` ${this.theme.fg(item.state === "failed" ? "error" : item.state === "updated" ? "success" : "muted", item.state === "failed" ? "!" : item.state === "updated" ? "✓" : "…")}`
 			: "";
-		return [truncateToWidth(`${label}${branch}${status}`, width, "")];
+		return [truncateToWidth(`${label}${owner}${branch}${status}`, width, "")];
 	}
 
 	private handleBranchInput(data: string): void {
@@ -636,7 +640,7 @@ function toListItem(item: ReferenceItem, state?: ReferenceListItem["state"]): Re
 }
 
 function toReferenceItem(item: ReferenceListItem): ReferenceItem {
-	return { name: item.name, path: item.path, dirty: item.dirty, branch: item.branch };
+	return { name: item.name, displayName: item.displayName, path: item.path, dirty: item.dirty, branch: item.branch };
 }
 
 async function cloneReference(
@@ -747,8 +751,10 @@ async function loadReferences(git: GitRunner): Promise<ReferenceItem[]> {
 async function loadReference(git: GitRunner, name: string, path: string): Promise<ReferenceItem> {
 	const branch = await git.run(["branch", "--show-current"], { cwd: path, optional: true });
 	const commit = branch ? "" : await git.run(["rev-parse", "--short", "HEAD"], { cwd: path, optional: true });
+	const remoteUrl = await git.run(["config", "--get", "remote.origin.url"], { cwd: path, optional: true });
 	return {
 		name,
+		displayName: referenceDisplayName(remoteUrl, name),
 		path,
 		dirty: (await git.run(["status", "--porcelain=v1"], { cwd: path, optional: true })).length > 0,
 		branch: branch || (commit ? `detached ${commit}` : ""),
@@ -865,6 +871,30 @@ function referenceNameFromUrl(url: string): string {
 	return name;
 }
 
+export function referenceDisplayName(remoteUrl: string, fallback: string): string {
+	const remote = remoteUrl
+		.trim()
+		.replace(/[?#].*$/, "")
+		.replace(/\/+$/, "")
+		.replace(/\.git$/i, "");
+	if (!remote) return fallback;
+
+	let path: string;
+	try {
+		const parsed = new URL(remote);
+		if (!parsed.host) return fallback;
+		path = parsed.pathname;
+	} catch {
+		const separator = remote.indexOf(":");
+		if (separator <= 0 || remote.slice(0, separator).includes("/")) return fallback;
+		path = remote.slice(separator + 1);
+	}
+
+	const segments = path.split("/").filter(Boolean);
+	if (segments.length < 2) return fallback;
+	return segments.slice(-2).join("/");
+}
+
 function shellQuote(value: string): string {
 	return `'${value.replaceAll("'", "'\\''")}'`;
 }

package/extensions/tau-help/help.md

@@ -36,7 +36,11 @@ Adds `/context` to set branch-local reusable repository work scopes from `.pi/co
 
 ## working-memory
 
-Gives agent `working_memory` for selective hard checkpoints. Model-only references identify useful user messages and visible assistant text. Requested source files return as structural outlines, deferred files remain cheap conditional reminders, and a continuation note carries conclusions extracted from exploration. Tool history and full file reads leave future model input without changing saved session. Advisory reminders begin at 40k active-context tokens. Run `/prune` to request reassessment manually.
+Gives agent `working_memory` for selective hard checkpoints. Every checkpoint retains at least one useful user message or visible assistant text. Requested source files return as structural outlines, deferred files remain cheap conditional reminders, and a continuation note carries conclusions extracted from exploration. Tool history and full file reads leave future model input without changing saved session. Advisory reminders begin at 40k active-context tokens. Run `/prune` to request reassessment manually.
+
+## effort
+
+Adds `/effort [low|medium|high]` to select effort and a provider from current logins. Tau selects provider’s best available model for tier, then tries its configured model fallback. `Ctrl+Shift+E` cycles tiers on current provider. Footer derives effort from current provider, model, and thinking level, and hides it when no configured tier matches.
 
 ## explore
 
@@ -66,10 +70,6 @@ Adds `/manage-sessions` to browse saved sessions and `/sweep` to archive or dele
 
 Replaces separate edit/write operations with one multi-file `patch` tool. It can create, rewrite, edit, move, and delete files in one structured call. Fewer tool calls means fewer turns, and each avoided turn prevents the full chat context from being sent again. Tau keeps `patch` disabled and uses `edit` and `write` for xAI and Grok models.
 
-## publish
-
-Adds `/publish` to create a tagged release, trigger trusted npm publishing in GitHub Actions, and show its status. It recommends a semantic version bump from commits since the prior release tag, but you must confirm the release type and publish action. If publishing fails, the agent investigates with read-only diagnostics and recommends a solution without applying it or retrying the release.
-
 ## qna
 
 Adds `/qna` for when the agent has asked you several questions in chat and you want a friendly UI for answering them on your own terms. It is only active when you manually run the command.

package/extensions/working-memory/README.md

@@ -2,7 +2,15 @@
 
 Working Memory gives agent selective checkpoints without changing saved conversation.
 
-`working_memory` keeps referenced user messages and visible assistant text, carries requested source files as structural outlines, and records deferred files as conditional reminders. Tool history and full file reads leave model context; useful findings from them are distilled into a compact continuation note.
+`working_memory` retains at least one referenced user message or visible assistant text. Keep task framing, constraints, decisions, and active work chain; continuation and file tiers support that conversation context. It has three file tiers:
+
+- Auto-read full source into next turn when agent needs its body to decide, edit, or debug.
+- Carry a structural outline when symbols and locations will support a later scoped read.
+- Defer inactive files with reason and condition that makes them relevant again.
+
+Use one tier for each path. `readFiles` publishes Tau's built-in autoread request; `outlineFiles` injects a structural outline; `deferFiles` records a conditional reminder.
+
+`continuation` is a working note for next step: keep durable decisions, findings, unresolved questions, remaining work, and next action. It should carry enough reasoning to resume without rereading discarded results.
 
 Automatic reminders begin at 40,000 active-context tokens and remain advisory. Run `/prune` to request reassessment manually.