mason-context 0.22.0 → 0.23.1

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+## 0.23.1 — 2026-10-21
+
+- Wait up to 60 seconds for the transparency log when signing the standalone update manifest. With the 5-second default, a slow log write timed out after succeeding and the retry failed with `409 entry already exists`, so the 0.23.0 release produced no GitHub release downloads.
+- Stop publishing to Smithery on release: Smithery now rejects server updates (`403 Updating servers has been removed`). Releases continue to npm, the official MCP Registry and GitHub release downloads; the existing Smithery listing is no longer updated.
+
+## 0.23.0 — 2026-10-21
+
+- `save_decision` guidance asks for the constrained functions, types, or settings to be named in backticks, so drift notices can judge relevance. Anchors remain whole files or directories, and anchored changes still require inspection; symbol anchors and automatic clearing of trivial drift were considered and not adopted.
+- Attribute decision drift on a branch to the branch or to the default branch it builds on. Previously a rebase made every decision the default branch had changed look like this checkout's unchecked work. Drift in anchors this branch touched is reported as before; drift that arrived only from the default branch is listed once per session, never blocks Stop, and is reported as usual on the default branch. `review_decision(prepare)` reports the same split in `previews.attribution`. Explicit audits still report all drift.
+- `review_decision(action: "prepare")` previews source, diff and anchor commits since the latest inspection still valid for the record and scope, instead of since the original evidence baseline, and reports the commit used in `previews.diffSince`. Earlier changes were already inspected, so long-lived records no longer return months of truncated history. Pass `diffFrom: "capture"` for the full history. Responses include the latest two inspections and count older ones; the record file keeps them all. Review evidence, tokens and verdict requirements are unchanged.
+- Stop failed, denied and interrupted tool calls from filling the automation store. Previously every new session failed once 128 sessions held unfinished calls, or once `state.json` passed 10 MiB, until the file was edited by hand. Claude configurations now register `PostToolUseFailure`; run `mason init --host claude` to add it, as older configurations stay compatible without it. Pending captures are dropped when the turn ends or after 24 idle hours. Sessions are evicted least recently used even with unfinished calls. `state.json` is written compactly and shrunk instead of failing when oversized, including files left by earlier versions. `mason status --json` reports unfinished tool calls, and an attempt still in flight no longer makes status `unavailable`.
+- Show the changed lines in decision drift notices, including the Claude Stop review, so most irrelevant edits can be dismissed without another tool call. Hunks are diffed against the exact captured content of the last inspection or save. Each notice reports code identifiers named by the decision (backticked names, calls, camelCase or snake_case) that the changed lines or their enclosing declarations mention, or `Low relevance` when none are; decisions naming no identifiers are not assessed. Relevance is a name match only: findings, inspection requirements and Stop blocking are unchanged.
+- Merge decision records automatically when branches each append inspections or review history, instead of conflicting inside the JSON on every rebase of a stacked branch. `mason init` adds a `.gitattributes` entry for `.mason/decisions/*.json`; `mason setup` configures the local `mason-decision` Git merge driver, and `mason status` reports a committed attribute without it. Two different changes to the same field still conflict, and Git's ordinary text conflict is used whenever Mason refuses a merge or is not on PATH. Run `mason init --host <host>` to add the attribute, commit `.gitattributes`, then run `mason setup` in each checkout.
+- Leave Git-ignored files beneath a directory anchor out of its capture instead of marking the capture incomplete, so local setup files no longer block `review_decision` inspection or make the anchor's freshness unknown. Anchors naming only ignored content still stay unknown. An incomplete capture now leaves only its own decision's earlier drift findings unverified instead of every decision's.
+
 ## 0.22.0 — 2026-10-12
 
 - Separate CLI scopes: `mason init` prepares shared repository integration without activating it; `mason setup` activates compatible existing configuration using local state only. `mason teardown` now disconnects locally; use `--project` explicitly for shared removal. Initialization and teardown support read-only `--dry-run` previews. Compatible older instructions, supported legacy hooks and JSON formatting do not force shared rewrites; status reports optional template updates separately. MCP exposes matching `init`/`setup` modes. Setup no longer triggers background update checks. Migrate scripts that used setup to generate configuration to `mason init` followed by `mason setup`; scripts removing shared configuration must add `teardown --project`.

package/dist/mason-audit.js

@@ -405,11 +405,12 @@ async function storePath(root, relative, createParents = false) {
   }
   return current;
 }
-async function readStoreJson(root, relative) {
+async function readStoreJson(root, relative, maxBytes = STORE_MAX_BYTES) {
   try {
     const file = await storePath(root, relative);
-    const raw = await readBoundedFile(file, 10 * 1024 * 1024);
-    if (raw === null) throw new Error("file is not regular or exceeds 10 MiB");
+    const raw = await readBoundedFile(file, maxBytes);
+    if (raw === null)
+      throw new Error(`file is not regular or exceeds ${maxBytes / 1024 / 1024} MiB`);
     const parsed = JSON.parse(raw);
     if (parsed === null) throw new Error("expected a JSON object, received null");
     return parsed;
@@ -421,9 +422,9 @@ async function readStoreJson(root, relative) {
     );
   }
 }
-async function writeStoreJson(root, relative, value) {
-  const payload = JSON.stringify(value, null, 2) + "\n";
-  if (Buffer.byteLength(payload) > 10 * 1024 * 1024) {
+async function writeStoreJson(root, relative, value, options = {}) {
+  const payload = JSON.stringify(value, null, options.compact ? void 0 : 2) + "\n";
+  if (Buffer.byteLength(payload) > STORE_MAX_BYTES) {
     throw new Error(`Mason store ${relative} exceeds 10 MiB`);
   }
   const file = await storePath(root, relative, true);
@@ -441,11 +442,13 @@ async function writeStoreJson(root, relative, value) {
     await fs2.rm(temporary, { force: true });
   }
 }
+var STORE_MAX_BYTES;
 var init_storage = __esm({
   "src/utils/storage.ts"() {
     "use strict";
     init_paths();
     init_files();
+    STORE_MAX_BYTES = 10 * 1024 * 1024;
   }
 });
 
@@ -2458,7 +2461,12 @@ async function captureAnchorScopes(root, scopes2) {
     );
     const inventory = access.inventory();
     if (!inventory) throw new Error("Git anchor inventory unavailable");
-    const ignored = await inspectionGit(
+    const visible = indexMatchingPaths(
+      union.map((anchor) => [anchor]),
+      inventory
+    );
+    const hidden = new Set(union.filter((_, index) => !visible[index].length));
+    const ignored = hidden.size ? (await inspectionGit(
       [
         "ls-files",
         "-z",
@@ -2466,13 +2474,11 @@ async function captureAnchorScopes(root, scopes2) {
         "--ignored",
         "--exclude-standard",
         "--",
-        ...union.map((anchor) => `:(literal)${anchor}`)
+        ...[...hidden].map((anchor) => `:(literal)${anchor}`)
       ],
       { cwd: root, maxBuffer: 8 * 1024 * 1024 }
-    );
-    const files = [
-      .../* @__PURE__ */ new Set([...inventory, ...ignored.stdout.split("\0").filter(Boolean)])
-    ].sort();
+    )).stdout.split("\0").filter(Boolean) : [];
+    const files = [.../* @__PURE__ */ new Set([...inventory, ...ignored])].sort();
     const patterns = await Promise.all(
       union.map(async (anchor) => {
         const literal2 = fg7.escapePath(anchor);
@@ -2488,7 +2494,7 @@ async function captureAnchorScopes(root, scopes2) {
     const filesByScope = new Map(
       scopes2.map((scope, index) => [JSON.stringify([...new Set(scope)].sort()), indexed[index]])
     );
-    return { filesByScope, eligible };
+    return { filesByScope, eligible, hidden, ignored: new Set(ignored) };
   };
   return Promise.all(
     scopes2.map((scope) => {
@@ -2500,8 +2506,10 @@ async function captureAnchorScopes(root, scopes2) {
           const capture = { anchors, files: {}, complete: true };
           if (!anchors.length) return capture;
           try {
-            const { eligible, filesByScope } = await (context ??= prepareContext());
-            const files = filesByScope.get(JSON.stringify(anchors));
+            const { eligible, filesByScope, hidden, ignored } = await (context ??= prepareContext());
+            const files = filesByScope.get(JSON.stringify(anchors)).filter(
+              (file) => !ignored.has(file) || anchors.some((anchor) => hidden.has(anchor) && anchorMatches(anchor, file))
+            );
             if (files.length > 2e3) return { ...capture, complete: false };
             for (const file of files) {
               const evidence = await inspectionRead(
@@ -2910,6 +2918,35 @@ var init_decisions = __esm({
   }
 });
 
+// src/decisions/excerpts.ts
+import { createHash as createHash4 } from "crypto";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+function driftBaseline(record) {
+  const effective = effectiveDecision(record);
+  const inspection = latestDecisionInspection(
+    record,
+    decisionApproval(effective) === "accepted" ? "operative" : "all"
+  );
+  return {
+    record: effective,
+    capture: inspection?.capture ?? (effective.version === 2 ? effective.capture : void 0),
+    commits: [inspection?.headHash, effective.refreshedHash].filter(
+      (hash) => !!hash && /^[a-f0-9]{40,64}$/.test(hash)
+    )
+  };
+}
+var exec;
+var init_excerpts = __esm({
+  "src/decisions/excerpts.ts"() {
+    "use strict";
+    init_files();
+    init_paths();
+    init_provenance();
+    exec = promisify2(execFile2);
+  }
+});
+
 // src/decisions/drift.ts
 import path17 from "path";
 async function computeDecisionDrift(rootDir, decisions) {
@@ -2974,15 +3011,11 @@ async function computeDecisionDrift(rootDir, decisions) {
   };
   for (const record of store.records) {
     if (record.status !== "active") continue;
-    const effective = effectiveDecision(record);
-    const inspection = latestDecisionInspection(
-      record,
-      decisionApproval(effective) === "accepted" ? "operative" : "all"
-    );
-    const state = await inspect(effective, inspection?.capture);
+    const baseline = driftBaseline(record);
+    const state = await inspect(baseline.record, baseline.capture);
     report.freshness[record.id] = state.freshness;
     if (state.changedFiles.length) report.staleDecisions[record.id] = state.changedFiles;
-    if (effective !== record)
+    if (baseline.record !== record)
       (report.pendingProposals ??= {})[record.id] = await inspect(
         record,
         latestDecisionInspection(record)?.capture
@@ -2998,13 +3031,14 @@ var init_drift2 = __esm({
     init_paths();
     init_snapshot();
     init_decisions();
+    init_excerpts();
     init_provenance();
   }
 });
 
 // src/audit/checks/decision-anchor.ts
 async function checkDecisionAnchors(ctx) {
-  const result = emptyResult();
+  const result = { ...emptyResult(), incompleteDecisions: [] };
   if (!ctx.decisionsPresent) return result;
   const store = await loadDecisionStore(ctx.root);
   const records = store.records;
@@ -3036,6 +3070,7 @@ async function checkDecisionAnchors(ctx) {
         check: "decision-anchor-drift",
         reason: `Anchor evidence for decision ${record.id} is incomplete or unreadable`
       });
+      result.incompleteDecisions.push(record.id);
       continue;
     }
     if (!changedFiles.length) continue;
@@ -3097,7 +3132,7 @@ var init_checks = __esm({
 });
 
 // src/audit/findings.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { z as z6 } from "zod";
 function findingId(finding) {
   const e = finding.evidence;
@@ -3128,7 +3163,7 @@ var digest, checkSchema, commitSchema, anchorSchema, count, scopeSchema, evidenc
 var init_findings = __esm({
   "src/audit/findings.ts"() {
     "use strict";
-    digest = (value) => createHash4("sha256").update(JSON.stringify(value)).digest("hex");
+    digest = (value) => createHash5("sha256").update(JSON.stringify(value)).digest("hex");
     checkSchema = z6.enum([
       "deleted-reference",
       "new-module",
@@ -3235,6 +3270,13 @@ var init_findings = __esm({
   }
 });
 
+// src/automation/pending-tools.ts
+var init_pending_tools = __esm({
+  "src/automation/pending-tools.ts"() {
+    "use strict";
+  }
+});
+
 // src/automation/stop-review.ts
 import { z as z7 } from "zod";
 var evidenceSchema2, stopReviewSchema;
@@ -3243,6 +3285,7 @@ var init_stop_review = __esm({
     "use strict";
     init_anchors();
     init_findings();
+    init_pending_tools();
     evidenceSchema2 = z7.record(z7.object({ digest: z7.string(), capture: anchorCaptureSchema }));
     stopReviewSchema = z7.object({
       pending: z7.record(z7.object({ head: z7.string(), evidence: evidenceSchema2 })),
@@ -3279,13 +3322,14 @@ import { z as z9 } from "zod";
 function withLock(root, directory, run, waitMs = 5e3) {
   return withStoreLock(root, directory, run, waitMs, "Automation");
 }
-var hostSchema, stateSchema;
+var hostSchema, stateSchema, IDLE_PENDING_MS, STATE_READ_MAX_BYTES;
 var init_store = __esm({
   "src/automation/store.ts"() {
     "use strict";
     init_store_lock();
     init_stop_review();
     init_notifications();
+    init_storage();
     hostSchema = z9.enum(["claude", "codex"]);
     stateSchema = z9.object({
       version: z9.literal(1),
@@ -3300,6 +3344,8 @@ var init_store = __esm({
           host: hostSchema,
           lastUsed: z9.string(),
           notifiedDiagnostics: z9.array(z9.string()).default([]),
+          /** Digest of the upstream drift notice already shown to this session. */
+          upstreamNotice: z9.string().optional(),
           pending: z9.record(z9.string()),
           stopReview: stopReviewSchema.optional(),
           coverageGaps: z9.array(z9.string()),
@@ -3314,6 +3360,8 @@ var init_store = __esm({
       agentNotifications: notificationStateSchema.optional(),
       analysis: z9.object({ id: z9.string(), fingerprint: z9.string(), completedAt: z9.number(), path: z9.string() }).optional()
     });
+    IDLE_PENDING_MS = 24 * 60 * 60 * 1e3;
+    STATE_READ_MAX_BYTES = 64 * 1024 * 1024;
   }
 });