tamperward 2.16.5 → 2.17.1

package/dist/cli/index.js

@@ -1385,6 +1385,7 @@ var lintSuppression = {
 };
 
 // src/detectors/test-skip.ts
+import ts2 from "typescript";
 var RULE3 = "test-skip";
 var acc = (names) => `(?:\\s*\\.\\s*(?:${names})(?![\\w$])|\\s*\\[\\s*['"\`](?:${names})['"\`]\\s*\\])`;
 var JS_RUNNER = "\\b(?:it|test|describe|suite)";
@@ -1393,10 +1394,10 @@ var PATTERNS2 = {
   js: [
     // The skip/only/todo family on a runner, by dot-or-bracket access, with one optional
     // vitest concurrency modifier hop: test.skip, test . skip, test['skip'], it.concurrent.skip.
-    { re: new RegExp(JS_RUNNER + acc(JS_MOD) + "?" + acc("skip|only|todo")), why: "a .skip/.only/.todo marker" },
-    { re: new RegExp(JS_RUNNER + acc("skipIf|runIf") + "\\s*\\("), why: "a .skipIf()/.runIf() condition (the test runs only when the condition allows)" },
-    { re: new RegExp(JS_RUNNER + acc("fails|failing") + "\\s*\\("), why: "a .fails/.failing marker (the test now passes by failing)" },
-    { re: /\b(?:it|test|describe)\.each\s*\(\s*\[\s*\]\s*\)/, why: "an empty .each table (no case ever runs)" },
+    { re: new RegExp(JS_RUNNER + acc(JS_MOD) + "?" + acc("skip|only|todo")), why: "a .skip/.only/.todo marker", astOwned: true },
+    { re: new RegExp(JS_RUNNER + acc("skipIf|runIf") + "\\s*\\("), why: "a .skipIf()/.runIf() condition (the test runs only when the condition allows)", astOwned: true },
+    { re: new RegExp(JS_RUNNER + acc("fails|failing") + "\\s*\\("), why: "a .fails/.failing marker (the test now passes by failing)", astOwned: true },
+    { re: /\b(?:it|test|describe)\.each\s*\(\s*\[\s*\]\s*\)/, why: "an empty .each table (no case ever runs)", astOwned: true },
     { re: /\b(?:xit|xtest|xdescribe)\s*\(/, why: "an x-prefixed disabled test" },
     { re: /\b(?:fit|ftest|fdescribe)\s*\(/, why: "an f-prefixed focused test (narrows the suite)" },
     { re: /\bpending\(\s*\)/, why: "a pending() marker" },
@@ -1406,7 +1407,7 @@ var PATTERNS2 = {
     // In options position (right after the title) ANY value but false/0 skips — a
     // non-literal `{ skip: process.env.CI }` included. Elsewhere on a line only the
     // literal forms count: `list({ skip: 1, take: 5 })` is pagination.
-    { re: /\b(?:it|test|describe|suite)\s*\(\s*(['"`])(?:(?!\1).)*\1\s*,\s*\{[^}]*?\bskip:(?!\s*(?:false|0)\b)/, why: "a { skip: ... } option disabling the test (node:test options form)" },
+    { re: /\b(?:it|test|describe|suite)\s*\(\s*(['"`])(?:(?!\1).)*\1\s*,\s*\{[^}]*?\bskip:(?!\s*(?:false|0)\b)/, why: "a { skip: ... } option disabling the test (node:test options form)", astOwned: true },
     { re: /\bskip:\s*(?:true|['"`])/, why: "a { skip: ... } option disabling the test (node:test options form)" },
     { re: /\btodo:\s*(?:true|['"`])/, why: "a { todo: ... } option (the test no longer fails the run)" },
     { re: new RegExp("\\b(?:t|ctx|context|this)" + acc("skip") + "\\s*\\("), why: "a runtime t.skip()/this.skip() call" }
@@ -1477,6 +1478,343 @@ function matchesOutsideString(p, content, lang) {
   }
   return false;
 }
+var JS_RUNNERS = /* @__PURE__ */ new Set(["it", "test", "describe", "suite"]);
+var JS_CHAIN_MODIFIERS = /* @__PURE__ */ new Set(["concurrent", "sequential", "shuffle"]);
+var JS_TEST_MODULES = /* @__PURE__ */ new Set([
+  "vitest",
+  "@jest/globals",
+  "node:test",
+  "node:test/promises",
+  "mocha",
+  "bun:test",
+  "@playwright/test"
+]);
+function scriptKind(path) {
+  if (/\.tsx$/i.test(path)) return ts2.ScriptKind.TSX;
+  if (/\.jsx$/i.test(path)) return ts2.ScriptKind.JSX;
+  if (/\.(?:js|mjs|cjs)$/i.test(path)) return ts2.ScriptKind.JS;
+  return ts2.ScriptKind.TS;
+}
+function addedLineNumbers(c) {
+  const out2 = /* @__PURE__ */ new Set();
+  for (const h of c.hunks) {
+    for (const line of h.lines) {
+      if (line.type === "add" && line.newLine != null) out2.add(line.newLine);
+    }
+  }
+  return out2;
+}
+function moduleName(expr) {
+  return ts2.isStringLiteralLike(expr) ? expr.text : null;
+}
+function requiredModule(expr) {
+  if (!ts2.isCallExpression(expr) || !ts2.isIdentifier(expr.expression) || expr.expression.text !== "require" || expr.arguments.length !== 1) return null;
+  return moduleName(expr.arguments[0]);
+}
+function astContext(path, source) {
+  const rootName = path.startsWith("/") ? path : "/tamperward/" + path;
+  const sf = ts2.createSourceFile(
+    rootName,
+    source,
+    ts2.ScriptTarget.Latest,
+    true,
+    scriptKind(path)
+  );
+  const diagnostics = sf.parseDiagnostics ?? [];
+  if (diagnostics.length > 0) return null;
+  const options = {
+    allowJs: true,
+    checkJs: false,
+    noLib: true,
+    noResolve: true,
+    target: ts2.ScriptTarget.Latest,
+    module: ts2.ModuleKind.ESNext
+  };
+  const host = ts2.createCompilerHost(options, true);
+  host.getSourceFile = (fileName) => fileName === rootName ? sf : void 0;
+  host.fileExists = (fileName) => fileName === rootName;
+  host.readFile = (fileName) => fileName === rootName ? source : void 0;
+  host.writeFile = () => {
+  };
+  host.getDefaultLibFileName = () => "";
+  host.getCurrentDirectory = () => "/tamperward";
+  host.getCanonicalFileName = (fileName) => fileName;
+  host.useCaseSensitiveFileNames = () => true;
+  host.getNewLine = () => "\n";
+  const program = ts2.createProgram([rootName], options, host);
+  return { sf, checker: program.getTypeChecker() };
+}
+function symbolAt(ctx, node) {
+  return ctx.checker.getSymbolAtLocation(node) ?? null;
+}
+function importAliases(ctx) {
+  const out2 = /* @__PURE__ */ new Map();
+  const simpleAliases = [];
+  const add = (id, causes = [id]) => {
+    const sym = symbolAt(ctx, id);
+    if (sym) out2.set(sym, { causes });
+  };
+  for (const stmt of ctx.sf.statements) {
+    if (ts2.isImportDeclaration(stmt) && ts2.isStringLiteralLike(stmt.moduleSpecifier)) {
+      if (!JS_TEST_MODULES.has(stmt.moduleSpecifier.text)) continue;
+      const clause = stmt.importClause;
+      if (!clause) continue;
+      if (clause.name && stmt.moduleSpecifier.text.startsWith("node:test")) add(clause.name);
+      const bindings = clause.namedBindings;
+      if (bindings && ts2.isNamedImports(bindings)) {
+        for (const el of bindings.elements) {
+          const imported = el.propertyName?.text ?? el.name.text;
+          if (JS_RUNNERS.has(imported)) add(el.name);
+        }
+      }
+      continue;
+    }
+    if (!ts2.isVariableStatement(stmt)) continue;
+    for (const decl of stmt.declarationList.declarations) {
+      if (ts2.isObjectBindingPattern(decl.name) && decl.initializer) {
+        const mod = requiredModule(decl.initializer);
+        if (!mod || !JS_TEST_MODULES.has(mod)) continue;
+        for (const el of decl.name.elements) {
+          if (!ts2.isIdentifier(el.name)) continue;
+          const imported = el.propertyName && ts2.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
+          if (JS_RUNNERS.has(imported)) add(el.name);
+        }
+      } else if (ts2.isIdentifier(decl.name) && decl.initializer && ts2.isIdentifier(decl.initializer)) {
+        simpleAliases.push({ local: decl.name, source: decl.initializer });
+      }
+    }
+  }
+  for (let pass = 0; pass < simpleAliases.length + 1; pass++) {
+    let changed = false;
+    for (const alias of simpleAliases) {
+      const localSym = symbolAt(ctx, alias.local);
+      if (!localSym || out2.has(localSym)) continue;
+      const sourceSym = symbolAt(ctx, alias.source);
+      const sourceBinding = sourceSym ? out2.get(sourceSym) : void 0;
+      const implicitGlobal = sourceSym == null && JS_RUNNERS.has(alias.source.text);
+      if (!sourceBinding && !implicitGlobal) continue;
+      out2.set(localSym, {
+        causes: [alias.local, ...sourceBinding?.causes ?? []]
+      });
+      changed = true;
+    }
+    if (!changed) break;
+  }
+  return out2;
+}
+function topLevelStaticStrings(ctx) {
+  const pending = /* @__PURE__ */ new Map();
+  for (const stmt of ctx.sf.statements) {
+    if (!ts2.isVariableStatement(stmt)) continue;
+    const isConst = (stmt.declarationList.flags & ts2.NodeFlags.Const) !== 0;
+    if (!isConst) continue;
+    for (const decl of stmt.declarationList.declarations) {
+      if (!ts2.isIdentifier(decl.name) || !decl.initializer) continue;
+      const sym = symbolAt(ctx, decl.name);
+      if (sym) pending.set(sym, { decl: decl.name, expr: decl.initializer });
+    }
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  const resolving = /* @__PURE__ */ new Set();
+  const valueOf = (expr) => {
+    if (ts2.isStringLiteralLike(expr)) return { value: expr.text, causes: [] };
+    if (ts2.isParenthesizedExpression(expr)) return valueOf(expr.expression);
+    if (ts2.isBinaryExpression(expr) && expr.operatorToken.kind === ts2.SyntaxKind.PlusToken) {
+      const left = valueOf(expr.left);
+      const right = valueOf(expr.right);
+      if (!left || !right) return null;
+      return { value: left.value + right.value, causes: [...left.causes, ...right.causes] };
+    }
+    if (ts2.isIdentifier(expr)) {
+      const sym = symbolAt(ctx, expr);
+      if (!sym) return null;
+      const cached = resolved.get(sym);
+      if (cached) return cached;
+      const item = pending.get(sym);
+      if (!item || resolving.has(sym)) return null;
+      resolving.add(sym);
+      const nested = valueOf(item.expr);
+      resolving.delete(sym);
+      if (!nested) return null;
+      const result = { value: nested.value, causes: [item.decl, ...nested.causes] };
+      resolved.set(sym, result);
+      return result;
+    }
+    return null;
+  };
+  for (const [sym, item] of pending) {
+    if (resolved.has(sym)) continue;
+    resolving.add(sym);
+    const nested = valueOf(item.expr);
+    resolving.delete(sym);
+    if (nested) resolved.set(sym, { value: nested.value, causes: [item.decl, ...nested.causes] });
+  }
+  return resolved;
+}
+function staticPropertyName(expr, ctx, strings) {
+  if (ts2.isStringLiteralLike(expr)) return { name: expr.text, causes: [] };
+  if (ts2.isParenthesizedExpression(expr)) return staticPropertyName(expr.expression, ctx, strings);
+  if (ts2.isBinaryExpression(expr) && expr.operatorToken.kind === ts2.SyntaxKind.PlusToken) {
+    const left = staticPropertyName(expr.left, ctx, strings);
+    const right = staticPropertyName(expr.right, ctx, strings);
+    if (!left || !right) return null;
+    return { name: left.name + right.name, causes: [...left.causes, ...right.causes] };
+  }
+  if (ts2.isIdentifier(expr)) {
+    const sym = symbolAt(ctx, expr);
+    if (!sym) return null;
+    const value = strings.get(sym);
+    return value ? { name: value.value, causes: value.causes } : null;
+  }
+  return null;
+}
+function runnerChain(expr, ctx, runners, strings) {
+  const props = [];
+  const causes = [];
+  let cur = expr;
+  let terminalNode = expr;
+  while (ts2.isPropertyAccessExpression(cur) || ts2.isElementAccessExpression(cur)) {
+    if (ts2.isPropertyAccessExpression(cur)) {
+      props.unshift(cur.name.text);
+      if (props.length === 1) terminalNode = cur.name;
+      cur = cur.expression;
+      continue;
+    }
+    if (!cur.argumentExpression) return null;
+    const property = staticPropertyName(cur.argumentExpression, ctx, strings);
+    if (!property) return null;
+    props.unshift(property.name);
+    causes.push(...property.causes);
+    if (props.length === 1) terminalNode = cur.argumentExpression;
+    cur = cur.expression;
+  }
+  if (!ts2.isIdentifier(cur)) return null;
+  const sym = symbolAt(ctx, cur);
+  if (sym) {
+    const binding = runners.get(sym);
+    if (!binding) return null;
+    causes.push(...binding.causes);
+  } else if (!JS_RUNNERS.has(cur.text)) {
+    return null;
+  }
+  return { root: cur.text, props, terminalNode, causes };
+}
+function optionDisables(value) {
+  return !(value.kind === ts2.SyntaxKind.FalseKeyword || ts2.isNumericLiteral(value) && Number(value.text) === 0);
+}
+function shorthandOptionDisables(prop, ctx) {
+  const sym = ctx.checker.getShorthandAssignmentValueSymbol(prop) ?? symbolAt(ctx, prop.name);
+  const decl = sym?.valueDeclaration ?? sym?.declarations?.find((d) => ts2.isVariableDeclaration(d));
+  if (!decl || !ts2.isVariableDeclaration(decl) || !decl.initializer) return true;
+  return optionDisables(decl.initializer);
+}
+function structuralNodeKey(node, sf) {
+  const children = node.getChildren(sf);
+  const text = node.text;
+  if (children.length === 0) {
+    return typeof text === "string" ? `${node.kind}:${JSON.stringify(text)}` : String(node.kind);
+  }
+  return `${node.kind}(${children.map((child) => structuralNodeKey(child, sf)).join(",")})`;
+}
+function semanticSkipHits(ctx) {
+  const runners = importAliases(ctx);
+  const strings = topLevelStaticStrings(ctx);
+  const hits = [];
+  const callOrdinals = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    if (ts2.isCallExpression(node)) {
+      const callText = node.getText(ctx.sf).trim();
+      const callIdentity = structuralNodeKey(node, ctx.sf);
+      const ordinal = (callOrdinals.get(callIdentity) ?? 0) + 1;
+      callOrdinals.set(callIdentity, ordinal);
+      const callKey = `${callIdentity}\0${ordinal}`;
+      const chain = runnerChain(node.expression, ctx, runners, strings);
+      if (chain) {
+        const { props, terminalNode, causes } = chain;
+        const terminal = props.at(-1);
+        const push = (target, extraCauses, why) => {
+          hits.push({
+            semanticKey: `${callKey}\0${why}`,
+            terminalNode: target,
+            causeNodes: [...causes, ...extraCauses],
+            why,
+            evidence: callText
+          });
+        };
+        if (terminal && (terminal === "skip" || terminal === "only" || terminal === "todo") && props.slice(0, -1).every((p) => JS_CHAIN_MODIFIERS.has(p))) {
+          push(terminalNode, [], "a .skip/.only/.todo marker");
+        } else if (terminal && ["skipIf", "runIf"].includes(terminal) && props.length === 1) {
+          push(terminalNode, [], "a .skipIf()/.runIf() condition (the test runs only when the condition allows)");
+        } else if (terminal && ["fails", "failing"].includes(terminal) && props.length === 1) {
+          push(terminalNode, [], "a .fails/.failing marker (the test now passes by failing)");
+        } else if (terminal === "each" && props.length === 1 && node.arguments.length > 0 && ts2.isArrayLiteralExpression(node.arguments[0]) && node.arguments[0].elements.length === 0) {
+          push(terminalNode, [], "an empty .each table (no case ever runs)");
+        }
+        if (props.length === 0) {
+          for (const arg of node.arguments) {
+            if (!ts2.isObjectLiteralExpression(arg)) continue;
+            for (const prop of arg.properties) {
+              if (ts2.isPropertyAssignment(prop)) {
+                let name = null;
+                let propertyCauses = [];
+                if (ts2.isIdentifier(prop.name) || ts2.isStringLiteralLike(prop.name)) {
+                  name = prop.name.text;
+                } else if (ts2.isComputedPropertyName(prop.name)) {
+                  const resolved = staticPropertyName(prop.name.expression, ctx, strings);
+                  name = resolved?.name ?? null;
+                  propertyCauses = resolved?.causes ?? [];
+                }
+                if (!name || !["skip", "todo", "only"].includes(name)) continue;
+                if (!optionDisables(prop.initializer)) continue;
+                const why = name === "only" ? "an { only: ... } option focusing the test" : name === "todo" ? "a { todo: ... } option (the test no longer fails the run)" : "a { skip: ... } option disabling the test";
+                push(prop.name, propertyCauses, why);
+              } else if (ts2.isShorthandPropertyAssignment(prop) && ["skip", "todo", "only"].includes(prop.name.text)) {
+                if (!shorthandOptionDisables(prop, ctx)) continue;
+                push(prop.name, [], `a { ${prop.name.text} } option that conditionally narrows the test run`);
+              }
+            }
+          }
+        }
+      }
+    }
+    ts2.forEachChild(node, visit);
+  };
+  visit(ctx.sf);
+  return hits;
+}
+function astSkipHits(c) {
+  if (c.after == null) return { hits: [], authoritative: false };
+  const added = addedLineNumbers(c);
+  if (added.size === 0) return { hits: [], authoritative: false };
+  const afterCtx = astContext(c.path, c.after);
+  if (!afterCtx) return { hits: [], authoritative: false };
+  const beforeCtx = c.before == null ? null : astContext(c.path, c.before);
+  const beforeKeys = beforeCtx == null ? null : new Set(semanticSkipHits(beforeCtx).map((hit) => hit.semanticKey));
+  const lineOf = (node) => afterCtx.sf.getLineAndCharacterOfPosition(node.getStart(afterCtx.sf)).line + 1;
+  const hits = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const hit of semanticSkipHits(afterCtx)) {
+    const directLine = lineOf(hit.terminalNode);
+    let findingLine = added.has(directLine) ? directLine : null;
+    if (findingLine == null) {
+      for (const cause of hit.causeNodes) {
+        const line = lineOf(cause);
+        if (added.has(line)) {
+          findingLine = line;
+          break;
+        }
+      }
+      if (findingLine == null) continue;
+      if (beforeKeys == null) continue;
+    }
+    if (beforeKeys?.has(hit.semanticKey)) continue;
+    const dedupe = `${findingLine}\0${hit.semanticKey}`;
+    if (seen.has(dedupe)) continue;
+    seen.add(dedupe);
+    hits.push({ line: findingLine, why: hit.why, evidence: hit.evidence });
+  }
+  return { hits, authoritative: true };
+}
 var testSkip = {
   id: RULE3,
   surface: ["file"],
@@ -1488,9 +1826,29 @@ var testSkip = {
       if (!isProtected(c.path, policy, "tests")) continue;
       const lang = langOf(c.path);
       const patterns = PATTERNS2[lang ?? "js"];
+      const astHitLines = /* @__PURE__ */ new Set();
+      let astAuthoritative = false;
+      if (lang === "js" && c.after != null) {
+        const analysis = astSkipHits(c);
+        astAuthoritative = analysis.authoritative;
+        for (const hit of analysis.hits) {
+          astHitLines.add(hit.line);
+          out2.push(
+            makeFinding(RULE3, policy, {
+              file: c.path,
+              line: hit.line,
+              message: `Test skipped or narrowed: ${hit.why}.`,
+              evidence: hit.evidence,
+              remediation: "Make the test pass rather than skipping it. If it is genuinely obsolete, a human must sign off."
+            })
+          );
+        }
+      }
       for (const l of addedLines(c)) {
+        if (l.newLine != null && astHitLines.has(l.newLine)) continue;
         const comment = isCommentLine(l.content.trim(), lang);
         for (const p of patterns) {
+          if (astAuthoritative && p.astOwned) continue;
           if (comment && !p.comment) continue;
           if (matchesOutsideString(p, l.content, lang)) {
             out2.push(
@@ -1513,7 +1871,7 @@ var testSkip = {
 
 // src/detectors/coverage-lowering.ts
 import picomatch2 from "picomatch";
-import ts2 from "typescript";
+import ts3 from "typescript";
 
 // src/detectors/repo.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
@@ -1641,29 +1999,29 @@ var METRICS = ["branches", "functions", "lines", "statements"];
 var isMetric = (k) => METRICS.includes(k);
 var norm = (p) => p.replace(/^\.\//, "");
 function keyName(name) {
-  if (ts2.isIdentifier(name) || ts2.isStringLiteral(name) || ts2.isNumericLiteral(name)) return name.text;
+  if (ts3.isIdentifier(name) || ts3.isStringLiteral(name) || ts3.isNumericLiteral(name)) return name.text;
   return null;
 }
 function numericOf(e) {
-  if (ts2.isNumericLiteral(e)) return Number(e.text);
-  if (ts2.isStringLiteral(e) && /^-?\d+(?:\.\d+)?$/.test(e.text.trim())) return Number(e.text);
-  if (ts2.isPrefixUnaryExpression(e) && e.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(e.operand)) {
+  if (ts3.isNumericLiteral(e)) return Number(e.text);
+  if (ts3.isStringLiteral(e) && /^-?\d+(?:\.\d+)?$/.test(e.text.trim())) return Number(e.text);
+  if (ts3.isPrefixUnaryExpression(e) && e.operator === ts3.SyntaxKind.MinusToken && ts3.isNumericLiteral(e.operand)) {
     return -Number(e.operand.text);
   }
   return void 0;
 }
 function metricsOf(expr, resolve9) {
   const obj = resolve9(expr);
-  if (!ts2.isObjectLiteralExpression(obj)) return void 0;
+  if (!ts3.isObjectLiteralExpression(obj)) return void 0;
   const out2 = { values: {}, opaque: false };
   let any = false;
   for (const p of obj.properties) {
-    if (ts2.isSpreadAssignment(p)) {
+    if (ts3.isSpreadAssignment(p)) {
       out2.opaque = true;
       any = true;
       continue;
     }
-    if (!ts2.isPropertyAssignment(p)) continue;
+    if (!ts3.isPropertyAssignment(p)) continue;
     const k = keyName(p.name);
     if (k === null || !isMetric(k)) continue;
     any = true;
@@ -1675,34 +2033,34 @@ function metricsOf(expr, resolve9) {
 }
 function underKey(node, key2) {
   for (let p = node.parent; p; p = p.parent) {
-    if (ts2.isPropertyAssignment(p) && keyName(p.name) === key2) return true;
+    if (ts3.isPropertyAssignment(p) && keyName(p.name) === key2) return true;
   }
   return false;
 }
 function ownerKey(node) {
   const obj = node.parent;
-  if (!obj || !ts2.isObjectLiteralExpression(obj)) return null;
+  if (!obj || !ts3.isObjectLiteralExpression(obj)) return null;
   let q = obj.parent;
-  while (q && (ts2.isParenthesizedExpression(q) || ts2.isAsExpression(q) || q.kind === ts2.SyntaxKind.SatisfiesExpression)) q = q.parent;
-  return q && ts2.isPropertyAssignment(q) ? keyName(q.name) : null;
+  while (q && (ts3.isParenthesizedExpression(q) || ts3.isAsExpression(q) || q.kind === ts3.SyntaxKind.SatisfiesExpression)) q = q.parent;
+  return q && ts3.isPropertyAssignment(q) ? keyName(q.name) : null;
 }
 function asExpression(src) {
   const t = src.trim();
   return t.startsWith("{") ? `(${t})` : src;
 }
 function sourceOf(src) {
-  return ts2.createSourceFile("cfg.ts", asExpression(src), ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TS);
+  return ts3.createSourceFile("cfg.ts", asExpression(src), ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
 }
 function resolverFor(sf) {
   const consts = /* @__PURE__ */ new Map();
   for (const st of sf.statements) {
-    if (!ts2.isVariableStatement(st)) continue;
+    if (!ts3.isVariableStatement(st)) continue;
     for (const d of st.declarationList.declarations) {
-      if (ts2.isIdentifier(d.name) && d.initializer) consts.set(d.name.text, d.initializer);
+      if (ts3.isIdentifier(d.name) && d.initializer) consts.set(d.name.text, d.initializer);
     }
   }
   return (e) => {
-    if (ts2.isIdentifier(e)) {
+    if (ts3.isIdentifier(e)) {
       const bound = consts.get(e.text);
       return bound ?? e;
     }
@@ -1715,25 +2073,25 @@ function parseThresholds(src) {
     const sf = sourceOf(src);
     const resolve9 = resolverFor(sf);
     const visit = (node) => {
-      if (ts2.isPropertyAssignment(node)) {
+      if (ts3.isPropertyAssignment(node)) {
         const key2 = keyName(node.name);
         if (key2 === "coverageThreshold" || key2 === "thresholds" && underKey(node, "coverage")) {
           res.present = true;
           const init = resolve9(node.initializer);
-          if (!ts2.isObjectLiteralExpression(init)) {
+          if (!ts3.isObjectLiteralExpression(init)) {
             res.opaque = true;
           } else {
             const flat = metricsOf(init, resolve9);
             if (flat) res.global = merge(res.global, flat);
             for (const p of init.properties) {
-              if (ts2.isSpreadAssignment(p)) {
+              if (ts3.isSpreadAssignment(p)) {
                 res.opaque = true;
                 continue;
               }
-              if (!ts2.isPropertyAssignment(p)) continue;
+              if (!ts3.isPropertyAssignment(p)) continue;
               const k = keyName(p.name);
               if (k === null || isMetric(k)) continue;
-              if (key2 === "thresholds" && k === "100" && p.initializer.kind === ts2.SyntaxKind.TrueKeyword) {
+              if (key2 === "thresholds" && k === "100" && p.initializer.kind === ts3.SyntaxKind.TrueKeyword) {
                 res.global = merge(res.global, { values: { branches: 100, functions: 100, lines: 100, statements: 100 }, opaque: false });
                 continue;
               }
@@ -1745,7 +2103,7 @@ function parseThresholds(src) {
           }
         }
       }
-      ts2.forEachChild(node, visit);
+      ts3.forEachChild(node, visit);
     };
     visit(sf);
   } catch {
@@ -1756,12 +2114,12 @@ function merge(a, b) {
   return { values: { ...a?.values ?? {}, ...b.values }, opaque: (a?.opaque ?? false) || b.opaque };
 }
 function literals(e) {
-  if (ts2.isStringLiteral(e)) return { items: [e.text], opaque: false };
-  if (!ts2.isArrayLiteralExpression(e)) return { items: [], opaque: true };
+  if (ts3.isStringLiteral(e)) return { items: [e.text], opaque: false };
+  if (!ts3.isArrayLiteralExpression(e)) return { items: [], opaque: true };
   const items = [];
   let opaque = false;
   for (const el of e.elements) {
-    if (ts2.isStringLiteral(el) || ts2.isNoSubstitutionTemplateLiteral(el)) items.push(el.text);
+    if (ts3.isStringLiteral(el) || ts3.isNoSubstitutionTemplateLiteral(el)) items.push(el.text);
     else opaque = true;
   }
   return { items, opaque };
@@ -1772,7 +2130,7 @@ function parseLists(src) {
     const sf = sourceOf(src);
     const resolve9 = resolverFor(sf);
     const visit = (node) => {
-      if (ts2.isPropertyAssignment(node)) {
+      if (ts3.isPropertyAssignment(node)) {
         const k = keyName(node.name);
         const vitestCoverage = ownerKey(node) === "coverage";
         if (k === "collectCoverageFrom" || k === "include" && vitestCoverage) {
@@ -1786,7 +2144,7 @@ function parseLists(src) {
           if (opaque) res.opaqueIgnore = true;
         }
       }
-      ts2.forEachChild(node, visit);
+      ts3.forEachChild(node, visit);
     };
     visit(sf);
   } catch {
@@ -1797,15 +2155,15 @@ function parseSwitches(src) {
   const res = {};
   try {
     const sf = sourceOf(src);
-    const bool = (e) => e.kind === ts2.SyntaxKind.TrueKeyword ? true : e.kind === ts2.SyntaxKind.FalseKeyword ? false : void 0;
+    const bool = (e) => e.kind === ts3.SyntaxKind.TrueKeyword ? true : e.kind === ts3.SyntaxKind.FalseKeyword ? false : void 0;
     const visit = (node) => {
-      if (ts2.isPropertyAssignment(node)) {
+      if (ts3.isPropertyAssignment(node)) {
         const k = keyName(node.name);
         const owner = ownerKey(node);
         if (k === "enabled" && owner === "coverage") res.enabled = bool(node.initializer);
         else if (k === "perFile" && owner === "thresholds" && underKey(node, "coverage")) res.perFile = bool(node.initializer);
       }
-      ts2.forEachChild(node, visit);
+      ts3.forEachChild(node, visit);
     };
     visit(sf);
   } catch {
@@ -1818,11 +2176,11 @@ function sectionText(src, key2) {
     let out2 = "";
     const visit = (node) => {
       if (out2) return;
-      if (ts2.isPropertyAssignment(node) && keyName(node.name) === key2 && ts2.isObjectLiteralExpression(node.initializer)) {
+      if (ts3.isPropertyAssignment(node) && keyName(node.name) === key2 && ts3.isObjectLiteralExpression(node.initializer)) {
         out2 = node.initializer.getText(sf);
         return;
       }
-      ts2.forEachChild(node, visit);
+      ts3.forEachChild(node, visit);
     };
     visit(sf);
     return out2;
@@ -5172,11 +5530,11 @@ var hookTampering = {
 };
 
 // src/detectors/test-deletion.ts
-import ts4 from "typescript";
+import ts5 from "typescript";
 
 // src/detectors/suite-config.ts
 import picomatch3 from "picomatch";
-import ts3 from "typescript";
+import ts4 from "typescript";
 var JEST_DEFAULT_MATCH = ["**/__tests__/**/*.[jt]s?(x)", "**/?(*.)+(spec|test).[jt]s?(x)"];
 var JEST_DEFAULT_IGNORE = ["/node_modules/"];
 var VITEST_DEFAULT_INCLUDE = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
@@ -5207,18 +5565,18 @@ var PYTEST_CANONICAL_SAMPLES = [
   "tests/conftest.py"
 ];
 function keyName2(name) {
-  if (ts3.isIdentifier(name) || ts3.isStringLiteral(name)) return name.text;
+  if (ts4.isIdentifier(name) || ts4.isStringLiteral(name)) return name.text;
   return null;
 }
-var isStr = (e) => ts3.isStringLiteral(e) || ts3.isNoSubstitutionTemplateLiteral(e);
+var isStr = (e) => ts4.isStringLiteral(e) || ts4.isNoSubstitutionTemplateLiteral(e);
 function literals2(e) {
   if (isStr(e)) return { items: [e.text], opaque: false };
-  if (!ts3.isArrayLiteralExpression(e)) return { items: [], opaque: true };
+  if (!ts4.isArrayLiteralExpression(e)) return { items: [], opaque: true };
   const items = [];
   let opaque = false;
   for (const el of e.elements) {
     if (isStr(el)) items.push(el.text);
-    else if (ts3.isSpreadElement(el) && /^(?:configDefaults\.|default)(?:exclude|include)$/i.test(el.expression.getText())) {
+    else if (ts4.isSpreadElement(el) && /^(?:configDefaults\.|default)(?:exclude|include)$/i.test(el.expression.getText())) {
       items.push(.../exclude$/i.test(el.expression.getText()) ? VITEST_DEFAULT_EXCLUDE : VITEST_DEFAULT_INCLUDE);
     } else opaque = true;
   }
@@ -5226,10 +5584,10 @@ function literals2(e) {
 }
 function ownerKey2(node) {
   const obj = node.parent;
-  if (!obj || !ts3.isObjectLiteralExpression(obj)) return null;
+  if (!obj || !ts4.isObjectLiteralExpression(obj)) return null;
   let q = obj.parent;
-  while (q && (ts3.isParenthesizedExpression(q) || ts3.isAsExpression(q) || q.kind === ts3.SyntaxKind.SatisfiesExpression)) q = q.parent;
-  return q && ts3.isPropertyAssignment(q) ? keyName2(q.name) : null;
+  while (q && (ts4.isParenthesizedExpression(q) || ts4.isAsExpression(q) || q.kind === ts4.SyntaxKind.SatisfiesExpression)) q = q.parent;
+  return q && ts4.isPropertyAssignment(q) ? keyName2(q.name) : null;
 }
 function asExpression2(src) {
   const t = src.trim();
@@ -5370,15 +5728,15 @@ function collect(root, runner) {
     projectList = e;
   };
   const visit = (node) => {
-    if (ts3.isSpreadAssignment(node) && spreadsIntoConfig(node, runner)) {
+    if (ts4.isSpreadAssignment(node) && spreadsIntoConfig(node, runner)) {
       sel.present = true;
       sel.opaque = true;
     }
-    if (ts3.isCallExpression(node) && /^(?:\w+\.)?mergeConfig$/.test(node.expression.getText()) && node.arguments[0] && !ts3.isObjectLiteralExpression(unwrapConfigCall(node.arguments[0]))) {
+    if (ts4.isCallExpression(node) && /^(?:\w+\.)?mergeConfig$/.test(node.expression.getText()) && node.arguments[0] && !ts4.isObjectLiteralExpression(unwrapConfigCall(node.arguments[0]))) {
       sel.present = true;
       sel.opaque = true;
     }
-    if (ts3.isPropertyAssignment(node)) {
+    if (ts4.isPropertyAssignment(node)) {
       const k = keyName2(node.name);
       if (runner === "jest") {
         if (k === "testMatch") sel.include = take(k, node.initializer);
@@ -5408,7 +5766,7 @@ function collect(root, runner) {
         }
       }
     }
-    ts3.forEachChild(node, visit);
+    ts4.forEachChild(node, visit);
   };
   visit(root);
   if (projectList) sel.projects = readProjects(projectList, sel, runner);
@@ -5417,30 +5775,30 @@ function collect(root, runner) {
 }
 function unwrapConfigCall(e) {
   let x = e;
-  while (ts3.isParenthesizedExpression(x) || ts3.isAsExpression(x) || x.kind === ts3.SyntaxKind.SatisfiesExpression) {
+  while (ts4.isParenthesizedExpression(x) || ts4.isAsExpression(x) || x.kind === ts4.SyntaxKind.SatisfiesExpression) {
     x = x.expression;
   }
-  if (ts3.isCallExpression(x) && /^(?:\w+\.)?define(?:Config|Project)$/.test(x.expression.getText()) && x.arguments[0]) return unwrapConfigCall(x.arguments[0]);
+  if (ts4.isCallExpression(x) && /^(?:\w+\.)?define(?:Config|Project)$/.test(x.expression.getText()) && x.arguments[0]) return unwrapConfigCall(x.arguments[0]);
   return x;
 }
 var JEST_SELECTION_KEYS = /^(?:testMatch|testRegex|testPathIgnorePatterns|modulePathIgnorePatterns|roots|rootDir|projects)$/;
 function spreadsIntoConfig(node, runner) {
   const obj = node.parent;
-  if (!ts3.isObjectLiteralExpression(obj)) return false;
-  const keys = obj.properties.map((p) => ts3.isPropertyAssignment(p) ? keyName2(p.name) : null);
+  if (!ts4.isObjectLiteralExpression(obj)) return false;
+  const keys = obj.properties.map((p) => ts4.isPropertyAssignment(p) ? keyName2(p.name) : null);
   if (runner === "vitest") {
     if (keys.includes("test")) return true;
     let q = obj.parent;
-    while (q && (ts3.isParenthesizedExpression(q) || ts3.isAsExpression(q) || q.kind === ts3.SyntaxKind.SatisfiesExpression)) q = q.parent;
-    return !!q && ts3.isPropertyAssignment(q) && keyName2(q.name) === "test";
+    while (q && (ts4.isParenthesizedExpression(q) || ts4.isAsExpression(q) || q.kind === ts4.SyntaxKind.SatisfiesExpression)) q = q.parent;
+    return !!q && ts4.isPropertyAssignment(q) && keyName2(q.name) === "test";
   }
   return keys.some((k) => k !== null && JEST_SELECTION_KEYS.test(k));
 }
 function extendsOf(el) {
   for (const p of el.properties) {
-    if (!ts3.isPropertyAssignment(p) || keyName2(p.name) !== "extends") continue;
-    if (p.initializer.kind === ts3.SyntaxKind.TrueKeyword) return true;
-    if (p.initializer.kind === ts3.SyntaxKind.FalseKeyword) return null;
+    if (!ts4.isPropertyAssignment(p) || keyName2(p.name) !== "extends") continue;
+    if (p.initializer.kind === ts4.SyntaxKind.TrueKeyword) return true;
+    if (p.initializer.kind === ts4.SyntaxKind.FalseKeyword) return null;
     return "path";
   }
   return null;
@@ -5461,14 +5819,14 @@ function readProject(el, root, runner) {
   return p;
 }
 function readProjects(e, root, runner) {
-  if (!ts3.isArrayLiteralExpression(e)) {
+  if (!ts4.isArrayLiteralExpression(e)) {
     root.opaque = true;
     return [];
   }
   const list2 = [];
   for (const el of e.elements) {
     const lit = unwrapConfigCall(el);
-    if (ts3.isObjectLiteralExpression(lit)) list2.push(readProject(lit, root, runner));
+    if (ts4.isObjectLiteralExpression(lit)) list2.push(readProject(lit, root, runner));
     else root.opaque = true;
   }
   return list2;
@@ -5476,14 +5834,14 @@ function readProjects(e, root, runner) {
 function workspaceArray(sf) {
   for (const st of sf.statements) {
     let e;
-    if (ts3.isExportAssignment(st)) e = st.expression;
-    else if (ts3.isExpressionStatement(st) && ts3.isBinaryExpression(st.expression) && /module\.exports/.test(st.expression.left.getText())) e = st.expression.right;
+    if (ts4.isExportAssignment(st)) e = st.expression;
+    else if (ts4.isExpressionStatement(st) && ts4.isBinaryExpression(st.expression) && /module\.exports/.test(st.expression.left.getText())) e = st.expression.right;
     if (!e) continue;
-    while (ts3.isParenthesizedExpression(e) || ts3.isAsExpression(e) || e.kind === ts3.SyntaxKind.SatisfiesExpression) {
+    while (ts4.isParenthesizedExpression(e) || ts4.isAsExpression(e) || e.kind === ts4.SyntaxKind.SatisfiesExpression) {
       e = e.expression;
     }
-    if (ts3.isCallExpression(e) && e.arguments.length > 0) e = e.arguments[0];
-    return ts3.isArrayLiteralExpression(e) ? e : null;
+    if (ts4.isCallExpression(e) && e.arguments.length > 0) e = e.arguments[0];
+    return ts4.isArrayLiteralExpression(e) ? e : null;
   }
   return null;
 }
@@ -5491,7 +5849,7 @@ function parseSelection(src, runner, path = "") {
   let sel = empty();
   if (runner === "pytest") return pytestSelection(src);
   try {
-    const sf = ts3.createSourceFile("cfg.ts", asExpression2(src), ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
+    const sf = ts4.createSourceFile("cfg.ts", asExpression2(src), ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TS);
     if (runner === "vitest" && isWorkspaceFile(path)) {
       const arr = workspaceArray(sf);
       if (arr) {
@@ -5598,21 +5956,21 @@ var TEST_DEFS = {
   cs: /^\s*\[(?:Fact|Theory|Test|TestMethod|TestCase|DataTestMethod)\b/
 };
 function calleeName(expr) {
-  if (ts4.isIdentifier(expr)) return expr.text;
-  if (ts4.isPropertyAccessExpression(expr) && ts4.isIdentifier(expr.expression)) {
+  if (ts5.isIdentifier(expr)) return expr.text;
+  if (ts5.isPropertyAccessExpression(expr) && ts5.isIdentifier(expr.expression)) {
     return expr.expression.text;
   }
   return null;
 }
 var TABLE_METHOD = /^(?:each|for)$/;
-var isEachOf = (expr) => ts4.isPropertyAccessExpression(expr) && ts4.isIdentifier(expr.expression) && (expr.expression.text === "it" || expr.expression.text === "test") && TABLE_METHOD.test(expr.name.text);
-var isDescribeEach = (expr) => ts4.isPropertyAccessExpression(expr) && ts4.isIdentifier(expr.expression) && expr.expression.text === "describe" && TABLE_METHOD.test(expr.name.text);
+var isEachOf = (expr) => ts5.isPropertyAccessExpression(expr) && ts5.isIdentifier(expr.expression) && (expr.expression.text === "it" || expr.expression.text === "test") && TABLE_METHOD.test(expr.name.text);
+var isDescribeEach = (expr) => ts5.isPropertyAccessExpression(expr) && ts5.isIdentifier(expr.expression) && expr.expression.text === "describe" && TABLE_METHOD.test(expr.name.text);
 function loopRows(iterable) {
-  if (ts4.isArrayLiteralExpression(iterable)) {
+  if (ts5.isArrayLiteralExpression(iterable)) {
     let n = 0;
     let open = false;
     for (const el of iterable.elements) {
-      if (ts4.isSpreadElement(el)) open = true;
+      if (ts5.isSpreadElement(el)) open = true;
       else n++;
     }
     return { n: Math.max(n, open ? 0 : 1), open };
@@ -5624,20 +5982,20 @@ function templateRows(node) {
   return Math.max(rows, 1);
 }
 function hasSubstantiveBody(call) {
-  const fn = call.arguments.find((a) => ts4.isArrowFunction(a) || ts4.isFunctionExpression(a));
+  const fn = call.arguments.find((a) => ts5.isArrowFunction(a) || ts5.isFunctionExpression(a));
   if (!fn) return true;
   const body = fn.body;
-  const text = ts4.isBlock(body) ? body.getText().slice(1, -1) : body.getText();
+  const text = ts5.isBlock(body) ? body.getText().slice(1, -1) : body.getText();
   return text.split("\n").some((l) => isSignificantLine(l.trim(), "js"));
 }
 function eachRows(call) {
   const arg = call.arguments[0];
   if (!arg) return { n: 1, open: true };
-  if (ts4.isArrayLiteralExpression(arg)) {
+  if (ts5.isArrayLiteralExpression(arg)) {
     let n = 0;
     let open = false;
     for (const el of arg.elements) {
-      if (ts4.isSpreadElement(el)) open = true;
+      if (ts5.isSpreadElement(el)) open = true;
       else n++;
     }
     return { n: Math.max(n, open ? 0 : 1), open };
@@ -5652,35 +6010,35 @@ function countTests(src, path = "spec.ts", substantiveOnly = false) {
     for (const line of src.split("\n")) if (re.test(line)) n2++;
     return { min: n2, open: false };
   }
-  const sf = ts4.createSourceFile("spec.ts", src, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TS);
+  const sf = ts5.createSourceFile("spec.ts", src, ts5.ScriptTarget.Latest, true, ts5.ScriptKind.TS);
   let n = 0;
   let open = false;
   const visit = (node, mult) => {
-    if (ts4.isForOfStatement(node)) {
+    if (ts5.isForOfStatement(node)) {
       const r = loopRows(node.expression);
       if (r.open) open = true;
       visit(node.statement, mult * r.n);
       return;
     }
-    if (ts4.isForStatement(node) || ts4.isForInStatement(node) || ts4.isWhileStatement(node) || ts4.isDoStatement(node)) {
+    if (ts5.isForStatement(node) || ts5.isForInStatement(node) || ts5.isWhileStatement(node) || ts5.isDoStatement(node)) {
       open = true;
     }
-    if (ts4.isCallExpression(node)) {
+    if (ts5.isCallExpression(node)) {
       const callee = node.expression;
-      if (ts4.isPropertyAccessExpression(callee) && callee.name.text === "forEach") {
+      if (ts5.isPropertyAccessExpression(callee) && callee.name.text === "forEach") {
         const r = loopRows(callee.expression);
         if (r.open) open = true;
         for (const a of node.arguments) visit(a, mult * r.n);
         return;
       }
       const head = node.expression;
-      if (ts4.isCallExpression(head) && isDescribeEach(head.expression)) {
+      if (ts5.isCallExpression(head) && isDescribeEach(head.expression)) {
         const r = eachRows(head);
         if (r.open) open = true;
         for (const a of node.arguments) visit(a, mult * r.n);
         return;
       }
-      if (ts4.isTaggedTemplateExpression(head) && isDescribeEach(head.tag)) {
+      if (ts5.isTaggedTemplateExpression(head) && isDescribeEach(head.tag)) {
         for (const a of node.arguments) visit(a, mult * templateRows(head));
         return;
       }
@@ -5692,10 +6050,10 @@ function countTests(src, path = "spec.ts", substantiveOnly = false) {
         const name = calleeName(node.expression);
         if ((name === "it" || name === "test") && (!substantiveOnly || hasSubstantiveBody(node))) n += mult;
       }
-    } else if (ts4.isTaggedTemplateExpression(node) && isEachOf(node.tag)) {
+    } else if (ts5.isTaggedTemplateExpression(node) && isEachOf(node.tag)) {
       n += templateRows(node) * mult;
     }
-    ts4.forEachChild(node, (c) => visit(c, mult));
+    ts5.forEachChild(node, (c) => visit(c, mult));
   };
   visit(sf, 1);
   return { min: n, open };
@@ -5997,7 +6355,7 @@ function pytestPrecedenceFindings(changes, policy, ctx) {
 }
 
 // src/detectors/test-content-removal.ts
-import ts5 from "typescript";
+import ts6 from "typescript";
 var RULE8 = "test-content-removal";
 var MIN_REMOVED_LINES = 3;
 var MIN_REMOVED_ROWS = 2;
@@ -6007,13 +6365,13 @@ function eachTables(src, path) {
   let open = false;
   if (langOf(path) !== "js" && langOf(path) !== null) return { rows, open };
   try {
-    const sf = ts5.createSourceFile("spec.ts", src, ts5.ScriptTarget.Latest, true, ts5.ScriptKind.TS);
+    const sf = ts6.createSourceFile("spec.ts", src, ts6.ScriptTarget.Latest, true, ts6.ScriptKind.TS);
     const visit = (node) => {
-      if (ts5.isCallExpression(node) && ts5.isPropertyAccessExpression(node.expression) && /^(?:each|for)$/.test(node.expression.name.text) && ts5.isIdentifier(node.expression.expression) && /^(?:it|test|describe)$/.test(node.expression.expression.text)) {
+      if (ts6.isCallExpression(node) && ts6.isPropertyAccessExpression(node.expression) && /^(?:each|for)$/.test(node.expression.name.text) && ts6.isIdentifier(node.expression.expression) && /^(?:it|test|describe)$/.test(node.expression.expression.text)) {
         const arg = node.arguments[0];
-        if (arg && ts5.isArrayLiteralExpression(arg)) {
+        if (arg && ts6.isArrayLiteralExpression(arg)) {
           for (const el of arg.elements) {
-            if (ts5.isSpreadElement(el)) {
+            if (ts6.isSpreadElement(el)) {
               open = true;
               continue;
             }
@@ -6023,7 +6381,7 @@ function eachTables(src, path) {
           }
         } else open = true;
       }
-      ts5.forEachChild(node, visit);
+      ts6.forEachChild(node, visit);
     };
     visit(sf);
   } catch {
@@ -6201,6 +6559,214 @@ var snapshotOnlyRewrite = {
   }
 };
 
+// src/detectors/assertion-weakening.ts
+import ts7 from "typescript";
+var RULE11 = "assertion-weakening";
+var TEST_CALLS = /* @__PURE__ */ new Set(["it", "test"]);
+var SUITE_CALLS = /* @__PURE__ */ new Set(["describe", "suite", "context"]);
+var EXACT_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual", "toMatchObject"]);
+var WEAK_MATCHERS = /* @__PURE__ */ new Set(["toBeTruthy", "toBeDefined"]);
+var compact = (s) => s.replace(/\s+/g, "");
+function literalTitle(node) {
+  if (!node) return null;
+  if (ts7.isStringLiteral(node) || ts7.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  return null;
+}
+function scriptKindForPath(path) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".tsx")) return ts7.ScriptKind.TSX;
+  if (lower.endsWith(".ts") || lower.endsWith(".mts") || lower.endsWith(".cts")) {
+    return ts7.ScriptKind.TS;
+  }
+  if (lower.endsWith(".jsx")) return ts7.ScriptKind.JSX;
+  return ts7.ScriptKind.JS;
+}
+function staticFacts(node) {
+  if (!node) return null;
+  if (node.kind === ts7.SyntaxKind.TrueKeyword) return { defined: true, truthy: true };
+  if (node.kind === ts7.SyntaxKind.FalseKeyword) return { defined: true, truthy: false };
+  if (node.kind === ts7.SyntaxKind.NullKeyword) return { defined: true, truthy: false };
+  if (ts7.isIdentifier(node) && node.text === "undefined") {
+    return { defined: false, truthy: false };
+  }
+  if (ts7.isVoidExpression(node)) return { defined: false, truthy: false };
+  if (ts7.isStringLiteral(node) || ts7.isNoSubstitutionTemplateLiteral(node)) {
+    return { defined: true, truthy: node.text.length > 0 };
+  }
+  if (ts7.isNumericLiteral(node)) {
+    return { defined: true, truthy: Number(node.text) !== 0 };
+  }
+  if (ts7.isBigIntLiteral(node)) {
+    return { defined: true, truthy: node.text.replace(/n$/i, "") !== "0" };
+  }
+  if (ts7.isPrefixUnaryExpression(node) && (node.operator === ts7.SyntaxKind.MinusToken || node.operator === ts7.SyntaxKind.PlusToken) && ts7.isNumericLiteral(node.operand)) {
+    const value = Number(node.operand.text) * (node.operator === ts7.SyntaxKind.MinusToken ? -1 : 1);
+    return { defined: true, truthy: value !== 0 };
+  }
+  if (ts7.isObjectLiteralExpression(node) || ts7.isArrayLiteralExpression(node) || ts7.isRegularExpressionLiteral(node) || ts7.isArrowFunction(node) || ts7.isFunctionExpression(node) || ts7.isClassExpression(node) || ts7.isNewExpression(node)) {
+    return { defined: true, truthy: true };
+  }
+  return null;
+}
+function expectAssertion(node, sf) {
+  if (!ts7.isPropertyAccessExpression(node.expression)) return null;
+  const matcher = node.expression.name.text;
+  let receiver = node.expression.expression;
+  let polarity = "";
+  if (ts7.isPropertyAccessExpression(receiver) && receiver.name.text === "not") {
+    polarity = "not";
+    receiver = receiver.expression;
+  }
+  if (!ts7.isCallExpression(receiver) || !ts7.isIdentifier(receiver.expression) || receiver.expression.text !== "expect" || receiver.arguments.length !== 1) {
+    return null;
+  }
+  const subject = compact(receiver.arguments[0].getText(sf));
+  const args = node.arguments.map((arg) => compact(arg.getText(sf)));
+  return {
+    subject,
+    polarity,
+    matcher,
+    args,
+    firstArgFacts: staticFacts(node.arguments[0]),
+    canonical: [subject, polarity, matcher, ...args].join("|"),
+    text: node.getText(sf).replace(/\s+/g, " ")
+  };
+}
+function simpleCallName(node) {
+  return ts7.isIdentifier(node.expression) ? node.expression.text : null;
+}
+function callbackFor(node) {
+  const cb = node.arguments[1];
+  return cb && (ts7.isArrowFunction(cb) || ts7.isFunctionExpression(cb)) ? cb : null;
+}
+function blocks(src, path) {
+  const out2 = /* @__PURE__ */ new Map();
+  if (langOf(path) !== "js") return out2;
+  try {
+    const sf = ts7.createSourceFile(path, src, ts7.ScriptTarget.Latest, true, scriptKindForPath(path));
+    const visit = (node, suites) => {
+      if (ts7.isCallExpression(node)) {
+        const call = simpleCallName(node);
+        const title = literalTitle(node.arguments[0]);
+        const cb = callbackFor(node);
+        if (call && SUITE_CALLS.has(call) && title !== null && cb) {
+          const nextSuites = [...suites, title];
+          ts7.forEachChild(cb, (child) => visit(child, nextSuites));
+          return;
+        }
+        if (call && TEST_CALLS.has(call) && title !== null && cb) {
+          const assertions = [];
+          const collect2 = (child) => {
+            if (child !== cb && ts7.isCallExpression(child)) {
+              const nestedCall = simpleCallName(child);
+              if (nestedCall && (TEST_CALLS.has(nestedCall) || SUITE_CALLS.has(nestedCall))) {
+                return;
+              }
+            }
+            if (ts7.isCallExpression(child)) {
+              const a = expectAssertion(child, sf);
+              if (a) assertions.push(a);
+            }
+            ts7.forEachChild(child, collect2);
+          };
+          collect2(cb);
+          const identity2 = [...suites, title].join(" > ");
+          const list2 = out2.get(identity2) ?? [];
+          list2.push({ title, identity: identity2, assertions });
+          out2.set(identity2, list2);
+          return;
+        }
+      }
+      ts7.forEachChild(node, (child) => visit(child, suites));
+    };
+    visit(sf, []);
+  } catch {
+  }
+  return out2;
+}
+function pureRemoval(before, after) {
+  if (after.length >= before.length) return null;
+  const remaining = /* @__PURE__ */ new Map();
+  for (const a of before) remaining.set(a.canonical, (remaining.get(a.canonical) ?? 0) + 1);
+  for (const a of after) {
+    const n = remaining.get(a.canonical) ?? 0;
+    if (n <= 0) return null;
+    remaining.set(a.canonical, n - 1);
+  }
+  for (const a of before) {
+    const n = remaining.get(a.canonical) ?? 0;
+    if (n > 0) return a;
+  }
+  return null;
+}
+function factsProveWeakMatcher(oldA, newMatcher) {
+  if (!EXACT_MATCHERS.has(oldA.matcher) || oldA.args.length !== 1) return false;
+  const facts = oldA.firstArgFacts;
+  if (!facts) return false;
+  if (newMatcher === "toBeDefined") return facts.defined;
+  if (newMatcher === "toBeTruthy") return facts.truthy === true;
+  return false;
+}
+function directionalWeakening(before, after) {
+  for (const oldA of before) {
+    for (const newA of after) {
+      if (oldA.subject !== newA.subject) continue;
+      if (oldA.polarity !== "" || newA.polarity !== "") continue;
+      if (WEAK_MATCHERS.has(newA.matcher) && newA.args.length === 0 && factsProveWeakMatcher(oldA, newA.matcher)) {
+        return { before: oldA, after: newA, kind: "matcher" };
+      }
+      if (oldA.matcher === "toThrow" && oldA.args.length > 0 && newA.matcher === "toThrow" && newA.args.length === 0) {
+        return { before: oldA, after: newA, kind: "throw-specificity" };
+      }
+    }
+  }
+  return null;
+}
+function findingForBlock(path, before, after, policy) {
+  const weakened = directionalWeakening(before.assertions, after.assertions);
+  if (weakened) {
+    const message = weakened.kind === "throw-specificity" ? `Assertion weakened in test "${before.identity}": exception-message specificity was removed from toThrow().` : `Assertion weakened in test "${before.identity}": ${weakened.before.matcher} was replaced by weaker ${weakened.after.matcher} on the same subject.`;
+    return makeFinding(RULE11, policy, {
+      file: path,
+      message,
+      evidence: `${weakened.before.text} -> ${weakened.after.text}`,
+      remediation: "Keep the stronger expectation and fix the code under test. If the contract genuinely changed, review the test change explicitly; this rule is warning-only while its precision is measured."
+    });
+  }
+  const removed = pureRemoval(before.assertions, after.assertions);
+  if (removed) {
+    return makeFinding(RULE11, policy, {
+      file: path,
+      message: `Assertion removed from kept test "${before.identity}" without a replacement assertion.`,
+      evidence: removed.text,
+      remediation: "Keep the assertion and fix the code under test. If the assertion is genuinely obsolete, review the test change explicitly; this rule is warning-only while its precision is measured."
+    });
+  }
+  return null;
+}
+var assertionWeakening = {
+  id: RULE11,
+  surface: ["file"],
+  certainty: "heuristic",
+  run(changes, policy) {
+    const out2 = [];
+    for (const c of changes) {
+      if (c.kind !== "file" || c.op !== "modify" && c.op !== "rename" || c.before == null || c.after == null || langOf(c.path) !== "js" || !isProtected(c.path, policy, "tests") || isProtected(c.path, policy, "snapshots")) {
+        continue;
+      }
+      const beforeBlocks = blocks(c.before, c.path);
+      const afterBlocks = blocks(c.after, c.path);
+      for (const [identity2, oldList] of beforeBlocks) {
+        const newList = afterBlocks.get(identity2);
+        if (!newList || oldList.length !== 1 || newList.length !== 1) continue;
+        const f = findingForBlock(c.path, oldList[0], newList[0], policy);
+        if (f) out2.push(f);
+      }
+    }
+    return out2;
+  }
+};
+
 // src/detectors/index.ts
 var allDetectors = [
   noVerify,
@@ -6213,7 +6779,8 @@ var allDetectors = [
   testDeletion,
   testContentRemoval,
   snapshotRewrite,
-  snapshotOnlyRewrite
+  snapshotOnlyRewrite,
+  assertionWeakening
 ];
 
 // src/engine.ts
@@ -6575,9 +7142,9 @@ function orderFindings(findings) {
     return (a.line ?? 0) - (b.line ?? 0);
   });
 }
-function countsPhrase(blocks, warns) {
+function countsPhrase(blocks2, warns) {
   const parts = [];
-  if (blocks) parts.push(`${blocks} blocking`);
+  if (blocks2) parts.push(`${blocks2} blocking`);
   if (warns) parts.push(`${warns} warning${warns === 1 ? "" : "s"}`);
   return parts.join(", ");
 }
@@ -6589,7 +7156,7 @@ var SIGNOFF_NOTE = "A blocking finding clears only with a human sign-off. In CI
 function renderText(input, opts) {
   const { scanned, ignoredFiles } = input;
   const findings = orderFindings(input.findings);
-  const blocks = findings.filter((f) => f.severity === "block");
+  const blocks2 = findings.filter((f) => f.severity === "block");
   const warns = findings.filter((f) => f.severity === "warn");
   const c = opts.colour;
   const out2 = [];
@@ -6597,8 +7164,8 @@ function renderText(input, opts) {
     return `${paint("tamperward: clean", GREEN, c)} \u2014 no integrity findings (${scopePhrase(scanned, ignoredFiles)}).
 `;
   }
-  const headColour = blocks.length ? RED : YELLOW;
-  out2.push(paint(`tamperward: ${countsPhrase(blocks.length, warns.length)}`, BOLD + headColour, c));
+  const headColour = blocks2.length ? RED : YELLOW;
+  out2.push(paint(`tamperward: ${countsPhrase(blocks2.length, warns.length)}`, BOLD + headColour, c));
   out2.push(paint(`(${scopePhrase(scanned, ignoredFiles)})`, DIM, c));
   out2.push("");
   const LABEL = "sign-off".length;
@@ -6618,7 +7185,7 @@ function renderText(input, opts) {
     if (f.signoff.required) row("sign-off", [stripControl(f.signoff.command)]);
     out2.push("");
   }
-  if (blocks.length > 0) {
+  if (blocks2.length > 0) {
     out2.push(
       wrap(SIGNOFF_NOTE, opts.width - 2).map((l) => paint(l, DIM, c)).join("\n")
     );
@@ -6668,7 +7235,7 @@ function locationCell(f, env) {
 }
 function renderSummary(input, env = process.env) {
   const findings = orderFindings(input.findings);
-  const blocks = findings.filter((f) => f.severity === "block");
+  const blocks2 = findings.filter((f) => f.severity === "block");
   const warns = findings.filter((f) => f.severity === "warn");
   const scope = scopePhrase(input.scanned, input.ignoredFiles);
   if (findings.length === 0) {
@@ -6678,7 +7245,7 @@ No integrity findings (${scope}).
 `;
   }
   const out2 = [
-    `## Tamperward: ${countsPhrase(blocks.length, warns.length)}`,
+    `## Tamperward: ${countsPhrase(blocks2.length, warns.length)}`,
     "",
     `${scope}. Every finding below is also annotated on the diff in **Files changed**.`,
     "",
@@ -6731,12 +7298,12 @@ function report(input) {
   const { findings, scanned, ignoredFiles } = input;
   const format = resolveFormat(input);
   if (format === "json") {
-    const blocks = findings.filter((f) => f.severity === "block").length;
+    const blocks2 = findings.filter((f) => f.severity === "block").length;
     process.stdout.write(
       JSON.stringify(
         // `findings`, `scanned` and `ignoredFiles` keep their exact prior shape; `summary`
         // is additive, so an existing consumer reading only the old keys is unaffected.
-        { findings, scanned, ignoredFiles, summary: { block: blocks, warn: findings.length - blocks } },
+        { findings, scanned, ignoredFiles, summary: { block: blocks2, warn: findings.length - blocks2 } },
         null,
         2
       ) + "\n"
@@ -6833,10 +7400,10 @@ import { readFileSync as readFileSync10, appendFileSync as appendFileSync4, writ
 import { createHash as createHash5 } from "node:crypto";
 
 // src/adapters/claude/deny.ts
-function formatDenial(blocks) {
-  const lead = blocks[0];
+function formatDenial(blocks2) {
+  const lead = blocks2[0];
   const lines = ["Tamperward blocked this change \u2014 it weakens a protected safety net to pass checks.", ""];
-  for (const f of blocks) {
+  for (const f of blocks2) {
     const loc = f.file ? ` (${escapeControl(f.file)}${f.line ? `:${f.line}` : ""})` : "";
     lines.push(`  \u2022 ${f.rule}${loc}: ${f.message}`);
   }
@@ -6845,7 +7412,7 @@ function formatDenial(blocks) {
   lines.push(
     "The other shortcuts are blocked too: skipping the hooks, editing the hook or CI workflow, lowering the coverage gate, and rewriting a protected file from the shell will each be denied."
   );
-  if (blocks.some((b) => b.signoff.required)) {
+  if (blocks2.some((b) => b.signoff.required)) {
     lines.push(`If this change is genuinely correct, a human must sign off: ${lead.signoff.command}`);
   }
   return lines.join("\n") + "\n";
@@ -7263,7 +7830,7 @@ function runWatch(args) {
 
 // src/detectors/fs-events.ts
 import { closeSync as closeSync2, openSync as openSync2, readSync as readSync2, statSync } from "node:fs";
-var RULE11 = "transient-protected-mutation";
+var RULE12 = "transient-protected-mutation";
 var MAX_EVENT_READ_BYTES = 4 * 1024 * 1024;
 var MAX_EVENT_SWEEP_BYTES = 16 * 1024 * 1024;
 var DEFAULT_EVENT_READ_IO = {
@@ -7458,7 +8025,7 @@ function drainEvents(log, offset, maxTotalBytes = MAX_EVENT_SWEEP_BYTES, io = DE
   };
 }
 function transientFindings(events, persistentPaths, policy, finalHash) {
-  if (!isEnabled(RULE11, policy)) return [];
+  if (!isEnabled(RULE12, policy)) return [];
   const byPath = /* @__PURE__ */ new Map();
   for (const e of events) {
     if (!isProtected(e.path, policy)) continue;
@@ -7478,7 +8045,7 @@ function transientFindings(events, persistentPaths, policy, finalHash) {
     const modeChurn = modes.size > 1;
     if (!contentChurn && !modeChurn) continue;
     const what = contentChurn ? `content was modified and restored within the turn (${hashes.size} distinct states observed)` : `file mode changed during the turn (${[...modes].map((m) => (m & 4095).toString(8)).join(" \u2192 ")})`;
-    const f = makeFinding(RULE11, policy, {
+    const f = makeFinding(RULE12, policy, {
       file: path,
       message: `Transient protected mutation: ${what}, leaving no net diff.`,
       evidence: evs.slice(0, 4).map((e) => `${e.ts} ${e.hash ?? "gone"}${e.mode != null ? `/${(e.mode & 4095).toString(8)}` : ""}`).join(" | "),
@@ -7517,11 +8084,11 @@ function parseInput(raw) {
   }
   return parsed;
 }
-function recordDenylog(blocks) {
+function recordDenylog(blocks2) {
   const log = process.env.TAMPERWARD_DENYLOG;
   if (!log) return;
   try {
-    appendFileSync4(log, blocks.map((b) => b.rule).join(",") + "\n");
+    appendFileSync4(log, blocks2.map((b) => b.rule).join(",") + "\n");
   } catch {
   }
 }
@@ -7540,10 +8107,10 @@ function failClosed(kind, detail) {
   };
   return verdict([f], kind);
 }
-function verdict(blocks, kind) {
-  if (blocks.length === 0) return { exitCode: 0, stdout: "" };
-  recordDenylog(blocks);
-  const reason = formatDenial(blocks);
+function verdict(blocks2, kind) {
+  if (blocks2.length === 0) return { exitCode: 0, stdout: "" };
+  recordDenylog(blocks2);
+  const reason = formatDenial(blocks2);
   const payload = kind === "PreToolUse" ? {
     hookSpecificOutput: {
       hookEventName: "PreToolUse",
@@ -7600,14 +8167,14 @@ function uncoveredDrift(cwd, policy, expected, current, covered, base, turnTree)
     if (c.oldPath) seen.add(c.oldPath);
   }
   const changes = [];
-  const blocks = [];
+  const blocks2 = [];
   const trusted = base ?? "HEAD";
   const candidates = base ? [base, "HEAD", ""] : ["HEAD", ""];
   for (const rel of [...d.changed, ...d.deleted]) {
     if (seen.has(rel)) continue;
     const unjudgeable = unjudgeableFinding(cwd, rel);
     if (unjudgeable) {
-      blocks.push(unjudgeable);
+      blocks2.push(unjudgeable);
       continue;
     }
     const after = fileOnDisk(rel, { cwd });
@@ -7627,7 +8194,7 @@ function uncoveredDrift(cwd, policy, expected, current, covered, base, turnTree)
       }
     }
     if (before == null) {
-      blocks.push({
+      blocks2.push({
         rule: "hidden-drift",
         severity: "block",
         file: rel,
@@ -7660,12 +8227,12 @@ function uncoveredDrift(cwd, policy, expected, current, covered, base, turnTree)
     if (seen.has(rel)) continue;
     const unjudgeable = unjudgeableFinding(cwd, rel);
     if (unjudgeable) {
-      blocks.push(unjudgeable);
+      blocks2.push(unjudgeable);
       continue;
     }
     const after = fileOnDisk(rel, { cwd });
     if (after == null) {
-      blocks.push({
+      blocks2.push({
         rule: "hidden-drift",
         severity: "block",
         file: rel,
@@ -7678,7 +8245,7 @@ function uncoveredDrift(cwd, policy, expected, current, covered, base, turnTree)
     }
     changes.push(...synthFileChange(rel, null, after));
   }
-  return { changes, blocks };
+  return { changes, blocks: blocks2 };
 }
 function effectDriftBlocks(cwd, sessionId, policy) {
   if (!sessionId || !isGitRepo(cwd)) return null;
@@ -7703,8 +8270,8 @@ function effectDriftBlocks(cwd, sessionId, policy) {
   );
   const gap = uncoveredDrift(cwd, policy, expected, current, scoped, base, loadTurnTree(cwd, sessionId));
   const judged = [...scoped, ...gap.changes];
-  const blocks = evaluate(judged, policy, void 0, "turn", { cwd }).filter((f) => f.severity === "block").concat(gap.blocks, unjudgeableProtected(cwd, policy, judged));
-  if (blocks.length > 0) return blocks;
+  const blocks2 = evaluate(judged, policy, void 0, "turn", { cwd }).filter((f) => f.severity === "block").concat(gap.blocks, unjudgeableProtected(cwd, policy, judged));
+  if (blocks2.length > 0) return blocks2;
   savePtree(cwd, sessionId, current);
   return null;
 }
@@ -7736,9 +8303,9 @@ function preToolUseVerdict(input) {
     const driftBlocks = effectDriftBlocks(cwd, input.session_id, policy);
     if (driftBlocks) return verdict(driftBlocks, "PreToolUse");
     const changes = changesFromClaudeHook(input, cwd);
-    const blocks = evaluate(changes, policy, void 0, "tool-call", { cwd }).filter((f) => f.severity === "block");
-    if (blocks.length === 0) sanctionPredictedWrites(cwd, input.session_id, policy, changes);
-    return verdict(blocks, "PreToolUse");
+    const blocks2 = evaluate(changes, policy, void 0, "tool-call", { cwd }).filter((f) => f.severity === "block");
+    if (blocks2.length === 0) sanctionPredictedWrites(cwd, input.session_id, policy, changes);
+    return verdict(blocks2, "PreToolUse");
   } catch (e) {
     return failClosed("PreToolUse", errText2(e));
   }
@@ -7840,7 +8407,7 @@ function stopVerdict(input) {
   if (input.stop_hook_active) return { exitCode: 0, stdout: "" };
   const cwd = input.cwd ?? process.cwd();
   if (!isGitRepo(cwd)) return { exitCode: 0, stdout: "" };
-  let blocks;
+  let blocks2;
   let commitCursor = () => {
   };
   try {
@@ -7855,22 +8422,22 @@ function stopVerdict(input) {
       changes = changes.concat(gap.changes);
       hiddenBlocks = gap.blocks;
     }
-    blocks = evaluate(changes, policy, void 0, "turn", { cwd }).filter((f) => f.severity === "block").concat(hiddenBlocks, unjudgeableProtected(cwd, policy, changes));
+    blocks2 = evaluate(changes, policy, void 0, "turn", { cwd }).filter((f) => f.severity === "block").concat(hiddenBlocks, unjudgeableProtected(cwd, policy, changes));
     const transient = turnTransientBlocks(cwd, input.session_id, policy, changes);
-    blocks = blocks.concat(transient.blocks);
+    blocks2 = blocks2.concat(transient.blocks);
     commitCursor = transient.commit;
-    if (blocks.length === 0 && input.session_id && current) {
+    if (blocks2.length === 0 && input.session_id && current) {
       savePtree(cwd, input.session_id, current);
       saveTurnTree(cwd, input.session_id, current);
     }
   } catch (e) {
     return failClosed("Stop", errText2(e));
   }
-  if (blocks.length === 0) {
+  if (blocks2.length === 0) {
     advanceTurnBaseline(cwd, input.session_id);
     commitCursor();
   }
-  return verdict(blocks, "Stop");
+  return verdict(blocks2, "Stop");
 }
 function emit(r) {
   if (r.stdout) process.stdout.write(r.stdout);