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

package/src/task/executor.ts

@@ -882,6 +882,7 @@ function createSubagentRunMonitor(args: RunMonitorArgs): SubagentRunMonitor {
 	const finalOutputChunks: string[] = [];
 	const RECENT_OUTPUT_TAIL_BYTES = 8 * 1024;
 	let recentOutputTail = "";
+	let tailLastLineRepresentable = false;
 	let resolved = false;
 	let abortSent = false;
 	let abortReason: AbortReason | undefined;
@@ -1060,17 +1061,35 @@ function createSubagentRunMonitor(args: RunMonitorArgs): SubagentRunMonitor {
 	};
 
 	const updateRecentOutputLines = () => {
-		const lines = recentOutputTail.split("\n").filter(line => line.trim());
-		progress.recentOutput = lines.slice(-8).reverse();
+		const lines = recentOutputTail.split("\n");
+		const filtered = lines.filter(line => line.trim());
+		progress.recentOutput = filtered.slice(-8).reverse();
+		// The tail's last raw segment (after its final newline) is "represented"
+		// in recentOutput only when it trims non-empty — an empty/whitespace-only
+		// trailing segment is filtered out, so recentOutput[0] is then the line
+		// before it, not the tail's true last line.
+		tailLastLineRepresentable = lines[lines.length - 1].trim().length > 0;
 	};
 
 	const appendRecentOutputTail = (text: string) => {
 		if (!text) return;
 		recentOutputTail += text;
-		if (recentOutputTail.length > RECENT_OUTPUT_TAIL_BYTES) {
+		const truncated = recentOutputTail.length > RECENT_OUTPUT_TAIL_BYTES;
+		if (truncated) {
 			recentOutputTail = recentOutputTail.slice(-RECENT_OUTPUT_TAIL_BYTES);
 		}
-		updateRecentOutputLines();
+		// Fast path: a token without a newline only extends the current last line.
+		// This runs on every text_delta token (hundreds/thousands per second while
+		// streaming), so skip re-splitting the whole (up to 8KB) tail unless the line
+		// structure actually changed. Requires no truncation AND the tail's last line
+		// already represented (trims non-empty) — otherwise boundaries shift and a
+		// full recompute is required. Appending to a non-empty line keeps it non-empty,
+		// so the flag stays valid across consecutive fast-path tokens.
+		if (truncated || text.includes("\n") || !tailLastLineRepresentable || progress.recentOutput.length === 0) {
+			updateRecentOutputLines();
+		} else {
+			progress.recentOutput = [progress.recentOutput[0] + text, ...progress.recentOutput.slice(1)];
+		}
 	};
 
 	const replaceRecentOutputFromContent = (content: unknown[]) => {
@@ -1090,6 +1109,7 @@ function createSubagentRunMonitor(args: RunMonitorArgs): SubagentRunMonitor {
 
 	const resetRecentOutput = () => {
 		recentOutputTail = "";
+		tailLastLineRepresentable = false;
 		progress.recentOutput = [];
 	};
 

package/src/task/render.ts

@@ -151,9 +151,9 @@ function normalizeReportFindings(value: unknown): ReportFindingDetails[] {
 const REVIEWER_ARRAY_LABELS: ReadonlySet<string> = new Set(["findings"]);
 
 function extractIncrementalReviewResult(
-	value: unknown,
+	items: RenderYieldItem[],
 ): { summary: SubmitReviewDetails; findings: ReportFindingDetails[] } | undefined {
-	const yieldItems: YieldItem[] = normalizeYieldData(value).map(item => ({
+	const yieldItems: YieldItem[] = items.map(item => ({
 		data: item.data,
 		type: item.type,
 		status: item.status === "aborted" ? "aborted" : item.status === "success" ? "success" : undefined,
@@ -962,7 +962,7 @@ function renderAgentProgress(
 		// yield sections. Fall back to the legacy `report_finding` side-channel.
 		if (progress.status === "completed") {
 			const completeData = normalizeYieldData(progress.extractedToolData.yield);
-			const incrementalReview = extractIncrementalReviewResult(progress.extractedToolData.yield);
+			const incrementalReview = extractIncrementalReviewResult(completeData);
 			const reportFindingData = normalizeReportFindings(progress.extractedToolData.report_finding);
 			if (incrementalReview) {
 				lines.push(
@@ -1253,7 +1253,7 @@ function renderAgentResult(
 	// is not a function` when the slot is a plain object (see issue #1987).
 	const completeData = normalizeYieldData(result.extractedToolData?.yield);
 	const reportFindingData = normalizeReportFindings(result.extractedToolData?.report_finding);
-	const incrementalReview = extractIncrementalReviewResult(result.extractedToolData?.yield);
+	const incrementalReview = extractIncrementalReviewResult(completeData);
 
 	if (incrementalReview) {
 		lines.push(
@@ -1491,9 +1491,27 @@ export function renderResult(
 	}
 
 	const hasResults = Boolean(details.results && details.results.length > 0);
-	const aborted = hasResults && details.results.some(r => r.aborted);
-	const failed = hasResults && details.results.some(r => !r.aborted && r.exitCode !== 0);
-	const mergeFailed = hasResults && details.results.some(r => !r.aborted && r.exitCode === 0 && Boolean(r.error));
+	// Single pass over details.results derives the header booleans AND the footer
+	// counts/totals. This block re-runs ~30×/sec via the 33ms spinner render; the
+	// previous form did 3× `.some()` here plus 3× `.filter()` + `.reduce()` again
+	// inside the frame below (7+ full passes per tick).
+	let abortedCount = 0;
+	let failCount = 0;
+	let mergeFailedCount = 0;
+	let successCount = 0;
+	let requestTotal = 0;
+	if (hasResults) {
+		for (const r of details.results) {
+			requestTotal += r.requests ?? 0;
+			if (r.aborted) abortedCount++;
+			else if (r.exitCode !== 0) failCount++;
+			else if (r.error) mergeFailedCount++;
+			else successCount++;
+		}
+	}
+	const aborted = abortedCount > 0;
+	const failed = failCount > 0;
+	const mergeFailed = mergeFailedCount > 0;
 	const isError = aborted || failed;
 	const agentCount = hasResults ? details.results.length : (details.progress?.length ?? 0);
 	const icon: ToolUIStatus = options.isPartial ? "running" : isError ? "error" : mergeFailed ? "warning" : "success";
@@ -1552,16 +1570,12 @@ export function renderResult(
 				);
 			}
 
-			const abortedCount = details.results.filter(r => r.aborted).length;
-			const mergeFailedCount = details.results.filter(r => !r.aborted && r.exitCode === 0 && r.error).length;
-			const successCount = details.results.filter(r => !r.aborted && r.exitCode === 0 && !r.error).length;
-			const failCount = details.results.length - successCount - mergeFailedCount - abortedCount;
 			const summaryParts: string[] = [];
 			if (abortedCount > 0) summaryParts.push(theme.fg("error", `${abortedCount} aborted`));
 			if (successCount > 0) summaryParts.push(theme.fg("success", `${successCount} succeeded`));
 			if (mergeFailedCount > 0) summaryParts.push(theme.fg("warning", `${mergeFailedCount} merge failed`));
 			if (failCount > 0) summaryParts.push(theme.fg("error", `${failCount} failed`));
-			const totalRequests = details.results.reduce((sum, r) => sum + (r.requests ?? 0), 0);
+			const totalRequests = requestTotal;
 			if (totalRequests > 0) summaryParts.push(theme.fg("dim", `${formatNumber(totalRequests)} req`));
 			summaryParts.push(theme.fg("dim", formatDuration(details.totalDurationMs)));
 			// Wrap the run summary in the theme's bracket glyphs (dim chrome, colored

package/src/task/renderer.ts

@@ -11,4 +11,5 @@ export const taskToolRenderer = {
 	renderCall,
 	renderResult,
 	mergeCallAndResult: true,
+	animatedPartialResult: true,
 } as const;

package/src/task/worktree.ts

@@ -481,41 +481,148 @@ function baselineHasRootWip(baseline: RepoBaseline): boolean {
 	return !!(baseline.staged.trim() || baseline.unstaged.trim() || baseline.untrackedPatch.trim());
 }
 
+/**
+ * Baseline WIP context needed to safely apply a delta patch whose hunks were
+ * captured against `HEAD + WIP` (see {@link captureRepoDeltaPatch}). Passed
+ * whenever {@link baselineHasRootWip} is true so
+ * {@link commitPatchToBranchWorktree} can replay the WIP into the temp
+ * worktree first, then rewind WIP-only files after applying the delta.
+ */
+interface BaselineWipContext {
+	readonly staged: string;
+	readonly unstaged: string;
+	readonly untrackedPatch: string;
+	/** Untracked file paths present in the baseline (never in HEAD). */
+	readonly untracked: readonly string[];
+}
+
+function collectWipPatches(wip: BaselineWipContext | undefined): string[] {
+	if (!wip) return [];
+	return [wip.staged, wip.unstaged, wip.untrackedPatch].filter(p => p.trim());
+}
+
 async function commitPatchToBranchWorktree(
 	tmpDir: string,
 	taskId: string,
 	patchText: string,
 	message: string,
 	author?: git.CommitAuthor,
+	baselineWip?: BaselineWipContext,
 ): Promise<void> {
+	// Try the two clean paths first — they yield an agent-only commit and are
+	// the happy case when the temp worktree can resolve the patch against
+	// HEAD directly:
+	//
+	//   1. Plain apply — works when WIP context happens to match HEAD (e.g.
+	//      WIP-touched files that the delta patch doesn't reference).
+	//   2. `--3way`   — works when the WIP-side blob is tracked in HEAD and
+	//      lives in the shared ODB (captureDeltaPatch seeded it while writing
+	//      the synthetic baseline tree). The 3-way merge subtracts WIP,
+	//      producing an agent-only commit even when WIP and agent modify the
+	//      same tracked file at unrelated lines.
+	//
+	// If both fail (untracked WIP files, staged-new WIP files, or overlap that
+	// --3way can't resolve — see #4136), replay the WIP into the worktree
+	// first so the delta's context lines match, then rewind WIP-only files so
+	// they don't leak into the commit. Files touched by BOTH WIP and delta
+	// keep their combined state; the parent's stash-pop reconciles the WIP
+	// side via 3-way merge on merge-back.
+	let plainErr: git.GitCommandError | undefined;
 	try {
 		await git.patch.applyText(tmpDir, patchText);
 	} catch (err) {
 		if (!(err instanceof git.GitCommandError)) throw err;
-		// Plain apply rejects when the parent checkout carries unrelated dirty
-		// context near the task's edits; retry with --3way before giving up.
+		plainErr = err;
+	}
+	if (plainErr) {
+		let threeWayErr: git.GitCommandError | undefined;
 		try {
 			await git.patch.applyText(tmpDir, patchText, { threeWay: true });
-		} catch (threeWayErr) {
-			if (threeWayErr instanceof git.GitCommandError) {
+		} catch (err) {
+			if (!(err instanceof git.GitCommandError)) throw err;
+			threeWayErr = err;
+		}
+		if (threeWayErr) {
+			const wipPatches = collectWipPatches(baselineWip);
+			if (wipPatches.length === 0 || !baselineWip) {
 				const stderr = threeWayErr.result.stderr.slice(0, 2000);
 				logger.error("commitToBranch: git apply --3way failed", {
 					taskId,
 					exitCode: threeWayErr.result.exitCode,
 					stderr,
-					initialStderr: err.result.stderr.slice(0, 2000),
+					initialStderr: plainErr.result.stderr.slice(0, 2000),
 					patchSize: patchText.length,
 					patchHead: patchText.slice(0, 500),
 				});
 				throw new Error(`git apply --3way failed for task ${taskId}: ${stderr}`);
 			}
-			throw threeWayErr;
+			try {
+				// `git apply --3way` leaves conflict markers in `U` files when
+				// it can't resolve; reset the worktree so the WIP-seeded retry
+				// starts from a clean HEAD tree.
+				await git.reset(tmpDir, { hard: true, target: "HEAD" });
+				await applyDeltaOverBaselineWip(tmpDir, taskId, patchText, wipPatches, baselineWip);
+			} catch (wipErr) {
+				if (!(wipErr instanceof git.GitCommandError)) throw wipErr;
+				const stderr = wipErr.result.stderr.slice(0, 2000);
+				logger.error("commitToBranch: git apply with baseline WIP failed", {
+					taskId,
+					exitCode: wipErr.result.exitCode,
+					stderr,
+					threeWayStderr: threeWayErr.result.stderr.slice(0, 2000),
+					initialStderr: plainErr.result.stderr.slice(0, 2000),
+					patchSize: patchText.length,
+					patchHead: patchText.slice(0, 500),
+				});
+				throw new Error(`git apply with baseline WIP failed for task ${taskId}: ${stderr}`);
+			}
 		}
 	}
+
 	await git.stage.files(tmpDir);
 	await git.commit(tmpDir, message, author ? { author } : {});
 }
 
+/**
+ * Replay baseline WIP into the temp worktree so the delta patch's HEAD+WIP
+ * context matches, apply the delta, then rewind files WIP touched but the
+ * delta didn't — HEAD-tracked files are restored via `git restore`, untracked
+ * or staged-new WIP files are removed from the worktree. The commit that
+ * follows reflects agent's delta plus any overlap with WIP; parent's
+ * stash-pop reconciles the WIP side on merge-back.
+ */
+async function applyDeltaOverBaselineWip(
+	tmpDir: string,
+	_taskId: string,
+	patchText: string,
+	wipPatches: readonly string[],
+	baselineWip: BaselineWipContext,
+): Promise<void> {
+	for (const wip of wipPatches) {
+		await git.patch.applyText(tmpDir, wip);
+	}
+	await git.patch.applyText(tmpDir, patchText);
+
+	const wipFiles = new Set(wipPatches.flatMap(patchTouchedFiles));
+	const deltaFiles = new Set(patchTouchedFiles(patchText));
+	const wipOnly = [...wipFiles].filter(f => !deltaFiles.has(f));
+	if (wipOnly.length === 0) return;
+
+	// Any wipOnly file baselined as untracked cannot be in HEAD.
+	// Everything else may or may not — verify against HEAD's tree.
+	const untrackedSet = new Set(baselineWip.untracked);
+	const candidates = wipOnly.filter(f => !untrackedSet.has(f));
+	const inHead = candidates.length > 0 ? new Set(await git.ls.tree(tmpDir, "HEAD", candidates)) : new Set<string>();
+	const toRestore = candidates.filter(f => inHead.has(f));
+	const toRemove = wipOnly.filter(f => !toRestore.includes(f));
+	if (toRestore.length > 0) {
+		await git.restore(tmpDir, { source: "HEAD", staged: true, worktree: true, files: toRestore });
+	}
+	for (const rel of toRemove) {
+		await fs.rm(path.join(tmpDir, rel), { force: true });
+	}
+}
+
 interface FilteredAgentReplayOptions {
 	baseline: WorktreeBaseline;
 	branchName: string;
@@ -542,6 +649,7 @@ async function replayFilteredAgentCommits(opts: FilteredAgentReplayOptions): Pro
 			opts.baseline.root.untrackedPatch,
 		]);
 		let previousFilteredTree = baselineSha;
+		let filteredCommitsApplied = 0;
 
 		for (const commitSha of agentCommits) {
 			const taskStatePatch = await git.diff.tree(opts.isolationDir, dirtyBaselineTree, `${commitSha}^{tree}`, {
@@ -562,18 +670,37 @@ async function replayFilteredAgentCommits(opts: FilteredAgentReplayOptions): Pro
 					details.message || commitSha,
 					details.author,
 				);
+				filteredCommitsApplied++;
 			}
 			previousFilteredTree = currentFilteredTree;
 		}
-
-		const finalFilteredTree = await writeSyntheticTree(opts.repoRoot, baselineSha, [opts.rootPatch]);
-		const leftoverPatch = await git.diff.tree(opts.repoRoot, previousFilteredTree, finalFilteredTree, {
-			allowFailure: true,
-			binary: true,
-		});
-		if (leftoverPatch.trim()) {
-			const msg = (opts.commitMessage && (await opts.commitMessage(leftoverPatch))) || opts.fallbackMessage;
-			await commitPatchToBranchWorktree(tmpDir, opts.taskId, leftoverPatch, msg);
+		if (filteredCommitsApplied === 0) {
+			// No filtered commit landed — tmpDir is still pinned at baselineSha.
+			// The `finalFilteredTree = writeSyntheticTree(HEAD, [rootPatch])`
+			// path here fails hard whenever rootPatch's WIP-context can't be
+			// applied to a HEAD-only index (untracked WIP + agent modifies,
+			// staged-new WIP + agent modifies — see #4136). Bypass the synthesis
+			// entirely and collapse the isolation output onto a single commit
+			// with WIP seed, matching the no-agent-commit path in commitToBranch.
+			// This also handles the "agent committed only baseline WIP" corner
+			// case where every filtered patch collapsed to empty.
+			if (opts.rootPatch.trim()) {
+				const msg = (opts.commitMessage && (await opts.commitMessage(opts.rootPatch))) || opts.fallbackMessage;
+				await commitPatchToBranchWorktree(tmpDir, opts.taskId, opts.rootPatch, msg, undefined, opts.baseline.root);
+			}
+		} else {
+			// A filtered commit landed; tmpDir has advanced past baselineSha and
+			// previousFilteredTree is HEAD-derived, so writeSyntheticTree +
+			// leftoverPatch stay HEAD-based and no WIP seed is needed.
+			const finalFilteredTree = await writeSyntheticTree(opts.repoRoot, baselineSha, [opts.rootPatch]);
+			const leftoverPatch = await git.diff.tree(opts.repoRoot, previousFilteredTree, finalFilteredTree, {
+				allowFailure: true,
+				binary: true,
+			});
+			if (leftoverPatch.trim()) {
+				const msg = (opts.commitMessage && (await opts.commitMessage(leftoverPatch))) || opts.fallbackMessage;
+				await commitPatchToBranchWorktree(tmpDir, opts.taskId, leftoverPatch, msg);
+			}
 		}
 	} finally {
 		await git.worktree.tryRemove(opts.repoRoot, tmpDir);
@@ -674,7 +801,8 @@ export async function commitToBranch(
 			await git.worktree.add(repoRoot, tmpDir, branchName);
 
 			const msg = (commitMessage && (await commitMessage(rootPatch))) || fallbackMessage;
-			await commitPatchToBranchWorktree(tmpDir, taskId, rootPatch, msg);
+			const wip = baselineHasRootWip(baseline.root) ? baseline.root : undefined;
+			await commitPatchToBranchWorktree(tmpDir, taskId, rootPatch, msg, undefined, wip);
 		} finally {
 			await git.worktree.tryRemove(repoRoot, tmpDir);
 			await fs.rm(tmpDir, { recursive: true, force: true });

package/src/tiny/text.ts

@@ -152,6 +152,34 @@ const FILLER_TITLE_TOKENS = new Set<string>([
 ]);
 
 const TITLE_WORD = /[\p{L}\p{N}]+/gu;
+const COMMON_TITLE_ACRONYMS = new Set<string>([
+	"API",
+	"CLI",
+	"CPU",
+	"CRUD",
+	"CSS",
+	"DNS",
+	"ETL",
+	"GPU",
+	"HTML",
+	"HTTP",
+	"HTTPS",
+	"ID",
+	"JSON",
+	"LLM",
+	"REST",
+	"SDK",
+	"SSH",
+	"TCP",
+	"TLS",
+	"TUI",
+	"UI",
+	"URI",
+	"URL",
+	"UX",
+	"XML",
+	"YAML",
+]);
 
 /**
  * True when a first user message is too low-signal to title (greeting, ack,
@@ -191,51 +219,115 @@ export function normalizeGeneratedTitle(value: string | null | undefined, source
  * Reconcile a generated title's casing against the user's own message.
  *
  * The title prompt asks for sentence case, but small title models still mangle
- * casing two ways: they sprout stray interior capitals on ordinary words
- * (`daemon` → `dAemon`) and they flatten proper nouns the user cares about
- * (`TinyVMM` → `tinyvmm`). The user's message is the source of truth, so per
- * title token:
+ * casing three ways: they sprout stray interior capitals on ordinary words
+ * (`daemon` → `dAemon`), they flatten proper nouns the user cased distinctively
+ * (`TinyVMM` → `tinyvmm`), and they title-case ALL-CAPS acronyms as if they
+ * were sentence words (`CNPG` → `Cnpg`). The user's message is the source of
+ * truth, so per title token:
  *  1. typed verbatim in the message → keep it (the user established the casing);
  *  2. else the message has the same word with *distinctive* mixed casing
  *     (`TinyVMM`, `iOS`, `IDs`) → adopt the user's casing (restoration);
- *  3. else it's a camelCase artifact (lowercase word + stray interior capital,
+ *  3. else the model produced a plain title-cased artifact (`Cnpg`) whose
+ *     lowercased form is a likely ALL-CAPS acronym in a non-shouty source
+ *     (`CNPG`, `API`, `ETL`) → restore the source acronym;
+ *  4. else it's a camelCase artifact (lowercase word + stray interior capital,
  *     `dAemon`) the user never wrote → lowercase it;
- *  4. else leave it — preserves model-cased proper nouns like `GitHub`, `OAuth`.
+ *  5. else leave it — preserves model-cased proper nouns like `GitHub`, `OAuth`.
  *
- * Restoration is limited to distinctively *mixed*-cased source tokens: a sentence
- * that merely *starts* with `For` can't force a mid-title `for` to `For`, and
- * emphatic all-caps (`ALL ERROR HANDLING`) is never re-shouted over sentence case.
+ * Restoration is limited to avoid three failure modes: a sentence that merely
+ * *starts* with `For` can't force a mid-title `for` to `For` (distinctive
+ * requires interior mixed casing); emphatic all-caps input (`ALL ERROR
+ * HANDLING`, `FIX the BUG NOW`) is never re-shouted — see {@link isShoutySource};
+ * and ordinary all-caps English words (`FIX`, `WORK`, `BUG`) are not treated as
+ * restorable acronyms unless they carry a stronger acronym signal.
  */
 function reconcileTitleCasing(title: string, sourceText: string): string {
 	const verbatim = new Set<string>();
 	const distinctive = new Map<string, string>();
+	const acronyms = new Map<string, string>();
+	const shouty = isShoutySource(sourceText);
 	for (const [token] of sourceText.matchAll(TITLE_WORD)) {
 		verbatim.add(token);
 		if (isDistinctiveCasing(token)) {
 			const lower = token.toLowerCase();
 			if (!distinctive.has(lower)) distinctive.set(lower, token);
+		} else if (!shouty && isAllCapsAcronym(token)) {
+			const lower = token.toLowerCase();
+			if (!acronyms.has(lower)) acronyms.set(lower, token);
 		}
 	}
 	return title.replace(TITLE_WORD, token => {
 		if (verbatim.has(token)) return token;
-		const restored = distinctive.get(token.toLowerCase());
+		const lower = token.toLowerCase();
+		const restored = distinctive.get(lower);
 		if (restored) return restored;
-		return isCamelArtifact(token) ? token.toLowerCase() : token;
+		if (isTitleCasedArtifact(token)) {
+			const acronym = acronyms.get(lower);
+			if (acronym) return acronym;
+		}
+		return isCamelArtifact(token) ? lower : token;
 	});
 }
 
 /** Mixed-case identifier the user cased deliberately (`TinyVMM`, `iOS`, `IDs`):
  *  an interior/repeated capital plus at least one lowercase letter. Only these
- *  are restored when the model flattens them.
- *
- *  Pure all-caps is intentionally excluded. The model preserves its own acronyms
- *  verbatim regardless, so restoring all-caps from the source would only ever
- *  re-shout emphatic input (`ALL ERROR HANDLING`, `FIX THE BUG`) over the
- *  sentence case the prompt asks for. */
+ *  are restored when the model flattens them. */
 function isDistinctiveCasing(token: string): boolean {
 	return /\p{Ll}/u.test(token) && /\p{L}\p{Lu}/u.test(token);
 }
 
+/** Multi-letter ALL-CAPS source token with a stronger acronym signal than a
+ *  plain emphasized word. Consonant-only tokens (`CNPG`, `SQL`, `JWT`) are
+ *  restored, digit-bearing identifiers are restored, and common technical
+ *  acronyms (`API`, `JSON`, `URL`) are allowlisted. Ordinary emphasized words
+ *  (`FIX`, `WORK`, `BUG`) contain vowels and are not restored from source. */
+function isAllCapsAcronym(token: string): boolean {
+	if (!isAllCapsWord(token)) return false;
+	const upper = token.toUpperCase();
+	if (COMMON_TITLE_ACRONYMS.has(upper)) return true;
+	if (/\p{N}/u.test(token)) return true;
+	return !/[AEIOU]/.test(upper);
+}
+
+/** Multi-letter ALL-CAPS word in the source. Used for shout detection, not for
+ *  acronym restoration — shouted English words (`FIX`, `WORK`) still count as
+ *  shouty even though they are not restorable acronyms. Requires an actual
+ *  uppercase letter so caseless scripts (CJK) never register as shouting and
+ *  disable acronym restoration for those messages. */
+function isAllCapsWord(token: string): boolean {
+	const letters = token.match(/\p{L}/gu);
+	if (!letters || letters.length < 2) return false;
+	return /\p{Lu}/u.test(token) && !/\p{Ll}/u.test(token);
+}
+
+/** Plain title-cased word (`Cnpg`, `Etl`): starts uppercase, has one-or-more
+ *  lowercase letters, no interior uppercase. This is the artifact a title model
+ *  produces when it sentence-cases an unfamiliar ALL-CAPS acronym; PascalCase
+ *  proper nouns like `GitHub`/`OAuth` have an interior capital and are
+ *  excluded so we don't misidentify them. */
+function isTitleCasedArtifact(token: string): boolean {
+	if (!/^\p{Lu}/u.test(token)) return false;
+	if (!/\p{Ll}/u.test(token)) return false;
+	return !/\p{Lu}/u.test(token.slice(1));
+}
+
+/** True when the source text is shouting — ≥2 consecutive multi-letter
+ *  ALL-CAPS tokens (`FIX the BUG NOW` has `BUG NOW`; `ALL ERROR HANDLING`
+ *  has all three adjacent). Acronym restoration is disabled for shouty input
+ *  so we don't re-shout emphatic prose the model correctly de-shouted. */
+function isShoutySource(sourceText: string): boolean {
+	let run = 0;
+	for (const [token] of sourceText.matchAll(TITLE_WORD)) {
+		if (isAllCapsWord(token)) {
+			run += 1;
+			if (run >= 2) return true;
+		} else {
+			run = 0;
+		}
+	}
+	return false;
+}
+
 /** A lowercase word carrying a stray interior capital (`dAemon`, `cReate`): the
  *  model-mangled shape we flatten when the user never wrote it. PascalCase proper
  *  nouns (`GitHub`, `OAuth`) start uppercase and are left untouched. */

package/src/tools/ast-grep.ts

@@ -19,7 +19,7 @@ import { createFileRecorder, formatResultPath } from "./file-recorder";
 import { classifyGroupedLines, formatGroupedFiles, groupLineIndicesByBlank } from "./grouped-file-output";
 import { formatMatchLine } from "./match-line-format";
 import type { OutputMeta } from "./output-meta";
-import { resolveToolSearchScope } from "./path-utils";
+import { resolveToolSearchScope, toPathList } from "./path-utils";
 import {
 	appendParseErrorsBulletList,
 	capParseErrors,
@@ -37,11 +37,9 @@ import { toolResult } from "./tool-result";
 
 const astGrepSchema = type({
 	pat: type("string").describe("ast pattern"),
-	paths: type("string")
-		.describe("file, directory, glob, or internal URL to search")
-		.array()
-		.atLeastLength(1)
-		.describe("files, directories, globs, or internal URLs to search"),
+	"path?": type("string").describe(
+		'file, directory, glob, or internal URL to search; pass several as a semicolon-delimited list ("src; tests"). Omitted -> searches the workspace root (".")',
+	),
 	"skip?": type("number").describe("matches to skip"),
 });
 
@@ -159,23 +157,23 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 	readonly examples: readonly ToolExample<typeof astGrepSchema.inferIn>[] = [
 		{
 			caption: "Search TypeScript files under src",
-			call: { pat: "console.log($$$)", paths: ["src/**/*.ts"] },
+			call: { pat: "console.log($$$)", path: "src/**/*.ts" },
 		},
 		{
 			caption: "Named imports from a specific package",
-			call: { pat: 'import { $$$IMPORTS } from "react"', paths: ["src/**/*.ts"] },
+			call: { pat: 'import { $$$IMPORTS } from "react"', path: "src/**/*.ts" },
 		},
 		{
 			caption: "Arrow functions assigned to a const",
-			call: { pat: "const $NAME = ($$$ARGS) => $BODY", paths: ["src/utils/**/*.ts"] },
+			call: { pat: "const $NAME = ($$$ARGS) => $BODY", path: "src/utils/**/*.ts" },
 		},
 		{
 			caption: "Method call on any object, ignoring method name with `$_`",
-			call: { pat: "logger.$_($$$ARGS)", paths: ["src/**/*.ts"] },
+			call: { pat: "logger.$_($$$ARGS)", path: "src/**/*.ts" },
 		},
 		{
 			caption: "Loosest existence check for a symbol in one file",
-			call: { pat: "processItems", paths: ["src/worker.ts"] },
+			call: { pat: "processItems", path: "src/worker.ts" },
 		},
 	];
 	readonly loadMode = "discoverable";
@@ -201,8 +199,10 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 			if (!Number.isFinite(skip) || skip < 0) {
 				throw new ToolError("skip must be a non-negative number");
 			}
+			const scopedPaths = toPathList(params.path);
+			const rawPaths = scopedPaths.length > 0 ? scopedPaths : ["."];
 			const scope = await resolveToolSearchScope({
-				rawPaths: params.paths,
+				rawPaths,
 				cwd: this.session.cwd,
 				internalUrlAction: "search",
 				settings: this.session.settings,
@@ -275,7 +275,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 
 			if (result.matches.length === 0) {
 				const noMatchMessage = cappedParseErrors.length
-					? "No matches found. Parse issues mean the query may be mis-scoped; narrow `paths` before concluding absence."
+					? "No matches found. Parse issues mean the query may be mis-scoped; narrow `path` before concluding absence."
 					: "No matches found";
 				const parseMessage = cappedParseErrors.length
 					? `\n${formatParseErrors(cappedParseErrors, parseErrorsTotal).join("\n")}`
@@ -375,7 +375,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 				displayContent: displayLines.join("\n"),
 			};
 			if (result.limitReached) {
-				outputLines.push("", "Result limit reached; narrow paths or increase limit.");
+				outputLines.push("", "Result limit reached; narrow path or increase limit.");
 			}
 			if (cappedParseErrors.length) {
 				outputLines.push("", ...formatParseErrors(cappedParseErrors, parseErrorsTotal));
@@ -392,6 +392,8 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 
 interface AstGrepRenderArgs {
 	pat?: string;
+	path?: string | string[];
+	/** Legacy pre-`path` argument name; kept so historical transcripts still render a scope. */
 	paths?: string[];
 	skip?: number;
 }
@@ -402,7 +404,8 @@ export const astGrepToolRenderer = {
 	inline: true,
 	renderCall(args: AstGrepRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const meta: string[] = [];
-		if (args.paths?.length) meta.push(`in ${args.paths.join(", ")}`);
+		const scopePaths = toPathList(args.path ?? args.paths);
+		if (scopePaths.length) meta.push(`in ${scopePaths.join(", ")}`);
 		if (args.skip !== undefined && args.skip > 0) meta.push(`skip:${args.skip}`);
 
 		const description = args.pat ?? "?";
@@ -436,7 +439,7 @@ export const astGrepToolRenderer = {
 			const header = renderStatusLine({ icon: "warning", title: "AST Grep", description, meta }, uiTheme);
 			const lines = [header, formatEmptyMessage("No matches found", uiTheme)];
 			if (details?.parseErrors?.length) {
-				lines.push(uiTheme.fg("warning", "Query may be mis-scoped; narrow `paths` before concluding absence"));
+				lines.push(uiTheme.fg("warning", "Query may be mis-scoped; narrow `path` before concluding absence"));
 				appendParseErrorsBulletList(lines, details.parseErrors, uiTheme, details.parseErrorsTotal);
 			}
 			return new Text(lines.join("\n"), 0, 0);
@@ -487,7 +490,7 @@ export const astGrepToolRenderer = {
 
 		const extraLines: string[] = [];
 		if (limitReached) {
-			extraLines.push(uiTheme.fg("warning", "limit reached; narrow paths or increase limit"));
+			extraLines.push(uiTheme.fg("warning", "limit reached; narrow path or increase limit"));
 		}
 		if (details?.parseErrors?.length) {
 			extraLines.push(