@oh-my-pi/pi-coding-agent 15.11.2 → 15.11.3

package/dist/types/lsp/format-options.d.ts

@@ -0,0 +1,32 @@
+/** Subset of the LSP `FormattingOptions` we send. */
+export interface LspFormattingOptions {
+    tabSize: number;
+    insertSpaces: boolean;
+    trimTrailingWhitespace: boolean;
+    insertFinalNewline: boolean;
+    trimFinalNewlines: boolean;
+}
+interface DetectedIndent {
+    tabSize?: number;
+    insertSpaces?: boolean;
+}
+/**
+ * Sniff `insertSpaces` and the indent unit from `content`.
+ *
+ * Walks the buffer once: the first indented line decides spaces vs tabs; for
+ * space indents, the GCD of all space-indent widths gives the stride (so a
+ * 2/4/6 file reports `2`, a 4/8 file reports `4`). Returns `undefined` for any
+ * field the content does not pin so a higher-precedence override (editorconfig)
+ * can win without being overwritten by sniffing noise.
+ */
+export declare function detectIndentFromContent(content: string): DetectedIndent;
+/**
+ * Resolve the `FormattingOptions` payload for a `textDocument/formatting` request
+ * targeting `filePath` with `content`.
+ *
+ * The two fields that actually affect on-disk bytes (`tabSize`, `insertSpaces`)
+ * are layered: editorconfig wins, then content sniffing, then the fallback.
+ * Trim/final-newline flags are static.
+ */
+export declare function resolveFormatOptions(filePath: string, content: string): LspFormattingOptions;
+export {};

package/dist/types/mnemopi/state.d.ts

@@ -75,7 +75,35 @@ export declare class MnemopiSessionState {
     }>, sourceId: string): Promise<void>;
     attachSessionListeners(): void;
     maybeRecallOnAgentStart(): Promise<void>;
-    dispose(): void;
+    /**
+     * Drain in-flight fact extraction and run beam consolidation on every owned
+     * bank, after capturing the current transcript. Mirrors the manual
+     * `/memory enqueue` slash command, but stops short of closing the DBs so
+     * callers can keep using the state. {@link dispose} composes this with the
+     * close step so normal session shutdown promotes working memory to
+     * episodic/gists/graph automatically (see issue #2320).
+     *
+     * Aliased subagent states share `scoped` (and therefore the actual SQLite
+     * banks) with their parent. `consolidate()` deliberately does NOT
+     * short-circuit on `aliasOf`: `forceRetainCurrentSession` already guards
+     * itself, and an explicit `/memory enqueue` invoked from within a subagent
+     * still needs to flush extractions and sleep the parent's shared banks —
+     * otherwise enqueue would report success while leaving the subagent's
+     * retained memories unconsolidated until the parent eventually shuts down
+     * (PR #2327 review).
+     */
+    consolidate(): Promise<void>;
+    /**
+     * Release the per-session resources. Defaults to running {@link consolidate}
+     * before closing handles so normal session shutdown promotes working memory
+     * into long-term storage. Callers that are about to delete the DB files —
+     * e.g. `mnemopiBackend.clear` — pass `{ consolidate: false }` to skip the
+     * extraction/sleep pass, since spending tokens on memories that will be
+     * wiped on the next line is wasted work (PR #2327 review).
+     */
+    dispose(options?: {
+        consolidate?: boolean;
+    }): Promise<void>;
 }
 export declare function getMnemopiScopedDbPaths(config: MnemopiBackendConfig): readonly string[];
 export declare function getMnemopiScopedBanks(config: MnemopiBackendConfig): readonly string[];

package/dist/types/tools/path-utils.d.ts

@@ -135,7 +135,7 @@ export declare function parseSearchPath(filePath: string): ParsedSearchPath;
 export declare function parseSearchPathPreferringLiteral(filePath: string, cwd: string): Promise<ParsedSearchPath>;
 export declare function parseFindPattern(pattern: string): ParsedFindPattern;
 export declare function combineSearchGlobs(prefixGlob?: string, suffixGlob?: string): string | undefined;
-export declare function resolveExplicitSearchPaths(pathItems: string[], cwd: string, suffixGlob?: string): Promise<ResolvedMultiSearchPath | undefined>;
+export declare function resolveExplicitSearchPaths(pathItems: string[], cwd: string, suffixGlob?: string, fanOutFileItems?: boolean): Promise<ResolvedMultiSearchPath | undefined>;
 export declare function resolveExplicitFindPatterns(patternItems: string[], cwd: string): Promise<ResolvedMultiFindPattern | undefined>;
 /**
  * Result of partitioning a list of user-supplied paths/globs into entries whose
@@ -176,6 +176,10 @@ export interface ToolScopeOptions {
     trackImmutableSources?: boolean;
     /** Honor `exactFilePaths` from {@link resolveExplicitSearchPaths} (search-only). */
     surfaceExactFilePaths?: boolean;
+    /** Fan plain-file entries out into per-target scans instead of folding them
+     * into a directory walk's glob union (search-only: the caller must dedupe
+     * matches from overlapping targets). */
+    fanOutFileTargets?: boolean;
     /** Extra hint appended to "Path not found" when stat fails and the user supplied multiple paths. */
     multipathStatHint?: string;
     /** Calling session's settings — forwarded to the internal-URL router so caller-aware handlers (issue://, pr://) honor it. */

package/dist/types/utils/git.d.ts

@@ -177,7 +177,7 @@ export declare const stage: {
 };
 /** Create a commit with the given message (passed via stdin). */
 export declare function commit(cwd: string, message: string, options?: CommitOptions): Promise<GitCommandResult>;
-/** Push the current branch. */
+/** Push the current branch (branch-scoped: never follows tags). */
 export declare function push(cwd: string, options?: PushOptions): Promise<void>;
 /** Checkout a ref. */
 export declare function checkout(cwd: string, ref: string, signal?: AbortSignal): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.11.2",
+	"version": "15.11.3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,16 +47,16 @@
 		"@agentclientprotocol/sdk": "0.22.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "15.11.2",
-		"@oh-my-pi/omp-stats": "15.11.2",
-		"@oh-my-pi/pi-agent-core": "15.11.2",
-		"@oh-my-pi/pi-ai": "15.11.2",
-		"@oh-my-pi/pi-catalog": "15.11.2",
-		"@oh-my-pi/pi-mnemopi": "15.11.2",
-		"@oh-my-pi/pi-natives": "15.11.2",
-		"@oh-my-pi/pi-tui": "15.11.2",
-		"@oh-my-pi/pi-utils": "15.11.2",
-		"@oh-my-pi/snapcompact": "15.11.2",
+		"@oh-my-pi/hashline": "15.11.3",
+		"@oh-my-pi/omp-stats": "15.11.3",
+		"@oh-my-pi/pi-agent-core": "15.11.3",
+		"@oh-my-pi/pi-ai": "15.11.3",
+		"@oh-my-pi/pi-catalog": "15.11.3",
+		"@oh-my-pi/pi-mnemopi": "15.11.3",
+		"@oh-my-pi/pi-natives": "15.11.3",
+		"@oh-my-pi/pi-tui": "15.11.3",
+		"@oh-my-pi/pi-utils": "15.11.3",
+		"@oh-my-pi/snapcompact": "15.11.3",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/lsp/clients/lsp-linter-client.ts

@@ -4,18 +4,10 @@
  */
 import { getOrCreateClient, notifySaved, sendRequest, syncContent } from "../../lsp/client";
 import { applyTextEditsToString } from "../../lsp/edits";
+import { resolveFormatOptions } from "../../lsp/format-options";
 import type { Diagnostic, LinterClient, LspClient, ServerConfig, TextEdit } from "../../lsp/types";
 import { fileToUri } from "../../lsp/utils";
 
-/** Default formatting options for LSP */
-const DEFAULT_FORMAT_OPTIONS = {
-	tabSize: 3,
-	insertSpaces: true,
-	trimTrailingWhitespace: true,
-	insertFinalNewline: true,
-	trimFinalNewlines: true,
-};
-
 /**
  * LSP-based linter client implementation.
  * Wraps the existing LSP client infrastructure.
@@ -56,7 +48,7 @@ export class LspLinterClient implements LinterClient {
 		// Request formatting
 		const edits = (await sendRequest(client, "textDocument/formatting", {
 			textDocument: { uri },
-			options: DEFAULT_FORMAT_OPTIONS,
+			options: resolveFormatOptions(filePath, content),
 		})) as TextEdit[] | null;
 
 		if (!edits || edits.length === 0) {

package/src/lsp/format-options.ts

@@ -0,0 +1,119 @@
+/**
+ * Per-file LSP `FormattingOptions` resolution.
+ *
+ * Replaces the historical hardcoded `{ tabSize: 3, insertSpaces: true }` default
+ * that fed every `textDocument/formatting` request — it silently re-indented
+ * 2-space YAML (and any LSP-formatted file) on every write/edit (issue #2329).
+ *
+ * Precedence, highest to lowest:
+ *   1. `.editorconfig` in the file's chain (`indent_style`, `indent_size`, `tab_width`).
+ *   2. Indent detected from the file content the agent is about to write.
+ *   3. Hardcoded fallback — 2 spaces, matching the dominant convention for YAML,
+ *      JSON, JS/TS, Python (PEP 8 is 4 but most LSP servers honour their own
+ *      defaults when ours don't disagree), and most config formats. The previous
+ *      `3` default was an unusual stride that actively damaged every file with
+ *      a 2/4-space convention.
+ */
+import { getEditorConfigFormatting } from "@oh-my-pi/pi-utils";
+
+/** Subset of the LSP `FormattingOptions` we send. */
+export interface LspFormattingOptions {
+	tabSize: number;
+	insertSpaces: boolean;
+	trimTrailingWhitespace: boolean;
+	insertFinalNewline: boolean;
+	trimFinalNewlines: boolean;
+}
+
+/** Sensible fallback when neither `.editorconfig` nor file content pins the indent. */
+const FALLBACK_TAB_SIZE = 2;
+const FALLBACK_INSERT_SPACES = true;
+
+/** Static flags we always pass — these have no per-file analogue and match common formatter expectations. */
+const TRIM_OPTIONS = {
+	trimTrailingWhitespace: true,
+	insertFinalNewline: true,
+	trimFinalNewlines: true,
+} as const;
+
+interface DetectedIndent {
+	tabSize?: number;
+	insertSpaces?: boolean;
+}
+
+/**
+ * Sniff `insertSpaces` and the indent unit from `content`.
+ *
+ * Walks the buffer once: the first indented line decides spaces vs tabs; for
+ * space indents, the GCD of all space-indent widths gives the stride (so a
+ * 2/4/6 file reports `2`, a 4/8 file reports `4`). Returns `undefined` for any
+ * field the content does not pin so a higher-precedence override (editorconfig)
+ * can win without being overwritten by sniffing noise.
+ */
+export function detectIndentFromContent(content: string): DetectedIndent {
+	if (content.length === 0) return {};
+
+	let insertSpaces: boolean | undefined;
+	let unit = 0;
+
+	// Split is the cheapest reliable line walk on arbitrary text; the
+	// per-line regex matches are O(leading whitespace) so total cost is
+	// linear in the file's indented prefix bytes.
+	for (const line of content.split("\n")) {
+		// Skip blank/whitespace-only lines — they carry no indent signal.
+		if (line.length === 0 || line.trim().length === 0) continue;
+
+		const first = line[0];
+		if (first !== " " && first !== "\t") continue;
+
+		if (insertSpaces === undefined) {
+			insertSpaces = first === " ";
+		}
+
+		// Tab-indented file: the unit is one tab per level; tabSize is a
+		// display concern, leave it to caller defaults / editorconfig.
+		if (first === "\t") continue;
+
+		// Space-indented: count the leading spaces (stop at first tab to avoid
+		// mixing). GCD across non-zero widths converges on the stride.
+		let n = 0;
+		while (n < line.length && line[n] === " ") n++;
+		if (n === 0) continue;
+		unit = unit === 0 ? n : gcd(unit, n);
+	}
+
+	const result: DetectedIndent = {};
+	if (insertSpaces !== undefined) result.insertSpaces = insertSpaces;
+	if (unit > 0 && insertSpaces === true) result.tabSize = unit;
+	return result;
+}
+
+function gcd(a: number, b: number): number {
+	let x = a;
+	let y = b;
+	while (y !== 0) {
+		const t = y;
+		y = x % y;
+		x = t;
+	}
+	return x;
+}
+
+/**
+ * Resolve the `FormattingOptions` payload for a `textDocument/formatting` request
+ * targeting `filePath` with `content`.
+ *
+ * The two fields that actually affect on-disk bytes (`tabSize`, `insertSpaces`)
+ * are layered: editorconfig wins, then content sniffing, then the fallback.
+ * Trim/final-newline flags are static.
+ */
+export function resolveFormatOptions(filePath: string, content: string): LspFormattingOptions {
+	const fromConfig = getEditorConfigFormatting(filePath);
+	const detected = detectIndentFromContent(content);
+
+	return {
+		tabSize: fromConfig.tabSize ?? detected.tabSize ?? FALLBACK_TAB_SIZE,
+		insertSpaces: fromConfig.insertSpaces ?? detected.insertSpaces ?? FALLBACK_INSERT_SPACES,
+		...TRIM_OPTIONS,
+	};
+}

package/src/lsp/index.ts

@@ -39,6 +39,7 @@ import {
 	flattenWorkspaceTextEdits,
 	rangesOverlap,
 } from "./edits";
+import { resolveFormatOptions } from "./format-options";
 import { detectLspmux } from "./lspmux";
 import {
 	type CodeAction,
@@ -779,15 +780,6 @@ export enum FileFormatResult {
 	FORMATTED = "formatted",
 }
 
-/** Default formatting options for LSP */
-const DEFAULT_FORMAT_OPTIONS = {
-	tabSize: 3,
-	insertSpaces: true,
-	trimTrailingWhitespace: true,
-	insertFinalNewline: true,
-	trimFinalNewlines: true,
-};
-
 /**
  * Format content using LSP or custom linter client.
  *
@@ -834,7 +826,7 @@ async function formatContent(
 				"textDocument/formatting",
 				{
 					textDocument: { uri },
-					options: DEFAULT_FORMAT_OPTIONS,
+					options: resolveFormatOptions(absolutePath, content),
 				},
 				signal,
 			)) as TextEdit[] | null;

package/src/mnemopi/backend.ts

@@ -82,7 +82,7 @@ export const mnemopiBackend: MemoryBackend = {
 					hasRecalledForFirstTurn: true,
 				}),
 			);
-			previous?.dispose();
+			await previous?.dispose();
 			return;
 		}
 
@@ -91,7 +91,7 @@ export const mnemopiBackend: MemoryBackend = {
 			await Promise.all([loadMnemopi(), loadMnemopiCore()]);
 			const state = new MnemopiSessionState({ sessionId, config, session });
 			const previous = setMnemopiSessionState(session, state);
-			previous?.dispose();
+			await previous?.dispose();
 			state.attachSessionListeners();
 		} catch (error) {
 			logger.warn("Mnemopi: backend startup failed; memory backend inert.", { error: String(error) });
@@ -115,7 +115,7 @@ export const mnemopiBackend: MemoryBackend = {
 
 	async clear(agentDir, _cwd, session): Promise<void> {
 		const previous = session ? setMnemopiSessionState(session, undefined) : undefined;
-		previous?.dispose();
+		await previous?.dispose({ consolidate: false });
 		const config = previous?.config ?? (session ? loadMnemopiConfig(session.settings, agentDir) : undefined);
 		if (!config) return;
 		await loadMnemopiCore();
@@ -136,11 +136,7 @@ export const mnemopiBackend: MemoryBackend = {
 				state = new MnemopiSessionState({ sessionId: session.sessionId, config, session });
 				setMnemopiSessionState(session, state);
 			}
-			await state?.forceRetainCurrentSession();
-			// Drain the background fact extraction scheduled by the final retain
-			// before the process can exit, otherwise the last turn's facts are lost.
-			await state?.memory.flushExtractions();
-			state?.memory.sleepAllSessions(false);
+			await state?.consolidate();
 		} catch (error) {
 			logger.warn("Mnemopi: enqueue failed.", { error: String(error) });
 		}

package/src/mnemopi/state.ts

@@ -370,12 +370,51 @@ export class MnemopiSessionState {
 		}
 	}
 
-	dispose(): void {
+	/**
+	 * Drain in-flight fact extraction and run beam consolidation on every owned
+	 * bank, after capturing the current transcript. Mirrors the manual
+	 * `/memory enqueue` slash command, but stops short of closing the DBs so
+	 * callers can keep using the state. {@link dispose} composes this with the
+	 * close step so normal session shutdown promotes working memory to
+	 * episodic/gists/graph automatically (see issue #2320).
+	 *
+	 * Aliased subagent states share `scoped` (and therefore the actual SQLite
+	 * banks) with their parent. `consolidate()` deliberately does NOT
+	 * short-circuit on `aliasOf`: `forceRetainCurrentSession` already guards
+	 * itself, and an explicit `/memory enqueue` invoked from within a subagent
+	 * still needs to flush extractions and sleep the parent's shared banks —
+	 * otherwise enqueue would report success while leaving the subagent's
+	 * retained memories unconsolidated until the parent eventually shuts down
+	 * (PR #2327 review).
+	 */
+	async consolidate(): Promise<void> {
+		await this.forceRetainCurrentSession();
+		for (const memory of this.scoped.owned) {
+			await memory.flushExtractions();
+			memory.sleepAllSessions(false);
+		}
+	}
+
+	/**
+	 * Release the per-session resources. Defaults to running {@link consolidate}
+	 * before closing handles so normal session shutdown promotes working memory
+	 * into long-term storage. Callers that are about to delete the DB files —
+	 * e.g. `mnemopiBackend.clear` — pass `{ consolidate: false }` to skip the
+	 * extraction/sleep pass, since spending tokens on memories that will be
+	 * wiped on the next line is wasted work (PR #2327 review).
+	 */
+	async dispose(options: { consolidate?: boolean } = {}): Promise<void> {
 		this.unsubscribe?.();
 		this.unsubscribe = undefined;
-		if (!this.aliasOf) {
-			for (const memory of this.scoped.owned) memory.close();
+		if (this.aliasOf) return;
+		if (options.consolidate !== false) {
+			try {
+				await this.consolidate();
+			} catch (error) {
+				logger.warn("Mnemopi: consolidation on dispose failed.", { error: String(error) });
+			}
 		}
+		for (const memory of this.scoped.owned) memory.close();
 	}
 }
 

package/src/modes/interactive-mode.ts

@@ -14,7 +14,14 @@ import {
 import type { CompactionOutcome } from "@oh-my-pi/pi-agent-core/compaction";
 import type { AssistantMessage, ImageContent, Message, Model, UsageReport } from "@oh-my-pi/pi-ai";
 import { modelsAreEqual } from "@oh-my-pi/pi-catalog/models";
-import type { Component, EditorTheme, LoaderMessageColorFn, OverlayHandle, SlashCommand } from "@oh-my-pi/pi-tui";
+import type {
+	Component,
+	EditorTheme,
+	LoaderMessageColorFn,
+	NativeScrollbackLiveRegion,
+	OverlayHandle,
+	SlashCommand,
+} from "@oh-my-pi/pi-tui";
 import {
 	Container,
 	clearRenderCache,
@@ -257,6 +264,19 @@ export interface InteractiveModeOptions {
 	initialMessages?: string[];
 }
 
+/**
+ * Hosts the working loader and transient status rows. While anything is
+ * mounted, every row is live: report a seam at 0 so the engine never commits
+ * a still-animating loader to native scrollback (stale `Working…` rows would
+ * otherwise pile up above the live one). The transcript's own seam, when
+ * present, sits higher and wins (topmost-seam merge in TUI.render).
+ */
+class StatusContainer extends Container implements NativeScrollbackLiveRegion {
+	getNativeScrollbackLiveRegionStart(): number | undefined {
+		return this.children.length > 0 ? 0 : undefined;
+	}
+}
+
 export class InteractiveMode implements InteractiveModeContext {
 	session: AgentSession;
 	sessionManager: SessionManager;
@@ -418,7 +438,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		setTerminalTextSizing(settings.get("tui.textSizing") && TERMINAL.textSizing);
 		this.chatContainer = new TranscriptContainer();
 		this.pendingMessagesContainer = new Container();
-		this.statusContainer = new Container();
+		this.statusContainer = new StatusContainer();
 		this.todoContainer = new Container();
 		this.btwContainer = new Container();
 		this.omfgContainer = new Container();

package/src/session/agent-session.ts

@@ -3213,7 +3213,7 @@ export class AgentSession {
 		this.setHindsightSessionState(undefined);
 		hindsightState?.dispose();
 		const mnemopiState = setMnemopiSessionState(this, undefined);
-		mnemopiState?.dispose();
+		await mnemopiState?.dispose();
 		this.#disconnectFromAgent();
 		if (this.#unsubscribeAppendOnly) {
 			this.#unsubscribeAppendOnly();

package/src/tools/path-utils.ts

@@ -729,6 +729,7 @@ async function resolveSearchPathItems(
 	pathItems: string[],
 	cwd: string,
 	suffixGlob?: string,
+	fanOutFileItems = false,
 ): Promise<ResolvedMultiSearchPath | undefined> {
 	if (pathItems.length < 1) {
 		return undefined;
@@ -760,14 +761,27 @@ async function resolveSearchPathItems(
 		}
 		return relativeBasePath === "." ? path.basename(item.absoluteBasePath) : relativeBasePath;
 	});
-	const rootPath = path.parse(commonBasePath).root;
-	const isDegenerateRoot = commonBasePath === rootPath && parsedItems.length > 1;
-	const targets = isDegenerateRoot
-		? parsedItems.map(item => ({
-				basePath: item.absoluteBasePath,
-				glob: item.parsedPath.glob ? combineSearchGlobs(item.parsedPath.glob, suffixGlob) : suffixGlob,
-			}))
-		: undefined;
+	// A single walk rooted at the common ancestor is only safe when that
+	// ancestor is itself one of the requested scopes (e.g. `.` + `src/foo.ts`):
+	// the walk then covers exactly what the caller asked for. When the common
+	// ancestor is an unrequested parent (`.` + `~/.gitconfig` → `$HOME`, or
+	// disjoint trees → `/`), a collapsed walk traverses every unrelated sibling
+	// under it — fan out into per-item targets so each scan stays bounded to a
+	// requested path.
+	const commonIsRequestedScope = parsedItems.some(item => item.absoluteBasePath === commonBasePath);
+	// Walkers prune `.git` unconditionally and honor gitignore, so a plain-file
+	// item folded into a directory walk's glob union (`.` + `.git/config`) can
+	// silently never match. Callers that dedupe overlapping results opt in via
+	// `fanOutFileItems` to get explicit file targets, which bypass the walker.
+	const demotesFileItem =
+		fanOutFileItems && !allExactFiles && parsedItems.some(item => !item.parsedPath.glob && item.stat.isFile());
+	const targets =
+		parsedItems.length > 1 && (!commonIsRequestedScope || demotesFileItem)
+			? parsedItems.map(item => ({
+					basePath: item.absoluteBasePath,
+					glob: item.parsedPath.glob ? combineSearchGlobs(item.parsedPath.glob, suffixGlob) : suffixGlob,
+				}))
+			: undefined;
 
 	return {
 		basePath: commonBasePath,
@@ -782,8 +796,9 @@ export async function resolveExplicitSearchPaths(
 	pathItems: string[],
 	cwd: string,
 	suffixGlob?: string,
+	fanOutFileItems = false,
 ): Promise<ResolvedMultiSearchPath | undefined> {
-	return resolveSearchPathItems([...new Set(pathItems)], cwd, suffixGlob);
+	return resolveSearchPathItems([...new Set(pathItems)], cwd, suffixGlob, fanOutFileItems);
 }
 
 async function resolveFindPatternItems(
@@ -928,6 +943,10 @@ export interface ToolScopeOptions {
 	trackImmutableSources?: boolean;
 	/** Honor `exactFilePaths` from {@link resolveExplicitSearchPaths} (search-only). */
 	surfaceExactFilePaths?: boolean;
+	/** Fan plain-file entries out into per-target scans instead of folding them
+	 * into a directory walk's glob union (search-only: the caller must dedupe
+	 * matches from overlapping targets). */
+	fanOutFileTargets?: boolean;
 	/** Extra hint appended to "Path not found" when stat fails and the user supplied multiple paths. */
 	multipathStatHint?: string;
 	/** Calling session's settings — forwarded to the internal-URL router so caller-aware handlers (issue://, pr://) honor it. */
@@ -1024,7 +1043,12 @@ export async function resolveToolSearchScope(opts: ToolScopeOptions): Promise<To
 		globFilter = parsedPath.glob;
 		scopePath = formatPathRelativeToCwd(searchPath, cwd);
 	} else {
-		const multiSearchPath = await resolveExplicitSearchPaths(effectivePaths, cwd);
+		const multiSearchPath = await resolveExplicitSearchPaths(
+			effectivePaths,
+			cwd,
+			undefined,
+			opts.fanOutFileTargets === true,
+		);
 		if (!multiSearchPath) {
 			throw new ToolError("`paths` must contain at least one path or glob");
 		}

package/src/tools/search.ts

@@ -795,6 +795,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 						internalUrlAction: "search",
 						trackImmutableSources: true,
 						surfaceExactFilePaths: true,
+						fanOutFileTargets: true,
 						multipathStatHint: " (`paths` entries must each exist relative to cwd)",
 						settings: this.session.settings,
 						signal,
@@ -863,6 +864,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					if (searchablePaths.length > 0) {
 						if (exactFilePaths || multiTargets) {
 							const matches: GrepMatch[] = [];
+							const seenMatchKeys = new Set<string>();
 							let limitReached = false;
 							let totalMatches = 0;
 							let filesSearched = 0;
@@ -900,6 +902,15 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 								filesSearched += targetResult.filesSearched;
 								for (const match of targetResult.matches) {
 									const absolute = path.resolve(target.basePath, match.path);
+									// Overlapping targets (a directory plus a file nested
+									// inside it) surface the same physical line twice;
+									// keep the first occurrence.
+									const matchKey = `${absolute}\0${match.lineNumber}`;
+									if (seenMatchKeys.has(matchKey)) {
+										totalMatches = Math.max(0, totalMatches - 1);
+										continue;
+									}
+									seenMatchKeys.add(matchKey);
 									const rebased = path.relative(searchPath, absolute).replace(/\\/g, "/");
 									matches.push({ ...match, path: rebased });
 								}

package/src/utils/git.ts

@@ -1126,9 +1126,14 @@ export async function commit(cwd: string, message: string, options: CommitOption
 	return runChecked(cwd, args, { signal: options.signal, stdin: message });
 }
 
-/** Push the current branch. */
+/** Push the current branch (branch-scoped: never follows tags). */
 export async function push(cwd: string, options: PushOptions = {}): Promise<void> {
-	const args = ["push"];
+	// `--no-follow-tags` overrides a user's `push.followTags = true`, which
+	// would otherwise ride every reachable annotated tag along with the
+	// branch — rejected refs ("permission denied") on remotes the user
+	// cannot tag (e.g. PR-head forks), failing the call after the branch
+	// itself already updated. Tool pushes push exactly the named refspec.
+	const args = ["push", "--no-follow-tags"];
 	if (options.forceWithLease) args.push("--force-with-lease");
 	if (options.remote) args.push(options.remote);
 	if (options.refspec) args.push(options.refspec);