fraim-hub 2.0.337 → 2.0.339

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/learning-context-builder.js

@@ -890,8 +890,9 @@ function enumerateFileEntries(file, threshold, usageClock, now) {
         out.push({
             // The store owns key construction. Building the composite key by hand here
             // would be a second definition of what an entry's identity is, and the two
-            // would drift the first time normalization changed.
-            key: current.id ?? (0, learning_usage_store_1.titleUsageKey)(file.fileType, current.title),
+            // would drift the first time normalization changed. Issue #1752 A1 made
+            // that one function rather than four copies of the same expression.
+            key: (0, learning_usage_store_1.resolveEntryIdentity)({ id: current.id, fileType: file.fileType, title: current.title }).key,
             family: 'learning',
             id: current.id,
             title: current.title,
@@ -939,9 +940,27 @@ function enumerateFileEntries(file, threshold, usageClock, now) {
  * listed. `aboveThreshold` is what separates active guidance from the dormant
  * rollup. Nothing here depends on the agent reading anything.
  *
- * Deduplicated by key with the later tier winning, matching how
- * `mergeLearningEntriesAcrossTiers` resolves a title collision across levels, so
- * one lesson is one offer even when two levels hold it.
+ * ## Issue #1752 A2 — one lesson, one offer, stamped or not
+ *
+ * This deduped by usage key, which sounds like the same thing as the context
+ * reader's rule and is not. `resolveOrgLearningFileTiers` deliberately returns
+ * both the org pack copy and the repo-local copy of an org family, because #1002
+ * R4 requires that a promoted entry not hide the rest of its family. The context
+ * reader then merges those tiers with `mergeLearningEntriesAcrossTiers`, keyed on
+ * the normalized title, so the agent sees one lesson. Keying the offer record on
+ * `id ?? titleUsageKey(...)` instead meant that a lesson carrying an `**Id**` line
+ * in one tier and not the other produced two keys, and both were recorded.
+ *
+ * That is defect 4 in #1752, and it is why `standing --changes-only` could
+ * recommend promoting and demoting the same lesson in one response: the
+ * title-keyed twin collected the offers while the id-keyed one collected the
+ * firings (the firing path never split, because `buildEntryIndex` dedups by
+ * identity first-wins). Measured live: five titles emitting two keys each in a
+ * single derived offer batch.
+ *
+ * So group by the same normalized title the context reader groups by, resolve one
+ * identity per group preferring whichever tier carries an id, and let the later
+ * tier win on content exactly as before.
  */
 function collectOfferedLearningEntries(workspaceRoot, userId, forJob, domain) {
     const roots = getLearningRoots(workspaceRoot);
@@ -950,13 +969,35 @@ function collectOfferedLearningEntries(workspaceRoot, userId, forJob, domain) {
     const usageClock = resolveUsageClock(workspaceRoot);
     const now = new Date();
     const resolved = resolveContextLearningFiles(workspaceRoot, resolvedUserId, roots, forJob, domain);
-    const byKey = new Map();
+    // Grouped by family plus normalized title, which is what `titleUsageKey`
+    // already computes. Two families holding the same title are two lessons, and
+    // that is the existing rule rather than a new one.
+    const byLesson = new Map();
     for (const file of [...resolved.l2, ...resolved.l1]) {
         for (const entry of enumerateFileEntries(file, threshold, usageClock, now)) {
-            byKey.set(entry.key, entry);
+            const lessonKey = (0, learning_usage_store_1.titleUsageKey)(entry.fileType, entry.title);
+            const group = byLesson.get(lessonKey);
+            if (group)
+                group.push(entry);
+            else
+                byLesson.set(lessonKey, [entry]);
         }
     }
-    return [...byKey.values()];
+    const out = [];
+    for (const group of byLesson.values()) {
+        // Later tier wins for content, unchanged precedence.
+        const winner = group[group.length - 1];
+        // The id comes from whichever tier carries one, because `stamp-ids` has not
+        // reached the org and manager pack homes for every corpus yet. Latest wins
+        // when more than one tier is stamped.
+        const id = group.reduce((found, entry) => entry.id ?? found, null);
+        out.push({
+            ...winner,
+            id,
+            key: (0, learning_usage_store_1.resolveEntryIdentity)({ id, fileType: winner.fileType, title: winner.title }).key,
+        });
+    }
+    return out;
 }
 /**
  * Issue #1103 R3: the auto-loaded Team Context rule files.

package/dist/src/local-mcp-server/learning-usage-events.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEventDir = resolveEventDir;
+exports.resolveMachineId = resolveMachineId;
+exports.appendEvents = appendEvents;
+exports.listEventLogs = listEventLogs;
+exports.readEventsSince = readEventsSince;
+exports.compactEventLogs = compactEventLogs;
+/**
+ * Issue #1752 — the durable half of the usage record.
+ *
+ * The store used to be one mutable JSON document rewritten by every writer with a
+ * plain `writeFileSync`. Measured (spike S1b): eight concurrent processes doing
+ * that on a *plain local disk*, no sync folder involved, lost 1589 of 1600
+ * writes. The four OneDrive conflict copies in issue #1752 are a symptom of the
+ * same defect, not its cause.
+ *
+ * So the durable artifact is an append-only log, one file per machine:
+ *
+ *   OFFER/FIRING event  →  appendFileSync of one whole JSON line
+ *   usage/learning-usage.json  →  a derived snapshot with a byte checkpoint
+ *
+ * Three measurements decided the shape, and each closed off an alternative:
+ *
+ *   S2   16 processes x 1000 lines on the real OneDrive-synced path produced
+ *        16000/16000 complete parseable lines, 0 interleaved, 0 conflict copies.
+ *        That is what removes the need for a same-machine lock. The per-machine
+ *        filename is what removes the cross-machine question, because two
+ *        machines then never write one file.
+ *   S3   `renameSync` over a target any process holds open fails EPERM 100 times
+ *        in 100 on Windows, on a synced path *and* a local one, because Node's
+ *        `openSync(path,'r')` does not request FILE_SHARE_DELETE. The usage store
+ *        is read by concurrent MCP processes by design, so rename-publish is not
+ *        available here. Recorded so it is not re-proposed. See also #820.
+ *   S4b  A full fold is linear: 84 ms at today's volume, 794 ms at ten times it.
+ *        A snapshot plus a tail fold is 2.6 ms at both 9.9 MB and 79 MB. Flat.
+ *
+ * This module owns the log files and nothing else: framing, appending, reading a
+ * tail from a byte offset, and compaction. It knows a line is a JSON object and
+ * knows nothing about what a usage record looks like. That is deliberate — the
+ * record shape lives in `learning-usage-store.ts`, which imports this, so there
+ * is no cycle between them.
+ *
+ * The same primitive is already used by `src/ai-hub/raw-event-log-store.ts`
+ * (append one JSON line, track byte offsets); this is the learning-usage
+ * equivalent rather than a second general mechanism.
+ */
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+/** Subdirectory of the usage folder holding the per-machine logs. */
+const EVENT_DIR_NAME = 'events';
+const LOG_SUFFIX = '.jsonl';
+/** The log directory that belongs to a snapshot: `<usage>/events/`. */
+function resolveEventDir(snapshotPath) {
+    return (0, path_1.join)((0, path_1.dirname)(snapshotPath), EVENT_DIR_NAME);
+}
+/**
+ * The filename component identifying this machine. Two machines must never write
+ * one file, which is the entire cross-machine safety argument, so anything that
+ * is not a safe filename character is replaced rather than dropped (dropping can
+ * collide two different hostnames onto one name).
+ */
+function resolveMachineId() {
+    const raw = (() => { try {
+        return (0, os_1.hostname)();
+    }
+    catch {
+        return '';
+    } })();
+    const safe = String(raw || 'unknown-machine').trim().replace(/[^A-Za-z0-9._-]/g, '_');
+    return safe || 'unknown-machine';
+}
+function logPathFor(eventDir, machineId) {
+    return (0, path_1.join)(eventDir, `${machineId}${LOG_SUFFIX}`);
+}
+/**
+ * Append one JSON line per record. No read, so there is no lost-update window to
+ * narrow: the window is gone rather than smaller.
+ */
+function appendEvents(eventDir, records, machineId = resolveMachineId()) {
+    if (records.length === 0)
+        return 0;
+    (0, fs_1.mkdirSync)(eventDir, { recursive: true });
+    const logPath = logPathFor(eventDir, machineId);
+    const separator = endsOnARecordBoundary(logPath) ? '' : '\n';
+    const payload = `${separator}${records.map((record) => JSON.stringify(record)).join('\n')}\n`;
+    (0, fs_1.appendFileSync)(logPath, payload, 'utf8');
+    return records.length;
+}
+/**
+ * Does the log already end where a record ends?
+ *
+ * A process killed part-way through an append leaves a line with no terminator.
+ * Appending straight onto it concatenates the torn record and the new one into a
+ * single unparseable line, so one interrupted write costs two events rather than
+ * one. Found in the #1752 bug bash. Closing the boundary first means a torn write
+ * loses only itself.
+ *
+ * One byte read per append, and only when the log already exists.
+ */
+function endsOnARecordBoundary(logPath) {
+    try {
+        const fd = (0, fs_1.openSync)(logPath, 'r');
+        try {
+            const size = (0, fs_1.fstatSync)(fd).size;
+            if (size === 0)
+                return true;
+            const last = Buffer.alloc(1);
+            (0, fs_1.readSync)(fd, last, 0, 1, size - 1);
+            return last[0] === 0x0a;
+        }
+        finally {
+            (0, fs_1.closeSync)(fd);
+        }
+    }
+    catch {
+        // No log yet, or it cannot be read. A fresh file starts on a boundary, and an
+        // unreadable one is the fold's problem rather than the append's.
+        return true;
+    }
+}
+function listEventLogs(eventDir) {
+    if (!(0, fs_1.existsSync)(eventDir))
+        return [];
+    let names;
+    try {
+        names = (0, fs_1.readdirSync)(eventDir);
+    }
+    catch {
+        return [];
+    }
+    const logs = [];
+    for (const name of names) {
+        if (!name.endsWith(LOG_SUFFIX))
+            continue;
+        const path = (0, path_1.join)(eventDir, name);
+        let size = 0;
+        try {
+            const fd = (0, fs_1.openSync)(path, 'r');
+            try {
+                size = (0, fs_1.fstatSync)(fd).size;
+            }
+            finally {
+                (0, fs_1.closeSync)(fd);
+            }
+        }
+        catch {
+            continue;
+        }
+        logs.push({ machineId: name.slice(0, -LOG_SUFFIX.length), path, size });
+    }
+    return logs.sort((a, b) => a.machineId.localeCompare(b.machineId));
+}
+function readTail(log, from) {
+    const restarted = from > log.size;
+    const start = restarted ? 0 : Math.max(0, from);
+    const length = log.size - start;
+    if (length <= 0) {
+        return { ...log, records: [], skippedLines: 0, through: start, restarted };
+    }
+    let text;
+    try {
+        const fd = (0, fs_1.openSync)(log.path, 'r');
+        try {
+            const buffer = Buffer.alloc(length);
+            const read = (0, fs_1.readSync)(fd, buffer, 0, length, start);
+            text = buffer.subarray(0, read).toString('utf8');
+        }
+        finally {
+            (0, fs_1.closeSync)(fd);
+        }
+    }
+    catch {
+        // Unreadable right now (locked, mid-sync). The checkpoint does not advance,
+        // so the next reader picks it up. Degrading to what is readable is the
+        // existing contract for this derived data.
+        return { ...log, records: [], skippedLines: 0, through: start, restarted };
+    }
+    // Only complete lines are consumed. A trailing partial is what an interrupted
+    // append leaves behind, and advancing past it would lose the record for good.
+    const lastNewline = text.lastIndexOf('\n');
+    if (lastNewline === -1) {
+        return { ...log, records: [], skippedLines: 0, through: start, restarted };
+    }
+    const complete = text.slice(0, lastNewline);
+    const partialBytes = Buffer.byteLength(text.slice(lastNewline + 1), 'utf8');
+    const records = [];
+    let skippedLines = 0;
+    for (const line of complete.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                records.push(parsed);
+            else
+                skippedLines += 1;
+        }
+        catch {
+            skippedLines += 1;
+        }
+    }
+    return { ...log, records, skippedLines, through: log.size - partialBytes, restarted };
+}
+/**
+ * Read every log's tail past its checkpoint.
+ *
+ * A checkpoint past the end of its log means the log was compacted or replaced
+ * underneath the snapshot. `restarted` says so, and the caller discards the whole
+ * snapshot rather than returning a short count that looks like real data.
+ */
+function readEventsSince(eventDir, checkpoints) {
+    const reads = listEventLogs(eventDir).map((log) => readTail(log, checkpoints[log.machineId] ?? 0));
+    return {
+        reads,
+        skippedLines: reads.reduce((sum, r) => sum + r.skippedLines, 0),
+        restarted: reads.some((r) => r.restarted),
+    };
+}
+/**
+ * Rewrite every log keeping only the records `keep` accepts.
+ *
+ * Required rather than an optimization: S4 measured a cold full fold growing
+ * linearly to 794 ms at ten times today's volume, and the checkpoint only makes a
+ * cold fold rare, not bounded.
+ *
+ * Published by writing a temp file and renaming it. That is safe here and not on
+ * the snapshot (S3), because nothing holds a compacted log open for reading in
+ * the way concurrent MCP processes hold the snapshot: this runs from the CLI, and
+ * a failed rename leaves the original log untouched.
+ */
+function compactEventLogs(eventDir, keep) {
+    const result = { scanned: 0, kept: 0, dropped: 0, skippedLines: 0, logs: [] };
+    for (const log of listEventLogs(eventDir)) {
+        const read = readTail(log, 0);
+        result.scanned += read.records.length;
+        result.skippedLines += read.skippedLines;
+        const retained = read.records.filter(keep);
+        result.kept += retained.length;
+        result.dropped += read.records.length - retained.length;
+        if (retained.length === read.records.length && read.skippedLines === 0)
+            continue;
+        const temp = `${log.path}.compacting`;
+        try {
+            (0, fs_1.writeFileSync)(temp, retained.length ? `${retained.map((r) => JSON.stringify(r)).join('\n')}\n` : '', 'utf8');
+            (0, fs_1.renameSync)(temp, log.path);
+        }
+        catch {
+            // The log is authoritative and the original is still intact, so a failed
+            // compaction costs a slower cold fold and nothing else.
+            try {
+                (0, fs_1.rmSync)(temp, { force: true });
+            }
+            catch { /* best effort */ }
+        }
+    }
+    result.logs = listEventLogs(eventDir);
+    return result;
+}

package/dist/src/local-mcp-server/learning-usage-projection.js

@@ -50,30 +50,34 @@ function buildUsageLookup(store) {
 /**
  * Resolve the usage for one entry from whichever handles it has. Prefers the id,
  * because a title is only a fallback for entries the id migration has not reached.
+ *
+ * Issue #1752 A1: the preference order is `resolveEntryIdentity`'s, not a second
+ * copy of it. The title key is still tried afterwards, because a record written
+ * before the entry was stamped is reachable only by title.
  */
 function lookupUsage(lookup, id, fileType, title) {
-    if (id) {
-        const byId = lookup.get(id);
-        if (byId)
-            return byId;
-    }
-    return lookup.get((0, learning_usage_store_1.titleUsageKey)(fileType, title));
+    const identity = (0, learning_usage_store_1.resolveEntryIdentity)({ id, fileType, title });
+    const resolved = lookup.get(identity.key);
+    if (resolved)
+        return resolved;
+    return identity.source === 'id' ? lookup.get((0, learning_usage_store_1.titleUsageKey)(fileType, title)) : undefined;
 }
 /**
- * The model with the most recent offer. Used as "the current model" for the
- * per-model retirement question, so it follows the agent in use rather than
- * needing to be configured.
+ * Issue #1752 C1 — "the current model" comes from the caller, never from the store.
+ *
+ * This used to return the model of the globally most-recent offer. The store is
+ * shared by concurrent sessions from two machines and two agents, so that reports
+ * whichever agent wrote last. On the sleep-on-learnings run of 2026-09-18 it
+ * answered `gpt-5` while the session was Claude Opus 5, and since retirement
+ * candidacy is computed per model, every per-model conclusion in that run was
+ * computed against a model that was not running.
+ *
+ * Resolution order is the explicit flag, then `FRAIM_ACTIVE_MODEL`, then null.
+ * That follows the existing `FRAIM_ACTIVE_USER_EMAIL` convention, which is
+ * read-only and operator-set, so it introduces no new configuration mechanism.
+ * Null is reported as `unknown` and suppresses every per-model conclusion rather
+ * than being computed against a null bucket.
  */
-function resolveCurrentModel(store) {
-    let bestDate = '';
-    let bestModel = null;
-    for (const record of Object.values(store.entries)) {
-        for (const entry of record.offered.log) {
-            if (entry.model && entry.date >= bestDate) {
-                bestDate = entry.date;
-                bestModel = entry.model;
-            }
-        }
-    }
-    return bestModel;
+function resolveCurrentModel(explicit) {
+    return (0, learning_usage_store_1.normalizeModelName)(explicit) ?? (0, learning_usage_store_1.normalizeModelName)(process.env.FRAIM_ACTIVE_MODEL);
 }