@shanepadgett/tau-agent 0.31.1 → 0.32.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/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

@@ -66,10 +66,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` keeps referenced user messages and visible assistant text. 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.
 

package/extensions/working-memory/checkpoint.ts

@@ -2,17 +2,38 @@ import { resolve } from "node:path";
 import { type ExtensionAPI, type ExtensionContext, type SessionEntry } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
 import { truncateBoundedHead } from "../../shared/bounded-text-result.ts";
+import { emitTauEvent } from "../../shared/events.ts";
 import { requestOutlineInjections, type PreparedOutlineInjection } from "../../shared/outline-injection.ts";
 import { buildMemoryCatalog, collectPrunedRowIds } from "./memory.ts";
-import { WORKING_MEMORY_TOOL, type DeferredFile, type WorkingMemoryCheckpointDetailsV1 } from "./state.ts";
+import {
+	replayWorkingMemoryState,
+	WORKING_MEMORY_TOOL,
+	type DeferredFile,
+	type WorkingMemoryCheckpointDetailsV2,
+} from "./state.ts";
 
 const PATH = Type.String({ minLength: 1, maxLength: 500, pattern: "\\S" });
 
 export const workingMemoryParameters = Type.Object(
 	{
-		continuation: Type.String({ minLength: 1, maxLength: 8_000, pattern: "\\S" }),
+		continuation: Type.String({
+			minLength: 1,
+			maxLength: 8_000,
+			pattern: "\\S",
+			description:
+				"Working note for resuming mid-task. Carry durable decisions, concrete findings, live reasoning, unresolved questions, remaining work, and next action; include enough detail to continue without rereading discarded results.",
+		}),
 		keep: Type.Array(Type.String({ minLength: 3, maxLength: 100 }), { maxItems: 100 }),
-		outlineFiles: Type.Array(PATH, { maxItems: 12 }),
+		readFiles: Type.Array(PATH, {
+			maxItems: 12,
+			description:
+				"Files whose source should be auto-read into the next turn. Use when the next work needs the complete file; do not also outline or defer these files.",
+		}),
+		outlineFiles: Type.Array(PATH, {
+			maxItems: 12,
+			description:
+				"Files whose structural outline should be carried into the next turn. Use when symbols and locations will guide later scoped inspection; do not use when the full source is still needed.",
+		}),
 		deferFiles: Type.Array(
 			Type.Object(
 				{
@@ -22,7 +43,11 @@ export const workingMemoryParameters = Type.Object(
 				},
 				{ additionalProperties: false },
 			),
-			{ maxItems: 8 },
+			{
+				maxItems: 8,
+				description:
+					"Files to leave out of active context. Record why they are inactive and the concrete condition that would make them relevant.",
+			},
 		),
 	},
 	{ additionalProperties: false },
@@ -43,7 +68,7 @@ interface ExecuteWorkingMemoryOptions {
 export interface WorkingMemoryExecution {
 	result: {
 		content: Array<{ type: "text"; text: string }>;
-		details: WorkingMemoryCheckpointDetailsV1;
+		details: WorkingMemoryCheckpointDetailsV2;
 	};
 	outlines: PreparedOutlineInjection[];
 }
@@ -52,6 +77,12 @@ export async function executeWorkingMemory(options: ExecuteWorkingMemoryOptions)
 	assertCurrent(options);
 	const branch = options.ctx.sessionManager.getBranch();
 	const catalog = buildMemoryCatalog(branch);
+	const anchorIndex = findAnchorEntry(branch, options.toolCallId);
+	const previousState = replayWorkingMemoryState(branch, true);
+	const previousAnchorIndex =
+		previousState.latestAnchorToolCallId === undefined
+			? -1
+			: findAnchorEntry(branch, previousState.latestAnchorToolCallId);
 	const requestedRefs = [...new Set(options.params.keep)];
 	const retained = requestedRefs
 		.flatMap((ref) => {
@@ -64,7 +95,25 @@ export async function executeWorkingMemory(options: ExecuteWorkingMemoryOptions)
 		.filter((ref) => !catalog.has(ref))
 		.map((ref) => `${ref}: memory reference is unavailable and was not retained`);
 
-	const outlinePaths = dedupePaths(options.params.outlineFiles, options.ctx.cwd);
+	const rootInstructionsKey = resolve(options.ctx.cwd, "AGENTS.md");
+	const requestedRootInstructions = [
+		...options.params.readFiles,
+		...options.params.outlineFiles,
+		...options.params.deferFiles.map((file) => file.path),
+	].some((path) => resolve(options.ctx.cwd, normalizePath(path)) === rootInstructionsKey);
+	if (requestedRootInstructions) {
+		warnings.push(
+			"AGENTS.md: omitted from working-memory checkpoint because it is already in your context window. Read it directly only when actively changing it.",
+		);
+	}
+
+	const readPaths = dedupePaths(options.params.readFiles, options.ctx.cwd).filter(
+		(path) => resolve(options.ctx.cwd, path) !== rootInstructionsKey,
+	);
+	const readKeys = new Set(readPaths.map((path) => resolve(options.ctx.cwd, path)));
+	const outlinePaths = dedupePaths(options.params.outlineFiles, options.ctx.cwd).filter(
+		(path) => resolve(options.ctx.cwd, path) !== rootInstructionsKey && !readKeys.has(resolve(options.ctx.cwd, path)),
+	);
 	const outlineResponse = await requestOutlineInjections(options.pi, {
 		cwd: options.ctx.cwd,
 		batchId: options.toolCallId,
@@ -75,34 +124,50 @@ export async function executeWorkingMemory(options: ExecuteWorkingMemoryOptions)
 	warnings.push(...outlineResponse.warnings.map((warning) => boundedWarning(warning)));
 	assertCurrent(options);
 
-	const outlinedKeys = new Set(
-		outlineResponse.messages.map((message) => resolve(options.ctx.cwd, message.details.path)),
-	);
+	const carriedKeys = new Set([
+		...readKeys,
+		...outlineResponse.messages.map((message) => resolve(options.ctx.cwd, message.details.path)),
+	]);
 	const deferredFiles: DeferredFile[] = [];
 	const deferredKeys = new Set<string>();
 	for (const file of options.params.deferFiles) {
 		const path = normalizePath(file.path);
 		const key = resolve(options.ctx.cwd, path);
-		if (outlinedKeys.has(key) || deferredKeys.has(key)) continue;
+		if (key === rootInstructionsKey || carriedKeys.has(key) || deferredKeys.has(key)) continue;
 		deferredKeys.add(key);
 		deferredFiles.push({ path, reason: file.reason.trim(), relevantWhen: file.relevantWhen.trim() });
 	}
 
-	const anchorIndex = findAnchorEntry(branch, options.toolCallId);
-	const preAnchorUnits = [...catalog.values()].filter((unit) => unit.order < anchorIndex);
+	if (readPaths.length > 0) {
+		emitTauEvent(options.pi, "tau:autoread.requested", {
+			source: WORKING_MEMORY_TOOL,
+			title: "Working-memory checkpoint",
+			cwd: options.ctx.cwd,
+			batchId: options.toolCallId,
+			files: readPaths.map((path) => ({ path })),
+		});
+	}
+
 	const prunedRowIds = collectPrunedRowIds(branch, anchorIndex);
-	const details: WorkingMemoryCheckpointDetailsV1 = {
-		v: 1,
+	const activeRefs = new Set(previousState.retainedRefs.filter((ref) => catalog.has(ref)));
+	for (const unit of catalog.values()) {
+		if (unit.order > previousAnchorIndex && unit.order < anchorIndex) activeRefs.add(unit.ref);
+	}
+	const newlyPrunedRows = prunedRowIds.filter((rowId) => !previousState.prunedRowIds.has(rowId));
+	const droppedBlocks = [...activeRefs].filter((ref) => !retainedRefs.includes(ref)).length + newlyPrunedRows.length;
+	const details: WorkingMemoryCheckpointDetailsV2 = {
+		v: 2,
 		anchorToolCallId: options.toolCallId,
 		retainedRefs,
 		retainedLabels: retained.map((unit) => ({ ref: unit.ref, label: unit.label, preview: unit.preview })),
 		prunedRowIds,
+		readFiles: readPaths,
 		outlinedFiles: outlineResponse.messages.map((message) => ({
 			path: message.details.path,
 			rowId: message.details.rowId,
 		})),
 		deferredFiles,
-		removedUnits: Math.max(0, preAnchorUnits.length - retained.length),
+		removedUnits: droppedBlocks,
 		warnings,
 	};
 	const markdown = formatResult(options.params.continuation.trim(), deferredFiles, warnings);

package/extensions/working-memory/index.ts

@@ -17,12 +17,12 @@ import {
 	type WorkingMemoryNudgeDetails,
 } from "./render.ts";
 import workingMemorySettings from "./settings.ts";
-import { replayWorkingMemoryState, WORKING_MEMORY_TOOL, type WorkingMemoryCheckpointDetailsV1 } from "./state.ts";
+import { replayWorkingMemoryState, WORKING_MEMORY_TOOL, type WorkingMemoryCheckpointDetailsV2 } from "./state.ts";
 
 const NUDGE_TYPE = "tau.working-memory.nudge";
 const BASELINE_TYPE = "tau.working-memory.nudge-baseline";
 const TOOL_DESCRIPTION =
-	"Create a selective hard checkpoint for future model context. Keep valuable user and visible assistant messages, carry file structure as outlines, defer conditionally relevant files without reading them, and distill exploration findings into one compact continuation note.";
+	"Create a selective hard checkpoint for future model context. Keep valuable user and visible assistant messages, auto-read full source or carry file structure as needed, defer conditionally relevant files, and distill exploration findings into one compact continuation note.";
 
 interface NudgeState {
 	anchorToolCallId: string | undefined;
@@ -91,7 +91,7 @@ export default function workingMemoryExtension(pi: ExtensionAPI): void {
 		instructions = settings.nudgeInstructions;
 		if (enabled && !toolRegistered) {
 			pi.registerTool(
-				defineTool<typeof workingMemoryParameters, WorkingMemoryCheckpointDetailsV1>({
+				defineTool<typeof workingMemoryParameters, WorkingMemoryCheckpointDetailsV2>({
 					name: WORKING_MEMORY_TOOL,
 					label: WORKING_MEMORY_TOOL,
 					description: TOOL_DESCRIPTION,
@@ -99,8 +99,9 @@ export default function workingMemoryExtension(pi: ExtensionAPI): void {
 					promptGuidelines: [
 						"Use working_memory when stale evidence has accumulated or a memory reminder asks for reassessment; continue coherent exploration when current evidence remains useful.",
 						"A hidden working-memory reference catalog provides keep refs only for user messages and visible assistant text. Tool calls, tool results, hidden reasoning, and framework messages cannot be retained.",
-						"Outline files that remain in the repository working set, defer paths whose relevance is conditional, and discard exploration history after extracting its useful conclusions.",
-						"Everything before working_memory leaves future model context unless selected in keep. Put findings from tools, durable decisions, constraints, unresolved matters, and next action in continuation without duplicating retained messages.",
+						"Choose one file tier: readFiles auto-reads source into the next turn when its body is needed; outlineFiles carries symbols and locations for later scoped inspection; deferFiles records inactive conditional paths. Do not read a file merely to decide whether to outline it.",
+						"Choose readFiles instead of outlineFiles when next work will require the complete file. Do not list a path in more than one file tier.",
+						"Use continuation as a working note for resuming mid-task. Carry durable decisions, concrete findings, live reasoning, unresolved questions, remaining work, and next action in as much detail as needed to continue without rereading discarded results. Do not make it a user-facing status update or narrate the checkpoint.",
 					],
 					parameters: workingMemoryParameters,
 					executionMode: "sequential",
@@ -123,6 +124,7 @@ export default function workingMemoryExtension(pi: ExtensionAPI): void {
 							rowId: context.toolCallId,
 							invalidate: context.invalidate,
 							lastComponent: context.lastComponent,
+							executionStarted: context.executionStarted,
 						});
 					},
 					renderResult(result, options, theme, context) {

package/extensions/working-memory/memory.ts

@@ -64,7 +64,7 @@ export function collectPrunedRowIds(branch: readonly SessionEntry[], before: num
 			}
 			if (
 				message.role === "custom" &&
-				message.customType === "tau.explore.outline" &&
+				(message.customType === "tau.explore.outline" || message.customType === "tau.autoread") &&
 				isRecord(message.details) &&
 				typeof message.details.rowId === "string"
 			) {

package/extensions/working-memory/render.ts

@@ -99,15 +99,21 @@ export function renderWorkingMemoryCall(
 		rowId: string;
 		invalidate: () => void;
 		lastComponent: unknown;
+		executionStarted: boolean;
 	},
 ): Text {
 	context.rowState.watch(context.rowId, context.invalidate);
 	const component = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
+	if (context.executionStarted) {
+		component.setText("");
+		return component;
+	}
 	const kept = Array.isArray(args.keep) ? args.keep.length : 0;
+	const read = Array.isArray(args.readFiles) ? args.readFiles.length : 0;
 	const outlined = Array.isArray(args.outlineFiles) ? args.outlineFiles.length : 0;
 	const deferred = Array.isArray(args.deferFiles) ? args.deferFiles.length : 0;
 	component.setText(
-		`${formatToolRowTitle(context.rowState, context.rowId, "working_memory", theme)} ${theme.fg("muted", `${kept} kept · ${outlined} outline · ${deferred} deferred`)}`,
+		`${formatToolRowTitle(context.rowState, context.rowId, "working_memory", theme)} ${theme.fg("muted", `${kept} kept · ${read} read · ${outlined} outline · ${deferred} deferred`)}`,
 	);
 	return component;
 }
@@ -128,12 +134,13 @@ export function renderWorkingMemoryResult(
 	}
 	let text = theme.fg(
 		details.warnings.length === 0 ? "success" : "warning",
-		`Checkpoint · kept ${details.retainedRefs.length} · outlined ${details.outlinedFiles.length} · deferred ${details.deferredFiles.length} · removed ${details.removedUnits}${details.warnings.length === 0 ? "" : ` · warnings ${details.warnings.length}`}`,
+		`Checkpoint · kept ${details.retainedRefs.length} · read ${details.readFiles.length} · outlined ${details.outlinedFiles.length} · deferred ${details.deferredFiles.length} · pruned ${details.removedUnits}${details.warnings.length === 0 ? "" : ` · warnings ${details.warnings.length}`}`,
 	);
 	if (expanded) {
 		const lines = [
 			bounded(firstText(result), 1_500),
 			...details.retainedLabels.map((item) => `${item.ref} ${item.label}: ${item.preview}`),
+			...details.readFiles.map((path) => `read: ${path}`),
 			...details.outlinedFiles.map((file) => `outlined: ${file.path}`),
 			...details.deferredFiles.map((file) => `deferred: ${file.path} — ${file.reason}; when ${file.relevantWhen}`),
 			...details.warnings.map((warning) => `warning: ${warning}`),

package/extensions/working-memory/state.ts

@@ -14,12 +14,13 @@ export interface RetainedLabel {
 	preview: string;
 }
 
-export interface WorkingMemoryCheckpointDetailsV1 {
-	v: 1;
+export interface WorkingMemoryCheckpointDetailsV2 {
+	v: 2;
 	anchorToolCallId: string;
 	retainedRefs: string[];
 	retainedLabels: RetainedLabel[];
 	prunedRowIds: string[];
+	readFiles: string[];
 	outlinedFiles: Array<{ path: string; rowId: string }>;
 	deferredFiles: DeferredFile[];
 	removedUnits: number;
@@ -32,14 +33,15 @@ export interface ActiveWorkingMemoryState {
 	prunedRowIds: ReadonlySet<string>;
 }
 
-export function parseWorkingMemoryDetails(value: unknown): WorkingMemoryCheckpointDetailsV1 | undefined {
-	if (!isRecord(value) || value.v !== 1 || !nonempty(value.anchorToolCallId)) return undefined;
+export function parseWorkingMemoryDetails(value: unknown): WorkingMemoryCheckpointDetailsV2 | undefined {
+	if (!isRecord(value) || value.v !== 2 || !nonempty(value.anchorToolCallId)) return undefined;
 	const keys = [
 		"v",
 		"anchorToolCallId",
 		"retainedRefs",
 		"retainedLabels",
 		"prunedRowIds",
+		"readFiles",
 		"outlinedFiles",
 		"deferredFiles",
 		"removedUnits",
@@ -48,6 +50,7 @@ export function parseWorkingMemoryDetails(value: unknown): WorkingMemoryCheckpoi
 	if (Object.keys(value).length !== keys.length || !keys.every((key) => Object.hasOwn(value, key))) return undefined;
 	const retainedRefs = uniqueStrings(value.retainedRefs);
 	const prunedRowIds = uniqueStrings(value.prunedRowIds);
+	const readFiles = uniqueStrings(value.readFiles);
 	const warnings = strings(value.warnings);
 	const retainedLabels = parseRetainedLabels(value.retainedLabels);
 	const outlinedFiles = parseOutlinedFiles(value.outlinedFiles);
@@ -55,6 +58,7 @@ export function parseWorkingMemoryDetails(value: unknown): WorkingMemoryCheckpoi
 	if (
 		!retainedRefs ||
 		!prunedRowIds ||
+		!readFiles ||
 		!warnings ||
 		!retainedLabels ||
 		retainedLabels.length !== retainedRefs.length ||
@@ -67,11 +71,12 @@ export function parseWorkingMemoryDetails(value: unknown): WorkingMemoryCheckpoi
 		return undefined;
 	}
 	return {
-		v: 1,
+		v: 2,
 		anchorToolCallId: value.anchorToolCallId,
 		retainedRefs,
 		retainedLabels,
 		prunedRowIds,
+		readFiles,
 		outlinedFiles,
 		deferredFiles,
 		removedUnits: value.removedUnits as number,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shanepadgett/tau-agent",
-	"version": "0.31.1",
+	"version": "0.32.0",
 	"description": "Tau is a custom agentic harness built with pi extensions",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -35,7 +35,7 @@
 	],
 	"dependencies": {
 		"@ast-grep/wasm": "0.45.0",
-		"@shanepadgett/tau-tui": "0.31.1",
+		"@shanepadgett/tau-tui": "0.32.0",
 		"@vscode/tree-sitter-wasm": "0.3.1",
 		"image-size": "2.0.2",
 		"smol-toml": "1.7.0",

package/shared/model-effort.ts

@@ -0,0 +1,38 @@
+import type { ThinkingLevel } from "@earendil-works/pi-ai";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { resolveCandidates } from "./model-fallback/index.ts";
+import type { ModelCandidate } from "./model-fallback/types.ts";
+
+export type ModelEffort = "low" | "medium" | "high";
+
+interface ModelPreference {
+	provider: string;
+	model: string;
+	reasoning: ThinkingLevel;
+}
+
+const MODEL_PREFERENCES: Record<ModelEffort, readonly ModelPreference[]> = {
+	low: [
+		{ provider: "openai-codex", model: "gpt-5.6-luna", reasoning: "high" },
+		{ provider: "xai", model: "grok-4.5", reasoning: "medium" },
+		{ provider: "anthropic", model: "claude-haiku-4-5", reasoning: "high" },
+	],
+	medium: [
+		{ provider: "openai-codex", model: "gpt-5.6-terra", reasoning: "high" },
+		{ provider: "xai", model: "grok-4.5", reasoning: "high" },
+		{ provider: "anthropic", model: "claude-sonnet-5", reasoning: "high" },
+	],
+	high: [
+		{ provider: "openai-codex", model: "gpt-5.6-sol", reasoning: "high" },
+		{ provider: "xai", model: "grok-4.5", reasoning: "high" },
+		{ provider: "anthropic", model: "claude-opus-5", reasoning: "high" },
+	],
+};
+
+export function resolveEffortCandidates(
+	ctx: Pick<ExtensionContext, "modelRegistry" | "model" | "cwd" | "isProjectTrusted">,
+	effort: ModelEffort,
+	includeParentModel: boolean,
+): Promise<ModelCandidate[]> {
+	return resolveCandidates(ctx, MODEL_PREFERENCES[effort], includeParentModel);
+}

package/extensions/publish/README.md

@@ -1,13 +0,0 @@
-# Publish
-
-Create a tagged Tau release and monitor its GitHub Actions npm publish run.
-
-## Usage
-
-```text
-/publish
-```
-
-`/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.
-
-If publishing fails, the agent runs read-only diagnostics and recommends a solution. It does not apply the fix or retry the release.

package/extensions/publish/index.ts

@@ -1,301 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { createGitRunner, type GitRunner, loadRepoStatus } from "../../shared/git.ts";
-import { errorText } from "../../shared/text.ts";
-import { PublishActivityPanel, type PublishProgress } from "./publish-ui.ts";
-
-const PACKAGE_PATHS = ["packages/tui/package.json", "packages/agent/package.json"] as const;
-const LOCKFILE_PATH = "package-lock.json";
-const WORKFLOW_NAME = "publish.yml";
-const WORKFLOW_WAIT_MS = 10 * 60_000;
-const POLL_INTERVAL_MS = 5_000;
-const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
-
-type Bump = "patch" | "minor" | "major";
-
-interface PackageManifest {
-	name: string;
-	version: string;
-	dependencies?: Record<string, string>;
-}
-
-interface WorkflowRun {
-	databaseId: number;
-	status: string;
-	conclusion: string | null;
-	url: string;
-}
-
-export default function publishExtension(pi: ExtensionAPI): void {
-	pi.registerCommand("publish", {
-		description: "Create a tagged release and monitor trusted npm publishing",
-		handler: async (args, ctx) => {
-			await ctx.waitForIdle();
-			if (args.trim()) {
-				ctx.ui.notify("Usage: /publish", "error");
-				return;
-			}
-			if (!ctx.hasUI) {
-				ctx.ui.notify("Publishing requires interactive confirmation.", "error");
-				return;
-			}
-			try {
-				await publish(pi, ctx);
-			} catch (error) {
-				pi.sendMessage(
-					{
-						customType: "tau.publish-failure",
-						content: [
-							"The /publish command failed with this error:",
-							errorText(error),
-							"Investigate the failure using read-only diagnostics. Determine the likely cause and recommend a solution to the user. Do not change files, git state, package state, or remote state, and do not retry publishing.",
-						].join("\n\n"),
-						display: false,
-					},
-					{ triggerTurn: true },
-				);
-			}
-		},
-	});
-}
-
-async function publish(pi: ExtensionAPI, ctx: ExtensionCommandContext): Promise<void> {
-	const git = createGitRunner(pi, ctx);
-	const repo = await loadRepoStatus(git);
-	if (!repo) throw new Error("No git repository found.");
-	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, DEFAULT_COMMAND_TIMEOUT_MS);
-	await run(pi, ctx, "npm", ["run", "check:package-sources"], repo.root, DEFAULT_COMMAND_TIMEOUT_MS);
-
-	const manifests = await loadManifests(repo.root);
-	const currentVersion = sharedVersion(manifests);
-	const tag = await latestReleaseTag(git, repo.root);
-	const bump = await recommendBump(git, repo.root, tag, currentVersion);
-	const version = tag ? incrementVersion(currentVersion, bump) : currentVersion;
-	const selectedBump = await ctx.ui.select(`Release ${version}`, [
-		`Use recommended ${bump} bump`,
-		"Choose a different bump",
-		"Cancel",
-	]);
-	if (!selectedBump || selectedBump === "Cancel") return;
-
-	const finalBump =
-		selectedBump === "Choose a different bump"
-			? await ctx.ui.select("Release type", ["patch", "minor", "major"])
-			: bump;
-	if (!finalBump) return;
-	const finalVersion = tag ? incrementVersion(currentVersion, finalBump as Bump) : currentVersion;
-	const releaseTag = `v${finalVersion}`;
-	if (await tagExists(git, repo.root, releaseTag)) throw new Error(`Tag ${releaseTag} already exists.`);
-
-	const confirmed = await ctx.ui.confirm(
-		`Publish ${releaseTag}?`,
-		`This will push ${releaseTag}. GitHub Actions will publish @shanepadgett/tau-tui and @shanepadgett/tau-agent to npm.`,
-	);
-	if (!confirmed) return;
-
-	if (ctx.mode !== "tui") {
-		await completePublish(pi, ctx, git, repo.root, manifests, tag, finalVersion, releaseTag);
-		return;
-	}
-	const failure = await ctx.ui.custom<Error | undefined>((tui, theme, _keybindings, done) => {
-		const progress = new PublishActivityPanel(tui, theme, releaseTag);
-		void completePublish(pi, ctx, git, repo.root, manifests, tag, finalVersion, releaseTag, progress)
-			.then(() => done(undefined))
-			.catch((error) => done(error instanceof Error ? error : new Error(errorText(error))));
-		return progress;
-	});
-	if (failure) throw failure;
-}
-
-async function completePublish(
-	pi: ExtensionAPI,
-	ctx: ExtensionCommandContext,
-	git: GitRunner,
-	root: string,
-	manifests: readonly PackageManifest[],
-	tag: string | undefined,
-	version: string,
-	releaseTag: string,
-	progress: PublishProgress | undefined = undefined,
-): Promise<void> {
-	if (tag) {
-		progress?.update("write package versions");
-		await writeReleaseVersion(root, manifests, version);
-	}
-	progress?.update("npm pack --dry-run @shanepadgett/tau-tui");
-	await run(
-		pi,
-		ctx,
-		"npm",
-		["pack", "--dry-run", "--workspace", "@shanepadgett/tau-tui"],
-		root,
-		DEFAULT_COMMAND_TIMEOUT_MS,
-	);
-	progress?.update("npm pack --dry-run @shanepadgett/tau-agent");
-	await run(
-		pi,
-		ctx,
-		"npm",
-		["pack", "--dry-run", "--workspace", "@shanepadgett/tau-agent"],
-		root,
-		DEFAULT_COMMAND_TIMEOUT_MS,
-	);
-	if (tag) {
-		progress?.update("git add release files");
-		await git.run(["add", ...PACKAGE_PATHS, LOCKFILE_PATH], { cwd: root });
-		progress?.update(`git commit chore(release): ${releaseTag}`);
-		await git.run(["commit", "-m", `chore(release): ${releaseTag}`], { cwd: root });
-	}
-	progress?.update(`git tag ${releaseTag}`);
-	await git.run(["tag", releaseTag], { cwd: root });
-	progress?.update("git push origin HEAD");
-	await git.run(["push", "origin", "HEAD"], { cwd: root, timeout: 120_000 });
-	progress?.update(`git push origin ${releaseTag}`);
-	await git.run(["push", "origin", releaseTag], { cwd: root, timeout: 120_000 });
-	progress?.update("Waiting for GitHub Actions");
-	await monitorWorkflow(pi, ctx, root, await git.run(["rev-parse", "HEAD"], { cwd: root }), releaseTag, progress);
-}
-
-async function loadManifests(root: string): Promise<PackageManifest[]> {
-	return Promise.all(
-		PACKAGE_PATHS.map(async (path) => JSON.parse(await readFile(join(root, path), "utf8")) as PackageManifest),
-	);
-}
-
-function sharedVersion(manifests: readonly PackageManifest[]): string {
-	const versions = new Set(manifests.map((manifest) => manifest.version));
-	if (versions.size !== 1) throw new Error("Publishable packages must use the same version.");
-	const version = manifests[0]?.version;
-	if (!version || !/^\d+\.\d+\.\d+$/.test(version)) throw new Error("Package version must be stable semver.");
-	return version;
-}
-
-async function latestReleaseTag(git: GitRunner, root: string): Promise<string | undefined> {
-	const tags = await git.run(["tag", "--list", "v*", "--sort=-version:refname"], { cwd: root });
-	return tags.split("\n").find((tag) => /^v\d+\.\d+\.\d+$/.test(tag));
-}
-
-async function recommendBump(
-	git: GitRunner,
-	root: string,
-	tag: string | undefined,
-	currentVersion: string,
-): Promise<Bump> {
-	const range = tag ? `${tag}..HEAD` : "HEAD";
-	const commits = await git.run(["log", "--format=%B%x00", range], { cwd: root });
-	if (/BREAKING CHANGE:|^[^\n]*!:/m.test(commits)) return currentVersion.startsWith("0.") ? "minor" : "major";
-	if (/^feat(?:\([^\n]+\))?:/m.test(commits)) return "minor";
-	return "patch";
-}
-
-function incrementVersion(version: string, bump: Bump): string {
-	const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
-	if (!match) throw new Error(`Invalid version: ${version}`);
-	const major = Number(match[1]);
-	const minor = Number(match[2]);
-	const patch = Number(match[3]);
-	if (bump === "major") return `${major + 1}.0.0`;
-	if (bump === "minor") return `${major}.${minor + 1}.0`;
-	return `${major}.${minor}.${patch + 1}`;
-}
-
-async function tagExists(git: GitRunner, root: string, tag: string): Promise<boolean> {
-	return Boolean(await git.run(["tag", "--list", tag], { cwd: root }));
-}
-
-async function writeReleaseVersion(
-	root: string,
-	manifests: readonly PackageManifest[],
-	version: string,
-): Promise<void> {
-	for (const [index, path] of PACKAGE_PATHS.entries()) {
-		const manifest = manifests[index];
-		if (!manifest) throw new Error(`Missing package manifest: ${path}`);
-		manifest.version = version;
-		if (manifest.name === "@shanepadgett/tau-agent" && manifest.dependencies)
-			manifest.dependencies["@shanepadgett/tau-tui"] = version;
-		await writeFile(join(root, path), `${JSON.stringify(manifest, null, "\t")}\n`);
-	}
-	const lockfile = JSON.parse(await readFile(join(root, LOCKFILE_PATH), "utf8")) as {
-		packages: Record<string, PackageManifest>;
-	};
-	for (const path of PACKAGE_PATHS) {
-		const lockfilePath = path.slice(0, -"/package.json".length);
-		const manifest = lockfile.packages[lockfilePath];
-		if (!manifest) throw new Error(`Missing lockfile package: ${lockfilePath}`);
-		manifest.version = version;
-		if (manifest.name === "@shanepadgett/tau-agent" && manifest.dependencies)
-			manifest.dependencies["@shanepadgett/tau-tui"] = version;
-	}
-	await writeFile(join(root, LOCKFILE_PATH), `${JSON.stringify(lockfile, null, "\t")}\n`);
-}
-
-async function run(
-	pi: ExtensionAPI,
-	ctx: ExtensionCommandContext,
-	command: string,
-	args: string[],
-	cwd: string,
-	timeout: number,
-): Promise<string> {
-	const result = await pi.exec(command, args, { cwd, signal: ctx.signal, timeout });
-	if (result.code === 0) return result.stdout.trim();
-	throw new Error([result.stderr, result.stdout].filter(Boolean).join("\n").trim() || `${command} failed`);
-}
-
-async function monitorWorkflow(
-	pi: ExtensionAPI,
-	ctx: ExtensionCommandContext,
-	root: string,
-	sha: string,
-	tag: string,
-	progress: PublishProgress | undefined = undefined,
-): Promise<void> {
-	const deadline = Date.now() + WORKFLOW_WAIT_MS;
-	while (Date.now() < deadline) {
-		const output = await run(
-			pi,
-			ctx,
-			"gh",
-			[
-				"run",
-				"list",
-				"--workflow",
-				WORKFLOW_NAME,
-				"--commit",
-				sha,
-				"--limit",
-				"1",
-				"--json",
-				"databaseId,status,conclusion,url",
-			],
-			root,
-			DEFAULT_COMMAND_TIMEOUT_MS,
-		);
-		const workflowRun = (JSON.parse(output) as WorkflowRun[])[0];
-		if (workflowRun) {
-			progress?.update(`GitHub Actions: ${workflowRun.status}`, workflowRun.url);
-			if (workflowRun.status === "completed") {
-				if (workflowRun.conclusion === "success") {
-					const version = tag.slice(1);
-					ctx.ui.notify(
-						[
-							`Published ${tag}`,
-							`GitHub Actions: ${workflowRun.url}`,
-							`npm TUI: https://www.npmjs.com/package/@shanepadgett/tau-tui/v/${version}`,
-							`npm Agent: https://www.npmjs.com/package/@shanepadgett/tau-agent/v/${version}`,
-						].join("\n"),
-						"info",
-					);
-					return;
-				}
-				throw new Error(`GitHub Actions ${workflowRun.conclusion ?? "failed"}: ${workflowRun.url}`);
-			}
-		}
-		await new Promise<void>((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-	}
-	throw new Error(`Timed out waiting for GitHub Actions for ${tag}. Check the Actions tab.`);
-}

package/extensions/publish/publish-ui.ts

@@ -1,73 +0,0 @@
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import { type Component, Text, type TUI } from "@earendil-works/pi-tui";
-import { ToolPanel } from "@shanepadgett/tau-tui";
-
-const RELEASE_STEPS = [
-	"write package versions",
-	"npm pack --dry-run @shanepadgett/tau-tui",
-	"npm pack --dry-run @shanepadgett/tau-agent",
-	"git add release files",
-	"git commit",
-	"git tag",
-	"git push origin HEAD",
-	"git push origin v",
-	"Waiting for GitHub Actions",
-	"GitHub Actions: publishing",
-] as const;
-
-export interface PublishProgress {
-	update(status: string, detail?: string): void;
-}
-
-export class PublishActivityPanel implements Component, PublishProgress {
-	private readonly tui: TUI;
-	private readonly theme: Theme;
-	private readonly body = new Text("", 0, 0);
-	private readonly panel: ToolPanel;
-	private status = "Preparing release";
-	private detail: string | undefined;
-	private readonly completed: string[] = ["Release confirmed"];
-
-	constructor(tui: TUI, theme: Theme, tag: string) {
-		this.tui = tui;
-		this.theme = theme;
-		this.panel = new ToolPanel(theme, {
-			title: `Publishing ${tag}`,
-			secondary: "Editor is unavailable until this release finishes.",
-			header: [theme.fg("muted", "GitHub Actions publishes through npm trusted publishing.")],
-			body: this.body,
-			footer: { kind: "hints", hints: [] },
-		});
-		this.renderBody();
-	}
-
-	update(status: string, detail: string | undefined = undefined): void {
-		if (this.status !== "Preparing release" && this.status !== status) this.completed.push(this.status);
-		this.status = status;
-		this.detail = detail;
-		this.renderBody();
-		this.tui.requestRender();
-	}
-
-	render(width: number): string[] {
-		return this.panel.render(width);
-	}
-
-	invalidate(): void {
-		this.panel.invalidate();
-	}
-
-	private renderBody(): void {
-		const upcoming = RELEASE_STEPS.filter(
-			(step) => !this.completed.some((completed) => completed.startsWith(step)) && step !== this.status,
-		);
-		this.body.setText(
-			[
-				...this.completed.map((step) => this.theme.fg("success", `✓ ${step}`)),
-				this.theme.fg("accent", `… ${this.status}`),
-				...(this.detail ? [this.theme.fg("muted", this.detail)] : []),
-				...upcoming.map((step) => this.theme.fg("muted", `· ${step}`)),
-			].join("\n"),
-		);
-	}
-}