@codyswann/lisa 4.50.5 → 4.50.7

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-wiki",
-  "version": "4.50.5",
+  "version": "4.50.7",
   "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-setup-remote-env/scripts/preflight-tools.mjs

@@ -15,9 +15,25 @@
  * 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
+ * **Three verdicts, and the third one was learned the hard way.** The original
+ * header here claimed two sufficed: `preflight-secrets` needs `unreachable`
+ * because a vault can fail to be asked, and "probing a local binary cannot: it
+ * is present or it is not." That sentence was true of probing and false of this
+ * module, because one branch of `planToolchain` never probed at all — an
+ * install entry with no pin for the running platform short-circuited to
+ * `invalid` before the binary was looked for. So a `bws` that was installed, on
+ * PATH, and resolving secrets in the very same session was reported under
+ * "These need you", next to an instruction to route the work to blocked. Four
+ * operator sessions believed it.
+ *
+ * The third tier is `unverified`: present and usable, but with no pin for this
+ * platform, so Lisa can neither reinstall it nor say where it came from. That
+ * is a real thing to know — an unpinned binary is a supply-chain claim nobody
+ * checked — and it is emphatically not a reason to stop. Availability and
+ * provenance are two questions, and answering the first with the second is the
+ * defect this tier exists to prevent recurring.
+ *
+ * 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.
@@ -34,12 +50,44 @@ 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 {
+  compareVersions,
+  currentPlatform,
+  planToolchain,
+} from "./toolchain.mjs";
 import { toolFloor } from "./tool-floor.mjs";
 
-/** Plan actions that mean the agent cannot use the tool right now. */
+/**
+ * Plan actions that mean the agent cannot use the tool right now.
+ *
+ * `invalid` is here because most of its causes really are stops — an unpinned
+ * version, a malformed `platforms` map, an unknown install method. The one
+ * cause that is not, an entry with no pin for this platform whose binary is
+ * nonetheless on PATH, is lifted out below before this set is applied.
+ */
 const BLOCKING = new Set(["missing", "invalid"]);
 
+/**
+ * Whether an unpinnable entry is nonetheless usable on this machine.
+ *
+ * Presence-only, and deliberately not a skip. Dropping the entry entirely would
+ * report clean for a tool that is neither pinned nor installed, which is the
+ * vacuous green this module refuses everywhere else. So the probe still decides
+ * — it just gets asked, which on this branch it previously never was.
+ *
+ * A declared `minVersion` still bites. The pin is unusable here (it names an
+ * artifact for another platform), but a minimum is a statement about the tool
+ * rather than about the download, and a binary below it cannot do the work.
+ * @param {object} step One `planToolchain` decision.
+ * @param {Record<string, string>} minVersions Declared minimums by tool name.
+ * @returns {boolean} Whether the tool is present and good enough to use.
+ */
+function usableWithoutPin(step, minVersions) {
+  if (!step.unpinnedForPlatform || !step.found?.present) return false;
+  const floor = minVersions[step.name];
+  return !floor || compareVersions(step.found.version ?? "0", floor) >= 0;
+}
+
 /**
  * Read the whole config, for the derivations that live outside `remoteEnv`.
  *
@@ -109,7 +157,7 @@ export function mergeFloor(tools, floor) {
  * @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>}}
+ * @returns {{verdict: string, blocked: Array<{name: string, action: string, reason: string}>, installable: Array<{name: string, action: string, reason: string}>, unverified: Array<{name: string, action: string, reason: string}>, reasons: Record<string, string>}}
  */
 export function preflightTools(
   config = readConfigRoot(),
@@ -122,19 +170,59 @@ export function preflightTools(
     toolFloor(config)
   );
   if (!(tools.require ?? []).length && !(tools.install ?? []).length) {
-    return { verdict: "ok", blocked: [], installable: [], reasons };
+    return {
+      verdict: "ok",
+      blocked: [],
+      installable: [],
+      unverified: [],
+      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 minVersions = Object.fromEntries(
+    (tools.install ?? [])
+      .filter(tool => tool.minVersion)
+      .map(tool => [tool.name, tool.minVersion])
+  );
+  const usable = new Set(
+    plan
+      .filter(step => usableWithoutPin(step, minVersions))
+      .map(step => step.name)
+  );
+  // Restated in this module's own vocabulary rather than passed through.
+  // `resolvePlatform`'s message is written for someone repairing a manifest —
+  // "add a block for darwin-arm64 with its own url and sha256" — and reads as a
+  // demand. What the reader here needs is the availability answer first and the
+  // provenance caveat second, because only one of the two affects whether they
+  // can start work.
+  const unverified = plan
+    .filter(step => usable.has(step.name))
+    .map(step => ({
+      ...step,
+      action: "unverified",
+      reason:
+        `${step.name} ${step.found.version ?? "(version unknown)"} is on ` +
+        `PATH and usable, but the manifest pins no artifact for ${platform}, ` +
+        `so Lisa cannot reinstall it or say where it came from`,
+    }));
+  const blocked = plan.filter(
+    step => BLOCKING.has(step.action) && !usable.has(step.name)
+  );
   const installable = plan.filter(step => step.action === "install");
+  if (blocked.length || installable.length)
+    return { verdict: "missing", blocked, installable, unverified, reasons };
+  // A note is not a failure and must not exit non-zero, but it does have to be
+  // said — an "ok" verdict renders nothing at all, which would drop the only
+  // signal this tier exists to carry.
   return {
-    verdict: blocked.length || installable.length ? "missing" : "ok",
+    verdict: unverified.length ? "notice" : "ok",
     blocked,
     installable,
+    unverified,
     reasons,
   };
 }
@@ -150,11 +238,14 @@ export function reportTools(result) {
   // 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.",
-  ];
+  const header = () => {
+    if (result.blocked.length) return "Tooling preflight FAILED.";
+    if (result.installable.length)
+      return "Tooling preflight — action available.";
+    // Nothing to do and nothing to fix; the note below is the whole message.
+    return "Tooling preflight passed, with a note.";
+  };
+  const lines = [header()];
   if (result.installable.length) {
     lines.push(
       ``,
@@ -183,6 +274,21 @@ export function reportTools(result) {
       `blocked with this reason rather than claiming it and stopping partway.`
     );
   }
+  if (result.unverified.length) {
+    lines.push(
+      ``,
+      `Installed, but Lisa did not put them there and cannot vouch for them:`,
+      ``
+    );
+    for (const step of result.unverified) {
+      lines.push(`  ${step.name} — ${step.reason}`);
+    }
+    lines.push(
+      ``,
+      `Nothing here blocks your work — these tools are usable right now. Add a`,
+      `pin for this platform when you want Lisa able to verify or replace them.`
+    );
+  }
   return lines.join("\n");
 }
 

package/plugins/src/base/skills/lisa-setup-remote-env/scripts/toolchain.mjs

@@ -146,6 +146,18 @@ function planInstallable(tool, found, pinIsFloor = false) {
 /** Surfaces a manifest entry may name. */
 const KNOWN_SURFACES = new Set(["local", "remote"]);
 
+/**
+ * Marks the one resolution failure that is a question about *this machine*.
+ *
+ * A `platforms` map that is not an object is a broken declaration, and nothing
+ * on PATH redeems it. A map that simply has no block for the running platform
+ * is a different statement: the manifest cannot say what Lisa should place
+ * here, which says nothing at all about what is already here. Callers that need
+ * to tell those apart get a code rather than a regex over the message, because
+ * a message is prose written for an operator and will be rewritten.
+ */
+export const NO_PIN_FOR_PLATFORM = "no-pin-for-platform";
+
 /**
  * The platform key a manifest entry is resolved against.
  *
@@ -197,13 +209,15 @@ export function resolvePlatform(tool, platform = currentPlatform()) {
   const block = platforms[platform];
   if (!block) {
     const known = Object.keys(platforms).sort().join(", ");
-    throw new Error(
+    const err = new Error(
       `${tool.name}: no pin for ${platform}.\n` +
         `Declared platforms: ${known || "(none)"}.\n` +
         `Add a block for ${platform} with its own url and sha256, or drop the ` +
         `tool from this surface. Guessing an artifact would defeat the ` +
         `checksum.`
     );
+    err.code = NO_PIN_FOR_PLATFORM;
+    throw err;
   }
   // The platform block wins over the shared fields, and `platforms` itself is
   // dropped so a resolved entry is indistinguishable from a flat one — that is
@@ -265,11 +279,17 @@ export function appliesToSurface(tool, surface) {
  * `require` entries are deliberately not resolved: they carry a name and a
  * minimum version, nothing platform-specific, and inventing a per-platform shape
  * for them would be ceremony with no artifact behind it.
+ *
+ * Every entry is probed, including one with no pin for this platform. That
+ * entry's verdict is still `invalid`, because provisioning genuinely cannot
+ * proceed — but `found` and `unpinnedForPlatform` travel with it so a caller
+ * asking about availability rather than provisioning has the answer instead of
+ * having to infer one from the other.
  * @param {{require?: object[], install?: object[]}} tools Manifest.
  * @param {(name: string) => {version: string|null, present: boolean}} probe Version probe.
  * @param {string} [surface] Surface being provisioned.
  * @param {string} [platform] Platform key to resolve install entries against.
- * @returns {Array<{name: string, action: string, reason: string, tool?: object}>} Ordered decisions.
+ * @returns {Array<{name: string, action: string, reason: string, tool?: object, found?: {version: string|null, present: boolean}, unpinnedForPlatform?: boolean}>} Ordered decisions.
  */
 export function planToolchain(
   tools,
@@ -287,7 +307,27 @@ export function planToolchain(
     try {
       resolved = resolvePlatform(tool, platform);
     } catch (err) {
-      plan.push({ name: tool.name, action: "invalid", reason: err.message });
+      // Ask the probe anyway, and carry its answer alongside the verdict.
+      //
+      // The verdict itself is right and does not change: Lisa cannot place an
+      // artifact it has no pin for. But "can Lisa provision this here?" and
+      // "can the agent use this right now?" are different questions, and
+      // skipping the probe on this branch left the second one unanswerable —
+      // so `preflight-tools` answered it with the first, and reported a `bws`
+      // that was installed, on PATH, and resolving secrets in the same session
+      // as a blocker that work had to be routed around.
+      //
+      // Only the missing-pin case gets a probe result. A malformed `platforms`
+      // map is a broken declaration rather than a fact about this machine, and
+      // a binary happening to be on PATH does not redeem it.
+      plan.push({
+        name: tool.name,
+        action: "invalid",
+        reason: err.message,
+        ...(err.code === NO_PIN_FOR_PLATFORM
+          ? { unpinnedForPlatform: true, found: probe(tool.name) }
+          : {}),
+      });
       continue;
     }
     // The resolved entry travels with the decision so the installer never has to

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

@@ -51,6 +51,16 @@ export const RETAINED_RELEASES = Object.freeze([
   // refusing to execute bytes it trusted yesterday. Rereading the tag is the
   // only sanctioned way to keep it: the digest is derived, never copied.
   "v4.26.1",
+  // The 1.7.0 guard, as the 50 releases from `4.22.13` through `4.26.0`
+  // published it. Commit 48c936bb9 moved the workspace guard and regeneration
+  // replaced the outgoing row instead of adding beside it, so the digest those
+  // 50 shipped was revoked and nothing noticed. Re-measured: 50 tags carrying
+  // it, bounded on both sides — v4.22.12 differs, v4.26.1 differs.
+  //
+  // `v4.17.16` above also certifies a 1.7.0 guard; the two are DIFFERENT bytes
+  // under the same contract version, which is why retention is a ref list and
+  // not a contract list.
+  "v4.26.0",
 ]);
 
 const digest = bytes => createHash("sha256").update(bytes).digest("hex");