@codyswann/lisa 4.74.0 → 4.74.2

package/expo/copy-overwrite/scripts/bdd/projection-render.mjs

@@ -0,0 +1,303 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Static entrypoints and deterministic feature-local document rendering. */
+import { byCodeUnit } from "./contract.mjs";
+import { cell } from "./markdown-cell.mjs";
+import {
+  featureArtifactPaths,
+  FEATURE_PROJECTION_SCHEMA,
+} from "./projection-paths.mjs";
+
+export const PROJECTION_INDEX_SCHEMA = "lisa-bdd-projection-index-v1";
+export const MATRIX_COMMAND =
+  'BDD_BASE_SHA="$(git merge-base HEAD origin/HEAD)" bun run bdd:matrix';
+export const COVERAGE_COMMAND =
+  'BDD_BASE_SHA="$(git merge-base HEAD origin/HEAD)" bun run bdd:coverage:write';
+export const REPORT_COMMAND =
+  'BDD_BASE_SHA="$(git merge-base HEAD origin/HEAD)" node scripts/check-bdd-coverage.mjs --report';
+export const AGGREGATE_MATRIX_COMMAND = "node scripts/bdd-matrix.mjs";
+const COMMAND_CONTEXT =
+  "The node scripts/... examples use installed host paths. In the Lisa monorepo, use BDD_COVERAGE_ROOT=. and the expo/copy-overwrite/scripts/ prefix instead; the coverage report still requires BDD_BASE_SHA.";
+
+/** Sort object properties recursively; retain meaningful ordered arrays. */
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (value === null || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.keys(value)
+      .sort(byCodeUnit)
+      .map(key => [key, stableValue(value[key])])
+  );
+}
+
+/** Complete records remain machine-readable without generation timestamps. */
+export const projectionJson = value =>
+  `${JSON.stringify(stableValue(value), null, 2)}\n`;
+
+/** Keep table data inert, including HTML, Markdown links and code delimiters. */
+export const projectionCell = value =>
+  cell(
+    String(value ?? "")
+      .replace(/&/g, "&")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/`/g, "&#96;")
+      .replace(/\[/g, "&#91;")
+      .replace(/\]/g, "&#93;")
+  );
+
+/** A bounded, encoded ownership marker cannot be terminated by source text. */
+export const projectionMarker = (sourceFile, kind) =>
+  `<!-- ${FEATURE_PROJECTION_SCHEMA} ${kind} source=${encodeURIComponent(sourceFile)} -->`;
+
+export const STATIC_ARTIFACTS = new Map([
+  [
+    "bdd/coverage-report.json",
+    projectionJson({
+      schemaVersion: PROJECTION_INDEX_SCHEMA,
+      generator: "lisa-bdd-feature-projection",
+      featureReports: "bdd/reports/v1/features/",
+      scenarioMatrices: "docs/bdd-scenario-matrix/",
+      coverageDocuments: "docs/e2e-bdd-coverage/",
+      sourceIdentity: "Full repository-relative bdd/features/*.feature path",
+      commandContext: COMMAND_CONTEXT,
+      commands: { matrix: MATRIX_COMMAND, coverage: COVERAGE_COMMAND },
+      aggregateCommands: {
+        matrix: AGGREGATE_MATRIX_COMMAND,
+        coverage: REPORT_COMMAND,
+      },
+      aggregate:
+        "The aggregate matrix displays declared mappings. The --report runtime report and feature leaves validate evidence resolution; CI publishes the global summary.",
+    }),
+  ],
+  [
+    "docs/bdd-scenario-matrix.md",
+    `# BDD scenario traceability matrix
+
+Generated by \`${MATRIX_COMMAND}\`; never hand-edited.
+
+Feature documents live under [bdd-scenario-matrix/](bdd-scenario-matrix/), using the complete repository-relative source path as their suffix. Their matching JSON records live under [../bdd/reports/v1/features/](../bdd/reports/v1/features/).
+
+Each document preserves its declarations, tracker references, mapped evidence and supplied execution outcomes. Traceability proves automation exists; it never proves that automation ran or passed. Waivers are never coverage.
+
+${COMMAND_CONTEXT}
+
+Run \`${AGGREGATE_MATRIX_COMMAND}\` for the current aggregate matrix. Its mapping cells display declared, configured mappings; they do not validate that each evidence title still exists. Evidence-resolution credit comes from the feature leaves and \`${REPORT_COMMAND}\`. CI publishes current global counts and the full runtime coverage summary. This entrypoint intentionally stores no feature list or global counts.
+`,
+  ],
+  [
+    "docs/e2e-bdd-coverage.md",
+    `# BDD behavior contract — coverage burndown
+
+Generated from \`bdd/features/*.feature\` and \`bdd/coverage-map.json\`.
+Regenerated by \`${COVERAGE_COMMAND}\`; never hand-edited.
+
+## What each number means
+
+Traceability coverage reports aligned mappings with evidence still present. **This is not execution coverage and not a pass rate.** Supplied execution outcomes remain separate. A waiver is an owned, dated IOU outside the obligation denominator; it is never coverage.
+
+Feature documents live under [e2e-bdd-coverage/](e2e-bdd-coverage/) with the complete source path as their suffix. Complete local records live under [../bdd/reports/v1/features/](../bdd/reports/v1/features/).
+
+${COMMAND_CONTEXT}
+
+Run \`${REPORT_COMMAND}\` for the current full runtime report. \`node scripts/check-bdd-coverage.mjs --report\` also emits diagnostic JSON, but can exit nonzero when a required baseline is absent or validation finds defects. CI publishes global counts, discovered-test inventory, floor evaluations and defects. Unassociated retirement records remain in \`bdd/coverage-map.json\`. This entrypoint intentionally stores no feature list or global counts.
+`,
+  ],
+]);
+
+/** Fixed headers keep author text exclusively inside escaped cells. */
+function table(headers, rows) {
+  const body = rows.length
+    ? rows.map(row => `| ${row.map(projectionCell).join(" | ")} |`).join("\n")
+    : `| ${headers.map(() => "—").join(" | ")} |`;
+  return `| ${headers.join(" | ")} |\n|${headers.map(() => "---").join("|")}|\n${body}`;
+}
+
+/** Preserve every mapped string and its genuine evidence verdict. */
+function mappingTable(scenarios) {
+  return table(
+    [
+      "Scenario",
+      "Runner",
+      "Platforms",
+      "File",
+      "Evidence",
+      "Evidence resolution",
+      "Execution",
+      "Run",
+    ],
+    scenarios.flatMap(row =>
+      row.mappings.map(mapping => [
+        row.id,
+        mapping.runner,
+        mapping.platforms.join(", "),
+        mapping.file,
+        mapping.evidence,
+        mapping.evidenceResolution.ok
+          ? "resolved"
+          : `invalid: ${mapping.evidenceResolution.detail}`,
+        mapping.execution.status,
+        mapping.execution.runId,
+      ])
+    )
+  );
+}
+
+/** Declaration facts include ordered primary steps and complete tag scopes. */
+function declarationTables(scenarios) {
+  return table(
+    [
+      "Scenario",
+      "Behavior",
+      "Feature",
+      "Source line",
+      "Platforms",
+      "Lifecycle",
+      "Tags",
+      "Steps",
+    ],
+    scenarios.map(row => [
+      row.id,
+      row.name,
+      row.feature,
+      row.line,
+      row.platforms.join(", "),
+      row.required ? "required" : row.lifecycle.join(", "),
+      row.tags.join(", "),
+      row.primarySteps.join("; "),
+    ])
+  );
+}
+
+/** Human-readable references remain separate from executable evidence. */
+function trackerTable(scenarios) {
+  return table(
+    ["Scenario", "Reference", "URL"],
+    scenarios.flatMap(row =>
+      row.trackers.map(reference => [
+        row.id,
+        reference.tag,
+        reference.url ?? "No URL template declared",
+      ])
+    )
+  );
+}
+
+/** Waiver compatibility retains the original seven-column contract. */
+function waiverSection(scenarios) {
+  const entries = scenarios.flatMap(row => row.waivers);
+  const ledger = table(
+    ["Scenario", "Platforms", "Runner", "Owner", "Reason", "Ticket", "Expires"],
+    entries.map(entry => [
+      entry.scenario,
+      Array.isArray(entry.platforms)
+        ? entry.platforms.join(", ")
+        : entry.platforms,
+      entry.runner,
+      entry.owner,
+      entry.reason,
+      entry.ticket,
+      entry.expiresAt,
+    ])
+  );
+  const dates = table(
+    ["Scenario", "Recorded at"],
+    entries.map(entry => [entry.scenario, entry.recordedAt])
+  );
+  return `${ledger}\n\nWaiver recording dates (complete records are retained in JSON):\n\n${dates}`;
+}
+
+/** Retirement fields stay readable; unrelated retirements remain input-owned. */
+function retirementTable(scenarios) {
+  return table(
+    ["Scenario", "Platforms", "Approved by", "Reason", "Ticket", "Recorded at"],
+    scenarios
+      .flatMap(row => row.retirements)
+      .map(entry => [
+        entry.scenario,
+        Array.isArray(entry.platforms)
+          ? entry.platforms.join(", ")
+          : entry.platforms,
+        entry.approvedBy,
+        entry.reason,
+        entry.ticket,
+        entry.recordedAt,
+      ])
+  );
+}
+
+/** Local obligations never claim execution credit or turn waivers into proof. */
+function obligationTable(scenarios) {
+  return table(
+    [
+      "Scenario",
+      "Platform",
+      "Configured runners",
+      "Traceability",
+      "Waived",
+      "Gap",
+    ],
+    scenarios.flatMap(row =>
+      row.obligations.map(value => [
+        row.id,
+        value.platform,
+        value.runners.join(", "),
+        value.covered ? "covered" : "uncovered",
+        value.waived ? "yes" : "no",
+        value.gap ? "yes" : "no",
+      ])
+    )
+  );
+}
+
+/** Both leaf documents carry the same local facts without a global roster. */
+function localDocument(model, kind) {
+  const title =
+    kind === "matrix"
+      ? "BDD scenario traceability matrix"
+      : "BDD behavior contract — feature coverage burndown";
+  return `${projectionMarker(model.sourceFile, kind)}
+# ${title}
+
+Source: ${projectionCell(model.sourceFile)}
+
+Traceability proves aligned automation exists, never that it ran or passed. A waiver is never coverage. Execution marked “not supplied” is unknown; “not run” means no supplied result matched this mapping. Retry outcomes retain the worst supplied result.
+
+## Declarations
+
+${declarationTables(model.scenarios)}
+
+## Tracker references
+
+${trackerTable(model.scenarios)}
+
+## Mapped evidence and execution
+
+${mappingTable(model.scenarios)}
+
+## Local obligations
+
+${obligationTable(model.scenarios)}
+
+## Waived obligations
+
+${waiverSection(model.scenarios)}
+
+## Associated retirements
+
+${retirementTable(model.scenarios)}
+
+The matching JSON leaf retains complete local declarations, mappings, waiver and retirement records. Current global inventory, counts, floor evaluations and defects are published by the runtime CI summary.
+`;
+}
+
+/** Render all three canonical leaves for one source identity. */
+export function renderFeatureArtifacts(model) {
+  const [json, matrix, coverage] = featureArtifactPaths(model.sourceFile);
+  return new Map([
+    [json, projectionJson(model)],
+    [matrix, localDocument(model, "matrix")],
+    [coverage, localDocument(model, "coverage")],
+  ]);
+}

package/expo/copy-overwrite/scripts/bdd/projection-write.mjs

@@ -0,0 +1,84 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Apply a preflighted ownership plan with no recursive deletions. */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomBytes } from "node:crypto";
+import {
+  inspectProjectionPath,
+  refuseProjection,
+} from "./projection-paths.mjs";
+import {
+  ownedFeatureLeaf,
+  prepareProjectionWrite,
+  validateProjectionTarget,
+} from "./projection-ownership.mjs";
+
+/** Create each missing parent only after the complete plan has passed. */
+function ensureParents(root, relative) {
+  const parts = relative.split("/").slice(0, -1);
+  for (let count = 1; count <= parts.length; count += 1) {
+    const directory = parts.slice(0, count).join("/");
+    if (!inspectProjectionPath(root, directory, "directory")) {
+      fs.mkdirSync(path.join(root, directory));
+    }
+  }
+}
+
+/** Refuse changed ownership before replacing an individually prepared target. */
+function checkUnchanged(root, entry) {
+  const previous = validateProjectionTarget(root, entry.relative, entry.body);
+  if (previous !== entry.previous)
+    refuseProjection(`target changed after preflight: ${entry.relative}`);
+}
+
+/** Exclusive same-directory temporaries avoid following or replacing foreign files. */
+function replaceLeaf(root, entry) {
+  ensureParents(root, entry.relative);
+  checkUnchanged(root, entry);
+  const absolute = path.join(root, entry.relative);
+  const temporary = `${absolute}.lisa-bdd-${randomBytes(12).toString("hex")}.tmp`;
+  let created = false;
+  try {
+    fs.writeFileSync(temporary, entry.body, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 0o644,
+    });
+    created = true;
+    checkUnchanged(root, entry);
+    fs.renameSync(temporary, absolute);
+    created = false;
+  } finally {
+    if (created) fs.unlinkSync(temporary);
+  }
+}
+
+/** Recheck the exact owned bytes before removing one obsolete regular leaf. */
+function removeObsolete(root, entry) {
+  if (!inspectProjectionPath(root, entry.relative)) {
+    refuseProjection(
+      `obsolete leaf changed after preflight: ${entry.relative}`
+    );
+  }
+  const absolute = path.join(root, entry.relative);
+  const body = fs.readFileSync(absolute, "utf8");
+  if (body !== entry.body || !ownedFeatureLeaf(entry.relative, body)) {
+    refuseProjection(
+      `obsolete ownership changed after preflight: ${entry.relative}`
+    );
+  }
+  fs.unlinkSync(absolute);
+}
+
+/** Return actual writes; a byte-identical repeat returns zero and touches nothing. */
+export function writeProjectionArtifacts(root, artifacts) {
+  const canonicalRoot = fs.realpathSync(root);
+  if (!fs.statSync(canonicalRoot).isDirectory())
+    refuseProjection("repository root is not a directory");
+  const plan = prepareProjectionWrite(canonicalRoot, artifacts);
+  for (const entry of plan.changed) replaceLeaf(canonicalRoot, entry);
+  for (const entry of plan.obsolete) removeObsolete(canonicalRoot, entry);
+  return plan.changed.length;
+}

package/expo/copy-overwrite/scripts/bdd/projection.mjs

@@ -0,0 +1,30 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Shared canonical writers emit one complete, feature-local projection set. */
+import { buildFeatureModels } from "./projection-model.mjs";
+import {
+  STATIC_ARTIFACTS,
+  renderFeatureArtifacts,
+} from "./projection-render.mjs";
+import { validateProjectionTargets } from "./projection-paths.mjs";
+import { writeProjectionArtifacts } from "./projection-write.mjs";
+
+export { FEATURE_PROJECTION_SCHEMA } from "./projection-paths.mjs";
+export { PROJECTION_INDEX_SCHEMA } from "./projection-render.mjs";
+
+/** Reads actual evidence; building the artifact map itself never writes files. */
+export function buildFeatureArtifacts(root, inputs) {
+  const artifacts = new Map(STATIC_ARTIFACTS);
+  for (const model of buildFeatureModels(root, inputs)) {
+    for (const [relative, body] of renderFeatureArtifacts(model))
+      artifacts.set(relative, body);
+  }
+  validateProjectionTargets(artifacts.keys());
+  return artifacts;
+}
+
+/** Preflight every desired/obsolete path, then write changed canonical bytes. */
+export function writeFeatureArtifacts(root, inputs) {
+  return writeProjectionArtifacts(root, buildFeatureArtifacts(root, inputs));
+}

package/expo/copy-overwrite/scripts/bdd-matrix.mjs

@@ -5,15 +5,16 @@
 /**
  * bdd-matrix — the per-scenario traceability matrix.
  *
- * The human-readable companion to `check-bdd-coverage.mjs`. It reuses that
- * gate's parser and the same `bdd/coverage-map.json`, so the two can never
- * disagree about what is covered.
+ * The human-readable companion to `check-bdd-coverage.mjs`. Committed feature
+ * projections reuse the gate's evidence validator. The retained aggregate
+ * stdout/API view reports configured mapping declarations; use the gate's
+ * `--report` for evidence-validated coverage credit.
  *
  * Every row separates the five facts the gate keeps apart: the behavior
  * DECLARED, where it came from, whether automation is MAPPED per runner
  * (traceability), whether that automation RAN, and what it returned. A `✓` in
- * the mapped column asserts an aligned test exists and still contains its
- * evidence string — never that it passed.
+ * the retained aggregate view reports a declared mapping without validating
+ * its evidence string — never that a test ran or passed.
  *
  * Usage: BDD_BASE_SHA="$(git merge-base HEAD origin/HEAD)" bun run bdd:matrix [--results <file>]
  *
@@ -26,15 +27,19 @@ import { fileURLToPath } from "node:url";
 import { waivedKeys } from "./bdd/baseline.mjs";
 import { byCodeUnit, declaredPlatforms, trackerUrl } from "./bdd/contract.mjs";
 import { loadScenarios } from "./bdd/parse.mjs";
+import { writeFeatureArtifacts } from "./bdd/projection.mjs";
 import { indexResults } from "./bdd/report.mjs";
-import { loadExecutionResults } from "./check-bdd-coverage.mjs";
+import {
+  loadExecutionResults,
+  parseArgs,
+  schemaDefect,
+} from "./check-bdd-coverage.mjs";
 import { invokedAsScript } from "./lib/invoked-as-script.mjs";
 
 const PACKAGE_ROOT = path.resolve(
   path.dirname(fileURLToPath(import.meta.url)),
   ".."
 );
-const OUT_REL = path.join("docs", "bdd-scenario-matrix.md");
 
 /**
  * Index mappings by scenario and runner.
@@ -221,7 +226,7 @@ function preamble(scenarios, supplied) {
 Every declared behavior, where it came from, and what actually proves it.
 Generated by \`BDD_BASE_SHA="$(git merge-base HEAD origin/HEAD)" bun run bdd:matrix\`; never hand-edited.
 
-- **Mapped** — aligned automation exists in that runner for the platforms the scenario requires, and its evidence string still resolves. This is **traceability**, not a result: a mapped test that fails still shows \`✓\`.
+- **Mapped** — a mapping is declared for that runner and platform. This retained aggregate view does not validate its evidence string. Use \`check-bdd-coverage.mjs --report\` or the committed feature leaves for evidence-validated traceability; a check mark here never proves a test ran or passed.
 - **Executed** — what the supplied run evidence returned for those mapped tests. ${supplied ? "Run evidence was supplied for this render." : "**No run evidence was supplied for this render**, so this column reads `not supplied` throughout — nothing here asserts any test ran."}
 - **Lifecycle** — \`required\` counts toward coverage; \`blocked\`, \`reference-only\`, and \`superseded\` are excluded until that changes.
 
@@ -237,19 +242,50 @@ ${scenarios.length} scenarios declared, ${required} required.
 function main() {
   const root = process.env.BDD_COVERAGE_ROOT || PACKAGE_ROOT;
   const argv = process.argv.slice(2);
-  const resultFiles = [];
-  for (let index = 0; index < argv.length; index += 1) {
-    if (argv[index] === "--results" && argv[index + 1])
-      resultFiles.push(argv[index + 1]);
-  }
-  const body = renderMatrix(root, resultFiles);
+  const { resultFiles } = parseArgs(argv, process.env);
   if (!argv.includes("--write")) {
-    console.log(body);
+    console.log(renderMatrix(root, resultFiles));
     return;
   }
-  fs.mkdirSync(path.join(root, "docs"), { recursive: true });
-  fs.writeFileSync(path.join(root, OUT_REL), body);
-  console.log(`[bdd-matrix] wrote ${OUT_REL}`);
+  writeMatrix(root, resultFiles);
+}
+
+/**
+ * Regenerate the same owned feature files as the coverage writer.
+ * @param {string} root - Project root.
+ * @param {readonly string[]} resultFiles - Explicit result inputs.
+ * @returns {void}
+ */
+function writeMatrix(root, resultFiles) {
+  try {
+    const contract = JSON.parse(
+      fs.readFileSync(path.join(root, "bdd", "coverage-map.json"), "utf8")
+    );
+    const unsupported = schemaDefect(contract);
+    if (unsupported)
+      throw new Error(`${unsupported.code}: ${unsupported.message}`);
+    const scenarios = loadScenarios(
+      root,
+      declaredPlatforms(contract.runnerPlatforms)
+    );
+    const execution = loadExecutionResults(root, resultFiles);
+    if (execution.defects.length) {
+      throw new Error(
+        execution.defects
+          .map(item => `${item.code}: ${item.message}`)
+          .join("; ")
+      );
+    }
+    const written = writeFeatureArtifacts(root, {
+      contract,
+      scenarios,
+      runs: execution.runs,
+    });
+    console.log(`[bdd-matrix] wrote ${written} feature projection files`);
+  } catch (error) {
+    console.error(`[bdd-matrix] report-write: ${error.message}`);
+    process.exitCode = 1;
+  }
 }
 
 if (invokedAsScript(import.meta.url)) main();

package/expo/copy-overwrite/scripts/check-bdd-coverage.mjs

@@ -74,8 +74,9 @@ import {
   missingDiscoveryDefects,
 } from "./bdd/discover.mjs";
 import { loadScenarios } from "./bdd/parse.mjs";
+import { appendCiSummary } from "./bdd/ci-summary.mjs";
+import { writeFeatureArtifacts } from "./bdd/projection.mjs";
 import { buildReport } from "./bdd/report.mjs";
-import { renderBurndown } from "./bdd/render.mjs";
 import {
   unresolvedEvidenceKeys,
   validateMappings,
@@ -447,7 +448,12 @@ export function run(root, options) {
     }),
     ...completenessDefects({ contract, scenarios, report, discovery }),
   ];
-  return result({ defects, report, contract });
+  return result({
+    defects,
+    report,
+    contract,
+    projectionInputs: { contract, scenarios, runs: execution.runs, cache },
+  });
 }
 
 /**
@@ -474,7 +480,7 @@ function configFatals(loaded) {
  * @param {object} contract - Parsed coverage map.
  * @returns {object|null} The defect, or null.
  */
-function schemaDefect(contract) {
+export function schemaDefect(contract) {
   const version = contract.schemaVersion;
   if (SUPPORTED_MAP_SCHEMA_VERSIONS.includes(version)) return null;
   return defect(
@@ -505,12 +511,13 @@ const INVALID_CODES = Object.freeze([
  * @param {object} input - Defects, report, and the parsed contract.
  * @returns {object} The internal result.
  */
-function result({ defects, report, contract }) {
+function result({ defects, report, contract, projectionInputs = null }) {
   return {
     status: statusFor({ defects, fatal: hasFatalDefect(defects), report }),
     defects,
     report,
     contract,
+    projectionInputs,
   };
 }
 
@@ -646,10 +653,31 @@ async function main() {
     return;
   }
   const options = parseArgs(process.argv.slice(2), process.env);
-  const gateRun = run(root, options);
-  const filesWritten =
-    options.write && gateRun.report ? writeArtifacts(root, gateRun.report) : 0;
-  const envelope = await sealEnvelope({ gateRun, options, filesWritten });
+  let gateRun = run(root, options);
+  let filesWritten = 0;
+  if (options.write && gateRun.report && gateRun.status !== "invalid") {
+    try {
+      filesWritten = writeFeatureArtifacts(root, gateRun.projectionInputs);
+    } catch (error) {
+      gateRun = result({
+        ...gateRun,
+        defects: [...gateRun.defects, defect("report-write", error.message)],
+      });
+    }
+  }
+  let envelope = await sealEnvelope({ gateRun, options, filesWritten });
+  try {
+    appendCiSummary(
+      { ...gateRun, status: envelope.status },
+      process.env.GITHUB_STEP_SUMMARY
+    );
+  } catch (error) {
+    gateRun = result({
+      ...gateRun,
+      defects: [...gateRun.defects, defect("ci-summary-write", error.message)],
+    });
+    envelope = await sealEnvelope({ gateRun, options, filesWritten });
+  }
   // Exactly ONE machine-readable object on stdout. `--report` is a diagnostic
   // that swaps the envelope for the detailed report; it never adds a second
   // document, because a stream carrying two shapes has no schema at all.
@@ -706,25 +734,6 @@ async function sealEnvelope({ gateRun, options, filesWritten }) {
   }
 }
 
-/**
- * Write the regenerated machine report and burndown.
- * @param {string} root - Repo root.
- * @param {object} report - The report.
- * @returns {number} How many files were written, for the envelope's counters.
- */
-function writeArtifacts(root, report) {
-  fs.writeFileSync(
-    path.join(root, "bdd", "coverage-report.json"),
-    `${JSON.stringify(report, null, 2)}\n`
-  );
-  fs.mkdirSync(path.join(root, "docs"), { recursive: true });
-  fs.writeFileSync(
-    path.join(root, "docs", "e2e-bdd-coverage.md"),
-    `${renderBurndown(report).trim()}\n`
-  );
-  return 2;
-}
-
 /**
  * Narrate the result on stderr, which the envelope contract reserves for
  * humans so stdout stays exactly one machine-readable object.

package/package.json

@@ -189,7 +189,7 @@
     "qs": "^6.16.0"
   },
   "name": "@codyswann/lisa",
-  "version": "4.74.0",
+  "version": "4.74.2",
   "description": "Claude Code governance framework that applies guardrails, guidance, and automated enforcement to projects",
   "main": "dist/index.js",
   "exports": {
@@ -345,7 +345,7 @@
     "test": "tests"
   },
   "types": "./dist/index.d.ts",
-  "lisaReleaseCommit": "fb7ed7c4d51c760b1855d4a68321a96ec0daf050",
-  "gitHead": "fb7ed7c4d51c760b1855d4a68321a96ec0daf050",
-  "lisaReleaseTag": "v4.74.0"
+  "lisaReleaseCommit": "49bcce1aacaea1aba5ff900d13d3c6231fa54ca7",
+  "gitHead": "49bcce1aacaea1aba5ff900d13d3c6231fa54ca7",
+  "lisaReleaseTag": "v4.74.2"
 }

package/plugins/lisa/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "4.74.0",
+  "version": "4.74.2",
   "description": "Universal governance — agents, skills, commands, hooks, and rules for all projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "4.74.0",
+  "version": "4.74.2",
   "description": "Universal governance: agents, skills, commands, hooks, and rules for all projects.",
   "author": {
     "name": "Cody Swann"