@gajae-code/coding-agent 0.16.7 → 0.17.1

package/src/discovery/claude-plugins.ts

@@ -16,7 +16,9 @@ import type { LoadContext, LoadResult } from "../capability/types";
 import { rootContainsGjcManifest } from "../extensibility/gjc-plugins";
 import {
 	type ClaudePluginRoot,
+	canonicalizePathWithinHome,
 	createSourceMeta,
+	getReadOptionsForContainment,
 	invalidateClaudePluginRoots,
 	listClaudePluginRoots,
 	loadFilesFromDir,
@@ -40,9 +42,20 @@ interface ResolvedPluginDir {
 	warning?: string;
 }
 
-async function readPluginManifest(root: ClaudePluginRoot): Promise<ClaudePluginManifest | null> {
-	const manifestPath = path.join(root.path, ".claude-plugin", "plugin.json");
-	const raw = await readFile(manifestPath);
+async function readPluginManifest(
+	root: ClaudePluginRoot,
+	ctx: Pick<LoadContext, "home" | "isolatedHome" | "userAgentDir" | "homeIdentity" | "userAgentIdentity">,
+): Promise<ClaudePluginManifest | null> {
+	const manifestPath = await canonicalizePathWithinHome(
+		ctx,
+		path.join(root.path, ".claude-plugin", "plugin.json"),
+		root.path,
+		root.scope,
+	);
+	if (!manifestPath) return null;
+	const readOptions = await getReadOptionsForContainment(ctx, root.scope, root.path);
+	if (ctx.isolatedHome && !readOptions) return null;
+	const raw = await readFile(manifestPath, readOptions);
 	if (raw === null) return null;
 
 	try {
@@ -60,11 +73,12 @@ function isWithinPluginRoot(rootPath: string, targetPath: string): boolean {
 }
 
 async function resolvePluginDir(
+	ctx: Pick<LoadContext, "home" | "isolatedHome" | "userAgentDir" | "homeIdentity" | "userAgentIdentity">,
 	root: ClaudePluginRoot,
 	manifestKeys: ReadonlyArray<keyof ClaudePluginManifest>,
 	fallback: string,
 ): Promise<ResolvedPluginDir> {
-	const manifest = await readPluginManifest(root);
+	const manifest = await readPluginManifest(root, ctx);
 	const fallbackDir = path.join(root.path, fallback);
 
 	let configured: string | undefined;
@@ -84,7 +98,8 @@ async function resolvePluginDir(
 
 	const resolved = path.resolve(root.path, configured);
 	if (isWithinPluginRoot(root.path, resolved)) {
-		return { dir: resolved };
+		const canonical = await canonicalizePathWithinHome(ctx, resolved, root.path, root.scope);
+		if (canonical) return { dir: canonical };
 	}
 
 	return {
@@ -96,16 +111,27 @@ async function resolvePluginDir(
 async function listNonGjcPluginRoots(
 	home: string,
 	cwd: string,
+	isolatedHome: boolean,
+	homeIdentity?: LoadContext["homeIdentity"],
 	allowedLevels: ReadonlySet<"user" | "project"> = new Set(["user", "project"]),
 ): Promise<{ roots: ClaudePluginRoot[]; warnings: string[] }> {
-	await invalidateClaudePluginRoots(home, cwd);
-	const { roots, warnings } = await listClaudePluginRoots(home, cwd);
+	await invalidateClaudePluginRoots(home, cwd, isolatedHome);
+	const { roots, warnings } = await listClaudePluginRoots(home, cwd, isolatedHome, homeIdentity);
 	const filteredRoots: ClaudePluginRoot[] = [];
 	const filteredWarnings = allowedLevels.size === 2 ? [...warnings] : [];
 
 	for (const root of roots) {
 		if (!allowedLevels.has(root.scope)) continue;
-		if (await rootContainsGjcManifest(root.path)) {
+		const manifestReadOptions = isolatedHome
+			? {
+					isolatedHome: true,
+					home,
+					homeIdentity,
+					scope: "project" as const,
+					bypassCache: true,
+				}
+			: undefined;
+		if (await rootContainsGjcManifest(root.path, manifestReadOptions)) {
 			filteredWarnings.push(`[claude-plugins] Skipping gajae-code plugin root (binding-only): ${root.path}`);
 			continue;
 		}
@@ -126,17 +152,25 @@ export async function loadMarketplaceSkills(
 	const items: Skill[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(ctx.home, ctx.cwd, allowedLevels);
+	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(
+		ctx.home,
+		ctx.cwd,
+		ctx.isolatedHome ?? false,
+		ctx.homeIdentity,
+		allowedLevels,
+	);
 	warnings.push(...rootWarnings);
 
 	const results = await Promise.all(
 		roots.map(async root => {
-			const { dir: skillsDir, warning } = await resolvePluginDir(root, ["skills"], "skills");
+			const { dir: skillsDir, warning } = await resolvePluginDir(ctx, root, ["skills"], "skills");
 			const result = await scanSkillsFromDir(ctx, {
 				dir: skillsDir,
 				providerId: PROVIDER_ID,
 				level: root.scope,
 				requireDescription: true,
+				containmentRoot: root.path,
+				scope: root.scope,
 			});
 			return { root, result, warning };
 		}),
@@ -162,14 +196,26 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 	const items: SlashCommand[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(ctx.home, ctx.cwd);
+	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(
+		ctx.home,
+		ctx.cwd,
+		ctx.isolatedHome ?? false,
+		ctx.homeIdentity,
+	);
 	warnings.push(...rootWarnings);
 
 	const results = await Promise.all(
 		roots.map(async root => {
-			const { dir: commandsDir, warning } = await resolvePluginDir(root, ["commands", "slash-commands"], "commands");
+			const { dir: commandsDir, warning } = await resolvePluginDir(
+				ctx,
+				root,
+				["commands", "slash-commands"],
+				"commands",
+			);
 			const result = await loadFilesFromDir<SlashCommand>(ctx, commandsDir, PROVIDER_ID, root.scope, {
 				extensions: ["md"],
+				containmentRoot: root.path,
+				scope: root.scope,
 				transform: (name, content, filePath, source) => {
 					const cmdName = name.replace(/\.md$/, "");
 					return {
@@ -202,7 +248,12 @@ async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 	const items: Hook[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(ctx.home, ctx.cwd);
+	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(
+		ctx.home,
+		ctx.cwd,
+		ctx.isolatedHome ?? false,
+		ctx.homeIdentity,
+	);
 	warnings.push(...rootWarnings);
 
 	const hookTypes = ["pre", "post"] as const;
@@ -218,6 +269,8 @@ async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 		loadTasks.map(async ({ root, hookType }) => {
 			const hooksDir = path.join(root.path, "hooks", hookType);
 			return loadFilesFromDir<Hook>(ctx, hooksDir, PROVIDER_ID, root.scope, {
+				containmentRoot: root.path,
+				scope: root.scope,
 				transform: (name, _content, filePath, source) => {
 					const toolName = name.replace(/\.(sh|bash|zsh|fish)$/, "");
 					return {
@@ -249,13 +302,20 @@ async function loadTools(ctx: LoadContext): Promise<LoadResult<CustomTool>> {
 	const items: CustomTool[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(ctx.home, ctx.cwd);
+	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(
+		ctx.home,
+		ctx.cwd,
+		ctx.isolatedHome ?? false,
+		ctx.homeIdentity,
+	);
 	warnings.push(...rootWarnings);
 
 	const results = await Promise.all(
 		roots.map(async root => {
 			const toolsDir = path.join(root.path, "tools");
 			return loadFilesFromDir<CustomTool>(ctx, toolsDir, PROVIDER_ID, root.scope, {
+				containmentRoot: root.path,
+				scope: root.scope,
 				transform: (name, _content, filePath, source) => {
 					const toolName = name.replace(/\.(ts|js|sh|bash|py)$/, "");
 					return {
@@ -286,12 +346,20 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 	const items: MCPServer[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(ctx.home, ctx.cwd);
+	const { roots, warnings: rootWarnings } = await listNonGjcPluginRoots(
+		ctx.home,
+		ctx.cwd,
+		ctx.isolatedHome ?? false,
+		ctx.homeIdentity,
+	);
 	warnings.push(...rootWarnings);
 
 	for (const root of roots) {
-		const mcpPath = path.join(root.path, ".mcp.json");
-		const raw = await readFile(mcpPath);
+		const mcpPath = await canonicalizePathWithinHome(ctx, path.join(root.path, ".mcp.json"), root.path, root.scope);
+		if (!mcpPath) continue;
+		const readOptions = await getReadOptionsForContainment(ctx, root.scope, root.path);
+		if (ctx.isolatedHome && !readOptions) continue;
+		const raw = await readFile(mcpPath, readOptions);
 		if (raw === null) continue; // file absent — skip silently
 
 		let parsed: unknown;

package/src/discovery/cline.ts

@@ -6,21 +6,38 @@
  */
 import * as path from "node:path";
 import { registerProvider } from "../capability";
-import { readDirEntries, readFile } from "../capability/fs";
+import { type ReadFileOptions, readDirEntries, readFile } from "../capability/fs";
 import type { Rule } from "../capability/rule";
 import { ruleCapability } from "../capability/rule";
 import type { LoadContext, LoadResult } from "../capability/types";
-import { buildRuleFromMarkdown, createSourceMeta, loadFilesFromDir } from "./helpers";
+import {
+	buildRuleFromMarkdown,
+	canonicalizePathWithinHome,
+	createSourceMeta,
+	getReadOptions,
+	loadFilesFromDir,
+} from "./helpers";
 
 const PROVIDER_ID = "cline";
 const DISPLAY_NAME = "Cline";
 const PRIORITY = 40;
 
-async function findClinerules(startDir: string): Promise<{ path: string; isDir: boolean } | null> {
+async function findClinerules(
+	startDir: string,
+	stopAt: string,
+	readOptions?: ReadFileOptions,
+): Promise<{ path: string; isDir: boolean } | null> {
 	let current = path.resolve(startDir);
+	const resolvedStop = path.resolve(stopAt);
+	const relativeStop = path.relative(resolvedStop, current);
+	const effectiveStop =
+		relativeStop === "" ||
+		(relativeStop !== ".." && !relativeStop.startsWith(`..${path.sep}`) && !path.isAbsolute(relativeStop))
+			? resolvedStop
+			: current;
 
 	while (true) {
-		const entries = await readDirEntries(current);
+		const entries = await readDirEntries(current, readOptions);
 		const entry = entries.find(e => e.name === ".clinerules");
 		if (entry) {
 			return {
@@ -29,7 +46,7 @@ async function findClinerules(startDir: string): Promise<{ path: string; isDir:
 			};
 		}
 		const parent = path.dirname(current);
-		if (parent === current) return null;
+		if (current === effectiveStop || parent === current) return null;
 		current = parent;
 	}
 }
@@ -42,7 +59,13 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 	const warnings: string[] = [];
 
 	// Project-level only (Cline uses root-level .clinerules)
-	const found = await findClinerules(ctx.cwd);
+	const homeRelative = path.relative(ctx.home, ctx.cwd);
+	const cwdIsWithinHome =
+		homeRelative === "" ||
+		(homeRelative !== ".." && !homeRelative.startsWith(`..${path.sep}`) && !path.isAbsolute(homeRelative));
+	const stopDirectory = ctx.repoRoot ?? (ctx.isolatedHome || cwdIsWithinHome ? ctx.home : path.parse(ctx.cwd).root);
+	const readOptions = getReadOptions(ctx, "project");
+	const found = await findClinerules(ctx.cwd, stopDirectory, readOptions);
 	if (!found) {
 		return { items, warnings };
 	}
@@ -60,14 +83,19 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 		if (result.warnings) warnings.push(...result.warnings);
 	} else {
 		// Single file format
-		const content = await readFile(found.path);
+		const filePath = await canonicalizePathWithinHome(ctx, found.path, undefined, "project");
+		if (!filePath) {
+			warnings.push(`Refusing to read .clinerules outside the supplied home at ${found.path}`);
+			return { items, warnings };
+		}
+		const content = await readFile(filePath, readOptions);
 		if (content === null) {
-			warnings.push(`Failed to read .clinerules at ${found.path}`);
+			warnings.push(`Failed to read .clinerules at ${filePath}`);
 			return { items, warnings };
 		}
 
-		const source = createSourceMeta(PROVIDER_ID, found.path, "project");
-		items.push(buildRuleFromMarkdown("clinerules.md", content, found.path, source, { ruleName: "clinerules" }));
+		const source = createSourceMeta(PROVIDER_ID, filePath, "project");
+		items.push(buildRuleFromMarkdown("clinerules.md", content, filePath, source, { ruleName: "clinerules" }));
 	}
 
 	return { items, warnings };

package/src/discovery/cursor.ts

@@ -25,7 +25,15 @@ import { ruleCapability } from "../capability/rule";
 import type { Settings } from "../capability/settings";
 import { settingsCapability } from "../capability/settings";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
-import { buildRuleFromMarkdown, createSourceMeta, getProjectPath, getUserPath, loadFilesFromDir } from "./helpers";
+import {
+	buildRuleFromMarkdown,
+	canonicalizePathWithinHome,
+	createSourceMeta,
+	getProjectPath,
+	getReadOptions,
+	getUserPath,
+	loadFilesFromDir,
+} from "./helpers";
 
 const PROVIDER_ID = "cursor";
 const DISPLAY_NAME = "Cursor";
@@ -79,15 +87,20 @@ async function loadSettings(ctx: LoadContext): Promise<LoadResult<Settings>> {
 	const items: Settings[] = [];
 	const warnings: string[] = [];
 
-	const userPath = getUserPath(ctx, "cursor", "settings.json");
+	const rawUserPath = getUserPath(ctx, "cursor", "settings.json");
+	const rawProjectPath = getProjectPath(ctx, "cursor", "settings.json");
 
-	const [userContent, projectPath] = await Promise.all([
-		userPath ? readFile(userPath) : Promise.resolve(null),
-		getProjectPath(ctx, "cursor", "settings.json"),
+	const [userPath, projectPath] = await Promise.all([
+		rawUserPath ? canonicalizePathWithinHome(ctx, rawUserPath, undefined, "user") : Promise.resolve(null),
+		rawProjectPath ? canonicalizePathWithinHome(ctx, rawProjectPath, undefined, "project") : Promise.resolve(null),
 	]);
 
-	const projectContentPromise = projectPath ? readFile(projectPath) : Promise.resolve(null);
+	const userContentPromise = userPath ? readFile(userPath, getReadOptions(ctx, "user")) : Promise.resolve(null);
+	const projectContentPromise = projectPath
+		? readFile(projectPath, getReadOptions(ctx, "project"))
+		: Promise.resolve(null);
 
+	const userContent = await userContentPromise;
 	if (userContent && userPath) {
 		const parsed = tryParseJson<Record<string, unknown>>(userContent);
 		if (parsed) {

package/src/discovery/gemini.ts

@@ -30,9 +30,11 @@ import type { LoadContext, LoadResult } from "../capability/types";
 import {
 	buildExtensionModuleItems,
 	calculateDepth,
+	canonicalizePathWithinHome,
 	createSourceMeta,
 	discoverExtensionModulePaths,
 	getProjectPath,
+	getReadOptions,
 	getUserPath,
 } from "./helpers";
 
@@ -49,9 +51,12 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 	const warnings: string[] = [];
 
 	// User-level: ~/.gemini/GEMINI.md
-	const userGeminiMd = getUserPath(ctx, "gemini", "GEMINI.md");
+	const rawUserGeminiMd = getUserPath(ctx, "gemini", "GEMINI.md");
+	const userGeminiMd = rawUserGeminiMd
+		? await canonicalizePathWithinHome(ctx, rawUserGeminiMd, undefined, "user")
+		: null;
 	if (userGeminiMd) {
-		const content = await readFile(userGeminiMd);
+		const content = await readFile(userGeminiMd, getReadOptions(ctx, "user"));
 		if (content) {
 			items.push({
 				path: userGeminiMd,
@@ -63,9 +68,12 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 	}
 
 	// Project-level: .gemini/GEMINI.md
-	const projectGeminiMd = getProjectPath(ctx, "gemini", "GEMINI.md");
+	const rawProjectGeminiMd = getProjectPath(ctx, "gemini", "GEMINI.md");
+	const projectGeminiMd = rawProjectGeminiMd
+		? await canonicalizePathWithinHome(ctx, rawProjectGeminiMd, undefined, "project")
+		: null;
 	if (projectGeminiMd) {
-		const content = await readFile(projectGeminiMd);
+		const content = await readFile(projectGeminiMd, getReadOptions(ctx, "project"));
 		if (content) {
 			const projectBase = getProjectPath(ctx, "gemini", "");
 			const depth = projectBase ? calculateDepth(ctx.cwd, projectBase, path.sep) : 0;
@@ -94,7 +102,7 @@ async function loadExtensions(ctx: LoadContext): Promise<LoadResult<Extension>>
 	// User-level: ~/.gemini/extensions/*/gemini-extension.json
 	const userExtPath = getUserPath(ctx, "gemini", "extensions");
 	if (userExtPath) {
-		const result = await loadExtensionsFromDir(userExtPath, "user");
+		const result = await loadExtensionsFromDir(ctx, userExtPath, "user");
 		items.push(...result.items);
 		if (result.warnings) warnings.push(...result.warnings);
 	}
@@ -102,7 +110,7 @@ async function loadExtensions(ctx: LoadContext): Promise<LoadResult<Extension>>
 	// Project-level: .gemini/extensions/*/gemini-extension.json
 	const projectExtPath = getProjectPath(ctx, "gemini", "extensions");
 	if (projectExtPath) {
-		const result = await loadExtensionsFromDir(projectExtPath, "project");
+		const result = await loadExtensionsFromDir(ctx, projectExtPath, "project");
 		items.push(...result.items);
 		if (result.warnings) warnings.push(...result.warnings);
 	}
@@ -110,15 +118,35 @@ async function loadExtensions(ctx: LoadContext): Promise<LoadResult<Extension>>
 	return { items, warnings };
 }
 
-async function loadExtensionsFromDir(extensionsDir: string, level: "user" | "project"): Promise<LoadResult<Extension>> {
-	const entries = await readDirEntries(extensionsDir);
+async function loadExtensionsFromDir(
+	ctx: LoadContext,
+	extensionsDir: string,
+	level: "user" | "project",
+): Promise<LoadResult<Extension>> {
+	const scope = level === "user" ? "user" : "project";
+	const readOptions = getReadOptions(ctx, scope);
+	const canonicalExtensionsDir = await canonicalizePathWithinHome(ctx, extensionsDir, undefined, scope);
+	if (!canonicalExtensionsDir) return { items: [], warnings: [] };
+	const entries = await readDirEntries(canonicalExtensionsDir, readOptions);
 	const dirEntries = entries.filter(entry => entry.isDirectory());
 
 	const results = await Promise.all(
 		dirEntries.map(async entry => {
-			const extPath = path.join(extensionsDir, entry.name);
-			const manifestPath = path.join(extPath, "gemini-extension.json");
-			const content = await readFile(manifestPath);
+			const extPath = await canonicalizePathWithinHome(
+				ctx,
+				path.join(canonicalExtensionsDir, entry.name),
+				undefined,
+				scope,
+			);
+			if (!extPath) return { entry, extPath: null, manifestPath: null, content: null };
+			const manifestPath = await canonicalizePathWithinHome(
+				ctx,
+				path.join(extPath, "gemini-extension.json"),
+				undefined,
+				scope,
+			);
+			if (!manifestPath) return { entry, extPath, manifestPath: null, content: null };
+			const content = await readFile(manifestPath, readOptions);
 			return { entry, extPath, manifestPath, content };
 		}),
 	);
@@ -127,7 +155,7 @@ async function loadExtensionsFromDir(extensionsDir: string, level: "user" | "pro
 	const warnings: string[] = [];
 
 	for (const { entry, extPath, manifestPath, content } of results) {
-		if (!content) continue;
+		if (!content || !extPath || !manifestPath) continue;
 
 		const manifest = tryParseJson<ExtensionManifest>(content);
 		if (!manifest) {
@@ -156,8 +184,10 @@ async function loadExtensionModules(ctx: LoadContext): Promise<LoadResult<Extens
 	const projectExtensionsDir = getProjectPath(ctx, "gemini", "extensions");
 
 	const [userPaths, projectPaths] = await Promise.all([
-		userExtensionsDir ? discoverExtensionModulePaths(ctx, userExtensionsDir) : Promise.resolve([]),
-		projectExtensionsDir ? discoverExtensionModulePaths(ctx, projectExtensionsDir) : Promise.resolve([]),
+		userExtensionsDir ? discoverExtensionModulePaths(ctx, userExtensionsDir, { scope: "user" }) : Promise.resolve([]),
+		projectExtensionsDir
+			? discoverExtensionModulePaths(ctx, projectExtensionsDir, { scope: "project" })
+			: Promise.resolve([]),
 	]);
 
 	const items = buildExtensionModuleItems(PROVIDER_ID, userPaths, projectPaths);
@@ -174,9 +204,10 @@ async function loadSettings(ctx: LoadContext): Promise<LoadResult<Settings>> {
 	const warnings: string[] = [];
 
 	// User-level: ~/.gemini/settings.json
-	const userPath = getUserPath(ctx, "gemini", "settings.json");
+	const rawUserPath = getUserPath(ctx, "gemini", "settings.json");
+	const userPath = rawUserPath ? await canonicalizePathWithinHome(ctx, rawUserPath, undefined, "user") : null;
 	if (userPath) {
-		const content = await readFile(userPath);
+		const content = await readFile(userPath, getReadOptions(ctx, "user"));
 		if (content) {
 			const parsed = tryParseJson<Record<string, unknown>>(content);
 			if (parsed) {
@@ -193,9 +224,12 @@ async function loadSettings(ctx: LoadContext): Promise<LoadResult<Settings>> {
 	}
 
 	// Project-level: .gemini/settings.json
-	const projectPath = getProjectPath(ctx, "gemini", "settings.json");
+	const rawProjectPath = getProjectPath(ctx, "gemini", "settings.json");
+	const projectPath = rawProjectPath
+		? await canonicalizePathWithinHome(ctx, rawProjectPath, undefined, "project")
+		: null;
 	if (projectPath) {
-		const content = await readFile(projectPath);
+		const content = await readFile(projectPath, getReadOptions(ctx, "project"));
 		if (content) {
 			const parsed = tryParseJson<Record<string, unknown>>(content);
 			if (parsed) {
@@ -234,9 +268,12 @@ async function loadSystemPrompt(ctx: LoadContext): Promise<LoadResult<SystemProm
 	const items: SystemPrompt[] = [];
 
 	// User-level: ~/.gemini/system.md
-	const userSystemMd = getUserPath(ctx, "gemini", "system.md");
+	const rawUserSystemMd = getUserPath(ctx, "gemini", "system.md");
+	const userSystemMd = rawUserSystemMd
+		? await canonicalizePathWithinHome(ctx, rawUserSystemMd, undefined, "user")
+		: null;
 	if (userSystemMd) {
-		const content = await readFile(userSystemMd);
+		const content = await readFile(userSystemMd, getReadOptions(ctx, "user"));
 		if (content) {
 			items.push({
 				path: userSystemMd,
@@ -248,9 +285,12 @@ async function loadSystemPrompt(ctx: LoadContext): Promise<LoadResult<SystemProm
 	}
 
 	// Project-level: .gemini/system.md
-	const projectSystemMd = getProjectPath(ctx, "gemini", "system.md");
+	const rawProjectSystemMd = getProjectPath(ctx, "gemini", "system.md");
+	const projectSystemMd = rawProjectSystemMd
+		? await canonicalizePathWithinHome(ctx, rawProjectSystemMd, undefined, "project")
+		: null;
 	if (projectSystemMd) {
-		const content = await readFile(projectSystemMd);
+		const content = await readFile(projectSystemMd, getReadOptions(ctx, "project"));
 		if (content) {
 			items.push({
 				path: projectSystemMd,

package/src/discovery/github.ts

@@ -19,7 +19,14 @@ import { readFile } from "../capability/fs";
 import { type Instruction, instructionCapability } from "../capability/instruction";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 
-import { calculateDepth, createSourceMeta, getProjectPath, loadFilesFromDir } from "./helpers";
+import {
+	calculateDepth,
+	canonicalizePathWithinHome,
+	createSourceMeta,
+	getProjectPath,
+	getReadOptions,
+	loadFilesFromDir,
+} from "./helpers";
 
 const PROVIDER_ID = "github";
 const DISPLAY_NAME = "GitHub Copilot";
@@ -33,9 +40,12 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 	const items: ContextFile[] = [];
 	const warnings: string[] = [];
 
-	const copilotInstructionsPath = getProjectPath(ctx, "github", "copilot-instructions.md");
+	const rawCopilotInstructionsPath = getProjectPath(ctx, "github", "copilot-instructions.md");
+	const copilotInstructionsPath = rawCopilotInstructionsPath
+		? await canonicalizePathWithinHome(ctx, rawCopilotInstructionsPath, undefined, "project")
+		: null;
 	if (copilotInstructionsPath) {
-		const content = await readFile(copilotInstructionsPath);
+		const content = await readFile(copilotInstructionsPath, getReadOptions(ctx, "project"));
 		if (content) {
 			const fileDir = path.dirname(copilotInstructionsPath);
 			const depth = calculateDepth(ctx.cwd, fileDir, path.sep);