pi-do-always 0.9.0 → 0.12.0

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

@@ -33,43 +33,95 @@
  * If no config file exists, built-in default tasks are used.
  */
 
-import { execFileSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { execFile } from "node:child_process";
+import { appendFileSync, existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+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,
 	type TuiMouseEvent,
 	type TuiMouseEventResult,
+	Container,
+	Text,
 	getKeybindings,
+	matchesKey,
 	truncateToWidth,
-	visibleWidth,
 	wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
 import {
+	CHAIN_MAX,
 	DEFAULT_SHORTCUT,
 	DEFAULT_TASKS,
+	assistantText,
+	buildTableRows,
+	chainAdd,
+	chainClear,
+	chainRemove,
+	chainRunLabel,
+	chainSummary,
+	chainUndo,
 	evaluateGuards,
 	evaluateWhen,
+	formatChainSequence,
 	formatList,
 	groupTasksByCategory,
 	isValidKeyId,
 	mergeTasks,
 	parseConfig,
+	parseConfigRegexpValueForKey,
+	parseCommitSubject,
 	parseStatusPorcelain,
+	parseStatusStagedUnstaged,
 	orderTasksByCategory,
+	reportAbandonedFooter,
+	reportFooter,
+	reportHeader,
+	reportStepSection,
+	reportWorthKeeping,
 	renderPrompt,
+	resolveReportPath,
 	resolveShortcut,
 	resolveTask,
 	shouldAutoRun,
-	splitFileLines,
+	stepSummary,
 	toPromptContext,
+	validateChain,
+	type ChainStepOutcome,
 	type DoAlwaysTask,
 	type TaskContext,
-	type TaskGroup,
+	type TableRow,
 } from "./tasks";
 
+/**
+ * What the selector resolved to: a single task (the classic pick), a chain to
+ * run, or a cancel.
+ */
+type SelectorResult =
+	| { kind: "single"; task: DoAlwaysTask }
+	| { kind: "chain"; names: string[] }
+	| { kind: "cancel" };
+
+/**
+ * Selector cursor: a cell in the task table (TASK or ORDER column) or the
+ * pinned Run row.
+ */
+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
@@ -86,16 +138,21 @@ function loadConfig(
 ): {
 	tasks: DoAlwaysTask[];
 	shortcut: string | null;
+	/** Whether chain runs write a Markdown report file (default true). */
+	report: boolean;
 } {
 	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)
-		: { tasks: [], shortcut: undefined, merge: undefined };
-	const project = existsSync(projectPath)
-		? parseConfig(readFileSync(projectPath, "utf-8"), projectPath, onError)
-		: { tasks: [], shortcut: undefined, merge: undefined };
+	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 = 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
 	// override (the historical behavior), so existing configs are unaffected.
@@ -106,6 +163,9 @@ function loadConfig(
 		// `/do-always <n>`, and `list` all share one consistent order.
 		tasks: orderTasksByCategory(mergeTasks(global.tasks, project.tasks, DEFAULT_TASKS, mode)),
 		shortcut: resolveShortcut(global.shortcut, project.shortcut),
+		// The project file's value wins; otherwise the global value; otherwise
+		// reports are on.
+		report: project.report ?? global.report ?? true,
 	};
 }
 
@@ -115,61 +175,109 @@ 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);
+			},
+		);
+	});
 }
 
 /**
  * Build the structured context for the current directory. Git facts fall back
  * to neutral values when unavailable (non-git dir, no git, empty repo) so
- * default prompts read cleanly in any directory. The string view for
- * `renderPrompt` is derived with `toPromptContext`.
+ * default prompts read cleanly in any directory.
+ *
+ * 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 {
-	const branch = git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]) ?? "unknown";
-	const lastCommit = git(cwd, ["log", "-1", "--format=%s"]) ?? "unknown";
-	const user = git(cwd, ["config", "user.name"]) ?? "unknown";
-	// Authoritative working-tree check — the branch sentinel is not (a branch
-	// could literally be named "unknown", and detached HEAD reports "HEAD").
-	const isGitRepo = git(cwd, ["rev-parse", "--is-inside-work-tree"]) === "true";
-
-	// repo = bare name of the git remote (owner/repo.git -> repo), falling back
-	// to the basename of cwd so monorepo work stays disambiguated everywhere.
-	const remoteUrl = git(cwd, ["config", "--get", "remote.origin.url"]);
+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: [],
+			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";
 
+	// 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,
 		date: new Date().toLocaleDateString("en-CA"), // local YYYY-MM-DD
 		branch,
 		lastCommit,
-		files: parseStatusPorcelain(git(cwd, ["status", "--porcelain"]) ?? ""),
-		user,
-		diffStat: git(cwd, ["diff", "--shortstat"]) ?? "none",
+		files: parseStatusPorcelain(porcelain ?? ""),
+		user: user ?? "unknown",
+		diffStat: diffStat ?? "none",
 		repo,
-		stagedFiles: splitFileLines(git(cwd, ["diff", "--cached", "--name-only"])),
-		unstagedFiles: splitFileLines(git(cwd, ["diff", "--name-only"])),
+		stagedFiles,
+		unstagedFiles,
 		isGitRepo,
 	};
 }
 
-/** Find the group (among `groups`) that contains a task. */
-function findGroupOf(task: DoAlwaysTask, groups: TaskGroup[]): TaskGroup | undefined {
-	return groups.find((g) => g.items.includes(task));
-}
-
 /** True for a single printable ASCII character (used for filter typing). */
 function isPrintable(data: string): boolean {
 	return data.length === 1 && data >= " " && data <= "~";
@@ -180,6 +288,28 @@ 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). */
+/**
+ * Status of one chain step for the below-prompt status widget: pending
+ * (not reached yet), running (its turn is in flight), waiting (fill-first:
+ * step 1 is in the editor, waiting for the user's Enter), completed, or one
+ * of the stop outcomes (failed-to-start/aborted/error/skipped-by-guards).
+ */
+type ChainStepStatus =
+	| "pending"
+	| "running"
+	| "waiting"
+	| "completed"
+	| "failed-to-start"
+	| "aborted"
+	| "error"
+	| "skipped";
+
+interface ChainStepView {
+	name: string;
+	status: ChainStepStatus;
+}
+
 export default function doAlwaysExtension(pi: ExtensionAPI) {
 	let tasks: DoAlwaysTask[] = [];
 	let loadedCwd = ""; // cwd the cached `tasks` were loaded for
@@ -189,6 +319,474 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 	// the full list rather than guessing.
 	let visibleCache: { cwd: string; visible: DoAlwaysTask[] } | null = null;
 
+	// Chain control: `pi.sendUserMessage` is fire-and-forget (returns void),
+	// so the chain runner sequences steps on session events:
+	//   agent_start   — the run actually began. A send that fails before the
+	//                   run starts (no API key, compaction collision) never
+	//                   emits agent events and its error is swallowed by the
+	//                   runtime; the grace timer in sendAndWait turns that
+	//                   into "failed-to-start".
+	//   agent_end     — carries the run's messages; the last assistant
+	//                   message's stopReason gives completed/aborted/error.
+	//   agent_settled — the session is fully idle (the busy flag is cleared
+	//                   before this fires), so the next step can be sent
+	//                   safely; auto-retry, compaction, and queued
+	//                   continuations have all had their chance.
+	let chainWaiter: {
+		started: boolean;
+		outcome: "completed" | "aborted" | "error" | null;
+		timer: NodeJS.Timeout | null;
+		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) {
+		if (!chainWaiter) return;
+		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);
+	}
+
+	// Below-prompt status widget while a chain is running: the chain's tasks
+	// with per-step status and a (n/N) progress marker. Shown in TUI mode
+	// only; cleared when the chain completes, kept (as a trace) when it stops
+	// early, and reset on session start.
+	let chainStatus: { steps: ChainStepView[]; note?: string } | null = null;
+	const CHAIN_WIDGET_KEY = "do-always-chain";
+	// The most recent command context, so event handlers (which carry no
+	// context of their own) can still refresh the widget.
+	let lastCtx: ExtensionContext | null = null;
+	// True while a chain's runner is in flight (from start to its final
+	// outcome). A second chain started while one is running would interleave
+	// 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), 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;
+		/** Index of the last step whose section was appended (-1 = none). */
+		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,
+		 * 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. */
+	function stepMarker(status: ChainStepStatus, theme: Theme): string {
+		switch (status) {
+			case "completed":
+				return theme.fg("success", "✓");
+			case "running":
+				return theme.fg("accent", theme.bold("▶"));
+			case "waiting":
+				return theme.fg("warning", "▶");
+			case "aborted":
+				return theme.fg("warning", "⊘");
+			case "error":
+			case "failed-to-start":
+				return theme.fg("error", "✗");
+			case "skipped":
+				return theme.fg("muted", "–");
+			default:
+				return theme.fg("dim", "○");
+		}
+	}
+
+	/** Replace the chain status and refresh the widget. */
+	function showChainStatus(ctx: ExtensionContext, steps: ChainStepView[], note?: string): void {
+		chainStatus = { steps, note };
+		updateChainWidget(ctx);
+	}
+
+	/** Update one step's status (and optionally the note) and refresh. */
+	function setChainStep(ctx: ExtensionContext, index: number, status: ChainStepStatus, note?: string): void {
+		if (!chainStatus) return;
+		const s = chainStatus.steps[index];
+		if (s) s.status = status;
+		if (note !== undefined) chainStatus.note = note;
+		updateChainWidget(ctx);
+	}
+
+	/**
+	 * Mark the chain as stopped at `index` with `status`, keeping the widget
+	 * visible as a trace of where it stopped.
+	 */
+	function markChainStopped(ctx: ExtensionContext, index: number, status: ChainStepStatus, detail?: string): void {
+		const name = chainStatus?.steps[index]?.name;
+		setChainStep(
+			ctx,
+			index,
+			status,
+			`stopped at step ${index + 1}${name ? ` (${name})` : ""}${detail ? `: ${detail}` : ""}`,
+		);
+	}
+
+	/**
+	 * Finish the report file: append the summary footer. Called on every
+	 * terminal path (complete, stopped, skipped); a no-op when no report was
+	 * created (disabled or write failure). A run that produced nothing worth
+	 * keeping (no completed step, no result text) leaves no file behind — see
+	 * `reportWorthKeeping`. When the chain completed fully (all steps done),
+	 * removes the status widget so nothing lingers below the prompt; otherwise
+	 * keeps it as a trace with the report path in the note.
+	 */
+	/**
+	 * 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
+		// same-minute retry doesn't get a -N sibling next to it.
+		if (!reportWorthKeeping(statuses, chainReport.hasContent)) {
+			closeAbandonedReport(statuses);
+			chainReport = null;
+			return;
+		}
+		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 the inline report, then clear the
+		// trace widget. Chain stopped early → keep the trace widget.
+		const allDone = statuses.every((s) => s === "completed");
+		if (allDone) {
+			await showInlineReport(ctx);
+			clearChainWidget(ctx);
+		} else {
+			updateChainWidget(ctx);
+		}
+	}
+
+	/**
+	 * 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.
+	 */
+	async function showInlineReport(ctx: ExtensionContext): Promise<void> {
+		if (ctx.mode !== "tui") return;
+		if (!chainReport || !chainStatus || chainReport.sections.length === 0) return;
+		// 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("");
+		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()));
+
+		// 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 (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 file if it was written.
+			if (chainReport.written) {
+				try {
+					unlinkSync(chainReport.path);
+				} catch {
+					// Best effort — the file stays on disk.
+				}
+			}
+			return;
+		}
+		try {
+			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.
+		}
+	}
+
+	/**
+	 * Remove the widget and forget the status (and any in-flight report).
+	 * When the report never reached a terminal path (e.g., the session
+	 * ended mid-chain), it is closed by `closeAbandonedReport`.
+	 */
+	function clearChainWidget(ctx: ExtensionContext): void {
+		if (!chainStatus) return;
+		const statuses = chainStatus.steps.map((s) => s.status);
+		chainStatus = null;
+		closeAbandonedReport(statuses);
+		chainReport = null;
+		if (ctx.mode === "tui") ctx.ui.setWidget(CHAIN_WIDGET_KEY, undefined);
+	}
+
+	/**
+	 * Render the status widget from `chainStatus` (TUI only): the chain's
+	 * steps with per-step markers, a (n/N) progress line, and the note,
+	 * below the editor. Refreshed on every step change; removed by
+	 * `clearChainWidget` when the chain completes or a new prompt starts.
+	 */
+	function updateChainWidget(ctx: ExtensionContext): void {
+		if (ctx.mode !== "tui" || !chainStatus) return;
+		const { steps, note } = chainStatus;
+
+		// Chain status widget: stays below the editor.
+		ctx.ui.setWidget(
+			CHAIN_WIDGET_KEY,
+			(tui, theme) => {
+				const lines: string[] = [];
+				// (n/N): the step the chain is currently at (N when it is done).
+				let at = 0;
+				steps.forEach((s, i) => {
+					if (s.status !== "pending") at = i + 1;
+				});
+				lines.push(theme.fg("accent", theme.bold(`⛓ do-always (${at}/${steps.length})`)));
+				for (const s of steps) {
+					lines.push(`  ${stepMarker(s.status, theme)} ${s.name}`);
+				}
+				if (note) lines.push(theme.fg("muted", truncateToWidth(`  ${note}`, tui.terminal.columns - 2, "…")));
+				const container = new Container();
+				for (const line of lines) container.addChild(new Text(line, 1, 0));
+				return container;
+			},
+			{ placement: "belowEditor" },
+		);
+	}
+
+	pi.on("agent_start", () => {
+		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
+		// widget (and drop the "press Enter" note) as soon as the run starts.
+		if (lastCtx && chainStatus?.steps[0]?.status === "waiting") {
+			setChainStep(lastCtx, 0, "running", "");
+		}
+		// User entered a new prompt and the old chain is no longer active —
+		// clear the trace widget so nothing lingers below the prompt.
+		if (!chainActive && chainStatus && lastCtx) {
+			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 = lastAssistantMessage(event.messages);
+		if (lastAssistant) {
+			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).
+			if (chainReport && chainStatus) {
+				const idx = chainWaiter.stepIndex;
+				// A retried/continued run emits a second agent_end for the
+				// same step before agent_settled — mark the repeat so the
+				// 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,
+					displayName,
+					outcome,
+					chainReport.stepStartedAt,
+					new Date(),
+					text,
+				);
+				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;
+			}
+		}
+	});
+	pi.on("agent_settled", () => {
+		if (!chainWaiter) return;
+		settleChainWaiter(chainWaiter.started ? (chainWaiter.outcome ?? "completed") : "failed-to-start");
+	});
+
+	/**
+	 * Arm the chain waiter and resolve when the next run has fully settled
+	 * (agent_settled), reporting that run's outcome. With `graceMs`, resolves
+	 * "failed-to-start" if no agent_start arrives in time — a send that
+	 * throws before the run begins emits no agent events and its error is
+	 * swallowed by the runtime. `stepIndex` tags the waiter so the report
+	 * knows which chain step the run belongs to.
+	 */
+	function armWaiter(graceMs?: number, stepIndex = 0): Promise<ChainStepOutcome> {
+		return new Promise((resolve) => {
+			const timer = graceMs
+				? setTimeout(() => {
+						if (chainWaiter && !chainWaiter.started) settleChainWaiter("failed-to-start");
+					}, graceMs)
+				: null;
+			chainWaiter = { started: false, outcome: null, timer, resolve, stepIndex };
+		});
+	}
+
+	/**
+	 * Send a prompt and resolve when the run it starts has fully settled,
+	 * reporting the run's outcome (see armWaiter).
+	 */
+	function sendAndWait(prompt: string, graceMs = 10_000, stepIndex = 0): Promise<ChainStepOutcome> {
+		const done = armWaiter(graceMs, stepIndex);
+		pi.sendUserMessage(prompt);
+		return done;
+	}
+
 	/** Filter tasks by their `when` condition and refresh the completion cache. */
 	function refreshVisible(cwd: string, context: TaskContext): DoAlwaysTask[] {
 		const visible = tasks.filter((t) => evaluateWhen(t, context));
@@ -215,20 +813,66 @@ 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.
 		const onError = (m: string) => {
 			if (ctx.mode === "tui") ctx.ui.notify(m, "warning");
 			else console.warn(m);
 		};
+		// 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;
-		refreshVisible(ctx.cwd, buildContext(ctx.cwd));
+		reportEnabled = config.report;
+		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> {
 		const blocked = evaluateGuards(task, context);
@@ -240,7 +884,22 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 		// user saw is exactly what gets injected.
 		const prompt = renderPrompt(task.prompt, toPromptContext(context));
 		if (shouldAutoRun(task)) {
-			await pi.sendUserMessage(prompt);
+			// 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;
 		}
@@ -248,23 +907,214 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 			ctx.ui.setEditorText(prompt);
 			ctx.ui.notify(`do-always: prompt for "${task.name}" filled — press Enter to run`, "info");
 		} else {
-			await pi.sendUserMessage(prompt);
+			pi.sendUserMessage(prompt);
+		}
+	}
+
+	/**
+	 * Run a chain: each step is sent as its own turn, awaited in order, so the
+	 * steps run strictly one after another. Aborting (or erroring) a step
+	 * stops the chain.
+	 *
+	 * Step 1 follows the task's autoRun semantics: ⚡ tasks (and non-TUI modes)
+	 * are sent immediately; fill tasks put step 1 in the editor and wait for
+	 * its run to settle before starting the remaining steps.
+	 */
+	async function runChain(
+		names: string[],
+		ctx: ExtensionContext,
+		cache: ReturnType<typeof createContextCache>,
+	): Promise<void> {
+		if (chainActive) {
+			ctx.ui.notify("do-always: a chain is already running — wait for it to finish (or abort the current step with Esc)", "info");
+			return;
+		}
+		const steps = names
+			.map((n) => tasks.find((t) => t.name === n))
+			.filter((t): t is DoAlwaysTask => t !== undefined);
+		if (steps.length === 0) {
+			ctx.ui.notify("do-always: nothing to run", "info");
+			return;
+		}
+		// Fail fast: report the first blocked step before sending anything.
+		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;
+		// 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);
+			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") {
+			try {
+				showChainStatus(
+					ctx,
+					steps.map((t, i) => ({ name: t.name, status: i === 0 ? "running" : "pending" })),
+				);
+				await runChainSteps(steps, ctx, 0);
+			} finally {
+				chainActive = false;
+			}
+			return;
+		}
+		// Fill-first: put step 1 in the editor; the remaining steps start once
+		// step 1's run has settled successfully. No grace timer — the user
+		// takes as long as they need to press Enter. (If the user runs an
+		// unrelated prompt instead, the chain continues after it, as the
+		// notification says.)
+		showChainStatus(
+			ctx,
+			steps.map((t, i) => ({ name: t.name, status: i === 0 ? "waiting" : "pending" })),
+			"step 1 is in the editor — press Enter to start",
+		);
+		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",
+		);
+		void armWaiter(undefined, 0).then(async (outcome) => {
+			try {
+				if (outcome !== "completed") {
+					markChainStopped(ctx, 0, outcome);
+					await finishReport(ctx);
+					ctx.ui.notify(`do-always: step 1 — ${outcome}; chain stopped`, "error");
+					return;
+				}
+				setChainStep(ctx, 0, "completed");
+				// Post-step summary for step 1 (fill-first)
+				const postContext = await getContext(ctx.cwd);
+				const fileCount = postContext.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);
+			} finally {
+				chainActive = false;
+			}
+		});
+	}
+
+	/**
+	 * 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.
+	 */
+	async function runChainSteps(
+		steps: DoAlwaysTask[],
+		ctx: ExtensionContext,
+		startAt: number,
+	): Promise<void> {
+		for (let i = startAt; i < steps.length; i++) {
+			const step = steps[i];
+			const context = await getContext(ctx.cwd);
+			const blocked = evaluateGuards(step, context);
+			if (blocked) {
+				markChainStopped(ctx, i, "skipped", blocked);
+				await finishReport(ctx);
+				ctx.ui.notify(`do-always: chain stopped at step ${i + 1} (${step.name}): ${blocked}`, "warning");
+				return;
+			}
+			const prompt = renderPrompt(step.prompt, toPromptContext(context));
+			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.
+				const postContext = await getContext(ctx.cwd);
+				const fileCount = postContext.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);
+			await finishReport(ctx);
+			const summary = stepSummary(outcome, step.name, stepDuration, 0);
+			if (outcome === "failed-to-start") {
+				ctx.ui.notify(`${label} — ${summary} (check model/API key); chain stopped`, "error");
+			} else if (outcome === "aborted") {
+				ctx.ui.notify(`${label} — ${summary}; chain stopped`, "error");
+			} else {
+				ctx.ui.notify(`${label} — ${summary}; chain stopped`, "error");
+			}
+			return;
+		}
+		// Complete: the report file holds the full results of every step;
+		// finishReport clears the status widget so nothing lingers below
+		// 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) {
+			await finishReport(ctx);
+			ctx.ui.notify(`do-always: ${chainSum} — report: ${reportDisplay}`, "info");
+		} else {
+			clearChainWidget(ctx);
+			ctx.ui.notify(`do-always: ${chainSum}`, "info");
 		}
 	}
 
 	/**
-	 * Numbered selector with categorized sections. Press 1-9 to pick by global
-	 * number, type to filter, or navigate with arrows + Enter, Esc to cancel.
-	 * The context is built once per command run (never inside the render loop
-	 * — no process spawning per frame) and shared with `fillPrompt`.
+	 * Task table with an ORDER column (the chain) and a pinned Run row:
+	 *
+	 *   #  TASK                  DESCRIPTION              ORDER
+	 *   1  ⚡ Review changes      Review the current       ►[1]
+	 *   2  Build                 Build the project          ·
+	 *   ─────────────────────────────────────────────────────
+	 *   Run the chain (1)
+	 *
+	 * The TASK column is primary: Enter runs just the task under the cursor
+	 * (the classic pick). The ORDER column is the optional chain: Enter
+	 * toggles the task's membership, and the pinned Run row runs the whole
+	 * chain. ←/→ switch columns, 1-9 still runs a task immediately (closing
+	 * the selector, discarding the chain). The context is built once per command
+	 * run (never inside the render loop — no process spawning per frame) and
+	 * shared with `fillPrompt`.
 	 */
-	async function showSelector(ctx: ExtensionContext, context: TaskContext): Promise<void> {
+	async function showSelector(
+		ctx: ExtensionContext,
+		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));
 		// String view for prompt rendering (derived once, used by the preview).
 		const strings = toPromptContext(context);
-		const selected = await ctx.ui.custom<number | null>((tui, theme, _kb, done) => {
+		const result = await ctx.ui.custom<SelectorResult>((tui, theme, _kb, done) => {
 			let settled = false;
 			let previewVisible = false;
 			let previewTimer: ReturnType<typeof setTimeout> | null = null;
@@ -276,16 +1126,28 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 				}
 			}
 
-			// `finish` receives the chosen task (or null) and translates it to the
-			// full index `tasks[selected]` expects. Reference-based, so it stays
-			// correct while a text filter is active (itemRows is then a subset of
-			// visibleTasks and positional indices would point at the wrong task).
-			const finish = (task: DoAlwaysTask | null) => {
+			// Finish the selector with a result. Reference-based (task object /
+			// chain names), so it stays correct while a text filter is active
+			// (itemRows is then a subset of visibleTasks and positional indices
+			// would point at the wrong task).
+			function finishSingle(task: DoAlwaysTask) {
 				if (settled) return;
 				settled = true;
 				clearPreviewTimer();
-				done(task ? tasks.indexOf(task) : null);
-			};
+				done({ kind: "single", task });
+			}
+			function finishChain(names: string[]) {
+				if (settled) return;
+				settled = true;
+				clearPreviewTimer();
+				done({ kind: "chain", names });
+			}
+			function finishCancel() {
+				if (settled) return;
+				settled = true;
+				clearPreviewTimer();
+				done({ kind: "cancel" });
+			}
 
 			// The prompt preview appears only after the selection has been stable
 			// for PREVIEW_DELAY_MS; any change hides it and restarts the delay.
@@ -307,7 +1169,9 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 			const kb = getKeybindings();
 			const maxVisible = 12;
 			let filter = "";
-			let selectedIndex = 0;
+			let chain = chainClear();
+			let cursor: Cursor = { kind: "cell", row: 0, col: "task" };
+			let lastCellRow = 0;
 			let mousePressedIndex: number | null = null;
 
 			// Arm the preview timer for the initial selection.
@@ -323,92 +1187,203 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 				);
 			};
 
-			// Recompute the visible (filtered, grouped) rows on every render so
-			// filter typing updates the list live.
+			// Recompute the visible (filtered) table rows on every render so
+			// filter typing and chain edits update the table live.
 			function getVisible() {
-				const visibleGroups = groups
-					.map((g) => ({ name: g.name, items: g.items.filter(matchesFilter) }))
-					.filter((g) => g.items.length > 0);
-				const rows: Array<
-					| { kind: "header"; name: string }
-					| { kind: "item"; task: DoAlwaysTask; group: string }
-				> = [];
-				for (const g of visibleGroups) {
-					rows.push({ kind: "header", name: g.name });
-					for (const t of g.items) rows.push({ kind: "item", task: t, group: g.name });
+				const filteredGroups = groups.map((g) => ({ name: g.name, items: g.items.filter(matchesFilter) }));
+				const tableRows = buildTableRows(filteredGroups, chain);
+				const bodyRows: TableRow[] = [];
+				const itemRows: { task: DoAlwaysTask; globalIndex: number; order?: number }[] = [];
+				// O(n) index map so indexOf → O(1) lookup.
+				const taskToGlobalIndex = new Map(visibleTasks.map((t, i) => [t, i]));
+				for (const r of tableRows) {
+					if (r.kind === "run") continue; // pinned row, rendered separately
+					bodyRows.push(r);
+					if (r.kind === "task" && r.task) {
+						itemRows.push({ task: r.task, globalIndex: taskToGlobalIndex.get(r.task) ?? -1, order: r.order });
+					}
 				}
-				const itemRows = rows.filter((r): r is (typeof rows)[number] & { kind: "item" } => r.kind === "item");
-				// Clamp selection to the visible item count.
-				selectedIndex = Math.max(0, Math.min(selectedIndex, Math.max(0, itemRows.length - 1)));
-				// Visible item window with scrolling.
-				const winStart = Math.max(0, Math.min(selectedIndex - Math.floor(maxVisible / 2), Math.max(0, itemRows.length - maxVisible)));
-				const visibleItemKeys = new Set(itemRows.slice(winStart, winStart + maxVisible).map((r) => r.task));
-				const visibleHeaderNames = new Set([...visibleItemKeys].map((t) => findGroupOf(t, visibleGroups)?.name ?? ""));
-				return { rows, itemRows, visibleItemKeys, visibleHeaderNames };
+				// Scroll window over the filtered items.
+				const anchor = cursor.kind === "cell" ? cursor.row : lastCellRow;
+				const winStart =
+					itemRows.length > maxVisible
+						? Math.max(0, Math.min(anchor + 1 - maxVisible, itemRows.length - maxVisible))
+						: 0;
+				// Headers whose group has at least one item in the window.
+				const inWindow = new Set(itemRows.slice(winStart, winStart + maxVisible).map((r) => r.task));
+				const visibleHeaderNames = new Set(
+					filteredGroups.filter((g) => g.items.some((t) => inWindow.has(t))).map((g) => g.name),
+				);
+				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>;
 
-			const labelCol = 26;
-
-			function renderLabel(task: DoAlwaysTask, globalIndex: number, isSelected: boolean, width: number): string {
-				const prefix = isSelected ? "▸ " : "  ";
-				const marker = shouldAutoRun(task) ? "⚡ " : "";
-				const label = `${prefix}${globalIndex + 1}. ${marker}${task.name}`;
-				if (!task.description) {
-					const line = truncateToWidth(label, Math.max(1, width - 2), "");
-					return isSelected ? theme.fg("accent", theme.bold(line)) : line;
-				}
-				// Width-aware two-column layout; fall back to label-only when the
-				// terminal is too narrow to fit a description column.
-				const effCol = Math.max(1, Math.min(labelCol, width - 8));
-				const nameOnly = truncateToWidth(label, effCol, "");
-				const pad = " ".repeat(Math.max(1, effCol - visibleWidth(nameOnly)));
-				const remaining = width - visibleWidth(nameOnly) - pad.length - 2;
-				if (remaining < 10) {
-					const line = truncateToWidth(label, Math.max(1, width - 2), "");
-					return isSelected ? theme.fg("accent", theme.bold(line)) : line;
+			// 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(visible: Visible) {
+				const { itemRows } = visible;
+				if (itemRows.length === 0) {
+					cursor = { kind: "cell", row: 0, col: "task" };
+					return;
 				}
-				const desc = truncateToWidth(task.description, remaining, "");
-				if (isSelected) {
-					return theme.fg("accent", theme.bold(`${nameOnly}${pad}${desc}`));
+				if (cursor.kind === "cell" && cursor.row >= itemRows.length) {
+					cursor = { kind: "cell", row: itemRows.length - 1, col: "task" };
 				}
-				return `${nameOnly}${pad}${theme.fg("muted", desc)}`;
 			}
 
-			// Build the full selector output for a width, plus a map from line
-			// index to task for the item rows (used by mouse handling).
-			function buildRender(width: number) {
-				const { rows, itemRows, visibleItemKeys, visibleHeaderNames } = getVisible();
+			// --- Table geometry ---------------------------------------------------
+			// Three tiers by width:
+			//   >= 76:   # TASK DESCRIPTION ORDER
+			//   58-75:   # TASK ORDER
+			//   < 58:    # TASK   (chain shown on its own line below the list)
+			const ORDER_COL_W = 5;
+			const TASK_COL_W = 24;
+			type Tier = "full" | "compact" | "narrow";
+			function tierFor(width: number): Tier {
+				if (width >= 76) return "full";
+				if (width >= 58) return "compact";
+				return "narrow";
+			}
+			// Column geometry: [2] # [3]  [taskCol]  [descCol]  [ORDER_COL_W] [1]
+			function tableGeometry(width: number) {
+				const tier = tierFor(width);
+				const taskCol = tier === "full" ? TASK_COL_W : Math.max(10, width - 2 - 3 - 2 - 2 - ORDER_COL_W - 1);
+				const descCol = tier === "full" ? Math.max(8, width - 2 - 3 - 2 - TASK_COL_W - 2 - 2 - ORDER_COL_W - 1) : 0;
+				// The ORDER cell is the last ORDER_COL_W characters of the line
+				// (the line is width-2 chars wide), so it starts at width-2-W.
+				const orderColX = tier === "narrow" ? null : width - 2 - ORDER_COL_W;
+				return { tier, taskCol, descCol, orderColX };
+			}
+
+			// Cached last buildTable result (avoids double-work on mouse hit-test).
+			// 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, 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>();
-				lines.push(theme.fg("accent", theme.bold("  do-always — pick a task")));
-				lines.push("");
+				let runLine = -1;
+				// Cursor marker: a large triangle in the accent color. The row
+				// background alone can be invisible (some themes map selectedBg
+				// to the terminal's default background), so the marker carries
+				// the cursor.
+				const cursorMark = theme.fg("accent", "►");
+
+				// Header.
+				lines.push(
+					theme.fg(
+						"muted",
+						truncateToWidth(
+							// The 6-char prefix ("   #  ") lines the header up with
+							// the body rows (2-digit number + 2 spaces).
+							tier === "full"
+								? `   #  ${"TASK".padEnd(taskCol)}  ${"DESCRIPTION".padEnd(descCol)}  ${"ORDER".padEnd(ORDER_COL_W)}`
+								: tier === "compact"
+									? `   #  ${"TASK".padEnd(taskCol)}  ${"ORDER".padEnd(ORDER_COL_W)}`
+									: "   #  TASK",
+							width - 2,
+							"",
+						),
+					),
+				);
+
 				if (itemRows.length === 0) {
 					lines.push(theme.fg("warning", "  No matching tasks"));
 				} else {
-					for (const row of rows) {
+					let itemShown = 0;
+					// O(n) index map so findIndex → O(1) lookup.
+					const idxMap = new Map(itemRows.map((x, i) => [x.task, i]));
+					for (const row of bodyRows) {
 						if (row.kind === "header") {
-							if (!visibleHeaderNames.has(row.name)) continue;
-							lines.push(theme.fg("accent", theme.bold(`  ${row.name.toUpperCase()}`)));
+							if (!visibleHeaderNames.has(row.name ?? "")) continue;
+							if (itemShown >= maxVisible) break;
+							lines.push(
+								theme.fg("accent", theme.bold(truncateToWidth(`  ${(row.name ?? "").toUpperCase()}`, width - 2, ""))),
+							);
 							continue;
 						}
-						if (!visibleItemKeys.has(row.task)) continue;
-						const globalIndex = visibleTasks.indexOf(row.task);
-						const isSelected = row.task === itemRows[selectedIndex].task;
-						lines.push(renderLabel(row.task, globalIndex, isSelected, width));
-						itemLine.set(lines.length - 1, row.task);
+						if (!row.task) continue;
+						const idx = idxMap.get(row.task);
+						if (idx === undefined || idx < winStart || idx >= winStart + maxVisible) continue;
+						itemShown++;
+						const task = row.task;
+						const auto = shouldAutoRun(task);
+						const focused = cursor.kind === "cell" && cursor.row === idx;
+						// Cursor markers: ► in the left gutter = TASK column, ► in the
+						// ORDER cell = ORDER column. The row background is applied too,
+						// but some themes map selectedBg to a color that is nearly
+						// indistinguishable from the terminal background, so the
+						// character marker is the reliable indicator.
+						const inTaskCol =
+							cursor.kind === "cell" && cursor.row === idx && cursor.col === "task";
+						const inOrderCol =
+							cursor.kind === "cell" && cursor.row === idx && cursor.col === "order";
+						const num = inTaskCol
+							? `${cursorMark} ${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).
+						const name = truncateToWidth(task.name, taskCol - (auto ? 3 : 0), "…", true);
+						const taskCell = (auto ? "⚡ " : "") + name;
+						// Every ORDER cell is exactly ORDER_COL_W wide so the column
+						// stays aligned (and mouse hit-testing stays exact).
+						const orderCell =
+							row.order !== undefined
+								? inOrderCol
+									? truncateToWidth(`${cursorMark}[${row.order}]`, ORDER_COL_W, "", true)
+									: ` [${row.order}] `
+								: inOrderCol
+									? `${cursorMark}  · `
+									: "  ·  ";
+						let line: string;
+						if (tier === "full") {
+							const desc = truncateToWidth(task.description ?? "", descCol, "…", true);
+							line = `${num}  ${taskCell}  ${desc}  ${orderCell}`;
+						} else if (tier === "compact") {
+							line = `${num}  ${taskCell}  ${orderCell}`;
+						} else {
+							line = truncateToWidth(`${num}  ${taskCell}`, width - 2, "…");
+						}
+						// Full-row background + bold where the theme makes it visible;
+						// the ► gutter/cell marker carries the cursor either way.
+						if (focused) line = theme.bg("selectedBg", theme.bold(line));
+						lines.push(line);
+						itemLine.set(lines.length - 1, task);
 					}
 					if (itemRows.length > maxVisible) {
-						const hint = `  (${selectedIndex + 1}/${itemRows.length})`;
-						lines.push(theme.fg("dim", truncateToWidth(hint, width - 2, "")));
+						const anchor = cursor.kind === "cell" ? cursor.row : lastCellRow;
+						lines.push(theme.fg("dim", truncateToWidth(`  (${anchor + 1}/${itemRows.length})`, width - 2, "")));
+					}
+					// Narrow tier: the chain gets its own line instead of a column.
+					if (tier === "narrow" && chain.items.length > 0) {
+						lines.push(
+							theme.fg("dim", truncateToWidth(`  chain: ${formatChainSequence(visibleTasks, chain)}`, width - 2, "…")),
+						);
 					}
 				}
-				// Prompt preview: revealed after the selection has been stable for
-				// PREVIEW_DELAY_MS, showing exactly what will be injected.
-				if (previewVisible) {
-					const sel = itemRows[selectedIndex];
+
+				// Prompt preview: revealed after the cursor has been stable on a
+				// task row for PREVIEW_DELAY_MS, showing exactly what will be
+				// injected.
+				if (previewVisible && cursor.kind === "cell" && cursor.col === "task") {
+					const sel = itemRows[cursor.row];
 					if (sel) {
 						const wrapWidth = Math.max(10, width - 4);
-						// Show the rendered prompt — exactly what will be injected.
 						const wrapped = wrapTextWithAnsi(renderPrompt(sel.task.prompt, strings), wrapWidth);
 						const shown = wrapped.slice(0, PREVIEW_MAX_LINES);
 						const truncated = wrapped.length > PREVIEW_MAX_LINES;
@@ -421,60 +1396,244 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 						});
 					}
 				}
+
+				// Pinned Run row (always visible, outside the scroll window).
 				lines.push("");
-				const anyAutoRun = itemRows.some((r) => shouldAutoRun(r.task));
-				const footer = anyAutoRun
-					? "  1-9 pick by number  •  type to filter  •  ↑↓ navigate  •  enter select  •  esc cancel  •  ⚡ auto-runs"
-					: "  1-9 pick by number  •  type to filter  •  ↑↓ navigate  •  enter select  •  esc cancel";
+				lines.push(theme.fg("dim", "  " + "─".repeat(Math.max(1, width - 4))));
+				const runLabel = chainRunLabel(chain.items.length);
+				runLine = lines.length;
+				// No play glyph in the label: the ► cursor marker is the only
+				// ">" and it appears only while the row is selected (like task rows).
+				if (cursor.kind === "run") {
+					lines.push(theme.bg("selectedBg", theme.bold(`${cursorMark} ${runLabel}`)));
+				} else if (chain.items.length === 0) {
+					lines.push(theme.fg("dim", `  ${runLabel}`));
+				} else {
+					lines.push(theme.fg("accent", `  ${runLabel}`));
+				}
+
+				// Context-sensitive footer.
+				let footer: string;
+				if (cursor.kind === "run") {
+					footer =
+						chain.items.length > 0
+							? `  ⏎ run: ${formatChainSequence(visibleTasks, chain)}`
+							: "  ⏎ run the chain (chain is empty)";
+				} else if (cursor.col === "order") {
+					const inChain = chain.items.includes(itemRows[cursor.row]?.task.name ?? "");
+					footer = inChain ? "  ← tasks  •  ⏎ remove  •  esc" : "  ← tasks  •  ⏎ add  •  esc";
+				} else {
+					footer = "  1-9 run now  •  ⏎ select  •  → order  •  ⌫ undo  •  esc";
+				}
+				if (chain.items.length > 0 && cursor.kind !== "run") footer += "  •  ctrl+u clear";
 				lines.push(theme.fg("dim", truncateToWidth(footer, width - 2, "")));
-				return { lines, itemLine, itemRows };
+
+				return { lines, itemLine, runLine, orderColX };
 			}
 
 			return {
 				render(width: number) {
-					return buildRender(width).lines;
+					lastTable = buildTable(width, getVisible());
+					return lastTable.lines;
+				},
+				invalidate() {
+					clearPreviewTimer();
 				},
-				invalidate() {},
 				handleInput(data: string) {
-					// Direct pick by number (1-9) — only when not filtering, and within
-					// the visible set, so digits pick a visible task by its number.
+					// Direct pick by number (1-9) — runs the task immediately (the
+					// classic fast path), closing the selector and discarding the
+					// chain. Only when not filtering, and within the visible set,
+					// so digits pick a visible task by its number.
 					if (!filter && /^[1-9]$/.test(data) && Number(data) <= visibleTasks.length) {
-						finish(visibleTasks[Number(data) - 1]);
+						finishSingle(visibleTasks[Number(data) - 1]);
 						return;
 					}
-					// Filter typing.
+					// Filter typing (Backspace edits the filter; with an empty
+					// 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")) {
-						filter = filter.slice(0, -1);
-						selectedIndex = 0;
+						if (filter.length > 0) {
+							filter = filter.slice(0, -1);
+							clampCursor(getVisible());
+						} else {
+							const { state, removed } = chainUndo(chain);
+							if (removed) {
+								chain = state;
+								clampCursor(getVisible());
+							}
+						}
 						resetPreview();
 						tui.requestRender();
 						return;
 					}
 					if (isPrintable(data)) {
 						filter += data;
-						selectedIndex = 0;
+						clampCursor(getVisible());
 						resetPreview();
 						tui.requestRender();
 						return;
 					}
-					// Navigation / confirmation.
-					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();
+						return;
+					}
+					// Column switching.
+					if (matchesKey(data, "left")) {
+						if (cursor.kind === "run") {
+							cursor = { kind: "cell", row: itemRows.length - 1, col: "task" };
+						} else if (cursor.col === "order") {
+							cursor = { kind: "cell", row: cursor.row, col: "task" };
+						}
+						lastCellRow = cursor.kind === "cell" ? cursor.row : lastCellRow;
+						resetPreview();
+						tui.requestRender();
+						return;
+					}
+					if (matchesKey(data, "right")) {
+						if (cursor.kind === "cell" && cursor.col === "task") {
+							// Same row: the ORDER cell shows whether this task is
+							// in the chain, and Enter toggles it.
+							cursor = { kind: "cell", row: cursor.row, col: "order" };
+						}
+						// (→ in the ORDER column and on the Run row is a no-op:
+						// the cursor is already at the right/bottom edge.)
+						lastCellRow = cursor.kind === "cell" ? cursor.row : lastCellRow;
+						resetPreview();
+						tui.requestRender();
+						return;
+					}
+					// Row navigation: the cursor moves in both columns (wrap at
+					// the edges); the Run row is reached from the last task row.
 					if (kb.matches(data, "tui.select.up")) {
-						selectedIndex = selectedIndex === 0 ? itemRows.length - 1 : selectedIndex - 1;
+						if (cursor.kind === "run") {
+							cursor = { kind: "cell", row: itemRows.length - 1, col: "task" };
+						} else {
+							cursor = {
+								kind: "cell",
+								row: cursor.row === 0 ? itemRows.length - 1 : cursor.row - 1,
+								col: cursor.col,
+							};
+						}
+						lastCellRow = cursor.kind === "cell" ? cursor.row : lastCellRow;
 						resetPreview();
 						tui.requestRender();
+						return;
 					}
-					else if (kb.matches(data, "tui.select.down")) {
-						selectedIndex = selectedIndex === itemRows.length - 1 ? 0 : selectedIndex + 1;
+					if (kb.matches(data, "tui.select.down")) {
+						if (cursor.kind === "run") {
+							cursor = { kind: "cell", row: 0, col: "task" };
+						} else if (cursor.row === itemRows.length - 1) {
+							// The pinned Run row sits below the last task row.
+							cursor = { kind: "run" };
+							lastCellRow = itemRows.length - 1;
+						} else {
+							cursor = {
+								kind: "cell",
+								row: cursor.row + 1,
+								col: cursor.col,
+							};
+						}
+						lastCellRow = cursor.kind === "cell" ? cursor.row : lastCellRow;
 						resetPreview();
 						tui.requestRender();
+						return;
 					}
-					else if (kb.matches(data, "tui.select.confirm")) {
-						const chosen = itemRows[selectedIndex];
-						if (chosen) finish(chosen.task);
+					// 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;
 					}
-					else if (kb.matches(data, "tui.select.cancel")) {
-						finish(null);
+					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") {
+							if (chain.items.length === 0) {
+								ctx.ui.notify("do-always: chain is empty — add a task first", "info");
+							} else {
+								finishChain([...chain.items]);
+							}
+							return;
+						}
+						const row = itemRows[cursor.row];
+						if (!row) return;
+						if (cursor.col === "task") {
+							// The classic pick: run just this task (fill or
+							// auto-run per its autoRun), discarding the chain.
+							finishSingle(row.task);
+							return;
+						}
+						// ORDER column: toggle this task's chain membership.
+						if (chain.items.includes(row.task.name)) {
+							chain = chainRemove(chain, row.task.name);
+						} else {
+							const { state, result } = chainAdd(chain, row.task.name);
+							chain = state;
+							if (result === "full") {
+								ctx.ui.notify(`do-always: chain is full (${CHAIN_MAX}) — remove a task first`, "error");
+							}
+						}
+						lastCellRow = cursor.kind === "cell" ? cursor.row : lastCellRow;
+						resetPreview();
+						tui.requestRender();
+						return;
+					}
+					// Clear the chain.
+					if (matchesKey(data, "ctrl+u")) {
+						if (chain.items.length > 0) {
+							chain = chainClear();
+							clampCursor(visible);
+							resetPreview();
+							tui.requestRender();
+						}
+						return;
+					}
+					if (kb.matches(data, "tui.select.cancel")) {
+						finishCancel();
 					}
 				},
 				handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
@@ -482,21 +1641,51 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 						const { itemRows } = getVisible();
 						if (itemRows.length === 0) return undefined;
 						const delta = event.wheelDelta < 0 ? -1 : 1;
-						const prev = selectedIndex;
-						selectedIndex = Math.max(0, Math.min(itemRows.length - 1, selectedIndex + delta));
-						if (selectedIndex !== prev) resetPreview();
-						return { handled: true, render: selectedIndex !== prev };
+						const prev = cursor.kind === "cell" ? cursor.row : lastCellRow;
+						const next = Math.max(0, Math.min(itemRows.length - 1, prev + delta));
+						if (next === prev) return { handled: true };
+						cursor = { kind: "cell", row: next, col: "task" };
+						lastCellRow = next;
+						resetPreview();
+						return { handled: true, render: true };
 					}
 					if (event.button !== "left" || (event.type !== "press" && event.type !== "click")) return undefined;
-					const { itemLine, itemRows } = buildRender(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) {
+							finishChain([...chain.items]);
+						}
+						return { handled: true };
+					}
 					const task = itemLine.get(event.y);
 					if (!task) return undefined;
+					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(visible);
+							resetPreview();
+							return { handled: true, render: true };
+						}
+						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;
-						if (selectedIndex !== idx) {
-							selectedIndex = idx;
+						if (cursor.kind !== "cell" || cursor.row !== idx) {
+							cursor = { kind: "cell", row: idx, col: "task" };
+							lastCellRow = idx;
 							resetPreview();
 						}
 						return { handled: true, focus: true, render: true };
@@ -504,14 +1693,18 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 					const clicked = mousePressedIndex ?? idx;
 					mousePressedIndex = null;
 					const chosen = itemRows[clicked];
-					if (chosen) finish(chosen.task);
+					if (chosen) finishSingle(chosen.task);
 					return { handled: true };
 				},
 			};
 		});
 
-		if (selected === null || selected === undefined) return;
-		await fillPrompt(tasks[selected], ctx, context);
+		if (!result || result.kind === "cancel") return;
+		if (result.kind === "single") {
+			await fillPrompt(result.task, ctx, context);
+		} else {
+			await runChain(result.names, ctx, cache);
+		}
 	}
 
 	pi.registerCommand("do-always", {
@@ -536,6 +1729,7 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 	});
 
 	async function runDoAlways(args: string, ctx: ExtensionContext): Promise<void> {
+		lastCtx = ctx;
 		// Reload when the active directory changes, so switching projects
 		// mid-session serves the right config instead of stale tasks.
 		if (ctx.cwd !== loadedCwd) {
@@ -544,19 +1738,22 @@ export default function doAlwaysExtension(pi: ExtensionAPI) {
 				if (ctx.mode === "tui") ctx.ui.notify(m, "warning");
 				else console.warn(m);
 			};
-			tasks = loadConfig(ctx.cwd, onError).tasks;
+			const config = loadConfig(ctx.cwd, onError);
+			tasks = config.tasks;
+			reportEnabled = config.report;
 		}
 
 		// One context per command run: shared by visibility filtering, rendering,
 		// and the completion cache (never inside a render loop).
-		const context = buildContext(ctx.cwd);
+		const cache = createContextCache();
+		const context = await cache.get(ctx.cwd);
 		const visible = refreshVisible(ctx.cwd, context);
 
 		const arg = args.trim();
 
 		if (!arg) {
 			if (ctx.mode === "tui") {
-				await showSelector(ctx, context);
+				await showSelector(ctx, context, cache);
 			} else {
 				ctx.ui.notify(`do-always tasks (use /do-always <number|name>):\n${formatList(visible)}`, "info");
 			}