@codyswann/lisa 4.21.4 → 4.21.6

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-typescript",
-  "version": "4.21.4",
+  "version": "4.21.6",
   "description": "TypeScript-specific hooks for formatting, linting, and ast-grep scanning on edit.",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-typescript-agy/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-typescript",
-  "version": "4.21.4",
+  "version": "4.21.6",
   "description": "TypeScript-specific hooks — Prettier formatting, ESLint linting, ast-grep scanning, and error-suppression blocking on edit",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-typescript",
-  "version": "4.21.4",
+  "version": "4.21.6",
   "description": "TypeScript-specific hooks — Prettier formatting, ESLint linting, ast-grep scanning, and error-suppression blocking on edit",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-typescript",
-  "version": "4.21.4",
+  "version": "4.21.6",
   "description": "TypeScript-specific hooks — Prettier formatting, ESLint linting, ast-grep scanning, and error-suppression blocking on edit",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-wiki",
-  "version": "4.21.4",
+  "version": "4.21.6",
   "description": "LLM Wiki — a distributable, git-native markdown knowledge base for Claude Code and Codex",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-wiki",
-  "version": "4.21.4",
+  "version": "4.21.6",
   "description": "Distributable LLM Wiki kernel — ingest, query, lint, and maintain a git-native markdown knowledge base across Claude and Codex.",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-wiki-agy/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-wiki",
-  "version": "4.21.4",
+  "version": "4.21.6",
   "description": "LLM Wiki — a distributable, git-native markdown knowledge base for Claude Code and Codex",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-wiki",
-  "version": "4.21.4",
+  "version": "4.21.6",
   "description": "LLM Wiki — a distributable, git-native markdown knowledge base for Claude Code and Codex",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-wiki",
-  "version": "4.21.4",
+  "version": "4.21.6",
   "description": "LLM Wiki — a distributable, git-native markdown knowledge base for Claude Code and Codex",
   "author": {
     "name": "Cody Swann"

package/plugins/src/base/skills/lisa-secrets-access/scripts/publish-aws-bootstrap.mjs

@@ -126,6 +126,10 @@ export function candidateAwsEnvironment(bundle) {
   env.AWS_SECRET_ACCESS_KEY = String(
     bundle.secretAccessKey ?? bundle.aws_secret_access_key
   );
+  // STS verification must reach AWS, not an endpoint inherited from the host.
+  // A redirected endpoint could otherwise answer the probe and turn a green
+  // result into evidence about a local emulator or an attacker-controlled URL.
+  env.AWS_IGNORE_CONFIGURED_ENDPOINT_URLS = "true";
   env.AWS_PAGER = "";
   return env;
 }
@@ -228,12 +232,17 @@ export function preflightAwsBootstrap(cfg, operations = {}) {
  * Restore the previous provider value and prove the restoration.
  * @param {object} cfg Resolved configuration.
  * @param {{id: string, value: string}} previous Previous entry.
+ * @param {string} candidateRaw Exact value written by this publication.
  * @param {Function} fetch Provider reader.
  * @param {Function} write Provider writer.
  * @returns {string} Human-readable rollback outcome with no secret material.
  */
-function rollback(cfg, previous, fetch, write) {
+function rollback(cfg, previous, candidateRaw, fetch, write) {
   try {
+    const current = currentEntry(cfg, fetch);
+    if (current.value !== candidateRaw) {
+      return "rollback skipped because the provider changed after this publication";
+    }
     write(cfg, previous.id, previous.value);
     const restored = currentEntry(cfg, fetch);
     if (restored.value !== previous.value) {
@@ -288,7 +297,13 @@ export function publishAwsBootstrap(raw, cfg, operations = {}) {
   } catch (error) {
     const reason =
       error instanceof Error ? error.message.split("\n")[0] : String(error);
-    const rollbackOutcome = rollback(cfg, previous, fetch, write);
+    const rollbackOutcome = rollback(
+      cfg,
+      previous,
+      candidate.raw,
+      fetch,
+      write
+    );
     throw new Error(
       `${BOOTSTRAP_KEY} publication failed: ${reason}; ${rollbackOutcome}`
     );

package/scripts/check-derived-artifacts.mjs

@@ -3,12 +3,14 @@
  * Fail a commit whose generated artifacts no longer vouch for the bytes beside
  * them.
  *
- * Lisa has two artifacts derived from tracked sources:
+ * Lisa has three artifact families derived from tracked sources:
  *
  * - `src/core/upstream-evidence-manifest.ts`, regenerated by
  *   `bun run build:upstream-evidence-manifest`
  * - `src/core/lisa-owned-hash-ledger.ts`, regenerated by
  *   `bun run build:lisa-owned-hash-ledger`
+ * - `src/core/nightly-e2e-guard-behavior-certificate.ts`, regenerated by
+ *   `bun run build:nightly-guard-certificate`
  *
  * Each already has a suite-level guard, but the suite is the slow and late place
  * to learn it. CodySwannGT/lisa#2557 is what that costs: three branches, each
@@ -20,8 +22,8 @@
  *
  * **This script verifies nothing itself.** It delegates to each generator's own
  * `--check`, which is the point: a second implementation of "is the artifact
- * current" would be a second thing to keep in step. The two checks deliberately
- * assert different properties, and both are correct for their artifact:
+ * current" would be a second thing to keep in step. The checks deliberately
+ * assert different properties, and each is correct for its artifact:
  *
  * - The manifest hashes tracked files with no history walk, so a fresh
  *   regeneration is byte-reproducible anywhere and byte-identity is a fair test.
@@ -38,7 +40,7 @@
  * NOT true: the manifest does not hash the ledger, so there is no required order
  * between the two, and a stale manifest is not evidence of a stale ledger.
  *
- * Both triggers below are deliberate **supersets** of what each artifact covers.
+ * The triggers below are deliberate **supersets** of what each artifact covers.
  * Re-deriving exact membership here would create a second copy of the rule that
  * could drift and silently stop firing; over-triggering only costs a few seconds
  * on a commit that owed nothing, which is the safe direction to be wrong in.
@@ -101,6 +103,25 @@ export function requiresLedgerCheck(stagedPaths) {
   return stagedPaths.some(staged => staged.includes(COPY_OVERWRITE));
 }
 
+const NIGHTLY_GUARD_CERTIFICATE_INPUTS = Object.freeze([
+  "package.json",
+  "scripts/generate-nightly-e2e-guard-certificate.mjs",
+  "src/core/nightly-e2e-guard-behavior-certificate.ts",
+  "typescript/copy-overwrite/scripts/check-nightly-e2e-health.mjs",
+  "typescript/copy-overwrite/scripts/lib/invoked-as-script.mjs",
+]);
+
+/**
+ * Whether staged bytes can change a behavior-certificate generation result.
+ * @param {readonly string[]} stagedPaths - Repo-relative staged paths
+ * @returns {boolean} True when the dedicated certificate check is owed
+ */
+export function requiresNightlyGuardCertificateCheck(stagedPaths) {
+  return stagedPaths.some(staged =>
+    NIGHTLY_GUARD_CERTIFICATE_INPUTS.includes(staged)
+  );
+}
+
 /**
  * Whether this change touches a path the evidence manifest hash-pins.
  * @param {readonly string[]} stagedPaths - Repo-relative staged paths
@@ -221,6 +242,12 @@ const ARTIFACTS = Object.freeze([
     command: "bun run build:lisa-owned-hash-ledger",
     trigger: requiresLedgerCheck,
   }),
+  Object.freeze({
+    name: "nightly guard behavior certificate",
+    script: "scripts/generate-nightly-e2e-guard-certificate.mjs",
+    command: "bun run build:nightly-guard-certificate",
+    trigger: requiresNightlyGuardCertificateCheck,
+  }),
 ]);
 
 /**
@@ -257,7 +284,7 @@ function main() {
       "\n\n"
     )}\n\n` +
       `The order is: git add the real changes, THEN regenerate, THEN git add the\n` +
-      `regenerated file. Both generators read the git index and the working tree,\n` +
+      `regenerated file. The generators read the git index and/or working tree,\n` +
       `so regenerating before staging records the file set you had a moment ago.\n\n` +
       `Passing by hand and failing here is expected, not a puzzle: lint-staged\n` +
       `reformats every staged file just above, and this gate runs after it on\n` +

package/scripts/generate-nightly-e2e-guard-certificate.mjs

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+/**
+ * Generate the digest-to-contract behavior certificate for the nightly guard.
+ *
+ * A Lisa-owned hash proves ownership, not behavior. This generator instead
+ * loads only Lisa package/release artifacts and exercises the actual exported
+ * waiver handler: valid audited waiver, self-service, non-maintainer refusal,
+ * malformed-trailer refusal, the 72-hour ceiling, and verdict application.
+ * Runtime doctor then needs only an exact digest lookup and never evaluates a
+ * host project's target.
+ *
+ * Retention is explicit. A future guard-changing release adds its immutable git
+ * ref to `RETAINED_RELEASES`; regeneration rereads that release artifact and
+ * reruns the behavior suite. No digest is copied forward from the generated
+ * output, so arbitrary historical bytes cannot become trusted by inertia.
+ * @module scripts/generate-nightly-e2e-guard-certificate
+ */
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { format } from "prettier";
+
+import { boundedExecFileSync } from "./lib/bounded-spawn.mjs";
+import { invokedAsScript } from "./lib/invoked-as-script.mjs";
+
+const DEFAULT_REPO_ROOT = path.resolve(import.meta.dirname, "..");
+const GUARD_PATH =
+  "typescript/copy-overwrite/scripts/check-nightly-e2e-health.mjs";
+const HELPER_PATH =
+  "typescript/copy-overwrite/scripts/lib/invoked-as-script.mjs";
+const OUTPUT_PATH = "src/core/nightly-e2e-guard-behavior-certificate.ts";
+const CERTIFICATE_SCHEMA_VERSION = 1;
+const SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u;
+
+/**
+ * Immutable releases retained after the workspace guard changes.
+ *
+ * Every entry is reread from git and behavior-tested. Adding a digest or source
+ * blob here is intentionally impossible; the only input is a release ref.
+ */
+export const RETAINED_RELEASES = Object.freeze(["v2.353.0", "v4.17.16"]);
+
+const digest = bytes => createHash("sha256").update(bytes).digest("hex");
+
+const invariant = (condition, message) => {
+  if (!condition) {
+    throw new Error(`Nightly guard behavior certificate refused: ${message}`);
+  }
+};
+
+const validRequest = Object.freeze({
+  labelEvent: Object.freeze({
+    actor: "maintainer",
+    createdAt: "2026-08-12T06:00:00Z",
+  }),
+  prAuthor: "author",
+  prNumber: 2519,
+  label: "nightly-e2e-bypass",
+  prBody: "Nightly-E2E-Bypass: #2519 bounded handler proof\n",
+  actorPermission: "maintain",
+  maxHours: 24,
+  extraReasonPattern: "",
+  now: new Date("2026-08-12T09:00:00Z"),
+});
+
+const VERSION_EXPECTATIONS = Object.freeze({
+  "1.1.0": Object.freeze({ selfService: "refused" }),
+  "1.7.0": Object.freeze({ selfService: "valid" }),
+});
+
+/**
+ * Exercise the exported handler and the waiver-to-verdict boundary.
+ * @param {Record<string, unknown>} mod - Imported Lisa package artifact
+ * @returns {string} Strict compatible contract version proven by behavior
+ */
+export function verifyNightlyGuardBehavior(mod) {
+  const version = mod.NIGHTLY_E2E_CONTRACT_VERSION;
+  const semantic = typeof version === "string" ? SEMVER.exec(version) : null;
+  invariant(
+    semantic?.[1] === "1",
+    "contract must be strict ASCII major-1 semver"
+  );
+  invariant(
+    typeof mod.evaluateBypass === "function" &&
+      typeof mod.decide === "function",
+    "actual handler exports evaluateBypass and decide"
+  );
+  const expectations = VERSION_EXPECTATIONS[version];
+  invariant(
+    expectations !== undefined,
+    `contract ${version} has no explicit version-appropriate behavior expectations`
+  );
+  invariant(
+    mod.BYPASS_ABSOLUTE_MAX_HOURS === 72,
+    "bounded waiver ceiling must remain 72 hours"
+  );
+
+  const valid = mod.evaluateBypass(validRequest);
+  invariant(
+    valid?.valid === true &&
+      valid.reason === "valid" &&
+      valid.ticket === "#2519" &&
+      valid.expiresAt === "2026-08-13T06:00:00.000Z",
+    "valid audited waiver behavior changed"
+  );
+  const selfService = mod.evaluateBypass({
+    ...validRequest,
+    labelEvent: { actor: "author", createdAt: "2026-08-12T06:00:00Z" },
+  });
+  invariant(
+    expectations.selfService === "valid"
+      ? selfService?.valid === true && selfService.actor === "author"
+      : selfService?.valid === false && selfService.reason === "self_bypass",
+    "self-service audited waiver behavior changed"
+  );
+  const unauthorized = mod.evaluateBypass({
+    ...validRequest,
+    actorPermission: "write",
+  });
+  invariant(
+    unauthorized?.valid === false &&
+      unauthorized.reason === "actor_not_maintainer",
+    "non-maintainer waiver refusal changed"
+  );
+  const malformed = mod.evaluateBypass({
+    ...validRequest,
+    prBody: "no ticketed waiver trailer",
+    extraReasonPattern: ".*",
+  });
+  invariant(
+    malformed?.valid === false && malformed.reason === "no_reason_or_ticket",
+    "built-in waiver reason may no longer be widened"
+  );
+  const expired = mod.evaluateBypass({
+    ...validRequest,
+    labelEvent: { actor: "maintainer", createdAt: "2026-08-08T06:00:00Z" },
+    maxHours: 24 * 365,
+  });
+  invariant(
+    expired?.valid === false &&
+      expired.reason === "bypass_expired" &&
+      expired.expiresAt === "2026-08-11T06:00:00.000Z",
+    "bounded waiver lifetime behavior changed"
+  );
+
+  const red = Object.freeze({ state: "fail", label: "nightly" });
+  const bootstrap = Object.freeze({ active: false, until: null });
+  const waived = mod.decide([red], { bootstrap, bypass: valid });
+  const rejected = mod.decide([red], { bootstrap, bypass: unauthorized });
+  invariant(
+    waived?.verdict === "bypassed" &&
+      waived.blocked === false &&
+      waived.bypass?.waived?.length === 1,
+    "valid waiver no longer produces one audited bypass verdict"
+  );
+  invariant(
+    rejected?.verdict === "fail" && rejected.blocked === true,
+    "rejected waiver no longer leaves the gate closed"
+  );
+  return version;
+}
+
+/**
+ * Import one candidate with only the sibling helper the package ships.
+ * @param {Buffer} guardBytes - Exact guard artifact bytes
+ * @param {Buffer | undefined} invokedAsScriptBytes - Exact sibling helper bytes when that release imports it
+ * @returns {Promise<Record<string, unknown>>} Imported module namespace
+ */
+async function importPackageArtifact(guardBytes, invokedAsScriptBytes) {
+  const temp = await mkdtemp(path.join(os.tmpdir(), "lisa-guard-cert-"));
+  try {
+    await mkdir(path.join(temp, "lib"));
+    await writeFile(path.join(temp, "guard.mjs"), guardBytes);
+    if (invokedAsScriptBytes !== undefined) {
+      await writeFile(
+        path.join(temp, "lib", "invoked-as-script.mjs"),
+        invokedAsScriptBytes
+      );
+    }
+    return await import(pathToFileURL(path.join(temp, "guard.mjs")).href);
+  } finally {
+    await rm(temp, { force: true, recursive: true });
+  }
+}
+
+/**
+ * Certify exact bytes from an identified Lisa package artifact.
+ * @param {{guardBytes: Buffer, invokedAsScriptBytes?: Buffer, packageVersion: string, provenance: string}} input - Package bytes and immutable origin
+ * @returns {Promise<{digest: string, contractVersion: string, packageVersion: string, provenance: string}>} Verified certificate source
+ */
+export async function certifyNightlyGuardPackageArtifact(input) {
+  invariant(
+    SEMVER.test(input.packageVersion),
+    "package provenance must carry a strict semantic version"
+  );
+  invariant(
+    typeof input.provenance === "string" && input.provenance.length > 0,
+    "package provenance must identify its artifact"
+  );
+  const mod = await importPackageArtifact(
+    input.guardBytes,
+    input.invokedAsScriptBytes
+  );
+  return Object.freeze({
+    digest: digest(input.guardBytes),
+    contractVersion: verifyNightlyGuardBehavior(mod),
+    packageVersion: input.packageVersion,
+    provenance: input.provenance,
+  });
+}
+
+const gitFile = (repoRoot, ref, file) =>
+  Buffer.from(
+    boundedExecFileSync("git", ["show", `${ref}:${file}`], {
+      cwd: repoRoot,
+      encoding: "buffer",
+      stdio: ["ignore", "pipe", "pipe"],
+    })
+  );
+
+const gitFileOptional = (repoRoot, ref, file) => {
+  try {
+    return gitFile(repoRoot, ref, file);
+  } catch {
+    return undefined;
+  }
+};
+
+const packageMetadata = bytes => {
+  const parsed = JSON.parse(bytes.toString("utf8"));
+  invariant(
+    parsed?.name === "@codyswann/lisa" &&
+      Array.isArray(parsed.files) &&
+      parsed.files.includes("typescript"),
+    "artifact is not an @codyswann/lisa package containing typescript"
+  );
+  return parsed;
+};
+
+const workspaceArtifact = async repoRoot => {
+  const metadata = packageMetadata(
+    await readFile(path.join(repoRoot, "package.json"))
+  );
+  return await certifyNightlyGuardPackageArtifact({
+    guardBytes: await readFile(path.join(repoRoot, GUARD_PATH)),
+    invokedAsScriptBytes: await readFile(path.join(repoRoot, HELPER_PATH)),
+    packageVersion: metadata.version,
+    provenance: `workspace package @codyswann/lisa@${metadata.version} (${GUARD_PATH})`,
+  });
+};
+
+const releaseArtifact = async (repoRoot, ref) => {
+  const metadata = packageMetadata(gitFile(repoRoot, ref, "package.json"));
+  return await certifyNightlyGuardPackageArtifact({
+    guardBytes: gitFile(repoRoot, ref, GUARD_PATH),
+    invokedAsScriptBytes: gitFileOptional(repoRoot, ref, HELPER_PATH),
+    packageVersion: metadata.version,
+    provenance: `git tag ${ref} package @codyswann/lisa@${metadata.version} (${GUARD_PATH})`,
+  });
+};
+
+const mergeCertificates = entries => {
+  const grouped = new Map();
+  for (const entry of entries) {
+    const prior = grouped.get(entry.digest);
+    if (prior && prior.contractVersion !== entry.contractVersion) {
+      throw new Error(
+        `Nightly guard behavior certificate refused: digest ${entry.digest} has conflicting contracts`
+      );
+    }
+    grouped.set(entry.digest, {
+      digest: entry.digest,
+      contractVersion: entry.contractVersion,
+      packageVersions: [
+        ...new Set([...(prior?.packageVersions ?? []), entry.packageVersion]),
+      ].sort(),
+      provenances: [
+        ...new Set([...(prior?.provenances ?? []), entry.provenance]),
+      ].sort(),
+    });
+  }
+  return [...grouped.values()].sort((left, right) =>
+    left.digest < right.digest ? -1 : left.digest > right.digest ? 1 : 0
+  );
+};
+
+const render = async certificates => {
+  const rows = certificates
+    .map(
+      certificate => `  ${JSON.stringify(certificate.digest)}: Object.freeze({
+    contractVersion: ${JSON.stringify(certificate.contractVersion)},
+    packageVersions: Object.freeze(${JSON.stringify(certificate.packageVersions)}),
+    provenances: Object.freeze(${JSON.stringify(certificate.provenances)}),
+  }),`
+    )
+    .join("\n");
+  return await format(
+    `/**
+ * @file nightly-e2e-guard-behavior-certificate.ts
+ * @description Generated exact-byte certificates for behavior-proven Lisa guard artifacts
+ * @module core/nightly-e2e-guard-behavior-certificate
+ * Generated by scripts/generate-nightly-e2e-guard-certificate.mjs.
+ */
+
+/** Behavior-certificate schema consumed by doctor. */
+export const NIGHTLY_E2E_GUARD_CERTIFICATE_SCHEMA_VERSION = ${CERTIFICATE_SCHEMA_VERSION};
+
+/**
+ * Exact digests whose real package handlers passed the bounded-waiver suite.
+ * Generic Lisa ownership hashes are deliberately not consulted at runtime.
+ */
+export const NIGHTLY_E2E_GUARD_BEHAVIOR_CERTIFICATES = Object.freeze({
+${rows}
+});
+`,
+    { parser: "typescript" }
+  );
+};
+
+/**
+ * Generate current workspace plus explicitly retained release certificates.
+ * @param {string} [repoRoot] - Canonical Lisa checkout
+ * @returns {Promise<{source: string, certificates: readonly object[]}>} Generated artifact and structured records
+ */
+export async function generateNightlyGuardBehaviorCertificate(
+  repoRoot = DEFAULT_REPO_ROOT
+) {
+  const sources = [await workspaceArtifact(repoRoot)];
+  for (const ref of RETAINED_RELEASES) {
+    sources.push(await releaseArtifact(repoRoot, ref));
+  }
+  const certificates = mergeCertificates(sources);
+  return Object.freeze({
+    source: await render(certificates),
+    certificates,
+  });
+}
+
+/**
+ * Generate or verify the checked-in artifact.
+ * @param {readonly string[]} argv - CLI arguments
+ * @param {string} [repoRoot] - Canonical Lisa checkout
+ * @returns {Promise<number>} Process exit code
+ */
+export async function runCertificateCli(argv, repoRoot = DEFAULT_REPO_ROOT) {
+  const generated = await generateNightlyGuardBehaviorCertificate(repoRoot);
+  const output = path.join(repoRoot, OUTPUT_PATH);
+  if (argv.includes("--check")) {
+    const current = await readFile(output, "utf8").catch(() => "");
+    if (current === generated.source) {
+      process.stdout.write("Nightly guard behavior certificate is current.\n");
+      return 0;
+    }
+    process.stderr.write(
+      "Nightly guard behavior certificate drifted. Run `bun run build:nightly-guard-certificate` and commit the generated artifact.\n"
+    );
+    return 1;
+  }
+  await writeFile(output, generated.source);
+  process.stdout.write(
+    `Wrote ${OUTPUT_PATH} (${generated.certificates.length} certified digest(s)).\n`
+  );
+  return 0;
+}
+
+if (invokedAsScript(import.meta.url)) {
+  process.exitCode = await runCertificateCli(process.argv.slice(2));
+}

package/scripts/two-channel-couplings.json

@@ -1,18 +1,19 @@
 {
   "ratified": {
-    "quality.yml::scripts/check-learnings-budget.ts": "Lisa-source-only branch, and the else arm is the delivery. The step tests for BOTH scripts/check-learnings-budget.ts and src/core/learnings-budget-check.ts, which co-exist only in this repository; every consumer takes the else arm and runs the prover as `bunx @codyswann/lisa@<their own declared version>`, which is the PACKAGE channel and not a caller-tree read at all. A trailing `grep -qE \"learnings budget (passed|saturated)|no learnings file\"` then refuses a run that printed no verdict, so the arm cannot pass vacuously. Ratified because the caller-tree read is unreachable outside this repository, not because the gap is tolerated."
+    "quality.yml::scripts/check-learnings-budget.ts": "Lisa-source-only branch, and the else arm is the delivery. The step tests for BOTH scripts/check-learnings-budget.ts and src/core/learnings-budget-check.ts, which co-exist only in this repository; every consumer takes the else arm and runs the prover as `bunx @codyswann/lisa@<their own declared version>`, which is the PACKAGE channel and not a caller-tree read at all. A trailing `grep -qE \"learnings budget (passed|saturated)|no learnings file\"` then refuses a run that printed no verdict, so the arm cannot pass vacuously. Ratified because the caller-tree read is unreachable outside this repository, not because the gap is tolerated.",
+    "quality.yml::scripts/generate-nightly-e2e-guard-certificate.mjs": "Lisa-source-only branch. Both reusable jobs require `github.repository == 'CodySwannGT/lisa'` before the step can start, and the run body repeats that exact repository guard before checking this artifact path. Ordinary and private host callers therefore skip the step without reading or fetching from their own tree. The scoped branch fetches only the immutable refs needed to behavior-test Lisa's own retained certificate inputs. Ratified because the caller-tree read is unreachable outside this repository, not because an undelivered host dependency is tolerated."
   },
   "inspected": {
     "workflows": 23,
-    "steps": 634,
-    "couplings": 25,
+    "steps": 636,
+    "couplings": 26,
     "inventory": 56
   },
   "counts": {
     "package-backed": 10,
     "apply-lagged": 14,
     "never-delivered": 0,
-    "undelivered": 1
+    "undelivered": 2
   },
   "couplings": [
     {
@@ -184,6 +185,17 @@
       ],
       "detail": "`quality.yml` is delivered at `@main`, so this step is live in every consumer on their next run. It reads `scripts/check-verification-coverage.mjs` from the CALLER's tree with no package-relative candidate, and Lisa delivers that path on the `lisa apply` channel (typescript/copy-overwrite). The two halves land in the wrong order: this step is live everywhere immediately, the file it needs is live only where somebody applied. The read is unguarded, so an absent path fails the job loudly. Visible, which makes it the better of the two failures."
     },
+    {
+      "key": "quality.yml::scripts/generate-nightly-e2e-guard-certificate.mjs",
+      "workflow": "quality.yml",
+      "path": "scripts/generate-nightly-e2e-guard-certificate.mjs",
+      "channel": "undelivered",
+      "verdict": "undelivered",
+      "remedy": "author-the-artifact",
+      "guarded": true,
+      "lanes": [],
+      "detail": "`quality.yml` is delivered at `@main`, so this step is live in every consumer on their next run. It reads `scripts/generate-nightly-e2e-guard-certificate.mjs` from the CALLER's tree, and Lisa ships no such path in any delivery lane — no apply and no bump ever produces it. Either the consumer authors it or this step proves nothing wherever it is absent. The read is guarded by an existence test, so an absent path SKIPS rather than fails — the step posts no context, and an absent required context is not a red one. Nothing reads as broken."
+    },
     {
       "key": "quality.yml::scripts/lisa-floor-collisions.mjs",
       "workflow": "quality.yml",