gsd-pi 2.34.0-dev.ed0bfbf → 2.35.0-dev.55dcc60

package/packages/pi-coding-agent/src/core/lock-utils.ts

@@ -0,0 +1,113 @@
+/**
+ * Shared file-locking utilities built on `proper-lockfile`.
+ *
+ * Centralises the synchronous retry-loop and async lock/release patterns
+ * that were previously duplicated across auth-storage, session-manager,
+ * settings-manager, and models-json-writer.
+ */
+
+import lockfile from "proper-lockfile";
+
+const DEFAULT_MAX_ATTEMPTS = 10;
+const DEFAULT_DELAY_MS = 20;
+
+/**
+ * Acquire a synchronous file lock with retry.
+ *
+ * Retries up to `maxAttempts` times when the lock is held by another process
+ * (ELOCKED), using a busy-wait between attempts.
+ *
+ * @returns A release function to unlock.
+ * @throws On non-ELOCKED errors or when all attempts are exhausted.
+ */
+export function acquireLockSyncWithRetry(
+	lockPath: string,
+	maxAttempts: number = DEFAULT_MAX_ATTEMPTS,
+	delayMs: number = DEFAULT_DELAY_MS,
+): () => void {
+	let lastError: unknown;
+
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		try {
+			return lockfile.lockSync(lockPath, { realpath: false });
+		} catch (error) {
+			const code =
+				typeof error === "object" && error !== null && "code" in error
+					? String((error as { code?: unknown }).code)
+					: undefined;
+			if (code !== "ELOCKED" || attempt === maxAttempts) {
+				throw error;
+			}
+			lastError = error;
+			const start = Date.now();
+			while (Date.now() - start < delayMs) {
+				// Busy-wait to avoid changing callers to async.
+			}
+		}
+	}
+
+	throw (lastError as Error) ?? new Error("Failed to acquire file lock");
+}
+
+/**
+ * Non-throwing variant of {@link acquireLockSyncWithRetry}.
+ *
+ * Returns `undefined` instead of throwing when the lock cannot be acquired,
+ * allowing callers to proceed without the lock rather than losing data.
+ */
+export function tryAcquireLockSync(
+	lockPath: string,
+	maxAttempts: number = DEFAULT_MAX_ATTEMPTS,
+	delayMs: number = DEFAULT_DELAY_MS,
+): (() => void) | undefined {
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		try {
+			return lockfile.lockSync(lockPath, { realpath: false });
+		} catch (error) {
+			const code =
+				typeof error === "object" && error !== null && "code" in error
+					? String((error as { code?: unknown }).code)
+					: undefined;
+			if (code !== "ELOCKED" || attempt === maxAttempts) {
+				// Non-fatal: proceed without lock rather than losing data
+				return undefined;
+			}
+			const start = Date.now();
+			while (Date.now() - start < delayMs) {
+				// Busy-wait to avoid changing callers to async.
+			}
+		}
+	}
+	return undefined;
+}
+
+export interface AsyncLockOptions {
+	/** Maximum staleness in ms before the lock is considered stale. */
+	staleMs?: number;
+	/** Called if the lock is compromised while held. */
+	onCompromised?: (err: Error) => void;
+}
+
+/**
+ * Acquire an async file lock with retries and optional staleness detection.
+ *
+ * Uses `proper-lockfile`'s async API with exponential-backoff retries.
+ *
+ * @returns A release function (async) to unlock.
+ */
+export async function acquireLockAsync(
+	lockPath: string,
+	options?: AsyncLockOptions,
+): Promise<() => Promise<void>> {
+	return lockfile.lock(lockPath, {
+		retries: {
+			retries: 10,
+			factor: 2,
+			minTimeout: 100,
+			maxTimeout: 10000,
+			randomize: true,
+		},
+		stale: options?.staleMs,
+		onCompromised: options?.onCompromised,
+	});
+}

package/packages/pi-coding-agent/src/core/lsp/config.ts

@@ -176,7 +176,7 @@ const LOCAL_BIN_PATHS: Array<{ markers: string[]; binDir: string }> = [
 	{ markers: ["go.mod", "go.sum"], binDir: "bin" },
 ];
 
-function which(command: string): string | null {
+export function which(command: string): string | null {
 	// On Windows, prefer `where.exe` over `which` — MSYS/Git Bash's `which`
 	// returns POSIX paths (/c/Users/...) that Node's spawn() can't execute.
 	// `where.exe` returns native Windows paths (C:\Users\...).
@@ -319,3 +319,6 @@ export function getServersForFile(config: LspConfig, filePath: string): Array<[s
 	});
 }
 
+export function getServerForFile(config: LspConfig, filePath: string): [string, ServerConfig] | null {
+	return getServersForFile(config, filePath)[0] ?? null;
+}

package/packages/pi-coding-agent/src/core/lsp/index.ts

@@ -14,7 +14,7 @@ import {
 	setIdleTimeout,
 	WARMUP_TIMEOUT_MS,
 } from "./client.js";
-import { getServersForFile, type LspConfig, loadConfig, hasRootMarkers, resolveCommand } from "./config.js";
+import { getServerForFile, getServersForFile, type LspConfig, loadConfig, hasRootMarkers, resolveCommand } from "./config.js";
 import { applyTextEdits, applyWorkspaceEdit } from "./edits.js";
 import { ToolAbortError, clampTimeout, throwIfAborted } from "./helpers.js";
 import { detectLspmux } from "./lspmux.js";
@@ -144,15 +144,6 @@ function getLspServers(config: LspConfig): Array<[string, ServerConfig]> {
 	return Object.entries(config.servers) as Array<[string, ServerConfig]>;
 }
 
-function getLspServersForFile(config: LspConfig, filePath: string): Array<[string, ServerConfig]> {
-	return getServersForFile(config, filePath);
-}
-
-function getLspServerForFile(config: LspConfig, filePath: string): [string, ServerConfig] | null {
-	const servers = getLspServersForFile(config, filePath);
-	return servers.length > 0 ? servers[0] : null;
-}
-
 const DIAGNOSTIC_MESSAGE_LIMIT = 50;
 const SINGLE_DIAGNOSTICS_WAIT_TIMEOUT_MS = 3000;
 const BATCH_DIAGNOSTICS_WAIT_TIMEOUT_MS = 400;
@@ -197,6 +188,73 @@ async function formatLocationWithContext(location: Location, cwd: string): Promi
 	return `${header}\n${context.map(lineText => `    ${lineText}`).join("\n")}`;
 }
 
+async function formatLocationResults(
+	result: Location | Location[] | LocationLink | LocationLink[] | null,
+	label: string,
+	cwd: string,
+): Promise<string> {
+	const locations = normalizeLocationResult(result);
+	if (locations.length === 0) {
+		return `No ${label} found`;
+	}
+	const lines = await Promise.all(locations.map(location => formatLocationWithContext(location, cwd)));
+	return `Found ${locations.length} ${label}(s):\n${lines.join("\n")}`;
+}
+
+async function formatCallHierarchyResults(
+	client: LspClient,
+	position: { line: number; character: number },
+	uri: string,
+	direction: "incoming" | "outgoing",
+	cwd: string,
+	signal?: AbortSignal,
+): Promise<string> {
+	const prepareResult = (await sendRequest(
+		client,
+		"textDocument/prepareCallHierarchy",
+		{ textDocument: { uri }, position },
+		signal,
+	)) as CallHierarchyItem[] | null;
+
+	if (!prepareResult || prepareResult.length === 0) {
+		return "No call hierarchy item found at this position";
+	}
+
+	const method = direction === "incoming" ? "callHierarchy/incomingCalls" : "callHierarchy/outgoingCalls";
+	const callResult = (await sendRequest(client, method, { item: prepareResult[0] }, signal)) as
+		| CallHierarchyIncomingCall[]
+		| CallHierarchyOutgoingCall[]
+		| null;
+
+	if (!callResult || callResult.length === 0) {
+		const verb = direction === "incoming" ? "incoming calls" : "outgoing calls";
+		const prep = direction === "incoming" ? "for" : "from";
+		return `No ${verb} found ${prep} ${prepareResult[0].name}`;
+	}
+
+	const lines: string[] = [];
+	const limited = callResult.slice(0, REFERENCE_CONTEXT_LIMIT);
+	for (const call of limited) {
+		const item = "from" in call ? call.from : call.to;
+		const header = formatCallHierarchyItem(item, cwd);
+		const filePath = uriToFile(item.uri);
+		const callLine = ("from" in call ? call.fromRanges[0]?.start.line : undefined) ?? item.selectionRange.start.line;
+		const context = await readLocationContext(filePath, callLine + 1, LOCATION_CONTEXT_LINES);
+		if (context.length > 0) {
+			lines.push(`  ${header}\n${context.map(l => `    ${l}`).join("\n")}`);
+		} else {
+			lines.push(`  ${header}`);
+		}
+	}
+
+	const noun = direction === "incoming" ? "caller" : "callee";
+	const prep = direction === "incoming" ? "of" : "from";
+	const truncation = callResult.length > REFERENCE_CONTEXT_LIMIT
+		? `\n  ... ${callResult.length - REFERENCE_CONTEXT_LIMIT} additional ${noun}(s) omitted`
+		: "";
+	return `${callResult.length} ${noun}(s) ${prep} ${prepareResult[0].name}:\n${lines.join("\n")}${truncation}`;
+}
+
 async function reloadServer(client: LspClient, serverName: string, signal?: AbortSignal): Promise<string> {
 	let output = `Restarted ${serverName}`;
 	const reloadMethods = ["rust-analyzer/reloadWorkspace", "workspace/didChangeConfiguration"];
@@ -647,7 +705,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 			}
 
 			// File-specific actions
-			const serverInfo = resolvedFile ? getLspServerForFile(config, resolvedFile) : null;
+			const serverInfo = resolvedFile ? getServerForFile(config, resolvedFile) : null;
 			if (!serverInfo) {
 				return {
 					content: [{ type: "text", text: "No language server found for this action" }],
@@ -676,74 +734,35 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 
 				switch (action) {
 					case "definition": {
-						const result = (await sendRequest(
+						const result = await sendRequest(
 							client,
 							"textDocument/definition",
-							{
-								textDocument: { uri },
-								position,
-							},
+							{ textDocument: { uri }, position },
 							signal,
-						)) as Location | Location[] | LocationLink | LocationLink[] | null;
-
-						const locations = normalizeLocationResult(result);
-
-						if (locations.length === 0) {
-							output = "No definition found";
-						} else {
-							const lines = await Promise.all(
-								locations.map(location => formatLocationWithContext(location, cwd)),
-							);
-							output = `Found ${locations.length} definition(s):\n${lines.join("\n")}`;
-						}
+						);
+						output = await formatLocationResults(result as Location | Location[] | LocationLink | LocationLink[] | null, "definition", cwd);
 						break;
 					}
 
 					case "type_definition": {
-						const result = (await sendRequest(
+						const result = await sendRequest(
 							client,
 							"textDocument/typeDefinition",
-							{
-								textDocument: { uri },
-								position,
-							},
+							{ textDocument: { uri }, position },
 							signal,
-						)) as Location | Location[] | LocationLink | LocationLink[] | null;
-
-						const locations = normalizeLocationResult(result);
-
-						if (locations.length === 0) {
-							output = "No type definition found";
-						} else {
-							const lines = await Promise.all(
-								locations.map(location => formatLocationWithContext(location, cwd)),
-							);
-							output = `Found ${locations.length} type definition(s):\n${lines.join("\n")}`;
-						}
+						);
+						output = await formatLocationResults(result as Location | Location[] | LocationLink | LocationLink[] | null, "type definition", cwd);
 						break;
 					}
 
 					case "implementation": {
-						const result = (await sendRequest(
+						const result = await sendRequest(
 							client,
 							"textDocument/implementation",
-							{
-								textDocument: { uri },
-								position,
-							},
+							{ textDocument: { uri }, position },
 							signal,
-						)) as Location | Location[] | LocationLink | LocationLink[] | null;
-
-						const locations = normalizeLocationResult(result);
-
-						if (locations.length === 0) {
-							output = "No implementation found";
-						} else {
-							const lines = await Promise.all(
-								locations.map(location => formatLocationWithContext(location, cwd)),
-							);
-							output = `Found ${locations.length} implementation(s):\n${lines.join("\n")}`;
-						}
+						);
+						output = await formatLocationResults(result as Location | Location[] | LocationLink | LocationLink[] | null, "implementation", cwd);
 						break;
 					}
 
@@ -917,100 +936,12 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 					}
 
 					case "incoming_calls": {
-						const prepareResult = (await sendRequest(
-							client,
-							"textDocument/prepareCallHierarchy",
-							{
-								textDocument: { uri },
-								position,
-							},
-							signal,
-						)) as CallHierarchyItem[] | null;
-
-						if (!prepareResult || prepareResult.length === 0) {
-							output = "No call hierarchy item found at this position";
-							break;
-						}
-
-						const incomingResult = (await sendRequest(
-							client,
-							"callHierarchy/incomingCalls",
-							{ item: prepareResult[0] },
-							signal,
-						)) as CallHierarchyIncomingCall[] | null;
-
-						if (!incomingResult || incomingResult.length === 0) {
-							output = `No incoming calls found for ${prepareResult[0].name}`;
-							break;
-						}
-
-						const incomingLines: string[] = [];
-						const limitedIncoming = incomingResult.slice(0, REFERENCE_CONTEXT_LIMIT);
-						for (const call of limitedIncoming) {
-							const header = formatCallHierarchyItem(call.from, cwd);
-							const filePath = uriToFile(call.from.uri);
-							const callLine = call.fromRanges[0]?.start.line ?? call.from.selectionRange.start.line;
-							const context = await readLocationContext(filePath, callLine + 1, LOCATION_CONTEXT_LINES);
-							if (context.length > 0) {
-								incomingLines.push(`  ${header}\n${context.map(l => `    ${l}`).join("\n")}`);
-							} else {
-								incomingLines.push(`  ${header}`);
-							}
-						}
-
-						const truncation = incomingResult.length > REFERENCE_CONTEXT_LIMIT
-							? `\n  ... ${incomingResult.length - REFERENCE_CONTEXT_LIMIT} additional caller(s) omitted`
-							: "";
-						output = `${incomingResult.length} caller(s) of ${prepareResult[0].name}:\n${incomingLines.join("\n")}${truncation}`;
+						output = await formatCallHierarchyResults(client, position, uri, "incoming", cwd, signal);
 						break;
 					}
 
 					case "outgoing_calls": {
-						const prepareResult = (await sendRequest(
-							client,
-							"textDocument/prepareCallHierarchy",
-							{
-								textDocument: { uri },
-								position,
-							},
-							signal,
-						)) as CallHierarchyItem[] | null;
-
-						if (!prepareResult || prepareResult.length === 0) {
-							output = "No call hierarchy item found at this position";
-							break;
-						}
-
-						const outgoingResult = (await sendRequest(
-							client,
-							"callHierarchy/outgoingCalls",
-							{ item: prepareResult[0] },
-							signal,
-						)) as CallHierarchyOutgoingCall[] | null;
-
-						if (!outgoingResult || outgoingResult.length === 0) {
-							output = `No outgoing calls found from ${prepareResult[0].name}`;
-							break;
-						}
-
-						const outgoingLines: string[] = [];
-						const limitedOutgoing = outgoingResult.slice(0, REFERENCE_CONTEXT_LIMIT);
-						for (const call of limitedOutgoing) {
-							const header = formatCallHierarchyItem(call.to, cwd);
-							const filePath = uriToFile(call.to.uri);
-							const callLine = call.to.selectionRange.start.line;
-							const context = await readLocationContext(filePath, callLine + 1, LOCATION_CONTEXT_LINES);
-							if (context.length > 0) {
-								outgoingLines.push(`  ${header}\n${context.map(l => `    ${l}`).join("\n")}`);
-							} else {
-								outgoingLines.push(`  ${header}`);
-							}
-						}
-
-						const outTruncation = outgoingResult.length > REFERENCE_CONTEXT_LIMIT
-							? `\n  ... ${outgoingResult.length - REFERENCE_CONTEXT_LIMIT} additional callee(s) omitted`
-							: "";
-						output = `${outgoingResult.length} callee(s) from ${prepareResult[0].name}:\n${outgoingLines.join("\n")}${outTruncation}`;
+						output = await formatCallHierarchyResults(client, position, uri, "outgoing", cwd, signal);
 						break;
 					}
 

package/packages/pi-coding-agent/src/core/lsp/lspmux.ts

@@ -1,8 +1,9 @@
-import { execSync, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import * as fsPromises from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { LSP_LIVENESS_TIMEOUT_MS, LSP_STATE_CACHE_TTL_MS } from "../constants.js";
+import { which } from "./config.js";
 
 /**
  * lspmux integration for LSP server multiplexing.
@@ -43,27 +44,6 @@ const DEFAULT_SUPPORTED_SERVERS = new Set([
 ]);
 
 
-// =============================================================================
-// Helpers
-// =============================================================================
-
-function which(command: string): string | null {
-	try {
-		// On Windows, prefer `where.exe` over `which` — MSYS/Git Bash's `which`
-		// returns POSIX paths (/c/Users/...) that Node's spawn() can't execute (#1121).
-		const isWindows = process.platform === "win32";
-		const cmd = isWindows ? "where.exe" : "which";
-		const result = isWindows
-			? execSync(`${cmd} ${command}`, { encoding: "utf-8" })
-			: execSync(`which ${command}`, { encoding: "utf-8" });
-		// `where.exe` may return multiple lines — take the first
-		const resolved = result.trim().split(/\r?\n/)[0]?.trim();
-		return resolved || null;
-	} catch {
-		return null;
-	}
-}
-
 // =============================================================================
 // Config Path
 // =============================================================================

package/packages/pi-coding-agent/src/core/lsp/types.ts

@@ -256,35 +256,6 @@ export type SymbolKind =
 	| 25 // Operator
 	| 26; // TypeParameter
 
-export const SYMBOL_KIND_NAMES: Record<SymbolKind, string> = {
-	1: "File",
-	2: "Module",
-	3: "Namespace",
-	4: "Package",
-	5: "Class",
-	6: "Method",
-	7: "Property",
-	8: "Field",
-	9: "Constructor",
-	10: "Enum",
-	11: "Interface",
-	12: "Function",
-	13: "Variable",
-	14: "Constant",
-	15: "String",
-	16: "Number",
-	17: "Boolean",
-	18: "Array",
-	19: "Object",
-	20: "Key",
-	21: "Null",
-	22: "EnumMember",
-	23: "Struct",
-	24: "Event",
-	25: "Operator",
-	26: "TypeParameter",
-};
-
 export interface DocumentSymbol {
 	name: string;
 	detail?: string;

package/packages/pi-coding-agent/src/core/package-manager.ts

@@ -7,6 +7,7 @@ import ignore from "ignore";
 import { minimatch } from "minimatch";
 import { CONFIG_DIR_NAME } from "../config.js";
 import { type GitSource, parseGitUrl } from "../utils/git.js";
+import { toPosixPath } from "../utils/path-display.js";
 import type { PackageSource, SettingsManager } from "./settings-manager.js";
 
 const NETWORK_TIMEOUT_MS = 10000;
@@ -121,10 +122,6 @@ const IGNORE_FILE_NAMES = [".gitignore", ".ignore", ".fdignore"];
 
 type IgnoreMatcher = ReturnType<typeof ignore>;
 
-function toPosixPath(p: string): string {
-	return p.split(sep).join("/");
-}
-
 function prefixIgnorePattern(line: string, prefix: string): string | null {
 	const trimmed = line.trim();
 	if (!trimmed) return null;

package/packages/pi-coding-agent/src/core/resource-loader.ts

@@ -4,7 +4,7 @@ import { join, resolve, sep } from "node:path";
 import chalk from "chalk";
 import { CONFIG_DIR_NAME, getAgentDir } from "../config.js";
 import { loadThemeFromPath, type Theme } from "../modes/interactive/theme/theme.js";
-import type { ResourceDiagnostic } from "./diagnostics.js";
+import type { ResourceCollision, ResourceDiagnostic } from "./diagnostics.js";
 
 export type { ResourceCollision, ResourceDiagnostic } from "./diagnostics.js";
 
@@ -422,12 +422,12 @@ export class DefaultResourceLoader implements ResourceLoader {
 		this.agentsFiles = resolvedAgentsFiles.agentsFiles;
 
 		const baseSystemPrompt = resolvePromptInput(
-			this.systemPromptSource ?? this.discoverSystemPromptFile(),
+			this.systemPromptSource ?? this.discoverFileInSearchPaths("SYSTEM.md"),
 			"system prompt",
 		);
 		this.systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(baseSystemPrompt) : baseSystemPrompt;
 
-		const appendSource = this.appendSystemPromptSource ?? this.discoverAppendSystemPromptFile();
+		const appendSource = this.appendSystemPromptSource ?? this.discoverFileInSearchPaths("APPEND_SYSTEM.md");
 		const resolvedAppend = resolvePromptInput(appendSource, "append system prompt");
 		const baseAppend = resolvedAppend ? [resolvedAppend] : [];
 		this.appendSystemPrompt = this.appendSystemPromptOverride
@@ -485,7 +485,13 @@ export class DefaultResourceLoader implements ResourceLoader {
 				promptPaths,
 				includeDefaults: false,
 			});
-			promptsResult = this.dedupePrompts(allPrompts);
+			const deduped = this.dedupeResources(allPrompts, {
+				getName: (p) => p.name,
+				getPath: (p) => p.filePath,
+				resourceType: "prompt",
+				namePrefix: "/",
+			});
+			promptsResult = { prompts: deduped.items, diagnostics: deduped.diagnostics };
 		}
 		const resolvedPrompts = this.promptsOverride ? this.promptsOverride(promptsResult) : promptsResult;
 		this.prompts = resolvedPrompts.prompts;
@@ -508,8 +514,12 @@ export class DefaultResourceLoader implements ResourceLoader {
 			themesResult = { themes: [], diagnostics: [] };
 		} else {
 			const loaded = this.loadThemes(themePaths, false);
-			const deduped = this.dedupeThemes(loaded.themes);
-			themesResult = { themes: deduped.themes, diagnostics: [...loaded.diagnostics, ...deduped.diagnostics] };
+			const deduped = this.dedupeResources(loaded.themes, {
+				getName: (t) => t.name ?? "unnamed",
+				getPath: (t) => t.sourcePath,
+				resourceType: "theme",
+			});
+			themesResult = { themes: deduped.items, diagnostics: [...loaded.diagnostics, ...deduped.diagnostics] };
 		}
 		const resolvedThemes = this.themesOverride ? this.themesOverride(themesResult) : themesResult;
 		this.themes = resolvedThemes.themes;
@@ -686,84 +696,50 @@ export class DefaultResourceLoader implements ResourceLoader {
 		return { extensions, errors };
 	}
 
-	private dedupePrompts(prompts: PromptTemplate[]): { prompts: PromptTemplate[]; diagnostics: ResourceDiagnostic[] } {
-		const seen = new Map<string, PromptTemplate>();
+	private dedupeResources<T>(
+		items: T[],
+		options: {
+			getName: (item: T) => string;
+			getPath: (item: T) => string | undefined;
+			resourceType: ResourceCollision["resourceType"];
+			namePrefix?: string;
+		},
+	): { items: T[]; diagnostics: ResourceDiagnostic[] } {
+		const seen = new Map<string, T>();
 		const diagnostics: ResourceDiagnostic[] = [];
+		const { getName, getPath, resourceType, namePrefix = "" } = options;
 
-		for (const prompt of prompts) {
-			const existing = seen.get(prompt.name);
-			if (existing) {
-				diagnostics.push({
-					type: "collision",
-					message: `name "/${prompt.name}" collision`,
-					path: prompt.filePath,
-					collision: {
-						resourceType: "prompt",
-						name: prompt.name,
-						winnerPath: existing.filePath,
-						loserPath: prompt.filePath,
-					},
-				});
-			} else {
-				seen.set(prompt.name, prompt);
-			}
-		}
-
-		return { prompts: Array.from(seen.values()), diagnostics };
-	}
-
-	private dedupeThemes(themes: Theme[]): { themes: Theme[]; diagnostics: ResourceDiagnostic[] } {
-		const seen = new Map<string, Theme>();
-		const diagnostics: ResourceDiagnostic[] = [];
-
-		for (const t of themes) {
-			const name = t.name ?? "unnamed";
+		for (const item of items) {
+			const name = getName(item);
 			const existing = seen.get(name);
 			if (existing) {
 				diagnostics.push({
 					type: "collision",
-					message: `name "${name}" collision`,
-					path: t.sourcePath,
+					message: `name "${namePrefix}${name}" collision`,
+					path: getPath(item),
 					collision: {
-						resourceType: "theme",
+						resourceType,
 						name,
-						winnerPath: existing.sourcePath ?? "<builtin>",
-						loserPath: t.sourcePath ?? "<builtin>",
+						winnerPath: getPath(existing) ?? "<builtin>",
+						loserPath: getPath(item) ?? "<builtin>",
 					},
 				});
 			} else {
-				seen.set(name, t);
+				seen.set(name, item);
 			}
 		}
 
-		return { themes: Array.from(seen.values()), diagnostics };
+		return { items: Array.from(seen.values()), diagnostics };
 	}
 
-	private discoverSystemPromptFile(): string | undefined {
-		const projectPath = join(this.cwd, CONFIG_DIR_NAME, "SYSTEM.md");
-		if (existsSync(projectPath)) {
-			return projectPath;
-		}
-
-		const globalPath = join(this.agentDir, "SYSTEM.md");
-		if (existsSync(globalPath)) {
-			return globalPath;
-		}
-
-		return undefined;
-	}
-
-	private discoverAppendSystemPromptFile(): string | undefined {
-		const projectPath = join(this.cwd, CONFIG_DIR_NAME, "APPEND_SYSTEM.md");
-		if (existsSync(projectPath)) {
-			return projectPath;
-		}
-
-		const globalPath = join(this.agentDir, "APPEND_SYSTEM.md");
-		if (existsSync(globalPath)) {
-			return globalPath;
+	private discoverFileInSearchPaths(filename: string): string | undefined {
+		const searchDirs = [join(this.cwd, CONFIG_DIR_NAME), this.agentDir];
+		for (const dir of searchDirs) {
+			const filePath = join(dir, filename);
+			if (existsSync(filePath)) {
+				return filePath;
+			}
 		}
-
 		return undefined;
 	}