fraim-hub 2.0.338 → 2.0.340

package/public/ai-hub/script.js

@@ -4186,6 +4186,9 @@ function renderActive() {
   // Issue #512 R7 — review experience: completion card + format artifact strip
   // + unified action bar (review actions sit beside the always-on coaching chips).
   renderReviewExperience(conv);
+  // Issue #1755 R5: the proposals are written into this conversation, so this is
+  // where they are acted on.
+  renderLearningProposalTurn(conv);
   // Issue #848 — "What's next?" chips below a completed conversation (post-retro).
   renderNextJobRecommendations(conv);
   renderDeliverablesBar(conv);
@@ -5660,6 +5663,26 @@ function latestEmployeeSurfaceText(conv) {
   return '';
 }
 
+/**
+ * Issue #1755: a sleep-on-learnings message carries its proposal set as a
+ * "## Pending Review" markdown block. That block is the Hub's input, not prose
+ * the manager should read: it renders below as cards they can act on. Printing
+ * both puts every lesson title on the screen twice.
+ *
+ * Only the block is dropped, and only when the cards are actually rendering.
+ * Whatever the job wrote above it (its analysis summary) is what the manager
+ * came to read, so that stays. When no cards render, nothing is stripped, so a
+ * proposal set can never go missing.
+ */
+function tfStripRenderedProposalBlock(text, conv) {
+  const raw = String(text || '');
+  if (!conv || conv.jobId !== 'sleep-on-learnings') return raw;
+  const marker = raw.search(/^##\s*Pending Review\s*$/im);
+  if (marker === -1) return raw;
+  if (typeof tfConvHasProposals !== 'function' || !tfConvHasProposals(conv)) return raw;
+  return raw.slice(0, marker).trimEnd();
+}
+
 function appendMessageDom(role, text, conv, message) {
   const article = document.createElement('article');
   article.className = 'message ' + role;
@@ -5723,7 +5746,7 @@ function appendMessageDom(role, text, conv, message) {
     // surfaceText collapses whitespace which destroys markdown. Only use it
     // when it returned a transformed value (Started/Resumed prefix overrides).
     const useSurfaced = surfaced && surfaced !== raw.replace(/\s+/g, ' ').trim();
-    const content = useSurfaced ? surfaced : raw;
+    const content = tfStripRenderedProposalBlock(useSurfaced ? surfaced : raw, conv);
     bubble.innerHTML = formatEmployeeText(content || (conv.status === 'completed' ? 'Done, please review.' : 'Working on it…'));
   } else {
     bubble.textContent = role === 'manager' ? managerBubbleText(text) : (surfaceText(role, text, conv) || text);
@@ -6502,6 +6525,7 @@ function normalizeReviewAction(raw, index) {
 
 function normalizeReviewHandoff(raw) {
   if (!raw || typeof raw !== 'object' || typeof raw.reviewRequired !== 'boolean') return null;
+  const producingJobName = typeof raw.producingJobName === 'string' ? raw.producingJobName.trim() : '';
   const artifacts = Array.isArray(raw.artifacts)
     ? raw.artifacts.map(normalizeReviewArtifact).filter(Boolean)
     : [];
@@ -6517,6 +6541,7 @@ function normalizeReviewHandoff(raw) {
   if (!raw.reviewRequired) {
     return {
       reviewRequired: false,
+      ...(producingJobName ? { producingJobName } : {}),
       reviewTarget: rawTarget ? { type: targetType || 'none', label: targetLabel || 'Completed work' } : null,
       artifacts,
       summary: typeof raw.summary === 'string' ? raw.summary.trim() : '',
@@ -6531,6 +6556,7 @@ function normalizeReviewHandoff(raw) {
     if (artifacts.length > 0) return null;
     return {
       reviewRequired: true,
+      ...(producingJobName ? { producingJobName } : {}),
       reviewTarget: { type: 'pull_request', label: targetLabel || 'Pull request', url },
       artifacts: [],
       summary: typeof raw.summary === 'string' ? raw.summary.trim() : '',
@@ -6540,9 +6566,10 @@ function normalizeReviewHandoff(raw) {
   }
 
   const fileArtifacts = artifacts.filter((artifact) => artifact.path && !artifact.url);
-  if (targetType === 'artifact_set' && fileArtifacts.length > 0 && fileArtifacts.length === artifacts.length) {
+  if (targetType === 'artifact_set' && fileArtifacts.length === artifacts.length) {
     return {
       reviewRequired: true,
+      ...(producingJobName ? { producingJobName } : {}),
       reviewTarget: { type: 'artifact_set', label: targetLabel || `${artifacts.length || 1} artifact${artifacts.length === 1 ? '' : 's'}` },
       artifacts: fileArtifacts,
       summary: typeof raw.summary === 'string' ? raw.summary.trim() : '',
@@ -7014,6 +7041,18 @@ function renderReviewExperience(conv) {
       const label = document.createElement('div');
       label.className = 'review-turn-label';
       label.textContent = 'Ready for your review';
+      // A settled review keeps the producer captured with its own handoff,
+      // even after another job submits work in this conversation.
+      try {
+        const handoff = normalizeReviewHandoff(JSON.parse(turn.signature));
+        if (handoff && handoff.producingJobName && handoff.producingJobName !== conv.jobId) {
+          const job = resolveNextJobFromCatalog(handoff.producingJobName);
+          const producer = document.createElement('span');
+          producer.className = 'js-review-job';
+          producer.textContent = (job && job.title) || humanizeSlug(handoff.producingJobName);
+          label.replaceChildren(producer);
+        }
+      } catch { /* Older/imported review history keeps the default label. */ }
       bubble.appendChild(label);
       row.appendChild(bubble);
       host.insertBefore(row, rows[turn.messageCount] || host.querySelector('#deliverables-bar, #next-job-section'));
@@ -7042,6 +7081,63 @@ function renderReviewExperience(conv) {
   }
 }
 
+// Issue #1755 R5: a sleep-on-learnings run writes its proposal set into its own
+// conversation as markdown. Render it there as an actionable review turn rather
+// than leaving the manager to find the controls in a panel on another page.
+//
+// The turn is rebuilt on every conversation render, because the thread itself is
+// rebuilt on the poll cadence and a decision changes what the cards show.
+function renderLearningProposalTurn(conv) {
+  const host = els['messages'];
+  if (!host) return;
+  const existing = host.querySelector('#learn-proposal-turn');
+  if (existing) existing.remove();
+  if (!conv || conv.jobId !== 'sleep-on-learnings' || !tfConvHasProposals(conv)) return;
+
+  // The scope the run was asked for decides where an approved lesson is written.
+  const scope = tfProposalScopeForConversation(conv);
+  const proposals = tfParsePendingProposals(conv, scope);
+  if (!proposals.length) return;
+  // Keep the relay pointed at this run even if the accordion never registered it.
+  tfLearningRunByScope[tfLearningRunKey(scope)] = conv;
+
+  const row = document.createElement('article');
+  row.className = 'message employee review-turn learn-proposal-turn';
+  row.id = 'learn-proposal-turn';
+  row.dataset.testid = 'learn-proposal-turn';
+  const bubble = document.createElement('div');
+  bubble.className = 'bubble';
+
+  const label = document.createElement('div');
+  label.className = 'review-turn-label';
+  const undecided = proposals.filter((p) => !tfProposalDecisions[p.id]).length;
+  label.textContent = undecided
+    ? `${undecided} lesson${undecided === 1 ? '' : 's'} waiting on your decision`
+    : 'Lessons reviewed';
+  bubble.appendChild(label);
+
+  bubble.appendChild(tfLearningBatchBar(proposals, scope));
+  const list = document.createElement('div');
+  list.className = 'learn-list';
+  for (const p of proposals) list.appendChild(tfProposalCard(p, scope));
+  bubble.appendChild(list);
+
+  row.appendChild(bubble);
+  // Below the thread, above the deliverables/next-job furniture.
+  host.insertBefore(row, host.querySelector('#deliverables-bar, #next-job-section'));
+}
+
+// Which corpus an approved proposal from this run belongs to. The kickoff text
+// names it, because `tfRunShareLearnings` writes the scope word into the message
+// it starts the run with; a run started another way defaults to the manager's own
+// corpus, which is where sleep-on-learnings writes when nothing narrows it.
+function tfProposalScopeForConversation(conv) {
+  const kickoff = typeof rawKickoffText === 'function' ? (rawKickoffText(conv) || '') : '';
+  if (/\borganization\b|\bcompany\b/i.test(kickoff)) return 'org';
+  if (/\bproject\b/i.test(kickoff)) return 'project';
+  return 'manager';
+}
+
 // Issue #848: "What's next?" chips below a completed conversation.
 function clearNextJobSection() {
   const messages = els['messages'];
@@ -12288,6 +12384,12 @@ async function tfSelectProjectView(view, projectId) {
       // a switched project never shows the prior project's learnings.
       delete tfPreservedCache()[tfLearnKey('manager', 'project')];
       delete tfThresholdCache()[tfLearnKey('manager', 'project')];
+      // #1755: the library's filters and expansions are per-corpus too. Carrying a
+      // domain filter into a project that has no entries in that domain leaves the
+      // manager looking at an empty list they did not ask for.
+      if (state._learningFilters) delete state._learningFilters[tfLearnKey('manager', 'project')];
+      if (state._learningDomains) delete state._learningDomains[tfLearnKey('manager', 'project')];
+      state._learningExpanded = {};
       tf._lastWorkspaceProject = tf.activeProjectId;
     }
     tfRenderTree();
@@ -14737,6 +14839,41 @@ const tfLearningRunByScope = { org: null, manager: null, project: null, reverse:
 function tfLearningRunKey(scope) {
   return scope === 'org' ? 'org' : scope === 'reverse' ? 'reverse' : 'manager';
 }
+
+/** True when a conversation's employee turns carry a sleep-on-learnings proposal set. */
+function tfConvHasProposals(conv) {
+  if (!conv || !Array.isArray(conv.messages)) return false;
+  const text = conv.messages.filter((m) => m && m.role === 'employee').map((m) => m.text || '').join('\n');
+  return /pending review/i.test(text) && /####\s*\[?P-(CRITICAL|HIGH|MED|LOW)\]?/i.test(text);
+}
+
+/**
+ * Issue #1755: find the run whose proposals this scope should act on.
+ *
+ * `tfLearningRunByScope` is a session-local map that only the accordion's own
+ * "Sleep on learnings" button writes to, and it is empty on every page load. A
+ * run started from the Kanban board, from a schedule, from the composer, or
+ * simply revisited after a reload left the proposals with no controls anywhere.
+ * The conversation record is the durable source, so fall back to it and cache
+ * the hit so a later Bless/Skip still relays into the right run.
+ */
+function tfFindLearningRun(scope) {
+  const key = tfLearningRunKey(scope);
+  const registered = tfLearningRunByScope[key];
+  if (tfConvHasProposals(registered)) return registered;
+  const list = (state.conversations && state.conversations[state.projectPath]) || [];
+  // Most recent first: the newest proposal set is the one awaiting a decision.
+  const candidates = list
+    .filter((c) => c && c.jobId === 'sleep-on-learnings' && tfConvHasProposals(c))
+    .sort((a, b) => (conversationTimestamp(b) || 0) - (conversationTimestamp(a) || 0));
+  // Prefer a run asked for at THIS scope. A decision is relayed into the run as a
+  // manager turn, and the job writes it to the corpus that run was scoped to, so
+  // picking the newest run regardless of scope could apply a manager-level
+  // decision to the company corpus when both have a set pending.
+  const found = candidates.find((c) => tfProposalScopeForConversation(c) === scope) || candidates[0];
+  if (found) tfLearningRunByScope[key] = found;
+  return found || registered || null;
+}
 // Per-scope decision record so a blessed/skipped proposal stays resolved in the
 // UI after the relay (the durable write is the job's apply phase, not the Hub).
 const tfProposalDecisions = {};
@@ -14807,7 +14944,7 @@ function tfParseLevelWord(raw) {
 // approve → "Approve as-is" ; reject → "Reject (skip)". The job's review-pending
 // phase consumes the decision and its apply phase performs the durable write.
 async function tfRelayProposalDecision(scope, proposal, decision) {
-  const conv = tfLearningRunByScope[tfLearningRunKey(scope)];
+  const conv = tfFindLearningRun(scope);
   const verb = decision === 'approve' ? 'Approve as-is' : 'Reject (skip)';
   const message = `${verb} the proposal: "${proposal.title}".`;
   tfProposalDecisions[proposal.id] = decision;
@@ -14856,6 +14993,9 @@ async function tfRunShareLearnings(scope) {
 // #533: per-(scope:level) cache of preserved learning entries read from disk via
 // GET /api/ai-hub/learnings, so each section can DISPLAY and edit them. Keyed by
 // `${scope}:${level}` (e.g. manager:machine, manager:project); `undefined` = unloaded.
+// Issue #1755: below this many entries the list is already scannable, so the
+// filter toolbar would be chrome with nothing to do. The stats row still shows.
+const TF_LEARN_TOOLBAR_MIN = 6;
 function tfPreservedCache() { if (!state._preservedLearnings) state._preservedLearnings = {}; return state._preservedLearnings; }
 function tfThresholdCache() { if (!state._learningThresholds) state._learningThresholds = {}; return state._learningThresholds; }
 function tfLearnKey(scope, level) { return scope + ':' + level; }
@@ -14866,6 +15006,12 @@ async function tfFetchPreservedLearnings(scope, level) {
     const data = await requestJson('/api/ai-hub/learnings?' + params.toString());
     tfPreservedCache()[tfLearnKey(scope, level)] = Array.isArray(data.entries) ? data.entries : [];
     if (typeof data.threshold === 'number') tfThresholdCache()[tfLearnKey(scope, level)] = data.threshold;
+    // #1755 R9: the valid domains travel with the corpus so the re-scope selector
+    // offers every domain, not only the ones already in use.
+    if (Array.isArray(data.domains)) {
+      if (!state._learningDomains) state._learningDomains = {};
+      state._learningDomains[tfLearnKey(scope, level)] = data.domains;
+    }
   } catch {
     tfPreservedCache()[tfLearnKey(scope, level)] = [];
   }
@@ -14927,6 +15073,23 @@ function tfLearningEditor(opts) {
   for (const p of ['P-CRITICAL', 'P-HIGH', 'P-MED', 'P-LOW']) { const o = document.createElement('option'); o.value = p; o.textContent = p.replace('P-', ''); prio.appendChild(o); }
   prio.value = (entry && entry.severity) || 'P-MED';
   row.appendChild(prio);
+  // Issue #1755 R4: domain is the entry's reach, and it used to be changeable only
+  // by renaming a file on disk. Here it is a control, and saving moves the entry.
+  const domSel = document.createElement('select');
+  domSel.className = 'lp-edit-domain';
+  domSel.dataset.testid = 'lp-edit-domain';
+  domSel.setAttribute('aria-label', 'Domain this learning applies to');
+  const currentDomain = tfLearnDomainLabel(entry && entry.domain);
+  const catalogue = tfDomainCatalogue(tfLearnKey(scope, level));
+  const domainOptions = catalogue.indexOf(currentDomain) === -1 ? catalogue.concat([currentDomain]) : catalogue;
+  for (const d of domainOptions) {
+    const o = document.createElement('option');
+    o.value = d;
+    o.textContent = d === 'global' ? 'global: every job' : d + ' jobs only';
+    domSel.appendChild(o);
+  }
+  domSel.value = currentDomain;
+  row.appendChild(domSel);
   const titleIn = document.createElement('input'); titleIn.className = 'lp-edit-title'; titleIn.type = 'text';
   titleIn.placeholder = 'Title'; titleIn.value = (entry && entry.title) || '';
   row.appendChild(titleIn);
@@ -14948,8 +15111,14 @@ function tfLearningEditor(opts) {
     save.disabled = true; save.textContent = 'Saving…'; err.textContent = '';
     try {
       await tfWriteLearning(isNew
-        ? { action: 'add', scope, level, category, severity: prio.value, title, body: bodyIn.value }
-        : { action: 'edit', scope, level, category, originalTitle: entry.title, severity: prio.value, title, body: bodyIn.value },
+        ? { action: 'add', scope, level, category, domain: domSel.value, severity: prio.value, title, body: bodyIn.value }
+        : {
+          action: 'edit', scope, level, category,
+          // `domain` is where the entry lives now; `targetDomain` is where it should
+          // live after the save. The server moves the file when they differ.
+          domain: currentDomain, targetDomain: domSel.value,
+          originalTitle: entry.title, severity: prio.value, title, body: bodyIn.value,
+        },
         scope, level);
     } catch (e) {
       save.disabled = false; save.textContent = isNew ? 'Add' : 'Save';
@@ -14959,14 +15128,347 @@ function tfLearningEditor(opts) {
   return form;
 }
 
-// A preserved learning card with category + priority + title + body, plus Edit and
-// Delete that write the underlying file (#533 #3) at the card's scope/level.
+// ── Issue #1755: the learnings library ──────────────────────────────────────
+// The corpus is the manager's, and until now the only thing the Hub showed of it
+// was a flat list of full-text cards. These helpers add the three facts the
+// manager could not see: which jobs an entry reaches (its domain), whether it has
+// ever worked (its usage), and how the two together rate it (its strength).
+
+// Domains are read from the corpus response so the filter offers every valid
+// domain rather than only the ones already in use. Keyed by `${scope}:${level}`.
+function tfDomainCatalogue(key) {
+  const all = state._learningDomains || {};
+  return Array.isArray(all[key]) && all[key].length ? all[key] : ['global'];
+}
+
+function tfLearnDomainLabel(domain) {
+  return (!domain || domain === 'global') ? 'global' : domain;
+}
+
+// A stable per-domain colour slot, so the same domain reads the same everywhere
+// without hard-coding a colour per domain name.
+const TF_DOMAIN_SLOTS = 6;
+function tfLearnDomainClass(domain) {
+  const d = tfLearnDomainLabel(domain);
+  if (d === 'global') return 'dom-global';
+  let h = 0;
+  for (let i = 0; i < d.length; i++) h = (h * 31 + d.charCodeAt(i)) % 9973;
+  return 'dom-c' + (h % TF_DOMAIN_SLOTS);
+}
+
+function tfDaysSince(iso) {
+  if (!iso) return null;
+  const t = Date.parse(iso);
+  if (!isFinite(t)) return null;
+  return Math.floor((Date.now() - t) / 86400000);
+}
+
+// "2d ago" / "3mo ago" / "today". Returns null when there is no date at all, so a
+// caller renders "never offered" rather than a fabricated recency.
+function tfRelDays(iso) {
+  const d = tfDaysSince(iso);
+  if (d === null) return null;
+  if (d <= 0) return 'today';
+  if (d === 1) return 'yesterday';
+  if (d < 30) return d + 'd ago';
+  if (d < 365) return Math.round(d / 30) + 'mo ago';
+  return Math.round(d / 365) + 'y ago';
+}
+
+// Neural strength: what the counters say about whether an entry is working.
+// Order matters: dormancy and mis-targeting are read before the firing ratio,
+// because an entry nobody sees any more cannot be called strong on old firings.
+// The strength classifier's policy, named so a reader can question the thresholds
+// without reading the function, and so changing one is a single edit.
+const TF_STRENGTH_POLICY = {
+  /** An entry below the injection threshold and unseen this long is Dead. */
+  deadAfterDays: 90,
+  /** Fewest attestations before the not-applicable ratio means anything. */
+  minAttestationsToJudge: 3,
+  /** At or above this share of not-applicable attestations, the entry is Unresolved. */
+  unresolvedNotApplicableRatio: 0.5,
+  /** Fewest firings before a firing ratio means anything. */
+  minFiringsForStrong: 3,
+  /** At or above this firings-per-offer ratio, the entry is Strong. */
+  strongFiringRatio: 0.2,
+  /** Fewest ignores before consistent passing-over means anything. */
+  minIgnoresForWouldFire: 3,
+};
+
+function tfLearningStrength(entry) {
+  const u = (entry && entry.usage) || null;
+  const offered = u ? (u.offered || 0) : 0;
+  const applied = u ? (u.applied || 0) : 0;
+  const prevented = u ? (u.prevented || 0) : 0;
+  const ignored = u ? (u.ignored || 0) : 0;
+  const notApplicable = u ? (u.notApplicable || 0) : 0;
+  const fired = applied + prevented;
+  const attested = fired + ignored + notApplicable;
+  const daysSinceOffered = tfDaysSince(u && u.lastOfferedAt);
+  // Dead: below the injection threshold AND not offered in the last 90 days.
+  const P = TF_STRENGTH_POLICY;
+  if (entry && entry.injected === false && (daysSinceOffered === null || daysSinceOffered > P.deadAfterDays)) return 'dead';
+  // Unresolved: at least half of the attestations said the entry did not apply -
+  // it is being offered into the wrong contexts.
+  if (attested >= P.minAttestationsToJudge && notApplicable / attested >= P.unresolvedNotApplicableRatio) return 'unresolved';
+  // Strong: it fires often enough relative to how often it is offered.
+  if (fired >= P.minFiringsForStrong && (offered === 0 || fired / offered >= P.strongFiringRatio)) return 'strong';
+  // Would-fire: offered repeatedly and consistently passed over.
+  if (ignored >= P.minIgnoresForWouldFire && ignored > fired) return 'wouldfire';
+  // Weak: offered but not yet proven either way.
+  return 'weak';
+}
+
+const TF_STRENGTH_META = {
+  strong: { label: 'Strong', rank: 0, hint: 'Fires often relative to how often it is offered.' },
+  wouldfire: { label: 'Would-fire', rank: 1, hint: 'Offered repeatedly and consistently passed over. The wording may be too broad.' },
+  unresolved: { label: 'Unresolved', rank: 2, hint: 'Most attestations say it did not apply. It is reaching the wrong jobs.' },
+  weak: { label: 'Weak', rank: 3, hint: 'Offered, but not yet proven either way.' },
+  dead: { label: 'Dead', rank: 4, hint: 'Below the injection threshold and not offered in over 90 days.' },
+};
+function tfStrengthMeta(key) { return TF_STRENGTH_META[key] || TF_STRENGTH_META.weak; }
+
+const TF_PRIO_RANK = { 'P-CRITICAL': 0, 'P-HIGH': 1, 'P-MED': 2, 'P-LOW': 3 };
+
+// Per-section toolbar state, so a re-render (poll, write, project switch back)
+// does not silently reset the manager's filter to All.
+function tfLearnFilters(key) {
+  if (!state._learningFilters) state._learningFilters = {};
+  if (!state._learningFilters[key]) state._learningFilters[key] = { strength: 'all', domain: 'all', sort: 'strength' };
+  return state._learningFilters[key];
+}
+
+// Which card bodies the manager has expanded. Bodies are clamped by default -
+// the corpus averages over 100 words an entry, and an unclamped list of 121 of
+// them is the readability defect #1755 names.
+/** A lesson longer than this, or taller than the clamp, gets a Show more control. */
+const TF_CLAMP_CHARS = 220;
+const TF_CLAMP_LINES = 3;
+
+function tfLearnExpanded() {
+  if (!state._learningExpanded) state._learningExpanded = {};
+  return state._learningExpanded;
+}
+function tfLearnCardKey(entry, key) { return key + '|' + (entry.id || entry.title || ''); }
+
+// Synthesis writes a provenance tail onto each entry (Domain, Originating job,
+// Sources, Details and friends). It is bookkeeping, not the lesson, and it is
+// roughly half the text of a typical entry. Split it off so the card leads with
+// what the lesson says and keeps the trail one click away.
+const TF_PROVENANCE_LINE = /^(Domain|Domain basis|Originating jobs?|First recorded|Last recorded|Sources?|Details|Users|Scope|Applies to|Technical trace|Id)\s*:/i;
+// Issue #1755 compliance requirement: the library must not surface raw file paths
+// or user identifiers. Synthesis writes both into an entry's `Sources:` line as a
+// full absolute path ending in `<email>-<family>.md`. Shorten it to the repo-relative
+// file it names, with the owner prefix dropped: the manager already knows whose
+// corpus they are reading, and the absolute path is noise on every entry.
+function tfRedactProvenance(text) {
+  return String(text)
+    // Absolute path -> the part from the learnings root onward.
+    .replace(/(?:[A-Za-z]:)?[\\/][^\s,;]*?(fraim[\\/]personalized-employee[\\/][^\s,;]*)/gi, '$1')
+    // `<owner>-<family>.md` -> `<family>.md`.
+    .replace(/([\\/])[^\s\\/]*?@[^\s\\/]*?-([a-z-]+\.md)/gi, '$1$2')
+    // Any remaining bare address in the provenance prose.
+    .replace(/\b[\w.+-]+@[\w.-]+\.[A-Za-z]{2,}\b/g, 'you');
+}
+
+function tfSplitLessonAndProvenance(text) {
+  const lines = String(text).split('\n');
+  const lesson = [];
+  const provenance = [];
+  // A provenance key opens a run that continues until the next blank line, because
+  // a value like `Details: ...` wraps. Runs appear both before the lesson (`Scope:`)
+  // and after it (the `Domain` / `Sources` tail), so this filters rather than cuts.
+  let inRun = false;
+  for (const line of lines) {
+    const t = line.trim();
+    if (TF_PROVENANCE_LINE.test(t)) { inRun = true; provenance.push(line); continue; }
+    if (inRun) {
+      if (!t) { inRun = false; provenance.push(''); continue; }
+      provenance.push(line);
+      continue;
+    }
+    lesson.push(line);
+  }
+  const lessonText = lesson.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+  // An entry that is nothing but bookkeeping still has to render something, so fall
+  // back to showing it whole rather than a card with an empty body.
+  if (!lessonText) return { lesson: String(text).trim(), provenance: '' };
+  return {
+    lesson: lessonText,
+    provenance: tfRedactProvenance(provenance.join('\n').replace(/\n{3,}/g, '\n\n').trim()),
+  };
+}
+
+function tfSortLearnings(entries, sort) {
+  const byScore = (e) => (typeof e.score === 'number' ? e.score : -Infinity);
+  const copy = entries.slice();
+  copy.sort((a, b) => {
+    if (sort === 'score') return byScore(b) - byScore(a);
+    if (sort === 'priority') {
+      const d = (TF_PRIO_RANK[a.severity] ?? 9) - (TF_PRIO_RANK[b.severity] ?? 9);
+      if (d) return d;
+      return byScore(b) - byScore(a);
+    }
+    const d = tfStrengthMeta(tfLearningStrength(a)).rank - tfStrengthMeta(tfLearningStrength(b)).rank;
+    if (d) return d;
+    return byScore(b) - byScore(a);
+  });
+  return copy;
+}
+
+function tfLearnMatchesFilters(entry, f) {
+  if (f.strength !== 'all' && tfLearningStrength(entry) !== f.strength) return false;
+  if (f.domain !== 'all' && tfLearnDomainLabel(entry.domain) !== f.domain) return false;
+  return true;
+}
+
+// The stats row: how the corpus is doing, in one line, before any card is read.
+function tfLearnStatsBar(entries) {
+  const bar = document.createElement('div');
+  bar.className = 'll-stats';
+  bar.dataset.testid = 'learn-stats';
+  const total = document.createElement('span');
+  total.className = 'll-stat ll-total';
+  const totalNum = document.createElement('b');
+  totalNum.textContent = String(entries.length);
+  const totalWord = document.createElement('span');
+  totalWord.textContent = entries.length === 1 ? 'entry' : 'entries';
+  total.appendChild(totalNum);
+  total.appendChild(totalWord);
+  bar.appendChild(total);
+  for (const cls of ['strong', 'wouldfire', 'unresolved', 'weak', 'dead']) {
+    const n = entries.filter((e) => tfLearningStrength(e) === cls).length;
+    if (!n) continue;
+    const meta = tfStrengthMeta(cls);
+    const s = document.createElement('span');
+    s.className = 'll-stat s-' + cls;
+    s.dataset.strength = cls;
+    s.title = meta.hint;
+    const b = document.createElement('b'); b.textContent = String(n);
+    const t = document.createElement('span'); t.textContent = meta.label;
+    s.appendChild(b); s.appendChild(t);
+    bar.appendChild(s);
+  }
+  return bar;
+}
+
+// Strength pills + domain and sort dropdowns. Dropdowns for domain and sort
+// because both spaces are unbounded; pills for strength because there are five.
+function tfLearnToolbar(entries, key, onChange) {
+  const f = tfLearnFilters(key);
+  const wrap = document.createElement('div');
+  wrap.className = 'll-tools';
+  wrap.dataset.testid = 'learn-toolbar';
+
+  const tabs = document.createElement('div');
+  tabs.className = 'll-tabs';
+  // Each facet counts what the OTHER facet currently allows, so a count never
+  // promises more rows than clicking it would show.
+  const inDomain = entries.filter((e) => f.domain === 'all' || tfLearnDomainLabel(e.domain) === f.domain);
+  const counts = { all: inDomain.length };
+  for (const cls of ['strong', 'wouldfire', 'unresolved', 'weak', 'dead']) {
+    counts[cls] = inDomain.filter((e) => tfLearningStrength(e) === cls).length;
+  }
+  for (const cls of ['all', 'strong', 'wouldfire', 'unresolved', 'weak', 'dead']) {
+    if (cls !== 'all' && !counts[cls]) continue;
+    const b = document.createElement('button');
+    b.type = 'button';
+    b.className = 'll-tab' + (f.strength === cls ? ' active' : '');
+    b.dataset.strength = cls;
+    b.textContent = (cls === 'all' ? 'All' : tfStrengthMeta(cls).label) + ' (' + counts[cls] + ')';
+    if (cls !== 'all') b.title = tfStrengthMeta(cls).hint;
+    b.addEventListener('click', () => { f.strength = cls; onChange(); });
+    tabs.appendChild(b);
+  }
+  wrap.appendChild(tabs);
+
+  const right = document.createElement('div');
+  right.className = 'll-selects';
+
+  const domainCounts = new Map();
+  for (const e of entries) {
+    if (f.strength !== 'all' && tfLearningStrength(e) !== f.strength) continue;
+    const d = tfLearnDomainLabel(e.domain);
+    domainCounts.set(d, (domainCounts.get(d) || 0) + 1);
+  }
+  // Keep the active domain selectable even when the strength filter empties it,
+  // otherwise the control silently resets and the manager loses their place.
+  if (f.domain !== 'all' && !domainCounts.has(f.domain)) domainCounts.set(f.domain, 0);
+  const domSel = document.createElement('select');
+  domSel.className = 'll-sel';
+  domSel.dataset.testid = 'learn-domain-filter';
+  domSel.setAttribute('aria-label', 'Filter by domain');
+  const allOpt = document.createElement('option');
+  allOpt.value = 'all'; allOpt.textContent = 'All domains';
+  domSel.appendChild(allOpt);
+  for (const d of Array.from(domainCounts.keys()).sort(tfDomainOrder)) {
+    const o = document.createElement('option');
+    o.value = d; o.textContent = d + ' (' + domainCounts.get(d) + ')';
+    domSel.appendChild(o);
+  }
+  domSel.value = domainCounts.has(f.domain) || f.domain === 'all' ? f.domain : 'all';
+  f.domain = domSel.value;
+  domSel.addEventListener('change', () => { f.domain = domSel.value; onChange(); });
+  right.appendChild(domSel);
+
+  const sortSel = document.createElement('select');
+  sortSel.className = 'll-sel';
+  sortSel.dataset.testid = 'learn-sort';
+  sortSel.setAttribute('aria-label', 'Sort entries');
+  for (const [v, label] of [['strength', 'Sort: Strength'], ['score', 'Sort: Score'], ['priority', 'Sort: Priority']]) {
+    const o = document.createElement('option'); o.value = v; o.textContent = label; sortSel.appendChild(o);
+  }
+  sortSel.value = f.sort;
+  sortSel.addEventListener('change', () => { f.sort = sortSel.value; onChange(); });
+  right.appendChild(sortSel);
+
+  wrap.appendChild(right);
+  return wrap;
+}
+
+// Global first, then domains alphabetically: the reading order the manager asked
+// for: what applies everywhere, then what is narrowed.
+function tfDomainOrder(a, b) {
+  if (a === b) return 0;
+  if (a === 'global') return -1;
+  if (b === 'global') return 1;
+  return a < b ? -1 : 1;
+}
+
+function tfLearnGroupHeader(domain, count) {
+  const h = document.createElement('div');
+  h.className = 'll-group-head';
+  h.dataset.domain = domain;
+  const name = document.createElement('span'); name.className = 'llg-name';
+  const reach = document.createElement('span'); reach.className = 'llg-reach';
+  if (domain === 'global') {
+    name.textContent = 'Global';
+    reach.textContent = 'loaded on every job';
+  } else {
+    name.textContent = domain + ' domain';
+    reach.textContent = 'loaded only on ' + domain + ' jobs';
+  }
+  const n = document.createElement('span'); n.className = 'llg-count'; n.textContent = String(count);
+  h.appendChild(name); h.appendChild(reach); h.appendChild(n);
+  return h;
+}
+
+// A preserved learning card: what it is (category, priority, domain), how well it
+// has worked (strength + usage counters), and what it says. Edit and Delete write
+// the underlying file (#533 #3) at the card's scope/level/domain.
 // When shareMode is true, the card shows a checkbox instead of edit/delete actions
 // and clicking anywhere on the card toggles the selection.
 function tfPreservedCard(entry, scope, level, shareMode, onSelectionChange) {
+  const key = tfLearnKey(scope, level);
   const card = document.createElement('div');
   card.className = 'learn-prop';
   if (shareMode) card.classList.add('lp-share-mode');
+  const strength = tfLearningStrength(entry);
+  card.dataset.strength = strength;
+  card.dataset.domain = tfLearnDomainLabel(entry.domain);
+  // The entry's own id, so a card stays identifiable across a re-render and after
+  // it flips into edit mode (where its title is no longer rendered as text).
+  if (entry.id) card.dataset.entryId = entry.id;
   const renderView = () => {
     card.innerHTML = '';
     const head = document.createElement('div'); head.className = 'lp-head';
@@ -14981,6 +15483,17 @@ function tfPreservedCard(entry, scope, level, shareMode, onSelectionChange) {
       });
       head.appendChild(chk);
     }
+    // Domain badge: which jobs this entry reaches. #1755 Gap 4: until now the
+    // only place this fact lived was the filename.
+    const dom = document.createElement('span');
+    dom.className = 'lp-domain ' + tfLearnDomainClass(entry.domain);
+    dom.dataset.testid = 'lp-domain';
+    dom.textContent = tfLearnDomainLabel(entry.domain);
+    dom.title = tfLearnDomainLabel(entry.domain) === 'global'
+      ? 'Loaded on every job'
+      : 'Loaded only on ' + tfLearnDomainLabel(entry.domain) + ' jobs';
+    head.appendChild(dom);
+
     const cat = tfCategoryMeta(entry.category);
     const cb = document.createElement('span'); cb.className = 'lp-scope'; cb.textContent = cat.label;
     cb.style.background = 'var(--bg)'; cb.style.color = cat.color;
@@ -14991,8 +15504,29 @@ function tfPreservedCard(entry, scope, level, shareMode, onSelectionChange) {
       prio.style.background = 'var(--bg)'; prio.style.color = tfPrioColor(entry.severity);
       head.appendChild(prio);
     }
+    // Neural strength badge.
+    const sMeta = tfStrengthMeta(strength);
+    const sb = document.createElement('span');
+    sb.className = 'lp-strength s-' + strength;
+    sb.dataset.testid = 'lp-strength';
+    sb.dataset.strength = strength;
+    sb.title = sMeta.hint;
+    const dot = document.createElement('i'); dot.className = 'lp-dot';
+    const sl = document.createElement('span'); sl.textContent = sMeta.label;
+    sb.appendChild(dot); sb.appendChild(sl);
+    head.appendChild(sb);
+
     const title = document.createElement('span'); title.className = 'lp-title'; title.textContent = entry.title || 'Learning';
     head.appendChild(title);
+
+    if (typeof entry.score === 'number') {
+      const sc = document.createElement('span');
+      sc.className = 'lp-score'; sc.dataset.testid = 'lp-score';
+      sc.textContent = entry.score.toFixed(1);
+      sc.title = 'Injection score';
+      head.appendChild(sc);
+    }
+
     if (!shareMode && entry.tier !== 'cold') {
       const edit = document.createElement('button'); edit.className = 'lp-act'; edit.type = 'button'; edit.title = 'Edit'; edit.textContent = '✎';
       const del = document.createElement('button'); del.className = 'lp-act lp-act-del'; del.type = 'button'; del.title = 'Delete'; del.textContent = '🗑';
@@ -15012,7 +15546,10 @@ function tfPreservedCard(entry, scope, level, shareMode, onSelectionChange) {
         no.addEventListener('click', () => c.remove());
         yes.addEventListener('click', async () => {
           yes.disabled = true; yes.textContent = 'Deleting…';
-          try { await tfWriteLearning({ action: 'delete', scope, level, category: entry.category, originalTitle: entry.title }, scope, level); }
+          // #1755: the domain names the file the entry actually lives in. Without it
+          // a delete resolved to the undecorated global file and failed, or removed
+          // a same-titled global entry instead.
+          try { await tfWriteLearning({ action: 'delete', scope, level, category: entry.category, domain: tfLearnDomainLabel(entry.domain), originalTitle: entry.title }, scope, level); }
           catch (e) { yes.disabled = false; yes.textContent = 'Delete'; }
         });
       });
@@ -15028,23 +15565,145 @@ function tfPreservedCard(entry, scope, level, shareMode, onSelectionChange) {
     }
     card.appendChild(head);
     if (entry.body) {
+      const split = tfSplitLessonAndProvenance(String(entry.body).replace(/\*\*/g, '').replace(/`/g, ''));
       const body = document.createElement('div'); body.className = 'lp-body';
-      body.textContent = String(entry.body).replace(/\*\*/g, '').replace(/`/g, '');
+      body.textContent = split.lesson;
+      const cardKey = tfLearnCardKey(entry, key);
+      const expanded = !!tfLearnExpanded()[cardKey];
+      // Clamp long bodies. The corpus averages well over 100 words an entry; an
+      // unclamped list is the "too dense to read" defect in #1755 Gap 8.
+      const longBody = split.lesson.length > TF_CLAMP_CHARS || split.lesson.split('\n').length > TF_CLAMP_LINES;
+      if (longBody && !expanded) body.classList.add('lp-clamped');
       card.appendChild(body);
+      let prov = null;
+      if (split.provenance) {
+        prov = document.createElement('div');
+        prov.className = 'lp-prov'; prov.dataset.testid = 'lp-prov';
+        prov.textContent = split.provenance;
+        prov.hidden = !expanded;
+        card.appendChild(prov);
+      }
+      if (longBody || prov) {
+        const more = document.createElement('button');
+        more.type = 'button'; more.className = 'lp-more'; more.dataset.testid = 'lp-more';
+        more.textContent = expanded ? 'Show less' : 'Show more';
+        more.addEventListener('click', () => {
+          const now = !tfLearnExpanded()[cardKey];
+          tfLearnExpanded()[cardKey] = now;
+          body.classList.toggle('lp-clamped', longBody && !now);
+          if (prov) prov.hidden = !now;
+          more.textContent = now ? 'Show less' : 'Show more';
+        });
+        card.appendChild(more);
+      }
+    }
+    if (!shareMode) {
+      const stats = tfLearnUsageRow(entry);
+      if (stats) card.appendChild(stats);
     }
   };
   renderView();
   return card;
 }
 
+// The usage footer: a proportional bar plus the counts behind it. Returns null
+// when the store holds no record for the entry, so the card says "never offered"
+// instead of showing four zeroes that read like a measured result.
+function tfLearnUsageRow(entry) {
+  const u = entry && entry.usage;
+  const row = document.createElement('div');
+  row.className = 'lp-stats';
+  row.dataset.testid = 'lp-stats';
+  if (!u || !u.offered) {
+    const none = document.createElement('span');
+    none.className = 'lps-none';
+    none.textContent = 'Never offered to an agent yet';
+    row.appendChild(none);
+    return row;
+  }
+  const applied = u.applied || 0, prevented = u.prevented || 0, ignored = u.ignored || 0;
+  const offered = u.offered || 0;
+  const bar = document.createElement('span');
+  bar.className = 'lp-bar'; bar.dataset.testid = 'lp-bar';
+  bar.setAttribute('role', 'img');
+  bar.setAttribute('aria-label', `${applied} applied, ${prevented} prevented, ${ignored} ignored of ${offered} offers`);
+  for (const [cls, n] of [['lb-applied', applied], ['lb-prevented', prevented], ['lb-ignored', ignored]]) {
+    if (!n) continue;
+    const seg = document.createElement('i');
+    seg.className = cls;
+    seg.style.width = Math.max(2, Math.round((n / offered) * 100)) + '%';
+    bar.appendChild(seg);
+  }
+  row.appendChild(bar);
+
+  const counts = document.createElement('span');
+  counts.className = 'lps-counts';
+  // Offered is always shown because it is the denominator. The outcome counts are
+  // shown only when they happened: four zeroes read like a measured result rather
+  // than an entry that has simply never fired.
+  const parts = [['offered', offered]];
+  if (applied) parts.push(['applied', applied]);
+  if (prevented) parts.push(['prevented', prevented]);
+  if (ignored) parts.push(['ignored', ignored]);
+  if (u.notApplicable) parts.push(['not applicable', u.notApplicable]);
+  if (parts.length === 1) parts.push(['no firings yet', null]);
+  for (const [label, n] of parts) {
+    const c = document.createElement('span');
+    c.className = 'lps-c';
+    if (n !== null) { const b = document.createElement('b'); b.textContent = String(n); c.appendChild(b); }
+    const t = document.createElement('span'); t.textContent = label;
+    c.appendChild(t);
+    counts.appendChild(c);
+  }
+  row.appendChild(counts);
+
+  const last = tfRelDays(u.lastOfferedAt);
+  if (last) {
+    const l = document.createElement('span');
+    l.className = 'lps-last'; l.textContent = 'last offered ' + last;
+    row.appendChild(l);
+  }
+  return row;
+}
+
 // scope='org'|'manager'|'reverse', level='machine'|'project'|'org'. Renders pending
-// proposals (if a live run surfaced any) + the preserved learnings (editable), and a
-// per-section "+ Add" that writes a new entry to the right file/level.
+// proposals (if a live run surfaced any) + the preserved learnings library (stats,
+// filters, domain groups, editable cards), and a per-section "+ Add" that writes a
+// new entry to the right file/level.
+// One sticky header holding the summary and the controls. The accordion body is a
+// capped scroll region, so an unpinned toolbar becomes unreachable the moment the
+// manager scrolls past the first few cards.
+function tfLearnLibraryHeader(preserved, key, onChange) {
+  const libHead = document.createElement('div');
+  libHead.className = 'll-head';
+  libHead.dataset.testid = 'learn-lib-head';
+  libHead.appendChild(tfLearnStatsBar(preserved));
+  if (preserved.length >= TF_LEARN_TOOLBAR_MIN) libHead.appendChild(tfLearnToolbar(preserved, key, onChange));
+  return libHead;
+}
+
+// Append cards to a host, grouped by domain so reach is a heading rather than a
+// badge the manager has to scan for. `withHeaders` is false inside the collapsed
+// below-threshold and archived sections, which are already one labelled group.
+function tfAppendGroupedCards(host, entries, sort, opts) {
+  const { scope, level, shareMode, onSelectionChange, withHeaders } = opts;
+  const groups = new Map();
+  for (const e of entries) {
+    const d = tfLearnDomainLabel(e.domain);
+    if (!groups.has(d)) groups.set(d, []);
+    groups.get(d).push(e);
+  }
+  const groupNames = Array.from(groups.keys()).sort(tfDomainOrder);
+  const showHeaders = withHeaders && groupNames.length > 1;
+  for (const d of groupNames) {
+    const sorted = tfSortLearnings(groups.get(d), sort);
+    if (showHeaders) host.appendChild(tfLearnGroupHeader(d, sorted.length));
+    for (const e of sorted) host.appendChild(tfPreservedCard(e, scope, level, shareMode, onSelectionChange));
+  }
+}
+
 function tfRenderLearningsList(host, scope, level, emptyText) {
   host.innerHTML = '';
-  const liveConv = tfLearningRunByScope[tfLearningRunKey(scope)];
-  const proposals = tfParsePendingProposals(liveConv, scope);
-  const live = proposals.length > 0;
   const key = tfLearnKey(scope, level);
   const preserved = tfPreservedCache()[key];
 
@@ -15065,14 +15724,18 @@ function tfRenderLearningsList(host, scope, level, emptyText) {
   // Issue #1002 R13: the whole pending batch is reviewed in ONE surface, with a
   // bulk accept that states its count. Serial presentation is prohibited: the
   // manager must be able to act on any row without first resolving the others.
-  if (proposals.length > 0) {
-    host.appendChild(tfLearningBatchBar(proposals, scope));
-  }
+  //
+  // Issue #1755: that one surface is the run's own conversation, where the job
+  // wrote the proposals. This panel is the corpus library: a durable list of what
+  // the agent already knows, editable, deletable and shareable. It carries no
+  // notice about a pending batch: a run waiting on a decision already reads
+  // "Waiting on you" in the employee rail like every other job awaiting review,
+  // so a second learnings-specific signal here would only point away from the
+  // panel it sits in.
   const shareMode = host.dataset.lpShareMode === 'true';
   // When share mode is active, update the floating share bar whenever selection changes.
   const onSelectionChange = shareMode ? () => tfUpdateShareBar(host, scope, level) : null;
 
-  for (const p of proposals) list.appendChild(tfProposalCard(p, scope, live));
   if (Array.isArray(preserved)) {
     const hotEntries = preserved.filter((e) => e.tier !== 'cold');
     const coldEntries = preserved.filter((e) => e.tier === 'cold');
@@ -15083,9 +15746,19 @@ function tfRenderLearningsList(host, scope, level, emptyText) {
     const injectedEntries = hotEntries.filter((e) => e.injected !== false);
     const dormantHotEntries = hotEntries.filter((e) => e.injected === false);
 
-    for (const e of injectedEntries) list.appendChild(tfPreservedCard(e, scope, level, shareMode, onSelectionChange));
+    // #1755: the library chrome: a strength summary over the whole corpus, and
+    // filters once the list is long enough that scrolling stops working.
+    const f = tfLearnFilters(key);
+    const reRender = () => tfRenderLearningsList(host, scope, level, emptyText);
+    if (!shareMode && preserved.length > 0) {
+      host.appendChild(tfLearnLibraryHeader(preserved, key, reRender));
+    }
+    const visible = shareMode ? injectedEntries : injectedEntries.filter((e) => tfLearnMatchesFilters(e, f));
+
+    tfAppendGroupedCards(list, visible, f.sort, { scope, level, shareMode, onSelectionChange, withHeaders: !shareMode });
 
-    if (dormantHotEntries.length) {
+    const dormantVisible = shareMode ? dormantHotEntries : dormantHotEntries.filter((e) => tfLearnMatchesFilters(e, f));
+    if (dormantVisible.length) {
       // Cut line: learnings below the score threshold. Agent won't see these.
       const cut = document.createElement('details');
       cut.className = 'learn-dormant-section learn-cutline-section';
@@ -15094,23 +15767,37 @@ function tfRenderLearningsList(host, scope, level, emptyText) {
       cutSummary.className = 'learn-dormant-header';
       const threshold = tfThresholdCache()[key];
       const thresholdLabel = typeof threshold === 'number' ? ` (score < ${threshold})` : '';
-      cutSummary.textContent = `Below threshold${thresholdLabel} — not injected into agent context (${dormantHotEntries.length})`;
+      cutSummary.textContent = `Below threshold${thresholdLabel}: not injected into agent context (${dormantVisible.length})`;
       cut.appendChild(cutSummary);
-      for (const e of dormantHotEntries) cut.appendChild(tfPreservedCard(e, scope, level, shareMode, onSelectionChange));
+      tfAppendGroupedCards(cut, dormantVisible, f.sort, { scope, level, shareMode, onSelectionChange, withHeaders: false });
       list.appendChild(cut);
     }
 
-    if (coldEntries.length) {
+    const coldVisible = shareMode ? coldEntries : coldEntries.filter((e) => tfLearnMatchesFilters(e, f));
+    if (coldVisible.length) {
       const dormant = document.createElement('details');
       dormant.className = 'learn-dormant-section';
       dormant.setAttribute('data-testid', 'dormant-section');
       const summary = document.createElement('summary');
       summary.className = 'learn-dormant-header';
-      summary.textContent = `Archived (${coldEntries.length})`;
+      summary.textContent = `Archived (${coldVisible.length})`;
       dormant.appendChild(summary);
-      for (const e of coldEntries) dormant.appendChild(tfPreservedCard(e, scope, level, shareMode, onSelectionChange));
+      tfAppendGroupedCards(dormant, coldVisible, f.sort, { scope, level, shareMode, onSelectionChange, withHeaders: false });
       list.appendChild(dormant);
     }
+
+    // A filter that hides everything must say so, or it reads as an empty corpus.
+    if (preserved.length > 0 && !list.children.length) {
+      const none = document.createElement('div');
+      none.className = 'll-nomatch';
+      none.dataset.testid = 'learn-no-match';
+      none.textContent = 'No entries match this filter.';
+      const clear = document.createElement('button');
+      clear.type = 'button'; clear.className = 'lp-add-btn'; clear.textContent = 'Clear filters';
+      clear.addEventListener('click', () => { f.strength = 'all'; f.domain = 'all'; reRender(); });
+      host.appendChild(none); host.appendChild(clear);
+      return;
+    }
   }
 
   const wireAdd = () => {
@@ -15296,7 +15983,7 @@ function tfLevelWord(level) {
 // Relay one manager turn into the running learning job, through the same
 // continueRun path every other in-conversation control uses. No second write path.
 async function tfRelayBatch(scope, message) {
-  const conv = tfLearningRunByScope[tfLearningRunKey(scope)];
+  const conv = tfFindLearningRun(scope);
   if (conv && conv.runId) {
     const prev = state.activeId;
     state.activeId = conv.id;
@@ -15311,6 +15998,12 @@ function tfReRenderLearnings(scope) {
   if (scope === 'org' && typeof tfRenderCompany === 'function') tfRenderCompany();
   else if (typeof tfRenderProjectContextTop === 'function') tfRenderProjectContextTop();
   if (typeof tfRenderManager === 'function' && (scope === 'manager' || scope === 'reverse')) tfRenderManager();
+  // #1755: a proposal decision is taken in the run's conversation, and none of the
+  // panel renders above rebuild it. Without this the card the manager just acted
+  // on keeps its pre-decision state while the panel's pending pointer updates.
+  if (typeof renderLearningProposalTurn === 'function' && typeof activeConversation === 'function') {
+    renderLearningProposalTurn(activeConversation());
+  }
 }
 
 // Share-mode: tracks which learning entries the manager has checked for sharing.
@@ -15498,7 +16191,7 @@ async function tfLaunchShareWithOthers(scope, level, selectedTitles, job, projec
   }
 }
 
-function tfProposalCard(p, scope, live) {
+function tfProposalCard(p, scope) {
   const meta = tfScopeMeta(scope);
   const card = document.createElement('div');
   card.className = 'learn-prop';
@@ -15529,6 +16222,17 @@ function tfProposalCard(p, scope, live) {
     card.appendChild(ex);
   }
 
+  // Issue #1755 R6: a proposal card reads as two zones: what you can still change
+  // before deciding, and the decision itself. They used to sit on one undivided
+  // row, so a level button and a Skip button looked like the same kind of control.
+  const config = document.createElement('div');
+  config.className = 'lp-config';
+  config.dataset.testid = 'lp-config';
+  const configHead = document.createElement('div');
+  configHead.className = 'lp-config-head';
+  configHead.textContent = 'Configure before deciding';
+  config.appendChild(configHead);
+
   const actions = document.createElement('div');
   actions.className = 'lp-actions';
   const reRender = () => {
@@ -15536,6 +16240,12 @@ function tfProposalCard(p, scope, live) {
     else if (tf.area === 'company') tfRenderCompany();
     else if (typeof tfRenderProjectContextTop === 'function') tfRenderProjectContextTop();
     else tfRenderTree();
+    // #1755: a proposal card lives in the conversation turn, which none of the
+    // panel renders above rebuild. Without this a level change repaints the
+    // panel and leaves the card the manager just clicked untouched.
+    if (typeof renderLearningProposalTurn === 'function' && typeof activeConversation === 'function') {
+      renderLearningProposalTurn(activeConversation());
+    }
   };
 
   // Issue #1002 R13: EVERY row carries its level and its own actions, on every
@@ -15594,6 +16304,12 @@ function tfProposalCard(p, scope, live) {
     pick.appendChild(b);
   }
   actions.appendChild(pick);
+  config.appendChild(actions);
+  card.appendChild(config);
+
+  const decide = document.createElement('div');
+  decide.className = 'lp-decide';
+  decide.dataset.testid = 'lp-decide';
 
   const skip = document.createElement('button');
   skip.className = 'lp-skip' + ((tfProposalOverrides[p.id] || {}).skipped || decided === 'reject' ? ' on' : '');
@@ -15606,8 +16322,7 @@ function tfProposalCard(p, scope, live) {
     tfSetProposalOverride(p, { skipped: !wasSkipped });
     reRender();
   });
-  actions.appendChild(skip);
-  card.appendChild(actions);
+  decide.appendChild(skip);
 
   // Issue #1002 R14: the reason field appears ONLY on a row the manager changed,
   // and is required before the batch can be saved. A row left at its suggested
@@ -15636,13 +16351,28 @@ function tfProposalCard(p, scope, live) {
     why.appendChild(label);
     why.appendChild(ta);
     why.appendChild(hint);
-    card.appendChild(why);
+    config.appendChild(why);
+  }
+
+  // R12: a decided card says which way it went, rather than leaving the manager to
+  // infer it from a dimmed card and a disabled button.
+  if (decided) {
+    const badge = document.createElement('span');
+    const skipped = decided === 'reject';
+    badge.className = 'lp-decided-badge' + (skipped ? ' is-skipped' : ' is-saved');
+    badge.dataset.testid = 'lp-decided-badge';
+    badge.textContent = skipped ? 'Skipped' : 'Saved';
+    decide.appendChild(badge);
   }
 
+  // R8: state what the decision will actually write, in the zone where it is made.
   const note = document.createElement('span');
   note.className = 'lp-scope-note';
-  note.textContent = TF_LEVEL_TITLE[currentLevel] || tfScopeMeta(scope).note;
-  card.appendChild(note);
+  note.textContent = (tfProposalOverrides[p.id] || {}).skipped
+    ? 'Nothing is written. The skip is recorded as a signal.'
+    : (TF_LEVEL_TITLE[currentLevel] || tfScopeMeta(scope).note);
+  decide.appendChild(note);
+  card.appendChild(decide);
   return card;
 }
 
@@ -15650,7 +16380,7 @@ function tfProposalCard(p, scope, live) {
 // (a scope-targeted instruction into the sleep-on-learnings run) — no new backend.
 async function tfPromoteProposal(originScope, proposal, targetScope) {
   const label = targetScope === 'org' ? 'Company' : targetScope === 'manager' ? 'Manager' : 'Project';
-  const conv = tfLearningRunByScope[tfLearningRunKey(originScope)];
+  const conv = tfFindLearningRun(originScope);
   const message = `Promote the proposal "${proposal.title}" to ${label.toLowerCase()} learnings (scope: ${targetScope}).`;
   tfProposalDecisions[proposal.id] = 'promote:' + targetScope;
   if (conv && conv.runId) {