fraim-hub 2.0.344 → 2.0.345

package/dist/src/ai-hub/conversation-store.js

@@ -11,6 +11,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
 const conversation_store_lock_1 = require("./conversation-store-lock");
+const proposal_set_contract_1 = require("../core/proposal-set-contract");
 const atomic_json_file_1 = require("./atomic-json-file");
 const conversation_search_projection_1 = require("./conversation-search-projection");
 // Issue #708: reserved, project-independent bucket keys for non-project scopes.
@@ -169,6 +170,45 @@ function conversationContinuityCompatible(left, right) {
         return false;
     return true;
 }
+// Acknowledged review snapshots are append-only presentation history. Merge under
+// the bucket lock so delayed browser patches and richer run projections cannot erase them.
+function mergeLearningReviewTurns(...sources) {
+    const turns = [];
+    const seen = new Set();
+    for (const source of sources) {
+        if (!Array.isArray(source))
+            continue;
+        for (const turn of source) {
+            if (!turn || !Number.isInteger(turn.messageCount) || turn.messageCount < 0
+                || !turn.proposalSet || (0, proposal_set_contract_1.validateProposalSet)(turn.proposalSet)
+                || !Array.isArray(turn.proposalSet.proposals) || !turn.proposalSet.proposals.length
+                || !Array.isArray(turn.decisions) || turn.decisions.length !== turn.proposalSet.proposals.length)
+                continue;
+            const proposals = turn.proposalSet.proposals;
+            if (!proposals.every((p, i) => {
+                const d = turn.decisions[i];
+                return d && d.proposalId === p.proposalId && d.revision === p.revision
+                    && ['approve', 'reject'].includes(d.action) && ['project', 'manager', 'org'].includes(d.level)
+                    && typeof d.reason === 'string';
+            }))
+                continue;
+            const indices = proposals.flatMap((p, i) => {
+                const key = JSON.stringify([p.proposalId, p.revision]);
+                if (seen.has(key))
+                    return [];
+                seen.add(key);
+                return [i];
+            });
+            if (indices.length)
+                turns.push({
+                    messageCount: turn.messageCount,
+                    proposalSet: { ...turn.proposalSet, proposals: indices.map((i) => proposals[i]) },
+                    decisions: indices.map((i) => turn.decisions[i]),
+                });
+        }
+    }
+    return turns;
+}
 // Place a raw conversation into a bucket, deduping by id. When the id already exists, keep the
 // richer copy (more run history); tie-break on newer lastUpdatedAt. Order-independent.
 function placeConversationInBucket(bucket, conv) {
@@ -196,6 +236,9 @@ function placeConversationInBucket(bucket, conv) {
         && timestampValue(value?.lastUpdatedAt) > timestampValue(existing.lastUpdatedAt)) {
         bucket.conversations[idx] = withStableConversationCreatedAt(existing, conv);
     }
+    const history = mergeLearningReviewTurns(existing.learningReviewTurns, conv.learningReviewTurns);
+    if (history.length)
+        bucket.conversations[idx].learningReviewTurns = history;
 }
 function stableConversationCreatedAt(existing, incoming) {
     const existingValue = existing?.createdAt;
@@ -651,8 +694,18 @@ class AiHubConversationStore {
                 }
                 catch { /* ignore */ }
             }
-            for (const conv of state.conversations)
+            for (const conv of state.conversations) {
+                try {
+                    const prior = JSON.parse(fs_1.default.readFileSync(this.convFilePath(bucketDir, conv.id), 'utf8')).conversation;
+                    if (conversationContinuityCompatible(prior, conv)) {
+                        const history = mergeLearningReviewTurns(prior?.learningReviewTurns, conv.learningReviewTurns);
+                        if (history.length)
+                            conv.learningReviewTurns = history;
+                    }
+                }
+                catch { /* no prior copy */ }
                 this.writeConvFile(bucketDir, bucketKey, conv);
+            }
             this.writeIndex(bucketDir, bucketKey, state.activeId, state.conversations);
             // Issue #1065 (GDPR Art. 17 / C1): deletion must reach every copy. The whole-bucket
             // rewrite prunes conversation shards that are no longer wanted; prune the matching
@@ -903,12 +956,19 @@ class AiHubConversationStore {
                 this.writeConvFile(bucketDir, key, candidate);
                 return this.reindexAfterUpsert(bucketDir, key, candidate, undefined);
             }
+            const history = mergeLearningReviewTurns(existing.learningReviewTurns, patch.learningReviewTurns);
             if (patch.lastUpdatedAt !== undefined && timestampValue(patch.lastUpdatedAt) < timestampValue(existing.lastUpdatedAt)) {
+                if (JSON.stringify(history) !== JSON.stringify(mergeLearningReviewTurns(existing.learningReviewTurns))) {
+                    existing.learningReviewTurns = history;
+                    this.writeConvFile(bucketDir, key, existing);
+                    return this.reindexAfterUpsert(bucketDir, key, existing, undefined);
+                }
                 return this.stateFromIndex(bucketDir, key);
             }
             const merged = normalizeConversation(key, {
                 ...existing,
                 ...patch,
+                ...(history.length ? { learningReviewTurns: history } : {}),
                 id: existing.id,
                 projectPath: key,
                 agentName: patch.agentName || existing.agentName,

package/dist/src/local-mcp-server/learning-source-record.js

@@ -22,7 +22,7 @@ function safePart(value) {
     return Boolean(value) && value !== '.' && value !== '..' && !/[\\/:*?"<>|\x00-\x1f]/.test(value)
         && value.trim() === value && !/[. ]$/.test(value);
 }
-/** Explicit paths keep parsing pure; otherwise resolve the owning configuration. Callers guard physical source containment. */
+/** Resolve only within the supplied owner. Callers guard physical source containment. */
 function parseLearningSourceRecord(content, filePath, homeRoot, contentRoot, configuredPaths) {
     const invalid = (reason) => ({ status: 'invalid', reason });
     const normalized = content.replace(/^\uFEFF/, '');
@@ -49,7 +49,7 @@ function parseLearningSourceRecord(content, filePath, homeRoot, contentRoot, con
     for (const line of fm[1].split(/\r?\n/)) {
         const match = /^([A-Za-z][A-Za-z0-9]*):[ \t]*(.*)$/.exec(line);
         if (!match) {
-            if (/^\s*["']?(artifactKind|author|date|job|runId|usageSourceRef|synthesized)["']?\s*:/.test(line))
+            if (/^\s*["']?(artifactKind|author|date|job|runId|sourceId|usageSourceRef|synthesized)["']?\s*:/.test(line))
                 malformedField = true;
             continue;
         }
@@ -76,7 +76,7 @@ function parseLearningSourceRecord(content, filePath, homeRoot, contentRoot, con
         return invalid('Unsupported metadata key spelling');
     if (duplicates.size)
         return invalid(`Duplicate metadata: ${[...duplicates].join(', ')}`);
-    for (const field of ['author', 'date', 'job', 'runId', 'usageSourceRef', 'synthesized']) {
+    for (const field of ['author', 'date', 'job', 'runId', 'sourceId', 'usageSourceRef', 'synthesized']) {
         if (!Object.prototype.hasOwnProperty.call(fields, field))
             return invalid(`Missing metadata: ${field}`);
     }
@@ -110,13 +110,22 @@ function parseLearningSourceRecord(content, filePath, homeRoot, contentRoot, con
         return invalid('Source is outside its configured learning location');
     if (state === 'archived' && !fields.synthesized)
         return invalid('Archive has no successful processing date');
-    if (!node_path_1.default.isAbsolute(fields.usageSourceRef) || /[\x00-\x1f]/.test(fields.usageSourceRef)
-        || fields.usageSourceRef.includes('\\')
-        || fields.usageSourceRef !== node_path_1.default.resolve(fields.usageSourceRef).replace(/\\/g, '/')
-        || normalizeLearningSourcePath(fields.usageSourceRef) !== normalizeLearningSourcePath(pendingPath)) {
-        return invalid('usageSourceRef must be the normalized absolute original pending path');
+    const reference = fields.usageSourceRef;
+    const relative = node_path_1.default.relative(homeRoot, pendingPath).replace(/\\/g, '/');
+    if (!relative || relative.split('/').some(part => !part || part === '.' || part === '..') || node_path_1.default.isAbsolute(relative))
+        return invalid('Source escapes its owning root');
+    if (!reference || /[\x00-\x1f]/.test(reference) || reference.includes('\\'))
+        return invalid('Invalid usageSourceRef');
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(fields.sourceId)) {
+        return invalid('Sources require an immutable sourceId UUID');
+    }
+    if (node_path_1.default.posix.isAbsolute(reference) || node_path_1.default.win32.isAbsolute(reference) || reference.includes(':')
+        || reference.split('/').some(part => !part || part === '.' || part === '..') || reference !== relative) {
+        return invalid('usageSourceRef must name the owner-relative pending path');
     }
     return { status: 'valid', record: { artifactKind: fields.artifactKind, kind, author: fields.author,
             date: fields.date, job: fields.job, runId: fields.runId, usageSourceRef: fields.usageSourceRef,
+            usageIdentity: `learning-source:${fields.sourceId}`,
+            sourceId: fields.sourceId,
             synthesized: fields.synthesized, pendingPath, archivePath, state } };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-hub",
-  "version": "2.0.344",
+  "version": "2.0.345",
   "description": "FRAIM Hub local companion package.",
   "author": "Sid Mathur <sid.mathur@gmail.com>",
   "homepage": "https://github.com/mathursrus/FRAIM#readme",
@@ -237,7 +237,7 @@
     "electron-updater": "^6.8.9",
     "express": "^5.2.1",
     "extract-zip": "^2.0.1",
-    "fraim": "2.0.344",
+    "fraim": "2.0.345",
     "mongodb": "^7.0.0",
     "node-cron": "4.2.1",
     "node-edge-tts": "^1.2.10",

package/public/ai-hub/review.css

@@ -1055,3 +1055,7 @@
 }
 .learn-proposal-turn .learn-list { gap: 10px; }
 .learn-proposal-turn .learn-prop { background: var(--surface); }
+.learn-proposal-history .learn-prop.resolved { opacity: 1; filter: grayscale(1); }
+.learn-proposal-history .lp-title,
+.learn-proposal-history .lp-body,
+.learn-proposal-history .lp-decided-badge { color: var(--muted); }

package/public/ai-hub/script.js

@@ -4226,7 +4226,10 @@ function renderActive() {
   const hadPendingRowsBeforeRebuild = !!threadHost.querySelector('.message[data-pending="true"]');
   const rebuildThread = messages.length < renderedMessageCount || messagesMutated;
   if (rebuildThread) {
-    els['messages'].innerHTML = '';
+    // Streaming message edits must not blur a proposal reason being composed.
+    for (const child of Array.from(threadHost.children)) {
+      if (child.id !== 'learn-proposal-turn') child.remove();
+    }
     renderedMessageCount = 0;
     renderedMessageFingerprints = [];
   }
@@ -5953,7 +5956,7 @@ function appendMessageDom(role, text, conv, message) {
       article.appendChild(chip);
     });
   }
-  els['messages'].appendChild(article);
+  els['messages'].insertBefore(article, els['messages'].querySelector('#learn-proposal-turn'));
 }
 
 function ensureThreadMessageViewportObserver() {
@@ -7304,44 +7307,52 @@ 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.
+// Proposal review belongs to its conversation, regardless of the launching job.
+// Keep the controls mounted while polling unchanged data, including typed reasons.
 function renderLearningProposalTurn(conv) {
   const host = els['messages'];
   if (!host) return;
+  renderLearningProposalHistory(conv);
   const existing = host.querySelector('#learn-proposal-turn');
-  if (existing) existing.remove();
-  if (!conv || conv.jobId !== 'sleep-on-learnings' || !tfConvHasProposals(conv)) return;
+  if (!tfConvHasProposals(conv)) {
+    if (existing) existing.remove();
+    return;
+  }
 
   // Issue #1857: the scope arrives on the set rather than being re-derived from
   // the kickoff text, so a decision reaches the corpus its run was scoped to even
   // when the kickoff wording is ambiguous.
   const scope = conv.proposalSet.runScope || tfProposalScopeForConversation(conv);
   const proposals = tfPendingProposals(conv);
-  if (!proposals.length) return;
-  // Keep the relay pointed at this run even if the accordion never registered it.
-  tfLearningRunByScope[tfLearningRunKey(scope)] = conv;
+  if (!proposals.length) {
+    if (existing) existing.remove();
+    return;
+  }
+  const signature = JSON.stringify([conv.id, tfProposalSubmissions.has(conv.id), conv.proposalSet, proposals.map((p) => {
+    const key = tfProposalStateKey(p);
+    const override = tfProposalOverrides[key] || {};
+    return [tfProposalDecisions[key], override.level, override.skipped];
+  })]);
+  if (existing && existing.proposalSignature === signature) return;
+  if (existing) existing.remove();
 
   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';
+  row.proposalSignature = signature;
   const bubble = document.createElement('div');
   bubble.className = 'bubble';
 
   const label = document.createElement('div');
   label.className = 'review-turn-label';
-  const undecided = proposals.filter((p) => !tfProposalDecisions[tfProposalKey(p)]).length;
+  const undecided = proposals.filter((p) => !tfProposalDecisions[tfProposalStateKey(p)]).length;
   label.textContent = undecided
     ? `${undecided} lesson${undecided === 1 ? '' : 's'} waiting on your decision`
     : 'Lessons reviewed';
   bubble.appendChild(label);
 
-  bubble.appendChild(tfLearningBatchBar(proposals, scope));
+  if (undecided) bubble.appendChild(tfLearningBatchBar(proposals, scope));
   const list = document.createElement('div');
   list.className = 'learn-list';
   for (const p of proposals) list.appendChild(tfProposalCard(p, scope));
@@ -7376,10 +7387,58 @@ function renderLearningProposalTurn(conv) {
   }
 
   row.appendChild(bubble);
+  if (tfProposalSubmissions.has(conv.id)) {
+    row.querySelectorAll('button, textarea').forEach((control) => { control.disabled = true; });
+  }
   // Below the thread, above the deliverables/next-job furniture.
   host.insertBefore(row, host.querySelector('#deliverables-bar, #next-job-section'));
 }
 
+// Like ordinary reviewTurns, acknowledged proposals belong to conversation history.
+// These snapshots describe a decision; they never authorize a later revision.
+function tfLearningReviewHistory(conv) {
+  return (Array.isArray(conv?.learningReviewTurns) ? conv.learningReviewTurns : []).filter((turn) =>
+    turn && Number.isInteger(turn.messageCount) && turn.messageCount >= 0
+    && tfConvHasProposals({ proposalSet: turn.proposalSet })
+    && Array.isArray(turn.decisions) && turn.decisions.length === turn.proposalSet.proposals.length
+    && turn.proposalSet.proposals.every((p, i) => {
+      const d = turn.decisions[i];
+      return d && d.proposalId === p.proposalId && d.revision === p.revision
+        && ['approve', 'reject'].includes(d.action) && ['project', 'manager', 'org'].includes(d.level)
+        && typeof d.reason === 'string';
+    }));
+}
+
+function renderLearningProposalHistory(conv) {
+  const host = els['messages'];
+  const turns = tfLearningReviewHistory(conv);
+  const signature = JSON.stringify([conv?.id, turns]);
+  const previous = Array.from(host.querySelectorAll('.learn-proposal-history'));
+  if (previous.length === turns.length && previous.every((row) => row.proposalSignature === signature)) return;
+  previous.forEach((row) => row.remove());
+  const messages = Array.from(host.children).filter((row) => row.classList.contains('message')
+    && !row.classList.contains('review-turn'));
+  for (const turn of turns) {
+    const row = document.createElement('article');
+    row.className = 'message employee review-turn learn-proposal-turn learn-proposal-history';
+    row.proposalSignature = signature;
+    const bubble = document.createElement('div');
+    bubble.className = 'bubble';
+    const label = document.createElement('div');
+    label.className = 'review-turn-label';
+    label.textContent = 'Lessons reviewed';
+    bubble.appendChild(label);
+    const list = document.createElement('div');
+    list.className = 'learn-list';
+    turn.proposalSet.proposals.forEach((p, i) => list.appendChild(tfProposalCard(
+      { ...p, reviewConversationId: conv.id }, turn.proposalSet.runScope, turn.decisions[i])));
+    bubble.appendChild(list);
+    row.appendChild(bubble);
+    host.insertBefore(row, messages[turn.messageCount]
+      || host.querySelector('#learn-proposal-turn, #employee-working-indicator, #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
@@ -15060,21 +15119,16 @@ function tfRenderManager() {
 // faithful and exercisable.
 // ---------------------------------------------------------------------------
 
-// Per-scope learnings run conversation (so a relayed decision continues the
-// right sleep-on-learnings turn). Keyed by scope: org | manager | project.
+// Per-scope discovery cache. Decisions resolve their displayed owner separately.
 const tfLearningRunByScope = { org: null, manager: null, project: null, reverse: null };
 
-// Issue #1002 R13: the run key is derived from the SURFACE that started the run,
-// not chosen ad hoc at each call site. Those drifted: the project workspace's
-// "Sleep on learnings" action filed its run under 'project' while the accordion
-// that launched it rendered with scope 'manager' and therefore read 'manager', so
-// live proposals from that button appeared nowhere. One function, both sides.
+// Keep project, manager and organization discovery scopes distinct.
 function tfLearningRunKey(scope) {
-  return scope === 'org' ? 'org' : scope === 'reverse' ? 'reverse' : 'manager';
+  return scope;
 }
 
 /**
- * A proposal's identity, and the only thing a decision is ever keyed on.
+ * A proposal's wire identity; local state additionally binds owner and revision.
  *
  * Issue #1857 R18: these used to be `scope + '-live-' + index`, positional per
  * render. A Skip therefore relayed a title, and `move-artifact-between-levels`
@@ -15086,6 +15140,19 @@ function tfProposalKey(p) {
   return p && p.proposalId;
 }
 
+// Local edits and decisions must not leak to another owner or a new revision.
+function tfProposalStateKey(p) {
+  return JSON.stringify([p.reviewConversationId, p.proposalId, p.revision]);
+}
+
+function tfProposalOwner(proposals) {
+  const conv = proposals.length && findConversation(proposals[0].reviewConversationId);
+  if (!tfConvHasProposals(conv)) return null;
+  return proposals.every((p) => p.reviewConversationId === conv.id
+    && conv.proposalSet.proposals.some((current) => current.proposalId === p.proposalId
+      && current.revision === p.revision)) ? conv : null;
+}
+
 /**
  * True when this run is carrying a structured proposal set.
  *
@@ -15097,8 +15164,30 @@ function tfProposalKey(p) {
  * Hub stores it on the conversation, so there is one source and nothing to parse.
  */
 function tfConvHasProposals(conv) {
-  return !!(conv && conv.proposalSet && Array.isArray(conv.proposalSet.proposals)
-    && conv.proposalSet.proposals.length > 0);
+  const set = conv && conv.proposalSet;
+  const levels = ['project', 'manager', 'org'];
+  const object = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+  const text = (v) => typeof v === 'string' && v.trim().length > 0;
+  const count = (v) => Number.isInteger(v) && v >= 0;
+  const optionalText = (v) => v === undefined || typeof v === 'string';
+  // The ingress validates the full contract. Defend the rendering/action boundary
+  // too, since persisted conversation data can be incomplete or from older clients.
+  return !!(object(set) && levels.includes(set.runScope) && Array.isArray(set.proposals)
+    && set.proposals.length > 0 && set.proposals.every((p) => object(p) &&
+      ['proposalId', 'claimKey', 'family', 'title', 'takeaway'].every((field) =>
+        text(p[field]))
+      && Number.isInteger(p.revision) && p.revision > 0
+      && levels.includes(p.suggestedLevel)
+      && ['new', 'update', 'cold'].includes(p.changeType)
+      && count(p.recurrences) && optionalText(p.example) && optionalText(p.suggestionReason)
+      && (p.domain == null || typeof p.domain === 'string')
+      && (p.recurrencesAtLastReview == null || count(p.recurrencesAtLastReview))
+      && (p.reopening === undefined || (object(p.reopening) && text(p.reopening.rejectedAt)
+        && text(p.reopening.reason) && count(p.reopening.countAtRejection))))
+    && (set.suppressed === undefined || (Array.isArray(set.suppressed)
+      && set.suppressed.every((p) => object(p)
+        && ['claimKey', 'family', 'rejectedAt', 'reason'].every((field) => text(p[field]))
+        && ['refused', 'superseded'].includes(p.kind) && count(p.newSourceCount)))));
 }
 
 /**
@@ -15114,23 +15203,25 @@ function tfConvHasProposals(conv) {
 function tfFindLearningRun(scope) {
   const key = tfLearningRunKey(scope);
   const registered = tfLearningRunByScope[key];
-  if (tfConvHasProposals(registered)) return registered;
   const list = (state.conversations && state.conversations[state.projectPath]) || [];
+  const current = registered && list.find((c) => c.id === registered.id);
+  if (tfConvHasProposals(current) && current.proposalSet.runScope === scope) return current;
   // 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))
+    .filter((c) => tfConvHasProposals(c) && c.proposalSet.runScope === scope)
     .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];
+  const found = candidates[0];
   if (found) tfLearningRunByScope[key] = found;
-  return found || registered || null;
+  return found || null;
 }
-// Per-scope decision record so a blessed/skipped proposal stays resolved in the
+// Per-owner/revision 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 = {};
+const tfProposalSubmissions = new Set();
 
 function tfScopeMeta(scope) {
   if (scope === 'org') return { cls: 'scope-org', label: 'Org', note: 'Saves to organization learnings · applies on every project' };
@@ -15148,13 +15239,16 @@ function tfScopeMeta(scope) {
  */
 function tfPendingProposals(conv) {
   if (!tfConvHasProposals(conv)) return [];
-  return conv.proposalSet.proposals;
+  const reviewed = tfLearningReviewHistory(conv).flatMap((turn) => turn.decisions);
+  return conv.proposalSet.proposals.filter((p) => !reviewed.some((d) =>
+    d.proposalId === p.proposalId && d.revision === p.revision))
+    .map((p) => ({ ...p, reviewConversationId: conv.id }));
 }
 
 /** Claims this run suppressed because the manager already decided them (R7). */
 function tfSuppressedClaims(conv) {
   const suppressed = conv && conv.proposalSet && conv.proposalSet.suppressed;
-  return Array.isArray(suppressed) ? suppressed : [];
+  return Array.isArray(suppressed) ? suppressed.filter((p) => p && typeof p === 'object') : [];
 }
 
 // Issue #1002 R13: the job states levels in the manager's words ("keep only for
@@ -15173,31 +15267,12 @@ 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 = tfFindLearningRun(scope);
   const verb = decision === 'approve' ? 'Approve as-is' : 'Reject (skip)';
-  const message = `${verb} the proposal: "${proposal.title}".`;
-  tfProposalDecisions[tfProposalKey(proposal)] = decision;
-  if (conv && conv.runId) {
-    // Relay into the live run via the existing manager-turn path.
-    const prev = state.activeId;
-    state.activeId = conv.id;
-    try {
-      // Issue #1857 R18: the decision names the proposal it decided. The prose is
-      // what the manager reads back; `proposalDecisions` is what the job records
-      // against, so it never has to re-derive a revision from a quoted title.
-      await continueRun(message, {
-        proposalDecisions: [{
-          proposalId: tfProposalKey(proposal), revision: proposal.revision,
-          action: decision === 'approve' ? 'approve' : 'reject',
-          level: tfProposalLevel(proposal), reason: tfProposalReason(proposal) || '',
-        }],
-      });
-    } finally { state.activeId = prev; }
-  } else if (typeof showStatus === 'function') {
-    showStatus(decision === 'approve'
-      ? `Blessed “${proposal.title}”. Run Share learnings to let sleep-on-learnings write it.`
-      : `Skipped “${proposal.title}”. Run Share learnings to record the rejection.`, false);
-  }
+  await tfRelayBatch(scope, `${verb} the proposal: "${proposal.title}".`, [{
+    proposalId: proposal.proposalId, revision: proposal.revision,
+    action: decision === 'approve' ? 'approve' : 'reject',
+    level: tfProposalLevel(proposal), reason: tfProposalReason(proposal),
+  }], [proposal]);
 }
 
 // Kick off (or resume) the sleep-on-learnings job for a scope — the live trigger.
@@ -16218,9 +16293,11 @@ function tfLearningBatchBar(proposals, scope) {
   accept.className = 'rb-approve';
   accept.type = 'button';
   accept.dataset.testid = 'learn-batch-accept';
+  const reviewed = proposals.every((p) => tfProposalDecisions[tfProposalStateKey(p)]);
+  accept.disabled = reviewed;
   // Do not say "Save all 5" when one of the five is skipped. Count what will
   // actually be written, and name the skips separately.
-  const skipped = proposals.filter((p) => (tfProposalOverrides[tfProposalKey(p)] || {}).skipped);
+  const skipped = proposals.filter((p) => (tfProposalOverrides[tfProposalStateKey(p)] || {}).skipped);
   const saving = proposals.length - skipped.length;
   if (changed.length === 0) {
     accept.textContent = `✓ Keep all ${proposals.length}`;
@@ -16256,6 +16333,7 @@ function tfLearningBatchBar(proposals, scope) {
     }
     accept.disabled = true;
     await tfAcceptLearningBatch(proposals, scope);
+    accept.disabled = false;
   });
   bar.appendChild(accept);
 
@@ -16264,10 +16342,13 @@ function tfLearningBatchBar(proposals, scope) {
   skipAll.type = 'button';
   skipAll.dataset.testid = 'learn-batch-skip-all';
   skipAll.textContent = 'Skip all';
+  skipAll.disabled = reviewed;
   skipAll.addEventListener('click', async () => {
     skipAll.disabled = true;
-    for (const p of proposals) tfProposalDecisions[tfProposalKey(p)] = 'reject';
-    await tfRelayBatch(scope, `Skip all ${proposals.length} proposals.`);
+    const decisions = proposals.map((p) => ({ proposalId: p.proposalId, revision: p.revision,
+      action: 'reject', level: tfProposalLevel(p), reason: tfProposalReason(p) }));
+    await tfRelayBatch(scope, `Skip all ${proposals.length} proposals.`, decisions, proposals);
+    skipAll.disabled = false;
   });
   bar.appendChild(skipAll);
 
@@ -16279,20 +16360,20 @@ function tfLearningBatchBar(proposals, scope) {
 // wiped by the next render before the manager could save it.
 const tfProposalOverrides = {};
 function tfProposalLevel(p) {
-  const o = tfProposalOverrides[tfProposalKey(p)];
+  const o = tfProposalOverrides[tfProposalStateKey(p)];
   return (o && o.level) || p.suggestedLevel || 'manager';
 }
 function tfProposalReason(p) {
-  const o = tfProposalOverrides[tfProposalKey(p)];
+  const o = tfProposalOverrides[tfProposalStateKey(p)];
   return (o && o.reason) || '';
 }
 function tfProposalChanged(p) {
-  const o = tfProposalOverrides[tfProposalKey(p)];
+  const o = tfProposalOverrides[tfProposalStateKey(p)];
   if (!o) return false;
   return !!o.skipped || (!!o.level && o.level !== (p.suggestedLevel || 'manager'));
 }
 function tfSetProposalOverride(p, patch) {
-  tfProposalOverrides[tfProposalKey(p)] = Object.assign({}, tfProposalOverrides[tfProposalKey(p)] || {}, patch);
+  tfProposalOverrides[tfProposalStateKey(p)] = Object.assign({}, tfProposalOverrides[tfProposalStateKey(p)] || {}, patch);
 }
 
 // Issue #1002 R13: accepting the batch relays ONE turn describing every decision,
@@ -16303,17 +16384,14 @@ async function tfAcceptLearningBatch(proposals, scope) {
   const decisions = [];
   for (const p of proposals) {
     const level = tfProposalLevel(p);
-    const o = tfProposalOverrides[tfProposalKey(p)] || {};
+    const o = tfProposalOverrides[tfProposalStateKey(p)] || {};
     if (o.skipped) {
-      tfProposalDecisions[tfProposalKey(p)] = 'reject';
       lines.push(`- Skip "${p.title}". Reason: ${tfProposalReason(p) || '(none given)'}`);
       decisions.push({ proposalId: tfProposalKey(p), revision: p.revision, action: 'reject', level, reason: tfProposalReason(p) || '' });
     } else if (tfProposalChanged(p)) {
-      tfProposalDecisions[tfProposalKey(p)] = 'promote:' + level;
       lines.push(`- Save "${p.title}" at ${tfLevelWord(level)}. Reason: ${tfProposalReason(p) || '(none given)'}`);
       decisions.push({ proposalId: tfProposalKey(p), revision: p.revision, action: 'approve', level, reason: tfProposalReason(p) || '' });
     } else {
-      tfProposalDecisions[tfProposalKey(p)] = 'approve';
       lines.push(`- Keep "${p.title}" at ${tfLevelWord(level)}.`);
       decisions.push({ proposalId: tfProposalKey(p), revision: p.revision, action: 'approve', level, reason: tfProposalReason(p) || '' });
     }
@@ -16326,7 +16404,7 @@ async function tfAcceptLearningBatch(proposals, scope) {
   // Issue #1857 R18. The prose above is what the manager reads back; `decisions`
   // is what the job records against. Previously only the prose existed, naming
   // each proposal by title, and the job had to guess which revision that was.
-  await tfRelayBatch(scope, msg, decisions);
+  await tfRelayBatch(scope, msg, decisions, proposals);
 }
 
 function tfLevelWord(level) {
@@ -16337,19 +16415,28 @@ 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, decisions) {
-  const conv = tfFindLearningRun(scope);
+async function tfRelayBatch(scope, message, decisions, proposals) {
+  const conv = tfProposalOwner(proposals);
   if (conv && conv.runId) {
-    const prev = state.activeId;
-    state.activeId = conv.id;
+    if (tfProposalSubmissions.has(conv.id)
+      || proposals.every((p) => tfProposalDecisions[tfProposalStateKey(p)])) return;
+    tfProposalSubmissions.add(conv.id);
+    const history = {
+      messageCount: (conv.messages || []).length,
+      proposalSet: { runScope: conv.proposalSet.runScope, proposals: proposals.map(({ reviewConversationId, ...p }) => p) },
+      decisions: decisions.map((d) => ({ ...d })),
+    };
+    tfReRenderLearnings(scope);
     try {
-      // Issue #1857 R18. Carried the same way an approve_delivery selection already
-      // travels: the job records against `proposalId` and `revision` rather than
-      // matching the titles quoted in the sentence the manager reads.
-      await continueRun(message, decisions && decisions.length ? { proposalDecisions: decisions } : undefined);
-    } finally { state.activeId = prev; }
+      const result = await continueRun(message, { conv, proposalDecisions: decisions });
+      if (result.ok) {
+        proposals.forEach((p, i) => { tfProposalDecisions[tfProposalStateKey(p)] = decisions[i].action; });
+        conv.learningReviewTurns = [...tfLearningReviewHistory(conv), history];
+        persistConversation(conv);
+      }
+    } finally { tfProposalSubmissions.delete(conv.id); }
   } else if (typeof showStatus === 'function') {
-    showStatus('Run Sleep on learnings first, then your decisions go straight into that run.', false);
+    showStatus('This proposal review has changed. Reopen its conversation before deciding.', true);
   }
   if (typeof tfReRenderLearnings === 'function') tfReRenderLearnings(scope);
 }
@@ -16551,10 +16638,10 @@ async function tfLaunchShareWithOthers(scope, level, selectedTitles, job, projec
   }
 }
 
-function tfProposalCard(p, scope) {
+function tfProposalCard(p, scope, recordedDecision) {
   const card = document.createElement('div');
   card.className = 'learn-prop';
-  const decided = tfProposalDecisions[p.proposalId];
+  const decided = recordedDecision?.action || tfProposalDecisions[tfProposalStateKey(p)];
   if (decided) card.classList.add('resolved');
 
   // Issue #1857: no scope chip. It showed the run's scope while the level buttons
@@ -16624,6 +16711,22 @@ function tfProposalCard(p, scope) {
   stats.appendChild(kind);
   card.appendChild(stats);
 
+  if (recordedDecision) {
+    const result = document.createElement('div');
+    result.className = 'lp-decided-badge';
+    result.dataset.testid = 'lp-decided-badge';
+    result.textContent = recordedDecision.action === 'reject' ? 'Skipped'
+      : 'Approved · ' + tfLevelWord(recordedDecision.level);
+    card.appendChild(result);
+    if (recordedDecision.reason) {
+      const reason = document.createElement('div');
+      reason.className = 'lp-reason';
+      reason.textContent = recordedDecision.reason;
+      card.appendChild(reason);
+    }
+    return card;
+  }
+
   // 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.
@@ -16688,7 +16791,7 @@ function tfProposalCard(p, scope) {
   // A skipped lesson is saved at no level, so no level is selected on that row.
   // Showing "Skipped" next to a highlighted level says two contradictory things
   // about the same row. The buttons stay live: picking a level clears the skip.
-  const isSkipped = !!(tfProposalOverrides[p.proposalId] || {}).skipped;
+  const isSkipped = !!(tfProposalOverrides[tfProposalStateKey(p)] || {}).skipped;
   if (isSkipped) pick.classList.add('lp-moot');
   for (const [level, label] of LEVELS) {
     const b = document.createElement('button');
@@ -16718,13 +16821,13 @@ function tfProposalCard(p, scope) {
   decide.dataset.testid = 'lp-decide';
 
   const skip = document.createElement('button');
-  skip.className = 'lp-skip' + ((tfProposalOverrides[p.proposalId] || {}).skipped || decided === 'reject' ? ' on' : '');
+  skip.className = 'lp-skip' + ((tfProposalOverrides[tfProposalStateKey(p)] || {}).skipped || decided === 'reject' ? ' on' : '');
   skip.type = 'button';
   skip.dataset.testid = 'lp-skip';
-  skip.textContent = (tfProposalOverrides[p.proposalId] || {}).skipped || decided === 'reject' ? '✕ Skipped' : 'Skip';
+  skip.textContent = (tfProposalOverrides[tfProposalStateKey(p)] || {}).skipped || decided === 'reject' ? '✕ Skipped' : 'Skip';
   skip.disabled = !!decided;
   skip.addEventListener('click', () => {
-    const wasSkipped = !!(tfProposalOverrides[p.proposalId] || {}).skipped;
+    const wasSkipped = !!(tfProposalOverrides[tfProposalStateKey(p)] || {}).skipped;
     tfSetProposalOverride(p, { skipped: !wasSkipped });
     reRender();
   });
@@ -16739,7 +16842,7 @@ function tfProposalCard(p, scope) {
     const id = 'lp-why-' + String(p.proposalId).replace(/[^a-zA-Z0-9_-]/g, '');
     const label = document.createElement('label');
     label.setAttribute('for', id);
-    label.textContent = (tfProposalOverrides[p.proposalId] || {}).skipped
+    label.textContent = (tfProposalOverrides[tfProposalStateKey(p)] || {}).skipped
       ? 'Why skip it?'
       : 'Why this level instead?';
     const ta = document.createElement('textarea');
@@ -16749,8 +16852,14 @@ function tfProposalCard(p, scope) {
     ta.value = tfProposalReason(p);
     // Persist on input so a re-render from the poll cadence cannot wipe what the
     // manager typed before they save.
-    ta.addEventListener('input', () => { tfSetProposalOverride(p, { reason: ta.value }); });
-    ta.addEventListener('change', () => { tfSetProposalOverride(p, { reason: ta.value }); reRender(); });
+    ta.addEventListener('input', () => {
+      tfSetProposalOverride(p, { reason: ta.value });
+      // Update the reason-required action without replacing the focused textarea.
+      const turn = card.closest('#learn-proposal-turn');
+      const bar = turn && turn.querySelector('.learn-batch');
+      const owner = tfProposalOwner([p]);
+      if (bar && owner) bar.replaceWith(tfLearningBatchBar(tfPendingProposals(owner), scope));
+    });
     const hint = document.createElement('span');
     hint.className = 'lp-why-hint';
     hint.textContent = 'Saved as a signal, so future runs get this right without asking.';
@@ -16774,7 +16883,7 @@ function tfProposalCard(p, scope) {
   // 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 = (tfProposalOverrides[p.proposalId] || {}).skipped
+  note.textContent = (tfProposalOverrides[tfProposalStateKey(p)] || {}).skipped
     ? 'Nothing is written. The skip is recorded as a signal.'
     : (TF_LEVEL_TITLE[currentLevel] || tfScopeMeta(scope).note);
   decide.appendChild(note);
@@ -16785,17 +16894,11 @@ function tfProposalCard(p, scope) {
 // #521 R7: promote a project candidate to a chosen scope. Reuses the live relay
 // (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 = tfFindLearningRun(originScope);
-  const message = `Promote the proposal "${proposal.title}" to ${label.toLowerCase()} learnings (scope: ${targetScope}).`;
-  tfProposalDecisions[tfProposalKey(proposal)] = 'promote:' + targetScope;
-  if (conv && conv.runId) {
-    const prev = state.activeId;
-    state.activeId = conv.id;
-    try { await continueRun(message); } finally { state.activeId = prev; }
-  } else if (typeof showStatus === 'function') {
-    showStatus(`Promoted “${proposal.title}” to ${label} learnings. Run Share learnings to let sleep-on-learnings persist it.`, false);
-  }
+  const label = tfLevelWord(targetScope);
+  await tfRelayBatch(originScope, `Promote the proposal "${proposal.title}" to ${label}.`, [{
+    proposalId: proposal.proposalId, revision: proposal.revision,
+    action: 'approve', level: targetScope, reason: tfProposalReason(proposal),
+  }], [proposal]);
 }
 
 // ---------------------------------------------------------------------------