fraim 2.0.243 → 2.0.245

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

@@ -53,6 +53,8 @@ class LocalRegistryResolver {
         this.remoteContentResolver = options.remoteContentResolver;
         this.parser = new inheritance_parser_1.InheritanceParser(options.maxDepth);
         this.shouldFilter = options.shouldFilter;
+        // Issue #1002: default the manager's writable home to ~/.fraim/personalized-employee/
+        this.managerLocalRoot = options.managerLocalRoot ?? (0, path_1.join)((0, project_fraim_paths_1.getUserFraimDirPath)(), 'personalized-employee');
         // Issue #869: default manager cache root to ~/.fraim/manager/
         this.managerCacheRoot = options.managerCacheRoot ?? (0, path_1.join)((0, project_fraim_paths_1.getUserFraimDirPath)(), 'manager');
         // Issue #869 Phase 2: default org cache root to ~/.fraim/org/
@@ -87,15 +89,27 @@ class LocalRegistryResolver {
             const literal = `${dir}/${baseName}`;
             if (this.hasLocalOverride(literal))
                 return literal;
-            // Deep search
-            const fullBaseDir = this.getFraimPath('personalized-employee', dir);
-            const found = this.searchFileRecursively(fullBaseDir, baseName);
-            if (found) {
-                // Convert absolute back to relative
+            // Deep search each layer that can hold a categorised capability, in the
+            // same precedence order resolveFile uses. Issue #1002: without the manager
+            // and org roots here, a manager-level job resolved to the uncategorised
+            // fallback `jobs/<name>.md`, which never matches the real overlay path
+            // `jobs/<category>/<name>.md`, so the job was reported not found even
+            // though the file existed.
+            const searchRoots = [
+                this.getFraimPath('personalized-employee', dir),
+                (0, path_1.join)(this.managerLocalRoot, dir),
+                (0, path_1.join)(this.managerCacheRoot, dir),
+                (0, path_1.join)(this.orgCacheRoot, dir),
+            ];
+            for (const root of searchRoots) {
+                const found = this.searchFileRecursively(root, baseName);
+                if (!found)
+                    continue;
+                // Convert absolute back to a registry-relative path.
                 const rel = found.replace(/\\/g, '/');
                 const dirMarker = `/${dir}/`;
                 if (rel.includes(dirMarker)) {
-                    return rel.substring(rel.indexOf(dirMarker) + 1);
+                    return rel.substring(rel.lastIndexOf(dirMarker) + 1);
                 }
             }
         }
@@ -229,6 +243,48 @@ class LocalRegistryResolver {
             return null;
         }
     }
+    /**
+     * Issue #1002: read a capability file from the manager's WRITABLE home
+     * (~/.fraim/personalized-employee/<type>/…). Returns null if not present or
+     * filtered.
+     *
+     * Precedence: project > MANAGER LOCAL > manager synced cache > org cache >
+     * synced baseline > registry > remote. Local beats the cache so a capability
+     * the manager just authored resolves immediately, before any publish or sync,
+     * and resolves at all under the `single-machine` backend where the cache is
+     * never populated (spec #1002 D-A).
+     *
+     * Security: same canonical-path containment guard as the other overlay
+     * readers, so a crafted path can never escape the home directory.
+     */
+    readManagerLocalOverlayFile(path) {
+        return this.readContainedOverlayFile(this.managerLocalRoot, path);
+    }
+    /**
+     * Shared overlay read with a canonical-path containment guard. Extracted so
+     * every overlay root uses one implementation of the guard rather than each
+     * repeating it (the manager cache and org cache readers below delegate here).
+     */
+    readContainedOverlayFile(root, path) {
+        const normalized = path.replace(/\\/g, '/').replace(/^\/+/, '');
+        const destination = (0, path_1.join)(root, ...normalized.split('/'));
+        const resolved = (0, path_1.resolve)(destination);
+        const rootResolved = (0, path_1.resolve)(root);
+        if (!resolved.startsWith(rootResolved + path_1.sep) && resolved !== rootResolved) {
+            return null;
+        }
+        if (!(0, fs_1.existsSync)(destination))
+            return null;
+        try {
+            const content = (0, fs_1.readFileSync)(destination, 'utf-8');
+            if (this.shouldFilter && this.shouldFilter(content))
+                return null;
+            return content;
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * Issue #869: read a capability file from the manager overlay cache
      * (~/.fraim/manager/<type>/…). Returns null if not present or filtered.
@@ -451,7 +507,20 @@ class LocalRegistryResolver {
         const stripMcpHeader = options.stripMcpHeader ?? false;
         // Check for local override
         if (!this.hasLocalOverride(path)) {
-            // Issue #869: manager overlay (precedence 2 — between project override and synced baseline)
+            // Issue #1002: the manager's writable home (precedence 2 — above the
+            // synced manager cache, so a just-authored capability resolves before any
+            // publish or sync and resolves at all under `single-machine`).
+            const managerLocalContent = this.readManagerLocalOverlayFile(path);
+            if (managerLocalContent !== null) {
+                return {
+                    content: managerLocalContent,
+                    source: 'local',
+                    personalized: true,
+                    inherited: false,
+                    scope: 'manager'
+                };
+            }
+            // Issue #869: manager overlay (precedence 3 — the synced cross-machine copy)
             const managerOverlayContent = this.readManagerOverlayFile(path);
             if (managerOverlayContent !== null) {
                 return {

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

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CATEGORY_TO_FILETYPE = exports.BRAIN_LEARNING_FILETYPE_TO_REGION = exports.LEARNING_PRIORITIES = void 0;
 exports.learningEntryHeadingRegex = learningEntryHeadingRegex;
 exports.computeEffectiveScore = computeEffectiveScore;
+exports.mergeLearningEntriesAcrossTiers = mergeLearningEntriesAcrossTiers;
 exports.buildLearningContextSection = buildLearningContextSection;
 exports.buildTeamContextSection = buildTeamContextSection;
 exports.resolveTeamContextFiles = resolveTeamContextFiles;
@@ -83,6 +84,46 @@ function resolvePersonalLearningFile(repoBase, managerCacheBase, managerCacheDis
     }
     return { present: false, path: globalPath, displayPath: `${globalDisplayBase.replace(/\/$/, '')}/${fileName}` };
 }
+/**
+ * Issue #1002 R4: resolve EVERY tier that holds this personal family, lowest
+ * precedence first, instead of only the winning one.
+ *
+ * The old behavior was a family-level override: a repo-local
+ * `<user>-preferences.md` shadowed the whole manager family, so promoting one
+ * entry to the project hid every other preference the manager had. Verified
+ * before the change, and the same shadowing applied to company families.
+ *
+ * Returning all tiers lets the context block list each present path and lets the
+ * Hub merge entries with the project entry winning only on a title collision.
+ */
+function resolvePersonalLearningFileTiers(repoBase, managerCacheBase, managerCacheDisplayBase, globalBase, globalDisplayBase, fileName) {
+    const tiers = [];
+    const cachePath = (0, path_1.join)(managerCacheBase, fileName);
+    if ((0, fs_1.existsSync)(cachePath)) {
+        tiers.push({
+            level: 'manager',
+            path: cachePath,
+            displayPath: `${managerCacheDisplayBase.replace(/\/$/, '')}/${fileName}`
+        });
+    }
+    const globalPath = (0, path_1.join)(globalBase, fileName);
+    if ((0, fs_1.existsSync)(globalPath)) {
+        tiers.push({
+            level: 'manager',
+            path: globalPath,
+            displayPath: `${globalDisplayBase.replace(/\/$/, '')}/${fileName}`
+        });
+    }
+    const repoPath = (0, path_1.join)(repoBase, fileName);
+    if ((0, fs_1.existsSync)(repoPath)) {
+        tiers.push({
+            level: 'project',
+            path: repoPath,
+            displayPath: `${REPO_LEARNINGS_REL}/${fileName}`
+        });
+    }
+    return tiers;
+}
 function buildUserIdCandidates(userId) {
     const candidates = new Set();
     const trimmed = userId.trim();
@@ -103,40 +144,6 @@ function countMatchingFilesByPrefix(dirPath, matcher) {
         return 0;
     }
 }
-function collectAvailableUserPrefixes(workspaceRoot, personalRoots) {
-    const prefixes = new Set();
-    const collect = (dirPath, extractor) => {
-        if (!(0, fs_1.existsSync)(dirPath))
-            return;
-        try {
-            for (const fileName of (0, fs_1.readdirSync)(dirPath)) {
-                const prefix = extractor(fileName);
-                if (prefix)
-                    prefixes.add(prefix);
-            }
-        }
-        catch {
-            // Ignore unreadable directories.
-        }
-    };
-    for (const personalRoot of personalRoots) {
-        collect(personalRoot, (fileName) => {
-            if (!fileName.endsWith('.md') || fileName.startsWith('org-'))
-                return null;
-            const match = fileName.match(/^(.*?)-(preferences|manager-coaching|mistake-patterns|validated-patterns)\.md$/);
-            return match ? match[1] : null;
-        });
-    }
-    collect((0, path_1.join)(personalRoots[0], 'raw'), (fileName) => {
-        const match = fileName.match(/^(.*?)-\d{4}-\d{2}-\d{2}-.*\.md$/);
-        return match ? match[1] : null;
-    });
-    collect((0, path_1.join)(workspaceRoot, 'docs', 'retrospectives'), (fileName) => {
-        const match = fileName.match(/^(.*?)-\d{4}-\d{2}-\d{2}-.*\.md$/);
-        return match ? match[1] : null;
-    });
-    return prefixes;
-}
 function resolveLearningUserId(workspaceRoot, userId, roots) {
     const candidates = buildUserIdCandidates(userId);
     let bestCandidate = candidates[0] || userId;
@@ -163,10 +170,18 @@ function resolveLearningUserId(workspaceRoot, userId, roots) {
     }
     if (bestScore > 0)
         return bestCandidate;
-    const availablePrefixes = collectAvailableUserPrefixes(workspaceRoot, [roots.repoLearningsBase, roots.managerCacheBase, roots.globalPersonalBase]);
-    if (availablePrefixes.size === 1) {
-        return Array.from(availablePrefixes)[0];
-    }
+    // Issue #1002 R4.1: an unresolved identity resolves to the current user's own
+    // prefix and therefore to an EMPTY personal section. It must never fall back
+    // to "whichever single prefix happens to exist on disk".
+    //
+    // That fallback used to live here, and it leaked: on a project holding only
+    // user A's personal learning files, user B with no files of their own resolved
+    // to A's prefix and loaded A's personal learnings, including entries A had
+    // deliberately kept at the project level. Verified before removal.
+    //
+    // Personal learnings are per-user by construction (the filename carries the
+    // owner). A learning that genuinely should reach everyone on a project belongs
+    // in the company-scope family, which is not keyed by user at all.
     return bestCandidate;
 }
 function readWorkspaceConfig(workspaceRoot) {
@@ -376,6 +391,46 @@ function resolveOrgLearningFile(repoLearningsBase, fileName) {
     }
     return { present: false, path: repoPath, displayPath: `${REPO_LEARNINGS_REL}/${fileName}` };
 }
+/**
+ * Issue #1002 R4: the company equivalent of the above. A repo-local `org-*.md`
+ * used to shadow the synced company family entirely, so a project-scoped company
+ * lesson made every company-wide lesson in that family disappear. Verified.
+ */
+function resolveOrgLearningFileTiers(repoLearningsBase, fileName) {
+    const tiers = [];
+    const cachePath = (0, path_1.join)((0, project_fraim_paths_1.getUserFraimDirPath)(), 'org', 'learnings', fileName);
+    if ((0, fs_1.existsSync)(cachePath)) {
+        tiers.push({
+            level: 'org',
+            path: cachePath,
+            displayPath: (0, project_fraim_paths_1.getUserFraimDisplayPath)(`org/learnings/${fileName}`)
+        });
+    }
+    const repoPath = (0, path_1.join)(repoLearningsBase, fileName);
+    if ((0, fs_1.existsSync)(repoPath)) {
+        tiers.push({
+            level: 'org',
+            path: repoPath,
+            displayPath: `${REPO_LEARNINGS_REL}/${fileName}`
+        });
+    }
+    return tiers;
+}
+/**
+ * Issue #1002 R4: merge entries across tiers. Lowest precedence first in, so a
+ * later tier overwrites on an identical title and nothing is duplicated. Entries
+ * whose titles do not collide all survive, which is the whole point: promoting
+ * one entry must not hide the rest of its family.
+ */
+function mergeLearningEntriesAcrossTiers(tiers) {
+    const byTitle = new Map();
+    for (const tier of tiers) {
+        for (const entry of tier.entries) {
+            byTitle.set(entry.title.trim().toLowerCase(), entry);
+        }
+    }
+    return [...byTitle.values()];
+}
 function buildLearningContextSection(workspaceRoot, userId, forJob, domain) {
     const roots = getLearningRoots(workspaceRoot);
     const resolvedUserId = resolveLearningUserId(workspaceRoot, userId, roots);
@@ -396,6 +451,29 @@ function buildLearningContextSection(workspaceRoot, userId, forJob, domain) {
     const l1Cats = forJob ? jobL1Cats : sessionCats;
     const activeDomain = forJob && domain ? domain : null;
     const dormantOf = (meta, filePath) => meta.gated ? scanMistakePatternFile(filePath, threshold, meta.ft).dormant : 0;
+    // Issue #1002 R4: same shape as resolveTier below, but a family may resolve to
+    // MORE THAN ONE file (one per level that holds it), so each is listed.
+    const resolveTierMulti = (cats, resolveFiles) => {
+        const global = [];
+        const domainFiles = [];
+        let coachPresent = false;
+        for (const key of cats) {
+            const meta = CAT[key];
+            for (const g of resolveFiles(meta.ft)) {
+                global.push({ displayPath: g.displayPath, label: meta.label, dormant: dormantOf(meta, g.path), isCoach: key === 'coach' });
+                if (key === 'coach')
+                    coachPresent = true;
+            }
+            if (activeDomain) {
+                for (const d of resolveFiles(meta.ft, activeDomain)) {
+                    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 };
+    };
     // Resolve one tier (L2 org or L1 personal) into ordered global + domain files.
     const resolveTier = (cats, resolveFile) => {
         const global = [];
@@ -420,8 +498,19 @@ function buildLearningContextSection(workspaceRoot, userId, forJob, domain) {
         }
         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`));
+    // Issue #1002 R4: resolve every tier holding each family, not just the winner,
+    // so a promoted entry never hides the rest of its family. `multiTier` is true
+    // when at least one family exists at more than one level, which is when the
+    // collision rule needs stating.
+    let multiTier = false;
+    const resolveTiersFor = (tiersFor) => (ft, dom) => {
+        const tiers = tiersFor(ft, dom);
+        if (tiers.length > 1)
+            multiTier = true;
+        return tiers.map((t) => ({ present: true, path: t.path, displayPath: t.displayPath }));
+    };
+    const l2 = resolveTierMulti(l2Cats, resolveTiersFor((ft, dom) => resolveOrgLearningFileTiers(roots.repoLearningsBase, dom ? `org-${dom}-${ft}.md` : `org-${ft}.md`)));
+    const l1 = resolveTierMulti(l1Cats, resolveTiersFor((ft, dom) => resolvePersonalLearningFileTiers(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);
@@ -478,6 +567,9 @@ function buildLearningContextSection(workspaceRoot, userId, forJob, domain) {
     if (forJob) {
         if (hasL2 || hasL1) {
             section += 'Read the listed synthesized learning files before continuing, then apply the relevant patterns and preferences in this job.\n';
+            if (multiTier) {
+                section += 'A family listed at more than one level is combined, not replaced: apply every entry, and where the same entry title appears at two levels apply the more specific one (project over manager).\n';
+            }
             if (coachPresent) {
                 section += 'Treat manager-coaching as feedback for how the manager should continue or improve managing AI, not as agent instruction.\n';
             }
@@ -485,6 +577,9 @@ function buildLearningContextSection(workspaceRoot, userId, forJob, domain) {
     }
     else if (hasL2 || hasL1) {
         section += 'Read the listed synthesized learning files before continuing, then use this synthesized learning context throughout the session.\n';
+        if (multiTier) {
+            section += 'A family listed at more than one level is combined, not replaced: apply every entry, and where the same entry title appears at two levels apply the more specific one (project over manager).\n';
+        }
         if (coachPresent) {
             section += 'Manager-coaching entries are manager-facing feedback, not instructions for the AI to follow.\n';
         }
@@ -779,45 +874,104 @@ function countLearningEntries(filePath) {
     return count;
 }
 /**
- * Count preserved learnings by scope for the Brain summary (R14). Organization
- * = L2 org-* files; manager = the personal manager-coaching file (reverse
- * mentoring); project = personal mistake/preferences/validated patterns. Raw =
- * un-dismissed L0 signals still awaiting synthesis. Reuses the same root/file
- * resolution as buildLearningContextSection so the counts line up with what the
- * agent actually auto-loads.
+ * Issue #1002 R4: the distinct entry titles in a learning file. Counting titles
+ * rather than raw headings is what lets a family present at two levels be summed
+ * without double-counting a promoted entry.
+ */
+function readLearningEntryTitles(filePath) {
+    if (!(0, fs_1.existsSync)(filePath))
+        return [];
+    let content;
+    try {
+        content = (0, fs_1.readFileSync)(filePath, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const titles = [];
+    const headingRe = learningEntryHeadingRegex();
+    for (const line of content.split(/\r?\n/)) {
+        const m = line.match(headingRe);
+        if (m)
+            titles.push(m[2].trim().toLowerCase());
+    }
+    return titles;
+}
+/**
+ * Count preserved learnings BY LEVEL for the Brain summary.
+ *
+ * Issue #1002: two changes from the original.
+ *
+ * R4: counts sum across every level that holds a family, deduped by entry title,
+ * rather than counting only the winning file. Under the old first-wins read a
+ * family present at two levels was counted once, so the Brain under-reported
+ * exactly the case this issue introduces.
+ *
+ * R11: `manager` now means the manager LEVEL and `reverseMentoring` carries the
+ * manager-coaching entries that field used to hold, so the tile labelled
+ * "Manager" reports the level rather than a category.
  */
 function countPreservedLearnings(workspaceRoot, userId) {
     const roots = getLearningRoots(workspaceRoot);
     const resolvedUserId = resolveLearningUserId(workspaceRoot, userId, roots);
-    // L2 organization-scope preserved files: repo-local override, then the
-    // synced org cache (#563), matching what buildLearningContextSection injects.
-    const organization = countLearningEntries(resolveOrgLearningFile(roots.repoLearningsBase, 'org-mistake-patterns.md').path) +
-        countLearningEntries(resolveOrgLearningFile(roots.repoLearningsBase, 'org-preferences.md').path) +
-        countLearningEntries(resolveOrgLearningFile(roots.repoLearningsBase, 'org-manager-coaching.md').path) +
-        countLearningEntries(resolveOrgLearningFile(roots.repoLearningsBase, 'org-validated-patterns.md').path);
-    const resolve = (fileName) => resolvePersonalLearningFile(roots.repoLearningsBase, roots.managerCacheBase, roots.managerCacheDisplayBase, roots.globalPersonalBase, roots.globalPersonalDisplayBase, fileName);
-    // L1 manager-facing reverse-mentoring file.
-    const manager = countLearningEntries(resolve(`${resolvedUserId}-manager-coaching.md`).path);
-    // L1 personal work patterns (project scope).
-    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;
+    // Distinct entry titles across every level holding this company family, so a
+    // family present at two levels is not counted once (R4) nor twice.
+    const countOrgFamily = (fileName) => {
+        const titles = new Set();
+        for (const tier of resolveOrgLearningFileTiers(roots.repoLearningsBase, fileName)) {
+            for (const t of readLearningEntryTitles(tier.path))
+                titles.add(t);
+        }
+        return titles.size;
+    };
+    // Same for a personal family, and reported per level so the Brain can show
+    // where each entry actually lives. A title present at both levels counts
+    // once, at the project level, matching which entry the agent applies.
+    const countPersonalFamilyByLevel = (fileName) => {
+        const tiers = resolvePersonalLearningFileTiers(roots.repoLearningsBase, roots.managerCacheBase, roots.managerCacheDisplayBase, roots.globalPersonalBase, roots.globalPersonalDisplayBase, fileName);
+        const projectTitles = new Set();
+        const managerTitles = new Set();
+        for (const tier of tiers) {
+            for (const t of readLearningEntryTitles(tier.path)) {
+                if (tier.level === 'project')
+                    projectTitles.add(t);
+                else
+                    managerTitles.add(t);
+            }
+        }
+        // A promoted entry lives at the project level; do not also count it as the
+        // manager's, or the two tiles would double-report the same lesson.
+        for (const t of projectTitles)
+            managerTitles.delete(t);
+        return { manager: managerTitles.size, project: projectTitles.size };
+    };
+    const PERSONAL_WORK_TYPES = ['mistake-patterns', 'preferences', 'validated-patterns'];
+    const ORG_TYPES = ['mistake-patterns', 'preferences', 'manager-coaching', 'validated-patterns'];
+    let organization = 0;
+    for (const ft of ORG_TYPES)
+        organization += countOrgFamily(`org-${ft}.md`);
+    let manager = 0;
+    let project = 0;
+    for (const ft of PERSONAL_WORK_TYPES) {
+        const byLevel = countPersonalFamilyByLevel(`${resolvedUserId}-${ft}.md`);
+        manager += byLevel.manager;
+        project += byLevel.project;
+    }
+    // R11: reverse mentoring is its own count, not folded into the manager level.
+    const coachByLevel = countPersonalFamilyByLevel(`${resolvedUserId}-manager-coaching.md`);
+    let reverseMentoring = coachByLevel.manager + coachByLevel.project;
+    // #806: domain-scoped files fold into the same per-level counts so the Brain
+    // reconciles with what the loader injects for a job.
     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);
+        for (const ft of ORG_TYPES)
+            organization += countOrgFamily(`org-${domain}-${ft}.md`);
+        for (const ft of PERSONAL_WORK_TYPES) {
+            const byLevel = countPersonalFamilyByLevel(`${resolvedUserId}-${domain}-${ft}.md`);
+            manager += byLevel.manager;
+            project += byLevel.project;
+        }
+        const domainCoach = countPersonalFamilyByLevel(`${resolvedUserId}-${domain}-manager-coaching.md`);
+        reverseMentoring += domainCoach.manager + domainCoach.project;
     }
     // L0 raw signals still awaiting synthesis (not dismissed).
     let rawSignals = 0;
@@ -838,9 +992,10 @@ function countPreservedLearnings(workspaceRoot, userId) {
         }
     }
     return {
-        organization: organization + organizationDomain,
-        manager: manager + managerDomain,
-        project: project + projectDomain,
+        organization,
+        manager,
+        project,
+        reverseMentoring,
         rawSignals,
     };
 }

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

@@ -2221,8 +2221,22 @@ class FraimLocalMCPServer {
                     try {
                         const projectRoot = this.findProjectRoot();
                         const uniqueLocalItems = new Map();
-                        if (projectRoot) {
-                            const personalizedJobsDir = (0, path_1.join)(projectRoot, 'fraim', 'personalized-employee', 'jobs');
+                        // 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 { getUserFraimDirPath } = require('../core/utils/project-fraim-paths');
+                        const userFraimDir = getUserFraimDirPath();
+                        const jobDirsByLevel = [
+                            { dir: (0, path_1.join)(userFraimDir, 'manager', 'jobs'), level: 'manager' },
+                            { dir: (0, path_1.join)(userFraimDir, 'personalized-employee', 'jobs'), level: 'manager' },
+                            ...(projectRoot
+                                ? [{ dir: (0, path_1.join)(projectRoot, 'fraim', 'personalized-employee', 'jobs'), level: 'project' }]
+                                : []),
+                        ];
+                        for (const { dir: jobsDir, level } of jobDirsByLevel) {
+                            const personalizedJobsDir = jobsDir;
                             if ((0, fs_1.existsSync)(personalizedJobsDir)) {
                                 const collectLocalJobPaths = (dir, currentRel = '') => {
                                     const results = [];
@@ -2242,16 +2256,19 @@ class FraimLocalMCPServer {
                                 const localJobPaths = collectLocalJobPaths(personalizedJobsDir);
                                 for (const relPath of localJobPaths) {
                                     const normalizedName = relPath.split('/').pop()?.replace(/\.md$/, '').trim() || '';
-                                    if (!normalizedName || uniqueLocalItems.has(normalizedName)) {
+                                    if (!normalizedName) {
                                         continue;
                                     }
                                     const category = relPath.includes('/')
                                         ? relPath.split('/').slice(0, -1).join('/') || 'personalized-employee'
                                         : 'personalized-employee';
+                                    // A later level overwrites an earlier one on the same job name,
+                                    // matching the resolver: project wins over manager.
                                     uniqueLocalItems.set(normalizedName, {
                                         name: normalizedName,
                                         path: relPath,
-                                        category
+                                        category,
+                                        level
                                     });
                                 }
                             }
@@ -2260,13 +2277,16 @@ class FraimLocalMCPServer {
                             const sortedLocalItems = Array.from(uniqueLocalItems.values())
                                 .sort((a, b) => a.category.localeCompare(b.category) || a.name.localeCompare(b.name));
                             let combinedText = response.result.content[0].text;
-                            combinedText += `\n\n## Local Personalized Jobs (${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('personalized-employee/jobs/')})\n`;
-                            combinedText += 'These local jobs override catalog jobs of the same name when you call `get_fraim_job`.\n';
+                            combinedText += '\n\n## Your Own Jobs\n';
+                            combinedText += 'These override catalog jobs of the same name when you call `get_fraim_job`. The level says who else has each one.\n';
                             for (const item of sortedLocalItems) {
                                 const categorySuffix = item.category && item.category !== 'personalized-employee'
                                     ? ` (${item.category})`
                                     : '';
-                                combinedText += `- **${item.name}**${categorySuffix}\n`;
+                                const levelWord = item.level === 'project'
+                                    ? 'this project only'
+                                    : 'yours, every project';
+                                combinedText += `- **${item.name}**${categorySuffix} - ${levelWord}\n`;
                             }
                             response.result.content[0].text = combinedText;
                         }

package/package.json

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