@ecoma-io/archkeep 0.19.0 → 0.20.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecoma-io/archkeep",
-  "version": "0.19.0",
+  "version": "0.20.1",
   "description": "Architecture enforcement for polyglot repositories — dependency graphs and module boundaries for Go, Rust, Python, TypeScript, JavaScript, Vue, Java and Kotlin",
   "keywords": [
     "architecture",

package/src/commands/impact-statement.mjs

@@ -53,13 +53,25 @@ import { isComboDepConstraint } from "../rules/tags.mjs";
  * @property {object[]} [constraintImpact] Per-dependent edge constraint
  *   analysis. Present only when a boundary config was provided.
  * @property {{decisions: object[], unresolvedDecisionRefs: string[]}} [decisionImpact]
- *   Which recorded decisions bind the affected constraint rows. Present only
- *   when a boundary config with `depConstraints` was provided.
+ *   Which recorded decisions bind the affected constraint rows. Each decision
+ *   carries an `evidence` field tracing the causal chain: which constraint
+ *   row index and which dependent project triggered the binding.
+ *   Present only when a boundary config with `depConstraints` was provided.
  * @property {{projects: string[], boundaries: string[], constraints: string[],
  *   decisions: string[]}} [evolutionAlignment] The `affected` shape matching
  *   `EvolutionEvent.affected` vocabulary.
+ * @property {{evaluated: boolean, entries: object[], note: string|null}} findingsImpact
+ *   Findings that affect the impacted projects. `evaluated: false` when no
+ *   findings data was provided — reported as a gap, never as "no findings".
+ * @property {{evaluated: boolean, entries: object[], note: string|null}} debtImpact
+ *   Debt entries that affect the impacted projects. `evaluated: false` when no
+ *   debt data was provided — reported as a gap, never as "no debt".
+ * @property {{boundaries: object[], evaluated: boolean}} boundaryImpact
+ *   Boundary-crossing analysis for each affected edge. `evaluated: false` when
+ *   no constraint impact was available.
  * @property {boolean} complete Whether the statement could be fully composed.
- * @property {string[]} notes Caveats about statement completeness.
+ * @property {string[]} notes Caveats about statement completeness and
+ *   governance gaps.
  */
 
 /**
@@ -103,17 +115,41 @@ function buildDecisionImpact(root, constraintImpact, config) {
   const seenRefs = new Set();
   const affectedRefs = [];
 
+  // Build evidence map: decisionRef -> { constraintRows, dependentProjects }
+  /** @type {Map<string, {constraintRows: number[], dependentProjects: string[]}>} */
+  const evidenceByRef = new Map();
+
   if (constraintImpact && config && config.depConstraints) {
     // Use identity matching: constraintImpact.constraintRows are the actual
     // config row objects returned by findConstraintsFor — check by reference,
     // not by string label, for exact causal binding.
-    const activeRows = new Set(constraintImpact.flatMap((entry) => entry.constraintRows));
+    for (const entry of constraintImpact) {
+      const activeRows = new Set(entry.constraintRows);
+      const sourceProject = entry.project;
+
+      for (let i = 0; i < config.depConstraints.length; i++) {
+        const row = config.depConstraints[i];
+        if (!row.decisionRef) continue;
+        if (!activeRows.has(row)) continue;
 
-    for (const row of config.depConstraints) {
-      if (!row.decisionRef) continue;
-      if (activeRows.has(row) && !seenRefs.has(row.decisionRef)) {
-        seenRefs.add(row.decisionRef);
-        affectedRefs.push(row.decisionRef);
+        if (!evidenceByRef.has(row.decisionRef)) {
+          evidenceByRef.set(row.decisionRef, {
+            constraintRows: [],
+            dependentProjects: [],
+          });
+        }
+        const evidence = evidenceByRef.get(row.decisionRef);
+        if (!evidence.constraintRows.includes(i)) {
+          evidence.constraintRows.push(i);
+        }
+        if (!evidence.dependentProjects.includes(sourceProject)) {
+          evidence.dependentProjects.push(sourceProject);
+        }
+
+        if (!seenRefs.has(row.decisionRef)) {
+          seenRefs.add(row.decisionRef);
+          affectedRefs.push(row.decisionRef);
+        }
       }
     }
   }
@@ -139,6 +175,7 @@ function buildDecisionImpact(root, constraintImpact, config) {
 
   for (const ref of affectedRefs) {
     const resolved = resolveDecision(ref, byId, knownFitness);
+    const evidence = evidenceByRef.get(ref);
 
     if (resolved.resolution === "unknown") {
       unresolvedDecisionRefs.push(ref);
@@ -152,6 +189,7 @@ function buildDecisionImpact(root, constraintImpact, config) {
         id: ref,
         kind: "fitness",
         resolution: "known",
+        evidence,
       });
       continue;
     }
@@ -165,6 +203,7 @@ function buildDecisionImpact(root, constraintImpact, config) {
       hasAuthority: hasAuthority(record.status),
       supersedes: record.supersedes.length > 0 ? record.supersedes : undefined,
       supersededBy: (record.supersededBy ?? []).length > 0 ? record.supersededBy : undefined,
+      evidence,
     });
   }
 
@@ -219,6 +258,167 @@ function buildEvolutionAlignment(projectName, impact, constraintImpact, resolved
   };
 }
 
+// ---------------------------------------------------------------------------
+// Findings and Debt impact (governance integration)
+// ---------------------------------------------------------------------------
+
+/**
+ * Evaluates findings impact for the affected projects.
+ *
+ * When no findings data is provided, reports the gap explicitly rather than
+ * claiming no findings exist.
+ *
+ * @param {string[]} affectedProjects The projects affected by the change.
+ * @param {object[]|null} [availableFindings] Optional pre-computed findings
+ *   from the check pipeline.
+ * @returns {{evaluated: boolean, entries: object[], note: string|null}}
+ *   `evaluated: true` when findings data was available and filtered.
+ *   `evaluated: false` when findings were not provided.
+ */
+function evaluateFindingsImpact(affectedProjects, availableFindings = null) {
+  if (!availableFindings) {
+    return {
+      evaluated: false,
+      entries: [],
+      note: "findings impact not evaluated — no findings data provided to impact statement",
+    };
+  }
+
+  // Filter findings by affected projects
+  const affectedSet = new Set(affectedProjects);
+  const entries = availableFindings.filter((f) => {
+    const source = f.source ?? f.project ?? "";
+    const target = f.target ?? "";
+    return affectedSet.has(source) || affectedSet.has(target);
+  });
+
+  return {
+    evaluated: true,
+    entries,
+    note:
+      entries.length > 0
+        ? `${entries.length} finding(s) affect impacted projects`
+        : "no findings affect impacted projects",
+  };
+}
+
+/**
+ * Evaluates debt impact for the affected projects.
+ *
+ *
+ * Debt entries have `source` as either a project name (for drift entries) or
+ * a file path (for waiver entries). When a `resolveProject` function is
+ * provided, file-path sources are resolved to project names for matching.
+ * When no debt data is provided, reports the gap explicitly rather than
+ * claiming no debt exists.
+ *
+ * @param {string[]} affectedProjects The projects affected by the change.
+ * @param {object[]|null} [availableDebt] Optional pre-computed debt entries
+ *   from the debt ledger (`computeDebtLedger().entries`).
+ * @param {function(string): string|null} [resolveProject] Optional function
+ *   to resolve a file path to its owning project name. Used for waiver entries
+ *   whose `source` is a file path, not a project name.
+ * @returns {{evaluated: boolean, entries: object[], note: string|null}}
+ *   `evaluated: true` when debt data was available and filtering was attempted.
+ *   `evaluated: false` when debt was not provided.
+ */
+function evaluateDebtImpact(affectedProjects, availableDebt = null, resolveProject = null) {
+  if (!availableDebt) {
+    return {
+      evaluated: false,
+      entries: [],
+      note: "debt impact not evaluated — no debt data provided to impact statement",
+    };
+  }
+
+  // Filter debt entries by affected projects.
+  // Debt entries use `source` as either a project name (drift, unresolved) or
+  // a file path (waiver, expired-waiver). For path-based sources, use the
+  // resolveProject function when available.
+  const affectedSet = new Set(affectedProjects);
+  const entries = availableDebt.filter((d) => {
+    // Drift and unresolved entries have source = project name directly
+    if (d.kind === "drift" || d.kind === "unresolved") {
+      return affectedSet.has(d.source ?? "");
+    }
+    // Waiver entries have source = file path; resolve via owning project
+    if (d.kind === "waiver" || d.kind === "expired-waiver") {
+      if (typeof resolveProject === "function") {
+        const project = resolveProject(d.source ?? "");
+        return project !== null && affectedSet.has(project);
+      }
+      // Without resolveProject, we cannot match path-based sources
+      return false;
+    }
+    // Aspirational-gap entries have source = note text — no project match
+    return false;
+  });
+
+  return {
+    evaluated: true,
+    entries,
+    note:
+      entries.length > 0
+        ? `${entries.length} debt entry(ies) affect impacted projects`
+        : "no debt entries affect impacted projects",
+  };
+}
+
+/**
+ * Evaluates boundary impact: which boundary tags/layers are crossed by the
+ * affected edges.
+ *
+ * Unlike `evolutionAlignment.boundaries` which collects edge identities, this
+ * evaluates whether the change crosses meaningful governance boundaries (e.g.
+ * layer transitions, scope crossings).
+ *
+ * @param {object} graph The project graph.
+ * @param {object[]} constraintImpact Per-dependent constraint analysis.
+ * @param {string} targetProject The target of the impact analysis.
+ * @returns {{boundaries: object[], evaluated: boolean}}
+ */
+function evaluateBoundaryImpact(graph, constraintImpact, targetProject) {
+  if (!constraintImpact || constraintImpact.length === 0) {
+    return { boundaries: [], evaluated: false };
+  }
+
+  const targetNode = graph.nodes[targetProject];
+  const targetTags = targetNode?.data?.tags ?? [];
+  const boundaries = [];
+
+  for (const entry of constraintImpact) {
+    const sourceTags = graph.nodes[entry.project]?.data?.tags ?? [];
+
+    for (const edge of entry.edges) {
+      // Determine if this edge crosses a layer boundary
+      const sourceLayer = sourceTags.find((t) => t.startsWith("layer:"));
+      const targetLayer = targetTags.find((t) => t.startsWith("layer:"));
+      const crossesLayer = sourceLayer && targetLayer && sourceLayer !== targetLayer;
+
+      // Determine if this edge crosses a scope boundary
+      const sourceScope = sourceTags.find((t) => t.startsWith("scope:"));
+      const targetScope = targetTags.find((t) => t.startsWith("scope:"));
+      const crossesScope = sourceScope && targetScope && sourceScope !== targetScope;
+
+      // Determine if any constraint row governs this edge
+      const violated = entry.violations?.length > 0;
+      const governingRowCount = entry.constraintRows?.length ?? 0;
+
+      boundaries.push({
+        source: entry.project,
+        target: edge.target,
+        type: edge.type,
+        crossesLayer,
+        crossesScope,
+        violated,
+        governingConstraintRows: governingRowCount,
+      });
+    }
+  }
+
+  return { boundaries, evaluated: true };
+}
+
 /**
  * Composes the full Impact Statement for a project.
  *
@@ -227,11 +427,17 @@ function buildEvolutionAlignment(projectName, impact, constraintImpact, resolved
  *   root, provider, etc.).
  * @param {object|null} [config] The loaded boundary config. When provided,
  *   constraint and decision impact are computed.
+ * @param {object} [options] Optional data for governance integration.
+ * @param {object[]|null} [options.findings] Pre-computed findings from the
+ *   check pipeline. When null, findings impact is reported as not evaluated.
+ * @param {object[]|null} [options.debt] Pre-computed debt entries from the
+ *   debt ledger. When null, debt impact is reported as not evaluated.
  * @returns {ImpactStatement}
  * @throws {import("../errors.mjs").UsageError} When the project is not in the graph.
  */
-export function composeImpactStatement(projectName, commandContext, config = null) {
+export function composeImpactStatement(projectName, commandContext, config = null, options = {}) {
   const { root, graph } = commandContext;
+  const { findings: availableFindings = null, debt: availableDebt = null } = options;
 
   // Step 1: Reverse reachability (existing primitive)
   const impact = computeImpact(projectName, graph);
@@ -248,7 +454,7 @@ export function composeImpactStatement(projectName, commandContext, config = nul
     );
   }
 
-  // Step 3: Decision impact
+  // Step 3: Decision impact (with evidence)
   let decisionImpact = null;
   if (constraintImpact) {
     decisionImpact = buildDecisionImpact(root, constraintImpact, config);
@@ -263,7 +469,15 @@ export function composeImpactStatement(projectName, commandContext, config = nul
     resolvedDecisions,
   );
 
-  // Step 5: Assemble the statement with coverage notes
+  // Step 5: Boundary impact evaluation
+  const boundaryImpact = evaluateBoundaryImpact(graph, constraintImpact, projectName);
+
+  // Step 6: Findings and Debt impact evaluation
+  const affectedProjects = [projectName, ...impact.dependents];
+  const findingsImpact = evaluateFindingsImpact(affectedProjects, availableFindings);
+  const debtImpact = evaluateDebtImpact(affectedProjects, availableDebt);
+
+  // Step 7: Assemble the statement with evidence and coverage notes
   const notes = [];
 
   if (config && config.depConstraints) {
@@ -274,10 +488,19 @@ export function composeImpactStatement(projectName, commandContext, config = nul
     );
   }
 
-  notes.push(
-    "finding and debt impact are not yet evaluated. " +
-      "The impact statement covers dependency structure and constraint violations only.",
-  );
+  if (!findingsImpact.evaluated) {
+    notes.push(
+      "finding impact not evaluated — no findings data provided to impact statement. " +
+        "Pass findings data for complete governance evaluation.",
+    );
+  }
+
+  if (!debtImpact.evaluated) {
+    notes.push(
+      "debt impact not evaluated — no debt data provided to impact statement. " +
+        "Pass debt data for complete governance evaluation.",
+    );
+  }
 
   const statement = {
     project: impact.project,
@@ -287,6 +510,9 @@ export function composeImpactStatement(projectName, commandContext, config = nul
       dependents: impact.dependents,
     },
     evolutionAlignment,
+    findingsImpact,
+    debtImpact,
+    boundaryImpact,
     complete: true,
     notes,
   };

package/src/commands/scenario-evaluation.mjs

@@ -36,6 +36,7 @@ import { computeImpactConstraints } from "./edge-constraints.mjs";
 import { readAdrContext } from "./adr.mjs";
 import { hasAuthority, resolveDecisionRef, stripAdrPrefix } from "../governance/adr-registry.mjs";
 import { isComboDepConstraint } from "../rules/tags.mjs";
+import { execSync } from "node:child_process";
 
 // ---------------------------------------------------------------------------
 // Scenario types
@@ -57,26 +58,41 @@ export const SCENARIO_CHANGE_TYPES = Object.freeze(["dependency_added", "depende
 
 /**
  * @typedef {object} ScenarioInput
- * @property {string} [base] Optional git revision for attribution.
+ * @property {string} [base] Optional git revision for attribution. When not
+ *   provided, resolved from `git rev-parse HEAD`.
  * @property {DependencyChange[]} changes The hypothetical changes to evaluate.
  */
 
 // ---------------------------------------------------------------------------
 // Output types
 // ---------------------------------------------------------------------------
-
 /**
  * @typedef {object} ScenarioEvaluation
  * @property {boolean} virtual Always true — a scenario is never authoritative.
  * @property {boolean} notAuthoritative Always true — mirrors `virtual`.
  * @property {string} project The target project being evaluated.
  * @property {object} base The base graph information.
+ * @property {string} base.revision The git revision or snapshot identity.
+ * @property {boolean} base.attributed Whether the base is a real, verifiable revision.
+ * @property {string} base.provenance How the base was determined (user-provided, auto-resolved, or unverifiable).
  * @property {string[]} changes The change descriptions that were applied.
  * @property {string[]|undefined} refused Changes that could not be applied, if any.
  * @property {object} current The current impact for the target project.
  * @property {object} scenario The would-be impact after applying the changes.
  * @property {object} delta What would change.
- * @property {boolean} complete Whether the evaluation could be completed.
+ * @property {object} [evidenceChain] The provenance chain: base → changes → re-evaluated → delta.
+ * @property {string} evidenceChain.baseRevision The revision the scenario started from.
+ * @property {string[]} evidenceChain.appliedChanges The changes applied to the base.
+ * @property {string} evidenceChain.currentState The state before applying changes ("current").
+ * @property {string} evidenceChain.scenarioState The state after applying changes ("scenario").
+ * @property {object} evidenceChain.delta The computed differences.
+ * @property {object} [governanceImpact] Governance re-evaluation results.
+ * @property {boolean} governanceImpact.findingsReEvaluated Whether findings were re-evaluated.
+ * @property {boolean} governanceImpact.debtReEvaluated Whether debt was re-evaluated.
+ * @property {boolean} governanceImpact.governanceComplete Whether all governance data was provided.
+ * @property {number} governanceImpact.scenarioFindingsCount Number of findings in the scenario state.
+ * @property {number} governanceImpact.scenarioDebtCount Number of debt entries in the scenario state.
+ * @property {boolean} complete Whether the evaluation could be fully completed.
  * @property {string[]} notes Caveats about the evaluation.
  */
 
@@ -311,6 +327,51 @@ function computeDelta(current, scenario) {
     decisionsChanged,
   };
 }
+/**
+ * Resolves the base revision for a scenario evaluation.
+ *
+ * When the user provides a `base` string, it is used as-is and marked as
+ * attributed. When no base is provided, we attempt to resolve from
+ * `git rev-parse HEAD`. If that fails, we report the gap rather than
+ * fabricating a revision.
+ *
+ * @param {string} root The workspace root.
+ * @param {string|undefined} userBase The user-provided base (optional).
+ * @returns {{revision: string, attributed: boolean, provenance: string}}
+ */
+function resolveBaseRevision(root, userBase) {
+  if (typeof userBase === "string" && userBase.length > 0) {
+    return {
+      revision: userBase,
+      attributed: true,
+      provenance: "user-provided",
+    };
+  }
+
+  // Attempt to resolve from git
+  try {
+    const revision = execSync("git rev-parse HEAD", {
+      cwd: root,
+      encoding: "utf8",
+      timeout: 5000,
+    }).trim();
+    if (revision && revision.length === 40) {
+      return {
+        revision,
+        attributed: true,
+        provenance: "auto-resolved: git rev-parse HEAD",
+      };
+    }
+  } catch {
+    // Fall through to unverifiable
+  }
+
+  return {
+    revision: "(unattributed workspace)",
+    attributed: false,
+    provenance: "unverifiable — git rev-parse HEAD failed or not a git repository",
+  };
+}
 
 /**
  * Evaluates a scenario against the current workspace.
@@ -319,12 +380,27 @@ function computeDelta(current, scenario) {
  * @param {object} commandContext The resolved command context.
  * @param {ScenarioInput} scenarioInput The scenario description.
  * @param {object|null} [config] The loaded boundary config.
+ * @param {object} [options] Optional data for governance integration.
+ * @param {object[]|null} [options.findings] Pre-computed findings for
+ *   governance re-evaluation on the hypothetical graph.
+ * @param {object[]|null} [options.debt] Pre-computed debt entries for
+ *   governance re-evaluation.
  * @returns {ScenarioEvaluation}
  */
-export function evaluateScenario(projectName, commandContext, scenarioInput, config = null) {
+export function evaluateScenario(
+  projectName,
+  commandContext,
+  scenarioInput,
+  config = null,
+  options = {},
+) {
   const { root, graph } = commandContext;
+  const { findings: availableFindings = null, debt: availableDebt = null } = options;
+
+  // Step 1: Resolve base revision (real attribution)
+  const base = resolveBaseRevision(root, scenarioInput.base);
 
-  // Step 1: Compute current impact
+  // Step 2: Compute current impact
   const currentImpact = computeImpact(projectName, graph);
 
   let currentConstraintImpact = null;
@@ -338,10 +414,10 @@ export function evaluateScenario(projectName, commandContext, scenarioInput, con
     );
   }
 
-  // Step 2: Apply scenario changes to the graph
+  // Step 3: Apply scenario changes to the graph
   const { graph: scenarioGraph, applied, refused } = applyChanges(graph, scenarioInput.changes);
 
-  // Step 3: Compute scenario impact
+  // Step 4: Compute scenario impact
   const scenarioImpact = computeImpact(projectName, scenarioGraph);
 
   let scenarioConstraintImpact = null;
@@ -355,7 +431,7 @@ export function evaluateScenario(projectName, commandContext, scenarioInput, con
     );
   }
 
-  // Step 4: Build decision impact for both sides
+  // Step 5: Build decision impact for both sides
   const currentDecisionImpact = buildScenarioDecisionImpact(root, currentConstraintImpact, config);
   const scenarioDecisionImpact = buildScenarioDecisionImpact(
     root,
@@ -363,7 +439,7 @@ export function evaluateScenario(projectName, commandContext, scenarioInput, con
     config,
   );
 
-  // Step 5: Build evolution alignment for both sides
+  // Step 6: Build evolution alignment for both sides
   const currentResolved = currentDecisionImpact
     ? currentDecisionImpact.decisions.map((d) => d.id)
     : [];
@@ -384,7 +460,7 @@ export function evaluateScenario(projectName, commandContext, scenarioInput, con
     scenarioResolved,
   );
 
-  // Step 6: Compute delta
+  // Step 7: Compute delta
   const currentState = {
     impact: currentImpact,
     constraintImpact: currentConstraintImpact,
@@ -397,7 +473,44 @@ export function evaluateScenario(projectName, commandContext, scenarioInput, con
   };
   const delta = computeDelta(currentState, scenarioState);
 
-  // Step 7: Build notes — coverage and completeness
+  // Step 8: Build evidence chain
+  const evidenceChain = {
+    baseRevision: base.revision,
+    appliedChanges: applied,
+    currentState: "current",
+    scenarioState: "scenario",
+    delta: {
+      dependentsAdded: delta.dependentsAdded,
+      dependentsRemoved: delta.dependentsRemoved,
+      constraintsChanged: delta.constraintsChanged,
+      decisionsChanged: delta.decisionsChanged,
+    },
+  };
+
+  // Step 9: Evaluate governance impact on scenario (hypothetical re-evaluation)
+  const scenarioAffectedProjects = [projectName, ...scenarioImpact.dependents];
+  let scenarioFindings = null;
+  let scenarioDebt = null;
+  if (availableFindings) {
+    // Re-filter findings for the hypothetical graph's affected projects
+    const affectedSet = new Set(scenarioAffectedProjects);
+    scenarioFindings = availableFindings.filter((f) => {
+      const source = f.source ?? f.project ?? "";
+      const target = f.target ?? "";
+      return affectedSet.has(source) || affectedSet.has(target);
+    });
+  }
+  if (availableDebt) {
+    const affectedSet = new Set(scenarioAffectedProjects);
+    scenarioDebt = availableDebt.filter((d) => {
+      if (d.kind === "drift" || d.kind === "unresolved") {
+        return affectedSet.has(d.source ?? "");
+      }
+      return false;
+    });
+  }
+
+  // Step 10: Build notes — coverage and completeness
   const notes = [
     "virtual evaluation — not authoritative",
     "this scenario has not been committed; run `check` for the real verdict",
@@ -408,31 +521,36 @@ export function evaluateScenario(projectName, commandContext, scenarioInput, con
         "A project with no violations here may still violate other rules.",
     );
   }
-  notes.push(
-    "finding and debt impact are not yet evaluated. " +
-      "The scenario covers dependency structure and constraint violations only.",
-  );
+  if (!availableFindings) {
+    notes.push(
+      "finding impact not re-evaluated — no findings data provided to scenario. " +
+        "Pass findings data for complete governance re-evaluation.",
+    );
+  }
+  if (!availableDebt) {
+    notes.push(
+      "debt impact not re-evaluated — no debt data provided to scenario. " +
+        "Pass debt data for complete governance re-evaluation.",
+    );
+  }
   if (refused.length > 0) {
     notes.push(`changes that could not be applied: ${refused.join("; ")}`);
   }
-  // Step 8: Assemble — determine provenance and completeness semantics
-  // Determine provenance: base is attributable only when a real revision was provided
-  const baseRevision = scenarioInput.base ?? "(current workspace)";
-  const isAttributed = typeof scenarioInput.base === "string" && scenarioInput.base.length > 0;
-
-  // Complete means all changes were applied AND all required evaluations completed
+  // Step 11: Assemble — determine provenance and completeness semantics
+  // `complete` reflects whether the core evaluation (graph + constraints)
+  // completed. `governanceComplete` tracks whether governance dimensions
+  // were fully evaluated.
+  const governanceComplete = availableFindings !== null && availableDebt !== null;
   const isComplete = refused.length === 0;
 
   return {
     virtual: true,
     notAuthoritative: true,
     project: projectName,
-    base: {
-      revision: baseRevision,
-      attributed: isAttributed,
-    },
+    base,
     changes: applied,
     refused: refused.length > 0 ? refused : undefined,
+    evidenceChain,
     current: {
       impact: {
         project: currentImpact.project,
@@ -454,6 +572,15 @@ export function evaluateScenario(projectName, commandContext, scenarioInput, con
       constraintImpact: scenarioConstraintImpact,
       decisionImpact: scenarioDecisionImpact,
       evolutionAlignment: scenarioEvolution,
+      ...(scenarioFindings !== null ? { findings: scenarioFindings } : {}),
+      ...(scenarioDebt !== null ? { debt: scenarioDebt } : {}),
+    },
+    governanceImpact: {
+      findingsReEvaluated: availableFindings !== null,
+      debtReEvaluated: availableDebt !== null,
+      governanceComplete,
+      scenarioFindingsCount: scenarioFindings?.length ?? 0,
+      scenarioDebtCount: scenarioDebt?.length ?? 0,
     },
     delta,
     complete: isComplete,

package/src/commands/scenario.mjs

@@ -87,6 +87,8 @@ export function scenarioCommand(projectName, scenarioJson, commandContext, confi
     refused: scenario.refused,
     current: scenario.current,
     scenario: scenario.scenario,
+    governanceImpact: scenario.governanceImpact,
+    evidenceChain: scenario.evidenceChain,
     delta: scenario.delta,
     notes: scenario.notes,
   };