@sammorrowdrums/mcpi 0.70.9 → 0.85.0-bootstrap.0

package/dist/core/resource-loader.js

@@ -1,17 +1,18 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, resolve, sep } from "node:path";
+import { basename, dirname, join, resolve, sep } from "node:path";
 import chalk from "chalk";
 import { CONFIG_DIR_NAME } from "../config.js";
 import { loadThemeFromPath } from "../modes/interactive/theme/theme.js";
-import { isLocalPath } from "../utils/paths.js";
+import { canonicalizePath, isLocalPath, resolvePath } from "../utils/paths.js";
 import { createEventBus } from "./event-bus.js";
-import { createExtensionRuntime, loadExtensionFromFactory, loadExtensions } from "./extensions/loader.js";
+import { clearExtensionCache, createExtensionRuntime, loadExtensionFromFactory, loadExtensionsCached, } from "./extensions/loader.js";
+import { findGitPaths } from "./footer-data-provider.js";
 import { DefaultPackageManager } from "./package-manager.js";
 import { loadPromptTemplates } from "./prompt-templates.js";
 import { SettingsManager } from "./settings-manager.js";
 import { loadSkills } from "./skills.js";
 import { createSourceInfo } from "./source-info.js";
+import { resetTimings } from "./timings.js";
 function resolvePromptInput(input, description) {
     if (!input) {
         return undefined;
@@ -28,11 +29,14 @@ function resolvePromptInput(input, description) {
     return input;
 }
 function loadContextFileFromDir(dir) {
-    const candidates = ["AGENTS.md", "CLAUDE.md"];
+    const candidates = ["AGENTS.override.md", "AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"];
     for (const filename of candidates) {
         const filePath = join(dir, filename);
         if (existsSync(filePath)) {
             try {
+                if (!statSync(filePath).isFile()) {
+                    continue;
+                }
                 return {
                     path: filePath,
                     content: readFileSync(filePath, "utf-8"),
@@ -45,9 +49,38 @@ function loadContextFileFromDir(dir) {
     }
     return null;
 }
+/**
+ * The main repo's context file that a nested linked worktree's own copy shadows: both
+ * occupy the same logical repository scope, so loading both applies that context twice. Returns
+ * undefined when nothing is shadowed, leaving normal ancestor inheritance alone.
+ *
+ * Returned canonicalized (realpath), because `git worktree add` writes the `.git`
+ * file's `gitdir:` target in realpath form while cwd may still be symlinked
+ * (macOS `/tmp` -> `/private/tmp`).
+ */
+function findShadowedContextFile(cwd) {
+    const gitPaths = findGitPaths(cwd);
+    if (!gitPaths)
+        return undefined;
+    const commonGitDir = canonicalizePath(gitPaths.commonGitDir);
+    const worktreeRoot = canonicalizePath(gitPaths.repoDir);
+    const mainRepoRoot = dirname(commonGitDir);
+    // False for an ordinary repo, where the two are the same dir, and for a sibling
+    // worktree (`git worktree add ../feat`), whose main repo is not an ancestor.
+    if (!worktreeRoot.startsWith(`${mainRepoRoot}${sep}`))
+        return undefined;
+    // dirname of the common git dir is the main worktree root only when that dir is
+    // itself checked out from the same repo. In a bare layout (`proj/.bare` +
+    // `proj/main`) it is just the directory holding `.bare`, which tracks nothing; a
+    // submodule's gitdir has no `commondir`, so it lands under `.git/modules`.
+    if (canonicalizePath(join(mainRepoRoot, ".git")) !== commonGitDir)
+        return undefined;
+    const worktreeContextFile = loadContextFileFromDir(worktreeRoot);
+    return worktreeContextFile ? join(mainRepoRoot, basename(worktreeContextFile.path)) : undefined;
+}
 export function loadProjectContextFiles(options) {
-    const resolvedCwd = options.cwd;
-    const resolvedAgentDir = options.agentDir;
+    const resolvedCwd = resolvePath(options.cwd);
+    const resolvedAgentDir = resolvePath(options.agentDir);
     const contextFiles = [];
     const seenPaths = new Set();
     const globalContext = loadContextFileFromDir(resolvedAgentDir);
@@ -56,17 +89,16 @@ export function loadProjectContextFiles(options) {
         seenPaths.add(globalContext.path);
     }
     const ancestorContextFiles = [];
+    const shadowedContextFile = findShadowedContextFile(resolvedCwd);
     let currentDir = resolvedCwd;
-    const root = resolve("/");
     while (true) {
         const contextFile = loadContextFileFromDir(currentDir);
-        if (contextFile && !seenPaths.has(contextFile.path)) {
+        const isShadowed = shadowedContextFile !== undefined && canonicalizePath(contextFile?.path ?? "") === shadowedContextFile;
+        if (contextFile && !isShadowed && !seenPaths.has(contextFile.path)) {
             ancestorContextFiles.unshift(contextFile);
             seenPaths.add(contextFile.path);
         }
-        if (currentDir === root)
-            break;
-        const parentDir = resolve(currentDir, "..");
+        const parentDir = dirname(currentDir);
         if (parentDir === currentDir)
             break;
         currentDir = parentDir;
@@ -108,21 +140,26 @@ export class DefaultResourceLoader {
     themeDiagnostics;
     agentsFiles;
     systemPrompt;
+    systemPromptSourcePath;
     appendSystemPrompt;
+    appendSystemPromptSourcePaths;
     lastSkillPaths;
     extensionSkillSourceInfos;
     extensionPromptSourceInfos;
     extensionThemeSourceInfos;
+    resourceMetadataByPath;
     lastPromptPaths;
     lastThemePaths;
+    loaded;
     constructor(options) {
-        this.cwd = options.cwd;
-        this.agentDir = options.agentDir;
+        this.cwd = resolvePath(options.cwd);
+        this.agentDir = resolvePath(options.agentDir);
         this.settingsManager = options.settingsManager ?? SettingsManager.create(this.cwd, this.agentDir);
         this.eventBus = options.eventBus ?? createEventBus();
         this.packageManager = new DefaultPackageManager({
             cwd: this.cwd,
             agentDir: this.agentDir,
+            cacheDir: options.cacheDir,
             settingsManager: this.settingsManager,
         });
         this.additionalExtensionPaths = options.additionalExtensionPaths ?? [];
@@ -153,12 +190,15 @@ export class DefaultResourceLoader {
         this.themeDiagnostics = [];
         this.agentsFiles = [];
         this.appendSystemPrompt = [];
+        this.appendSystemPromptSourcePaths = [];
         this.lastSkillPaths = [];
         this.extensionSkillSourceInfos = new Map();
         this.extensionPromptSourceInfos = new Map();
         this.extensionThemeSourceInfos = new Map();
+        this.resourceMetadataByPath = new Map();
         this.lastPromptPaths = [];
         this.lastThemePaths = [];
+        this.loaded = false;
     }
     getExtensions() {
         return this.extensionsResult;
@@ -178,9 +218,15 @@ export class DefaultResourceLoader {
     getSystemPrompt() {
         return this.systemPrompt;
     }
+    getSystemPromptSource() {
+        return this.systemPromptSourcePath ? { path: this.systemPromptSourcePath } : undefined;
+    }
     getAppendSystemPrompt() {
         return this.appendSystemPrompt;
     }
+    getAppendSystemPromptSources() {
+        return this.appendSystemPromptSourcePaths.map((path) => ({ path }));
+    }
     extendResources(paths) {
         const skillPaths = this.normalizeExtensionPaths(paths.skillPaths ?? []);
         const promptPaths = this.normalizeExtensionPaths(paths.promptPaths ?? []);
@@ -196,24 +242,44 @@ export class DefaultResourceLoader {
         }
         if (skillPaths.length > 0) {
             this.lastSkillPaths = this.mergePaths(this.lastSkillPaths, skillPaths.map((entry) => entry.path));
-            this.updateSkillsFromPaths(this.lastSkillPaths);
+            this.updateSkillsFromPaths(this.lastSkillPaths, this.resourceMetadataByPath);
         }
         if (promptPaths.length > 0) {
             this.lastPromptPaths = this.mergePaths(this.lastPromptPaths, promptPaths.map((entry) => entry.path));
-            this.updatePromptsFromPaths(this.lastPromptPaths);
+            this.updatePromptsFromPaths(this.lastPromptPaths, this.resourceMetadataByPath);
         }
         if (themePaths.length > 0) {
             this.lastThemePaths = this.mergePaths(this.lastThemePaths, themePaths.map((entry) => entry.path));
-            this.updateThemesFromPaths(this.lastThemePaths);
+            this.updateThemesFromPaths(this.lastThemePaths, this.resourceMetadataByPath);
         }
     }
-    async reload() {
+    async loadProjectTrustExtensions() {
+        // Force untrusted project settings for the bootstrap pass. This keeps project-local
+        // extensions/packages out while still loading user/global and temporary CLI extensions.
+        this.settingsManager.setProjectTrusted(false);
+        await this.settingsManager.reload();
+        return this.loadCurrentExtensionSet({ includeInlineFactories: true });
+    }
+    async reload(options) {
+        resetTimings("extensions");
+        if (this.loaded) {
+            clearExtensionCache();
+        }
+        let preTrustExtensions;
+        if (options?.resolveProjectTrust) {
+            preTrustExtensions = await this.loadProjectTrustExtensions();
+            const projectTrusted = await options.resolveProjectTrust({ extensionsResult: preTrustExtensions });
+            this.settingsManager.setProjectTrusted(projectTrusted);
+        }
+        // reload() preserves SettingsManager.projectTrusted and reloads settings for that trust state.
         await this.settingsManager.reload();
         const resolvedPaths = await this.packageManager.resolve();
         const cliExtensionPaths = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, {
             temporary: true,
         });
-        const metadataByPath = new Map();
+        // Kept on the instance so post-reload passes (extendResources) can still resolve package metadata.
+        this.resourceMetadataByPath = new Map();
+        const metadataByPath = this.resourceMetadataByPath;
         this.extensionSkillSourceInfos = new Map();
         this.extensionPromptSourceInfos = new Map();
         this.extensionThemeSourceInfos = new Map();
@@ -231,29 +297,7 @@ export class DefaultResourceLoader {
         const enabledSkillResources = getEnabledResources(resolvedPaths.skills);
         const enabledPrompts = getEnabledPaths(resolvedPaths.prompts);
         const enabledThemes = getEnabledPaths(resolvedPaths.themes);
-        const mapSkillPath = (resource) => {
-            if (resource.metadata.source !== "auto" && resource.metadata.origin !== "package") {
-                return resource.path;
-            }
-            try {
-                const stats = statSync(resource.path);
-                if (!stats.isDirectory()) {
-                    return resource.path;
-                }
-            }
-            catch {
-                return resource.path;
-            }
-            const skillFile = join(resource.path, "SKILL.md");
-            if (existsSync(skillFile)) {
-                if (!metadataByPath.has(skillFile)) {
-                    metadataByPath.set(skillFile, resource.metadata);
-                }
-                return skillFile;
-            }
-            return resource.path;
-        };
-        const enabledSkills = enabledSkillResources.map(mapSkillPath);
+        const enabledSkills = enabledSkillResources.map((resource) => this.mapSkillPath(resource, metadataByPath));
         // Add CLI paths metadata
         for (const r of cliExtensionPaths.extensions) {
             if (!metadataByPath.has(r.path)) {
@@ -272,19 +316,13 @@ export class DefaultResourceLoader {
         const extensionPaths = this.noExtensions
             ? cliEnabledExtensions
             : this.mergePaths(cliEnabledExtensions, enabledExtensions);
-        const extensionsResult = await loadExtensions(extensionPaths, this.cwd, this.eventBus);
-        const inlineExtensions = await this.loadExtensionFactories(extensionsResult.runtime);
-        extensionsResult.extensions.push(...inlineExtensions.extensions);
-        extensionsResult.errors.push(...inlineExtensions.errors);
-        // Detect extension conflicts (tools, commands, flags with same names from different extensions)
-        // Keep all extensions loaded. Conflicts are reported as diagnostics, and precedence is handled by load order.
-        const conflicts = this.detectExtensionConflicts(extensionsResult.extensions);
-        for (const conflict of conflicts) {
-            extensionsResult.errors.push({ path: conflict.path, error: conflict.message });
-        }
+        const extensionsResult = await this.loadFinalExtensionSet(extensionPaths, preTrustExtensions);
         for (const p of this.additionalExtensionPaths) {
-            if (isLocalPath(p) && !existsSync(p)) {
-                extensionsResult.errors.push({ path: p, error: `Extension path does not exist: ${p}` });
+            if (isLocalPath(p)) {
+                const resolved = this.resolveResourcePath(p);
+                if (!existsSync(resolved)) {
+                    extensionsResult.errors.push({ path: resolved, error: `Extension path does not exist: ${resolved}` });
+                }
             }
         }
         this.extensionsResult = this.extensionsOverride ? this.extensionsOverride(extensionsResult) : extensionsResult;
@@ -295,8 +333,11 @@ export class DefaultResourceLoader {
         this.lastSkillPaths = skillPaths;
         this.updateSkillsFromPaths(skillPaths, metadataByPath);
         for (const p of this.additionalSkillPaths) {
-            if (isLocalPath(p) && !existsSync(p) && !this.skillDiagnostics.some((d) => d.path === p)) {
-                this.skillDiagnostics.push({ type: "error", message: "Skill path does not exist", path: p });
+            if (isLocalPath(p)) {
+                const resolved = this.resolveResourcePath(p);
+                if (!existsSync(resolved) && !this.skillDiagnostics.some((d) => d.path === resolved)) {
+                    this.skillDiagnostics.push({ type: "error", message: "Skill path does not exist", path: resolved });
+                }
             }
         }
         const promptPaths = this.noPromptTemplates
@@ -305,8 +346,15 @@ export class DefaultResourceLoader {
         this.lastPromptPaths = promptPaths;
         this.updatePromptsFromPaths(promptPaths, metadataByPath);
         for (const p of this.additionalPromptTemplatePaths) {
-            if (isLocalPath(p) && !existsSync(p) && !this.promptDiagnostics.some((d) => d.path === p)) {
-                this.promptDiagnostics.push({ type: "error", message: "Prompt template path does not exist", path: p });
+            if (isLocalPath(p)) {
+                const resolved = this.resolveResourcePath(p);
+                if (!existsSync(resolved) && !this.promptDiagnostics.some((d) => d.path === resolved)) {
+                    this.promptDiagnostics.push({
+                        type: "error",
+                        message: "Prompt template path does not exist",
+                        path: resolved,
+                    });
+                }
             }
         }
         const themePaths = this.noThemes
@@ -315,31 +363,139 @@ export class DefaultResourceLoader {
         this.lastThemePaths = themePaths;
         this.updateThemesFromPaths(themePaths, metadataByPath);
         for (const p of this.additionalThemePaths) {
-            if (!existsSync(p) && !this.themeDiagnostics.some((d) => d.path === p)) {
-                this.themeDiagnostics.push({ type: "error", message: "Theme path does not exist", path: p });
+            const resolved = this.resolveResourcePath(p);
+            if (!existsSync(resolved) && !this.themeDiagnostics.some((d) => d.path === resolved)) {
+                this.themeDiagnostics.push({ type: "error", message: "Theme path does not exist", path: resolved });
             }
         }
         const agentsFiles = {
-            agentsFiles: this.noContextFiles ? [] : loadProjectContextFiles({ cwd: this.cwd, agentDir: this.agentDir }),
+            agentsFiles: this.noContextFiles
+                ? []
+                : loadProjectContextFiles({
+                    cwd: this.cwd,
+                    agentDir: this.agentDir,
+                }),
         };
         const resolvedAgentsFiles = this.agentsFilesOverride ? this.agentsFilesOverride(agentsFiles) : agentsFiles;
         this.agentsFiles = resolvedAgentsFiles.agentsFiles;
-        const baseSystemPrompt = resolvePromptInput(this.systemPromptSource ?? this.discoverSystemPromptFile(), "system prompt");
+        const systemPromptSource = this.systemPromptSource ?? this.discoverSystemPromptFile();
+        const baseSystemPrompt = resolvePromptInput(systemPromptSource, "system prompt");
         this.systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(baseSystemPrompt) : baseSystemPrompt;
-        const appendSources = this.appendSystemPromptSource ??
-            (this.discoverAppendSystemPromptFile() ? [this.discoverAppendSystemPromptFile()] : []);
+        this.systemPromptSourcePath =
+            systemPromptSource && existsSync(systemPromptSource) ? resolvePath(systemPromptSource) : undefined;
+        let appendSources = this.appendSystemPromptSource;
+        if (!appendSources) {
+            const discoveredAppendSystemPromptFile = this.discoverAppendSystemPromptFile();
+            appendSources = discoveredAppendSystemPromptFile ? [discoveredAppendSystemPromptFile] : [];
+        }
         const baseAppend = appendSources
             .map((s) => resolvePromptInput(s, "append system prompt"))
             .filter((s) => s !== undefined);
         this.appendSystemPrompt = this.appendSystemPromptOverride
             ? this.appendSystemPromptOverride(baseAppend)
             : baseAppend;
+        this.appendSystemPromptSourcePaths = appendSources
+            .filter((source) => existsSync(source))
+            .map((source) => resolvePath(source));
+        this.loaded = true;
+    }
+    async loadCurrentExtensionSet(options) {
+        const resolvedPaths = await this.packageManager.resolve();
+        const cliExtensionPaths = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, {
+            temporary: true,
+        });
+        const enabledExtensions = resolvedPaths.extensions.filter((r) => r.enabled).map((r) => r.path);
+        const cliEnabledExtensions = cliExtensionPaths.extensions.filter((r) => r.enabled).map((r) => r.path);
+        const extensionPaths = this.noExtensions
+            ? cliEnabledExtensions
+            : this.mergePaths(cliEnabledExtensions, enabledExtensions);
+        const extensionsResult = await loadExtensionsCached(extensionPaths, this.cwd, this.eventBus);
+        if (!options.includeInlineFactories) {
+            return extensionsResult;
+        }
+        const inlineExtensions = await this.loadExtensionFactories(extensionsResult.runtime);
+        extensionsResult.extensions.push(...inlineExtensions.extensions);
+        extensionsResult.errors.push(...inlineExtensions.errors);
+        return extensionsResult;
+    }
+    resolveExtensionLoadPath(path) {
+        return resolvePath(path, this.cwd, { normalizeUnicodeSpaces: true });
+    }
+    async loadFinalExtensionSet(extensionPaths, preTrustExtensions) {
+        if (!preTrustExtensions) {
+            const extensionsResult = await loadExtensionsCached(extensionPaths, this.cwd, this.eventBus);
+            const inlineExtensions = await this.loadExtensionFactories(extensionsResult.runtime);
+            extensionsResult.extensions.push(...inlineExtensions.extensions);
+            extensionsResult.errors.push(...inlineExtensions.errors);
+            this.addExtensionConflictDiagnostics(extensionsResult);
+            return extensionsResult;
+        }
+        const preloadedByPath = new Map(preTrustExtensions.extensions
+            .filter((extension) => !extension.path.startsWith("<inline:"))
+            .map((extension) => [extension.resolvedPath, extension]));
+        const failedPreloadPaths = new Set(preTrustExtensions.errors.map((error) => this.resolveExtensionLoadPath(error.path)));
+        const remainingPaths = extensionPaths.filter((path) => {
+            const resolvedPath = this.resolveExtensionLoadPath(path);
+            return !preloadedByPath.has(resolvedPath) && !failedPreloadPaths.has(resolvedPath);
+        });
+        const remainingExtensions = await loadExtensionsCached(remainingPaths, this.cwd, this.eventBus, preTrustExtensions.runtime);
+        const loadedByPath = new Map(preloadedByPath);
+        for (const extension of remainingExtensions.extensions) {
+            loadedByPath.set(extension.resolvedPath, extension);
+        }
+        const inlineExtensions = preTrustExtensions.extensions.filter((extension) => extension.path.startsWith("<inline:"));
+        const orderedExtensions = extensionPaths
+            .map((path) => loadedByPath.get(this.resolveExtensionLoadPath(path)))
+            .filter((extension) => extension !== undefined);
+        orderedExtensions.push(...inlineExtensions);
+        const extensionsResult = {
+            extensions: orderedExtensions,
+            errors: [...preTrustExtensions.errors, ...remainingExtensions.errors],
+            runtime: preTrustExtensions.runtime,
+        };
+        this.addExtensionConflictDiagnostics(extensionsResult);
+        return extensionsResult;
+    }
+    addExtensionConflictDiagnostics(extensionsResult) {
+        // Detect extension conflicts (tools, commands, flags with same names from different extensions)
+        // Keep all extensions loaded. Conflicts are reported as diagnostics, and precedence is handled by load order.
+        const conflicts = this.detectExtensionConflicts(extensionsResult.extensions);
+        for (const conflict of conflicts) {
+            extensionsResult.errors.push({ path: conflict.path, error: conflict.message });
+        }
+    }
+    mapSkillPath(resource, metadataByPath) {
+        if (resource.metadata.source !== "auto" && resource.metadata.origin !== "package") {
+            return resource.path;
+        }
+        try {
+            const stats = statSync(resource.path);
+            if (!stats.isDirectory()) {
+                return resource.path;
+            }
+        }
+        catch {
+            return resource.path;
+        }
+        const skillFile = join(resource.path, "SKILL.md");
+        if (existsSync(skillFile)) {
+            if (!metadataByPath.has(skillFile)) {
+                metadataByPath.set(skillFile, resource.metadata);
+            }
+            return skillFile;
+        }
+        return resource.path;
     }
     normalizeExtensionPaths(entries) {
-        return entries.map((entry) => ({
-            path: this.resolveResourcePath(entry.path),
-            metadata: entry.metadata,
-        }));
+        return entries.map((entry) => {
+            const metadata = entry.metadata.baseDir
+                ? { ...entry.metadata, baseDir: this.resolveResourcePath(entry.metadata.baseDir) }
+                : entry.metadata;
+            return {
+                path: this.resolveResourcePath(entry.path),
+                metadata,
+            };
+        });
     }
     updateSkillsFromPaths(skillPaths, metadataByPath) {
         let skillsResult;
@@ -498,26 +654,16 @@ export class DefaultResourceLoader {
         const seen = new Set();
         for (const p of [...primary, ...additional]) {
             const resolved = this.resolveResourcePath(p);
-            if (seen.has(resolved))
+            const canonicalPath = canonicalizePath(resolved);
+            if (seen.has(canonicalPath))
                 continue;
-            seen.add(resolved);
+            seen.add(canonicalPath);
             merged.push(resolved);
         }
         return merged;
     }
     resolveResourcePath(p) {
-        const trimmed = p.trim();
-        let expanded = trimmed;
-        if (trimmed === "~") {
-            expanded = homedir();
-        }
-        else if (trimmed.startsWith("~/")) {
-            expanded = join(homedir(), trimmed.slice(2));
-        }
-        else if (trimmed.startsWith("~")) {
-            expanded = join(homedir(), trimmed.slice(1));
-        }
-        return resolve(this.cwd, expanded);
+        return resolvePath(p, this.cwd, { trim: true });
     }
     loadThemes(paths, includeDefaults = true) {
         const themes = [];
@@ -529,7 +675,7 @@ export class DefaultResourceLoader {
             }
         }
         for (const p of paths) {
-            const resolved = resolve(this.cwd, p);
+            const resolved = this.resolveResourcePath(p);
             if (!existsSync(resolved)) {
                 diagnostics.push({ type: "warning", message: "theme path does not exist", path: resolved });
                 continue;
@@ -595,10 +741,13 @@ export class DefaultResourceLoader {
     async loadExtensionFactories(runtime) {
         const extensions = [];
         const errors = [];
-        for (const [index, factory] of this.extensionFactories.entries()) {
-            const extensionPath = `<inline:${index + 1}>`;
+        for (const [index, input] of this.extensionFactories.entries()) {
+            const isNamed = typeof input !== "function";
+            const factory = isNamed ? input.factory : input;
+            const extensionPath = `<inline:${isNamed ? input.name : index + 1}>`;
             try {
                 const extension = await loadExtensionFromFactory(factory, this.cwd, this.eventBus, runtime, extensionPath);
+                extension.hidden = isNamed && input.hidden;
                 extensions.push(extension);
             }
             catch (error) {
@@ -659,7 +808,7 @@ export class DefaultResourceLoader {
     }
     discoverSystemPromptFile() {
         const projectPath = join(this.cwd, CONFIG_DIR_NAME, "SYSTEM.md");
-        if (existsSync(projectPath)) {
+        if (this.settingsManager.isProjectTrusted() && existsSync(projectPath)) {
             return projectPath;
         }
         const globalPath = join(this.agentDir, "SYSTEM.md");
@@ -670,7 +819,7 @@ export class DefaultResourceLoader {
     }
     discoverAppendSystemPromptFile() {
         const projectPath = join(this.cwd, CONFIG_DIR_NAME, "APPEND_SYSTEM.md");
-        if (existsSync(projectPath)) {
+        if (this.settingsManager.isProjectTrusted() && existsSync(projectPath)) {
             return projectPath;
         }
         const globalPath = join(this.agentDir, "APPEND_SYSTEM.md");