@codyswann/lisa 2.317.7 → 2.319.0

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-phaser",
-  "version": "2.317.7",
+  "version": "2.319.0",
   "description": "Phaser 4 game-development rules for TypeScript projects",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-phaser",
-  "version": "2.317.7",
+  "version": "2.319.0",
   "description": "Phaser 4 game-development rules for TypeScript projects",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-phaser",
-  "version": "2.317.7",
+  "version": "2.319.0",
   "description": "Phaser 4 game-development rules for TypeScript projects",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-phaser",
-  "version": "2.317.7",
+  "version": "2.319.0",
   "description": "Phaser 4 game-development rules for TypeScript projects",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-rails",
-  "version": "2.317.7",
+  "version": "2.319.0",
   "description": "Ruby on Rails-specific hooks — RuboCop linting/formatting and ast-grep scanning on edit",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-rails",
-  "version": "2.317.7",
+  "version": "2.319.0",
   "description": "Ruby on Rails-specific skills and hooks for RuboCop and ast-grep scanning on edit.",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-rails",
-  "version": "2.317.7",
+  "version": "2.319.0",
   "description": "Ruby on Rails-specific hooks — RuboCop linting/formatting and ast-grep scanning on edit",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-rails",
-  "version": "2.317.7",
+  "version": "2.319.0",
   "description": "Ruby on Rails-specific hooks — RuboCop linting/formatting and ast-grep scanning on edit",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-rails",
-  "version": "2.317.7",
+  "version": "2.319.0",
   "description": "Ruby on Rails-specific hooks — RuboCop linting/formatting and ast-grep scanning on edit",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-typescript",
-  "version": "2.317.7",
+  "version": "2.319.0",
   "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/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-typescript",
-  "version": "2.317.7",
+  "version": "2.319.0",
   "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": "2.317.7",
+  "version": "2.319.0",
   "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": "2.317.7",
+  "version": "2.319.0",
   "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": "2.317.7",
+  "version": "2.319.0",
   "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": "2.317.7",
+  "version": "2.319.0",
   "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": "2.317.7",
+  "version": "2.319.0",
   "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": "2.317.7",
+  "version": "2.319.0",
   "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": "2.317.7",
+  "version": "2.319.0",
   "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": "2.317.7",
+  "version": "2.319.0",
   "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/doctor-secrets.mjs

@@ -47,6 +47,16 @@ function fingerprint(value) {
   return createHash("sha256").update(value).digest("hex").slice(0, 12);
 }
 
+/**
+ * The value a proxied credential reads as instead of a usable token.
+ *
+ * Some surfaces keep a credential outside the sandbox entirely and substitute
+ * the real value at egress. The variable is then present and non-empty, which
+ * is exactly what makes it dangerous: a presence check passes, and only a
+ * consumer that reads the variable *itself* discovers it holds a placeholder.
+ */
+const PROXY_PLACEHOLDER = "proxy-injected";
+
 /**
  * Assert every declared name actually resolves.
  * @param {object} cfg Resolved configuration.
@@ -56,18 +66,36 @@ function fingerprint(value) {
  */
 export function checkRequired(cfg, provider, file, report) {
   for (const name of cfg.require ?? []) {
-    const resolves =
-      (process.env[name] ?? "").trim() ||
-      file.get(name) ||
-      provider.get(name)?.value;
-    if (resolves) report("ok", name, "resolves");
-    else
+    const fromEnv = (process.env[name] ?? "").trim();
+    const resolves = fromEnv || file.get(name) || provider.get(name)?.value;
+
+    if (!resolves) {
       report(
         "error",
         name,
         "declared in secrets.require but resolves nowhere — a startup error, " +
           "not a late surprise"
       );
+      continue;
+    }
+
+    // Reported separately from "resolves" because the two are not the same
+    // claim. A tool that authenticates through the proxy works; a script that
+    // reads this variable and puts it in an Authorization header sends the
+    // literal placeholder and gets a confusing auth failure far from here.
+    if (fromEnv === PROXY_PLACEHOLDER) {
+      report(
+        "warn",
+        name,
+        `reads as the literal string "${PROXY_PLACEHOLDER}" — the value is ` +
+          `substituted at egress and never enters this environment. Tools that ` +
+          `authenticate through the proxy work; anything reading this variable ` +
+          `directly gets the placeholder, not a credential`
+      );
+      continue;
+    }
+
+    report("ok", name, "resolves");
   }
 }
 

package/plugins/src/base/skills/lisa-secrets-access/scripts/surfaces.mjs

@@ -28,11 +28,19 @@ import { join } from "node:path";
  * drift and leak. It is *required* on surfaces whose bootstrap runs before the
  * consuming process exists and which therefore have no other channel; a remote
  * agent container prepares itself during setup, long before any task starts.
+ *
+ * The two remote surfaces share the capability but not the timing, and a reader
+ * adding a third should not assume otherwise. `codex-cloud` re-runs its setup
+ * script when a container resumes, so materializing there picks up a rotated
+ * value. `claude-web` *skips* its setup script whenever a filesystem cache
+ * exists, so materializing there would strand a rotated value until the cache
+ * expired — its materialize step runs from a session-start hook instead.
  */
 export const SURFACES = {
   local: { materialized: false, mayWriteValues: false },
   "github-actions": { materialized: false, mayWriteValues: false },
   "codex-cloud": { materialized: true, mayWriteValues: true },
+  "claude-web": { materialized: true, mayWriteValues: true },
 };
 
 /** Config defaults when `.lisa.config.json` carries no `secrets` block. */
@@ -68,6 +76,10 @@ export function detectSurface(configured = null, env = process.env) {
     return explicit;
   }
   if ((env.GITHUB_ACTIONS ?? "") === "true") return "github-actions";
+  // Compared to the exact string rather than tested for presence: the variable
+  // is documented as carrying "true" in a cloud session and never being true
+  // locally, so a presence test would misread a shell that exports it empty.
+  if ((env.CLAUDE_CODE_REMOTE ?? "") === "true") return "claude-web";
   if ((env.CODEX_SANDBOX ?? env.CODEX_HOME ?? "") !== "") return "codex-cloud";
   return "local";
 }

package/plugins/src/base/skills/lisa-secrets-access/scripts/validate-config.mjs

@@ -19,14 +19,59 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
+import { SURFACES as SURFACE_CAPABILITIES } from "./surfaces.mjs";
+
 /** Providers with a read implementation today. */
 const IMPLEMENTED_PROVIDERS = new Set(["bitwarden", "doppler", "env"]);
 
 /** Providers named in the dispatch table but not yet implemented. */
 const DECLARED_PROVIDERS = new Set(["1password", "aws", "vault"]);
 
-/** Surfaces the resolver knows. */
-const SURFACES = new Set(["local", "github-actions", "codex-cloud"]);
+/**
+ * Surfaces the resolver knows.
+ *
+ * Derived from the resolver's own table rather than restated here. The two
+ * lists previously drifted apart by construction: adding a surface meant
+ * remembering to edit a second file, and forgetting produced a config that
+ * resolved correctly at runtime while `doctor` called it unknown.
+ */
+const SURFACES = new Set(Object.keys(SURFACE_CAPABILITIES));
+
+/**
+ * What a provisioned surface must record before anything dispatches to it.
+ *
+ * Deliberately not uniform, because these surfaces do not bind the same way. A
+ * Codex Cloud environment is bound to one repository, so naming the repository
+ * is part of proving the environment is the right one. A Claude cloud
+ * environment has no repository at all — it is account-scoped configuration
+ * (network policy, variables, setup script) and the repository arrives per
+ * session — so its durable handle is the routine that dispatch fires.
+ *
+ * Requiring `repository` of every surface, as this file used to, would demand
+ * a field that cannot be true of `claude-web` in any meaningful sense.
+ *
+ * `repository` stays the default so every existing surface keeps its current
+ * contract. This file checks structure only — whether a declaration *could* be
+ * correct — so it deliberately does not restate the fuller preconditions that
+ * `lisa-remote-dispatch` enforces at the moment it actually dispatches.
+ */
+const SURFACE_BINDINGS = {
+  "claude-web": ["routineId", "fireUrl"],
+};
+
+/**
+ * The fields a surface must record, with the default applied.
+ *
+ * Read through one helper rather than at each call site, because the two
+ * callers answer different questions — "could this declaration be correct" and
+ * "may an automation dispatch to it" — and a fallback that drifted between them
+ * would let those answers disagree about the very same config.
+ * @param {string} surface Surface name.
+ * @returns {string[]} Field names that must be present.
+ */
+function bindingsFor(surface) {
+  return SURFACE_BINDINGS[surface] ?? ["repository"];
+}
 
 /** Install methods the toolchain runner supports. */
 const INSTALL_METHODS = new Set(["release-zip", "npm-global"]);
@@ -139,15 +184,30 @@ export function validateRemoteEnv(remoteEnv) {
   for (const [surface, block] of Object.entries(remoteEnv.surfaces ?? {})) {
     if (!SURFACES.has(surface)) {
       problems.push(`remoteEnv.surfaces has unknown surface "${surface}"`);
+      continue;
     }
-    if (!block.repository) {
-      problems.push(`remoteEnv.surfaces["${surface}"] has no repository`);
+    for (const field of bindingsFor(surface)) {
+      if (!block[field]) {
+        problems.push(`remoteEnv.surfaces["${surface}"] has no ${field}`);
+      }
     }
   }
 
   return problems;
 }
 
+/**
+ * Report whether a surface has been provisioned far enough to dispatch to.
+ * @param {object|undefined} remoteEnv The remote-environment block.
+ * @param {string} surface Surface name.
+ * @returns {boolean} Whether every binding field is recorded.
+ */
+export function isProvisioned(remoteEnv, surface) {
+  const block = remoteEnv?.surfaces?.[surface];
+  if (!block) return false;
+  return bindingsFor(surface).every(field => Boolean(block[field]));
+}
+
 /**
  * Validate the `automations` block against declared surfaces.
  * @param {object|undefined} automations The block, if present.
@@ -173,7 +233,7 @@ export function validateAutomations(automations, remoteEnv) {
       );
       continue;
     }
-    if (!remoteEnv?.surfaces?.[loop.executionEnv]?.repository) {
+    if (!isProvisioned(remoteEnv, loop.executionEnv)) {
       problems.push(
         `automations["${name}"] dispatches to "${loop.executionEnv}", which is ` +
           `not provisioned. Run /lisa:setup:remote-env ${loop.executionEnv} first.`

package/scripts/check-security-floors.mjs

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+/**
+ * Verify no force-pinned version floor permits a known-vulnerable release.
+ *
+ * A floor in a `force` section does not merely fail to protect when it goes
+ * stale — it OVERWRITES whatever the downstream project had. A project that
+ * pinned correctly gets moved back onto the vulnerable range by `lisa apply`,
+ * silently, and the only signal is a suspicious line in a diff nobody is
+ * looking for. That is how `brace-expansion >=5.0.7` survived: it was written
+ * to match GHSA-3jxr-9vmj-r5cp, whose first_patched_version genuinely is
+ * 5.0.7, and GHSA-mh99-v99m-4gvg later moved the floor to 5.0.8.
+ *
+ * The floors are therefore checked against the advisory database rather than
+ * against what npm happens to resolve. Resolution drifts as new advisories
+ * land; `first_patched_version` does not. Deriving floors from resolution is
+ * the specific mistake this exists to catch — it produced the same defect
+ * three times (fast-uri, js-yaml, and the three fixed in #2168).
+ *
+ * Usage:
+ *   check-security-floors.mjs [--strict] [--json]
+ *
+ * Exits non-zero only with --strict, so the job can report before it gates.
+ * @module scripts/check-security-floors
+ */
+
+import { readFileSync } from "node:fs";
+import { globSync } from "node:fs";
+
+/** Sections whose entries are version constraints worth checking. */
+const CONSTRAINT_SECTIONS = [
+  "overrides",
+  "resolutions",
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+];
+
+/** Governance groups in a package.lisa.json. */
+const GOVERNANCE_GROUPS = ["force", "defaults", "merge"];
+
+/** Severities that gate. Medium and low advisories are ignored by this check. */
+const GATING_SEVERITIES = new Set(["high", "critical"]);
+
+const ADVISORY_ENDPOINT = "https://api.github.com/advisories";
+
+/**
+ * Every version constraint declared across the template manifests.
+ * @returns {Map<string, Array<{file: string, path: string, spec: string}>>} By package name.
+ */
+function collectFloors() {
+  const found = new Map();
+  const files = globSync("*/package-lisa/package.lisa.json").filter(
+    file => !file.includes("node_modules") && !file.includes(".worktrees")
+  );
+  for (const file of files) {
+    let manifest;
+    try {
+      manifest = JSON.parse(readFileSync(file, "utf8"));
+    } catch (error) {
+      throw new Error(`${file} is not valid JSON: ${error.message}`);
+    }
+    for (const group of GOVERNANCE_GROUPS) {
+      const block = manifest[group];
+      if (!block || typeof block !== "object") continue;
+      for (const section of CONSTRAINT_SECTIONS) {
+        const entries = block[section];
+        if (!entries || typeof entries !== "object") continue;
+        for (const [name, spec] of Object.entries(entries)) {
+          // `$name` self-references defer to the project's own pin and carry
+          // no floor of their own; a literal like "workspace:*" likewise.
+          if (typeof spec !== "string" || !/\d/.test(spec)) continue;
+          if (spec.startsWith("$")) continue;
+          if (!found.has(name)) found.set(name, []);
+          found.get(name).push({ file, path: `${group}.${section}`, spec });
+        }
+      }
+    }
+  }
+  return found;
+}
+
+/**
+ * Lowest version a spec permits, as a comparable tuple.
+ * @param {string} spec A range like ">=5.0.7", "^1.2.3", "~2.0.0".
+ * @returns {number[]|null} [major, minor, patch], or null if unparseable.
+ */
+export function lowestPermitted(spec) {
+  const match = /(\d+)\.(\d+)\.(\d+)/.exec(spec);
+  if (!match) return null;
+  return match.slice(1, 4).map(Number);
+}
+
+/**
+ * Compare two version tuples.
+ * @param {number[]} left First version.
+ * @param {number[]} right Second version.
+ * @returns {number} Negative, zero, or positive.
+ */
+function compare(left, right) {
+  for (let index = 0; index < 3; index += 1) {
+    if (left[index] !== right[index]) return left[index] - right[index];
+  }
+  return 0;
+}
+
+/**
+ * Whether a version falls inside an advisory's vulnerable range.
+ * @param {number[]} version Candidate version.
+ * @param {string} range e.g. ">= 4.0.0, < 5.0.8".
+ * @returns {boolean} True when the version is vulnerable.
+ */
+export function withinRange(version, range) {
+  if (!range) return false;
+  let inside = true;
+  for (const clause of range.split(",")) {
+    const match = /(>=|<=|<|>|=)\s*(\d+)\.(\d+)\.(\d+)/.exec(clause.trim());
+    if (!match) continue;
+    const bound = match.slice(2, 5).map(Number);
+    const delta = compare(version, bound);
+    switch (match[1]) {
+      case ">=":
+        inside &&= delta >= 0;
+        break;
+      case ">":
+        inside &&= delta > 0;
+        break;
+      case "<=":
+        inside &&= delta <= 0;
+        break;
+      case "<":
+        inside &&= delta < 0;
+        break;
+      default:
+        inside &&= delta === 0;
+    }
+  }
+  return inside;
+}
+
+/**
+ * Advisories affecting one package.
+ *
+ * Distinguishes "no advisories" from "could not ask", because conflating them
+ * is how a check like this goes quietly blind. The anonymous advisory limit is
+ * 60 requests/hour and these manifests declare roughly 200 packages, so an
+ * unauthenticated run answers for the first 60 and silently reports the other
+ * 140 as clean unless the difference is tracked.
+ * @param {string} name npm package name.
+ * @returns {Promise<{advisories: Array}|{error: string}>} Result or reason.
+ */
+async function advisoriesFor(name) {
+  const url = `${ADVISORY_ENDPOINT}?ecosystem=npm&affects=${encodeURIComponent(name)}&per_page=100`;
+  const headers = { accept: "application/vnd.github+json" };
+  // Authenticated calls get 5000/hour instead of 60. CI supplies the token via
+  // the standard GITHUB_TOKEN; locally, `gh auth token` covers it.
+  const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+  if (token) headers.authorization = `Bearer ${token}`;
+
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    let response;
+    try {
+      response = await fetch(url, { headers });
+    } catch (error) {
+      return { error: `network: ${error.message}` };
+    }
+    if (response.ok) return { advisories: await response.json() };
+
+    const remaining = response.headers.get("x-ratelimit-remaining");
+    const limited =
+      response.status === 429 || (response.status === 403 && remaining === "0");
+    if (!limited) return { error: `HTTP ${response.status}` };
+
+    // Honour Retry-After when given, otherwise back off. A rate-limited run
+    // cannot demonstrate anything, so it is worth waiting rather than
+    // reporting a clean sheet that was never checked.
+    const retryAfter = Number(response.headers.get("retry-after"));
+    const waitSeconds =
+      Number.isFinite(retryAfter) && retryAfter > 0
+        ? Math.min(retryAfter, 30)
+        : 2 ** attempt;
+    await new Promise(resolve => setTimeout(resolve, waitSeconds * 1000));
+  }
+  return { error: "rate limited" };
+}
+
+/**
+ * Audit every collected floor.
+ * @returns {Promise<{problems: Array, unreachable: string[], checked: number}>} Findings.
+ */
+async function audit() {
+  const floors = collectFloors();
+  const problems = [];
+  const unreachable = [];
+  for (const [name, sites] of floors) {
+    const result = await advisoriesFor(name);
+    if (result.error) {
+      unreachable.push({ name, reason: result.error });
+      continue;
+    }
+    const { advisories } = result;
+    for (const advisory of advisories) {
+      if (!GATING_SEVERITIES.has(advisory.severity)) continue;
+      for (const vulnerability of advisory.vulnerabilities ?? []) {
+        if (vulnerability.package?.name !== name) continue;
+        for (const site of sites) {
+          const lowest = lowestPermitted(site.spec);
+          if (!lowest) continue;
+          if (!withinRange(lowest, vulnerability.vulnerable_version_range)) {
+            continue;
+          }
+          problems.push({
+            package: name,
+            ...site,
+            advisory: advisory.ghsa_id,
+            severity: advisory.severity,
+            vulnerableRange: vulnerability.vulnerable_version_range,
+            patched: vulnerability.first_patched_version,
+          });
+        }
+      }
+    }
+  }
+  return { problems, unreachable, checked: floors.size };
+}
+
+async function main() {
+  const strict = process.argv.includes("--strict");
+  const asJson = process.argv.includes("--json");
+  const { problems, unreachable, checked } = await audit();
+
+  if (asJson) {
+    console.log(JSON.stringify({ problems, unreachable, checked }, null, 2));
+  } else if (problems.length === 0) {
+    console.log(
+      `## Security floors\n\nNo force-pinned floor permits a high or critical vulnerable release. ${checked} package(s) checked.`
+    );
+  } else {
+    console.log("## Security floors\n");
+    console.log(
+      "These pins permit a release the advisory database marks vulnerable. Because they sit in governance sections, a stale floor **overwrites** a downstream project that pinned correctly.\n"
+    );
+    console.log("| package | pinned | permits | advisory | patched | site |");
+    console.log("|---|---|---|---|---|---|");
+    for (const problem of problems) {
+      console.log(
+        `| \`${problem.package}\` | \`${problem.spec}\` | ${problem.vulnerableRange} | ${problem.advisory} (${problem.severity}) | **${problem.patched}** | ${problem.file} ${problem.path} |`
+      );
+    }
+    console.log(
+      "\nRaise each floor to the advisory's `first_patched_version`, then confirm the new value actually resolves on npm — a floor nothing satisfies is its own breakage."
+    );
+  }
+
+  if (unreachable.length > 0) {
+    const limited = unreachable.filter(entry =>
+      entry.reason.includes("rate limited")
+    );
+    console.log(
+      `\n> **Inconclusive for ${unreachable.length} of ${checked} package(s).** Their floors were NOT verified — this is not a clean result for them.`
+    );
+    if (limited.length > 0) {
+      console.log(
+        "> Cause is rate limiting. The anonymous advisory limit is 60 requests/hour; set `GITHUB_TOKEN` for 5000."
+      );
+    }
+    console.log(
+      `> Affected: ${unreachable.map(entry => entry.name).join(", ")}`
+    );
+  }
+
+  // Deliberately exit 0 without --strict. An advisory landing overnight would
+  // otherwise fail a PR that changed nothing, and a check that cries wolf gets
+  // disabled rather than fixed.
+  //
+  // Under --strict an inconclusive run also fails: it proves nothing, and
+  // treating "could not check" as "checked and clean" is exactly the silent
+  // degradation this script exists to prevent.
+  if (strict && (problems.length > 0 || unreachable.length > 0)) {
+    process.exitCode = 1;
+  }
+}
+
+if (import.meta.main) {
+  await main();
+}