@oh-my-pi/pi-coding-agent 14.9.2 → 14.9.5

package/src/tools/path-utils.ts

@@ -6,6 +6,8 @@ import { isEnoent } from "@oh-my-pi/pi-utils";
 
 const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
 const FILE_LINE_RANGE_RE = /^(?:L?\d+(?:[-+]L?\d+)?|raw)$/i;
+const FILE_LINE_RANGE_ONLY_RE = /^L?\d+(?:[-+]L?\d+)?$/i;
+const FILE_RAW_ONLY_RE = /^raw$/i;
 const NARROW_NO_BREAK_SPACE = "\u202F";
 const TOP_LEVEL_INTERNAL_URL_PREFIXES = [
 	"agent://",
@@ -110,7 +112,25 @@ export function splitPathAndSel(rawPath: string): { path: string; sel?: string }
 	const candidate = rawPath.slice(colon + 1);
 	if (!FILE_LINE_RANGE_RE.test(candidate)) return { path: rawPath };
 
-	return { path: rawPath.slice(0, colon), sel: candidate };
+	let basePath = rawPath.slice(0, colon);
+	let sel = candidate;
+
+	// Allow a compound trailing selector: `path:1-50:raw` or `path:raw:1-50`.
+	// The two chunks must be one line-range plus one `raw`, in either order.
+	const innerColon = basePath.lastIndexOf(":");
+	if (innerColon > 0) {
+		const innerCandidate = basePath.slice(innerColon + 1);
+		const innerIsRaw = FILE_RAW_ONLY_RE.test(innerCandidate);
+		const outerIsRaw = FILE_RAW_ONLY_RE.test(candidate);
+		const innerIsRange = FILE_LINE_RANGE_ONLY_RE.test(innerCandidate);
+		const outerIsRange = FILE_LINE_RANGE_ONLY_RE.test(candidate);
+		if ((innerIsRaw && outerIsRange) || (innerIsRange && outerIsRaw)) {
+			sel = `${innerCandidate}:${candidate}`;
+			basePath = basePath.slice(0, innerColon);
+		}
+	}
+
+	return { path: basePath, sel };
 }
 
 function assertNotInternalUrl(expanded: string, original: string): void {

package/src/tools/read.ts

@@ -12,6 +12,7 @@ import { getFileReadCache } from "../edit/file-read-cache";
 import { isNotebookPath, readEditableNotebookText } from "../edit/notebook";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { formatHashLine, formatHashLines, formatLineHash, HL_BODY_SEP } from "../hashline/hash";
+import { InternalUrlRouter } from "../internal-urls";
 import { parseInternalUrl } from "../internal-urls/parse";
 import type { InternalUrl } from "../internal-urls/types";
 import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
@@ -431,7 +432,7 @@ function prependSuffixResolutionNotice(text: string, suffixResolution?: { from:
 const readSchema = Type.Object({
 	path: Type.String({
 		description: 'path or url; append :<sel> for line ranges or raw mode (e.g. "src/foo.ts:50-100")',
-		examples: ["src/foo.ts", "src/foo.ts:50-100", "https://example.com:L1-L40"],
+		examples: ["src/foo.ts", "src/foo.ts:50-100", "https://example.com/:1-40"],
 	}),
 });
 
@@ -462,34 +463,67 @@ type ReadParams = ReadToolInput;
 type ParsedSelector =
 	| { kind: "none" }
 	| { kind: "raw" }
-	| { kind: "lines"; startLine: number; endLine: number | undefined };
+	| { kind: "lines"; startLine: number; endLine: number | undefined; raw?: boolean };
 
 const LINE_RANGE_RE = /^L?(\d+)(?:([-+])L?(\d+))?$/i;
 
-function parseSel(sel: string | undefined): ParsedSelector {
-	if (!sel || sel.length === 0) return { kind: "none" };
-	if (sel.toLowerCase() === "raw") return { kind: "raw" };
+/** Returns true when the selector requested verbatim/raw output (alone or combined with a range). */
+function isRawSelector(parsed: ParsedSelector): boolean {
+	return parsed.kind === "raw" || (parsed.kind === "lines" && parsed.raw === true);
+}
+
+function parseLineRangeChunk(sel: string): { startLine: number; endLine: number | undefined } | null {
 	const lineMatch = LINE_RANGE_RE.exec(sel);
-	if (lineMatch) {
-		const rawStart = Number.parseInt(lineMatch[1]!, 10);
-		if (rawStart < 1) {
-			throw new ToolError("Line selector 0 is invalid; lines are 1-indexed. Use :1.");
+	if (!lineMatch) return null;
+	const rawStart = Number.parseInt(lineMatch[1]!, 10);
+	if (rawStart < 1) {
+		throw new ToolError("Line selector 0 is invalid; lines are 1-indexed. Use :1.");
+	}
+	const sep = lineMatch[2];
+	const rhs = lineMatch[3] ? Number.parseInt(lineMatch[3], 10) : undefined;
+	let rawEnd: number | undefined;
+	if (sep === "+") {
+		if (rhs === undefined || rhs < 1) {
+			throw new ToolError(`Invalid range ${rawStart}+${rhs ?? 0}: count must be >= 1.`);
 		}
-		const sep = lineMatch[2];
-		const rhs = lineMatch[3] ? Number.parseInt(lineMatch[3], 10) : undefined;
-		let rawEnd: number | undefined;
-		if (sep === "+") {
-			if (rhs === undefined || rhs < 1) {
-				throw new ToolError(`Invalid range ${rawStart}+${rhs ?? 0}: count must be >= 1.`);
-			}
-			rawEnd = rawStart + rhs - 1;
-		} else if (sep === "-") {
-			if (rhs === undefined || rhs < rawStart) {
-				throw new ToolError(`Invalid range ${rawStart}-${rhs ?? 0}: end must be >= start.`);
+		rawEnd = rawStart + rhs - 1;
+	} else if (sep === "-") {
+		if (rhs === undefined || rhs < rawStart) {
+			throw new ToolError(`Invalid range ${rawStart}-${rhs ?? 0}: end must be >= start.`);
+		}
+		rawEnd = rhs;
+	}
+	return { startLine: rawStart, endLine: rawEnd };
+}
+
+function parseSel(sel: string | undefined): ParsedSelector {
+	if (!sel || sel.length === 0) return { kind: "none" };
+
+	// Compound selector: `1-50:raw` or `raw:1-50`. Split into chunks and accept
+	// any combination of one line range and the literal `raw`.
+	if (sel.includes(":")) {
+		const chunks = sel.split(":");
+		if (chunks.length === 2) {
+			const [a, b] = chunks as [string, string];
+			const aIsRaw = a.toLowerCase() === "raw";
+			const bIsRaw = b.toLowerCase() === "raw";
+			const rangeChunk = aIsRaw ? b : bIsRaw ? a : null;
+			const rawChunk = aIsRaw ? a : bIsRaw ? b : null;
+			if (rangeChunk !== null && rawChunk !== null) {
+				const range = parseLineRangeChunk(rangeChunk);
+				if (range) {
+					return { kind: "lines", startLine: range.startLine, endLine: range.endLine, raw: true };
+				}
 			}
-			rawEnd = rhs;
 		}
-		return { kind: "lines", startLine: rawStart, endLine: rawEnd };
+		// Unrecognized compound — fall through (sqlite/archive/url consume their own colon syntax).
+		return { kind: "none" };
+	}
+
+	if (sel.toLowerCase() === "raw") return { kind: "raw" };
+	const range = parseLineRangeChunk(sel);
+	if (range) {
+		return { kind: "lines", startLine: range.startLine, endLine: range.endLine };
 	}
 	// Unrecognized selectors fall through; sqlite/archive/url readers consume their own colon syntax.
 	return { kind: "none" };
@@ -653,9 +687,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			entityLabel: string;
 			ignoreResultLimits?: boolean;
 			raw?: boolean;
+			immutable?: boolean;
 		},
 	): AgentToolResult<ReadToolDetails> {
-		const displayMode = resolveFileDisplayMode(this.session, { raw: options.raw });
+		const displayMode = resolveFileDisplayMode(this.session, { raw: options.raw, immutable: options.immutable });
 		const details = options.details ?? {};
 		const allLines = text.split("\n");
 		const totalLines = allLines.length;
@@ -1139,6 +1174,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					details: { ...cached.details },
 					sourceUrl: cached.details.finalUrl,
 					entityLabel: "URL output",
+					immutable: true,
 				});
 			}
 			return executeReadUrl(this.session, { path: parsedUrlTarget.path, raw: parsedUrlTarget.raw }, signal);
@@ -1146,11 +1182,11 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 
 		// Handle internal URLs (agent://, artifact://, memory://, skill://, rule://, local://, mcp://)
 		const internalTarget = splitPathAndSel(readPath);
-		const internalRouter = this.session.internalRouter;
-		if (internalRouter?.canHandle(internalTarget.path)) {
+		const internalRouter = InternalUrlRouter.instance();
+		if (internalRouter.canHandle(internalTarget.path)) {
 			const parsed = parseSel(internalTarget.sel);
 			const { offset, limit } = selToOffsetLimit(parsed);
-			return this.#handleInternalUrl(internalTarget.path, offset, limit);
+			return this.#handleInternalUrl(internalTarget.path, offset, limit, { raw: isRawSelector(parsed) });
 		}
 
 		const archivePath = await this.#resolveArchiveReadPath(readPath, signal);
@@ -1164,7 +1200,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				limit,
 				{ ...archivePath, archiveSubPath: archiveSubPath.path },
 				signal,
-				{ raw: archiveParsed.kind === "raw" },
+				{ raw: isRawSelector(archiveParsed) },
 			);
 		}
 
@@ -1293,7 +1329,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					throw error;
 				}
 			}
-		} else if (isNotebookPath(absolutePath) && parsed.kind !== "raw") {
+		} else if (isNotebookPath(absolutePath) && !isRawSelector(parsed)) {
 			const { offset, limit } = selToOffsetLimit(parsed);
 			return this.#buildInMemoryTextResult(
 				await readEditableNotebookText(absolutePath, localReadPath),
@@ -1421,7 +1457,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					getFileReadCache(this.session).recordContiguous(absolutePath, startLineDisplay, collectedLines);
 				}
 
-				const isRawMode = parsed.kind === "raw";
+				const isRawMode = isRawSelector(parsed);
 				const shouldAddHashLines = !isRawMode && displayMode.hashLines;
 				const shouldAddLineNumbers = isRawMode ? false : shouldAddHashLines ? false : displayMode.lineNumbers;
 				let capturedDisplayContent: { text: string; startLine: number } | undefined;
@@ -1510,8 +1546,13 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	 * Handle internal URLs (agent://, artifact://, memory://, skill://, rule://, local://, mcp://).
 	 * Supports pagination via offset/limit but rejects them when query extraction is used.
 	 */
-	async #handleInternalUrl(url: string, offset?: number, limit?: number): Promise<AgentToolResult<ReadToolDetails>> {
-		const internalRouter = this.session.internalRouter!;
+	async #handleInternalUrl(
+		url: string,
+		offset?: number,
+		limit?: number,
+		options?: { raw?: boolean },
+	): Promise<AgentToolResult<ReadToolDetails>> {
+		const internalRouter = InternalUrlRouter.instance();
 
 		// Check if URL has query extraction (agent:// only).
 		// Use parseInternalUrl which handles colons in host (namespaced skills).
@@ -1550,6 +1591,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			sourceInternal: url,
 			entityLabel: "resource",
 			ignoreResultLimits: scheme === "skill",
+			immutable: resource.immutable,
+			raw: options?.raw,
 		});
 	}
 

package/src/tools/search.ts

@@ -8,6 +8,7 @@ import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { getFileReadCache } from "../edit/file-read-cache";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { InternalUrlRouter } from "../internal-urls";
 import type { Theme } from "../modes/theme/theme";
 import searchDescription from "../prompts/tools/search.md" with { type: "text" };
 import { DEFAULT_MAX_COLUMN, type TruncationResult, truncateHead } from "../session/streaming-output";
@@ -121,7 +122,6 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			const patternHasNewline = normalizedPattern.includes("\n") || normalizedPattern.includes("\\n");
 			const effectiveMultiline = patternHasNewline;
 
-			const useHashLines = resolveFileDisplayMode(this.session).hashLines;
 			const formatScopePath = (targetPath: string): string => formatPathRelativeToCwd(targetPath, this.session.cwd);
 			let searchPath: string;
 			let scopePath: string;
@@ -132,10 +132,14 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			if (rawPaths.some(rawPath => rawPath.length === 0)) {
 				throw new ToolError("`paths` must contain non-empty paths or globs");
 			}
-			const internalRouter = this.session.internalRouter;
+			const internalRouter = InternalUrlRouter.instance();
 			const resolvedPathInputs: string[] = [];
+			// Absolute filesystem paths whose source is immutable (e.g. artifact://,
+			// pi://, skill://). Hashline anchors are suppressed for these on a
+			// per-file basis, leaving editable mixed-in files untouched.
+			const immutableSourcePaths = new Set<string>();
 			for (const rawPath of rawPaths) {
-				if (!internalRouter?.canHandle(rawPath)) {
+				if (!internalRouter.canHandle(rawPath)) {
 					resolvedPathInputs.push(rawPath);
 					continue;
 				}
@@ -146,8 +150,13 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				if (!resource.sourcePath) {
 					throw new ToolError(`Cannot search internal URL without a backing file: ${rawPath}`);
 				}
+				if (resource.immutable) {
+					immutableSourcePaths.add(path.resolve(resource.sourcePath));
+				}
 				resolvedPathInputs.push(resource.sourcePath);
 			}
+			const baseDisplayMode = resolveFileDisplayMode(this.session);
+			const immutableDisplayMode = resolveFileDisplayMode(this.session, { immutable: true });
 			// Tolerate missing entries in a multi-path call: skip ones whose base
 			// directory is gone, and only error if every entry is missing. Single
 			// missing path keeps the original ENOENT semantics.
@@ -336,6 +345,10 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				const modelOut: string[] = [];
 				const displayOut: string[] = [];
 				const fileMatches = matchesByFile.get(relativePath) ?? [];
+				const absoluteFilePath = path.resolve(this.session.cwd, relativePath);
+				const useHashLines = immutableSourcePaths.has(absoluteFilePath)
+					? immutableDisplayMode.hashLines
+					: baseDisplayMode.hashLines;
 				const lineNumberWidth = fileMatches.reduce((width, match) => {
 					let nextWidth = Math.max(width, String(match.lineNumber).length);
 					for (const ctx of match.contextBefore ?? []) {

package/src/tools/todo-write.ts

@@ -631,7 +631,7 @@ function renderNoteAttachments(phases: TodoPhase[], uiTheme: Theme): string[] {
 		for (const task of phase.tasks) {
 			if (task.status !== "in_progress" || !task.notes || task.notes.length === 0) continue;
 			const bar = uiTheme.fg("dim", uiTheme.tree.vertical);
-			const title = uiTheme.fg("dim", chalk.italic(`\u00a7 notes \u2014 ${task.content}`));
+			const title = uiTheme.fg("dim", chalk.italic(`§ notes — ${task.content}`));
 			lines.push("");
 			lines.push(`  ${title}`);
 			for (let j = 0; j < task.notes.length; j++) {

package/src/utils/file-display-mode.ts

@@ -21,17 +21,23 @@ export interface FileDisplayModeSession {
 /**
  * Computes effective line display mode from session settings/env.
  * Hashline mode takes precedence and implies line-addressed output everywhere.
- * Hashlines are suppressed when the edit tool is not available (e.g. explore agents)
- * and when the caller signals a `raw` read — raw output should be returned as-is
- * without injecting hashline anchors or line numbers.
+ * Hashlines are suppressed when the edit tool is not available (e.g. explore agents),
+ * when the caller signals a `raw` read, and when the source is `immutable`
+ * (e.g. internal URLs like artifact://, agent://, memory:// — there is no edit
+ * path that could consume the anchors). Raw output is returned as-is.
  */
-export function resolveFileDisplayMode(session: FileDisplayModeSession, options?: { raw?: boolean }): FileDisplayMode {
+export function resolveFileDisplayMode(
+	session: FileDisplayModeSession,
+	options?: { raw?: boolean; immutable?: boolean },
+): FileDisplayMode {
 	const { settings } = session;
 	const hasEditTool = session.hasEditTool ?? true;
 	const editMode = resolveEditMode(session);
 	const usesHashLineAnchors = editMode === "hashline";
 	const raw = options?.raw === true;
-	const hashLines = !raw && hasEditTool && usesHashLineAnchors && settings.get("readHashLines") !== false;
+	const immutable = options?.immutable === true;
+	const hashLines =
+		!raw && !immutable && hasEditTool && usesHashLineAnchors && settings.get("readHashLines") !== false;
 	return {
 		hashLines,
 		lineNumbers: !raw && (hashLines || settings.get("readLineNumbers") === true),

package/src/web/scrapers/mastodon.ts

@@ -273,7 +273,7 @@ export const handleMastodon: SpecialHandler = async (
 						md += `### ${formatDate(status.created_at)}\n\n`;
 						const content = await htmlToBasicMarkdown(status.content);
 						md += `${content}\n\n`;
-						md += `\uD83D\uDCAC ${status.replies_count} \u00B7 \uD83D\uDD01 ${status.reblogs_count} \u00B7 \u2B50 ${status.favourites_count}\n\n`;
+						md += `💬 ${status.replies_count} · 🔁 ${status.reblogs_count} · ⭐ ${status.favourites_count}\n\n`;
 					}
 				}
 			}

package/src/web/scrapers/repology.ts

@@ -32,19 +32,19 @@ interface RepologyPackage {
 function statusIndicator(status: string): string {
 	switch (status) {
 		case "newest":
-			return "\u2705"; // green check
+			return "✅"; // green check
 		case "devel":
-			return "\uD83D\uDEA7"; // construction
+			return "🚧"; // construction
 		case "unique":
-			return "\uD83D\uDD35"; // blue circle
+			return "🔵"; // blue circle
 		case "outdated":
-			return "\uD83D\uDD34"; // red circle
+			return "🔴"; // red circle
 		case "legacy":
-			return "\u26A0\uFE0F"; // warning
+			return "⚠\uFE0F"; // warning
 		case "rolling":
-			return "\uD83D\uDD04"; // arrows
+			return "🔄"; // arrows
 		default:
-			return "\u2796"; // minus
+			return "➖"; // minus
 	}
 }
 

package/src/internal-urls/jobs-protocol.ts

@@ -1,119 +0,0 @@
-import type { AsyncJobManager } from "../async";
-import { formatDuration } from "../tools/render-utils";
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
-
-export interface JobsProtocolOptions {
-	getAsyncJobManager: () => AsyncJobManager | undefined;
-}
-
-function formatJobTime(startTime: number): string {
-	return new Date(startTime).toISOString();
-}
-
-function formatJobDuration(startTime: number): string {
-	return formatDuration(Math.max(0, Date.now() - startTime));
-}
-
-function normalizeJobId(url: InternalUrl): string {
-	const host = url.rawHost || url.hostname;
-	const pathname = (url.rawPathname ?? url.pathname).replace(/^\/+/, "").trim();
-	if (host && pathname) return `${host}/${pathname}`;
-	if (host) return host;
-	return pathname;
-}
-
-export class JobsProtocolHandler implements ProtocolHandler {
-	readonly scheme = "jobs";
-
-	constructor(private readonly options: JobsProtocolOptions) {}
-
-	async resolve(url: InternalUrl): Promise<InternalResource> {
-		const manager = this.options.getAsyncJobManager();
-		if (!manager) {
-			const content =
-				"# Jobs\n\nBackground job support is disabled. Enable `async.enabled` or `bash.autoBackground.enabled` to use jobs://.";
-			return {
-				url: url.href,
-				content,
-				contentType: "text/markdown",
-				size: Buffer.byteLength(content, "utf-8"),
-			};
-		}
-
-		const jobId = normalizeJobId(url);
-		if (!jobId) {
-			return this.#listJobs(url, manager);
-		}
-
-		return this.#getJob(url, manager, jobId);
-	}
-
-	#listJobs(url: InternalUrl, manager: AsyncJobManager): InternalResource {
-		const jobs = manager.getAllJobs();
-		const running = jobs.filter(job => job.status === "running").sort((a, b) => a.startTime - b.startTime);
-		const done = jobs.filter(job => job.status !== "running").sort((a, b) => b.startTime - a.startTime);
-		const ordered = [...running, ...done];
-
-		if (ordered.length === 0) {
-			const content = "# Jobs\n\nNo background jobs found.";
-			return {
-				url: url.href,
-				content,
-				contentType: "text/markdown",
-				size: Buffer.byteLength(content, "utf-8"),
-			};
-		}
-
-		const lines = ordered.map(job => {
-			return `- \`${job.id}\` [${job.type}] **${job.status}** — ${job.label}  \n  started: ${formatJobTime(job.startTime)} · duration: ${formatJobDuration(job.startTime)}`;
-		});
-		const content = `# Jobs\n\n${ordered.length} job${ordered.length === 1 ? "" : "s"}\n\n${lines.join("\n")}`;
-		return {
-			url: url.href,
-			content,
-			contentType: "text/markdown",
-			size: Buffer.byteLength(content, "utf-8"),
-		};
-	}
-
-	#getJob(url: InternalUrl, manager: AsyncJobManager, jobId: string): InternalResource {
-		const job = manager.getJob(jobId);
-		if (!job) {
-			const content = `# Job Not Found\n\n404: No async job found with id \`${jobId}\`.`;
-			return {
-				url: url.href,
-				content,
-				contentType: "text/markdown",
-				size: Buffer.byteLength(content, "utf-8"),
-			};
-		}
-
-		const sections = [
-			`# Job ${job.id}`,
-			"",
-			`- type: ${job.type}`,
-			`- status: ${job.status}`,
-			`- label: ${job.label}`,
-			`- start: ${formatJobTime(job.startTime)}`,
-			`- duration: ${formatJobDuration(job.startTime)}`,
-		];
-
-		if (job.status === "completed" && job.resultText) {
-			sections.push("", "## Result", "", "```", job.resultText, "```");
-		}
-		if (job.status === "failed" && job.errorText) {
-			sections.push("", "## Error", "", "```", job.errorText, "```");
-		}
-		if (job.status === "cancelled" && job.errorText) {
-			sections.push("", "## Cancellation", "", "```", job.errorText, "```");
-		}
-
-		const content = sections.join("\n");
-		return {
-			url: url.href,
-			content,
-			contentType: "text/markdown",
-			size: Buffer.byteLength(content, "utf-8"),
-		};
-	}
-}

package/src/task/template.ts

@@ -1,47 +0,0 @@
-import { prompt } from "@oh-my-pi/pi-utils";
-import subagentUserPromptTemplate from "../prompts/system/subagent-user-prompt.md" with { type: "text" };
-import { getTaskSimpleModeCapabilities, type TaskSimpleMode } from "./simple-mode";
-import type { TaskItem } from "./types";
-
-interface RenderResult {
-	/** Full task text sent to the subagent */
-	task: string;
-	/** Raw per-task assignment text, without prompt template boilerplate */
-	assignment: string;
-	id: string;
-	description: string;
-}
-
-/**
- * Build the full task text from shared context and per-task assignment.
- *
- * If context is provided, it is prepended with a separator.
- */
-export function renderTemplate(
-	context: string | undefined,
-	task: TaskItem,
-	simpleMode: TaskSimpleMode = "default",
-): RenderResult {
-	let { id, description, assignment } = task;
-	assignment = assignment.trim();
-	const { contextEnabled } = getTaskSimpleModeCapabilities(simpleMode);
-	context = contextEnabled ? context?.trim() : undefined;
-
-	if (!context || !assignment) {
-		if (simpleMode === "independent" && assignment) {
-			return {
-				task: prompt.render(subagentUserPromptTemplate, { assignment, independentMode: true }),
-				assignment,
-				id,
-				description,
-			};
-		}
-		return { task: assignment || context!, assignment: assignment || context!, id, description };
-	}
-	return {
-		task: prompt.render(subagentUserPromptTemplate, { context, assignment, independentMode: false }),
-		assignment,
-		id,
-		description,
-	};
-}

package/src/tools/bash-normalize.ts

@@ -1,107 +0,0 @@
-/**
- * Bash command normalizer - extracts patterns that are better handled natively.
- *
- * Detects and extracts:
- * - `| head -n N` / `| head -N` - extracted to headLines
- * - `| tail -n N` / `| tail -N` - extracted to tailLines
- */
-
-export interface NormalizedCommand {
-	/** Cleaned command with patterns stripped */
-	command: string;
-	/** Extracted head line count, if any */
-	headLines?: number;
-	/** Extracted tail line count, if any */
-	tailLines?: number;
-}
-
-/**
- * Pattern to match trailing pipe to head/tail.
- * Captures: full match, command (head/tail), line count
- *
- * Matches:
- * - `| head -n 50`
- * - `| head -50`
- * - `| tail -n 100`
- * - `| tail -100`
- *
- * Does NOT match head/tail with other flags or without line count.
- */
-const TRAILING_HEAD_TAIL_PATTERN = /\|\s*(head|tail)\s+(?:-n\s*(\d+)|(-\d+))\s*$/;
-
-/**
- * Normalize a bash command by stripping patterns better handled natively.
- *
- * Extracts `| head -n N` and `| tail -n N` suffixes into separate fields
- * so they can be applied post-execution without breaking streaming.
- *
- * Strips `2>&1` since we already merge stdout/stderr.
- */
-export function normalizeBashCommand(command: string): NormalizedCommand {
-	let normalized = command;
-	let headLines: number | undefined;
-	let tailLines: number | undefined;
-
-	// Extract trailing head/tail
-	const match = normalized.match(TRAILING_HEAD_TAIL_PATTERN);
-	if (match) {
-		const [fullMatch, cmd, nValue, dashValue] = match;
-		const lineCount = nValue ? Number.parseInt(nValue, 10) : Number.parseInt(dashValue.slice(1), 10);
-
-		if (cmd === "head") {
-			headLines = lineCount;
-		} else {
-			tailLines = lineCount;
-		}
-
-		normalized = normalized.slice(0, -fullMatch.length);
-	}
-
-	// Preserve internal whitespace (important for heredocs / indentation-sensitive scripts)
-	normalized = normalized.trim();
-
-	return {
-		command: normalized,
-		headLines,
-		tailLines,
-	};
-}
-
-/**
- * Apply head/tail limits to output text.
- *
- * If both head and tail are specified, head is applied first (take first N lines),
- * then tail is applied (take last M lines of that).
- */
-export function applyHeadTail(
-	text: string,
-	headLines?: number,
-	tailLines?: number,
-): { text: string; applied: boolean; headApplied?: number; tailApplied?: number } {
-	if (!headLines && !tailLines) {
-		return { text, applied: false };
-	}
-
-	let lines = text.split("\n");
-	let headApplied: number | undefined;
-	let tailApplied: number | undefined;
-
-	// Apply head first (keep first N lines)
-	if (headLines !== undefined && headLines > 0 && lines.length > headLines) {
-		lines = lines.slice(0, headLines);
-		headApplied = headLines;
-	}
-
-	// Then apply tail (keep last N lines)
-	if (tailLines !== undefined && tailLines > 0 && lines.length > tailLines) {
-		lines = lines.slice(-tailLines);
-		tailApplied = tailLines;
-	}
-
-	return {
-		text: lines.join("\n"),
-		applied: headApplied !== undefined || tailApplied !== undefined,
-		headApplied,
-		tailApplied,
-	};
-}