mason-context 0.10.0 → 0.11.0

package/dist/mason-hook.js

@@ -153,6 +153,19 @@ import path6 from "path";
 
 // 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"]),
@@ -257,6 +270,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 index = record.history.length - 1;
+  while (index >= 0 && !["accepted", "reaffirmed"].includes(record.history[index].kind)) index--;
+  if (index < 0) return record;
+  const event = record.history[index];
+  return {
+    ...record,
+    ...event.content,
+    owner: event.content.owner,
+    approval: "accepted",
+    revision: event.revision,
+    refreshedHash: event.refreshedHash,
+    updatedAt: event.at,
+    history: record.history.slice(0, index + 1)
+  };
+}
+function decisionAnchors(record) {
+  return [.../* @__PURE__ */ new Set([...effectiveDecision(record).files, ...record.files])];
+}
 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;
@@ -270,6 +303,21 @@ 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) } : {}
+  };
+}
+var 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.";
 
 // src/decisions/decisions.ts
 async function loadDecisionStore(rootDir) {
@@ -354,12 +402,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);
@@ -368,9 +412,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;
 }
@@ -399,10 +450,10 @@ async function findMasonRoot(startDir) {
   return null;
 }
 function anchorsCover(record, relPath) {
-  return record.files.some((anchor) => anchorMatches(anchor, relPath));
+  return decisionAnchors(record).some((anchor) => anchorMatches(anchor, relPath));
 }
 function exactAnchor(record, relPath) {
-  return record.files.some((a) => a.replace(/\/+$/, "") === relPath);
+  return decisionAnchors(record).some((a) => a.replace(/\/+$/, "") === relPath);
 }
 function stateKey(input) {
   const raw = `${input.session_id ?? "nosession"}${input.agent_id ? `-${input.agent_id}` : ""}`;
@@ -416,18 +467,21 @@ async function loadInjected(stateFile) {
     return /* @__PURE__ */ new Set();
   }
 }
-function formatContext(relPath, records, freshness) {
+function formatContext(relPath, records, drift) {
   const lines = [];
   lines.push(
-    `Mason: recorded knowledge anchored to ${relPath}. Accepted records are constraints subject to freshness; proposals are suggestions and legacy unreviewed records need confirmation. Retired or superseded records are no longer active. Do not modify decision records in .mason/decisions/.`
+    `Mason: decision knowledge relevant to ${relPath} or updated since this session saw it. This replaces earlier guidance for the same decision id. ${DECISION_GUIDANCE} Retired or superseded records are no longer active. Do not modify decision records in .mason/decisions/.`
   );
-  for (const record of records) {
-    const provenance = decisionProvenance(record, freshness[record.id] ?? "unknown");
-    const label = record.status === "active" ? provenance.approval : record.status;
-    const stale = freshness[record.id] === "current" ? "" : freshness[record.id] === "changed" ? " [recorded against changed files \u2013 verify against current code before relying on it]" : " [freshness unknown \u2013 verify against current code before relying on it]";
+  const append = (id, knowledge, label, freshness) => {
+    const stale = freshness === "current" ? "" : freshness === "changed" ? " [recorded against changed files \u2013 verify against current code before relying on it]" : " [freshness unknown \u2013 verify against current code before relying on it]";
     lines.push(
-      `- [${label}] [${record.category}] ${record.title}: ${record.body} (anchors: ${record.files.join(", ")}; owner: ${provenance.owner ?? "unknown"}; sources: ${provenance.sources.slice(0, 2).map((s) => s.reference).join(", ") || "unrecorded"})${stale}`
+      `- [${label}] [${knowledge.category}] ${knowledge.title}: ${knowledge.body} (id: ${id}; revision: ${knowledge.revision}; anchors: ${knowledge.files.join(", ")}; owner: ${knowledge.owner ?? "unknown"}; sources: ${knowledge.sources.slice(0, 2).map((s) => s.reference).join(", ") || "unrecorded"})${stale}`
     );
+  };
+  for (const record of records) {
+    const knowledge = decisionKnowledge(record, drift.freshness?.[record.id] ?? "unknown", drift.pendingProposals?.[record.id]?.freshness ?? "unknown");
+    append(record.id, knowledge, record.status === "active" ? knowledge.approval : record.status, knowledge.trust.freshness);
+    if (knowledge.pendingProposal) append(record.id, knowledge.pendingProposal, "proposed", knowledge.pendingProposal.trust.freshness);
   }
   return lines.join("\n");
 }
@@ -448,13 +502,12 @@ async function runHook(stdinText, env = {}) {
   const relPath = path10.relative(root, absPath).split(path10.sep).join("/");
   if (relPath.startsWith("..")) return null;
   const { records } = await loadDecisionStore(root);
-  const matched = records.filter((r) => anchorsCover(r, relPath));
-  if (matched.length === 0) return null;
   const stateDir = env.stateDir ?? os.tmpdir();
   const stateFile = path10.join(stateDir, `mason-hook-${createHash2("sha256").update(root).digest("hex").slice(0, 12)}-${stateKey(input)}.json`);
   const injected = await loadInjected(stateFile);
   const recordKey = (record) => `${record.id}:${createHash2("sha256").update(JSON.stringify(record)).digest("hex")}`;
-  const fresh = matched.filter((r) => !injected.has(recordKey(r)) && (r.status === "active" || [...injected].some((key) => key === r.id || key.startsWith(`${r.id}:`))));
+  const previouslyInjected = (record) => [...injected].some((key) => key === record.id || key.startsWith(`${record.id}:`));
+  const fresh = records.filter((r) => !injected.has(recordKey(r)) && (previouslyInjected(r) || r.status === "active" && anchorsCover(r, relPath)));
   if (fresh.length === 0) return null;
   fresh.sort((a, b) => {
     const withdrawn = Number(b.status !== "active") - Number(a.status !== "active");
@@ -465,7 +518,6 @@ async function runHook(stdinText, env = {}) {
   });
   const selected = fresh.slice(0, MAX_INJECTED_DECISIONS);
   const drift = await computeDecisionDrift(root, selected);
-  const freshness = drift.freshness ?? {};
   for (const record of selected) injected.add(recordKey(record));
   try {
     await fs5.writeFile(stateFile, JSON.stringify([...injected]), "utf-8");
@@ -474,7 +526,7 @@ async function runHook(stdinText, env = {}) {
   return JSON.stringify({
     hookSpecificOutput: {
       hookEventName: "PostToolUse",
-      additionalContext: formatContext(relPath, selected, freshness)
+      additionalContext: formatContext(relPath, selected, drift)
     }
   });
 }