fraim 2.0.335 → 2.0.338

package/dist/registry/scripts/learning/entry-format.js

@@ -0,0 +1,27 @@
+'use strict';
+
+// Read the shared author's current entry format for identity and update guards.
+function learningEntryBlocks(body) {
+    const headings = [...body.matchAll(/^#{2,6}\s+\[P-[A-Z]+\].*$/gm)];
+    return headings.map((heading, index) => {
+        const start = heading.index;
+        const next = headings[index + 1]?.index ?? body.length;
+        const ownDepth = heading[0].match(/^#+/)[0].length;
+        const afterHeading = start + heading[0].length;
+        const shallower = [...body.slice(afterHeading, next).matchAll(/^(#{1,6})\s+.*$/gm)].find(m => m[1].length <= ownDepth);
+        const limit = shallower ? afterHeading + shallower.index : next;
+        const text = body.slice(start, limit).trimEnd();
+        return { start, end: start + text.length, text, id: text.match(/^\*\*Id\*\*:\s*(L-[a-f0-9]{10})\s*$/m)?.[1] ?? null };
+    });
+}
+
+function learningEntryMetadata(content) {
+    const metadata = {};
+    for (const match of content.matchAll(/^\*\*(Recurrences|First recorded|First synthesized)\*\*:\s*([^\r\n]+)$/gm)) {
+        if (metadata[match[1]] !== undefined && metadata[match[1]] !== match[2]) throw new Error('entry-metadata-conflict');
+        metadata[match[1]] = match[2];
+    }
+    return metadata;
+}
+
+module.exports = { learningEntryMetadata, learningEntryBlocks };

package/dist/registry/scripts/learning/learning-domains.json

@@ -0,0 +1,78 @@
+{
+  "schemaVersion": 1,
+  "mapVersion": 1,
+  "domains": [
+    "engineering",
+    "product",
+    "go-to-market",
+    "people-ops",
+    "finance",
+    "legal",
+    "compliance",
+    "customer",
+    "company-building",
+    "operations"
+  ],
+  "jobDomainMap": {
+    "product-building": "engineering",
+    "dev-ops": "engineering",
+    "quality-assurance": "engineering",
+    "migration": "engineering",
+    "replicate": "engineering",
+    "reviewer": "engineering",
+    "security": "engineering",
+    "delivery-ops": "engineering",
+    "salesforce": "engineering",
+    "ai-engineering": "engineering",
+    "product-management": "product",
+    "customer-development": "product",
+    "brainstorming": "product",
+    "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",
+    "inclusion-ops": "people-ops",
+    "career": "people-ops",
+    "finance": "finance",
+    "invoicing": "finance",
+    "banking": "finance",
+    "legal": "legal",
+    "compliance": "compliance",
+    "customer-success": "customer",
+    "customer-communication": "customer",
+    "company-creation": "company-building",
+    "bootstrap": "company-building",
+    "fundraising": "company-building",
+    "business-ops": "operations",
+    "procurement": "operations",
+    "project-management": "operations"
+  },
+  "globalJobCategories": [
+    "manager",
+    "fraim",
+    "1-1",
+    "coaching",
+    "delegation",
+    "hiring",
+    "productivity",
+    "project-setup",
+    "setup-guardrails",
+    "team-learning",
+    "verification"
+  ],
+  "domainVoice": {
+    "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."
+  }
+}

package/dist/src/cli/commands/doctor.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.doctorCommand = void 0;
 exports.getAllChecks = getAllChecks;
 exports.runFixMcpRepair = runFixMcpRepair;
+exports.runRepairMcpCache = runRepairMcpCache;
 const commander_1 = require("commander");
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -17,6 +18,8 @@ const mcp_connectivity_checks_1 = require("../doctor/checks/mcp-connectivity-che
 const scripts_checks_1 = require("../doctor/checks/scripts-checks");
 const agent_cli_health_checks_1 = require("../doctor/checks/agent-cli-health-checks");
 const llm_auth_route_checks_1 = require("../doctor/checks/llm-auth-route-checks");
+const fraim_mcp_cache_repair_1 = require("../doctor/checks/fraim-mcp-cache-repair");
+const fraim_mcp_latest_launcher_1 = require("../mcp/fraim-mcp-latest-launcher");
 const add_ide_1 = require("./add-ide");
 // Read version from package.json
 const getFramVersion = () => {
@@ -85,18 +88,34 @@ async function runFixMcpRepair(options, repair = add_ide_1.runAddIDE) {
         console.log = originalLog;
     }
 }
+async function runRepairMcpCache(options, dependencies = {}) {
+    if (!options.repairMcpCache) {
+        return;
+    }
+    const ensureShims = dependencies.ensureShims ?? fraim_mcp_latest_launcher_1.ensureFraimMcpLatestLauncher;
+    const repairCache = dependencies.repairCache ?? fraim_mcp_cache_repair_1.repairFraimMcpPackageCache;
+    const warmPackage = dependencies.warmPackage ?? fraim_mcp_cache_repair_1.warmFraimPackage;
+    ensureShims();
+    const result = repairCache({});
+    if (!options.json) {
+        console.log(`FRAIM MCP package cache repair removed ${result.removedBrokenNpxEntries.length} broken _npx entr${result.removedBrokenNpxEntries.length === 1 ? 'y' : 'ies'} and ${result.removedStaleRetryCaches.length} stale retry cache${result.removedStaleRetryCaches.length === 1 ? '' : 's'}.`);
+    }
+    await warmPackage(FRAIM_VERSION === 'unknown' ? 'latest' : FRAIM_VERSION);
+}
 exports.doctorCommand = new commander_1.Command('doctor')
     .description('Validate FRAIM installation and configuration')
     .option('--test-mcp', 'Test only MCP server connectivity')
     .option('--test-config', 'Validate only configuration files')
     .option('--test-jobs', 'Check only job status')
     .option('--fix-mcp', 'Repair FRAIM-owned MCP server entries in detected IDE configs, then validate MCP connectivity')
+    .option('--repair-mcp-cache', 'Repair corrupted FRAIM MCP package cache entries, then validate MCP connectivity')
     .option('--verbose', 'Show detailed output including successful checks')
     .option('--json', 'Output results as JSON')
     .action(async (cmdOptions) => {
     const startTime = Date.now();
     const options = {
-        testMcp: cmdOptions.testMcp || cmdOptions.fixMcp,
+        testMcp: cmdOptions.testMcp || cmdOptions.fixMcp || cmdOptions.repairMcpCache,
+        repairMcpCache: cmdOptions.repairMcpCache,
         testConfig: cmdOptions.testConfig,
         testJobs: cmdOptions.testJobs,
         fixMcp: cmdOptions.fixMcp,
@@ -110,6 +129,7 @@ exports.doctorCommand = new commander_1.Command('doctor')
             testConfig: options.testConfig || false,
             testJobs: options.testJobs || false,
             fixMcp: options.fixMcp || false,
+            repairMcpCache: options.repairMcpCache || false,
             verbose: options.verbose || false,
             json: options.json || false
         }
@@ -125,12 +145,15 @@ exports.doctorCommand = new commander_1.Command('doctor')
         trackMetric('doctor.flags.test_jobs', 1);
     if (options.fixMcp)
         trackMetric('doctor.flags.fix_mcp', 1);
+    if (options.repairMcpCache)
+        trackMetric('doctor.flags.repair_mcp_cache', 1);
     if (options.verbose)
         trackMetric('doctor.flags.verbose', 1);
     if (options.json)
         trackMetric('doctor.flags.json', 1);
     try {
         await runFixMcpRepair(options);
+        await runRepairMcpCache(options);
         // Collect all checks
         const checks = getAllChecks();
         // Run checks

package/dist/src/cli/commands/sync.js

@@ -311,13 +311,11 @@ const runSync = async (options) => {
             if (ignoreUpdate.gitignoreUpdated) {
                 console.log(chalk_1.default.green('Removed legacy FRAIM sync block from .gitignore'));
             }
-            if (options.projectAdapters) {
-                const allowedTypes = resolveAllowedConfigTypes();
-                await cleanupStaleAdapterFiles(projectRoot, allowedTypes);
-                const adapterUpdates = (0, agent_adapters_1.ensureAgentAdapterFiles)(projectRoot, allowedTypes);
-                if (adapterUpdates.length > 0) {
-                    console.log(chalk_1.default.green(`Updated FRAIM agent adapter files: ${adapterUpdates.join(', ')}`));
-                }
+            const allowedLocalTypes = resolveAllowedConfigTypes();
+            await cleanupStaleAdapterFiles(projectRoot, allowedLocalTypes);
+            const localAdapterUpdates = (0, agent_adapters_1.ensureAgentAdapterFiles)(projectRoot, allowedLocalTypes);
+            if (localAdapterUpdates.length > 0) {
+                console.log(chalk_1.default.green(`Updated FRAIM agent adapter files: ${localAdapterUpdates.join(', ')}`));
             }
             await refreshOrgCache(localUrl, 'local-dev');
             await refreshManagerCache(localUrl, 'local-dev');
@@ -437,13 +435,11 @@ const runSync = async (options) => {
     if (ignoreUpdate.gitignoreUpdated) {
         console.log(chalk_1.default.green('Removed legacy FRAIM sync block from .gitignore'));
     }
-    if (options.projectAdapters) {
-        const allowedTypes = resolveAllowedConfigTypes();
-        await cleanupStaleAdapterFiles(projectRoot, allowedTypes);
-        const adapterUpdates = (0, agent_adapters_1.ensureAgentAdapterFiles)(projectRoot, allowedTypes);
-        if (adapterUpdates.length > 0) {
-            console.log(chalk_1.default.green(`Updated FRAIM agent adapter files: ${adapterUpdates.join(', ')}`));
-        }
+    const allowedTypes = resolveAllowedConfigTypes();
+    await cleanupStaleAdapterFiles(projectRoot, allowedTypes);
+    const adapterUpdates = (0, agent_adapters_1.ensureAgentAdapterFiles)(projectRoot, allowedTypes);
+    if (adapterUpdates.length > 0) {
+        console.log(chalk_1.default.green(`Updated FRAIM agent adapter files: ${adapterUpdates.join(', ')}`));
     }
     console.log(chalk_1.default.green('✅ Project-level sync complete.'));
 };

package/dist/src/cli/doctor/checks/fraim-mcp-cache-repair.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RETRY_CACHE_AGE_FLOOR_MS = exports.CORRUPTED_NPX_PACKAGE_CACHE_CLASSIFICATION = exports.FRAIM_MCP_CACHE_REPAIR_DIAGNOSTIC_VERSION = void 0;
+exports.getFraimMcpCacheRoot = getFraimMcpCacheRoot;
+exports.inspectFraimMcpPackageCache = inspectFraimMcpPackageCache;
+exports.repairFraimMcpPackageCache = repairFraimMcpPackageCache;
+exports.buildFraimMcpCacheDiagnostic = buildFraimMcpCacheDiagnostic;
+exports.warmFraimPackage = warmFraimPackage;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const fraim_mcp_latest_launcher_1 = require("../../mcp/fraim-mcp-latest-launcher");
+exports.FRAIM_MCP_CACHE_REPAIR_DIAGNOSTIC_VERSION = 'fraim-mcp-cache-repair-v1';
+exports.CORRUPTED_NPX_PACKAGE_CACHE_CLASSIFICATION = 'corrupted-npx-package-cache';
+exports.DEFAULT_RETRY_CACHE_AGE_FLOOR_MS = 7 * 24 * 60 * 60 * 1000;
+const FRAIM_MCP_CACHE_REPAIR_COMMAND = 'npx --yes fraim@latest doctor --repair-mcp-cache';
+const VALID_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$/;
+function userDir() {
+    return process.env.FRAIM_USER_DIR || path_1.default.join(os_1.default.homedir(), '.fraim');
+}
+function getFraimMcpCacheRoot() {
+    return path_1.default.join(userDir(), 'npm-cache', 'mcp');
+}
+function versionFromCacheDir(versionCacheDir) {
+    const base = path_1.default.basename(versionCacheDir);
+    if (!base.startsWith('fraim-'))
+        return null;
+    const version = base.slice('fraim-'.length);
+    return VALID_VERSION_PATTERN.test(version) ? version : null;
+}
+function safeChild(parent, child) {
+    const parentResolved = path_1.default.resolve(parent);
+    const childResolved = path_1.default.resolve(child);
+    return childResolved === parentResolved || childResolved.startsWith(parentResolved + path_1.default.sep);
+}
+function directoryExists(dir) {
+    try {
+        return fs_1.default.statSync(dir).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function findBrokenNpxEntries(versionCacheDir) {
+    const version = versionFromCacheDir(versionCacheDir);
+    if (!version)
+        return [];
+    const npxRoot = path_1.default.join(versionCacheDir, '_npx');
+    if (!directoryExists(npxRoot))
+        return [];
+    return fs_1.default.readdirSync(npxRoot, { withFileTypes: true })
+        .filter(entry => entry.isDirectory())
+        .map(entry => path_1.default.join(npxRoot, entry.name))
+        .filter(entryPath => safeChild(npxRoot, entryPath))
+        .filter(entryPath => (directoryExists(path_1.default.join(entryPath, 'node_modules')) &&
+        !fs_1.default.existsSync(path_1.default.join(entryPath, 'package.json'))))
+        .map(entryPath => ({ version, path: entryPath }));
+}
+function findStaleRetryCaches(cacheRoot, options = {}) {
+    if (!directoryExists(cacheRoot))
+        return [];
+    const nowMs = options.nowMs ?? Date.now();
+    const ageFloorMs = options.ageFloorMs ?? exports.DEFAULT_RETRY_CACHE_AGE_FLOOR_MS;
+    return fs_1.default.readdirSync(cacheRoot, { withFileTypes: true })
+        .filter(entry => entry.isDirectory() && /^retry-\d+-\d+$/.test(entry.name))
+        .map(entry => {
+        const entryPath = path_1.default.join(cacheRoot, entry.name);
+        const stat = fs_1.default.statSync(entryPath);
+        return { path: entryPath, mtimeMs: stat.mtimeMs, ageMs: nowMs - stat.mtimeMs };
+    })
+        .filter(entry => entry.ageMs >= ageFloorMs && safeChild(cacheRoot, entry.path));
+}
+function inspectFraimMcpPackageCache(options = {}) {
+    const cacheRoot = options.cacheRoot ?? getFraimMcpCacheRoot();
+    const brokenNpxEntries = [];
+    if (directoryExists(cacheRoot)) {
+        for (const entry of fs_1.default.readdirSync(cacheRoot, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const versionCacheDir = path_1.default.join(cacheRoot, entry.name);
+            brokenNpxEntries.push(...findBrokenNpxEntries(versionCacheDir));
+        }
+    }
+    const counts = new Map();
+    for (const entry of brokenNpxEntries) {
+        counts.set(entry.version, (counts.get(entry.version) ?? 0) + 1);
+    }
+    return {
+        cacheRoot,
+        brokenNpxEntries,
+        staleRetryCaches: findStaleRetryCaches(cacheRoot, {
+            nowMs: options.nowMs,
+            ageFloorMs: options.retryAgeFloorMs,
+        }),
+        affectedVersions: [...counts.entries()]
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([version, brokenNpxEntryCount]) => ({ version, brokenNpxEntryCount })),
+    };
+}
+function repairFraimMcpPackageCache(options = {}) {
+    const inspection = inspectFraimMcpPackageCache(options);
+    const removedBrokenNpxEntries = [];
+    const removedStaleRetryCaches = [];
+    if (!options.dryRun) {
+        for (const entry of inspection.brokenNpxEntries) {
+            if (!safeChild(inspection.cacheRoot, entry.path))
+                continue;
+            fs_1.default.rmSync(entry.path, { recursive: true, force: true });
+            removedBrokenNpxEntries.push(entry);
+        }
+        for (const entry of inspection.staleRetryCaches) {
+            if (!safeChild(inspection.cacheRoot, entry.path))
+                continue;
+            fs_1.default.rmSync(entry.path, { recursive: true, force: true });
+            removedStaleRetryCaches.push(entry);
+        }
+    }
+    return {
+        ...inspection,
+        removedBrokenNpxEntries,
+        removedStaleRetryCaches,
+    };
+}
+function buildFraimMcpCacheDiagnostic(options = {}) {
+    const inspection = inspectFraimMcpPackageCache({
+        cacheRoot: options.cacheRoot,
+        nowMs: options.nowMs,
+    });
+    if (inspection.brokenNpxEntries.length === 0) {
+        return {
+            status: 'passed',
+            message: 'FRAIM MCP package cache has no corrupted _npx entries',
+            details: {
+                diagnosticVersion: exports.FRAIM_MCP_CACHE_REPAIR_DIAGNOSTIC_VERSION,
+                cacheRoot: inspection.cacheRoot,
+                affectedVersions: [],
+                staleRetryCacheCount: inspection.staleRetryCaches.length,
+            },
+        };
+    }
+    const status = options.mcpRuntimeStatus === 'error' ? 'error' : 'warning';
+    return {
+        status,
+        message: 'FRAIM MCP package cache is corrupted',
+        suggestion: `Run: ${FRAIM_MCP_CACHE_REPAIR_COMMAND}`,
+        details: {
+            diagnosticVersion: exports.FRAIM_MCP_CACHE_REPAIR_DIAGNOSTIC_VERSION,
+            classification: exports.CORRUPTED_NPX_PACKAGE_CACHE_CLASSIFICATION,
+            cacheRoot: inspection.cacheRoot,
+            affectedVersions: inspection.affectedVersions,
+            brokenNpxEntryCount: inspection.brokenNpxEntries.length,
+            staleRetryCacheCount: inspection.staleRetryCaches.length,
+            repairCommand: FRAIM_MCP_CACHE_REPAIR_COMMAND,
+        },
+    };
+}
+function readRecordedLauncherVersion() {
+    try {
+        const state = JSON.parse(fs_1.default.readFileSync((0, fraim_mcp_latest_launcher_1.getFraimMcpLauncherStatePath)(), 'utf8'));
+        const version = typeof state?.version === 'string' ? state.version : '';
+        return VALID_VERSION_PATTERN.test(version) ? version : null;
+    }
+    catch {
+        return null;
+    }
+}
+function versionCacheDirName(version) {
+    return `fraim-${version.replace(/[^a-zA-Z0-9._-]/g, '_')}`;
+}
+async function warmFraimPackage(versionFallback) {
+    const version = readRecordedLauncherVersion() || versionFallback;
+    const cacheDir = path_1.default.join(getFraimMcpCacheRoot(), versionCacheDirName(version));
+    const command = process.platform === 'win32' ? (process.env.ComSpec || 'cmd.exe') : 'npx';
+    const args = process.platform === 'win32'
+        ? ['/d', '/s', '/c', `npx --yes --package fraim@${version} fraim --version`]
+        : ['--yes', '--package', `fraim@${version}`, 'fraim', '--version'];
+    fs_1.default.mkdirSync(cacheDir, { recursive: true });
+    (0, child_process_1.execFileSync)(command, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        env: { ...process.env, npm_config_cache: cacheDir },
+        timeout: 120000,
+    });
+}

package/dist/src/cli/doctor/checks/mcp-connectivity-checks.js

@@ -59,6 +59,7 @@ const redact_secrets_1 = require("../../../core/utils/redact-secrets");
 const ide_detector_1 = require("../../setup/ide-detector");
 const fraim_mcp_latest_launcher_1 = require("../../mcp/fraim-mcp-latest-launcher");
 const fraim_mcp_diagnostics_1 = require("./fraim-mcp-diagnostics");
+const fraim_mcp_cache_repair_1 = require("./fraim-mcp-cache-repair");
 // Cache the npm major version so execFileSync is called at most once per process.
 // Without caching, each IDE config check calls diagnoseFraimMcpLaunchPlan which calls
 // getNpmMajorVersion, and execFileSync blocks the event loop for ~2s on Windows.
@@ -1001,8 +1002,18 @@ function getStdioMCPRuntimeChecks() {
 /**
  * Get all MCP connectivity checks
  */
-function getMCPConnectivityChecks() {
+function getMCPConnectivityChecks(dependencies = {}) {
     const checks = [];
+    const ensureLauncher = dependencies.ensureLauncher ?? fraim_mcp_latest_launcher_1.ensureFraimMcpLatestLauncher;
+    const runStdioServer = dependencies.testStdioServer ?? testStdioMCPServer;
+    ensureLauncher();
+    const npx = dependencies.npxPath ?? (0, fraim_mcp_latest_launcher_1.getFraimNpxShimPath)();
+    const fraimMcp = dependencies.fraimMcpPath ?? (0, fraim_mcp_latest_launcher_1.getFraimMcpShimPath)();
+    let fraimRuntimeCheck = null;
+    const runFraimRuntimeCheck = () => {
+        fraimRuntimeCheck ??= runStdioServer('fraim', fraimMcp, []);
+        return fraimRuntimeCheck;
+    };
     // Check 1: Test FRAIM server connectivity with actual API key
     checks.push({
         name: 'FRAIM server connectivity',
@@ -1016,6 +1027,14 @@ function getMCPConnectivityChecks() {
         critical: false,
         run: testFraimLocalProxyTroubleshooting
     });
+    checks.push({
+        name: 'FRAIM MCP package cache health',
+        category: 'mcpConnectivity',
+        critical: false,
+        run: async () => (0, fraim_mcp_cache_repair_1.buildFraimMcpCacheDiagnostic)({
+            mcpRuntimeStatus: (await runFraimRuntimeCheck()).status
+        })
+    });
     // Check 2: Validate each installed IDE's MCP config
     const installedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
     for (const ide of installedIDEs) {
@@ -1029,6 +1048,23 @@ function getMCPConnectivityChecks() {
     // Check 3 (Issue #532): Confirm stdio MCP servers respond at runtime.
     // "Disconnected" in mcp list is expected on-demand-spawn behavior. These checks
     // verify that each server can actually start and complete a JSON-RPC handshake.
-    checks.push(...getStdioMCPRuntimeChecks());
+    checks.push({
+        name: 'git stdio runtime check',
+        category: 'mcpConnectivity',
+        critical: false,
+        run: () => runStdioServer('git', npx, ['-y', '@cyanheads/git-mcp-server'])
+    });
+    checks.push({
+        name: 'playwright stdio runtime check',
+        category: 'mcpConnectivity',
+        critical: false,
+        run: () => runStdioServer('playwright', npx, ['-y', '@playwright/mcp'])
+    });
+    checks.push({
+        name: 'fraim stdio runtime check',
+        category: 'mcpConnectivity',
+        critical: false,
+        run: runFraimRuntimeCheck
+    });
     return checks;
 }

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

@@ -113,12 +113,14 @@ function defaultCloneDir(layer) {
  * Resolve where this layer's details live. Never throws and never touches the
  * network; call `ensurePackClone` separately when the git working copy has to
  * be present and current.
+ * Read-only inventory callers set `migrateLegacy: false` to suppress the
+ * otherwise backwards-compatible flat org layout migration.
  */
-function resolvePackHome(layer) {
+function resolvePackHome(layer, options = {}) {
     const config = (0, user_config_1.getLayerBackend)(layer);
     const standard = standardHome(layer);
     const make = (root, extra) => {
-        if (layer === 'org')
+        if (layer === 'org' && options.migrateLegacy !== false)
             migrateOrgFlatContent(root);
         return { layer, root, contentRoot: path_1.default.join(root, 'personalized-employee'), ...extra };
     };

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

@@ -12,130 +12,27 @@
  * 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
+ * The shared registry/scripts/learning/learning-domains.json owns the domain list, the
+ * registry-category -> domain map, and the per-domain authoring voice (R3).
+ * This module provides the pure resolver used at the injection sites, following 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.DOMAIN_VOICE = exports.GLOBAL_JOB_CATEGORIES = exports.JOB_DOMAIN_MAP = exports.LEARNING_DOMAINS = exports.LEARNING_DOMAIN_MAP_VERSION = 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',
-];
+const learningDomainData = require('../../registry/scripts/learning/learning-domains.json');
+exports.LEARNING_DOMAIN_MAP_VERSION = learningDomainData.mapVersion;
+exports.LEARNING_DOMAINS = Object.freeze(learningDomainData.domains);
+exports.JOB_DOMAIN_MAP = Object.freeze(learningDomainData.jobDomainMap);
+exports.GLOBAL_JOB_CATEGORIES = new Set(learningDomainData.globalJobCategories);
+exports.DOMAIN_VOICE = Object.freeze(learningDomainData.domainVoice);
 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',
-    'ai-engineering': '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.
  *

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

@@ -102,11 +102,17 @@ class LocalRegistryResolver {
                 (0, path_1.join)(this.managerCacheRoot, dir),
                 (0, path_1.join)(this.orgCacheRoot, dir),
                 (0, path_1.join)(this.workspaceRoot, 'registry', dir),
+                // Installed projects have categorized job stubs in the synced roles,
+                // without a source registry checkout. Keep authored overrides first.
+                ...(type === 'jobs' ? [this.getFraimPath('ai-employee', dir), this.getFraimPath('ai-manager', dir)] : []),
             ];
             for (const root of searchRoots) {
                 const found = this.searchFileRecursively(root, baseName);
                 if (!found)
                     continue;
+                const syncedRole = ['ai-employee', 'ai-manager'].find(role => root === this.getFraimPath(role, dir));
+                if (syncedRole)
+                    return `${dir}/${syncedRole}/${found.slice(root.length + 1).replace(/\\/g, '/')}`;
                 // Convert absolute back to a registry-relative path.
                 const rel = found.replace(/\\/g, '/');
                 const dirMarker = `/${dir}/`;

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

@@ -1612,17 +1612,8 @@ class FraimLocalMCPServer {
         // 4. After get_fraim_job succeeds, inject learning context with job-focus frame.
         if (toolName === 'get_fraim_job' && !finalizedResponse.error) {
             const text = finalizedResponse.result?.content?.[0]?.text;
-            const userEmail = this.ensureEngine().getUserEmail();
-            if (typeof text === 'string' && userEmail) {
-                const workspaceRoot = this.findProjectRoot() || process.cwd();
-                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} (domain: ${jobDomain ?? 'global'})`);
-                }
-                this.recordUsageOffers(workspaceRoot, userEmail, true, jobDomain, String(args.job ?? 'unknown'), requestId);
+            if (typeof text === 'string') {
+                finalizedResponse.result.content[0].text = await this.appendJobContext(text, args.job, requestSessionId, requestId);
             }
             // Issue #1345: forward executionMode from get_fraim_job response to Hub so
             // the chip reads from run data (no local file read, no separate endpoint needed).
@@ -1640,6 +1631,22 @@ class FraimLocalMCPServer {
         }
         return this.processResponseWithHydration(finalizedResponse, requestSessionId);
     }
+    /** Keep context delivery and offer attribution together for local and remote jobs. */
+    async appendJobContext(text, jobName, requestSessionId, requestId) {
+        const userEmail = this.ensureEngine().getUserEmail();
+        if (!userEmail)
+            return text;
+        const workspaceRoot = this.findProjectRoot() || process.cwd();
+        const jobDomain = await this.resolveJobDomainForJob(jobName, 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) {
+            text += `\n\n---` + learningSection + teamContextSection;
+            this.log(`[req:${requestId}] Injected job-focus learning/team context for ${userEmail} (domain: ${jobDomain ?? 'global'})`);
+        }
+        this.recordUsageOffers(workspaceRoot, userEmail, true, jobDomain, String(jobName ?? 'unknown'), requestId);
+        return text;
+    }
     /**
      * Issue #1103 R1, R2 and R3: record what this context injection delivered.
      *
@@ -2627,18 +2634,7 @@ class FraimLocalMCPServer {
                                 responseText = `${mentor.getCompactPhaseAuthority()}\n\n${responseText}`;
                                 responseText += `\n\n---\n\n**Job ID:** \`${jobId}\`\n\n**This job has phases.** Use \`seekMentoring\` with the jobId above to get phase-specific instructions.`;
                             }
-                            // Inject local learning context for job requests (RFC 177).
-                            const userEmail = this.ensureEngine().getUserEmail();
-                            if (userEmail) {
-                                const workspaceRoot = this.findProjectRoot() || process.cwd();
-                                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, domain: ${jobDomain ?? 'global'})`);
-                                }
-                            }
+                            responseText = await this.appendJobContext(responseText, name, requestSessionId, requestId);
                             return await this.finalizeLocalToolTextResponse(request, requestSessionId, requestId, responseText);
                         }
                     }

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "fraim",
-  "version": "2.0.335",
+  "version": "2.0.338",
   "description": "FRAIM core CLI and MCP package.",
   "main": "index.js",
   "bin": {
     "fraim": "bin/fraim.js"
   },
   "files": [
+    "dist/registry/scripts/learning/learning-domains.json",
+    "dist/registry/scripts/learning/entry-format.js",
     "dist/src/local-mcp-server/",
     "dist/src/cli/",
     "!dist/src/cli/fraim-hub.js",