fraim 2.0.276 → 2.0.278

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/mcp/tool-schemas.js

@@ -0,0 +1,376 @@
+"use strict";
+/**
+ * MCP Tool Definitions
+ *
+ * This file contains the JSON schemas for all tools exposed by the FRAIM MCP Server.
+ * Centralizing these definitions improves readability and maintainability of the McpService.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToolDefinitions = void 0;
+const readOnlyClosedWorldAnnotations = {
+    readOnlyHint: true,
+    openWorldHint: false,
+    destructiveHint: false,
+};
+const writeClosedWorldAnnotations = {
+    readOnlyHint: false,
+    openWorldHint: false,
+    destructiveHint: false,
+};
+const readOnlyOpenWorldAnnotations = {
+    readOnlyHint: true,
+    openWorldHint: true,
+    destructiveHint: false,
+};
+const writeOpenWorldAnnotations = {
+    readOnlyHint: false,
+    openWorldHint: true,
+    destructiveHint: false,
+};
+const getToolDefinitions = (options = {}) => {
+    const surface = options.surface ?? 'local-proxy';
+    const isLocalProxySurface = surface === 'local-proxy';
+    const sessionIdProperty = isLocalProxySurface
+        ? {
+            sessionId: {
+                type: 'string',
+                description: 'Active FRAIM session ID. Required on local-proxy runtime calls.'
+            }
+        }
+        : {};
+    const requiredWithSession = (fields) => isLocalProxySurface
+        ? ['sessionId', ...fields]
+        : fields;
+    const fraimConnectDescription = isLocalProxySurface
+        ? `Bootstrap and initialize a FRAIM session and obtain the sessionId used by active FRAIM workflow tools. Use this after explicit FRAIM activation: the user invoked FRAIM, named a FRAIM job, asked for FRAIM job recommendations, or the active surface selected a FRAIM job. Must be called before any FRAIM workflow tool calls. For ordinary requests, do not start a FRAIM session or scan the catalog.
+
+Example:
+{
+  "agent": {"name": "Claude", "model": "claude-3.5-sonnet"}
+}`
+        : `Bootstrap and initialize a FRAIM session and obtain the sessionId used by active FRAIM workflow tools. Use this after explicit FRAIM activation: the user invoked FRAIM, named a FRAIM job, asked for FRAIM job recommendations, or the active surface selected a FRAIM job. Must be called before any FRAIM workflow tool calls. For ordinary requests, do not start a FRAIM session or scan the catalog.
+
+Hosted marketplace clients may call this with only agent information. If machine or repository context is omitted, FRAIM creates a hosted marketplace session context automatically.
+
+Example:
+{
+  "agent": {"name": "ChatGPT", "model": "gpt-5"}
+}`;
+    return [
+        {
+            name: 'fraim_connect',
+            description: fraimConnectDescription,
+            annotations: writeClosedWorldAnnotations,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    agent: {
+                        type: 'object',
+                        description: 'Agent identification',
+                        properties: {
+                            name: {
+                                type: 'string',
+                                description: 'Agent name (e.g., "Claude", "Cursor", "Kiro", "Windsurf", "Antigravity", "Grok")',
+                                examples: ['Claude', 'Cursor', 'Kiro', 'Windsurf', 'Antigravity', 'Grok']
+                            },
+                            model: {
+                                type: 'string',
+                                description: 'Model name/version (e.g., "claude-3.5-sonnet", "gpt-4", "cursor-small")',
+                                examples: ['claude-3.5-sonnet', 'gpt-4', 'cursor-small', 'kiro-agent']
+                            },
+                            version: {
+                                type: 'string',
+                                description: 'Agent version if available',
+                                examples: ['1.0.0', '2024.12.1']
+                            }
+                        },
+                        required: ['name', 'model'],
+                        additionalProperties: true
+                    },
+                    ...(isLocalProxySurface
+                        ? {}
+                        : {
+                            machine: {
+                                type: 'object',
+                                description: 'Optional machine specifications. Hosted marketplace sessions default this when omitted.',
+                                properties: {
+                                    hostname: {
+                                        type: 'string',
+                                        description: 'Machine hostname'
+                                    },
+                                    platform: {
+                                        type: 'string',
+                                        description: 'Platform (win32, darwin, linux)'
+                                    },
+                                    memory: {
+                                        type: 'number',
+                                        description: 'Total memory in bytes (auto-detected by local proxy)'
+                                    },
+                                    cpus: {
+                                        type: 'number',
+                                        description: 'CPU count (auto-detected by local proxy)'
+                                    }
+                                },
+                                required: ['hostname', 'platform', 'memory', 'cpus'],
+                                additionalProperties: true
+                            },
+                            repo: {
+                                type: 'object',
+                                description: 'Optional repository context. Hosted marketplace sessions default to FRAIM public catalog context when omitted.',
+                                properties: {
+                                    url: {
+                                        type: 'string',
+                                        description: 'Git repository URL'
+                                    },
+                                    owner: {
+                                        type: 'string',
+                                        description: 'Repository owner'
+                                    },
+                                    namespace: {
+                                        type: 'string',
+                                        description: 'Repository namespace (GitLab group/subgroup path)'
+                                    },
+                                    name: {
+                                        type: 'string',
+                                        description: 'Repository name'
+                                    },
+                                    projectPath: {
+                                        type: 'string',
+                                        description: 'Repository project path (GitLab, for example group/subgroup/repo)'
+                                    },
+                                    branch: {
+                                        type: 'string',
+                                        description: 'Current branch'
+                                    }
+                                },
+                                required: ['url'],
+                                additionalProperties: true
+                            }
+                        }),
+                    issueTracking: {
+                        type: 'object',
+                        description: 'Optional issue tracking context for split-provider setups (for example Jira + GitHub)',
+                        properties: {
+                            provider: {
+                                type: 'string',
+                                description: 'Issue tracking provider',
+                                enum: ['jira', 'github', 'ado', 'linear', 'gitlab']
+                            },
+                            owner: {
+                                type: 'string',
+                                description: 'Issue tracking owner (GitHub)'
+                            },
+                            name: {
+                                type: 'string',
+                                description: 'Issue tracking repository or project name'
+                            },
+                            organization: {
+                                type: 'string',
+                                description: 'Issue tracking organization (ADO)'
+                            },
+                            project: {
+                                type: 'string',
+                                description: 'Issue tracking project (ADO)'
+                            },
+                            namespace: {
+                                type: 'string',
+                                description: 'Issue tracking namespace (GitLab group/subgroup path)'
+                            },
+                            projectPath: {
+                                type: 'string',
+                                description: 'Issue tracking project path (GitLab, for example group/subgroup/repo)'
+                            },
+                            baseUrl: {
+                                type: 'string',
+                                description: 'Base URL for issue tracker (for example myorg.atlassian.net)'
+                            },
+                            projectKey: {
+                                type: 'string',
+                                description: 'Project key or namespace for issue IDs'
+                            }
+                        },
+                        required: ['provider'],
+                        additionalProperties: true
+                    }
+                },
+                required: ['agent']
+            }
+        },
+        {
+            name: 'get_fraim_file',
+            description: `Get a specific skill, rule, or reference file from the FRAIM registry by path.
+
+For running FRAIM jobs, use get_fraim_job instead — do NOT call get_fraim_file for job execution.
+
+Examples:
+- get_fraim_file({ path: "skills/communication/active-listening.md" })
+- get_fraim_file({ path: "rules/local-development.md" })`,
+            annotations: readOnlyClosedWorldAnnotations,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    ...sessionIdProperty,
+                    path: {
+                        type: 'string',
+                        description: 'Path to the file (e.g., skills/communication/active-listening.md, rules/local-development.md, templates/specs/FEATURESPEC-TEMPLATE.md)'
+                    },
+                    raw: {
+                        type: 'boolean',
+                        description: 'If true, returns the raw unparsed content without any MCP headers or parsing.'
+                    }
+                },
+                required: requiredWithSession(['path'])
+            }
+        },
+        {
+            name: 'get_fraim_job',
+            description: `Execute a named FRAIM job after explicit FRAIM activation. Call this tool whenever the user asks to run, start, or execute a named FRAIM job. Returns phased instructions — follow each phase and call seekMentoring to advance phases.
+
+Do NOT use get_fraim_file to load job content. Always use get_fraim_job for job execution.
+
+Examples:
+- get_fraim_job({ job: "feature-specification" })
+- get_fraim_job({ job: "technical-design" })
+- get_fraim_job({ job: "feature-implementation" })`,
+            annotations: readOnlyClosedWorldAnnotations,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    ...sessionIdProperty,
+                    job: {
+                        type: 'string',
+                        description: 'Job name (e.g., "feature-implementation", "technical-design", "feature-specification")'
+                    },
+                    raw: {
+                        type: 'boolean',
+                        description: 'If true, returns the raw unparsed markdown content of the job.'
+                    }
+                },
+                required: requiredWithSession(['job'])
+            }
+        },
+        {
+            name: 'list_fraim_jobs',
+            description: `List the FRAIM job catalog. Use this when the user asks what FRAIM jobs are available, asks for FRAIM job recommendations, or after explicit FRAIM activation when local stubs are unavailable. Do not use this for ordinary requests. If no exact or high-confidence job match exists, do not pick the nearest job; continue normally or ask one concise clarification.`,
+            annotations: readOnlyClosedWorldAnnotations,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    ...sessionIdProperty
+                },
+                required: requiredWithSession([])
+            }
+        },
+        {
+            name: 'file_fraim_github_issue',
+            description: `Create a GitHub issue in the FRAIM repository.
+      
+Use this tool when you need to report a bug, request a feature from FRAIM. Do not use this tool to file issues in other repositories.
+Supports dry-run mode to preview the operation.
+
+This tool accepts text only. If visual evidence is needed, upload images to a stable shared HTTPS URL first and include those URLs in the issue body as markdown images or plain links. Do not include local file paths or base64-encoded image data in the issue body.`,
+            annotations: writeOpenWorldAnnotations,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    ...sessionIdProperty,
+                    title: {
+                        type: 'string',
+                        description: 'Title of the issue'
+                    },
+                    body: {
+                        type: 'string',
+                        description: 'Body/Content of the issue. If visual evidence is needed, include shared HTTPS image URLs in the body; do not include local file paths or base64 image data.'
+                    },
+                    labels: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'List of labels to apply'
+                    },
+                    dryRun: {
+                        type: 'boolean',
+                        description: 'If true, simulates the creation without actually notifying GitHub'
+                    }
+                },
+                required: requiredWithSession(['title', 'body'])
+            }
+        },
+        {
+            name: 'list_my_fraim_github_issues',
+            description: `List issues the current FRAIM user filed into the FRAIM GitHub repository.
+
+This tool is the read-side companion to file_fraim_github_issue. Use it when you need a simple list of issues filed by the current FRAIM user into the FRAIM repository.
+
+Returns only:
+- issue number
+- title
+- status
+- created date
+
+Do not use this tool for other repositories or external project issue trackers.`,
+            annotations: readOnlyOpenWorldAnnotations,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    ...sessionIdProperty,
+                    limit: {
+                        type: 'integer',
+                        description: 'Optional maximum number of issues to return. Defaults to 20 and is capped at 100.'
+                    }
+                },
+                required: requiredWithSession([])
+            }
+        },
+        {
+            name: 'seekMentoring',
+            description: `Get the instructions for the current FRAIM phase, advance to the next phase, or ask for help on the active phase after fraim_connect starts the session.`,
+            annotations: writeClosedWorldAnnotations,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    ...sessionIdProperty,
+                    jobName: {
+                        type: 'string',
+                        description: 'Name of the job you are following',
+                    },
+                    jobId: {
+                        type: 'string',
+                        description: 'Job ID returned by get_fraim_job. Required for tracking job execution and completion.'
+                    },
+                    issueNumber: {
+                        type: 'string',
+                        description: 'Issue number or Task ID you are working on'
+                    },
+                    currentPhase: {
+                        type: 'string',
+                        description: 'The phase you are currently in or have just finished (e.g., "implement-scoping"). For initial workflow start, use "starting".'
+                    },
+                    status: {
+                        type: 'string',
+                        description: 'Status of your work in the current phase',
+                        enum: ['starting', 'complete', 'incomplete', 'failure']
+                    },
+                    findings: {
+                        type: 'object',
+                        description: 'Your findings, summaries, or results from the current phase (required for status="complete")',
+                        properties: {
+                            uncertainties: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Any unclear aspects that need clarification'
+                            }
+                        },
+                        additionalProperties: true
+                    },
+                    evidence: {
+                        type: 'object',
+                        description: 'Structured evidence or data collected (e.g., prospect counts, test results). Submit phases should put review artifacts in evidence.reviewHandoff rather than printing raw JSON to the user. Retrospective phases may put follow-on job recommendations in evidence.nextJobRecommendations (array of { jobId, label, reason?, contextSummary? }, max 3) so the work surface can offer them as next steps.',
+                        additionalProperties: true
+                    }
+                },
+                required: requiredWithSession(['jobName', 'jobId', 'issueNumber', 'currentPhase', 'status'])
+            }
+        }
+    ];
+};
+exports.getToolDefinitions = getToolDefinitions;

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.278",
   "description": "FRAIM core CLI and MCP package.",
   "main": "index.js",
   "bin": {
@@ -19,8 +19,9 @@
     "dist/src/services/",
     "dist/src/api/",
     "dist/src/middleware/",
-    "dist/src/models/",
-    "dist/src/types/",
+    "dist/src/models/",
+    "dist/src/mcp/",
+    "dist/src/types/",
     "dist/src/utils/",
     "bin/fraim.js",
     "public/first-run/",