fraim-hub 2.0.339 → 2.0.340

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

@@ -10,6 +10,7 @@ exports.ruleUsageKey = ruleUsageKey;
 exports.resolveEntryIdentity = resolveEntryIdentity;
 exports.normalizeModelName = normalizeModelName;
 exports.readUsageSnapshot = readUsageSnapshot;
+exports.resolveUsageCheckpointPath = resolveUsageCheckpointPath;
 exports.writeUsageSnapshot = writeUsageSnapshot;
 exports.foldUsageEvents = foldUsageEvents;
 exports.readUsageStore = readUsageStore;
@@ -46,18 +47,10 @@ exports.compactUsageEvents = compactUsageEvents;
  * (`src/ai-hub/server.ts`). That placement is what satisfies R18; there is no
  * second guardrail here.
  *
- * It is derived data (R17): deleting it loses no lesson, because every firing is
- * still written in the retrospective that attested it and every offer is
- * re-recorded the next time the entry is delivered.
- *
- * ## Issue #1752 — what changed and why
- *
- * The durable artifact is now the append-only event log in
- * `learning-usage-events.ts`; `usage/learning-usage.json` is a derived snapshot
- * carrying a `foldedThroughBytes` checkpoint into it. The old read-modify-write
- * lost 1589 of 1600 writes from eight concurrent processes on a plain local disk
- * (spike S1b), which is the real cause of both the impossible `fired > offered`
- * counts and the four OneDrive conflict copies.
+ * Sleep consolidates the append-only journal into learning-usage.json and its
+ * recoverable .checkpoint copy before clearing processed events. Those snapshots
+ * preserve lifetime aggregates and source bookmarks after journal cleanup.
+ * Raw retrospectives preserve lessons and attestations, not every runtime offer.
  *
  * Four smaller corrections ride with it, each removing a place where the record
  * gave a confident answer it could not prove:
@@ -306,32 +299,45 @@ function readCheckpoints(value) {
     }
     return out;
 }
-/**
- * Parse the snapshot alone, with no event folding. A missing or corrupt snapshot
- * reads as empty: it is derived data, so losing it is recoverable and must never
- * break the loader that reads it.
- */
+/** Read the normal snapshot, recovering a missing or torn copy from its checkpoint. */
 function readUsageSnapshot(storePath = resolveUsageStorePath()) {
+    for (const candidate of [storePath, resolveUsageCheckpointPath(storePath)]) {
+        const snapshot = parseUsageSnapshot(candidate);
+        if (snapshot)
+            return snapshot;
+    }
+    if ((0, fs_1.existsSync)(resolveUsageCheckpointPath(storePath))) {
+        throw new Error('Usage snapshot and checkpoint backup are unreadable. Restore a matching backup; do not delete the usage directory.');
+    }
+    return emptyStore();
+}
+function resolveUsageCheckpointPath(storePath) {
+    return storePath + '.checkpoint';
+}
+function parseUsageSnapshot(storePath) {
     try {
         if (!(0, fs_1.existsSync)(storePath))
-            return emptyStore();
+            return null;
         const parsed = JSON.parse((0, fs_1.readFileSync)(storePath, 'utf8'));
         // `typeof [] === 'object'`, so an array has to be rejected explicitly: otherwise
         // Object.values yields whatever the array held and every consumer that reads
         // `entry.offered` throws on it.
         if (!parsed || typeof parsed !== 'object' || !parsed.entries
             || typeof parsed.entries !== 'object' || Array.isArray(parsed.entries)) {
-            return emptyStore();
+            return null;
         }
         // Drop any value that is not a usable record rather than handing a caller
         // something it will crash on. A partially corrupt store degrades to the records
-        // that are still readable, which is the right behaviour for derived data.
+        // that are still readable before consolidation. Consolidated snapshots must be complete.
         const entries = {};
         for (const [key, value] of Object.entries(parsed.entries)) {
             if (isUsableRecord(value))
                 entries[key] = value;
+            else if (parsed.consolidated)
+                return null;
         }
         return {
+            consolidated: parsed.consolidated === true,
             version: parsed.version ?? STORE_VERSION,
             updatedAt: parsed.updatedAt ?? emptyStore().updatedAt,
             entries,
@@ -342,28 +348,18 @@ function readUsageSnapshot(storePath = resolveUsageStorePath()) {
         };
     }
     catch {
-        return emptyStore();
+        return null;
     }
 }
 /**
- * Publish the derived snapshot.
- *
- * In place, with a plain `writeFileSync`, and never by rename. S3 measured a
- * rename over a target any process holds open failing EPERM 100 times in 100, on
- * both a synced and a local path, because that is Windows file-sharing semantics
- * rather than a OneDrive artefact. The usage store is read by concurrent MCP
- * processes by design, so a rename-published snapshot would fail essentially
- * always in production. This is safe precisely because the snapshot is derived: a
- * torn one is rejected by `readUsageSnapshot` and rebuilt from the log.
- *
- * Returns whether it landed. A failure is never thrown: the log is authoritative
- * and the next reader either uses the older snapshot with a longer tail, or folds
- * cold.
+ * Refresh the normal snapshot in place (Windows readers can prevent rename).
+ * Sleep alone publishes the separate flushed checkpoint backup before clearing
+ * journals, so a torn ordinary refresh can recover without replaying old history.
  */
 function writeUsageSnapshot(store, storePath = resolveUsageStorePath()) {
     try {
         (0, fs_1.mkdirSync)((0, path_1.dirname)(storePath), { recursive: true });
-        (0, fs_1.writeFileSync)(storePath, `${JSON.stringify(store, null, 2)}\n`, 'utf8');
+        (0, fs_1.writeFileSync)(storePath, `${JSON.stringify(store, null, 2)}\n`, { encoding: 'utf8', flush: true });
         return true;
     }
     catch {
@@ -385,6 +381,8 @@ function foldUsageEvents(options) {
     // A checkpoint past the end of its log means the log was compacted or replaced
     // under this snapshot, so the snapshot may already count events the log no
     // longer holds. Re-folding onto it would double count. Discard and fold cold.
+    if (tail.restarted && base.consolidated)
+        throw new Error('Usage journal no longer matches its consolidated snapshot. Restore matching checkpoint files before continuing.');
     if (tail.restarted) {
         const cold = (0, learning_usage_events_1.readEventsSince)(options.eventDir, {});
         return applyTail(emptyStore(), cold, limits, now, true);
@@ -393,6 +391,7 @@ function foldUsageEvents(options) {
 }
 function applyTail(base, tail, limits, now, restarted) {
     const store = {
+        consolidated: base.consolidated,
         version: base.version,
         updatedAt: base.updatedAt,
         entries: base.entries,
@@ -430,13 +429,23 @@ function readUsageStore(storePath = resolveUsageStorePath(), options = {}) {
     const eventDir = options.eventDir ?? (0, learning_usage_events_1.resolveEventDir)(storePath);
     if ((0, learning_usage_events_1.listEventLogs)(eventDir).length === 0)
         return snapshot;
-    const folded = foldUsageEvents({
+    const fold = (base) => foldUsageEvents({
         eventDir,
         limits: options.limits,
         now: options.now,
-        base: snapshot,
-        checkpoints: snapshot.foldedThroughBytes ?? {},
+        base,
+        checkpoints: base.foldedThroughBytes ?? {},
     });
+    let folded;
+    try {
+        folded = fold(snapshot);
+    }
+    catch (error) {
+        const backup = parseUsageSnapshot(resolveUsageCheckpointPath(storePath));
+        if (!backup)
+            throw error;
+        folded = fold(backup);
+    }
     const mode = options.refreshSnapshot ?? 'auto';
     const shouldRefresh = mode === 'always'
         || (mode === 'auto' && (folded.tailBytes >= SNAPSHOT_REFRESH_BYTES || !(0, fs_1.existsSync)(storePath) || folded.restarted));
@@ -747,7 +756,7 @@ function flagIntegrity(store) {
 /**
  * Materialize the snapshot when there is none.
  *
- * The snapshot is derived and normally published by readers, but a workspace that
+ * Before the first consolidation, readers publish snapshots, but a workspace that
  * has only ever been written to would have no snapshot at all, so every reader
  * would pay a cold fold and anything inspecting the store as a file would find
  * nothing there. Bounded: it only runs when the file is absent, and at that point
@@ -761,7 +770,7 @@ function ensureSnapshotExists(storePath, eventDir, limits, now) {
         readUsageStore(storePath, { limits, now, eventDir, refreshSnapshot: 'always' });
     }
     catch {
-        // The log is authoritative. A missing snapshot costs a cold fold, nothing else.
+        // Initial cache publication can retry; consolidated history has a separate backup.
     }
 }
 /**
@@ -899,26 +908,48 @@ function pruneUsageStore(limits, options = {}) {
     const compaction = compactUsageEvents({ eventDir, snapshotPath: storePath, limits, now, store });
     return { prunedOfferRecords, prunedFiringRecords, entries: Object.keys(store.entries).length, compaction };
 }
-/**
- * Rewrite the event logs to the configured retention window and re-base the
- * snapshot's checkpoint onto the rewritten logs.
- *
- * Re-basing is not optional: leaving a checkpoint pointing into the old log would
- * make the next reader either re-count events the snapshot already holds, or skip
- * ones it does not.
+/** Save totals and source bookmarks in both copies, then clear processed journals.
+ * Requires an interval without concurrent writers or sync activity.
  */
 function compactUsageEvents(options) {
     const now = options.now ?? new Date();
     const store = options.store
         ?? readUsageStore(options.snapshotPath, { limits: options.limits, now, eventDir: options.eventDir });
-    const result = (0, learning_usage_events_1.compactEventLogs)(options.eventDir, (event) => {
+    for (const log of (0, learning_usage_events_1.listEventLogs)(options.eventDir)) {
+        if ((store.foldedThroughBytes?.[log.machineId] ?? 0) < log.baseOffset) {
+            throw new Error('Cannot consolidate from a snapshot older than the journal checkpoint.');
+        }
+    }
+    for (const entry of Object.values(store.entries))
+        trimLogs(entry, options.limits, now);
+    store.consolidated = true;
+    store.updatedAt = now.toISOString();
+    // Publish the recoverable checkpoint first, then the normal snapshot. No
+    // journal is cleared unless both writes succeed. The backup is never written
+    // by ordinary readers, so a torn cache refresh cannot destroy both copies.
+    const checkpoint = resolveUsageCheckpointPath(options.snapshotPath);
+    const temp = checkpoint + '.tmp';
+    try {
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(checkpoint), { recursive: true });
+        (0, fs_1.writeFileSync)(temp, JSON.stringify(store, null, 2) + '\n', { encoding: 'utf8', flush: true });
+        (0, fs_1.renameSync)(temp, checkpoint);
+    }
+    catch {
+        try {
+            (0, fs_1.rmSync)(temp, { force: true });
+        }
+        catch { /* Best effort. */ }
+        throw new Error('Cannot consolidate usage events: checkpoint backup could not be saved.');
+    }
+    if (!writeUsageSnapshot(store, options.snapshotPath)) {
+        throw new Error('Cannot consolidate usage events: aggregate snapshot could not be saved.');
+    }
+    return (0, learning_usage_events_1.compactEventLogs)(options.eventDir, (event) => {
+        if (event.kind !== 'offer' && event.kind !== 'firing')
+            return true;
         const date = typeof event.date === 'string' ? event.date : '';
-        if (!isValidDate(date))
+        if (typeof event.key !== 'string' || !event.key || !isValidDate(date))
             return true;
-        return withinRetention(date, options.limits.retentionDays, now);
-    });
-    store.foldedThroughBytes = Object.fromEntries(result.logs.map((log) => [log.machineId, log.size]));
-    store.updatedAt = now.toISOString();
-    writeUsageSnapshot(store, options.snapshotPath);
-    return result;
+        return event.kind === 'firing' && !exports.FIRING_OUTCOMES.includes(event.outcome);
+    }, store.foldedThroughBytes ?? {});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-hub",
-  "version": "2.0.339",
+  "version": "2.0.340",
   "description": "FRAIM Hub local companion package.",
   "author": "Sid Mathur <sid.mathur@gmail.com>",
   "homepage": "https://github.com/mathursrus/FRAIM#readme",
@@ -18,6 +18,7 @@
   "files": [
     "dist/registry/scripts/learning/learning-domains.json",
     "dist/registry/scripts/learning/entry-format.js",
+    "dist/registry/scripts/learning/completion-state.js",
     "dist/src/ai-hub/",
     "dist/src/api/admin/payments.js",
     "dist/src/api/admin/sales-leads.js",
@@ -72,6 +73,7 @@
     "dist/src/config/stripe.js",
     "dist/src/core/brand-store.js",
     "dist/src/core/capability-pack.js",
+    "dist/src/core/handoff-contracts.js",
     "dist/src/core/quality-evidence.js",
     "dist/src/core/job-visualization.js",
     "dist/src/core/resolve-phase-edge.js",
@@ -226,7 +228,7 @@
     "electron-updater": "^6.8.9",
     "express": "^5.2.1",
     "extract-zip": "^2.0.1",
-    "fraim": "2.0.339",
+    "fraim": "2.0.340",
     "mongodb": "^7.0.0",
     "node-cron": "4.2.1",
     "node-edge-tts": "^1.2.10",

package/public/ai-hub/review.css

@@ -634,3 +634,381 @@
 
 .review-turn .review-actions { border: 0; margin: 0; padding: 0; }
 .review-turn .rb-handoff { flex-basis: 100%; }
+
+/* ===========================================================================
+   Issue #1755 - the learnings library.
+   The corpus was a flat list of full-text cards with no summary, no filter and
+   no sign of whether an entry has ever worked. These rules add the stats row,
+   the filter toolbar, the domain grouping, and the per-card strength + usage
+   footer. Every colour comes from the existing token set.
+   =========================================================================== */
+
+/* Stats row */
+.ll-stats {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 6px 14px;
+  padding: 2px 2px 12px;
+}
+.ll-stats .ll-stat {
+  display: inline-flex;
+  align-items: baseline;
+  gap: 5px;
+  font-size: 11.5px;
+  color: var(--muted);
+  white-space: nowrap;
+}
+.ll-stats .ll-stat b { font-size: 14px; font-weight: 700; color: var(--text); }
+.ll-stats .ll-total b { font-size: 16px; }
+.ll-stats .ll-stat::before {
+  content: '';
+  width: 7px; height: 7px; border-radius: 50%;
+  background: var(--muted);
+  align-self: center;
+}
+.ll-stats .ll-total::before { display: none; }
+.ll-stats .s-strong::before { background: var(--done); }
+.ll-stats .s-wouldfire::before { background: var(--warn); }
+.ll-stats .s-unresolved::before { background: var(--strength-unresolved); }
+.ll-stats .s-weak::before { background: var(--line); box-shadow: inset 0 0 0 1px var(--muted); }
+.ll-stats .s-dead::before { background: transparent; box-shadow: inset 0 0 0 1px var(--line); }
+
+/* Filter + sort toolbar */
+.ll-tools {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  flex-wrap: wrap;
+  gap: 8px;
+  padding-bottom: 12px;
+}
+.ll-tools .ll-tabs { display: flex; flex-wrap: wrap; gap: 6px; }
+.ll-tools .ll-tab {
+  font: inherit;
+  font-size: 11.5px;
+  font-weight: 600;
+  color: var(--muted);
+  background: var(--surface);
+  border: 1px solid var(--line);
+  border-radius: 999px;
+  padding: 4px 11px;
+  cursor: pointer;
+  transition: background 120ms ease, color 120ms ease, border-color 120ms ease;
+}
+.ll-tools .ll-tab:hover { color: var(--text); border-color: var(--muted); }
+.ll-tools .ll-tab.active {
+  color: var(--accent-strong);
+  background: var(--accent-soft);
+  border-color: var(--accent);
+}
+.ll-tools .ll-selects { display: flex; gap: 8px; }
+.ll-tools .ll-sel {
+  font: inherit;
+  font-size: 11.5px;
+  color: var(--text);
+  background: var(--surface);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  padding: 4px 8px;
+  cursor: pointer;
+  max-width: 190px;
+}
+.ll-tools .ll-sel:focus { outline: none; border-color: var(--accent); }
+
+/* Domain group header */
+.ll-group-head {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  margin-top: 8px;
+  padding-bottom: 5px;
+  border-bottom: 1px solid var(--line);
+}
+.learn-list > .ll-group-head:first-child { margin-top: 0; }
+.ll-group-head .llg-name {
+  font-size: 10.5px;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--text);
+}
+.ll-group-head .llg-reach { font-size: 11px; color: var(--muted); }
+.ll-group-head .llg-count {
+  margin-left: auto;
+  font-size: 11px;
+  font-weight: 600;
+  color: var(--muted);
+}
+
+/* No-match state */
+.ll-nomatch { font-size: 13px; color: var(--muted); padding: 18px 2px 4px; }
+
+/* Card: domain, strength and score badges */
+.learn-prop .lp-domain {
+  font-size: 10px;
+  font-weight: 700;
+  padding: 2px 8px;
+  border-radius: 6px;
+  letter-spacing: 0.03em;
+  flex-shrink: 0;
+  background: var(--bg);
+  color: var(--muted);
+  box-shadow: inset 0 0 0 1px var(--line);
+}
+.learn-prop .lp-domain.dom-global { color: var(--muted); }
+.learn-prop .lp-domain.dom-c0 { color: var(--domain-slot-0); box-shadow: inset 0 0 0 1px var(--domain-slot-0-ring); }
+.learn-prop .lp-domain.dom-c1 { color: var(--domain-slot-1); box-shadow: inset 0 0 0 1px var(--domain-slot-1-ring); }
+.learn-prop .lp-domain.dom-c2 { color: var(--domain-slot-2); box-shadow: inset 0 0 0 1px var(--domain-slot-2-ring); }
+.learn-prop .lp-domain.dom-c3 { color: var(--domain-slot-3); box-shadow: inset 0 0 0 1px var(--domain-slot-3-ring); }
+.learn-prop .lp-domain.dom-c4 { color: var(--domain-slot-4); box-shadow: inset 0 0 0 1px var(--domain-slot-4-ring); }
+.learn-prop .lp-domain.dom-c5 { color: var(--domain-slot-5); box-shadow: inset 0 0 0 1px var(--domain-slot-5-ring); }
+
+.learn-prop .lp-strength {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  font-size: 10.5px;
+  font-weight: 700;
+  padding: 2px 8px 2px 6px;
+  border-radius: 6px;
+  flex-shrink: 0;
+  background: var(--bg);
+  color: var(--muted);
+}
+.learn-prop .lp-strength .lp-dot {
+  width: 6px; height: 6px; border-radius: 50%; background: currentColor;
+  flex-shrink: 0;
+}
+.learn-prop .lp-strength.s-strong { color: var(--done); }
+.learn-prop .lp-strength.s-wouldfire { color: var(--warn); }
+.learn-prop .lp-strength.s-unresolved { color: var(--strength-unresolved); }
+.learn-prop .lp-strength.s-weak { color: var(--muted); }
+.learn-prop .lp-strength.s-dead { color: var(--muted); opacity: 0.65; }
+.learn-prop .lp-strength.s-dead .lp-dot { background: transparent; box-shadow: inset 0 0 0 1px currentColor; }
+
+.learn-prop .lp-score {
+  font-size: 11px;
+  font-weight: 700;
+  font-variant-numeric: tabular-nums;
+  color: var(--muted);
+  background: var(--bg);
+  border-radius: 6px;
+  padding: 2px 7px;
+  flex-shrink: 0;
+}
+
+/* Card body clamp */
+.learn-prop .lp-body.lp-clamped {
+  display: -webkit-box;
+  -webkit-line-clamp: 3;
+  line-clamp: 3;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+}
+.learn-prop .lp-more {
+  align-self: flex-start;
+  font: inherit;
+  font-size: 11.5px;
+  font-weight: 600;
+  color: var(--accent);
+  background: none;
+  border: none;
+  padding: 0;
+  margin-top: -2px;
+  cursor: pointer;
+}
+.learn-prop .lp-more:hover { color: var(--accent-strong); text-decoration: underline; }
+
+/* Card usage footer */
+.learn-prop .lp-stats {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 6px 12px;
+  margin-top: 2px;
+  padding-top: 9px;
+  border-top: 1px solid var(--line);
+  font-size: 11px;
+  color: var(--muted);
+}
+.learn-prop .lp-stats .lps-none { font-style: italic; }
+.learn-prop .lp-bar {
+  display: flex;
+  width: 68px;
+  height: 4px;
+  border-radius: 999px;
+  overflow: hidden;
+  background: var(--line);
+  flex-shrink: 0;
+}
+.learn-prop .lp-bar i { display: block; height: 100%; }
+.learn-prop .lp-bar .lb-applied { background: var(--done); }
+.learn-prop .lp-bar .lb-prevented { background: var(--accent); }
+.learn-prop .lp-bar .lb-ignored { background: var(--warn); }
+.learn-prop .lp-stats .lps-counts { display: flex; flex-wrap: wrap; gap: 10px; }
+.learn-prop .lp-stats .lps-c { display: inline-flex; align-items: baseline; gap: 4px; }
+.learn-prop .lp-stats .lps-c b { font-weight: 700; color: var(--text); font-variant-numeric: tabular-nums; }
+.learn-prop .lp-stats .lps-last { margin-left: auto; white-space: nowrap; }
+
+/* Domain select in the inline editor */
+.learn-prop .lp-edit-domain {
+  font: inherit; font-size: 12px; padding: 6px 8px; border: 1px solid var(--line);
+  border-radius: 8px; background: var(--surface); color: var(--text);
+}
+.learn-prop .lp-edit-domain:focus { outline: none; border-color: var(--accent); }
+
+/* Collapsed sections (below-threshold + archived). These had no rules at all,
+   so they rendered as an unstyled details block in the middle of a card list. */
+.learn-dormant-section {
+  border: 1px dashed var(--line);
+  border-radius: 14px;
+  padding: 4px 12px;
+  background: transparent;
+}
+.learn-dormant-section > .learn-dormant-header {
+  font-size: 11.5px;
+  font-weight: 600;
+  color: var(--muted);
+  padding: 8px 2px;
+  cursor: pointer;
+  list-style: none;
+}
+.learn-dormant-section > .learn-dormant-header::-webkit-details-marker { display: none; }
+.learn-dormant-section > .learn-dormant-header::before {
+  content: '\25B8';
+  display: inline-block;
+  width: 12px;
+  transition: transform 140ms ease;
+}
+.learn-dormant-section[open] > .learn-dormant-header::before { transform: rotate(90deg); }
+.learn-dormant-section > .learn-prop {
+  margin-bottom: 10px;
+  background: var(--bg);
+}
+
+
+/* Issue #1755: entries are authored as short labelled lines (Takeaway / Why this
+   matters / Example / What to do next). Collapsing them into one paragraph is
+   what made the readable ones read like the dense ones. */
+.learn-prop .lp-body { white-space: pre-line; }
+
+/* The provenance tail, revealed with the rest of the entry. */
+.learn-prop .lp-prov {
+  white-space: pre-line;
+  font-size: 11.5px;
+  line-height: 1.55;
+  color: var(--muted);
+  border-left: 2px solid var(--line);
+  padding-left: 10px;
+}
+
+/* Issue #1755: the accordion body is a capped scroll region (.ctx-acc-body), so
+   the library's summary and controls pin to its top rather than scrolling out of
+   reach behind a hundred cards. */
+.ll-head {
+  position: sticky;
+  top: -4px;
+  z-index: 2;
+  background: var(--ll-head-bg);
+  margin: -4px -2px 0;
+  padding: 6px 2px 0;
+  box-shadow: var(--ll-head-shadow);
+}
+.ll-head .ll-tools { padding-bottom: 10px; }
+
+/* Issue #1755 R6: the proposal card's two zones. Configuration sits in a recessed
+   block so the controls that change what gets written read as settings, and the
+   decision sits below a hairline so it reads as the commit. */
+.learn-prop .lp-config {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  background: var(--lp-recessed);
+  border-radius: 10px;
+  padding: 9px 11px 11px;
+  margin-top: 2px;
+}
+.learn-prop .lp-config .lp-config-head {
+  font-size: 10px;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--muted);
+}
+.learn-prop .lp-config .lp-actions { margin-top: 0; }
+.learn-prop .lp-decide {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 10px;
+  margin-top: 2px;
+  padding-top: 10px;
+  border-top: 1px solid var(--line);
+}
+.learn-prop .lp-decide .lp-scope-note { margin-left: auto; text-align: right; }
+.learn-prop .lp-decided-badge {
+  font-size: 10.5px;
+  font-weight: 700;
+  padding: 2px 9px;
+  border-radius: 999px;
+  letter-spacing: 0.02em;
+}
+/* Tinted with its own outcome colour rather than --accent-soft: an org brand
+   overrides --accent, and a purple-tinted pill around green text reads as two
+   unrelated signals. */
+.learn-prop .lp-decided-badge.is-saved { background: var(--bg); color: var(--done); box-shadow: inset 0 0 0 1px currentColor; }
+.learn-prop .lp-decided-badge.is-skipped { background: var(--bg); color: var(--muted); box-shadow: inset 0 0 0 1px var(--line); }
+
+/* Issue #1755: at a narrow panel width the head row's badges (domain, category,
+   priority, strength) plus the score chip outrun the row, and an unbreakable
+   title word pushes the card into horizontal overflow. Let the row wrap and let
+   a long title break, rather than letting the card scroll sideways. */
+.learn-prop .lp-head { flex-wrap: wrap; row-gap: 6px; }
+/* A 220px basis is the hinge: while that much room is left after the badges the
+   title stays on their line, and below it the title takes a full row of its own
+   instead of being squeezed into a four-word-wide column. */
+.learn-prop .lp-head .lp-title { flex: 1 1 220px; overflow-wrap: break-word; }
+
+/* Issue #1755: the row actions were display:none until hover, which takes them out
+   of the tab order entirely: a keyboard or screen-reader manager could not reach
+   Edit or Delete at all, and Edit is now also where an entry is re-scoped. Hide
+   them visually instead of structurally, and reveal on focus as well as hover.
+   Reserving their space also stops the title reflowing every time the pointer
+   crosses a card. */
+.learn-prop .lp-act {
+  display: inline-flex;
+  opacity: 0;
+  transition: opacity 120ms ease;
+}
+.learn-prop:hover .lp-act,
+.learn-prop:focus-within .lp-act,
+.learn-prop .lp-act:focus-visible { opacity: 1; }
+.learn-prop .lp-act:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
+.ll-tools .ll-tab:focus-visible,
+.ll-tools .ll-sel:focus-visible,
+.learn-prop .lp-more:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: 2px;
+}
+
+/* Issue #1755 R5: the sleep-on-learnings proposal set, rendered in the
+   conversation where the job wrote it. Full conversation width, because a
+   proposal carries a lesson body, a configuration zone and a decision. */
+.learn-proposal-turn .bubble {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  width: 100%;
+  max-width: 100%;
+  box-sizing: border-box;
+}
+.learn-proposal-turn .review-turn-label { margin-bottom: 0; }
+.learn-proposal-turn .learn-batch {
+  background: var(--lp-raised);
+  border: 1px solid var(--lp-raised-line);
+  border-radius: 12px;
+  padding: 9px 12px;
+}
+.learn-proposal-turn .learn-list { gap: 10px; }
+.learn-proposal-turn .learn-prop { background: var(--surface); }