@codyswann/lisa 4.45.5 → 4.45.7

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

@@ -28,6 +28,12 @@
  * proof that none is takeable *right now*. Deleting a worktree that holds
  * uncommitted work permanently forecloses the only window in which its own
  * case was detectable.
+ *
+ * That limit is now held open from the other end by
+ * `lisa-worktree-guard.mjs` (CodySwannGT/lisa#3863), which refuses to remove a
+ * worktree whose uncommitted bytes exist in no commit. The two are one control
+ * read in two directions: this file needs the original to still be there, and
+ * that one is what keeps it there.
  */
 
 import { execFileSync } from "node:child_process";

package/all/copy-overwrite/scripts/lisa-hooks/parity-safety-net.sh

@@ -2033,6 +2033,77 @@ readonly GIT_CONTROL_PLANE='(^|[[:space:]='"$qc"'./])\.git([/[:space:]'"$qc"']|$
 # that could not run produced no lines, the loop body never executed, and the
 # guard was skipped with the command ALLOWED. A segmentation that cannot answer
 # must refuse, exactly like a scan that cannot answer.
+# 14b. Linked worktrees, which are the same principle one level out. `.git` is
+# protected because nothing in the working tree can rebuild it; a linked
+# worktree is protected because nothing OUTSIDE it can rebuild what it holds.
+# The asymmetry is exact and it is invisible from the prompt: `.git/refs` and
+# the object store are shared by every worktree of a repository, while
+# `.git/index` and the working files are per-worktree. So `git commit` moves
+# work somewhere a deletion cannot reach, and `git add` does not — a staged file
+# shows green in `git status`, which reads as saved, and dies with the
+# directory.
+#
+# Measured twice in one evening (issue #3863): one worktree lost a 284-line
+# staged test file, and a second lost nothing from the identical event purely
+# because a gate had forced its work into a commit first. Neither deletion
+# announced itself. That is the second reason this is a block rather than a
+# warning — a worktree deletion destroys the only evidence its own case could
+# leave, so there is no after-the-fact detection to fall back on.
+#
+# `git worktree remove` (guard 12) already refuses a dirty tree, and
+# `--force` is already blocked. This closes the spelling that walks around both:
+# `rm -rf` on the directory, which git never sees.
+#
+# Matching is by REGISTERED path — `git worktree list` names them — so an
+# ordinary directory that merely lives near one is untouched. A repository that
+# cannot be read answers "no": this guard adds protection to a shape that was
+# fully allowed a moment ago, and failing it closed would deny every recursive
+# delete on every path outside a repository.
+#
+# The comparison is on WHOLE TOKENS, which is the only spelling that gets both
+# error directions right. Substring containment would let a worktree named
+# `wt-1` claim `rm -rf wt-10`, an over-block on an unrelated directory; and
+# hand-written boundary classes leak the other way, because `rm -rf <wt>/`
+# with one trailing slash ends on a character every such class treats as
+# "inside a path". So every non-path character — quote, space, parenthesis,
+# redirection — is folded to a space first, which makes each argument a
+# space-delimited token regardless of how it was quoted, and the match is then
+# an equality test on that token. A SUBPATH (`rm -rf <wt>/node_modules`) is
+# deliberately not this guard's business: it is not a worktree deletion, and
+# blocking routine cleanup inside a worktree is how a guard gets switched off.
+names_linked_worktree() {
+  local stmt="$1" probe root listed line primary wt rel
+  root="$(git -C "${CLAUDE_PROJECT_DIR:-$PWD}" rev-parse --show-toplevel 2> /dev/null)" || return 1
+  [ -n "$root" ] || return 1
+  listed="$(git -C "$root" worktree list --porcelain 2> /dev/null)" || return 1
+  probe=" $(printf '%s' "$stmt" | tr -c 'A-Za-z0-9_./-' ' ') "
+  primary=""
+  while IFS= read -r line; do
+    case "$line" in
+      worktree\ *) wt="${line#worktree }" ;;
+      *) continue ;;
+    esac
+    # First entry is the primary checkout, which is not a linked worktree.
+    if [ -z "$primary" ]; then
+      primary="$wt"
+      continue
+    fi
+    case "$probe" in
+      *" $wt "* | *" $wt/ "*) return 0 ;;
+    esac
+    rel="${wt#"$primary"/}"
+    [ "$rel" != "$wt" ] || continue
+    # `./` is the same path spelled the way an agent in the project root types
+    # it, and a token comparison is exact, so it has to be spelled here too.
+    case "$probe" in
+      *" $rel "* | *" $rel/ "* | *" ./$rel "* | *" ./$rel/ "*) return 0 ;;
+    esac
+  done <<EOF
+$listed
+EOF
+  return 1
+}
+
 git_segments_status=0
 git_segments="$(printf '%s' "$normalized_command_str" \
   | awk '{ if (/\|[ \t]*$/) printf "%s ", $0; else print }' \
@@ -2055,6 +2126,9 @@ while IFS= read -r git_stmt; do
   if scan -E "$git_stmt" "$GIT_CONTROL_PLANE"; then
     block "recursive forced delete of the git control plane (.git holds every commit, branch and stash not already pushed; nothing in the working tree can rebuild it). Delete a specific ignored artifact instead. Re-cloning is NOT a like-for-like replacement: every linked worktree stores a pointer into this .git, so discarding it discards each of them and any uncommitted work they hold — check \`git worktree list\` before treating the checkout as disposable."
   fi
+  if names_linked_worktree "$git_stmt"; then
+    block "recursive forced delete of a linked git worktree. A worktree's index and working files are private to it — only commits are shared — so this destroys any staged or unwritten-to-a-commit work another agent left there, and destroys the evidence that it did (CodySwannGT/lisa#3863). Use 'node scripts/lisa-worktree-guard.mjs remove <path>' instead: it deletes clean and already-committed trees without ceremony, names the files when they exist nowhere else, and records an explicit --force override."
+  fi
 done <<<"$git_segments"
 
 # 15. Credential stores. Reading one into an agent transcript is disclosure even

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

@@ -0,0 +1,456 @@
+#!/usr/bin/env node
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/**
+ * lisa-worktree-guard — refuse to delete a linked worktree whose uncommitted
+ * work exists in no commit (CodySwannGT/lisa#3863).
+ *
+ * @remarks
+ * ## The asymmetry that makes this necessary
+ *
+ * `.git/refs` and the object store are **shared** across every linked worktree
+ * of a repository; `.git/index` and the working files are **per-worktree**. So
+ * deleting a worktree spares everything that was committed and destroys
+ * everything that was only staged or only written. Two agents hit the same
+ * deletion event on the same evening: the one whose work was in a commit lost
+ * nothing, the one whose work was staged lost the whole deliverable. Nothing
+ * about the two situations looked different from the outside — `git status`
+ * reports staged work in green, which reads as "saved".
+ *
+ * `lisa-cross-worktree-guard.mjs` is the same control read from the other end:
+ * it detects one agent committing another agent's uncommitted file, and it
+ * needs BOTH halves — the commit and the surviving original — to see anything
+ * at all. This guard is what keeps the second half in existence.
+ *
+ * ## Why the deletion cannot be allowed to report success quietly
+ *
+ * A worktree deletion **destroys the only evidence its own case could leave**.
+ * Once the directory is gone the staged blob is unreferenced and the incident
+ * is indistinguishable from ordinary cleanup: no per-agent identifier appears
+ * in any git object, the branch survives, and the aggregate worktree count is
+ * flat whenever deletions are matched by creations. Any detection has to happen
+ * *before* the removal, which is why this is a pre-flight refusal rather than a
+ * monitor.
+ *
+ * ## What is refused, and what is not
+ *
+ * The question asked of every uncommitted file is narrow and answerable:
+ * **does a commit anywhere in this repository already contain these exact
+ * bytes?** If yes, deleting the worktree costs nothing recoverable and the
+ * removal proceeds without ceremony — a worktree full of untracked build
+ * output, or holding a file byte-identical to one already pushed, is not work
+ * at risk. If no, the removal is refused and the at-risk files are named.
+ *
+ * Reachability is answered from `git rev-list --objects --all`, which walks
+ * every ref rather than only the current branch, so work committed on a
+ * different branch (or already pushed and merged) reads as safe. A blob that
+ * exists only in the object database — which is exactly what `git add` writes —
+ * is NOT reachable and is exactly the case this guard exists to catch.
+ *
+ * ## The override is real, and it is recorded
+ *
+ * An operator who genuinely wants the directory gone must not be stranded, so
+ * `--force` (or `LISA_WORKTREE_REMOVE_OVERRIDE=1`) proceeds. Both the refusal
+ * and the override append a line to a JSONL ledger in the **common** git
+ * directory — never inside the worktree, which is about to stop existing. The
+ * ledger is the only artifact that survives to say a detectable case was
+ * knowingly made undetectable.
+ *
+ * Failing closed is deliberate: an unreadable repository, a `rev-list` that
+ * cannot be buffered, or a worktree git does not know about all resolve to
+ * refusal. "I could not tell" must never be cheaper than "there is work here".
+ * @module scripts/lisa-worktree-guard
+ */
+import { execFileSync } from "node:child_process";
+import { appendFileSync, existsSync } from "node:fs";
+import path from "node:path";
+
+import { invokedAsScript } from "./lib/invoked-as-script.mjs";
+
+/** Exit code meaning "safe, or removed". */
+const OK = 0;
+/** Exit code meaning "usage or environment error". */
+const ERROR = 1;
+/** Exit code meaning "refused: uncommitted work would be destroyed". */
+const REFUSED = 2;
+
+/** Ledger filename, written beside the shared object store. */
+const LEDGER = "lisa-worktree-removals.jsonl";
+
+/** Environment variable spelling of `--force`. */
+const OVERRIDE_ENV = "LISA_WORKTREE_REMOVE_OVERRIDE";
+
+/** Verdict reason: the path is not a git worktree at all. */
+const NOT_A_WORKTREE = "not-a-worktree";
+
+/** Verdict reason: the path is the primary checkout, which is never removable. */
+const PRIMARY_CHECKOUT = "primary-checkout";
+
+/** Verdict reason: the repository's objects could not be enumerated. */
+const UNREADABLE = "unreadable";
+
+/** Largest `git rev-list` payload buffered before the guard fails closed. */
+const MAX_BUFFER = 1 << 28;
+
+/**
+ * Run git, returning stdout.
+ * @param {string[]} args - Arguments after `git`.
+ * @param {string} cwd - Directory to run in.
+ * @returns {string} Captured stdout.
+ */
+function git(args, cwd) {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: MAX_BUFFER,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}
+
+/**
+ * Run git, returning `null` instead of throwing.
+ * @param {string[]} args - Arguments after `git`.
+ * @param {string} cwd - Directory to run in.
+ * @returns {string | null} Captured stdout, or `null` when git failed.
+ */
+function gitOrNull(args, cwd) {
+  try {
+    return git(args, cwd);
+  } catch {
+    // probe-direction: fail-closed — no caller spends this null as an answer.
+    // `candidatePaths`, `indexBlobs` and `candidateBlobs` each propagate it,
+    // and `classifyWorktree` turns it into UNREADABLE, which REFUSES the
+    // removal. A git that cannot answer costs a false refusal, never a
+    // silent deletion.
+    return null;
+  }
+}
+
+/**
+ * Split NUL-delimited git output into entries.
+ * @param {string | null} out - Raw git output.
+ * @returns {string[]} Non-empty entries.
+ */
+function splitZ(out) {
+  return (out ?? "").split("\0").filter(Boolean);
+}
+
+/**
+ * Repo-relative paths whose current bytes may differ from every commit.
+ *
+ * Staged additions, unstaged modifications and untracked files are all at risk;
+ * ignored files are not (that is what makes build output cheap to delete).
+ *
+ * Returns `null` when any of the three probes failed. An empty list means
+ * "git looked and found nothing"; `null` means "git could not look", and the
+ * two must never collapse into each other — collapsing them is what lets an
+ * unreadable worktree be deleted as though it were empty.
+ * @param {string} wt - Worktree path.
+ * @returns {string[] | null} Candidate repo-relative paths, or `null`.
+ */
+function candidatePaths(wt) {
+  const staged = gitOrNull(
+    ["diff", "--cached", "--name-only", "--no-renames", "-z"],
+    wt
+  );
+  const unstaged = gitOrNull(["diff", "--name-only", "--no-renames", "-z"], wt);
+  const untracked = gitOrNull(
+    ["ls-files", "--others", "--exclude-standard", "-z"],
+    wt
+  );
+  if (staged === null || unstaged === null || untracked === null) return null;
+  return [
+    ...new Set([...splitZ(staged), ...splitZ(unstaged), ...splitZ(untracked)]),
+  ];
+}
+
+/**
+ * Index blob ids for the given paths, keyed by path.
+ * @param {string} wt - Worktree path.
+ * @param {string[]} paths - Candidate repo-relative paths.
+ * @returns {Map<string, string> | null} Path to staged blob id, or `null`.
+ */
+function indexBlobs(wt, paths) {
+  const entries = new Map();
+  if (paths.length === 0) return entries;
+  const raw = gitOrNull(["ls-files", "-s", "-z", "--", ...paths], wt);
+  if (raw === null) return null;
+  for (const line of splitZ(raw)) {
+    const tab = line.indexOf("\t");
+    if (tab === -1) continue;
+    const fields = line.slice(0, tab).split(" ");
+    if (fields.length >= 2) entries.set(line.slice(tab + 1), fields[1]);
+  }
+  return entries;
+}
+
+/**
+ * Every blob a worktree holds that no commit may contain, as path/blob pairs.
+ *
+ * Both sides of a path are collected: the INDEX blob (what `git add` wrote) and
+ * the WORKING blob (what is on disk). They differ for a file staged and then
+ * edited again, and losing either is losing work.
+ * @param {string} wt - Worktree path.
+ * @returns {{path: string, blob: string, source: string}[] | null} Candidate
+ *   blobs, or `null` when the worktree could not be read.
+ */
+function candidateBlobs(wt) {
+  const paths = candidatePaths(wt);
+  if (paths === null) return null;
+  const staged = indexBlobs(wt, paths);
+  if (staged === null) return null;
+  const found = [];
+  for (const rel of paths) {
+    const stagedBlob = staged.get(rel);
+    if (stagedBlob)
+      found.push({ path: rel, blob: stagedBlob, source: "index" });
+    if (!existsSync(path.join(wt, rel))) continue;
+    const hashed = gitOrNull(["hash-object", "--", rel], wt);
+    // A file that is on disk but cannot be hashed is unread, not unchanged.
+    if (hashed === null) return null;
+    const id = hashed.trim();
+    if (id && id !== stagedBlob) {
+      found.push({ path: rel, blob: id, source: "worktree" });
+    }
+  }
+  return found;
+}
+
+/**
+ * The subset of `wanted` blob ids that some commit already contains.
+ *
+ * Returns `null` when the answer could not be computed, which callers must
+ * treat as "nothing is reachable" rather than as "everything is".
+ * @param {string} wt - Worktree path.
+ * @param {Set<string>} wanted - Blob ids to look for.
+ * @returns {Set<string> | null} Reachable ids, or `null` on failure.
+ */
+function reachableBlobs(wt, wanted) {
+  if (wanted.size === 0) return new Set();
+  const raw = gitOrNull(["rev-list", "--objects", "--all"], wt);
+  if (raw === null) return null;
+  const reachable = new Set();
+  for (const line of raw.split("\n")) {
+    const space = line.indexOf(" ");
+    const id = space === -1 ? line : line.slice(0, space);
+    if (wanted.has(id)) reachable.add(id);
+  }
+  return reachable;
+}
+
+/**
+ * Resolve the worktree's identity: its branch, the primary checkout, and
+ * whether the path is a linked worktree at all.
+ * @param {string} target - Path to inspect.
+ * @returns {{worktree: string, primary: string, common: string, branch: string, linked: boolean} | null} Identity, or `null` when not a repository.
+ */
+function identify(target) {
+  const top = gitOrNull(["rev-parse", "--show-toplevel"], target)?.trim();
+  if (!top) return null;
+  const gitDir = gitOrNull(["rev-parse", "--absolute-git-dir"], target)?.trim();
+  const commonRaw = gitOrNull(
+    ["rev-parse", "--git-common-dir"],
+    target
+  )?.trim();
+  if (!gitDir || !commonRaw) return null;
+  const common = path.resolve(top, commonRaw);
+  const listed = gitOrNull(["worktree", "list", "--porcelain"], target) ?? "";
+  const first = listed.split("\n")[0] ?? "";
+  return {
+    worktree: top,
+    primary: first.startsWith("worktree ")
+      ? first.slice(9)
+      : path.dirname(common),
+    common,
+    branch:
+      gitOrNull(["rev-parse", "--abbrev-ref", "HEAD"], target)?.trim() ?? "",
+    linked: path.resolve(gitDir) !== common,
+  };
+}
+
+/**
+ * Classify a worktree for removal safety.
+ * @param {string} target - Path to inspect.
+ * @returns {{ok: boolean, reason: string, identity: object | null, atRisk: object[]}} Verdict.
+ */
+export function classifyWorktree(target) {
+  const identity = identify(target);
+  if (!identity) {
+    return { ok: false, reason: NOT_A_WORKTREE, identity: null, atRisk: [] };
+  }
+  if (!identity.linked) {
+    return { ok: false, reason: PRIMARY_CHECKOUT, identity, atRisk: [] };
+  }
+  const blobs = candidateBlobs(identity.worktree);
+  if (blobs === null) {
+    return { ok: false, reason: UNREADABLE, identity, atRisk: [] };
+  }
+  const reachable = reachableBlobs(
+    identity.worktree,
+    new Set(blobs.map(entry => entry.blob))
+  );
+  if (reachable === null) {
+    return { ok: false, reason: UNREADABLE, identity, atRisk: blobs };
+  }
+  const atRisk = blobs.filter(entry => !reachable.has(entry.blob));
+  return {
+    ok: atRisk.length === 0,
+    reason: atRisk.length === 0 ? "safe" : "work-at-risk",
+    identity,
+    atRisk,
+  };
+}
+
+/**
+ * Append one line to the removal ledger in the shared git directory.
+ *
+ * Best-effort by construction: a ledger that cannot be written must not turn a
+ * safe removal into a failure, and must not turn a refusal into a pass.
+ * @param {string} common - Absolute path to the common git directory.
+ * @param {object} row - The record to append.
+ * @returns {string | null} Ledger path when written, else `null`.
+ */
+export function recordRemoval(common, row) {
+  const file = path.join(common, LEDGER);
+  try {
+    appendFileSync(file, `${JSON.stringify(row)}\n`, "utf8");
+    return file;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Human-readable refusal, naming every file that exists nowhere else.
+ * @param {object} verdict - Result of `classifyWorktree`.
+ * @returns {string} Message for stderr.
+ */
+function refusalMessage(verdict) {
+  const lines = verdict.atRisk.map(
+    entry => `  ${entry.source.padEnd(8)} ${entry.path}  (blob ${entry.blob})`
+  );
+  return [
+    `REFUSED: ${verdict.identity.worktree}`,
+    `${verdict.atRisk.length} file(s) here exist in no commit, in this repository or any other:`,
+    ...lines,
+    "",
+    "A worktree's index and working files are per-worktree; only commits are shared.",
+    "Deleting this directory destroys the bytes above and leaves no trace that it did.",
+    "Commit them (they need no push to survive), or re-run with --force to delete them",
+    `anyway — an override is recorded in ${LEDGER}.`,
+  ].join("\n");
+}
+
+/**
+ * Reasons that describe a broken request rather than work at risk.
+ * @param {string} reason - Verdict reason.
+ * @returns {string} Operator-readable explanation.
+ */
+function hardFailure(reason) {
+  if (reason === NOT_A_WORKTREE) return "not a git worktree";
+  if (reason === PRIMARY_CHECKOUT) {
+    return "refusing to touch the primary checkout (no override exists)";
+  }
+  return "could not read the repository's objects; refusing fail-closed";
+}
+
+/**
+ * Parse argv into a verb, a target and flags.
+ * @param {string[]} argv - Arguments after the script name.
+ * @returns {{verb: string, target: string, force: boolean, json: boolean}} Options.
+ */
+function parseArgs(argv) {
+  const rest = argv.filter(arg => !arg.startsWith("--"));
+  const verb = rest[0] === "remove" || rest[0] === "check" ? rest[0] : "check";
+  const positional = rest[0] === verb && rest.length > 1 ? rest[1] : rest[0];
+  return {
+    verb,
+    target: positional ?? "",
+    force: argv.includes("--force") || process.env[OVERRIDE_ENV] === "1",
+    json: argv.includes("--json"),
+  };
+}
+
+/**
+ * Entry point.
+ * @param {string[]} argv - Arguments after the script name.
+ * @param {{out?: NodeJS.WritableStream, err?: NodeJS.WritableStream}} [io] - Streams.
+ * @returns {number} Process exit code.
+ */
+export function main(argv, io = {}) {
+  const out = io.out ?? process.stdout;
+  const err = io.err ?? process.stderr;
+  const opts = parseArgs(argv);
+  if (!opts.target) {
+    err.write(
+      "usage: lisa-worktree-guard [check|remove] <worktree> [--force]\n"
+    );
+    return ERROR;
+  }
+  const verdict = classifyWorktree(opts.target);
+  if (opts.json) out.write(`${JSON.stringify(verdict)}\n`);
+  if (!verdict.identity || verdict.reason === PRIMARY_CHECKOUT) {
+    err.write(`${hardFailure(verdict.reason)}\n`);
+    return ERROR;
+  }
+  return finish(verdict, opts, out, err);
+}
+
+/**
+ * Apply the verdict: refuse, record an override, or remove.
+ * @param {object} verdict - Result of `classifyWorktree`.
+ * @param {object} opts - Parsed options.
+ * @param {NodeJS.WritableStream} out - Stdout.
+ * @param {NodeJS.WritableStream} err - Stderr.
+ * @returns {number} Process exit code.
+ */
+function finish(verdict, opts, out, err) {
+  const { identity } = verdict;
+  const base = {
+    at: new Date().toISOString(),
+    worktree: identity.worktree,
+    branch: identity.branch,
+    verb: opts.verb,
+    atRisk: verdict.atRisk,
+  };
+  if (!verdict.ok && !opts.force) {
+    recordRemoval(identity.common, { ...base, action: "refused" });
+    if (verdict.reason === UNREADABLE) {
+      err.write(`${hardFailure(verdict.reason)}\n`);
+      return REFUSED;
+    }
+    err.write(`${refusalMessage(verdict)}\n`);
+    return REFUSED;
+  }
+  const action = verdict.ok ? "removed" : "override";
+  if (opts.verb === "check") {
+    if (!verdict.ok) recordRemoval(identity.common, { ...base, action });
+    return OK;
+  }
+  return remove(identity, { ...base, action }, out, err);
+}
+
+/**
+ * Remove the worktree and record it.
+ * @param {object} identity - Worktree identity.
+ * @param {object} row - Ledger row.
+ * @param {NodeJS.WritableStream} out - Stdout.
+ * @param {NodeJS.WritableStream} err - Stderr.
+ * @returns {number} Process exit code.
+ */
+function remove(identity, row, out, err) {
+  recordRemoval(identity.common, row);
+  try {
+    git(["worktree", "remove", "--force", identity.worktree], identity.primary);
+  } catch (error) {
+    err.write(`error: git worktree remove failed: ${error.message}\n`);
+    return ERROR;
+  }
+  out.write(`removed ${identity.worktree}\n`);
+  return OK;
+}
+
+if (invokedAsScript(import.meta.url)) {
+  process.exitCode = main(process.argv.slice(2));
+}

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,CAykCjC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CACpD,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CA4+BjC,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,CAqlCjC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CACpD,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAw/BjC,CAAC"}

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

@@ -426,11 +426,14 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "99422b4912cd660ddeb5ec5ab9fc333e57fa5763e711117a00b06dd2eda0bbb7",
     ]),
     "scripts/lisa-cross-worktree-guard.mjs": Object.freeze([
+        "2ca521021c535be700caaaf4755a54363f685a9a85e435624833cb838a072c5d",
         "3967e4eb189c043e8702ca5cff40c4612ed77027a053e23635eeb367a436cb9d",
         "41b92e1e94a8ee9ad0235359dbd83566a49b17db60da933835057dc77008ab87",
         "592aed14ae21fea08be73497f5cb5d8c94a0a1915792632265fe2717a8817176",
         "d8625e2d339ac512350203e29e70f7b20546bf5248cf952aafd997389feb230f",
+        "da6ec451ca6ea7d890874f8f54bc56f41e541a1190bb170a5167ea104637aba6",
         "e0ef99ef1df32f76601a2106a2b68b3c31a126e0b48e8b8ceaba1a7476c32900",
+        "e3422f6177b6d6eb5509f17673ff8e10e7ed91bf59dd1630e9c5f77d2b56f327",
     ]),
     "scripts/lisa-destructive-guard.mjs": Object.freeze([
         "4fb431a3c58f443e303d613934d023d9e95ddae5c42710bb7009f7c080c82a64",
@@ -740,9 +743,11 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "1d4fbe135f1bb4e861d286a6512ed201d4522250dfe3f9eba6584bc5ff166a95",
         "2b1ca7d317dea3af106df1a74b1718e3df9c18e76e9d9d769aa3271b7abf8a3f",
         "2bdba97c9a1ccc0e70247ee02b5eff02c042aba83b8e7fed3dfbf29a8a83b394",
+        "2da3ad6d7680b61e20b48022e57b8960e063266cb26c197c2c8daa89adf4b648",
         "388cf8847581d96a1ff8ea98290a33a5f96d67cdd502ea807a0b8d88efe90e19",
         "4242b39169bb05aaac4113569125a2c3a351c5dde2d12fd7dacc303dd9a2b5a4",
         "450338257697a75a8fce9f06f3fc00bf3417947e50d601794da41f9c520a7cc3",
+        "57051a1913665b34acc342002d799c703258650a19c9b9894e1911ddf3bd519f",
         "5ef7c10bee0110c4af1e429fac01332433102c495ec467966ddd7b1494dc899d",
         "64546813f168fb446f39e34bc674fd3af85b15bd5e7f4f6bf4503463e701a7b9",
         "74b5b90fcf15dbeb14a69677cf74e339154421cd056fdaf603d1167b34a74105",
@@ -758,6 +763,7 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "a211f1a06aecddb841851463da302f694ab0eafff6bab75ee944b0a58aac431d",
         "a22fd1b7c483f1a538202353ee85c82be17a8910e03c0a930635ce8cb3595c64",
         "a28779ba2e6e4e999014d50734ea0b7e36af886bdb08d144bd4274acd642c902",
+        "afe82473fe2a08af298997cbce62417fdaefa37f4a963f720ed38b992a65b8d3",
         "b5505f55a5092f1d451ae5a01ada85a031e5b063d08fc0ce5527d94b67191a60",
         "b6fbbda29d897a7c39cf0524c91d5c66a47054df32e036f15cdabefdc34ac72a",
         "b83c5043a0f29b2d8851258acfe6906aab7922cd80f486e25220e55f26a8c0a5",
@@ -1019,6 +1025,12 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "fc0d92739e620d8fd70f7aa4a12d3e0b3a8f790d47c4a8322040f32c30b9445a",
         "fe064a2bd11200ed256fb36e203978f858fccbcaf40708496c066383345900ef",
     ]),
+    "scripts/lisa-worktree-guard.mjs": Object.freeze([
+        "2535ef2a60b3413dacb8491c008ab28f0a07929196277d1d1fed54a04740c025",
+        "71b67f940338e66864eec970b6881aba639176c9d262ab0ecf7203006d9f7cbf",
+        "80ff38d47bdf125526bdbf4f41c1df6154baff2834dad4ec5a11a3dd3df5747e",
+        "ebcea40e1484501f257128c9c92b8a3e2c4cefaeae397b96d267ef878d962da4",
+    ]),
     "scripts/nightly-e2e-github-tracking.mjs": Object.freeze([
         "2606caa9d31b2488aa7e468e584c9f2afda8581fa1941f4da9ec8b3cab09c1de",
         "6fc4edbb8707a90ee878567d88f05dd2d7c2df062f81983c5419c8d4036b203f",
@@ -1516,11 +1528,14 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "5d587fd849cef02e9706d084ac2b508f3885da0ba59b76311e3b666f4fbff01e",
     ]),
     "scripts/lisa-cross-worktree-guard.mjs": Object.freeze([
+        "2ca521021c535be700caaaf4755a54363f685a9a85e435624833cb838a072c5d",
         "3967e4eb189c043e8702ca5cff40c4612ed77027a053e23635eeb367a436cb9d",
         "41b92e1e94a8ee9ad0235359dbd83566a49b17db60da933835057dc77008ab87",
         "592aed14ae21fea08be73497f5cb5d8c94a0a1915792632265fe2717a8817176",
         "d8625e2d339ac512350203e29e70f7b20546bf5248cf952aafd997389feb230f",
+        "da6ec451ca6ea7d890874f8f54bc56f41e541a1190bb170a5167ea104637aba6",
         "e0ef99ef1df32f76601a2106a2b68b3c31a126e0b48e8b8ceaba1a7476c32900",
+        "e3422f6177b6d6eb5509f17673ff8e10e7ed91bf59dd1630e9c5f77d2b56f327",
     ]),
     "scripts/lisa-destructive-guard.mjs": Object.freeze([
         "4fb431a3c58f443e303d613934d023d9e95ddae5c42710bb7009f7c080c82a64",
@@ -1785,9 +1800,11 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "1bf3512bb94923a6cb25b1e7a619a3fc8e1336bffa16f499b459aaee3eaed66d",
         "1d4fbe135f1bb4e861d286a6512ed201d4522250dfe3f9eba6584bc5ff166a95",
         "2bdba97c9a1ccc0e70247ee02b5eff02c042aba83b8e7fed3dfbf29a8a83b394",
+        "2da3ad6d7680b61e20b48022e57b8960e063266cb26c197c2c8daa89adf4b648",
         "388cf8847581d96a1ff8ea98290a33a5f96d67cdd502ea807a0b8d88efe90e19",
         "4242b39169bb05aaac4113569125a2c3a351c5dde2d12fd7dacc303dd9a2b5a4",
         "450338257697a75a8fce9f06f3fc00bf3417947e50d601794da41f9c520a7cc3",
+        "57051a1913665b34acc342002d799c703258650a19c9b9894e1911ddf3bd519f",
         "5ef7c10bee0110c4af1e429fac01332433102c495ec467966ddd7b1494dc899d",
         "64546813f168fb446f39e34bc674fd3af85b15bd5e7f4f6bf4503463e701a7b9",
         "74b5b90fcf15dbeb14a69677cf74e339154421cd056fdaf603d1167b34a74105",
@@ -1803,6 +1820,7 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "a211f1a06aecddb841851463da302f694ab0eafff6bab75ee944b0a58aac431d",
         "a22fd1b7c483f1a538202353ee85c82be17a8910e03c0a930635ce8cb3595c64",
         "a28779ba2e6e4e999014d50734ea0b7e36af886bdb08d144bd4274acd642c902",
+        "afe82473fe2a08af298997cbce62417fdaefa37f4a963f720ed38b992a65b8d3",
         "b5505f55a5092f1d451ae5a01ada85a031e5b063d08fc0ce5527d94b67191a60",
         "b6fbbda29d897a7c39cf0524c91d5c66a47054df32e036f15cdabefdc34ac72a",
         "b83c5043a0f29b2d8851258acfe6906aab7922cd80f486e25220e55f26a8c0a5",
@@ -2040,6 +2058,12 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "fc0d92739e620d8fd70f7aa4a12d3e0b3a8f790d47c4a8322040f32c30b9445a",
         "fe064a2bd11200ed256fb36e203978f858fccbcaf40708496c066383345900ef",
     ]),
+    "scripts/lisa-worktree-guard.mjs": Object.freeze([
+        "2535ef2a60b3413dacb8491c008ab28f0a07929196277d1d1fed54a04740c025",
+        "71b67f940338e66864eec970b6881aba639176c9d262ab0ecf7203006d9f7cbf",
+        "80ff38d47bdf125526bdbf4f41c1df6154baff2834dad4ec5a11a3dd3df5747e",
+        "ebcea40e1484501f257128c9c92b8a3e2c4cefaeae397b96d267ef878d962da4",
+    ]),
     "scripts/nightly-e2e-github-tracking.mjs": Object.freeze([
         "2606caa9d31b2488aa7e468e584c9f2afda8581fa1941f4da9ec8b3cab09c1de",
         "6fc4edbb8707a90ee878567d88f05dd2d7c2df062f81983c5419c8d4036b203f",