@codyswann/lisa 4.73.1 → 4.73.3

package/all/copy-overwrite/scripts/lisa-hooks/block-blind-automerge.sh

@@ -211,6 +211,7 @@ if [ -z "$command_str" ]; then
 fi
 
 if ! BLOCK_BLIND_AUTOMERGE_COMMAND="$command_str" python3 - <<'PY'
+import io
 import json
 import os
 import re
@@ -244,7 +245,41 @@ MERGE_SEPARATE_VALUE = {
 
 COMMAND_SEPARATORS = {
     ";", "|", "||", "&", "&&", "(", ")", "<", ">", ">>", "<<", "&|",
+    # `|&` pipes stdout AND stderr into the next command, so it ends a command
+    # exactly as `|` does. shlex emits it as one token, and before it was listed
+    # here `echo hi |& git commit --no-verify` read as a single `echo` command
+    # whose arguments happened to include git. The case terminators end a
+    # command the same way.
+    "|&", ";;", ";&", ";;&",
 }
+# shlex also GLUES adjacent punctuation into one token across distinct
+# operators: `(echo hi)|&git ...` arrives as `)|&`, which no set membership
+# test can recognise. An operator-only token is therefore re-split into the
+# operators it is made of, longest first. Redirections are kept whole and are
+# deliberately NOT separators, so `git commit 2>&1 -n` keeps its `-n` inside the
+# commit's argv scope.
+OPERATOR_ONLY = re.compile(r"^[();<>|&]+$")
+SHELL_OPERATOR = re.compile("|".join(
+    re.escape(operator) for operator in sorted(
+        COMMAND_SEPARATORS | {">|", "&>", "&>>", ">&", "<&", "<>", "<<<"},
+        key=lambda operator: (-len(operator), operator),
+    )
+))
+
+
+def split_operators(token):
+    """Split a glued operator-only token into the shell operators it holds.
+
+    Args:
+        token: One shlex token that was not read inside a quote or escape.
+
+    Returns:
+        The operators, longest first, or the token itself when it is not
+        made only of shell punctuation.
+    """
+    if OPERATOR_ONLY.match(token):
+        return SHELL_OPERATOR.findall(token)
+    return [token]
 
 # Shell wrappers whose `-c` argument is a command in a string rather than argv.
 # The outer argv names bash, so the arming is invisible without recursing once.
@@ -422,12 +457,40 @@ def shell_tokens(text):
     Returns:
         The token list, with `;`, `|`, `&&`, `(` and friends standing alone.
     """
-    lexer = shlex.shlex(
-        line_boundaries_as_separators(text), posix=True, punctuation_chars=True
-    )
+    stream = OperatorStream(line_boundaries_as_separators(text))
+    lexer = shlex.shlex(stream, posix=True, punctuation_chars=True)
     lexer.whitespace_split = True
     lexer.commenters = ""
-    return list(lexer)
+    stream.lexer = lexer
+    tokens = []
+    while True:
+        stream.literal_operator = False
+        token = lexer.get_token()
+        if token is None:
+            return tokens
+        # Quoted punctuation is an argument, never a boundary: a branch can be
+        # named `|&`, and `gh pr merge '|&' --auto` must keep `--auto` in the
+        # merge's own argv. Only real operator runs are split.
+        if stream.literal_operator:
+            tokens.append(
+                chr(0) + token if token in COMMAND_SEPARATORS else token
+            )
+        else:
+            tokens.extend(split_operators(token))
+
+
+class OperatorStream(io.StringIO):
+    """Remember punctuation read while shlex is inside a quote or escape."""
+
+    lexer = None
+    literal_operator = False
+
+    def read(self, size=-1):
+        value = super().read(size)
+        if (self.lexer is not None and self.lexer.state in {"'", '"', chr(92)}
+                and any(char in "();|&<>" for char in value)):
+            self.literal_operator = True
+        return value
 
 
 def is_gh(token):
@@ -493,6 +556,22 @@ def arms_auto_merge(argv):
     return False
 
 
+def literal_value(token):
+    """The argument a token stands for, without the quoted-separator marker.
+
+    `shell_tokens` prefixes a QUOTED separator with NUL so no scan stops at it.
+    That marker is for boundary checks only: a value handed to a gh probe
+    (a selector, a base ref, a repo) must be the argument the shell passes.
+
+    Args:
+        token: One token from `shell_tokens`.
+
+    Returns:
+        The token as the shell would pass it.
+    """
+    return token[1:] if token.startswith(chr(0)) else token
+
+
 def pr_selector(argv, separate_value=MERGE_SEPARATE_VALUE):
     """The PR the command names, as gh itself would read it.
 
@@ -518,7 +597,7 @@ def pr_selector(argv, separate_value=MERGE_SEPARATE_VALUE):
             index += 1
             continue
         if not token.startswith("-"):
-            return token
+            return literal_value(token)
     return None
 
 
@@ -538,7 +617,7 @@ def retarget_target(argv):
         if token in COMMAND_SEPARATORS:
             return None
         if token in BASE_FLAGS and index < len(argv):
-            return argv[index]
+            return literal_value(argv[index])
         if token.startswith("--base="):
             return token.split("=", 1)[1]
         if token in EDIT_SEPARATE_VALUE:
@@ -562,7 +641,7 @@ def repo_flag(tokens, start):
         if token in COMMAND_SEPARATORS:
             break
         if token in {"-R", "--repo"} and index + 1 < len(tokens):
-            return ["--repo", tokens[index + 1]]
+            return ["--repo", literal_value(tokens[index + 1])]
         if token.startswith("--repo="):
             return ["--repo", token.split("=", 1)[1]]
         index += 1

package/all/copy-overwrite/scripts/lisa-hooks/block-managed-file-edits.sh

@@ -597,7 +597,13 @@ ENV_SPLIT_UNRESOLVED = 42
 BACKSLASH = chr(92)
 NEWLINE = chr(10)
 
-STATEMENT_SEPARATORS = {";", "|", "||", "&", "&&", "(", ")", "&|"}
+# `|&` pipes stdout and stderr into the next command, and the case terminators
+# end a statement as `;` does. Without them `printf x |& tee <managed>` stayed
+# one statement whose command word was `printf`, so the `tee` write target was
+# never examined.
+STATEMENT_SEPARATORS = {
+    ";", "|", "||", "&", "&&", "(", ")", "&|", "|&", ";;", ";&", ";;&",
+}
 # Ordinary output, noclobber override, and combined stdout/stderr output.
 # shlex separates fd prefixes (e.g. 10>>) from the operator automatically.
 REDIRECT_OUT = {">", ">>", ">|", "&>", "&>>", ">&"}

package/all/copy-overwrite/scripts/lisa-hooks/block-no-verify.sh

@@ -271,7 +271,41 @@ def disables_verification(token):
 # tokens, so the invocation's boundary is a token the scan can stop at.
 COMMAND_SEPARATORS = {
     ";", "|", "||", "&", "&&", "(", ")", "<", ">", ">>", "<<", "&|",
+    # `|&` pipes stdout AND stderr into the next command, so it ends a command
+    # exactly as `|` does. shlex emits it as one token, and before it was listed
+    # here `echo hi |& git commit --no-verify` read as a single `echo` command
+    # whose arguments happened to include git. The case terminators end a
+    # command the same way.
+    "|&", ";;", ";&", ";;&",
 }
+# shlex also GLUES adjacent punctuation into one token across distinct
+# operators: `(echo hi)|&git ...` arrives as `)|&`, which no set membership
+# test can recognise. An operator-only token is therefore re-split into the
+# operators it is made of, longest first. Redirections are kept whole and are
+# deliberately NOT separators, so `git commit 2>&1 -n` keeps its `-n` inside the
+# commit's argv scope.
+OPERATOR_ONLY = re.compile(r"^[();<>|&]+$")
+SHELL_OPERATOR = re.compile("|".join(
+    re.escape(operator) for operator in sorted(
+        COMMAND_SEPARATORS | {">|", "&>", "&>>", ">&", "<&", "<>", "<<<"},
+        key=lambda operator: (-len(operator), operator),
+    )
+))
+
+
+def split_operators(token):
+    """Split a glued operator-only token into the shell operators it holds.
+
+    Args:
+        token: One shlex token that was not read inside a quote or escape.
+
+    Returns:
+        The operators, longest first, or the token itself when it is not
+        made only of shell punctuation.
+    """
+    if OPERATOR_ONLY.match(token):
+        return SHELL_OPERATOR.findall(token)
+    return [token]
 
 SHELL_PROGRAMS = {"bash", "dash", "ksh", "sh", "zsh"}
 MAX_SHELL_NESTING = 8
@@ -425,14 +459,28 @@ def shell_tokens(text):
     Returns:
         The token list, with `;`, `|`, `&&`, `(` and friends standing alone.
     """
-    lexer = shlex.shlex(
-        line_boundaries_as_separators(text), posix=True, punctuation_chars=True
-    )
+    stream = OperatorStream(line_boundaries_as_separators(text))
+    lexer = shlex.shlex(stream, posix=True, punctuation_chars=True)
     lexer.whitespace_split = True
     # shlex treats `#` as a comment introducer by default and would silently
     # truncate the rest of the line; `shlex.split` disables it, and so must this.
     lexer.commenters = ""
-    return list(lexer)
+    stream.lexer = lexer
+    tokens = []
+    while True:
+        stream.literal_operator = False
+        token = lexer.get_token()
+        if token is None:
+            return tokens
+        # Quoted punctuation is an argument, never a boundary: it stays whole,
+        # and a quoted separator is marked so no scan stops at it (a path or
+        # branch can be named `|&`). Only real operator runs are split.
+        if stream.literal_operator:
+            tokens.append(
+                chr(0) + token if token in COMMAND_SEPARATORS else token
+            )
+        else:
+            tokens.extend(split_operators(token))
 
 
 def cluster_skips_verification(cluster):
@@ -1048,6 +1096,10 @@ def resolve_script(token):
     """
     if COMPUTED_VALUE.search(token):
         return (None, "a computed path the guard cannot resolve before the shell does")
+    # A quoted separator carries a NUL marker from shell_tokens; the path the
+    # shell passes is the argument without it.
+    if token.startswith(chr(0)):
+        token = token[1:]
     text = os.path.expanduser(token.strip().strip("'\""))
     # `bash -` and a bare `-` read the script from stdin; there is no file.
     if not text or text == "-":
@@ -1998,9 +2050,12 @@ def flat_tokens(text):
             # shlex otherwise makes quoted ";" indistinguishable from a real
             # command boundary. Keep literal destinations as data, so a setter
             # cannot masquerade as a one-operand configuration read.
-            if token in COMMAND_SEPARATORS and stream.literal_operator:
-                token = "\x00" + token
-            tokens.append(token)
+            if stream.literal_operator:
+                if token in COMMAND_SEPARATORS:
+                    token = "\x00" + token
+                tokens.append(token)
+            else:
+                tokens.extend(split_operators(token))
         return [
             token
             for index, token in enumerate(tokens)

package/all/copy-overwrite/scripts/lisa-rails-prepush.mjs

@@ -68,7 +68,10 @@ export const main = async (remoteArgs = process.argv.slice(2)) => {
     // Import/call inside this boundary instead of forwarding raw Node bootstrap
     // stderr. The scanner receives exactly the buffered Git stream.
     const { main: scan } = await import("./lisa-history-secrets.mjs");
-    if ((await scan(["pre-push"], process.cwd(), input)) !== 0) failed = true;
+    // Git's remote arguments bound a new ref's range by what that remote
+    // already holds; without them a new branch rescans the whole history.
+    if ((await scan(["pre-push", ...remoteArgs], process.cwd(), input)) !== 0)
+      failed = true;
   } catch {
     console.error(
       "Managed history scanner is unavailable or damaged. Run full Lisa apply and retry; raw bootstrap errors are withheld."

package/all/copy-overwrite/scripts/lisa-work-item.mjs

@@ -12,6 +12,8 @@ import { createHash } from "node:crypto";
 import {
   chmodSync,
   existsSync,
+  lstatSync,
+  readlinkSync,
   mkdirSync,
   readFileSync,
   renameSync,
@@ -4515,7 +4517,28 @@ export function commitPendingLisaUpdate(ref, contract, cwd = process.cwd()) {
     rmSync(marker, { force: true });
     return;
   }
+  // The marker names paths, and a path is not the update: an edit made to one
+  // of these files after the session-start update would otherwise be swept
+  // into the update commit under its message (CodySwannGT/lisa#4393). Commit
+  // only when every file still holds the bytes the update recorded; a legacy
+  // marker with no digests cannot prove that, so it is left for a human too.
+  const changed = changedSinceUpdate(pending, files, cwd);
+  if (changed.length > 0) {
+    console.error(
+      `The pending Lisa ${pending.to} update was NOT committed automatically: ${pending.digests ? "these files changed after the update wrote them" : "its record predates content checks, so these files cannot be proved unchanged"}: ${changed.join(", ")}. Review them and commit the Lisa update as its own commit before feature work.`
+    );
+    return;
+  }
+  // Snapshot the index entries for these paths so a failed commit puts back
+  // exactly what the user had staged, rather than unstaging it.
+  const snapshot = run("git", ["ls-files", "-s", "-z", "--", ...files], {
+    cwd,
+  }).stdout;
+  // Set once the commit has landed, so a later failure (reading its tree,
+  // undoing it) is never reported as "not committed".
+  let landed = false;
   try {
+    const previous = git(["rev-parse", "--verify", "HEAD"], { cwd });
     git(["add", "--", ...files], { cwd });
     // `--only` commits exactly these paths, so a feature edit the user had
     // already staged stays staged and out of the update commit. The project's
@@ -4532,19 +4555,182 @@ export function commitPendingLisaUpdate(ref, contract, cwd = process.cwd()) {
       ],
       { cwd, timeout: 10 * 60 * 1000 }
     );
+    landed = true;
+    // `--only` reads the paths again at commit time, and the project's hooks
+    // run in between, so the comparison above does not by itself bind what
+    // was committed. Check the commit's own tree against the recorded
+    // identities; if anything differs, the commit is undone and the update
+    // left for a human, exactly as if the check above had failed.
+    const drifted = committedDrift(pending.digests, files, cwd);
+    if (drifted.length > 0) {
+      git(["reset", "--soft", previous], { cwd });
+      landed = false;
+      const restored = restoreIndexEntries(snapshot, files, cwd);
+      console.error(
+        `The pending Lisa ${pending.to} update was NOT committed automatically: these files changed while it was being committed: ${drifted.join(", ")}. The commit was undone${restored ? "" : ", but restoring what was staged for them failed; check `git status`"}. Review them and commit the Lisa update as its own commit before feature work.`
+      );
+      return;
+    }
     rmSync(marker, { force: true });
     console.log(
       `Committed the pending Lisa ${pending.to} update first, as its own commit, under ${ref}.`
     );
   } catch (error) {
-    run("git", ["reset", "--quiet", "--", ...files], {
-      cwd,
-      allowFailure: true,
-    });
+    if (landed) {
+      console.error(
+        `The pending Lisa ${pending.to} update was committed as HEAD, but it could not be verified or undone (${String(error?.message ?? error).split("\n")[0]}). Inspect HEAD before feature work; if it holds anything besides the Lisa update, undo it with git reset --soft HEAD~1.`
+      );
+      return;
+    }
+    const restored = restoreIndexEntries(snapshot, files, cwd);
     console.error(
-      `The pending Lisa ${pending.to} update could not be committed (${String(error?.message ?? error).split("\n")[0]}). Its files are still in the working tree; commit them as their own commit before feature work.`
+      `The pending Lisa ${pending.to} update could not be committed (${String(error?.message ?? error).split("\n")[0]}). Its files are still in the working tree; commit them as their own commit before feature work.${restored ? "" : " Restoring what was staged for them beforehand also failed; check `git status` before committing."}`
+    );
+  }
+}
+
+/**
+ * Pending files whose current bytes differ from what the update recorded.
+ *
+ * Recomputed exactly as the auto-update's `workingTreeDigests` records them:
+ * `<100644|100755> <blob id>` for a regular file, `120000 link:<target>` for a
+ * symlink (never hash-object, which follows the link), null for an absent
+ * path. A path the record does not carry, or one that is neither, counts as
+ * changed.
+ * @param {{digests?: Record<string, string | null>}} pending The marker.
+ * @param {string[]} files Pending paths still dirty.
+ * @param {string} cwd Repository directory.
+ * @returns {string[]} The paths that cannot be proved unchanged.
+ */
+function changedSinceUpdate(pending, files, cwd) {
+  const recorded = pending.digests;
+  if (!recorded || typeof recorded !== "object") return [...files];
+  const current = new Map();
+  const present = [];
+  for (const file of files) {
+    let stat;
+    try {
+      stat = lstatSync(resolve(cwd, file));
+    } catch {
+      current.set(file, null);
+      continue;
+    }
+    // Same identity the auto-update recorded: git mode plus blob id for a
+    // file (so an executable-bit change alone counts), the link target for a
+    // symlink (hash-object would follow it to whatever it now reaches).
+    if (stat.isSymbolicLink()) {
+      // A link that vanishes before it can be read stays unrecorded, which
+      // counts as changed.
+      try {
+        current.set(file, `120000 link:${readlinkSync(resolve(cwd, file))}`);
+      } catch {
+        continue;
+      }
+    } else if (stat.isFile())
+      present.push([file, stat.mode & 0o111 ? "100755" : "100644"]);
+  }
+  if (present.length > 0) {
+    const ids = run(
+      "git",
+      ["hash-object", "--", ...present.map(([file]) => file)],
+      {
+        cwd,
+        allowFailure: true,
+      }
+    )
+      .stdout.split("\n")
+      .map(line => line.trim())
+      .filter(Boolean);
+    if (ids.length !== present.length) return [...files];
+    present.forEach(([file, mode], index) =>
+      current.set(file, `${mode} ${ids[index]}`)
     );
   }
+  return files.filter(
+    file =>
+      !Object.hasOwn(recorded, file) ||
+      !current.has(file) ||
+      current.get(file) !== recorded[file]
+  );
+}
+
+/**
+ * Pending files whose entry in the new HEAD commit is not the recorded identity.
+ *
+ * Reads the commit's tree, not the working tree: a file absent from the record
+ * as null must be absent from HEAD, a `<mode> <blob>` record must match the
+ * tree entry exactly, and a `120000 link:<target>` record must be a symlink
+ * entry whose blob is that target.
+ * @param {Record<string, string | null>} recorded The marker's digests.
+ * @param {string[]} files Paths the commit carried.
+ * @param {string} cwd Repository directory.
+ * @returns {string[]} The paths the commit does not hold as recorded.
+ */
+function committedDrift(recorded, files, cwd) {
+  const listing = run("git", ["ls-tree", "-z", "HEAD", "--", ...files], {
+    cwd,
+    allowFailure: true,
+  });
+  // probe-direction: fail-closed — an unreadable tree counts every path as
+  // drifted, which undoes the commit rather than trusting it.
+  if (listing.status !== 0) return [...files];
+  const entries = new Map();
+  for (const record of listing.stdout.split("\0").filter(Boolean)) {
+    const tab = record.indexOf("\t");
+    const [mode, , blob] = record.slice(0, tab).split(" ");
+    entries.set(record.slice(tab + 1), { mode, blob });
+  }
+  return files.filter(file => {
+    const expected = recorded[file];
+    const entry = entries.get(file);
+    if (expected === null) return entry !== undefined;
+    if (entry === undefined) return true;
+    if (expected.startsWith("120000 link:")) {
+      if (entry.mode !== "120000") return true;
+      const target = run("git", ["cat-file", "blob", entry.blob], {
+        cwd,
+        allowFailure: true,
+      });
+      return (
+        target.status !== 0 ||
+        target.stdout !== expected.slice("120000 link:".length)
+      );
+    }
+    return `${entry.mode} ${entry.blob}` !== expected;
+  });
+}
+
+/**
+ * Put the index entries for `files` back to a `git ls-files -s -z` snapshot.
+ *
+ * A path absent from the snapshot was not in the index before, so it stays
+ * removed; every other path gets its recorded mode, blob and stage back.
+ *
+ * probe-direction: fail-closed — a failed git call returns false, which the
+ * caller reports to the user as an index it could not restore; it never reads
+ * as a successful restore.
+ * @param {string} snapshot NUL-delimited `ls-files -s` output taken beforehand.
+ * @param {string[]} files Paths the failed commit staged.
+ * @param {string} cwd Repository directory.
+ * @returns {boolean} Whether the restore succeeded.
+ */
+function restoreIndexEntries(snapshot, files, cwd) {
+  const entries = snapshot.split("\0").filter(Boolean);
+  // Drop every entry for these paths first, so a restored stage-0 entry does
+  // not sit beside anything `git add` wrote; then lay the snapshot back.
+  const removal = run(
+    "git",
+    ["update-index", "--force-remove", "--", ...files],
+    { cwd, allowFailure: true }
+  );
+  if (removal.status !== 0) return false;
+  if (entries.length === 0) return true;
+  const restore = run("git", ["update-index", "-z", "--index-info"], {
+    cwd,
+    input: entries.map(entry => `${entry}\0`).join(""),
+    allowFailure: true,
+  });
+  return restore.status === 0;
 }
 
 /**

package/all/copy-overwrite/scripts/npm-updater-helper-graph.json

@@ -132,7 +132,7 @@
       "children": []
     },
     "lib/history-secret-git.mjs": {
-      "sha256": "102276aef106e07b2b385fe8f2d3b54a9d30381633a22e07d5d74a5db9ddf320",
+      "sha256": "7e0939373625ef741f9a455a1959abfaef6c69961ed4a30044d4dab0fa2d9916",
       "staticImports": [
         "node:child_process",
         "node:fs",
@@ -315,7 +315,7 @@
       "children": []
     },
     "lib/npm-update-contract.mjs": {
-      "sha256": "553f75ff705aa1c03d6480a377b530c4096e836e716846fbb8bed989fd32c732",
+      "sha256": "d5c4bf65603bb212e1e8f99a39c38d9c5eff103b1f1b28966e20557bb7f3e85d",
       "staticImports": [
         "lib/automation-provenance-contract.mjs",
         "lib/github-attestation-verifier.mjs",
@@ -1165,7 +1165,7 @@
       "children": []
     },
     "lisa-history-secrets.mjs": {
-      "sha256": "966301ef764ddd5cfb37d26c22dd2dc4712496e67f63adddde9635fec6f6136c",
+      "sha256": "815fd6403aed6194d30939b59dc5ce894f7122a9da598acee4cd529a1b520de3",
       "staticImports": [
         "node:fs"
       ],
@@ -1204,7 +1204,7 @@
       "children": []
     },
     "lisa-rails-prepush.mjs": {
-      "sha256": "b963ce2647fd6daa95ceb5607691c5fb7d9f847a54d93a3d36718c5f7567905c",
+      "sha256": "31a61d5c53db977fb1d6ff8f125ec785db98e79290a4ea5225e4322d9915038d",
       "staticImports": [
         "node:child_process",
         "node:fs",
@@ -1258,7 +1258,7 @@
       "children": []
     },
     "lisa-work-item.mjs": {
-      "sha256": "64f01819287d902ed830285c256dd0a589330bce5be9c7b8b1f2563d811db287",
+      "sha256": "203f110fd4752ff89d906276a5115500a2f42289d00cb5435345c90c433edf46",
       "staticImports": [
         "lib/invoked-as-script.mjs",
         "node:child_process",

package/all/deletions.json

@@ -136,7 +136,8 @@
     ".claude/rules/security-audit-handling.md",
     ".claude/rules/verification.md",
     ".lisa-manifest",
-    ".github/workflows/lisa-update.yml"
+    ".github/workflows/lisa-update.yml",
+    "scripts/lisa-self-update.mjs"
   ],
   "keep": [
     "scripts/setup-deploy-key.sh",
@@ -277,6 +278,22 @@
     ".claude/rules/security-audit-handling.md": "needs-review",
     ".claude/rules/verification.md": "needs-review",
     ".lisa-manifest": "needs-review",
-    ".github/workflows/lisa-update.yml": "legacy: the scheduled Lisa Update workflow (4.67.0-4.68.x) opened update pull requests as a bot and so needed a PAT secret in every repository; replaced by the local session-start auto-update (CodySwannGT/lisa#4337), which needs no token"
+    ".github/workflows/lisa-update.yml": "legacy: the scheduled Lisa Update workflow (4.67.0-4.68.x) opened update pull requests as a bot and so needed a PAT secret in every repository; replaced by the local session-start auto-update (CodySwannGT/lisa#4337), which needs no token",
+    "scripts/lisa-self-update.mjs": "legacy: the self-update script (4.67.0-4.68.x) only ever ran from the scheduled Lisa Update workflow, retired with it in CodySwannGT/lisa#4337; removed only while unedited and unreferenced (CodySwannGT/lisa#4393)"
+  },
+  "retireUnmodified": {
+    ".github/workflows/lisa-update.yml": [
+      "5fb8822126277d0e4c89d3086857653f313f74a13d96f3aeeae97a0f4ccd81b6",
+      "7fd71e48b7b84460eeef86e2f8e00b59001bd23071a54a9406d8e7e604e7fc4d",
+      "9c1c05ffe39a6d5e41a3e82afbbc227097e071b26d2bbc56281ef1373c5a035d"
+    ],
+    "scripts/lisa-self-update.mjs": [
+      "1a455b97fc2e978a3bd039e327067b4c7ced7395808eed8eb4baa25c2b9c05e7",
+      "37f02f512e8d347885c302612895873087e0a62bb81f22436862764ff26c8a06",
+      "80d07132cffc8532e79f75acb1d1053c034800bec9b81b354131d4248934b02e",
+      "80dc15053af22133cfe50e48484b24b098eb9f2095999b649694ad11ce64175a",
+      "a123e9cdc7b090cec1ebaad1061487ed3fe7ae41ff29114182decb739c58ca7e",
+      "afbc340a6512e495b80ddfd327202812fc4ae333be8b6bfad74fb6d46df6fdca"
+    ]
   }
 }