@greppleai/grip 0.0.0-stage → 0.0.1

package/dist/core/resource-loader.js

@@ -0,0 +1,1209 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { 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 { canonicalizePath, isLocalPath, resolvePath } from "../utils/paths.js";
+import { createEventBus } from "./event-bus.js";
+import { createExtensionRuntime, loadExtensionFromFactory, loadExtensions } from "./extensions/loader.js";
+import { dirnamePortablePath, joinPortablePath, pathComparisonValue, relativeWithin } from "./lsp/portable-path.js";
+import { DefaultPackageManager, } from "./package-manager.js";
+import { loadPromptTemplates, loadPromptTemplatesWithOperations } from "./prompt-templates.js";
+import { loadRules, loadRulesWithOperations } from "./rules.js";
+import { SettingsManager } from "./settings-manager.js";
+import { loadSkills, loadSkillsWithOperations } from "./skills.js";
+import { createSourceInfo, createSyntheticSourceInfo } from "./source-info.js";
+import { resetTimings } from "./timings.js";
+function appendMissingResourceDiagnostic(resolvedPath, diagnostics, diagnosticPaths, message) {
+    if (existsSync(resolvedPath) || diagnosticPaths.has(resolvedPath))
+        return;
+    diagnostics.push({ type: "error", message, path: resolvedPath });
+    diagnosticPaths.add(resolvedPath);
+}
+function mergeNamedResources(primary, secondary, resourceType) {
+    const resources = new Map(primary.map((resource) => [resource.name, resource]));
+    const diagnostics = [];
+    for (const resource of secondary) {
+        const winner = resources.get(resource.name);
+        if (!winner) {
+            resources.set(resource.name, resource);
+            continue;
+        }
+        diagnostics.push({
+            type: "collision",
+            message: `name ${JSON.stringify(resource.name)} collision`,
+            path: resource.filePath,
+            collision: {
+                resourceType,
+                name: resource.name,
+                winnerPath: winner.filePath,
+                loserPath: resource.filePath,
+            },
+        });
+    }
+    return { resources: [...resources.values()], diagnostics };
+}
+async function resolvePromptInput(input, description, operations) {
+    if (!input) {
+        return undefined;
+    }
+    if (existsSync(input)) {
+        try {
+            return readFileSync(input, "utf-8");
+        }
+        catch (error) {
+            console.error(chalk.yellow(`Warning: Could not read ${description} file ${input}: ${error}`));
+            return input;
+        }
+    }
+    if (operations) {
+        try {
+            await operations.access(input, "read");
+            return (await operations.readFile(input)).toString("utf-8");
+        }
+        catch { }
+    }
+    return input;
+}
+const CONTEXT_FILE_CANDIDATES = ["AGENTS.override.md", "AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"];
+function loadContextFileFromDir(dir) {
+    for (const filename of CONTEXT_FILE_CANDIDATES) {
+        const filePath = join(dir, filename);
+        if (existsSync(filePath)) {
+            try {
+                if (!statSync(filePath).isFile())
+                    continue;
+                return {
+                    path: filePath,
+                    content: readFileSync(filePath, "utf-8"),
+                };
+            }
+            catch (error) {
+                console.error(chalk.yellow(`Warning: Could not read ${filePath}: ${error}`));
+            }
+        }
+    }
+    return null;
+}
+export function loadProjectContextFiles(options) {
+    const resolvedCwd = resolvePath(options.cwd);
+    const resolvedAgentDir = resolvePath(options.agentDir);
+    const contextFiles = [];
+    const seenPaths = new Set();
+    const globalContext = loadContextFileFromDir(resolvedAgentDir);
+    if (globalContext) {
+        contextFiles.push(globalContext);
+        seenPaths.add(globalContext.path);
+    }
+    const ancestorContextFiles = [];
+    let currentDir = resolvedCwd;
+    const root = resolve("/");
+    while (true) {
+        const contextFile = loadContextFileFromDir(currentDir);
+        if (contextFile && !seenPaths.has(contextFile.path)) {
+            ancestorContextFiles.unshift(contextFile);
+            seenPaths.add(contextFile.path);
+        }
+        if (currentDir === root)
+            break;
+        const parentDir = resolve(currentDir, "..");
+        if (parentDir === currentDir)
+            break;
+        currentDir = parentDir;
+    }
+    contextFiles.push(...ancestorContextFiles);
+    return contextFiles;
+}
+async function loadContextFileFromDirWithOperations(operations, dir, workspace) {
+    for (const filename of CONTEXT_FILE_CANDIDATES) {
+        const filePath = joinPortablePath(dir, filename);
+        try {
+            if (!(await operations.stat(filePath)).isFile())
+                continue;
+            await operations.access(filePath, "read");
+            return {
+                path: filePath,
+                content: (await operations.readFile(filePath)).toString("utf-8"),
+                sourceInfo: {
+                    path: filePath,
+                    source: "remote",
+                    scope: "project",
+                    origin: "top-level",
+                    baseDir: dir,
+                    ...(workspace ? { workspace } : {}),
+                },
+            };
+        }
+        catch { }
+    }
+    return null;
+}
+async function loadProjectContextFilesWithOperations(options) {
+    const contextFiles = [];
+    const seenPaths = new Set();
+    const globalContext = loadContextFileFromDir(resolvePath(options.agentDir));
+    if (globalContext) {
+        contextFiles.push(globalContext);
+        seenPaths.add(globalContext.path);
+    }
+    const sandboxUserContext = await loadDaemonContextFileWithOperations(options.operations, options.workspace, "AGENTS.md", "~/.grip/AGENTS.md", "user", "~/.grip");
+    if (sandboxUserContext && !seenPaths.has(sandboxUserContext.path)) {
+        contextFiles.push(sandboxUserContext);
+        seenPaths.add(sandboxUserContext.path);
+    }
+    const ancestorContextFiles = [];
+    let currentDir = options.cwd;
+    while (true) {
+        const contextFile = await loadContextFileFromDirWithOperations(options.operations, currentDir, options.workspace);
+        if (contextFile && !seenPaths.has(contextFile.path)) {
+            ancestorContextFiles.unshift(contextFile);
+            seenPaths.add(contextFile.path);
+        }
+        if (options.workspace &&
+            pathComparisonValue(currentDir, options.workspace.pathFlavor) ===
+                pathComparisonValue(options.workspace.root, options.workspace.pathFlavor))
+            break;
+        const parentDir = dirnamePortablePath(currentDir, options.workspace?.pathFlavor);
+        if (parentDir === currentDir)
+            break;
+        currentDir = parentDir;
+    }
+    contextFiles.push(...ancestorContextFiles);
+    const sandboxContext = await loadDaemonContextFileWithOperations(options.operations, options.workspace, "SANDBOX.md", "SANDBOX.md", "project", options.workspace?.root);
+    if (sandboxContext && !seenPaths.has(sandboxContext.path))
+        contextFiles.push(sandboxContext);
+    return contextFiles;
+}
+async function loadDaemonContextFileWithOperations(operations, workspace, resourcePath, displayPath, scope, baseDir) {
+    if (!workspace || !operations.readResource)
+        return null;
+    try {
+        const content = (await operations.readResource(resourcePath)).toString("utf-8");
+        return {
+            path: displayPath,
+            content,
+            sourceInfo: createSyntheticSourceInfo(displayPath, {
+                source: "remote",
+                scope,
+                origin: "top-level",
+                baseDir,
+                workspace,
+            }),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export class DefaultResourceLoader {
+    cwd;
+    agentDir;
+    settingsManager;
+    eventBus;
+    packageManager;
+    additionalExtensionPaths;
+    additionalSkillPaths;
+    additionalRulePaths;
+    additionalPromptTemplatePaths;
+    additionalThemePaths;
+    extensionFactories;
+    noExtensions;
+    noSkills;
+    noRules;
+    noPromptTemplates;
+    noThemes;
+    noContextFiles;
+    systemPromptSource;
+    appendSystemPromptSource;
+    toolOperations;
+    extensionsOverride;
+    skillsOverride;
+    rulesOverride;
+    promptsOverride;
+    themesOverride;
+    agentsFilesOverride;
+    systemPromptOverride;
+    appendSystemPromptOverride;
+    extensionsResult;
+    skills;
+    skillDiagnostics;
+    rules;
+    ruleDiagnostics;
+    prompts;
+    promptDiagnostics;
+    themes;
+    themeDiagnostics;
+    agentsFiles;
+    systemPrompt;
+    appendSystemPrompt;
+    lastSkillPaths;
+    lastRulePaths;
+    extensionSkillSourceInfos;
+    extensionRuleSourceInfos;
+    extensionPromptSourceInfos;
+    extensionThemeSourceInfos;
+    lastPromptPaths;
+    lastThemePaths;
+    constructor(options) {
+        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,
+            settingsManager: this.settingsManager,
+        });
+        this.additionalExtensionPaths = options.additionalExtensionPaths ?? [];
+        this.additionalSkillPaths = options.additionalSkillPaths ?? [];
+        this.additionalRulePaths = options.additionalRulePaths ?? [];
+        this.additionalPromptTemplatePaths = options.additionalPromptTemplatePaths ?? [];
+        this.additionalThemePaths = options.additionalThemePaths ?? [];
+        this.extensionFactories = options.extensionFactories ?? [];
+        this.noExtensions = options.noExtensions ?? false;
+        this.noSkills = options.noSkills ?? false;
+        this.noRules = options.noRules ?? false;
+        this.noPromptTemplates = options.noPromptTemplates ?? false;
+        this.noThemes = options.noThemes ?? false;
+        this.noContextFiles = options.noContextFiles ?? false;
+        this.systemPromptSource = options.systemPrompt;
+        this.appendSystemPromptSource = options.appendSystemPrompt;
+        this.toolOperations = options.toolOperations;
+        this.extensionsOverride = options.extensionsOverride;
+        this.skillsOverride = options.skillsOverride;
+        this.rulesOverride = options.rulesOverride;
+        this.promptsOverride = options.promptsOverride;
+        this.themesOverride = options.themesOverride;
+        this.agentsFilesOverride = options.agentsFilesOverride;
+        this.systemPromptOverride = options.systemPromptOverride;
+        this.appendSystemPromptOverride = options.appendSystemPromptOverride;
+        this.extensionsResult = { extensions: [], errors: [], runtime: createExtensionRuntime() };
+        this.skills = [];
+        this.skillDiagnostics = [];
+        this.rules = [];
+        this.ruleDiagnostics = [];
+        this.prompts = [];
+        this.promptDiagnostics = [];
+        this.themes = [];
+        this.themeDiagnostics = [];
+        this.agentsFiles = [];
+        this.appendSystemPrompt = [];
+        this.lastSkillPaths = [];
+        this.lastRulePaths = [];
+        this.extensionSkillSourceInfos = new Map();
+        this.extensionRuleSourceInfos = new Map();
+        this.extensionPromptSourceInfos = new Map();
+        this.extensionThemeSourceInfos = new Map();
+        this.lastPromptPaths = [];
+        this.lastThemePaths = [];
+    }
+    getExtensions() {
+        return this.extensionsResult;
+    }
+    getSkills() {
+        return { skills: this.skills, diagnostics: this.skillDiagnostics };
+    }
+    getRules() {
+        return { rules: this.rules, diagnostics: this.ruleDiagnostics };
+    }
+    getPrompts() {
+        return { prompts: this.prompts, diagnostics: this.promptDiagnostics };
+    }
+    getThemes() {
+        return { themes: this.themes, diagnostics: this.themeDiagnostics };
+    }
+    getAgentsFiles() {
+        return { agentsFiles: this.agentsFiles };
+    }
+    getSystemPrompt() {
+        return this.systemPrompt;
+    }
+    getAppendSystemPrompt() {
+        return this.appendSystemPrompt;
+    }
+    setToolOperations(operations) {
+        this.toolOperations = operations;
+    }
+    getInstructionOperations() {
+        const backend = this.toolOperations?.getBackendInfo?.();
+        return backend?.type === "remote" && backend.configured ? this.toolOperations : undefined;
+    }
+    getRemoteProjectInstructionResourcePaths(cwd, backend) {
+        const projectBaseDir = joinPortablePath(cwd, CONFIG_DIR_NAME);
+        const projectMetadata = {
+            source: "remote",
+            scope: "project",
+            origin: "top-level",
+            baseDir: projectBaseDir,
+            workspace: backend.workspace,
+        };
+        const skills = [
+            { path: joinPortablePath(projectBaseDir, "skills"), metadata: projectMetadata },
+        ];
+        const rules = [
+            { path: joinPortablePath(projectBaseDir, "rules"), metadata: projectMetadata },
+        ];
+        const prompts = [
+            { path: joinPortablePath(projectBaseDir, "prompts"), metadata: projectMetadata },
+        ];
+        let currentDir = cwd;
+        const boundary = backend.workspace.root;
+        while (true) {
+            const agentsBaseDir = joinPortablePath(currentDir, ".agents");
+            const agentsMetadata = {
+                source: "remote",
+                scope: "project",
+                origin: "top-level",
+                baseDir: agentsBaseDir,
+                workspace: backend.workspace,
+            };
+            skills.push({ path: joinPortablePath(agentsBaseDir, "skills"), metadata: agentsMetadata });
+            rules.push({ path: joinPortablePath(agentsBaseDir, "rules"), metadata: agentsMetadata });
+            if (pathComparisonValue(currentDir, backend.workspace.pathFlavor) ===
+                pathComparisonValue(boundary, backend.workspace.pathFlavor))
+                break;
+            const parentDir = dirnamePortablePath(currentDir, backend.workspace.pathFlavor);
+            if (parentDir === currentDir)
+                break;
+            currentDir = parentDir;
+        }
+        return { skills, rules, prompts };
+    }
+    extendResources(paths) {
+        const skillPaths = this.normalizeExtensionPaths(paths.skillPaths ?? []);
+        const rulePaths = this.normalizeExtensionPaths(paths.rulePaths ?? []);
+        const promptPaths = this.normalizeExtensionPaths(paths.promptPaths ?? []);
+        const themePaths = this.normalizeExtensionPaths(paths.themePaths ?? []);
+        for (const entry of skillPaths) {
+            this.extensionSkillSourceInfos.set(entry.path, createSourceInfo(entry.path, entry.metadata));
+        }
+        for (const entry of rulePaths) {
+            this.extensionRuleSourceInfos.set(entry.path, createSourceInfo(entry.path, entry.metadata));
+        }
+        for (const entry of promptPaths) {
+            this.extensionPromptSourceInfos.set(entry.path, createSourceInfo(entry.path, entry.metadata));
+        }
+        for (const entry of themePaths) {
+            this.extensionThemeSourceInfos.set(entry.path, createSourceInfo(entry.path, entry.metadata));
+        }
+        if (skillPaths.length > 0) {
+            this.lastSkillPaths = this.mergePaths(this.lastSkillPaths, skillPaths.map((entry) => entry.path));
+            this.updateSkillsFromPaths(this.lastSkillPaths);
+        }
+        if (rulePaths.length > 0) {
+            this.lastRulePaths = this.mergePaths(this.lastRulePaths, rulePaths.map((entry) => entry.path));
+            this.updateRulesFromPaths(this.lastRulePaths);
+        }
+        if (promptPaths.length > 0) {
+            this.lastPromptPaths = this.mergePaths(this.lastPromptPaths, promptPaths.map((entry) => entry.path));
+            this.updatePromptsFromPaths(this.lastPromptPaths);
+        }
+        if (themePaths.length > 0) {
+            this.lastThemePaths = this.mergePaths(this.lastThemePaths, themePaths.map((entry) => entry.path));
+            this.updateThemesFromPaths(this.lastThemePaths);
+        }
+    }
+    recordResourceMetadata(resources, metadataByPath) {
+        for (const resource of resources) {
+            if (!metadataByPath.has(resource.path))
+                metadataByPath.set(resource.path, resource.metadata);
+        }
+    }
+    getEnabledResources(resources, metadataByPath) {
+        this.recordResourceMetadata(resources, metadataByPath);
+        return resources.filter((resource) => resource.enabled);
+    }
+    getEnabledPaths(resources, metadataByPath) {
+        return this.getEnabledResources(resources, metadataByPath).map((resource) => resource.path);
+    }
+    shouldExcludeLocalProjectInstructionResource(resource, loadProjectInstructionsRemotely) {
+        return (loadProjectInstructionsRemotely &&
+            resource.metadata.scope === "project" &&
+            resource.metadata.origin === "top-level");
+    }
+    normalizePackagedInstructionPath(resource, filename, metadataByPath) {
+        if (resource.metadata.source !== "auto" && resource.metadata.origin !== "package")
+            return resource.path;
+        try {
+            if (!statSync(resource.path).isDirectory())
+                return resource.path;
+        }
+        catch {
+            return resource.path;
+        }
+        const instructionFile = join(resource.path, filename);
+        if (!existsSync(instructionFile))
+            return resource.path;
+        if (!metadataByPath.has(instructionFile))
+            metadataByPath.set(instructionFile, resource.metadata);
+        return instructionFile;
+    }
+    async filterExistingRemoteInstructionPaths(entries, operations) {
+        const existing = [];
+        for (const entry of entries) {
+            try {
+                await operations.access(entry.path, "exists");
+                existing.push(entry);
+            }
+            catch { }
+        }
+        return existing;
+    }
+    async discoverRemoteInstructionResourcePaths(operations) {
+        const emptyPaths = { skills: [], rules: [], prompts: [] };
+        if (!operations)
+            return emptyPaths;
+        const backend = operations.getBackendInfo?.();
+        if (backend?.type !== "remote" || !backend.configured)
+            return emptyPaths;
+        const discovered = this.getRemoteProjectInstructionResourcePaths(operations.cwd, backend);
+        return {
+            skills: await this.filterExistingRemoteInstructionPaths(discovered.skills, operations),
+            rules: await this.filterExistingRemoteInstructionPaths(discovered.rules, operations),
+            prompts: await this.filterExistingRemoteInstructionPaths(discovered.prompts, operations),
+        };
+    }
+    recordRemoteInstructionMetadata(paths, metadataByPath) {
+        for (const entry of [...paths.skills, ...paths.rules, ...paths.prompts]) {
+            metadataByPath.set(entry.path, entry.metadata);
+        }
+    }
+    recordCliInstructionMetadata(paths, metadataByPath) {
+        for (const resource of [...paths.extensions, ...paths.skills, ...paths.rules]) {
+            if (!metadataByPath.has(resource.path)) {
+                metadataByPath.set(resource.path, { source: "cli", scope: "temporary", origin: "top-level" });
+            }
+        }
+    }
+    async collectReloadResourcePaths(resolvedPaths, cliPaths, metadataByPath, instructionOperations) {
+        const loadProjectInstructionsRemotely = instructionOperations !== undefined;
+        const enabledExtensions = this.getEnabledPaths(resolvedPaths.extensions, metadataByPath);
+        const enabledSkillResources = this.getEnabledResources(resolvedPaths.skills, metadataByPath).filter((resource) => !this.shouldExcludeLocalProjectInstructionResource(resource, loadProjectInstructionsRemotely));
+        const enabledRuleResources = this.getEnabledResources(resolvedPaths.rules, metadataByPath).filter((resource) => !this.shouldExcludeLocalProjectInstructionResource(resource, loadProjectInstructionsRemotely));
+        const enabledPrompts = this.getEnabledResources(resolvedPaths.prompts, metadataByPath)
+            .filter((resource) => !this.shouldExcludeLocalProjectInstructionResource(resource, loadProjectInstructionsRemotely))
+            .map((resource) => resource.path);
+        const enabledThemes = this.getEnabledPaths(resolvedPaths.themes, metadataByPath);
+        const remotePaths = await this.discoverRemoteInstructionResourcePaths(instructionOperations);
+        this.recordRemoteInstructionMetadata(remotePaths, metadataByPath);
+        const enabledSkills = enabledSkillResources.map((resource) => this.normalizePackagedInstructionPath(resource, "SKILL.md", metadataByPath));
+        const enabledRules = enabledRuleResources.map((resource) => this.normalizePackagedInstructionPath(resource, "RULES.md", metadataByPath));
+        this.recordCliInstructionMetadata(cliPaths, metadataByPath);
+        const cliExtensions = this.getEnabledPaths(cliPaths.extensions, metadataByPath);
+        const cliSkills = this.getEnabledPaths(cliPaths.skills, metadataByPath);
+        const cliRules = this.getEnabledPaths(cliPaths.rules, metadataByPath);
+        const cliPrompts = this.getEnabledPaths(cliPaths.prompts, metadataByPath);
+        const cliThemes = this.getEnabledPaths(cliPaths.themes, metadataByPath);
+        return {
+            extensions: this.noExtensions ? cliExtensions : this.mergePaths(cliExtensions, enabledExtensions),
+            skills: this.noSkills
+                ? this.mergePaths(cliSkills, this.additionalSkillPaths)
+                : this.mergePaths([...cliSkills, ...enabledSkills, ...remotePaths.skills.map((entry) => entry.path)], this.additionalSkillPaths),
+            rules: this.noRules
+                ? this.mergePaths(cliRules, this.additionalRulePaths)
+                : this.mergePaths([...cliRules, ...enabledRules, ...remotePaths.rules.map((entry) => entry.path)], this.additionalRulePaths),
+            prompts: this.noPromptTemplates
+                ? this.mergePaths(cliPrompts, this.additionalPromptTemplatePaths)
+                : this.mergePaths([...cliPrompts, ...enabledPrompts, ...remotePaths.prompts.map((entry) => entry.path)], this.additionalPromptTemplatePaths),
+            themes: this.noThemes
+                ? this.mergePaths(cliThemes, this.additionalThemePaths)
+                : this.mergePaths([...cliThemes, ...enabledThemes], this.additionalThemePaths),
+        };
+    }
+    async reloadExtensions(extensionPaths, metadataByPath) {
+        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);
+        for (const conflict of this.detectExtensionConflicts(extensionsResult.extensions)) {
+            extensionsResult.errors.push({ path: conflict.path, error: conflict.message });
+        }
+        for (const path of this.additionalExtensionPaths) {
+            if (!isLocalPath(path))
+                continue;
+            const resolved = this.resolveResourcePath(path);
+            if (!existsSync(resolved)) {
+                extensionsResult.errors.push({ path: resolved, error: `Extension path does not exist: ${resolved}` });
+            }
+        }
+        this.extensionsResult = this.extensionsOverride ? this.extensionsOverride(extensionsResult) : extensionsResult;
+        this.applyExtensionSourceInfo(this.extensionsResult.extensions, metadataByPath);
+    }
+    async reloadSkills(skillPaths, metadataByPath) {
+        this.lastSkillPaths = skillPaths;
+        await this.updateSkillsFromPathsForReload(skillPaths, metadataByPath);
+        const diagnosticPaths = new Set(this.skillDiagnostics.map((diagnostic) => diagnostic.path));
+        for (const path of this.additionalSkillPaths) {
+            if (!isLocalPath(path))
+                continue;
+            const resolved = this.resolveResourcePath(path);
+            appendMissingResourceDiagnostic(resolved, this.skillDiagnostics, diagnosticPaths, "Skill path does not exist");
+        }
+    }
+    async reloadRules(rulePaths, metadataByPath) {
+        this.lastRulePaths = rulePaths;
+        await this.updateRulesFromPathsForReload(rulePaths, metadataByPath);
+        const diagnosticPaths = new Set(this.ruleDiagnostics.map((diagnostic) => diagnostic.path));
+        for (const path of this.additionalRulePaths) {
+            if (!isLocalPath(path))
+                continue;
+            const resolved = this.resolveResourcePath(path);
+            appendMissingResourceDiagnostic(resolved, this.ruleDiagnostics, diagnosticPaths, "Rule path does not exist");
+        }
+    }
+    async reloadPrompts(promptPaths, metadataByPath) {
+        this.lastPromptPaths = promptPaths;
+        await this.updatePromptsFromPathsForReload(promptPaths, metadataByPath);
+        const diagnosticPaths = new Set(this.promptDiagnostics.map((diagnostic) => diagnostic.path));
+        for (const path of this.additionalPromptTemplatePaths) {
+            if (!isLocalPath(path))
+                continue;
+            const resolved = this.resolveResourcePath(path);
+            appendMissingResourceDiagnostic(resolved, this.promptDiagnostics, diagnosticPaths, "Prompt template path does not exist");
+        }
+    }
+    reloadThemes(themePaths, metadataByPath) {
+        this.lastThemePaths = themePaths;
+        this.updateThemesFromPaths(themePaths, metadataByPath);
+        const diagnosticPaths = new Set(this.themeDiagnostics.map((diagnostic) => diagnostic.path));
+        for (const path of this.additionalThemePaths) {
+            const resolved = this.resolveResourcePath(path);
+            appendMissingResourceDiagnostic(resolved, this.themeDiagnostics, diagnosticPaths, "Theme path does not exist");
+        }
+    }
+    async reloadProjectContextFiles(instructionOperations) {
+        const backend = instructionOperations?.getBackendInfo?.();
+        const agentsFiles = {
+            agentsFiles: this.noContextFiles
+                ? []
+                : instructionOperations
+                    ? await loadProjectContextFilesWithOperations({
+                        cwd: instructionOperations.cwd,
+                        agentDir: this.agentDir,
+                        operations: instructionOperations,
+                        workspace: backend?.type === "remote" && backend.configured ? backend.workspace : undefined,
+                    })
+                    : loadProjectContextFiles({ cwd: this.cwd, agentDir: this.agentDir }),
+        };
+        const resolvedAgentsFiles = this.agentsFilesOverride ? this.agentsFilesOverride(agentsFiles) : agentsFiles;
+        this.agentsFiles = resolvedAgentsFiles.agentsFiles;
+    }
+    async reloadSystemPrompts() {
+        const baseSystemPrompt = await resolvePromptInput(this.systemPromptSource ?? this.discoverSystemPromptFile(), "system prompt", this.getInstructionOperations());
+        this.systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(baseSystemPrompt) : baseSystemPrompt;
+        const appendSources = this.appendSystemPromptSource ??
+            (this.discoverAppendSystemPromptFile() ? [this.discoverAppendSystemPromptFile()] : []);
+        const baseAppend = (await Promise.all(appendSources.map((source) => resolvePromptInput(source, "append system prompt", this.getInstructionOperations())))).filter((source) => source !== undefined);
+        this.appendSystemPrompt = this.appendSystemPromptOverride
+            ? this.appendSystemPromptOverride(baseAppend)
+            : baseAppend;
+    }
+    async reload() {
+        resetTimings("extensions");
+        await this.settingsManager.reload();
+        const resolvedPaths = await this.packageManager.resolve();
+        const cliPaths = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, {
+            temporary: true,
+        });
+        const metadataByPath = new Map();
+        this.extensionSkillSourceInfos = new Map();
+        this.extensionRuleSourceInfos = new Map();
+        this.extensionPromptSourceInfos = new Map();
+        this.extensionThemeSourceInfos = new Map();
+        const instructionOperations = this.getInstructionOperations();
+        const paths = await this.collectReloadResourcePaths(resolvedPaths, cliPaths, metadataByPath, instructionOperations);
+        await this.reloadExtensions(paths.extensions, metadataByPath);
+        await this.reloadSkills(paths.skills, metadataByPath);
+        await this.reloadRules(paths.rules, metadataByPath);
+        await this.reloadPrompts(paths.prompts, metadataByPath);
+        this.reloadThemes(paths.themes, metadataByPath);
+        await this.reloadProjectContextFiles(instructionOperations);
+        await this.reloadSystemPrompts();
+    }
+    normalizeExtensionPaths(entries) {
+        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,
+            };
+        });
+    }
+    getExtensionRegisteredSkills() {
+        return this.extensionsResult.extensions.flatMap((extension) => Array.from(extension.skills.values()));
+    }
+    getExtensionRegisteredRules() {
+        return this.extensionsResult.extensions.flatMap((extension) => Array.from(extension.rules.values()));
+    }
+    getExtensionRegisteredPrompts() {
+        return this.extensionsResult.extensions.flatMap((extension) => Array.from(extension.prompts.values()));
+    }
+    applyLoadedSkills(skillsResult, metadataByPath) {
+        const extensionSkills = this.getExtensionRegisteredSkills();
+        const seenSkillNames = new Set(extensionSkills.map((skill) => skill.name));
+        const baseSkillsResult = {
+            skills: [...extensionSkills, ...skillsResult.skills.filter((skill) => !seenSkillNames.has(skill.name))],
+            diagnostics: skillsResult.diagnostics,
+        };
+        const resolvedSkills = this.skillsOverride ? this.skillsOverride(baseSkillsResult) : baseSkillsResult;
+        this.skills = resolvedSkills.skills.map((skill) => ({
+            ...skill,
+            sourceInfo: this.findSourceInfoForPath(skill.filePath, this.extensionSkillSourceInfos, metadataByPath) ??
+                skill.sourceInfo ??
+                this.getDefaultSourceInfoForPath(skill.filePath),
+        }));
+        this.skillDiagnostics = resolvedSkills.diagnostics;
+    }
+    updateSkillsFromPaths(skillPaths, metadataByPath) {
+        let skillsResult;
+        if (this.noSkills && skillPaths.length === 0) {
+            skillsResult = { skills: [], diagnostics: [] };
+        }
+        else {
+            skillsResult = loadSkills({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                skillPaths,
+                includeDefaults: false,
+            });
+        }
+        this.applyLoadedSkills(skillsResult, metadataByPath);
+    }
+    shouldLoadPathWithInstructionOperations(path, metadataByPath) {
+        const operations = this.getInstructionOperations();
+        if (!operations)
+            return false;
+        const sourceInfo = this.findSourceInfoForPath(path, undefined, metadataByPath);
+        if (sourceInfo?.source === "remote")
+            return true;
+        const backend = operations.getBackendInfo?.();
+        if (backend?.type === "remote" && backend.configured) {
+            return relativeWithin(backend.workspace.root, path) !== undefined;
+        }
+        const cwd = operations.cwd.endsWith(sep) ? operations.cwd : `${operations.cwd}${sep}`;
+        return path === operations.cwd || path.startsWith(cwd);
+    }
+    async updateSkillsFromPathsForReload(skillPaths, metadataByPath) {
+        let skillsResult;
+        const operations = this.getInstructionOperations();
+        if (this.noSkills && skillPaths.length === 0) {
+            skillsResult = { skills: [], diagnostics: [] };
+        }
+        else if (operations) {
+            const remotePaths = skillPaths.filter((path) => this.shouldLoadPathWithInstructionOperations(path, metadataByPath));
+            const localPaths = skillPaths.filter((path) => !this.shouldLoadPathWithInstructionOperations(path, metadataByPath));
+            const remoteResult = await loadSkillsWithOperations({
+                cwd: operations.cwd,
+                agentDir: this.agentDir,
+                skillPaths: remotePaths,
+                includeDefaults: false,
+                operations,
+            });
+            const localResult = loadSkills({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                skillPaths: localPaths,
+                includeDefaults: false,
+            });
+            const merged = mergeNamedResources(remoteResult.skills, localResult.skills, "skill");
+            skillsResult = {
+                skills: merged.resources,
+                diagnostics: [...remoteResult.diagnostics, ...localResult.diagnostics, ...merged.diagnostics],
+            };
+        }
+        else {
+            skillsResult = loadSkills({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                skillPaths,
+                includeDefaults: false,
+            });
+        }
+        this.applyLoadedSkills(skillsResult, metadataByPath);
+    }
+    applyLoadedRules(rulesResult, metadataByPath) {
+        const extensionRules = this.getExtensionRegisteredRules();
+        const seenRuleNames = new Set(extensionRules.map((rule) => rule.name));
+        const baseRulesResult = {
+            rules: [...extensionRules, ...rulesResult.rules.filter((rule) => !seenRuleNames.has(rule.name))],
+            diagnostics: rulesResult.diagnostics,
+        };
+        const resolvedRules = this.rulesOverride ? this.rulesOverride(baseRulesResult) : baseRulesResult;
+        this.rules = resolvedRules.rules.map((rule) => ({
+            ...rule,
+            sourceInfo: this.findSourceInfoForPath(rule.filePath, this.extensionRuleSourceInfos, metadataByPath) ??
+                rule.sourceInfo ??
+                this.getDefaultSourceInfoForPath(rule.filePath),
+        }));
+        this.ruleDiagnostics = resolvedRules.diagnostics;
+    }
+    updateRulesFromPaths(rulePaths, metadataByPath) {
+        let rulesResult;
+        if (this.noRules && rulePaths.length === 0) {
+            rulesResult = { rules: [], diagnostics: [] };
+        }
+        else {
+            rulesResult = loadRules({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                rulePaths,
+                includeDefaults: false,
+            });
+        }
+        this.applyLoadedRules(rulesResult, metadataByPath);
+    }
+    async updateRulesFromPathsForReload(rulePaths, metadataByPath) {
+        let rulesResult;
+        const operations = this.getInstructionOperations();
+        if (this.noRules && rulePaths.length === 0) {
+            rulesResult = { rules: [], diagnostics: [] };
+        }
+        else if (operations) {
+            const remotePaths = rulePaths.filter((path) => this.shouldLoadPathWithInstructionOperations(path, metadataByPath));
+            const localPaths = rulePaths.filter((path) => !this.shouldLoadPathWithInstructionOperations(path, metadataByPath));
+            const remoteResult = await loadRulesWithOperations({
+                cwd: operations.cwd,
+                agentDir: this.agentDir,
+                rulePaths: remotePaths,
+                includeDefaults: false,
+                operations,
+            });
+            const localResult = loadRules({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                rulePaths: localPaths,
+                includeDefaults: false,
+            });
+            const merged = mergeNamedResources(remoteResult.rules, localResult.rules, "rule");
+            rulesResult = {
+                rules: merged.resources,
+                diagnostics: [...remoteResult.diagnostics, ...localResult.diagnostics, ...merged.diagnostics],
+            };
+        }
+        else {
+            rulesResult = loadRules({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                rulePaths,
+                includeDefaults: false,
+            });
+        }
+        this.applyLoadedRules(rulesResult, metadataByPath);
+    }
+    applyLoadedPrompts(promptsResult, metadataByPath) {
+        const extensionPrompts = this.getExtensionRegisteredPrompts();
+        const basePromptsResult = this.dedupePrompts([...extensionPrompts, ...promptsResult.prompts]);
+        basePromptsResult.diagnostics.unshift(...promptsResult.diagnostics);
+        const resolvedPrompts = this.promptsOverride ? this.promptsOverride(basePromptsResult) : basePromptsResult;
+        this.prompts = resolvedPrompts.prompts.map((prompt) => ({
+            ...prompt,
+            sourceInfo: this.findSourceInfoForPath(prompt.filePath, this.extensionPromptSourceInfos, metadataByPath) ??
+                prompt.sourceInfo ??
+                this.getDefaultSourceInfoForPath(prompt.filePath),
+        }));
+        this.promptDiagnostics = resolvedPrompts.diagnostics;
+    }
+    updatePromptsFromPaths(promptPaths, metadataByPath) {
+        let promptsResult;
+        if (this.noPromptTemplates && promptPaths.length === 0) {
+            promptsResult = { prompts: [], diagnostics: [] };
+        }
+        else {
+            const allPrompts = loadPromptTemplates({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                promptPaths,
+                includeDefaults: false,
+            });
+            promptsResult = this.dedupePrompts(allPrompts);
+        }
+        this.applyLoadedPrompts(promptsResult, metadataByPath);
+    }
+    async updatePromptsFromPathsForReload(promptPaths, metadataByPath) {
+        let promptsResult;
+        const operations = this.getInstructionOperations();
+        if (this.noPromptTemplates && promptPaths.length === 0) {
+            promptsResult = { prompts: [], diagnostics: [] };
+        }
+        else if (operations) {
+            const remotePaths = promptPaths.filter((path) => this.shouldLoadPathWithInstructionOperations(path, metadataByPath));
+            const localPaths = promptPaths.filter((path) => !this.shouldLoadPathWithInstructionOperations(path, metadataByPath));
+            const remotePrompts = await loadPromptTemplatesWithOperations({
+                cwd: operations.cwd,
+                agentDir: this.agentDir,
+                promptPaths: remotePaths,
+                includeDefaults: false,
+                operations,
+            });
+            const localPrompts = loadPromptTemplates({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                promptPaths: localPaths,
+                includeDefaults: false,
+            });
+            promptsResult = this.dedupePrompts([...remotePrompts, ...localPrompts]);
+        }
+        else {
+            const allPrompts = loadPromptTemplates({
+                cwd: this.cwd,
+                agentDir: this.agentDir,
+                promptPaths,
+                includeDefaults: false,
+            });
+            promptsResult = this.dedupePrompts(allPrompts);
+        }
+        this.applyLoadedPrompts(promptsResult, metadataByPath);
+    }
+    updateThemesFromPaths(themePaths, metadataByPath) {
+        let themesResult;
+        if (this.noThemes && themePaths.length === 0) {
+            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 resolvedThemes = this.themesOverride ? this.themesOverride(themesResult) : themesResult;
+        this.themes = resolvedThemes.themes.map((theme) => {
+            const sourcePath = theme.sourcePath;
+            theme.sourceInfo = sourcePath
+                ? (this.findSourceInfoForPath(sourcePath, this.extensionThemeSourceInfos, metadataByPath) ??
+                    theme.sourceInfo ??
+                    this.getDefaultSourceInfoForPath(sourcePath))
+                : theme.sourceInfo;
+            return theme;
+        });
+        this.themeDiagnostics = resolvedThemes.diagnostics;
+    }
+    applyExtensionSourceInfo(extensions, metadataByPath) {
+        for (const extension of extensions) {
+            extension.sourceInfo =
+                this.findSourceInfoForPath(extension.path, undefined, metadataByPath) ??
+                    this.getDefaultSourceInfoForPath(extension.path);
+            for (const command of extension.commands.values()) {
+                command.sourceInfo = extension.sourceInfo;
+            }
+            for (const tool of extension.tools.values()) {
+                tool.sourceInfo = extension.sourceInfo;
+            }
+            for (const skill of extension.skills.values()) {
+                skill.sourceInfo = extension.sourceInfo;
+            }
+            for (const rule of extension.rules.values()) {
+                rule.sourceInfo = extension.sourceInfo;
+            }
+            for (const prompt of extension.prompts.values()) {
+                prompt.sourceInfo = extension.sourceInfo;
+            }
+        }
+    }
+    findRegisteredSourceInfoForPath(resourcePath, normalizedResourcePath, sourceInfos) {
+        for (const [sourcePath, sourceInfo] of sourceInfos.entries()) {
+            const normalizedSourcePath = resolve(sourcePath);
+            if (normalizedResourcePath === normalizedSourcePath ||
+                normalizedResourcePath.startsWith(`${normalizedSourcePath}${sep}`)) {
+                return { ...sourceInfo, path: resourcePath };
+            }
+        }
+        return undefined;
+    }
+    findResolvedResourceSourceInfoForPath(resourcePath, normalizedResourcePath, metadataByPath) {
+        const exact = metadataByPath.get(normalizedResourcePath) ?? metadataByPath.get(resourcePath);
+        if (exact)
+            return createSourceInfo(resourcePath, exact);
+        for (const [sourcePath, metadata] of metadataByPath.entries()) {
+            if (metadata.workspace) {
+                if (relativeWithin(sourcePath, resourcePath) !== undefined) {
+                    return createSourceInfo(resourcePath, metadata);
+                }
+                continue;
+            }
+            const normalizedSourcePath = resolve(sourcePath);
+            if (normalizedResourcePath === normalizedSourcePath ||
+                normalizedResourcePath.startsWith(`${normalizedSourcePath}${sep}`)) {
+                return createSourceInfo(resourcePath, metadata);
+            }
+        }
+        return undefined;
+    }
+    findSourceInfoForPath(resourcePath, extraSourceInfos, metadataByPath) {
+        if (!resourcePath)
+            return undefined;
+        if (resourcePath.startsWith("<"))
+            return this.getDefaultSourceInfoForPath(resourcePath);
+        const normalizedResourcePath = resolve(resourcePath);
+        const registeredSourceInfo = extraSourceInfos
+            ? this.findRegisteredSourceInfoForPath(resourcePath, normalizedResourcePath, extraSourceInfos)
+            : undefined;
+        if (registeredSourceInfo)
+            return registeredSourceInfo;
+        return metadataByPath
+            ? this.findResolvedResourceSourceInfoForPath(resourcePath, normalizedResourcePath, metadataByPath)
+            : undefined;
+    }
+    getDefaultSourceInfoForPath(filePath) {
+        if (filePath.startsWith("<") && filePath.endsWith(">")) {
+            return {
+                path: filePath,
+                source: filePath.slice(1, -1).split(":")[0] || "temporary",
+                scope: "temporary",
+                origin: "top-level",
+            };
+        }
+        const normalizedPath = resolve(filePath);
+        const agentRoots = [
+            join(this.agentDir, "skills"),
+            join(this.agentDir, "rules"),
+            join(this.agentDir, "prompts"),
+            join(this.agentDir, "themes"),
+            join(this.agentDir, "extensions"),
+        ];
+        const projectRoots = [
+            join(this.cwd, CONFIG_DIR_NAME, "skills"),
+            join(this.cwd, CONFIG_DIR_NAME, "rules"),
+            join(this.cwd, CONFIG_DIR_NAME, "prompts"),
+            join(this.cwd, CONFIG_DIR_NAME, "themes"),
+            join(this.cwd, CONFIG_DIR_NAME, "extensions"),
+        ];
+        for (const root of agentRoots) {
+            if (this.isUnderPath(normalizedPath, root)) {
+                return { path: filePath, source: "local", scope: "user", origin: "top-level", baseDir: root };
+            }
+        }
+        for (const root of projectRoots) {
+            if (this.isUnderPath(normalizedPath, root)) {
+                return { path: filePath, source: "local", scope: "project", origin: "top-level", baseDir: root };
+            }
+        }
+        return {
+            path: filePath,
+            source: "local",
+            scope: "temporary",
+            origin: "top-level",
+            baseDir: statSync(normalizedPath).isDirectory() ? normalizedPath : resolve(normalizedPath, ".."),
+        };
+    }
+    mergePaths(primary, additional) {
+        const merged = [];
+        const seen = new Set();
+        for (const p of [...primary, ...additional]) {
+            const resolved = this.resolveResourcePath(p);
+            const canonicalPath = canonicalizePath(resolved);
+            if (seen.has(canonicalPath))
+                continue;
+            seen.add(canonicalPath);
+            merged.push(resolved);
+        }
+        return merged;
+    }
+    resolveResourcePath(p) {
+        return resolvePath(p, this.cwd, { trim: true });
+    }
+    loadThemes(paths, includeDefaults = true) {
+        const themes = [];
+        const diagnostics = [];
+        if (includeDefaults) {
+            const defaultDirs = [join(this.agentDir, "themes"), join(this.cwd, CONFIG_DIR_NAME, "themes")];
+            for (const dir of defaultDirs) {
+                this.loadThemesFromDir(dir, themes, diagnostics);
+            }
+        }
+        for (const p of paths) {
+            const resolved = this.resolveResourcePath(p);
+            if (!existsSync(resolved)) {
+                diagnostics.push({ type: "warning", message: "theme path does not exist", path: resolved });
+                continue;
+            }
+            try {
+                const stats = statSync(resolved);
+                if (stats.isDirectory()) {
+                    this.loadThemesFromDir(resolved, themes, diagnostics);
+                }
+                else if (stats.isFile() && resolved.endsWith(".json")) {
+                    this.loadThemeFromFile(resolved, themes, diagnostics);
+                }
+                else {
+                    diagnostics.push({ type: "warning", message: "theme path is not a json file", path: resolved });
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "failed to read theme path";
+                diagnostics.push({ type: "warning", message, path: resolved });
+            }
+        }
+        return { themes, diagnostics };
+    }
+    loadThemesFromDir(dir, themes, diagnostics) {
+        if (!existsSync(dir)) {
+            return;
+        }
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                let isFile = entry.isFile();
+                if (entry.isSymbolicLink()) {
+                    try {
+                        isFile = statSync(join(dir, entry.name)).isFile();
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                if (!isFile) {
+                    continue;
+                }
+                if (!entry.name.endsWith(".json")) {
+                    continue;
+                }
+                this.loadThemeFromFile(join(dir, entry.name), themes, diagnostics);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "failed to read theme directory";
+            diagnostics.push({ type: "warning", message, path: dir });
+        }
+    }
+    loadThemeFromFile(filePath, themes, diagnostics) {
+        try {
+            themes.push(loadThemeFromPath(filePath));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "failed to load theme";
+            diagnostics.push({ type: "warning", message, path: filePath });
+        }
+    }
+    async loadExtensionFactories(runtime) {
+        const extensions = [];
+        const errors = [];
+        for (const [index, factory] of this.extensionFactories.entries()) {
+            const extensionPath = `<inline:${index + 1}>`;
+            try {
+                const extension = await loadExtensionFromFactory(factory, this.cwd, this.eventBus, runtime, extensionPath);
+                extensions.push(extension);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "failed to load extension";
+                errors.push({ path: extensionPath, error: message });
+            }
+        }
+        return { extensions, errors };
+    }
+    dedupePrompts(prompts) {
+        const seen = new Map();
+        const diagnostics = [];
+        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 };
+    }
+    dedupeThemes(themes) {
+        const seen = new Map();
+        const diagnostics = [];
+        for (const t of themes) {
+            const name = t.name ?? "unnamed";
+            const existing = seen.get(name);
+            if (existing) {
+                diagnostics.push({
+                    type: "collision",
+                    message: `name "${name}" collision`,
+                    path: t.sourcePath,
+                    collision: {
+                        resourceType: "theme",
+                        name,
+                        winnerPath: existing.sourcePath ?? "<builtin>",
+                        loserPath: t.sourcePath ?? "<builtin>",
+                    },
+                });
+            }
+            else {
+                seen.set(name, t);
+            }
+        }
+        return { themes: Array.from(seen.values()), diagnostics };
+    }
+    discoverSystemPromptFile() {
+        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;
+    }
+    discoverAppendSystemPromptFile() {
+        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;
+        }
+        return undefined;
+    }
+    isUnderPath(target, root) {
+        const normalizedRoot = resolve(root);
+        if (target === normalizedRoot) {
+            return true;
+        }
+        const prefix = normalizedRoot.endsWith(sep) ? normalizedRoot : `${normalizedRoot}${sep}`;
+        return target.startsWith(prefix);
+    }
+    detectExtensionConflicts(extensions) {
+        const conflicts = [];
+        // Track which extension registered each tool and flag
+        const toolOwners = new Map();
+        const flagOwners = new Map();
+        for (const ext of extensions) {
+            // Check tools
+            for (const toolName of ext.tools.keys()) {
+                const existingOwner = toolOwners.get(toolName);
+                if (existingOwner && existingOwner !== ext.path) {
+                    conflicts.push({
+                        path: ext.path,
+                        message: `Tool "${toolName}" conflicts with ${existingOwner}`,
+                    });
+                }
+                else {
+                    toolOwners.set(toolName, ext.path);
+                }
+            }
+            // Check flags
+            for (const flagName of ext.flags.keys()) {
+                const existingOwner = flagOwners.get(flagName);
+                if (existingOwner && existingOwner !== ext.path) {
+                    conflicts.push({
+                        path: ext.path,
+                        message: `Flag "--${flagName}" conflicts with ${existingOwner}`,
+                    });
+                }
+                else {
+                    flagOwners.set(flagName, ext.path);
+                }
+            }
+        }
+        return conflicts;
+    }
+}
+//# sourceMappingURL=resource-loader.js.map