@ecoma-io/archkeep 0.27.0 → 0.27.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecoma-io/archkeep",
-  "version": "0.27.0",
+  "version": "0.27.1",
   "description": "Architecture authority for human and agentic software development — deterministic, evidence-backed enforcement of declared architecture.",
   "keywords": [
     "architecture",
@@ -73,6 +73,7 @@
     "!src/custom-rules/wasm-fixture.mjs",
     "!src/report/envelope-shape.json",
     "!src/custom-rules/evidence-golden.json",
+    "!src/fixtures/",
     "presets/",
     "LICENSE",
     "README.md"

package/src/commands/README.md

@@ -54,8 +54,10 @@ the resolution order.
   introduced/resolved/unchanged/unknown (`./delta-classify.mjs`), with
   unresolvable import sites carried as their own category, never counted as
   violations. Refuses an unreadable, malformed, foreign-schema, or
-  incomplete-coverage baseline, a provider mismatch (stricter than `diff`'s
-  note — violation identity across two project models is not evidence),
+  incomplete-coverage baseline, a `command`-carrying report envelope (a graph
+  snapshot is `diff`'s input, not delta evidence), a provider mismatch
+  (stricter than `diff`'s note — violation identity across two project models
+  is not evidence),
   incomplete head coverage, and an Nx workspace with polyglot manifests but no
   plugin registration; a policy-fingerprint change is a loud coverage note, not
   a refusal. A verdict, not a description: a non-waived introduced violation is
@@ -84,8 +86,9 @@ the resolution order.
   pins); an unproven base identity or an undeterminable
   constraint is exit 3, and constraints are left unevaluated over a base the
   run cannot vouch for. Refuses a manifest that fails shape or reference
-  validation, an unreadable/malformed/incomplete baseline, a provider
-  mismatch, incomplete head coverage, and the unregistered-plugin graph.
+  validation, an unreadable/malformed/incomplete baseline, a `command`-carrying
+  report envelope in its place, a provider mismatch, incomplete head coverage,
+  and the unregistered-plugin graph.
 
 - **`impact`** (`./impact.mjs`'s `impactCommand`) — reverse reachability from
   the project graph: given a project name, lists every project that transitively

package/src/commands/change.mjs

@@ -76,8 +76,9 @@
  * exit 3, a `coverage` block naming every file and site the run could not
  * judge — where a parser and `--output` can read it; the rest are throws →
  * exit 3 upstream: a manifest that fails shape or reference validation, an
- * unreadable/malformed/foreign-schema baseline, incomplete baseline coverage,
- * a provider mismatch, an unregistered-plugin graph over polyglot manifests,
+ * unreadable/malformed/foreign-schema baseline, a `command`-carrying report
+ * envelope in its place, incomplete baseline coverage, a provider mismatch,
+ * an unregistered-plugin graph over polyglot manifests,
  * and a run with no boundary law (constraints and the law fingerprint need
  * one).
  *

package/src/commands/delta-snapshot.mjs

@@ -320,6 +320,10 @@ export function readEvidenceSnapshot(path, io = {}) {
  *
  * Refusals, each loud:
  * - unreadable/malformed JSON — named with the path and the parse error;
+ * - a `command` field — that marker belongs to a report envelope (the graph
+ *   family), so the document is not delta evidence at all; the family is
+ *   decided before the schemaVersion refusals, whose "newer version" advice
+ *   would be false for a file this binary itself wrote;
  * - a `schemaVersion` that is not the integer this format uses — a FUTURE
  *   version refuses too: a reader that half-understood a newer format would
  *   classify over evidence it misread;
@@ -360,6 +364,19 @@ export function parseEvidenceSnapshot(text, path) {
     );
   }
 
+  // A `command` field marks a report envelope — the graph family's document,
+  // not delta evidence. The family decides before the schemaVersion refusals
+  // below: that number is the OTHER format's version, so its "newer version;
+  // upgrade" advice would be false for a file this binary itself wrote (#810).
+  if (typeof parsed.command === "string") {
+    const pointer = parsed.command === "graph" ? " For graph snapshots use 'diff <baseline>'." : "";
+    throw new Error(
+      `archkeep: the evidence snapshot '${path}' has a 'command' field — it is not a delta ` +
+        `evidence snapshot, it is a '${parsed.command}' envelope. delta requires an evidence ` +
+        `snapshot (from 'delta --capture').${pointer}`,
+    );
+  }
+
   const problems = [];
   if (!Number.isInteger(parsed.schemaVersion)) {
     problems.push(

package/src/commands/delta.mjs

@@ -29,8 +29,10 @@
  * status "no-verdict", exit 3, a `coverage` block naming every file and site
  * the run could not judge — where a parser and `--output` can read it; the
  * rest are throws, exit 3 upstream:
- * - a baseline that cannot be read, parsed, or holds a foreign schemaVersion
- *   (`./delta-snapshot.mjs`'s loader owns those);
+ * - a baseline that cannot be read, parsed, or holds a foreign schemaVersion,
+ *   or a report envelope — a document carrying a `command` field (a graph
+ *   snapshot is `diff`'s input), refused as the wrong family before any
+ *   schemaVersion reading (`./delta-snapshot.mjs`'s loader owns those);
  * - a provider mismatch between baseline and this run (`providerMismatch`) —
  *   a THROW here where `diff` settles for a note, because violation IDENTITY
  *   across two different project models is not trustworthy: the same tree

package/src/commands/scenario-evaluation.mjs

@@ -152,11 +152,13 @@ function cloneGraph(graph) {
  *
  * @param {object} graph The base graph to apply changes to.
  * @param {DependencyChange[]} changes The hypothetical changes.
- * @returns {{graph: object, applied: string[], refused: string[]}}
+ * @returns {{graph: object, applied: string[],
+ *   mutations: {type: string, source: string, target: string}[], refused: string[]}}
  */
 function applyChanges(graph, changes) {
   const cloned = cloneGraph(graph);
   const applied = [];
+  const mutations = [];
   const refused = [];
 
   for (const change of changes) {
@@ -203,6 +205,7 @@ function applyChanges(graph, changes) {
         source: change.source,
       });
       applied.push(`added dependency: ${change.source} → ${change.target} (${change.edgeType})`);
+      mutations.push({ type: "dependency_added", source: change.source, target: change.target });
     }
 
     if (change.type === "dependency_removed") {
@@ -238,6 +241,7 @@ function applyChanges(graph, changes) {
       existing.splice(idx, 1);
       const typeLabel = change.edgeType ? ` (${change.edgeType})` : "";
       applied.push(`removed dependency: ${change.source} → ${change.target}${typeLabel}`);
+      mutations.push({ type: "dependency_removed", source: change.source, target: change.target });
     }
   }
   // Clean up empty dependency arrays
@@ -247,7 +251,7 @@ function applyChanges(graph, changes) {
     }
   }
 
-  return { graph: cloned, applied, refused };
+  return { graph: cloned, applied, mutations, refused };
 }
 
 /**
@@ -410,6 +414,50 @@ function resolveBaseRevision(root, userBase) {
   };
 }
 
+/**
+ * Merges constraint-impact rows for the named project's own changed edges
+ * into one side's rows (#809), preserving the row shape the primitive
+ * returns — no new fields, no second judgment.
+ *
+ * One row per project: when the side already carries a row for the project,
+ * the edge, constraint-row and violation lists union without duplicates
+ * (constraint rows match by identity — they are the config's own row
+ * objects; violations by value, since `judgeEdge` builds fresh objects);
+ * otherwise the row is appended. Appending keeps every pre-existing row
+ * byte-identical and the order deterministic, because it follows the
+ * input changes' order.
+ *
+ * @param {{project: string, edges: object[], constraintRows: object[],
+ *   violations: object[]}[]} rows The side's constraint impact, mutated in place.
+ * @param {{project: string, edges: object[], constraintRows: object[],
+ *   violations: object[]}[]} merged Rows computed for the changed edge.
+ */
+function mergeConstraintImpact(rows, merged) {
+  for (const row of merged) {
+    const existing = rows.find((r) => r.project === row.project);
+    if (!existing) {
+      rows.push(row);
+      continue;
+    }
+    for (const edge of row.edges) {
+      if (!existing.edges.some((e) => e.target === edge.target && e.type === edge.type)) {
+        existing.edges.push(edge);
+      }
+    }
+    for (const constraintRow of row.constraintRows) {
+      if (!existing.constraintRows.includes(constraintRow)) {
+        existing.constraintRows.push(constraintRow);
+      }
+    }
+    for (const violation of row.violations) {
+      const identity = JSON.stringify(violation);
+      if (!existing.violations.some((v) => JSON.stringify(v) === identity)) {
+        existing.violations.push(violation);
+      }
+    }
+  }
+}
+
 /**
  * Evaluates a scenario against the current workspace.
  *
@@ -452,7 +500,12 @@ export function evaluateScenario(
   }
 
   // Step 3: Apply scenario changes to the graph
-  const { graph: scenarioGraph, applied, refused } = applyChanges(graph, scenarioInput.changes);
+  const {
+    graph: scenarioGraph,
+    applied,
+    mutations,
+    refused,
+  } = applyChanges(graph, scenarioInput.changes);
 
   // Step 4: Compute scenario impact
   const scenarioImpact = computeImpact(projectName, scenarioGraph);
@@ -468,6 +521,47 @@ export function evaluateScenario(
     );
   }
 
+  // Step 4b: the named project's own changed edges (#809).
+  //
+  // `computeImpactConstraints` judges edges INTO the target from its
+  // dependents, so a change whose SOURCE is the named project never enters
+  // that frame — an edge pointing out of the target is invisible to it, and
+  // the source-named run reported `unchanged` where the target-named run of
+  // the same change reported the violation. The rows for the changed edge
+  // are computed here by the same primitive — never a second judgment — and
+  // merged into the frame the edge actually belongs to: additions into the
+  // scenario side (the edge exists only there), removals into the current
+  // side (it exists only there).
+  if (config && config.depConstraints) {
+    for (const mutation of mutations) {
+      if (mutation.source !== projectName) continue;
+      if (mutation.type === "dependency_added") {
+        mergeConstraintImpact(
+          scenarioConstraintImpact,
+          computeImpactConstraints(
+            mutation.target,
+            [mutation.source],
+            scenarioGraph.nodes,
+            scenarioGraph.dependencies,
+            config.depConstraints,
+          ),
+        );
+      }
+      if (mutation.type === "dependency_removed") {
+        mergeConstraintImpact(
+          currentConstraintImpact,
+          computeImpactConstraints(
+            mutation.target,
+            [mutation.source],
+            graph.nodes,
+            graph.dependencies,
+            config.depConstraints,
+          ),
+        );
+      }
+    }
+  }
+
   // Step 5: Build decision impact for both sides
   const currentDecisionImpact = buildDecisionImpact(root, currentConstraintImpact, config);
   const scenarioDecisionImpact = buildDecisionImpact(root, scenarioConstraintImpact, config);

package/src/corpus/goldens/adr.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "adr",
   "workspace": {

package/src/corpus/goldens/change.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "change",
   "workspace": {
@@ -45,7 +45,7 @@
       "path": "<fixture-root>/.archkeep-delta.json",
       "tool": {
         "name": "@ecoma-io/archkeep",
-        "version": "0.27.0"
+        "version": "0.27.1"
       },
       "provider": "native",
       "provenance": {

package/src/corpus/goldens/check.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "check",
   "workspace": {

package/src/corpus/goldens/context.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "context",
   "workspace": {

package/src/corpus/goldens/debt.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "debt",
   "workspace": {

package/src/corpus/goldens/decisions.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "decisions",
   "workspace": {

package/src/corpus/goldens/delta.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "delta",
   "workspace": {
@@ -31,7 +31,7 @@
       "path": "<fixture-root>/.archkeep-delta.json",
       "tool": {
         "name": "@ecoma-io/archkeep",
-        "version": "0.27.0"
+        "version": "0.27.1"
       },
       "provider": "native",
       "provenance": {

package/src/corpus/goldens/diff.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "diff",
   "workspace": {
@@ -33,7 +33,7 @@
       "path": "<fixture-root>/.archkeep-graph.json",
       "projects": 3,
       "edges": 2,
-      "toolVersion": "0.27.0",
+      "toolVersion": "0.27.1",
       "provenance": {
         "commit": "1fd51709c377d99a6139891e1200291cf08aede9",
         "remote": null,

package/src/corpus/goldens/discover.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "discover",
   "workspace": {

package/src/corpus/goldens/drift.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "drift",
   "workspace": {

package/src/corpus/goldens/evolution.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "evolution",
   "workspace": {

package/src/corpus/goldens/explain.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "explain",
   "workspace": {

package/src/corpus/goldens/fitness.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "fitness",
   "workspace": {

package/src/corpus/goldens/graph.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "graph",
   "workspace": {

package/src/corpus/goldens/health.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "health",
   "workspace": {

package/src/corpus/goldens/history.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "history",
   "workspace": {

package/src/corpus/goldens/impact.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "impact",
   "workspace": {

package/src/corpus/goldens/provenance.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "provenance",
   "workspace": {

package/src/corpus/goldens/reconcile.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "reconcile",
   "workspace": {

package/src/corpus/goldens/report.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "report",
   "workspace": {

package/src/corpus/goldens/scenario.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "scenario",
   "workspace": {

package/src/corpus/goldens/trajectory.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "trajectory",
   "workspace": {

package/src/corpus/goldens/waivers.json

@@ -2,7 +2,7 @@
   "schemaVersion": 2,
   "tool": {
     "name": "@ecoma-io/archkeep",
-    "version": "0.27.0"
+    "version": "0.27.1"
   },
   "command": "waivers",
   "workspace": {

package/src/governance/reconcile-score.mjs

@@ -268,8 +268,13 @@ export function scoreEdge(edge, keys, intentForbiddenPairs, tagForbiddenPairs) {
  * Boundary `allowed`/`forbidden` rows are scored from the canonical judge's
  * findings (matched exactly by `from`/`to`): a `forbidden` row with an
  * `intentForbiddenEdge` finding is `unexpected`, an `allowed` row with an
- * `intentAllowedMissing` finding is `absent`. Project and dependency rows are
- * scored directly against the observed names and edges. A
+ * `intentAllowedMissing` finding is `absent`. Project rows are scored against
+ * the observed names, and the two forbidden drift planes are scored from the
+ * judge's findings as well — `dependencies.forbidden` through its
+ * `dependencyForbidden` findings, `forbiddenTags` through its
+ * `tagDependencyForbidden` witnesses attributed via `tagsByProject` — so a
+ * row's verdict IS the verdict `check` and `drift` render, including the
+ * transitive closure a direct-edge re-derivation would read as "match". A
  * `dependencies.allowed` row is an allowlist entry, not an existence claim —
  * its absence in the graph is not divergence, so it scores `match` either
  * way (the divergent direction is the observed edge outside the list, scored
@@ -285,7 +290,29 @@ export function scoreIntentRows(intent, judgeVerdict, observed, tagsByProject) {
   // used by its own test
   const rows = [];
   const observedNames = new Set(observed.projects.map((p) => p.name));
-  const observedEdgeKeys = new Set(observed.edges.map((e) => `${e.source} → ${e.target}`));
+  // The judge has already judged every forbidden plane on the any-path
+  // closure (`../architecture-intent/judge.mjs` emits `dependencyForbidden`
+  // and `tagDependencyForbidden` for direct AND transitive paths, as concrete
+  // `source`/`target` project names with `boundaryFrom: null`). These two
+  // projections score the drift rows from those findings — projecting the
+  // canonical verdict, never re-deriving reachability here: a re-walk of the
+  // direct-edge list would score a transitive violation the judge reported
+  // as a row "match", the divergence `check` and `drift` do report. The
+  // judge's pairless findings (`intentUnknownProject`, `intentUnknownTag`)
+  // carry no witness pair; the rows they belong to are scored below from the
+  // observed names and tags themselves — the same existence predicate the
+  // judge used to emit them: a row whose endpoint can never resolve is
+  // unknown/unverifiable, never a silent "match".
+  const dependencyForbiddenPairs = new Set();
+  const tagForbiddenWitnesses = [];
+  for (const finding of judgeVerdict.findings) {
+    if (finding.source === null || finding.target === null) continue;
+    if (finding.rule === "dependencyForbidden") {
+      dependencyForbiddenPairs.add(`${finding.source} → ${finding.target}`);
+    } else if (finding.rule === "tagDependencyForbidden") {
+      tagForbiddenWitnesses.push([finding.source, finding.target]);
+    }
+  }
 
   const boundaryFinding = new Map();
   for (const finding of judgeVerdict.findings) {
@@ -341,22 +368,45 @@ export function scoreIntentRows(intent, judgeVerdict, observed, tagsByProject) {
   }
   for (const forbidden of dependencies.forbidden ?? []) {
     const key = `${forbidden.source} → ${forbidden.target}`;
+    // A row naming a project the observed architecture does not have can
+    // never fire — the judge reports it as `intentUnknownProject` with no
+    // witness pair, so the projection above stays empty for it. Reading
+    // that as "match — the ban holds" would be the silent direction; score
+    // it unknown, mirroring the boundary plane (`reconcileScores`).
+    if (!observedNames.has(forbidden.source) || !observedNames.has(forbidden.target)) {
+      row("edge", key, "unknown", "intentUnknownProject", "forbidden", key);
+      continue;
+    }
+    const violated = dependencyForbiddenPairs.has(key);
     row(
       "edge",
       key,
-      observedEdgeKeys.has(key) ? "unexpected" : "match",
-      observedEdgeKeys.has(key) ? "dependencyForbidden" : "match",
+      violated ? "unexpected" : "match",
+      violated ? "dependencyForbidden" : "match",
       "forbidden",
       key,
     );
   }
 
+  // Every tag any observed project carries — the existence side of a
+  // `forbiddenTags` row, the same vocabulary the judge checks when it emits
+  // `intentUnknownTag`.
+  const allTags = new Set();
+  for (const tags of tagsByProject.values()) {
+    for (const tag of tags) allTags.add(tag);
+  }
   for (const tagRow of intent.forbiddenTags ?? []) {
     const key = `${tagRow.from} → ${tagRow.to}`;
-    const violated = observed.edges.some((e) => {
-      if (e.source === e.target) return false;
-      const sourceTags = tagsByProject.get(e.source) ?? [];
-      const targetTags = tagsByProject.get(e.target) ?? [];
+    // A row naming a tag no observed project carries can never fire — the
+    // judge reports it as `intentUnknownTag` with no witness pair. Score it
+    // unknown, never a silent "match".
+    if (!allTags.has(tagRow.from) || !allTags.has(tagRow.to)) {
+      row("tag", key, "unknown", "intentUnknownTag", "tag-forbidden", key);
+      continue;
+    }
+    const violated = tagForbiddenWitnesses.some(([source, target]) => {
+      const sourceTags = tagsByProject.get(source) ?? [];
+      const targetTags = tagsByProject.get(target) ?? [];
       return sourceTags.includes(tagRow.from) && targetTags.includes(tagRow.to);
     });
     row(

package/src/report/text.mjs

@@ -774,7 +774,7 @@ function formatUntrackedFilesGap(gap) {
     `⚠ ${count} project-owned file${count === 1 ? "" : "s"} ${count === 1 ? "is" : "are"} ` +
     `not tracked by git — never read by this run, so no boundary verdict here covers ${them}\n` +
     `${lines.join("\n")}\n` +
-    `${DETAIL}git add ${them} so the next run reads ${them}, or let git ignore ${them}`
+    `${DETAIL}git add ${them} so the next run reads ${them}`
   );
 }
 

package/src/fixtures/evolution-lifecycle/workspace.mjs

@@ -1,248 +0,0 @@
-/**
- * Fixture scaffolding for the Wave 3 W8 evolution-lifecycle conformance suite
- * (`../evolution-lifecycle.integration.test.mjs`). This module is the ONE home
- * for the real-git workspace builders that suite uses — a throwaway native Go
- * workspace per case, materialized through real `git`, driven through the real
- * `archkeep evolution` entry point.
- *
- * It deliberately reuses the native-workspace recipe already proven by
- * `../commands/evolution.cli.integration.test.mjs` (an `archkeep.json` model,
- * a `module-boundaries.config.mjs` law, and Go sources) rather than inventing
- * a second convention, and threads the same environment guard (`../process.mjs`).
- *
- * Nothing here decides a verdict. It builds trees and drives the CLI; the
- * assertions live in the suite. Keeping the builders here (and only here) is
- * what the W8 task boundary requires: fixture scaffolding lives in
- * `./fixtures/evolution-lifecycle/`, nowhere else.
- */
-
-import { execFileSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { EXIT, runCli } from "../../../cli.mjs";
-import { SPAWN_BUDGET_MS, SPAWN_TEST_BUDGET_MS } from "../../../spawn-budget.mjs";
-import { environmentForTree } from "../../workspace.mjs";
-
-export { SPAWN_TEST_BUDGET_MS, EXIT };
-
-/** Identity flags keeping every fixture commit independent of the machine. */
-const IDENTITY = ["-c", "user.name=t", "-c", "user.email=t@t", "-c", "commit.gpgsign=false"];
-
-/**
- * Runs git in `cwd` through the same environment guard production uses, with
- * the single-spawn budget on every child so a wedged git fails the test rather
- * than blocking the worker thread forever.
- */
-export function git(cwd, ...args) {
-  // used by its own test
-  return execFileSync("git", args, {
-    cwd,
-    env: environmentForTree(),
-    encoding: "utf8",
-    timeout: SPAWN_BUDGET_MS,
-    killSignal: "SIGKILL",
-  });
-}
-
-/** Writes `text` to `root/relativePath`, creating parent directories. */
-export function writeIn(root, relativePath, text) {
-  // used by its own test
-  mkdirSync(join(root, relativePath, ".."), { recursive: true });
-  writeFileSync(join(root, relativePath), text);
-}
-
-/** Stages every change and commits with the fixture identity; returns the SHA. */
-export function commit(root, message) {
-  // used by its own test
-  git(root, ...IDENTITY, "add", "-A");
-  git(root, ...IDENTITY, "commit", "-q", "-m", message);
-  return git(root, "rev-parse", "HEAD").trim();
-}
-
-/**
- * Opens a brand-new throwaway native git workspace (never the repository's own
- * tree). `archkeep.json` declares two Go projects on two layers, exactly the
- * MODEL `../commands/evolution.cli.integration.test.mjs` uses, so a case can
- * lay an edge between them and the native provider draws it.
- *
- * @returns {{root: string}}
- */
-export function createWorkspace() {
-  const root = mkdtempSync(join(tmpdir(), "archkeep-lifecycle-"));
-  git(root, "init", "-q", "-b", "main");
-  writeIn(root, "archkeep.json", `${MODEL()}\n`);
-  writeIn(root, "libs/alpha/go.mod", "module example.com/alpha\n\ngo 1.22\n");
-  writeIn(root, "libs/beta/go.mod", "module example.com/beta\n\ngo 1.22\n");
-  return { root };
-}
-
-/**
- * The native workspace model: two Go projects on two layers (alpha is
- * `layer:a`, beta is `layer:b`), the law file exempted from coverage.
- */
-const MODEL = () =>
-  JSON.stringify(
-    {
-      projects: {
-        declared: [
-          { root: "libs/alpha", name: "alpha", tags: ["layer:a"] },
-          { root: "libs/beta", name: "beta", tags: ["layer:b"] },
-        ],
-      },
-      coverage: {
-        exempt: [{ path: "module-boundaries.config.mjs", reason: "the workspace's own law" }],
-      },
-    },
-    null,
-    2,
-  );
-
-/** The eight options a valid boundary law must carry, per `policyFrom`. */
-const OPTIONS = `export const moduleBoundaryOptions = {
-  allow: [],
-  buildTargets: ["build"],
-  enforceBuildableLibDependency: false,
-  allowCircularSelfDependency: false,
-  checkDynamicDependenciesExceptions: [],
-  ignoredCircularDependencies: [],
-  banTransitiveDependencies: false,
-  checkNestedExternalImports: false,
-};
-`;
-
-export const ALPHA_CLEAN = `package alpha // used by its own test
-
-func Name() string { return "alpha" }
-`;
-
-export const ALPHA_REACHING = `package alpha // used by its own test
-
-import (
-	"example.com/beta"
-)
-
-func Name() string { return "alpha" + beta.Suffix() }
-`;
-
-export const BETA = `package beta // used by its own test
-
-func Suffix() string { return "-beta" }
-`;
-
-/**
- * Writes a `module-boundaries.config.mjs` law at `root` with the given
- * `depConstraints` rows and optional `fitness` array.
- *
- * @param {string} root
- * @param {{rows?: string, fitness?: string}} [law]
- */
-export function writeLaw(root, { rows = "", fitness } = {}) {
-  // used by its own test
-  writeIn(
-    root,
-    "module-boundaries.config.mjs",
-    `export const depConstraints = [\n${rows}\n];\n${OPTIONS}` +
-      (fitness === undefined ? "" : `\nexport const fitness = ${fitness};\n`),
-  );
-}
-
-/**
- * A single permitted layer rule (a may reach b). The same ONE_ROW the
- * evolution CLI integration fixtures use, so an allowed alpha→beta edge never
- * trips a boundary rule.
- */
-export const ALLOW_A_TO_B = `  { sourceTag: "layer:a", onlyDependOnLibsWithTags: ["layer:b"] },`; // used by its own test
-
-/**
- * Writes `architecture-intent.json` at `root`. `sections` carries the top-level
- * keys directly (`version`, `boundaries`, `allowed`, `forbidden`,
- * `dependencies`, …); `version` defaults to "1".
- */
-export function writeIntent(root, sections) {
-  // used by its own test
-  writeIn(root, "architecture-intent.json", `${JSON.stringify(sections, null, 2)}\n`);
-}
-
-/**
- * Writes one ADR record under `docs/adr/`, the shape `adr-registry.mjs` reads.
- * `record` is the frontmatter map (`{id, status, supersedes?, bindings?}`).
- */
-export function writeAdr(root, filename, record) {
-  // used by its own test
-  const lines = ["---", `id: ${record.id}`, `status: ${record.status}`];
-  if (record.supersedes?.length) {
-    lines.push("supersedes:");
-    for (const target of record.supersedes) lines.push(`  - ${target}`);
-  }
-  if (record.bindings?.length) {
-    lines.push("bindings:");
-    for (const binding of record.bindings) lines.push(`  - ${binding}`);
-  }
-  lines.push("---", "", `# ${record.id}`, "");
-  writeIn(root, join("docs/adr", filename), `${lines.join("\n")}\n`);
-}
-
-/**
- * Drives the CLI in-process over `cwd`, capturing streams. Returns the exit
- * code and joined `out`/`err`. `runCli` is the real entry point
- * (`../cli.mjs`), never a shell-out to a binary named `archkeep`.
- */
-export async function runEvolution(cwd, argv) {
-  // used by its own test
-  const out = [];
-  const err = [];
-  const exitCode = await runCli(argv, {
-    out: (text) => out.push(text),
-    err: (text) => err.push(text),
-    cwd,
-  });
-  return { exitCode, out: out.join("\n"), err: err.join("\n") };
-}
-
-/**
- * Invokes `evolution --base <base> [--head <head>] [--event-out <dir>] [--format json]`.
- *
- * @param {string} base The base revision (full SHA).
- * @param {{head?: string, eventOut?: string, format?: string}} [options]
- */
-export function evolutionArgs(base, { head, eventOut, format = "json" } = {}) {
-  // used by its own test
-  const args = ["evolution", "--base", base];
-  if (head) args.push("--head", head);
-  if (eventOut) args.push("--event-out", eventOut);
-  if (format) args.push("--format", format);
-  return args;
-}
-
-/**
- * Parses the `--format json` envelope out of a successful evolution run.
- */
-export function parseEnvelope(run) {
-  // used by its own test
-  if (run.exitCode !== EXIT.ok) throw new Error(`evolution exited ${run.exitCode}: ${run.err}`);
-  return JSON.parse(run.out);
-}
-
-/** The parsed event files in `dir`, in filename order. */
-export function readEvents(dir) {
-  return readdirSync(dir)
-    .filter((name) => name.endsWith(".json") && !name.endsWith(".json.tmp"))
-    .sort()
-    .map((name) => JSON.parse(readFileSync(join(dir, name), "utf8")));
-}
-
-/** The event store's file names in `dir`, in filename order. */
-export function eventFiles(dir) {
-  // used by its own test
-  return readdirSync(dir)
-    .filter((name) => name.endsWith(".json") && !name.endsWith(".json.tmp"))
-    .sort();
-}
-
-/** Removes a throwaway workspace. */
-export function dispose(root) {
-  // used by its own test
-  rmSync(root, { recursive: true, force: true });
-}