@codyswann/lisa 4.45.5 → 4.45.6

package/plugins/src/base/hooks/parity-safety-net.sh

@@ -2030,6 +2030,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 }' \
@@ -2052,6 +2123,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/scripts/cleanup-worktrees.sh

@@ -13,8 +13,13 @@
 #   3. No modified/staged TRACKED files ("real work" is never deleted).
 #   4. Its HEAD commit is reachable from some remote ref (nothing unpushed).
 #   5. It is older than --min-age-days (default 7) by directory mtime.
+#   6. Its uncommitted content is reachable from some commit — asked of the
+#      bytes, not of the tracking state, by lisa-worktree-guard.
 #   Untracked-only dirt (node_modules, .env.local, build output) blocks
-#   removal by default; pass --force-untracked to treat it as junk.
+#   removal by default; pass --force-untracked to treat it as junk. Even then
+#   the content gate stands: --force-untracked means "untracked files are not
+#   by themselves work", not "delete bytes that exist in no commit"
+#   (CodySwannGT/lisa#3863).
 #
 # DRY-RUN BY DEFAULT. Nothing is deleted until you pass --apply.
 #
@@ -46,7 +51,12 @@ while [ $# -gt 0 ]; do
       fi
       MIN_AGE_DAYS="$1" ;;
     --delete-branches) DELETE_BRANCHES=1 ;;
-    -h|--help) sed -n '2,30p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+    # Print the whole leading comment block, not a hardcoded line count. `2,30p`
+    # silently stopped covering the last option the moment the header grew by
+    # six lines, and nothing reported it — the help text is not asserted
+    # anywhere, so the only symptom is an operator who never learns an option
+    # exists. Stop at the first non-comment line instead, which cannot drift.
+    -h|--help) sed -n '2,${/^[^#]/q;p;}' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
     *) REPO="$1" ;;
   esac
   shift
@@ -61,6 +71,21 @@ fi
 NOW=$(date +%s)
 MIN_AGE_SECS=$((MIN_AGE_DAYS * 86400))
 REMOVED=0 KEPT_DIRTY=0 KEPT_UNPUSHED=0 KEPT_YOUNG=0 KEPT_UNTRACKED=0 ORPHANS=0 ERRORS=0
+KEPT_UNREACHABLE=0
+
+# Content-reachability guard. Absent node or an unresolvable script leaves the
+# older gates in charge rather than silently widening what this script deletes.
+GUARD=""
+for candidate in \
+  "$REPO/scripts/lisa-worktree-guard.mjs" \
+  "$REPO/node_modules/@codyswann/lisa/all/copy-overwrite/scripts/lisa-worktree-guard.mjs" \
+  "$REPO/all/copy-overwrite/scripts/lisa-worktree-guard.mjs"; do
+  if [ -f "$candidate" ]; then
+    GUARD="$candidate"
+    break
+  fi
+done
+command -v node > /dev/null 2>&1 || GUARD=""
 
 log() { printf '%s\n' "$*"; }
 act() { if [ "$APPLY" = 1 ]; then log "REMOVE  $*"; else log "WOULD-REMOVE  $*"; fi; }
@@ -149,6 +174,14 @@ process_worktree() {
     return
   fi
 
+  # Content gate: bytes that exist in no commit are never junk, whatever
+  # --force-untracked says about tracking state.
+  if [ -n "$GUARD" ] && ! node "$GUARD" check "$wt" > /dev/null 2>&1; then
+    KEPT_UNREACHABLE=$((KEPT_UNREACHABLE + 1))
+    log "KEEP (holds content that exists in no commit)  $wt"
+    return
+  fi
+
   local force_flag=()
   if [ -n "$(git -C "$wt" status --porcelain 2>/dev/null)" ]; then
     if [ "$FORCE_UNTRACKED" = 1 ]; then
@@ -217,6 +250,6 @@ fi
 log ""
 log "=== summary ==="
 log "removed (or would remove): $REMOVED   orphan dirs: $ORPHANS"
-log "kept: $KEPT_DIRTY modified-tracked, $KEPT_UNPUSHED unpushed, $KEPT_UNTRACKED untracked-only, $KEPT_YOUNG too-young   errors: $ERRORS"
+log "kept: $KEPT_DIRTY modified-tracked, $KEPT_UNPUSHED unpushed, $KEPT_UNTRACKED untracked-only, $KEPT_UNREACHABLE uncommitted-content, $KEPT_YOUNG too-young   errors: $ERRORS"
 [ "$APPLY" = 0 ] && log "(dry run — rerun with --apply to delete)"
 exit 0

package/scripts/two-channel-couplings.json

@@ -7,7 +7,7 @@
     "workflows": 22,
     "steps": 716,
     "couplings": 34,
-    "inventory": 76
+    "inventory": 77
   },
   "counts": {
     "package-backed": 10,

package/typescript/copy-overwrite/.prettierignore

@@ -93,6 +93,7 @@ scripts/lisa-run-gates.mjs
 scripts/lisa-schema-validate.mjs
 scripts/lisa-test-node.mjs
 scripts/lisa-work-item.mjs
+scripts/lisa-worktree-guard.mjs
 scripts/nightly-e2e-provider-action.mjs
 scripts/nightly-e2e-provider-github-jira.mjs
 scripts/nightly-e2e-provider-linear-sentry.mjs

package/typescript/create-only/.github/workflows/review-evidence.yml

@@ -123,7 +123,26 @@ concurrency:
 
 jobs:
   vacuity:
-    name: 🕵️ Did the required review checks do any work?
+    # DECLARATIVE, NOT A QUESTION (#3917). This was `🕵️ Did the required review
+    # checks do any work?`, and an unsatisfied verdict exits non-zero, so the
+    # row rendered `Did the required review checks do any work?  fail`. A yes/no
+    # question answered `fail` composes to "NO" — the row asserted that the
+    # review checks did no work at exactly the moment the verdict said
+    # `UNDETERMINED — ... is NOT reporting that nobody reviewed`. A
+    # question-shaped name cannot safely carry more than two outcomes, and the
+    # settle-timeout gives this gate a third.
+    #
+    # AND THE OBVIOUS REPLACEMENT WOULD BE A NEW FALSE CLAIM. `Required review
+    # checks did work` reads true on a failure but FALSE on a pass: this job
+    # exits 0 for a SATISFIED gate and for a WAIVED one alike, so the pass path
+    # would assert work on the very pull requests nothing reviewed. The name
+    # therefore describes the GATE and asserts nothing about the review; the
+    # three-valued answer is published next door as `🕵️ Review evidence
+    # verdict`, which is where it belongs.
+    #
+    # Only the name changed. Severity, exit codes, the wait, and the verdict
+    # vocabulary are untouched.
+    name: 🕵️ Review evidence gate
     runs-on: ubuntu-latest
     # The guard waits for the declared checks to settle before judging them: a
     # review bot posts `pending — "Review queued"` and `pending — "Review in