@codyswann/lisa 4.43.0 → 4.44.0

package/all/copy-overwrite/scripts/lisa-hooks/worktree-binding-guard.mjs

@@ -50,7 +50,13 @@
  */
 
 import { execFileSync } from "node:child_process";
-import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import {
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 
@@ -151,6 +157,258 @@ function mainCheckout(cwd) {
   return null;
 }
 
+/**
+ * How much of an executed script this guard will read, in bytes.
+ *
+ * A generated fixture can be megabytes, and a guard that reads all of it on
+ * every Bash call is a guard someone switches off.
+ */
+const SCRIPT_READ_LIMIT = 256 * 1024;
+
+/**
+ * Programs that take their operands as DATA and never execute them.
+ *
+ * The same split `block-direct-issue-create.sh` makes, and for the same reason
+ * it had to: a guard that opens every file a command names, then judges the
+ * COMMAND by that FILE's contents, refuses ordinary inspection. Reading a
+ * script that visits another worktree is not visiting it.
+ *
+ * The list is an exemption, not an allowlist. Anything unrecognised is
+ * FOLLOWED, because an interpreter roster fails open on the runner nobody
+ * enumerated.
+ */
+const READ_ONLY_PROGRAMS = new Set([
+  "awk",
+  "basename",
+  "cat",
+  "cksum",
+  "cmp",
+  "comm",
+  "cut",
+  "diff",
+  "dirname",
+  "du",
+  "file",
+  "find",
+  "grep",
+  "egrep",
+  "fgrep",
+  "head",
+  "less",
+  "ls",
+  "md5",
+  "md5sum",
+  "more",
+  "nl",
+  "od",
+  "realpath",
+  "rg",
+  "sed",
+  "sha1sum",
+  "sha256sum",
+  "sort",
+  "stat",
+  "strings",
+  "tail",
+  "tee",
+  "tr",
+  "uniq",
+  "wc",
+  "xxd",
+]);
+
+/** Interpreters whose first non-option operand is the file they run. */
+const EXECUTING_INTERPRETERS = new Set([
+  "bash",
+  "dash",
+  "ksh",
+  "node",
+  "perl",
+  "python",
+  "python3",
+  "ruby",
+  "sh",
+  "zsh",
+  "bun",
+  "deno",
+  "tsx",
+]);
+
+/** Shell builtins that run a file in the CURRENT shell. */
+const SOURCE_BUILTINS = new Set([".", "source"]);
+
+/** Where one command ends and the next begins. */
+const COMMAND_SEPARATORS = /\|\||&&|[;|&\n]/u;
+
+/**
+ * Split a command into tokens, honouring simple quoting.
+ *
+ * Deliberately simple, and the guard fails OPEN when it is not enough — see
+ * {@link scriptReachingForeignTree}. A tokeniser that guessed would be worse
+ * than one that says it does not know.
+ */
+function tokenise(segment) {
+  const tokens = segment.match(/"[^"]*"|'[^']*'|[^\s]+/gu) ?? [];
+  return tokens.map(token => token.replace(/^["']|["']$/gu, ""));
+}
+
+/**
+ * The path this command EXECUTES, or null.
+ *
+ * The command-position question. A path anywhere else is an argument, and an
+ * argument is data.
+ */
+function executedPath(segment) {
+  const tokens = tokenise(segment);
+  if (tokens.length === 0) return null;
+  const [head, ...rest] = tokens;
+  const program = head.split("/").pop() ?? "";
+  if (READ_ONLY_PROGRAMS.has(program)) return null;
+  if (SOURCE_BUILTINS.has(program)) return rest[0] ?? null;
+  if (!EXECUTING_INTERPRETERS.has(program)) {
+    // A command word that is itself a file runs by its shebang.
+    return head.includes("/") ? head : null;
+  }
+  // A known interpreter: the first operand that is not an option.
+  const operand = rest.find(token => !token.startsWith("-"));
+  return operand ?? null;
+}
+
+/**
+ * A worktree root other than `bound` that this text reaches into, or null.
+ *
+ * ## Why this does not enumerate `cd`
+ *
+ * The redirect spellings — `cd`, `git -C`, `--work-tree`, `--git-dir`, a
+ * subshell, `env -C`, a variable holding the path — are an open set, and
+ * enumerating them is the failure this arm exists to end
+ * (CodySwannGT/lisa#3927 states it for the sibling guard). So the question is
+ * inverted the same way the filing guard inverted its own: not *which syntax
+ * moves*, which is unbounded, but *which tokens name a directory in another
+ * worktree*, which is bounded by the file.
+ *
+ * A path only has to RESOLVE. How it arrived does not matter, which is what
+ * makes an unenumerated spelling reach the same verdict as `cd`.
+ *
+ * ## Why comments are stripped first
+ *
+ * A script that merely MENTIONS a sibling worktree — a usage line, a comment,
+ * a log message — would otherwise be refused for describing the thing rather
+ * than doing it. Prose about a subject is the likeliest text to contain the
+ * subject's shapes, and the population that writes it is the people
+ * documenting the guard. A parity classifier elsewhere in this repository was
+ * fooled by exactly that and was caught only by a known-answer control.
+ */
+function foreignTreeIn(text, bound, cwd) {
+  const code = text
+    .split("\n")
+    .map(line => line.replace(/^\s*#.*$/u, ""))
+    .join("\n");
+  for (const raw of code.match(/[^\s'";|&()<>]+/gu) ?? []) {
+    const token = raw.replace(/^["']|["']$/gu, "");
+    if (!token.includes("/")) continue;
+    const candidate = isAbsolute(token) ? token : join(cwd, token);
+    let root;
+    try {
+      if (!statSync(candidate).isDirectory()) continue;
+      root = worktreeRoot(realpathSync(candidate));
+    } catch {
+      continue;
+    }
+    if (root && root !== bound) return root;
+  }
+  return null;
+}
+
+/**
+ * The foreign worktree an executed script reaches, or null.
+ *
+ * ## Why this arm exists at all
+ *
+ * The check above compares `payload.cwd` against the bound root, and that is
+ * the right comparison — but **`payload.cwd` is sampled before the child
+ * process runs**. A script that changes directory internally moves AFTER the
+ * guard has measured. The guard is not wrong about the target; it is right
+ * about a target that stops being the target one instruction later.
+ *
+ * A measurement taken before execution cannot bind what execution does
+ * (CodySwannGT/lisa#3924). So the only thing left is to read what is about to
+ * run.
+ *
+ * ## What this arm does NOT cover, stated rather than implied
+ *
+ * An INLINE redirect — `cd B && git status`, `git -C B status` — is not
+ * refused here. Those are already refused by the runtime's own worktree
+ * isolation, and duplicating a control is how two controls drift into
+ * disagreeing. The scripted form is the one neither covers, and it is the only
+ * cell this arm fills.
+ *
+ * ## A relative script path is resolved against `payload.cwd`, and that is a
+ * KNOWN limitation shared with `parity-safety-net.sh`
+ *
+ * CodySwannGT/lisa#3933, filed against that guard, is the same defect: a
+ * relative token is resolved against the hook process's working directory, not
+ * against the directory the command will have once it runs its own leading
+ * `cd`. So `cd <other tree> && bash scripts/foo.sh` reads THIS tree's copy of
+ * `scripts/foo.sh` and reports on it with full confidence.
+ *
+ * It matters here for the same reason it matters there: on a machine running
+ * many worktrees of one repository, every tree holds its own copy of every
+ * script at the same relative path, and they differ by whatever each lane is
+ * doing. A confident scan of the wrong copy is wrong in both directions, and
+ * the silent one — the copy that will run reaches out, the copy that was read
+ * does not — is the direction this arm exists to prevent.
+ *
+ * NOT fixed here on purpose. #3933 is assigned and its options (honour a
+ * leading `cd`, or fail closed when the effective cwd is uncertain) belong in
+ * one place rather than two: a second implementation of the same resolution is
+ * how two guards drift into disagreeing about which file a command runs.
+ * When that lands, this call site should adopt whatever it produces.
+ *
+ * The exposure here is narrower than there. This arm is reached only after the
+ * session has been confirmed to be in its bound worktree, so the common case
+ * is a relative path resolving inside the tree the session is actually in.
+ *
+ * Fails OPEN and says so, like every other undecidable case in this file.
+ */
+function scriptReachingForeignTree(payload, bound) {
+  const command = payload.tool_input?.command;
+  if (typeof command !== "string" || !command) return null;
+  for (const segment of command.split(COMMAND_SEPARATORS)) {
+    const named = executedPath(segment);
+    if (!named) continue;
+    const path = isAbsolute(named) ? named : join(payload.cwd, named);
+    let text;
+    try {
+      if (statSync(path).size > SCRIPT_READ_LIMIT) {
+        say(`${path} is too large to inspect; NOT enforcing on it`);
+        continue;
+      }
+      text = readFileSync(path, "utf8");
+    } catch {
+      // Not a readable file: nothing was executed that this can read.
+      continue;
+    }
+    const foreign = foreignTreeIn(text, bound, payload.cwd);
+    if (foreign) return { script: path, foreign };
+  }
+  return null;
+}
+
+function reachesOut(script, foreign, bound) {
+  return refuse([
+    "worktree-binding-guard: this command runs a script that reaches into",
+    "another worktree.",
+    `  script:    ${script}`,
+    `  reaches:   ${foreign}`,
+    `  bound to:  ${bound}`,
+    "The directory change lives inside the file, so it happens after this",
+    "guard has measured where the session is. Run the work from the tree it",
+    "belongs to, or acknowledge the move:",
+    acceptanceLine(foreign),
+  ]);
+}
+
 function stateFile(sessionId) {
   const home = process.env.LISA_STATE_HOME || join(homedir(), ".lisa");
   return join(home, "worktree-binding", `${sessionId}.json`);
@@ -331,6 +589,10 @@ function evaluate(payload) {
     return 0;
   }
   if (state.boundRoot !== observed) return displaced(state.boundRoot, observed);
+  // Last, and only once the session is provably where it should be: a script
+  // that moves somewhere else after this check has already run.
+  const reach = scriptReachingForeignTree(payload, observed);
+  if (reach) return reachesOut(reach.script, reach.foreign, observed);
   return 0;
 }
 

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

@@ -2460,8 +2460,11 @@ function remoteDefaultRef(remote) {
  * the rule is unchanged and now applied to the unit it was always about.
  * @param {string} input The pre-push stdin stream.
  * @param {string} remote Remote being pushed to.
- * @returns {{localRef: string|undefined, commits: string[]}[]} One entry per
- *   ref update that introduces commits.
+ * @returns {{localRef: string|undefined, commits: string[], scope: string[]}[]}
+ *   One entry per ref update that introduces commits. `scope` is the rev-list
+ *   argument vector the commit list came from, kept so a later question about
+ *   the same range — see {@link ancestryUnreachable} — is asked of the range
+ *   itself rather than re-derived from a list that has already lost its bounds.
  */
 function parsePushGroups(input, remote) {
   const groups = [];
@@ -2488,14 +2491,15 @@ function parsePushGroups(input, remote) {
     groups.push({
       localRef,
       commits: git(args).split("\n").filter(Boolean),
+      scope: args,
     });
   }
   if (groups.length === 0 && input.trim() === "") {
+    const args = ["rev-list", "HEAD", "--not", `--remotes=${remote}`];
     groups.push({
       localRef: undefined,
-      commits: git(["rev-list", "HEAD", "--not", `--remotes=${remote}`])
-        .split("\n")
-        .filter(Boolean),
+      commits: git(args).split("\n").filter(Boolean),
+      scope: args,
     });
   }
   return groups;
@@ -4236,14 +4240,100 @@ function validateCommit(args) {
  * that answer into silence.
  * @param {string} input The pre-push stdin stream.
  * @param {string} remote Remote being pushed to.
- * @returns {{localRef: string|undefined, commits: string[]}[]} Groups to check.
+ * @returns {{localRef: string|undefined, commits: string[], scope: string[]}[]}
+ *   Groups to check.
  */
 function pushGroups(input, remote) {
   const parsed = parsePushGroups(input, remote);
   const carrying = parsed.filter(group => group.commits.length > 0);
   return carrying.length > 0
     ? carrying
-    : [{ localRef: parsed[0]?.localRef, commits: [] }];
+    : [{ localRef: parsed[0]?.localRef, commits: [], scope: [] }];
+}
+
+/**
+ * Whether this range reaches back to the beginning of history.
+ *
+ * THE QUESTION THIS ANSWERS IS "IS MY SCOPE STILL VALID", not "is this commit
+ * traceable", and that is the whole of CodySwannGT/lisa#3719. The new-branch
+ * lane bounds itself with `--not --remotes=<remote>`, which is exact while
+ * reachability holds and silently unbounded the moment it does not. A history
+ * rewrite gives every commit a new object id, so a branch created before one
+ * shares NOTHING with the rewritten remote: the exclusion set removes nothing,
+ * the entire history falls into the range, and the gate then refuses on a
+ * stranger's years-old commit whose work item closed long ago. It computes a
+ * correct answer to the wrong question, and nothing in the refusal says so.
+ *
+ * A ROOT COMMIT IN RANGE IS THE DISCRIMINATOR, and it is deliberately not a
+ * size heuristic. A range that legitimately belongs to one branch begins at a
+ * base the remote can still reach, so the walk stops there — reaching a
+ * parentless commit means it did not stop anywhere, which is the unbounded case
+ * itself rather than a proxy for it. A long branch stays a long branch.
+ *
+ * `--max-parents=0` re-asks the range's OWN rev-list, so the answer costs one
+ * git call whatever the history's size. Filtering the returned commit list
+ * instead would spawn one child per commit — thousands of them in exactly the
+ * case this detects, inside a push gate.
+ * @param {{commits: string[], scope: string[]}} group One pushed ref's range.
+ * @param {string} remote Remote being pushed to.
+ * @returns {boolean} True when the range runs to a parentless commit.
+ */
+export function ancestryUnreachable(group, remote) {
+  if (group.commits.length === 0 || group.scope.length === 0) return false;
+  // A repository's FIRST push carries its root commit legitimately: nothing is
+  // published yet, so the exclusion set is empty because there is nothing to
+  // exclude, not because history moved. Reading that as a rewrite would make
+  // every new repository unpushable — the same defect, inverted.
+  // `--format` is presentation only, and deliberately not asserted on: this
+  // reads the ANSWER's emptiness, not its shape, so emptying the format still
+  // prints for-each-ref's default line for each ref and still prints nothing
+  // for none. A hand-run mutant emptying it survives, and is equivalent rather
+  // than a test gap — the ref pattern beside it is the argument that decides
+  // the answer, and a mutant emptying THAT is killed.
+  const published = git([
+    "for-each-ref",
+    "--count=1",
+    "--format=%(refname)",
+    `refs/remotes/${remote}/`,
+  ]);
+  if (published === "") return false;
+  return git([...group.scope, "--max-parents=0"]) !== "";
+}
+
+/**
+ * The refusal for a range whose base the remote can no longer reach.
+ *
+ * Deliberately says NOTHING about work items. The defect being repaired is that
+ * this push was refused over a stranger's closed ticket, so a message that
+ * still argues about tickets — even the right ones — reproduces the
+ * misdirection at a different address. `selfExplanatory` suppresses the
+ * five-gate checklist for the same reason it is suppressed on the
+ * push-destination refusal: no gate here is cleared by naming a ticket.
+ * @param {string|undefined} localRef The ref being pushed.
+ * @returns {TrackingError} The refusal to raise.
+ */
+export function unreachableAncestryRefusal(localRef) {
+  const branch = localRef
+    ? pushedBranchName(localRef) || localRef
+    : "this branch";
+  const error = new TrackingError(
+    `The commits on ${branch} are no longer reachable from "origin", so this ` +
+      `push cannot tell which of them the branch actually adds.\n\n` +
+      `WHAT HAPPENED: the shared history was rewritten after this branch was ` +
+      `created. Rewriting gives every commit a new identity, so nothing this ` +
+      `branch was built on still exists on the remote — and the check that ` +
+      `normally asks "what is new here?" gets the whole history back instead.\n\n` +
+      `WHY IT IS NOT REFUSING YOUR WORK: the commits it would otherwise ` +
+      `complain about are other people's, from before the rewrite. Nothing is ` +
+      `wrong with what you wrote.\n\n` +
+      `WHAT TO DO: copy your commits onto the current branch instead of ` +
+      `pushing this one as it stands — \`git cherry-pick\` each of your own ` +
+      `commits onto a fresh branch taken from an up-to-date "main", then push ` +
+      `that. Merging "main" into this branch does NOT help: a merge adds a ` +
+      `parent, it cannot make the old commits exist on the remote again.`
+  );
+  error.selfExplanatory = true;
+  return error;
 }
 
 /**
@@ -4392,6 +4482,12 @@ function validatePush(args) {
   const pr = currentPullRequest();
   const target = prTargetGroup(groups, pr);
   for (const group of groups) {
+    // BEFORE the commits are judged, not after: every verdict below is computed
+    // over a range, and a range this wide is not evidence about anything. The
+    // order is the fix — judging first and diagnosing afterwards is what
+    // produced a refusal naming a stranger's closed ticket (#3719).
+    if (ancestryUnreachable(group, remote))
+      throw unreachableAncestryRefusal(group.localRef);
     const outcome = commitOutcome(group.commits, configRef, remote);
     reportPushGroup(
       outcome,

package/dist/core/lisa-owned-hash-ledger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lisa-owned-hash-ledger.d.ts","sourceRoot":"","sources":["../../src/core/lisa-owned-hash-ledger.ts"],"names":[],"mappings":"AACA,6EAA6E;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAqjCjC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CACpD,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAw9BjC,CAAC"}
+{"version":3,"file":"lisa-owned-hash-ledger.d.ts","sourceRoot":"","sources":["../../src/core/lisa-owned-hash-ledger.ts"],"names":[],"mappings":"AACA,6EAA6E;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CA+jCjC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CACpD,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAk+BjC,CAAC"}

package/dist/core/lisa-owned-hash-ledger.js

@@ -781,6 +781,10 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "f21cdcb54b353714a92c2d1e25fd6b76318e8e8d7cb90cdb016f174923c532ef",
     ]),
     "scripts/lisa-hooks/worktree-binding-guard.mjs": Object.freeze([
+        "248939a111ad7d03d19ae210e5d76cb13613815719610ef22df9a5199f0631e8",
+        "2d094120f2c1748144f1c0e5757a60ecc7c6ae3e4f57fa54ab6a15c5a9e1868f",
+        "5fe074e29a332c8c4c83a1bdf3bdc766675203178810e0977e7d270ef680636a",
+        "6b0c13bf89dd62577baebb7e6e8ff7a0bbcb1e83b32c5a1b878a64c76d83d822",
         "822e4f9d2c3ad8fb184ff7fc880f6811004852fb731c7878b5a8a1a9532bceb8",
         "bc1118b05eaea3fc7b3409c96979d64e3dee0907118f3e84d735163f473f632a",
         "e121219bbee1960a6bf88d1e2ba0b50587d63013e7872c56619c04182e8a7561",
@@ -921,6 +925,7 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
     "scripts/lisa-work-item.mjs": Object.freeze([
         "04401ae05bf9464e6929180ffdfff80afc528a1df20733b032a0342252ca1d4a",
         "04f78df45465d01601c8b5711b74749b2a2c2b70b9c916d6790bd69e1c11865d",
+        "06f82a176755c7ff464e263c8a0a6249e02bed710504acf1129ff8fc4c2c0326",
         "08ec9a37d66fb35443a5aac72e09d7ab5478cbd516f72e248d01b3befabddfe5",
         "0b6eff0a306ccd8396d6e3d71ac9c54d3a1c8c29449a9146e0c2e5726b74feb9",
         "1365fd1272eac2d046bbc54d50b0ebdce5b1d9863c832d93c9d4671c3fa13e3c",
@@ -937,10 +942,13 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "3a9ec1ff863693a0fa0fef0ade6fa5534485d0249fb78302d37cdac3781348f1",
         "3f8c59e0f4ad43211f6964b4889f3fc673bee0496ec3613bdbdc4544424340f6",
         "41b967f736d7fcf9d8928ad7c8cc767c5beb9544e2fbfa3317c65734aa02fcfd",
+        "42176fa5ee6df11d2337a91b2eeeb31a9ed7cc1e16acb0cec11739ba5a6849ed",
         "4372872a448d3b943dea5541167ed5be6155703b57b9f8224d19ddefd3b80898",
         "475cb9ef86c2ac54c8fd8cb6d63e9a55ea8cd0017e26efbe3c44391a4aeeab41",
         "4c263fef48c03b3b6c623ea8a6cd55505bfaf28197e5072226ea35f9f3d26885",
         "4da6624ff233f5ea781c5cb1f2e13d0062fd071e66c4b866fcefb89a6e6247d4",
+        "50e3a04a3e5c961b7f70d1a23cab1a6b560ec463a4b76727fe64e6e773d42b0e",
+        "56d3718b1243506965b5898c3eb81cb3ff3c6233a2a5185be80fb099933a5a26",
         "5a0b82045d9795284a109c28e5e9dd97a5488ff540bb7034b84077d1447ffd7c",
         "5ba15f6126e253ce9554579ddde86fc0bd744cd0c5c1395cb4e4b8f0472cc134",
         "5bc1466a79c18e565e62305d4adeca0c7de94a1e5a22b2c2a75c84f634fcec86",
@@ -958,6 +966,7 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "7573b5170fcba45ccd6123cd0712baba8faa52f063b639140be829d9ce87327d",
         "7ab29cc836e026e4f71a65df9cf5340b7830fb45eec191354ef227d60f8230db",
         "83e7f1257bfee293bcdcdafef4272f40fcdca2d9e43ceb9df647c13c8277423d",
+        "89a9c4c2f93ed1e318e61f15f66b89e924c624eaf3fbaae8eeb4a94ca7158be5",
         "8c3effe804dfbea75011271f9d96eeb125fcbb97dc6397cc2c2dffd935f3aef0",
         "8cd8d102d4b3276f92bb4706274d280c302269fb2f564ca93b1d79cb3ff26841",
         "9223856be4618fb1e3e731b259ae5bf5328decc322f0b4a0d0fd18d6b12cd45a",
@@ -965,6 +974,7 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "96a87c131606b3edd43e52485e68f8ffbf5c528cb4beb7a1185263519a9632ce",
         "9a470f2590772e144b6ed08512e51244fa1293dfd08d5c42daaa38fed22bdafb",
         "9b3dda4a697bc23d8e71a0f00cf6204c80f5670724b843764af4fe8ecd9b2df2",
+        "9c4f6cd0aec2598d1563fa56d87fd05aceaf28752cb811a280e30d369119885e",
         "9e1db1f28cc7ee4b66b08c2fd2ee0ebf98054786d5902245941641e98783bf47",
         "9e5db767677bc9fb07a97109e9036d1ffeda6018c6e678f5c28c55a6c516c234",
         "9fc4267020b6341f74dabebb17123206293280b58cf114932f05a8234426445c",
@@ -1805,6 +1815,10 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "f21cdcb54b353714a92c2d1e25fd6b76318e8e8d7cb90cdb016f174923c532ef",
     ]),
     "scripts/lisa-hooks/worktree-binding-guard.mjs": Object.freeze([
+        "248939a111ad7d03d19ae210e5d76cb13613815719610ef22df9a5199f0631e8",
+        "2d094120f2c1748144f1c0e5757a60ecc7c6ae3e4f57fa54ab6a15c5a9e1868f",
+        "5fe074e29a332c8c4c83a1bdf3bdc766675203178810e0977e7d270ef680636a",
+        "6b0c13bf89dd62577baebb7e6e8ff7a0bbcb1e83b32c5a1b878a64c76d83d822",
         "822e4f9d2c3ad8fb184ff7fc880f6811004852fb731c7878b5a8a1a9532bceb8",
         "bc1118b05eaea3fc7b3409c96979d64e3dee0907118f3e84d735163f473f632a",
         "e121219bbee1960a6bf88d1e2ba0b50587d63013e7872c56619c04182e8a7561",
@@ -1924,6 +1938,7 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
     ]),
     "scripts/lisa-work-item.mjs": Object.freeze([
         "04401ae05bf9464e6929180ffdfff80afc528a1df20733b032a0342252ca1d4a",
+        "06f82a176755c7ff464e263c8a0a6249e02bed710504acf1129ff8fc4c2c0326",
         "08ec9a37d66fb35443a5aac72e09d7ab5478cbd516f72e248d01b3befabddfe5",
         "0b6eff0a306ccd8396d6e3d71ac9c54d3a1c8c29449a9146e0c2e5726b74feb9",
         "1365fd1272eac2d046bbc54d50b0ebdce5b1d9863c832d93c9d4671c3fa13e3c",
@@ -1940,10 +1955,13 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "3a9ec1ff863693a0fa0fef0ade6fa5534485d0249fb78302d37cdac3781348f1",
         "3f8c59e0f4ad43211f6964b4889f3fc673bee0496ec3613bdbdc4544424340f6",
         "41b967f736d7fcf9d8928ad7c8cc767c5beb9544e2fbfa3317c65734aa02fcfd",
+        "42176fa5ee6df11d2337a91b2eeeb31a9ed7cc1e16acb0cec11739ba5a6849ed",
         "4372872a448d3b943dea5541167ed5be6155703b57b9f8224d19ddefd3b80898",
         "475cb9ef86c2ac54c8fd8cb6d63e9a55ea8cd0017e26efbe3c44391a4aeeab41",
         "4c263fef48c03b3b6c623ea8a6cd55505bfaf28197e5072226ea35f9f3d26885",
         "4da6624ff233f5ea781c5cb1f2e13d0062fd071e66c4b866fcefb89a6e6247d4",
+        "50e3a04a3e5c961b7f70d1a23cab1a6b560ec463a4b76727fe64e6e773d42b0e",
+        "56d3718b1243506965b5898c3eb81cb3ff3c6233a2a5185be80fb099933a5a26",
         "5a0b82045d9795284a109c28e5e9dd97a5488ff540bb7034b84077d1447ffd7c",
         "5ba15f6126e253ce9554579ddde86fc0bd744cd0c5c1395cb4e4b8f0472cc134",
         "5bc1466a79c18e565e62305d4adeca0c7de94a1e5a22b2c2a75c84f634fcec86",
@@ -1960,6 +1978,7 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "7573b5170fcba45ccd6123cd0712baba8faa52f063b639140be829d9ce87327d",
         "7ab29cc836e026e4f71a65df9cf5340b7830fb45eec191354ef227d60f8230db",
         "83e7f1257bfee293bcdcdafef4272f40fcdca2d9e43ceb9df647c13c8277423d",
+        "89a9c4c2f93ed1e318e61f15f66b89e924c624eaf3fbaae8eeb4a94ca7158be5",
         "8c3effe804dfbea75011271f9d96eeb125fcbb97dc6397cc2c2dffd935f3aef0",
         "8cd8d102d4b3276f92bb4706274d280c302269fb2f564ca93b1d79cb3ff26841",
         "9223856be4618fb1e3e731b259ae5bf5328decc322f0b4a0d0fd18d6b12cd45a",
@@ -1967,6 +1986,7 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "96a87c131606b3edd43e52485e68f8ffbf5c528cb4beb7a1185263519a9632ce",
         "9a470f2590772e144b6ed08512e51244fa1293dfd08d5c42daaa38fed22bdafb",
         "9b3dda4a697bc23d8e71a0f00cf6204c80f5670724b843764af4fe8ecd9b2df2",
+        "9c4f6cd0aec2598d1563fa56d87fd05aceaf28752cb811a280e30d369119885e",
         "9e1db1f28cc7ee4b66b08c2fd2ee0ebf98054786d5902245941641e98783bf47",
         "9e5db767677bc9fb07a97109e9036d1ffeda6018c6e678f5c28c55a6c516c234",
         "9fc4267020b6341f74dabebb17123206293280b58cf114932f05a8234426445c",