@oh-my-pi/pi-coding-agent 16.2.12 → 16.3.0

package/src/tools/ast-edit.ts

@@ -16,6 +16,7 @@ import { Ellipsis, fileHyperlink, framedBlock, renderStatusLine, truncateToWidth
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
 import { truncateForPrompt } from "./approval";
+import { parseReadUrlTarget } from "./fetch";
 import { createFileRecorder, formatResultPath } from "./file-recorder";
 import { classifyGroupedLines, formatGroupedFiles, groupLineIndicesByBlank } from "./grouped-file-output";
 import type { OutputMeta } from "./output-meta";
@@ -284,6 +285,12 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 				signal,
 				localProtocolOptions: this.session.localProtocolOptions,
 				skills: this.session.skills,
+				resolveExternalUrl: async rawPath => {
+					if (!parseReadUrlTarget(rawPath)) return undefined;
+					throw new ToolError(
+						`Cannot rewrite external URL: ${rawPath}. Use \`read\` or \`search\` to inspect fetched web content; ast_edit only applies to local files.`,
+					);
+				},
 			});
 			const { searchPath: resolvedSearchPath, scopePath, isDirectory, multiTargets, globFilter } = scope;
 

package/src/tools/ast-grep.ts

@@ -14,6 +14,7 @@ import astGrepDescription from "../prompts/tools/ast-grep.md" with { type: "text
 import { Ellipsis, fileHyperlink, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
+import { materializeReadUrlToFile, parseReadUrlTarget } from "./fetch";
 import { createFileRecorder, formatResultPath } from "./file-recorder";
 import { classifyGroupedLines, formatGroupedFiles, groupLineIndicesByBlank } from "./grouped-file-output";
 import { formatMatchLine } from "./match-line-format";
@@ -208,6 +209,16 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 				signal,
 				localProtocolOptions: this.session.localProtocolOptions,
 				skills: this.session.skills,
+				resolveExternalUrl: async rawPath => {
+					const target = parseReadUrlTarget(rawPath);
+					if (!target) return undefined;
+					const materialized = await materializeReadUrlToFile(
+						this.session,
+						{ path: target.path, raw: target.raw },
+						signal,
+					);
+					return { sourcePath: materialized.path, immutable: true };
+				},
 			});
 			const { searchPath: resolvedSearchPath, scopePath, isDirectory, multiTargets, globFilter } = scope;
 

package/src/tools/bash.ts

@@ -29,7 +29,12 @@ import { checkBashInterception } from "./bash-interceptor";
 import { canUseInteractiveBashPty } from "./bash-pty-selection";
 import { expandInternalUrls, type InternalUrlExpansionOptions } from "./bash-skill-urls";
 import { invalidateGithubCacheForBashCommand } from "./gh-cache-invalidation";
-import { formatStyledTruncationWarning, type OutputMeta, stripOutputNotice } from "./output-meta";
+import {
+	formatStyledTruncationWarning,
+	type OutputMeta,
+	stripOutputNotice,
+	stripRawOutputArtifactNotice,
+} from "./output-meta";
 import { resolveToCwd } from "./path-utils";
 import { capPreviewLines, formatToolWorkingDirectory, previewWindowRows, replaceTabs } from "./render-utils";
 import { ToolAbortError, ToolError } from "./tool-errors";
@@ -292,35 +297,6 @@ function formatExitCodeNotice(exitCode: number): string {
 	return `Command exited with code ${exitCode}`;
 }
 
-const RAW_OUTPUT_ARTIFACT_PREFIX = "[raw output: artifact://";
-const RAW_OUTPUT_ARTIFACT_SUFFIX = "]";
-
-function stripRawOutputArtifactNotice(text: string): { text: string; artifactId?: string } {
-	const trimmed = text.trimEnd();
-	const lineStart = trimmed.lastIndexOf("\n");
-	const candidateStart = lineStart === -1 ? 0 : lineStart + 1;
-	if (
-		!trimmed.startsWith(RAW_OUTPUT_ARTIFACT_PREFIX, candidateStart) ||
-		!trimmed.endsWith(RAW_OUTPUT_ARTIFACT_SUFFIX)
-	) {
-		return { text };
-	}
-
-	const idStart = candidateStart + RAW_OUTPUT_ARTIFACT_PREFIX.length;
-	const idEnd = trimmed.length - RAW_OUTPUT_ARTIFACT_SUFFIX.length;
-	if (idStart === idEnd) return { text };
-	for (let i = idStart; i < idEnd; i++) {
-		const code = trimmed.charCodeAt(i);
-		if (code < 48 || code > 57) return { text };
-	}
-
-	const artifactId = trimmed.slice(idStart, idEnd);
-	return {
-		text: trimmed.slice(0, lineStart === -1 ? 0 : lineStart).trimEnd(),
-		artifactId,
-	};
-}
-
 /**
  * Strip the trailing occurrence of `notice` (plus a single surrounding newline
  * on each side) so the TUI can echo the value via a styled footer label

package/src/tools/checkpoint.ts

@@ -17,6 +17,15 @@ export interface CheckpointState {
 	startedAt: string;
 }
 
+export interface CompletedRewindState {
+	/** Report retained after a successful rewind. */
+	report: string;
+	/** Timestamp for the checkpoint that was rewound. */
+	startedAt: string;
+	/** Timestamp when the rewind completed. */
+	rewoundAt: string;
+}
+
 const checkpointSchema = type({
 	goal: type("string").describe("investigation goal"),
 });
@@ -123,7 +132,12 @@ export class RewindTool implements AgentTool<typeof rewindSchema, RewindToolDeta
 			throw new ToolError("Checkpoint not available in subagents.");
 		}
 		if (!this.session.getCheckpointState?.()) {
-			throw new ToolError("No active checkpoint.");
+			if (this.session.getLastCompletedRewind?.()) {
+				throw new ToolError(
+					"Checkpoint already completed; continue from the retained rewind report instead of calling rewind again.",
+				);
+			}
+			throw new ToolError("No active checkpoint. Create a checkpoint before calling rewind.");
 		}
 		const report = params.report.trim();
 		if (report.length === 0) {

package/src/tools/eval-render.ts

@@ -775,4 +775,19 @@ export const evalToolRenderer = {
 	// below the first cell. Expanded output is top-anchored enough for the
 	// transcript to commit its settled prefix.
 	provisionalPendingPreview: "collapsed",
+	// Partial-result chrome is NOT byte-stable: `renderAgentProgressEvents`
+	// inserts/removes each subagent's current-tool line as it starts/stops a
+	// tool, and ticks status icon/stats/duration on already-rendered rows,
+	// while `options.isPartial` holds for the whole eval() cell (agent
+	// progress ticks never carry an `async` completed/failed state, so
+	// `event-controller.ts` keeps `isPartial: true` throughout). If this
+	// block were commit-stable during that churn, `deriveLiveCommitState`'s
+	// stable-prefix ratchet would promote agent rows that keep mutating (a
+	// "slow ticker", see transcript-container.ts) into native scrollback,
+	// and the tui resync's "duplication, never loss" contract would
+	// repeatedly re-show the frame tail under a heavy concurrent
+	// `agent()`/`parallel()` fan-out — the overlapping/duplicated tree rows
+	// seen when many subagents run at once. Once the cell settles
+	// (`isPartial === false`) the block is commit-stable again.
+	provisionalPartialResult: true,
 };

package/src/tools/fetch.ts

@@ -27,7 +27,7 @@ import { finalizeOutput, loadPage, looksLikeHtml, MAX_BYTES, MAX_OUTPUT_CHARS }
 import { convertWithMarkit, fetchBinary } from "../web/scrapers/utils";
 import { applyListLimit } from "./list-limit";
 import { formatStyledArtifactReference, type OutputMeta } from "./output-meta";
-import { type LineRange, parseLineRanges } from "./path-utils";
+import { isReadableUrlPath, type LineRange, parseLineRanges } from "./path-utils";
 import { formatBytes, formatExpandHint, getDomain, replaceTabs } from "./render-utils";
 import { listTables, looksLikeSqlite, renderTableList } from "./sqlite-reader";
 import { ToolAbortError, ToolError } from "./tool-errors";
@@ -145,10 +145,6 @@ function normalizeUrl(url: string): string {
 	return url;
 }
 
-export function isReadableUrlPath(value: string): boolean {
-	return /^https?:\/\/?/i.test(value) || /^www\./i.test(value);
-}
-
 // URL line selectors mirror the file form: `:50`, `:50-100`, `:50+150`, `:5-10,20-30`, `:raw`,
 // or `:raw:N-M` / `:N-M:raw` to combine raw mode with a range. If a URL would otherwise look
 // like `host:port`, add a trailing slash before the selector (e.g. `https://example.com/:80`
@@ -1559,9 +1555,12 @@ export interface ReadUrlToolDetails {
 
 interface ReadUrlCacheEntry {
 	artifactId?: string;
+	artifactPath?: string;
+	contentPath?: string;
 	details: ReadUrlToolDetails;
 	image?: FetchImagePayload;
 	output: string;
+	content: string;
 }
 
 const READ_URL_CACHE_MAX_ENTRIES = 100;
@@ -1572,20 +1571,24 @@ function getReadUrlCacheKey(session: ToolSession, requestedUrl: string, raw: boo
 	return `${scope}::${raw ? "raw" : "rendered"}::${normalizeUrl(requestedUrl)}`;
 }
 
-async function readArtifactOutput(session: ToolSession, artifactId: string): Promise<string | null> {
+async function findArtifactPath(session: ToolSession, artifactId: string): Promise<string | null> {
 	const artifactsDir = session.getArtifactsDir?.();
 	if (!artifactsDir) return null;
 
 	try {
 		const files = await fs.readdir(artifactsDir);
 		const match = files.find(file => file.startsWith(`${artifactId}.`));
-		if (!match) return null;
-		return await Bun.file(path.join(artifactsDir, match)).text();
+		return match ? path.join(artifactsDir, match) : null;
 	} catch {
 		return null;
 	}
 }
 
+async function readArtifactOutput(session: ToolSession, artifactId: string): Promise<string | null> {
+	const artifactPath = await findArtifactPath(session, artifactId);
+	return artifactPath ? await Bun.file(artifactPath).text() : null;
+}
+
 async function materializeReadUrlCacheEntry(
 	session: ToolSession,
 	entry: ReadUrlCacheEntry,
@@ -1600,17 +1603,58 @@ async function materializeReadUrlCacheEntry(
 	return entry.output.length > 0 ? entry : null;
 }
 
-async function persistReadUrlArtifact(session: ToolSession, output: string): Promise<string | undefined> {
-	const { path: artifactPath, id } = (await session.allocateOutputArtifact?.("read")) ?? {};
-	if (!artifactPath) return undefined;
-	await Bun.write(artifactPath, output);
-	return id;
+async function persistReadUrlArtifact(
+	session: ToolSession,
+	output: string,
+): Promise<{ id?: string; path?: string } | undefined> {
+	const artifact = await session.allocateOutputArtifact?.("read");
+	if (!artifact?.path) return undefined;
+	await Bun.write(artifact.path, output);
+	return artifact;
 }
 
 async function ensureReadUrlCacheArtifact(session: ToolSession, entry: ReadUrlCacheEntry): Promise<ReadUrlCacheEntry> {
-	if (entry.artifactId) return entry;
-	const artifactId = await persistReadUrlArtifact(session, entry.output);
-	return artifactId ? { ...entry, artifactId } : entry;
+	if (entry.artifactId && entry.artifactPath) return entry;
+	if (entry.artifactId) {
+		const artifactPath = await findArtifactPath(session, entry.artifactId);
+		if (artifactPath) return { ...entry, artifactPath };
+	}
+	const artifact = await persistReadUrlArtifact(session, entry.output);
+	return artifact?.id ? { ...entry, artifactId: artifact.id, artifactPath: artifact.path } : entry;
+}
+
+function readUrlContentExtension(finalUrl: string): string {
+	try {
+		const ext = getFilenameExtensionHint(new URL(finalUrl).pathname);
+		return ext && /^\.[a-z0-9][a-z0-9+.-]{0,15}$/i.test(ext) ? ext : ".txt";
+	} catch {
+		return ".txt";
+	}
+}
+
+async function ensureReadUrlContentFile(
+	session: ToolSession,
+	entry: ReadUrlCacheEntry,
+	raw: boolean,
+): Promise<ReadUrlCacheEntry> {
+	if (entry.contentPath) {
+		try {
+			await Bun.file(entry.contentPath).stat();
+			return entry;
+		} catch {
+			// Recreate below when the cached scratch file was removed.
+		}
+	}
+	const root = session.getArtifactsDir?.();
+	if (!root) {
+		throw new ToolError("Cannot search URL output because this session cannot materialize read artifacts.");
+	}
+	const dir = path.join(root, "url-search");
+	await fs.mkdir(dir, { recursive: true });
+	const hash = Bun.hash(`${raw ? "raw" : "rendered"}:${entry.details.finalUrl}`).toString(36);
+	const contentPath = path.join(dir, `${hash}${readUrlContentExtension(entry.details.finalUrl)}`);
+	await Bun.write(contentPath, entry.content);
+	return { ...entry, contentPath };
 }
 
 function cacheReadUrlEntry(session: ToolSession, requestedUrl: string, raw: boolean, entry: ReadUrlCacheEntry): void {
@@ -1644,10 +1688,11 @@ async function buildReadUrlCacheEntry(
 		webpExclusionForModel(session.getActiveModel?.()),
 	);
 	const output = buildUrlReadOutput(result, result.content);
-	const artifactId = options?.ensureArtifact ? await persistReadUrlArtifact(session, output) : undefined;
+	const artifact = options?.ensureArtifact ? await persistReadUrlArtifact(session, output) : undefined;
 
 	return {
-		artifactId,
+		artifactId: artifact?.id,
+		artifactPath: artifact?.path,
 		details: {
 			kind: "url",
 			url: result.url,
@@ -1659,6 +1704,7 @@ async function buildReadUrlCacheEntry(
 		},
 		image: result.image,
 		output,
+		content: result.content,
 	};
 }
 
@@ -1686,6 +1732,24 @@ export async function loadReadUrlCacheEntry(
 	return fresh;
 }
 
+/** Materialize rendered URL body text to a local file for tools that require filesystem paths. */
+export async function materializeReadUrlToFile(
+	session: ToolSession,
+	params: { path: string; raw?: boolean },
+	signal?: AbortSignal,
+): Promise<{ path: string; details: ReadUrlToolDetails }> {
+	if (!session.settings.get("fetch.enabled")) {
+		throw new ToolError("URL reads are disabled by settings.");
+	}
+	const cacheEntry = await loadReadUrlCacheEntry(session, params, signal, { preferCached: true });
+	const materialized = await ensureReadUrlContentFile(session, cacheEntry, params.raw ?? false);
+	cacheReadUrlEntry(session, params.path, params.raw ?? false, materialized);
+	if (!materialized.contentPath) {
+		throw new ToolError("Cannot search URL output because this session cannot materialize read artifacts.");
+	}
+	return { path: materialized.contentPath, details: materialized.details };
+}
+
 function buildUrlReadOutput(result: FetchRenderResult, content: string): string {
 	let output = "";
 	output += `URL: ${result.finalUrl}\n`;

package/src/tools/gh.ts

@@ -3112,7 +3112,7 @@ async function checkoutPullRequest(
 				remote.name,
 				`refs/heads/${headRefName}`,
 				`refs/remotes/${remote.name}/${headRefName}`,
-				signal,
+				{ signal },
 			);
 
 			if (!existingWorktree) {

package/src/tools/grep.ts

@@ -36,6 +36,7 @@ import {
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import { type ArchiveReader, type ExtractedArchiveFile, openArchive, parseArchivePathCandidates } from "../utils/zip";
 import type { ToolSession } from ".";
+import { materializeReadUrlToFile, parseReadUrlTarget } from "./fetch";
 import { createFileRecorder, formatResultPath } from "./file-recorder";
 import { classifyGroupedLines, formatGroupedFiles, groupLineIndicesByBlank } from "./grouped-file-output";
 import { formatMatchLine } from "./match-line-format";
@@ -901,6 +902,18 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 			const rawEntries = await expandDelimitedPathEntries(effectivePaths, this.session.cwd);
 			const pathSpecs = parsePathSpecs(rawEntries);
 			const paths = pathSpecs.map(spec => spec.clean);
+			const materializedExternalPaths = new Map<string, string>();
+			const materializeExternalUrlForSearch = async (rawPath: string) => {
+				const target = parseReadUrlTarget(rawPath);
+				if (!target) return undefined;
+				const materialized = await materializeReadUrlToFile(
+					this.session,
+					{ path: target.path, raw: target.raw },
+					signal,
+				);
+				materializedExternalPaths.set(rawPath, materialized.path);
+				return { sourcePath: materialized.path, immutable: true };
+			};
 			const {
 				resolvedPaths,
 				displayMap: archiveDisplayMap,
@@ -921,34 +934,7 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 				});
 				const searchablePaths = internalResolution.paths;
 				const { virtualResources, virtualPathSet, virtualInputIndexes } = internalResolution;
-				// Build the per-file line-range filter (keyed by absolute path) now that
-				// archive entries have been materialized to scratch files. Plain entries
-				// resolve through `resolveReadPath`; archive entries are keyed by the
-				// scratch path that grep will actually report against.
 				const rangesByAbsPath = new Map<string, LineRange[]>();
-				for (let idx = 0; idx < pathSpecs.length; idx++) {
-					const spec = pathSpecs[idx];
-					if (!spec.ranges) continue;
-					if (virtualInputIndexes.has(idx)) continue;
-					const resolved = internalResolution.resolvedPathsByInput[idx];
-					if (!resolved) continue;
-					if (resolved === spec.clean && !archiveDisplayMap.has(resolved)) {
-						// Non-archive entry; ensure the cleaned path resolves to a regular file.
-						const absKey = path.resolve(resolveReadPath(resolved, this.session.cwd));
-						const stats = await stat(absKey).catch(() => null);
-						if (!stats) {
-							throw new ToolError(`Path not found for line-range selector: ${spec.original}`);
-						}
-						if (!stats.isFile()) {
-							throw new ToolError(`Line-range selector requires a single file: ${spec.original} is a directory`);
-						}
-						mergeRangesInto(rangesByAbsPath, absKey, spec.ranges);
-					} else {
-						// Archive entry — `resolveArchiveSearchPaths` substituted a scratch path.
-						const absKey = path.resolve(resolved);
-						mergeRangesInto(rangesByAbsPath, absKey, spec.ranges);
-					}
-				}
 
 				if (
 					archiveUnreadable.length > 0 &&
@@ -991,6 +977,7 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 						signal,
 						localProtocolOptions: this.session.localProtocolOptions,
 						skills: this.session.skills,
+						resolveExternalUrl: materializeExternalUrlForSearch,
 					});
 					searchPath = scope.searchPath;
 					isDirectory = scope.isDirectory;
@@ -1001,6 +988,37 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 					for (const immutablePath of scope.immutableSourcePaths) {
 						immutableSourcePaths.add(immutablePath);
 					}
+					// Build the per-file line-range filter after URL materialization has run:
+					// archive entries are keyed by scratch path, URL entries by read-cache
+					// content path, and ordinary files by their resolved filesystem path.
+					for (let idx = 0; idx < pathSpecs.length; idx++) {
+						const spec = pathSpecs[idx];
+						if (!spec.ranges) continue;
+						if (virtualInputIndexes.has(idx)) continue;
+						const resolved = internalResolution.resolvedPathsByInput[idx];
+						if (!resolved) continue;
+						const materializedExternalPath = materializedExternalPaths.get(spec.clean);
+						if (materializedExternalPath) {
+							mergeRangesInto(rangesByAbsPath, path.resolve(materializedExternalPath), spec.ranges);
+							continue;
+						}
+						if (resolved === spec.clean && !archiveDisplayMap.has(resolved)) {
+							// Non-archive entry; ensure the cleaned path resolves to a regular file.
+							const absKey = path.resolve(resolveReadPath(resolved, this.session.cwd));
+							const stats = await stat(absKey).catch(() => null);
+							if (!stats) {
+								throw new ToolError(`Path not found for line-range selector: ${spec.original}`);
+							}
+							if (!stats.isFile()) {
+								throw new ToolError(
+									`Line-range selector requires a single file: ${spec.original} is a directory`,
+								);
+							}
+							mergeRangesInto(rangesByAbsPath, absKey, spec.ranges);
+						} else {
+							mergeRangesInto(rangesByAbsPath, path.resolve(resolved), spec.ranges);
+						}
+					}
 					// When the only input was an archive selector, surface that selector instead
 					// of the temp scratch path the resolver substituted in.
 					const physicalScopePath =

package/src/tools/index.ts

@@ -40,7 +40,7 @@ import { AstGrepTool } from "./ast-grep";
 import { BashTool } from "./bash";
 import { BrowserTool } from "./browser";
 import { type BuiltinToolName, normalizeToolNames } from "./builtin-names";
-import { type CheckpointState, CheckpointTool, RewindTool } from "./checkpoint";
+import { type CheckpointState, CheckpointTool, type CompletedRewindState, RewindTool } from "./checkpoint";
 import { DebugTool } from "./debug";
 import { EvalTool } from "./eval";
 import { resolveEvalBackends } from "./eval-backends";
@@ -332,6 +332,8 @@ export interface ToolSession {
 	getCheckpointState?: () => CheckpointState | undefined;
 	/** Set or clear active checkpoint state. */
 	setCheckpointState?: (state: CheckpointState | null) => void;
+	/** Get the most recent completed rewind, if this session just rewound a checkpoint. */
+	getLastCompletedRewind?: () => CompletedRewindState | undefined;
 
 	/** Per-session snapshot store of file contents as last shown to the model
 	 *  by `read`/`search`. Used by hashline anchor-stale recovery to

package/src/tools/irc.ts

@@ -97,6 +97,7 @@ export class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
 	readonly description: string;
 	readonly parameters = ircSchema;
 	readonly strict = true;
+	readonly interruptible = true;
 
 	readonly examples: readonly ToolExample<typeof ircSchema.infer>[] = [
 		{
@@ -317,16 +318,30 @@ export class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
 				lines.push("");
 				if (delivered.length > 0) {
 					const reply = await waiting;
-					if (reply.error) throw reply.error;
-					waited = reply.message;
-					if (waited) {
-						lines.push(`Reply from ${waited.from}:`);
-						lines.push(waited.body);
+					if (reply.error) {
+						// The send already succeeded; if the wait was interrupted by our
+						// caller signal (steering / IRC), preserve the delivery receipt so
+						// the agent loop keeps this tool as "sent" instead of marking it
+						// skipped, which would prompt a duplicate resend on the next turn.
+						if (signal?.aborted) {
+							lines.push(
+								`Send delivered but the reply wait was interrupted before ${to} answered. ` +
+									"Check `inbox` or `wait` again after handling the interrupt.",
+							);
+						} else {
+							throw reply.error;
+						}
 					} else {
-						lines.push(
-							`No reply from ${to} within ${formatDuration(timeoutMs)}. ` +
-								"They may answer later — check `inbox` or `wait` again.",
-						);
+						waited = reply.message;
+						if (waited) {
+							lines.push(`Reply from ${waited.from}:`);
+							lines.push(waited.body);
+						} else {
+							lines.push(
+								`No reply from ${to} within ${formatDuration(timeoutMs)}. ` +
+									"They may answer later — check `inbox` or `wait` again.",
+							);
+						}
 					}
 				} else {
 					awaitAbort?.abort(awaitCancelled);

package/src/tools/output-meta.ts

@@ -385,6 +385,56 @@ export function formatFullOutputReference(artifactId: string): string {
 	return `Read artifact://${artifactId} for full output`;
 }
 
+const RAW_OUTPUT_ARTIFACT_PREFIX = "[raw output: artifact://";
+const RAW_OUTPUT_ARTIFACT_SUFFIX = "]";
+
+/** Remove the trailing bash raw-output artifact footer while preserving its artifact id. */
+export function stripRawOutputArtifactNotice(text: string): { text: string; artifactId?: string } {
+	const trimmed = text.trimEnd();
+	const lineStart = trimmed.lastIndexOf("\n");
+	const candidateStart = lineStart === -1 ? 0 : lineStart + 1;
+	if (
+		!trimmed.startsWith(RAW_OUTPUT_ARTIFACT_PREFIX, candidateStart) ||
+		!trimmed.endsWith(RAW_OUTPUT_ARTIFACT_SUFFIX)
+	) {
+		return { text };
+	}
+
+	const idStart = candidateStart + RAW_OUTPUT_ARTIFACT_PREFIX.length;
+	const idEnd = trimmed.length - RAW_OUTPUT_ARTIFACT_SUFFIX.length;
+	if (idStart === idEnd) return { text };
+	for (let i = idStart; i < idEnd; i++) {
+		const code = trimmed.charCodeAt(i);
+		if (code < 48 || code > 57) return { text };
+	}
+
+	const artifactId = trimmed.slice(idStart, idEnd);
+	return {
+		text: trimmed.slice(0, lineStart === -1 ? 0 : lineStart).trimEnd(),
+		artifactId,
+	};
+}
+
+function isGeneratedOutputNoticeLine(line: string): boolean {
+	if (!line.startsWith("[") || !line.endsWith("]")) return false;
+	const body = line.slice(1, -1);
+	return (
+		body.startsWith("Showing ") ||
+		/^\d+ matches limit reached\. Use limit=\d+ for more/u.test(body) ||
+		/^\d+ results limit reached\. Use limit=\d+ for more/u.test(body) ||
+		body.startsWith("Some lines truncated to ")
+	);
+}
+
+/** Remove a trailing generated output notice when metadata is unavailable. */
+export function stripGeneratedOutputNotice(text: string): string {
+	const trimmed = text.trimEnd();
+	const lineStart = trimmed.lastIndexOf("\n");
+	const candidateStart = lineStart === -1 ? 0 : lineStart + 1;
+	if (!isGeneratedOutputNoticeLine(trimmed.slice(candidateStart))) return text;
+	return trimmed.slice(0, lineStart === -1 ? 0 : lineStart).trimEnd();
+}
+
 export function formatTruncationMetaNotice(truncation: TruncationMeta): string {
 	let notice: string;