fraim-framework 2.0.96 → 2.0.98

package/dist/src/local-mcp-server/stdio-server.js

@@ -29,7 +29,9 @@ const provider_utils_1 = require("../core/utils/provider-utils");
 const object_utils_1 = require("../core/utils/object-utils");
 const local_registry_resolver_1 = require("../core/utils/local-registry-resolver");
 const ai_mentor_1 = require("../core/ai-mentor");
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
 const usage_collector_js_1 = require("./usage-collector.js");
+const learning_context_builder_js_1 = require("./learning-context-builder.js");
 /**
  * Handle template substitution logic separately for better testability
  */
@@ -75,6 +77,9 @@ class FraimTemplateEngine {
     setUserEmail(email) {
         this.userEmail = email;
     }
+    getUserEmail() {
+        return this.userEmail;
+    }
     substituteTemplates(content) {
         let result = content;
         // Substitute {{proxy.user.email}} with the email captured from fraim_connect
@@ -349,8 +354,8 @@ class FraimLocalMCPServer {
             process.env.INIT_CWD,
         ];
         for (const hint of workspaceHints) {
-            if (hint && (0, fs_1.existsSync)((0, path_1.join)(hint, '.fraim'))) {
-                this.log(`✅ Found .fraim via workspace env var: ${hint}`);
+            if (hint && (0, project_fraim_paths_1.workspaceFraimExists)(hint)) {
+                this.log(`Found ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)()} via workspace env var: ${hint}`);
                 return hint;
             }
         }
@@ -363,43 +368,43 @@ class FraimLocalMCPServer {
             this.log(`🏠 Home directory (will skip): ${homeDir}`);
         }
         while (currentDir !== root) {
-            const fraimDir = (0, path_1.join)(currentDir, '.fraim');
+            const fraimDir = (0, project_fraim_paths_1.getWorkspaceConfigPath)(currentDir).replace(/[\\/]config\.json$/, '');
             this.log(`   Checking: ${fraimDir}`);
             if ((0, fs_1.existsSync)(fraimDir)) {
-                // Skip home directory .fraim - continue searching for project-specific one
+                // Skip the home directory FRAIM dir and continue searching for a project-specific one
                 if (homeDir && currentDir === homeDir) {
-                    this.log(`   ⚠️  Skipping home directory .fraim, continuing search...`);
+                    this.log(`Skipping home directory ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)()}, continuing search...`);
                     currentDir = (0, path_1.dirname)(currentDir);
                     continue;
                 }
-                this.log(`✅ Found .fraim at: ${currentDir}`);
+                this.log(`Found workspace FRAIM dir at: ${currentDir}`);
                 return currentDir;
             }
             currentDir = (0, path_1.dirname)(currentDir);
         }
-        // Priority 3: Fall back to home directory .fraim if nothing else found
+        // Priority 3: Fall back to the home directory .fraim if nothing else found
         if (homeDir && (0, fs_1.existsSync)((0, path_1.join)(homeDir, '.fraim'))) {
             this.log(`⚠️  Using home directory .fraim as fallback: ${homeDir}`);
             return homeDir;
         }
-        this.log(`❌ No .fraim directory found`);
+        this.log('No workspace FRAIM directory found');
         return null;
     }
     loadConfig() {
         try {
             this.log(`📍 Process started from: ${process.cwd()}`);
-            // Try to find project root by searching for .fraim directory
+            // Try to find the project root by searching for the workspace FRAIM directory
             const projectDir = this.findProjectRoot() || process.cwd();
-            const configPath = (0, path_1.join)(projectDir, '.fraim', 'config.json');
+            const configPath = (0, project_fraim_paths_1.getWorkspaceConfigPath)(projectDir);
             this.log(`🔍 Looking for config at: ${configPath}`);
             if ((0, fs_1.existsSync)(configPath)) {
                 const configContent = (0, fs_1.readFileSync)(configPath, 'utf8');
                 this.config = JSON.parse(configContent);
-                this.log('✅ Loaded local .fraim/config.json');
+                this.log(`Loaded local ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('config.json')}`);
             }
             else {
                 this.config = null;
-                this.log('⚠️ No .fraim/config.json found - template substitution disabled');
+                this.log(`No ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('config.json')} found - template substitution disabled`);
             }
             if (this.engine) {
                 this.engine.setConfig(this.config);
@@ -546,6 +551,10 @@ class FraimLocalMCPServer {
      * Get the user's working style preference from ~/.fraim/config.json
      */
     getWorkingStyle() {
+        // Workspace config takes precedence over global config
+        if (this.config?.workingStyle) {
+            return this.config.workingStyle;
+        }
         try {
             const homeDir = process.env.HOME || process.env.USERPROFILE || '';
             const configPath = (0, path_1.join)(homeDir, '.fraim', 'config.json');
@@ -836,16 +845,17 @@ class FraimLocalMCPServer {
                 registryPath = await resolver.findRegistryPath('skills', args.skill);
             else if (toolName === 'get_fraim_job')
                 registryPath = await resolver.findRegistryPath('jobs', args.job);
-            else if (toolName === 'get_fraim_workflow')
-                registryPath = await resolver.findRegistryPath('workflows', args.workflow);
             if (registryPath) {
                 const localOverride = resolver.hasLocalOverride(registryPath);
-                const remoteFailed = response.error && (response.error.code === -32001 ||
-                    response.error.data?.remoteStatus === 404);
+                const remoteFailed = Boolean(response.error);
+                if (response.error) {
+                    this.log(`[req:${requestId}] Remote error for ${registryPath}: code=${response.error.code}`);
+                }
                 if (localOverride || remoteFailed) {
                     try {
-                        const resolved = await resolver.resolveFile(registryPath);
-                        if (resolved.content) {
+                        // personalized-employee/ takes priority; when remote fails, resolver falls back to synced/cached content
+                        const resolved = await resolver.resolveFile(registryPath).catch(() => null);
+                        if (resolved?.content) {
                             const substitutedContent = this.substituteTemplates(resolved.content);
                             const newResponse = {
                                 ...response,
@@ -856,7 +866,6 @@ class FraimLocalMCPServer {
                             };
                             delete newResponse.error;
                             finalizedResponse = newResponse;
-                            // Continue to Step 2 to resolve includes within the local override
                         }
                     }
                     catch (error) {
@@ -867,14 +876,35 @@ class FraimLocalMCPServer {
         }
         // 2. Resolve includes within the content (for all registry tools)
         finalizedResponse = await this.resolveIncludesInResponse(finalizedResponse, requestSessionId, requestId);
-        // 3. After fraim_connect succeeds, capture user email for {{proxy.user.email}} substitution
+        // 3. After fraim_connect succeeds, capture user email and inject learning context.
         if (toolName === 'fraim_connect' && !finalizedResponse.error) {
             const text = finalizedResponse.result?.content?.[0]?.text;
             if (typeof text === 'string') {
                 const emailMatch = text.match(/Your identity for this session: \*\*([^*]+)\*\*/);
                 if (emailMatch) {
-                    this.ensureEngine().setUserEmail(emailMatch[1].trim());
-                    this.log(`[req:${requestId}] Captured user email for template substitution: ${emailMatch[1].trim()}`);
+                    const userEmail = emailMatch[1].trim();
+                    this.ensureEngine().setUserEmail(userEmail);
+                    this.log(`[req:${requestId}] Captured user email for template substitution: ${userEmail}`);
+                    // Inject learning context from the local workspace (RFC 177: files live on disk, not server).
+                    const workspaceRoot = this.findProjectRoot() || process.cwd();
+                    const learningSection = (0, learning_context_builder_js_1.buildLearningContextSection)(workspaceRoot, userEmail, false);
+                    if (learningSection) {
+                        finalizedResponse.result.content[0].text = text + learningSection;
+                        this.log(`[req:${requestId}] Injected learning context for ${userEmail} from ${workspaceRoot}`);
+                    }
+                }
+            }
+        }
+        // 4. After get_fraim_job succeeds, inject learning context with job-focus frame.
+        if (toolName === 'get_fraim_job' && !finalizedResponse.error) {
+            const text = finalizedResponse.result?.content?.[0]?.text;
+            const userEmail = this.ensureEngine().getUserEmail();
+            if (typeof text === 'string' && userEmail) {
+                const workspaceRoot = this.findProjectRoot() || process.cwd();
+                const learningSection = (0, learning_context_builder_js_1.buildLearningContextSection)(workspaceRoot, userEmail, true);
+                if (learningSection) {
+                    finalizedResponse.result.content[0].text = text + `\n\n---` + learningSection;
+                    this.log(`[req:${requestId}] Injected job-focus learning context for ${userEmail}`);
                 }
             }
         }
@@ -1167,7 +1197,7 @@ class FraimLocalMCPServer {
                             id: request.id,
                             error: {
                                 code: -32603,
-                                message: 'Failed to detect repository information. Please ensure you are in a git repository or have .fraim/config.json configured with repository details, or provide repo info in fraim_connect arguments.'
+                                message: `Failed to detect repository information. Please ensure you are in a git repository or have ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('config.json')} configured with repository details, or provide repo info in fraim_connect arguments.`
                             }
                         };
                     }
@@ -1339,7 +1369,7 @@ class FraimLocalMCPServer {
                 try {
                     const mentor = this.getMentor(requestSessionId);
                     const tutoringResponse = await mentor.handleMentoringRequest(args);
-                    this.log(`✅ Local seekMentoring succeeded for ${args.workflowType}:${args.currentPhase}`);
+                    this.log(`✅ Local seekMentoring succeeded for ${args.jobName}:${args.currentPhase}`);
                     return await this.finalizeLocalToolTextResponse(request, requestSessionId, requestId, tutoringResponse.message);
                 }
                 catch (error) {
@@ -1347,44 +1377,50 @@ class FraimLocalMCPServer {
                     // If local fails, we continue to proxy to the remote server
                 }
             }
-            if (toolName === 'get_fraim_job' || toolName === 'get_fraim_workflow') {
-                const isJob = toolName === 'get_fraim_job';
-                const name = isJob ? args.job : args.workflow;
+            if (toolName === 'get_fraim_job') {
+                const name = args.job;
                 if (name) {
                     try {
                         const mentor = this.getMentor(requestSessionId);
-                        const overview = isJob
-                            ? await mentor.getJobOverview(name)
-                            : await mentor.getWorkflowOverview(name);
+                        const overview = await mentor.getJobOverview(name);
                         if (overview) {
-                            this.log(`✅ Local override found for ${toolName}: ${name}`);
+                            this.log(`✅ Local override found for get_fraim_job: ${name}`);
                             let responseText = overview.overview;
                             if (!overview.isSimple) {
                                 const phaseAuthority = await mentor.getPhaseAuthorityContent();
                                 if (phaseAuthority)
                                     responseText = `${phaseAuthority}\n\n---\n\n${responseText}`;
-                                responseText += `\n\n---\n\n**This ${isJob ? 'job' : 'workflow'} has phases.** Use \`seekMentoring\` to get phase-specific instructions.`;
+                                responseText += `\n\n---\n\n**This job has phases.** Use \`seekMentoring\` to get phase-specific instructions.`;
+                            }
+                            // Inject local learning context for job requests (RFC 177).
+                            const userEmail = this.ensureEngine().getUserEmail();
+                            if (userEmail) {
+                                const workspaceRoot = this.findProjectRoot() || process.cwd();
+                                const learningSection = (0, learning_context_builder_js_1.buildLearningContextSection)(workspaceRoot, userEmail, true);
+                                if (learningSection) {
+                                    responseText += `\n\n---` + learningSection;
+                                    this.log(`✅ Injected job-focus learning context for ${userEmail} (local override path)`);
+                                }
                             }
                             return await this.finalizeLocalToolTextResponse(request, requestSessionId, requestId, responseText);
                         }
                     }
                     catch (error) {
-                        this.log(`⚠️ Local ${toolName} failed for ${name}: ${error.message}. Falling back to remote.`);
+                        this.log(`⚠️ Local get_fraim_job failed for ${name}: ${error.message}. Falling back to remote.`);
                     }
                 }
             }
-            // DISCOVERY AGGREGATION: Merge local and remote jobs/workflows
-            if (toolName === 'list_fraim_jobs' || toolName === 'list_fraim_workflows') {
-                const isJob = toolName === 'list_fraim_jobs';
+            // DISCOVERY AGGREGATION: Merge local and remote jobs
+            if (toolName === 'list_fraim_jobs') {
                 const response = await this._doProxyToRemote(request, requestId);
                 if (!response.error && response.result?.content?.[0]?.text) {
                     try {
                         const resolver = this.getRegistryResolver(requestSessionId);
-                        const localItems = await resolver.listItems(isJob ? 'job' : 'workflow');
+                        const localItems = await resolver.listItems('job');
                         if (localItems.length > 0) {
-                            this.log(`📦 Aggregating ${localItems.length} local ${isJob ? 'jobs' : 'workflows'} into remote response`);
+                            this.log(`📦 Aggregating ${localItems.length} local jobs into remote response`);
                             let combinedText = response.result.content[0].text;
-                            combinedText += `\n\n## Local & Personalized ${isJob ? 'Jobs' : 'Workflows'} (.fraim/)\n\n`;
+                            combinedText += `\n\n## Local & Personalized Jobs (${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)()})\n\n`;
                             for (const item of localItems) {
                                 combinedText += `- **${item.name}**: ${item.description || '(No description available)'}\n`;
                             }
@@ -1600,14 +1636,33 @@ class FraimLocalMCPServer {
         if (toolName && requestSessionId) {
             const success = !response.error;
             this.log(`📊 Collecting usage: ${toolName} (session: ${requestSessionId}, success: ${success})`);
-            this.usageCollector.collectMCPCall(toolName, args, requestSessionId, success);
+            // Capture the current queue size before collection
+            const beforeCount = this.usageCollector.getEventCount();
+            try {
+                this.usageCollector.collectMCPCall(toolName, args, requestSessionId, success);
+                // Check if the event was actually added to the queue
+                const afterCount = this.usageCollector.getEventCount();
+                if (afterCount > beforeCount) {
+                    this.log(`📊 ✅ Event queued successfully (queue: ${afterCount})`);
+                }
+                else {
+                    this.log(`📊 ⚠️ Event not queued - tool may not be tracked: ${toolName}`);
+                    // Log the args for debugging path parsing issues
+                    if (toolName === 'get_fraim_file' && args.path) {
+                        this.log(`📊 🔍 Debug: get_fraim_file path="${args.path}"`);
+                    }
+                }
+            }
+            catch (error) {
+                this.log(`📊 ❌ Usage collection error: ${error.message}`);
+            }
         }
         else if (request.method === 'tools/call') {
             this.log(`⚠️ Skipping usage collection: toolName=${toolName}, sessionId=${requestSessionId}`);
         }
     }
     /**
-     * Flush collected usage data to the local database
+     * Flush collected usage data to the remote server
      */
     async uploadUsageData() {
         const eventCount = this.usageCollector.getEventCount();
@@ -1616,11 +1671,16 @@ class FraimLocalMCPServer {
             return; // Nothing to flush
         }
         try {
+            this.log(`📊 Attempting to flush ${eventCount} events to ${this.remoteUrl}/api/analytics/events`);
             await this.usageCollector.flush(this.remoteUrl, this.apiKey);
-            this.log(`📊 Flushed ${eventCount} usage events to remote server`);
+            this.log(`📊 ✅ Successfully flushed ${eventCount} usage events to remote server`);
         }
         catch (error) {
-            this.log(`❌ Usage flushing error: ${error.message}`);
+            this.log(`📊 ❌ Usage flushing error: ${error.message}`);
+            // Log additional details for debugging
+            if (error.response) {
+                this.log(`📊 🔍 HTTP Status: ${error.response.status}, Data: ${JSON.stringify(error.response.data)}`);
+            }
         }
     }
 }

package/dist/src/local-mcp-server/usage-collector.js

@@ -18,6 +18,22 @@ class UsageCollector {
         this.events = [];
         this.apiKeyId = null;
     }
+    static resolveMentoringJobName(args) {
+        if (!args || typeof args !== 'object') {
+            return 'unknown';
+        }
+        if (typeof args.jobName === 'string' && args.jobName.trim().length > 0) {
+            return args.jobName.trim();
+        }
+        // Backward compatibility for older callers and docs that still use workflowType.
+        if (typeof args.workflowType === 'string' && args.workflowType.trim().length > 0) {
+            return args.workflowType.trim();
+        }
+        if (typeof args.job === 'string' && args.job.trim().length > 0) {
+            return args.job.trim();
+        }
+        return 'unknown';
+    }
     /**
      * Set the API key ID for this session
      */
@@ -27,12 +43,17 @@ class UsageCollector {
     /**
      * Collect MCP tool call event
      */
-    collectMCPCall(toolName, args, sessionId, success = true, duration) {
+    collectMCPCall(toolName, args, sessionId, success = true) {
         const parsed = this.parseMCPCall(toolName, args);
         if (!parsed) {
-            console.error(`[UsageCollector] 🚫 Tool not tracked: ${toolName}`);
+            const errorMsg = `[UsageCollector] 🚫 Tool not tracked: ${toolName}`;
+            console.error(errorMsg);
+            // Also log to stderr for better visibility in main logs
+            process.stderr.write(errorMsg + '\n');
             return;
         }
+        // Extract useful args for analytics
+        const analyticsArgs = this.extractAnalyticsArgs(toolName, args);
         const event = {
             type: parsed.type,
             name: parsed.name,
@@ -40,18 +61,19 @@ class UsageCollector {
             // The server will override this with the correct value from the auth token.
             apiKeyId: this.apiKeyId || PLACEHOLDER_API_KEY_ID,
             sessionId,
-            success
+            success,
+            args: analyticsArgs
         };
-        if (duration !== undefined) {
-            event.duration = duration;
-        }
         this.events.push(event);
-        console.error(`[UsageCollector] ✅ Collected event: ${parsed.type}/${parsed.name} (session: ${sessionId}, queue: ${this.events.length})`);
+        const successMsg = `[UsageCollector] ✅ Collected event: ${parsed.type}/${parsed.name} (session: ${sessionId}, queue: ${this.events.length})`;
+        console.error(successMsg);
+        // Also log to stderr for better visibility in main logs
+        process.stderr.write(successMsg + '\n');
     }
     /**
      * Collect usage event directly (for backward compatibility with tests)
      */
-    collectEvent(type, name, sessionId, success = true, duration) {
+    collectEvent(type, name, sessionId, success = true, args) {
         const event = {
             type,
             name,
@@ -59,13 +81,57 @@ class UsageCollector {
             // The server will override this with the correct value from the auth token.
             apiKeyId: this.apiKeyId || PLACEHOLDER_API_KEY_ID,
             sessionId,
-            success
+            success,
+            args
         };
-        if (duration !== undefined) {
-            event.duration = duration;
-        }
         this.events.push(event);
     }
+    /**
+     * Extract useful arguments for analytics tracking
+     */
+    extractAnalyticsArgs(toolName, args) {
+        const analyticsArgs = {};
+        switch (toolName) {
+            case 'seekMentoring':
+                if (args.currentPhase)
+                    analyticsArgs.currentPhase = args.currentPhase;
+                if (args.status)
+                    analyticsArgs.status = args.status;
+                const mentoringJobName = UsageCollector.resolveMentoringJobName(args);
+                if (mentoringJobName !== 'unknown')
+                    analyticsArgs.jobName = mentoringJobName;
+                if (args.issueNumber)
+                    analyticsArgs.issueNumber = args.issueNumber;
+                break;
+            case 'get_fraim_file':
+                if (args.path) {
+                    analyticsArgs.path = args.path;
+                    // Extract category and subcategory from path
+                    const pathParts = args.path.split('/');
+                    if (pathParts.length >= 2) {
+                        analyticsArgs.category = pathParts[1]; // skills, jobs, rules, workflows
+                        if (pathParts.length >= 3) {
+                            analyticsArgs.subcategory = pathParts[2]; // engineering, product-building, etc.
+                        }
+                    }
+                }
+                break;
+            case 'get_fraim_job':
+                if (args.job)
+                    analyticsArgs.job = args.job;
+                break;
+            case 'fraim_connect':
+                if (args.agent?.name)
+                    analyticsArgs.agentName = args.agent.name;
+                if (args.agent?.model)
+                    analyticsArgs.agentModel = args.agent.model;
+                break;
+            default:
+                // For other tools, don't collect args to avoid PII
+                return undefined;
+        }
+        return Object.keys(analyticsArgs).length > 0 ? analyticsArgs : undefined;
+    }
     /**
      * Parse MCP tool call to extract usage analytics info
      */
@@ -79,7 +145,11 @@ class UsageCollector {
                 }
                 return null;
             case 'seekMentoring':
-                return { type: 'mentoring', name: args.workflowType || 'unknown' };
+                return { type: 'mentoring', name: UsageCollector.resolveMentoringJobName(args) };
+            case 'list_fraim_jobs':
+                return { type: 'job', name: 'list' };
+            case 'fraim_connect':
+                return { type: 'session', name: 'connect' };
             default:
                 return null;
         }
@@ -103,12 +173,16 @@ class UsageCollector {
      */
     async flush(remoteUrl, apiKey) {
         if (this.events.length === 0) {
-            console.error(`[UsageCollector] 📊 No events to flush`);
+            const noEventsMsg = `[UsageCollector] 📊 No events to flush`;
+            console.error(noEventsMsg);
+            process.stderr.write(noEventsMsg + '\n');
             return;
         }
         const events = [...this.events];
         this.events = [];
-        console.error(`[UsageCollector] 📤 Flushing ${events.length} events to ${remoteUrl}/api/analytics/events`);
+        const flushMsg = `[UsageCollector] 📤 Flushing ${events.length} events to ${remoteUrl}/api/analytics/events`;
+        console.error(flushMsg);
+        process.stderr.write(flushMsg + '\n');
         try {
             const response = await axios_1.default.post(`${remoteUrl}/api/analytics/events`, {
                 events,
@@ -120,15 +194,27 @@ class UsageCollector {
                     'Content-Type': 'application/json'
                 }
             });
-            console.error(`[UsageCollector] ✅ Successfully flushed ${events.length} events (HTTP ${response.status})`);
+            const successMsg = `[UsageCollector] ✅ Successfully flushed ${events.length} events (HTTP ${response.status})`;
+            console.error(successMsg);
+            process.stderr.write(successMsg + '\n');
             // Success - events are already cleared from the queue
         }
         catch (error) {
             const status = error.response?.status;
             const message = error.response?.data?.error || error.message;
-            console.error(`[UsageCollector] ❌ Failed to flush usage events (HTTP ${status}): ${message}`);
+            const errorMsg = `[UsageCollector] ❌ Failed to flush usage events (HTTP ${status}): ${message}`;
+            console.error(errorMsg);
+            process.stderr.write(errorMsg + '\n');
+            // Log additional debug info
+            if (error.response?.data) {
+                const debugMsg = `[UsageCollector] 🔍 Response data: ${JSON.stringify(error.response.data)}`;
+                console.error(debugMsg);
+                process.stderr.write(debugMsg + '\n');
+            }
             // Put events back at the beginning of the queue for next try
             this.events = [...events, ...this.events];
+            // Re-throw the error so the main server can log it too
+            throw error;
         }
     }
     /**
@@ -141,24 +227,37 @@ class UsageCollector {
      * Parse component name from file path
      */
     static parseComponentName(path) {
-        if (path.includes('/jobs/')) {
-            const jobMatch = path.match(/\/jobs\/[^/]+\/[^/]+\/([^/]+)\.md$/);
-            if (jobMatch) {
-                return { type: 'job', name: jobMatch[1] };
-            }
-        }
-        if (path.includes('/skills/')) {
-            const skillMatch = path.match(/\/skills\/[^/]+\/([^/]+)\.md$/);
+        // Normalize path to have leading slash for consistent regex matching
+        const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+        // Match skills files: /skills/category/skill-name.md
+        if (normalizedPath.includes('/skills/')) {
+            const skillMatch = normalizedPath.match(/\/skills\/[^/]+\/([^/]+)\.md$/);
             if (skillMatch) {
                 return { type: 'skill', name: skillMatch[1] };
             }
         }
-        if (path.includes('/rules/')) {
-            const ruleMatch = path.match(/\/rules\/[^/]+\/([^/]+)\.md$/);
+        // Match job files: /jobs/category/subcategory/job-name.md
+        if (normalizedPath.includes('/jobs/')) {
+            const jobMatch = normalizedPath.match(/\/jobs\/[^/]+\/[^/]+\/([^/]+)\.md$/);
+            if (jobMatch) {
+                return { type: 'job', name: jobMatch[1] };
+            }
+        }
+        // Match rule files: /rules/category/rule-name.md
+        if (normalizedPath.includes('/rules/')) {
+            const ruleMatch = normalizedPath.match(/\/rules\/[^/]+\/([^/]+)\.md$/);
             if (ruleMatch) {
                 return { type: 'rule', name: ruleMatch[1] };
             }
         }
+        // For other paths that don't match the expected patterns, 
+        // we'll classify them as 'job' type with a generic name
+        // This ensures we track usage even for non-standard paths
+        const fileName = normalizedPath.split('/').pop();
+        if (fileName && fileName.endsWith('.md')) {
+            const baseName = fileName.replace(/\.md$/, '');
+            return { type: 'job', name: baseName };
+        }
         return null;
     }
 }

package/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 /**
  * FRAIM Framework - Smart Entry Point

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.96",
+  "version": "2.0.98",
   "description": "FRAIM v2: Framework for Rigor-based AI Management - Transform from solo developer to AI manager orchestrating production-ready code with enterprise-grade discipline",
   "main": "index.js",
   "bin": {
@@ -35,10 +35,10 @@
     "postinstall": "fraim sync --skip-updates || echo 'FRAIM setup skipped.'",
     "prepublishOnly": "npm run build",
     "release": "npm version patch && npm publish",
-    "validate:registry": "tsx scripts/verify-registry-paths.ts && npm run validate:workflows && npm run validate:skills && npm run validate:platform-agnostic && npm run validate:template-namespaces && npm run validate:config-fallbacks && npm run validate:bootstrap-config-coverage && npm run validate:provider-action-mappings && npm run validate:fidelity && npm run validate:config-tokens && npm run validate:brain-mapping && npm run validate:template-syntax",
+    "validate:registry": "tsx scripts/verify-registry-paths.ts && npm run validate:jobs && npm run validate:skills && npm run validate:platform-agnostic && npm run validate:template-namespaces && npm run validate:config-fallbacks && npm run validate:bootstrap-config-coverage && npm run validate:provider-action-mappings && npm run validate:fidelity && npm run validate:config-tokens && npm run validate:brain-mapping && npm run validate:template-syntax",
     "validate:brain-mapping": "tsx scripts/validate-brain-mapping.ts",
     "validate:fraim-pro-assets": "tsx scripts/validate-fraim-pro-assets.ts",
-    "validate:workflows": "tsx scripts/validate-workflows.ts",
+    "validate:jobs": "tsx scripts/validate-jobs.ts",
     "validate:platform-agnostic": "tsx scripts/validate-platform-agnostic.ts",
     "validate:skills": "tsx scripts/validate-skills.ts",
     "validate:template-namespaces": "tsx scripts/validate-template-namespaces.ts",
@@ -60,7 +60,6 @@
     "ai-agents",
     "multi-agent",
     "github",
-    "workflow",
     "automation",
     "gitops",
     "cursor",