tewip-ai 0.33.0 → 0.34.0

package/README.md

@@ -1,6 +1,10 @@
 # Tewip
 
-**Tewip** (Uyghur *téwip*, تېۋىپ: healer, doctor) finds why each failing test failed: a real bug, a flaky test, the environment, test data, or a changed selector. Every answer comes with its confidence, its evidence and one next step, and names its source: a deterministic rule, the AI model, or a person's correction.
+**Tewip** (Uyghur *téwip*, تېۋىپ: healer, doctor) is the layer that **proves software work** - written by a person or by an agent.
+
+It finds why each failing test failed (a real bug, a flaky test, the environment, test data, or a changed selector), says whether a test could ever fail at all, breaks your code to find out whether the tests would notice, reads what a migration will do to a live database, and gives one verdict on whether a change is done. Every answer carries its evidence and names what decided it: a deterministic rule, the AI model, or a person's correction.
+
+What makes it worth installing is what it refuses to say. It answers *"cannot say"* rather than guessing, it will not narrow a test run it cannot prove safe to narrow, and every report ends with what it did **not** check. Each number below was measured on strangers' real code, never on fixtures.
 
 It works for every stack: Node.js (node:test, Jest, Vitest, Mocha), Python (pytest, unittest), Java and Kotlin (JUnit, TestNG), Go, .NET, Ruby, PHP and Rust, each checked against its real runner's report ([the full list](QUICKSTART.md#not-using-playwright-every-stack-works)), plus Playwright in depth with traces, selector drift and verified fixes. It also reads the failure wording of the browser and component-test tools on top of those runners (Selenium, WebdriverIO, Cypress, Testing Library for React, Vue and Angular, Vue Test Utils, jest-dom and Jasmine), checked against more than 500 real messages from public projects.
 
@@ -112,18 +116,20 @@ jobs:
 
 The report reads the history cache of the branch it runs on, usually the default branch.
 
-The repository needs "Allow GitHub Actions to create and approve pull requests" enabled for fix PRs. Pull requests opened by the workflow token don't trigger CI themselves; the agent verified each change by re-running the test before opening the PR. See [triage-agent-sandbox](https://github.com/hmamut39/triage-agent-sandbox) for a working example. If this repository is private, other repositories can only use the action when Settings → Actions → Access allows it.
+The repository needs "Allow GitHub Actions to create and approve pull requests" enabled for fix PRs. Pull requests opened by the workflow token don't trigger CI themselves; the agent verified each change by re-running the test before opening the PR. It was first proved end to end on a private practice repository, which is why there is no link to click here. If this repository is private, other repositories can only use the action when Settings → Actions → Access allows it.
 
 ### As a Claude Code plugin (no account, no marketplace approval)
 
 ```bash
-claude plugin marketplace add hmamut39/tewip
+claude plugin marketplace add hmamut39/tewip-plugin
 claude plugin install tewip@tewip
 ```
 
 That is the whole publication process. A marketplace is a `.claude-plugin/marketplace.json` file in a git
-repository, so Tewip ships one in its own repo - nobody has to approve it, and there is nothing to pay
-for. The plugin brings Tewip's MCP server and three skills that tell Claude Code *when* to use it:
+repository, so Tewip publishes one at
+[hmamut39/tewip-plugin](https://github.com/hmamut39/tewip-plugin) - nobody has to approve it, and there
+is nothing to pay for. That repository holds the plugin only: a manifest, three skills and a pointer to
+the npm package, which is why this one can stay private. The plugin brings Tewip's MCP server and three skills that tell Claude Code *when* to use it:
 before claiming a change is done, when a test fails, and when a change touches a migration. It costs
 about 410 tokens per session until a skill is actually needed.
 
@@ -817,7 +823,7 @@ With `--act` it carries the decision out, and this is where the refusals matter
 
 | Project | How | Result |
 |---|---|---|
-| [triage-agent-sandbox](https://github.com/hmamut39/triage-agent-sandbox) (private practice repo) | Live GitHub Action on a release PR with 11 planted failures | Diagnosis comment, one environment issue, and a fix PR whose 5 locator changes pass when checked out. Traps left alone. Synthetic. |
+| A private practice repository (not linked: it is private) | Live GitHub Action on a release PR with 11 planted failures | Diagnosis comment, one environment issue, and a fix PR whose 5 locator changes pass when checked out. Traps left alone. Synthetic. |
 | WordPress Gutenberg (public) | Offline, from 5 windows of real CI blob reports, two of them harvested after the pipeline was frozen | 84–98% accuracy on 1,441 labelled real failures; the only project with enough drift cases to measure that category (see [eval/README.md](eval/README.md) for caveats) |
 | JupyterLab (public) | Offline, from its Galata UI suite | 90.2% on 41 labelled failures; the deterministic rules alone were right on 34 of 34 they decided |
 | LXD UI (public) | Offline, from its pull-request suite | 91.3% on 69 labelled failures; rules right on 63 of 63. All 6 misses are cross-branch flakes read as real bugs |

package/dist/cli/tewip.js

@@ -12,6 +12,7 @@ import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { flag } from './args.js';
 import { HELP } from './help.js';
+import { proveVerb } from './verbs-prove.js';
 import { workVerb } from './verbs-work.js';
 // cli/ in the source tree, dist/cli/ in the published package: package.json is one or two levels up.
 const ROOT = [join(import.meta.dirname, '..'), join(import.meta.dirname, '..', '..')].find((d) => existsSync(join(d, 'package.json'))) ?? join(import.meta.dirname, '..');
@@ -21,6 +22,9 @@ async function main() {
     // The verbs that reach into a tracker, a scan or a build live next door; the rest are here.
     if (await workVerb(verb, args))
         return;
+    // The verbs that prove a change live next door too.
+    if (await proveVerb(verb, args))
+        return;
     switch (verb) {
         case 'explain': {
             // The explain script reads its arguments from process.argv, as when it is run directly.
@@ -185,75 +189,6 @@ async function main() {
             runPursue({ root: process.cwd(), goal, act: args.includes('--act'), name: flag(args, 'name'), out: flag(args, 'out') });
             return;
         }
-        case 'done': {
-            const { runDone } = await import('../engine/verdict/verdict-command.js');
-            runDone({
-                root: process.cwd(),
-                diff: flag(args, 'diff') ?? 'main...HEAD',
-                prove: args.includes('--prove'),
-                proveBudgetSeconds: Number(flag(args, 'budget') ?? '300'),
-                out: flag(args, 'out'),
-                json: flag(args, 'json'),
-                name: flag(args, 'name'),
-                strict: args.includes('--strict'),
-            });
-            return;
-        }
-        case 'standards': {
-            const { runStandards } = await import('../engine/standards/standards-command.js');
-            runStandards({
-                root: process.cwd(),
-                diff: flag(args, 'diff'),
-                files: args.filter((a, i) => !a.startsWith('--') && args[i - 1] !== '--diff' && args[i - 1] !== '--out'),
-                out: flag(args, 'out'),
-                strict: args.includes('--strict'),
-            });
-            return;
-        }
-        case 'schema': {
-            const { runSchema } = await import('../engine/schema/schema-command.js');
-            runSchema({
-                root: process.cwd(),
-                diff: flag(args, 'diff') ?? 'main...HEAD',
-                files: args.filter((a, i) => !a.startsWith('--') && args[i - 1] !== '--diff' && args[i - 1] !== '--out'),
-                out: flag(args, 'out'),
-                strict: args.includes('--strict'),
-            });
-            return;
-        }
-        case 'pick': {
-            const { runPick } = await import('../engine/pick/pick-command.js');
-            runPick({
-                root: process.cwd(),
-                diff: flag(args, 'diff') ?? 'main...HEAD',
-                files: args.filter((a, i) => !a.startsWith('--') && args[i - 1] !== '--diff' && args[i - 1] !== '--out' && args[i - 1] !== '--recent' && args[i - 1] !== '--name'),
-                out: flag(args, 'out'),
-                list: args.includes('--list'),
-                recentRuns: Number(flag(args, 'recent') ?? '5'),
-                name: flag(args, 'name'),
-            });
-            return;
-        }
-        case 'prove': {
-            const paths = args.filter((a, i) => !a.startsWith('--') && !['--out', '--diff', '--limit', '--budget'].includes(args[i - 1] ?? ''));
-            const { runProve } = await import('../engine/prove/prove-command.js');
-            runProve({
-                root: process.cwd(),
-                files: paths,
-                diff: flag(args, 'diff'),
-                limit: Number(flag(args, 'limit') ?? '6'),
-                budgetSeconds: Number(flag(args, 'budget') ?? '600'),
-                out: flag(args, 'out'),
-                strict: args.includes('--strict'),
-            });
-            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/cli/verbs-prove.js

@@ -0,0 +1,82 @@
+// The verbs that prove a change rather than describe it: the verdict, the project's own standards,
+// what a migration does to a live database, which tests could notice a change, whether the tests would
+// catch a bug, and whether a test could ever fail. Split out of cli/tewip.ts the same way the work
+// verbs were, to keep every file inside this project's own 300-line rule.
+import { flag } from './args.js';
+/** Runs `verb` if it is one of these, and says whether it did. */
+export async function proveVerb(verb, args) {
+    switch (verb) {
+        case 'done': {
+            const { runDone } = await import('../engine/verdict/verdict-command.js');
+            runDone({
+                root: process.cwd(),
+                diff: flag(args, 'diff') ?? 'main...HEAD',
+                prove: args.includes('--prove'),
+                proveBudgetSeconds: Number(flag(args, 'budget') ?? '300'),
+                out: flag(args, 'out'),
+                json: flag(args, 'json'),
+                name: flag(args, 'name'),
+                strict: args.includes('--strict'),
+            });
+            return true;
+        }
+        case 'standards': {
+            const { runStandards } = await import('../engine/standards/standards-command.js');
+            runStandards({
+                root: process.cwd(),
+                diff: flag(args, 'diff'),
+                files: args.filter((a, i) => !a.startsWith('--') && args[i - 1] !== '--diff' && args[i - 1] !== '--out'),
+                out: flag(args, 'out'),
+                strict: args.includes('--strict'),
+            });
+            return true;
+        }
+        case 'schema': {
+            const { runSchema } = await import('../engine/schema/schema-command.js');
+            runSchema({
+                root: process.cwd(),
+                diff: flag(args, 'diff') ?? 'main...HEAD',
+                files: args.filter((a, i) => !a.startsWith('--') && args[i - 1] !== '--diff' && args[i - 1] !== '--out'),
+                out: flag(args, 'out'),
+                strict: args.includes('--strict'),
+            });
+            return true;
+        }
+        case 'pick': {
+            const { runPick } = await import('../engine/pick/pick-command.js');
+            runPick({
+                root: process.cwd(),
+                diff: flag(args, 'diff') ?? 'main...HEAD',
+                files: args.filter((a, i) => !a.startsWith('--') && args[i - 1] !== '--diff' && args[i - 1] !== '--out' && args[i - 1] !== '--recent' && args[i - 1] !== '--name'),
+                out: flag(args, 'out'),
+                list: args.includes('--list'),
+                recentRuns: Number(flag(args, 'recent') ?? '5'),
+                name: flag(args, 'name'),
+            });
+            return true;
+        }
+        case 'prove': {
+            const paths = args.filter((a, i) => !a.startsWith('--') && !['--out', '--diff', '--limit', '--budget'].includes(args[i - 1] ?? ''));
+            const { runProve } = await import('../engine/prove/prove-command.js');
+            runProve({
+                root: process.cwd(),
+                files: paths,
+                diff: flag(args, 'diff'),
+                limit: Number(flag(args, 'limit') ?? '6'),
+                budgetSeconds: Number(flag(args, 'budget') ?? '600'),
+                out: flag(args, 'out'),
+                strict: args.includes('--strict'),
+            });
+            return true;
+        }
+        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 true;
+        }
+        default:
+            return false;
+    }
+    return true;
+}

package/dist/engine/import/case.js

@@ -0,0 +1,16 @@
+/** A passing attempt: the same object every time, since it carries nothing.
+ */
+export const PASSED = { failed: false, message: '', stack: '' };
+/** One failed attempt, read out of whatever the runner wrote. */
+export function failure(rawMessage, rawDetail) {
+    // Terminal colour codes: XML cannot hold the escape character, so runners often write what is left
+    // of them ("[2mexpect([22m"); both forms are noise to the rules.
+    const plain = (s) => s.replace(/\u001b?\[(?:\d{1,3};)*\d{1,3}m/g, '');
+    const message = plain(rawMessage);
+    const detail = plain(rawDetail);
+    const head = message.trim() || detail.split('\n').find((l) => l.trim() !== '') || 'failed';
+    const stack = detail.trim();
+    // The full detail goes into the message too: outside Playwright the useful part (the assertion,
+    // the exception) is usually in the detail, and the rules read the message.
+    return { failed: true, message: stack && !stack.includes(head) ? `${head}\n${stack}` : stack || head, stack };
+}

package/dist/engine/import/dotnet.js

@@ -0,0 +1,58 @@
+// The .NET report formats: Visual Studio's own TRX, and NUnit 3's XML.
+//
+// Both say the same things as a JUnit report in different words, so they are read into the same `Case`
+// shape and the rest of the pipeline never learns the difference. Split out of junit.ts to keep that
+// file inside this project's 300-line rule; nothing else changed.
+import { PASSED, failure } from './case.js';
+import { descendants } from './xml.js';
+/** "00:00:01.2340000" -> 1234 ms. */
+const trxDuration = (d) => {
+    const m = d?.match(/^(\d+):(\d+):(\d+(?:\.\d+)?)$/);
+    return m ? Math.round(((Number(m[1]) * 60 + Number(m[2])) * 60 + Number(m[3])) * 1000) : 0;
+};
+/** .NET's native TRX report (dotnet test --logger trx). */
+export function trxCases(root) {
+    const methods = new Map();
+    for (const unit of descendants(root, 'UnitTest')) {
+        const method = unit.children.find((c) => c.name === 'TestMethod');
+        if (unit.attrs.id && method)
+            methods.set(unit.attrs.id, { className: method.attrs.className ?? '', name: method.attrs.name ?? '' });
+    }
+    return descendants(root, 'UnitTestResult')
+        .filter((r) => r.attrs.outcome !== 'NotExecuted')
+        .map((r) => {
+        const method = methods.get(r.attrs.testId ?? '');
+        const testId = method?.className ? `${method.className} > ${method.name}` : (r.attrs.testName ?? '').trim();
+        const info = descendants(r, 'ErrorInfo')[0];
+        const text = (name) => info?.children.find((c) => c.name === name)?.text ?? '';
+        const failed = r.attrs.outcome === 'Failed' || r.attrs.outcome === 'Error' || r.attrs.outcome === 'Timeout';
+        return {
+            testId,
+            file: method?.className ?? testId,
+            duration: trxDuration(r.attrs.duration),
+            attempts: [failed ? failure(text('Message'), text('StackTrace')) : PASSED],
+        };
+    });
+}
+/**
+ * NUnit 3's own result file (`nunit3-console --result=x.xml`), whose root is <test-run>. NUnit does
+ * not write JUnit XML at all - its console offers only the nunit3 and nunit2 formats - so a .NET
+ * team on NUnit has nothing else to hand Tewip.
+ */
+export function nunitCases(root) {
+    return descendants(root, 'test-case')
+        .filter((t) => t.attrs.result !== 'Skipped' && t.attrs.result !== 'Inconclusive')
+        .map((t) => {
+        const failureEl = t.children.find((c) => c.name === 'failure');
+        const child = (parent, name) => parent?.children.find((c) => c.name === name)?.text ?? '';
+        const testId = (t.attrs.fullname ?? '').trim() || [t.attrs.classname, t.attrs.methodname ?? t.attrs.name].filter(Boolean).join(' > ');
+        const seconds = Number(t.attrs.duration);
+        return {
+            testId,
+            file: (t.attrs.classname ?? '').trim(),
+            duration: Number.isFinite(seconds) ? Math.round(seconds * 1000) : 0,
+            attempts: [t.attrs.result === 'Failed' ? failure(child(failureEl, 'message'), child(failureEl, 'stack-trace')) : PASSED],
+        };
+    });
+}
+// .jtl is JMeter's, and a k6 summary is JSON; both are read below.

package/dist/engine/import/junit.js

@@ -14,23 +14,12 @@ import { join } from 'node:path';
 import { SCHEMA_VERSION } from '../../reporters/types.js';
 import { descendants, parseXml } from './xml.js';
 import { jmeterCases, k6Cases, looksLikeK6, robotCases, robotTime } from './other-formats.js';
-const PASSED = { failed: false, message: '', stack: '' };
+import { nunitCases, trxCases } from './dotnet.js';
+import { PASSED, failure } from './case.js';
 const FAILURE = new Set(['failure', 'error']);
 /** Maven Surefire's records of earlier attempts: flaky* when a later one passed, rerun* when not. */
 const RETRY_FAILURE = new Set(['flakyFailure', 'flakyError', 'rerunFailure', 'rerunError']);
 /** A failure's message and detail; runners disagree on which of the two holds what. */
-function failure(rawMessage, rawDetail) {
-    // Terminal colour codes: XML cannot hold the escape character, so runners often write what is left
-    // of them ("[2mexpect([22m"); both forms are noise to the rules.
-    const plain = (s) => s.replace(/\u001b?\[(?:\d{1,3};)*\d{1,3}m/g, '');
-    const message = plain(rawMessage);
-    const detail = plain(rawDetail);
-    const head = message.trim() || detail.split('\n').find((l) => l.trim() !== '') || 'failed';
-    const stack = detail.trim();
-    // The full detail goes into the message too: outside Playwright the useful part (the assertion,
-    // the exception) is usually in the detail, and the rules read the message.
-    return { failed: true, message: stack && !stack.includes(head) ? `${head}\n${stack}` : stack || head, stack };
-}
 const fromElement = (e) => failure(e.attrs.message ?? e.attrs.type ?? '', e.children.find((c) => c.name === 'stackTrace')?.text ?? e.text);
 /** The attempts one <testcase> records: earlier failed retries first, then the final outcome. */
 function attemptsOf(testcase) {
@@ -130,57 +119,6 @@ function junitCases(root, workspace) {
     }
     return out;
 }
-/** "00:00:01.2340000" -> 1234 ms. */
-const trxDuration = (d) => {
-    const m = d?.match(/^(\d+):(\d+):(\d+(?:\.\d+)?)$/);
-    return m ? Math.round(((Number(m[1]) * 60 + Number(m[2])) * 60 + Number(m[3])) * 1000) : 0;
-};
-/** .NET's native TRX report (dotnet test --logger trx). */
-function trxCases(root) {
-    const methods = new Map();
-    for (const unit of descendants(root, 'UnitTest')) {
-        const method = unit.children.find((c) => c.name === 'TestMethod');
-        if (unit.attrs.id && method)
-            methods.set(unit.attrs.id, { className: method.attrs.className ?? '', name: method.attrs.name ?? '' });
-    }
-    return descendants(root, 'UnitTestResult')
-        .filter((r) => r.attrs.outcome !== 'NotExecuted')
-        .map((r) => {
-        const method = methods.get(r.attrs.testId ?? '');
-        const testId = method?.className ? `${method.className} > ${method.name}` : (r.attrs.testName ?? '').trim();
-        const info = descendants(r, 'ErrorInfo')[0];
-        const text = (name) => info?.children.find((c) => c.name === name)?.text ?? '';
-        const failed = r.attrs.outcome === 'Failed' || r.attrs.outcome === 'Error' || r.attrs.outcome === 'Timeout';
-        return {
-            testId,
-            file: method?.className ?? testId,
-            duration: trxDuration(r.attrs.duration),
-            attempts: [failed ? failure(text('Message'), text('StackTrace')) : PASSED],
-        };
-    });
-}
-/**
- * NUnit 3's own result file (`nunit3-console --result=x.xml`), whose root is <test-run>. NUnit does
- * not write JUnit XML at all - its console offers only the nunit3 and nunit2 formats - so a .NET
- * team on NUnit has nothing else to hand Tewip.
- */
-function nunitCases(root) {
-    return descendants(root, 'test-case')
-        .filter((t) => t.attrs.result !== 'Skipped' && t.attrs.result !== 'Inconclusive')
-        .map((t) => {
-        const failureEl = t.children.find((c) => c.name === 'failure');
-        const child = (parent, name) => parent?.children.find((c) => c.name === name)?.text ?? '';
-        const testId = (t.attrs.fullname ?? '').trim() || [t.attrs.classname, t.attrs.methodname ?? t.attrs.name].filter(Boolean).join(' > ');
-        const seconds = Number(t.attrs.duration);
-        return {
-            testId,
-            file: (t.attrs.classname ?? '').trim(),
-            duration: Number.isFinite(seconds) ? Math.round(seconds * 1000) : 0,
-            attempts: [t.attrs.result === 'Failed' ? failure(child(failureEl, 'message'), child(failureEl, 'stack-trace')) : PASSED],
-        };
-    });
-}
-// .jtl is JMeter's, and a k6 summary is JSON; both are read below.
 const REPORT_FILE = /\.(xml|trx|jtl|json)$/i;
 /** Report files under `path` (a file, or a directory searched recursively). */
 export function junitFiles(path) {

package/dist/mcp/server.js

@@ -5,6 +5,7 @@
 // Read-only by design, except test_plan, which saves the plan it returns in the project's .tewip
 // folder: no tool changes code, CI, GitHub or collected data.
 // Run: node mcp/server.ts (stdio). Setup for each client is in README.md.
+import { registerProofTools } from './tools-prove.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { existsSync } from 'node:fs';
@@ -137,115 +138,5 @@ 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;
-}));
-server.registerTool('prove_tests_catch_bugs', {
-    title: 'Would the tests catch a bug here?',
-    description: "Breaks one source file in small, deliberate ways - a boundary moved by one, a condition inverted, an and that became an or, a returned flag flipped - runs the tests that reach that file, and reports every change none of them noticed. This is execution, not opinion: the line was covered, it just was not checked. Slow by nature (each change means a real test run, so expect minutes) and it needs a unit test framework. The file is always put back exactly as it was, and if the tests turn out not to load the file at all it says so instead of reporting false holes. Use it after writing or changing code, to find out whether the tests you are relying on would have stopped a mistake.",
-    inputSchema: {
-        project,
-        file: z.string().describe('One source file, relative to the project, e.g. src/pricing.js'),
-        limit: z.number().optional().describe('How many changes to try (default 6). More is a better answer and a longer wait.'),
-        budgetSeconds: z.number().optional().describe('Total seconds to spend before stopping and saying how many were left (default 600)'),
-    },
-    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-}, ({ project: root, file, limit, budgetSeconds }) => answer(async () => {
-    if (!isAbsolute(root) || !existsSync(root))
-        throw new Error(`project must be an existing absolute path, got "${root}"`);
-    // runProve prints its report; over MCP the report is the return value and printing would corrupt
-    // the protocol, so the pieces are called directly.
-    const { proveOne } = await import('../engine/prove/prove-command.js');
-    return proveOne(root, file, { limit, budgetSeconds });
-}));
-server.registerTool('is_the_work_done', {
-    title: 'Is this work actually done?',
-    description: "One verdict on a change, from the layers that each have their own measured accuracy: is anything failing, is the changed code tested by something that really reaches it, can the tests in the change fail at all, would they catch a bug (only when prove is asked for, because that costs minutes), and is what was asked for covered. Answers ready, not ready, or cannot say - and cannot say is never rounded up to ready. Use it before claiming a piece of work is finished, including your own: a green test run is not the same as work that is done.",
-    inputSchema: {
-        project,
-        diff: z.string().optional().describe('A git range, e.g. main...HEAD (the default)'),
-        prove: z.boolean().optional().describe('Also break the changed code and run the tests against it. Costs minutes.'),
-    },
-    annotations: readOnly,
-}, ({ project: root, diff, prove }) => answer(async () => {
-    if (!isAbsolute(root) || !existsSync(root))
-        throw new Error(`project must be an existing absolute path, got "${root}"`);
-    // gather/decide/render are pure; runDone prints, which would corrupt the protocol.
-    const { gather } = await import('../engine/verdict/verdict-command.js');
-    const { decide, renderDecision } = await import('../engine/verdict/verdict.js');
-    const range = diff ?? 'main...HEAD';
-    const gathered = gather({ root, diff: range, prove });
-    if (!gathered)
-        return `Nothing changed in ${range}, or that range could not be read here.`;
-    return renderDecision(range, decide(gathered.evidence));
-}));
-server.registerTool('which_tests_to_run', {
-    title: 'Which tests could notice this change?',
-    description: "Narrows a test run to the tests that could notice a change, from facts in the source rather than a prediction: a test runs when it imports a changed file, reaches one through another module, is itself edited by the change, reads the repository at run time, or has failed recently. It refuses to narrow at all - and says why - when the change touches dependencies, build or test configuration, shared setup or fixtures, when the suite drives a browser, or when a changed file cannot be traced to any test. Use it to run the right tests quickly; what it leaves out, it leaves out for a stated reason.",
-    inputSchema: {
-        project,
-        diff: z.string().optional().describe('A git range, e.g. main...HEAD (the default)'),
-        files: z.array(z.string()).optional().describe('The changed files, when they do not come from a git range'),
-    },
-    annotations: readOnly,
-}, ({ project: root, diff, files }) => answer(async () => {
-    if (!isAbsolute(root) || !existsSync(root))
-        throw new Error(`project must be an existing absolute path, got "${root}"`);
-    // choose/renderPick are pure; runPick prints, which would corrupt the protocol.
-    const { choose } = await import('../engine/pick/pick-command.js');
-    const { renderPick } = await import('../engine/pick/pick.js');
-    const range = diff ?? 'main...HEAD';
-    const chosen = choose({ root, diff: range, files });
-    if (!chosen)
-        return `Nothing changed in ${range}, or that range could not be read here.`;
-    return renderPick(chosen.picked, chosen.total, chosen.command, chosen.noHistory);
-}));
-server.registerTool('what_will_this_migration_do', {
-    title: 'What will this migration do to a live database?',
-    description: "Reads the migrations in a change and names what will happen when they run against a live database: a column dropped while the version still running keeps selecting it, a table dropped, an index built under a lock that blocks writes, a NOT NULL added to a populated table, a type change that rewrites it, a foreign key validated against every row, a data migration holding a transaction open, a step that cannot be undone. It also searches the repository for code that still uses the column being taken away. Reads SQL, Django, Rails and Alembic, judges only the forward path, and says plainly when it cannot read a migration. It does not know your table sizes, so it says what a statement does rather than how long it will take.",
-    inputSchema: {
-        project,
-        diff: z.string().optional().describe('A git range, e.g. main...HEAD (the default)'),
-        files: z.array(z.string()).optional().describe('Migration files to read, when they do not come from a git range'),
-    },
-    annotations: readOnly,
-}, ({ project: root, diff, files }) => answer(async () => {
-    if (!isAbsolute(root) || !existsSync(root))
-        throw new Error(`project must be an existing absolute path, got "${root}"`);
-    const { readMigration, renderSchema, schemaFiles, stillUsed } = await import('../engine/schema/schema-command.js');
-    const cmd = { root, diff: diff ?? 'main...HEAD', files };
-    const migrations = schemaFiles(cmd).map((file) => readMigration(root, file));
-    if (migrations.length === 0)
-        return 'No migration or schema file in that change.';
-    return renderSchema(migrations, stillUsed(root, migrations.flatMap((m) => m.findings)));
-}));
-server.registerTool('project_standards', {
-    title: "What are this project's own rules?",
-    description: "The house rules this team has written down in .tewip/standards/, and whether a change keeps them. Returns two things kept carefully apart: rules Tewip checks and enforces (a forbid or require pattern over a set of files), and guidance it can only carry - prose for the parts no pattern captures, which is passed on when something is written but never reported as verified. Use it before writing or changing code in somebody's project, so what you produce matches their conventions rather than yours.",
-    inputSchema: {
-        project,
-        files: z.array(z.string()).optional().describe('Files to check against the rules. Omit to list what the project has written.'),
-        diff: z.string().optional().describe('A git range whose changed files should be checked instead'),
-    },
-    annotations: readOnly,
-}, ({ project: root, files, diff }) => answer(async () => {
-    if (!isAbsolute(root) || !existsSync(root))
-        throw new Error(`project must be an existing absolute path, got "${root}"`);
-    const { checkChanged, loadStandards, renderStandards } = await import('../engine/standards/standards-command.js');
-    const { changeSummary } = await import('../engine/quality/grounding.js');
-    const standards = loadStandards(root);
-    const changed = files && files.length > 0 ? files : diff ? (changeSummary(root, diff)?.files ?? []) : [];
-    return renderStandards(standards, changed.length > 0 ? checkChanged(root, standards, changed) : [], changed.length);
-}));
+registerProofTools(server, { answer, readOnly, project });
 await server.connect(new StdioServerTransport());

package/dist/mcp/tools-prove.js

@@ -0,0 +1,116 @@
+import { existsSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
+import { z } from 'zod';
+export function registerProofTools(server, { answer, readOnly, project }) {
+    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;
+    }));
+    server.registerTool('prove_tests_catch_bugs', {
+        title: 'Would the tests catch a bug here?',
+        description: "Breaks one source file in small, deliberate ways - a boundary moved by one, a condition inverted, an and that became an or, a returned flag flipped - runs the tests that reach that file, and reports every change none of them noticed. This is execution, not opinion: the line was covered, it just was not checked. Slow by nature (each change means a real test run, so expect minutes) and it needs a unit test framework. The file is always put back exactly as it was, and if the tests turn out not to load the file at all it says so instead of reporting false holes. Use it after writing or changing code, to find out whether the tests you are relying on would have stopped a mistake.",
+        inputSchema: {
+            project,
+            file: z.string().describe('One source file, relative to the project, e.g. src/pricing.js'),
+            limit: z.number().optional().describe('How many changes to try (default 6). More is a better answer and a longer wait.'),
+            budgetSeconds: z.number().optional().describe('Total seconds to spend before stopping and saying how many were left (default 600)'),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    }, ({ project: root, file, limit, budgetSeconds }) => answer(async () => {
+        if (!isAbsolute(root) || !existsSync(root))
+            throw new Error(`project must be an existing absolute path, got "${root}"`);
+        // runProve prints its report; over MCP the report is the return value and printing would corrupt
+        // the protocol, so the pieces are called directly.
+        const { proveOne } = await import('../engine/prove/prove-command.js');
+        return proveOne(root, file, { limit, budgetSeconds });
+    }));
+    server.registerTool('is_the_work_done', {
+        title: 'Is this work actually done?',
+        description: "One verdict on a change, from the layers that each have their own measured accuracy: is anything failing, is the changed code tested by something that really reaches it, can the tests in the change fail at all, would they catch a bug (only when prove is asked for, because that costs minutes), and is what was asked for covered. Answers ready, not ready, or cannot say - and cannot say is never rounded up to ready. Use it before claiming a piece of work is finished, including your own: a green test run is not the same as work that is done.",
+        inputSchema: {
+            project,
+            diff: z.string().optional().describe('A git range, e.g. main...HEAD (the default)'),
+            prove: z.boolean().optional().describe('Also break the changed code and run the tests against it. Costs minutes.'),
+        },
+        annotations: readOnly,
+    }, ({ project: root, diff, prove }) => answer(async () => {
+        if (!isAbsolute(root) || !existsSync(root))
+            throw new Error(`project must be an existing absolute path, got "${root}"`);
+        // gather/decide/render are pure; runDone prints, which would corrupt the protocol.
+        const { gather } = await import('../engine/verdict/verdict-command.js');
+        const { decide, renderDecision } = await import('../engine/verdict/verdict.js');
+        const range = diff ?? 'main...HEAD';
+        const gathered = gather({ root, diff: range, prove });
+        if (!gathered)
+            return `Nothing changed in ${range}, or that range could not be read here.`;
+        return renderDecision(range, decide(gathered.evidence));
+    }));
+    server.registerTool('which_tests_to_run', {
+        title: 'Which tests could notice this change?',
+        description: "Narrows a test run to the tests that could notice a change, from facts in the source rather than a prediction: a test runs when it imports a changed file, reaches one through another module, is itself edited by the change, reads the repository at run time, or has failed recently. It refuses to narrow at all - and says why - when the change touches dependencies, build or test configuration, shared setup or fixtures, when the suite drives a browser, or when a changed file cannot be traced to any test. Use it to run the right tests quickly; what it leaves out, it leaves out for a stated reason.",
+        inputSchema: {
+            project,
+            diff: z.string().optional().describe('A git range, e.g. main...HEAD (the default)'),
+            files: z.array(z.string()).optional().describe('The changed files, when they do not come from a git range'),
+        },
+        annotations: readOnly,
+    }, ({ project: root, diff, files }) => answer(async () => {
+        if (!isAbsolute(root) || !existsSync(root))
+            throw new Error(`project must be an existing absolute path, got "${root}"`);
+        // choose/renderPick are pure; runPick prints, which would corrupt the protocol.
+        const { choose } = await import('../engine/pick/pick-command.js');
+        const { renderPick } = await import('../engine/pick/pick.js');
+        const range = diff ?? 'main...HEAD';
+        const chosen = choose({ root, diff: range, files });
+        if (!chosen)
+            return `Nothing changed in ${range}, or that range could not be read here.`;
+        return renderPick(chosen.picked, chosen.total, chosen.command, chosen.noHistory);
+    }));
+    server.registerTool('what_will_this_migration_do', {
+        title: 'What will this migration do to a live database?',
+        description: "Reads the migrations in a change and names what will happen when they run against a live database: a column dropped while the version still running keeps selecting it, a table dropped, an index built under a lock that blocks writes, a NOT NULL added to a populated table, a type change that rewrites it, a foreign key validated against every row, a data migration holding a transaction open, a step that cannot be undone. It also searches the repository for code that still uses the column being taken away. Reads SQL, Django, Rails and Alembic, judges only the forward path, and says plainly when it cannot read a migration. It does not know your table sizes, so it says what a statement does rather than how long it will take.",
+        inputSchema: {
+            project,
+            diff: z.string().optional().describe('A git range, e.g. main...HEAD (the default)'),
+            files: z.array(z.string()).optional().describe('Migration files to read, when they do not come from a git range'),
+        },
+        annotations: readOnly,
+    }, ({ project: root, diff, files }) => answer(async () => {
+        if (!isAbsolute(root) || !existsSync(root))
+            throw new Error(`project must be an existing absolute path, got "${root}"`);
+        const { readMigration, renderSchema, schemaFiles, stillUsed } = await import('../engine/schema/schema-command.js');
+        const cmd = { root, diff: diff ?? 'main...HEAD', files };
+        const migrations = schemaFiles(cmd).map((file) => readMigration(root, file));
+        if (migrations.length === 0)
+            return 'No migration or schema file in that change.';
+        return renderSchema(migrations, stillUsed(root, migrations.flatMap((m) => m.findings)));
+    }));
+    server.registerTool('project_standards', {
+        title: "What are this project's own rules?",
+        description: "The house rules this team has written down in .tewip/standards/, and whether a change keeps them. Returns two things kept carefully apart: rules Tewip checks and enforces (a forbid or require pattern over a set of files), and guidance it can only carry - prose for the parts no pattern captures, which is passed on when something is written but never reported as verified. Use it before writing or changing code in somebody's project, so what you produce matches their conventions rather than yours.",
+        inputSchema: {
+            project,
+            files: z.array(z.string()).optional().describe('Files to check against the rules. Omit to list what the project has written.'),
+            diff: z.string().optional().describe('A git range whose changed files should be checked instead'),
+        },
+        annotations: readOnly,
+    }, ({ project: root, files, diff }) => answer(async () => {
+        if (!isAbsolute(root) || !existsSync(root))
+            throw new Error(`project must be an existing absolute path, got "${root}"`);
+        const { checkChanged, loadStandards, renderStandards } = await import('../engine/standards/standards-command.js');
+        const { changeSummary } = await import('../engine/quality/grounding.js');
+        const standards = loadStandards(root);
+        const changed = files && files.length > 0 ? files : diff ? (changeSummary(root, diff)?.files ?? []) : [];
+        return renderStandards(standards, changed.length > 0 ? checkChanged(root, standards, changed) : [], changed.length);
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tewip-ai",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "mcpName": "io.github.hmamut39/tewip",
   "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": [
@@ -78,5 +78,5 @@
   "bugs": {
     "url": "https://github.com/hmamut39/tewip/issues"
   },
-  "author": "Hasan Mamut"
+  "author": "Mamuti Aishan (Hasan)"
 }