fraim-framework 2.0.87 → 2.0.89

package/dist/src/core/utils/inheritance-parser.js

@@ -81,14 +81,14 @@ class InheritanceParser {
         }
     }
     /**
-     * Resolve all import directives in content recursively
+     * Resolve all import and extends directives in content recursively
      *
-     * @param content - Content with {{ import }} directives
+     * @param content - Content with {{ import }} or extends frontmatter
      * @param currentPath - Path of current file (for circular detection)
      * @param options - Resolution options
-     * @returns Resolved content with all imports replaced
+     * @returns Resolved content with all inheritance applied
      *
-     * @throws {InheritanceError} If circular import, path traversal, or max depth exceeded
+     * @throws {InheritanceError} If circular inheritance, path traversal, or max depth exceeded
      */
     async resolve(content, currentPath, options) {
         const depth = options.currentDepth || 0;
@@ -96,18 +96,53 @@ class InheritanceParser {
         const maxDepth = options.maxDepth || this.maxDepth;
         // Check depth limit
         if (depth > maxDepth) {
-            throw new InheritanceError(`Max import depth exceeded (${maxDepth})`, currentPath);
+            throw new InheritanceError(`Max inheritance depth exceeded (${maxDepth})`, currentPath);
         }
-        // Check circular imports (but allow importing the same path as parent)
+        // Check circular inheritance (but allow importing/extending the same path as parent)
         this.detectCircularImport(currentPath, visited, false);
         visited.add(currentPath);
-        // Extract imports
-        const imports = this.extractImports(content);
-        if (imports.length === 0) {
-            return content;
+        let resolvedContent = content;
+        // 1. Handle JSON frontmatter 'extends'
+        const metadataMatch = resolvedContent.match(/^---\r?\n([\s\S]+?)\r?\n---/);
+        if (metadataMatch) {
+            try {
+                const metadata = JSON.parse(metadataMatch[1]);
+                const extendsPath = metadata.extends;
+                if (extendsPath && typeof extendsPath === 'string') {
+                    // Sanitize path
+                    const sanitizedExtends = this.sanitizePath(extendsPath);
+                    const isParentExtends = sanitizedExtends === currentPath;
+                    // Fetch parent content
+                    let parentContent;
+                    try {
+                        parentContent = await options.fetchParent(sanitizedExtends);
+                    }
+                    catch (error) {
+                        throw new InheritanceError(`Failed to fetch extended parent content: ${sanitizedExtends}. ${error.message}`, sanitizedExtends);
+                    }
+                    // Recursively resolve parent
+                    const parentVisited = isParentExtends ? new Set() : new Set(visited);
+                    const resolvedParent = await this.resolve(parentContent, sanitizedExtends, {
+                        ...options,
+                        currentDepth: depth + 1,
+                        visited: parentVisited
+                    });
+                    // Merge current content with resolved parent
+                    resolvedContent = this.mergeContent(resolvedContent, resolvedParent);
+                }
+            }
+            catch (error) {
+                if (error instanceof SyntaxError) {
+                    // Not JSON or invalid JSON, ignore extends logic but log it
+                    console.warn(`[InheritanceParser] Failed to parse frontmatter for ${currentPath}: ${error.message}`);
+                }
+                else {
+                    throw error;
+                }
+            }
         }
-        // Resolve each import
-        let resolved = content;
+        // 2. Handle {{ import: path }}
+        const imports = this.extractImports(resolvedContent);
         for (const importPath of imports) {
             // Sanitize path
             const sanitized = this.sanitizePath(importPath);
@@ -122,7 +157,6 @@ class InheritanceParser {
                 throw new InheritanceError(`Failed to fetch parent content: ${sanitized}. ${error.message}`, sanitized);
             }
             // Recursively resolve parent imports
-            // For parent imports, use a fresh visited set to allow the same path
             const parentVisited = isParentImport ? new Set() : new Set(visited);
             const resolvedParent = await this.resolve(parentContent, sanitized, {
                 ...options,
@@ -131,20 +165,124 @@ class InheritanceParser {
             });
             // Replace import directive with resolved parent content
             const importDirective = `{{ import: ${importPath} }}`;
-            resolved = resolved.replace(importDirective, resolvedParent);
+            resolvedContent = resolvedContent.replace(importDirective, resolvedParent);
         }
-        return resolved;
+        return resolvedContent;
+    }
+    /**
+     * Merge two registry files (child override + parent base)
+     *
+     * Merging rules:
+     * 1. Metadata: JSON merge (child overrides parent)
+     * 2. Overview: Parent overview + child overview (if multi-para)
+     * 3. Phases: Phase override (child phase with same ID replaces parent phase)
+     */
+    mergeContent(child, parent) {
+        const childMatch = child.match(/^---\r?\n([\s\S]+?)\r?\n---/);
+        const parentMatch = parent.match(/^---\r?\n([\s\S]+?)\r?\n---/);
+        if (!childMatch || !parentMatch)
+            return child;
+        // 1. Merge Metadata
+        const childMeta = JSON.parse(childMatch[1]);
+        const parentMeta = JSON.parse(parentMatch[1]);
+        const mergedMeta = { ...parentMeta, ...childMeta };
+        delete mergedMeta.extends; // Remove extends from final merged content
+        // 2. Extract Body (everything after frontmatter)
+        const childBody = this.stripRedundantParentImports(child.substring(childMatch[0].length).trim(), typeof childMeta.extends === 'string' ? childMeta.extends : undefined);
+        const parentBody = parent.substring(parentMatch[0].length).trim();
+        // 3. Parse Phases and Overview
+        const parsePhases = (body) => {
+            const phases = new Map();
+            const sections = body.split(/^##\s+Phase:\s+/m);
+            const overview = sections[0]?.trim() || '';
+            for (let i = 1; i < sections.length; i++) {
+                const section = sections[i];
+                if (!section.trim())
+                    continue;
+                // Extract ID from first line: e.g. "implement-scoping (Primary)" -> "implement-scoping"
+                const firstLine = section.split(/\r?\n/)[0].trim();
+                const id = firstLine.split(/[ (]/)[0].trim().toLowerCase();
+                phases.set(id, `## Phase: ${section.trim()}`);
+            }
+            return { overview, phases };
+        };
+        const childParts = parsePhases(childBody);
+        const parentParts = parsePhases(parentBody);
+        // 4. Merge Overview: retain the parent framing, then append local overview additions.
+        const mergedOverview = childParts.overview
+            ? `${parentParts.overview}\n\n${childParts.overview}`.trim()
+            : parentParts.overview;
+        // 5. Merge Phases
+        const mergedPhases = new Map(parentParts.phases);
+        for (const [id, content] of childParts.phases.entries()) {
+            mergedPhases.set(id, content);
+        }
+        // 6. Reassemble
+        let finalContent = `---\n${JSON.stringify(mergedMeta, null, 2)}\n---\n\n`;
+        if (mergedOverview) {
+            finalContent += `${mergedOverview}\n\n`;
+        }
+        const addedPhases = new Set();
+        // First, add parent phases in order, using child overrides when present.
+        for (const id of parentParts.phases.keys()) {
+            if (mergedPhases.has(id)) {
+                finalContent += `${mergedPhases.get(id)}\n\n`;
+                addedPhases.add(id);
+            }
+        }
+        // Then append child-only phases in the order the child declared them.
+        for (const [id, content] of childParts.phases.entries()) {
+            if (!addedPhases.has(id)) {
+                finalContent += `${content}\n\n`;
+                addedPhases.add(id);
+            }
+        }
+        return finalContent.trim();
     }
     /**
      * Parse content and return detailed information about imports
      */
     parse(content) {
         const imports = this.extractImports(content);
+        const hasExtends = /^---\r?\n[\s\S]*?"extends":\s*"[^"]+"[\s\S]*?\r?\n---/m.test(content);
         return {
             content,
             imports,
-            hasImports: imports.length > 0
+            hasImports: imports.length > 0 || hasExtends
         };
     }
+    normalizeImportRef(path) {
+        let normalized = path.trim().replace(/\\/g, '/').replace(/^\/+/, '');
+        if (normalized.endsWith('.md')) {
+            normalized = normalized.slice(0, -3);
+        }
+        return normalized;
+    }
+    stripTypePrefix(path) {
+        return path.replace(/^(jobs|workflows|skills|rules|templates)\//, '');
+    }
+    isEquivalentImportRef(left, right) {
+        const normalizedLeft = this.normalizeImportRef(left);
+        const normalizedRight = this.normalizeImportRef(right);
+        const strippedLeft = this.stripTypePrefix(normalizedLeft);
+        const strippedRight = this.stripTypePrefix(normalizedRight);
+        return normalizedLeft === normalizedRight ||
+            strippedLeft === strippedRight ||
+            normalizedLeft.endsWith(`/${strippedRight}`) ||
+            normalizedRight.endsWith(`/${strippedLeft}`) ||
+            strippedLeft.endsWith(`/${strippedRight}`) ||
+            strippedRight.endsWith(`/${strippedLeft}`);
+    }
+    stripRedundantParentImports(body, extendsPath) {
+        if (!extendsPath) {
+            return body;
+        }
+        return body
+            .replace(/\{\{\s*import:\s*([^\}]+)\s*\}\}\s*\r?\n?/g, (match, importPath) => {
+            return this.isEquivalentImportRef(importPath, extendsPath) ? '' : match;
+        })
+            .replace(/\n{3,}/g, '\n\n')
+            .trim();
+    }
 }
 exports.InheritanceParser = InheritanceParser;

package/dist/src/core/utils/local-registry-resolver.js

@@ -5,16 +5,52 @@
  * Resolves registry file requests by checking for local overrides first,
  * then falling back to remote registry. Handles inheritance via InheritanceParser.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalRegistryResolver = void 0;
+const fs = __importStar(require("fs"));
 const fs_1 = require("fs");
 const path_1 = require("path");
 const inheritance_parser_1 = require("./inheritance-parser");
+const workflow_parser_1 = require("./workflow-parser");
 class LocalRegistryResolver {
     constructor(options) {
         this.workspaceRoot = options.workspaceRoot;
         this.remoteContentResolver = options.remoteContentResolver;
         this.parser = new inheritance_parser_1.InheritanceParser(options.maxDepth);
+        this.shouldFilter = options.shouldFilter;
     }
     /**
      * Check if a local override exists for the given path
@@ -22,9 +58,52 @@ class LocalRegistryResolver {
     hasLocalOverride(path) {
         const primaryPath = this.getOverridePath(path);
         const legacyPath = this.getLegacyOverridePath(path);
-        const exists = (0, fs_1.existsSync)(primaryPath) || (0, fs_1.existsSync)(legacyPath);
-        console.error(`[LocalRegistryResolver] hasLocalOverride(${path}) -> primary: ${primaryPath}, legacy: ${legacyPath}, exists: ${exists}`);
-        return exists;
+        return (0, fs_1.existsSync)(primaryPath) || (0, fs_1.existsSync)(legacyPath);
+    }
+    /**
+     * Find the actual relative path for a registry item by searching subdirectories.
+     * Returns '{type}/{category}/{name}.md' or '{type}/{name}.md'.
+     */
+    async findRegistryPath(type, name) {
+        const baseName = `${name}.md`;
+        const searchDirs = [type];
+        for (const dir of searchDirs) {
+            // Check literal path first
+            const literal = `${dir}/${baseName}`;
+            if (this.hasLocalOverride(literal))
+                return literal;
+            // Deep search
+            const fullBaseDir = (0, path_1.join)(this.workspaceRoot, '.fraim', 'personalized-employee', dir);
+            const legacyBaseDir = (0, path_1.join)(this.workspaceRoot, '.fraim', 'overrides', dir);
+            const found = this.searchFileRecursively(fullBaseDir, baseName) ||
+                this.searchFileRecursively(legacyBaseDir, baseName);
+            if (found) {
+                // Convert absolute back to relative
+                const rel = found.replace(/\\/g, '/');
+                const dirMarker = `/${dir}/`;
+                if (rel.includes(dirMarker)) {
+                    return rel.substring(rel.indexOf(dirMarker) + 1);
+                }
+            }
+        }
+        return `${type}/${name}.md`;
+    }
+    searchFileRecursively(dir, fileName) {
+        if (!(0, fs_1.existsSync)(dir))
+            return null;
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = (0, path_1.join)(dir, entry.name);
+            if (entry.isDirectory()) {
+                const found = this.searchFileRecursively(fullPath, fileName);
+                if (found)
+                    return found;
+            }
+            else if (entry.name === fileName) {
+                return fullPath;
+            }
+        }
+        return null;
     }
     /**
      * Check if a locally synced skill/rule file exists for the given registry path.
@@ -37,14 +116,24 @@ class LocalRegistryResolver {
      * Get the full path to a local override file
      */
     getOverridePath(path) {
-        return (0, path_1.join)(this.workspaceRoot, '.fraim/personalized-employee', path);
+        const normalized = path.replace(/\\/g, '/').replace(/^\/+/, '');
+        // Personal overrides are in .fraim/personalized-employee/
+        // We don't need a redundant 'registry/' subfolder here as the path already includes type (e.g. jobs/)
+        return (0, path_1.join)(this.workspaceRoot, '.fraim', 'personalized-employee', normalized);
     }
     /**
      * Get the full path to a legacy local override file.
      * Kept for backward compatibility while migrating to personalized-employee.
      */
     getLegacyOverridePath(path) {
-        return (0, path_1.join)(this.workspaceRoot, '.fraim/overrides', path);
+        const normalized = path.replace(/\\/g, '/').replace(/^\/+/, '');
+        const parts = normalized.split('/');
+        let lookupPath = normalized;
+        if (parts.length > 1 && (parts[0] === 'jobs' || parts[0] === 'workflows' || parts[0] === 'skills' || parts[0] === 'rules')) {
+            lookupPath = parts.slice(1).join('/');
+            return (0, path_1.join)(this.workspaceRoot, '.fraim', 'overrides', parts[0], lookupPath);
+        }
+        return (0, path_1.join)(this.workspaceRoot, '.fraim/overrides', normalized);
     }
     /**
      * Get the full path to a locally synced FRAIM file when available.
@@ -54,9 +143,58 @@ class LocalRegistryResolver {
      */
     getSyncedFilePath(path) {
         const normalizedPath = path.replace(/\\/g, '/').replace(/^\/+/, '');
+        // 1. Workflows: workflows/[role]/path -> .fraim/[role]/workflows/path
+        if (normalizedPath.startsWith('workflows/')) {
+            const parts = normalizedPath.split('/');
+            if (parts.length >= 3 && (parts[1] === 'ai-employee' || parts[1] === 'ai-manager')) {
+                const role = parts[1];
+                const subPath = parts.slice(2).join('/');
+                return (0, path_1.join)(this.workspaceRoot, '.fraim', role, 'workflows', subPath);
+            }
+            // Fallback: Try ai-employee and ai-manager if no role prefix
+            const subPath = normalizedPath.substring('workflows/'.length);
+            const employeePath = (0, path_1.join)(this.workspaceRoot, '.fraim', 'ai-employee', 'workflows', subPath);
+            if (fs.existsSync(employeePath))
+                return employeePath;
+            const managerPath = (0, path_1.join)(this.workspaceRoot, '.fraim', 'ai-manager', 'workflows', subPath);
+            if (fs.existsSync(managerPath))
+                return managerPath;
+            // Fallback for non-role-prefixed (legacy or direct)
+            return (0, path_1.join)(this.workspaceRoot, '.fraim', normalizedPath);
+        }
+        // 2. Jobs: jobs/[role]/path -> .fraim/[role]/jobs/path
+        if (normalizedPath.startsWith('jobs/')) {
+            const parts = normalizedPath.split('/');
+            if (parts.length >= 3 && (parts[1] === 'ai-employee' || parts[1] === 'ai-manager')) {
+                const role = parts[1];
+                const subPath = parts.slice(2).join('/');
+                return (0, path_1.join)(this.workspaceRoot, '.fraim', role, 'jobs', subPath);
+            }
+            // Fallback: Try ai-employee and ai-manager if no role prefix
+            const subPath = normalizedPath.substring('jobs/'.length);
+            const employeePath = (0, path_1.join)(this.workspaceRoot, '.fraim', 'ai-employee', 'jobs', subPath);
+            if (fs.existsSync(employeePath))
+                return employeePath;
+            const managerPath = (0, path_1.join)(this.workspaceRoot, '.fraim', 'ai-manager', 'jobs', subPath);
+            if (fs.existsSync(managerPath))
+                return managerPath;
+            // Fallback
+            return (0, path_1.join)(this.workspaceRoot, '.fraim', normalizedPath);
+        }
+        // 3. Rules: [role]/rules/path -> .fraim/[role]/rules/path
+        if (normalizedPath.includes('/rules/')) {
+            const role = normalizedPath.includes('/ai-manager/') ? 'ai-manager' : 'ai-employee';
+            // Extract the part after "rules/"
+            const rulesIdx = normalizedPath.indexOf('rules/');
+            const subPath = normalizedPath.substring(rulesIdx + 'rules/'.length);
+            return (0, path_1.join)(this.workspaceRoot, '.fraim', role, 'rules', subPath);
+        }
+        // 4. Skills: skills/path -> .fraim/ai-employee/skills/path (default to ai-employee)
         if (normalizedPath.startsWith('skills/')) {
-            return (0, path_1.join)(this.workspaceRoot, '.fraim/ai-employee', normalizedPath);
+            const subPath = normalizedPath.substring('skills/'.length);
+            return (0, path_1.join)(this.workspaceRoot, '.fraim/ai-employee', 'skills', subPath);
         }
+        // 5. Rules: rules/path -> .fraim/ai-employee/rules/path (default to ai-employee)
         if (normalizedPath.startsWith('rules/')) {
             return (0, path_1.join)(this.workspaceRoot, '.fraim/ai-employee', normalizedPath);
         }
@@ -84,12 +222,55 @@ class LocalRegistryResolver {
             return null;
         }
         try {
-            return (0, fs_1.readFileSync)(syncedPath, 'utf-8');
+            const content = (0, fs_1.readFileSync)(syncedPath, 'utf-8');
+            if (this.shouldFilter && this.shouldFilter(content)) {
+                return null;
+            }
+            return content;
         }
         catch {
             return null;
         }
     }
+    normalizeRegistryPath(path) {
+        const normalized = path.trim().replace(/\\/g, '/').replace(/^\/+/, '');
+        return normalized.endsWith('.md') ? normalized : `${normalized}.md`;
+    }
+    stripTypePrefix(path) {
+        return path.replace(/^(jobs|workflows|skills|rules|templates)\//, '');
+    }
+    areEquivalentRegistryPaths(left, right) {
+        const normalizedLeft = this.normalizeRegistryPath(left);
+        const normalizedRight = this.normalizeRegistryPath(right);
+        const strippedLeft = this.stripTypePrefix(normalizedLeft);
+        const strippedRight = this.stripTypePrefix(normalizedRight);
+        return normalizedLeft === normalizedRight ||
+            strippedLeft === strippedRight ||
+            normalizedLeft.endsWith(`/${strippedRight}`) ||
+            normalizedRight.endsWith(`/${strippedLeft}`) ||
+            strippedLeft.endsWith(`/${strippedRight}`) ||
+            strippedRight.endsWith(`/${strippedLeft}`);
+    }
+    async fetchRemoteWithFallback(...paths) {
+        const candidates = new Set();
+        for (const path of paths) {
+            if (!path)
+                continue;
+            const normalized = this.normalizeRegistryPath(path);
+            candidates.add(normalized);
+            candidates.add(this.stripTypePrefix(normalized));
+        }
+        let lastError = null;
+        for (const candidate of candidates) {
+            try {
+                return await this.remoteContentResolver(candidate);
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        throw lastError || new Error(`Failed to fetch remote content for ${paths.join(', ')}`);
+    }
     stripMcpHeader(content) {
         const trimmed = content.trimStart();
         if (!trimmed.startsWith('#')) {
@@ -115,10 +296,44 @@ class LocalRegistryResolver {
         if (!parseResult.hasImports) {
             return { content, imports: [] };
         }
-        // Resolve imports
+        // Resolve inheritance
         try {
             const resolved = await this.parser.resolve(content, currentPath, {
-                fetchParent: this.remoteContentResolver,
+                fetchParent: async (path) => {
+                    const normalized = this.normalizeRegistryPath(path);
+                    const normalizedCurrent = this.normalizeRegistryPath(currentPath);
+                    // If the import points back to the current file, skip local resolution and fetch
+                    // from the next layer (remote/global) instead.
+                    if (this.areEquivalentRegistryPaths(normalized, normalizedCurrent)) {
+                        return this.fetchRemoteWithFallback(normalizedCurrent, normalized);
+                    }
+                    // Otherwise, resolve through the normal local-first path.
+                    try {
+                        let targetPath = normalized;
+                        const hasKnownPrefix = targetPath.startsWith('jobs/') || targetPath.startsWith('workflows/') ||
+                            targetPath.startsWith('skills/') || targetPath.startsWith('rules/') || targetPath.startsWith('templates/');
+                        if (!hasKnownPrefix) {
+                            // Try to guess type from currentPath or just try jobs/workflows
+                            const type = normalizedCurrent.startsWith('jobs/') ? 'jobs' : (normalizedCurrent.startsWith('workflows/') ? 'workflows' : null);
+                            if (type) {
+                                try {
+                                    targetPath = await this.findRegistryPath(type, normalized.replace(/\.md$/, ''));
+                                }
+                                catch {
+                                    // Ignore and use original normalized
+                                }
+                            }
+                        }
+                        const res = await this.resolveFile(targetPath, {
+                            includeMetadata: false,
+                            stripMcpHeader: true
+                        });
+                        return res.content;
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                },
                 maxDepth: 5
             });
             return {
@@ -158,7 +373,6 @@ class LocalRegistryResolver {
      * @returns Resolved file with metadata
      */
     async resolveFile(path, options = {}) {
-        console.error(`[LocalRegistryResolver] ===== resolveFile called for: ${path} =====`);
         const includeMetadata = options.includeMetadata ?? true;
         const stripMcpHeader = options.stripMcpHeader ?? false;
         // Check for local override
@@ -171,9 +385,9 @@ class LocalRegistryResolver {
                     inherited: false
                 };
             }
-            // No override, fetch from remote
+            // No useful override or synced content, fetch from remote
             try {
-                const rawContent = await this.remoteContentResolver(path);
+                const rawContent = await this.fetchRemoteWithFallback(path);
                 const content = stripMcpHeader ? this.stripMcpHeader(rawContent) : rawContent;
                 return {
                     content,
@@ -189,11 +403,15 @@ class LocalRegistryResolver {
         let localContent;
         try {
             localContent = this.readLocalOverride(path);
+            if (this.shouldFilter && this.shouldFilter(localContent)) {
+                console.warn(`[LocalRegistryResolver] Local override for ${path} filtered (e.g. stub), falling back to remote.`);
+                throw new Error('CONTENT_FILTERED');
+            }
         }
         catch (error) {
             // If local read fails, fall back to remote
             console.warn(`Local override read failed, falling back to remote: ${path}`);
-            const rawContent = await this.remoteContentResolver(path);
+            const rawContent = await this.fetchRemoteWithFallback(path);
             const content = stripMcpHeader ? this.stripMcpHeader(rawContent) : rawContent;
             return {
                 content,
@@ -204,18 +422,11 @@ class LocalRegistryResolver {
         // Resolve inheritance
         let resolved;
         try {
-            console.error(`[LocalRegistryResolver] Resolving inheritance for ${path}`);
-            console.error(`[LocalRegistryResolver] Local content length: ${localContent.length} chars`);
-            console.error(`[LocalRegistryResolver] Local content preview: ${localContent.substring(0, 200)}`);
             resolved = await this.resolveInheritance(localContent, path);
-            console.error(`[LocalRegistryResolver] Inheritance resolved: ${resolved.imports.length} imports`);
-            console.error(`[LocalRegistryResolver] Resolved content length: ${resolved.content.length} chars`);
-            console.error(`[LocalRegistryResolver] Resolved content preview: ${resolved.content.substring(0, 200)}`);
         }
         catch (error) {
-            // If inheritance resolution fails, fall back to remote
-            console.error(`❌ Inheritance resolution failed for ${path}:`, error);
-            const content = await this.remoteContentResolver(path);
+            const rawContent = await this.fetchRemoteWithFallback(path);
+            const content = stripMcpHeader ? this.stripMcpHeader(rawContent) : rawContent;
             return {
                 content,
                 source: 'remote',
@@ -317,6 +528,99 @@ class LocalRegistryResolver {
             cache: new Map()
         });
     }
+    /**
+     * Implement RegistryResolver: Resolve raw file content
+     */
+    async getFile(path) {
+        try {
+            const result = await this.resolveFile(path, {
+                includeMetadata: false,
+                stripMcpHeader: true
+            });
+            return result.content;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Implement RegistryResolver: Parse and resolve a workflow or job
+     */
+    async getWorkflow(name, preferredType) {
+        const types = preferredType
+            ? [preferredType === 'job' ? 'jobs' : 'workflows']
+            : ['workflows', 'jobs'];
+        for (const typeDir of types) {
+            try {
+                const path = await this.findRegistryPath(typeDir, name);
+                const resolved = await this.resolveFile(path, {
+                    includeMetadata: false,
+                    stripMcpHeader: true
+                });
+                if (resolved) {
+                    return workflow_parser_1.WorkflowParser.parseContent(resolved.content, name, path);
+                }
+            }
+            catch (err) {
+                // Continue to next type if not successful
+                continue;
+            }
+        }
+        // Fallback for names that might already include type/category
+        try {
+            const finalPath = name.endsWith('.md') ? name : `${name}.md`;
+            const resolved = await this.resolveFile(finalPath, {
+                includeMetadata: false,
+                stripMcpHeader: true
+            });
+            return workflow_parser_1.WorkflowParser.parseContent(resolved.content, name, finalPath);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Implement RegistryResolver: List available items
+     * Note: For proxy, this is a merged view of local and potentially remote.
+     * Remote discovery is handled separately in list_fraim_jobs/workflows.
+     */
+    async listItems(type) {
+        // Current LocalRegistryResolver doesn't maintain a full list of remote items,
+        // so it primarily returns local overrides.
+        const items = [];
+        const dirs = type === 'job' ? ['jobs'] : (type === 'workflow' ? ['workflows'] : ['jobs', 'workflows']);
+        for (const dir of dirs) {
+            const localDir = (0, path_1.join)(this.workspaceRoot, '.fraim', 'personalized-employee', dir);
+            if (fs.existsSync(localDir)) {
+                const relPaths = this.collectLocalMarkdownPaths(localDir);
+                for (const rel of relPaths) {
+                    items.push({
+                        name: rel.replace(/\.md$/, ''),
+                        path: `${dir}/${rel}`,
+                        type: dir === 'jobs' ? 'job' : 'workflow'
+                    });
+                }
+            }
+        }
+        return items;
+    }
+    collectLocalMarkdownPaths(dir, currentRel = '') {
+        const results = [];
+        if (!fs.existsSync(dir))
+            return results;
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const rel = currentRel ? `${currentRel}/${entry.name}` : entry.name;
+            const full = (0, path_1.join)(dir, entry.name);
+            if (entry.isDirectory()) {
+                results.push(...this.collectLocalMarkdownPaths(full, rel));
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                results.push(rel);
+            }
+        }
+        return results;
+    }
 }
 exports.LocalRegistryResolver = LocalRegistryResolver;
 LocalRegistryResolver.MAX_INCLUDE_DEPTH = 10;