fraim 2.0.276 → 2.0.277

package/dist/src/cli/utils/pack-home.js

@@ -7,6 +7,7 @@ exports.packsDir = packsDir;
 exports.defaultCloneDir = defaultCloneDir;
 exports.resolvePackHome = resolvePackHome;
 exports.packReadRoots = packReadRoots;
+exports.personalizedCapabilityReadRoots = personalizedCapabilityReadRoots;
 exports.migrateStrandedContent = migrateStrandedContent;
 exports.findStrandedLegacyContent = findStrandedLegacyContent;
 exports.gitUrlHasUserinfo = gitUrlHasUserinfo;
@@ -173,6 +174,45 @@ function resolvePackHome(layer) {
 function packReadRoots(layer) {
     return [resolvePackHome(layer).contentRoot];
 }
+function displayPathForContentRoot(contentRoot) {
+    const userRoot = (0, project_fraim_paths_1.getUserFraimDirPath)();
+    const rel = path_1.default.relative(userRoot, contentRoot);
+    if (rel === '' || (rel && !rel.startsWith('..') && !path_1.default.isAbsolute(rel))) {
+        return (0, project_fraim_paths_1.getUserFraimDisplayPath)(rel);
+    }
+    return contentRoot.replace(/\\/g, '/');
+}
+/**
+ * Return personalized capability roots in merge order: org, manager, project.
+ *
+ * Callers that de-duplicate by key can iterate this array directly and let
+ * later entries overwrite earlier ones, matching capability resolution
+ * precedence where project overrides manager and manager overrides org.
+ */
+function personalizedCapabilityReadRoots(projectRoot, capabilityDir) {
+    const roots = [];
+    for (const layer of ['org', 'manager']) {
+        const contentRoot = resolvePackHome(layer).contentRoot;
+        roots.push({
+            scope: layer,
+            contentRoot,
+            capabilityRoot: path_1.default.join(contentRoot, capabilityDir),
+            displayRoot: contentRoot,
+            displayPrefix: displayPathForContentRoot(contentRoot),
+        });
+    }
+    if (projectRoot) {
+        const contentRoot = (0, project_fraim_paths_1.getWorkspaceFraimPath)(projectRoot, 'personalized-employee');
+        roots.push({
+            scope: 'project',
+            contentRoot,
+            capabilityRoot: path_1.default.join(contentRoot, capabilityDir),
+            displayRoot: contentRoot,
+            displayPrefix: (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('personalized-employee'),
+        });
+    }
+    return roots;
+}
 /**
  * Auto-migrate content stranded at the legacy standard path to the configured
  * contentRoot. Runs at most once per process per (layer + contentRoot) pair.

package/dist/src/core/job-visualization.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildJobVisualization = buildJobVisualization;
+const local_registry_resolver_1 = require("./utils/local-registry-resolver");
+const job_parser_1 = require("./utils/job-parser");
+function friendlyLabel(id) {
+    const PREFIXES = ['implement-', 'address-', 'spec-', 'design-', 'context-'];
+    let body = id;
+    for (const p of PREFIXES) {
+        if (body.startsWith(p) && body.length > p.length) {
+            body = body.slice(p.length);
+            break;
+        }
+    }
+    const spaced = body.replace(/-/g, ' ').trim();
+    if (!spaced)
+        return id;
+    return spaced[0].toUpperCase() + spaced.slice(1).toLowerCase();
+}
+function readSection(content, heading) {
+    const re = new RegExp(`(?:^|\\r?\\n)#{1,6} ${heading}[ \\t]*\\r?\\n([\\s\\S]*?)(?=\\r?\\n#{1,6} |\\r?\\n---|$)`);
+    const m = content.match(re);
+    if (!m)
+        return null;
+    const text = m[1]
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l && !l.startsWith('{{'))
+        .map((l) => l.replace(/^[-*]\s*/, ''))
+        .join(' ')
+        .trim();
+    return text || null;
+}
+function parseSkillIdFromInclude(line) {
+    const m = line.match(/\{\{include:skills\/([^}]+?)(?:\.md)?\}\}/);
+    if (!m)
+        return null;
+    return m[1].replace(/\.md$/, '');
+}
+function skillLabelFromId(skillId) {
+    const base = skillId.includes('/') ? skillId.split('/').pop() : skillId;
+    return base.replace(/-/g, ' ');
+}
+function isStub(content) {
+    return (content.includes('<!-- FRAIM_DISCOVERY_STUB -->') ||
+        content.includes('STUB:') ||
+        content.includes('<!-- STUB -->'));
+}
+function buildResolver(projectPath) {
+    // remoteContentResolver is required by LocalRegistryResolver but never reached
+    // for local repos: findRegistryPath now searches registry/ as a fallback layer,
+    // and readWorkspaceRegistryFile handles the direct path lookup.
+    return new local_registry_resolver_1.LocalRegistryResolver({
+        workspaceRoot: projectPath,
+        shouldFilter: isStub,
+        remoteContentResolver: async (registryPath) => {
+            throw new Error(`registry file not found locally: ${registryPath}`);
+        },
+    });
+}
+function toTitleCase(id) {
+    return id
+        .split('-')
+        .map((w) => w[0].toUpperCase() + w.slice(1).toLowerCase())
+        .join(' ');
+}
+function parseJobTitle(content, jobId) {
+    const m = content.match(/^#\s+(?:FRAIM Job:\s*)?(.+)/m);
+    if (m) {
+        const raw = m[1].trim();
+        if (/^[a-z0-9-]+$/.test(raw))
+            return toTitleCase(raw);
+        return raw;
+    }
+    return toTitleCase(jobId);
+}
+function parseJobLevelIntent(content) {
+    const m = content.match(/(?:^|\r?\n)## Intent[ \t]*\r?\n([\s\S]*?)(?=\r?\n#{1,6} |\r?\n---|$)/);
+    if (!m)
+        return null;
+    const lines = m[1].split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith('{{'));
+    const text = lines.map((l) => l.replace(/^[-*]\s*/, '')).join(' ').trim();
+    return text || null;
+}
+const EMPTY_RESPONSE = (jobId) => ({
+    jobId,
+    title: toTitleCase(jobId),
+    intent: null,
+    personalized: false,
+    phases: [],
+});
+async function buildJobVisualization(jobId, projectPath) {
+    const resolver = buildResolver(projectPath);
+    const registryPath = await resolver.findRegistryPath('jobs', jobId);
+    let jobFile;
+    try {
+        jobFile = await resolver.resolveFile(registryPath, {
+            includeMetadata: false,
+            stripMcpHeader: true,
+        });
+    }
+    catch {
+        return EMPTY_RESPONSE(jobId);
+    }
+    const content = jobFile.content;
+    if (!content?.trim())
+        return EMPTY_RESPONSE(jobId);
+    const title = parseJobTitle(content, jobId);
+    const intent = parseJobLevelIntent(content);
+    // Phase splitting reuses JobParser — the same parser the MCP proxy uses.
+    const jobDef = job_parser_1.JobParser.parseContent(content, jobId);
+    if (!jobDef || jobDef.phases.size === 0) {
+        return { jobId, title, intent, personalized: jobFile.personalized, scope: jobFile.scope, phases: [] };
+    }
+    const phases = await Promise.all([...jobDef.phases.entries()].map(async ([phaseId, phaseContent]) => {
+        const phaseIntent = readSection(phaseContent, 'Intent');
+        const phaseOutcome = readSection(phaseContent, 'Outcome');
+        const skillIds = [];
+        for (const line of phaseContent.split(/\r?\n/)) {
+            const id = parseSkillIdFromInclude(line);
+            if (id)
+                skillIds.push(id);
+        }
+        const skills = await Promise.all(skillIds.map(async (skillId) => {
+            try {
+                const skillFile = await resolver.resolveFile(`skills/${skillId}.md`, {
+                    includeMetadata: false,
+                    stripMcpHeader: true,
+                });
+                return {
+                    id: skillId,
+                    label: skillLabelFromId(skillId),
+                    input: readSection(skillFile.content, 'Skill Input'),
+                    output: readSection(skillFile.content, 'Skill Output'),
+                    personalized: skillFile.personalized,
+                    scope: skillFile.scope,
+                };
+            }
+            catch {
+                return { id: skillId, label: skillLabelFromId(skillId), input: null, output: null, personalized: false };
+            }
+        }));
+        return {
+            id: phaseId,
+            label: friendlyLabel(phaseId),
+            intent: phaseIntent,
+            outcome: phaseOutcome,
+            personalized: jobFile.personalized,
+            scope: jobFile.scope,
+            skills,
+        };
+    }));
+    return {
+        jobId,
+        title,
+        intent,
+        personalized: jobFile.personalized,
+        scope: jobFile.scope,
+        phases,
+    };
+}

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

@@ -130,9 +130,12 @@ class JobParser {
     }
     static parseSimpleJob(filePath, content) {
         const jobName = (0, path_1.basename)(filePath, '.md');
-        const metadata = {
-            name: jobName
-        };
+        const metadata = { name: jobName };
+        // If the content contains ## Phase: sections, parse them the same way as
+        // phase-based jobs so callers always get a populated phases Map.
+        if (/^##\s+Phase:/im.test(content)) {
+            return this.parsePhaseBasedJob(filePath, content, metadata, 0);
+        }
         return {
             metadata,
             overview: content.trim(),

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

@@ -101,6 +101,7 @@ class LocalRegistryResolver {
                 (0, path_1.join)(this.managerLocalRoot, dir),
                 (0, path_1.join)(this.managerCacheRoot, dir),
                 (0, path_1.join)(this.orgCacheRoot, dir),
+                (0, path_1.join)(this.workspaceRoot, 'registry', dir),
             ];
             for (const root of searchRoots) {
                 const found = this.searchFileRecursively(root, baseName);

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

@@ -2272,19 +2272,9 @@ class FraimLocalMCPServer {
                     try {
                         const projectRoot = this.findProjectRoot();
                         const uniqueLocalItems = new Map();
-                        // Issue #1002 R3: list the manager's own jobs too, not only the
-                        // project's. A job authored at the manager level resolves by name
-                        // from every project, so omitting it here made it invisible in the
-                        // one place the manager looks to find out what their employee can do.
                         // Lowest precedence first, so a project job of the same name wins.
-                        const { resolvePackHome: _resolvePackHome } = require('../cli/utils/pack-home');
-                        const managerJobsDir = (0, path_1.join)(_resolvePackHome('manager').contentRoot, 'jobs');
-                        const jobDirsByLevel = [
-                            { dir: managerJobsDir, level: 'manager' },
-                            ...(projectRoot
-                                ? [{ dir: (0, path_1.join)(projectRoot, 'fraim', 'personalized-employee', 'jobs'), level: 'project' }]
-                                : []),
-                        ];
+                        const jobDirsByLevel = (0, pack_home_1.personalizedCapabilityReadRoots)(projectRoot, 'jobs')
+                            .map((root) => ({ dir: root.capabilityRoot, level: root.scope }));
                         for (const { dir: jobsDir, level } of jobDirsByLevel) {
                             const personalizedJobsDir = jobsDir;
                             if ((0, fs_1.existsSync)(personalizedJobsDir)) {
@@ -2335,7 +2325,9 @@ class FraimLocalMCPServer {
                                     : '';
                                 const levelWord = item.level === 'project'
                                     ? 'this project only'
-                                    : 'yours, every project';
+                                    : item.level === 'org'
+                                        ? 'everyone in the organization'
+                                        : 'yours, every project';
                                 combinedText += `- **${item.name}**${categorySuffix} - ${levelWord}\n`;
                             }
                             response.result.content[0].text = combinedText;

package/dist/src/services/mcp-service.js

@@ -160,7 +160,7 @@ class McpService {
                 ? 'local-proxy'
                 : 'remote';
         return {
-            tools: (0, tool_schemas_1.getToolDefinitions)(this.getAvailableJobs(), { surface })
+            tools: (0, tool_schemas_1.getToolDefinitions)({ surface })
         };
     }
     handleListResources() {
@@ -794,9 +794,5 @@ class McpService {
                 throw new Error(`Unknown raw tool: ${tool}`);
         }
     }
-    getAvailableJobs() {
-        const jobs = Array.from(this.registryService.getFileIndex().values()).filter(f => f.type === 'job' && !f.isStub);
-        return Array.from(new Set(jobs.map(f => f.name.replace('.md', ''))));
-    }
 }
 exports.McpService = McpService;

package/dist/src/services/registry-service.js

@@ -9,7 +9,7 @@ const path_1 = require("path");
 const crypto_1 = __importDefault(require("crypto"));
 const stub_generator_1 = require("../core/utils/stub-generator");
 const job_parser_1 = require("../core/utils/job-parser");
-const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const pack_home_1 = require("../cli/utils/pack-home");
 class RegistryService {
     constructor() {
         this.fileIndex = new Map();
@@ -523,10 +523,6 @@ class RegistryService {
         return files.sort((a, b) => a.path.localeCompare(b.path));
     }
     getPersonalizedTopology() {
-        const personalizedRoot = (0, project_fraim_paths_1.getWorkspaceFraimPath)(process.cwd(), 'personalized-employee');
-        if (!(0, fs_1.existsSync)(personalizedRoot)) {
-            return { nodes: [], edges: [] };
-        }
         const nodes = [];
         const edges = [];
         const seenNodeIds = new Set();
@@ -537,8 +533,12 @@ class RegistryService {
             seenNodeIds.add(node.id);
             nodes.push(node);
         };
-        const skillsRoot = (0, path_1.join)(personalizedRoot, 'skills');
-        if ((0, fs_1.existsSync)(skillsRoot)) {
+        const skillRoots = (0, pack_home_1.personalizedCapabilityReadRoots)(process.cwd(), 'skills');
+        for (const root of skillRoots) {
+            const skillsRoot = root.capabilityRoot;
+            if (!(0, fs_1.existsSync)(skillsRoot)) {
+                continue;
+            }
             for (const relativePath of this.collectMarkdownRelativePaths(skillsRoot)) {
                 const normalizedRelativePath = normalize(relativePath);
                 const skillId = normalizedRelativePath.replace(/\.md$/, '');
@@ -551,13 +551,17 @@ class RegistryService {
                     category,
                     group: skillId.includes('/') ? skillId.slice(0, skillId.lastIndexOf('/')) : skillId,
                     role: null,
-                    path: (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)(`personalized-employee/skills/${normalizedRelativePath}`),
+                    path: `${root.displayPrefix.replace(/\/$/, '')}/skills/${normalizedRelativePath}`,
                     shadowing: (0, fs_1.existsSync)(baselinePath)
                 });
             }
         }
-        const jobsRoot = (0, path_1.join)(personalizedRoot, 'jobs');
-        if ((0, fs_1.existsSync)(jobsRoot)) {
+        const jobRoots = (0, pack_home_1.personalizedCapabilityReadRoots)(process.cwd(), 'jobs');
+        for (const root of jobRoots) {
+            const jobsRoot = root.capabilityRoot;
+            if (!(0, fs_1.existsSync)(jobsRoot)) {
+                continue;
+            }
             for (const relativePath of this.collectMarkdownRelativePaths(jobsRoot)) {
                 const normalizedRelativePath = normalize(relativePath);
                 const jobPathWithoutExt = normalizedRelativePath.replace(/\.md$/, '');
@@ -574,7 +578,7 @@ class RegistryService {
                     category,
                     group: parts.slice(0, -1).join('/') || category,
                     role: category === 'ai-manager' ? 'ai-manager' : 'ai-employee',
-                    path: (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)(`personalized-employee/jobs/${normalizedRelativePath}`),
+                    path: `${root.displayPrefix.replace(/\/$/, '')}/jobs/${normalizedRelativePath}`,
                     shadowing: (0, fs_1.existsSync)(baselinePath)
                 });
                 const includes = [...content.matchAll(/\{\{include:skills\/([^}]+)\.md\}\}/g)];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim",
-  "version": "2.0.276",
+  "version": "2.0.277",
   "description": "FRAIM core CLI and MCP package.",
   "main": "index.js",
   "bin": {