@ultimat3/manifest 19.2.0 → 19.3.1

package/CLAUDE.md

@@ -113,6 +113,15 @@ by the CLI, not imported.
   route's `surface`/`offline`/`hydrate`, and a query's `cacheTags` — and every one of them
   reported exactly `[{ kind: 'internal', path: 'buildId' }]` with `hasBreaking: false`. A new
   SECTION needs its own file beside the others; a new FIELD joins the file its section owns.
+- **`ActionFact.mutator` is classified, and LOSING it is breaking** (`As of 2026-09`). It was
+  written by `sources.ts` and read by no `diff-*.ts` rule — two manifests differing only in an
+  action that stopped being a mutator answered `[{ kind: 'internal', path: 'buildId' }]`, the exact
+  failure the rule above exists for. A mutator is a client-contract CAPABILITY (it decides the HTTP
+  method and the idempotency the typed client and OpenAPI publish), so losing it refuses callers
+  written against it and gaining it refuses nobody. Folded with `=== true` rather than compared
+  through `diffScalar`: `sources.ts` writes the field only when true, so absence IS `false` here,
+  and an older manifest can therefore only under-report a mutator as newly GAINED, which is
+  additive. `mcp.description` joins it as `internal` — visible in the file, in no contract.
 - **The axis is what a change refuses, not how it reads.** Something that rejects input that was
   valid yesterday is breaking (an invariant added, a NOT NULL, a gained permission, a gained
   enforcement site, a lowered `retry.attempts`); something that accepts more is additive and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/manifest",
-  "version": "19.2.0",
+  "version": "19.3.1",
   "description": "x.manifest.json: deterministic generated facts, contract diff, AGENTS.md budget",
   "license": "MIT",
   "type": "module",
@@ -31,10 +31,10 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ultimat3/action": "19.2.0",
-    "@ultimat3/core": "19.2.0",
-    "@ultimat3/entity": "19.2.0",
-    "@ultimat3/jobs": "19.2.0",
-    "@ultimat3/query": "19.2.0"
+    "@ultimat3/action": "19.3.1",
+    "@ultimat3/core": "19.3.1",
+    "@ultimat3/entity": "19.3.1",
+    "@ultimat3/jobs": "19.3.1",
+    "@ultimat3/query": "19.3.1"
   }
 }

package/src/diff-operations.ts

@@ -2,7 +2,7 @@
 
 import { canonicalJson, isMcpExposed } from '@ultimat3/core';
 import type { ManifestChange } from './diff-change';
-import { index } from './diff-change';
+import { diffScalar, index } from './diff-change';
 import { diffRateLimit } from './diff-rate-limit';
 import type { ActionFact, QueryFact } from './schema';
 
@@ -49,6 +49,35 @@ export function diffActions(
         detail: `mcp exposure ${String(exposed)} -> ${String(nextExposed)}`,
       });
     }
+    // `?.`, because `before` is a file parsed off DISK: a hand-trimmed or older manifest can carry
+    // no `mcp` block at all, and a description is not worth a throw out of the differ.
+    changes.push(
+      ...diffScalar(
+        'internal',
+        `${path}.mcp.description`,
+        action.mcp?.description,
+        next.mcp?.description,
+        () => 'description changed',
+      ),
+    );
+    // Written only when TRUE (`sources.ts`), so absence IS `false` here — a fold, the way
+    // `isMcpExposed` folds `expose`, and deliberately not `diffScalar`'s "absence is no evidence":
+    // the value this field is absent FOR is the value it means. A manifest written before the
+    // field existed can therefore only under-report a mutator as newly gained, which is additive
+    // and not a wall of false breakings.
+    //
+    // The direction is the decision: a mutator is a client-contract CAPABILITY, not a label — it
+    // decides the HTTP method and the idempotency the typed client and the OpenAPI document
+    // publish — so an action that stops being one refuses callers written against it.
+    const mutator = action.mutator === true;
+    const nextMutator = next.mutator === true;
+    if (mutator !== nextMutator) {
+      changes.push({
+        kind: nextMutator ? 'additive' : 'breaking',
+        path: `${path}.mutator`,
+        detail: `mutator ${String(mutator)} -> ${String(nextMutator)}`,
+      });
+    }
     changes.push(...diffPermissions(path, action, next));
     changes.push(...diffRateLimit(path, action, next));
     if (canonicalJson(action.cacheInvalidates) !== canonicalJson(next.cacheInvalidates)) {