@codyswann/lisa 4.33.8 → 4.33.10

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

@@ -1687,7 +1687,50 @@ fi
 
 # 13. Dropping or truncating a database / schema / table (Lisa-only guard —
 #     upstream has no SQL protection; keep).
-if matches '\b(drop[[:space:]]+(database|schema|table)|truncate[[:space:]]+(table[[:space:]]+)?[[:alnum:]_."`]+)\b'; then
+#
+# The two arms used to be asymmetric, and only the lopsided one produced false
+# positives (issue #3530). The `drop` arm requires a following keyword —
+# `drop database|schema|table` — so `drop the ball` never matched it. The
+# `truncate` arm made that keyword OPTIONAL:
+#
+#     truncate[[:space:]]+(table[[:space:]]+)?[[:alnum:]_."`]+
+#
+# which reduces to "`truncate`, whitespace, any identifier-ish word", so
+# `truncate the board`, `truncate results` and `truncate output` all matched.
+# A session was refused for a bug-report TITLE describing a connection that
+# truncates results — and a title has no escape hatch, because the remedy this
+# hook prints at the wall (write the text to a file, pass it BY PATH) covers a
+# body, while the title flag of an issue-filing CLI is necessarily inline. The
+# only exit left was to reword, which is what trains people to route around a
+# guard.
+#
+# The fix keeps the coverage and drops the English, in three arms.
+#
+# ARM 1 — `drop`, byte-identical to before. It was already correct, and a
+# rewrite that unified the arms could only make it permissive.
+readonly SQL_DROP='\bdrop[[:space:]]+(database|schema|table)\b'
+# ARM 2 — `truncate` carrying its own evidence that it is a statement rather
+# than a verb: the TABLE keyword (what the drop arm demands), a
+# schema-qualified name, a quoted identifier, a trailing `;`, or one of the
+# tail keywords that only ever follow a TRUNCATE. English has none of these.
+readonly SQL_TRUNCATE_TAIL='(cascade|restrict|restart[[:space:]]+identity|continue[[:space:]]+identity)([^[:alnum:]_]|$)'
+readonly SQL_TRUNCATE_EVIDENCE='\btruncate[[:space:]]+(table[[:space:]]+[[:alnum:]_."`]+|(only[[:space:]]+)?([[:alnum:]_]+\.[[:alnum:]_."`]+|["`][[:alnum:]_. ]+["`]|[[:alnum:]_]+[[:space:]]*(;|'"$SQL_TRUNCATE_TAIL"')))'
+# ARM 3 — the permissive-dialect `TRUNCATE <name>` with none of that evidence.
+# Deleting this shape is what a lazy fix does: it passes every prose scenario
+# while silently removing the coverage a regression fixture already asserts
+# (`mysql -e 'TRUNCATE sessions'`). So it is recognized by CONTEXT instead —
+# the same command must also invoke a command-line database client. Prose in a
+# tracker filing or a commit message invokes none, which is exactly the
+# difference the text scan could not see on its own.
+readonly SQL_CLIENT='(^|[^[:alnum:]_./-])([[:alnum:]_./-]*/)?(psql|pgcli|mysql|mysqladmin|mysqlsh|mariadb|mycli|sqlite3|sqlcmd|cqlsh|clickhouse-client|cockroach|mongosh|duckdb|usql)([[:space:]]|$)'
+readonly SQL_TRUNCATE_BARE='\btruncate[[:space:]]+(only[[:space:]]+)?[[:alnum:]_."`]'
+# Residual, accepted and stated: a bare `TRUNCATE <name>` with no terminator,
+# no qualification and no recognized client in the same command goes unmatched
+# — the same trade the `drop` arm has always made for `drop the ball`. No DROP
+# shape is weakened, and the guard still fails in the safe direction.
+if matches "$SQL_DROP" \
+  || matches "$SQL_TRUNCATE_EVIDENCE" \
+  || { matches "$SQL_CLIENT" && matches "$SQL_TRUNCATE_BARE"; }; then
   block "destructive SQL (DROP/TRUNCATE) detected"
 fi
 

package/plugins/src/base/skills/lisa-drive-pr-to-merge/SKILL.md

@@ -652,7 +652,7 @@ result: **27 of 27** open items carrying the claimed role in this repository had
 a merged pull request — the claimed lane reported 27 things in flight when the
 real number was one.
 
-Three properties make the command safe to run unconditionally:
+Four properties make the command safe to run unconditionally:
 
 1. **The terminal role is RESOLVED, never assumed.** `lifecycleContract` reads
    `github.labels.build.done` (or the Jira/Linear equivalent), which is
@@ -666,7 +666,22 @@ Three properties make the command safe to run unconditionally:
    a real one afterwards. Cross-repository references do not count: a downstream
    consumer's PR mentioning an upstream issue is not evidence the upstream issue
    shipped.
-3. **It is idempotent**, so re-running after a retry converges rather than
+3. **It weighs the merged pull request's BASE BRANCH**, the same way step (c)
+   above does, and for the same reason. A merged pull request is not evidence
+   on its own: the writer resolves `<baseRefName>` through `.lisa.config.json`
+   `deploy.branches` and applies only the role that base earned. A merge into
+   the production deploy branch is terminal and closes the item; a merge into a
+   branch mapping to a lower env records that env's role and leaves the item
+   open; a merge into a branch the project does not deploy at all — an
+   integration/stack branch — records nothing, closes nothing, and reports the
+   base it observed. **Measured**: on a stacked-PR queue the previous writer
+   stamped the production terminal role and closed every ticket in the batch at
+   the moment its PR landed on the stacking branch, and one of those false
+   completions then made push gate 1 refuse a follow-up commit on the same
+   ticket, because there was no longer an open work item to bind. When the
+   command reports `work-item NOT completed`, that is the correct answer for a
+   stacked merge — re-run it after the stack reaches the deploy branch.
+4. **It is idempotent**, so re-running after a retry converges rather than
    accumulating.
 
 It also removes the claimed role rather than only adding the terminal one.

package/plugins/src/base/skills/lisa-github-build-intake/SKILL.md

@@ -539,7 +539,7 @@ gh issue comment <number> --repo <org>/<repo> --body "[claude-build-intake] Buil
 
 The ordering is the point. Announcing before verifying leaves a public "Build complete" on an item whose lifecycle state was never confirmed, and a reader has no way to tell that claim apart from a verified one — the same indistinguishability the readback exists to prevent. On a failed readback, comment the Error instead.
 
-`node scripts/lisa-work-item.mjs complete --ref <org>/<repo>#<number>` performs this whole terminal sequence — merged-PR evidence check, full role reconciliation, close, independent readback — in one step, and is the preferred path whenever `$DONE` is the terminal value. Use the manual commands above for intermediate env transitions, which must not close the issue.
+`node scripts/lisa-work-item.mjs complete --ref <org>/<repo>#<number>` performs this whole terminal sequence — merged-PR evidence check, full role reconciliation, close, independent readback — in one step, and is the preferred path whenever `$DONE` is the terminal value. It also decides for itself whether `$DONE` is terminal here: it resolves each merged PR's base branch through `.lisa.config.json` `deploy.branches`, so a merge into an intermediate env branch records that env's role WITHOUT closing the issue, and a merge into a branch the project does not deploy records nothing and says which base it saw. The manual commands above remain available for an intermediate env transition performed without merge evidence.
 
 For any non-Success outcome, do NOT transition. The issue sits in `$CLAIMED` (or wherever the lifecycle left it) — humans take it from there.
 

package/scripts/install-claude-plugins.sh

@@ -178,15 +178,24 @@ HOST_HAS_LISA_POSTINSTALL="$(node -e "
   process.stdout.write(postinstall.includes('node_modules/@codyswann/lisa/dist/index.js') ? 'true' : 'false');
 " 2>/dev/null || echo false)"
 
+# Set when the package-side apply below fails. Read at the very end of this
+# script, which exits non-zero. See the exit block for why it is deferred.
+APPLY_FAILED=false
+
 if [ "$IS_LISA_SELF" != "true" ] && [ -z "${CI:-}" ]; then
   if [ "$HOST_HAS_LISA_POSTINSTALL" = "true" ]; then
     echo "Lisa apply deferred to the host project's own postinstall script."
   elif ! LISA_BOOTSTRAP=1 LISA_POSTINSTALL=1 node "$LISA_DIR/dist/index.js" --yes --skip-git-check "$PROJECT_ROOT"; then
-    # Loud but non-fatal, for the same reason as the host-side bootstrap: a
-    # postinstall that exits non-zero aborts the whole install. The durable
-    # signal is the apply receipt this failed run did NOT write, which
-    # `lisa doctor` reports (CodySwannGT/lisa#2467).
+    # Loud AND fatal, matching the host-side bootstrap in
+    # src/migrations/ensure-lisa-postinstall.ts. This used to warn and exit 0,
+    # reasoning that the apply receipt the failed run did NOT write was signal
+    # enough for `lisa doctor` (CodySwannGT/lisa#2467) — but a missing receipt
+    # cannot distinguish a failed apply from one that never ran or was skipped,
+    # so the failure was reported as a successful install
+    # (CodySwannGT/lisa#3466). The `[ -z "${CI:-}" ]` guard above keeps the
+    # blast radius to local installs, and `CI=1` remains the escape hatch.
     echo "⚠️  lisa: TEMPLATE APPLY FAILED (error above) - this project is NOT receiving Lisa template or guardrail updates. Diagnose with: node $LISA_DIR/dist/index.js doctor" >&2
+    APPLY_FAILED=true
   fi
 fi
 
@@ -599,3 +608,12 @@ if [ -n "$LISA_VERSION" ]; then
     && printf '%s' "$LISA_VERSION" > "$PLUGIN_SYNC_MARKER" 2>/dev/null \
     || true
 fi
+
+# A failed template apply fails this lifecycle script (CodySwannGT/lisa#3466).
+# Deferred to here rather than exiting at the failure itself: plugin sync is
+# independent work that did succeed, and the sync marker above must record it
+# so the next install does not redo it. What must NOT happen is reporting
+# success — that is the whole defect.
+if [ "$APPLY_FAILED" = "true" ]; then
+  exit 1
+fi

package/scripts/two-channel-couplings.json

@@ -5,7 +5,7 @@
   },
   "inspected": {
     "workflows": 22,
-    "steps": 677,
+    "steps": 678,
     "couplings": 33,
     "inventory": 69
   },

package/typescript/copy-overwrite/scripts/lisa-mutation.mjs

@@ -197,6 +197,87 @@ export const OUTCOMES = Object.freeze({
   noFloorApplied: "mutation-gate: no-floor-applied",
 });
 
+/**
+ * The outcomes under which Stryker generated mutants and produced a score.
+ *
+ * THE POINT OF #3668. Every other outcome in {@link OUTCOMES} ends a run that
+ * MEASURED NOTHING, and until this set existed the exit-0 members of that group
+ * were indistinguishable from a real pass at the only layer a merge decision
+ * consults: `🔍 Quality Checks / 🧬 Mutation Testing Gate` printed `pass` for a
+ * pull request no mutant had touched. Measured on #3664 — a 400-line change to
+ * a shipped guard script, `nothing-to-mutate`, `pass`.
+ *
+ * The file said so itself, above {@link OUTCOMES}, and had for months: "both
+ * exit 0, and only the marker says which one happened." The marker lives in a
+ * log; a log is not a control. This set is what lets the workflow render the
+ * difference.
+ *
+ * MEMBERSHIP IS THE STRYKER RUN, not the verdict. `scoped` and `wholeList` are
+ * the two outcomes that carry a `reportRun`, so they are the two under which
+ * mutants existed — whether the score then cleared the floor or not is a
+ * different question, answered by the exit code. A run that measured and FAILED
+ * is still a run that measured.
+ */
+export const MEASURED_OUTCOMES = Object.freeze([
+  OUTCOMES.scoped,
+  OUTCOMES.wholeList,
+]);
+
+/**
+ * Whether an outcome means mutants were generated against this change.
+ *
+ * An unknown marker answers `false`, and that direction is deliberate: a new
+ * outcome added without being classified must not inherit "measured". Failing
+ * closed here costs a `skipping` row on a run that did measure; failing open
+ * costs exactly the false green this issue is about.
+ *
+ * @param {string} outcome - One {@link OUTCOMES} marker
+ * @returns {boolean} True when Stryker produced mutants
+ */
+export const measuredAnything = outcome =>
+  MEASURED_OUTCOMES.includes(String(outcome));
+
+/**
+ * Publishes the outcome where the workflow can render it, then returns the code.
+ *
+ * Every exit in {@link runGate} goes through here, and that is the property
+ * worth more than the plumbing: an exit that forgets to name its outcome is now
+ * impossible to write, rather than merely discouraged by a convention. It is
+ * the same shape the automation-runbook contract asks of a loop — end in
+ * exactly one named outcome — applied to a gate.
+ *
+ * `$GITHUB_OUTPUT` rather than a check-run publish, and the difference is
+ * forced rather than chosen: `test_mutation` in `quality.yml` declares
+ * `permissions: contents: read`, and `quality.yml` is `workflow_call`-only. A
+ * called workflow may only DOWNGRADE its caller's grant — asking for `checks:
+ * write` is a `startup_failure` for the entire run (#2049), which is why
+ * `review-evidence.yml` is a standalone workflow rather than a job. So the
+ * verdict leaves as a job output and a downstream job renders it.
+ *
+ * Best-effort, for the reason every reporting path in this repository is: a
+ * lost output line must never change the exit code the gate worked to earn.
+ *
+ * @param {string} outcome - The {@link OUTCOMES} marker this run ended on
+ * @param {number} code - The exit code to return unchanged
+ * @param {NodeJS.ProcessEnv} [env] - Environment, injectable for tests
+ * @returns {number} `code`, unchanged
+ */
+export const finish = (outcome, code, env = process.env) => {
+  const target = env.GITHUB_OUTPUT;
+  if (target === undefined || target === "") return code;
+  try {
+    fs.appendFileSync(
+      target,
+      `mutation_outcome=${outcome}\nmutation_measured=${measuredAnything(outcome)}\n`
+    );
+  } catch (error) {
+    console.error(
+      `[mutation-gate] outcome outputs not written: ${error.message}`
+    );
+  }
+  return code;
+};
+
 /**
  * Stryker config file names, in the order Stryker itself resolves them.
  *
@@ -2080,7 +2161,7 @@ export const runGate = (cwd = process.cwd(), argv = []) => {
       `⚪ ${OUTCOMES.disabled} — mutation.gate.json says "enabled": false. Skipping.\n` +
         '   Flip "enabled": true (and tune thresholds.break in stryker.conf.json) to turn it on.'
     );
-    return 0;
+    return finish(OUTCOMES.disabled, 0);
   }
 
   const declaration = resolveMutateDeclaration(cwd);
@@ -2093,7 +2174,7 @@ export const runGate = (cwd = process.cwd(), argv = []) => {
         `   ${error instanceof Error ? error.message : String(error)}\n` +
         `   Fix the \`mutate\` patterns in ${declaration.source} before re-running.`
     );
-    return 1;
+    return finish(OUTCOMES.invalidMutatePattern, 1);
   }
 
   if (countMutateTargetsInRepo(cwd, patterns) === 0) {
@@ -2105,7 +2186,7 @@ export const runGate = (cwd = process.cwd(), argv = []) => {
         "   that is switched on and wired to nothing.\n" +
         "   Fix the `mutate` patterns in your Stryker config, or turn the gate off."
     );
-    return 1;
+    return finish(OUTCOMES.inertConfig, 1);
   }
 
   const unparseable = selectUninstrumentableMutateTargets(cwd, patterns);
@@ -2127,7 +2208,7 @@ export const runGate = (cwd = process.cwd(), argv = []) => {
         "   script against a payload table and asserts the blocked/allowed\n" +
         "   verdict — never by this gate."
     );
-    return 1;
+    return finish(OUTCOMES.uninstrumentableTarget, 1);
   }
 
   if (argv.includes(WHOLE_LIST_FLAG)) {
@@ -2135,7 +2216,7 @@ export const runGate = (cwd = process.cwd(), argv = []) => {
       `🧬 ${OUTCOMES.wholeList} — Stryker over every pattern in ` +
         `${declaration.source}, with no diff scoping.`
     );
-    return reportRun(cwd, runStryker(cwd, []));
+    return finish(OUTCOMES.wholeList, reportRun(cwd, runStryker(cwd, [])));
   }
 
   const base = resolveDiffBase(cwd, since);
@@ -2145,7 +2226,7 @@ export const runGate = (cwd = process.cwd(), argv = []) => {
         "   unknown ref). Skipping rather than mutating the whole repository.\n" +
         "   Nothing was measured; this is not a mutation score."
     );
-    return 0;
+    return finish(OUTCOMES.noBase, 0);
   }
 
   let scope;
@@ -2168,7 +2249,7 @@ export const runGate = (cwd = process.cwd(), argv = []) => {
         "   NO mutant was generated and NO score was computed. Nothing was measured,\n" +
         "   so nothing passed."
     );
-    return 1;
+    return finish(OUTCOMES.diffFailed, 1);
   }
 
   if (scope.uninstrumentable.length > 0) {
@@ -2191,7 +2272,7 @@ export const runGate = (cwd = process.cwd(), argv = []) => {
         "   on both sides. Check that one exists; nothing here did."
     );
     if (scope.selected.length === 0 && scope.noCurrentLines.length === 0)
-      return 0;
+      return finish(OUTCOMES.uninstrumentableLanguage, 0);
   }
 
   if (scope.selected.length === 0) {
@@ -2207,7 +2288,7 @@ export const runGate = (cwd = process.cwd(), argv = []) => {
           "   Stryker can place mutants only on current lines. NO mutant was generated\n" +
           "   and NO score was computed; this is not a measured pass."
       );
-      return 0;
+      return finish(OUTCOMES.noCurrentLines, 0);
     }
     console.log(
       `⚪ ${OUTCOMES.nothingToMutate}\n` +
@@ -2216,7 +2297,7 @@ export const runGate = (cwd = process.cwd(), argv = []) => {
         "   NO mutant was generated and NO score was computed. Nothing was measured,\n" +
         "   so nothing passed — do not read this as evidence about your tests."
     );
-    return 0;
+    return finish(OUTCOMES.nothingToMutate, 0);
   }
 
   // `--mutate` is one comma-separated argument, so a path containing a comma
@@ -2234,7 +2315,7 @@ export const runGate = (cwd = process.cwd(), argv = []) => {
         `${listed}\n` +
         "   Rename them, or exclude them in your Stryker config."
     );
-    return 1;
+    return finish(OUTCOMES.unrepresentablePath, 1);
   }
 
   console.log(
@@ -2243,7 +2324,10 @@ export const runGate = (cwd = process.cwd(), argv = []) => {
   );
   for (const file of scope.selected) console.log(`   • ${file}`);
 
-  return reportRun(cwd, runStryker(cwd, scope.selected));
+  return finish(
+    OUTCOMES.scoped,
+    reportRun(cwd, runStryker(cwd, scope.selected))
+  );
 };
 
 /**

package/typescript/copy-overwrite/scripts/reconcile-nightly-e2e-tracking.mjs

@@ -36,8 +36,9 @@ function validateAuthority(findings, trackers) {
   if (!Array.isArray(findings) || findings.length !== 2) {
     refuse(exactSuiteMessage);
   }
-  const labels = findings.map(finding => finding?.label).sort();
-  const expected = [...TRACKED_SUITE_LABELS].sort();
+  const byLabel = (left, right) => String(left).localeCompare(String(right));
+  const labels = findings.map(finding => finding?.label).sort(byLabel);
+  const expected = [...TRACKED_SUITE_LABELS].sort(byLabel);
   if (JSON.stringify(labels) !== JSON.stringify(expected)) {
     refuse(exactSuiteMessage);
   }