fraim 2.0.208 → 2.0.210

package/dist/src/cli/setup/ide-invocation-surfaces.js

@@ -56,17 +56,20 @@ function buildDeferredToolBootstrapSection(profile) {
 function buildFraimInvocationBody(profile = 'none') {
     return `Follow this process:
 
-${buildDeferredToolBootstrapSection(profile)}1. **If the user did not specify a FRAIM job or topic**:
+${buildDeferredToolBootstrapSection(profile)}1. **Confirm FRAIM activation**:
+   Use this process only when the user explicitly invokes FRAIM, names a FRAIM job, asks what FRAIM job to run, or the active surface has already selected a FRAIM job. For ordinary requests, answer or work normally; do not scan FRAIM stubs first.
+
+2. **If the user did not specify a FRAIM job or topic after activation**:
    If local FRAIM job stubs are present in the workspace, inspect those first and match the request locally. Also inspect \`fraim/personalized-employee/jobs/\` for local overrides or repo-specific jobs. If local files are missing or you cannot inspect workspace files, call \`list_fraim_jobs()\` to view the full catalog, including any proxy-discoverable personalized jobs.
 
-2. **Find the match**:
-   Match the user's request to a FRAIM job from the local stub catalog, \`fraim/personalized-employee/jobs/\`, or the full \`list_fraim_jobs()\` response. If no job matches, try a likely FRAIM skill with \`get_fraim_file({ path: "skills/<likely-category>/<argument>.md" })\` and confirm the match with the user.
+3. **Find the match**:
+   If the user names an exact FRAIM job, call \`get_fraim_job({ job: "<job-name>" })\` directly. Otherwise, match the user's request to a FRAIM job from the local stub catalog, \`fraim/personalized-employee/jobs/\`, or the full \`list_fraim_jobs()\` response. If no exact or high-confidence job match exists, say that no FRAIM job matches and continue with normal tools or ask one concise clarification. Do not pick the nearest catalog job.
 
-3. **Load the full content**:
+4. **Load the full content**:
    - For jobs, call \`get_fraim_job({ job: "<matched-job-name>" })\`.
    - For skills, use the content returned by \`get_fraim_file(...)\`.
 
-4. **Execute**:
+5. **Execute**:
    - For jobs, follow the phased instructions and use \`seekMentoring\` when the job requires phase transitions.
    - For skills, apply the skill steps directly to the user's current context.
 `;
@@ -96,18 +99,18 @@ ${buildFraimInvocationBody('generic-tool-discovery')}
 `;
 }
 function buildCodexSkillContent() {
-    return `# FRAIM
-
+    return `# FRAIM
+
 ${buildFraimInvocationBody('codex-tool-search')}`;
 }
 function buildGrokSkillContent() {
-    return `# FRAIM
-
+    return `# FRAIM
+
 ${buildFraimInvocationBody('generic-tool-discovery')}`;
 }
 function buildWindsurfCommandContent() {
-    return `# FRAIM
-
+    return `# FRAIM
+
 ${buildFraimInvocationBody('generic-tool-discovery')}`;
 }
 function buildKiroCommandContent() {

package/dist/src/cli/utils/agent-adapters.js

@@ -69,8 +69,12 @@ This repository uses FRAIM.
 - Skills under \`${employeeSkillsPath}/\` are reusable capabilities that jobs compose.
 - Rules under \`${employeeRulesPath}/\` are always-on constraints and conventions.
 - Repo-specific overrides and learning artifacts live under \`${personalizedRootPath}/\` and take precedence over synced baseline content.
-- Before acting on any user request, scan the job stubs under \`${employeeJobsPath}/\` and \`${managerJobsPath}/\` to identify the most appropriate job. Read stub filenames and their Intent/Outcome sections to match the request to the right job.
+- Use FRAIM when the user explicitly invokes FRAIM, names a FRAIM job, asks what FRAIM job to run, or the active surface has already selected a FRAIM job.
+- For ordinary requests, answer or work normally. Do not scan FRAIM stubs first.
+- If the user names an exact FRAIM job, call \`get_fraim_job({ job: "<job-name>" })\` directly.
+- When FRAIM routing is active but the job is not exact, scan the job stubs under \`${employeeJobsPath}/\` and \`${managerJobsPath}/\` to identify the most appropriate job. Read stub filenames and their Intent/Outcome sections before using catalog tools.
 - Once you identify the relevant job, call \`get_fraim_job({ job: "<job-name>" })\` to get the full phased instructions.
+- If no exact or high-confidence job match exists, say that no FRAIM job matches and continue with normal tools or ask one concise clarification.
 - For deeper capability detail, call \`get_fraim_file({ path: "skills/<category>/<skill-name>.md" })\` or \`get_fraim_file({ path: "rules/<category>/<rule-name>.md" })\`.
 - Read \`${projectRulesPath}\` if it exists before doing work.
 - When users ask for next step recommendations, use recommend-next-job skill under \`${employeeSkillsPath}/\` to gather context before suggesting jobs.
@@ -91,7 +95,11 @@ ${(0, ide_invocation_surfaces_1.buildFraimInvocationBody)('generic-tool-discover
 - FRAIM skills are reusable capabilities jobs compose.
 - FRAIM rules are always-on constraints and conventions.
 - Repo-specific overrides and learnings live under \`${personalizedRootPath}/\`.
-- Use the stubs to identify which job to invoke before fetching full content with FRAIM MCP tools.
+- Use FRAIM when the user explicitly invokes FRAIM, names a FRAIM job, asks what FRAIM job to run, or the active surface has already selected a FRAIM job.
+- For ordinary requests, answer or work normally. Do not scan FRAIM stubs first.
+- If the user names an exact FRAIM job, fetch that full job directly with FRAIM MCP tools.
+- When FRAIM routing is active but the job is not exact, use local stubs to identify which job to invoke before fetching full content with FRAIM MCP tools.
+- If no exact or high-confidence job match exists, say that no FRAIM job matches and continue with normal tools or ask one concise clarification.
 - **Job stubs are for discovery only.** Never execute a job from stub content - always call \`get_fraim_job({ job: "<job-name>" })\` first.
 `);
     const fraimReadme = `# FRAIM Catalog
@@ -104,7 +112,7 @@ This directory is the repository-visible FRAIM surface.
 - \`ai-employee/rules/\`: rule stubs
 - \`personalized-employee/\`: repo-specific overrides and learnings
 
-Use the stubs here to discover which FRAIM job, skill, or rule is relevant, then load the full content through FRAIM MCP tools.
+When FRAIM routing is active and no exact FRAIM job is named, use the stubs here to discover which FRAIM job, skill, or rule is relevant, then load the full content through FRAIM MCP tools. If an exact FRAIM job is named, load it directly. For ordinary requests, do not scan this catalog first.
 `;
     const vscodePrompt = `# FRAIM
 

package/dist/src/config/learning-domains.js

@@ -0,0 +1,221 @@
+"use strict";
+/**
+ * Learning domains (issue #806).
+ *
+ * A learning's DOMAIN is the fourth axis of the learning system, alongside:
+ *   - tier   (L0 raw / L1 personal / L2 org),
+ *   - category (mistake-patterns / preferences / validated-patterns / manager-coaching),
+ *   - scope  (machine-global `~/.fraim` vs repo-local `fraim/`).
+ *
+ * A learning is either `global` (applies to every job) or scoped to exactly one
+ * coarse job-domain. At `get_fraim_job`, the loader injects global learnings plus
+ * the current job's-domain learnings only, so a marketing job no longer loads
+ * engineering learnings.
+ *
+ * This module is the single source of truth for the domain list, the
+ * registry-category -> domain map, the per-domain authoring voice (R3), and the
+ * resolver used at the injection sites. It is pure (no I/O) and mirrors the
+ * config-module convention of `src/config/portfolio-slug-overrides.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOMAIN_VOICE = exports.GLOBAL_JOB_CATEGORIES = exports.JOB_DOMAIN_MAP = exports.LEARNING_DOMAINS = void 0;
+exports.isLearningDomain = isLearningDomain;
+exports.jobCategoryFromRegistryPath = jobCategoryFromRegistryPath;
+exports.resolveJobDomain = resolveJobDomain;
+exports.domainFromJobFrontmatter = domainFromJobFrontmatter;
+exports.resolveDomainForJob = resolveDomainForJob;
+/** The coarse learning domains. `global` is represented by the absence of a domain. */
+exports.LEARNING_DOMAINS = [
+    'engineering',
+    'product',
+    'go-to-market',
+    'people-ops',
+    'finance',
+    'legal',
+    'compliance',
+    'customer',
+    'company-building',
+    'operations',
+];
+function isLearningDomain(value) {
+    return typeof value === 'string' && exports.LEARNING_DOMAINS.includes(value);
+}
+/**
+ * Registry job category -> learning domain. Seeded from the registry taxonomy and
+ * the `PERSONA_CAPABILITY_BUNDLES` groupings. Every domain-scoped category maps
+ * here; cross-cutting categories are listed in `GLOBAL_JOB_CATEGORIES` instead.
+ *
+ * A build-time test (`tests/test-unit-learning-domains.ts`) asserts that every
+ * registry job category (from `registry/jobs/**`) is covered by exactly one of
+ * this map or `GLOBAL_JOB_CATEGORIES`, so the taxonomy cannot silently drift as
+ * new job categories are added.
+ */
+exports.JOB_DOMAIN_MAP = {
+    // engineering
+    'product-building': 'engineering',
+    'dev-ops': 'engineering',
+    'quality-assurance': 'engineering',
+    'migration': 'engineering',
+    'replicate': 'engineering',
+    'reviewer': 'engineering',
+    'security': 'engineering',
+    'delivery-ops': 'engineering',
+    'salesforce': 'engineering',
+    // product
+    'product-management': 'product',
+    'customer-development': 'product',
+    'brainstorming': 'product',
+    // go-to-market
+    'marketing': 'go-to-market',
+    'branding': 'go-to-market',
+    'sales': 'go-to-market',
+    'go-to-market': 'go-to-market',
+    'business-development': 'go-to-market',
+    'commercial-ops': 'go-to-market',
+    // people-ops
+    'people-ops': 'people-ops',
+    'inclusion-ops': 'people-ops',
+    'career': 'people-ops',
+    // finance
+    'finance': 'finance',
+    'invoicing': 'finance',
+    'banking': 'finance',
+    // legal
+    'legal': 'legal',
+    // compliance
+    'compliance': 'compliance',
+    // customer
+    'customer-success': 'customer',
+    'customer-communication': 'customer',
+    // company-building
+    'company-creation': 'company-building',
+    'bootstrap': 'company-building',
+    'fundraising': 'company-building',
+    // operations
+    'business-ops': 'operations',
+    'procurement': 'operations',
+    'project-management': 'operations',
+};
+/**
+ * Cross-cutting job categories that intentionally resolve to `global` (no domain).
+ * Management and framework-meta learnings apply regardless of the work domain, so
+ * they are never hidden from any job. Listed explicitly so the completeness test
+ * can tell an intentional global category apart from a forgotten mapping.
+ */
+exports.GLOBAL_JOB_CATEGORIES = new Set([
+    // ai-employee cross-cutting
+    'manager',
+    'fraim',
+    // ai-manager (all management categories)
+    '1-1',
+    'coaching',
+    'delegation',
+    'hiring',
+    'productivity',
+    'project-setup',
+    'setup-guardrails',
+    'team-learning',
+    'verification',
+]);
+/**
+ * One-line authoring voice per domain (R3). Consumed as documentation and by the
+ * synthesis jobs/skills (`sleep-on-learnings`, `organizational-learning-synthesis`,
+ * `l1-signal-classification`) so a domain-specific learning is written in that
+ * domain's language and stays human-auditable.
+ */
+exports.DOMAIN_VOICE = {
+    'engineering': 'Precise and technical; file paths, commands, and test names are appropriate.',
+    'product': 'Product and user-outcome language; behavior and flow, not code symbols.',
+    'go-to-market': 'Marketing and sales language; campaigns, funnels, messaging, audience.',
+    'people-ops': 'Plain HR and recruiting language; no engineering jargon.',
+    'finance': 'Finance and accounting language; figures, close, forecasts.',
+    'legal': 'Contract and IP language; obligations, clauses, risk.',
+    'compliance': 'Controls, evidence, and regulation language.',
+    'customer': 'Customer-relationship and support language.',
+    'company-building': 'Founder and operations language; setup, entity, funding.',
+    'operations': 'Business-operations language; process, vendors, planning, coordination.',
+};
+/**
+ * Extract the registry job category from a job's registry path.
+ *
+ * Handles both `jobs/ai-employee/<category>/<name>.md` (and `ai-manager`,
+ * `personalized-employee`) and the flatter `jobs/<category>/<name>.md`, with or
+ * without a leading `registry/` prefix and with either slash style. Returns null
+ * when the input is not a job path (for example a bare job name with no directory).
+ *
+ * Mirrors the jobs branch of `UsageCollector.parseComponentName` so both derive
+ * the category the same way.
+ */
+function jobCategoryFromRegistryPath(registryPath) {
+    if (!registryPath || typeof registryPath !== 'string')
+        return null;
+    let clean = registryPath.replace(/\\/g, '/').replace(/^registry\//, '');
+    if (clean.startsWith('/'))
+        clean = clean.slice(1);
+    const parts = clean.split('/');
+    if (parts[0] !== 'jobs')
+        return null;
+    if (parts[1] === 'ai-employee' || parts[1] === 'ai-manager' || parts[1] === 'personalized-employee') {
+        return parts.length > 3 ? parts[2] : null; // jobs/ai-employee/<category>/<name>.md
+    }
+    return parts.length > 2 ? parts[1] : null; // jobs/<category>/<name>.md
+}
+/**
+ * Resolve the learning domain for a job from its registry path.
+ *
+ * Returns a `LearningDomain` for domain-scoped categories, or `null` for
+ * cross-cutting categories, unmapped categories, and unparseable inputs. `null`
+ * means "load global learnings only" at the injection site: global is never
+ * hidden and an unknown category never guesses a wrong domain. The completeness
+ * test is what distinguishes an intentional global from a missing mapping.
+ */
+function resolveJobDomain(registryPath) {
+    const category = jobCategoryFromRegistryPath(registryPath);
+    if (!category)
+        return null;
+    return exports.JOB_DOMAIN_MAP[category] ?? null;
+}
+/**
+ * Read an explicit learning domain a job declares in its own frontmatter, if any.
+ *
+ * This is the extensibility hook (issue #806 review): a job can self-declare
+ * `domain` so a newly-taught job with a new category is handled without editing
+ * `JOB_DOMAIN_MAP`. Supports the JSON frontmatter block FRAIM jobs use
+ * (`---\n{ ..., "domain": "people-ops" }\n---`) and a plain `domain: <value>`
+ * line. Returns null when there is no frontmatter, no `domain`, or an unknown
+ * domain - callers then fall back to the category map.
+ */
+function domainFromJobFrontmatter(jobFileContent) {
+    if (!jobFileContent || typeof jobFileContent !== 'string')
+        return null;
+    const fm = jobFileContent.match(/^?---\r?\n([\s\S]*?)\r?\n---/);
+    if (!fm)
+        return null;
+    const block = fm[1];
+    const trimmed = block.trim();
+    if (trimmed.startsWith('{')) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            return isLearningDomain(parsed?.domain) ? parsed.domain : null;
+        }
+        catch {
+            // fall through to line parsing
+        }
+    }
+    const line = block.match(/^\s*domain:\s*["']?([a-z][a-z-]*)["']?\s*$/m);
+    return line && isLearningDomain(line[1]) ? line[1] : null;
+}
+/**
+ * Resolve the learning domain for a job from its registry path and (optional)
+ * file content. A domain the job self-declares in frontmatter overrides the
+ * category map; otherwise the map applies; a null/unparseable path yields null
+ * (load global only). Pure and side-effect-free: callers do the I/O (reading the
+ * registry path and job file) and pass the results here, which keeps this
+ * decision logic directly testable with mocked inputs.
+ */
+function resolveDomainForJob(registryPath, jobFileContent) {
+    if (!registryPath)
+        return null;
+    const declared = jobFileContent ? domainFromJobFrontmatter(jobFileContent) : null;
+    return declared ?? resolveJobDomain(registryPath);
+}

package/dist/src/local-mcp-server/learning-context-builder.js

@@ -24,6 +24,7 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
 const brand_store_1 = require("../core/brand-store");
+const learning_domains_1 = require("../config/learning-domains");
 const REPO_LEARNINGS_REL = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('personalized-employee/learnings').replace(/\/$/, '');
 const DEFAULT_THRESHOLD = 3.0;
 const AGING_HORIZON_DAYS = 7;
@@ -374,32 +375,58 @@ function resolveOrgLearningFile(repoLearningsBase, fileName) {
     }
     return { present: false, path: repoPath, displayPath: `${REPO_LEARNINGS_REL}/${fileName}` };
 }
-function buildLearningContextSection(workspaceRoot, userId, forJob) {
+function buildLearningContextSection(workspaceRoot, userId, forJob, domain) {
     const roots = getLearningRoots(workspaceRoot);
     const resolvedUserId = resolveLearningUserId(workspaceRoot, userId, roots);
     const threshold = getScoreThreshold(workspaceRoot);
-    // L2 org learnings resolve repo-local first, then the synced org cache (#563).
-    const l2Mistake = resolveOrgLearningFile(roots.repoLearningsBase, 'org-mistake-patterns.md');
-    const l2Pref = resolveOrgLearningFile(roots.repoLearningsBase, 'org-preferences.md');
-    const l2Coach = resolveOrgLearningFile(roots.repoLearningsBase, 'org-manager-coaching.md');
-    const l2Validated = resolveOrgLearningFile(roots.repoLearningsBase, 'org-validated-patterns.md');
-    const l2MistakePresent = l2Mistake.present;
-    const l2PrefPresent = l2Pref.present;
-    const l2CoachPresent = l2Coach.present;
-    const l2ValidatedPresent = l2Validated.present;
-    const l2MistakeStats = l2MistakePresent ? scanMistakePatternFile(l2Mistake.path, threshold, 'mistake-patterns') : null;
-    const l2ValidatedStats = l2ValidatedPresent ? scanMistakePatternFile(l2Validated.path, threshold, 'validated-patterns') : null;
-    const l1Mistake = resolvePersonalLearningFile(roots.repoLearningsBase, roots.managerCacheBase, roots.managerCacheDisplayBase, roots.globalPersonalBase, roots.globalPersonalDisplayBase, `${resolvedUserId}-mistake-patterns.md`);
-    const l1Pref = resolvePersonalLearningFile(roots.repoLearningsBase, roots.managerCacheBase, roots.managerCacheDisplayBase, roots.globalPersonalBase, roots.globalPersonalDisplayBase, `${resolvedUserId}-preferences.md`);
-    const l1Coach = resolvePersonalLearningFile(roots.repoLearningsBase, roots.managerCacheBase, roots.managerCacheDisplayBase, roots.globalPersonalBase, roots.globalPersonalDisplayBase, `${resolvedUserId}-manager-coaching.md`);
-    const l1Validated = resolvePersonalLearningFile(roots.repoLearningsBase, roots.managerCacheBase, roots.managerCacheDisplayBase, roots.globalPersonalBase, roots.globalPersonalDisplayBase, `${resolvedUserId}-validated-patterns.md`);
-    const l1MistakeStats = l1Mistake.present ? scanMistakePatternFile(l1Mistake.path, threshold, 'mistake-patterns') : null;
-    const l1ValidatedStats = l1Validated.present ? scanMistakePatternFile(l1Validated.path, threshold, 'validated-patterns') : null;
+    const CAT = {
+        mistake: { ft: 'mistake-patterns', gated: true, label: '(entries above score threshold)' },
+        pref: { ft: 'preferences', gated: false, label: '(all entries)' },
+        coach: { ft: 'manager-coaching', gated: false, label: '(manager-facing; all entries)' },
+        validated: { ft: 'validated-patterns', gated: true, label: '(entries above score threshold)' },
+    };
+    // Domain axis (issue #806, Option 1): `fraim_connect` (forJob=false) loads only
+    // the interaction-preference files + the L0 nudge, since it runs with no job.
+    // A job (forJob=true) loads every category globally, plus the current job's
+    // domain files. Category order within a tier is preserved from prior behavior;
+    // domain files are appended after the global files.
+    const l2Cats = forJob ? ['mistake', 'pref', 'coach', 'validated'] : ['pref'];
+    const l1Cats = forJob ? ['pref', 'coach', 'mistake', 'validated'] : ['pref'];
+    const activeDomain = forJob && domain ? domain : null;
+    const dormantOf = (meta, filePath) => meta.gated ? scanMistakePatternFile(filePath, threshold, meta.ft).dormant : 0;
+    // Resolve one tier (L2 org or L1 personal) into ordered global + domain files.
+    const resolveTier = (cats, resolveFile) => {
+        const global = [];
+        const domainFiles = [];
+        let coachPresent = false;
+        for (const key of cats) {
+            const meta = CAT[key];
+            const g = resolveFile(meta.ft);
+            if (g.present) {
+                global.push({ displayPath: g.displayPath, label: meta.label, dormant: dormantOf(meta, g.path), isCoach: key === 'coach' });
+                if (key === 'coach')
+                    coachPresent = true;
+            }
+            if (activeDomain) {
+                const d = resolveFile(meta.ft, activeDomain);
+                if (d.present) {
+                    domainFiles.push({ displayPath: d.displayPath, label: meta.label, dormant: dormantOf(meta, d.path), isCoach: key === 'coach' });
+                    if (key === 'coach')
+                        coachPresent = true;
+                }
+            }
+        }
+        return { global, domain: domainFiles, coachPresent };
+    };
+    const l2 = resolveTier(l2Cats, (ft, dom) => resolveOrgLearningFile(roots.repoLearningsBase, dom ? `org-${dom}-${ft}.md` : `org-${ft}.md`));
+    const l1 = resolveTier(l1Cats, (ft, dom) => resolvePersonalLearningFile(roots.repoLearningsBase, roots.managerCacheBase, roots.managerCacheDisplayBase, roots.globalPersonalBase, roots.globalPersonalDisplayBase, dom ? `${resolvedUserId}-${dom}-${ft}.md` : `${resolvedUserId}-${ft}.md`));
+    const l2Files = [...l2.global, ...l2.domain];
+    const l1Files = [...l1.global, ...l1.domain];
     const pendingL0Sources = collectPendingL0SourceFiles(workspaceRoot, resolvedUserId, roots);
     const l0CoachingCount = pendingL0Sources.filter(source => source.kind === 'coaching-moment').length;
     const l0RetroCount = pendingL0Sources.filter(source => source.kind === 'retrospective').length;
-    const hasL2 = l2MistakePresent || l2PrefPresent || l2CoachPresent || l2ValidatedPresent;
-    const hasL1 = l1Mistake.present || l1Pref.present || l1Coach.present || l1Validated.present;
+    const hasL2 = l2Files.length > 0;
+    const hasL1 = l1Files.length > 0;
     const hasContent = hasL2 || hasL1 || l0CoachingCount > 0 || l0RetroCount > 0;
     if (!hasContent)
         return '';
@@ -408,15 +435,9 @@ function buildLearningContextSection(workspaceRoot, userId, forJob) {
         : '\n\n## Learning Context\n\n';
     if (hasL2) {
         section += '### L2 - Org patterns\n';
-        if (l2MistakePresent)
-            section += `\`${l2Mistake.displayPath}\`  (entries above score threshold)\n`;
-        if (l2PrefPresent)
-            section += `\`${l2Pref.displayPath}\`  (all entries)\n`;
-        if (l2CoachPresent)
-            section += `\`${l2Coach.displayPath}\`  (manager-facing; all entries)\n`;
-        if (l2ValidatedPresent)
-            section += `\`${l2Validated.displayPath}\`  (entries above score threshold)\n`;
-        const l2DormantTotal = (l2MistakeStats?.dormant || 0) + (l2ValidatedStats?.dormant || 0);
+        for (const f of l2Files)
+            section += `\`${f.displayPath}\`  ${f.label}\n`;
+        const l2DormantTotal = l2Files.reduce((sum, f) => sum + f.dormant, 0);
         if (l2DormantTotal > 0) {
             section += `Dormant: ${l2DormantTotal} org pattern${l2DormantTotal !== 1 ? 's' : ''} below threshold\n`;
         }
@@ -424,15 +445,9 @@ function buildLearningContextSection(workspaceRoot, userId, forJob) {
     }
     if (hasL1) {
         section += '### L1 - Your patterns\n';
-        if (l1Pref.present)
-            section += `\`${l1Pref.displayPath}\`  (all entries)\n`;
-        if (l1Coach.present)
-            section += `\`${l1Coach.displayPath}\`  (manager-facing; all entries)\n`;
-        if (l1Mistake.present)
-            section += `\`${l1Mistake.displayPath}\`  (entries above score threshold)\n`;
-        if (l1Validated.present)
-            section += `\`${l1Validated.displayPath}\`  (entries above score threshold)\n`;
-        const l1DormantTotal = (l1MistakeStats?.dormant || 0) + (l1ValidatedStats?.dormant || 0);
+        for (const f of l1Files)
+            section += `\`${f.displayPath}\`  ${f.label}\n`;
+        const l1DormantTotal = l1Files.reduce((sum, f) => sum + f.dormant, 0);
         if (l1DormantTotal > 0) {
             section += `Dormant: ${l1DormantTotal} personal pattern${l1DormantTotal !== 1 ? 's' : ''} below threshold\n`;
         }
@@ -457,17 +472,18 @@ function buildLearningContextSection(workspaceRoot, userId, forJob) {
         }
         section += '\n';
     }
+    const coachPresent = l1.coachPresent || l2.coachPresent;
     if (forJob) {
         if (hasL2 || hasL1) {
             section += 'Use the relevant patterns and preferences in this job.\n';
-            if (l1Coach.present || l2CoachPresent) {
+            if (coachPresent) {
                 section += 'Treat manager-coaching as feedback for how the manager should continue or improve managing AI, not as agent instruction.\n';
             }
         }
     }
     else {
         section += 'Use this synthesized learning context throughout the session.\n';
-        if (l1Coach.present || l2CoachPresent) {
+        if (coachPresent) {
             section += 'Manager-coaching entries are manager-facing feedback, not instructions for the AI to follow.\n';
         }
     }
@@ -784,6 +800,23 @@ function countPreservedLearnings(workspaceRoot, userId) {
     const project = countLearningEntries(resolve(`${resolvedUserId}-mistake-patterns.md`).path) +
         countLearningEntries(resolve(`${resolvedUserId}-preferences.md`).path) +
         countLearningEntries(resolve(`${resolvedUserId}-validated-patterns.md`).path);
+    // #806: fold domain-scoped files into the same per-scope counts so the Brain
+    // summary reconciles with what the loader injects for a job.
+    let organizationDomain = 0;
+    let managerDomain = 0;
+    let projectDomain = 0;
+    for (const domain of learning_domains_1.LEARNING_DOMAINS) {
+        organizationDomain +=
+            countLearningEntries(resolveOrgLearningFile(roots.repoLearningsBase, `org-${domain}-mistake-patterns.md`).path) +
+                countLearningEntries(resolveOrgLearningFile(roots.repoLearningsBase, `org-${domain}-preferences.md`).path) +
+                countLearningEntries(resolveOrgLearningFile(roots.repoLearningsBase, `org-${domain}-manager-coaching.md`).path) +
+                countLearningEntries(resolveOrgLearningFile(roots.repoLearningsBase, `org-${domain}-validated-patterns.md`).path);
+        managerDomain += countLearningEntries(resolve(`${resolvedUserId}-${domain}-manager-coaching.md`).path);
+        projectDomain +=
+            countLearningEntries(resolve(`${resolvedUserId}-${domain}-mistake-patterns.md`).path) +
+                countLearningEntries(resolve(`${resolvedUserId}-${domain}-preferences.md`).path) +
+                countLearningEntries(resolve(`${resolvedUserId}-${domain}-validated-patterns.md`).path);
+    }
     // L0 raw signals still awaiting synthesis (not dismissed).
     let rawSignals = 0;
     const rawDir = (0, path_1.join)(roots.repoLearningsBase, 'raw');
@@ -802,7 +835,12 @@ function countPreservedLearnings(workspaceRoot, userId) {
             // ignore unreadable raw dir
         }
     }
-    return { organization, manager, project, rawSignals };
+    return {
+        organization: organization + organizationDomain,
+        manager: manager + managerDomain,
+        project: project + projectDomain,
+        rawSignals,
+    };
 }
 exports.CATEGORY_TO_FILETYPE = {
     avoid: 'mistake-patterns',
@@ -816,10 +854,26 @@ const FILETYPE_TO_CATEGORY = {
     'validated-patterns': 'repeat',
     'manager-coaching': 'coaching',
 };
+/**
+ * Enumerate domain-scoped learning files (`<prefix>-<domain>-<filetype>.md`, issue
+ * #806) present in a directory, in a deterministic domain order. Used by the Hub
+ * read/count paths so domain learnings appear alongside the flat global files.
+ */
+function listDomainLearningFiles(dir, prefix, fileType) {
+    if (!(0, fs_1.existsSync)(dir))
+        return [];
+    const out = [];
+    for (const domain of learning_domains_1.LEARNING_DOMAINS) {
+        const fileName = `${prefix}-${domain}-${fileType}.md`;
+        if ((0, fs_1.existsSync)((0, path_1.join)(dir, fileName)))
+            out.push({ fileName, domain });
+    }
+    return out;
+}
 // Parse the `## [P-…] Title` entries (and their body prose) out of one learning
 // file. Score/Last seen/Recurrences metadata lines are dropped — the Hub shows
 // the human-readable learning, not the bookkeeping.
-function parseLearningEntries(filePath, displayPath, category, level) {
+function parseLearningEntries(filePath, displayPath, category, level, domain = 'global') {
     if (!(0, fs_1.existsSync)(filePath))
         return [];
     let content;
@@ -845,7 +899,7 @@ function parseLearningEntries(filePath, displayPath, category, level) {
         const header = line.match(headingRe);
         if (header) {
             flush();
-            current = { severity: header[1], title: header[2].trim(), body: '', source: displayPath, category, level };
+            current = { severity: header[1], title: header[2].trim(), body: '', source: displayPath, category, level, domain };
             continue;
         }
         if (!current)
@@ -877,8 +931,13 @@ function readPreservedLearnings(workspaceRoot, userId, scope, level = 'machine')
     const out = [];
     if (scope === 'org') {
         for (const cat of ['avoid', 'preference', 'repeat', 'coaching']) {
-            const f = `org-${exports.CATEGORY_TO_FILETYPE[cat]}.md`;
+            const fileType = exports.CATEGORY_TO_FILETYPE[cat];
+            const f = `org-${fileType}.md`;
             out.push(...parseLearningEntries((0, path_1.join)(roots.repoLearningsBase, f), `${REPO_LEARNINGS_REL}/${f}`, cat, 'org'));
+            // #806: domain-scoped org learnings alongside the flat global file.
+            for (const { fileName, domain } of listDomainLearningFiles(roots.repoLearningsBase, 'org', fileType)) {
+                out.push(...parseLearningEntries((0, path_1.join)(roots.repoLearningsBase, fileName), `${REPO_LEARNINGS_REL}/${fileName}`, cat, 'org', domain));
+            }
         }
         return out;
     }
@@ -886,8 +945,13 @@ function readPreservedLearnings(workspaceRoot, userId, scope, level = 'machine')
     const { dir, displayBase } = levelDir(roots, level);
     const cats = scope === 'reverse' ? ['coaching'] : ['avoid', 'preference', 'repeat'];
     for (const cat of cats) {
-        const f = `${resolvedUserId}-${exports.CATEGORY_TO_FILETYPE[cat]}.md`;
+        const fileType = exports.CATEGORY_TO_FILETYPE[cat];
+        const f = `${resolvedUserId}-${fileType}.md`;
         out.push(...parseLearningEntries((0, path_1.join)(dir, f), `${displayBase}/${f}`, cat, level));
+        // #806: domain-scoped personal learnings alongside the flat global file.
+        for (const { fileName, domain } of listDomainLearningFiles(dir, resolvedUserId, fileType)) {
+            out.push(...parseLearningEntries((0, path_1.join)(dir, fileName), `${displayBase}/${fileName}`, cat, level, domain));
+        }
     }
     return out;
 }

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

@@ -68,6 +68,7 @@ const usage_collector_js_1 = require("./usage-collector.js");
 const otlp_metrics_receiver_js_1 = require("./otlp-metrics-receiver.js");
 const token_adapter_registry_js_1 = require("./token-adapter-registry.js");
 const learning_context_builder_js_1 = require("./learning-context-builder.js");
+const learning_domains_js_1 = require("../config/learning-domains.js");
 /**
  * Handle template substitution logic separately for better testability
  */
@@ -1371,16 +1372,42 @@ class FraimLocalMCPServer {
             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);
+                const jobDomain = await this.resolveJobDomainForJob(args.job, requestSessionId);
+                const learningSection = (0, learning_context_builder_js_1.buildLearningContextSection)(workspaceRoot, userEmail, true, jobDomain);
                 const teamContextSection = (0, learning_context_builder_js_1.buildTeamContextSection)(workspaceRoot, true);
                 if (learningSection || teamContextSection) {
                     finalizedResponse.result.content[0].text = text + `\n\n---` + learningSection + teamContextSection;
-                    this.log(`[req:${requestId}] Injected job-focus learning/team context for ${userEmail}`);
+                    this.log(`[req:${requestId}] Injected job-focus learning/team context for ${userEmail} (domain: ${jobDomain ?? 'global'})`);
                 }
             }
         }
         return this.processResponseWithHydration(finalizedResponse, requestSessionId);
     }
+    /**
+     * Resolve the learning domain for a `get_fraim_job` request (issue #806) from
+     * the job's registry path, so the loader injects global + that domain's
+     * learnings only. Returns null (global-only) on any failure: the learning
+     * context must never break a job response, and an unknown job never guesses a
+     * wrong domain.
+     */
+    async resolveJobDomainForJob(jobName, requestSessionId) {
+        try {
+            const resolver = this.getRegistryResolver(requestSessionId);
+            if (!resolver)
+                return null;
+            const registryPath = await resolver.findRegistryPath('jobs', jobName);
+            if (!registryPath)
+                return null;
+            // Read the job file so a domain it self-declares in frontmatter can override
+            // the category map (extensible for newly-taught jobs); the pure resolver
+            // owns the decision logic.
+            const resolved = await resolver.resolveFile(registryPath).catch(() => null);
+            return (0, learning_domains_js_1.resolveDomainForJob)(registryPath, resolved?.content ?? null);
+        }
+        catch {
+            return null;
+        }
+    }
     async finalizeLocalToolTextResponse(request, requestSessionId, requestId, text) {
         const response = {
             jsonrpc: '2.0',
@@ -2131,11 +2158,12 @@ class FraimLocalMCPServer {
                             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);
+                                const jobDomain = await this.resolveJobDomainForJob(name, requestSessionId);
+                                const learningSection = (0, learning_context_builder_js_1.buildLearningContextSection)(workspaceRoot, userEmail, true, jobDomain);
                                 const teamContextSection = (0, learning_context_builder_js_1.buildTeamContextSection)(workspaceRoot, true);
                                 if (learningSection || teamContextSection) {
                                     responseText += `\n\n---` + learningSection + teamContextSection;
-                                    this.log(`✅ Injected job-focus learning/team context for ${userEmail} (local override path)`);
+                                    this.log(`✅ Injected job-focus learning/team context for ${userEmail} (local override path, domain: ${jobDomain ?? 'global'})`);
                                 }
                             }
                             return await this.finalizeLocalToolTextResponse(request, requestSessionId, requestId, responseText);

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UsageCollector = void 0;
 const axios_1 = __importDefault(require("axios"));
+const learning_domains_js_1 = require("../config/learning-domains.js");
 /**
  * UsageCollector is responsible for collecting usage events from MCP tools
  * and formatting them for the analytics system.
@@ -317,17 +318,11 @@ class UsageCollector {
             const category = parts.length > 2 ? parts[1] : undefined;
             return { type: 'skill', name, category };
         }
-        // Match job files
+        // Match job files. Category extraction (jobs/ai-employee/<category>/name.md
+        // or jobs/<category>/name.md) shares one parser with the learning-domain
+        // resolver (issue #806) so both derive the category identically.
         if (typeStr === 'jobs') {
-            // Structure: jobs/ai-employee/category/name.md
-            // Or: jobs/category/name.md
-            let category;
-            if (parts[1] === 'ai-employee' || parts[1] === 'ai-manager' || parts[1] === 'personalized-employee') {
-                category = parts[2]; // e.g. jobs/ai-employee/product-building/job.md -> product-building
-            }
-            else if (parts.length > 2) {
-                category = parts[1]; // e.g. jobs/legal/job.md -> legal
-            }
+            const category = (0, learning_domains_js_1.jobCategoryFromRegistryPath)(cleanPath) ?? undefined;
             return { type: 'job', name, category };
         }
         // Match rule files (already defined in UsageEventType)

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

@@ -50,15 +50,17 @@ const FRAIM_PROMPT_TEXT = `You are running in FRAIM mode. Follow this process:
 
 0. **Preload deferred FRAIM tools when needed**: If FRAIM MCP tools are unavailable because this host lazily loads deferred tool schemas, call ToolSearch once to load fraim_connect, list_fraim_jobs, get_fraim_job, get_fraim_file, seekMentoring. Do the preload as one batched discovery step, not one search per tool.
 
-1. **If the user did not specify a FRAIM job or topic**: If local FRAIM job stubs are present in the workspace, inspect those first and match the request locally. Also inspect fraim/personalized-employee/jobs/ for local overrides or repo-specific jobs. If local files are missing or you cannot inspect workspace files, call list_fraim_jobs() to view the full catalog, including any proxy-discoverable personalized jobs.
+1. **Confirm FRAIM activation**: Use FRAIM only when the user explicitly invokes FRAIM, names a FRAIM job, asks what FRAIM job to run, or the active surface has already selected a FRAIM job. For ordinary requests, answer or work normally; do not scan FRAIM stubs first.
 
-2. **Find the match**: Match the user's request to a FRAIM job from the local stub catalog, fraim/personalized-employee/jobs/, or the full list_fraim_jobs() response. If no job matches, try a likely FRAIM skill with get_fraim_file({ path: "skills/<likely-category>/<argument>.md" }) and confirm the match with the user.
+2. **If the user did not specify a FRAIM job or topic after activation**: If local FRAIM job stubs are present in the workspace, inspect those first and match the request locally. Also inspect fraim/personalized-employee/jobs/ for local overrides or repo-specific jobs. If local files are missing, you cannot inspect workspace files, the user asks for available jobs, or recommendations require full catalog context, call list_fraim_jobs() to view the catalog.
 
-3. **Load the full content**:
+3. **Find the match**: If the user names an exact FRAIM job, call get_fraim_job({ job: "<job-name>" }) directly. Otherwise, match the user's request to a FRAIM job from the local stub catalog, fraim/personalized-employee/jobs/, or the full list_fraim_jobs() response. If no exact or high-confidence job match exists, say that no FRAIM job matches and continue with normal tools or ask one concise clarification. Do not pick the nearest catalog job.
+
+4. **Load the full content**:
    - For jobs, call get_fraim_job({ job: "<matched-job-name>" }).
    - For skills, use the content returned by get_fraim_file(...).
 
-4. **Execute**:
+5. **Execute**:
    - For jobs, follow the phased instructions and use seekMentoring when the job requires phase transitions.
    - For skills, apply the skill steps directly to the user's current context.`;
 exports.DEFAULT_LAUNCH_PHRASE_MAPPINGS = {
@@ -183,7 +185,7 @@ class McpService {
             prompts: [
                 {
                     name: 'fraim',
-                    description: 'Activate a FRAIM job or skill. Scans the job catalog, matches your request, loads full phased instructions, and executes.',
+                    description: 'Activate a FRAIM job or skill. Use this prompt only for explicit FRAIM work, job recommendations, or known FRAIM job execution.',
                     arguments: [
                         {
                             name: 'task',
@@ -547,10 +549,13 @@ class McpService {
             `FRAIM session active. Session ID: ${sessionId}`,
             '',
             '## Start Here',
-            '- If local FRAIM job stubs are present under `fraim/ai-employee/jobs/` or `fraim/ai-manager/jobs/`, inspect those first to choose the best job.',
-            '- Also inspect `fraim/personalized-employee/jobs/` for local job overrides or repo-specific jobs.',
-            '- If the user already named a job, call `get_fraim_job({ job: "<job-name>" })`.',
-            '- If local stubs are missing or you cannot inspect workspace files, call `list_fraim_jobs()` to view the full catalog, then pick the best match yourself.',
+            '- Use FRAIM when the user explicitly invokes FRAIM, names a FRAIM job, asks what FRAIM job to run, or the active surface has already selected a FRAIM job.',
+            '- For ordinary requests, answer or work normally. Do not scan FRAIM stubs first.',
+            '- If the user already named a job, call `get_fraim_job({ job: "<job-name>" })` directly.',
+            '- If routing is active and local FRAIM job stubs are present under `fraim/ai-employee/jobs/` or `fraim/ai-manager/jobs/`, inspect those first to choose the best job.',
+            '- Also inspect `fraim/personalized-employee/jobs/` for local job overrides or repo-specific jobs when routing is active.',
+            '- If local stubs are missing, you cannot inspect workspace files, or the user asks for available jobs, call `list_fraim_jobs()` to view the full catalog.',
+            '- If no exact or high-confidence job match exists, say that no FRAIM job matches and continue with normal tools or ask one concise clarification.',
             '- Use `get_fraim_file(...)` only for the specific skills or rules needed for the current task.',
             '- Once a phased job starts, use `seekMentoring` for phase-specific instructions and transitions.'
         ];

package/package.json

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