mason-context 0.21.0 → 0.22.0

package/dist/mason-hook.js

@@ -43,7 +43,7 @@ function isStringArray(value) {
 
 // src/hook/hook.ts
 import fs7 from "fs/promises";
-import path11 from "path";
+import path9 from "path";
 import os2 from "os";
 
 // src/audit/inspection.ts
@@ -543,12 +543,11 @@ function changedCaptureFiles(before, after) {
 
 // src/decisions/decisions.ts
 import fs5 from "fs/promises";
-import path8 from "path";
+import path6 from "path";
 import { createHash as createHash3 } from "crypto";
 import { z as z5 } from "zod";
 
 // src/snapshot/snapshot.ts
-import path6 from "path";
 import { z as z3 } from "zod";
 
 // src/utils/store-lock.ts
@@ -557,9 +556,6 @@ import fs4 from "fs/promises";
 import os from "os";
 var lockOwnerSchema = z2.object({ host: z2.string(), pid: z2.number().int().positive() });
 
-// src/test-map.ts
-import path5 from "path";
-
 // src/snapshot/snapshot.ts
 var repoPath2 = z3.string().refine((value) => normalizeRepoPath(value) !== null, "Expected a relative repository path");
 var verificationFields = {
@@ -598,7 +594,7 @@ async function getCurrentGitHash(rootDir) {
 }
 
 // src/context/lexical.ts
-import path7 from "path";
+import path5 from "path";
 
 // src/decisions/provenance.ts
 import { z as z4 } from "zod";
@@ -708,6 +704,7 @@ var currentSchema = legacySchema.extend({
       inspector: text(200),
       note: text(1500),
       outcome: z4.literal("no_contradiction_found"),
+      scope: z4.literal("operative").optional(),
       decisionDigest: z4.string().regex(/^[a-f0-9]{64}$/),
       headHash: z4.string(),
       capture: anchorCaptureSchema
@@ -821,8 +818,19 @@ function decisionTrust(record, freshness) {
     freshness
   );
 }
-function decisionInspectionDigest(record) {
+function decisionInspectionDigest(record, scope = "all") {
   const effective = effectiveDecision(record);
+  if (scope === "operative")
+    return createHash2("sha256").update(
+      JSON.stringify([
+        "operative",
+        record.status,
+        decisionApproval(effective),
+        effective.version === 2 ? effective.revision : 0,
+        decisionContent(effective),
+        effective.refreshedHash
+      ])
+    ).digest("hex");
   return createHash2("sha256").update(
     JSON.stringify([
       record.status,
@@ -834,8 +842,10 @@ function decisionInspectionDigest(record) {
     ])
   ).digest("hex");
 }
-function latestDecisionInspection(record) {
-  return record.version === 2 ? record.inspections?.filter((i) => i.decisionDigest === decisionInspectionDigest(record)).at(-1) : void 0;
+function latestDecisionInspection(record, scope = "all") {
+  return record.version === 2 ? record.inspections?.filter(
+    (i) => (scope === "operative" || i.scope !== "operative") && i.decisionDigest === decisionInspectionDigest(record, i.scope ?? "all")
+  ).at(-1) : void 0;
 }
 function revisionKnowledge(record, freshness) {
   return {
@@ -846,7 +856,10 @@ function revisionKnowledge(record, freshness) {
 }
 function decisionKnowledge(record, freshness = "unknown", proposalFreshness = "unknown") {
   const effective = effectiveDecision(record);
-  const inspection = latestDecisionInspection(record);
+  const inspection = latestDecisionInspection(
+    record,
+    decisionApproval(effective) === "accepted" ? "operative" : "all"
+  );
   return {
     ...revisionKnowledge(effective, freshness),
     ...inspection ? {
@@ -856,10 +869,16 @@ function decisionKnowledge(record, freshness = "unknown", proposalFreshness = "u
         inspector: inspection.inspector,
         note: inspection.note,
         outcome: inspection.outcome,
+        scope: inspection.scope ?? "all",
         headHash: inspection.headHash
       }
     } : {},
-    ...effective !== record ? { pendingProposal: revisionKnowledge(record, proposalFreshness) } : {}
+    ...effective !== record ? {
+      pendingProposal: {
+        ...revisionKnowledge(record, proposalFreshness),
+        assessment: latestDecisionInspection(record) ? "no_contradiction_found" : "not_assessed"
+      }
+    } : {}
   };
 }
 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 prepare evidence and record a separate source inspection without human approval, or an authorized human review; identities and sources are recorded assertions, not authenticated proof.";
@@ -944,11 +963,11 @@ async function loadDecisionStore(rootDir) {
 import { createHash as createHash4 } from "crypto";
 
 // src/decisions/drift.ts
-import path10 from "path";
+import path8 from "path";
 
 // src/drift/drift.ts
 import fs6 from "fs/promises";
-import path9 from "path";
+import path7 from "path";
 function parseChanges(output) {
   const fields = output.split("\0");
   const changes = [];
@@ -1009,7 +1028,7 @@ async function getWorkingTree(resolvedRoot) {
 
 // src/decisions/drift.ts
 async function computeDecisionDrift(rootDir, decisions) {
-  const resolvedRoot = path10.resolve(rootDir);
+  const resolvedRoot = path8.resolve(rootDir);
   const store = decisions ? { records: decisions, diagnostics: [] } : await loadDecisionStore(resolvedRoot);
   const report = {
     historyAvailable: true,
@@ -1024,11 +1043,15 @@ async function computeDecisionDrift(rootDir, decisions) {
   ]);
   const changesByHash = /* @__PURE__ */ new Map();
   const baselines = store.records.filter((record) => record.status === "active").flatMap((record) => {
-    const inspection = latestDecisionInspection(record);
-    if (inspection) return [inspection.capture];
-    return [.../* @__PURE__ */ new Set([effectiveDecision(record), record])].flatMap(
-      (candidate) => candidate.version === 2 && candidate.capture ? [candidate.capture] : []
-    );
+    const effective = effectiveDecision(record);
+    return [.../* @__PURE__ */ new Set([effective, record])].flatMap((candidate) => {
+      const inspection = latestDecisionInspection(
+        record,
+        candidate === effective && decisionApproval(effective) === "accepted" ? "operative" : "all"
+      );
+      const capture = inspection?.capture ?? (candidate.version === 2 ? candidate.capture : void 0);
+      return capture ? [capture] : [];
+    });
   });
   const captures = await captureAnchorScopes(
     resolvedRoot,
@@ -1067,12 +1090,18 @@ async function computeDecisionDrift(rootDir, decisions) {
   for (const record of store.records) {
     if (record.status !== "active") continue;
     const effective = effectiveDecision(record);
-    const inspection = latestDecisionInspection(record);
+    const inspection = latestDecisionInspection(
+      record,
+      decisionApproval(effective) === "accepted" ? "operative" : "all"
+    );
     const state = await inspect(effective, inspection?.capture);
     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, inspection?.capture);
+      (report.pendingProposals ??= {})[record.id] = await inspect(
+        record,
+        latestDecisionInspection(record)?.capture
+      );
   }
   return report;
 }
@@ -1100,9 +1129,9 @@ async function exists(p) {
 async function findMasonRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < MAX_WALK_UP; i++) {
-    if (await exists(path11.join(dir, ".mason", "decisions"))) return dir;
-    if (await exists(path11.join(dir, ".git"))) return null;
-    const parent = path11.dirname(dir);
+    if (await exists(path9.join(dir, ".mason", "decisions"))) return dir;
+    if (await exists(path9.join(dir, ".git"))) return null;
+    const parent = path9.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -1170,14 +1199,15 @@ async function runHook(stdinText, env = {}) {
   if (input.tool_name && !SUPPORTED_TOOLS.has(input.tool_name)) return null;
   const filePath = input.tool_input?.file_path;
   if (!filePath || typeof filePath !== "string") return null;
-  const absPath = path11.isAbsolute(filePath) ? filePath : path11.resolve(input.cwd ?? process.cwd(), filePath);
-  const root = await findMasonRoot(path11.dirname(absPath));
+  const absPath = path9.isAbsolute(filePath) ? filePath : path9.resolve(input.cwd ?? process.cwd(), filePath);
+  const root = await findMasonRoot(path9.dirname(absPath));
   if (!root) return null;
-  const relPath = path11.relative(root, absPath).split(path11.sep).join("/");
+  if (env.rootDir && await fs7.realpath(root) !== await fs7.realpath(env.rootDir)) return null;
+  const relPath = path9.relative(root, absPath).split(path9.sep).join("/");
   if (relPath.startsWith("..")) return null;
   const { records } = await loadDecisionStore(root);
   const stateDir = env.stateDir ?? os2.tmpdir();
-  const stateFile = path11.join(
+  const stateFile = path9.join(
     stateDir,
     `mason-hook-${createHash4("sha256").update(root).digest("hex").slice(0, 12)}-${stateKey(input)}.json`
   );
@@ -1204,7 +1234,7 @@ async function runHook(stdinText, env = {}) {
   }
   return JSON.stringify({
     hookSpecificOutput: {
-      hookEventName: "PostToolUse",
+      hookEventName: env.hookEventName ?? "PostToolUse",
       additionalContext: formatContext(relPath, selected, drift)
     }
   });