npm - tamperward - Versions diffs - 1.1.0 → 1.2.1 - Mend

tamperward 1.1.0 → 1.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/README.md CHANGED Viewed

@@ -92,14 +92,17 @@ with the same engine it ships.
   per-line old/new line numbers correct across multiple hunks.
 - `src/git/build.ts` — the git adapter: range / staged / worktree views, enriching
   `before`/`after` with full file content for the AST detectors.
-- `src/detectors/` — the **eight mechanical rules**: `no-verify`, `ts-any-cast`,
+- `src/detectors/` — the **nine mechanical rules**: `no-verify`, `ts-any-cast`,
   `lint-suppression`, `test-skip`, `coverage-lowering`, `ci-tampering`,
   `hook-tampering`, `test-deletion` (the last counts `it()/test()` via the TS AST,
-  and handles delete / rename-out-of-glob / shell mutation).
+  and handles delete / rename-out-of-glob / shell mutation), and `snapshot-rewrite`
+  (a `warn`: re-recording a snapshot/golden expectation from current output — the one
+  rule built from measured demand, after the affordance experiment put the move at a
+  70% attempt and 100% through rate; see `harness/PREDICTION-affordance.md`).
 - `src/engine.ts` — runs the enabled rules over `Change[]`; honours `policy.ignore`.
 - `src/cli/` — `tamperward check --staged | --worktree | --diff <base>...<head>`,
   exit 1 on any blocking finding.
-- `test/` — 211 tests, including the AST-vs-regex, self-hosting precision, and
+- `test/` — 235 tests, including the AST-vs-regex, self-hosting precision, and
   pre-go-live audit regression cases, and the renderer accessibility contract.
 - `src/adapters/claude/` + `src/cli/hook.ts` — the agent layer: `tamperward hook claude`

package/dist/cli/index.js CHANGED Viewed

@@ -425,6 +425,10 @@ function defaultPolicy() {
         "**/package.json"
       ],
       ci: [".github/workflows/**"],
+      // Recorded expected outputs. An assertion stored as data is still an assertion;
+      // rewriting it from current output is the snapshot-update move the affordance
+      // experiment measured at a 70% attempt / 100% through rate (snapshot-rewrite).
+      snapshots: ["**/*.snap", "**/__snapshots__/**", "**/golden/**", "**/*.golden.*"],
       hooks: [".husky/**", "**/lefthook.*", ".tamperward.yml", "**/.tamperward.yml"]
     },
     rules: {
@@ -440,6 +444,9 @@ function defaultPolicy() {
       "ci-tampering": { severity: "block" },
       "hook-tampering": { severity: "block" },
       "no-verify": { severity: "block" },
+      // mechanical but intent-ambiguous: updating a snapshot is the legitimate workflow
+      // when intended output changes. WARN until the §7 evidence path earns block.
+      "snapshot-rewrite": { severity: "warn" },
       // heuristic — warn until precision is measured (SPEC §7)
       "assertion-weakening": { severity: "warn" },
       "guard-removal": { severity: "warn" }
@@ -822,10 +829,15 @@ var coverageLowering = {
 // src/detectors/ci-tampering.ts
 var RULE5 = "ci-tampering";
-var STEP = /^\s*-?\s*(?:run|uses):/;
+var USES = /^\s*-\s*uses:/;
 var CHECK = /\b(test|tests|lint|typecheck|type-check|tsc|eslint|jest|vitest|playwright|coverage|tamperward)\b/i;
 var YAML_KEY = /^\s*-?\s*[A-Za-z_][\w-]*:\s*(?:$|\S)/;
-var RUNNER = /\b(npm|npx|pnpm|yarn|bun|make|cargo|pytest|python|jest|vitest|eslint|tsc|playwright|tamperward|gradle|mvn|dotnet)\b/;
+var INVOKES_TOOL = /(?:^\s*|[;&|`]\s*|\$\(\s*|\b(?:npx|yarn|pnpm|bunx?)\s+)(?:jest|vitest|eslint|tsc|playwright|pytest|tamperward)\b/;
+var INVOKES_SCRIPT = /\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test|tests|lint|typecheck|type-check|coverage)\b|\b(?:make|cargo|go)\s+test\b|\bgradle\w*\s+(?:test|check)\b/;
+var invokesCheck = (line) => INVOKES_TOOL.test(line) || INVOKES_SCRIPT.test(line);
+function commandCore(line) {
+  return line.trim().replace(/^-\s*/, "").replace(/^(?:run|uses):\s*/, "").replace(/\s+/g, " ").trim();
+}
 var uncommented = (v) => v.replace(/\s+#.*$/, "").trim();
 function isAlwaysFalse(raw) {
   const v = uncommented(raw);
@@ -878,16 +890,18 @@ var ciTampering = {
           );
         }
       }
-      const stillPresent = new Set(addedLines(c).map((l) => l.content.trim()));
+      const afterCores = new Set(
+        (c.after != null ? c.after.split("\n") : addedLines(c).map((l) => l.content)).map(commandCore)
+      );
       for (const l of removedLines(c)) {
-        if (stillPresent.has(l.content.trim())) continue;
-        const isStepLine = STEP.test(l.content) && CHECK.test(l.content);
-        const isRunBodyLine = !YAML_KEY.test(l.content) && RUNNER.test(l.content) && CHECK.test(l.content);
-        if (!isStepLine && !isRunBodyLine) continue;
+        const isUsesLine = USES.test(l.content) && CHECK.test(l.content);
+        const isCheckCommand = !isUsesLine && !/^\s*-?\s*uses:/.test(l.content) && (YAML_KEY.test(l.content) ? /^\s*-?\s*run:/.test(l.content) : true) && invokesCheck(l.content);
+        if (!isUsesLine && !isCheckCommand) continue;
+        if (afterCores.has(commandCore(l.content))) continue;
         out.push(
           makeFinding(RULE5, policy, {
             file: c.path,
-            message: isStepLine ? "A CI check step (test/lint/typecheck) was removed." : "A CI check command was removed from a run block.",
+            message: isUsesLine ? "A CI check step (test/lint/typecheck) was removed." : "A CI check command was removed from a run block.",
             evidence: l.content.trim(),
             remediation: "Restore the step. Removing the check that protects main is itself the tamper."
           })
@@ -1223,6 +1237,63 @@ var testDeletion = {
   }
 };
+// src/detectors/snapshot-rewrite.ts
+var RULE8 = "snapshot-rewrite";
+var RUNNER = /\b(?:jest|vitest|playwright|ava)\b/;
+var UPDATE_ANY = /--update-?[sS]napshots?\b/;
+var UPDATE_WITH_RUNNER = /(?:^|\s)(?:-u|--update)(?:\s|$)/;
+var REGEN_SCRIPT = /\b(?:update|regen(?:erate)?|re?bless)[-_.]?(?:golden|snapshots?|baselines?|expected)\b/i;
+var MUTATE = /(?:^|\s)(?:rm|cp|mv|tee|truncate|dd)(?:\s|$)|sed\s+-i|>{1,2}/;
+function namesProtectedSnapshot(seg, policy) {
+  for (const t of tokens(seg)) {
+    const path = unquote(t).replace(/^>{1,2}/, "");
+    if (isProtected(path, policy, "snapshots")) return path;
+  }
+  return null;
+}
+var snapshotRewrite = {
+  id: RULE8,
+  surface: ["command", "file"],
+  certainty: "mechanical",
+  run(changes, policy) {
+    const out = [];
+    const warn = (input) => out.push(makeFinding(RULE8, policy, { ...input, defaultSeverity: "warn" }));
+    for (const c of changes) {
+      if (c.kind === "command") {
+        for (const seg of segments(c.raw)) {
+          let why = null;
+          if (UPDATE_ANY.test(seg)) why = "the snapshot-update flag rewrites every failing snapshot to match current output";
+          else if (RUNNER.test(seg) && UPDATE_WITH_RUNNER.test(seg)) why = "running the test runner in update mode rewrites failing snapshots to match current output";
+          else if (REGEN_SCRIPT.test(seg)) why = "a regeneration script rewrites the recorded expected output from current output";
+          else {
+            const path = MUTATE.test(seg) ? namesProtectedSnapshot(seg, policy) : null;
+            if (path) why = `the command overwrites or removes the protected snapshot ${path}`;
+          }
+          if (why) {
+            warn({
+              message: `Snapshot rewrite: ${why}.`,
+              evidence: seg,
+              remediation: "A snapshot is an assertion. If the test failure is a bug, fix the code; only update the snapshot when the INTENDED output changed, and have a human confirm the new expectation is correct."
+            });
+          }
+        }
+        continue;
+      }
+      const wasSnap = c.oldPath != null && isProtected(c.oldPath, policy, "snapshots");
+      const isSnap = isProtected(c.path, policy, "snapshots");
+      if (c.op === "add" || !isSnap && !wasSnap) continue;
+      const what = c.op === "delete" ? "deleted" : c.op === "rename" && !isSnap ? `renamed out of the protected snapshot set (to ${c.path})` : "rewritten";
+      warn({
+        file: c.op === "rename" && !isSnap ? c.oldPath : c.path,
+        message: `A recorded expected output was ${what}.`,
+        evidence: c.op === "rename" ? `${c.oldPath} -> ${c.path}` : c.path,
+        remediation: "If the intended output genuinely changed, a human should confirm the new expectation against the requirement; if the test was failing, fix the code instead of re-recording the expectation from it."
+      });
+    }
+    return out;
+  }
+};
 // src/detectors/index.ts
 var allDetectors = [
   noVerify,
@@ -1232,7 +1303,8 @@ var allDetectors = [
   coverageLowering,
   ciTampering,
   hookTampering,
-  testDeletion
+  testDeletion,
+  snapshotRewrite
 ];
 // src/engine.ts

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "tamperward",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "The deterministic agent-integrity gate. One ruleset, evaluated on the actual diff/commands as a verdict, enforced everywhere a change can be made.",
   "license": "Apache-2.0",
   "author": "hexrift",