pi-do-always 0.10.0 → 0.13.0

package/extensions/pi-do-always/index.ts

@@ -33,10 +33,10 @@
  * If no config file exists, built-in default tasks are used.
  */
 
-import { execFileSync } from "node:child_process";
+import { execFile } from "node:child_process";
 import { appendFileSync, existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { join, relative } from "node:path";
-import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import type { AgentEndEvent, ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
 import {
 	type KeyId,
@@ -51,6 +51,8 @@ import {
 } from "@earendil-works/pi-tui";
 import {
 	CHAIN_MAX,
+	COMMIT_BROWSER_MAX,
+	COMMIT_SELECT_MAX,
 	DEFAULT_SHORTCUT,
 	DEFAULT_TASKS,
 	assistantText,
@@ -59,16 +61,24 @@ import {
 	chainClear,
 	chainRemove,
 	chainRunLabel,
+	chainSummary,
 	chainUndo,
 	evaluateGuards,
 	evaluateWhen,
 	formatChainSequence,
 	formatList,
+	formatSelectedCommits,
+	groupCommitsByDate,
 	groupTasksByCategory,
+	isTaskVisible,
 	isValidKeyId,
 	mergeTasks,
 	parseConfig,
+	parseConfigRegexpValueForKey,
+	parseCommitSubject,
+	parseGitLogOutput,
 	parseStatusPorcelain,
+	parseStatusStagedUnstaged,
 	orderTasksByCategory,
 	reportAbandonedFooter,
 	reportFooter,
@@ -80,9 +90,14 @@ import {
 	resolveShortcut,
 	resolveTask,
 	shouldAutoRun,
+	stepSummary,
 	toPromptContext,
 	validateChain,
+	type ChainStepOutcome,
+	type CommitInfo,
+	type DateGroup,
 	type DoAlwaysTask,
+	type SelectedCommit,
 	type TaskContext,
 	type TableRow,
 } from "./tasks";
@@ -102,6 +117,20 @@ type SelectorResult =
  */
 type Cursor = { kind: "cell"; row: number; col: "task" | "order" } | { kind: "run" };
 
+/**
+ * Safely read a config file's contents, returning null if missing or unreadable.
+ * Read errors are reported through `onError`.
+ */
+function readConfigFile(filePath: string, onError: (message: string) => void): string | null {
+	if (!existsSync(filePath)) return null;
+	try {
+		return readFileSync(filePath, "utf-8");
+	} catch (err) {
+		onError(`do-always: could not read ${filePath}: ${err}`);
+		return null;
+	}
+}
+
 /**
  * Load tasks and the selector shortcut from config files.
  * Project-local tasks override global tasks with the same name (or are
@@ -124,11 +153,14 @@ function loadConfig(
 	const globalPath = join(getAgentDir(), "do-always.json");
 	const projectPath = join(cwd, CONFIG_DIR_NAME, "do-always.json");
 
-	const global = existsSync(globalPath)
-		? parseConfig(readFileSync(globalPath, "utf-8"), globalPath, onError)
+	const globalRaw = readConfigFile(globalPath, onError);
+	const projectRaw = readConfigFile(projectPath, onError);
+
+	const global = globalRaw !== null
+		? parseConfig(globalRaw, globalPath, onError)
 		: { tasks: [], shortcut: undefined, merge: undefined, report: undefined };
-	const project = existsSync(projectPath)
-		? parseConfig(readFileSync(projectPath, "utf-8"), projectPath, onError)
+	const project = projectRaw !== null
+		? parseConfig(projectRaw, projectPath, onError)
 		: { tasks: [], shortcut: undefined, merge: undefined, report: undefined };
 
 	// The project file's merge mode wins; otherwise the global value; otherwise
@@ -152,36 +184,36 @@ function loadConfig(
  * empty repo, …) so callers can fall back to a neutral value.
  * No shell is involved (argument array), so file names cannot inject commands.
  */
-function git(cwd: string, args: string[]): string | undefined {
-	try {
-		const out = execFileSync("git", args, {
-			cwd,
-			encoding: "utf-8",
-			stdio: ["ignore", "pipe", "ignore"],
-		});
-		const trimmed = out.trim();
-		return trimmed === "" ? undefined : trimmed;
-	} catch {
-		return undefined;
-	}
+function git(cwd: string, args: string[]): Promise<string | undefined> {
+	return new Promise((resolve) => {
+		// No stdio option: execFile's string-encoding overload doesn't accept
+		// it, and stdin/stderr need no special handling here (no input is
+		// written; stderr is simply ignored by the callback).
+		execFile(
+			"git",
+			args,
+			{ cwd, encoding: "utf-8" },
+			(error, stdout) => {
+				if (error) {
+					resolve(undefined);
+					return;
+				}
+				const trimmed = stdout.trim();
+				resolve(trimmed === "" ? undefined : trimmed);
+			},
+		);
+	});
 }
 
 /**
- * Cache that deduplicates `buildContext` calls for the same cwd within a
- * single user action (chain run, /do-always invocation, session_start).
- * The cache is created fresh for each action entry point.
+ * Count changed files (staged, unstaged, untracked) with a single git spawn.
+ * Lighter than a full `buildContext` when only the count is needed (chain
+ * step summaries). Returns 0 when git is unavailable — the same neutral
+ * result `buildContext` yields via its empty file list.
  */
-function createContextCache(): {
-	get(cwd: string): TaskContext;
-} {
-	let cached: { cwd: string; ctx: TaskContext } | null = null;
-	return {
-		get(cwd: string): TaskContext {
-			if (cached && cached.cwd === cwd) return cached.ctx;
-			cached = { cwd, ctx: buildContext(cwd) };
-			return cached.ctx;
-		},
-	};
+async function changedFileCount(cwd: string): Promise<number> {
+	const porcelain = await git(cwd, ["status", "--porcelain"]);
+	return porcelain ? parseStatusPorcelain(porcelain).length : 0;
 }
 
 /**
@@ -189,57 +221,68 @@ function createContextCache(): {
  * to neutral values when unavailable (non-git dir, no git, empty repo) so
  * default prompts read cleanly in any directory.
  *
- * Batches the 9 individual git calls into 5:
- *  1. rev-parse --abbrev-ref HEAD --is-inside-work-tree → branch + isGitRepo
- *  2. log -1 --format="%H %s" → commit hash + subject
- *  3. config --get-regexp "^user.name$|^remote.origin.url$" → user + remote
- *  4. status --porcelain → stagedFiles + unstagedFiles (parsed from porcelain)
- *  5. diff --shortstat → diffStat
+ * Collects the git facts the prompts interpolate:
+ *  1. rev-parse --is-inside-work-tree → isGitRepo
+ *  2. branch --show-current → branch (fallback: rev-parse --abbrev-ref HEAD)
+ *  3. log -1 --format="%H %s" → commit hash + subject
+ *  4. config --get-regexp "^(user.name|remote.origin.url)$" → user + repo
+ *  5. status --porcelain → files + stagedFiles + unstagedFiles
+ *  6. diff --shortstat → diffStat
+ *
+ * Outside a work tree only call 1 runs; inside one, calls 2–6 run in
+ * parallel, so wall time is about one spawn.
  */
-function buildContext(cwd: string): TaskContext {
-	// 1. Branch + isGitRepo in one call.
-	//    rev-parse --abbrev-ref HEAD --is-inside-work-tree outputs two lines:
-	//      <branch-name>
-	//      true|false
-	//    Fails (exit != 0) when not in a work tree.
-	const revParse = git(cwd, ["rev-parse", "--abbrev-ref", "HEAD", "--is-inside-work-tree"]);
-	const lines = revParse ? revParse.split("\n") : [];
-	const branch = lines[0] ?? "unknown";
-	const isGitRepo = lines[1] === "true";
-
-	// 2. Commit subject (hash is unused but cheap to fetch alongside).
-	const commitLine = isGitRepo ? git(cwd, ["log", "-1", "--format=%H %s"]) : undefined;
-	const lastCommit = commitLine ? commitLine.split(" ", 2).pop() ?? "unknown" : "unknown";
-
-	// 3. User + remote in one config call.
-	const user = isGitRepo ? git(cwd, ["config", "--get-regexp", "^user\\.name$"]) : undefined;
-	const remoteUrl = isGitRepo ? git(cwd, ["config", "--get-regexp", "^remote\\.origin\\.url$"]) : undefined;
+async function buildContext(cwd: string): Promise<TaskContext> {
+	// 1. Authoritative check: are we inside a work tree?
+	//    rev-parse --is-inside-work-tree outputs "true" when inside a work tree,
+	//    and fails (exit != 0) when outside.
+	const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+	const isGitRepo = inside === "true";
+
+	// Outside a work tree the remaining facts don't exist; skip the spawns
+	// and return the neutral fallbacks directly.
+	if (!isGitRepo) {
+		return {
+			cwd,
+			date: new Date().toLocaleDateString("en-CA"), // local YYYY-MM-DD
+			branch: "unknown",
+			lastCommit: "unknown",
+			files: [],
+			user: "unknown",
+			diffStat: "none",
+			repo: cwd.split(/[\\/]/).filter(Boolean).pop() ?? "unknown",
+			stagedFiles: [],
+			unstagedFiles: [],
+			selectedCommits: "none",
+			isGitRepo: false,
+		};
+	}
+
+	// 2–6. In a work tree: query branch and the remaining facts in parallel.
+	const [branchOut, lastCommitLine, configLine, porcelain, diffStat] = await Promise.all([
+		// branch --show-current works on both normal and unborn (empty repo) branches;
+		// returns empty on detached HEAD.
+		git(cwd, ["branch", "--show-current"]),
+		// "%H %s" prints "<hash> <subject>"; the subject may contain spaces.
+		git(cwd, ["log", "-1", "--format=%H %s"]),
+		// --get-regexp prints "key value" lines; one call covers both keys.
+		git(cwd, ["config", "--get-regexp", "^(user\\.name|remote\\.origin\\.url)$"]),
+		git(cwd, ["status", "--porcelain"]),
+		git(cwd, ["diff", "--shortstat"]),
+	]);
+
+	const branch = branchOut || (await git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])) || "unknown";
+	const lastCommit = parseCommitSubject(lastCommitLine);
+	const user = parseConfigRegexpValueForKey(configLine, "user.name");
+	const remoteUrl = parseConfigRegexpValueForKey(configLine, "remote.origin.url");
 	const repo = remoteUrl
 		? (remoteUrl.replace(/\.git$/, "").split("/").pop() ?? "unknown")
 		: cwd.split(/[\\/]/).filter(Boolean).pop() ?? "unknown";
 
-	// 4. status --porcelain gives staged + unstaged in one call.
-	//    Lines starting with a space are unstaged; others are staged/untracked.
-	const porcelain = isGitRepo ? git(cwd, ["status", "--porcelain"]) : "";
-	const stagedFiles: string[] = [];
-	const unstagedFiles: string[] = [];
-	const fileSet = new Set<string>();
-	if (porcelain) {
-		for (const line of porcelain.split("\n")) {
-			if (line.length < 2) continue;
-			const file = line.slice(2);
-			if (fileSet.has(file)) continue; // deduplicate
-			fileSet.add(file);
-			if (line[0] === " ") {
-				unstagedFiles.push(file);
-			} else {
-				stagedFiles.push(file);
-			}
-		}
-	}
-
-	// 5. diff --shortstat.
-	const diffStat = isGitRepo ? git(cwd, ["diff", "--shortstat"]) : undefined;
+	// status --porcelain gives staged + unstaged in one call.
+	// Porcelain v1 lines are "XY <path>" (path starts at index 3); a space
+	// in the X column means unstaged, anything else is staged/untracked.
+	const { staged: stagedFiles, unstaged: unstagedFiles } = parseStatusStagedUnstaged(porcelain ?? "");
 
 	return {
 		cwd,
@@ -252,23 +295,572 @@ function buildContext(cwd: string): TaskContext {
 		repo,
 		stagedFiles,
 		unstagedFiles,
+		selectedCommits: "none",
 		isGitRepo,
 	};
 }
 
+/**
+ * Fetch a page of commits from git with lightweight stats via a single log call.
+ * Fetches pageSize + 1 commits to determine if more commits are available.
+ */
+async function fetchCommitsPage(
+	cwd: string,
+	page = 0,
+	pageSize = COMMIT_BROWSER_MAX,
+): Promise<{ commits: CommitInfo[]; groups: DateGroup[]; hasMore: boolean }> {
+	const countToFetch = pageSize + 1;
+	const skip = page * pageSize;
+	const format = "COMMIT%x09%H%x09%h%x09%s%x09%ad%x09%an";
+	const logOutput = await git(cwd, [
+		"log",
+		"-n",
+		`${countToFetch}`,
+		`--skip=${skip}`,
+		`--format=${format}`,
+		"--shortstat",
+		"--date=short",
+	]);
+	if (!logOutput) {
+		return { commits: [], groups: [], hasMore: false };
+	}
+
+	const allParsed = parseGitLogOutput(logOutput);
+	const hasMore = allParsed.length > pageSize;
+	const commits = hasMore ? allParsed.slice(0, pageSize) : allParsed;
+	const groups = groupCommitsByDate(commits);
+	return { commits, groups, hasMore };
+}
+
+/**
+ * Date-grouped commit browser: browse recent commits in pages of 20, select some,
+ * then review them. Reuses the task-selector interaction model (↑↓, Space toggle,
+ * type-to-filter, Ctrl+U clear, Esc cancel, ←/→ or PgUp/PgDn for paging).
+ *
+ * Returns the selected commits (ordered by user selection), or null on cancel.
+ */
+function browseCommits(
+	ctx: ExtensionContext,
+	initialData?: { commits: CommitInfo[]; groups: DateGroup[]; hasMore: boolean },
+): Promise<SelectedCommit[] | null> {
+	return new Promise<SelectedCommit[] | null>((resolve) => {
+		const pageCache = new Map<number, { commits: CommitInfo[]; groups: DateGroup[]; hasMore: boolean }>();
+		let page = 0;
+		if (initialData) {
+			pageCache.set(0, initialData);
+		}
+
+		type CommitCursor = { kind: "commit"; index: number } | { kind: "run" };
+		const maxVisible = 14; // commits visible in the scroll window
+		const selectedMap = new Map<string, SelectedCommit>(); // hash -> SelectedCommit
+		let cursor: CommitCursor = { kind: "commit", index: 0 };
+		let lastCommitIndex = 0;
+		let filter = "";
+		let settled = false;
+		let isLoading = false;
+
+		ctx.ui.custom<SelectedCommit[] | null>((tui, theme, _kb, done) => {
+			const kb = getKeybindings();
+
+			function finish(selectedCommits: SelectedCommit[]) {
+				if (settled) return;
+				settled = true;
+				done(selectedCommits);
+				resolve(selectedCommits);
+			}
+
+			function finishCancel() {
+				if (settled) return;
+				settled = true;
+				done(null);
+				resolve(null);
+			}
+
+			async function loadPage(newPage: number) {
+				if (isLoading || newPage < 0) return;
+				page = newPage;
+				if (!pageCache.has(page)) {
+					isLoading = true;
+					tui.requestRender();
+					try {
+						const fetched = await fetchCommitsPage(ctx.cwd, page);
+						pageCache.set(page, fetched);
+					} finally {
+						isLoading = false;
+					}
+				}
+				cursor = { kind: "commit", index: 0 };
+				lastCommitIndex = 0;
+				tui.requestRender();
+			}
+
+			function getCurrentPageData() {
+				return pageCache.get(page) ?? { commits: [], groups: [], hasMore: false };
+			}
+
+			function getVisibleCommits(): CommitInfo[] {
+				const { commits } = getCurrentPageData();
+				if (!filter) return commits;
+				const f = filter.toLowerCase();
+				return commits.filter(
+					(c) => c.subject.toLowerCase().includes(f) || c.shortHash.toLowerCase().includes(f),
+				);
+			}
+
+			function render(width: number): string[] {
+				const currentData = getCurrentPageData();
+				const visibleCommits = getVisibleCommits();
+				const lines: string[] = [];
+
+				// Clamp cursor index if visible list changed
+				if (cursor.kind === "commit") {
+					if (visibleCommits.length === 0) {
+						cursor = { kind: "run" };
+					} else if (cursor.index >= visibleCommits.length) {
+						cursor = { kind: "commit", index: visibleCommits.length - 1 };
+						lastCommitIndex = cursor.index;
+					}
+				}
+
+				// Header
+				const startNum = page * COMMIT_BROWSER_MAX + 1;
+				const endNum = page * COMMIT_BROWSER_MAX + (visibleCommits.length || 0);
+				const pageLabel = currentData.hasMore
+					? `Page ${page + 1} (${startNum}–${endNum}+)`
+					: `Page ${page + 1} (${startNum}–${endNum})`;
+
+				lines.push(
+					theme.fg(
+						"muted",
+						truncateToWidth(
+							`   #  DATE       HASH     FILES  ORDER  SUBJECT  [${pageLabel}]`,
+							width - 2,
+							"",
+						),
+					),
+				);
+
+				if (isLoading) {
+					lines.push(theme.fg("accent", "  Loading commits from git…"));
+				} else if (visibleCommits.length === 0) {
+					lines.push(
+						filter
+							? theme.fg("warning", `  No commits matching "${filter}" on this page`)
+							: theme.fg("muted", "  No commits found"),
+					);
+				} else {
+					const anchor = cursor.kind === "commit" ? cursor.index : lastCommitIndex;
+					const winStart = visibleCommits.length > maxVisible
+						? Math.max(0, Math.min(anchor + 1 - maxVisible, visibleCommits.length - maxVisible))
+						: 0;
+					const winEnd = Math.min(winStart + maxVisible, visibleCommits.length);
+
+					for (let i = winStart; i < winEnd; i++) {
+						const c = visibleCommits[i];
+						// Show date divider if it's the first commit in window or date changed
+						if (i === winStart || c.date !== visibleCommits[i - 1].date) {
+							lines.push(theme.fg("dim", `  ── ${c.date} ──`));
+						}
+
+						const isCursor = cursor.kind === "commit" && cursor.index === i;
+						const isSelected = selectedMap.has(c.hash);
+						const order = isSelected ? [...selectedMap.keys()].indexOf(c.hash) + 1 : 0;
+						const cursorMark = isCursor ? theme.fg("accent", "►") : " ";
+						const globalIdx = page * COMMIT_BROWSER_MAX + i + 1;
+						const num = `${cursorMark} ${String(globalIdx).padStart(2)}`;
+						const marker = isSelected ? `${theme.fg("accent", "◉")} [${order}]` : "  ·  ";
+						const hash = theme.fg("dim", c.shortHash.slice(0, 7));
+						const statStr = c.filesChanged > 0 ? `${c.filesChanged}f` : "";
+						const statCell = statStr.padStart(3);
+						const dateShort = c.date.slice(5); // MM-DD
+						const subject = truncateToWidth(c.subject, Math.max(10, width - 36), "…");
+
+						const rowText = `${num}  ${dateShort}  ${hash}  ${statCell}  ${marker}  ${subject}`;
+						if (isCursor) {
+							lines.push(theme.bg("selectedBg", theme.bold(rowText)));
+						} else {
+							lines.push(rowText);
+						}
+					}
+
+					if (visibleCommits.length > maxVisible) {
+						lines.push(
+							theme.fg(
+								"dim",
+								truncateToWidth(
+									`  (${cursor.kind === "commit" ? cursor.index + 1 : lastCommitIndex + 1}/${visibleCommits.length} on page ${page + 1})`,
+									width - 2,
+									"",
+								),
+							),
+						);
+					}
+				}
+
+				// Run row
+				lines.push("");
+				lines.push(theme.fg("dim", "  " + "─".repeat(Math.max(1, width - 4))));
+				const runLabel = selectedMap.size === 0
+					? "do on the commits (no commits selected)"
+					: `do on the commits (${selectedMap.size} commit${selectedMap.size !== 1 ? "s" : ""})`;
+				if (cursor.kind === "run") {
+					lines.push(theme.bg("selectedBg", theme.bold(`${theme.fg("accent", "►")} ${runLabel}`)));
+				} else if (selectedMap.size === 0) {
+					lines.push(theme.fg("dim", `  ${runLabel}`));
+				} else {
+					lines.push(theme.fg("accent", `  ${runLabel}`));
+				}
+
+				// Footer
+				const pageNavHints: string[] = [];
+				if (page > 0) pageNavHints.push("← prev page");
+				if (currentData.hasMore) pageNavHints.push("→ next page");
+				const pageHintStr = pageNavHints.length > 0 ? `  •  ${pageNavHints.join("  •  ")}` : "";
+
+				let footer = `  space/⏎ select  •  ↑/↓ move${pageHintStr}  •  esc`;
+				if (selectedMap.size > 0) {
+					footer += "  •  ctrl+u clear";
+				}
+				if (filter) {
+					footer += `  •  filter: "${filter}"`;
+				}
+				lines.push(theme.fg("dim", truncateToWidth(footer, width - 2, "")));
+
+				return lines;
+			}
+
+			async function handleInput(data: string) {
+				if (settled) return;
+				const currentData = getCurrentPageData();
+				const visibleCommits = getVisibleCommits();
+
+				// Space: toggle selection on current commit
+				if (matchesKey(data, "space")) {
+					if (cursor.kind === "commit" && visibleCommits[cursor.index]) {
+						const c = visibleCommits[cursor.index];
+						if (selectedMap.has(c.hash)) {
+							selectedMap.delete(c.hash);
+							let i = 1;
+							for (const sc of selectedMap.values()) {
+								sc.selectionOrder = i++;
+							}
+						} else if (selectedMap.size < COMMIT_SELECT_MAX) {
+							selectedMap.set(c.hash, { ...c, selectionOrder: selectedMap.size + 1 });
+						} else {
+							ctx.ui.notify(`do-always: chain is full (${COMMIT_SELECT_MAX}) — remove a commit first`, "error");
+						}
+						tui.requestRender();
+					}
+					return;
+				}
+
+				// Confirm (Enter): run the chain if on run row, or toggle selection if on a commit
+				if (kb.matches(data, "tui.select.confirm") || matchesKey(data, "enter")) {
+					if (cursor.kind === "run") {
+						if (selectedMap.size === 0) {
+							ctx.ui.notify("do-always: no commits selected", "info");
+						} else {
+							finish([...selectedMap.values()]);
+						}
+						return;
+					}
+					if (cursor.kind === "commit" && visibleCommits[cursor.index]) {
+						const c = visibleCommits[cursor.index];
+						if (selectedMap.has(c.hash)) {
+							selectedMap.delete(c.hash);
+							let i = 1;
+							for (const sc of selectedMap.values()) {
+								sc.selectionOrder = i++;
+							}
+						} else if (selectedMap.size < COMMIT_SELECT_MAX) {
+							selectedMap.set(c.hash, { ...c, selectionOrder: selectedMap.size + 1 });
+						} else {
+							ctx.ui.notify(`do-always: chain is full (${COMMIT_SELECT_MAX}) — remove a commit first`, "error");
+						}
+						tui.requestRender();
+					}
+					return;
+				}
+
+				// Cancel (Esc / Ctrl+C)
+				if (kb.matches(data, "tui.select.cancel") || matchesKey(data, "escape")) {
+					finishCancel();
+					return;
+				}
+
+				// Ctrl+U: clear selections
+				if (matchesKey(data, "ctrl+u")) {
+					if (selectedMap.size > 0) {
+						selectedMap.clear();
+						tui.requestRender();
+					}
+					return;
+				}
+
+				// Backspace: delete character from filter, or undo last selection
+				if (kb.matches(data, "tui.editor.deleteCharBackward") || matchesKey(data, "backspace")) {
+					if (filter.length > 0) {
+						filter = filter.slice(0, -1);
+						cursor = { kind: "commit", index: 0 };
+						lastCommitIndex = 0;
+					} else if (selectedMap.size > 0) {
+						const lastHash = [...selectedMap.keys()].pop()!;
+						selectedMap.delete(lastHash);
+					}
+					tui.requestRender();
+					return;
+				}
+
+				// Page navigation: Next page (Right arrow, or PageDown when at the end)
+				if (matchesKey(data, "right")) {
+					if (currentData.hasMore) {
+						await loadPage(page + 1);
+					}
+					return;
+				}
+				if (kb.matches(data, "tui.select.pageDown") || matchesKey(data, "pageDown")) {
+					if (cursor.kind === "commit") {
+						const next = cursor.index + maxVisible;
+						if (next < visibleCommits.length) {
+							cursor = { kind: "commit", index: next };
+							lastCommitIndex = next;
+							tui.requestRender();
+						} else if (currentData.hasMore) {
+							await loadPage(page + 1);
+						} else {
+							cursor = { kind: "run" };
+							tui.requestRender();
+						}
+					} else if (currentData.hasMore) {
+						await loadPage(page + 1);
+					}
+					return;
+				}
+
+				// Page navigation: Previous page (Left arrow, or PageUp when at the top)
+				if (matchesKey(data, "left")) {
+					if (page > 0) {
+						await loadPage(page - 1);
+					}
+					return;
+				}
+				if (kb.matches(data, "tui.select.pageUp") || matchesKey(data, "pageUp")) {
+					if (cursor.kind === "commit") {
+						const prev = cursor.index - maxVisible;
+						if (prev >= 0) {
+							cursor = { kind: "commit", index: prev };
+							lastCommitIndex = prev;
+							tui.requestRender();
+						} else if (page > 0) {
+							await loadPage(page - 1);
+						} else {
+							cursor = { kind: "commit", index: 0 };
+							lastCommitIndex = 0;
+							tui.requestRender();
+						}
+					} else if (visibleCommits.length > 0) {
+						cursor = { kind: "commit", index: Math.max(0, visibleCommits.length - maxVisible) };
+						lastCommitIndex = cursor.index;
+						tui.requestRender();
+					}
+					return;
+				}
+
+				// Up arrow
+				if (kb.matches(data, "tui.select.up") || matchesKey(data, "up")) {
+					if (cursor.kind === "run") {
+						if (visibleCommits.length > 0) {
+							cursor = { kind: "commit", index: visibleCommits.length - 1 };
+							lastCommitIndex = visibleCommits.length - 1;
+						}
+					} else if (cursor.index > 0) {
+						cursor = { kind: "commit", index: cursor.index - 1 };
+						lastCommitIndex = cursor.index;
+					} else {
+						cursor = { kind: "run" };
+					}
+					tui.requestRender();
+					return;
+				}
+
+				// Down arrow
+				if (kb.matches(data, "tui.select.down") || matchesKey(data, "down")) {
+					if (cursor.kind === "run") {
+						if (visibleCommits.length > 0) {
+							cursor = { kind: "commit", index: 0 };
+							lastCommitIndex = 0;
+						}
+					} else if (cursor.index < visibleCommits.length - 1) {
+						cursor = { kind: "commit", index: cursor.index + 1 };
+						lastCommitIndex = cursor.index;
+					} else {
+						cursor = { kind: "run" };
+					}
+					tui.requestRender();
+					return;
+				}
+
+				// Home / End
+				if (matchesKey(data, "home")) {
+					if (visibleCommits.length > 0) {
+						cursor = { kind: "commit", index: 0 };
+						lastCommitIndex = 0;
+						tui.requestRender();
+					}
+					return;
+				}
+				if (matchesKey(data, "end")) {
+					cursor = { kind: "run" };
+					tui.requestRender();
+					return;
+				}
+
+				// Filter typing (printable chars, excluding Space which toggles)
+				if (isPrintable(data) && data !== " ") {
+					filter += data;
+					cursor = { kind: "commit", index: 0 };
+					lastCommitIndex = 0;
+					tui.requestRender();
+					return;
+				}
+			}
+
+			return {
+				render,
+				handleInput,
+				invalidate: () => {},
+			};
+		});
+	});
+}
+
 /** True for a single printable ASCII character (used for filter typing). */
 function isPrintable(data: string): boolean {
 	return data.length === 1 && data >= " " && data <= "~";
 }
 
+/**
+ * Task picker shown after a commit selection: proposes the Plan tasks (hidden
+ * ones included — e.g. "Review commits" exists to be picked here) to run on
+ * the selected commits. Type to filter, ↑/↓ move, Enter runs, Esc cancels.
+ * Returns the chosen task, or null on cancel.
+ */
+function pickPlanTaskForCommits(
+	ctx: ExtensionContext,
+	candidates: DoAlwaysTask[],
+	commitCount: number,
+): Promise<DoAlwaysTask | null> {
+	return new Promise<DoAlwaysTask | null>((resolve) => {
+		ctx.ui.custom<DoAlwaysTask | null>((tui, theme, _kb, done) => {
+			const kb = getKeybindings();
+			let settled = false;
+			let filter = "";
+			let cursor = 0;
+
+			const visible = () => {
+				if (!filter) return candidates;
+				const f = filter.toLowerCase();
+				return candidates.filter(
+					(t) =>
+						t.name.toLowerCase().includes(f) ||
+						(t.description ?? "").toLowerCase().includes(f),
+				);
+			};
+
+			function finish(task: DoAlwaysTask | null) {
+				if (settled) return;
+				settled = true;
+				done(task);
+				resolve(task);
+			}
+
+			function render(width: number): string[] {
+				const items = visible();
+				if (items.length === 0) cursor = 0;
+				else if (cursor >= items.length) cursor = items.length - 1;
+				const lines: string[] = [];
+				lines.push(
+					theme.fg(
+						"accent",
+						theme.bold(
+							truncateToWidth(
+								`  do-always — run on ${commitCount} selected commit${commitCount !== 1 ? "s" : ""}`,
+								width - 2,
+								"",
+							),
+						),
+					),
+				);
+				lines.push(theme.fg("muted", "   #  TASK"));
+				if (items.length === 0) {
+					lines.push(theme.fg("warning", `  No Plan tasks matching "${filter}"`));
+				} else {
+					for (let i = 0; i < items.length; i++) {
+						const t = items[i];
+						const auto = shouldAutoRun(t);
+						const name = truncateToWidth(t.name, Math.max(10, width - 8 - (auto ? 3 : 0)), "…", true);
+						const rowText = `  ${String(i + 1).padStart(2)}  ${auto ? "⚡ " : ""}${name}`;
+						lines.push(i === cursor ? theme.bg("selectedBg", theme.bold(rowText)) : rowText);
+					}
+				}
+				lines.push(
+					theme.fg(
+						"dim",
+						truncateToWidth(
+							`  ↑/↓ move  •  ⏎ run  •  esc${filter ? `  •  filter: "${filter}"` : ""}`,
+							width - 2,
+							"",
+						),
+					),
+				);
+				return lines;
+			}
+
+			function handleInput(data: string) {
+				if (settled) return;
+				const items = visible();
+				if (kb.matches(data, "tui.select.cancel") || matchesKey(data, "escape")) {
+					finish(null);
+					return;
+				}
+				if (kb.matches(data, "tui.select.confirm") || matchesKey(data, "enter")) {
+					finish(items[cursor] ?? null);
+					return;
+				}
+				if (kb.matches(data, "tui.select.up") || matchesKey(data, "up")) {
+					if (items.length > 0) cursor = cursor === 0 ? items.length - 1 : cursor - 1;
+					tui.requestRender();
+					return;
+				}
+				if (kb.matches(data, "tui.select.down") || matchesKey(data, "down")) {
+					if (items.length > 0) cursor = cursor === items.length - 1 ? 0 : cursor + 1;
+					tui.requestRender();
+					return;
+				}
+				if (kb.matches(data, "tui.editor.deleteCharBackward") || matchesKey(data, "backspace")) {
+					filter = filter.slice(0, -1);
+					cursor = 0;
+					tui.requestRender();
+					return;
+				}
+				if (isPrintable(data)) {
+					filter += data;
+					cursor = 0;
+					tui.requestRender();
+				}
+			}
+
+			return { render, handleInput, invalidate: () => {} };
+		});
+	});
+}
+
 /** Delay before the selector reveals the selected task's prompt preview. */
 const PREVIEW_DELAY_MS = 2000;
 /** Max lines of the prompt shown in the selector preview. */
 const PREVIEW_MAX_LINES = 3;
 
 /** Outcome of one chain step's run (see sendAndWait). */
-type ChainStepOutcome = "completed" | "aborted" | "error" | "failed-to-start";
-
 /**
  * Status of one chain step for the below-prompt status widget: pending
  * (not reached yet), running (its turn is in flight), waiting (fill-first:
@@ -319,6 +911,7 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 		resolve: (outcome: ChainStepOutcome) => void;
 		/** Which chain step (0-based) this waiter belongs to — for the report. */
 		stepIndex: number;
+		startTime?: number;
 	} | null = null;
 
 	function settleChainWaiter(outcome: ChainStepOutcome) {
@@ -326,6 +919,9 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 		const waiter = chainWaiter;
 		chainWaiter = null;
 		if (waiter.timer) clearTimeout(waiter.timer);
+		if (waiter.startTime !== undefined) {
+			chainDurations[waiter.stepIndex] = performance.now() - waiter.startTime;
+		}
 		waiter.resolve(outcome);
 	}
 
@@ -343,18 +939,49 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 	// their event waiters (the old chain's sendAndWait would resolve on the
 	// new chain's step), so starting one is refused until the first ends.
 	let chainActive = false;
+	// Per-step durations (ms) for the chain-end summary. Indexed by step
+	// position; 0 means the step was not timed (e.g. blocked before running).
+	let chainDurations: number[] = [];
+	// For single auto-run tasks: the task name whose summary we post after
+	// agent_end. Only set when a Plan task (auto-run) is sent via
+	// pi.sendUserMessage (which does NOT arm a chainWaiter). The grace timer
+	// mirrors the chain's failed-to-start handling: a send that fails before
+	// the run starts emits no agent events at all, so without it the stale
+	// flag would post a spurious summary for the next unrelated turn.
+	let pendingSummaryTask: string | null = null;
+	let pendingSummaryTimer: NodeJS.Timeout | null = null;
+
+	/** Clear the auto-run summary flag and its grace timer (session start). */
+	function resetPendingSummary(): void {
+		pendingSummaryTask = null;
+		if (pendingSummaryTimer) {
+			clearTimeout(pendingSummaryTimer);
+			pendingSummaryTimer = null;
+		}
+	}
 	// Whether chain runs write a Markdown report file (config `report`,
 	// default true). Refreshed whenever the config is (re)loaded.
 	let reportEnabled = true;
 	// The in-flight chain's report file: its path (absolute + relative for
-	// display), when the current step's run actually started (agent_start;
-	// null until then and for failed-to-start steps), whether the footer has
-	// been appended, the index of the last step section written (dedupes
-	// retried runs), and whether any step section carried result text (the
-	// file is worth keeping).
+	// display), the precomputed header (deferred — written together with the
+	// first step section, so a chain that dies before that leaves no
+	// header-only file behind), whether the file exists on disk yet, when the
+	// current step's run actually started (agent_start; null until then and
+	// for failed-to-start steps), whether the footer has been appended, the
+	// index of the last step section written (dedupes retried runs), and
+	// whether any step section carried result text (the file is worth
+	// keeping).
+	// Max in-memory sections kept for inline display; the file on disk retains
+	// all steps. Bounded to avoid holding 400KB–2MB of assistant text per chain.
+	const MAX_INLINE_SECTIONS = 3;
+
 	let chainReport: {
 		path: string;
 		display: string;
+		/** Precomputed header; written together with the first section. */
+		header: string;
+		/** True once the file exists on disk (header written). */
+		written: boolean;
 		stepStartedAt: Date | null;
 		/** True once the summary (or abandoned) footer has been appended. */
 		footerWritten: boolean;
@@ -362,8 +989,12 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 		lastStepSection: number;
 		/** True once a step section with result text was appended. */
 		hasContent: boolean;
-		/** In-memory section data for inline display (populated in agent_end). */
-		sections: Array<{ name: string; outcome: string; text: string }>;
+		/**
+		 * In-memory section data for inline display (populated in agent_end,
+		 * bounded to the last MAX_INLINE_SECTIONS). `index` is the step's
+		 * position in the chain (retries share it); `markdown` is the formatted section.
+		 */
+		sections: Array<{ index: number; markdown: string }>;
 	} | null = null;
 
 	/** Status marker glyph (all one column wide) with its color. */
@@ -425,7 +1056,25 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 	 * removes the status widget so nothing lingers below the prompt; otherwise
 	 * keeps it as a trace with the report path in the note.
 	 */
-	function finishReport(ctx: ExtensionContext): void {
+	/**
+	 * Write the deferred report header so the file exists before the first
+	 * section/footer append. Returns false when there is no report or the
+	 * write failed (a warning was shown); the chain runs on without a file.
+	 */
+	function ensureReportFile(ctx: ExtensionContext | null): boolean {
+		const report = chainReport;
+		if (!report || report.written) return report !== null;
+		try {
+			writeFileSync(report.path, report.header);
+			report.written = true;
+			return true;
+		} catch (err) {
+			ctx?.ui.notify(`do-always: could not create the report file: ${err}`, "warning");
+			return false;
+		}
+	}
+
+	async function finishReport(ctx: ExtensionContext): Promise<void> {
 		if (!chainReport || !chainStatus) return;
 		const statuses = chainStatus.steps.map((s) => s.status);
 		// Nothing worth keeping — remove the (mostly) empty file so a quick
@@ -435,19 +1084,21 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 			chainReport = null;
 			return;
 		}
-		try {
-			appendFileSync(chainReport.path, reportFooter(statuses, new Date()));
-			chainReport.footerWritten = true;
-		} catch (err) {
-			ctx.ui.notify(`do-always: could not update the report file: ${err}`, "warning");
+		if (ensureReportFile(ctx)) {
+			try {
+				appendFileSync(chainReport.path, reportFooter(statuses, new Date()));
+				chainReport.footerWritten = true;
+			} catch (err) {
+				ctx.ui.notify(`do-always: could not update the report file: ${err}`, "warning");
+			}
 		}
 		const prev = chainStatus.note ? `${chainStatus.note} • ` : "";
 		chainStatus.note = `${prev}📄 ${chainReport.display}`;
-		// Chain fully done → show inline report above editor, then clear the
+		// Chain fully done → show the inline report, then clear the
 		// trace widget. Chain stopped early → keep the trace widget.
 		const allDone = statuses.every((s) => s === "completed");
 		if (allDone) {
-			showInlineReport();
+			await showInlineReport(ctx);
 			clearChainWidget(ctx);
 		} else {
 			updateChainWidget(ctx);
@@ -455,63 +1106,69 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 	}
 
 	/**
-	 * Send the full chain report as a markdown message in the chat when a chain
-	 * completes. Built from in-memory section data (no file read needed).
-	 * Auto-cleared on the next agent_start / session_start.
+	 * Show the full chain report in an ephemeral editor view when a chain
+	 * completes (TUI only). Built from in-memory section data (no file read
+	 * needed). Nothing is persisted to the session — the view closes with
+	 * Esc and the report file on disk is the permanent artifact. In non-TUI
+	 * modes the editor is a no-op; the final notification carries the file
+	 * path.
 	 */
-	function showInlineReport(): void {
+	async function showInlineReport(ctx: ExtensionContext): Promise<void> {
+		if (ctx.mode !== "tui") return;
 		if (!chainReport || !chainStatus || chainReport.sections.length === 0) return;
-		// Reconstruct the full markdown report from in-memory sections.
+		// Reconstruct the report from in-memory sections. Only the last
+		// MAX_INLINE_SECTIONS are kept (the file on disk has all of them), so
+		// flag the omission when a step has no section in the window.
+		const shownSteps = new Set(chainReport.sections.map((s) => s.index));
+		const omitted = chainStatus.steps.length - shownSteps.size;
 		const lines: string[] = [];
 		lines.push(`# do-always chain report — ${new Date().toISOString().slice(0, 10)}`);
 		lines.push("");
 		lines.push(`- Project: ${chainReport.display}`);
 		lines.push(`- Steps: ${chainStatus.steps.map((s) => s.name).join(" → ")}`);
 		lines.push("");
-		for (const sec of chainReport.sections) {
-			const section = reportStepSection(
-				0, // index not meaningful for display
-				sec.name,
-				sec.outcome,
-				new Date(), // approximate start
-				new Date(), // approximate end
-				sec.text,
-			);
-			lines.push(section);
+		if (omitted > 0) {
+			lines.push(`> … ${omitted} earlier step${omitted === 1 ? "" : "s"} omitted — see ${chainReport.display}`);
 			lines.push("");
 		}
+		for (const sec of chainReport.sections) {
+			lines.push(sec.markdown);
+		}
 		// Footer.
 		const statuses = chainStatus.steps.map((s) => s.status);
 		lines.push(reportFooter(statuses, new Date()));
 
-		// Send as a markdown message in the chat (renders as markdown, not plain text).
-		pi.sendMessage({
-			customType: "do-always-report",
-			content: lines.join("\n"),
-			display: true,
-			details: chainReport.display,
-		});
+		// Ephemeral editor view: read the report, Esc to dismiss. Unlike
+		// pi.sendMessage this persists nothing to the session.
+		await ctx.ui.editor("do-always — chain report", lines.join("\n"));
 	}
 
 	/**
 	 * Close an in-flight report that never reached a terminal path (e.g.,
 	 * the session ended mid-chain): delete the file when the run produced
-	 * nothing worth keeping, otherwise append an "abandoned" footer so it
-	 * does not stay header-only on disk.
+	 * nothing worth keeping (a no-op when the deferred header was never
+	 * written), otherwise append an "abandoned" footer so it does not stay
+	 * header-only on disk.
 	 */
 	function closeAbandonedReport(statuses: string[]): void {
 		if (!chainReport || chainReport.footerWritten) return;
 		if (!reportWorthKeeping(statuses, chainReport.hasContent)) {
-			// Nothing worth keeping — remove the (mostly) empty file.
-			try {
-				unlinkSync(chainReport.path);
-			} catch {
-				// Best effort — the file stays on disk.
+			// Nothing worth keeping — remove the file if it was written.
+			if (chainReport.written) {
+				try {
+					unlinkSync(chainReport.path);
+				} catch {
+					// Best effort — the file stays on disk.
+				}
 			}
 			return;
 		}
 		try {
-			appendFileSync(chainReport.path, reportAbandonedFooter(statuses, new Date()));
+			if (chainReport.written) {
+				appendFileSync(chainReport.path, reportAbandonedFooter(statuses, new Date()));
+			} else {
+				writeFileSync(chainReport.path, chainReport.header + reportAbandonedFooter(statuses, new Date()));
+			}
 		} catch {
 			// Best effort — the report file stays as-is on disk.
 		}
@@ -565,7 +1222,16 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 	}
 
 	pi.on("agent_start", () => {
-		if (chainWaiter) chainWaiter.started = true;
+		if (chainWaiter) {
+			chainWaiter.started = true;
+			chainWaiter.startTime = performance.now();
+		}
+		// The run actually began — cancel the auto-run task's failed-to-start
+		// grace timer (its summary posts at agent_end).
+		if (pendingSummaryTimer) {
+			clearTimeout(pendingSummaryTimer);
+			pendingSummaryTimer = null;
+		}
 		// The run actually began — time the step for the report.
 		if (chainReport) chainReport.stepStartedAt = new Date();
 		// Fill-first: step 1 left the editor and is running — update the
@@ -579,12 +1245,47 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 			clearChainWidget(lastCtx);
 		}
 	});
+	/** The turn's last assistant message (backward scan — no copy/reverse). */
+	function lastAssistantMessage(messages: AgentEndEvent["messages"]) {
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const m = messages[i];
+			if (m.role === "assistant") return m;
+		}
+		return null;
+	}
+
+	/** Map an assistant message's stopReason to a chain step outcome. */
+	function outcomeFromStopReason(stopReason: string | undefined): "completed" | "aborted" | "error" {
+		if (stopReason === "aborted") return "aborted";
+		if (stopReason === "error") return "error";
+		return "completed";
+	}
+
 	pi.on("agent_end", (event) => {
+		// The agent may have changed the repo — drop the TTL context cache so
+		// the next action sees the new tree (a running chain keeps its own
+		// per-action snapshot and is unaffected).
+		contextCache = null;
+		// Single auto-run task summary (no chainWaiter: pi.sendUserMessage is
+		// fire-and-forget, so no armWaiter is called).
+		if (!chainWaiter && pendingSummaryTask) {
+			if (pendingSummaryTimer) {
+				clearTimeout(pendingSummaryTimer);
+				pendingSummaryTimer = null;
+			}
+			const lastAssistant = lastAssistantMessage(event.messages);
+			if (lastAssistant) {
+				const outcome = outcomeFromStopReason(lastAssistant.stopReason);
+				const summary = stepSummary(outcome, pendingSummaryTask, 0, 0);
+				lastCtx?.ui.notify(`do-always: ${summary}`, "info");
+			}
+			pendingSummaryTask = null;
+			return;
+		}
 		if (!chainWaiter) return;
-		const lastAssistant = [...event.messages].reverse().find((m) => m.role === "assistant");
+		const lastAssistant = lastAssistantMessage(event.messages);
 		if (lastAssistant) {
-			const stopReason = lastAssistant.stopReason;
-			const outcome = stopReason === "aborted" ? "aborted" : stopReason === "error" ? "error" : "completed";
+			const outcome = outcomeFromStopReason(lastAssistant.stopReason);
 			chainWaiter.outcome = outcome;
 			// Append this step's result to the report while the transcript is
 			// fresh (the step's final assistant message is its result).
@@ -595,23 +1296,30 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 				// report shows both attempts without a duplicate heading.
 				const isRetry = chainReport.lastStepSection === idx;
 				const name = chainStatus.steps[idx]?.name ?? `step ${idx + 1}`;
+				const displayName = isRetry ? `${name} (retry)` : name;
 				const text = assistantText(lastAssistant.content);
 				const section = reportStepSection(
 					idx,
-					isRetry ? `${name} (retry)` : name,
+					displayName,
 					outcome,
 					chainReport.stepStartedAt,
 					new Date(),
 					text,
 				);
-				try {
-					appendFileSync(chainReport.path, section);
-					chainReport.lastStepSection = idx;
-					if (text.trim() !== "") chainReport.hasContent = true;
-					// Keep in-memory section data for inline display.
-					chainReport.sections.push({ name, outcome, text });
-				} catch (err) {
-					lastCtx?.ui.notify(`do-always: could not update the report file: ${err}`, "warning");
+				if (ensureReportFile(lastCtx)) {
+					try {
+						appendFileSync(chainReport.path, section);
+						chainReport.lastStepSection = idx;
+						if (text.trim() !== "") chainReport.hasContent = true;
+						// Keep in-memory section data for inline display (bounded);
+						// index lets it number sections like the file.
+						chainReport.sections.push({ index: idx, markdown: section });
+						if (chainReport.sections.length > MAX_INLINE_SECTIONS) {
+							chainReport.sections.splice(0, chainReport.sections.length - MAX_INLINE_SECTIONS);
+						}
+					} catch (err) {
+						lastCtx?.ui.notify(`do-always: could not update the report file: ${err}`, "warning");
+					}
 				}
 				chainReport.stepStartedAt = null;
 			}
@@ -651,9 +1359,9 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 		return done;
 	}
 
-	/** Filter tasks by their `when` condition and refresh the completion cache. */
+	/** Filter tasks by visibility (`hidden` flag + `when` condition) and refresh the completion cache. */
 	function refreshVisible(cwd: string, context: TaskContext): DoAlwaysTask[] {
-		const visible = tasks.filter((t) => evaluateWhen(t, context));
+		const visible = tasks.filter((t) => isTaskVisible(t, context));
 		visibleCache = { cwd, visible };
 		return visible;
 	}
@@ -677,7 +1385,7 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 		});
 	}
 
-	pi.on("session_start", (_event, ctx) => {
+	pi.on("session_start", async (_event, ctx) => {
 		lastCtx = ctx;
 		// Surface config validation problems (the README promises warnings);
 		// in non-TUI modes there is no UI, so fall back to the console.
@@ -688,16 +1396,157 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 		// A failed chain's status widget is a trace of the previous session;
 		// start each session clean.
 		clearChainWidget(ctx);
+		// Likewise a stale auto-run summary flag (e.g., a send that never
+		// started) must not post a spurious summary for this session's turns.
+		resetPendingSummary();
 		loadedCwd = ctx.cwd;
 		const config = loadConfig(ctx.cwd, onError);
 		tasks = config.tasks;
 		reportEnabled = config.report;
-		refreshVisible(ctx.cwd, buildContext(ctx.cwd));
+		refreshVisible(ctx.cwd, await getContext(ctx.cwd));
 		registerShortcut(config.shortcut, onError);
 	});
 
+	// Extension-level git context cache, keyed by cwd with a short TTL:
+	// buildContext spawns git, and the repo rarely changes between actions,
+	// so the session_start precompute feeds the first /do-always and
+	// repeated invocations within the window reuse the same context.
+	// Invalidated on agent_end (the agent may have changed the repo); a
+	// running chain keeps its own per-action snapshot (createContextCache),
+	// so its steps reuse one context across the run.
+	let contextCache: { cwd: string; at: number; ctx: TaskContext } | null = null;
+	const CONTEXT_TTL_MS = 5_000;
+
+	async function getContext(cwd: string): Promise<TaskContext> {
+		if (contextCache && contextCache.cwd === cwd && Date.now() - contextCache.at < CONTEXT_TTL_MS) {
+			return contextCache.ctx;
+		}
+		const ctx = await buildContext(cwd);
+		contextCache = { cwd, at: Date.now(), ctx };
+		return ctx;
+	}
+
+	/**
+	 * Per-action context cache: the first build consults the extension-level
+	 * TTL cache (getContext), and later builds within the same action reuse
+	 * that snapshot — what the user saw in the preview is what gets injected.
+	 * Created fresh at each action entry point (runDoAlways, runChain).
+	 */
+	function createContextCache(): {
+		get(cwd: string): Promise<TaskContext>;
+	} {
+		let cached: { cwd: string; ctx: TaskContext } | null = null;
+		return {
+			async get(cwd: string): Promise<TaskContext> {
+				if (cached && cached.cwd === cwd) return cached.ctx;
+				cached = { cwd, ctx: await getContext(cwd) };
+				return cached.ctx;
+			},
+		};
+	}
+
 	/** Put the task prompt into the editor (TUI) or send it as a user message (other modes). */
 	async function fillPrompt(task: DoAlwaysTask, ctx: ExtensionContext, context: TaskContext): Promise<void> {
+		// Commit browser: any task with `browser: "commits"` opens the
+		// date-grouped browser first. The name check keeps configs that
+		// predate the field working. After the selection: a task whose prompt
+		// references {{selected_commits}} runs itself on the selection; a
+		// generic entry (e.g. "Browse commits") proposes the Plan tasks to
+		// run on it — hidden tasks included, since they exist to be picked
+		// here (non-TUI: the first one whose guards pass).
+		if (task.browser === "commits" || task.name === "Review commits") {
+			let selected: SelectedCommit[] = [];
+			if (ctx.mode !== "tui") {
+				const initialData = await fetchCommitsPage(ctx.cwd, 0, 1);
+				if (initialData.commits.length === 0) {
+					ctx.ui.notify("do-always: no commits found", "info");
+					return;
+				}
+				selected = [{ ...initialData.commits[0], selectionOrder: 1 }];
+			} else {
+				const initialData = await fetchCommitsPage(ctx.cwd, 0);
+				if (initialData.commits.length === 0) {
+					ctx.ui.notify("do-always: no commits found", "info");
+					return;
+				}
+				const result = await browseCommits(ctx, initialData);
+				if (!result) {
+					ctx.ui.notify("do-always: commit browser cancelled", "info");
+					return;
+				}
+				if (result.length === 0) {
+					ctx.ui.notify("do-always: no commits selected", "info");
+					return;
+				}
+				selected = result;
+			}
+
+			// Which task runs on the selection: the originating task when its
+			// prompt consumes {{selected_commits}}; otherwise a Plan task
+			// picked by the user (TUI) or the first whose guards pass (non-TUI).
+			const planTasks = tasks.filter(
+				(t) =>
+					!t.notForCommits &&
+					evaluateWhen(t, context) &&
+					(t.category ?? "").trim().toLowerCase() === "plan",
+			);
+			if (planTasks.length === 0) {
+				ctx.ui.notify("do-always: no Plan task available to run on the selected commits", "info");
+				return;
+			}
+			let chosen: DoAlwaysTask | undefined;
+			if (/\{\{\s*selected_commits\s*\}\}/.test(task.prompt)) {
+				chosen = task;
+			} else if (ctx.mode === "tui") {
+				const picked = await pickPlanTaskForCommits(ctx, planTasks, selected.length);
+				if (!picked) {
+					ctx.ui.notify("do-always: no task chosen — commits not used", "info");
+					return;
+				}
+				chosen = picked;
+			} else {
+				// Non-TUI: no picker — the first Plan task whose guards pass.
+				chosen = planTasks.find((t) => evaluateGuards(t, context) === null);
+			}
+			if (!chosen) {
+				ctx.ui.notify("do-always: no Plan task available to run on the selected commits (guards unmet)", "info");
+				return;
+			}
+
+			// Guards apply to the commit run too: a picked (or originating)
+			// task blocked for the current tree is not sent — same as the
+			// non-browser path below.
+			const blocked = evaluateGuards(chosen, context);
+			if (blocked) {
+				ctx.ui.notify(`do-always: ${blocked}`, "info");
+				return;
+			}
+
+			// Inject the selection: substitute {{selected_commits}} when the
+			// prompt references it, otherwise append the detail block. The run
+			// is a single turn (not a chain): sendUserMessage + summary.
+			const details = formatSelectedCommits(selected);
+			const strings = toPromptContext(context);
+			const prompt = /\{\{\s*selected_commits\s*\}\}/.test(chosen.prompt)
+				? renderPrompt(chosen.prompt, { ...strings, selected_commits: details })
+				: `${renderPrompt(chosen.prompt, strings)}\n\nSelected commits:\n${details}`;
+
+			pendingSummaryTask = chosen.name;
+			if (pendingSummaryTimer) clearTimeout(pendingSummaryTimer);
+			pendingSummaryTimer = setTimeout(() => {
+				pendingSummaryTimer = null;
+				if (!pendingSummaryTask) return;
+				const name = pendingSummaryTask;
+				pendingSummaryTask = null;
+				lastCtx?.ui.notify(`do-always: "${name}" failed to start (check model/API key)`, "error");
+			}, 10_000);
+			pi.sendUserMessage(prompt);
+			ctx.ui.notify(
+				`do-always: ${selected.length} commit${selected.length !== 1 ? "s" : ""} → ${chosen.name}`,
+				"info",
+			);
+			return;
+		}
 		const blocked = evaluateGuards(task, context);
 		if (blocked) {
 			ctx.ui.notify(`do-always: ${blocked}`, "info");
@@ -709,6 +1558,19 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 		if (shouldAutoRun(task)) {
 			// Fire-and-forget: sendUserMessage returns void; the run proceeds
 			// independently (see the chain control notes for why).
+			// Track the task so we can post a summary after agent_end.
+			pendingSummaryTask = task.name;
+			// If the run never starts (no agent events at all — same failure
+			// mode the chain's grace timer handles), drop the flag so a later
+			// unrelated turn can't post a spurious summary for this task.
+			if (pendingSummaryTimer) clearTimeout(pendingSummaryTimer);
+			pendingSummaryTimer = setTimeout(() => {
+				pendingSummaryTimer = null;
+				if (!pendingSummaryTask) return;
+				const name = pendingSummaryTask;
+				pendingSummaryTask = null;
+				lastCtx?.ui.notify(`do-always: "${name}" failed to start (check model/API key)`, "error");
+			}, 10_000);
 			pi.sendUserMessage(prompt);
 			ctx.ui.notify(`do-always: auto-ran "${task.name}"`, "info");
 			return;
@@ -747,33 +1609,37 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 			return;
 		}
 		// Fail fast: report the first blocked step before sending anything.
-		const blocked = validateChain(tasks, { items: names, history: [] }, cache.get(ctx.cwd));
+		const blocked = validateChain(tasks, { items: names, history: [] }, await cache.get(ctx.cwd));
 		if (blocked) {
 			ctx.ui.notify(`do-always: chain blocked at step ${blocked.step} (${blocked.task.name}): ${blocked.message}`, "warning");
 			return;
 		}
 		chainActive = true;
-		// Report file: one per run, in the project root, appended as each step
-		// finishes (see the report section in tasks.ts). A write failure is not
+		// Per-step durations for the chain-end summary. Re-initialized each
+		// chain run so stale durations from a previous run don't leak in.
+		// Pre-filled with 0 so the fill-first step (index 0, timed outside
+		// runChainSteps) and any unrun steps don't leave `undefined` holes
+		// that would poison the reduce with NaN.
+		chainDurations = Array.from({ length: steps.length }, () => 0);
+		// Report file: one per run, in the project root. The header is
+		// deferred until the first step section (a chain that dies before
+		// that leaves no file), and each step is appended as it finishes
+		// (see the report section in tasks.ts). A write failure is not
 		// fatal — the chain still runs, just without a report.
 		if (reportEnabled) {
 			const now = new Date();
 			const path = resolveReportPath(ctx.cwd, now);
-			try {
-				writeFileSync(path, reportHeader(ctx.cwd, steps.map((t) => t.name), now));
-				chainReport = {
-					path,
-					display: relative(ctx.cwd, path),
-					stepStartedAt: null,
-					footerWritten: false,
-					lastStepSection: -1,
-					hasContent: false,
-					sections: [],
-				};
-			} catch (err) {
-				ctx.ui.notify(`do-always: could not create the report file: ${err}`, "warning");
-				chainReport = null;
-			}
+			chainReport = {
+				path,
+				display: relative(ctx.cwd, path),
+				header: reportHeader(ctx.cwd, steps.map((t) => t.name), now),
+				written: false,
+				stepStartedAt: null,
+				footerWritten: false,
+				lastStepSection: -1,
+				hasContent: false,
+				sections: [],
+			};
 		}
 		const first = steps[0];
 		if (shouldAutoRun(first) || ctx.mode !== "tui") {
@@ -782,7 +1648,7 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 					ctx,
 					steps.map((t, i) => ({ name: t.name, status: i === 0 ? "running" : "pending" })),
 				);
-				await runChainSteps(steps, ctx, 0, cache);
+				await runChainSteps(steps, ctx, 0);
 			} finally {
 				chainActive = false;
 			}
@@ -798,7 +1664,8 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 			steps.map((t, i) => ({ name: t.name, status: i === 0 ? "waiting" : "pending" })),
 			"step 1 is in the editor — press Enter to start",
 		);
-		ctx.ui.setEditorText(renderPrompt(first.prompt, toPromptContext(cache.get(ctx.cwd))));
+		const firstContext = await cache.get(ctx.cwd);
+		ctx.ui.setEditorText(renderPrompt(first.prompt, toPromptContext(firstContext)));
 		ctx.ui.notify(
 			`do-always: step 1 of ${steps.length} in the editor — press Enter to run; steps 2–${steps.length} follow automatically`,
 			"info",
@@ -807,12 +1674,26 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 			try {
 				if (outcome !== "completed") {
 					markChainStopped(ctx, 0, outcome);
-					finishReport(ctx);
+					await finishReport(ctx);
 					ctx.ui.notify(`do-always: step 1 — ${outcome}; chain stopped`, "error");
 					return;
 				}
 				setChainStep(ctx, 0, "completed");
-				await runChainSteps(steps, ctx, 1, cache);
+				// Post-step summary for step 1 (fill-first). When more steps
+				// follow, the fresh full build doubles as step 2's pre-context
+				// (the tree can only change via agent runs, which have settled);
+				// a single-task chain only needs the file count.
+				let nextContext: TaskContext | undefined;
+				let fileCount: number;
+				if (steps.length === 1) {
+					fileCount = await changedFileCount(ctx.cwd);
+				} else {
+					nextContext = await getContext(ctx.cwd);
+					fileCount = nextContext.files.length;
+				}
+				const summary = stepSummary(outcome, first.name, chainDurations[0], fileCount);
+				ctx.ui.notify(`do-always: step 1/${steps.length} — ${summary}`, "info");
+				await runChainSteps(steps, ctx, 1, nextContext);
 			} finally {
 				chainActive = false;
 			}
@@ -820,24 +1701,31 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 	}
 
 	/**
-	 * Send chain steps `startAt..end` sequentially. Each step gets a fresh
-	 * context (so its guards see the tree as it is now) and is awaited until
-	 * its run has fully settled; an aborted/errored step (or a send that
-	 * failed to start) stops the chain.
+	 * Send chain steps `startAt..end` sequentially. Each step evaluates guards
+	 * and renders prompts against fresh repository context, and each step is
+	 * awaited until its run has fully settled; an aborted/errored step (or a
+	 * send that failed to start) stops the chain.
+	 *
+	 * Context builds are shared across steps: after each completed step the
+	 * fresh full build (needed for the file-count summary) is reused as the
+	 * next step's pre-context — the tree can only change via agent runs, and
+	 * the step has fully settled before the build runs. `initialContext` lets
+	 * the fill-first path hand over its post-step-1 build. The last step's
+	 * summary uses a single-spawn file count instead of a full build.
 	 */
 	async function runChainSteps(
 		steps: DoAlwaysTask[],
 		ctx: ExtensionContext,
 		startAt: number,
-		cache: ReturnType<typeof createContextCache>,
+		initialContext?: TaskContext,
 	): Promise<void> {
+		let context = initialContext ?? (await getContext(ctx.cwd));
 		for (let i = startAt; i < steps.length; i++) {
 			const step = steps[i];
-			const context = cache.get(ctx.cwd);
 			const blocked = evaluateGuards(step, context);
 			if (blocked) {
 				markChainStopped(ctx, i, "skipped", blocked);
-				finishReport(ctx);
+				await finishReport(ctx);
 				ctx.ui.notify(`do-always: chain stopped at step ${i + 1} (${step.name}): ${blocked}`, "warning");
 				return;
 			}
@@ -845,19 +1733,35 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 			const label = `do-always: step ${i + 1}/${steps.length} — ${step.name}`;
 			setChainStep(ctx, i, "running");
 			ctx.ui.notify(`${label} — starting`, "info");
+			const stepStart = performance.now();
 			const outcome = await sendAndWait(prompt, 10_000, i);
+			const stepDuration = chainDurations[i] || performance.now() - stepStart;
+			chainDurations[i] = stepDuration;
 			if (outcome === "completed") {
 				setChainStep(ctx, i, "completed");
+				// Post-step summary: files changed + duration. All but the last
+				// step get a fresh full build that doubles as the next step's
+				// pre-context; the last step only needs the count (one spawn).
+				let fileCount: number;
+				if (i === steps.length - 1) {
+					fileCount = await changedFileCount(ctx.cwd);
+				} else {
+					context = await getContext(ctx.cwd);
+					fileCount = context.files.length;
+				}
+				const summary = stepSummary(outcome, step.name, stepDuration, fileCount);
+				ctx.ui.notify(`do-always: step ${i + 1}/${steps.length} — ${summary}`, "info");
 				continue;
 			}
 			markChainStopped(ctx, i, outcome);
-			finishReport(ctx);
+			await finishReport(ctx);
+			const summary = stepSummary(outcome, step.name, stepDuration, 0);
 			if (outcome === "failed-to-start") {
-				ctx.ui.notify(`${label} — failed to start (check model/API key); chain stopped`, "error");
+				ctx.ui.notify(`${label} — ${summary} (check model/API key); chain stopped`, "error");
 			} else if (outcome === "aborted") {
-				ctx.ui.notify(`${label} — aborted; chain stopped`, "error");
+				ctx.ui.notify(`${label} — ${summary}; chain stopped`, "error");
 			} else {
-				ctx.ui.notify(`${label} — run errored; chain stopped`, "error");
+				ctx.ui.notify(`${label} — ${summary}; chain stopped`, "error");
 			}
 			return;
 		}
@@ -866,12 +1770,16 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 		// the prompt. Capture the display path first — finishReport clears
 		// `chainReport` when the chain is fully done.
 		const reportDisplay = chainReport?.display;
+		// Chain-end summary.
+		const completed = chainDurations.filter((d) => d > 0).length;
+		const totalMs = chainDurations.reduce((a, b) => a + b, 0);
+		const chainSum = chainSummary(completed, steps.length, totalMs);
 		if (chainReport) {
-			finishReport(ctx);
-			ctx.ui.notify(`do-always: chain complete (${steps.length} steps) — report: ${reportDisplay}`, "info");
+			await finishReport(ctx);
+			ctx.ui.notify(`do-always: ${chainSum} — report: ${reportDisplay}`, "info");
 		} else {
 			clearChainWidget(ctx);
-			ctx.ui.notify(`do-always: chain complete (${steps.length} steps)`, "info");
+			ctx.ui.notify(`do-always: ${chainSum}`, "info");
 		}
 	}
 
@@ -897,9 +1805,10 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 		context: TaskContext,
 		cache: ReturnType<typeof createContextCache>,
 	): Promise<void> {
-		// Filter by the `when` condition once per session, so hidden tasks never
-		// appear, are never numbered, and can't be picked.
-		const visibleTasks = tasks.filter((t) => evaluateWhen(t, context));
+		// Filter by the `hidden` flag and the `when` condition once per session,
+		// so hidden tasks never appear, are never numbered, and can't be picked
+		// (same predicate as refreshVisible, which numbers `/do-always <n>`).
+		const visibleTasks = tasks.filter((t) => isTaskVisible(t, context));
 		// String view for prompt rendering (derived once, used by the preview).
 		const strings = toPromptContext(context);
 		const result = await ctx.ui.custom<SelectorResult>((tui, theme, _kb, done) => {
@@ -1004,12 +1913,15 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 				);
 				return { bodyRows, itemRows, winStart, visibleHeaderNames };
 			}
+			// One pass's visible state, computed once per input event / render
+			// and shared by clampCursor, buildTable, and the navigation logic.
+			type Visible = ReturnType<typeof getVisible>;
 
 			// Keep the cursor valid after the rows or the chain change. (The
 			// ORDER cell of a non-chained row is a valid cursor position: it is
 			// the "add" state.)
-			function clampCursor() {
-				const { itemRows } = getVisible();
+			function clampCursor(visible: Visible) {
+				const { itemRows } = visible;
 				if (itemRows.length === 0) {
 					cursor = { kind: "cell", row: 0, col: "task" };
 					return;
@@ -1044,15 +1956,18 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 			}
 
 			// Cached last buildTable result (avoids double-work on mouse hit-test).
-			// Invalidated whenever chain/filter changes (handledInput calls
-			// requestRender, which re-renders before any subsequent mouse event).
-			let lastTable: ReturnType<typeof buildTable> | null = null;
+			// The table depends on cursor and preview state, so render() must
+			// rebuild it on every pass; handleMouse only reuses the last render's
+			// table (or builds one if no render has happened yet, e.g. the very
+			// first mouse event).
+			type Table = { lines: string[]; itemLine: Map<number, DoAlwaysTask>; runLine: number; orderColX: number | null };
+			let lastTable: Table | null = null;
 
 			// Build the full selector output for a width, plus the line map for
 			// mouse handling (itemLine: line -> task, runLine: the Run row,
 			// orderColX: where the ORDER cell starts, or null in the narrow tier).
-			function buildTable(width: number) {
-				const { bodyRows, itemRows, winStart, visibleHeaderNames } = getVisible();
+			function buildTable(width: number, visible: Visible = getVisible()): Table {
+				const { bodyRows, itemRows, winStart, visibleHeaderNames } = visible;
 				const { tier, taskCol, descCol, orderColX } = tableGeometry(width);
 				const lines: string[] = [];
 				const itemLine = new Map<number, DoAlwaysTask>();
@@ -1114,7 +2029,9 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 							cursor.kind === "cell" && cursor.row === idx && cursor.col === "order";
 						const num = inTaskCol
 							? `${cursorMark} ${String(itemRows[idx].globalIndex + 1).padStart(2)}`
-							: `  ${String(itemRows[idx].globalIndex + 1).padStart(2)}`;
+							: inOrderCol && tier === "narrow"
+								? `${theme.fg("warning", "►")} ${String(itemRows[idx].globalIndex + 1).padStart(2)}`
+								: `  ${String(itemRows[idx].globalIndex + 1).padStart(2)}`;
 						// ⚡ is 2 columns wide, so "⚡ " takes 3 — reserve it so
 						// auto-run rows align with the others (ORDER cell is
 						// hit-tested at a fixed x).
@@ -1213,10 +2130,12 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 
 			return {
 				render(width: number) {
-					lastTable = buildTable(width);
-					return lastTable!.lines;
+					lastTable = buildTable(width, getVisible());
+					return lastTable.lines;
+				},
+				invalidate() {
+					clearPreviewTimer();
 				},
-				invalidate() {},
 				handleInput(data: string) {
 					// Direct pick by number (1-9) — runs the task immediately (the
 					// classic fast path), closing the selector and discarding the
@@ -1227,16 +2146,17 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 						return;
 					}
 					// Filter typing (Backspace edits the filter; with an empty
-					// filter it undoes the last chain add).
+					// filter it undoes the last chain add). The filter change
+					// invalidates the visible set, so the clamp gets a fresh pass.
 					if (kb.matches(data, "tui.editor.deleteCharBackward")) {
 						if (filter.length > 0) {
 							filter = filter.slice(0, -1);
-							clampCursor();
+							clampCursor(getVisible());
 						} else {
 							const { state, removed } = chainUndo(chain);
 							if (removed) {
 								chain = state;
-								clampCursor();
+								clampCursor(getVisible());
 							}
 						}
 						resetPreview();
@@ -1245,12 +2165,16 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 					}
 					if (isPrintable(data)) {
 						filter += data;
-						clampCursor();
+						clampCursor(getVisible());
 						resetPreview();
 						tui.requestRender();
 						return;
 					}
-					const { itemRows } = getVisible();
+					// One pass for the rest of the event: navigation, confirm,
+					// and clear below all share this result (chain edits don't
+					// change itemRows, so it stays valid).
+					const visible = getVisible();
+					const { itemRows } = visible;
 					if (itemRows.length === 0) {
 						// Nothing to navigate; only Esc is useful here.
 						if (kb.matches(data, "tui.select.cancel")) finishCancel();
@@ -1317,6 +2241,51 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 						tui.requestRender();
 						return;
 					}
+					// Extended navigation: home, end, pageup, pagedown.
+					if (matchesKey(data, "home")) {
+						cursor = { kind: "cell", row: 0, col: cursor.kind === "cell" ? cursor.col : "task" };
+						lastCellRow = 0;
+						resetPreview();
+						tui.requestRender();
+						return;
+					}
+					if (matchesKey(data, "end")) {
+						cursor = { kind: "run" };
+						lastCellRow = itemRows.length - 1;
+						resetPreview();
+						tui.requestRender();
+						return;
+					}
+					if (matchesKey(data, "pageUp")) {
+						if (cursor.kind === "run") {
+							cursor = { kind: "cell", row: Math.max(0, itemRows.length - maxVisible), col: "task" };
+						} else {
+							cursor = {
+								kind: "cell",
+								row: Math.max(0, cursor.row - maxVisible),
+								col: cursor.col,
+							};
+						}
+						lastCellRow = cursor.row;
+						resetPreview();
+						tui.requestRender();
+						return;
+					}
+					if (matchesKey(data, "pageDown")) {
+						if (cursor.kind === "cell") {
+							const next = cursor.row + maxVisible;
+							if (next >= itemRows.length) {
+								cursor = { kind: "run" };
+								lastCellRow = itemRows.length - 1;
+							} else {
+								cursor = { kind: "cell", row: next, col: cursor.col };
+								lastCellRow = next;
+							}
+						}
+						resetPreview();
+						tui.requestRender();
+						return;
+					}
 					// Confirm: context-dependent.
 					if (kb.matches(data, "tui.select.confirm")) {
 						if (cursor.kind === "run") {
@@ -1336,6 +2305,13 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 							return;
 						}
 						// ORDER column: toggle this task's chain membership.
+						// Browser tasks can't be chained: the chain runner sends
+						// prompts directly, so the browser (and
+						// {{selected_commits}}) never run — run them on their own.
+						if (row.task.browser) {
+							ctx.ui.notify(`do-always: "${row.task.name}" opens a browser — it can't be chained, run it on its own`, "info");
+							return;
+						}
 						if (chain.items.includes(row.task.name)) {
 							chain = chainRemove(chain, row.task.name);
 						} else {
@@ -1354,7 +2330,7 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 					if (matchesKey(data, "ctrl+u")) {
 						if (chain.items.length > 0) {
 							chain = chainClear();
-							clampCursor();
+							clampCursor(visible);
 							resetPreview();
 							tui.requestRender();
 						}
@@ -1378,11 +2354,14 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 						return { handled: true, render: true };
 					}
 					if (event.button !== "left" || (event.type !== "press" && event.type !== "click")) return undefined;
-					// Reuse the last render's table for hit-testing (avoids
-				// rebuilding the table twice per mouse event). The table is
-				// always fresh because handleInput calls requestRender before
-				// the next mouse event can arrive.
-				const { itemLine, runLine, orderColX } = lastTable ?? buildTable(event.width);
+				// Reuse the last render's table for hit-testing (avoids rebuilding
+				// the table twice per mouse event). The table is always fresh
+				// because handleInput calls requestRender before the next mouse
+				// event can arrive; build one if no render has happened yet.
+				// One getVisible() per event, shared by the (possibly fresh)
+				// table and the itemRows lookup below.
+				const visible = getVisible();
+				const { itemLine, runLine, orderColX } = lastTable ?? buildTable(event.width, visible);
 					// Pinned Run row: press runs the chain.
 					if (runLine >= 0 && event.y === runLine) {
 						if (event.type === "press" && chain.items.length > 0) {
@@ -1392,19 +2371,25 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 					}
 					const task = itemLine.get(event.y);
 					if (!task) return undefined;
-					const { itemRows } = getVisible();
+					const { itemRows } = visible;
 					const idx = itemRows.findIndex((r) => r.task === task);
 					if (idx < 0) return undefined;
-					// ORDER cell: press toggles chain membership.
-					if (orderColX !== null && event.x >= orderColX) {
-						if (event.type === "press") {
-							chain = chain.items.includes(task.name) ? chainRemove(chain, task.name) : chainAdd(chain, task.name).state;
-							clampCursor();
-							resetPreview();
-							return { handled: true, render: true };
+						// ORDER cell: press toggles chain membership.
+						if (orderColX !== null && event.x >= orderColX) {
+							if (event.type === "press") {
+								if (task.browser) {
+									// Same rule as the keyboard toggle: browser tasks
+									// can't be chained (see ORDER column).
+									ctx.ui.notify(`do-always: "${task.name}" opens a browser — it can't be chained, run it on its own`, "info");
+									return { handled: true };
+								}
+								chain = chain.items.includes(task.name) ? chainRemove(chain, task.name) : chainAdd(chain, task.name).state;
+								clampCursor(visible);
+								resetPreview();
+								return { handled: true, render: true };
+							}
+							return { handled: true }; // swallow the click after the press action
 						}
-						return { handled: true }; // swallow the click after the press action
-					}
 					// Task area: press selects, click runs (the classic fast path).
 					if (event.type === "press") {
 						mousePressedIndex = idx;
@@ -1471,7 +2456,7 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 		// One context per command run: shared by visibility filtering, rendering,
 		// and the completion cache (never inside a render loop).
 		const cache = createContextCache();
-		const context = cache.get(ctx.cwd);
+		const context = await cache.get(ctx.cwd);
 		const visible = refreshVisible(ctx.cwd, context);
 
 		const arg = args.trim();