tewip-ai 0.24.0 → 0.26.0

package/README.md

@@ -444,6 +444,115 @@ Every change is small (1 to 16 lines, median 4) and most are what the developers
 **No wrong fix was offered**: anything that could not be proved was thrown away and the file put
 back byte for byte.
 
+## One bundle a release manager can read (Phase 15)
+
+```bash
+tewip attest --out attestation.md
+```
+
+Everything Tewip knows about a build, in one file: which tests ran, what each failure was, which
+rule or which model decided it, **what it refused to decide**, and what it never looked at. The
+refusals are the point - a tool that never says "I could not tell" has nothing worth attesting,
+because every line it writes might be a guess.
+
+The bundle carries a digest, and an Ed25519 signature when you give it a key:
+
+```bash
+TEWIP_ATTEST_KEY=./private.pem tewip attest            # sign it
+tewip attest --verify attestation.json --key public.pem  # check it
+```
+
+A digest is not a signature and Tewip says so: without a key it tells you the bundle is undamaged,
+not that nobody edited it. Editing a claim out of a signed bundle makes verification fail and exit
+non-zero. Every CI run writes one of these automatically.
+
+## Is this incident covered by a test? (Phase 16)
+
+```bash
+tewip incident sentry-issue.json
+```
+
+Reads a Sentry payload, an OpenTelemetry span or a plain stack trace, finds the test that should
+have caught it, and answers with one of four verdicts: **reproduced**, **passed** (the test ran and
+did not catch it, which is worse news), **failed differently**, or **never ran**. It does not say
+"probably covered".
+
+## What did we decide about this last time? (Phase 17)
+
+```bash
+tewip recall "the login test that keeps flaking"
+```
+
+Every correction your team ever gave Tewip is kept. Ask, and it answers with your own decision from
+then, and says it was yours - not its. It never acts on a correction by itself.
+
+## From the ticket to the run (Phase 18)
+
+```bash
+tewip trace --only "SHOP-12"
+```
+
+Joins the test plans Tewip wrote to the tests that cover them and the runs that attempted them. A
+scenario counts as covered only when a real test can be named, and passing only when a real run
+attempted it; everything else says what is missing. No model, no cost.
+
+## Could these tests ever fail? (Phase 22)
+
+```bash
+tewip vouch tests/            # or a file, or the whole project
+tewip vouch tests/ --strict   # exits non-zero, for a merge gate
+```
+
+Most tests in a pull request are now written by an agent, and the question that decides whether they
+are worth anything goes unasked: **could this test ever fail?** Coverage counts a test that checks
+nothing. CI goes green on it. A reviewer skims something plausible and approves it.
+
+`vouch` reads tests somebody else wrote and answers per test, quoting the line it rests on. It finds
+tests that leave an expectation unfinished (`expect(value);` with no matcher - it reads exactly like a
+check), tests that compare a value with itself, tests that catch and discard their own failure, tests
+that never run, and tests that compare no value at all. No model, no cost.
+
+It is also an MCP tool, so a coding agent can ask about the tests it just wrote before claiming a
+change is covered.
+
+**Measured on 5,448 tests in 8 public projects across 5 languages** (express, axios, chalk, requests,
+click, gorilla/mux, cobra, gson): 19 tests were called unable to fail, and **all 19 were correct** when
+read against the files - one unconditional skip in psf/requests, eighteen `@Ignore` methods in gson.
+
+Two things it refuses to do, which is why the list is worth reading:
+
+- **It will not guess.** A test whose checking happens inside a helper it cannot follow is reported as
+  undecided, by name, never as worthless. A wrong accusation about somebody's test costs more than a
+  missed one.
+- **It will not overclaim.** A test with no assertion still fails when the code throws - in axios, a
+  test that compiles a TypeScript fixture and runs it asserts nothing *on purpose*. Those are reported
+  separately as "compares no value", not as broken, and they do not trip `--strict`.
+
+Honest limit, also printed at the bottom of every report: its **recall is unmeasured**. A clean report
+means nothing it found was wrong, not that every test in the file is worth something.
+
+## A goal instead of a verb (Phases 19 and 21)
+
+```bash
+tewip pursue "keep the checkout flow green"
+tewip pursue "keep the checkout flow green" --act
+```
+
+Give Tewip a goal and it says what it would do next, and why, from what it can actually see. The
+order is fixed, published and testable - **not chosen by a model**: a real bug first, then the
+environment, then flakiness, then anything failing it cannot explain, then a coverage gap, and only
+then is the goal worth attesting. Deciding the same state twice gives the same answer.
+
+With `--act` it carries the decision out, and this is where the refusals matter most:
+
+- It **never does the work itself.** Each action is an existing command that already proves what it
+  changes - `write` keeps a test only when it passes *and* fails when broken.
+- **Two actions are on the allowlist**: write a missing test, and attest a green goal. Everything
+  else is refused by name. It will not work around a real bug.
+- **One action, then stop.** There is no unattended loop.
+- Everything it did or refused goes to `.tewip/actions.jsonl`, with the run that justified it.
+- It **will not repeat itself**: the same attempt is refused until a new run gives it new evidence.
+
 ## Where it has been tried
 
 | Project | How | Result |

package/dist/cli/help.js

@@ -105,8 +105,19 @@ Usage:
                                     green" - and it says what it would do next and why, from what
                                     it can actually see. The order is fixed and written down: a
                                     real bug first, then the environment, then flakiness, then a
-                                    coverage gap. It decides; it does not act unless you ask, and
-                                    even then only through the gates that prove a change.
+                                    coverage gap. It decides; it does not act unless you ask. With
+                                    --act it carries out the two safe ones - writing a missing test,
+                                    or attesting a green goal - by running the command that already
+                                    proves them. It will not touch a real bug, and it writes what it
+                                    did or refused to .tewip/actions.jsonl.
+  tewip vouch [<paths>] [--strict] [--out vouch.md] [--json vouch.json]
+                                    Could these tests ever fail? Reads tests somebody else wrote -
+                                    an agent, a contractor, last year's team - and names the ones
+                                    that check nothing, compare a value with itself, leave an
+                                    expectation unfinished, swallow their own failure, or never run.
+                                    Where the checking is in a helper it cannot follow it says so
+                                    instead of accusing. --strict exits non-zero on a finding, for a
+                                    gate. No model, no cost.
   tewip trace [--only "<ticket or title>"] [--out trace.md]
                                     Is this requirement covered, and is it passing right now? Joins
                                     the plans Tewip wrote to the tests that cover them and the runs

package/dist/cli/tewip.js

@@ -185,6 +185,12 @@ async function main() {
             runPursue({ root: process.cwd(), goal, act: args.includes('--act'), name: flag(args, 'name'), out: flag(args, 'out') });
             return;
         }
+        case 'vouch': {
+            const paths = args.filter((a, i) => !a.startsWith('--') && !['--out', '--json'].includes(args[i - 1] ?? ''));
+            const { runVouch } = await import('../engine/vouch/run-vouch.js');
+            runVouch({ root: process.cwd(), paths: paths.length > 0 ? paths : ['.'], out: flag(args, 'out'), json: flag(args, 'json'), strict: args.includes('--strict') });
+            return;
+        }
         case 'trace': {
             const { runTrace } = await import('../engine/trace/trace-command.js');
             runTrace({ root: process.cwd(), only: flag(args, 'only'), name: flag(args, 'name'), out: flag(args, 'out') });

package/dist/engine/attest/attest-command.js

@@ -46,9 +46,18 @@ function history(root, only) {
 function whatWasChecked(records) {
     const checked = [];
     const notChecked = [];
-    checked.push('every failing test in the run was read, and each was given a cause or left undecided');
-    const byRules = records.filter((r) => r.diagnosis?.source === 'rules').length;
-    const byModel = records.filter((r) => r.diagnosis?.source === 'llm').length;
+    // Decided means settled: a rule that looked and could not say is a refusal, and counting it here
+    // would have a bundle claim more decisions than it lists claims.
+    const settledBy = (source) => records.filter((r) => {
+        const d = r.diagnosis;
+        return d?.source === source && d.category && d.category !== 'UNKNOWN';
+    }).length;
+    if (records.length === 0)
+        checked.push('every test in the run passed, so there was nothing to diagnose');
+    else
+        checked.push('every failing test in the run was read, and each was given a cause or left undecided');
+    const byRules = settledBy('rules');
+    const byModel = settledBy('llm');
     if (byRules > 0)
         checked.push(`${byRules} decided by deterministic rules (${ENGINE_VERSION}), which call no model and give the same answer every time`);
     if (byModel > 0)

package/dist/engine/pursue/act.js

@@ -0,0 +1,39 @@
+/**
+ * What Tewip may carry out, and with what. Anything absent is refused: reporting a real bug, for
+ * instance, is deliberately not an action - it is for a person to read.
+ */
+export function planFor(decision) {
+    switch (decision.act) {
+        case 'cover-gap': {
+            // `write` drafts the test, runs it, breaks it on purpose to see it fail, and keeps it only
+            // if both hold. The scenario id is in the decision's own next step.
+            const id = /write a test for ([\w-]+)/.exec(decision.next)?.[1];
+            return id ? { command: ['write', '--only', id], target: `scenario ${id}` } : null;
+        }
+        case 'attest':
+            return { command: ['attest'], target: 'the evidence bundle' };
+        default:
+            return null;
+    }
+}
+/** Why an action was not carried out, in words a person can act on. */
+export const cannotAct = {
+    'look-first': 'there is nothing to act on until a report has been read',
+    'triage-real-bug': 'a real bug is for a person to see, and Tewip will not work around one on its own',
+    'rerun-environment': 'a re-run belongs to whatever runs the tests, not to Tewip',
+    'settle-flaky': 'settling a flaky test changes a test file, which Tewip does only when asked directly with `tewip fix`',
+    'triage-undecided': 'Tewip cannot say why these failed, so it has nothing it could safely do about them',
+    'cover-gap': '',
+    attest: '',
+    'stand-down': 'there is nothing here that matches the goal',
+};
+/**
+ * Has this exact action already been tried against this exact evidence? A scheduled run that keeps
+ * attempting an impossible task is the failure mode that makes people turn an agent off. A new run
+ * is new evidence and unblocks it; running again over the same report does not.
+ *
+ * Refusals are not counted: refusing costs nothing and says nothing about whether it would work.
+ */
+export function alreadyTried(records, act, target, runId) {
+    return records.find((r) => r.act === act && r.target === target && r.runId === runId && r.outcome !== 'refused') ?? null;
+}

package/dist/engine/pursue/pursue-command.js

@@ -4,9 +4,11 @@
 // it chose, and only through the gates that already prove a change before keeping it. There is no
 // mode in which it loops unattended: an agent that keeps going until it decides to stop is the
 // thing teams roll back, and nothing here needs it.
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { datasetFiles, readJsonl, readTriageRecords } from '../../reporters/store.js';
+import { alreadyTried, cannotAct, planFor } from './act.js';
 import { decide } from './policy.js';
 const words = (text) => (text.toLowerCase().match(/[a-z][a-z0-9]{2,}/g) ?? []).filter((w) => !['the', 'and', 'for', 'this', 'that', 'with', 'keep', 'green', 'sprint', 'flow', 'test', 'tests'].includes(w));
 /** Does this test or scenario belong to the goal? Deterministic, so a person can predict it. */
@@ -53,6 +55,7 @@ export function observe(root, goal, only) {
         uncovered: uncoveredScenarios(root, wanted, attempted),
         passing: attempted.length - failing.length,
         noHistory: runs.length === 0,
+        runId: newest?.runId ?? '',
     };
 }
 /** Scenarios of a kept plan that no attempted test can be matched to, worst priority first. */
@@ -108,15 +111,100 @@ export function renderPursuit(goal, seen, decision, acting) {
         : 'Tewip has not done anything: this is a decision, and the action is yours.', '', 'The order of these decisions is fixed and written down, not chosen by a model: a real bug first,', 'then the environment, then flakiness, then a coverage gap, and only then is a goal worth attesting.');
     return lines.join('\n');
 }
+/** The audit file the team owns: every action Tewip took on its own, and every one it refused. */
+const auditPath = (root) => join(root, '.tewip', 'actions.jsonl');
+export function actionsTaken(root) {
+    try {
+        return readFileSync(auditPath(root), 'utf8')
+            .split(String.fromCharCode(10))
+            .filter(Boolean)
+            .map((l) => JSON.parse(l));
+    }
+    catch {
+        return [];
+    }
+}
+function record(root, entry) {
+    mkdirSync(dirname(auditPath(root)), { recursive: true });
+    appendFileSync(auditPath(root), JSON.stringify(entry) + String.fromCharCode(10), 'utf8');
+}
+/**
+ * The Tewip command line belonging to *this* build, found from this file rather than from how the
+ * process was started.
+ *
+ * This is not a detail. The first version used process.argv[1], which is the command line only when
+ * a person typed it: under a test runner argv[1] is the test file, so acting re-ran the test file,
+ * which acted again, which re-ran it - a fork bomb that froze the machine it was written on. What
+ * re-enters Tewip has to be Tewip, established here, or nothing is carried out at all.
+ */
+export function cliEntry() {
+    const here = import.meta.dirname;
+    for (const candidate of [join(here, '..', '..', 'cli', 'tewip.ts'), join(here, '..', '..', 'cli', 'tewip.js')]) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+/**
+ * Carries out the one action that was decided, by running the command that already proves it.
+ * Tewip does not do the work here; it asks the gate to.
+ */
+function carryOut(cmd, decision, observed) {
+    const plan = planFor(decision);
+    const runId = observed.runId ?? '';
+    const note = (outcome, detail, target = plan?.target ?? '') => ({
+        at: new Date().toISOString(),
+        goal: cmd.goal,
+        act: decision.act,
+        target,
+        command: plan ? 'tewip ' + plan.command.join(' ') : '',
+        runId,
+        outcome,
+        detail,
+    });
+    if (!plan) {
+        const why = cannotAct[decision.act] || 'this is not something Tewip carries out on its own';
+        record(cmd.root, note('refused', why, decision.act));
+        return 'Not carried out: ' + why + '.';
+    }
+    const tried = alreadyTried(actionsTaken(cmd.root), decision.act, plan.target, runId);
+    if (tried) {
+        record(cmd.root, note('refused', 'already attempted at ' + tried.at + ', on the same evidence'));
+        return ['Not carried out: Tewip already attempted this at ' + tried.at.slice(0, 19).replace('T', ' ') + ' UTC, and nothing has happened since that would make the outcome different.', '', 'That attempt ' + (tried.outcome === 'done' ? 'succeeded' : 'did not finish') + ': ' + tried.detail, '', 'Run ' + tried.command + ' yourself if you want it tried again.'].join(String.fromCharCode(10));
+    }
+    // Re-enter this same build, so an installed Tewip runs the installed gates and a checkout runs
+    // the checkout's - never a different version from the one that decided, and never whatever
+    // happens to have started this process.
+    const entry = cliEntry();
+    if (!entry) {
+        record(cmd.root, note('refused', 'the Tewip command line could not be found next to this build, so there is nothing safe to re-enter'));
+        return 'Not carried out: Tewip could not find its own command line beside this build, and it will not guess at one. Run ' + 'tewip ' + plan.command.join(' ') + ' yourself.';
+    }
+    const ran = spawnSync(process.execPath, [entry, ...plan.command], { cwd: cmd.root, encoding: 'utf8', timeout: 20 * 60_000, maxBuffer: 32 * 1024 * 1024 });
+    const output = ((ran.stdout ?? '') + (ran.stderr ?? '')).trim();
+    const ok = ran.status === 0;
+    // What the audit file remembers: the headline of a success, the tail of a failure. A failure's
+    // reason is at the end of what it printed; a success's is at the start.
+    const lines = output.split(String.fromCharCode(10)).map((l) => l.trim()).filter(Boolean);
+    const detail = (ok ? lines[0] ?? 'it printed nothing' : lines.slice(-3).join(' ')).slice(0, 300);
+    record(cmd.root, note(ok ? 'done' : 'failed', detail));
+    return [
+        ok ? 'Carried out: tewip ' + plan.command.join(' ') : 'Tried and did not finish: tewip ' + plan.command.join(' '),
+        '',
+        output.slice(-2000),
+        '',
+        ok
+            ? 'Anything kept by that command was proved by it; anything unproved was thrown away. Written to .tewip/actions.jsonl.'
+            : 'Nothing was kept. Written to .tewip/actions.jsonl.',
+    ].join(String.fromCharCode(10));
+}
 export function runPursue(cmd) {
     const observed = observe(cmd.root, cmd.goal, cmd.name);
     const decision = decide(cmd.goal, observed);
     const report = renderPursuit(cmd.goal, observed, decision, Boolean(cmd.act));
     console.log(report);
-    if (cmd.act && decision.changesFiles) {
-        console.error('\n`--act` is accepted, but Tewip carries out a change only through the command that proves it.');
-        console.error(`Run: ${decision.next}`);
-    }
+    if (cmd.act)
+        console.log(String.fromCharCode(10) + '---' + String.fromCharCode(10) + carryOut(cmd, decision, observed));
     if (cmd.out) {
         mkdirSync(dirname(resolve(cmd.out)), { recursive: true });
         writeFileSync(resolve(cmd.out), `${report}\n`, 'utf8');

package/dist/engine/vouch/assertions.js

@@ -0,0 +1,138 @@
+// What counts as checking something, across the frameworks people actually use.
+//
+// This vocabulary is the whole accuracy of Phase 22, and its width is a lesson already paid for:
+// in Phase 8 the wait fix refused six real Cypress fixes because "asserted" meant `expect(` and
+// Cypress asserts with `.should(`, and refused the commonest shape of JavaScript unit test because
+// `assert.equal` was not on the list either. A missing entry here does not produce a smaller
+// answer, it produces a confident wrong one - Tewip telling somebody their test checks nothing when
+// it checks plenty. So the list is broad, and anything not on it is undecided rather than damning.
+const CHECKS = [
+    // JavaScript and TypeScript: Jest, Vitest, Chai, node:test, Playwright, Cypress, Supertest.
+    /\bexpect\s*\(/,
+    /\bexpect\s*\.\s*(soft|poll)\s*\(/,
+    /\.\s*should\s*[.(]/,
+    /\bshould\s*\.\s*not\b/,
+    /\bassert\b\s*[.(]/,
+    /\bassert(Equals?|True|False|Null|NotNull|That|Throws|Match|Contains|Rejects|Fails)\b/i,
+    /\.\s*to\s*\.\s*(equal|be|deep|have|include|throw|match|exist)\b/,
+    /\btoMatch(Snapshot|InlineSnapshot|ImageSnapshot)\s*\(/,
+    /\bexpect(Type|TypeOf)\s*[<(]/,
+    // AVA, tap and node-tap put their assertions on the test's own context object. Missing this made
+    // Tewip condemn all 59 tests in chalk - a third repeat of the Phase 8 lesson, so the pattern here
+    // is deliberately generous about what an assertion on `t` can be called.
+    /\bt\s*\.\s*(is|not|deepEqual|notDeepEqual|like|true|false|truthy|falsy|throws(Async)?|notThrows(Async)?|regex|notRegex|snapshot|pass|equal|same|strictSame|ok|notOk|match|type|has|hasStrict|rejects|resolves)\b/,
+    // Mocking libraries: verifying a call is a real check.
+    /\b(verify|verifyNoMoreInteractions|toHaveBeenCalled)\b/,
+    /\bsinon\s*\.\s*assert\b/,
+    // Python: pytest, unittest, hypothesis.
+    /(^|[^\w.])assert\s+[^=]/m,
+    /\bself\s*\.\s*assert[A-Z]/,
+    /\bpytest\s*\.\s*(raises|warns|approx|fail)\b/,
+    /\bnp\s*\.\s*testing\s*\.\s*assert/,
+    /\bassert_(frame|series|index)_equal\b/,
+    // Java, Kotlin, C#, Scala.
+    /\bAssert(ions)?\s*\./,
+    /\bassertThat\s*\(/,
+    /\bShould(Be|NotBe|Throw|Contain)\b/,
+    /\bFluentActions\b/,
+    // Go.
+    /\bt\s*\.\s*(Error|Errorf|Fatal|Fatalf|Fail|FailNow)\b/,
+    /\b(require|assert)\s*\.\s*[A-Z]\w+\s*\(/,
+    // Ruby, PHP, Rust.
+    /\bexpect\s*\(.*\)\s*\.\s*to\b/,
+    /\b\$this\s*->\s*assert/,
+    /\bassert(_eq|_ne|_matches)?!\s*\(/,
+    // Robot Framework and other keyword styles: a line that reads as a check.
+    /^\s*Should\s+(Be|Not|Contain|Match)\b/im,
+];
+/** Does this text check anything at all, by any framework's idea of checking? */
+export function checksSomething(text) {
+    return CHECKS.some((pattern) => pattern.test(text));
+}
+/**
+ * An `expect(...)` that was never finished: no matcher was called on it, so it runs clean and proves
+ * nothing. `expect(user).toBe(x)` checks; `expect(user);` does not, and neither does a matcher left
+ * as a property - `expect(user).toBeDefined;` is a reference to a function nobody called.
+ *
+ * Both shapes are ordinary typos that no test run can catch, which is exactly why they survive.
+ */
+export function unfinishedExpectations(body) {
+    const found = [];
+    for (const line of body.split(String.fromCharCode(10))) {
+        const text = line.trim();
+        if (!/^(await\s+)?expect(\.soft)?\s*\(/.test(text))
+            continue;
+        const after = afterBalanced(text, text.indexOf('('));
+        if (after === null)
+            continue; // the call spans more lines; judged as part of the whole body
+        const rest = after.trim();
+        if (rest === '' || rest === ';')
+            found.push(text);
+        // A matcher named but not called: `.toBeVisible;` or `.toBeVisible` at the end of a statement.
+        else if (/^\.\s*[A-Za-z$_][\w$]*\s*;?$/.test(rest))
+            found.push(text);
+    }
+    return found;
+}
+/** What follows the balanced bracket that opens at `from`, or null when it never closes here. */
+function afterBalanced(text, from) {
+    let depth = 0;
+    let quote = '';
+    for (let i = from; i < text.length; i += 1) {
+        const ch = text[i];
+        if (quote) {
+            if (ch === '\\')
+                i += 1;
+            else if (ch === quote)
+                quote = '';
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`')
+            quote = ch;
+        else if (ch === '(' || ch === '[')
+            depth += 1;
+        else if (ch === ')' || ch === ']') {
+            depth -= 1;
+            if (depth === 0)
+                return text.slice(i + 1);
+        }
+    }
+    return null;
+}
+/**
+ * A check that cannot fail because both sides are the same literal, or the same expression.
+ * `expect(true).toBe(true)`, `assertEquals(1, 1)`, `assert x == x`. These appear in generated tests
+ * and in tests somebody left as a placeholder, and they pass forever.
+ */
+export function tautologies(body) {
+    const found = [];
+    const literal = String.raw `(?:true|false|null|None|nil|undefined|-?\d+(?:\.\d+)?|'[^']*'|"[^"]*")`;
+    const patterns = [
+        new RegExp(String.raw `expect\s*\(\s*(${literal})\s*\)\s*\.\s*(?:to\s*\.\s*)?(?:toBe|toEqual|toStrictEqual|equal|eq|is)\s*\(\s*(${literal})\s*\)`),
+        new RegExp(String.raw `assert(?:Equals?|\.equal|\.strictEqual|\.deepEqual)\s*\(\s*(${literal})\s*,\s*(${literal})\s*\)`),
+        new RegExp(String.raw `^\s*assert\s+(${literal})\s*==\s*(${literal})\s*$`),
+    ];
+    for (const line of body.split(String.fromCharCode(10))) {
+        for (const pattern of patterns) {
+            const hit = pattern.exec(line);
+            if (hit && same(hit[1], hit[2]))
+                found.push(line.trim());
+        }
+        // The same name on both sides of a comparison, which no value can falsify.
+        const self = /(?:expect\s*\(\s*([\w.$]+)\s*\)\s*\.\s*(?:toBe|toEqual|equal)\s*\(\s*([\w.$]+)\s*\)|^\s*assert\s+([\w.$]+)\s*==\s*([\w.$]+)\s*$)/.exec(line);
+        if (self) {
+            const [left, right] = [self[1] ?? self[3], self[2] ?? self[4]];
+            if (left && right && left === right && !/^(true|false|null|undefined|None)$/.test(left))
+                found.push(line.trim());
+        }
+        // `assert True` / `assert 1`: a constant truth written as a statement.
+        if (/^\s*assert\s+(True|true|1)\s*(,|$)/.test(line))
+            found.push(line.trim());
+    }
+    return [...new Set(found)];
+}
+/** Two literals that mean the same value, allowing for how each language spells truth. */
+function same(a, b) {
+    const clean = (v) => v.trim().replace(/^['"]|['"]$/g, '');
+    return clean(a) === clean(b);
+}

package/dist/engine/vouch/run-vouch.js

@@ -0,0 +1,35 @@
+// The command around `vouch`: read the paths, print the report, and exit non-zero under --strict so
+// it can sit in front of a merge. Kept apart from the report itself so the MCP server can ask the
+// same question without anything being printed to the stream it speaks on.
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { CANNOT_FAIL } from './vouch.js';
+import { renderVouch, vouchAll } from './vouch-command.js';
+/** The silent core: every MCP caller and the report itself use this. */
+export function vouchReport(root, paths) {
+    const files = vouchAll(root, paths);
+    const all = files.flatMap((f) => f.judgements);
+    return {
+        report: renderVouch(files),
+        cannotFail: all.filter((j) => CANNOT_FAIL.includes(j.verdict)).length,
+        read: all.length,
+    };
+}
+export function runVouch(cmd) {
+    const files = vouchAll(cmd.root, cmd.paths);
+    const report = renderVouch(files);
+    console.log(report);
+    if (cmd.out) {
+        mkdirSync(dirname(resolve(cmd.out)), { recursive: true });
+        writeFileSync(resolve(cmd.out), report + String.fromCharCode(10), 'utf8');
+    }
+    if (cmd.json) {
+        mkdirSync(dirname(resolve(cmd.json)), { recursive: true });
+        writeFileSync(resolve(cmd.json), JSON.stringify(files, null, 2), 'utf8');
+    }
+    const cannotFail = files.flatMap((f) => f.judgements).filter((j) => CANNOT_FAIL.includes(j.verdict)).length;
+    if (cmd.strict && cannotFail > 0) {
+        console.error(String.fromCharCode(10) + `${cannotFail} test(s) here cannot fail. Fix them or take them out; a test that cannot fail is worse than no test, because it reads as coverage.`);
+        process.exitCode = 1;
+    }
+}

package/dist/engine/vouch/tests-in.js

@@ -0,0 +1,275 @@
+/** Which language this file is, by extension. Unknown extensions are not guessed at. */
+export function languageOf(file) {
+    const lower = file.toLowerCase();
+    if (/\.(js|jsx|mjs|cjs|ts|tsx|mts|cts)$/.test(lower))
+        return 'js';
+    if (lower.endsWith('.py'))
+        return 'python';
+    if (/\.(java|kt|kts|scala|groovy)$/.test(lower))
+        return 'jvm';
+    if (lower.endsWith('.go'))
+        return 'go';
+    if (/\.(cs|fs)$/.test(lower))
+        return 'csharp';
+    return null;
+}
+/** Does this file look like tests at all? Vouching for a source file is a category error. */
+export function looksLikeTests(file, text) {
+    const named = /(^|[\\/])(tests?|spec|specs|__tests__|e2e|it|integration)[\\/]|[._-](test|tests|spec|specs|it)\.[a-z]+$|(^|[\\/])test_[^\\/]+\.py$|_test\.(go|py|rb)$|Tests?\.(java|kt|cs|scala)$/i.test(file);
+    const declares = /\b(it|test|describe|Scenario)\s*\(|^\s*def\s+test_|@Test\b|\[(Test|Fact|Theory)\]|\bfunc\s+Test[A-Z]/m.test(text);
+    return named || declares;
+}
+/**
+ * The offsets of this file that are inside a string, a template literal or a comment - text, not
+ * code. Test files are full of test code that is not test code: fixtures quoting a fake test,
+ * snapshots, documentation examples, and the input to tools like Tewip itself. Judging those is how
+ * a checker ends up telling somebody that a string in their fixture checks nothing. Found by
+ * pointing this at Tewip's own test suite, where it produced 27 confident false accusations.
+ */
+export function textRanges(text) {
+    const ranges = [];
+    const TRIPLES = ['"'.repeat(3), "'".repeat(3)];
+    for (let i = 0; i < text.length; i += 1) {
+        const ch = text[i];
+        const next = text[i + 1];
+        if (ch === '/' && next === '/') {
+            const end = indexOrEnd(text, String.fromCharCode(10), i);
+            ranges.push([i, end]);
+            i = end;
+        }
+        else if (ch === '/' && next === '*') {
+            const end = indexOrEnd(text, '*/', i) + 1;
+            ranges.push([i, end]);
+            i = end;
+        }
+        else if (ch === '#' && /[#\s]/.test(next ?? '')) {
+            const end = indexOrEnd(text, String.fromCharCode(10), i);
+            ranges.push([i, end]);
+            i = end;
+        }
+        else if (ch === '"' || ch === "'" || ch === '`') {
+            // A Python docstring runs to the next triple quote, not to the next single one.
+            const triple = TRIPLES.find((t) => text.startsWith(t, i));
+            const end = triple ? indexOrEnd(text, triple, i + 2) + 2 : closingQuote(text, i);
+            ranges.push([i, end]);
+            i = end;
+        }
+    }
+    return ranges;
+}
+/** Is this offset inside text rather than code? */
+const isText = (ranges, at) => ranges.some(([from, to]) => at > from && at < to);
+export function testsIn(language, text) {
+    if (language === 'python')
+        return pythonTests(text);
+    if (language === 'js')
+        return jsTests(text);
+    return bracedTests(language, text);
+}
+/** The line number of an offset, 1-based. */
+const lineAt = (text, index) => text.slice(0, index).split(String.fromCharCode(10)).length;
+/**
+ * `it('...', async () => { ... })` and its many spellings, including `test.each`, `it.skip` and a
+ * plain `function ()` callback. The body is taken by matching braces from the callback's opening one.
+ */
+function jsTests(text) {
+    const found = [];
+    const ranges = textRanges(text);
+    const declaration = /\b(it|test|specify)\s*(\.\s*(skip|only|todo|failing|concurrent|each|for)\s*(\([^)]*\)|`[^`]*`)?\s*)*\(\s*(['"`])((?:\\.|(?!\5)[^\\])*)\5/g;
+    for (const hit of text.matchAll(declaration)) {
+        const at = hit.index ?? 0;
+        if (isText(ranges, at))
+            continue;
+        const open = text.indexOf('{', at + hit[0].length);
+        if (open === -1)
+            continue;
+        const body = braced(text, open);
+        if (body === null)
+            continue;
+        const signature = text.slice(at + hit[0].length, open);
+        found.push({
+            name: hit[6],
+            line: lineAt(text, at),
+            body,
+            skipped: /\.\s*(skip|todo|failing)\b/.test(hit[0]) || /\bxit\s*\(/.test(hit[0]),
+            callback: /\(\s*([A-Za-z_$][\w$]*)\s*\)\s*(=>)?\s*$/.exec(signature.trim())?.[1] ?? '',
+        });
+    }
+    // `xit(...)` and `xtest(...)`, which the pattern above deliberately does not match.
+    for (const hit of text.matchAll(/\bx(it|test)\s*\(\s*(['"`])((?:\\.|(?!\2)[^\\])*)\2/g)) {
+        const at = hit.index ?? 0;
+        if (isText(ranges, at))
+            continue;
+        const open = text.indexOf('{', at + hit[0].length);
+        const body = open === -1 ? null : braced(text, open);
+        found.push({ name: hit[3], line: lineAt(text, at), body: body ?? '', skipped: true, callback: '' });
+    }
+    return found.sort((a, b) => a.line - b.line);
+}
+/** Python has no braces: a test's body is everything indented further than its `def`. */
+function pythonTests(text) {
+    const lines = text.split(String.fromCharCode(10));
+    const ranges = textRanges(text);
+    const offsets = [];
+    let seen = 0;
+    for (const line of lines) {
+        offsets.push(seen);
+        seen += line.length + 1;
+    }
+    const found = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const hit = /^(\s*)(?:async\s+)?def\s+(test_\w+|test)\s*\(/.exec(lines[i]);
+        if (!hit)
+            continue;
+        if (isText(ranges, offsets[i] + hit[1].length + 1))
+            continue;
+        const indent = hit[1].length;
+        // Nested in another def? Then it is a helper or, in Click's tests, a CLI command that happens to
+        // be named `test`. Only a module-level def, or a method of a test class, is a test.
+        if (nestedInFunction(lines, i, indent))
+            continue;
+        if (hit[2] === 'test' && indent > 0)
+            continue;
+        // A def whose parameters run over several lines ends at the line that closes them, and the body
+        // starts after that. Without this, the parameter list was read as the body and the real body was
+        // thrown away: psf/requests has several, and each came back as a test that compares no value.
+        let signatureEnds = i;
+        let open = 0;
+        for (let j = i; j < lines.length && j < i + 20; j += 1) {
+            open += (lines[j].match(/\(/g) ?? []).length - (lines[j].match(/\)/g) ?? []).length;
+            signatureEnds = j;
+            if (open <= 0)
+                break;
+        }
+        const body = [];
+        for (let j = signatureEnds + 1; j < lines.length; j += 1) {
+            const line = lines[j];
+            if (line.trim() === '') {
+                body.push(line);
+                continue;
+            }
+            const width = line.length - line.trimStart().length;
+            if (width <= indent)
+                break;
+            body.push(line);
+        }
+        // Decorators sit above the def, so skipping is read upwards.
+        const above = lines.slice(Math.max(0, i - 4), i).join(String.fromCharCode(10));
+        // A conditional skip runs somewhere - `skipif` on Windows registry tests in psf/requests runs
+        // on Windows - so only an unconditional skip means the test never runs. `xfail` runs too.
+        const skipped = /@\s*(pytest\s*\.\s*mark\s*\.\s*skip|unittest\s*\.\s*skip)\b/.test(above) && !/skipif|skipUnless|xfail/.test(above);
+        found.push({ name: hit[2], line: i + 1, body: body.join(String.fromCharCode(10)), skipped, callback: '' });
+    }
+    return found;
+}
+/** Is the def on line `i` nested inside another def, rather than inside a class or at the top? */
+function nestedInFunction(lines, i, indent) {
+    for (let j = i - 1; j >= 0; j -= 1) {
+        const line = lines[j];
+        if (line.trim() === '')
+            continue;
+        const width = line.length - line.trimStart().length;
+        if (width >= indent)
+            continue;
+        return /^\s*(async\s+)?def\s/.test(line);
+    }
+    return false;
+}
+/** JUnit, Kotlin, Scala, Go and C#: an annotation or a naming convention, then a braced body. */
+function bracedTests(language, text) {
+    const found = [];
+    const ranges = textRanges(text);
+    const declaration = language === 'go'
+        ? // Only a Test function. A Benchmark asserts nothing by design, an Example is checked against
+            // its own Output comment, and a Fuzz target is not a test - all three were condemned as
+            // "checks nothing" in gorilla/mux before this narrowed.
+            /\bfunc\s+(Test)(\w+)\s*\(\s*\w+\s+\*testing\.[TB]\s*\)\s*\{/g
+        : /(@Test\b[^\n]*|\[\s*(?:Test|Fact|Theory)[^\]]*\]|@(?:ParameterizedTest|RepeatedTest)\b)/g;
+    for (const hit of text.matchAll(declaration)) {
+        const at = hit.index ?? 0;
+        if (isText(ranges, at))
+            continue;
+        const open = language === 'go' ? text.indexOf('{', at) : text.indexOf('{', text.indexOf('(', at + hit[0].length));
+        if (open === -1)
+            continue;
+        const body = braced(text, open);
+        if (body === null)
+            continue;
+        const signature = text.slice(at, open);
+        // `void foo() throws IOException` still names foo. Without allowing the throws clause, every
+        // checked-exception test in gson was reported as 'unnamed'.
+        const name = language === 'go' ? hit[1] + hit[2] : /([\w]+)\s*\([^)]*\)\s*(throws\s+[\w.,\s]+)?$/.exec(signature.trim())?.[1] ?? 'unnamed';
+        const around = text.slice(Math.max(0, at - 200), open);
+        // An annotation disables a test outright. A `t.Skip()` may be conditional - cobra's
+        // TestDeadcodeElimination skips on Windows and runs everywhere else - so it counts only when it
+        // is unconditional, at the top level of the body.
+        const skipped = /@(Disabled|Ignore)\b|\[\s*Ignore\b/.test(around) || skipsUnconditionally(body);
+        found.push({ name, line: lineAt(text, at), body, skipped, callback: '' });
+    }
+    return found;
+}
+/**
+ * A `t.Skip()` that runs whatever happens: at the top level of the body, not inside an `if`. Go
+ * tests commonly skip on one platform and run on the others, and calling those "never runs" is
+ * wrong.
+ */
+function skipsUnconditionally(body) {
+    let depth = 0;
+    for (const line of body.split(String.fromCharCode(10))) {
+        const text = line.trim();
+        if (depth === 0 && /^\w+\s*\.\s*Skip(Now)?\s*\(/.test(text))
+            return true;
+        depth += (line.match(/\{/g) ?? []).length - (line.match(/\}/g) ?? []).length;
+    }
+    return false;
+}
+/**
+ * The text between the brace at `open` and the one that closes it, skipping over strings, template
+ * literals, comments and regular expressions - all of which can hold a brace that closes nothing.
+ */
+export function braced(text, open) {
+    let depth = 0;
+    for (let i = open; i < text.length; i += 1) {
+        const ch = text[i];
+        const next = text[i + 1];
+        if (ch === '/' && next === '/') {
+            i = indexOrEnd(text, String.fromCharCode(10), i);
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            i = indexOrEnd(text, '*/', i) + 1;
+            continue;
+        }
+        if (ch === '#' && /[#\s]/.test(next ?? '')) {
+            i = indexOrEnd(text, String.fromCharCode(10), i);
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`') {
+            i = closingQuote(text, i);
+            continue;
+        }
+        if (ch === '{')
+            depth += 1;
+        else if (ch === '}') {
+            depth -= 1;
+            if (depth === 0)
+                return text.slice(open + 1, i);
+        }
+    }
+    return null;
+}
+const indexOrEnd = (text, needle, from) => {
+    const at = text.indexOf(needle, from + 1);
+    return at === -1 ? text.length : at;
+};
+/** Where the string opening at `from` ends, honouring escapes. */
+function closingQuote(text, from) {
+    const quote = text[from];
+    for (let i = from + 1; i < text.length; i += 1) {
+        if (text[i] === '\\')
+            i += 1;
+        else if (text[i] === quote)
+            return i;
+    }
+    return text.length;
+}

package/dist/engine/vouch/vouch-command.js

@@ -0,0 +1,135 @@
+// `tewip vouch <paths>`: which of these tests could never fail.
+//
+// Costs nothing and calls no model: every verdict is a line of the file quoted back. The report is
+// ordered for a reviewer with ten minutes - what cannot fail, then what does not run, then what
+// Tewip would not judge - and it ends with what it refused, because that is what makes the rest of
+// it believable.
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { CANNOT_FAIL, vouchFile } from './vouch.js';
+const SKIP = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', 'vendor', 'target', '.venv', '__pycache__', '.tewip']);
+/** Every file under these paths that could hold tests. */
+export function testFiles(root, paths) {
+    const found = [];
+    const walk = (where, depth) => {
+        if (depth > 12)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(where);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (SKIP.has(entry))
+                continue;
+            const full = join(where, entry);
+            let stat;
+            try {
+                stat = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory())
+                walk(full, depth + 1);
+            else if (/\.(js|jsx|mjs|cjs|ts|tsx|mts|cts|py|java|kt|kts|scala|groovy|go|cs|fs)$/i.test(entry))
+                found.push(full);
+        }
+    };
+    for (const path of paths) {
+        const full = join(root, path);
+        if (!existsSync(full))
+            continue;
+        if (statSync(full).isDirectory())
+            walk(full, 0);
+        else
+            found.push(full);
+    }
+    return found;
+}
+export function vouchAll(root, paths) {
+    const out = [];
+    for (const file of testFiles(root, paths)) {
+        let text;
+        try {
+            text = readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (text.length > 2_000_000)
+            continue; // a generated file, not a test somebody wrote
+        const vouched = vouchFile(relative(root, file).split('\\').join('/'), text);
+        if (vouched.judgements.length > 0 || vouched.focused)
+            out.push(vouched);
+    }
+    return out;
+}
+const count = (all, verdict) => all.filter((j) => j.verdict === verdict).length;
+export function renderVouch(files) {
+    const all = files.flatMap((f) => f.judgements);
+    const cannotFail = all.filter((j) => CANNOT_FAIL.includes(j.verdict));
+    const crashOnly = count(all, 'crash-only');
+    const lines = [
+        '# Which of these tests could fail?',
+        '',
+        `${all.length} test(s) read in ${files.length} file(s). **${cannotFail.length} cannot fail at all.** ${crashOnly} compare no value, so only a crash would fail them. ${count(all, 'cannot-tell')} Tewip would not judge.`,
+        '',
+        'A test that cannot fail still passes, still counts towards coverage, and still looks like work.',
+        '',
+    ];
+    if (cannotFail.length === 0) {
+        lines.push('## Nothing here is unable to fail', '', 'Every test read can be broken by a change to the code, or by the code throwing.', '');
+    }
+    for (const verdict of CANNOT_FAIL) {
+        const group = cannotFail.filter((j) => j.verdict === verdict);
+        if (group.length === 0)
+            continue;
+        lines.push(`## ${TITLES[verdict]} (${group.length})`, '');
+        for (const j of group) {
+            lines.push(`- **${j.name}** — ${j.file}:${j.line}`);
+            if (j.evidence)
+                lines.push(`  - \`${j.evidence.replace(/`/g, "'")}\``);
+            lines.push(`  - ${j.why}`);
+        }
+        lines.push('');
+    }
+    const focused = files.filter((f) => f.focused);
+    if (focused.length > 0) {
+        lines.push(`## Files where most tests do not run (${focused.length})`, '');
+        for (const f of focused)
+            lines.push(`- ${f.file}: ${f.focused}`);
+        lines.push('');
+    }
+    const weak = all.filter((j) => j.verdict === 'crash-only');
+    if (weak.length > 0) {
+        lines.push(`## Compare no value (${weak.length})`, '', 'These are not broken. They fail if the code throws and pass whatever it returns, which is', 'sometimes exactly the intention - a test that compiles a fixture and runs it is checking that', 'nothing blew up. Worth a look where a value was meant to be checked.', '');
+        for (const j of weak.slice(0, 40))
+            lines.push(`- ${j.name} — ${j.file}:${j.line}: \`${j.evidence.replace(/`/g, "'")}\``);
+        if (weak.length > 40)
+            lines.push(`- …and ${weak.length - 40} more`);
+        lines.push('');
+    }
+    const undecided = all.filter((j) => j.verdict === 'cannot-tell');
+    if (undecided.length > 0) {
+        lines.push(`## Not judged (${undecided.length})`, '', 'Tewip will not call these either way, because the checking may be somewhere it cannot follow.', '');
+        for (const j of undecided.slice(0, 25))
+            lines.push(`- ${j.name} — ${j.file}:${j.line}: ${j.evidence}`);
+        if (undecided.length > 25)
+            lines.push(`- …and ${undecided.length - 25} more`);
+        lines.push('');
+    }
+    lines.push('---', '', 'Every verdict above quotes the line it is based on, and nothing was inferred by a model: this', 'costs nothing to run. Where the checking happens in a helper Tewip cannot follow it says so', 'rather than guessing, which is why the list above is worth reading.', '', 'What this does not tell you is how many it missed. Everything it reports here has been measured', 'for correctness on real projects; its recall has not been measured at all, so a clean report is', 'not proof that every test in these files is worth something.');
+    return lines.join(String.fromCharCode(10));
+}
+const TITLES = {
+    'crash-only': 'Compares no value: only a crash can fail it',
+    'unfinished-expectation': 'An expectation nobody finished',
+    tautology: 'Compares a value with itself',
+    'swallows-failure': 'Discards its own failure',
+    'never-runs': 'Never runs',
+    'cannot-tell': 'Not judged',
+    checks: 'Can fail',
+};

package/dist/engine/vouch/vouch.js

@@ -0,0 +1,193 @@
+// Phase 22: does this test prove anything?
+//
+// By 2026 most tests in a pull request were written by an agent, and the one question that decides
+// whether they are worth anything goes unasked: could this test ever fail? Coverage counts a test
+// that checks nothing. CI goes green on it. A reviewer skims something plausible and approves it.
+//
+// This file answers that per test, from the text alone, and its accuracy rests on refusing to guess.
+// Telling somebody their test is worthless when it is not costs more than missing one: it spends
+// their time and their trust, and a reviewer who is wrong once is ignored afterwards. So a body whose
+// checking happens somewhere this cannot follow is reported as undecided, by name, and never as
+// vacuous.
+import { checksSomething, tautologies, unfinishedExpectations } from './assertions.js';
+import { languageOf, looksLikeTests, testsIn, textRanges } from './tests-in.js';
+/** Everything a verdict other than `checks` means, in the words the report uses. */
+export const MEANS = {
+    checks: 'it asserts something, so it can fail',
+    'crash-only': 'it compares no value, so it passes whatever the code returns; only an exception can fail it',
+    'unfinished-expectation': 'an expectation was written but no matcher was called on it, so nothing is compared',
+    tautology: 'the check compares a value with itself, which no change to the code can falsify',
+    'swallows-failure': 'its own failure is caught and discarded, so it reports success either way',
+    'never-runs': 'it is skipped, so it proves nothing until somebody turns it back on',
+    'cannot-tell': 'the checking may happen inside a helper this cannot follow, so Tewip is not calling it either way',
+};
+/**
+ * Tests that cannot fail at all, worst first.
+ *
+ * `crash-only` is deliberately not in this list, and that correction came from reading real code.
+ * "It checks nothing, so it cannot fail" is false: a test with no assertion still fails when the
+ * code throws, and in axios a test that compiles a TypeScript fixture and runs it asserts nothing
+ * on purpose - the crash *is* the check. Tewip would have called 143 such tests worthless across
+ * seven real projects. Overclaiming about somebody's tests is the exact failure this project exists
+ * not to commit, so the two are reported apart and worded for what each really is.
+ */
+export const CANNOT_FAIL = ['unfinished-expectation', 'tautology', 'swallows-failure', 'never-runs'];
+/** Weaker than a check, and worth knowing, but not a defect on its own. */
+export const CRASH_ONLY = ['crash-only'];
+export function vouchFile(file, text) {
+    const language = languageOf(file);
+    if (!language)
+        return { file, judgements: [], unread: 'Tewip does not read this kind of file', focused: '' };
+    if (!looksLikeTests(file, text))
+        return { file, judgements: [], unread: 'this does not look like a test file, and vouching for source code is a different question', focused: '' };
+    const tests = testsIn(language, text);
+    if (tests.length === 0) {
+        return { file, judgements: [], unread: 'no test in a shape Tewip recognises, so it says nothing about this file rather than clearing it', focused: '' };
+    }
+    const helpers = helpersThatCheck(text, language);
+    // Masked the same way the extractor is: a `.only` quoted inside a fixture focuses nothing.
+    const ranges = textRanges(text);
+    const focus = [...text.matchAll(/\b(it|test|describe)\s*\.\s*only\s*\(|\bfdescribe\s*\(|\bfit\s*\(/g)].find((hit) => !ranges.some(([from, to]) => (hit.index ?? 0) > from && (hit.index ?? 0) < to));
+    return {
+        file,
+        judgements: tests.map((test) => judge(file, test, helpers)),
+        unread: '',
+        focused: focus ? `${focus[0].trim()}…) is focused, so the rest of this file does not run` : '',
+    };
+}
+function judge(file, test, helpers) {
+    const at = { file, name: test.name, line: test.line };
+    if (test.skipped)
+        return { ...at, verdict: 'never-runs', evidence: test.name, why: MEANS['never-runs'] };
+    const body = withoutComments(test.body);
+    const tautology = tautologies(body);
+    const unfinished = unfinishedExpectations(body);
+    const checks = checksSomething(body);
+    // A body that checks nothing else and contains only a tautology cannot fail. One alongside real
+    // checks is untidy, not broken, so it is left alone.
+    if (tautology.length > 0 && !checksSomething(stripLines(body, tautology))) {
+        return { ...at, verdict: 'tautology', evidence: tautology[0], why: MEANS.tautology };
+    }
+    if (unfinished.length > 0 && !checksSomething(stripLines(body, unfinished))) {
+        return { ...at, verdict: 'unfinished-expectation', evidence: unfinished[0], why: MEANS['unfinished-expectation'] };
+    }
+    const swallowed = swallowsFailure(body, checks);
+    if (swallowed)
+        return { ...at, verdict: 'swallows-failure', evidence: swallowed, why: MEANS['swallows-failure'] };
+    if (checks)
+        return { ...at, verdict: 'checks', evidence: '', why: MEANS.checks };
+    // Mocha's `done`: the test fails when the callback never arrives, which is a real check with
+    // nothing asserted. express has dozens, and calling them unchecked was simply wrong.
+    if (test.callback && new RegExp('\\b' + test.callback + '\\b').test(body)) {
+        return { ...at, verdict: 'checks', evidence: test.callback, why: `it fails if ${test.callback}() is never called, which is what it is checking` };
+    }
+    // Nothing in the body checks anything. Before saying so, look for the checking somewhere else:
+    // a helper in this file that asserts, or a call this cannot follow at all.
+    const called = [...body.matchAll(/([A-Za-z_$][\w$]*)\s*\(/g)].map((m) => m[1]).filter((name) => !LANGUAGE_NOISE.has(name));
+    const helping = called.find((name) => helpers.has(name));
+    if (helping)
+        return { ...at, verdict: 'checks', evidence: `${helping}(…)`, why: `it checks through ${helping}(), which asserts` };
+    const unknown = called.find((name) => /^(check|verify|ensure|validate|assert|expect|should|confirm)/i.test(name));
+    if (unknown)
+        return { ...at, verdict: 'cannot-tell', evidence: `${unknown}(…)`, why: `${unknown}() may assert, and it is not in this file, so Tewip will not call this either way` };
+    if (unfinished.length > 0)
+        return { ...at, verdict: 'unfinished-expectation', evidence: unfinished[0], why: MEANS['unfinished-expectation'] };
+    if (tautology.length > 0)
+        return { ...at, verdict: 'tautology', evidence: tautology[0], why: MEANS.tautology };
+    if (body.trim() === '')
+        return { ...at, verdict: 'crash-only', evidence: '(the body is empty)', why: 'the test has no body at all, so nothing can fail it' };
+    return { ...at, verdict: 'crash-only', evidence: firstRealLine(body), why: MEANS['crash-only'] };
+}
+/**
+ * Everything inside a `try` whose `catch` discards what it caught. An assertion failure is an
+ * exception, so a test shaped this way reports success however the code behaves - and a `catch` that
+ * asserts, re-throws or fails the test is the legitimate version, which this leaves alone.
+ */
+function swallowsFailure(body, checks) {
+    if (!checks)
+        return ''; // nothing to swallow; judged as no-assertion instead
+    for (const hit of body.matchAll(/catch\s*(\([^)]*\))?\s*\{/g)) {
+        const open = body.indexOf('{', hit.index ?? 0);
+        const handler = balanced(body, open);
+        if (handler === null)
+            continue;
+        const meaningful = withoutComments(handler).trim();
+        const rescues = checksSomething(handler) || /\b(throw|raise|rethrow|fail|t\s*\.\s*(Error|Fatal)|pytest\s*\.\s*fail)\b/.test(handler);
+        if (rescues)
+            continue;
+        // A handler that only logs, or does nothing at all, discards the failure.
+        if (meaningful === '' || /^(console\s*\.\s*\w+\s*\([^;]*\)\s*;?|print\s*\([^;]*\)\s*;?|pass|;)$/.test(meaningful.replace(/\s+/g, ' ').trim())) {
+            return meaningful === '' ? 'catch { }' : meaningful.slice(0, 120);
+        }
+    }
+    return '';
+}
+/** Functions defined in this file that assert, so a test calling one really is checking something. */
+function helpersThatCheck(text, language) {
+    const names = new Set();
+    const declarations = language === 'python'
+        ? /^\s*(?:async\s+)?def\s+(\w+)\s*\(/gm
+        : /(?:function\s+([A-Za-z_$][\w$]*)|(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[\w$]+)\s*=>|(?:public|private|protected|static|\s)+[\w<>,\[\]]+\s+([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*\{)/g;
+    for (const hit of text.matchAll(declarations)) {
+        const name = hit[1] ?? hit[2] ?? hit[3];
+        if (!name)
+            continue;
+        const from = (hit.index ?? 0) + hit[0].length;
+        const body = language === 'python' ? indentedFrom(text, from) : balanced(text, text.indexOf('{', from - 1));
+        if (body && checksSomething(body))
+            names.add(name);
+    }
+    return names;
+}
+/** Python's block after an offset: every line indented further than the line the offset is on. */
+function indentedFrom(text, from) {
+    const lines = text.slice(from).split(String.fromCharCode(10));
+    const start = text.slice(0, from).split(String.fromCharCode(10)).pop() ?? '';
+    const indent = start.length - start.trimStart().length;
+    const body = [];
+    for (const line of lines.slice(1)) {
+        if (line.trim() === '')
+            continue;
+        if (line.length - line.trimStart().length <= indent)
+            break;
+        body.push(line);
+    }
+    return body.join(String.fromCharCode(10));
+}
+/** Names that are calls but not helpers: language and framework machinery. */
+const LANGUAGE_NOISE = new Set(['if', 'for', 'while', 'switch', 'catch', 'return', 'function', 'await', 'typeof', 'new', 'require', 'import', 'print', 'console', 'log', 'describe', 'beforeEach', 'afterEach', 'it', 'test', 'range', 'len', 'str', 'int', 'super', 'Error', 'Promise', 'Array', 'Object', 'String', 'Number', 'Boolean', 'Date', 'JSON', 'Math', 'Map', 'Set']);
+const balanced = (text, open) => {
+    if (open === -1)
+        return null;
+    let depth = 0;
+    for (let i = open; i < text.length; i += 1) {
+        if (text[i] === '{')
+            depth += 1;
+        else if (text[i] === '}') {
+            depth -= 1;
+            if (depth === 0)
+                return text.slice(open + 1, i);
+        }
+    }
+    return null;
+};
+/** Comments cannot assert, and a commented-out check is the classic way a test stops checking. */
+function withoutComments(body) {
+    return body
+        .replace(/\/\*[\s\S]*?\*\//g, ' ')
+        .split(String.fromCharCode(10))
+        .map((line) => line.replace(/(^|\s)\/\/.*$/, '').replace(/(^|\s)#(?!\{).*$/, ''))
+        .join(String.fromCharCode(10));
+}
+const stripLines = (body, lines) => body
+    .split(String.fromCharCode(10))
+    .filter((line) => !lines.some((drop) => line.trim() === drop.trim()))
+    .join(String.fromCharCode(10));
+/** The first line that does something, for the report to quote. */
+function firstRealLine(body) {
+    const line = body
+        .split(String.fromCharCode(10))
+        .map((l) => l.trim())
+        .find((l) => l !== '' && l !== '{' && l !== '}');
+    return (line ?? '').slice(0, 120);
+}

package/dist/mcp/server.js

@@ -123,4 +123,18 @@ server.registerTool('next_action', {
     const observed = observe(root, goal);
     return renderPursuit(goal, observed, decide(goal, observed), false);
 }));
+server.registerTool('vouch_tests', {
+    title: 'Could these tests ever fail?',
+    description: "Reads test files and says, per test, whether a change to the code could break them: which compare no value, which leave an expectation unfinished, which compare something with itself, which catch and discard their own failure, and which never run. Where the checking happens in a helper it cannot follow it says so instead of accusing. Costs nothing and uses no model. Use it on tests that were just written - including tests you wrote yourself - before claiming a change is covered.",
+    inputSchema: {
+        project,
+        paths: z.array(z.string()).optional().describe('Paths inside the project to read, relative to it. Defaults to the whole project.'),
+    },
+    annotations: readOnly,
+}, ({ project: root, paths }) => answer(async () => {
+    if (!isAbsolute(root) || !existsSync(root))
+        throw new Error(`project must be an existing absolute path, got "${root}"`);
+    const { vouchReport } = await import('../engine/vouch/run-vouch.js');
+    return vouchReport(root, paths && paths.length > 0 ? paths : ['.']).report;
+}));
 await server.connect(new StdioServerTransport());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tewip-ai",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "description": "Tewip finds why each failing test failed - real bug, flaky test, environment, test data or changed selector - for any stack, from the command line, CI, or your editor.",
   "keywords": [
     "test-failures",