fraim 2.0.209 → 2.0.210

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/package.json

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