@codyswann/lisa 3.16.0 → 3.17.1

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

@@ -206,22 +206,11 @@ export function validateSecrets(secrets) {
     );
   }
 
-  for (const field of ["require", "rotating"]) {
-    const value = secrets[field];
-    if (value === undefined || value === null) continue;
-    if (!Array.isArray(value)) {
-      problems.push(`secrets.${field} must be an array of exact key names`);
-      continue;
-    }
-    for (const name of value) {
-      if (typeof name !== "string" || !/^[A-Z][A-Z0-9_]*$/.test(name)) {
-        problems.push(
-          `secrets.${field} entry ${JSON.stringify(name)} is not an exact ` +
-            `UPPER_SNAKE_CASE environment-variable name. Lookup is never fuzzy.`
-        );
-      }
-    }
-  }
+  // `rotating` is a flat list on every surface. `require` also accepts a
+  // surface-scoped object, because the required set genuinely differs by where
+  // the agent runs — see `resolveRequire` in surfaces.mjs.
+  validateKeyList("rotating", secrets.rotating, problems);
+  validateRequire(secrets.require, problems);
 
   problems.push(...validatePropagating(secrets.propagating));
 
@@ -263,6 +252,73 @@ export function validateSecrets(secrets) {
  * @param {object} entry The entry or platform block.
  * @param {string[]} problems Accumulator.
  */
+/**
+ * Whether a value parses as a dotted version the comparator can order.
+ * @param {unknown} value Candidate version.
+ * @returns {boolean} True for "20", "1.2", "1.2.3" and similar.
+ */
+function isVersionish(value) {
+  return typeof value === "string" && /^\d+(\.\d+)*$/.test(value.trim());
+}
+
+/**
+ * Validate a flat list of exact environment-variable names.
+ * @param {string} field Config field name, for messages.
+ * @param {unknown} value The declared value.
+ * @param {string[]} problems Collector.
+ */
+function validateKeyList(field, value, problems) {
+  if (value === undefined || value === null) return;
+  if (!Array.isArray(value)) {
+    problems.push(`secrets.${field} must be an array of exact key names`);
+    return;
+  }
+  for (const name of value) {
+    if (typeof name !== "string" || !/^[A-Z][A-Z0-9_]*$/.test(name)) {
+      problems.push(
+        `secrets.${field} entry ${JSON.stringify(name)} is not an exact ` +
+          `UPPER_SNAKE_CASE environment-variable name. Lookup is never fuzzy.`
+      );
+    }
+  }
+}
+
+/**
+ * Validate `require` in either of its two shapes.
+ *
+ * An array means every surface. An object scopes per surface, with `all`
+ * applying everywhere. Unknown keys are rejected rather than ignored: a typo
+ * like `github_actions` for `github-actions` would otherwise resolve to an
+ * empty list and silently assert nothing on the one surface it was written
+ * for — a declaration that reads as protection and delivers none.
+ * @param {unknown} value The declared value.
+ * @param {string[]} problems Collector.
+ */
+function validateRequire(value, problems) {
+  if (value === undefined || value === null) return;
+  if (Array.isArray(value)) {
+    validateKeyList("require", value, problems);
+    return;
+  }
+  if (typeof value !== "object") {
+    problems.push(
+      `secrets.require must be an array of key names, or an object keyed by ` +
+        `surface with an optional "all" entry`
+    );
+    return;
+  }
+  for (const [key, names] of Object.entries(value)) {
+    if (key !== "all" && !SURFACES.has(key)) {
+      problems.push(
+        `secrets.require key "${key}" is not a known surface. ` +
+          `Known: all, ${[...SURFACES].join(", ")}.`
+      );
+      continue;
+    }
+    validateKeyList(`require.${key}`, names, problems);
+  }
+}
+
 function validateInstallArtifact(label, entry, problems) {
   if (!INSTALL_METHODS.has(entry.install)) {
     problems.push(
@@ -308,7 +364,23 @@ export function validateRemoteEnv(remoteEnv) {
   const problems = [];
 
   for (const tool of remoteEnv.tools?.require ?? []) {
-    if (!tool.name) problems.push("remoteEnv.tools.require entry has no name");
+    if (!tool.name) {
+      problems.push("remoteEnv.tools.require entry has no name");
+      continue;
+    }
+    // `minVersion` was accepted unvalidated while `install` entries had their
+    // shape checked in full. The asymmetry mattered: the value is fed to a
+    // version comparison, so `minVersion: "twenty"` sorted below every real
+    // version and the requirement silently passed for any installed release —
+    // a declared constraint that enforced nothing.
+    if (tool.minVersion !== undefined && !isVersionish(tool.minVersion)) {
+      problems.push(
+        `remoteEnv require "${tool.name}" has minVersion ` +
+          `${JSON.stringify(tool.minVersion)}, which is not a dotted version ` +
+          `like "20" or "1.2.3". It is compared numerically, so a value that ` +
+          `does not parse would accept every installed version.`
+      );
+    }
   }
   for (const tool of remoteEnv.tools?.install ?? []) {
     if (!tool.name) {

package/plugins/lisa-copilot/skills/lisa-setup-remote-env/scripts/preflight-tools.mjs

@@ -0,0 +1,242 @@
+/**
+ * Prove, before an agent starts work, that the CLIs it needs are on PATH.
+ *
+ * The symmetric half of `preflight-secrets.mjs`, and it exists for the same
+ * reason: the logic to answer the question was already good, and nothing asked
+ * it at the moment the answer mattered. `planToolchain` decides presence,
+ * minimum version, and installability correctly — but its only callers were
+ * `/lisa:setup:local-env`, which a human runs deliberately, and container
+ * provisioning. An agent on a laptop could claim a ticket, cut a branch, and
+ * discover `maestro` was never installed forty minutes later.
+ *
+ * **This is a caller, not a checker.** Every decision comes from
+ * `planToolchain`. Writing a second implementation is exactly the defect this
+ * change also fixes elsewhere — `verify-remote-env.mjs` grew its own toolchain
+ * check that forgot `minVersion`, so a container verified clean against a node
+ * older than the manifest demanded. One function, one verdict, no drift.
+ *
+ * **Two verdicts, not three.** `preflight-secrets` needs `unreachable` because
+ * a vault can fail to be asked. Probing a local binary cannot: it is present or
+ * it is not. The analogous trap — a tool whose version cannot be parsed — is
+ * already handled correctly upstream, because `planRequired` compares
+ * `found.version ?? "0"` and an unknown version loses every `minVersion`
+ * comparison. It fails closed without needing a verdict of its own.
+ *
+ * **The one thing tools have that credentials do not** is a self-service
+ * remedy. An `install` entry is pinned and checksummed, so "missing" splits
+ * into "Lisa can place this for you" and "you must act". A credential can never
+ * be self-provisioned, which is why that distinction has no secrets equivalent.
+ * @module preflight-tools
+ */
+
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { probe, readRemoteEnvConfig } from "./setup-remote-env.mjs";
+import { currentPlatform, planToolchain } from "./toolchain.mjs";
+import { toolFloor } from "./tool-floor.mjs";
+
+/** Plan actions that mean the agent cannot use the tool right now. */
+const BLOCKING = new Set(["missing", "invalid"]);
+
+/**
+ * Read the whole config, for the derivations that live outside `remoteEnv`.
+ *
+ * The floor is implied by `tracker`, `secrets.provider` and `quality`, none of
+ * which sit under `remoteEnv` — so this reads the root rather than reusing
+ * `readRemoteEnvConfig`, which deliberately returns only its own block.
+ *
+ * **Absent and damaged are not the same answer.** A project with no
+ * `.lisa.config.json` declares no tools, and `{}` states that correctly. A file
+ * that exists and does not parse states nothing — and returning `{}` for it
+ * derives an empty floor, which reports `ok` precisely when the declaration
+ * this check exists to enforce could not be read. That is the vacuous green
+ * `preflight-secrets` refuses in its own header, so this throws instead, the
+ * same way `readConfig` in `surfaces.mjs` does.
+ * @param {string} [cwd] Directory to look in.
+ * @returns {object} Parsed config root, empty only when the file is absent.
+ * @throws {Error} When the file exists but cannot be read or parsed.
+ */
+export function readConfigRoot(cwd = process.cwd()) {
+  const path = join(cwd, ".lisa.config.json");
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (err) {
+    throw new Error(
+      `${path} is not readable, so the tools it requires could not be ` +
+        `derived and nothing was checked: ${err.message}`
+    );
+  }
+}
+
+/**
+ * Merge the derived floor into a declared manifest.
+ *
+ * A derived tool that the project already declares is dropped rather than
+ * duplicated, and the declaration wins: a project that pinned `minVersion` for
+ * `gh` has said something more specific than the derivation knows, and
+ * overriding it would discard the more informed statement.
+ * @param {{require?: object[], install?: object[]}} tools Declared manifest.
+ * @param {Array<{name: string, reason: string}>} floor Derived tools.
+ * @returns {{tools: {require: object[], install?: object[]}, reasons: Record<string, string>}} Merged manifest.
+ */
+export function mergeFloor(tools, floor) {
+  const declared = new Set([
+    ...(tools.require ?? []).map(tool => tool.name),
+    ...(tools.install ?? []).map(tool => tool.name),
+  ]);
+  const added = floor.filter(entry => !declared.has(entry.name));
+  const reasons = Object.fromEntries(
+    floor.map(entry => [entry.name, entry.reason])
+  );
+  return {
+    tools: {
+      ...tools,
+      require: [
+        ...(tools.require ?? []),
+        ...added.map(entry => ({ name: entry.name })),
+      ],
+    },
+    reasons,
+  };
+}
+
+/**
+ * Check every required tool against this machine.
+ * @param {object} [config] Parsed config root.
+ * @param {object} [remoteEnv] Parsed `remoteEnv` block.
+ * @param {Function} [versionProbe] Version probe, injected for tests.
+ * @param {string} [platform] Platform key, injected for tests.
+ * @returns {{verdict: string, blocked: Array<{name: string, action: string, reason: string}>, installable: Array<{name: string, action: string, reason: string}>, reasons: Record<string, string>}}
+ */
+export function preflightTools(
+  config = readConfigRoot(),
+  remoteEnv = readRemoteEnvConfig(),
+  versionProbe = probe,
+  platform = currentPlatform()
+) {
+  const { tools, reasons } = mergeFloor(
+    remoteEnv.tools ?? {},
+    toolFloor(config)
+  );
+  if (!(tools.require ?? []).length && !(tools.install ?? []).length) {
+    return { verdict: "ok", blocked: [], installable: [], reasons };
+  }
+
+  // "local" because this runs where the agent is, and it is the surface word
+  // `appliesToSurface` already understands — a tool narrowed to ["remote"] is
+  // correctly ignored on a laptop rather than reported as missing there.
+  const plan = planToolchain(tools, versionProbe, "local", platform);
+  const blocked = plan.filter(step => BLOCKING.has(step.action));
+  const installable = plan.filter(step => step.action === "install");
+  return {
+    verdict: blocked.length || installable.length ? "missing" : "ok",
+    blocked,
+    installable,
+    reasons,
+  };
+}
+
+/**
+ * Render a verdict for whoever has to act on it.
+ * @param {object} result A {@link preflightTools} result.
+ * @returns {string} Operator-readable report, empty when nothing needs saying.
+ */
+export function reportTools(result) {
+  if (result.verdict === "ok") return "";
+
+  // The header tracks the exit code. Only a blocked tool is a failure — one
+  // Lisa can install is an action with a command attached, and calling that
+  // "FAILED" while exiting zero teaches readers that the word means nothing.
+  const lines = [
+    result.blocked.length
+      ? "Tooling preflight FAILED."
+      : "Tooling preflight — action available.",
+  ];
+  if (result.installable.length) {
+    lines.push(
+      ``,
+      `Lisa can install these itself — they are pinned and checksummed.`,
+      `Run /lisa:setup:local-env to place them:`,
+      ``
+    );
+    for (const step of result.installable) {
+      lines.push(`  ${step.name} — ${step.reason}`);
+    }
+  }
+  if (result.blocked.length) {
+    lines.push(
+      ``,
+      `These need you. Lisa has no pinned artifact it can place:`,
+      ``
+    );
+    for (const step of result.blocked) {
+      const why = result.reasons[step.name];
+      lines.push(`  ${step.name} — ${step.reason}`);
+      if (why) lines.push(`      required because ${why}`);
+    }
+    lines.push(
+      ``,
+      `Work needing one of these cannot be completed. Route the item to`,
+      `blocked with this reason rather than claiming it and stopping partway.`
+    );
+  }
+  return lines.join("\n");
+}
+
+/**
+ * CLI entry point. Prints the report and exits non-zero when anything blocks.
+ */
+function main() {
+  let result;
+  try {
+    result = preflightTools();
+  } catch (err) {
+    // A config that cannot be read is its own outcome, and it is not "ok". Said
+    // in the operator's vocabulary rather than as a stack trace, because this
+    // text is what the session-start hook injects for someone to act on.
+    console.error(
+      [
+        `Tooling preflight could NOT be completed.`,
+        ``,
+        `  reason: ${err.message}`,
+        ``,
+        `Nothing was checked, so this is not a report that the toolchain is`,
+        `fine. Repair the configuration, then start a new session.`,
+      ].join("\n")
+    );
+    process.exit(1);
+  }
+  const text = reportTools(result);
+  if (text) console.error(text);
+  if (result.blocked.length) process.exit(1);
+}
+
+/**
+ * Whether this module is the entry point node was asked to run.
+ *
+ * Both sides are realpath'd rather than compared as text: `import.meta.url` is
+ * the resolved path while `process.argv[1]` is whatever the caller typed, so a
+ * symlinked path — every git worktree, and every `/tmp` path on macOS — makes a
+ * raw comparison false. The module then loads, runs nothing, and exits 0, which
+ * is a readiness check reporting clean because it never ran. Same rule and same
+ * reasoning as `scripts/lib/invoked-as-script.mjs`, written out here because a
+ * plugin payload has no `./lib/` to import from.
+ * @param {string} moduleUrl This module's own `import.meta.url`.
+ * @param {string} [argv1] Entry path; defaults to `process.argv[1]`.
+ * @returns {boolean} Whether the CLI body should run.
+ */
+function invokedAsScript(moduleUrl, argv1 = process.argv[1]) {
+  if (!argv1) return false;
+  try {
+    return realpathSync(argv1) === realpathSync(fileURLToPath(moduleUrl));
+  } catch {
+    return false;
+  }
+}
+
+if (invokedAsScript(import.meta.url)) {
+  main();
+}

package/plugins/lisa-copilot/skills/lisa-setup-remote-env/scripts/tool-floor.mjs

@@ -0,0 +1,94 @@
+/**
+ * Derive the CLIs a project's own configuration already implies.
+ *
+ * The symmetric half of `routing-floor.mjs`. A credential and the binary that
+ * consumes it are the same question asked twice — can this agent do the work —
+ * and both were answered only by a hand-maintained list.
+ *
+ * `detect-tooling` already knows most of these pairings and states them well:
+ * "the work-item guardrails shell out to `gh` for every tracker read". But it
+ * knows them at *proposal* time, as suggestions a human runs a skill to see and
+ * then copies into config. Nothing derives them at runtime, so a project that
+ * never ran the skill — or ran it before it adopted Maestro — has a manifest
+ * that silently understates what its agents need.
+ *
+ * This promotes those pairings to a derivation. The floor is unioned into the
+ * required set, never written into config, so it cannot drift from the routing
+ * that produces it.
+ *
+ * Deliberately narrow. An entry belongs here only when the configuration that
+ * implies it makes the tool unavoidable — not merely likely. A project can have
+ * `quality.testCoverage` thresholds and run them through any runner, so no CLI
+ * is derived from that; `secrets.provider: "bitwarden"` on the other hand
+ * cannot resolve one credential without `bws`.
+ * @module tool-floor
+ */
+
+/**
+ * Config predicates that make a CLI unavoidable, with the reason to report.
+ *
+ * The reason is not decoration. A missing tool has two valid remedies — install
+ * it, or change the configuration that demands it — and an operator cannot pick
+ * between them without knowing which line of config is responsible.
+ */
+const DERIVATIONS = [
+  {
+    tool: "gh",
+    applies: cfg => cfg.tracker === "github" || cfg.source === "github",
+    reason: cfg =>
+      `${cfg.tracker === "github" ? "tracker" : "source"} is "github", and ` +
+      `the work-item guardrails shell out to gh for every tracker read`,
+  },
+  {
+    tool: "bws",
+    applies: cfg => cfg.secrets?.provider === "bitwarden",
+    reason: () =>
+      `secrets.provider is "bitwarden", and the CLI is how every secret is ` +
+      `resolved`,
+  },
+  {
+    tool: "doppler",
+    applies: cfg => cfg.secrets?.provider === "doppler",
+    reason: () => `secrets.provider is "doppler"`,
+  },
+  {
+    tool: "maestro",
+    // Keyed on the coverage block rather than a `.maestro` directory: config is
+    // the declaration that this project gates on Maestro, where a stray
+    // directory could be a leftover. `detect-tooling` uses the directory
+    // because it is guessing; here the project has already said so.
+    applies: cfg => cfg.quality?.e2eCoverage?.maestro !== undefined,
+    reason: () =>
+      `quality.e2eCoverage.maestro is configured, and nothing installs the ` +
+      `maestro binary`,
+  },
+];
+
+/**
+ * The CLIs a project's configuration makes mandatory.
+ * @param {object} [config] Parsed `.lisa.config.json` root.
+ * @returns {Array<{name: string, reason: string}>} Sorted derived tools.
+ */
+export function toolFloor(config = {}) {
+  return DERIVATIONS.filter(entry => safely(() => entry.applies(config)))
+    .map(entry => ({ name: entry.tool, reason: entry.reason(config) }))
+    .sort((left, right) => left.name.localeCompare(right.name));
+}
+
+/**
+ * Evaluate a predicate, treating a malformed config as "does not apply".
+ *
+ * A config shaped unexpectedly is a problem for the schema validator to report
+ * in its own vocabulary. Throwing here would make a readiness check the place a
+ * structural defect first surfaces, with a message about tools that names
+ * nothing an operator can act on.
+ * @param {Function} predicate Test to run.
+ * @returns {boolean} The result, or false when it threw.
+ */
+function safely(predicate) {
+  try {
+    return Boolean(predicate());
+  } catch {
+    return false;
+  }
+}

package/plugins/lisa-copilot/skills/lisa-setup-remote-env/scripts/verify-remote-env.mjs

@@ -25,8 +25,8 @@ import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 
-import { readRemoteEnvConfig } from "./setup-remote-env.mjs";
-import { extractVersion } from "./toolchain.mjs";
+import { probe, readRemoteEnvConfig } from "./setup-remote-env.mjs";
+import { planToolchain } from "./toolchain.mjs";
 
 /** Collected results, so every check runs before anything reports failure. */
 const results = [];
@@ -84,39 +84,21 @@ function node(args) {
 
 /**
  * Assert each declared tool is present at its pinned or minimum version.
+ *
+ * Delegates every decision to `planToolchain` rather than probing here. This
+ * function used to run its own loop, and the copy silently forgot `minVersion`:
+ * a `require` entry passed as long as the binary answered `--version` at all,
+ * so a container verified clean against a node older than the manifest
+ * demanded. The plan-side check rejected exactly what this one accepted.
+ *
+ * That is the same failure the note validators had before one shared module
+ * replaced them, and it recurs for the same reason — two implementations of one
+ * question cannot be kept in step by intention. There is now one.
  * @param {object} tools Toolchain manifest.
  */
 function verifyToolchain(tools) {
-  for (const tool of tools.require ?? []) {
-    try {
-      const out = execFileSync(tool.name, ["--version"], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-      });
-      check(true, `tool ${tool.name}`, extractVersion(out) ?? "present");
-    } catch {
-      check(false, `tool ${tool.name}`, "required but not present");
-    }
-  }
-  for (const tool of tools.install ?? []) {
-    try {
-      const out = execFileSync(tool.name, ["--version"], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-      });
-      const found = extractVersion(out);
-      check(
-        found === tool.version,
-        `tool ${tool.name}`,
-        `${found} (pin ${tool.version})`
-      );
-    } catch {
-      check(
-        false,
-        `tool ${tool.name}`,
-        `pinned ${tool.version} but not installed`
-      );
-    }
+  for (const step of planToolchain(tools, probe, "remote")) {
+    check(step.action === "present", `tool ${step.name}`, step.reason);
   }
 }
 

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

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

package/plugins/lisa-cursor/hooks/hooks.json

@@ -57,6 +57,9 @@
       },
       {
         "command": "${CURSOR_PLUGIN_ROOT}/hooks/setup-jira-cli.sh"
+      },
+      {
+        "command": "${CURSOR_PLUGIN_ROOT}/hooks/secrets-preflight.sh"
       }
     ],
     "subagentStart": [

package/plugins/lisa-cursor/hooks/secrets-preflight.sh

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+# Prove at session start that this agent can actually do the work: that the
+# credentials the project needs resolve, and that the CLIs it needs are on PATH.
+#
+# One hook for both because it is one question — can this agent do the work —
+# and an operator reading two separate reports has to assemble the answer
+# themselves. Both halves also share the same failure mode if split: two hooks
+# means two subprocess spawns on every session start, for a check that is silent
+# almost every time.
+#
+# Injects rather than blocks, and that is deliberate. The right response to a
+# missing credential or tool is for the agent to know before it claims work and
+# to route the item to blocked with a reason a human can act on — not for the
+# session to die. A session that cannot reach the vault can still write code,
+# review a PR, or answer a question; killing it would tax every session for a
+# minority need, and a control people route around enforces nothing.
+#
+# The hard gates live where they can afford to be hard: `lisa doctor` and CI
+# run the same two scripts and exit non-zero on them.
+#
+# Silent on success on purpose. A control that announces itself when everything
+# is fine trains its readers to skim past it, and then it is decoration.
+set -uo pipefail
+
+INPUT=$(cat 2>/dev/null || true)
+if [ -n "$INPUT" ]; then
+  HOOK_EVENT=$(printf '%s' "$INPUT" | jq -r '.hook_event_name // "SessionStart"' 2>/dev/null || echo "SessionStart")
+else
+  HOOK_EVENT="SessionStart"
+fi
+
+ROOT="${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}}"
+SECRETS="$ROOT/skills/lisa-secrets-access/scripts/preflight-secrets.mjs"
+TOOLS="$ROOT/skills/lisa-setup-remote-env/scripts/preflight-tools.mjs"
+
+command -v node >/dev/null 2>&1 || exit 0
+# The hook's whole output is one `jq -n` document. Without jq there is nothing
+# to write, so exiting is the only honest outcome — the alternative is a hook
+# that prints `jq: command not found` and exits 127, which reports a failure
+# from a check designed never to block. The doctor and CI gates run the same
+# two scripts without jq involved.
+command -v jq >/dev/null 2>&1 || exit 0
+
+# stderr carries each report; stdout is reserved for the hook's JSON. A script
+# that is absent (partial or older install) or fails to run at all contributes
+# nothing, because a broken hook must not manufacture a finding.
+REPORT=""
+for script in "$SECRETS" "$TOOLS"; do
+  [ -f "$script" ] || continue
+  # An escape hatch that is honest about what it costs, and scoped to what it
+  # names. Set when a surface has no secrets provider by design and the noise is
+  # not worth it; the doctor and CI gates are unaffected, so opting out here
+  # does not opt out of the check entirely. It must not also silence the
+  # TOOLING half — a variable about secrets that hides a missing `gh` or
+  # `maestro` is an opt-out from a check nobody opted out of.
+  if [ "$script" = "$SECRETS" ] && [ "${LISA_SKIP_SECRETS_PREFLIGHT:-}" = "1" ]; then
+    continue
+  fi
+  OUT=$(node "$script" 2>&1 >/dev/null) || true
+  [ -n "$OUT" ] || continue
+  [ -n "$REPORT" ] && REPORT+=$'\n\n'
+  REPORT+="$OUT"
+done
+
+[ -n "$REPORT" ] || exit 0
+
+CONTEXT="## Readiness preflight
+
+$REPORT"
+
+jq -n --arg event "$HOOK_EVENT" --arg ctx "$CONTEXT" \
+  '{"hookSpecificOutput": {"hookEventName": $event, "additionalContext": $ctx}}'