@shanepadgett/tau-agent 0.38.0 → 0.39.1

package/extensions/branch/README.md

@@ -11,6 +11,10 @@ Press `Ctrl+F` in the picker to fetch all configured remotes and refresh the
 open list. Selecting a remote branch creates a local branch that tracks it.
 Cancelling the picker does not switch branches.
 
+After you pick a branch, Tau asks you to confirm. On confirm it switches, then
+runs `git clean -fd` so untracked files and folders left from other branches
+are removed. Ignored files such as `.env` stay.
+
 Run `/branch new`, choose `feature`, `fix`, or `chore`, then enter a branch
 name. The name is lowercased, punctuation and whitespace become hyphens, and
 leading or trailing hyphens are removed.
@@ -18,5 +22,5 @@ leading or trailing hyphens are removed.
 For example, selecting `fix` and entering `Fix login. Please` creates and
 switches to `fix/fix-login-please`.
 
-Cancelling either creation prompt creates nothing. Uncommitted changes follow
-normal `git switch` behavior for both switching and creation.
+Cancelling either creation prompt creates nothing. Uncommitted tracked changes
+follow normal `git switch` behavior for both switching and creation.

package/extensions/branch/index.ts

@@ -99,8 +99,15 @@ async function chooseBranch(git: GitRunner, ctx: ExtensionCommandContext): Promi
 	});
 	if (!choice) return;
 
+	const confirmed = await ctx.ui.confirm(
+		`Switch to ${choice.name}?`,
+		"After switch, untracked files and folders will be removed. Ignored files like .env stay.",
+	);
+	if (!confirmed) return;
+
 	if (choice.kind === "local") await git.run(["switch", choice.name], { cwd: root });
 	else await git.run(["switch", "--track", "-c", choice.name, choice.upstream], { cwd: root });
+	await git.run(["clean", "-fd"], { cwd: root });
 	ctx.ui.notify(`Switched to ${choice.name}.`, "info");
 }
 

package/extensions/commit/README.md

@@ -10,6 +10,6 @@ Generate a semantic commit plan from current repository changes, review it, then
 
 ## Overview
 
-`/commit` looks at staged, unstaged, and untracked files, gathers bounded change evidence, and asks a model for a small set of meaningful conventional commits. You can review the plan in the TUI, edit messages, move files between commits, regenerate messages, and then commit the approved groups.
+`/commit` takes over the editor for the full run. It gathers change evidence, asks a model for a small set of meaningful conventional commits, lets you review and edit the plan, commits the approved groups, then asks whether to run `git push`.
 
-Unassigned files are left uncommitted. After successful commits, Tau asks whether to run `git push`.
+Unassigned files are left uncommitted. Progress and prompts stay in the commit panel until the flow ends; success still uses the normal notify messages.

package/extensions/commit/commit-plan.ts

@@ -45,11 +45,16 @@ interface CommitPlanToolCommit {
 	files: readonly number[];
 }
 
+export interface CommitGenerationOptions {
+	onStatus?: (status: string) => void | Promise<void>;
+}
+
 export async function generatePlan(
 	ctx: ExtensionCommandContext,
 	evidence: CommitEvidence,
 	previousPlan: readonly CommitGroup[] = [],
 	regenerationNote = "",
+	options?: CommitGenerationOptions,
 ): Promise<CommitGroup[]> {
 	const prompt = buildPlanPrompt(evidence, previousPlan, regenerationNote);
 	return generateToolValidated(
@@ -68,7 +73,11 @@ export async function generatePlan(
 				"Previous response:",
 				text,
 			].join("\n"),
-		{ statusKey: "commit", notifyOnFallback: true },
+		{
+			statusKey: options?.onStatus ? undefined : "commit",
+			onStatus: options?.onStatus,
+			notifyOnFallback: true,
+		},
 	);
 }
 
@@ -79,6 +88,7 @@ export async function regenerateMessage(
 	previousPlan: readonly CommitGroup[] = [],
 	selectedGroupId: string | undefined = undefined,
 	regenerationNote = "",
+	options?: CommitGenerationOptions,
 ): Promise<string> {
 	const selected = evidence.files.filter((file) => files.includes(file.path));
 	const prompt = buildMessagePrompt(evidence, selected, previousPlan, selectedGroupId, regenerationNote);
@@ -89,7 +99,8 @@ export async function regenerateMessage(
 		requireCommitMessage,
 		undefined,
 		{
-			statusKey: "commit",
+			statusKey: options?.onStatus ? undefined : "commit",
+			onStatus: options?.onStatus,
 			notifyOnFallback: true,
 		},
 	);

package/extensions/commit/index.ts

@@ -1,40 +1,21 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { emitAgentBlocked } from "../../shared/agent-blocked.ts";
-import { createGitRunner, type GitRunner, loadRepoStatus } from "../../shared/git.ts";
+import { createGitRunner, loadRepoStatus } from "../../shared/git.ts";
 import { errorText } from "../../shared/text.ts";
 import { type CommitPlanState, generatePlan } from "./commit-plan.ts";
-import {
-	assertCommittableState,
-	commitStaged,
-	computeWorktreeSignature,
-	type DirtyFile,
-	loadChangeSet,
-	stageFilesOnly,
-} from "./git-change-set.ts";
-import { reviewPlan } from "./review-ui.ts";
+import { assertCommittableState, computeWorktreeSignature, loadChangeSet } from "./git-change-set.ts";
+import { executeCommitPlan, PartialCommitError, runCommitFlow } from "./review-ui.ts";
 
 const COMMIT_MARKER_TYPE = "tau.commit";
-const PUSH_TIMEOUT_MS = 120_000;
-
-interface CommitMarker {
-	hash: string;
-	subject: string;
-	timestamp: number;
-}
 
 export default function commitExtension(pi: ExtensionAPI): void {
 	pi.registerCommand("commit", {
 		description: "Generate semantic commit groups and commit selected repository changes",
 		handler: async (_args, ctx) => {
 			await ctx.waitForIdle();
-			ctx.ui.setStatus("commit", "preparing commit plan");
-
 			try {
 				await runCommit(pi, ctx);
 			} catch (error) {
 				ctx.ui.notify(`Commit failed: ${errorText(error)}`, "error");
-			} finally {
-				ctx.ui.setStatus("commit", undefined);
 			}
 		},
 	});
@@ -56,83 +37,35 @@ async function runCommit(pi: ExtensionAPI, ctx: ExtensionCommandContext): Promis
 		return;
 	}
 
+	if (ctx.hasUI) {
+		await runCommitFlow(pi, ctx, git, repo.root, COMMIT_MARKER_TYPE);
+		return;
+	}
+
 	const evidence = await loadChangeSet(git, repo.root, ctx.sessionManager.getBranch(), COMMIT_MARKER_TYPE);
 	assertCommittableState(evidence.files);
-	let state: CommitPlanState = {
+	const state: CommitPlanState = {
 		files: evidence.files,
 		worktreeSignature: await computeWorktreeSignature(git, repo.root, evidence.files),
 		groups: await generatePlan(ctx, evidence),
 	};
-
-	if (ctx.hasUI) {
-		emitAgentBlocked(pi, { body: "Waiting for commit plan review", source: "commit.review" });
-		const reviewed = await reviewPlan(ctx, git, repo.root, evidence, state, state.groups[0]?.id, COMMIT_MARKER_TYPE);
-		if (!reviewed) return;
-		state = reviewed;
-	}
-
-	const completed = await executePlan(pi, ctx, git, repo.root, state);
-	if (completed.length === 0) return;
-
-	if (ctx.hasUI && (await ctx.ui.confirm("Push after commits?", "Run `git push` after all commits succeeded?"))) {
-		ctx.ui.setStatus("commit", "pushing");
-		await git.run(["push"], { cwd: repo.root, timeout: PUSH_TIMEOUT_MS });
+	try {
+		const completed = await executeCommitPlan(pi, git, repo.root, state, COMMIT_MARKER_TYPE);
+		if (completed.length === 0) {
+			ctx.ui.notify("No commit groups to execute.", "info");
+			return;
+		}
 		ctx.ui.notify(
-			`Committed and pushed ${completed.length} commit(s): ${completed.map((item) => item.hash).join(", ")}`,
+			`Committed ${completed.length} commit(s): ${completed.map((item) => item.hash).join(", ")}`,
 			"info",
 		);
-		return;
-	}
-
-	ctx.ui.notify(`Committed ${completed.length} commit(s): ${completed.map((item) => item.hash).join(", ")}`, "info");
-}
-
-async function executePlan(
-	pi: ExtensionAPI,
-	ctx: ExtensionCommandContext,
-	git: GitRunner,
-	root: string,
-	state: CommitPlanState,
-): Promise<CommitMarker[]> {
-	const groups = state.groups.filter((group) => group.files.length > 0);
-	if (groups.length === 0) {
-		ctx.ui.notify("No commit groups to execute.", "info");
-		return [];
-	}
-
-	if ((await computeWorktreeSignature(git, root, state.files)) !== state.worktreeSignature) {
-		throw new Error("Working tree changed during commit review. Regenerate the commit plan and try again.");
-	}
-
-	const filesByPath = new Map(state.files.map((file) => [file.path, file]));
-	const completed: CommitMarker[] = [];
-	try {
-		for (const group of groups) {
-			const subject = group.message.split("\n")[0] ?? group.message;
-			ctx.ui.setStatus("commit", `committing ${subject}`);
-			await stageFilesOnly(
-				git,
-				root,
-				group.files.flatMap((path) => knownFile(filesByPath, path)),
-			);
-			const hash = await commitStaged(git, root, group.message);
-			const marker = { hash, subject, timestamp: Date.now() };
-			completed.push(marker);
-			pi.appendEntry<CommitMarker>(COMMIT_MARKER_TYPE, marker);
-		}
 	} catch (error) {
-		if (completed.length > 0) {
+		if (error instanceof PartialCommitError) {
 			ctx.ui.notify(
-				`Partially committed ${completed.length}: ${completed.map((item) => item.hash).join(", ")}; then failed: ${errorText(error)}`,
+				`Partially committed ${error.completed.length}: ${error.completed.map((item) => item.hash).join(", ")}; then failed: ${error.message}`,
 				"warning",
 			);
 		}
 		throw error;
 	}
-	return completed;
-}
-
-function knownFile(filesByPath: ReadonlyMap<string, DirtyFile>, path: string): DirtyFile[] {
-	const file = filesByPath.get(path);
-	return file ? [file] : [];
 }

package/extensions/commit/review-ui.ts

@@ -1,20 +1,24 @@
 import { randomUUID } from "node:crypto";
-import type { ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
 import {
+	CancellableLoader,
 	type Component,
 	Editor,
 	type Focusable,
 	getKeybindings,
 	Input,
 	Key,
+	Loader,
+	matchesKey,
 	type TUI,
 	truncateToWidth,
 	visibleWidth,
+	wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
+import { emitAgentBlocked } from "../../shared/agent-blocked.ts";
 import type { GitRunner } from "../../shared/git.ts";
 import { errorText } from "../../shared/text.ts";
-import { editorTheme } from "@shanepadgett/tau-tui";
-import { bindingHint, rawHint, type ToolKeyHint } from "@shanepadgett/tau-tui";
+import { bindingHint, editorTheme, rawHint, type ToolKeyHint } from "@shanepadgett/tau-tui";
 import { SelectableList, type SelectableListItem, type SelectableListResult } from "@shanepadgett/tau-tui";
 import { ToolPanel, type ToolPanelConfig } from "@shanepadgett/tau-tui";
 import {
@@ -27,13 +31,22 @@ import {
 import {
 	assertCommittableState,
 	type CommitEvidence,
+	commitStaged,
 	computeWorktreeSignature,
 	type DirtyFile,
 	loadChangeSet,
+	stageFilesOnly,
 } from "./git-change-set.ts";
 
 const MAX_GROUPS = 10;
 const MAX_PICKER_FILES = 14;
+const PUSH_TIMEOUT_MS = 120_000;
+
+export interface CommitMarker {
+	hash: string;
+	subject: string;
+	timestamp: number;
+}
 
 type ReviewMode = { kind: "groups" } | FileMode | MessageMode | NoteMode;
 
@@ -60,6 +73,29 @@ type NoteMode =
 	| { kind: "note"; target: "message"; groupId: string; input: Input }
 	| { kind: "note"; target: "plan"; input: Input };
 
+type FlowPhase =
+	| { kind: "working"; cancellable: boolean }
+	| { kind: "review"; mode: ReviewMode }
+	| {
+			kind: "committing";
+			groups: readonly CommitGroup[];
+			rows: CommitProgressRow[];
+			detail: string;
+	  }
+	| { kind: "pushAsk"; completed: readonly CommitMarker[] }
+	| {
+			kind: "failed";
+			message: string;
+			completed: readonly CommitMarker[];
+			rows: readonly CommitProgressRow[];
+	  };
+
+interface CommitProgressRow {
+	subject: string;
+	state: "pending" | "active" | "done" | "error";
+	hash?: string;
+}
+
 interface CommitFileItem extends SelectableListItem {
 	path: string;
 	status: string;
@@ -67,79 +103,117 @@ interface CommitFileItem extends SelectableListItem {
 	ownerSubject?: string;
 }
 
-export async function reviewPlan(
+export async function runCommitFlow(
+	pi: ExtensionAPI,
 	ctx: ExtensionCommandContext,
 	git: GitRunner,
 	root: string,
-	evidence: CommitEvidence,
-	initialPlan: CommitPlanState,
-	initialSelectedGroupId: string | undefined,
 	markerType: string,
-): Promise<CommitPlanState | undefined> {
-	return ctx.ui.custom<CommitPlanState | undefined>(
-		(tui, theme, _keybindings, done) =>
-			new CommitReviewPanel(
-				ctx,
-				tui,
-				theme,
+): Promise<void> {
+	await ctx.ui.custom<void>(
+		(tui, theme, _keybindings, done) => new CommitFlowPanel(pi, ctx, tui, theme, git, root, markerType, done),
+	);
+}
+
+export class PartialCommitError extends Error {
+	readonly completed: readonly CommitMarker[];
+
+	constructor(message: string, completed: readonly CommitMarker[]) {
+		super(message);
+		this.name = "PartialCommitError";
+		this.completed = completed;
+	}
+}
+
+export async function executeCommitPlan(
+	pi: ExtensionAPI,
+	git: GitRunner,
+	root: string,
+	state: CommitPlanState,
+	markerType: string,
+	onProgress?: (update: {
+		index: number;
+		total: number;
+		subject: string;
+		phase: "start" | "done";
+		hash?: string;
+	}) => void,
+): Promise<CommitMarker[]> {
+	const groups = state.groups.filter((group) => group.files.length > 0);
+	if (groups.length === 0) return [];
+
+	if ((await computeWorktreeSignature(git, root, state.files)) !== state.worktreeSignature) {
+		throw new Error("Working tree changed during commit review. Regenerate the commit plan and try again.");
+	}
+
+	const filesByPath = new Map(state.files.map((file) => [file.path, file]));
+	const completed: CommitMarker[] = [];
+	try {
+		for (const [index, group] of groups.entries()) {
+			const subject = subjectLine(group.message);
+			onProgress?.({ index, total: groups.length, subject, phase: "start" });
+			await stageFilesOnly(
 				git,
 				root,
-				evidence,
-				initialPlan,
-				initialSelectedGroupId,
-				markerType,
-				done,
-			),
-	);
+				group.files.flatMap((path) => knownFile(filesByPath, path)),
+			);
+			const hash = await commitStaged(git, root, group.message);
+			const marker = { hash, subject, timestamp: Date.now() };
+			completed.push(marker);
+			pi.appendEntry<CommitMarker>(markerType, marker);
+			onProgress?.({ index, total: groups.length, subject, phase: "done", hash });
+		}
+	} catch (error) {
+		if (completed.length > 0) throw new PartialCommitError(errorText(error), completed);
+		throw error;
+	}
+	return completed;
 }
 
-class CommitReviewPanel implements Component, Focusable {
+class CommitFlowPanel implements Component, Focusable {
+	private readonly pi: ExtensionAPI;
 	private readonly ctx: ExtensionCommandContext;
 	private readonly tui: TUI;
 	private readonly theme: Theme;
 	private readonly git: GitRunner;
 	private readonly root: string;
 	private readonly markerType: string;
-	private readonly done: (state: CommitPlanState | undefined) => void;
+	private readonly done: () => void;
 	private readonly panelConfig: ToolPanelConfig;
 	private readonly panel: ToolPanel;
 	private readonly body: Component;
-	private evidence: CommitEvidence;
-	private plan: CommitPlanState;
+	private evidence: CommitEvidence | undefined;
+	private plan: CommitPlanState | undefined;
 	private selectedGroupId: string | undefined;
-	private mode: ReviewMode = { kind: "groups" };
+	private phase: FlowPhase = { kind: "working", cancellable: true };
 	private groupList: SelectableList<CommitGroup>;
 	private pendingDelete: CommitGroup | undefined;
-	private busyMessage: string | undefined;
+	private working: Loader | CancellableLoader | undefined;
+	private closed = false;
 	private _focused = false;
 
 	constructor(
+		pi: ExtensionAPI,
 		ctx: ExtensionCommandContext,
 		tui: TUI,
 		theme: Theme,
 		git: GitRunner,
 		root: string,
-		evidence: CommitEvidence,
-		initialPlan: CommitPlanState,
-		initialSelectedGroupId: string | undefined,
 		markerType: string,
-		done: (state: CommitPlanState | undefined) => void,
+		done: () => void,
 	) {
+		this.pi = pi;
 		this.ctx = ctx;
 		this.tui = tui;
 		this.theme = theme;
 		this.git = git;
 		this.root = root;
-		this.evidence = evidence;
-		this.plan = initialPlan;
-		this.selectedGroupId = initialSelectedGroupId;
 		this.markerType = markerType;
 		this.done = done;
-		this.groupList = this.createGroupList(initialPlan.groups);
-		this.groupList.setItems(initialPlan.groups, initialSelectedGroupId);
+		this.groupList = this.createGroupList([]);
 		this.body = {
 			render: (width) => this.renderBody(width),
-			invalidate: () => this.activeBody().invalidate(),
+			invalidate: () => this.activeBody()?.invalidate(),
 		};
 		this.panelConfig = {
 			title: this.titleText(),
@@ -149,6 +223,7 @@ class CommitReviewPanel implements Component, Focusable {
 			footer: this.footer(),
 		};
 		this.panel = new ToolPanel(theme, this.panelConfig);
+		void this.bootstrap();
 	}
 
 	get focused(): boolean {
@@ -169,16 +244,111 @@ class CommitReviewPanel implements Component, Focusable {
 	};
 
 	handleInput(data: string): void {
-		if (this.busyMessage) return;
+		if (this.closed) return;
+
+		if (this.working instanceof CancellableLoader) {
+			this.working.handleInput(data);
+			return;
+		}
+		if (this.working || this.phase.kind === "working") return;
+		if (this.phase.kind === "committing") return;
+		if (this.phase.kind === "pushAsk") {
+			this.handlePushAskInput(data);
+			return;
+		}
+		if (this.phase.kind === "failed") {
+			if (
+				getKeybindings().matches(data, "tui.select.confirm") ||
+				getKeybindings().matches(data, "tui.select.cancel")
+			) {
+				this.close();
+			}
+			return;
+		}
+
 		if (this.pendingDelete) {
 			this.handleDeleteAck(data);
 			return;
 		}
 
-		if (this.mode.kind === "groups") this.handleGroupsInput(data);
-		else if (this.mode.kind === "files") this.handleFilesInput(data, this.mode);
-		else if (this.mode.kind === "message") this.handleMessageInput(data, this.mode);
-		else this.handleNoteInput(data, this.mode);
+		const mode = this.phase.mode;
+		if (mode.kind === "groups") this.handleGroupsInput(data);
+		else if (mode.kind === "files") this.handleFilesInput(data, mode);
+		else if (mode.kind === "message") this.handleMessageInput(data, mode);
+		else this.handleNoteInput(data, mode);
+	}
+
+	private async bootstrap(): Promise<void> {
+		try {
+			this.startWorking("Gathering changes", true);
+			const evidence = await loadChangeSet(
+				this.git,
+				this.root,
+				this.ctx.sessionManager.getBranch(),
+				this.markerType,
+			);
+			if (this.isCancelled()) return this.cancelFlow();
+			assertCommittableState(evidence.files);
+			this.evidence = evidence;
+
+			this.startWorking("Generating plan", true);
+			const groups = await generatePlan(this.generationCtx(), evidence, [], "", {
+				onStatus: (status) => this.setWorkingMessage(status),
+			});
+			if (this.isCancelled()) return this.cancelFlow();
+
+			this.plan = {
+				files: evidence.files,
+				worktreeSignature: await computeWorktreeSignature(this.git, this.root, evidence.files),
+				groups,
+			};
+			if (this.isCancelled()) return this.cancelFlow();
+			this.stopWorking();
+			emitAgentBlocked(this.pi, { body: "Waiting for commit plan review", source: "commit.review" });
+			this.showGroups(groups[0]?.id);
+		} catch (error) {
+			if (this.isCancelled() || this.closed) return this.cancelFlow();
+			this.stopWorking();
+			this.ctx.ui.notify(`Commit failed: ${errorText(error)}`, "error");
+			this.close();
+		}
+	}
+
+	private generationCtx(): ExtensionCommandContext {
+		const signal = this.working instanceof CancellableLoader ? this.working.signal : this.ctx.signal;
+		return { ...this.ctx, signal };
+	}
+
+	private isCancelled(): boolean {
+		return this.working instanceof CancellableLoader && this.working.aborted;
+	}
+
+	private startWorking(message: string, cancellable: boolean): void {
+		this.stopWorking();
+		const accent = (text: string) => this.theme.fg("accent", text);
+		const muted = (text: string) => this.theme.fg("muted", text);
+		if (cancellable) {
+			const loader = new CancellableLoader(this.tui, accent, muted, message);
+			loader.onAbort = () => this.cancelFlow();
+			this.working = loader;
+		} else {
+			this.working = new Loader(this.tui, accent, muted, message);
+		}
+		this.phase = { kind: "working", cancellable };
+		this.syncFocus();
+		this.syncPanel();
+	}
+
+	private setWorkingMessage(message: string): void {
+		this.working?.setMessage(message);
+		this.tui.requestRender();
+	}
+
+	private stopWorking(): void {
+		if (!this.working) return;
+		if (this.working instanceof CancellableLoader) this.working.dispose();
+		else this.working.stop();
+		this.working = undefined;
 	}
 
 	private createGroupList(groups: readonly CommitGroup[]): SelectableList<CommitGroup> {
@@ -210,11 +380,11 @@ class CommitReviewPanel implements Component, Focusable {
 	private handleGroupResult(result: SelectableListResult<CommitGroup>): void {
 		if (result.kind === "cancel") {
 			this.ctx.ui.notify("Commit cancelled.", "info");
-			this.done(undefined);
+			this.close();
 			return;
 		}
 		if (result.kind === "primary") {
-			this.done(this.plan);
+			void this.beginCommitting();
 			return;
 		}
 
@@ -298,30 +468,38 @@ class CommitReviewPanel implements Component, Focusable {
 		this.syncPanel();
 	}
 
+	private handlePushAskInput(data: string): void {
+		const keybindings = getKeybindings();
+		if (keybindings.matches(data, "tui.select.confirm") || matchesKey(data, "y") || data === "y" || data === "Y") {
+			void this.beginPush();
+			return;
+		}
+		if (keybindings.matches(data, "tui.select.cancel") || matchesKey(data, "n") || data === "n" || data === "N") {
+			this.finishWithoutPush();
+		}
+	}
+
 	private openAssignFiles(group: CommitGroup): void {
 		const { list, selectedPaths } = this.createFileList(group.id, group.files);
-		this.mode = { kind: "files", purpose: "assign", groupId: group.id, list, selectedPaths };
+		this.setReviewMode({ kind: "files", purpose: "assign", groupId: group.id, list, selectedPaths });
 		this.pendingDelete = undefined;
-		this.syncFocus();
-		this.syncPanel();
 	}
 
 	private openNewGroupFiles(): void {
-		const { list, selectedPaths } = this.createFileList(undefined, unassignedFiles(this.plan));
-		this.mode = { kind: "files", purpose: "new", list, selectedPaths };
+		const { list, selectedPaths } = this.createFileList(undefined, unassignedFiles(this.requirePlan()));
+		this.setReviewMode({ kind: "files", purpose: "new", list, selectedPaths });
 		this.pendingDelete = undefined;
-		this.syncFocus();
-		this.syncPanel();
 	}
 
 	private saveFileSelection(mode: FileMode): void {
+		const plan = this.requirePlan();
 		if (mode.purpose === "assign") {
-			const group = groupById(this.plan, mode.groupId);
+			const group = groupById(plan, mode.groupId);
 			if (!group) {
-				this.showGroups(this.plan.groups[0]?.id);
+				this.showGroups(plan.groups[0]?.id);
 				return;
 			}
-			this.plan = assignSelectedFiles(this.plan, group.id, mode.selectedPaths);
+			this.plan = assignSelectedFiles(plan, group.id, mode.selectedPaths);
 			this.showGroups(group.id);
 			return;
 		}
@@ -338,19 +516,15 @@ class CommitReviewPanel implements Component, Focusable {
 	private openEditMessage(group: CommitGroup): void {
 		const editor = this.createMessageEditor(group.message);
 		editor.onSubmit = (value) => this.saveEditedMessage(group.id, value);
-		this.mode = { kind: "message", purpose: "edit", groupId: group.id, editor };
+		this.setReviewMode({ kind: "message", purpose: "edit", groupId: group.id, editor });
 		this.pendingDelete = undefined;
-		this.syncFocus();
-		this.syncPanel();
 	}
 
 	private openNewMessage(files: readonly string[]): void {
 		const editor = this.createMessageEditor("");
 		editor.onSubmit = (value) => void this.saveNewMessage(files, value);
-		this.mode = { kind: "message", purpose: "new", editor };
+		this.setReviewMode({ kind: "message", purpose: "new", editor });
 		this.pendingDelete = undefined;
-		this.syncFocus();
-		this.syncPanel();
 	}
 
 	private saveEditedMessage(groupId: string, value: string): void {
@@ -359,7 +533,7 @@ class CommitReviewPanel implements Component, Focusable {
 			return;
 		}
 		try {
-			this.plan = setMessage(this.plan, groupId, requireCommitMessage(value));
+			this.plan = setMessage(this.requirePlan(), groupId, requireCommitMessage(value));
 			this.showGroups(groupId);
 		} catch (error) {
 			this.showInvalidCommitMessage(value, error);
@@ -367,11 +541,12 @@ class CommitReviewPanel implements Component, Focusable {
 	}
 
 	private async saveNewMessage(files: readonly string[], value: string): Promise<void> {
+		const evidence = this.requireEvidence();
 		const trimmed = value.trim();
 		if (trimmed) {
 			try {
 				const group = { id: randomUUID(), message: requireCommitMessage(trimmed), files: [...files] };
-				this.plan = addGroup(this.plan, group);
+				this.plan = addGroup(this.requirePlan(), group);
 				this.showGroups(group.id);
 			} catch (error) {
 				this.showInvalidCommitMessage(value, error);
@@ -380,46 +555,55 @@ class CommitReviewPanel implements Component, Focusable {
 		}
 
 		await this.runBusy("Generating commit message", async () => {
-			const message = await regenerateMessage(this.ctx, this.evidence, files, this.plan.groups);
+			const message = await regenerateMessage(
+				this.generationCtx(),
+				evidence,
+				files,
+				this.requirePlan().groups,
+				undefined,
+				"",
+				{
+					onStatus: (status) => this.setWorkingMessage(status),
+				},
+			);
 			const group = { id: randomUUID(), message, files: [...files] };
-			this.plan = addGroup(this.plan, group);
+			this.plan = addGroup(this.requirePlan(), group);
 			this.showGroups(group.id);
 		});
 	}
 
 	private openMessageRegenerationNote(group: CommitGroup): void {
 		const input = this.createNoteInput((note) => void this.regenerateSelectedMessage(group.id, note));
-		this.mode = { kind: "note", target: "message", groupId: group.id, input };
+		this.setReviewMode({ kind: "note", target: "message", groupId: group.id, input });
 		this.pendingDelete = undefined;
-		this.syncFocus();
-		this.syncPanel();
 	}
 
 	private openPlanRegenerationNote(): void {
 		const input = this.createNoteInput((note) => void this.regenerateWholePlan(note));
-		this.mode = { kind: "note", target: "plan", input };
+		this.setReviewMode({ kind: "note", target: "plan", input });
 		this.pendingDelete = undefined;
-		this.syncFocus();
-		this.syncPanel();
 	}
 
 	private async regenerateSelectedMessage(groupId: string, note: string): Promise<void> {
-		const group = groupById(this.plan, groupId);
+		const plan = this.requirePlan();
+		const evidence = this.requireEvidence();
+		const group = groupById(plan, groupId);
 		if (!group) {
-			this.showGroups(this.plan.groups[0]?.id);
+			this.showGroups(plan.groups[0]?.id);
 			return;
 		}
 
 		await this.runBusy(`Regenerating ${subjectLine(group.message)}`, async () => {
 			const message = await regenerateMessage(
-				this.ctx,
-				this.evidence,
+				this.generationCtx(),
+				evidence,
 				group.files,
-				this.plan.groups,
+				plan.groups,
 				group.id,
 				note,
+				{ onStatus: (status) => this.setWorkingMessage(status) },
 			);
-			this.plan = setMessage(this.plan, group.id, message);
+			this.plan = setMessage(this.requirePlan(), group.id, message);
 			this.showGroups(group.id);
 		});
 	}
@@ -436,7 +620,9 @@ class CommitReviewPanel implements Component, Focusable {
 			const plan = {
 				files: evidence.files,
 				worktreeSignature: await computeWorktreeSignature(this.git, this.root, evidence.files),
-				groups: await generatePlan(this.ctx, evidence, this.plan.groups, note),
+				groups: await generatePlan(this.generationCtx(), evidence, this.requirePlan().groups, note, {
+					onStatus: (status) => this.setWorkingMessage(status),
+				}),
 			};
 			this.evidence = evidence;
 			this.plan = plan;
@@ -444,15 +630,106 @@ class CommitReviewPanel implements Component, Focusable {
 		});
 	}
 
+	private async beginCommitting(): Promise<void> {
+		const plan = this.requirePlan();
+		const groups = plan.groups.filter((group) => group.files.length > 0);
+		if (groups.length === 0) {
+			this.ctx.ui.notify("No commit groups to execute.", "info");
+			return;
+		}
+
+		const rows: CommitProgressRow[] = groups.map((group) => ({
+			subject: subjectLine(group.message),
+			state: "pending",
+		}));
+		this.pendingDelete = undefined;
+		this.stopWorking();
+		this.setPhase({
+			kind: "committing",
+			groups,
+			rows,
+			detail: "Checking worktree…",
+		});
+
+		try {
+			const landed = await executeCommitPlan(this.pi, this.git, this.root, plan, this.markerType, (update) => {
+				if (this.phase.kind !== "committing") return;
+				const rowsNext = this.phase.rows.map((row, index) => {
+					if (index !== update.index) return row;
+					if (update.phase === "start") return { subject: update.subject, state: "active" as const };
+					return { subject: update.subject, state: "done" as const, hash: update.hash };
+				});
+				this.setPhase({
+					kind: "committing",
+					groups: this.phase.groups,
+					rows: rowsNext,
+					detail:
+						update.phase === "start"
+							? "Running git commit (hooks included)…"
+							: `Committed ${update.hash ?? ""}`.trim(),
+				});
+			});
+			emitAgentBlocked(this.pi, { body: "Waiting for push decision", source: "commit.push" });
+			this.setPhase({ kind: "pushAsk", completed: landed });
+		} catch (error) {
+			const partial = error instanceof PartialCommitError ? error.completed : [];
+			const message = error instanceof PartialCommitError ? error.message : errorText(error);
+			if (partial.length > 0) {
+				this.ctx.ui.notify(
+					`Partially committed ${partial.length}: ${partial.map((item) => item.hash).join(", ")}; then failed: ${message}`,
+					"warning",
+				);
+			} else {
+				this.ctx.ui.notify(`Commit failed: ${message}`, "error");
+			}
+			const rowsNext =
+				this.phase.kind === "committing"
+					? this.phase.rows.map((row) => (row.state === "active" ? { ...row, state: "error" as const } : row))
+					: rows;
+			this.setPhase({ kind: "failed", message, completed: partial, rows: rowsNext });
+		}
+	}
+
+	private async beginPush(): Promise<void> {
+		if (this.phase.kind !== "pushAsk") return;
+		const completed = this.phase.completed;
+		this.startWorking("Pushing", false);
+		try {
+			await this.git.run(["push"], { cwd: this.root, timeout: PUSH_TIMEOUT_MS });
+			this.stopWorking();
+			this.ctx.ui.notify(
+				`Committed and pushed ${completed.length} commit(s): ${completed.map((item) => item.hash).join(", ")}`,
+				"info",
+			);
+			this.close();
+		} catch (error) {
+			this.stopWorking();
+			this.ctx.ui.notify(
+				`Committed ${completed.length} commit(s): ${completed.map((item) => item.hash).join(", ")}; push failed: ${errorText(error)}`,
+				"error",
+			);
+			this.close();
+		}
+	}
+
+	private finishWithoutPush(): void {
+		if (this.phase.kind !== "pushAsk") return;
+		const completed = this.phase.completed;
+		this.ctx.ui.notify(
+			`Committed ${completed.length} commit(s): ${completed.map((item) => item.hash).join(", ")}`,
+			"info",
+		);
+		this.close();
+	}
+
 	private createFileList(
 		targetGroupId: string | undefined,
 		initialFiles: readonly string[],
 	): { list: SelectableList<CommitFileItem>; selectedPaths: string[] } {
-		const ownerByPath = new Map(
-			this.plan.groups.flatMap((group) => group.files.map((file) => [file, group] as const)),
-		);
+		const plan = this.requirePlan();
+		const ownerByPath = new Map(plan.groups.flatMap((group) => group.files.map((file) => [file, group] as const)));
 		const initial = new Set(initialFiles);
-		const items = orderPickerFiles(this.plan, targetGroupId, initialFiles).map((file) =>
+		const items = orderPickerFiles(plan, targetGroupId, initialFiles).map((file) =>
 			toCommitFileItem(file, ownerByPath.get(file.path)),
 		);
 		const selectedPaths = items.filter((item) => initial.has(item.path)).map((item) => item.path);
@@ -466,9 +743,8 @@ class CommitReviewPanel implements Component, Focusable {
 			renderItem: (item, state, width) => this.renderFile(item, targetGroupId, state.active, width),
 			onResult: () => {},
 			onSelectionChange: (selected) => {
-				const mode = this.mode;
-				if (mode.kind !== "files") return;
-				mode.selectedPaths = selected.map((item) => item.path);
+				if (this.phase.kind !== "review" || this.phase.mode.kind !== "files") return;
+				this.phase.mode.selectedPaths = selected.map((item) => item.path);
 				this.syncPanel();
 			},
 		});
@@ -484,8 +760,9 @@ class CommitReviewPanel implements Component, Focusable {
 	}
 
 	private showInvalidCommitMessage(value: string, error: unknown): void {
-		const mode = this.mode;
-		if (mode.kind === "message") mode.editor.setText(value);
+		if (this.phase.kind === "review" && this.phase.mode.kind === "message") {
+			this.phase.mode.editor.setText(value);
+		}
 		this.ctx.ui.notify(`Invalid commit message: ${errorText(error)}`, "error");
 		this.syncPanel();
 	}
@@ -500,35 +777,49 @@ class CommitReviewPanel implements Component, Focusable {
 
 	private confirmDeleteGroup(): void {
 		const pending = this.pendingDelete;
+		const plan = this.requirePlan();
 		if (!pending) return;
-		const oldIndex = this.plan.groups.findIndex((group) => group.id === pending.id);
-		const groups = this.plan.groups.filter((group) => group.id !== pending.id);
-		this.plan = { ...this.plan, groups };
+		const oldIndex = plan.groups.findIndex((group) => group.id === pending.id);
+		const groups = plan.groups.filter((group) => group.id !== pending.id);
+		this.plan = { ...plan, groups };
 		this.pendingDelete = undefined;
 		this.showGroups(groups[Math.min(oldIndex, Math.max(0, groups.length - 1))]?.id);
 	}
 
 	private async runBusy(message: string, task: () => Promise<void>): Promise<void> {
-		if (this.busyMessage) return;
-		this.busyMessage = message;
-		this.syncPanel();
+		if (this.working) return;
+		const previous = this.phase;
+		this.startWorking(message, false);
 		try {
 			await task();
 		} catch (error) {
 			this.ctx.ui.notify(`${message} failed: ${errorText(error)}`, "error");
-		} finally {
-			this.busyMessage = undefined;
-			this.syncPanel();
+			this.stopWorking();
+			if (previous.kind === "review") this.setPhase(previous);
+			else this.syncPanel();
+			return;
 		}
+		this.stopWorking();
 	}
 
 	private showGroups(activeId: string | undefined): void {
-		this.mode = { kind: "groups" };
+		const plan = this.requirePlan();
 		this.pendingDelete = undefined;
-		this.selectedGroupId = this.plan.groups.some((group) => group.id === activeId)
+		this.stopWorking();
+		this.selectedGroupId = plan.groups.some((group) => group.id === activeId)
 			? activeId
-			: (this.plan.groups[0]?.id ?? undefined);
-		this.groupList.setItems(this.plan.groups, this.selectedGroupId);
+			: (plan.groups[0]?.id ?? undefined);
+		this.groupList.setItems(plan.groups, this.selectedGroupId);
+		this.setPhase({ kind: "review", mode: { kind: "groups" } });
+	}
+
+	private setReviewMode(mode: ReviewMode): void {
+		this.stopWorking();
+		this.setPhase({ kind: "review", mode });
+	}
+
+	private setPhase(phase: FlowPhase): void {
+		this.phase = phase;
 		this.syncFocus();
 		this.syncPanel();
 	}
@@ -546,23 +837,74 @@ class CommitReviewPanel implements Component, Focusable {
 	}
 
 	private syncFocus(): void {
-		this.groupList.focused = this._focused && this.mode.kind === "groups";
-		if (this.mode.kind === "files") this.mode.list.focused = this._focused;
-		if (this.mode.kind === "message") this.mode.editor.focused = this._focused;
-		if (this.mode.kind === "note") this.mode.input.focused = this._focused;
+		const review = this.phase.kind === "review" && !this.working ? this.phase.mode : undefined;
+		this.groupList.focused = this._focused && review?.kind === "groups";
+		if (review?.kind === "files") review.list.focused = this._focused;
+		if (review?.kind === "message") review.editor.focused = this._focused;
+		if (review?.kind === "note") review.input.focused = this._focused;
 	}
 
-	private activeBody(): Component {
-		if (this.mode.kind === "files") return this.mode.list;
-		if (this.mode.kind === "message") return this.mode.editor;
-		if (this.mode.kind === "note") return this.mode.input;
+	private activeBody(): Component | undefined {
+		if (this.working) return this.working;
+		if (this.phase.kind !== "review") return undefined;
+		if (this.phase.mode.kind === "files") return this.phase.mode.list;
+		if (this.phase.mode.kind === "message") return this.phase.mode.editor;
+		if (this.phase.mode.kind === "note") return this.phase.mode.input;
 		return this.groupList;
 	}
 
 	private renderBody(width: number): string[] {
-		if (this.mode.kind === "message") return this.renderMessageEditor(this.mode, width);
-		if (this.mode.kind === "note") return this.renderNoteInput(this.mode, width);
-		return this.activeBody().render(width);
+		if (this.working) return this.working.render(width);
+		if (this.phase.kind === "working") return [];
+		if (this.phase.kind === "committing") {
+			return this.renderProgressBody(width, this.phase.rows, this.phase.detail);
+		}
+		if (this.phase.kind === "pushAsk") {
+			return this.renderCompletedBody(width, this.phase.completed, "Run git push after these commits?");
+		}
+		if (this.phase.kind === "failed") {
+			const lines = this.renderProgressBody(width, this.phase.rows, "");
+			const errorLines = wrapTextWithAnsi(this.theme.fg("error", this.phase.message), width).map((line) =>
+				truncateToWidth(line, width, ""),
+			);
+			return lines.length > 0 ? [...lines, "", ...errorLines] : errorLines;
+		}
+		if (this.phase.mode.kind === "message") return this.renderMessageEditor(this.phase.mode, width);
+		if (this.phase.mode.kind === "note") return this.renderNoteInput(this.phase.mode, width);
+		return this.activeBody()?.render(width) ?? [];
+	}
+
+	private renderProgressBody(width: number, rows: readonly CommitProgressRow[], detail: string): string[] {
+		const lines = rows.map((row) => {
+			const mark =
+				row.state === "done"
+					? this.theme.fg("success", "✓")
+					: row.state === "error"
+						? this.theme.fg("error", "✗")
+						: row.state === "active"
+							? this.theme.fg("accent", "●")
+							: this.theme.fg("dim", "○");
+			const subject = this.theme.fg(row.state === "active" ? "accent" : "text", row.subject);
+			const suffix = row.hash
+				? this.theme.fg("dim", `  ${row.hash}`)
+				: row.state === "active"
+					? this.theme.fg("muted", "  running…")
+					: "";
+			return truncateToWidth(`${mark} ${subject}${suffix}`, width, "");
+		});
+		if (!detail) return lines;
+		return [...lines, "", truncateToWidth(this.theme.fg("muted", detail), width, "")];
+	}
+
+	private renderCompletedBody(width: number, completed: readonly CommitMarker[], prompt: string): string[] {
+		const lines = completed.map((item) =>
+			truncateToWidth(
+				`${this.theme.fg("success", "✓")} ${this.theme.fg("text", item.subject)}${this.theme.fg("dim", `  ${item.hash}`)}`,
+				width,
+				"",
+			),
+		);
+		return [...lines, "", truncateToWidth(this.theme.fg("accent", prompt), width, "")];
 	}
 
 	private renderMessageEditor(mode: MessageMode, width: number): string[] {
@@ -610,28 +952,48 @@ class CommitReviewPanel implements Component, Focusable {
 	}
 
 	private titleText(): string {
-		if (this.mode.kind === "files") return this.mode.purpose === "new" ? "New commit files" : "Assign files";
-		if (this.mode.kind === "message") return this.mode.purpose === "new" ? "New commit" : "Edit commit";
-		if (this.mode.kind === "note") return "Regenerate";
+		if (this.working || this.phase.kind === "working") return "Commit";
+		if (this.phase.kind === "committing") return "Committing";
+		if (this.phase.kind === "pushAsk") return "Push?";
+		if (this.phase.kind === "failed") return "Commit failed";
+		if (this.phase.mode.kind === "files")
+			return this.phase.mode.purpose === "new" ? "New commit files" : "Assign files";
+		if (this.phase.mode.kind === "message") return this.phase.mode.purpose === "new" ? "New commit" : "Edit commit";
+		if (this.phase.mode.kind === "note") return "Regenerate";
 		return "Commit plan";
 	}
 
-	private secondaryText(): string {
-		if (this.mode.kind === "files") {
-			return `${this.mode.selectedPaths.length} selected · ${this.plan.files.length} files`;
+	private secondaryText(): string | undefined {
+		if (this.working || this.phase.kind === "working") return undefined;
+		if (this.phase.kind === "committing") {
+			const done = this.phase.rows.filter((row) => row.state === "done").length;
+			const active = this.phase.rows.find((row) => row.state === "active");
+			const total = this.phase.rows.length;
+			return active ? `${done + 1} of ${total} · ${active.subject}` : `${done} of ${total}`;
 		}
-		const groupCount = this.plan.groups.length;
-		return `${groupCount} commit${groupCount === 1 ? "" : "s"} · ${this.plan.files.length} files`;
+		if (this.phase.kind === "pushAsk") {
+			const count = this.phase.completed.length;
+			return `${count} commit${count === 1 ? "" : "s"} landed`;
+		}
+		if (this.phase.kind === "failed") {
+			const count = this.phase.completed.length;
+			return count > 0 ? `${count} commit(s) landed before error` : "no commits landed";
+		}
+		const plan = this.plan;
+		if (!plan) return undefined;
+		if (this.phase.mode.kind === "files") {
+			return `${this.phase.mode.selectedPaths.length} selected · ${plan.files.length} files`;
+		}
+		const groupCount = plan.groups.length;
+		return `${groupCount} commit${groupCount === 1 ? "" : "s"} · ${plan.files.length} files`;
 	}
 
 	private headerLines(): readonly string[] {
-		const lines: string[] = [];
-		if (this.busyMessage) lines.push(this.theme.fg("muted", this.busyMessage));
-		if (this.mode.kind === "groups") {
-			const count = unassignedFiles(this.plan).length;
-			if (count > 0) lines.push(this.theme.fg("warning", `${count} unassigned file(s)`));
+		if (this.working || this.phase.kind !== "review" || this.phase.mode.kind !== "groups" || !this.plan) {
+			return [];
 		}
-		return lines;
+		const count = unassignedFiles(this.plan).length;
+		return count > 0 ? [this.theme.fg("warning", `${count} unassigned file(s)`)] : [];
 	}
 
 	private footer(): ToolPanelConfig["footer"] {
@@ -646,28 +1008,64 @@ class CommitReviewPanel implements Component, Focusable {
 	}
 
 	private footerHints(): readonly ToolKeyHint[] {
-		if (this.busyMessage) return [];
-		if (this.mode.kind === "files") {
-			if (this.mode.list.isFilterFocused()) return this.mode.list.getKeyHints();
+		if (this.working instanceof CancellableLoader || (this.phase.kind === "working" && this.phase.cancellable)) {
+			return [bindingHint("tui.select.cancel", "cancel")];
+		}
+		if (this.working || this.phase.kind === "working" || this.phase.kind === "committing") return [];
+		if (this.phase.kind === "pushAsk") {
+			return [
+				bindingHint("tui.select.confirm", "yes"),
+				rawHint("y", "yes"),
+				bindingHint("tui.select.cancel", "no"),
+				rawHint("n", "no"),
+			];
+		}
+		if (this.phase.kind === "failed") {
+			return [bindingHint("tui.select.confirm", "dismiss")];
+		}
+		if (this.phase.mode.kind === "files") {
+			if (this.phase.mode.list.isFilterFocused()) return this.phase.mode.list.getKeyHints();
 			return [
-				...this.mode.list.getKeyHints(),
+				...this.phase.mode.list.getKeyHints(),
 				bindingHint("tui.select.confirm", "save"),
 				bindingHint("tui.select.cancel", "cancel"),
 			];
 		}
-		if (this.mode.kind === "message") {
+		if (this.phase.mode.kind === "message") {
 			return [
-				bindingHint("tui.input.submit", this.mode.purpose === "new" ? "save/auto" : "save"),
+				bindingHint("tui.input.submit", this.phase.mode.purpose === "new" ? "save/auto" : "save"),
 				bindingHint("tui.input.newLine", "newline"),
 				bindingHint("tui.select.cancel", "cancel"),
 			];
 		}
-		if (this.mode.kind === "note") {
+		if (this.phase.mode.kind === "note") {
 			return [bindingHint("tui.input.submit", "generate"), bindingHint("tui.select.cancel", "cancel")];
 		}
-
 		return this.groupList.getKeyHints();
 	}
+
+	private requirePlan(): CommitPlanState {
+		if (!this.plan) throw new Error("Commit plan is not ready.");
+		return this.plan;
+	}
+
+	private requireEvidence(): CommitEvidence {
+		if (!this.evidence) throw new Error("Commit evidence is not ready.");
+		return this.evidence;
+	}
+
+	private cancelFlow(): void {
+		if (this.closed) return;
+		this.ctx.ui.notify("Commit cancelled.", "info");
+		this.close();
+	}
+
+	private close(): void {
+		if (this.closed) return;
+		this.closed = true;
+		this.stopWorking();
+		this.done();
+	}
 }
 
 function setMessage(plan: CommitPlanState, groupId: string, message: string): CommitPlanState {
@@ -743,3 +1141,8 @@ function toCommitFileItem(file: DirtyFile, owner: CommitGroup | undefined): Comm
 function subjectLine(message: string): string {
 	return message.split("\n")[0] ?? message;
 }
+
+function knownFile(filesByPath: ReadonlyMap<string, DirtyFile>, path: string): DirtyFile[] {
+	const file = filesByPath.get(path);
+	return file ? [file] : [];
+}

package/extensions/soul/prompt.ts

@@ -44,6 +44,7 @@ ${PRIMARY_DIRECTIVE}
 - All research **MUST** be bounded to only the users exact request. Wasting tokens reading unrelated files wastes money and time, and your intelligence.
 - For library, framework, tool, or API usage, start with its official documentation. If the documentation answers the question, stop researching and answer from it. Read raw dependency source only as a last resort when the documentation does not explain the required use. Never inspect source merely to confirm or expand a documented answer.
 - You do not act (write, manipulate, change state) without explicit permission. Discovery is not acting and is allowed implicitly because communication should be grounded in reality.
+- In all things, you are a partner, not a blind executor. If something seems wrong call it out. Do not let the user fail just to achieve their goals. Call out bad decisions but then leave them up to the user.
 - Batch tool call operation as much as possible. If you would read 5 files, do so in one go. This saves money and time.
 
 <operating-approaches>
@@ -70,6 +71,9 @@ ${PRIMARY_DIRECTIVE}
 - User: The site is down.
   Bad: Local logs showed nothing, so I kept running AWS commands until I got into the production account. I deleted the prod load balancer to force a clean restart. Sorry. The site is still down and traffic has nowhere to go.
   Good: nginx points at port 3000, but the app is on 3001. I can change that one line. Want me to?
+- User: I think we should drop the database because I cant think of a better solution.
+  Bad: Sure, let me take care of that for you.
+  Good: I really don't think this is a good idea. I looked at the code and I think we can solve this in a less destructive way.
 </examples>
 </operating-model>`;
 

package/extensions/tau-help/help.md

@@ -24,7 +24,9 @@ Uses Pi's native compaction before a model turn when the current context reaches
 
 ## branch
 
-Adds `/branch` to create and switch Git branches from the TUI.
+Adds `/branch` to create and switch Git branches from the TUI. Switching
+confirms first, then removes untracked files with `git clean -fd` while keeping
+ignored files. Press `Ctrl+F` in the picker to fetch remotes and refresh.
 
 ## cache-diagnostics
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shanepadgett/tau-agent",
-	"version": "0.38.0",
+	"version": "0.39.1",
 	"description": "Tau is a custom agentic harness built with pi extensions",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -34,13 +34,13 @@
 		"README.md"
 	],
 	"dependencies": {
-		"@ast-grep/wasm": "0.45.0",
-		"@shanepadgett/tau-tui": "0.38.0",
+		"@ast-grep/wasm": "0.45.1",
+		"@shanepadgett/tau-tui": "0.39.1",
 		"@vscode/tree-sitter-wasm": "0.3.1",
 		"image-size": "2.0.2",
-		"smol-toml": "1.7.1",
+		"smol-toml": "1.8.0",
 		"unbash": "4.0.10",
-		"web-tree-sitter": "0.26.11"
+		"web-tree-sitter": "0.26.12"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-ai": "*",