fraim 2.0.339 → 2.0.341

package/dist/src/core/run-recovery-state.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeRunStateKey = safeRunStateKey;
+const crypto_1 = require("crypto");
+/** UUIDs retain their documented filenames; other IDs cannot become paths or device names. */
+function safeRunStateKey(id) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)
+        ? id : `id-${(0, crypto_1.createHash)('sha256').update(id).digest('hex')}`;
+}

package/dist/src/local-mcp-server/artifact-retention-cleanup.js

@@ -28,9 +28,14 @@ exports.ARTIFACT_RETENTION_CATEGORIES = [
     'learning_usage',
     'hub_event_logs',
 ];
+function contentRoot(workspaceRoot) {
+    const packContent = node_path_1.default.join(workspaceRoot, 'personalized-employee');
+    return node_fs_1.default.existsSync(packContent) ? packContent : node_path_1.default.join(workspaceRoot, 'fraim', 'personalized-employee');
+}
 function readWorkspaceConfig(workspaceRoot) {
     try {
-        const configPath = (0, project_fraim_paths_1.getWorkspaceConfigPath)(workspaceRoot);
+        const configPath = contentRoot(workspaceRoot) === node_path_1.default.join(workspaceRoot, 'personalized-employee')
+            ? node_path_1.default.join(workspaceRoot, 'config.json') : (0, project_fraim_paths_1.getWorkspaceConfigPath)(workspaceRoot);
         if (!node_fs_1.default.existsSync(configPath))
             return {};
         return JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
@@ -143,7 +148,7 @@ function loadGitLastChangeDates(workspaceRoot, relativeDir) {
     return dates;
 }
 function readFrontmatter(content) {
-    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    const match = content.match(/^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---/);
     if (!match)
         return {};
     const values = {};
@@ -167,8 +172,20 @@ function synthesizedDate(absolutePath) {
         return undefined;
     }
 }
-function userScoped(fileName, activeUserEmail) {
-    return fileName.startsWith(`${activeUserEmail}-`);
+function userScoped(filePath, activeUserEmail) {
+    try {
+        const body = node_fs_1.default.readFileSync(filePath, 'utf8');
+        const author = readFrontmatter(body).author;
+        if (author !== undefined) {
+            const value = author.replace(/^(?:"([^"]*)"|'([^']*)')$/, (_match, double, single) => double ?? single);
+            return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) && value === activeUserEmail;
+        }
+        // Older artifacts used the author in their filename.
+        return node_path_1.default.basename(filePath).startsWith(`${activeUserEmail}-`);
+    }
+    catch {
+        return false;
+    }
 }
 function evidenceEligibilityDate(workspaceRoot, absolutePath, gitDates) {
     const relativePath = normalizeRelative(workspaceRoot, absolutePath);
@@ -187,17 +204,22 @@ function collectCandidates(workspaceRoot, options) {
             eligibilityDate,
         });
     };
-    const archiveDir = node_path_1.default.join(workspaceRoot, 'fraim', 'personalized-employee', 'learnings', 'archive');
+    const content = contentRoot(workspaceRoot);
+    const archiveDir = node_path_1.default.join(content, 'learnings', 'archive');
     for (const filePath of listFiles(archiveDir)) {
         const fileName = node_path_1.default.basename(filePath);
-        if (!fileName.endsWith('.md') || !userScoped(fileName, activeUserEmail))
+        if (!fileName.endsWith('.md') || !userScoped(filePath, activeUserEmail))
             continue;
         add('learning_archive', filePath, true, 'Archived learning source for active user.', fileMtime(filePath));
     }
-    const retrospectivesDir = node_path_1.default.join(workspaceRoot, 'docs', 'retrospectives');
-    for (const filePath of listFiles(retrospectivesDir)) {
+    const retrospectives = new Set([
+        node_path_1.default.join(workspaceRoot, 'docs', 'retrospectives'),
+        node_path_1.default.join(workspaceRoot, 'retrospectives'),
+        node_path_1.default.join(content, 'retrospectives'),
+    ].flatMap(listFiles));
+    for (const filePath of retrospectives) {
         const fileName = node_path_1.default.basename(filePath);
-        if (!fileName.endsWith('.md') || !userScoped(fileName, activeUserEmail))
+        if (!fileName.endsWith('.md') || !userScoped(filePath, activeUserEmail))
             continue;
         const date = synthesizedDate(filePath);
         if (date)
@@ -209,6 +231,11 @@ function collectCandidates(workspaceRoot, options) {
     const evidenceGitDates = loadGitLastChangeDates(workspaceRoot, 'docs/evidence');
     for (const filePath of listFiles(evidenceDir)) {
         const fileName = node_path_1.default.basename(filePath);
+        // A surviving run journal is unfinished recovery; completion removes it.
+        if (fileName.endsWith('.queue.jsonl')) {
+            add('evidence', filePath, false, 'Unfinished Sleep run journal; removed by run completion.');
+            continue;
+        }
         const isMarkdown = fileName.endsWith('.md');
         const isJson = fileName.endsWith('.json');
         const eligibilityDate = evidenceEligibilityDate(workspaceRoot, filePath, evidenceGitDates);

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

@@ -24,7 +24,9 @@ exports.readOrgBrand = readOrgBrand;
 exports.resolveOrgBrandWriteDir = resolveOrgBrandWriteDir;
 exports.countPreservedLearnings = countPreservedLearnings;
 exports.collectBrainLearningDots = collectBrainLearningDots;
+exports.readRejectedProposals = readRejectedProposals;
 exports.readPreservedLearnings = readPreservedLearnings;
+exports.normalizeLearningDomain = normalizeLearningDomain;
 exports.applyLearningEntryChange = applyLearningEntryChange;
 exports.isTruthyFlag = isTruthyFlag;
 const fs_1 = require("fs");
@@ -496,6 +498,15 @@ function scanMistakePatternFile(filePath, threshold, fileType = 'mistake-pattern
  * behaviour instead of merely equivalent.
  */
 function resolveUsageClock(workspaceRoot) {
+    return resolveUsageViews(workspaceRoot).clock;
+}
+/**
+ * Issue #1755: one store read, two views of it: the clock the scorer needs and
+ * the counters a surface renders. They are resolved together because reading the
+ * store twice for the same pass would let the two disagree, and because the
+ * identity resolution that finds a record is the projection's, not each caller's.
+ */
+function resolveUsageViews(workspaceRoot) {
     try {
         // Required lazily: the store imports the retention config, which imports the
         // workspace path helpers, and a cycle through this module would be fragile.
@@ -503,14 +514,31 @@ function resolveUsageClock(workspaceRoot) {
         const projection = require('./learning-usage-projection');
         const loaded = store.readUsageStore();
         if (Object.keys(loaded.entries).length === 0)
-            return undefined;
+            return {};
         const lookup = projection.buildUsageLookup(loaded);
-        return (id, fileType, title) => projection.lookupUsage(lookup, id, fileType, title)?.lastFired ?? null;
+        return {
+            clock: (id, fileType, title) => projection.lookupUsage(lookup, id, fileType, title)?.lastFired ?? null,
+            stats: (id, fileType, title) => {
+                const found = projection.lookupUsage(lookup, id, fileType, title);
+                if (!found)
+                    return null;
+                return {
+                    offered: found.offered,
+                    offeredAboveThreshold: found.offeredAboveThreshold,
+                    applied: found.byOutcome.applied || 0,
+                    prevented: found.byOutcome.prevented || 0,
+                    ignored: found.byOutcome.ignored || 0,
+                    notApplicable: found.byOutcome['not-applicable'] || 0,
+                    lastOfferedAt: found.lastOffered,
+                    lastFiredAt: found.lastFired,
+                };
+            },
+        };
     }
     catch {
         // Usage data is derived and optional. A failure here must never change what
         // the agent is given.
-        return undefined;
+        return {};
     }
 }
 function readFrontmatter(content) {
@@ -552,6 +580,34 @@ function pendingL0SortKey(fileName) {
     const timestamp = fileName.match(/\d{4}-\d{2}-\d{2}(?:T\d{2}-\d{2}-\d{2})?/);
     return timestamp?.[0] || fileName;
 }
+/**
+ * Issue #1857 R11: how many proposals are waiting for the manager's review.
+ *
+ * This counts directory entries and nothing else. It does not open a proposal, and
+ * deliberately has no access to one: R10 is an invariant about influence rather
+ * than storage, so the employee learns that a backlog exists and which job clears
+ * it, never what any pending claim says.
+ *
+ * The same shape as the pending-L0 line it sits beside, for the same reason: a
+ * count plus the job that clears it is actionable; a list of contents is not.
+ */
+function countPendingProposals(roots, resolvedUserId) {
+    let total = 0;
+    for (const base of [roots.repoLearningsBase, roots.globalPersonalBase]) {
+        if (!base)
+            continue;
+        const queueDir = (0, path_1.join)(base, 'review-queue', resolvedUserId);
+        if (!(0, fs_1.existsSync)(queueDir))
+            continue;
+        try {
+            total += (0, fs_1.readdirSync)(queueDir).filter((name) => name.endsWith('.json')).length;
+        }
+        catch {
+            // An unreadable queue is not worth failing a job's startup over.
+        }
+    }
+    return total;
+}
 function collectPendingL0SourceFiles(workspaceRoot, resolvedUserId, roots) {
     const sources = [];
     const rawPath = (0, path_1.join)(roots.repoLearningsBase, 'raw');
@@ -796,7 +852,11 @@ function buildLearningContextSection(workspaceRoot, userId, forJob, domain) {
     const l0RetroCount = pendingL0Sources.filter(source => source.kind === 'retrospective').length;
     const hasL2 = l2Files.length > 0;
     const hasL1 = l1Files.length > 0;
-    const hasContent = hasL2 || hasL1 || l0CoachingCount > 0 || l0RetroCount > 0;
+    // Issue #1857 R11. Counted before the gate on purpose: a manager with a full
+    // review queue and an empty corpus is exactly the case where the backlog most
+    // needs saying, and computing it after the early return would silence it there.
+    const pendingProposals = countPendingProposals(roots, resolvedUserId);
+    const hasContent = hasL2 || hasL1 || l0CoachingCount > 0 || l0RetroCount > 0 || pendingProposals > 0;
     if (!hasContent)
         return '';
     let section = forJob
@@ -835,6 +895,13 @@ function buildLearningContextSection(workspaceRoot, userId, forJob, domain) {
         }
         section += '\n';
     }
+    // Issue #1857 R11. The count, never the content: an unapproved proposal does
+    // not influence this job, and the employee is told only that the manager has a
+    // backlog and which job clears it.
+    if (pendingProposals > 0) {
+        const plural = pendingProposals !== 1;
+        section += `${pendingProposals} proposal${plural ? 's are' : ' is'} waiting for your manager's review; run \`sleep-on-learnings\` to review ${plural ? 'them' : 'it'}.\n\n`;
+    }
     const coachPresent = resolved.coachPresent;
     if (forJob) {
         if (hasL2 || hasL1) {
@@ -1216,7 +1283,7 @@ function isTeamContextKey(value) {
  *   user-level `~/.fraim/…` path (where org onboarding writes).
  * - Project scope (projectContext/projectBrief/projectRules/projectQa): repo-local only.
  */
-function resolveTeamContextFile(workspaceRoot, key) {
+function resolveTeamContextFile(workspaceRoot, key, options = {}) {
     const { relativePath, scope } = TEAM_CONTEXT_FILE_MAP[key];
     const repoPath = (0, path_1.join)((0, project_fraim_paths_1.getWorkspaceFraimDir)(workspaceRoot), 'personalized-employee', relativePath);
     const repoDisplay = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)(`personalized-employee/${relativePath}`);
@@ -1245,7 +1312,7 @@ function resolveTeamContextFile(workspaceRoot, key) {
     // destination (R5.1), so writePath stays empty and the caller must route
     // edits through the org backend's propose-and-approve flow.
     if (key === 'org' || key === 'orgRules') {
-        const cachePath = (0, path_1.join)((0, pack_home_1.resolvePackHome)('org').contentRoot, relativePath);
+        const cachePath = (0, path_1.join)((0, pack_home_1.resolvePackHome)('org', options).contentRoot, relativePath);
         if ((0, fs_1.existsSync)(cachePath)) {
             const fraimDir = (0, project_fraim_paths_1.getUserFraimDirPath)();
             const orgDisplayPath = cachePath.startsWith(fraimDir)
@@ -1262,7 +1329,7 @@ function resolveTeamContextFile(workspaceRoot, key) {
         }
     }
     if (key === 'manager' || key === 'managerRules') {
-        const managerHome = (0, pack_home_1.resolvePackHome)('manager');
+        const managerHome = (0, pack_home_1.resolvePackHome)('manager', options);
         const managerCachePath = (0, path_1.join)(managerHome.contentRoot, relativePath);
         if ((0, fs_1.existsSync)(managerCachePath)) {
             const fraimDir = (0, project_fraim_paths_1.getUserFraimDirPath)();
@@ -1697,7 +1764,7 @@ function listDomainLearningFiles(dir, prefix, fileType) {
 // threshold: entries with score >= threshold (or in a non-gated category) are
 //   marked injected:true. Callers that don't need scoring pass Infinity so
 //   all entries are injected.
-function parseLearningEntries(filePath, displayPath, category, level, domain = 'global', tier, threshold = exports.DEFAULT_THRESHOLD, usageClock) {
+function parseLearningEntries(filePath, displayPath, category, level, domain = 'global', tier, threshold = exports.DEFAULT_THRESHOLD, usageClock, usageStats) {
     if (!(0, fs_1.existsSync)(filePath))
         return [];
     let content;
@@ -1719,6 +1786,10 @@ function parseLearningEntries(filePath, displayPath, category, level, domain = '
     const flush = () => {
         if (current) {
             current.body = bodyLines.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+            // Issue #1755: resolve usage once per entry, before scoring, so the
+            // counters a surface renders and the clock the score uses come from
+            // the same record rather than two independent lookups.
+            current.usage = usageStats ? usageStats(current.id, fileType, current.title) : null;
             if (isScoreGated) {
                 if (curLastSeen !== null) {
                     const lastFired = usageClock ? usageClock(current.id, fileType, current.title) : null;
@@ -1753,7 +1824,7 @@ function parseLearningEntries(filePath, displayPath, category, level, domain = '
                 title: header[2].trim(),
                 id: null,
                 body: '', source: displayPath, category, level, domain,
-                score: null, injected: true,
+                score: null, injected: true, usage: null,
             };
             if (tier !== undefined)
                 entry.tier = tier;
@@ -1794,18 +1865,106 @@ function parseLearningEntries(filePath, displayPath, category, level, domain = '
     flush();
     return out;
 }
+/**
+ * Read the rejection history a sleep run writes on completion.
+ *
+ * The file is a sequence of `<!-- sleep-rejection:run:action:revision -->` blocks,
+ * each holding a heading, the manager's reason, an optional revisit condition and
+ * the rejected proposal as JSON. `run-application.ts` writes it; this reads it
+ * back without changing a byte, because the file is also a synthesis input and a
+ * reader that rewrote it would corrupt the next run's history.
+ *
+ * A malformed block is skipped rather than failing the whole read: the manager
+ * losing the view of every rejection because one block is damaged is worse than
+ * the view missing that one.
+ */
+function readRejectedProposals(workspaceRoot, userId) {
+    const roots = getLearningRoots(workspaceRoot);
+    const resolvedUserId = resolveLearningUserId(workspaceRoot, userId, roots);
+    if (!resolvedUserId)
+        return [];
+    const out = [];
+    const seen = new Set();
+    const headingRe = /^## (Rejected|Superseded): (.+)$/m;
+    const reasonRe = /^Reason: (.+)$/m;
+    const revisitRe = /^Revisit when: (.+)$/m;
+    const jsonRe = /```json\r?\n([\s\S]*?)\r?\n```/;
+    for (const base of [roots.repoLearningsBase, roots.globalPersonalBase, roots.managerCacheBase]) {
+        if (!base)
+            continue;
+        const file = (0, path_1.join)(base, `${resolvedUserId}-rejected-proposals.md`);
+        if (!(0, fs_1.existsSync)(file))
+            continue;
+        let body;
+        try {
+            body = (0, fs_1.readFileSync)(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const displayPath = file.split('\\').join('/');
+        for (const raw of body.split('<!-- sleep-rejection:').slice(1)) {
+            const end = raw.indexOf('<!-- /sleep-rejection -->');
+            const chunk = end >= 0 ? raw.slice(0, end) : raw;
+            const marker = chunk.slice(0, Math.max(0, chunk.indexOf('-->')));
+            const parts = marker.trim().split(':');
+            const heading = headingRe.exec(chunk);
+            const reason = reasonRe.exec(chunk);
+            const revisit = revisitRe.exec(chunk);
+            const json = jsonRe.exec(chunk);
+            if (!heading || !reason)
+                continue;
+            let proposal = {};
+            if (json) {
+                try {
+                    proposal = JSON.parse(json[1]);
+                }
+                catch {
+                    // Keep the human-readable half; the JSON only enriches it.
+                }
+            }
+            const decision = (proposal.decision || {});
+            const content = (proposal.content || {});
+            const trace = (content.trace || {});
+            const claimKey = typeof proposal.claimKey === 'string' && proposal.claimKey
+                ? proposal.claimKey
+                : parts[1] || heading[2];
+            // The same claim can appear in more than one configured base. The first
+            // base that carries it wins, matching how the tier merge resolves.
+            const key = `${claimKey}:${String(decision.at || '')}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({
+                claimKey,
+                title: heading[2].trim(),
+                reason: reason[1].trim(),
+                ...(revisit ? { revisitCondition: revisit[1].trim() } : {}),
+                // The heading and the stored decision agree; the heading is what a
+                // manager reading the file sees, so it is the one that governs here.
+                kind: heading[1] === 'Superseded' || decision.kind === 'superseded' ? 'superseded' : 'refused',
+                rejectedAt: typeof decision.at === 'string' ? decision.at : '',
+                ...(typeof trace.recurrences === 'number' ? { recurrencesAtRejection: trace.recurrences } : {}),
+                displayPath,
+            });
+        }
+    }
+    // Newest first: the manager is most often checking what they just said no to.
+    return out.sort((a, b) => String(b.rejectedAt).localeCompare(String(a.rejectedAt)));
+}
 function readPreservedLearnings(workspaceRoot, userId, scope, level = 'machine') {
     const roots = getLearningRoots(workspaceRoot);
     const threshold = getScoreThreshold(workspaceRoot);
     // Issue #1103 R8: the Hub's injected flag must agree with the loader's, so both
     // read the same clock. One store read serves the whole call.
-    const usageClock = resolveUsageClock(workspaceRoot);
+    // Issue #1755: the same read also yields the counters the Hub renders.
+    const { clock: usageClock, stats: usageStats } = resolveUsageViews(workspaceRoot);
     const out = [];
     // Helper: parse + merge a list of tier paths for one file family.
     // ResolvedLearningTier uses 'manager' to mean machine-level personal; map it to 'machine'.
     const tierLevel = (t) => t.level === 'manager' ? 'machine' : t.level;
     const parseTiers = (tiers, cat, tierVal, domainVal) => mergeLearningEntriesAcrossTiers(tiers.map((t) => ({
-        entries: parseLearningEntries(t.path, t.displayPath, cat, tierLevel(t), domainVal ?? 'global', tierVal, threshold, usageClock),
+        entries: parseLearningEntries(t.path, t.displayPath, cat, tierLevel(t), domainVal ?? 'global', tierVal, threshold, usageClock, usageStats),
     })));
     if (scope === 'org') {
         for (const cat of ['avoid', 'preference', 'repeat', 'coaching']) {
@@ -1826,7 +1985,7 @@ function readPreservedLearnings(workspaceRoot, userId, scope, level = 'machine')
                 seenDomainFile.add(fileName);
                 const domainTiers = resolveOrgLearningFileTiers(roots.repoLearningsBase, fileName);
                 if (domainTiers.length === 0) {
-                    out.push(...parseLearningEntries((0, path_1.join)(base, fileName), `${REPO_LEARNINGS_REL}/${fileName}`, cat, 'org', domain, undefined, threshold));
+                    out.push(...parseLearningEntries((0, path_1.join)(base, fileName), `${REPO_LEARNINGS_REL}/${fileName}`, cat, 'org', domain, undefined, threshold, usageClock, usageStats));
                 }
                 else {
                     out.push(...parseTiers(domainTiers, cat, undefined, domain));
@@ -1843,13 +2002,13 @@ function readPreservedLearnings(workspaceRoot, userId, scope, level = 'machine')
         for (const cat of cats) {
             const fileType = exports.CATEGORY_TO_FILETYPE[cat];
             const f = `${resolvedUserId}-${fileType}.md`;
-            out.push(...parseLearningEntries((0, path_1.join)(roots.repoLearningsBase, f), `${REPO_LEARNINGS_REL}/${f}`, cat, 'project', 'global', 'hot', threshold));
+            out.push(...parseLearningEntries((0, path_1.join)(roots.repoLearningsBase, f), `${REPO_LEARNINGS_REL}/${f}`, cat, 'project', 'global', 'hot', threshold, usageClock, usageStats));
             const coldF = `${resolvedUserId}-${fileType}${COLD_FILE_SUFFIX}.md`;
             if ((0, fs_1.existsSync)((0, path_1.join)(roots.repoLearningsBase, coldF))) {
-                out.push(...parseLearningEntries((0, path_1.join)(roots.repoLearningsBase, coldF), `${REPO_LEARNINGS_REL}/${coldF}`, cat, 'project', 'global', 'cold', threshold));
+                out.push(...parseLearningEntries((0, path_1.join)(roots.repoLearningsBase, coldF), `${REPO_LEARNINGS_REL}/${coldF}`, cat, 'project', 'global', 'cold', threshold, usageClock, usageStats));
             }
             for (const { fileName, domain } of listDomainLearningFiles(roots.repoLearningsBase, resolvedUserId, fileType)) {
-                out.push(...parseLearningEntries((0, path_1.join)(roots.repoLearningsBase, fileName), `${REPO_LEARNINGS_REL}/${fileName}`, cat, 'project', domain, 'hot', threshold));
+                out.push(...parseLearningEntries((0, path_1.join)(roots.repoLearningsBase, fileName), `${REPO_LEARNINGS_REL}/${fileName}`, cat, 'project', domain, 'hot', threshold, usageClock, usageStats));
             }
         }
         return out;
@@ -1880,6 +2039,25 @@ function readPreservedLearnings(workspaceRoot, userId, scope, level = 'machine')
     }
     return out;
 }
+/** True for a domain value that means "the undecorated global file". */
+function isGlobalDomain(domain) {
+    return !domain || domain === 'global';
+}
+/** Normalize a caller-supplied domain to one of the known domains, or 'global'. */
+function normalizeLearningDomain(domain) {
+    if (isGlobalDomain(domain))
+        return 'global';
+    const found = learning_domains_1.LEARNING_DOMAINS.find((d) => d === domain);
+    return found ?? 'global';
+}
+function learningFileName(userId, fileType, domain) {
+    // Issue #1755 / #754: normalize here rather than trusting the caller. The HTTP
+    // layer already allowlists the domain, but this function builds a path and a
+    // direct caller passing `../../escape` would otherwise write outside the
+    // learnings root. Anything not in the known set resolves to the global file.
+    const safe = normalizeLearningDomain(domain);
+    return safe === 'global' ? `${userId}-${fileType}.md` : `${userId}-${safe}-${fileType}.md`;
+}
 function resolveLearningFilePath(workspaceRoot, userId, ref) {
     const roots = getLearningRoots(workspaceRoot);
     const fileType = exports.CATEGORY_TO_FILETYPE[ref.category];
@@ -1887,12 +2065,12 @@ function resolveLearningFilePath(workspaceRoot, userId, ref) {
         // Write org entries to the org pack home — same location share-with-others uses.
         // The Hub read path already merges pack home + repo-local, so edits land where
         // the agent reads them without needing a repo commit.
-        return (0, path_1.join)((0, pack_home_1.resolvePackHome)('org').contentRoot, 'learnings', `org-${fileType}.md`);
+        return (0, path_1.join)((0, pack_home_1.resolvePackHome)('org').contentRoot, 'learnings', learningFileName('org', fileType, ref.domain));
     }
     const resolvedUserId = resolveLearningUserId(workspaceRoot, userId, roots);
     // Issue #1070: for the 'machine' level use the configured manager home.
     const base = ref.level === 'project' ? roots.repoLearningsBase : roots.managerHomeBase;
-    return (0, path_1.join)(base, `${resolvedUserId}-${fileType}.md`);
+    return (0, path_1.join)(base, learningFileName(resolvedUserId, fileType, ref.domain));
 }
 function titleCaseFromFileType(fileType) {
     return fileType.split('-').map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
@@ -1916,9 +2094,10 @@ function applyLearningEntryChange(workspaceRoot, userId, ref, action, payload) {
         const body = String(payload.body || '').trim();
         const block = [`#### [${sev}] ${title}`, '', body, '', '---'].join(nl);
         const fileType = exports.CATEGORY_TO_FILETYPE[ref.category];
+        const addDomain = normalizeLearningDomain(ref.domain);
         const preamble = existing.trim()
             ? existing.replace(/\s*$/, '')
-            : `# ${ref.scope === 'org' ? 'Org ' : ''}${titleCaseFromFileType(fileType)}`;
+            : `# ${ref.scope === 'org' ? 'Org ' : ''}${titleCaseFromFileType(fileType)}${addDomain === 'global' ? '' : ` (${addDomain})`}`;
         write(preamble + nl + nl + block);
         return { ok: true, path: filePath };
     }
@@ -1935,8 +2114,12 @@ function applyLearningEntryChange(workspaceRoot, userId, ref, action, payload) {
         write(next.join(nl).replace(/\n{3,}/g, '\n\n'));
         return { ok: true, path: filePath };
     }
-    // edit: keep the entry's metadata lines (Score/Last seen/Recurrences/...) intact,
+    // edit: keep the entry's metadata lines (Id/Score/Last seen/Recurrences/...) intact,
     // replace only the heading (priority + title) and the prose body.
+    //
+    // Issue #1755: `Id` is in this list. It used not to be, so every Hub edit dropped
+    // the entry's stable identifier and the usage record keyed to it (#1752) was
+    // orphaned: silently, and permanently once the title also changed.
     const headerMatch = lines[start].match(headingRe);
     const sev = (payload.severity || headerMatch[1]);
     const title = (payload.title !== undefined ? payload.title : headerMatch[2]).trim();
@@ -1945,11 +2128,32 @@ function applyLearningEntryChange(workspaceRoot, userId, ref, action, payload) {
         const t = l.trim();
         if (t === '---')
             continue;
-        if (/^\*\*(Score|Last seen|Recurrences|Technical trace|Users|First synthesized)\*\*:/i.test(t) || /^(First|Last) synthesized:/i.test(t))
+        if (/^\*\*(Id|Score|Last seen|Recurrences|Technical trace|Users|First synthesized)\*\*:/i.test(t) || /^(First|Last) synthesized:/i.test(t))
             meta.push(l);
     }
     const body = String(payload.body !== undefined ? payload.body : '').trim();
     const rebuilt = [`#### [${sev}] ${title}`, '', ...meta, ...(meta.length ? [''] : []), body, '', '---'];
+    // Issue #1755 R2/R4: a domain change is a move between files, because the domain
+    // IS the filename. Cut the rebuilt block from the source file and append it to the
+    // destination, so the entry keeps its id, score and history rather than being
+    // re-created as a new entry with no past.
+    const targetDomain = payload.targetDomain === undefined ? undefined : normalizeLearningDomain(payload.targetDomain);
+    if (targetDomain !== undefined && targetDomain !== normalizeLearningDomain(ref.domain)) {
+        const destPath = resolveLearningFilePath(workspaceRoot, userId, { ...ref, domain: targetDomain });
+        const destExisting = (0, fs_1.existsSync)(destPath) ? (0, fs_1.readFileSync)(destPath, 'utf8') : '';
+        const destNl = destExisting.includes('\r\n') ? '\r\n' : nl;
+        const fileTypeForHeader = exports.CATEGORY_TO_FILETYPE[ref.category];
+        const destPreamble = destExisting.trim()
+            ? destExisting.replace(/\s*$/, '')
+            : `# ${ref.scope === 'org' ? 'Org ' : ''}${titleCaseFromFileType(fileTypeForHeader)}${targetDomain === 'global' ? '' : ` (${targetDomain})`}`;
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(destPath), { recursive: true });
+        (0, fs_1.writeFileSync)(destPath, (destPreamble + destNl + destNl + rebuilt.join(destNl)).replace(/\s*$/, '') + destNl, 'utf8');
+        // Remove from the source only after the destination write succeeded, so a
+        // failure mid-move duplicates rather than loses the entry.
+        const without = [...lines.slice(0, start), ...lines.slice(end)];
+        write(without.join(nl).replace(/\n{3,}/g, '\n\n'));
+        return { ok: true, path: destPath };
+    }
     const next = [...lines.slice(0, start), ...rebuilt, ...lines.slice(end)];
     write(next.join(nl).replace(/\n{3,}/g, '\n\n'));
     return { ok: true, path: filePath };

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

@@ -27,6 +27,7 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const learning_usage_store_1 = require("./learning-usage-store");
 const learning_usage_projection_1 = require("./learning-usage-projection");
+const learning_usage_eligibility_1 = require("./learning-usage-eligibility");
 function daysBetween(from, to) {
     const a = new Date(from).getTime();
     const b = new Date(to).getTime();
@@ -39,6 +40,7 @@ function firedCount(record) {
 }
 function classifyRecurrence(store, options) {
     const record = store.entries[options.key];
+    const excluded = (0, learning_usage_eligibility_1.usageEvidenceExclusions)(store);
     const base = {
         key: options.key,
         title: record?.titles[record.titles.length - 1] ?? null,
@@ -51,6 +53,14 @@ function classifyRecurrence(store, options) {
             firedTotal: record ? firedCount(record) : 0,
         },
     };
+    if (record && excluded.has(record.key)) {
+        return {
+            ...base, classification: 'undetermined',
+            diagnosis: 'The available usage evidence cannot establish this recurrence.',
+            recommendation: 'Review independent source evidence without attributing this recurrence to usage.',
+            recurrenceBump: false, targetOfFix: 'none',
+        };
+    }
     if (!record) {
         return {
             ...base,
@@ -94,7 +104,7 @@ function classifyRecurrence(store, options) {
     // per entry per session and a plain newest-N bound evicted the job-labelled
     // ones within about a day. Asking about a job the store has never retained an
     // offer for is a gap in the record, not a delivery failure.
-    const jobCoverage = Object.values(store.entries).some((entry) => entry.offered.log.some((offer) => offer.job === options.job && daysBetween(offer.date, options.date) <= options.windowDays));
+    const jobCoverage = Object.values(store.entries).some((entry) => !excluded.has(entry.key) && entry.offered.log.some((offer) => offer.job === options.job && daysBetween(offer.date, options.date) <= options.windowDays));
     if (matchingOffers.length > 0) {
         return {
             ...base,
@@ -231,7 +241,7 @@ function firingsUnderModel(record, model) {
  * unrecorded.
  */
 function modelAttributionUnknown(record) {
-    return firedCount(record) > 0 && Object.keys(record.fired.byModel).length === 0;
+    return (0, learning_usage_eligibility_1.modelAttributionIncomplete)(record);
 }
 function earlierModelFirings(record, currentModel) {
     return Object.entries(record.fired.byModel)
@@ -261,24 +271,22 @@ function findRetirementCandidates(store, options) {
     }
     const candidates = [];
     const notCandidates = [];
+    const excluded = (0, learning_usage_eligibility_1.usageEvidenceExclusions)(store);
     for (const record of Object.values(store.entries)) {
         if (record.family !== 'learning')
             continue;
         const title = latestTitle(record);
+        if (excluded.has(record.key) || modelAttributionUnknown(record)) {
+            notCandidates.push({ key: record.key, title,
+                reason: excluded.get(record.key) ?? 'Model attribution is incomplete; unknown use is not zero use.' });
+            continue;
+        }
         const offered = offersUnderModel(record, currentModel);
         const fired = firingsUnderModel(record, currentModel);
         if (fired > 0) {
             notCandidates.push({ key: record.key, title, reason: `It fired ${fired} time${fired === 1 ? '' : 's'} under the current model, so it is still earning its place.` });
             continue;
         }
-        if (modelAttributionUnknown(record)) {
-            notCandidates.push({
-                key: record.key,
-                title,
-                reason: `Per-model attribution is unknown for this entry: it fired ${firedCount(record)} time${firedCount(record) === 1 ? '' : 's'} and no firing carries a model, so how hard it is working under ${currentModel} cannot be measured. Held back rather than counted as zero.`,
-            });
-            continue;
-        }
         if (offered < threshold) {
             notCandidates.push({
                 key: record.key,
@@ -326,6 +334,10 @@ function deriveStanding(record, options) {
     const offered = record.offered.aboveThreshold;
     const title = latestTitle(record);
     const threshold = options.limits.retirementOfferThreshold;
+    if ((0, learning_usage_eligibility_1.countEvidenceProblem)(record, options.offersEraStart)) {
+        return { key: record.key, title, standing: options.currentStanding?.(record.key) ?? 'standard',
+            reason: 'No usage-based change is supported.', offered: null, fired: null, recommendation: null };
+    }
     let standing;
     let reason;
     if (fired > 0 && daysSince(record.fired.lastFiredAt, now) <= STANDING_RECENT_DAYS) {
@@ -356,10 +368,11 @@ function deriveStanding(record, options) {
  */
 function assessStanding(store, options) {
     const now = options.now ?? new Date();
+    const excluded = (0, learning_usage_eligibility_1.usageEvidenceExclusions)(store);
     const assessments = Object.values(store.entries)
-        .filter((r) => r.family === 'learning')
-        .map((r) => deriveStanding(r, { ...options, now }))
-        .sort((a, b) => b.fired - a.fired || b.offered - a.offered);
+        .filter((r) => r.family === 'learning' && !excluded.has(r.key))
+        .map((r) => deriveStanding(r, { ...options, now, offersEraStart: store.offersEraStart }))
+        .sort((a, b) => (b.fired ?? 0) - (a.fired ?? 0) || (b.offered ?? 0) - (a.offered ?? 0));
     return {
         generatedAt: now.toISOString(),
         assessments,
@@ -374,7 +387,7 @@ function toReportEntry(record) {
         fired: firedCount(record),
         ignored: record.fired.byOutcome.ignored,
         lastFired: record.fired.lastFiredAt,
-        firedUnder: Object.keys(record.fired.byModel),
+        firedUnder: (0, learning_usage_eligibility_1.modelAttributionIncomplete)(record) ? undefined : Object.keys(record.fired.byModel),
         recentLog: record.fired.log,
     };
 }
@@ -388,7 +401,10 @@ function toReportEntry(record) {
 function buildUsageReport(store, options) {
     const now = options.now ?? new Date();
     const limit = options.limit ?? 10;
-    const learningRecords = Object.values(store.entries).filter((r) => r.family === 'learning');
+    const excluded = (0, learning_usage_eligibility_1.usageEvidenceExclusions)(store);
+    const allRecords = Object.values(store.entries).filter((r) => r.family === 'learning');
+    const learningRecords = allRecords.filter(r => !excluded.has(r.key));
+    const complete = excluded.size === 0 && (!store.evidence || store.evidence.status === 'reliable');
     const offered = learningRecords.filter((r) => r.offered.total > 0);
     const fired = learningRecords.filter((r) => firedCount(r) > 0);
     const neverFired = offered.filter((r) => firedCount(r) === 0);
@@ -397,11 +413,11 @@ function buildUsageReport(store, options) {
         generatedAt: now.toISOString(),
         windowDays: options.windowDays,
         currentModel: (0, learning_usage_projection_1.resolveCurrentModel)(options.currentModel),
-        integrityFlagged: learningRecords.filter((r) => Boolean(r.integrity)).length,
+        integrityFlagged: excluded.size,
         totals: {
-            entriesOffered: offered.length,
-            entriesWithFirings: fired.length,
-            entriesNeverFired: neverFired.length,
+            entriesOffered: complete ? offered.length : null,
+            entriesWithFirings: complete ? fired.length : null,
+            entriesNeverFired: complete ? neverFired.length : null,
         },
         workingHardest: fired
             .sort((a, b) => {