@ecoma-io/archkeep 0.25.0 → 0.26.0

package/src/commands/impact.mjs

@@ -40,8 +40,10 @@ import { coverageRefusal, coverageVerdict } from "./coverage-verdict.mjs";
 import { jsonEnvelope, renderJson } from "../report/json.mjs";
 import { formatImpactReport } from "../report/impact-text.mjs";
 import { resolveProvenance } from "./provenance.mjs";
+import { resolveCommandContext } from "./context.mjs";
 import { composeImpactStatement } from "./impact-statement.mjs";
 import { computeImpact } from "./impact-reachability.mjs";
+import { resolvePolicy } from "./policy.mjs";
 
 /**
  * The reachability walk this command reports, shared with the canonical
@@ -171,3 +173,24 @@ export function impactCommand(projectName, commandContext, config = null) {
     },
   };
 }
+
+/**
+ * `impact` as the CLI drives it: the shared preamble — command context, then
+ * the boundary law — resolved here so `../../cli.mjs`'s driver only wires
+ * options, IO seams, and where output lands (`./README.md`). The engine this
+ * returns from is `impactCommand` above, unchanged.
+ *
+ * @param {string} projectName The project whose dependents are walked.
+ * @param {{config: string|null}} options This run's parsed flags.
+ * @param {{cwd: string, readGraph?: Function, listFiles?: Function}} io The
+ *   seams a test injects, the same ones `check` takes.
+ * @returns {Promise<object>} `impactCommand`'s result, unmodified.
+ */
+export async function impact(projectName, options, { cwd, readGraph, listFiles }) {
+  const commandContext = resolveCommandContext({ cwd }, { readGraph, listFiles });
+  // Load the boundary config when --config is given or when the workspace
+  // declares one, so constraint-impact analysis is computed — profile-aware
+  // the same way `check` is (`resolvePolicy`).
+  const { config } = await resolvePolicy(options, commandContext, cwd);
+  return impactCommand(projectName, commandContext, config);
+}

package/src/commands/inspect-capability.mjs

@@ -0,0 +1,16 @@
+/**
+ * `inspect` capability facade — the word's verb roster as explicit named
+ * re-exports: `graph`, `impact`, `context` (the non-plan read; `--plan`
+ * dispatches to `planContext`), `health`.
+ *
+ * Pure surface module: no judgment, no defaults, no logic — every export is
+ * a re-export of a command module. `cli.mjs` routes its verb imports through
+ * the facade so the vocabulary's code referent is visible to the import
+ * graph, not just to a comment (PD-18,
+ * ../../../../docs/architecture/refactor/DECISIONS.md).
+ */
+export { graph } from "./graph.mjs";
+export { impact } from "./impact.mjs";
+export { context } from "./context-command.mjs";
+export { planContext } from "./plan-context-command.mjs";
+export { health } from "./health.mjs";

package/src/commands/plan-context-command.mjs

@@ -61,6 +61,7 @@
  * reporting set. This makes the plan's verdict correct on every provider.
  */
 import { statSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
 import { join } from "node:path";
 
 import { INTENT_FILE, loadIntent } from "../architecture-intent/model.mjs";
@@ -82,6 +83,8 @@ import { buildDependencies, buildProjects, computePolicyFingerprint } from "./gr
 import { resolveProvenance } from "./provenance.mjs";
 import { readAdrContext } from "./adr.mjs";
 import { declaresFitness, fitnessForCheck } from "./fitness.mjs";
+import { resolveCommandContext } from "./context.mjs";
+import { resolvePolicy } from "./policy.mjs";
 import { computeWaivers } from "./waivers.mjs";
 import { declaredFitnessNames, unresolvedDecisionRefRows } from "../governance/adr-registry.mjs";
 import { formatPlanContextReport } from "../report/plan-context-text.mjs";
@@ -667,3 +670,35 @@ function goWorkResult(goWork) {
 function tsconfigPathsResult(tsconfigPaths) {
   return tsconfigPaths === null ? null : { checked: true, findings: tsconfigPaths.findings };
 }
+
+/**
+ * `context --plan` as the CLI drives it: the shared preamble — command
+ * context, then the boundary law — resolved here, plus the plan's own
+ * arguments (the project, the change's scope paths, the optional history
+ * directory), so `../../cli.mjs`'s driver only wires options, IO seams, and
+ * where output lands (`./README.md`). The engine this returns from is
+ * `planContextCommand` above, unchanged.
+ *
+ * @param {{config: string|null, historyDir: string|null, paths: string[]}} options
+ *   This run's parsed flags; `paths[0]` is the project name, the rest are
+ *   the change's scope.
+ * @param {{cwd: string, readGraph?: Function, listFiles?: Function}} io The
+ *   seams a test injects, the same ones `check` takes.
+ * @returns {Promise<object>} `planContextCommand`'s result, unmodified.
+ */
+export async function planContext(options, { cwd, readGraph, listFiles }) {
+  const commandContext = resolveCommandContext({ cwd }, { readGraph, listFiles });
+  const { config } = await resolvePolicy(options, commandContext, cwd);
+  const historyDir = options.historyDir
+    ? isAbsolute(options.historyDir)
+      ? options.historyDir
+      : resolve(cwd, options.historyDir)
+    : null;
+  return planContextCommand(
+    options.paths[0],
+    options.paths.slice(1),
+    commandContext,
+    config,
+    historyDir,
+  );
+}

package/src/commands/policy.mjs

@@ -14,7 +14,7 @@ import { isAbsolute, relative, resolve } from "node:path";
 import { containmentViolation } from "../containment.mjs";
 import { loadBoundaryConfig, loadBoundaryConfigFile, policyFrom } from "../config.mjs";
 import { profilePolicy } from "../governance/profile-registry.mjs";
-import { ARCHKEEP_MODEL_FILE } from "../providers/native/model.mjs";
+import { ARCHKEEP_MODEL_FILE, loadNativeModel } from "../providers/native/model.mjs";
 
 /**
  * Whether the workspace's resolved options name a `profiles` registry — the
@@ -35,7 +35,9 @@ function hasProfiles(options) {
  * shares, in the one place all of them now call it from. Hand-copied 11
  * times before this — `check`, `graph`, `diff`, `waivers`, `fitness`,
  * `impact`, `explain`, `context`, `history`'s `--capture` branch, `debt`,
- * `health` — the duplication is what let two defects land in it independently:
+ * `health` — and `provenance` joined at WI-2's fold, its private walk until
+ * then keeping the P1-26 class alive there too — the duplication is what
+ * let two defects land in it independently:
  * P1-25 found `graph`'s copy alone missing the inline-object arm, and P1-26
  * found only `check`'s copy aware of a `profiles` registry at all — the other
  * ten tried to resolve a profile NAME as a file, and named the wrong problem
@@ -43,7 +45,7 @@ function hasProfiles(options) {
  * `"strict"` as "names an unsupported boundaryConfig extension '(none)'",
  * which blames a typo that was never made rather than naming the real gap —
  * that command never knew profiles existed. One function, called from all
- * eleven sites, is what makes that defect class structurally impossible to
+ * twelve sites, is what makes that defect class structurally impossible to
  * reintroduce one copy at a time.
  *
  * Checked in order, and the first match wins:
@@ -76,7 +78,7 @@ function hasProfiles(options) {
  * intent's `file`). Only `check` reads either field today (P1-01, naming the
  * law that governed a run in its own report), but they are returned
  * unconditionally rather than as a second, `check`-only code path, so the
- * eleven callers keep sharing the one ladder this function exists to be.
+ * twelve callers keep sharing the one ladder this function exists to be.
  *
  * @param {{config: string|null}} options The command's own parsed flags —
  *   only `config` is read here, so a command with no `--config` flag at all
@@ -231,3 +233,39 @@ async function resolvePolicyArm(options, commandContext, cwd) {
   }
   return { config: null, profile: null, source: null };
 }
+
+/**
+ * The options `--help` words itself with over a native-only workspace — the
+ * `loadNativeModel` read the entry file used to carry inline. Help names the
+ * boundary law a run would actually read, and on a native tree that law
+ * lives on `archkeep.json` itself: a string `boundaryConfig` is a filename,
+ * an object is the inline policy (there is no other channel).
+ *
+ * Throws exactly what `loadNativeModel` throws; the caller owns the
+ * best-effort posture (`--help` falls back to the defaults rather than
+ * refusing to print), this function owns only the reading and the wording
+ * shape.
+ *
+ * @param {string} root Absolute workspace root.
+ * @param {{readFile: (path: string) => string|null}} io Workspace-relative
+ *   read, injectable for the same reason `loadNativeModel`'s is.
+ * @returns {{boundaryConfig: string, tsConfig: string, inline?: boolean}}
+ *   `inline: true` marks the object-policy case: the boundaryConfig "name"
+ *   is then prose, not a file.
+ */
+export function nativePolicyOptions(root, { readFile }) {
+  const model = loadNativeModel(root, { readFile });
+  // An inline policy object has no filename to print — `${boundaryConfig}`
+  // would otherwise coerce it to the literal text "[object Object]", which
+  // reads as a real (and wrong) filename rather than as the "there is no
+  // file" it actually means. `inline: true` is what tells the usage text to
+  // print the paragraph that says so, instead of the one describing a named
+  // file.
+  return typeof model.boundaryConfig === "string"
+    ? { boundaryConfig: model.boundaryConfig, tsConfig: model.tsConfig }
+    : {
+        boundaryConfig: `an inline policy in ${ARCHKEEP_MODEL_FILE}`,
+        tsConfig: model.tsConfig,
+        inline: true,
+      };
+}

package/src/commands/provenance-command.mjs

@@ -73,7 +73,7 @@
 import { jsonEnvelope, renderJson } from "../report/json.mjs";
 import { formatProvenanceReport } from "../report/provenance-text.mjs";
 import { loadIntent } from "../architecture-intent/model.mjs";
-import { loadBoundaryConfig } from "../config.mjs";
+import { resolvePolicy } from "./policy.mjs";
 import { resolveFileAttribution, resolveProvenance } from "./provenance.mjs";
 import { readAdrContext } from "./adr.mjs";
 import {
@@ -206,7 +206,6 @@ export function unresolvedDecisionRefNote(decisionRef) {
  *   options: {boundaryConfig: string|object, inline?: boolean}}} commandContext
  *   From `resolveCommandContext`.
  * @param {{loadIntentOverride?: (root: string, io: object) => Promise<object>,
- *   loadConfigOverride?: (root: string, boundaryConfig: string) => Promise<object>,
  *   loadAdrRegistryOverride?: typeof import("../governance/adr-registry.mjs").loadAdrRegistry,
  *   fileAttribution?: (root: string, file: string) =>
  *     {createdBy: import("../governance/provenance-record.mjs").OriginRecord,
@@ -234,7 +233,7 @@ export function unresolvedDecisionRefNote(decisionRef) {
  *   exit 3, the loud refusal every command that reads them makes.
  */
 export async function provenanceCommand(commandContext, io = {}) {
-  const { root, tracked, options } = commandContext;
+  const { root, tracked } = commandContext;
 
   const repo = resolveProvenance(root);
   const rowList = [];
@@ -254,27 +253,19 @@ export async function provenanceCommand(commandContext, io = {}) {
     }
   }
 
-  // The boundary law is either a filename (the string form `loadBoundaryConfig`
-  // reads) or an inline policy object living directly in `archkeep.json`
-  // (`../providers/native/model.mjs`, `normalizeNativeModel`'s
-  // `inlineBoundaryConfig`). Both are walked — a policy whose rows the report
-  // never inspected would claim "every row attests" over an unread table,
-  // which is the silent direction this command exists to end.
-  const boundaryConfig = options.boundaryConfig;
-  const walked = [];
-  let loadedConfig = null;
-  if (typeof boundaryConfig === "string") {
-    const config = await (io.loadConfigOverride ?? loadBoundaryConfig)(root, boundaryConfig);
-    loadedConfig = config;
-    walked.push(...configRows(config));
-  } else if (
-    boundaryConfig !== null &&
-    typeof boundaryConfig === "object" &&
-    !Array.isArray(boundaryConfig)
-  ) {
-    loadedConfig = boundaryConfig;
-    walked.push(...configRows(boundaryConfig));
-  }
+  // The boundary law resolves through the one policy ladder every command
+  // that reads a law shares (`./policy.mjs`'s `resolvePolicy`) — the
+  // profile, file, and inline arms included — so the rows attested here are
+  // exactly the rows `check` judges, never a law resolved by a private
+  // second copy. A policy whose rows the report never inspected would claim
+  // "every row attests" over an unread table, which is the silent direction
+  // this command exists to end. `config: null` — there is no `--config`
+  // flag here (`PROVENANCE_FLAG_HELP`): the workspace's own law,
+  // profile-selected when a registry is named, is the only one a provenance
+  // report may cite. A `null` config (the workspace declares no law) walks
+  // zero rows.
+  const { config: loadedConfig } = await resolvePolicy({ config: null }, commandContext, root);
+  const walked = configRows(loadedConfig);
   for (const { kind, row } of walked) {
     const attested = hasOrigin(row);
     rowList.push({ kind, attested, origin: attested ? row.origin : null });

package/src/commands/report.mjs

@@ -107,6 +107,7 @@
  */
 import { formatGovernanceReport } from "../report/report-text.mjs";
 import { jsonEnvelope, renderJson } from "../report/json.mjs";
+import { isAbsolute, resolve } from "node:path";
 import { healthCommand } from "./health.mjs";
 import { declaresFitness, fitnessCommand } from "./fitness.mjs";
 import { waiversCommand } from "./waivers.mjs";
@@ -128,6 +129,9 @@ import {
 } from "../governance/adr-registry.mjs";
 import { computeDecisionFitness } from "../governance/decision-fitness.mjs";
 import { hasAuthority, stripRuleFitnessPrefix } from "../governance/adr-registry.mjs";
+import { resolveCommandContext } from "./context.mjs";
+import { loadIntentIfTracked } from "../architecture-intent/model.mjs";
+import { resolvePolicy } from "./policy.mjs";
 
 /**
  * The message a thrown refusal carries, as the report's reason for a surface
@@ -598,3 +602,37 @@ export async function reportCommand(commandContext, io = {}) {
     },
   };
 }
+
+/**
+ * `report` as the CLI drives it: the shared preamble — command context, the
+ * ONE boundary law the whole document is written against, the tracked
+ * intent — resolved here, so `../../cli.mjs`'s driver only wires options,
+ * IO seams, and where output lands (`./README.md`). The engine this returns
+ * from is `reportCommand` above, unchanged.
+ *
+ * @param {{config: string|null, paths: string[]}} options This run's parsed
+ *   flags; at most one positional, the snapshot directory for trends.
+ * @param {{cwd: string, readGraph?: Function, listFiles?: Function}} io The
+ *   seams a test injects, the same ones `check` takes.
+ * @returns {Promise<object>} `reportCommand`'s result, unmodified.
+ */
+export async function report(options, { cwd, readGraph, listFiles }) {
+  const commandContext = resolveCommandContext({ cwd }, { readGraph, listFiles });
+  // ONE law for the whole document — resolved exactly the way `check` and
+  // `health` resolve theirs, and handed to every surface the report
+  // composes, so no two sections can cite different laws.
+  const { config, source } = await resolvePolicy(options, commandContext, cwd);
+  const intent = await loadIntentIfTracked(commandContext.root, commandContext.tracked);
+  const trendDir =
+    options.paths.length === 1
+      ? isAbsolute(options.paths[0])
+        ? options.paths[0]
+        : resolve(cwd, options.paths[0])
+      : null;
+  return reportCommand(commandContext, {
+    config,
+    intent,
+    trendDir,
+    policySource: source,
+  });
+}

package/src/commands/rules-capability.mjs

@@ -0,0 +1,16 @@
+/**
+ * `rules` capability facade — the word's verb roster as explicit named
+ * re-exports: `rules` (the `list`, `info`, `verify`, and `add` subcommands).
+ *
+ * Pure surface module: no judgment, no defaults, no logic — every export is
+ * a re-export of a command module. `cli.mjs` routes its verb imports through
+ * the facade so the vocabulary's code referent is visible to the import
+ * graph, not just to a comment (PD-18,
+ * ../../../../docs/architecture/refactor/DECISIONS.md).
+ */
+export {
+  rulesAddCommand,
+  rulesInfoCommand,
+  rulesListCommand,
+  rulesVerifyCommand,
+} from "./rules.mjs";

package/src/commands/rules.mjs

@@ -341,7 +341,8 @@ export async function rulesInfoCommand(options, { cwd, ruleName }) {
  *
  * @param {{catalog?: string}} options The parsed command options.
  * @param {{cwd: string}} runContext The command context.
- * @returns {Promise<{status: "ok"|"findings"|"no-verdict", catalog: object, report: {text: string, json: string}}>}
+ * @returns {Promise<{status: "ok"|"findings"|"no-verdict", exitCode: 0|1|3,
+ *   catalog: object, report: {text: string, json: string}}>}
  */
 export async function rulesVerifyCommand(options, { cwd }) {
   const catalogPath = resolveCatalogPath(options, cwd);
@@ -473,6 +474,7 @@ export async function rulesVerifyCommand(options, { cwd }) {
 
   return {
     status,
+    exitCode,
     catalog,
     report: {
       text,

package/src/commands/scenario.mjs

@@ -11,9 +11,11 @@
  */
 import { resolveProvenance } from "./provenance.mjs";
 import { jsonEnvelope, renderJson } from "../report/json.mjs";
+import { resolveCommandContext } from "./context.mjs";
 import { coverageRefusal, coverageVerdict } from "./coverage-verdict.mjs";
 import { evaluateScenario, parseScenarioInput } from "./scenario-evaluation.mjs";
 export { parseScenarioInput } from "./scenario-evaluation.mjs";
+import { resolvePolicy } from "./policy.mjs";
 
 /**
  * Runs the `scenario` command: parses the scenario input, evaluates it, and
@@ -195,3 +197,24 @@ function formatScenarioReport(scenario, coverage) {
 
   return lines.join("\n");
 }
+
+/**
+ * `scenario` as the CLI drives it: the shared preamble — command context,
+ * then the boundary law — resolved here so `../../cli.mjs`'s driver only
+ * wires options, IO seams, and where output lands (`./README.md`). The
+ * engine this returns from is `scenarioCommand` above, unchanged. The
+ * scenario file itself is read by the driver, because a file the CLI cannot
+ * read is a usage error (exit 2), not a run failure (exit 3).
+ *
+ * @param {string} projectName The target project.
+ * @param {string} scenarioJson The scenario description, read by the driver.
+ * @param {{config: string|null}} options This run's parsed flags.
+ * @param {{cwd: string, readGraph?: Function, listFiles?: Function}} io The
+ *   seams a test injects, the same ones `check` takes.
+ * @returns {Promise<object>} `scenarioCommand`'s result, unmodified.
+ */
+export async function scenario(projectName, scenarioJson, options, { cwd, readGraph, listFiles }) {
+  const commandContext = resolveCommandContext({ cwd }, { readGraph, listFiles });
+  const { config } = await resolvePolicy(options, commandContext, cwd);
+  return scenarioCommand(projectName, scenarioJson, commandContext, config);
+}

package/src/commands/trajectory.mjs

@@ -92,6 +92,8 @@
 import { jsonEnvelope, renderJson } from "../report/json.mjs";
 import { formatTrajectoryReport } from "../report/trajectory-text.mjs";
 import { edgeIdentityKey } from "./diff.mjs";
+import { isAbsolute, resolve } from "node:path";
+import { dirname } from "node:path";
 import { classifyTransition, readSnapshots } from "./history.mjs";
 import { resolveProvenance } from "./provenance.mjs";
 
@@ -522,3 +524,36 @@ export function trajectoryCommand(dir, commandContext, options = {}) {
     },
   };
 }
+
+/**
+ * `trajectory`'s self-footgun guard, declared by the command that owns the
+ * law and enforced by the driver's write door: a report written into the
+ * directory being read would be read back as a snapshot on the next run
+ * (the envelope is not a `graph` snapshot, which `parseBaseline` refuses) —
+ * poison the record loudly refused rather than quietly planted. `null`
+ * means no refusal.
+ *
+ * @param {{output: string|null, paths: string[]}} options This run's parsed
+ *   flags; `paths[0]` is the history directory.
+ * @param {string} cwd The run's working directory, for relative flag
+ *   resolution.
+ * @returns {string|null} The refusal message, or `null` when the output is
+ *   safe.
+ */
+export function trajectoryOutputRefusal(options, cwd) {
+  if (!options.output) return null;
+  const dir = isAbsolute(options.paths[0])
+    ? resolve(options.paths[0])
+    : resolve(cwd, options.paths[0]);
+  const outputAbs = isAbsolute(options.output)
+    ? resolve(options.output)
+    : resolve(cwd, options.output);
+  if (dirname(outputAbs) === dir) {
+    return (
+      `archkeep: --output '${options.output}' is inside the history directory '${dir}' — ` +
+      `writing the report there would be read back as a snapshot on the next run. ` +
+      `Write it somewhere else.`
+    );
+  }
+  return null;
+}

package/src/commands/waivers.mjs

@@ -44,11 +44,13 @@ import { isWaiver, remainingMs, waiverStatus } from "../governance/waiver.mjs";
 import { coverageRefusal, coverageVerdict } from "./coverage-verdict.mjs";
 import { jsonEnvelope, renderJson } from "../report/json.mjs";
 import { formatWaiversReport } from "../report/waivers-text.mjs";
+import { resolveCommandContext } from "./context.mjs";
 import { partitionUnownedCoverage } from "./coverage-acceptance.mjs";
 import { unownedGapWithoutRunConfiguration } from "./context.mjs";
 import { refuseIncompleteGraph } from "./drift.mjs";
 import { resolveProvenance } from "./provenance.mjs";
 import { evaluateRun } from "../rules/index.mjs";
+import { resolvePolicy } from "./policy.mjs";
 
 /**
  * The waivers verdict for a run: every waiver with its term and what it
@@ -296,3 +298,31 @@ export async function waiversCommand(commandContext, boundaryConfig, io = {}) {
     },
   };
 }
+
+/**
+ * `waivers` as the CLI drives it: the shared preamble — command context,
+ * then the boundary law — resolved here so `../../cli.mjs`'s driver only
+ * wires options, IO seams, and where output lands (`./README.md`). The
+ * engine this returns from is `waiversCommand` above, unchanged.
+ *
+ * @param {{config: string|null, paths: string[]}} options This run's parsed
+ *   flags.
+ * @param {{cwd: string, readGraph?: Function, listFiles?: Function}} io The
+ *   seams a test injects, the same ones `check` takes.
+ * @returns {Promise<object>} `waiversCommand`'s result, unmodified.
+ */
+export async function waivers(options, { cwd, readGraph, listFiles }) {
+  const commandContext = resolveCommandContext({ cwd }, { readGraph, listFiles });
+  // The waivers surface is part of the run's boundary law, so the law is
+  // loaded the same way `check` loads it (`resolvePolicy`) and `--config`
+  // wins the same way — resolved against the working directory, never
+  // against this tool's own location, and a `profiles` registry resolves
+  // `--config`/`boundaryConfig` as a profile NAME the same way `check`
+  // does. A malformed law throws here, exit 3, exactly as in `check`.
+  const { config, source } = await resolvePolicy(options, commandContext, cwd);
+  // `source` rides along for one job: `waiversCommand` subtracts the law's
+  // own file from the unowned-file set the `coverage.unowned` acceptances
+  // are matched against, exactly as `check` does — the law is not source
+  // judged by the law (`./context.mjs`'s `unownedGapWithoutRunConfiguration`).
+  return waiversCommand(commandContext, config, { policySource: source });
+}

package/src/corpus/goldens/adr.json

@@ -0,0 +1,62 @@
+{
+  "schemaVersion": 2,
+  "tool": {
+    "name": "@ecoma-io/archkeep",
+    "version": "0.26.0"
+  },
+  "command": "adr",
+  "workspace": {
+    "root": "/tmp/archkeep-golden-fixture",
+    "provider": "native",
+    "marker": "docs/adr",
+    "provenance": null
+  },
+  "status": "ok",
+  "exitCode": 0,
+  "coverage": {
+    "complete": true,
+    "projects": 0,
+    "analyzedFiles": 1,
+    "imports": 0,
+    "notAnalyzed": [],
+    "blindSpots": [],
+    "notes": []
+  },
+  "result": {
+    "adrs": [
+      "0001-layers"
+    ],
+    "registry": {
+      "dir": "docs/adr",
+      "count": 1
+    },
+    "statuses": [
+      {
+        "id": "0001-layers",
+        "status": "accepted"
+      }
+    ],
+    "bindings": [
+      {
+        "adr": "0001-layers",
+        "binding": "intentForbiddenEdge"
+      }
+    ],
+    "supersedes": [],
+    "supersededBy": [],
+    "fitness": [
+      {
+        "id": "0001-layers",
+        "status": "accepted",
+        "level": "unverifiable",
+        "verified": false,
+        "reason": "no bound constraint for 0001-layers resolves or was evaluated — none can be verified"
+      }
+    ],
+    "unresolved": [],
+    "knownFitness": [
+      "intentForbiddenEdge"
+    ]
+  }
+}
+

package/src/corpus/goldens/adr.text

@@ -0,0 +1,6 @@
+0001-layers  (accepted)
+-----------------------
+bindings:   intentForbiddenEdge
+fitness:      unverifiable — no bound constraint for 0001-layers resolves or was evaluated — none can be verified
+status set: proposed, accepted, active, superseded, retired
+

package/src/corpus/goldens/change.json

@@ -0,0 +1,98 @@
+{
+  "schemaVersion": 2,
+  "tool": {
+    "name": "@ecoma-io/archkeep",
+    "version": "0.26.0"
+  },
+  "command": "change",
+  "workspace": {
+    "root": "/tmp/archkeep-golden-fixture",
+    "provider": "native",
+    "marker": "archkeep.json",
+    "provenance": {
+      "commit": "1fd51709c377d99a6139891e1200291cf08aede9",
+      "remote": null,
+      "dirty": false
+    }
+  },
+  "status": "ok",
+  "exitCode": 0,
+  "coverage": {
+    "complete": true,
+    "projects": 3,
+    "analyzedFiles": 3,
+    "imports": 2,
+    "notAnalyzed": [],
+    "blindSpots": [],
+    "notes": []
+  },
+  "result": {
+    "intent": {
+      "file": "/tmp/archkeep-golden-fixture/.archkeep-change.json",
+      "version": "1",
+      "base": {
+        "commit": "1fd51709c377d99a6139891e1200291cf08aede9"
+      },
+      "declared": {
+        "projectsAdd": 0,
+        "projectsRemove": 0,
+        "edgesAdd": 0,
+        "edgesRemove": 0,
+        "constraints": []
+      }
+    },
+    "baseline": {
+      "path": "/tmp/archkeep-golden-fixture/.archkeep-delta.json",
+      "tool": {
+        "name": "@ecoma-io/archkeep",
+        "version": "0.26.0"
+      },
+      "provider": "native",
+      "provenance": {
+        "commit": "1fd51709c377d99a6139891e1200291cf08aede9",
+        "dirty": false,
+        "remote": null
+      },
+      "policyFingerprint": "e18ba4307f6baaaa0d558822327788e8925cb3c52dfac6b170ce4d89b5a728ca",
+      "projects": 3,
+      "records": 2
+    },
+    "head": {
+      "provenance": {
+        "commit": "1fd51709c377d99a6139891e1200291cf08aede9",
+        "remote": null,
+        "dirty": false
+      },
+      "policyFingerprint": "e18ba4307f6baaaa0d558822327788e8925cb3c52dfac6b170ce4d89b5a728ca",
+      "projects": 3
+    },
+    "reconciliation": {
+      "verdict": "matched",
+      "reasons": [],
+      "matched": [],
+      "unexpected": [],
+      "missingExpected": []
+    },
+    "constraints": [],
+    "policy": {
+      "fingerprint": "e18ba4307f6baaaa0d558822327788e8925cb3c52dfac6b170ce4d89b5a728ca",
+      "changedSinceBase": false,
+      "liveViolations": 0
+    },
+    "classifications": [],
+    "affected": {
+      "projects": [],
+      "boundaries": [],
+      "constraints": [],
+      "decisions": []
+    },
+    "debt": {
+      "introduced": [],
+      "resolved": []
+    }
+  },
+  "decision": {
+    "verdict": "pass"
+  }
+}
+

package/src/corpus/goldens/change.text

@@ -0,0 +1,6 @@
+intent     /tmp/archkeep-golden-fixture/.archkeep-change.json — base 1fd51709
+baseline   /tmp/archkeep-golden-fixture/.archkeep-delta.json — 1fd51709, 2 records, 3 projects
+head       1fd51709, 3 projects
+reconciliation ✔ MATCHED — the delta is exactly the declared change
+workspace law  0 live violations under the current law — informational; archkeep check remains the authoritative verdict
+reconciled 0 declared changes and 0 declared constraints — base 1fd51709 (3 projects, 2 records) against head 1fd51709 (3 projects)