fraim 2.0.346 → 2.0.348

package/dist/src/local-mcp-server/learning-entry-format.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEARNING_ENTRY_ID_LINE = exports.LEARNING_ENTRY_ID_REGEX = exports.LEARNING_PRIORITIES = void 0;
+exports.learningEntryHeadingRegex = learningEntryHeadingRegex;
+exports.learningEntryIdLineRegex = learningEntryIdLineRegex;
+exports.generateLearningEntryId = generateLearningEntryId;
+/** Stable learning IDs and headings shared by corpus readers and explicit stamping. */
+const node_crypto_1 = require("node:crypto");
+exports.LEARNING_PRIORITIES = ['P-CRITICAL', 'P-HIGH', 'P-MED', 'P-LOW'];
+function learningEntryHeadingRegex(flags = '') {
+    return new RegExp(`^#{2,}\\s+\\[(${exports.LEARNING_PRIORITIES.join('|')})\\]\\s*(.*)$`, flags);
+}
+/** Generated IDs are deterministic on first stamping; persisted IDs survive title edits. */
+exports.LEARNING_ENTRY_ID_REGEX = /^L-[0-9a-f]{10}$/;
+/** Readers honor previously handwritten IDs as well as generated IDs. */
+exports.LEARNING_ENTRY_ID_LINE = /^\*\*Id\*\*:\s*(L-[0-9A-Za-z]{6,24})\s*$/;
+function learningEntryIdLineRegex() {
+    return new RegExp(exports.LEARNING_ENTRY_ID_LINE.source);
+}
+function generateLearningEntryId(fileType, title) {
+    const digest = (0, node_crypto_1.createHash)('sha1')
+        .update(`${fileType}|${title.trim().replace(/\s+/g, ' ').toLowerCase()}`)
+        .digest('hex');
+    return `L-${digest.slice(0, 10)}`;
+}

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

@@ -1,389 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.classifyRecurrence = classifyRecurrence;
-exports.resolveStructuralProbe = resolveStructuralProbe;
-exports.findRetirementCandidates = findRetirementCandidates;
-exports.deriveStanding = deriveStanding;
-exports.assessStanding = assessStanding;
 exports.buildUsageReport = buildUsageReport;
-/**
- * Issue #1103 — what the usage record lets you conclude.
- *
- * Three questions, each with an answer the record can prove:
- *
- *   R7  Why did this recur? `ignored` means the entry was in context and did not
- *       change the outcome, so the fix is the entry. `not-offered` means it never
- *       reached the agent, so the fix is the delivery. Today a recurrence cannot
- *       tell those apart, which is why the same lesson gets rewritten when the
- *       real bug is in the loader.
- *   R9  Which entries have stopped earning their place under the current model?
- *   R20 And is there a second, independent signal agreeing before anything is
- *       recommended for retirement?
- *
- * Everything here is read-only. R10 and R19: usage data produces recommendations,
- * and every change to an entry still passes the existing review gate.
- */
-const fs_1 = require("fs");
-const path_1 = require("path");
+/** Optional historical outcome reporting. */
 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();
-    if (Number.isNaN(a) || Number.isNaN(b))
-        return Number.POSITIVE_INFINITY;
-    return Math.abs(b - a) / 86_400_000;
-}
+function latestTitle(record) { return record.titles.at(-1) ?? record.key; }
 function firedCount(record) {
     return learning_usage_store_1.CLOCK_ADVANCING_OUTCOMES.reduce((sum, outcome) => sum + record.fired.byOutcome[outcome], 0);
 }
-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,
-        evidence: {
-            recurrenceDate: options.date,
-            recurrenceJob: options.job,
-            windowDays: options.windowDays,
-            matchingOffers: [],
-            offeredTotal: record?.offered.total ?? 0,
-            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,
-            classification: 'undetermined',
-            diagnosis: 'There is no usage record for this entry, so whether it was in context for that job cannot be determined.',
-            recommendation: 'No usage record exists for this entry yet. Treat this recurrence the way you would have before usage attribution, and re-check after the entry has been offered a few times.',
-            recurrenceBump: true,
-            targetOfFix: 'none',
-        };
-    }
-    // "In context for that job" means an offer for the same job inside the window.
-    // A different job's offer is not evidence: domain filtering is exactly the
-    // mechanism that can deliver an entry to one job and withhold it from another.
-    const matchingOffers = record.offered.log.filter((offer) => offer.job === options.job
-        && offer.aboveThreshold
-        && daysBetween(offer.date, options.date) <= options.windowDays);
-    base.evidence.matchingOffers = matchingOffers;
-    // Absence of a matching offer record is only evidence of absence when the offer
-    // log actually reaches back over the window. The log is bounded (R16a), so an
-    // entry offered many times can have had every relevant record trimmed away.
-    // Reporting `not-offered` there would tell the manager to fix the loader for an
-    // entry that was in fact delivered, which is the wrong-fix failure R7 exists to
-    // prevent. The history is complete when nothing has been trimmed, or when the
-    // oldest retained record predates the window.
-    const windowStartMs = new Date(options.date).getTime() - options.windowDays * 86_400_000;
-    const oldestRetained = record.offered.log.length
-        ? record.offered.log.reduce((min, o) => (o.date < min ? o.date : min), record.offered.log[0].date)
-        : null;
-    const historyComplete = record.offered.log.length === record.offered.total
-        || (oldestRetained !== null && new Date(oldestRetained).getTime() <= windowStartMs);
-    // #1752 D2, the issue's suggested fix 4. `report` selects an entry into
-    // `ignoredWhileInContext` on `byOutcome.ignored > 0`, which asserts the entry
-    // was in context; `classify` was answering `not-offered` for the same entry,
-    // which asserts the opposite, with no hedge. The #1740 postmortem states in
-    // first-hand prose that L-abc958f241 "was above threshold and in context".
-    // When the two halves of one record disagree, neither is evidence.
-    const ignoredInWindow = record.fired.log.filter((firing) => firing.outcome === 'ignored' && daysBetween(firing.date, options.date) <= options.windowDays);
-    // #1752 D1. Absence of an offer for this job is only evidence when the record
-    // can resolve this job at all. Measured: 2067 of 2354 retained offer records
-    // carry `session` or `__freeform__`, because `fraim_connect` writes one offer
-    // 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) => !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,
-            classification: 'ignored',
-            diagnosis: `This entry was in context for ${options.job} when the mistake recurred, and being in context did not change what happened.`,
-            recommendation: 'The entry reached the agent and did not change the outcome, so the entry itself is what needs work. Fix its wording so the required action is unambiguous, or fix its placement so it is read at the moment the decision is made. Do not record another recurrence as if the lesson were simply not learned yet.',
-            recurrenceBump: true,
-            targetOfFix: 'entry',
-        };
-    }
-    if (ignoredInWindow.length > 0) {
-        return {
-            ...base,
-            classification: 'undetermined',
-            diagnosis: `The two halves of this entry's record disagree: it carries ${ignoredInWindow.length} attested \`ignored\` outcome${ignoredInWindow.length === 1 ? '' : 's'} inside the window, which says it was in context and the work went against it, while the offer log holds no matching offer for ${options.job}, which says it was never delivered. Both cannot be true.`,
-            recommendation: 'Do not act on either reading. An `ignored` attestation and an empty offer log are contradictory evidence about the same event, so the record cannot say whether the entry or the delivery is at fault. Run `learning-usage verify` to see whether this entry carries an integrity flag, and treat the recurrence on its own terms until the record agrees with itself.',
-            recurrenceBump: true,
-            targetOfFix: 'none',
-        };
-    }
-    if (!jobCoverage) {
-        return {
-            ...base,
-            classification: 'undetermined',
-            diagnosis: `No offer anywhere in the record carries the job label ${options.job} inside this window, so the per-job offer record has no resolution for that job and cannot say whether this entry was in context for it.`,
-            recommendation: 'The offer record cannot answer this question for this job, so absence of a match is not evidence of absence. Do not conclude a delivery problem. Re-ask once the job has run with offer recording in place, or widen the window to one the record covers.',
-            recurrenceBump: true,
-            targetOfFix: 'none',
-        };
-    }
-    if (!historyComplete) {
-        return {
-            ...base,
-            classification: 'undetermined',
-            diagnosis: `Whether this entry was in context for ${options.job} cannot be determined: it has been offered ${record.offered.total} times, but the retained offer log no longer reaches back over the window being asked about.`,
-            recommendation: 'The offer history for this window has been pruned, so absence of a record is not evidence that the entry was not delivered. Do not conclude a delivery problem from this. Either widen the retained offer log for this corpus, or ask again about a more recent recurrence.',
-            recurrenceBump: true,
-            targetOfFix: 'none',
-        };
-    }
-    return {
-        ...base,
-        classification: 'not-offered',
-        diagnosis: `This entry was never in context for ${options.job}, so it had no opportunity to change what happened.`,
-        recommendation: 'The entry never reached the agent, so the delivery is what is wrong and the entry text is fine. Check the entry\'s domain and its threshold in the loader: widen the domain if the lesson applies beyond the jobs it is currently scoped to. Do not raise the recurrence count, because the count measures how often the lesson failed to stick and this is not an instance of that.',
-        recurrenceBump: false,
-        targetOfFix: 'delivery',
-    };
-}
-const UNDETERMINED = {
-    signal: 'undetermined',
-    detail: 'The structural signal could not be determined: the corpus hygiene detector is not available in this workspace, so whether the thing this entry guards still exists is unknown.',
-};
-/**
- * R20's structural half comes from issue #1100's inert and orphan detection, which
- * answers a different question from usage: is the thing this entry guards still
- * there? The two specs meet at exactly this point, and #1103 reads that detector
- * rather than re-deriving it.
- *
- * When the detector is absent the probe says so plainly. That is not a fallback
- * for convenience: R20's third acceptance criterion requires the undetermined case
- * to be stated rather than presented as if both signals agreed.
- */
-/**
- * The only module this integration loads. Naming it exactly, rather than accepting
- * any path, keeps `require` of a caller-supplied string from becoming a general
- * arbitrary-module loader: a mistyped or hostile `--detector` value fails closed to
- * the undetermined signal instead of executing.
- */
-const STRUCTURAL_DETECTOR_FILENAME = 'instruction-hygiene.js';
-function resolveStructuralProbe(detectorPath) {
-    if (!detectorPath || !(0, fs_1.existsSync)(detectorPath)) {
-        return () => UNDETERMINED;
-    }
-    if ((0, path_1.basename)(detectorPath) !== STRUCTURAL_DETECTOR_FILENAME) {
-        return () => ({
-            signal: 'undetermined',
-            detail: `The structural signal could not be determined: the detector path must end in ${STRUCTURAL_DETECTOR_FILENAME}, and this one does not.`,
-        });
-    }
-    let detector;
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        detector = require(detectorPath);
-    }
-    catch {
-        return () => UNDETERMINED;
-    }
-    if (!detector || typeof detector.analyzeInstructionHygiene !== 'function') {
-        return () => UNDETERMINED;
-    }
-    return (key, title) => {
-        try {
-            const report = detector.analyzeInstructionHygiene({ root: process.cwd() });
-            const findings = report?.findings ?? [];
-            const needle = (title ?? key).toLowerCase();
-            const inert = findings.find((f) => (f.type === 'inert' || f.type === 'orphan')
-                && `${f.file ?? ''} ${f.message ?? ''}`.toLowerCase().includes(needle));
-            if (inert) {
-                return { signal: 'guard-absent', detail: `The corpus hygiene detector reports this as ${inert.type}: ${inert.message ?? 'no consumer found'}.` };
-            }
-            return { signal: 'still-referenced', detail: 'The corpus hygiene detector finds the surface this entry guards is still referenced.' };
-        }
-        catch {
-            return UNDETERMINED;
-        }
-    };
-}
-function offersUnderModel(record, model) {
-    if (!model)
-        return 0;
-    return record.offered.byModel[model] ?? 0;
-}
-function firingsUnderModel(record, model) {
-    if (!model)
-        return 0;
-    return record.fired.byModel[model] ?? 0;
-}
-/**
- * #1752 C4 - is this entry's per-model attribution unknown, as opposed to zero?
- *
- * All 781 retained firing records in the live store carry `agent: null,
- * model: null`, because `attest-learning-firings.md` invoked `record-firings`
- * with no `--agent` or `--model`. `firedUnderCurrentModel` was therefore
- * structurally 0 for every entry, which is why `candidates` proposed 31
- * retirements: every entry clearing the offer threshold became one, however hard
- * it was working. Fixing the `currentModel` resolution alone would not have
- * changed a single one of them.
- *
- * The predicate is deliberately narrower than "fired at all". An entry whose only
- * outcomes are `ignored` or `not-applicable` has an empty `byModel` because those
- * outcomes correctly do not bucket by model; that is information, not a gap. Only
- * a clock-advancing firing that produced no bucket means the model went
- * unrecorded.
- */
-function modelAttributionUnknown(record) {
-    return (0, learning_usage_eligibility_1.modelAttributionIncomplete)(record);
-}
-function earlierModelFirings(record, currentModel) {
-    return Object.entries(record.fired.byModel)
-        .filter(([model]) => model !== currentModel)
-        .map(([model, count]) => ({ model, count }))
-        .sort((a, b) => b.count - a.count);
-}
-function latestTitle(record) {
-    return record.titles[record.titles.length - 1] ?? record.key;
-}
-function findRetirementCandidates(store, options) {
-    const currentModel = (0, learning_usage_projection_1.resolveCurrentModel)(options.currentModel);
-    const threshold = options.limits.retirementOfferThreshold;
-    const probe = options.structuralProbe ?? resolveStructuralProbe(options.structuralSignalPath);
-    // #1752 C1: retirement candidacy is computed per model, so with no model there
-    // is no question to answer. An empty list with the reason stated is the honest
-    // answer; computing against a null bucket is how defect 3 produced 31
-    // proposals nobody could act on.
-    if (!currentModel) {
-        return {
-            currentModel: null,
-            offerThreshold: threshold,
-            candidates: [],
-            notCandidates: [],
-            reason: 'The current model did not resolve, so no per-model conclusion can be drawn. Pass --model <model>, or set FRAIM_ACTIVE_MODEL. The current model is never inferred from the usage record, because the record is shared by concurrent sessions from more than one agent and would report whichever wrote last.',
-        };
-    }
-    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 (offered < threshold) {
-            notCandidates.push({
-                key: record.key,
-                title,
-                reason: `Only ${offered} offer${offered === 1 ? '' : 's'} under the current model, which is below the threshold of ${threshold}. That is more likely to mean the work that triggers it has not come up than that it is no longer needed.`,
-            });
-            continue;
-        }
-        const structural = probe(record.key, title);
-        // R20: two independent signals before recommending removal. Usage alone says
-        // "unused"; only usage plus an absent guard says "obsolete".
-        const recommendation = structural.signal === 'guard-absent' ? 'retire' : 'keep-and-reword';
-        candidates.push({
-            key: record.key,
-            title,
-            offeredUnderCurrentModel: offered,
-            firedUnderCurrentModel: fired,
-            firedUnderEarlierModels: earlierModelFirings(record, currentModel),
-            currentModel,
-            structural: structural.signal,
-            structuralDetail: structural.detail,
-            recommendation,
-        });
-    }
-    candidates.sort((a, b) => b.offeredUnderCurrentModel - a.offeredUnderCurrentModel);
-    return { currentModel, offerThreshold: threshold, candidates, notCandidates };
-}
-/**
- * The window in which a firing still counts as recent for standing purposes.
- * Longer than the Brain's 30-day "fired recently" glance signal, because standing
- * is a slower-moving decision than a dot colour.
- */
-const STANDING_RECENT_DAYS = 90;
-function daysSince(date, now) {
-    if (!date)
-        return Number.POSITIVE_INFINITY;
-    const parsed = new Date(date).getTime();
-    if (Number.isNaN(parsed))
-        return Number.POSITIVE_INFINITY;
-    return (now.getTime() - parsed) / 86_400_000;
-}
-function deriveStanding(record, options) {
-    const now = options.now ?? new Date();
-    const fired = firedCount(record);
-    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) {
-        standing = 'promoted';
-        reason = `Fired ${fired} time${fired === 1 ? '' : 's'}, most recently ${record.fired.lastFiredAt}. It is changing outcomes, so it stays fully in context.`;
-    }
-    else if (offered >= threshold && fired === 0) {
-        standing = 'demoted';
-        reason = `Offered ${offered} times as active guidance and never changed an outcome. Demoted rather than removed: it stays readable and can earn its way back the first time it fires.`;
-    }
-    else if (fired > 0) {
-        standing = 'standard';
-        reason = `Fired ${fired} time${fired === 1 ? '' : 's'}, but not within the last ${STANDING_RECENT_DAYS} days. Held at standard while it is neither proving itself nor failing to.`;
-    }
-    else {
-        standing = 'standard';
-        reason = offered === 0
-            ? 'No usage record yet. An entry FRAIM has not measured is held at standard rather than judged.'
-            : `Offered ${offered} times, which is below the ${threshold} needed to conclude anything from silence.`;
-    }
-    const current = options.currentStanding ? options.currentStanding(record.key) : 'standard';
-    const recommendation = standing === current ? null : standing === 'promoted' ? 'promote' : standing === 'demoted' ? 'demote' : null;
-    return { key: record.key, title, standing, reason, offered, fired, recommendation };
-}
-/**
- * Assess every entry with a usage record. Read-only: this recommends, and
- * `sleep-on-learnings` applies under the existing approval gate (R10, R19).
- */
-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' && !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,
-        changes: assessments.filter((a) => a.recommendation !== null),
-    };
-}
 function toReportEntry(record) {
     return {
         key: record.key,
         title: latestTitle(record),
-        offered: record.offered.total,
         fired: firedCount(record),
         ignored: record.fired.byOutcome.ignored,
         lastFired: record.fired.lastFiredAt,
@@ -392,49 +20,23 @@ function toReportEntry(record) {
     };
 }
 /**
- * The answer to "which of my learnings are still earning their place?".
+ * Historical outcome observations without fresh effectiveness or rank judgments.
  *
  * Only entries with a usage record appear. An entry FRAIM has never measured is
  * absent rather than listed with zeroes, because a fabricated zero reads as
  * evidence of disuse when it is only evidence of no data.
  */
-function buildUsageReport(store, options) {
+function buildUsageReport(store, options = {}) {
     const now = options.now ?? new Date();
-    const limit = options.limit ?? 10;
     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);
-    const ignored = learningRecords.filter((r) => r.fired.byOutcome.ignored > 0);
+    const records = Object.values(store.entries).filter(record => record.family === 'learning' && !excluded.has(record.key));
+    const historicalOutcomes = records.filter(record => record.fired.total > 0)
+        .sort((a, b) => (b.fired.lastAttestedAt ?? '').localeCompare(a.fired.lastAttestedAt ?? ''))
+        .slice(0, options.limit ?? 10).map(toReportEntry);
     return {
-        generatedAt: now.toISOString(),
-        windowDays: options.windowDays,
-        currentModel: (0, learning_usage_projection_1.resolveCurrentModel)(options.currentModel),
-        integrityFlagged: excluded.size,
-        totals: {
-            entriesOffered: complete ? offered.length : null,
-            entriesWithFirings: complete ? fired.length : null,
-            entriesNeverFired: complete ? neverFired.length : null,
-        },
-        workingHardest: fired
-            .sort((a, b) => {
-            const byCount = firedCount(b) - firedCount(a);
-            if (byCount !== 0)
-                return byCount;
-            return (b.fired.lastFiredAt ?? '').localeCompare(a.fired.lastFiredAt ?? '');
-        })
-            .slice(0, limit)
-            .map(toReportEntry),
-        neverFired: neverFired
-            .sort((a, b) => b.offered.total - a.offered.total)
-            .slice(0, limit)
-            .map(toReportEntry),
-        ignoredWhileInContext: ignored
-            .sort((a, b) => b.fired.byOutcome.ignored - a.fired.byOutcome.ignored)
-            .slice(0, limit)
-            .map(toReportEntry),
+        generatedAt: now.toISOString(), historical: true,
+        lastObservedAt: records.map(record => record.fired.lastAttestedAt)
+            .filter((date) => Boolean(date) && Number.isFinite(Date.parse(date))).sort().at(-1) ?? null,
+        excludedCount: excluded.size, historicalOutcomes,
     };
 }

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

@@ -7,28 +7,22 @@ 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];
+    const buckets = [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;
+    return 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),
+function countEvidenceProblem(record) {
+    const counts = [record.fired.total,
+        ...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;
+    return null;
 }
 /** Read-time exclusions follow the actual record, never ambient UI or model state. */
 function usageEvidenceExclusions(store) {
@@ -37,7 +31,7 @@ function usageEvidenceExclusions(store) {
         excluded.set(key, 'Unreadable usage record.');
     const byTitle = new Map();
     for (const record of Object.values(store.entries)) {
-        const problem = countEvidenceProblem(record, store.offersEraStart);
+        const problem = countEvidenceProblem(record);
         if (store.evidence?.status === 'unavailable')
             excluded.set(record.key, 'Usage history is unavailable.');
         else if (problem)

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

@@ -7,7 +7,7 @@ exports.resolveCurrentModel = resolveCurrentModel;
  * Issue #1103 — projecting the usage record into the shapes its readers need.
  *
  * The store owns writing and persistence; this owns turning what is stored into
- * what a scorer, a surface, or a report asks for. Split out because those are two
+ * what a human surface or report asks for. Split out because those are two
  * jobs with different reasons to change: the record's schema changes when the
  * privacy or retention contract changes, and these projections change when a
  * consumer needs a different view.
@@ -18,13 +18,11 @@ const learning_usage_store_1 = require("./learning-usage-store");
 const learning_usage_eligibility_1 = require("./learning-usage-eligibility");
 function toLookupValue(record) {
     return {
+        historical: true, countingStatus: 'deferred', lastObservedAt: record.fired.lastAttestedAt && Number.isFinite(Date.parse(record.fired.lastAttestedAt)) ? record.fired.lastAttestedAt : null,
         key: record.key,
-        offered: record.offered.total,
-        offeredAboveThreshold: record.offered.aboveThreshold,
         fired: record.fired.byOutcome.prevented + record.fired.byOutcome.applied,
         firedTotalAttestations: record.fired.total,
         lastFired: record.fired.lastFiredAt,
-        lastOffered: record.offered.lastOfferedAt,
         firedUnder: (0, learning_usage_eligibility_1.modelAttributionIncomplete)(record) ? undefined : Object.keys(record.fired.byModel),
         byOutcome: record.fired.byOutcome,
         log: record.fired.log,
@@ -32,14 +30,14 @@ function toLookupValue(record) {
 }
 /**
  * A lookup keyed by every identifier that resolves to a record: the entry id, and
- * every title the entry has been known by. That is what lets a scorer look up an
+ * every title the entry has been known by. That lets a historical surface look up an
  * entry by whichever handle it has.
  */
 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))
+        if (excluded.has(record.key) || record.fired.total === 0)
             continue;
         const value = toLookupValue(record);
         lookup.set(record.key, value);
@@ -66,22 +64,7 @@ function lookupUsage(lookup, id, fileType, title) {
         return resolved;
     return identity.source === 'id' ? lookup.get((0, learning_usage_store_1.titleUsageKey)(fileType, title)) : undefined;
 }
-/**
- * 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.
- */
+/** Model identity comes from the caller or explicit environment, never historical observations. */
 function resolveCurrentModel(explicit) {
     return (0, learning_usage_store_1.normalizeModelName)(explicit) ?? (0, learning_usage_store_1.normalizeModelName)(process.env.FRAIM_ACTIVE_MODEL);
 }