fraim 2.0.340 → 2.0.342

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

@@ -520,33 +520,60 @@ class LocalRegistryResolver {
             // publish or sync and resolves at all under `single-machine`).
             const managerLocalContent = this.readManagerLocalOverlayFile(path);
             if (managerLocalContent !== null) {
+                // Issue #1867: apply inheritance so an extends-based override merges with its parent.
+                let resolvedManagerLocal;
+                try {
+                    resolvedManagerLocal = await this.resolveInheritance(managerLocalContent, path);
+                }
+                catch {
+                    resolvedManagerLocal = { content: managerLocalContent, imports: [] };
+                }
                 return {
-                    content: managerLocalContent,
+                    content: resolvedManagerLocal.content,
                     source: 'local',
                     personalized: true,
-                    inherited: false,
+                    inherited: resolvedManagerLocal.imports.length > 0,
+                    imports: resolvedManagerLocal.imports.length > 0 ? resolvedManagerLocal.imports : undefined,
                     scope: 'manager'
                 };
             }
             // Issue #869: manager overlay (precedence 3 — the synced cross-machine copy)
             const managerOverlayContent = this.readManagerOverlayFile(path);
             if (managerOverlayContent !== null) {
+                // Issue #1867: apply inheritance so an extends-based override merges with its parent.
+                let resolvedManagerOverlay;
+                try {
+                    resolvedManagerOverlay = await this.resolveInheritance(managerOverlayContent, path);
+                }
+                catch {
+                    resolvedManagerOverlay = { content: managerOverlayContent, imports: [] };
+                }
                 return {
-                    content: managerOverlayContent,
+                    content: resolvedManagerOverlay.content,
                     source: 'local',
                     personalized: true,
-                    inherited: false,
+                    inherited: resolvedManagerOverlay.imports.length > 0,
+                    imports: resolvedManagerOverlay.imports.length > 0 ? resolvedManagerOverlay.imports : undefined,
                     scope: 'manager'
                 };
             }
             // Issue #869 Phase 2: org overlay (precedence 3 — after manager, before synced baseline)
             const orgOverlayContent = this.readOrgOverlayFile(path);
             if (orgOverlayContent !== null) {
+                // Issue #1867: apply inheritance so an extends-based override merges with its parent.
+                let resolvedOrgOverlay;
+                try {
+                    resolvedOrgOverlay = await this.resolveInheritance(orgOverlayContent, path);
+                }
+                catch {
+                    resolvedOrgOverlay = { content: orgOverlayContent, imports: [] };
+                }
                 return {
-                    content: orgOverlayContent,
+                    content: resolvedOrgOverlay.content,
                     source: 'local',
                     personalized: true,
-                    inherited: false,
+                    inherited: resolvedOrgOverlay.imports.length > 0,
+                    imports: resolvedOrgOverlay.imports.length > 0 ? resolvedOrgOverlay.imports : undefined,
                     scope: 'org'
                 };
             }

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

@@ -24,6 +24,7 @@ exports.readOrgBrand = readOrgBrand;
 exports.resolveOrgBrandWriteDir = resolveOrgBrandWriteDir;
 exports.countPreservedLearnings = countPreservedLearnings;
 exports.collectBrainLearningDots = collectBrainLearningDots;
+exports.readRejectedProposals = readRejectedProposals;
 exports.readPreservedLearnings = readPreservedLearnings;
 exports.normalizeLearningDomain = normalizeLearningDomain;
 exports.applyLearningEntryChange = applyLearningEntryChange;
@@ -579,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');
@@ -823,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
@@ -862,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) {
@@ -1825,6 +1865,93 @@ 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);

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) => {

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

@@ -277,7 +277,8 @@ const reportCommand = addModelOption(addCommonOptions(new commander_1.Command('r
     });
     emit(report, options.json, () => {
         const lines = [
-            `${report.totals.entriesOffered} entries were offered. ${report.totals.entriesWithFirings} fired. ${report.totals.entriesNeverFired} have never fired.`,
+            report.totals.entriesOffered === null ? 'Corpus totals are unavailable; listed entries have independent usable evidence.'
+                : `${report.totals.entriesOffered} entries were offered. ${report.totals.entriesWithFirings} fired. ${report.totals.entriesNeverFired} have never fired.`,
         ];
         if (report.workingHardest.length) {
             lines.push('', 'Working hardest');
@@ -295,7 +296,7 @@ const reportCommand = addModelOption(addCommonOptions(new commander_1.Command('r
             report.ignoredWhileInContext.forEach((e, i) => lines.push(`${i + 1}. ${e.title}. Attested ignored ${e.ignored} time${e.ignored === 1 ? '' : 's'} (fired ${e.fired}). In context and the work went against it, so the entry needs work rather than another recurrence.`));
         }
         if (report.integrityFlagged > 0) {
-            lines.push('', `${report.integrityFlagged} entr${report.integrityFlagged === 1 ? 'y has' : 'ies have'} an integrity flag: more attested firings than recorded offers. Run \`learning-usage verify\` before acting on anything below.`);
+            lines.push('', `${report.integrityFlagged} entries were excluded from usage conclusions. Run \`learning-usage verify\` for diagnostic details.`);
         }
         lines.push('', 'Nothing is retired from this view. Run sleep-on-learnings to decide.');
         return lines.join('\n');
@@ -450,7 +451,8 @@ const pruneCommand = addCommonOptions(new commander_1.Command('prune'))
     const workspaceRoot = resolveWorkspaceRoot(options);
     const limits = (0, learning_usage_store_1.resolveUsageLimits)(workspaceRoot);
     const result = (0, learning_usage_store_1.pruneUsageStore)(limits);
-    emit({ ...result, storePath: (0, learning_usage_store_1.resolveUsageStorePath)(), limits }, options.json, () => `Pruned ${result.prunedOfferRecords} offer records and ${result.prunedFiringRecords} firing records across ${result.entries} entries. Aggregates unchanged.`);
+    emit({ ...result, storePath: (0, learning_usage_store_1.resolveUsageStorePath)(), limits }, options.json, () => result.maintenanceStatus === 'deferred' ? `Maintenance deferred; history unchanged. ${result.evidence?.observations.join(', ') ?? ''}`
+        : `Pruned ${result.prunedOfferRecords} offer records and ${result.prunedFiringRecords} firing records across ${result.entries} entries. Aggregates unchanged.`);
 });
 function mb(bytes) {
     return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
@@ -472,9 +474,11 @@ const verifyCommand = addModelOption(addCommonOptions(new commander_1.Command('v
             '',
         ];
         const finding = (count, singular, plural, remedy) => count === 0 ? `  none: ${singular}` : `  ${count} ${count === 1 ? singular : plural}. ${remedy}`;
+        if (report.evidence)
+            lines.push(`Evidence: ${report.evidence.status}. ${report.evidence.observations.join(', ')}.`, ...(report.evidence.recovery ? [`Recovered from ${report.evidence.recovery}; primary replacement was not persisted by this read.`] : []), '');
         lines.push('Identity', finding(report.twinPairs.length, 'lesson tracked under two keys', 'lessons tracked under two keys', 'Its offers and its firings are on different records, so every count about it is partial.'), report.unmatchedTitleKeys.length
             ? `  ${report.unmatchedTitleKeys.length} title-keyed record${report.unmatchedTitleKeys.length === 1 ? ' has' : 's have'} no id twin. Expected for entries no tier has stamped; run \`stamp-ids\` to reduce it.`
-            : '  every title-keyed record has been matched or has no twin', '', 'Counters', finding(report.invariantViolations.length, 'entry holds more attested firings than recorded offers', 'entries hold more attested firings than recorded offers', 'An entry cannot fire without being offered, so one of the two counters is wrong. History stranded in a store copy nothing reads is the usual cause.'), finding(report.caseVariantModelBuckets.length, 'model bucket differs only by case', 'model buckets differ only by case', 'One model spelled two ways splits its own denominator, so every per-model conclusion about it is computed on a fraction of its traffic.'), finding(report.unknownModelAttribution.length, 'entry fired with no model recorded', 'entries fired with no model recorded', 'Per-model retirement cannot be answered for these, and they are held back rather than counted as zero. These were attested before record-firings carried --agent and --model, so the model was never recorded against them and a rebuild cannot invent it; attestations recorded from now on carry both.'), '', 'Storage');
+            : '  every title-keyed record has been matched or has no twin', '', 'Counters', finding(report.invariantViolations.length, 'entry holds more attested firings than recorded offers', 'entries hold more attested firings than recorded offers', 'The counts are inconsistent. This observation does not establish their cause.'), finding(report.caseVariantModelBuckets.length, 'model bucket differs only by case', 'model buckets differ only by case', 'One model spelled two ways splits its own denominator, so every per-model conclusion about it is computed on a fraction of its traffic.'), finding(report.unknownModelAttribution.length, 'entry has incomplete model attribution', 'entries have incomplete model attribution', 'Affected model conclusions are withheld. The cause is not established; unknown historical attribution cannot be inferred from the current model.'), '', 'Storage');
         if (report.storeCopies.length === 0) {
             lines.push('  one store file, no unmerged copies');
         }

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelAttributionIncomplete = modelAttributionIncomplete;
+exports.countEvidenceProblem = countEvidenceProblem;
+exports.usageEvidenceExclusions = usageEvidenceExclusions;
+const learning_usage_store_1 = require("./learning-usage-store");
+const validCount = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+/** Missing attribution is unknown, including a known bucket beside unattributed history. */
+function modelAttributionIncomplete(record) {
+    const buckets = [record.offered.byModel, record.fired.byModel];
+    if (buckets.some(map => !map || Object.entries(map).some(([name, n]) => !validCount(n) || !(0, learning_usage_store_1.normalizeModelName)(name) || (0, learning_usage_store_1.normalizeModelName)(name) !== name)))
+        return true;
+    return Object.values(record.offered.byModel).reduce((a, b) => a + b, 0) !== record.offered.total
+        || Object.values(record.fired.byModel).reduce((a, b) => a + b, 0)
+            !== record.fired.byOutcome.applied + record.fired.byOutcome.prevented;
+}
+/** Validate counts independently of a cached integrity flag. Never alter the record. */
+function countEvidenceProblem(record, offersEraStart) {
+    const counts = [record.offered.total, record.offered.aboveThreshold, record.fired.total,
+        ...Object.values(record.offered.byModel), ...Object.values(record.fired.byModel),
+        ...Object.values(record.fired.byOutcome)];
+    if (counts.some(n => !validCount(n)) || learning_usage_store_1.FIRING_OUTCOMES.some(outcome => !validCount(record.fired.byOutcome[outcome]))
+        || record.offered.aboveThreshold > record.offered.total
+        || Object.values(record.fired.byOutcome).reduce((a, b) => a + b, 0) !== record.fired.total) {
+        return 'Usage counters are inconsistent.';
+    }
+    const violation = record.integrity ?? (0, learning_usage_store_1.integrityViolation)(record, offersEraStart);
+    if (!offersEraStart && record.offered.total > 0 && record.fired.total > record.offered.total) {
+        return 'Excess uses lack provenance establishing the offer-recording era.';
+    }
+    return violation ? violation.detail : null;
+}
+/** Read-time exclusions follow the actual record, never ambient UI or model state. */
+function usageEvidenceExclusions(store) {
+    const excluded = new Map();
+    for (const key of store.evidence?.excludedKeys ?? [])
+        excluded.set(key, 'Unreadable usage record.');
+    const byTitle = new Map();
+    for (const record of Object.values(store.entries)) {
+        const problem = countEvidenceProblem(record, store.offersEraStart);
+        if (store.evidence?.status === 'unavailable')
+            excluded.set(record.key, 'Usage history is unavailable.');
+        else if (problem)
+            excluded.set(record.key, problem);
+        if (!record.fileType)
+            continue;
+        for (const title of record.titles) {
+            const titleKey = (0, learning_usage_store_1.titleUsageKey)(record.fileType, title);
+            byTitle.set(titleKey, [...new Set([...(byTitle.get(titleKey) ?? []), record.key])]);
+        }
+    }
+    for (const keys of byTitle.values()) {
+        if (keys.length > 1 && keys.some(key => key.startsWith('T:'))) {
+            for (const key of keys)
+                excluded.set(key, 'Ambiguous duplicate usage identity.');
+        }
+    }
+    return excluded;
+}

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

@@ -15,6 +15,7 @@ exports.resolveCurrentModel = resolveCurrentModel;
  * Nothing here writes.
  */
 const learning_usage_store_1 = require("./learning-usage-store");
+const learning_usage_eligibility_1 = require("./learning-usage-eligibility");
 function toLookupValue(record) {
     return {
         key: record.key,
@@ -24,7 +25,7 @@ function toLookupValue(record) {
         firedTotalAttestations: record.fired.total,
         lastFired: record.fired.lastFiredAt,
         lastOffered: record.offered.lastOfferedAt,
-        firedUnder: Object.keys(record.fired.byModel),
+        firedUnder: (0, learning_usage_eligibility_1.modelAttributionIncomplete)(record) ? undefined : Object.keys(record.fired.byModel),
         byOutcome: record.fired.byOutcome,
         log: record.fired.log,
     };
@@ -36,7 +37,10 @@ function toLookupValue(record) {
  */
 function buildUsageLookup(store) {
     const lookup = new Map();
+    const excluded = (0, learning_usage_eligibility_1.usageEvidenceExclusions)(store);
     for (const record of Object.values(store.entries)) {
+        if (excluded.has(record.key))
+            continue;
         const value = toLookupValue(record);
         lookup.set(record.key, value);
         if (record.fileType) {