fraim 2.0.337 → 2.0.339

package/dist/registry/scripts/learning/entry-format.js

@@ -0,0 +1,27 @@
+'use strict';
+
+// Read the shared author's current entry format for identity and update guards.
+function learningEntryBlocks(body) {
+    const headings = [...body.matchAll(/^#{2,6}\s+\[P-[A-Z]+\].*$/gm)];
+    return headings.map((heading, index) => {
+        const start = heading.index;
+        const next = headings[index + 1]?.index ?? body.length;
+        const ownDepth = heading[0].match(/^#+/)[0].length;
+        const afterHeading = start + heading[0].length;
+        const shallower = [...body.slice(afterHeading, next).matchAll(/^(#{1,6})\s+.*$/gm)].find(m => m[1].length <= ownDepth);
+        const limit = shallower ? afterHeading + shallower.index : next;
+        const text = body.slice(start, limit).trimEnd();
+        return { start, end: start + text.length, text, id: text.match(/^\*\*Id\*\*:\s*(L-[a-f0-9]{10})\s*$/m)?.[1] ?? null };
+    });
+}
+
+function learningEntryMetadata(content) {
+    const metadata = {};
+    for (const match of content.matchAll(/^\*\*(Recurrences|First recorded|First synthesized)\*\*:\s*([^\r\n]+)$/gm)) {
+        if (metadata[match[1]] !== undefined && metadata[match[1]] !== match[2]) throw new Error('entry-metadata-conflict');
+        metadata[match[1]] = match[2];
+    }
+    return metadata;
+}
+
+module.exports = { learningEntryMetadata, learningEntryBlocks };

package/dist/registry/scripts/learning/learning-domains.json

@@ -0,0 +1,78 @@
+{
+  "schemaVersion": 1,
+  "mapVersion": 1,
+  "domains": [
+    "engineering",
+    "product",
+    "go-to-market",
+    "people-ops",
+    "finance",
+    "legal",
+    "compliance",
+    "customer",
+    "company-building",
+    "operations"
+  ],
+  "jobDomainMap": {
+    "product-building": "engineering",
+    "dev-ops": "engineering",
+    "quality-assurance": "engineering",
+    "migration": "engineering",
+    "replicate": "engineering",
+    "reviewer": "engineering",
+    "security": "engineering",
+    "delivery-ops": "engineering",
+    "salesforce": "engineering",
+    "ai-engineering": "engineering",
+    "product-management": "product",
+    "customer-development": "product",
+    "brainstorming": "product",
+    "marketing": "go-to-market",
+    "branding": "go-to-market",
+    "sales": "go-to-market",
+    "go-to-market": "go-to-market",
+    "business-development": "go-to-market",
+    "commercial-ops": "go-to-market",
+    "people-ops": "people-ops",
+    "inclusion-ops": "people-ops",
+    "career": "people-ops",
+    "finance": "finance",
+    "invoicing": "finance",
+    "banking": "finance",
+    "legal": "legal",
+    "compliance": "compliance",
+    "customer-success": "customer",
+    "customer-communication": "customer",
+    "company-creation": "company-building",
+    "bootstrap": "company-building",
+    "fundraising": "company-building",
+    "business-ops": "operations",
+    "procurement": "operations",
+    "project-management": "operations"
+  },
+  "globalJobCategories": [
+    "manager",
+    "fraim",
+    "1-1",
+    "coaching",
+    "delegation",
+    "hiring",
+    "productivity",
+    "project-setup",
+    "setup-guardrails",
+    "team-learning",
+    "verification"
+  ],
+  "domainVoice": {
+    "engineering": "Precise and technical; file paths, commands, and test names are appropriate.",
+    "product": "Product and user-outcome language; behavior and flow, not code symbols.",
+    "go-to-market": "Marketing and sales language; campaigns, funnels, messaging, audience.",
+    "people-ops": "Plain HR and recruiting language; no engineering jargon.",
+    "finance": "Finance and accounting language; figures, close, forecasts.",
+    "legal": "Contract and IP language; obligations, clauses, risk.",
+    "compliance": "Controls, evidence, and regulation language.",
+    "customer": "Customer-relationship and support language.",
+    "company-building": "Founder and operations language; setup, entity, funding.",
+    "operations": "Business-operations language; process, vendors, planning, coordination."
+  }
+}

package/dist/src/cli/utils/pack-home.js

@@ -113,12 +113,14 @@ function defaultCloneDir(layer) {
  * Resolve where this layer's details live. Never throws and never touches the
  * network; call `ensurePackClone` separately when the git working copy has to
  * be present and current.
+ * Read-only inventory callers set `migrateLegacy: false` to suppress the
+ * otherwise backwards-compatible flat org layout migration.
  */
-function resolvePackHome(layer) {
+function resolvePackHome(layer, options = {}) {
     const config = (0, user_config_1.getLayerBackend)(layer);
     const standard = standardHome(layer);
     const make = (root, extra) => {
-        if (layer === 'org')
+        if (layer === 'org' && options.migrateLegacy !== false)
             migrateOrgFlatContent(root);
         return { layer, root, contentRoot: path_1.default.join(root, 'personalized-employee'), ...extra };
     };

package/dist/src/config/learning-domains.js

@@ -12,130 +12,27 @@
  * the current job's-domain learnings only, so a marketing job no longer loads
  * engineering learnings.
  *
- * This module is the single source of truth for the domain list, the
- * registry-category -> domain map, the per-domain authoring voice (R3), and the
- * resolver used at the injection sites. It is pure (no I/O) and mirrors the
+ * The shared registry/scripts/learning/learning-domains.json owns the domain list, the
+ * registry-category -> domain map, and the per-domain authoring voice (R3).
+ * This module provides the pure resolver used at the injection sites, following the
  * config-module convention of `src/config/portfolio-slug-overrides.ts`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DOMAIN_VOICE = exports.GLOBAL_JOB_CATEGORIES = exports.JOB_DOMAIN_MAP = exports.LEARNING_DOMAINS = void 0;
+exports.DOMAIN_VOICE = exports.GLOBAL_JOB_CATEGORIES = exports.JOB_DOMAIN_MAP = exports.LEARNING_DOMAINS = exports.LEARNING_DOMAIN_MAP_VERSION = void 0;
 exports.isLearningDomain = isLearningDomain;
 exports.jobCategoryFromRegistryPath = jobCategoryFromRegistryPath;
 exports.resolveJobDomain = resolveJobDomain;
 exports.domainFromJobFrontmatter = domainFromJobFrontmatter;
 exports.resolveDomainForJob = resolveDomainForJob;
-/** The coarse learning domains. `global` is represented by the absence of a domain. */
-exports.LEARNING_DOMAINS = [
-    'engineering',
-    'product',
-    'go-to-market',
-    'people-ops',
-    'finance',
-    'legal',
-    'compliance',
-    'customer',
-    'company-building',
-    'operations',
-];
+const learningDomainData = require('../../registry/scripts/learning/learning-domains.json');
+exports.LEARNING_DOMAIN_MAP_VERSION = learningDomainData.mapVersion;
+exports.LEARNING_DOMAINS = Object.freeze(learningDomainData.domains);
+exports.JOB_DOMAIN_MAP = Object.freeze(learningDomainData.jobDomainMap);
+exports.GLOBAL_JOB_CATEGORIES = new Set(learningDomainData.globalJobCategories);
+exports.DOMAIN_VOICE = Object.freeze(learningDomainData.domainVoice);
 function isLearningDomain(value) {
     return typeof value === 'string' && exports.LEARNING_DOMAINS.includes(value);
 }
-/**
- * Registry job category -> learning domain. Seeded from the registry taxonomy and
- * the `PERSONA_CAPABILITY_BUNDLES` groupings. Every domain-scoped category maps
- * here; cross-cutting categories are listed in `GLOBAL_JOB_CATEGORIES` instead.
- *
- * A build-time test (`tests/test-unit-learning-domains.ts`) asserts that every
- * registry job category (from `registry/jobs/**`) is covered by exactly one of
- * this map or `GLOBAL_JOB_CATEGORIES`, so the taxonomy cannot silently drift as
- * new job categories are added.
- */
-exports.JOB_DOMAIN_MAP = {
-    // engineering
-    'product-building': 'engineering',
-    'dev-ops': 'engineering',
-    'quality-assurance': 'engineering',
-    'migration': 'engineering',
-    'replicate': 'engineering',
-    'reviewer': 'engineering',
-    'security': 'engineering',
-    'delivery-ops': 'engineering',
-    'salesforce': 'engineering',
-    'ai-engineering': 'engineering',
-    // product
-    'product-management': 'product',
-    'customer-development': 'product',
-    'brainstorming': 'product',
-    // go-to-market
-    'marketing': 'go-to-market',
-    'branding': 'go-to-market',
-    'sales': 'go-to-market',
-    'go-to-market': 'go-to-market',
-    'business-development': 'go-to-market',
-    'commercial-ops': 'go-to-market',
-    // people-ops
-    'people-ops': 'people-ops',
-    'inclusion-ops': 'people-ops',
-    'career': 'people-ops',
-    // finance
-    'finance': 'finance',
-    'invoicing': 'finance',
-    'banking': 'finance',
-    // legal
-    'legal': 'legal',
-    // compliance
-    'compliance': 'compliance',
-    // customer
-    'customer-success': 'customer',
-    'customer-communication': 'customer',
-    // company-building
-    'company-creation': 'company-building',
-    'bootstrap': 'company-building',
-    'fundraising': 'company-building',
-    // operations
-    'business-ops': 'operations',
-    'procurement': 'operations',
-    'project-management': 'operations',
-};
-/**
- * Cross-cutting job categories that intentionally resolve to `global` (no domain).
- * Management and framework-meta learnings apply regardless of the work domain, so
- * they are never hidden from any job. Listed explicitly so the completeness test
- * can tell an intentional global category apart from a forgotten mapping.
- */
-exports.GLOBAL_JOB_CATEGORIES = new Set([
-    // ai-employee cross-cutting
-    'manager',
-    'fraim',
-    // ai-manager (all management categories)
-    '1-1',
-    'coaching',
-    'delegation',
-    'hiring',
-    'productivity',
-    'project-setup',
-    'setup-guardrails',
-    'team-learning',
-    'verification',
-]);
-/**
- * One-line authoring voice per domain (R3). Consumed as documentation and by the
- * synthesis jobs/skills (`sleep-on-learnings`, `organizational-learning-synthesis`,
- * `l1-signal-classification`) so a domain-specific learning is written in that
- * domain's language and stays human-auditable.
- */
-exports.DOMAIN_VOICE = {
-    'engineering': 'Precise and technical; file paths, commands, and test names are appropriate.',
-    'product': 'Product and user-outcome language; behavior and flow, not code symbols.',
-    'go-to-market': 'Marketing and sales language; campaigns, funnels, messaging, audience.',
-    'people-ops': 'Plain HR and recruiting language; no engineering jargon.',
-    'finance': 'Finance and accounting language; figures, close, forecasts.',
-    'legal': 'Contract and IP language; obligations, clauses, risk.',
-    'compliance': 'Controls, evidence, and regulation language.',
-    'customer': 'Customer-relationship and support language.',
-    'company-building': 'Founder and operations language; setup, entity, funding.',
-    'operations': 'Business-operations language; process, vendors, planning, coordination.',
-};
 /**
  * Extract the registry job category from a job's registry path.
  *

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

@@ -102,11 +102,17 @@ class LocalRegistryResolver {
                 (0, path_1.join)(this.managerCacheRoot, dir),
                 (0, path_1.join)(this.orgCacheRoot, dir),
                 (0, path_1.join)(this.workspaceRoot, 'registry', dir),
+                // Installed projects have categorized job stubs in the synced roles,
+                // without a source registry checkout. Keep authored overrides first.
+                ...(type === 'jobs' ? [this.getFraimPath('ai-employee', dir), this.getFraimPath('ai-manager', dir)] : []),
             ];
             for (const root of searchRoots) {
                 const found = this.searchFileRecursively(root, baseName);
                 if (!found)
                     continue;
+                const syncedRole = ['ai-employee', 'ai-manager'].find(role => root === this.getFraimPath(role, dir));
+                if (syncedRole)
+                    return `${dir}/${syncedRole}/${found.slice(root.length + 1).replace(/\\/g, '/')}`;
                 // Convert absolute back to a registry-relative path.
                 const rel = found.replace(/\\/g, '/');
                 const dirMarker = `/${dir}/`;

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

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

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

@@ -81,6 +81,20 @@ function classifyRecurrence(store, options) {
         : 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) => entry.offered.log.some((offer) => offer.job === options.job && daysBetween(offer.date, options.date) <= options.windowDays));
     if (matchingOffers.length > 0) {
         return {
             ...base,
@@ -91,6 +105,26 @@ function classifyRecurrence(store, options) {
             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,
@@ -179,6 +213,26 @@ function firingsUnderModel(record, 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 firedCount(record) > 0 && Object.keys(record.fired.byModel).length === 0;
+}
 function earlierModelFirings(record, currentModel) {
     return Object.entries(record.fired.byModel)
         .filter(([model]) => model !== currentModel)
@@ -189,9 +243,22 @@ function latestTitle(record) {
     return record.titles[record.titles.length - 1] ?? record.key;
 }
 function findRetirementCandidates(store, options) {
-    const currentModel = options.currentModel ?? (0, learning_usage_projection_1.resolveCurrentModel)(store);
+    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 = [];
     for (const record of Object.values(store.entries)) {
@@ -204,6 +271,14 @@ function findRetirementCandidates(store, options) {
             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,
@@ -297,6 +372,7 @@ function toReportEntry(record) {
         title: latestTitle(record),
         offered: record.offered.total,
         fired: firedCount(record),
+        ignored: record.fired.byOutcome.ignored,
         lastFired: record.fired.lastFiredAt,
         firedUnder: Object.keys(record.fired.byModel),
         recentLog: record.fired.log,
@@ -320,7 +396,8 @@ function buildUsageReport(store, options) {
     return {
         generatedAt: now.toISOString(),
         windowDays: options.windowDays,
-        currentModel: (0, learning_usage_projection_1.resolveCurrentModel)(store),
+        currentModel: (0, learning_usage_projection_1.resolveCurrentModel)(options.currentModel),
+        integrityFlagged: learningRecords.filter((r) => Boolean(r.integrity)).length,
         totals: {
             entriesOffered: offered.length,
             entriesWithFirings: fired.length,

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

@@ -48,7 +48,9 @@ function buildEntryIndex(workspaceRoot, userId) {
         for (const entry of entries) {
             const fileType = fileTypeOf(entry);
             const attestable = {
-                key: entry.id ?? (0, learning_usage_store_1.titleUsageKey)(fileType, entry.title),
+                // #1752 A1: one definition of what an entry is, shared with the offer
+                // path. These two disagreeing is defect 4.
+                key: (0, learning_usage_store_1.resolveEntryIdentity)({ id: entry.id, fileType, title: entry.title }).key,
                 family: 'learning',
                 title: entry.title,
                 fileType,
@@ -142,7 +144,9 @@ function recordAttestationsFromRetrospective(workspaceRoot, userId, options) {
     let applied = 0;
     let alreadyRecorded = 0;
     if (inputs.length > 0) {
-        const result = (0, learning_usage_store_1.recordFirings)(inputs, { limits, now: options.now, storePath: options.storePath });
+        const result = (0, learning_usage_store_1.recordFirings)(inputs, {
+            limits, now: options.now, storePath: options.storePath, integrityMode: options.integrityMode,
+        });
         applied = result.recorded;
         alreadyRecorded = result.alreadyRecorded;
     }
@@ -208,6 +212,9 @@ function runBackfill(workspaceRoot, userId, options) {
             limits,
             now: options.now,
             storePath: options.storePath,
+            // A backfill reconciles hundreds of retrospectives at once, so a single
+            // stranded-offer entry must not refuse the whole run.
+            integrityMode: 'flag',
         });
         if (result.sectionState !== 'absent')
             report.filesWithSection += 1;