mason-context 0.10.0 → 0.11.0

package/dist/mason-review.js

@@ -376,6 +376,19 @@ async function getWorkingTree(resolvedRoot) {
 
 // src/decisions/provenance.ts
 import { z as z2 } from "zod";
+
+// src/context/trust.ts
+function assessTrust(entry, freshness) {
+  const verification = entry.verificationFailed ? "failed" : entry.verifiedAt ? "passed" : "unverified";
+  const reasons = [];
+  if (freshness === "unknown") reasons.push("Anchors, history, or working-tree evidence are unavailable; verify before relying on this entry.");
+  if (freshness === "changed") reasons.push("Anchored files changed; verify against current code before relying on this entry.");
+  if (verification === "failed") reasons.push(`Verification failed: ${entry.verificationNote ?? "re-map this entry before relying on it"}`);
+  if (verification === "unverified") reasons.push("No correctness verification has been recorded.");
+  return { freshness, verification, verifiedAt: entry.verifiedAt, verifiedHash: entry.verifiedHash, reasons };
+}
+
+// src/decisions/provenance.ts
 var text = (max) => z2.string().trim().min(1).max(max);
 var decisionSourceSchema = z2.object({
   kind: z2.enum(["pull_request", "issue", "incident", "discussion", "document", "other"]),
@@ -480,6 +493,23 @@ 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 decisionProvenance(record, freshness = "unknown") {
   const approval = decisionApproval(record);
   const review = record.version === 2 ? [...record.history].reverse().find((e) => ["accepted", "reaffirmed"].includes(e.kind) && e.revision === record.revision) : void 0;
@@ -493,6 +523,20 @@ function decisionProvenance(record, freshness = "unknown") {
     lastReview: review ? { reviewer: review.actor, at: review.at, note: review.note, gitHash: review.refreshedHash } : null
   };
 }
+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) } : {}
+  };
+}
 
 // src/decisions/decisions.ts
 import fs4 from "fs/promises";
@@ -535,12 +579,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);
@@ -549,9 +589,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;
 }
@@ -873,7 +920,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 };
   });
@@ -1105,16 +1152,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
       });
@@ -1242,10 +1290,14 @@ function formatReviewSummary(report) {
     lines.push("Recorded decisions touched by this diff (check approval and freshness before relying on them):");
     for (const d of report.touchedDecisions) {
       lines.push(
-        `  [decision] ${d.title} (${d.category}; ${d.approval ?? "unreviewed"}; owner ${d.owner ?? "unknown"}; freshness ${d.freshness ?? "unknown"}; via ${d.touchedFiles.join(", ")})`
+        `  [decision] ${d.title} (${d.category}; ${d.approval ?? "unreviewed"}; owner ${d.owner ?? "unknown"}; freshness ${d.freshness ?? "unknown"}; via ${d.touchedFiles.join(", ") || "pending proposal"})`
       );
       if (d.sources?.length) lines.push(`    sources: ${d.sources.map((s) => s.reference).join(", ")}`);
       if (d.lastReview) lines.push(`    last review: ${d.lastReview.reviewer} at ${d.lastReview.gitHash.slice(0, 7)}`);
+      if (d.pendingProposal) {
+        const p = d.pendingProposal;
+        lines.push(`    [proposed revision ${p.revision}] ${p.title} (owner ${p.owner ?? "unknown"}; freshness ${p.trust.freshness}; via ${p.touchedFiles.join(", ") || "no draft anchors touched"}); accepted revision ${d.revision} remains operative`);
+      }
     }
   }
   lines.push(