fraim-framework 2.0.86 → 2.0.88

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;

package/dist/src/core/utils/server-startup.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPortConflictError = createPortConflictError;
+exports.startListening = startListening;
+exports.logStartupError = logStartupError;
+function createPortConflictError(port) {
+    const error = new Error(`Port ${port} is already in use. Another process is already listening on http://localhost:${port}. Stop that process or set FRAIM_MCP_PORT/PORT to a different port.`);
+    error.code = 'EADDRINUSE';
+    return error;
+}
+async function startListening(app, port, onListening) {
+    await new Promise((resolve, reject) => {
+        const server = app.listen(port);
+        server.once('listening', () => {
+            onListening();
+            resolve();
+        });
+        server.once('error', (error) => {
+            if (error?.code === 'EADDRINUSE') {
+                reject(createPortConflictError(port));
+                return;
+            }
+            reject(error);
+        });
+    });
+}
+function logStartupError(error) {
+    const maybePortError = error;
+    if (maybePortError?.code === 'EADDRINUSE') {
+        console.error(`[FRAIM PORT] ${maybePortError.message}`);
+        return;
+    }
+    console.error('❌ Failed to start FRAIM MCP Server:', error);
+}

package/dist/src/core/utils/stub-generator.js

@@ -8,6 +8,7 @@ exports.generateRuleStub = generateRuleStub;
 exports.parseRegistryJob = parseRegistryJob;
 exports.parseRegistrySkill = parseRegistrySkill;
 exports.parseRegistryRule = parseRegistryRule;
+const STUB_MARKER = '<!-- FRAIM_DISCOVERY_STUB -->';
 function extractSection(content, headingPatterns) {
     for (const heading of headingPatterns) {
         const pattern = new RegExp(`(?:^|\\n)#{2,3}\\s*${heading}\\s*\\n([\\s\\S]*?)(?=\\n#{2,3}\\s|$)`, 'i');
@@ -49,7 +50,8 @@ function extractLeadParagraph(content) {
  * These stubs are committed to the user's repo for discoverability.
  */
 function generateWorkflowStub(workflowName, workflowPath, intent, principles) {
-    return `# FRAIM Workflow: ${workflowName}
+    return `${STUB_MARKER}
+# FRAIM Workflow: ${workflowName}
 
 > [!IMPORTANT]
 > This is a **FRAIM-managed workflow stub**. 
@@ -78,8 +80,9 @@ function parseRegistryWorkflow(content) {
 /**
  * Coaching stubs are discoverability artifacts and should be resolved with get_fraim_file.
  */
-function generateJobStub(jobName, _jobPath, intent, outcome) {
-    return `# FRAIM Job: ${jobName}
+function generateJobStub(jobName, _jobPath, intent, outcome, steps) {
+    return `${STUB_MARKER}
+# FRAIM Job: ${jobName}
 
 ## Intent
 ${intent}
@@ -87,6 +90,9 @@ ${intent}
 ## Outcome
 ${outcome}
 
+## Steps
+${steps}
+
 ---
 
 > [!IMPORTANT]
@@ -103,19 +109,21 @@ ${outcome}
 /**
  * Generates a lightweight markdown stub for a skill.
  */
-function generateSkillStub(skillName, skillPath, intent, outcome) {
-    return `# FRAIM Skill: ${skillName}
+function generateSkillStub(skillName, skillPath, skillInput, skillOutput) {
+    return `${STUB_MARKER}
+# FRAIM Skill: ${skillName}
 
-## Intent
-${intent}
+## Skill Input
+${skillInput}
 
-## Outcome
-${outcome}
+## Skill Output
+${skillOutput}
 
 ---
 
 > [!IMPORTANT]
-> **For AI Agents:** This is a skill stub for discoverability.
+> **For AI Agents:** This is a discoverability stub for the skill.
+> All execution details must be fetched from MCP before use.
 > To retrieve the complete skill instructions, call:
 > \`get_fraim_file({ path: "skills/${skillPath}" })\`
 `;
@@ -123,52 +131,51 @@ ${outcome}
 /**
  * Generates a lightweight markdown stub for a rule.
  */
-function generateRuleStub(ruleName, rulePath, intent, outcome) {
-    return `# FRAIM Rule: ${ruleName}
+function generateRuleStub(ruleName, rulePath, intent) {
+    return `${STUB_MARKER}
+# FRAIM Rule: ${ruleName}
 
 ## Intent
 ${intent}
 
-## Outcome
-${outcome}
-
 ---
 
 > [!IMPORTANT]
-> **For AI Agents:** This is a rule stub for discoverability.
+> **For AI Agents:** This is a discoverability stub for the rule.
+> All rule details must be fetched from MCP before use.
 > To retrieve the complete rule instructions, call:
 > \`get_fraim_file({ path: "rules/${rulePath}" })\`
 `;
 }
 /**
- * Parses a job file from the registry to extract its intent and outcome for the stub.
+ * Parses a job file from the registry to extract its intent, outcome, and steps for the stub.
  */
 function parseRegistryJob(content) {
     const intentMatch = content.match(/##\s*intent\s+([\s\S]*?)(?=\n##|$)/i);
     const outcomeMatch = content.match(/##\s*outcome\s+([\s\S]*?)(?=\n##|$)/i);
+    const stepsMatch = content.match(/##\s*steps\s+([\s\S]*?)(?=\n##|$)/i);
     const intent = intentMatch ? intentMatch[1].trim() : 'No intent defined.';
     const outcome = outcomeMatch ? outcomeMatch[1].trim() : 'No outcome defined.';
-    return { intent, outcome };
+    const steps = stepsMatch ? stepsMatch[1].trim() : 'Use get_fraim_job to retrieve the full phase-by-phase execution steps.';
+    return { intent, outcome, steps };
 }
 /**
  * Parses a skill file from the registry to extract intent and expected outcome for stubs.
  */
 function parseRegistrySkill(content) {
-    const intent = extractSection(content, ['intent', 'skill intent']) ||
+    const skillInput = extractSection(content, ['skill input', 'input', 'intent', 'skill intent']) ||
         extractLeadParagraph(content) ||
-        'Apply the skill correctly using the provided inputs and constraints.';
-    const outcome = extractSection(content, ['outcome', 'expected behavior', 'skill output']) ||
-        'Produce the expected skill output while following skill guardrails.';
-    return { intent, outcome };
+        'Use this skill only when the task matches the skill trigger, context, and required inputs.';
+    const skillOutput = extractSection(content, ['skill output', 'output', 'outcome', 'expected behavior']) ||
+        'Produce the concrete deliverable or decision this skill is designed to return.';
+    return { skillInput, skillOutput };
 }
 /**
- * Parses a rule file from the registry to extract intent and expected behavior for stubs.
+ * Parses a rule file from the registry to extract intent for stubs.
  */
 function parseRegistryRule(content) {
     const intent = extractSection(content, ['intent']) ||
         extractLeadParagraph(content) ||
         'Follow this rule when executing related FRAIM workflows and jobs.';
-    const outcome = extractSection(content, ['outcome', 'expected behavior', 'principles']) ||
-        'Consistently apply this rule throughout execution.';
-    return { intent, outcome };
+    return { intent };
 }