fraim 2.0.337 → 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/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.337",
+  "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",