mandrel 2.62.0 → 2.63.0

package/.agents/scripts/lib/baselines/merge-envelopes.js

@@ -1,11 +1,10 @@
 /**
  * Pure 3-way merge of baseline envelopes by row identity. A line-based git
- * merge either conflicts on disjoint work (the `generatedAt` line) or splices
- * both sides into a row set no scorer produced.
+ * merge conflicts on disjoint rows that sit adjacent in sort order, and can
+ * splice both sides into a row set no scorer produced.
  *
  * Per identity the side that differs from base wins; both differing is a
- * conflict; absence is a value. The rollup is always recomputed from the
- * merged rows, never merged. Identity comes from the kind's `rowIdentity`,
+ * conflict; absence is a value. Identity comes from the kind's `rowIdentity`,
  * never `keyField`. No I/O: the driver validates the result.
  *
  * @module lib/baselines/merge-envelopes
@@ -15,8 +14,8 @@ import { deepEqual } from '../json-utils.js';
 import { KNOWN_KINDS } from './envelope.js';
 import { getKindModule } from './kernel.js';
 
-/** Keys not merged 3-way: rows by identity, rollup derived, stamp = later. */
-const DERIVED_KEYS = Object.freeze(['rows', 'rollup', 'generatedAt']);
+/** Merged by identity, not as a stamp. */
+const ROW_KEY = 'rows';
 
 /**
  * Kind from `$schema`, or `null` for anything not a known per-kind envelope.
@@ -76,20 +75,6 @@ function indexRows(rows, rowIdentity, side) {
   return out;
 }
 
-/**
- * @param {string|undefined} ours
- * @param {string|undefined} theirs
- * @returns {string|undefined}
- */
-function laterStamp(ours, theirs) {
-  if (typeof ours !== 'string') return theirs;
-  if (typeof theirs !== 'string') return ours;
-  const a = Date.parse(ours);
-  const b = Date.parse(theirs);
-  if (Number.isNaN(a) || Number.isNaN(b)) return ours > theirs ? ours : theirs;
-  return a >= b ? ours : theirs;
-}
-
 /**
  * 3-way merge of envelope stamps; a double bump to different values is a
  * real conflict (two scorers).
@@ -102,7 +87,7 @@ function laterStamp(ours, theirs) {
 function mergeStamps(base, ours, theirs) {
   const keys = new Set(
     [...Object.keys(ours), ...Object.keys(theirs), ...Object.keys(base)].filter(
-      (k) => !DERIVED_KEYS.includes(k),
+      (k) => k !== ROW_KEY,
     ),
   );
   const merged = {};
@@ -170,15 +155,13 @@ function mergeRowSets({ baseEnv, ours, theirs, rowIdentity }) {
 }
 
 /**
- * `base` is `null` when the file was added on both sides. `components`
- * defaults to `[]`, matching what a refresh writes.
+ * `base` is `null` when the file was added on both sides.
  *
  * @param {{
  *   base: object|null,
  *   ours: object,
  *   theirs: object,
  *   kind?: string,
- *   components?: Array<object>,
  * }} params
  * @returns {{
  *   kind: string,
@@ -186,13 +169,7 @@ function mergeRowSets({ baseEnv, ours, theirs, rowIdentity }) {
  *   conflicts: Array<{scope: string, identity: string, base?: unknown, ours?: unknown, theirs?: unknown}>,
  * }}
  */
-export function mergeEnvelopes({
-  base,
-  ours,
-  theirs,
-  kind,
-  components = [],
-} = {}) {
+export function mergeEnvelopes({ base, ours, theirs, kind } = {}) {
   const resolvedKind =
     kind ?? kindFromEnvelope(ours) ?? kindFromEnvelope(theirs);
   if (!resolvedKind) {
@@ -217,12 +194,7 @@ export function mergeEnvelopes({
     theirs ?? {},
   );
 
-  const envelope = {
-    ...stamps,
-    generatedAt: laterStamp(ours?.generatedAt, theirs?.generatedAt),
-    rollup: mod.rollup(sortedRows, components),
-    rows: sortedRows,
-  };
+  const envelope = { ...stamps, rows: sortedRows };
 
   return {
     kind: resolvedKind,
@@ -251,41 +223,15 @@ function orderKeys(obj, order) {
 }
 
 /**
- * Same arithmetic as `buildCyclomaticEnvelope`. Must be derived: two branches
- * each adding a row both write `n + 1`, which a 3-way merge resolves cleanly
- * and wrongly.
- *
- * @param {Array<object>} rows
- * @returns {{ '*': { filesAboveCeiling: number, methodsAboveCeiling: number, maxCyclomatic: number } }}
- */
-function cyclomaticRollup(rows) {
-  let methods = 0;
-  let max = 0;
-  for (const row of rows) {
-    methods += Number(row?.methodsAboveCeiling ?? 0);
-    const rowMax = Number(row?.maxCyclomatic ?? 0);
-    if (rowMax > max) max = rowMax;
-  }
-  return {
-    '*': {
-      filesAboveCeiling: rows.length,
-      methodsAboveCeiling: methods,
-      maxCyclomatic: max,
-    },
-  };
-}
-
-/**
- * Row-set baselines that are not per-kind envelopes. `rollup: null` is real:
- * the dead-export generator writes none. `keyOrder` mirrors each generator.
+ * Row-set baselines that are not per-kind envelopes. `keyOrder` mirrors each
+ * generator.
  */
 const PLAIN_BASELINE_KINDS = Object.freeze({
   cyclomatic: Object.freeze({
     rowIdentity: (row) => String(row?.file ?? ''),
     sortRows: (rows) =>
       [...rows].sort((a, b) => String(a.file).localeCompare(String(b.file))),
-    rollup: cyclomaticRollup,
-    keyOrder: ['$schema', 'generatedAt', 'ceiling', 'rollup', 'rows'],
+    keyOrder: ['$schema', 'ceiling', 'rows'],
   }),
   'dead-exports': Object.freeze({
     rowIdentity: (row) => `${row?.file ?? ''}::${row?.symbol ?? ''}`,
@@ -295,8 +241,7 @@ const PLAIN_BASELINE_KINDS = Object.freeze({
           String(a.file).localeCompare(String(b.file)) ||
           String(a.symbol).localeCompare(String(b.symbol)),
       ),
-    rollup: null,
-    keyOrder: ['$schema', 'kernelVersion', 'generatedAt', 'mode', 'rows'],
+    keyOrder: ['$schema', 'kernelVersion', 'mode', 'rows'],
   }),
 });
 
@@ -357,15 +302,7 @@ export function mergePlainBaseline({ base, ours, theirs, kind } = {}) {
     ours ?? {},
     theirs ?? {},
   );
-  const envelope = orderKeys(
-    {
-      ...stamps,
-      generatedAt: laterStamp(ours?.generatedAt, theirs?.generatedAt),
-      ...(spec.rollup ? { rollup: spec.rollup(sortedRows) } : {}),
-      rows: sortedRows,
-    },
-    spec.keyOrder,
-  );
+  const envelope = orderKeys({ ...stamps, rows: sortedRows }, spec.keyOrder);
   return {
     kind: resolvedKind,
     envelope,
@@ -380,8 +317,8 @@ const REGENERATE_COMMANDS = Object.freeze({
 });
 
 /**
- * After a conflicted merge, hand-resolving rows never updates the rollup, so
- * the driver must name the regeneration command.
+ * After a conflicted merge, hand-resolved rows describe a tree nobody scored,
+ * so the driver must name the regeneration command.
  *
  * @param {string} kind
  * @returns {string}

package/.agents/scripts/lib/baselines/reader.js

@@ -130,21 +130,21 @@ function validate(kind, parsed, sourceHint) {
 /**
  * The one narrowing projection for every loaded envelope. It is an
  * allow-list: compat axes read stamps off the loaded object and fail closed
- * on `undefined`, so every envelope stamp must be carried through here.
+ * on `undefined`, so every envelope stamp must be carried through here. The
+ * committed file carries no rollup; a consumer that needs one derives it from
+ * `rows` through the kind module.
  *
  * @param {string} kind
  * @param {object} parsed A validated baseline envelope.
- * @returns {{ rollup: object, rows: Array<object>, kernelVersion: string, generatedAt: string }}
+ * @returns {{ rows: Array<object>, kernelVersion: string }}
  */
 function shapeEnvelope(kind, parsed) {
   const rows = Array.isArray(parsed.rows)
     ? parsed.rows.map((row) => canonicaliseRow(kind, row))
     : [];
   return {
-    rollup: parsed.rollup ?? { '*': {} },
     rows,
     kernelVersion: parsed.kernelVersion,
-    generatedAt: parsed.generatedAt,
     scoringSemantics: parsed.scoringSemantics,
     tsTranspilerVersion: parsed.tsTranspilerVersion,
     provenanceStamped: parsed.provenanceStamped,
@@ -154,7 +154,7 @@ function shapeEnvelope(kind, parsed) {
 /**
  * @param {string} kind
  * @param {string} absolutePath
- * @returns {{ rollup: object, rows: Array<object>, kernelVersion: string, generatedAt: string }}
+ * @returns {{ rows: Array<object>, kernelVersion: string }}
  */
 function readAndShape(kind, absolutePath) {
   let raw;
@@ -195,7 +195,7 @@ function inferKindFromSchema(schemaValue) {
 /**
  * @param {string} kind
  * @param {{ configPath?: string, cwd?: string }} [opts]
- * @returns {{ rollup: object, rows: Array<object>, kernelVersion: string, generatedAt: string }}
+ * @returns {{ rows: Array<object>, kernelVersion: string }}
  */
 export function load(kind, opts = {}) {
   if (!Object.hasOwn(KIND_TO_SCHEMA_FILE, kind)) {
@@ -214,7 +214,7 @@ export function load(kind, opts = {}) {
  *
  * @param {string} absolutePath
  * @param {{ kind?: string }} [opts]
- * @returns {{ rollup: object, rows: Array<object>, kernelVersion: string, generatedAt: string }}
+ * @returns {{ rows: Array<object>, kernelVersion: string }}
  */
 export function loadFile(absolutePath, opts = {}) {
   if (typeof absolutePath !== 'string' || absolutePath.length === 0) {

package/.agents/scripts/lib/baselines/refresh-service.js

@@ -260,7 +260,6 @@ export function resolveDefaultScorer(kind, { cwd } = {}) {
  *   fs?: typeof nodeFs,
  *   gitDiff?: (args: { baseRef: string, headRef: string, cwd: string }) => Iterable<string> | Promise<Iterable<string>>,
  *   cwd?: string,
- *   generatedAt?: string,
  *   requireRowsForScopeFiles?: boolean,
  *   requiredScopeFilePredicate?: (file: string) => boolean,
  * }} opts
@@ -285,7 +284,6 @@ export async function refreshBaseline(opts = {}) {
     fs = nodeFs,
     gitDiff = defaultGitDiff,
     cwd = process.cwd(),
-    generatedAt,
     requireRowsForScopeFiles = false,
     requiredScopeFilePredicate,
   } = opts;
@@ -349,11 +347,10 @@ export async function refreshBaseline(opts = {}) {
       scope.mode === 'full'
         ? null
         : { mode: 'diff', files: new Set(scope.files) },
-    generatedAt: generatedAt ?? process.env.MANDREL_BASELINE_GENERATED_AT,
   });
 
   // The writer returns the prior object itself when nothing changed; skip the
-  // write so on-disk bytes (including `generatedAt`) stay verbatim.
+  // write so on-disk bytes stay verbatim.
   let wrote = false;
   if (priorEnvelope === null || envelope !== priorEnvelope) {
     writeEnvelopeFile(writePath, envelope, { fsImpl: fs });
@@ -523,9 +520,7 @@ function readPriorEnvelope(writePath, fs) {
       parsed &&
       typeof parsed === 'object' &&
       !Array.isArray(parsed) &&
-      Array.isArray(parsed.rows) &&
-      parsed.rollup &&
-      typeof parsed.rollup === 'object'
+      Array.isArray(parsed.rows)
     ) {
       return parsed;
     }

package/.agents/scripts/lib/baselines/writer.js

@@ -1,7 +1,6 @@
 /**
  * Shared baseline writer, the single funnel for envelope assembly
- * (`write`: project, canonical-assert, merge, stabilise, sort, rollup, stamp,
- * validate) and serialisation (`writeFile`: atomic tmp + rename).
+ * (`write`: project, canonical-assert, merge, stabilise, sort, stamp, validate) and serialisation (`writeFile`: atomic tmp + rename).
  *
  * @module lib/baselines/writer
  */
@@ -16,16 +15,14 @@ import { assertCanonical } from './path-canon.js';
 /**
  * Assemble and validate an envelope (no I/O). With `scope`, out-of-scope
  * `prior` rows are preserved first; with `epsilon`, sub-epsilon deltas then
- * resolve to prior bytes. `prior` rows must already be canonical. When rows
- * and rollup deep-equal the prior envelope, the prior is returned unchanged
- * so a no-op refresh leaves no `generatedAt` diff.
+ * resolve to prior bytes. `prior` rows must already be canonical. When the
+ * rows deep-equal the prior envelope's, the prior is returned unchanged so a
+ * no-op refresh leaves no diff.
  *
  * @param {{
  *   kind: string,
  *   rows: Array<object>,
- *   components?: Array<object>,
  *   kernelVersion?: string,
- *   generatedAt?: string,
  *   prior?: Array<object>,
  *   priorEnvelope?: object,
  *   epsilon?: number,
@@ -36,9 +33,7 @@ import { assertCanonical } from './path-canon.js';
 export function write({
   kind,
   rows,
-  components,
   kernelVersion,
-  generatedAt,
   prior,
   priorEnvelope,
   epsilon,
@@ -79,20 +74,9 @@ export function write({
   const stabilised = stabiliseRows(mod, merged, prior, epsilon);
 
   const sortedRows = mod.sortRows(stabilised);
-  const rollup = mod.rollup(sortedRows, components ?? []);
-
-  if (!Object.hasOwn(rollup, '*')) {
-    throw new Error(
-      `writer.write: ${kind} rollup is missing the required "*" key`,
-    );
-  }
 
   const priorEnv = resolvePriorEnvelope(priorEnvelope, prior);
-  if (
-    priorEnv &&
-    deepEqual(sortedRows, priorEnv.rows) &&
-    deepEqual(rollup, priorEnv.rollup)
-  ) {
+  if (priorEnv && deepEqual(sortedRows, priorEnv.rows)) {
     // No smuggling an invalid envelope through the short-circuit.
     assertEnvelope(priorEnv);
     return priorEnv;
@@ -101,9 +85,7 @@ export function write({
   const envelope = buildEnvelope({
     kind,
     rows: sortedRows,
-    rollup,
     kernelVersion: kernelVersion ?? currentKernelVersion(kind),
-    generatedAt,
     extras:
       typeof mod.envelopeExtras === 'function' ? mod.envelopeExtras() : null,
   });
@@ -113,29 +95,20 @@ export function write({
 
 /** `priorEnvelope`, else `prior` when it is a whole envelope, else null. */
 function resolvePriorEnvelope(priorEnvelope, prior) {
-  if (
-    priorEnvelope &&
-    typeof priorEnvelope === 'object' &&
-    !Array.isArray(priorEnvelope) &&
-    Array.isArray(priorEnvelope.rows) &&
-    priorEnvelope.rollup &&
-    typeof priorEnvelope.rollup === 'object'
-  ) {
-    return priorEnvelope;
-  }
-  if (
-    prior &&
-    typeof prior === 'object' &&
-    !Array.isArray(prior) &&
-    Array.isArray(prior.rows) &&
-    prior.rollup &&
-    typeof prior.rollup === 'object'
-  ) {
-    return prior;
-  }
+  if (isEnvelopeObject(priorEnvelope)) return priorEnvelope;
+  if (isEnvelopeObject(prior)) return prior;
   return null;
 }
 
+function isEnvelopeObject(value) {
+  return (
+    Boolean(value) &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    Array.isArray(value.rows)
+  );
+}
+
 /**
  * Serialise deterministically (fixed top-level key order, two-space indent,
  * trailing newline) and atomically (tmp + rename).
@@ -161,11 +134,9 @@ export function writeFile(absPath, envelope, opts = {}) {
   const canonical = {
     $schema: envelope.$schema,
     kernelVersion: envelope.kernelVersion,
-    generatedAt: envelope.generatedAt,
     scoringSemantics: envelope.scoringSemantics,
     tsTranspilerVersion: envelope.tsTranspilerVersion,
     provenanceStamped: envelope.provenanceStamped,
-    rollup: envelope.rollup,
     rows: envelope.rows,
   };
 

package/.agents/scripts/lib/coverage-baseline.js

@@ -156,8 +156,6 @@ function writeEnvelopeViaFsImpl(abs, envelope, fsImpl) {
   const canonical = {
     $schema: envelope.$schema,
     kernelVersion: envelope.kernelVersion,
-    generatedAt: envelope.generatedAt,
-    rollup: envelope.rollup,
     rows: envelope.rows,
   };
   fsImpl.writeFileSync(abs, `${JSON.stringify(canonical, null, 2)}\n`);

package/.agents/scripts/lib/cyclomatic-ceiling.js

@@ -163,29 +163,17 @@ export function diffCyclomaticRows(baselineRows, currentRows) {
 }
 
 /**
- * @param {{ rows: Array<object>, ceiling: number, generatedAt?: string }} args
+ * No stamp and no rollup: both would rewrite on every refresh and conflict
+ * textually wherever the merge driver does not run.
+ *
+ * @param {{ rows: Array<object>, ceiling: number }} args
  * @returns {object}
  */
-export function buildCyclomaticEnvelope({ rows, ceiling, generatedAt }) {
-  const safeRows = rows ?? [];
-  let methods = 0;
-  let max = 0;
-  for (const row of safeRows) {
-    methods += Number(row.methodsAboveCeiling ?? 0);
-    if (Number(row.maxCyclomatic ?? 0) > max) max = Number(row.maxCyclomatic);
-  }
+export function buildCyclomaticEnvelope({ rows, ceiling }) {
   return {
     $schema: CYCLOMATIC_BASELINE_SCHEMA,
-    generatedAt: generatedAt ?? new Date().toISOString(),
     ceiling,
-    rollup: {
-      '*': {
-        filesAboveCeiling: safeRows.length,
-        methodsAboveCeiling: methods,
-        maxCyclomatic: max,
-      },
-    },
-    rows: safeRows,
+    rows: rows ?? [],
   };
 }
 

package/.agents/scripts/lib/git/sync-from-base.js

@@ -38,7 +38,7 @@ function refuseWithoutMergeDriver(cwd, gitSpawn) {
       `.gitattributes routes baselines/*.json through the mandrel-baseline merge ` +
       `driver, but ${BASELINE_MERGE_DRIVER_CONFIG_KEY} is unset in this clone. ` +
       'Merging origin now would text-merge generated baselines, which conflicts on ' +
-      'the generatedAt stamp and can splice rows neither branch scored. Register the ' +
+      'adjacent rows and can splice rows neither branch scored. Register the ' +
       `driver, then re-run:\n  ${BASELINE_MERGE_DRIVER_REMEDY}\n` +
       '  (or: npm run baselines:merge-driver)',
     remedy: BASELINE_MERGE_DRIVER_REMEDY,

package/.agents/scripts/lib/orchestration/check-baselines/phases/evaluate.js

@@ -17,34 +17,28 @@ import { applyFloors, flattenBreaches } from './floors.js';
 import { applyRefreshAcknowledgment } from './refresh-ack.js';
 
 /**
- * Recompute the `*` floor rollup without `ignoreGlobs` rows, in case a
- * baseline was poisoned by some route other than generation (which already
- * drops them); an ignored file could otherwise breach a global floor. A no-op
- * for a correct baseline; compare is untouched.
+ * The floor rollup, derived from the rows (the committed file carries none).
+ * `ignoreGlobs` rows are dropped first in case a baseline was poisoned by some
+ * route other than generation, which already drops them; an ignored file
+ * could otherwise breach a global floor.
  *
- * @param {{ kind: string, baseline: { rollup?: object, rows?: object[] }, ignoreGlobs?: string[], cwd?: string }} args
+ * @param {{ kind: string, baseline: { rows?: object[] }, ignoreGlobs?: string[], cwd?: string }} args
  * @returns {object}
  */
-function rollupExcludingIgnored({ kind, baseline, ignoreGlobs, cwd }) {
-  const rollup = baseline?.rollup;
-  if (!Array.isArray(ignoreGlobs) || ignoreGlobs.length === 0) return rollup;
-  const rows = baseline?.rows;
-  if (!Array.isArray(rows) || rows.length === 0) return rollup;
-  let mod;
-  try {
-    mod = getKindModule(kind);
-  } catch {
-    return rollup;
-  }
-  if (mod?.keyField !== 'path' || typeof mod.rollup !== 'function')
-    return rollup;
-  const kept = rows.filter((row) => {
-    const p = row?.path;
-    return typeof p !== 'string' || !isIgnoredByGlobs(p, ignoreGlobs, cwd);
-  });
-  if (kept.length === rows.length) return rollup;
-  const recomputed = mod.rollup(kept);
-  return { ...rollup, '*': recomputed?.['*'] ?? rollup?.['*'] };
+function floorRollupOf({ kind, baseline, ignoreGlobs, cwd }) {
+  const mod = getKindModule(kind);
+  const rows = Array.isArray(baseline?.rows) ? baseline.rows : [];
+  const filterIgnored =
+    mod.keyField === 'path' &&
+    Array.isArray(ignoreGlobs) &&
+    ignoreGlobs.length > 0;
+  const kept = filterIgnored
+    ? rows.filter((row) => {
+        const p = row?.path;
+        return typeof p !== 'string' || !isIgnoredByGlobs(p, ignoreGlobs, cwd);
+      })
+    : rows;
+  return mod.rollup(kept);
 }
 
 function loadHeadBaseline(kind, cwd, configPath) {
@@ -87,7 +81,6 @@ function buildGateReport({
     baseRef: cmp.baseRef ?? null,
     // Without this a compare arm that never ran looks identical to a clean run.
     baseRead: cmp.baseRead === true,
-    generatedAt: baseline.generatedAt,
     acknowledged: ack.acknowledged,
     // Acknowledgment can be partial; name which regressions it cleared.
     acknowledgedKeys: ack.acknowledgedKeys,
@@ -114,7 +107,7 @@ export async function evaluateKind({
       schemaError: { tag: 'semantics', message: semanticsError },
     };
   }
-  const floorRollup = rollupExcludingIgnored({
+  const floorRollup = floorRollupOf({
     kind,
     baseline,
     ignoreGlobs: gateBlock.ignoreGlobs,

package/.agents/scripts/merge-baseline.js

@@ -3,10 +3,12 @@
 /**
  * merge-baseline.js — git merge driver for `baselines/*.json`.
  *
- * A text merge of a baseline either conflicts on the always-different
- * `generatedAt` stamp or, worse, silently splices both sides' rows into a set
- * no scorer produced. This merges rows by identity and re-derives the rollup.
- * Files that are not a known row baseline go to `git merge-file` unchanged.
+ * A text merge of a baseline conflicts on rows adjacent in sort order or
+ * appended at the tail, and can splice both sides' rows into a set no scorer
+ * produced. This merges rows by identity instead. The committed shape carries
+ * no stamp or rollup, so disjoint non-adjacent refreshes also merge textually
+ * where this driver never runs (GitHub). Files that are not a known row
+ * baseline go to `git merge-file` unchanged.
  *
  *   node .agents/scripts/merge-baseline.js %O %A %B %P
  *
@@ -115,7 +117,7 @@ function delegateToGit(basePath, oursPath, theirsPath) {
 }
 
 /**
- * Envelope kinds (rollup re-derived) or plain row baselines (cyclomatic,
+ * Envelope kinds or plain row baselines (cyclomatic,
  * dead-exports*); anything else resolves `null` and goes back to git.
  *
  * @param {unknown} ours
@@ -269,8 +271,8 @@ function markConflicts({ kind, merged, oursPath, label }) {
 }
 
 /**
- * Names the regenerate command: the rollup was derived from unresolved rows,
- * so hand-resolving the markers leaves it describing a tree nobody scored.
+ * Names the regenerate command: hand-resolved rows describe a tree nobody
+ * scored.
  *
  * @param {{ kind: string, label: string, rowConflicts: Array<object>, envelopeConflicts: Array<object> }} args
  */
@@ -286,9 +288,9 @@ function reportConflicts({ kind, label, rowConflicts, envelopeConflicts }) {
     );
   }
   process.stderr.write(
-    `merge-baseline: ${label} is conflicted — the rollup in it was derived from ` +
-      `unresolved rows and must not be trusted. After resolving the markers, ` +
-      `regenerate it: ${baselineRegenerateRemedy(kind)}\n`,
+    `merge-baseline: ${label} is conflicted — hand-resolved rows describe a ` +
+      `tree nobody scored. After resolving the markers, regenerate it: ` +
+      `${baselineRegenerateRemedy(kind)}\n`,
   );
 }
 
@@ -302,7 +304,7 @@ runAsCli(import.meta.url, main, {
   usage: {
     invocation: 'node .agents/scripts/merge-baseline.js %O %A %B %P',
     summary:
-      'Git merge driver for baselines/*.json. Merges per-kind envelopes by ROW IDENTITY — disjoint refreshes merge clean, the rollup is recomputed from the merged rows, and generatedAt resolves to the later stamp instead of conflicting. A baselines file that is not a known per-kind envelope is handed back to git merge-file unchanged. Exit 0 clean, 1 conflicted.',
+      'Git merge driver for baselines/*.json. Merges per-kind envelopes by ROW IDENTITY — disjoint refreshes merge clean even where their rows are adjacent, and a row both sides changed differently conflicts. A baselines file that is not a known per-kind envelope is handed back to git merge-file unchanged. Exit 0 clean, 1 conflicted.',
     flags: [
       ['%O', 'Merge ancestor (git supplies this).'],
       ['%A', 'Our version — the driver writes its result here.'],

package/.agents/workflows/audit-baselines.md

@@ -114,7 +114,8 @@ Two envelope-level reads come **before** any finding:
    gate **High** (delivery reads that file every run), a dead glob **Low**.
 
 2. **Staleness.** Two clocks. `staleDays` is whole days since the baseline's
-   own `generatedAt`; `staleCommits` is commits touching the measured surface
+   own stamp where it carries one, else its last-commit date (row-set
+   baselines carry no stamp); `staleCommits` is commits touching the measured surface
    since the baseline was last committed, with `surfaceStale` its boolean. A
    `null` on either is never a fabricated zero — the stamp is unreadable, git
    cannot answer, or the rows are not file paths — and is itself the finding.

package/docs/CHANGELOG.md

@@ -15,6 +15,17 @@ All notable changes to this project will be documented in this file.
 -->
 <!-- markdownlint-disable-file MD004 MD012 MD037 -->
 
+## [2.63.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.62.0...mandrel-v2.63.0) (2026-09-18)
+
+
+### ⚠ BREAKING CHANGES
+
+* committed baselines/*.json row-set files no longer carry `generatedAt` or `rollup`, and the per-kind schemas reject both keys. Run `mandrel migrate` (step 2.63.0, run by `mandrel update`) to rewrite existing baselines. `MANDREL_BASELINE_GENERATED_AT` is retired.
+
+### Added
+
+* make committed row-set baselines merge clean without the custom merge driver ([#5400](https://github.com/dsj1984/mandrel/issues/5400)) ([#5401](https://github.com/dsj1984/mandrel/issues/5401)) ([8a2df0a](https://github.com/dsj1984/mandrel/commit/8a2df0aeb6c75c2c08ef70eeb970b88bef716bde))
+
 ## [2.62.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.61.0...mandrel-v2.62.0) (2026-09-18)
 
 

package/lib/cli/registry.js

@@ -814,7 +814,7 @@ export function runMergeDriver({ cwd, fsImpl = fs, runner = spawn } = {}) {
   if (command === '') {
     return {
       ok: false,
-      detail: `${BASELINE_MERGE_DRIVER_CONFIG_KEY} is unset — baselines/*.json will fall back to git's text merge, which conflicts on the generatedAt stamp and can splice rows neither branch scored`,
+      detail: `${BASELINE_MERGE_DRIVER_CONFIG_KEY} is unset — baselines/*.json will fall back to git's text merge, which conflicts on adjacent rows and can splice rows neither branch scored`,
       remedy: BASELINE_MERGE_DRIVER_REMEDY,
     };
   }

package/lib/migrations/index.js

@@ -15,6 +15,7 @@ import { retireLintBaselineCommand } from './steps/2.32.0-retire-lint-baseline-c
 import { retireDeliveryLimitKnobs } from './steps/2.57.0-retire-delivery-limit-knobs.js';
 import { retirePlanningLimitKnobs } from './steps/2.57.0-retire-planning-limit-knobs.js';
 import { retireAuditResultsAutoFile } from './steps/2.60.0-retire-audit-results-autofile.js';
+import { baselineMergeQueueShape } from './steps/2.63.0-baseline-merge-queue-shape.js';
 import { stripRemovedAgentrcKeys } from './steps/strip-removed-agentrc-keys.js';
 
 /**
@@ -38,6 +39,7 @@ export const migrations = [
   retireDeliveryLimitKnobs,
   retireAuditResultsAutoFile,
   stripRemovedAgentrcKeys,
+  baselineMergeQueueShape,
 ];
 
 export { compareVersions };