@oh-my-pi/pi-coding-agent 15.10.1 → 15.10.3

package/src/tools/eval-render.ts

@@ -16,9 +16,8 @@ import type { EvalCellResult, EvalLanguage, EvalStatusEvent, EvalToolDetails } f
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { formatContextUsage } from "../modes/components/status-line/context-thresholds";
 import { truncateToVisualLines } from "../modes/components/visual-truncate";
-import { shimmerEnabled } from "../modes/theme/shimmer";
 import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
-import { borderShimmerTick, markFramedBlockComponent, renderCodeCell } from "../tui";
+import { markFramedBlockComponent, renderCodeCell } from "../tui";
 import {
 	JSON_TREE_MAX_DEPTH_COLLAPSED,
 	JSON_TREE_MAX_DEPTH_EXPANDED,
@@ -491,8 +490,7 @@ export const evalToolRenderer = {
 
 		return markFramedBlockComponent({
 			render: (width: number): string[] => {
-				const animate = options.isPartial && shimmerEnabled();
-				const key = `${animate ? borderShimmerTick() : 0}|${options.expanded ? 1 : 0}|${cells.map(c => `${c.language}:${c.title ?? ""}:${c.code.length}`).join("|")}`;
+				const key = `${options.expanded ? 1 : 0}|${cells.map(c => `${c.language}:${c.title ?? ""}:${c.code.length}`).join("|")}`;
 				if (cached && cached.key === key && cached.width === width) {
 					return cached.result;
 				}
@@ -510,13 +508,9 @@ export const evalToolRenderer = {
 							status: "pending",
 							width,
 							// Always render the full source: the code is fixed input, not the
-							// streaming part, so it is never compacted. While still pending
-							// (args streaming) the block is not yet committed to native
-							// scrollback — its head is only committed once a result exists and
-							// the code has finalized (see `isStreamingPreviewAppendOnly`).
+							// streaming part, so it is never compacted.
 							codeMaxLines: Number.POSITIVE_INFINITY,
 							expanded: options.expanded,
-							animate,
 						},
 						uiTheme,
 					);
@@ -579,8 +573,7 @@ export const evalToolRenderer = {
 				render: (width: number): string[] => {
 					const expanded = options.renderContext?.expanded ?? options.expanded;
 					const previewLines = options.renderContext?.previewLines ?? EVAL_DEFAULT_PREVIEW_LINES;
-					const animate = options.isPartial && shimmerEnabled();
-					const key = `${expanded}|${previewLines}|${options.spinnerFrame}|${animate ? borderShimmerTick() : 0}`;
+					const key = `${expanded}|${previewLines}|${options.spinnerFrame}`;
 					if (cached && cached.key === key && cached.width === width) {
 						return cached.result;
 					}
@@ -622,7 +615,6 @@ export const evalToolRenderer = {
 								codeMaxLines: Number.POSITIVE_INFINITY,
 								expanded,
 								width,
-								animate,
 							},
 							uiTheme,
 						);
@@ -752,17 +744,6 @@ export const evalToolRenderer = {
 		};
 	},
 
-	// Append-only once a result exists (args complete → code finalized). The code
-	// is rendered in full as a fixed top-anchored prefix, and the streamed stdout
-	// below it only appends rows at the bottom, so the scrolled-off head commits
-	// to native scrollback instead of being yanked — collapsed or expanded, since
-	// the collapsed output cap keeps its sliding tail in the bottom live region.
-	// Returns false while still pending: the code is mid-stream (args incomplete)
-	// and its header still reads "pending", so committing it would strand a stale
-	// pending preview in history.
-	isStreamingPreviewAppendOnly(_args: EvalRenderArgs, _options: RenderResultOptions, result?: unknown): boolean {
-		return result != null;
-	},
 	mergeCallAndResult: true,
 	inline: true,
 };

package/src/tools/eval.ts

@@ -88,12 +88,21 @@ function formatDisplayOutputsForText(outputs: EvalDisplayOutput[]): string {
 export interface EvalToolDescriptionOptions {
 	py?: boolean;
 	js?: boolean;
+	/**
+	 * Whether `agent()` is allowed in this session. Driven by the parent's
+	 * spawn policy (`getSessionSpawns`). Defaults to `true` for backward
+	 * compatibility — when the session forbids spawning, the prelude doc
+	 * omits the `agent()` entry so the model does not promise itself a
+	 * helper that will only ever throw "spawns disabled".
+	 */
+	spawns?: boolean;
 }
 
 export function getEvalToolDescription(options: EvalToolDescriptionOptions = {}): string {
 	const py = options.py ?? true;
 	const js = options.js ?? true;
-	return prompt.render(evalDescription, { py, js });
+	const spawns = options.spawns ?? true;
+	return prompt.render(evalDescription, { py, js, spawns });
 }
 
 export interface EvalToolOptions {
@@ -169,7 +178,9 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 	get description(): string {
 		if (!this.session) return getEvalToolDescription();
 		const backends = resolveEvalBackends(this.session);
-		return getEvalToolDescription({ py: backends.python, js: backends.js });
+		const sessionSpawns = this.session.getSessionSpawns?.() ?? "*";
+		const spawnsAllowed = sessionSpawns !== "" && sessionSpawns !== null;
+		return getEvalToolDescription({ py: backends.python, js: backends.js, spawns: spawnsAllowed });
 	}
 	readonly parameters = evalSchema;
 	readonly concurrency = "exclusive";

package/src/tools/find.ts

@@ -117,6 +117,12 @@ export interface FindToolOptions {
 	operations?: FindOperations;
 }
 
+interface FindTarget {
+	searchPath: string;
+	globPattern: string;
+	hasGlob: boolean;
+}
+
 export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 	readonly name = "find";
 	readonly approval = "read" as const;
@@ -193,15 +199,31 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			}
 
 			const multiPattern = await resolveExplicitFindPatterns(effectivePatterns, this.session.cwd);
-			const parsedPattern = multiPattern ? null : parseFindPattern(effectivePatterns[0] ?? ".");
-			const hasGlob = multiPattern ? true : (parsedPattern?.hasGlob ?? false);
-			const globPattern = multiPattern?.globPattern ?? parsedPattern?.globPattern ?? "**/*";
-			const searchPath = resolveToCwd(multiPattern?.basePath ?? parsedPattern?.basePath ?? ".", this.session.cwd);
-			const scopePath = multiPattern?.scopePath ?? formatScopePath(searchPath);
-
-			if (searchPath === "/") {
-				throw new ToolError("Searching from root directory '/' is not allowed");
+			const isSingle = !multiPattern;
+			const targets: FindTarget[] = multiPattern
+				? multiPattern.targets.map(target => ({
+						searchPath: resolveToCwd(target.basePath, this.session.cwd),
+						globPattern: target.globPattern,
+						hasGlob: target.hasGlob,
+					}))
+				: [
+						(() => {
+							const parsed = parseFindPattern(effectivePatterns[0] ?? ".");
+							return {
+								searchPath: resolveToCwd(parsed.basePath, this.session.cwd),
+								globPattern: parsed.globPattern,
+								hasGlob: parsed.hasGlob,
+							};
+						})(),
+					];
+			const scopePath = multiPattern?.scopePath ?? formatScopePath(targets[0].searchPath);
+
+			for (const target of targets) {
+				if (target.searchPath === "/") {
+					throw new ToolError("Searching from root directory '/' is not allowed");
+				}
 			}
+
 			const requestedLimit = limit ?? DEFAULT_LIMIT;
 			if (!Number.isFinite(requestedLimit) || requestedLimit <= 0) {
 				throw new ToolError("Limit must be a positive number");
@@ -213,9 +235,9 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			const timeoutMs = Math.min(MAX_GLOB_TIMEOUT_MS, Math.max(MIN_GLOB_TIMEOUT_MS, requestedTimeoutMs));
 			const timeoutSignal = AbortSignal.timeout(timeoutMs);
 			const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
-			const formatMatchPath = (matchPath: string, fileType?: natives.FileType): string => {
+			const formatMatchPath = (matchPath: string, base: string, fileType?: natives.FileType): string => {
 				const hadTrailingSlash = matchPath.endsWith("/") || matchPath.endsWith("\\");
-				const absolutePath = path.isAbsolute(matchPath) ? matchPath : path.resolve(searchPath, matchPath);
+				const absolutePath = path.isAbsolute(matchPath) ? matchPath : path.resolve(base, matchPath);
 				return formatPathRelativeToCwd(absolutePath, this.session.cwd, {
 					trailingSlash: fileType === natives.FileType.Dir || hadTrailingSlash,
 				});
@@ -276,45 +298,41 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				return resultBuilder.done();
 			};
 
+			// Walk each user path as its own root and run the globs concurrently.
+			// Collapsing multiple paths to a shared base would force the walker to
+			// traverse and stat every unrelated sibling under that ancestor; per-path
+			// roots keep each scan bounded to exactly what the user asked for.
 			if (this.#customOps?.glob) {
-				if (!(await this.#customOps.exists(searchPath))) {
-					throw new ToolError(`Path not found: ${scopePath}`);
-				}
-
-				if (!hasGlob && this.#customOps.stat) {
-					const stat = await this.#customOps.stat(searchPath);
-					if (stat.isFile()) {
-						return buildResult([scopePath]);
+				const customOps = this.#customOps;
+				const perTarget = await Promise.all(
+					targets.map(async target => {
+						if (!(await customOps.exists(target.searchPath))) {
+							if (isSingle) throw new ToolError(`Path not found: ${scopePath}`);
+							return [] as string[];
+						}
+						if (!target.hasGlob && customOps.stat) {
+							const stat = await customOps.stat(target.searchPath);
+							if (stat.isFile()) return [formatScopePath(target.searchPath)];
+						}
+						const results = await customOps.glob(target.globPattern, target.searchPath, {
+							ignore: ["**/node_modules/**", "**/.git/**"],
+							limit: effectiveLimit,
+						});
+						return results.map(matchPath => formatMatchPath(matchPath, target.searchPath));
+					}),
+				);
+				const seen = new Set<string>();
+				const merged: string[] = [];
+				for (const group of perTarget) {
+					for (const entry of group) {
+						if (seen.has(entry)) continue;
+						seen.add(entry);
+						merged.push(entry);
 					}
 				}
-
-				const results = await this.#customOps.glob(globPattern, searchPath, {
-					ignore: ["**/node_modules/**", "**/.git/**"],
-					limit: effectiveLimit,
-				});
-				const relativized = results.map(p => formatMatchPath(p));
-
-				return buildResult(relativized);
-			}
-
-			let searchStat: fs.Stats;
-			try {
-				searchStat = await fs.promises.stat(searchPath);
-			} catch (err) {
-				if (isEnoent(err)) {
-					throw new ToolError(`Path not found: ${scopePath}`);
-				}
-				throw err;
-			}
-
-			if (!hasGlob && searchStat.isFile()) {
-				return buildResult([scopePath]);
-			}
-			if (!searchStat.isDirectory()) {
-				throw new ToolError(`Path is not a directory: ${searchPath}`);
+				return buildResult(merged);
 			}
 
-			let matches: natives.GlobMatch[];
 			const onUpdateMatches: string[] = [];
 			const onUpdateMtimes: number[] = [];
 			const updateIntervalMs = 200;
@@ -335,80 +353,111 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					details,
 				});
 			};
-			const onMatch = (err: Error | null, match: natives.GlobMatch | null) => {
-				if (err || combinedSignal.aborted || !match?.path) return;
-				const relativePath = formatMatchPath(match.path, match.fileType);
-				onUpdateMatches.push(relativePath);
-				onUpdateMtimes.push(match.mtime ?? 0);
-				emitUpdate();
-			};
-
-			const doGlob = async (useGitignore: boolean) =>
-				untilAborted(combinedSignal, () =>
-					natives.glob(
-						{
-							pattern: globPattern,
-							path: searchPath,
-							hidden: includeHidden,
-							maxResults: effectiveLimit,
-							sortByMtime: true,
-							gitignore: useGitignore,
-							signal: combinedSignal,
-						},
-						onMatch,
-					),
-				);
+			const streamed = new Set<string>();
+			const makeOnMatch =
+				(base: string) =>
+				(err: Error | null, match: natives.GlobMatch | null): void => {
+					if (err || combinedSignal.aborted || !match?.path) return;
+					const relativePath = formatMatchPath(match.path, base, match.fileType);
+					if (streamed.has(relativePath)) return;
+					streamed.add(relativePath);
+					onUpdateMatches.push(relativePath);
+					onUpdateMtimes.push(match.mtime ?? 0);
+					emitUpdate();
+				};
 
 			let timedOut = false;
-			try {
-				const result = await doGlob(useGitignore);
-				// Native glob returns a bounded mtime-ranked set; keep the JS sort for
-				// deterministic ordering across cached and uncached native paths.
-				result.matches.sort((a, b) => (b.mtime ?? 0) - (a.mtime ?? 0));
-				matches = result.matches;
-			} catch (error) {
-				if (error instanceof Error && error.name === "AbortError") {
-					if (timeoutSignal.aborted && !signal?.aborted) {
-						timedOut = true;
-						matches = [];
-					} else {
+			const runTarget = async (target: FindTarget): Promise<Array<{ path: string; mtime: number }>> => {
+				throwIfAborted(signal);
+				let stat: fs.Stats;
+				try {
+					stat = await fs.promises.stat(target.searchPath);
+				} catch (err) {
+					if (isEnoent(err)) {
+						if (isSingle) throw new ToolError(`Path not found: ${scopePath}`);
+						return [];
+					}
+					throw err;
+				}
+				if (!target.hasGlob && stat.isFile()) {
+					return [{ path: formatScopePath(target.searchPath), mtime: stat.mtimeMs }];
+				}
+				if (!stat.isDirectory()) {
+					if (isSingle) throw new ToolError(`Path is not a directory: ${target.searchPath}`);
+					return [];
+				}
+				try {
+					const result = await untilAborted(combinedSignal, () =>
+						natives.glob(
+							{
+								pattern: target.globPattern,
+								path: target.searchPath,
+								hidden: includeHidden,
+								maxResults: effectiveLimit,
+								sortByMtime: true,
+								gitignore: useGitignore,
+								// parseFindPattern explicitly prepends "**/" when the user's
+								// pattern begins with a glob (so `*.ts` becomes `**/*.ts`).
+								// Anything that arrives here without "**/" was scoped to a
+								// single directory by the user (e.g. `dir/*`); disable the
+								// native auto-recursion so `dir/*` does not silently match
+								// `dir/sub/nested.ts`.
+								recursive: false,
+								signal: combinedSignal,
+							},
+							makeOnMatch(target.searchPath),
+						),
+					);
+					throwIfAborted(signal);
+					const out: Array<{ path: string; mtime: number }> = [];
+					for (const match of result.matches) {
+						if (!match.path) continue;
+						out.push({
+							path: formatMatchPath(match.path, target.searchPath, match.fileType),
+							mtime: match.mtime ?? 0,
+						});
+					}
+					return out;
+				} catch (error) {
+					if (error instanceof Error && error.name === "AbortError") {
+						if (timeoutSignal.aborted && !signal?.aborted) {
+							timedOut = true;
+							return [];
+						}
 						throw new ToolAbortError();
 					}
-				} else {
 					throw error;
 				}
-			}
+			};
+
+			const perTarget = await Promise.all(targets.map(runTarget));
 
 			if (timedOut) {
 				// Drain the partial matches accumulated during streaming and return them
 				// instead of throwing — empty results after a multi-second wait force the
 				// caller to retry blind, which is the worst possible outcome.
-				const seen = new Set<string>();
-				const partial: Array<{ p: string; m: number }> = [];
-				for (let i = 0; i < onUpdateMatches.length; i++) {
-					const entry = onUpdateMatches[i];
-					if (seen.has(entry)) continue;
-					seen.add(entry);
-					partial.push({ p: entry, m: onUpdateMtimes[i] ?? 0 });
-				}
+				const partial = onUpdateMatches.map((entry, index) => ({ p: entry, m: onUpdateMtimes[index] ?? 0 }));
 				partial.sort((a, b) => b.m - a.m);
-				const sortedPaths = partial.map(e => e.p);
+				const sortedPaths = partial.map(entry => entry.p);
 				const seconds = timeoutMs % 1000 === 0 ? `${timeoutMs / 1000}` : (timeoutMs / 1000).toFixed(1);
 				const notice = `find timed out after ${seconds}s; returning ${sortedPaths.length} partial matches — increase timeout or narrow pattern`;
 				return buildResult(sortedPaths, { notice, forceTruncated: true });
 			}
 
-			const relativized: string[] = [];
-			for (const match of matches) {
-				throwIfAborted(signal);
-				if (!match.path) {
-					continue;
+			// Merge per-target results: native glob already ranks each target's own
+			// matches by mtime and caps them at the limit, so a global mtime re-sort
+			// plus dedup yields the correct top-N across all roots.
+			const seen = new Set<string>();
+			const merged: Array<{ path: string; mtime: number }> = [];
+			for (const group of perTarget) {
+				for (const entry of group) {
+					if (seen.has(entry.path)) continue;
+					seen.add(entry.path);
+					merged.push(entry);
 				}
-
-				relativized.push(formatMatchPath(match.path, match.fileType));
 			}
-
-			return buildResult(relativized);
+			merged.sort((a, b) => b.mtime - a.mtime);
+			return buildResult(merged.map(entry => entry.path));
 		});
 	}
 }

package/src/tools/gh-cache-invalidation.ts

@@ -0,0 +1,200 @@
+/**
+ * Detect cache-mutating `gh` subcommands inside a bash invocation and drop
+ * the matching `github-cache` rows so a subsequent `issue://<n>` or
+ * `pr://<n>` read sees the post-mutation state instead of the stale
+ * pre-mutation snapshot.
+ *
+ * Triggered before the bash command runs: on success the cache is now
+ * empty and the next read fetches fresh; on failure the worst case is one
+ * extra `gh` round-trip on the following read. That cost is bounded and
+ * eliminates the much-worse "issue shows OPEN for up to softTtlSec after
+ * `gh issue close`" failure mode reported by users.
+ *
+ * Detector scope: ops that change visible issue/PR state — `close`,
+ * `reopen`, `merge`, `delete`, `ready`, `lock`, `unlock`, `pin`, `unpin`,
+ * `transfer`, plus the comment/review/edit ops that change the rendered
+ * body. We deliberately over-invalidate (e.g. all matching rows for the
+ * number, all auth_keys) because the upside of staleness elimination
+ * dwarfs the cost of one cache miss.
+ */
+import { invalidateAllForNumber } from "./github-cache";
+
+const PR_URL_PATTERN = /^https:\/\/github\.com\/([^/\s]+\/[^/\s]+)\/pull\/(\d+)(?:[/?#].*)?$/i;
+const ISSUE_URL_PATTERN = /^https:\/\/github\.com\/([^/\s]+\/[^/\s]+)\/issues\/(\d+)(?:[/?#].*)?$/i;
+
+/** Subcommands that mutate the rendered issue/PR view in any meaningful way. */
+const MUTATING_ISSUE_SUBCMDS: Record<string, true> = {
+	close: true,
+	reopen: true,
+	delete: true,
+	edit: true,
+	comment: true,
+	lock: true,
+	unlock: true,
+	pin: true,
+	unpin: true,
+	transfer: true,
+	develop: true,
+};
+
+const MUTATING_PR_SUBCMDS: Record<string, true> = {
+	close: true,
+	reopen: true,
+	merge: true,
+	ready: true,
+	edit: true,
+	comment: true,
+	review: true,
+	lock: true,
+	unlock: true,
+};
+/**
+ * Walk a single shell command's token stream looking for a top-level
+ * `gh (issue|pr) <subcmd> <id-or-url>` invocation and return the
+ * invalidation key when one is found. Returns `null` for non-matching
+ * commands so the caller can iterate cheaply.
+ */
+function detectGhMutation(tokens: readonly string[]): { number: number; repo?: string } | null {
+	const ghIdx = tokens.indexOf("gh");
+	if (ghIdx === -1) return null;
+	const subject = tokens[ghIdx + 1];
+	if (subject !== "issue" && subject !== "pr") return null;
+	const subcmd = tokens[ghIdx + 2];
+	if (!subcmd) return null;
+	const expected = subject === "issue" ? MUTATING_ISSUE_SUBCMDS : MUTATING_PR_SUBCMDS;
+	if (!expected[subcmd]) return null;
+
+	let repo: string | undefined;
+	// First pass: scan for --repo so it wins regardless of position relative
+	// to the issue/PR identifier (gh accepts the flag both before and after
+	// the positional argument).
+	for (let i = ghIdx + 3; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token === "-R" || token === "--repo") {
+			const next = tokens[i + 1];
+			if (next) repo = next;
+			i++;
+			continue;
+		}
+		if (token.startsWith("--repo=")) {
+			repo = token.slice("--repo=".length);
+		}
+	}
+	for (let i = ghIdx + 3; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token === "-R" || token === "--repo") {
+			i++;
+			continue;
+		}
+		if (token.startsWith("-")) continue;
+		const direct = /^\d+$/.test(token) ? Number(token) : undefined;
+		if (direct !== undefined && Number.isSafeInteger(direct) && direct > 0) {
+			return repo !== undefined ? { number: direct, repo } : { number: direct };
+		}
+		const urlMatch = (subject === "pr" ? PR_URL_PATTERN : ISSUE_URL_PATTERN).exec(token);
+		if (urlMatch) {
+			const num = Number(urlMatch[2]);
+			if (Number.isSafeInteger(num) && num > 0) {
+				// URL carries its own repo and wins over a stray --repo flag.
+				return { number: num, repo: urlMatch[1] };
+			}
+		}
+	}
+	return null;
+}
+
+/**
+ * Conservative tokenizer that splits a bash command into individual word
+ * tokens. Handles single/double-quoted strings, backslash escapes, and
+ * standard operators (`;`, `&&`, `||`, `|`, `&`, newlines) as token
+ * boundaries that emit a sentinel `";"` so the caller treats the segments
+ * as independent command sequences. We do not attempt full POSIX shell
+ * parsing — heredocs, command substitution, and arithmetic expansion are
+ * out of scope; the detector simply falls through when it cannot find a
+ * clean `gh issue|pr <subcmd>` triple.
+ */
+function tokenize(command: string): string[][] {
+	const segments: string[][] = [];
+	let current: string[] = [];
+	let buffer = "";
+	let inSingle = false;
+	let inDouble = false;
+	const pushBuffer = () => {
+		if (buffer.length > 0) {
+			current.push(buffer);
+			buffer = "";
+		}
+	};
+	const pushSegment = () => {
+		pushBuffer();
+		if (current.length > 0) segments.push(current);
+		current = [];
+	};
+	for (let i = 0; i < command.length; i++) {
+		const ch = command[i];
+		if (inSingle) {
+			if (ch === "'") {
+				inSingle = false;
+				continue;
+			}
+			buffer += ch;
+			continue;
+		}
+		if (inDouble) {
+			if (ch === "\\" && i + 1 < command.length) {
+				const next = command[i + 1];
+				if (next === '"' || next === "\\" || next === "$" || next === "`") {
+					buffer += next;
+					i++;
+					continue;
+				}
+			}
+			if (ch === '"') {
+				inDouble = false;
+				continue;
+			}
+			buffer += ch;
+			continue;
+		}
+		if (ch === "'") {
+			inSingle = true;
+			continue;
+		}
+		if (ch === '"') {
+			inDouble = true;
+			continue;
+		}
+		if (ch === "\\" && i + 1 < command.length) {
+			buffer += command[i + 1];
+			i++;
+			continue;
+		}
+		if (ch === " " || ch === "\t") {
+			pushBuffer();
+			continue;
+		}
+		if (ch === "\n" || ch === ";" || ch === "&" || ch === "|" || ch === "(" || ch === ")") {
+			pushSegment();
+			// `&&`, `||` already collapsed by the segment break above.
+			continue;
+		}
+		buffer += ch;
+	}
+	pushSegment();
+	return segments;
+}
+
+/**
+ * Drop `github-cache` rows for any `gh issue|pr <mutating-subcmd>` call
+ * embedded in `command`. Safe to invoke unconditionally; no-op when the
+ * command does not touch GitHub state.
+ */
+export function invalidateGithubCacheForBashCommand(command: string): void {
+	if (!command?.includes("gh")) return;
+	const segments = tokenize(command);
+	for (const segment of segments) {
+		const hit = detectGhMutation(segment);
+		if (!hit) continue;
+		invalidateAllForNumber(hit.number, hit.repo);
+	}
+}

package/src/tools/github-cache.ts

@@ -316,6 +316,31 @@ export function invalidate(
 	}
 }
 
+/**
+ * Drop every cached row for a given issue/PR number, regardless of repo,
+ * auth key, include_comments flag, or row kind ({@link CacheKind}). Best-effort:
+ * swallows DB failures the same way {@link invalidate} does.
+ *
+ * Used by the bash-side detector that reacts to `gh issue close` / `gh pr merge`
+ * style mutations. Repo + auth-key narrowing is intentionally skipped because
+ * the bash command often does not name the repo (defaults to cwd's `gh`
+ * config) and resolving the *current* repo from `cwd` for every bash call would
+ * be far more expensive than a write-amplified DELETE.
+ */
+export function invalidateAllForNumber(number: number, repo?: string): void {
+	const db = openDb();
+	if (!db) return;
+	try {
+		if (repo === undefined) {
+			db.prepare("DELETE FROM github_view_cache WHERE number = ?").run(number);
+		} else {
+			db.prepare("DELETE FROM github_view_cache WHERE number = ? AND repo = ?").run(number, normalizeRepo(repo));
+		}
+	} catch (err) {
+		logger.debug("github cache: invalidateAllForNumber failed", { err: String(err) });
+	}
+}
+
 /** Drop every cached row. Test helper. */
 export function clearAll(): void {
 	const db = openDb();