tewip-ai 0.25.0 → 0.26.0

package/README.md

@@ -496,6 +496,41 @@ Joins the test plans Tewip wrote to the tests that cover them and the runs that
 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

package/dist/cli/help.js

@@ -110,6 +110,14 @@ Usage:
                                     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/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.25.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",