@oh-my-pi/pi-coding-agent 16.3.4 → 16.3.6

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

@@ -324,6 +324,22 @@ export declare const patch: {
 };
 export declare const cherryPick: ((cwd: string, revision: string, signal?: AbortSignal) => Promise<void>) & {
     abort(cwd: string, signal?: AbortSignal): Promise<void>;
+    /**
+     * Skip the current commit of an in-progress cherry-pick sequence and
+     * continue with the rest of the range. Use after {@link isEmptyError}
+     * reports the current attempt collapsed to a no-op — the alternative,
+     * `--abort`, throws away every remaining commit in the range.
+     */
+    skip(cwd: string, signal?: AbortSignal): Promise<void>;
+    /**
+     * True when a cherry-pick failure was caused by the current commit
+     * being empty against HEAD — either redundant with an already-applied
+     * change, or auto-resolved to HEAD by a 3-way merge. Callers should
+     * `--skip` in this case to advance the sequencer rather than aborting
+     * the whole range: an empty commit is not a merge conflict, and any
+     * later commits in the range still deserve to land.
+     */
+    isEmptyError(err: unknown): boolean;
 };
 export declare const stash: {
     /** Stash working tree + index changes. Returns true when git created a new stash entry. */

package/package.json

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

package/src/cli/auth-broker-cli.ts

@@ -222,8 +222,19 @@ async function runLocalLogin(provider: OAuthProvider): Promise<void> {
 		// for non-paste-code providers, so this is defense-in-depth on the same gate.
 		const usesManualInput = PASTE_CODE_LOGIN_PROVIDERS.has(provider);
 		await storage.login(provider, {
-			onAuth({ url, instructions }) {
-				process.stdout.write(`\nOpen this URL in your browser:\n${url}\n`);
+			onAuth({ url, launchUrl, instructions }) {
+				process.stdout.write("\nOpen this URL in your browser:\n");
+				// Full URL first so the CLI works from any machine, including SSH
+				// sessions where a `launchUrl` (loopback `/launch` on the OMP
+				// host) would resolve against the caller's browser and fail.
+				// Headless capture is unaffected: it reads the first URL line.
+				process.stdout.write(`${url}\n`);
+				if (launchUrl && launchUrl !== url) {
+					// Local shortcut for the machine running OMP. Terminals or
+					// screen-scrapers narrower than the full URL still get an
+					// unbroken copy target here.
+					process.stdout.write(`Local shortcut (this machine only): ${launchUrl}\n`);
+				}
 				if (instructions) process.stdout.write(`${instructions}\n`);
 				process.stdout.write("\n");
 			},

package/src/cli/tiny-models-cli.ts

@@ -35,12 +35,19 @@ function writeLine(text = ""): void {
 	process.stdout.write(`${text}\n`);
 }
 
+const ACTIONABLE_DOWNLOAD_ERROR_LINE = /PI_TINY_|CUDA|cuDNN|cudnn|libcudnn|tiny-title-runtime|onnxruntime-node/i;
+
 function downloadErrorSummary(error: string | undefined): string | undefined {
-	return error
-		?.split(/\r?\n/)
-		.map(line => line.trim())
-		.find(line => line.length > 0)
-		?.replace(/^Error:\s*/, "");
+	const lines =
+		error
+			?.split(/\r?\n/)
+			.map(line => line.trim().replace(/^Error:\s*/, ""))
+			.filter(line => line.length > 0) ?? [];
+	const first = lines[0];
+	if (!first) return undefined;
+	const details = lines.slice(1).filter(line => ACTIONABLE_DOWNLOAD_ERROR_LINE.test(line));
+	if (details.length === 0) return first;
+	return [first, ...details].join("\n");
 }
 
 export function resolveModels(model: string | undefined): TinyLocalModelKey[] {

package/src/edit/file-snapshot-store.ts

@@ -74,17 +74,20 @@ export function canonicalSnapshotKey(absolutePath: string): string {
  * Producers that only displayed a slice of the file (range reads, search hits)
  * use this to mint a whole-file tag: the displayed lines stay partial, but the
  * tag fingerprints the entire file so a follow-up edit anchored at any line
- * validates whenever the live file is byte-identical to what was read.
+ * validates whenever the live file is byte-identical to what was read. Raw
+ * reads pass `seenLines` even though they do not emit a header, letting a prior
+ * or later same-content hashline tag inherit the raw range's provenance.
  */
 export async function recordFileSnapshot(
 	session: FileSnapshotStoreOwner,
 	absolutePath: string,
+	seenLines?: Iterable<number>,
 ): Promise<string | undefined> {
 	try {
 		const file = Bun.file(absolutePath);
 		if (file.size > SNAPSHOT_MAX_BYTES) return undefined;
 		const normalized = normalizeToLF(await file.text());
-		return getFileSnapshotStore(session).record(canonicalSnapshotKey(absolutePath), normalized);
+		return getFileSnapshotStore(session).record(canonicalSnapshotKey(absolutePath), normalized, seenLines);
 	} catch {
 		return undefined;
 	}

package/src/edit/renderer.ts

@@ -696,11 +696,6 @@ function wrapEditRendererLine(line: string, width: number): string[] {
 
 export const editToolRenderer = {
 	mergeCallAndResult: true,
-	// Pending preview is a TAIL window of the streamed diff ("… N more lines
-	// above" + last rows); the result render re-anchors the block top-first, so
-	// committing the preview's settled head would strand a stale call-box
-	// fragment in native scrollback.
-	provisionalPendingPreview: true,
 
 	renderCall(
 		args: EditRenderArgs,

package/src/extensibility/custom-tools/types.ts

@@ -26,6 +26,7 @@ import type * as PiCodingAgent from "../../index";
 import type { Theme } from "../../modes/theme/theme";
 import type { ReadonlySessionManager } from "../../session/session-manager";
 import type { TodoItem } from "../../tools/todo";
+import type { RecoveredRetryError } from "../shared-events";
 import type * as TypeBox from "../typebox";
 
 /** Alias for clarity */
@@ -133,6 +134,7 @@ export type CustomToolSessionEvent =
 			success: boolean;
 			attempt: number;
 			finalError?: string;
+			recoveredErrors?: RecoveredRetryError[];
 	  }
 	| {
 			reason: "ttsr_triggered";

package/src/extensibility/shared-events.ts

@@ -14,7 +14,7 @@
  */
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { CompactionPreparation, CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
-import type { ImageContent, TextContent, ToolResultMessage } from "@oh-my-pi/pi-ai";
+import type { AssistantRetryRecovery, ImageContent, TextContent, ToolResultMessage } from "@oh-my-pi/pi-ai";
 import type { Rule } from "../capability/rule";
 import type { Goal, GoalModeState } from "../goals/state";
 import type { BranchSummaryEntry, CompactionEntry, SessionEntry } from "../session/session-entries";
@@ -241,12 +241,20 @@ export interface AutoRetryStartEvent {
 	errorId?: number;
 }
 
+export interface RecoveredRetryError {
+	entryId: string;
+	persistenceKey?: string;
+	note: string;
+	retryRecovery: AssistantRetryRecovery;
+}
+
 /** Fired when auto-retry ends */
 export interface AutoRetryEndEvent {
 	type: "auto_retry_end";
 	success: boolean;
 	attempt: number;
 	finalError?: string;
+	recoveredErrors?: RecoveredRetryError[];
 }
 
 // ============================================================================

package/src/hindsight/content.ts

@@ -25,6 +25,7 @@ const LEGACY_HINDSIGHT_MEMORIES_REGEX = /<hindsight_memories>[\s\S]*?<\/hindsigh
 const LEGACY_RELEVANT_MEMORIES_REGEX = /<relevant_memories>[\s\S]*?<\/relevant_memories>/g;
 const MENTAL_MODELS_REGEX = /<mental_models>[\s\S]*?<\/mental_models>/g;
 
+const RETENTION_PROTOCOL_MARKER_REGEX = /^\[(?:role:\s*[-_a-zA-Z0-9]+|[-_a-zA-Z0-9]+:end)\]$/;
 /**
  * Strip `<memories>`, `<mental_models>`, and legacy memory blocks.
  *
@@ -205,6 +206,32 @@ function formatRetentionMessages(messages: HindsightMessage[]): RetentionTranscr
 	return { transcript, messageCount: parts.length };
 }
 
+function formatEmbeddableRetentionMessages(messages: HindsightMessage[]): RetentionTranscript {
+	const parts: string[] = [];
+	for (const msg of messages) {
+		const content = stripRetentionProtocolMarkers(stripMemoryTags(msg.content)).trim();
+		if (!hasSubstantiveContent(content)) continue;
+		parts.push(content);
+	}
+
+	if (parts.length === 0) return { transcript: null, messageCount: 0 };
+
+	const transcript = parts.join("\n\n");
+	if (transcript.trim().length < 10) return { transcript: null, messageCount: 0 };
+
+	return { transcript, messageCount: parts.length };
+}
+
+/** Remove retention framing lines from a stored coding-agent episode transcript. */
+export function stripRetentionProtocolMarkers(content: string): string {
+	return content
+		.split(/\r?\n/)
+		.filter(line => !RETENTION_PROTOCOL_MARKER_REGEX.test(line.trim()))
+		.join("\n")
+		.replace(/\n{3,}/g, "\n\n")
+		.trim();
+}
+
 export function prepareRetentionTranscript(
 	messages: HindsightMessage[],
 	retainFullWindow = false,
@@ -229,6 +256,10 @@ export function prepareRetentionTranscript(
 	return formatRetentionMessages(targetMessages);
 }
 
+/** Format all retention messages without protocol markers for embedding, FTS, and recall display. */
+export function prepareEmbeddableRetentionTranscript(messages: HindsightMessage[]): RetentionTranscript {
+	return formatEmbeddableRetentionMessages(messages);
+}
 /** Format only user-authored messages for memory fact/entity extraction. */
 export function prepareUserRetentionTranscript(messages: HindsightMessage[]): RetentionTranscript {
 	return formatRetentionMessages(messages.filter(message => message.role === "user"));

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

@@ -15,75 +15,119 @@ import { isEnoent } from "@oh-my-pi/pi-utils";
 import { artifactsDirsFromRegistry } from "./registry-helpers";
 import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types";
 
-export class ArtifactProtocolHandler implements ProtocolHandler {
-	readonly scheme = "artifact";
-	readonly immutable = true;
+const MAX_INLINE_ARTIFACT_BYTES = 8 * 1024 * 1024;
 
-	async resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
-		const id = url.rawHost || url.hostname;
-		if (!id) {
-			throw new Error("artifact:// URL requires a numeric ID: artifact://0");
+/** Filesystem location for a session artifact, resolved without materializing its content. */
+export interface ResolvedArtifactFile {
+	id: string;
+	path: string;
+	size: number;
+}
+
+function parseArtifactId(url: InternalUrl): string {
+	const id = url.rawHost || url.hostname;
+	if (!id) {
+		throw new Error("artifact:// URL requires a numeric ID: artifact://0");
+	}
+	if (!/^\d+$/.test(id)) {
+		throw new Error(`artifact:// ID must be numeric, got: ${id}`);
+	}
+	return id;
+}
+
+/** Resolve an `artifact://` URL to its backing file without reading artifact bytes. */
+export async function resolveArtifactFile(url: InternalUrl, context?: ResolveContext): Promise<ResolvedArtifactFile> {
+	const id = parseArtifactId(url);
+
+	// Artifact ids are per-session counters; in multi-session hosts the same
+	// id exists in several dirs. Pin resolution to the calling session's
+	// artifacts dir first so `artifact://3` means *this* session's #3.
+	const dirs = artifactsDirsFromRegistry();
+	const pinnedDir = context?.localProtocolOptions?.getArtifactsDir?.() ?? null;
+	if (pinnedDir) {
+		const pinnedIndex = dirs.indexOf(pinnedDir);
+		if (pinnedIndex >= 0) dirs.splice(pinnedIndex, 1);
+		dirs.unshift(pinnedDir);
+	}
+
+	if (dirs.length === 0) {
+		throw new Error("No session - artifacts unavailable");
+	}
+
+	let foundPath: string | undefined;
+	let anyDirExists = false;
+	const availableIds = new Set<string>();
+
+	for (const dir of dirs) {
+		let files: string[];
+		try {
+			files = await fs.readdir(dir);
+			anyDirExists = true;
+		} catch (err) {
+			if (isEnoent(err)) continue;
+			throw err;
 		}
-		if (!/^\d+$/.test(id)) {
-			throw new Error(`artifact:// ID must be numeric, got: ${id}`);
+		const match = files.find(f => f.startsWith(`${id}.`));
+		if (match) {
+			foundPath = path.join(dir, match);
+			break;
 		}
-
-		// Artifact ids are per-session counters; in multi-session hosts the same
-		// id exists in several dirs. Pin resolution to the calling session's
-		// artifacts dir first so `artifact://3` means *this* session's #3.
-		const dirs = artifactsDirsFromRegistry();
-		const pinnedDir = context?.localProtocolOptions?.getArtifactsDir?.() ?? null;
-		if (pinnedDir) {
-			const pinnedIndex = dirs.indexOf(pinnedDir);
-			if (pinnedIndex >= 0) dirs.splice(pinnedIndex, 1);
-			dirs.unshift(pinnedDir);
+		for (const f of files) {
+			const m = f.match(/^(\d+)\./);
+			if (m) availableIds.add(m[1]);
 		}
+	}
 
-		if (dirs.length === 0) {
-			throw new Error("No session - artifacts unavailable");
-		}
+	if (!anyDirExists) {
+		throw new Error("No artifacts directory found");
+	}
 
-		let foundPath: string | undefined;
-		let anyDirExists = false;
-		const availableIds = new Set<string>();
+	if (!foundPath) {
+		const sorted = [...availableIds].sort((a, b) => Number(a) - Number(b));
+		const availableStr = sorted.length > 0 ? sorted.join(", ") : "none";
+		throw new Error(`Artifact ${id} not found. Available: ${availableStr}`);
+	}
 
-		for (const dir of dirs) {
-			let files: string[];
-			try {
-				files = await fs.readdir(dir);
-				anyDirExists = true;
-			} catch (err) {
-				if (isEnoent(err)) continue;
-				throw err;
-			}
-			const match = files.find(f => f.startsWith(`${id}.`));
-			if (match) {
-				foundPath = path.join(dir, match);
-				break;
-			}
-			for (const f of files) {
-				const m = f.match(/^(\d+)\./);
-				if (m) availableIds.add(m[1]);
-			}
-		}
+	const stat = await Bun.file(foundPath).stat();
+	if (stat.isDirectory()) {
+		throw new Error(`Artifact ${id} resolved to a directory, not a file`);
+	}
+	return { id, path: foundPath, size: stat.size };
+}
+
+export class ArtifactProtocolHandler implements ProtocolHandler {
+	readonly scheme = "artifact";
+	readonly immutable = true;
+
+	async resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
+		const artifact = await resolveArtifactFile(url, context);
 
-		if (!anyDirExists) {
-			throw new Error("No artifacts directory found");
+		// Path-only callers (search/grep, bash URL expansion) never touch the
+		// artifact bytes. Return the resource shape so those flows keep working
+		// on artifacts of any size — only content materialization is gated.
+		if (context?.pathOnly) {
+			return {
+				url: url.href,
+				content: "",
+				contentType: "text/plain",
+				size: artifact.size,
+				sourcePath: artifact.path,
+			};
 		}
 
-		if (!foundPath) {
-			const sorted = [...availableIds].sort((a, b) => Number(a) - Number(b));
-			const availableStr = sorted.length > 0 ? sorted.join(", ") : "none";
-			throw new Error(`Artifact ${id} not found. Available: ${availableStr}`);
+		if (artifact.size > MAX_INLINE_ARTIFACT_BYTES) {
+			throw new Error(
+				`Artifact ${artifact.id} is ${artifact.size} bytes; full internal resolution is blocked. Use read selectors such as artifact://${artifact.id}:1-3000 or artifact://${artifact.id}:raw:1-3000, and use the artifact file path for search/copy workflows: ${artifact.path}`,
+			);
 		}
 
-		const content = await Bun.file(foundPath).text();
+		const content = await Bun.file(artifact.path).text();
 		return {
 			url: url.href,
 			content,
 			contentType: "text/plain",
-			size: Buffer.byteLength(content, "utf-8"),
-			sourcePath: foundPath,
+			size: artifact.size,
+			sourcePath: artifact.path,
 		};
 	}
 

package/src/internal-urls/types.ts

@@ -107,6 +107,16 @@ export interface ResolveContext {
 	 * reject directory resources, so they never need the listing.
 	 */
 	skipDirectoryListing?: boolean;
+	/**
+	 * When set, handlers that would otherwise materialize expensive content
+	 * (e.g. reading a multi-MiB artifact into memory just to expose its
+	 * `sourcePath`) may return the resource shape without content. Callers
+	 * that only need `sourcePath` — search/grep, bash URL expansion — pass
+	 * this so a large `artifact://` still resolves to its backing file
+	 * without OOM risk. Handlers that cannot separate path from content
+	 * ignore the flag.
+	 */
+	pathOnly?: boolean;
 }
 
 /**

package/src/lsp/config.ts

@@ -201,6 +201,21 @@ export function hasRootMarkers(cwd: string, markers: string[]): boolean {
 	return false;
 }
 
+/**
+ * Check whether any ancestor directory of a file is an LSP project root.
+ */
+export function hasRootMarkerAncestor(filePath: string, markers: string[]): boolean {
+	if (markers.length === 0) return false;
+
+	let dir = path.dirname(path.resolve(filePath));
+	while (true) {
+		if (hasRootMarkers(dir, markers)) return true;
+		const parent = path.dirname(dir);
+		if (parent === dir) return false;
+		dir = parent;
+	}
+}
+
 // =============================================================================
 // Local Binary Resolution
 // =============================================================================

package/src/lsp/edits.ts

@@ -1,5 +1,5 @@
 import * as fs from "node:fs/promises";
-import path from "node:path";
+import * as path from "node:path";
 import { formatPathRelativeToCwd } from "../tools/path-utils";
 import { ToolError } from "../tools/tool-errors";
 import type {
@@ -48,6 +48,17 @@ export function applyTextEditsToString(content: string, edits: TextEdit[]): stri
 function comparePosition(a: Position, b: Position): number {
 	return a.line === b.line ? a.character - b.character : a.line - b.line;
 }
+function positionsEqual(a: Position, b: Position): boolean {
+	return a.line === b.line && a.character === b.character;
+}
+
+function rangesEqual(a: Range, b: Range): boolean {
+	return positionsEqual(a.start, b.start) && positionsEqual(a.end, b.end);
+}
+
+function isEmptyRange(range: Range): boolean {
+	return positionsEqual(range.start, range.end);
+}
 
 function formatRange(range: Range): string {
 	return `${range.start.line + 1}:${range.start.character + 1}-${range.end.line + 1}:${range.end.character + 1}`;
@@ -63,6 +74,8 @@ export function rangesOverlap(a: Range, b: Range): boolean {
  * Equal start positions tiebreak by original array index descending so that,
  * applied bottom-up, inserts at the same position land in array order
  * (LSP spec: the order of edits in the array defines the order in the result).
+ * Byte-identical non-empty range edits are idempotent, so duplicate server
+ * output is collapsed before overlap validation.
  */
 export function sortAndValidateTextEdits(edits: TextEdit[]): TextEdit[] {
 	const sorted = edits
@@ -77,21 +90,29 @@ export function sortAndValidateTextEdits(edits: TextEdit[]): TextEdit[] {
 			return b.index - a.index;
 		})
 		.map(entry => entry.edit);
+	const unique: TextEdit[] = [];
+	for (const edit of sorted) {
+		const prev = unique[unique.length - 1];
+		if (prev && !isEmptyRange(edit.range) && rangesEqual(prev.range, edit.range) && prev.newText === edit.newText) {
+			continue;
+		}
+		unique.push(edit);
+	}
 
 	// Detect overlapping ranges: in reverse-sorted order, each edit's start
 	// must be >= the next edit's end. If not, the edits would clobber each other
-	// once applied bottom-up (typically a multi-server rename with stale positions).
-	for (let i = 0; i < sorted.length - 1; i++) {
-		const later = sorted[i].range;
-		const earlier = sorted[i + 1].range;
+	// once applied bottom-up.
+	for (let i = 0; i < unique.length - 1; i++) {
+		const later = unique[i].range;
+		const earlier = unique[i + 1].range;
 		if (comparePosition(earlier.end, later.start) > 0) {
 			throw new ToolError(
-				`overlapping LSP edits: ${formatRange(earlier)} conflicts with ${formatRange(later)}; multi-server rename produced inconsistent edits`,
+				`overlapping LSP edits: ${formatRange(earlier)} conflicts with ${formatRange(later)}; LSP produced inconsistent edits`,
 			);
 		}
 	}
 
-	return sorted;
+	return unique;
 }
 
 /**

package/src/lsp/index.ts

@@ -31,7 +31,7 @@ import {
 	waitForProjectLoaded,
 } from "./client";
 import { getLinterClient } from "./clients";
-import { getServersForFile, type LspConfig, loadConfig } from "./config";
+import { getServersForFile, hasRootMarkerAncestor, type LspConfig, loadConfig } from "./config";
 import {
 	applyTextEdits,
 	applyTextEditsToString,
@@ -357,6 +357,41 @@ function limitDiagnosticMessages(messages: string[]): string[] {
 	return messages.slice(0, DIAGNOSTIC_MESSAGE_LIMIT);
 }
 
+const ORPHAN_TYPESCRIPT_PROJECT_DIAGNOSTIC_CODES: Record<number, true> = {
+	1375: true,
+	1378: true,
+	2307: true,
+	2580: true,
+	2591: true,
+	2792: true,
+	2867: true,
+};
+
+function diagnosticCodeNumber(diagnostic: Diagnostic): number | null {
+	if (typeof diagnostic.code === "number") return diagnostic.code;
+	if (typeof diagnostic.code === "string" && /^\d+$/.test(diagnostic.code)) return Number(diagnostic.code);
+	return null;
+}
+function isTypeScriptProjectDiagnostic(serverName: string, diagnostic: Diagnostic): boolean {
+	if (diagnostic.source !== "typescript" && !serverName.toLowerCase().includes("typescript")) {
+		return false;
+	}
+	const code = diagnosticCodeNumber(diagnostic);
+	return code !== null && ORPHAN_TYPESCRIPT_PROJECT_DIAGNOSTIC_CODES[code] === true;
+}
+
+function filterOrphanProjectDiagnostics(
+	absolutePath: string,
+	serverName: string,
+	serverConfig: ServerConfig,
+	diagnostics: Diagnostic[],
+): Diagnostic[] {
+	if (!serverConfig.rootMarkers.length || hasRootMarkerAncestor(absolutePath, serverConfig.rootMarkers)) {
+		return diagnostics;
+	}
+	return diagnostics.filter(diagnostic => !isTypeScriptProjectDiagnostic(serverName, diagnostic));
+}
+
 const LOCATION_CONTEXT_LINES = 1;
 const REFERENCE_CONTEXT_LIMIT = 50;
 
@@ -709,7 +744,7 @@ async function getDiagnosticsForFile(
 			if (serverConfig.createClient) {
 				const linterClient = getLinterClient(serverName, serverConfig, cwd);
 				const diagnostics = await linterClient.lint(absolutePath);
-				return { serverName, diagnostics };
+				return { serverName, serverConfig, diagnostics };
 			}
 
 			// Default: use LSP
@@ -728,14 +763,21 @@ async function getDiagnosticsForFile(
 				minVersion,
 				expectedDocumentVersion,
 			});
-			return { serverName, diagnostics };
+			return { serverName, serverConfig, diagnostics };
 		}),
 	);
 
 	for (const result of results) {
 		if (result.status === "fulfilled") {
 			serverNames.push(result.value.serverName);
-			allDiagnostics.push(...result.value.diagnostics);
+			allDiagnostics.push(
+				...filterOrphanProjectDiagnostics(
+					absolutePath,
+					result.value.serverName,
+					result.value.serverConfig,
+					result.value.diagnostics,
+				),
+			);
 		}
 	}