mason-context 0.10.0 → 0.10.1

package/dist/mason-mcp.js

@@ -79,6 +79,26 @@ function decisionContent(record) {
 function decisionApproval(record) {
   return record.version === 1 ? "unreviewed" : record.approval;
 }
+function effectiveDecision(record) {
+  if (record.version !== 2 || record.status !== "active" || record.approval !== "proposed") return record;
+  let index2 = record.history.length - 1;
+  while (index2 >= 0 && !["accepted", "reaffirmed"].includes(record.history[index2].kind)) index2--;
+  if (index2 < 0) return record;
+  const event = record.history[index2];
+  return {
+    ...record,
+    ...event.content,
+    owner: event.content.owner,
+    approval: "accepted",
+    revision: event.revision,
+    refreshedHash: event.refreshedHash,
+    updatedAt: event.at,
+    history: record.history.slice(0, index2 + 1)
+  };
+}
+function decisionAnchors(record) {
+  return [.../* @__PURE__ */ new Set([...effectiveDecision(record).files, ...record.files])];
+}
 function importLegacy(record, now) {
   if (record.version === 2) return record;
   const content = decisionContent({ title: record.title, body: record.body, category: record.category, files: record.files });
@@ -122,6 +142,22 @@ function decisionTrust(record, freshness) {
   const review = decisionProvenance(record, freshness).lastReview;
   return assessTrust(review ? { verifiedAt: review.at, verifiedHash: review.gitHash } : {}, freshness);
 }
+function revisionKnowledge(record, freshness) {
+  return { ...decisionContent(record), ...decisionProvenance(record, freshness), trust: decisionTrust(record, freshness) };
+}
+function decisionKnowledge(record, freshness = "unknown", proposalFreshness = "unknown") {
+  const effective = effectiveDecision(record);
+  return {
+    ...revisionKnowledge(effective, freshness),
+    ...effective !== record ? { pendingProposal: revisionKnowledge(record, proposalFreshness) } : {}
+  };
+}
+function compactDecisionKnowledge(...args) {
+  const { body, pendingProposal, ...summary } = decisionKnowledge(...args);
+  if (!pendingProposal) return summary;
+  const { body: proposalBody, ...proposal } = pendingProposal;
+  return { ...summary, pendingProposal: proposal };
+}
 var text, decisionSourceSchema, attributionSchema, contentSchema, approvalSchema, statusSchema, reviewEvidenceSchema, eventSchema, legacySchema, currentSchema, decisionSchema, DECISION_GUIDANCE;
 var init_provenance = __esm({
   "src/decisions/provenance.ts"() {
@@ -219,7 +255,7 @@ var init_provenance = __esm({
       if (!previous || !same(previous.content, decisionContent(record)) || previous.approval !== record.approval || previous.status !== record.status || previous.revision !== record.revision || previous.refreshedHash !== record.refreshedHash) invalid("Decision does not match the final history event");
     });
     decisionSchema = z.union([legacySchema, currentSchema]);
-    DECISION_GUIDANCE = "Accepted decisions are recorded team constraints, subject to freshness checks. Proposals are suggestions; legacy unreviewed records need confirmation. Use review_decision to inspect provenance and record an authorized review; identities and sources are recorded assertions, not authenticated proof.";
+    DECISION_GUIDANCE = "Accepted decisions are recorded team constraints, subject to freshness checks. A pendingProposal is an unaccepted replacement; the accepted revision remains operative until explicit acceptance or retirement. Proposals are suggestions; legacy unreviewed records need confirmation. Use review_decision to inspect provenance and record an authorized review; identities and sources are recorded assertions, not authenticated proof.";
   }
 });
 
@@ -867,7 +903,7 @@ async function upsertDecision(rootDir, input) {
         warnings.push(`anchor file does not exist on disk: ${file}`);
       }
     }
-    const hint = "Saved locally for review and commit. Proposals are not accepted constraints. Use review_decision to inspect evidence and record an authorized acceptance or reaffirmation.";
+    const hint = "Saved locally for review and commit. Proposals are not accepted constraints; an existing accepted revision remains operative while its replacement is proposed. Use review_decision to inspect evidence and record an authorized acceptance or reaffirmation.";
     if (input.id) {
       const original = byId.get(input.id);
       if (!original) return { status: "error", error: `no decision with id "${input.id}"` };
@@ -907,7 +943,7 @@ async function upsertDecision(rootDir, input) {
     }
     const old = input.supersedes ? byId.get(input.supersedes) : void 0;
     if (input.supersedes && !old) return { status: "error", error: `no decision with id "${input.supersedes}" to supersede` };
-    if (old && (old.status !== "active" || decisionApproval(old) === "accepted")) {
+    if (old && (old.status !== "active" || decisionApproval(effectiveDecision(old)) === "accepted")) {
       return { status: "error", error: "A proposal cannot supersede an accepted or archived record. Create and review the replacement separately, then explicitly retire the old decision with review_decision." };
     }
     if (!input.force) {
@@ -1153,12 +1189,8 @@ async function computeDecisionDrift(rootDir, decisions) {
   const report = { historyAvailable: true, totalDecisions: store.records.length, staleDecisions: {}, freshness: {}, diagnostics: store.diagnostics };
   const [head, workingTree] = await Promise.all([getCurrentGitHash(resolvedRoot), getWorkingTree(resolvedRoot)]);
   const changesByHash = /* @__PURE__ */ new Map();
-  for (const record of store.records) {
-    if (record.status !== "active") continue;
-    if (record.files.length === 0) {
-      report.freshness[record.id] = "unknown";
-      continue;
-    }
+  const inspect = async (record) => {
+    if (record.files.length === 0) return { freshness: "unknown", changedFiles: [] };
     let touched = changesByHash.get(record.refreshedHash);
     if (touched === void 0) {
       const changes = record.refreshedHash === head && head !== "unknown" ? [] : await getChangesWithStatus(resolvedRoot, record.refreshedHash);
@@ -1167,9 +1199,16 @@ async function computeDecisionDrift(rootDir, decisions) {
     }
     if (touched === null) report.historyAvailable = false;
     const hits = touched ? matchingPaths(record.files, touched) : [];
-    if (hits.length) report.staleDecisions[record.id] = hits;
     const localHits = matchingPaths(record.files, workingTree.changedFiles);
-    report.freshness[record.id] = touched === null || !workingTree.available ? "unknown" : hits.length || localHits.length ? "changed" : "current";
+    return { freshness: touched === null || !workingTree.available ? "unknown" : hits.length || localHits.length ? "changed" : "current", changedFiles: hits };
+  };
+  for (const record of store.records) {
+    if (record.status !== "active") continue;
+    const effective = effectiveDecision(record);
+    const state = await inspect(effective);
+    report.freshness[record.id] = state.freshness;
+    if (state.changedFiles.length) report.staleDecisions[record.id] = state.changedFiles;
+    if (effective !== record) (report.pendingProposals ??= {})[record.id] = await inspect(record);
   }
   return report;
 }
@@ -1180,6 +1219,7 @@ var init_drift2 = __esm({
     init_paths();
     init_snapshot();
     init_decisions();
+    init_provenance();
   }
 });
 
@@ -1407,7 +1447,7 @@ async function assembleContext(rootDir, task, files) {
   };
   if (!snapshot) {
     const decisions2 = matchDecisions(allDecisions, taskTokens, anchorBoost, /* @__PURE__ */ new Set(), decisionDrift);
-    const { impact: impact2, relatedTests: relatedTests2 } = await collectImpact(resolvedRoot, [...anchorFiles, ...Object.values(decisions2).flatMap((d) => d.files)]);
+    const { impact: impact2, relatedTests: relatedTests2 } = await collectImpact(resolvedRoot, [...anchorFiles, ...Object.values(decisions2).flatMap((d) => [...d.files, ...d.pendingProposal?.files ?? []])]);
     const invalid = mapState.status === "invalid";
     return {
       exists: false,
@@ -1420,7 +1460,7 @@ async function assembleContext(rootDir, task, files) {
       relatedTests: relatedTests2,
       diagnostics: [...mapState.diagnostics, ...store.diagnostics],
       freshness: { stale: null, recommendation: invalid ? "repair-map" : "no-map", staleMatches: [] },
-      hint: (invalid ? "The concept map is invalid; consult diagnostics and repair it before relying on map entries. " : "No concept map is present. Maps are optional; decisions and file impact work now. ") + (Object.keys(decisions2).length ? DECISION_GUIDANCE + " " + trustHint(Object.values(decisions2).map((d) => d.trust)) : "No saved decision matched. Inspect the source and use save_decision for a learned constraint or incident rationale. ") + (store.diagnostics.length ? " Some decision records are invalid; consult diagnostics before assuming all constraints were retrieved." : "")
+      hint: (invalid ? "The concept map is invalid; consult diagnostics and repair it before relying on map entries. " : "No concept map is present. Maps are optional; decisions and file impact work now. ") + (Object.keys(decisions2).length ? DECISION_GUIDANCE + " " + trustHint(Object.values(decisions2).flatMap((d) => [d.trust, ...d.pendingProposal ? [d.pendingProposal.trust] : []])) : "No saved decision matched. Inspect the source and use save_decision for a learned constraint or incident rationale. ") + (store.diagnostics.length ? " Some decision records are invalid; consult diagnostics before assuming all constraints were retrieved." : "")
     };
   }
   const drift = await computeDrift(resolvedRoot);
@@ -1447,7 +1487,7 @@ async function assembleContext(rootDir, task, files) {
   );
   if (featureScores.length === 0 && flowScores.length === 0) {
     const bundle = noMatchBundle(snapshot, task, decisions);
-    Object.assign(bundle, await collectImpact(resolvedRoot, [...anchorFiles, ...Object.values(decisions).flatMap((d) => d.files)]));
+    Object.assign(bundle, await collectImpact(resolvedRoot, [...anchorFiles, ...Object.values(decisions).flatMap((d) => [...d.files, ...d.pendingProposal?.files ?? []])]));
     bundle.diagnostics = store.diagnostics;
     bundle.freshness = drift;
     bundle.trust = {
@@ -1461,7 +1501,7 @@ async function assembleContext(rootDir, task, files) {
     bundle.hint += " " + trustHint([
       ...Object.values(bundle.trust.features),
       ...Object.values(bundle.trust.flows),
-      ...Object.values(decisions).map((d) => d.trust)
+      ...Object.values(decisions).flatMap((d) => [d.trust, ...d.pendingProposal ? [d.pendingProposal.trust] : []])
     ]);
     if (Object.keys(decisions).length) bundle.hint += " " + DECISION_GUIDANCE;
     if (store.diagnostics.length) bundle.hint += " Some decision records are invalid; consult diagnostics.";
@@ -1500,7 +1540,7 @@ async function assembleContext(rootDir, task, files) {
     ...anchorFiles,
     ...featureScores.flatMap((e) => e.feat.files),
     ...flowScores.flatMap((e) => e.flow.chain),
-    ...Object.values(decisions).flatMap((d) => d.files)
+    ...Object.values(decisions).flatMap((d) => [...d.files, ...d.pendingProposal?.files ?? []])
   ]);
   const relatedTests = [
     .../* @__PURE__ */ new Set([
@@ -1524,32 +1564,21 @@ async function assembleContext(rootDir, task, files) {
       recommendation: drift?.recommendation ?? "up-to-date",
       staleMatches
     },
-    hint: (Object.keys(decisions).length ? DECISION_GUIDANCE + " " : "") + trustHint([...Object.values(features), ...Object.values(flows), ...Object.values(decisions)].map((e) => e.trust)) + (store.diagnostics.length ? " Some decision records are invalid; consult diagnostics before assuming all constraints were retrieved." : "")
+    hint: (Object.keys(decisions).length ? DECISION_GUIDANCE + " " : "") + trustHint([...Object.values(features).map((e) => e.trust), ...Object.values(flows).map((e) => e.trust), ...Object.values(decisions).flatMap((d) => [d.trust, ...d.pendingProposal ? [d.pendingProposal.trust] : []])]) + (store.diagnostics.length ? " Some decision records are invalid; consult diagnostics before assuming all constraints were retrieved." : "")
   };
 }
 function matchDecisions(allDecisions, taskTokens, anchorBoost, matchedEntryFiles, decisionDrift) {
   const scored = allDecisions.filter((d) => d.status === "active").map((d) => {
-    let score = scoreEntry(taskTokens, {
-      name: d.title,
-      description: d.body,
-      files: d.files
-    }) + anchorBoost(d.files);
-    if (d.files.some((f) => [...matchedEntryFiles].some((file) => anchorMatches(f, file)))) {
-      score += DECISION_FEATURE_OVERLAP_BOOST;
-    }
+    const scoreRevision = (revision) => scoreEntry(taskTokens, { name: revision.title, description: revision.body, files: revision.files }) + anchorBoost(revision.files) + (revision.files.some((f) => [...matchedEntryFiles].some((file) => anchorMatches(f, file))) ? DECISION_FEATURE_OVERLAP_BOOST : 0);
+    const score = Math.max(scoreRevision(effectiveDecision(d)), scoreRevision(d));
     return { d, score };
   }).filter((e) => e.score > 0).sort((a, b) => b.score - a.score).slice(0, MAX_DECISIONS);
   const result = {};
   for (const { d, score } of scored) {
     result[d.id] = {
-      title: d.title,
-      body: d.body,
-      category: d.category,
-      files: d.files,
+      ...decisionKnowledge(d, decisionDrift.freshness?.[d.id] ?? "unknown", decisionDrift.pendingProposals?.[d.id]?.freshness ?? "unknown"),
       score,
-      stale: decisionDrift.freshness?.[d.id] !== "current",
-      ...decisionProvenance(d, decisionDrift.freshness?.[d.id] ?? "unknown"),
-      trust: decisionTrust(d, decisionDrift.freshness?.[d.id] ?? "unknown")
+      stale: decisionDrift.freshness?.[d.id] !== "current"
     };
   }
   return result;
@@ -3017,24 +3046,26 @@ async function reviewState(root, record) {
     getWorkingTree(root),
     getChangesWithStatus(root, record.refreshedHash)
   ]);
-  const committed = (changes ?? []).filter((c) => [c.path, ...c.previousPath ? [c.previousPath] : []].some((file) => record.files.some((anchor) => anchorMatches(anchor, file))));
+  const anchors = decisionAnchors(record);
+  const committed = (changes ?? []).filter((c) => [c.path, ...c.previousPath ? [c.previousPath] : []].some((file) => anchors.some((anchor) => anchorMatches(anchor, file))));
   const evidence = {
     baseHash: record.refreshedHash,
     headHash,
     historyAvailable: changes !== null,
     changedFiles: touchedPaths(committed),
-    localChanges: matchingPaths(record.files, workingTree.changedFiles)
+    localChanges: matchingPaths(anchors, workingTree.changedFiles)
   };
   const reviewToken = createHash2("sha256").update(JSON.stringify({ record, evidence, workingTreeAvailable: workingTree.available })).digest("hex");
   return { reviewToken, evidence, committed, workingTreeAvailable: workingTree.available };
 }
 async function previews(root, record, state) {
   const access = await createFileAccess(root);
+  const anchors = decisionAnchors(record);
   const candidates = [.../* @__PURE__ */ new Set([
     ...state.evidence.changedFiles,
     ...state.evidence.localChanges,
-    ...record.files,
-    ...(await access.list()).filter((file) => record.files.some((anchor) => anchorMatches(anchor, file)))
+    ...anchors,
+    ...(await access.list()).filter((file) => anchors.some((anchor) => anchorMatches(anchor, file)))
   ])];
   const files = [];
   const omittedFiles = [];
@@ -3077,14 +3108,16 @@ async function reviewDecision(root, input) {
     const { record, diagnostics } = await read();
     if (!record) return { status: "error", error: `No readable decision with id "${request.id}"`, diagnostics };
     const state = await reviewState(root, record);
+    const operativeDecision = effectiveDecision(record);
     return {
       status: "prepared",
       record,
+      ...operativeDecision !== record ? { operativeDecision } : {},
       provenance: decisionProvenance(record),
       ...state,
       diagnostics,
       previews: await previews(root, record, state),
-      hint: "Inspect the content, sources, history, and code changes. Only record acceptance or reaffirmation when the user or cited team review has authorized it. Supply that reviewer's identity, a reason, and this reviewToken. Do not invent identities or infer agreement from unchanged code. Acceptance and reaffirmation require committed anchor changes; retirement is available independently. Missing old history remains visible in the event even if a reviewer establishes a new baseline at HEAD. Saved reviews are local assertions for normal PR review, not authenticated approvals."
+      hint: "Inspect the proposed content, operativeDecision, sources, history, and code changes. A pending proposal leaves the prior accepted revision operative; accepting it replaces that revision, and retirement withdraws the entire decision including its proposal. Evidence covers both revisions' anchors. Only record acceptance or reaffirmation when the user or cited team review has authorized it. Supply that reviewer's identity, a reason, and this reviewToken. Do not invent identities or infer agreement from unchanged code. Acceptance and reaffirmation require committed anchor changes; retirement is available independently. Missing old history remains visible in the event even if a reviewer establishes a new baseline at HEAD. Saved reviews are local assertions for normal PR review, not authenticated approvals."
     };
   }
   if (!request.reviewer || !request.note || !request.reviewToken) return { status: "error", error: "Prepare the review first, then provide reviewToken, reviewer, and note." };
@@ -3300,7 +3333,7 @@ Mason provides recorded decisions and file impact over MCP. A concept map is opt
 - Task, bug, or change request \u2192 \`get_context\` with the task text and known files: matching decisions, related tests, impact, and any available map entries.
 - Before editing a file \u2192 \`get_impact\` to check references, tests, and historical change partners.
 - Learned something the code cannot explain (a failed approach, an incident's cause, a workaround's reason, a review-settled convention) \u2192 \`save_decision\` with rationale, anchors, and any known owner, sources, and recorder. It creates a proposal immediately without setup or a map. Never invent attribution or record code-derivable facts, session trivia, or secrets.
-- Consult trust metadata before relying on entries: unknown or changed freshness requires inspection, and failed verification means the description must be corrected. Check approval too: proposals are suggestions, legacy records are unreviewed, and accepted decisions are recorded constraints subject to freshness checks.
+- Consult trust metadata before relying on entries: unknown or changed freshness requires inspection, and failed verification means the description must be corrected. Check approval too: proposals are suggestions, legacy records are unreviewed, and accepted decisions are recorded constraints subject to freshness checks. An accepted revision remains operative while a pending proposal is reviewed; keep both versions and their freshness distinct.
 - Asked to review or re-verify a decision \u2192 \`review_decision\` first to inspect content, sources, history, and code changes. Record acceptance, reaffirmation, or retirement only when authorized by the user or a cited team review, with the actual reviewer and reason. Never infer approval from unchanged code. Review and commit the local record through the normal project workflow.
 - For an architectural overview, use \`get_snapshot\` if a map is available. If \`map.status\` is missing or invalid, use available decisions and source evidence; do not start building a map unless requested.
 - \`mason_init\` returns documentation audit and committed-diff review results, plus a short setup guide. Pass \`evidence\` with local CI manifest paths to include test and analysis results; the CLI equivalent is \`mason-review --evidence <manifest>\`. State skipped, unavailable, stale, or unknown checks explicitly. Related accepted decisions identify review context, not proven violations.
@@ -3323,7 +3356,7 @@ var QUICKSTART_PLAYBOOK = `Start with the audit and review results included in t
 
 1. Explain the actionable findings with their source evidence. Separate audit issues, advisories, and skipped checks. The review covers committed changes from the merge base to HEAD; workingTree paths are not included in that review. An unavailable or empty check is not proof that the project is correct. Use the CLI for full output if a summary is truncated.
 2. Address findings within the user's requested scope. Inspect relevant source and tests. Do not invent a decision just to populate the store.
-3. When the task reveals a real lesson or constraint, call \`save_decision\` with title, body, category, anchors, and known owner/source/actor information. Missing attribution can be added later. The tool writes a local proposal; editing it preserves revision history and requires a new acceptance. An unchanged save never refreshes its evidence. When decision review is requested, \`review_decision\` prepares the record and code evidence before any authorized verdict. Review and commit records through the normal workflow. Retrieve it on the next relevant task with \`get_context(dir, task, files)\`.
+3. When the task reveals a real lesson or constraint, call \`save_decision\` with title, body, category, anchors, and known owner/source/actor information. Missing attribution can be added later. The tool writes a local proposal; editing it preserves revision history and requires a new acceptance, while any earlier accepted revision remains operative. An unchanged save never refreshes its evidence. When decision review is requested, \`review_decision\` prepares the record and code evidence before any authorized verdict. Review and commit records through the normal workflow. Retrieve it on the next relevant task with \`get_context(dir, task, files)\`.
 
 ${ASSISTANT_SETUP}
 
@@ -4255,11 +4288,14 @@ async function checkDecisionAnchors(ctx) {
       reason: "some decision base commits are unreachable (shallow clone?)"
     });
   }
-  const byId = new Map(records.map((r) => [r.id, r]));
-  for (const [id, changedFiles] of Object.entries(drift.staleDecisions)) {
-    const record = byId.get(id);
-    if (!record) continue;
-    const provenance = decisionProvenance(record, drift.freshness?.[id] ?? "unknown");
+  const changed = records.flatMap((record) => [
+    { record: effectiveDecision(record), changedFiles: drift.staleDecisions[record.id] ?? [], freshness: drift.freshness?.[record.id] ?? "unknown" },
+    { record, changedFiles: drift.pendingProposals?.[record.id]?.changedFiles ?? [], freshness: drift.pendingProposals?.[record.id]?.freshness ?? "unknown" }
+  ]);
+  for (const { record, changedFiles, freshness } of changed) {
+    if (!changedFiles.length) continue;
+    const id = record.id;
+    const provenance = decisionProvenance(record, freshness);
     result.advisories.push({
       type: "decision-anchor-drift",
       message: `decision "${record.title}" (${provenance.approval}) has anchor files that changed since its evidence baseline \u2013 needs human review`,
@@ -4685,7 +4721,7 @@ function linkFinding(finding, changed, pairs, decisions, freshness) {
     if (changed.has(pair.source) && !relatedChangedFiles.some((f) => f.file === pair.source)) relatedChangedFiles.push({ file: pair.source, relationship: "paired-test", confidence: pair.confidence });
   }
   const allFiles = [.../* @__PURE__ */ new Set([...located, ...paired.map((pair) => pair.source)])];
-  const acceptedDecisions = decisions.filter((d) => d.status === "active" && decisionApproval(d) === "accepted").map((d) => ({ d, viaFiles: matchingPaths(d.files, allFiles) })).filter((match) => match.viaFiles.length).map(({ d, viaFiles }) => {
+  const acceptedDecisions = decisions.map(effectiveDecision).filter((d) => d.status === "active" && decisionApproval(d) === "accepted").map((d) => ({ d, viaFiles: matchingPaths(d.files, allFiles) })).filter((match) => match.viaFiles.length).map(({ d, viaFiles }) => {
     const state = freshness[d.id] ?? "unknown", provenance = decisionProvenance(d, state);
     return { id: d.id, title: d.title, owner: provenance.owner, freshness: state, reviewRequired: provenance.reviewRequired, viaFiles };
   });
@@ -4947,16 +4983,17 @@ async function computeReview(rootDir, base, options = {}) {
   }
   const decisions = store.records;
   for (const record of decisions) {
-    if (record.status !== "active" || record.files.length === 0) continue;
-    const touched = anchorsTouched(record, changedFiles);
-    if (touched.length > 0) {
+    if (record.status !== "active") continue;
+    const effective = effectiveDecision(record);
+    const touched = anchorsTouched(effective, changedFiles);
+    const proposalTouched = effective !== record ? anchorsTouched(record, changedFiles) : [];
+    if (touched.length > 0 || proposalTouched.length > 0) {
+      const { pendingProposal, ...knowledge } = decisionKnowledge(record, decisionDrift.freshness?.[record.id] ?? "unknown", decisionDrift.pendingProposals?.[record.id]?.freshness ?? "unknown");
       report.touchedDecisions.push({
-        ...decisionProvenance(record, decisionDrift.freshness?.[record.id] ?? "unknown"),
+        ...knowledge,
+        ...pendingProposal ? { pendingProposal: { ...pendingProposal, touchedFiles: proposalTouched } } : {},
         id: record.id,
-        title: record.title,
-        body: record.body,
-        category: record.category,
-        anchors: record.files,
+        anchors: effective.files,
         freshness: decisionDrift.freshness?.[record.id] ?? "unknown",
         touchedFiles: touched
       });
@@ -5028,7 +5065,8 @@ async function inspectOnboarding(root, base, evidence) {
     map: { status: map.status },
     decisions: {
       active: decisions.records.filter((record) => record.status === "active").length,
-      ...Object.fromEntries(["accepted", "proposed", "unreviewed"].map((approval) => [approval, decisions.records.filter((record) => record.status === "active" && decisionApproval(record) === approval).length]))
+      ...Object.fromEntries(["accepted", "proposed", "unreviewed"].map((approval) => [approval, decisions.records.filter((record) => record.status === "active" && decisionApproval(effectiveDecision(record)) === approval).length])),
+      pendingProposals: decisions.records.filter((record) => effectiveDecision(record) !== record).length
     },
     diagnostics: [...map.diagnostics, ...decisions.diagnostics]
   };
@@ -5292,7 +5330,7 @@ async function getSnapshot(dir) {
   const trust = {
     features: Object.fromEntries(Object.entries(snapshot.features).map(([name, entry]) => [name, assessTrust(entry, drift?.featureFreshness?.[name] ?? "unknown")])),
     flows: Object.fromEntries(Object.entries(snapshot.flows).map(([name, entry]) => [name, assessTrust(entry, drift?.flowFreshness?.[name] ?? "unknown")])),
-    decisions: Object.fromEntries(decisionRecords.filter((d) => d.status === "active").map((d) => [d.id, decisionTrust(d, decisionDrift.freshness?.[d.id] ?? "unknown")]))
+    decisions: Object.fromEntries(decisionRecords.filter((d) => d.status === "active").map((d) => [d.id, decisionTrust(effectiveDecision(d), decisionDrift.freshness?.[d.id] ?? "unknown")]))
   };
   output.trust = trust;
   output.workingTree = drift?.workingTree;
@@ -5301,12 +5339,7 @@ async function getSnapshot(dir) {
     const compactDecisions = {};
     for (const d of decisionRecords) {
       if (d.status !== "active") continue;
-      compactDecisions[d.id] = {
-        ...decisionProvenance(d, decisionDrift.freshness?.[d.id] ?? "unknown"),
-        title: d.title,
-        category: d.category,
-        files: d.files
-      };
+      compactDecisions[d.id] = compactDecisionKnowledge(d, decisionDrift.freshness?.[d.id] ?? "unknown", decisionDrift.pendingProposals?.[d.id]?.freshness ?? "unknown");
     }
     output.decisions = compactDecisions;
     output.decisionsHint = DECISION_GUIDANCE + " Full bodies via get_context; full history via review_decision.";
@@ -5930,7 +5963,7 @@ function createMcpServer() {
   const server = new McpServer(
     {
       name: "mason",
-      version: "0.10.0"
+      version: "0.10.1"
     },
     {
       instructions: 'Mason retrieves recorded decisions, file impact, and optional feature/flow maps. Use get_context with the task and known files, and get_impact before editing. Save learned rationale and constraints with save_decision; review and commit the local records through the project workflow. These tools work without initialization or a concept map. Consult trust and diagnostics: changed or unknown freshness needs source inspection, failed verification needs correction, and proposals are suggestions and legacy records are unreviewed. Accepted decisions are recorded team constraints, still subject to freshness checks. Use review_decision to prepare code evidence and record only authorized acceptance, reaffirmation, or retirement. Never invent a reviewer or treat these recorded identities as authenticated approval. mason_init returns documentation audit and committed-diff review findings with a quickstart guide. Use mode: "map" only when a full architecture map is requested. A missing map is not a setup failure; use decisions and source evidence. get_snapshot provides architecture navigation when a map is available. The mason-audit and mason-review CLIs also work without setup.'
@@ -6150,7 +6183,7 @@ function createMcpServer() {
   );
   server.tool(
     "save_decision",
-    "Capture or revise a decision proposal with rationale, anchors, optional owner, sources, and a known actor. No setup or map required. Writes a local record and preserves content history. Changes reset acceptance to proposed; unchanged content does not re-verify or refresh it. Use review_decision for authorized acceptance or reaffirmation. A proposal cannot supersede an accepted record; review its replacement and retire the original separately.",
+    "Capture or revise a decision proposal with rationale, anchors, optional owner, sources, and a known actor. No setup or map required. Writes a local record and preserves content history. Changes create a pending proposal while the last accepted revision remains operative; unchanged content does not re-verify or refresh it. Use review_decision for authorized acceptance or reaffirmation. A proposal cannot supersede a record with an operative accepted revision; review its replacement and retire the original separately.",
     {
       dir: z9.string().describe("Absolute path to the project root directory"),
       title: z9.string().max(80).describe("Short, specific headline \u2014 becomes the stable record id"),
@@ -6158,7 +6191,7 @@ function createMcpServer() {
       category: z9.enum(["decision", "gotcha", "deprecation", "convention"]),
       files: z9.array(z9.string()).optional().describe("Repo-relative files or directory prefixes this applies to. Matching is shared by retrieval, hooks, review, and drift checking; changes flag the decision for re-verification."),
       id: z9.string().optional().describe("Existing id to revise. Changed content becomes a proposal; unchanged content leaves the review and freshness untouched."),
-      supersedes: z9.string().optional().describe("Id of an unreviewed record or proposal to replace. Accepted decisions require separate review and retirement."),
+      supersedes: z9.string().optional().describe("Id of an unreviewed record or proposal with no accepted revision to replace. Operative accepted decisions require separate review and retirement."),
       owner: attributionSchema.shape.owner.describe("Responsible person or team, when known. Null clears it. Required for acceptance."),
       sources: attributionSchema.shape.sources.describe("Known PR, issue, incident, discussion, or document references. Omit to preserve; [] clears. At least one is required for acceptance."),
       actor: attributionSchema.shape.actor.describe("Known person or agent recording this revision. Omit if unknown; do not infer from Git identity."),
@@ -6182,7 +6215,7 @@ function createMcpServer() {
   );
   server.tool(
     "review_decision",
-    "Prepare a decision review: returns the full record and history, provenance, committed changes, local edits, bounded source/diff previews, and a reviewToken. Then record accept, reaffirm, or retire with that token, the authorized reviewer, and a reason. Acceptance requires owner, source, readable Git HEAD, and committed anchor changes. Changed records or code invalidate the token. Identities and approvals are recorded assertions for normal PR review, not authenticated proof.",
+    "Prepare a decision review: returns the full record and history, any operative accepted revision, provenance, changes and previews for both sets of anchors, and a reviewToken. Then record accept, reaffirm, or retire with that token, the authorized reviewer, and a reason. Acceptance replaces the operative revision; retirement withdraws the entire record including its proposal. Acceptance requires owner, source, readable Git HEAD, and committed anchor changes. Changed records or code invalidate the token. Identities and approvals are recorded assertions for normal PR review, not authenticated proof.",
     {
       dir: z9.string().describe("Absolute path to the project root directory"),
       id: z9.string().regex(/^[a-zA-Z0-9_-]+$/).describe("Decision id from get_context or save_decision"),