@shanepadgett/tau-agent 0.28.1 → 0.30.0

package/extensions/review/panel.ts

@@ -0,0 +1,128 @@
+import { bindingHint, bindingsHint, rawHint, ToolPanel } from "@shanepadgett/tau-tui";
+import { getMarkdownTheme, type Theme } from "@earendil-works/pi-coding-agent";
+import { Markdown, type Component, type KeybindingsManager, truncateToWidth, type TUI } from "@earendil-works/pi-tui";
+import { formatReviewMarkdown, reviewModeLabel, type ReviewMode, type ReviewRecord } from "./model.ts";
+
+export class ReviewProgressPanel implements Component {
+	private readonly tui: TUI;
+	private readonly panel: ToolPanel;
+	private readonly lines: string[] = [];
+
+	constructor(tui: TUI, theme: Theme, mode: ReviewMode, keys: KeybindingsManager, cancel: () => void) {
+		this.tui = tui;
+		this.panel = new ToolPanel(theme, {
+			title: `${reviewModeLabel(mode)} review`,
+			secondary: "Fresh isolated review · hidden from parent context",
+			body: {
+				render: (width) =>
+					(this.lines.length ? this.lines.slice(-5) : ["Starting review"]).map((line) =>
+						truncateToWidth(theme.fg("muted", line), width, "…"),
+					),
+				invalidate() {},
+			},
+			footer: { kind: "hints", hints: [bindingHint("tui.select.cancel", "cancel")] },
+			border: "box",
+		});
+		this.handleInput = (data) => {
+			if (!keys.matches(data, "tui.select.cancel")) return;
+			cancel();
+			this.update("Cancelling review");
+		};
+	}
+
+	handleInput: (data: string) => void;
+
+	update(status: string): void {
+		if (this.lines.at(-1) !== status) {
+			this.lines.push(status);
+			if (this.lines.length > 5) this.lines.shift();
+		}
+		this.tui.requestRender();
+	}
+
+	render(width: number): string[] {
+		return this.panel.render(width);
+	}
+
+	invalidate(): void {
+		this.panel.invalidate();
+	}
+}
+
+export type ReviewResultAction = "send" | "export" | "close";
+
+export class ReviewResultPanel implements Component {
+	private readonly panel: ToolPanel;
+	private readonly body: ReviewMarkdownBody;
+
+	constructor(
+		tui: TUI,
+		theme: Theme,
+		keys: KeybindingsManager,
+		review: ReviewRecord,
+		done: (action: ReviewResultAction) => void,
+	) {
+		this.body = new ReviewMarkdownBody(tui, formatReviewMarkdown(review));
+		this.panel = new ToolPanel(theme, {
+			title: `${reviewModeLabel(review.mode)} review · ${review.verdict}`,
+			secondary: `${review.findings.length} finding${review.findings.length === 1 ? "" : "s"} · not in parent context`,
+			body: this.body,
+			footer: {
+				kind: "hints",
+				hints: [
+					bindingsHint(["tui.select.up", "tui.select.down"], "scroll"),
+					rawHint("a", "send to agent"),
+					rawHint("e", "export"),
+					bindingHint("tui.select.cancel", "close"),
+				],
+			},
+			border: "box",
+		});
+		this.handleInput = (data) => {
+			if (keys.matches(data, "tui.select.up")) this.body.scroll(-1);
+			else if (keys.matches(data, "tui.select.down")) this.body.scroll(1);
+			else if (data === "a") done("send");
+			else if (data === "e") done("export");
+			else if (keys.matches(data, "tui.select.cancel")) done("close");
+		};
+	}
+
+	handleInput: (data: string) => void;
+
+	render(width: number): string[] {
+		return this.panel.render(width);
+	}
+
+	invalidate(): void {
+		this.panel.invalidate();
+	}
+}
+
+class ReviewMarkdownBody implements Component {
+	private readonly tui: TUI;
+	private readonly markdown: Markdown;
+	private offset = 0;
+	private maxOffset = 0;
+
+	constructor(tui: TUI, content: string) {
+		this.tui = tui;
+		this.markdown = new Markdown(content, 0, 0, getMarkdownTheme());
+	}
+
+	scroll(delta: number): void {
+		this.offset = Math.max(0, Math.min(this.maxOffset, this.offset + delta));
+		this.tui.requestRender();
+	}
+
+	render(width: number): string[] {
+		const lines = this.markdown.render(width);
+		const height = Math.max(4, Math.floor(this.tui.terminal.rows * 0.9) - 9);
+		this.maxOffset = Math.max(0, lines.length - height);
+		this.offset = Math.min(this.offset, this.maxOffset);
+		return lines.slice(this.offset, this.offset + height);
+	}
+
+	invalidate(): void {
+		this.markdown.invalidate();
+	}
+}

package/extensions/review/session.ts

@@ -0,0 +1,106 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineTool, type AgentSessionEvent, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	createIsolatedSessionResource,
+	resolveIsolatedSessionModel,
+	type IsolatedSessionResource,
+} from "../../shared/isolated-session.ts";
+import { buildReviewPrompt, REVIEW_RESULT_TOOL, type ReviewMode, type ReviewOutput } from "./model.ts";
+
+const REVIEW_MODEL = "openai-codex/gpt-5.6-sol";
+const REVIEW_TOOLS = [
+	"read",
+	"bash",
+	"outline",
+	"show",
+	"discover",
+	"ast_search",
+	"deps",
+	"reverse_deps",
+	"callers",
+	"callees",
+	"references",
+	"implementations",
+	"impact",
+	"context",
+	REVIEW_RESULT_TOOL.name,
+];
+const EXPLORE_EXTENSION = join(dirname(fileURLToPath(import.meta.url)), "..", "explore", "index.ts");
+
+export async function runReview(options: {
+	ctx: ExtensionContext;
+	root: string;
+	mode: ReviewMode;
+	parentThinkingLevel: NonNullable<ExtensionContext["thinkingLevel"]>;
+	signal: AbortSignal;
+	onProgress: (status: string) => void;
+}): Promise<ReviewOutput> {
+	const { ctx, root, mode, signal, onProgress } = options;
+	let output: ReviewOutput | undefined;
+	const outputTool = defineTool({
+		...REVIEW_RESULT_TOOL,
+		label: "Review Result",
+		async execute(_toolCallId, params) {
+			output = params;
+			return {
+				content: [{ type: "text" as const, text: "Review recorded" }],
+				details: params,
+				terminate: true,
+			};
+		},
+	});
+	let resource: IsolatedSessionResource | undefined;
+	let unsubscribe: (() => void) | undefined;
+	try {
+		const selected = await resolveIsolatedSessionModel({
+			label: "Review",
+			preferredModel: REVIEW_MODEL,
+			preferredThinkingLevel: "high",
+			usePreferredThinkingAfterModelFallback: false,
+			ctx,
+			parentThinkingLevel: options.parentThinkingLevel,
+			signal,
+			onWarning: onProgress,
+		});
+		resource = await createIsolatedSessionResource(
+			{
+				...selected,
+				label: "Review",
+				extensionPaths: [EXPLORE_EXTENSION],
+				cwd: root,
+				tools: REVIEW_TOOLS,
+				customTools: [outputTool],
+				bindTarget: { mode: "print" },
+			},
+			signal,
+		);
+		const { session } = resource;
+		unsubscribe = session.subscribe((event: AgentSessionEvent) => {
+			if (event.type === "tool_execution_start") {
+				onProgress(`${event.toolName} ${summarizeArgs(event.args)}`.trim());
+			} else if (event.type === "tool_execution_end") {
+				onProgress(event.isError ? `${event.toolName} failed` : `${event.toolName} complete`);
+			}
+		});
+		const abort = () => void session.abort().catch(() => undefined);
+		signal.addEventListener("abort", abort, { once: true });
+		try {
+			onProgress(`Running ${mode} review`);
+			await session.prompt(buildReviewPrompt(root, mode), { expandPromptTemplates: false });
+		} finally {
+			signal.removeEventListener("abort", abort);
+		}
+		if (signal.aborted) throw new Error("Review cancelled");
+		if (!output) throw new Error("Review ended without structured output");
+		return output;
+	} finally {
+		unsubscribe?.();
+		await resource?.dispose();
+	}
+}
+
+function summarizeArgs(args: unknown): string {
+	const text = typeof args === "string" ? args : (JSON.stringify(args) ?? String(args));
+	return text.length > 140 ? `${text.slice(0, 139)}…` : text;
+}

package/extensions/runtime-context/README.md

@@ -1,5 +1,5 @@
 # Runtime Context
 
-Supplies Tau with the current local date and an initial root directory snapshot as hidden session context. The snapshot remains fixed until the extension runtime restarts, while the date updates when the local day changes.
+Supplies Tau with current local date and initial root directory snapshot in each agent run's system prompt. Snapshot remains fixed until extension runtime restarts, while date updates when local day changes.
 
 After changing this extension, run `/reload` before testing the new behavior.

package/extensions/runtime-context/index.ts

@@ -1,22 +1,11 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
-	fingerprintRuntimeSnapshot,
-	formatLocalDateKey,
 	formatLocalDisplayDate,
 	formatRuntimeContextMessage,
 	freezeRuntimeContext,
 	type RuntimeContext,
 } from "./context.ts";
 
-const RUNTIME_CONTEXT_TYPE = "tau.runtime-context";
-
-interface RuntimeContextMessageDetails {
-	version: 1;
-	dateKey: string;
-	snapshotHash: string;
-	includesSnapshot: boolean;
-}
-
 export default function runtimeContextExtension(pi: ExtensionAPI): void {
 	let runtimeContext: RuntimeContext | undefined;
 
@@ -24,61 +13,9 @@ export default function runtimeContextExtension(pi: ExtensionAPI): void {
 		runtimeContext = freezeRuntimeContext(ctx.cwd);
 	});
 
-	pi.on("before_agent_start", (_event, ctx) => {
+	pi.on("before_agent_start", (event, ctx) => {
 		runtimeContext ??= freezeRuntimeContext(ctx.cwd);
-		const now = new Date();
-		const dateKey = formatLocalDateKey(now);
-		const snapshotHash = fingerprintRuntimeSnapshot(runtimeContext);
-		let hasDate = false;
-		let hasSnapshot = false;
-		for (const entry of ctx.sessionManager.buildContextEntries()) {
-			const details = runtimeContextDetails(entry);
-			if (!details) continue;
-			if (details.dateKey === dateKey) hasDate = true;
-			if (details.includesSnapshot && details.snapshotHash === snapshotHash) hasSnapshot = true;
-		}
-
-		if (hasDate && hasSnapshot) return undefined;
-		const includeSnapshot = !hasSnapshot;
-		return {
-			message: {
-				customType: RUNTIME_CONTEXT_TYPE,
-				content: formatRuntimeContextMessage(
-					formatLocalDisplayDate(now),
-					includeSnapshot ? runtimeContext.rootSnapshot : undefined,
-				),
-				display: false,
-				details: {
-					version: 1,
-					dateKey,
-					snapshotHash,
-					includesSnapshot: includeSnapshot,
-				} satisfies RuntimeContextMessageDetails,
-			},
-		};
+		const content = formatRuntimeContextMessage(formatLocalDisplayDate(new Date()), runtimeContext.rootSnapshot);
+		return { systemPrompt: `${event.systemPrompt}\n\n${content}` };
 	});
 }
-
-function runtimeContextDetails(value: unknown): RuntimeContextMessageDetails | undefined {
-	if (!value || typeof value !== "object") return undefined;
-	const entry = value as Record<string, unknown>;
-	if (entry.type !== "custom_message" || entry.customType !== RUNTIME_CONTEXT_TYPE || entry.display !== false) {
-		return undefined;
-	}
-	if (!entry.details || typeof entry.details !== "object") return undefined;
-	const details = entry.details as Record<string, unknown>;
-	if (
-		details.version !== 1 ||
-		typeof details.dateKey !== "string" ||
-		typeof details.snapshotHash !== "string" ||
-		typeof details.includesSnapshot !== "boolean"
-	) {
-		return undefined;
-	}
-	return {
-		version: 1,
-		dateKey: details.dateKey,
-		snapshotHash: details.snapshotHash,
-		includesSnapshot: details.includesSnapshot,
-	};
-}

package/extensions/script-runner/README.md

@@ -0,0 +1,7 @@
+# Script Runner
+
+Gives the agent a first-class `script_runner` tool for running Python and TypeScript instead of falling back to bash. The agent picks whichever language is more efficient for the task.
+
+When a run fails, the tool keeps the script and returns a `scriptId`. The agent retries with targeted `{oldText, newText}` edits against what it just wrote instead of resending the whole script, saving output tokens and keeping duplicate scripts out of context. Only the source the agent already sent is referenced; no file path is exposed.
+
+Languages are detected from the environment: Python via `python3`/`python`, TypeScript via Node with `--experimental-strip-types` (Node 22.6 or newer). The tool registers only the languages actually available and is hidden from the prompt entirely when neither is present.

package/extensions/script-runner/index.ts

@@ -0,0 +1,275 @@
+import { execFileSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { StringEnum } from "@earendil-works/pi-ai";
+import {
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	defineTool,
+	type ExecResult,
+	type ExtensionAPI,
+	type Theme,
+	truncateTail,
+} from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+
+type Language = "python" | "typescript";
+
+interface Runtimes {
+	python: string | undefined;
+	typescript: string | undefined;
+}
+
+interface StoredScript {
+	language: Language;
+	source: string;
+}
+
+const TIMEOUT_MS = 120_000;
+const MAX_STORED = 8;
+
+function detectRuntimes(): Runtimes {
+	let python: string | undefined;
+	for (const cmd of ["python3", "python"] as const) {
+		try {
+			execFileSync(cmd, ["--version"], { stdio: ["ignore", "pipe", "ignore"] });
+			python = cmd;
+			break;
+		} catch {
+			// runtime not installed
+		}
+	}
+	const [major, minor] = process.versions.node.split(".").map(Number);
+	let typescript: string | undefined;
+	if (major > 22 || (major === 22 && minor >= 6)) {
+		typescript = process.execPath;
+	}
+	return { python, typescript };
+}
+
+function capitalize(lang: Language): string {
+	return lang === "python" ? "Python" : "TypeScript";
+}
+
+function newScriptId(): string {
+	return randomBytes(5).toString("base64url").slice(0, 7);
+}
+
+function scrubPath(text: string, file: string, dir: string): string {
+	if (!text) return text;
+	return text.replaceAll(file, "<script>").replaceAll(dir, "<tmpdir>");
+}
+
+function applyEdits(source: string, edits: ReadonlyArray<{ oldText: string; newText: string }>): string {
+	let next = source;
+	for (const edit of edits) {
+		const idx = next.indexOf(edit.oldText);
+		if (idx === -1) {
+			throw new Error(
+				"An edits oldText was not found in the script. Copy the exact text from the script you wrote.",
+			);
+		}
+		next = next.slice(0, idx) + edit.newText + next.slice(idx + edit.oldText.length);
+	}
+	return next;
+}
+
+function renderEditsPreview(edits: ReadonlyArray<{ oldText: string; newText: string }>, theme: Theme): string {
+	return edits
+		.map((edit) => {
+			const oldLines = edit.oldText
+				.split("\n")
+				.map((line) => theme.fg("error", `- ${line}`))
+				.join("\n");
+			const newLines = edit.newText
+				.split("\n")
+				.map((line) => theme.fg("success", `+ ${line}`))
+				.join("\n");
+			return `${oldLines}\n${newLines}`;
+		})
+		.join("\n");
+}
+
+export default function scriptRunnerExtension(pi: ExtensionAPI): void {
+	const runtimes = detectRuntimes();
+	const detected = (["python", "typescript"] as const).filter(
+		(lang): lang is Language => (lang === "python" ? runtimes.python : runtimes.typescript) !== undefined,
+	);
+	if (detected.length === 0) return;
+
+	const langPhrase = detected.map(capitalize).join(" or ");
+
+	const scripts = new Map<string, StoredScript>();
+	let tempDir: string | undefined;
+
+	function remember(scriptId: string, script: StoredScript): void {
+		scripts.set(scriptId, script);
+		while (scripts.size > MAX_STORED) {
+			const oldest = scripts.keys().next().value;
+			if (oldest === undefined) break;
+			scripts.delete(oldest);
+		}
+	}
+
+	function resolveCommand(language: Language): string {
+		if (language === "python") {
+			const cmd = runtimes.python;
+			if (!cmd) throw new Error("Python is not available on this machine.");
+			return cmd;
+		}
+		const cmd = runtimes.typescript;
+		if (!cmd) throw new Error("TypeScript is not available (requires Node >= 22.6).");
+		return cmd;
+	}
+
+	async function ensureTempDir(): Promise<string> {
+		if (tempDir) return tempDir;
+		tempDir = await mkdtemp(join(tmpdir(), "tau-script-runner-"));
+		return tempDir;
+	}
+
+	async function runScript(
+		language: Language,
+		command: string,
+		source: string,
+		cwd: string,
+		signal: AbortSignal | undefined,
+	): Promise<ExecResult> {
+		const dir = await ensureTempDir();
+		const file = join(dir, language === "python" ? "_run.py" : "_run.ts");
+		await writeFile(file, source, "utf8");
+		const args = language === "python" ? [file] : ["--experimental-strip-types", file];
+		const result = await pi.exec(command, args, { cwd, signal, timeout: TIMEOUT_MS });
+		return {
+			...result,
+			stdout: scrubPath(result.stdout, file, dir),
+			stderr: scrubPath(result.stderr, file, dir),
+		};
+	}
+
+	const paramsSchema = Type.Object(
+		{
+			language: StringEnum(detected, { description: "Execution language available on this machine." }),
+			script: Type.Optional(
+				Type.String({ description: "Full script source for a new run. Omit when retrying with edits." }),
+			),
+			scriptId: Type.Optional(
+				Type.String({ description: "scriptId returned by a failed run. Required when retrying with edits." }),
+			),
+			edits: Type.Optional(
+				Type.Array(
+					Type.Object({
+						oldText: Type.String({ description: "Exact text currently in the script." }),
+						newText: Type.String({ description: "Replacement text." }),
+					}),
+					{
+						description:
+							"Targeted oldText/newText patches applied to the stored script before rerun. Prefer this over resending the whole script.",
+					},
+				),
+			),
+		},
+		{ additionalProperties: false },
+	);
+
+	const tool = defineTool<typeof paramsSchema, undefined>({
+		name: "script_runner",
+		label: "Script Runner",
+		description: `Run a ${langPhrase} script in the project working directory and return its output. On a non-zero exit, returns a scriptId; retry by sending targeted {oldText,newText} edits against the script you already wrote (same language + scriptId) instead of resending the whole script. Available on this machine: ${langPhrase}.`,
+		promptSnippet: `Run ${langPhrase} scripts; fix failures with targeted edits instead of rewriting the whole script.`,
+		promptGuidelines: [
+			`Prefer script_runner over bash for ${langPhrase} when computation, data handling, or bulk file work is cleaner than chaining built-in tools.`,
+			`When script_runner fails, do not resend the full script. Call script_runner again with the same language, the returned scriptId, and an edits array of {oldText,newText} patches against the script you just wrote. Only resend a full script if the approach itself was wrong.`,
+			`script_runner never exposes the script file path, and you already know the script you sent. Never try to read it back.`,
+		],
+		parameters: paramsSchema,
+		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+			const language = params.language;
+			if (signal?.aborted) {
+				return { content: [{ type: "text", text: "Cancelled." }], details: undefined };
+			}
+
+			const command = resolveCommand(language);
+			const edits = params.edits;
+			let scriptId: string | undefined = params.scriptId;
+			let source: string;
+
+			if (edits && edits.length > 0) {
+				if (!scriptId) throw new Error("edits require the scriptId returned by the failed run.");
+				const stored = scripts.get(scriptId);
+				if (!stored) {
+					throw new Error(
+						`No stored script for scriptId ${scriptId}. It may have been evicted; resend the full script.`,
+					);
+				}
+				if (stored.language !== language) {
+					throw new Error(`Language mismatch: scriptId ${scriptId} is ${stored.language}, not ${language}.`);
+				}
+				source = applyEdits(stored.source, edits);
+			} else {
+				if (typeof params.script !== "string" || params.script.length === 0) {
+					throw new Error("Provide a script for a new run, or edits + scriptId to retry.");
+				}
+				source = params.script;
+				if (!scriptId) scriptId = newScriptId();
+			}
+
+			remember(scriptId, { language, source });
+			await onUpdate?.({ content: [{ type: "text", text: `Running ${language}...` }], details: undefined });
+
+			const result = await runScript(language, command, source, ctx.cwd, signal);
+			if (result.code === 0 && !result.killed) {
+				scripts.delete(scriptId);
+				const trunc = truncateTail(result.stdout.trim(), {
+					maxLines: DEFAULT_MAX_LINES,
+					maxBytes: DEFAULT_MAX_BYTES,
+				});
+				const out = trunc.content.trim();
+				const note = trunc.truncated
+					? `\n\n[output truncated: kept tail ${trunc.outputLines} / ${trunc.totalLines} lines]`
+					: "";
+				return {
+					content: [{ type: "text", text: out ? `${out}${note}` : `(no output)${note}` }],
+					details: undefined,
+				};
+			}
+
+			const diag = result.stderr.trim() || result.stdout.trim();
+			const trunc = truncateTail(diag, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
+			const note = trunc.truncated
+				? `\n\n[output truncated: kept tail ${trunc.outputLines} / ${trunc.totalLines} lines]`
+				: "";
+			const detail = trunc.content ? `${trunc.content}${note}\n\n` : "";
+			throw new Error(
+				`${detail}scriptId: ${scriptId}\nRetry with edits: [{oldText,newText}] using the same language and scriptId; do not resend the full script.`,
+			);
+		},
+		renderCall(args, theme, context) {
+			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+			const header = `${theme.fg("toolTitle", theme.bold("script_runner"))} ${theme.fg("muted", args.language)}`;
+			const edits = args.edits;
+			const body =
+				edits && edits.length > 0
+					? renderEditsPreview(edits, theme)
+					: theme.fg("accent", theme.bold(args.script ?? ""));
+			text.setText(body ? `${header}\n${body}` : header);
+			return text;
+		},
+	});
+
+	pi.registerTool(tool);
+
+	pi.on("session_shutdown", () => {
+		scripts.clear();
+		const dir = tempDir;
+		tempDir = undefined;
+		if (dir) {
+			void rm(dir, { recursive: true, force: true }).catch(() => {
+				// best-effort cleanup
+			});
+		}
+	});
+}

package/extensions/stash/browser.ts

@@ -6,13 +6,14 @@ import {
 	type TextRecordSelectPanelConfig,
 	type TextRecordSelectResult,
 } from "@shanepadgett/tau-tui";
+import { errorText } from "../../shared/text.ts";
 import { loadStashes, removeStash, type Stash, stashFilePath } from "./store.ts";
 
-const CONFIG: Omit<TextRecordSelectPanelConfig, "path"> = {
+const CONFIG: Omit<TextRecordSelectPanelConfig<Stash>, "path" | "destructiveAction"> = {
 	title: "Stash",
 	emptyMessage: "No stashed prompts. Use the stash shortcut while typing to stash.",
 	primaryLabel: "pop",
-	actions: [{ id: "discard", key: Key.ctrl("d"), hint: rawHint("ctrl+d", "discard") }],
+	actions: [],
 	expandActiveItem: false,
 };
 
@@ -24,20 +25,9 @@ export async function browseStash(ctx: ExtensionCommandContext): Promise<Stash |
 
 	const path = await stashFilePath(ctx.cwd);
 
-	while (true) {
-		const stashes = await loadStashes(ctx.cwd);
-		const result = await show(ctx, stashes, path);
-
-		if (result.kind === "cancel") return undefined;
-		if (result.kind === "primary") return result.item;
-
-		// discard: drop the stashed prompt without restoring it.
-		const ok = await ctx.ui.confirm("Discard stashed prompt?", result.item.text);
-		if (ok) {
-			await removeStash(ctx.cwd, result.item.id);
-			ctx.ui.notify("Stash discarded.", "info");
-		}
-	}
+	const stashes = await loadStashes(ctx.cwd);
+	const result = await show(ctx, stashes, path);
+	return result.kind === "primary" ? result.item : undefined;
 }
 
 async function show(
@@ -45,7 +35,29 @@ async function show(
 	stashes: readonly Stash[],
 	path: string,
 ): Promise<TextRecordSelectResult<Stash>> {
-	return ctx.ui.custom<TextRecordSelectResult<Stash>>((_tui, theme, _keybindings, done) =>
-		createTextRecordSelectPanel(theme, stashes, { ...CONFIG, path }, done),
+	return ctx.ui.custom<TextRecordSelectResult<Stash>>((tui, theme, _keybindings, done) =>
+		createTextRecordSelectPanel(
+			tui,
+			theme,
+			stashes,
+			{
+				...CONFIG,
+				path,
+				destructiveAction: {
+					id: "discard",
+					key: Key.ctrl("d"),
+					hint: rawHint("ctrl+d", "discard"),
+					confirmLabel: () => "Discard stashed prompt?",
+					runningLabel: "Discarding stashed prompt…",
+					onConfirm: async (item) => {
+						const next = await removeStash(ctx.cwd, item.id);
+						ctx.ui.notify("Stash discarded.", "info");
+						return next;
+					},
+					onError: (error) => ctx.ui.notify(`Stash discard failed: ${errorText(error)}`, "error"),
+				},
+			},
+			done,
+		),
 	);
 }