tewip-ai 0.31.0 → 0.32.0

package/README.md

@@ -552,6 +552,43 @@ With `--json` the verdict is **sealed**: editing `not-ready` to `ready` in the f
 fail, so a verdict that travels into a ticket or a release note can be checked rather than trusted. It is
 also an MCP tool, so an agent can ask whether its own work is done before saying that it is.
 
+## Teach it your house rules (Phase 27)
+
+```bash
+tewip standards                        # what this project has taught Tewip
+tewip standards --diff main...HEAD --strict
+```
+
+Tewip knows a lot that is true of software in general and nothing that is true of *your company*. Every
+IT department has its own rules — "never drop a column in the release that stops writing to it",
+"locators use data-testid", "no test may sleep" — and a tool that cannot be taught them is a tool that
+argues with the house.
+
+A standard is a markdown file in `.tewip/standards/`:
+
+```markdown
+---
+description: A fixed wait hides a race instead of fixing it.
+applies-to: tests/, e2e/
+forbid: /waitForTimeout|sleep\(/ because a fixed wait passes by luck and fails in CI
+---
+
+Wait for the thing you are actually waiting for — an element, a response, a state —
+never for a number of milliseconds.
+```
+
+**The split is the point.** The `forbid` and `require` lines are checked and enforced, with the offending
+line quoted and your own reason printed beside it. The prose below is **guidance**: Tewip carries it into
+whatever it writes or fixes, and quotes it in reports — but it is never counted as checked and never
+reported as kept. A team that believes an unenforceable rule is being enforced is worse off than a team
+with no tool at all, because they have stopped watching for it themselves. A rule Tewip cannot parse is
+reported as unusable rather than silently dropped.
+
+Once written, the rules appear everywhere the work is judged: in `tewip review`, in the pull request
+comment, and as a question in `tewip done` — *"Does it keep this project's own standards?"* — which
+answers **no** and names the rule. The guidance goes into the prompt when `tewip write` drafts a test, so
+what comes back is in your conventions rather than Tewip's.
+
 ## What will this migration do to a live database? (Phase 26)
 
 ```bash

package/dist/cli/help.js

@@ -118,6 +118,13 @@ Usage:
                                     is what was asked for covered. Answers ready, not ready, or cannot
                                     say - and cannot say is never rounded up to ready. --json writes a
                                     sealed verdict that can be checked later. No model, no cost.
+  tewip standards [--diff main...HEAD] [--strict] [--out standards.md]
+                                    Teach Tewip your house rules. Markdown files in
+                                    .tewip/standards/ - a forbid or require line is checked and
+                                    enforced on the files a change touches; the prose below it is
+                                    guidance Tewip carries into whatever it writes or fixes. It never
+                                    reports guidance as verified, because a rule nobody enforces is
+                                    worse than no rule. No model, no cost.
   tewip schema [<files>] [--diff main...HEAD] [--strict] [--out schema.md]
                                     What will this migration do to a live database? Names the changes
                                     that break the version still running during a deploy, destroy data,

package/dist/cli/tewip.js

@@ -199,6 +199,17 @@ async function main() {
             });
             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({

package/dist/engine/quality/write-command.js

@@ -1,6 +1,7 @@
 // `tewip write`: turn a plan's "to automate next" scenarios into tests in the project's own
 // framework. Kept tests stay beside the project's tests for the team to review and commit; every
 // other draft is moved to .tewip/drafts with the reason, and nothing is committed or pushed.
+import { guidanceFor, loadStandards } from '../standards/standards-command.js';
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, extname, join, relative } from 'node:path';
 import { noModelHelp } from '../llm/providers.js';
@@ -76,7 +77,7 @@ ${noModelHelp()}`);
         process.once('SIGINT', leaveNothing).once('SIGTERM', leaveNothing);
         let outcome;
         try {
-            ({ outcome } = await writeAndVerify(model, { framework, fileName, pages, feature: saved.feature, code }, scenario, file, { runs: cmd.runs, repairs: cmd.repairs, mutateSource: cmd.mutateSource, log: (l) => console.error(l) }));
+            ({ outcome } = await writeAndVerify(model, { framework, fileName, pages, feature: saved.feature, code, houseRules: guidanceFor(loadStandards(cmd.root), fileName) }, scenario, file, { runs: cmd.runs, repairs: cmd.repairs, mutateSource: cmd.mutateSource, log: (l) => console.error(l) }));
         }
         catch (error) {
             outcome = { kind: 'rejected', reason: `stopped: ${error.message}`, repairs: 0, passedReliably: false };

package/dist/engine/quality/write.js

@@ -7,6 +7,7 @@ import { readFileSync } from 'node:fs';
 export const WRITE_PROMPT_VERSION = 'write-6';
 const RULES = `Rules:
 - Write in the given framework and language, in the style of the example test: the same imports, helpers, and way of opening pages (if it uses a base URL with relative paths, do the same).
+- When houseRules is given, it is this team's own written guidance. Follow it as you would the example test; where it conflicts with your habits, the team wins.
 - Find elements only by what the accessibility snapshots show: role and accessible name, label, placeholder or visible text. Never invent ids, classes or test ids that no snapshot shows.
 - Check the scenario's expected result specifically. A check that is always true (a page merely loads, a list merely exists) is not a test.
 - Wait for conditions, never for fixed times.
@@ -42,6 +43,7 @@ function contextFor(ctx, scenario) {
         exampleTest: example,
         pages: ctx.pages.map((p) => ({ readAt: p.url, title: p.title, accessibilitySnapshot: p.aria })),
         codeUnderTest: ctx.code?.length ? ctx.code : undefined,
+        houseRules: ctx.houseRules || undefined,
     };
 }
 export async function draftTest(model, ctx, scenario) {

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

@@ -9,6 +9,8 @@ import { renderReview, reviewChange } from './review.js';
 import { changedExpectations } from './expectations.js';
 import { changedAgreements } from './agreements.js';
 import { changedTestLines, vouchChanged } from '../vouch/changed.js';
+import { checkChanged, loadStandards } from '../standards/standards-command.js';
+import { renderViolations } from '../standards/standards.js';
 /** Every failure Tewip has diagnosed in this project, from the history it keeps. */
 function history(root, only) {
     const dir = join(root, '.tewip', 'history');
@@ -37,7 +39,10 @@ export async function runReview(cmd) {
     // Whether the tests in this change could ever fail. Costs nothing, calls no model, and is the one
     // question an agent-written diff most needs asked of it.
     const vouched = changedTestLines(vouchChanged(cmd.root, files));
-    const report = [renderReview(review, runCommand), ...(vouched.length > 0 ? ['', ...vouched] : [])].join(String.fromCharCode(10));
+    // The project's own rules, which Tewip only knows because this team wrote them down.
+    const standards = loadStandards(cmd.root);
+    const broken = renderViolations(checkChanged(cmd.root, standards, files), standards);
+    const report = [renderReview(review, runCommand), ...(vouched.length > 0 ? ['', ...vouched] : []), ...(broken.length > 0 ? ['', ...broken] : [])].join(String.fromCharCode(10));
     console.log(report);
     if (past.length === 0) {
         console.log('\nNo failure history yet, so the "what has gone wrong here before" part is empty. It fills itself: run `tewip explain` or `tewip report` on your CI reports and every later review knows more.');

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

@@ -0,0 +1,126 @@
+// `tewip standards`: what this project has taught Tewip, and what of it can actually be checked.
+//
+// Loading is on demand and cheap: only the name and description of each standard are read until
+// something needs the rest, which is the same discipline a skill file uses. The report leads with the
+// split that matters - rules Tewip enforces, and guidance it can only carry - because a team that
+// believes an unenforceable rule is being enforced is worse off than a team with no tool at all.
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { changeSummary } from '../quality/grounding.js';
+import { check, readStandard, renderViolations } from './standards.js';
+export const STANDARDS_DIR = join('.tewip', 'standards');
+/** Every standard this project has written, newest name order, with unreadable ones reported. */
+export function loadStandards(root) {
+    const dir = join(root, STANDARDS_DIR);
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const entry of readdirSync(dir).filter((f) => /\.(md|markdown)$/i.test(f)).sort()) {
+        try {
+            out.push(readStandard(entry, readFileSync(join(dir, entry), 'utf8')));
+        }
+        catch {
+            out.push({ name: entry, description: '', appliesTo: [], rules: [], guidance: '', unusable: 'the file could not be read' });
+        }
+    }
+    return out;
+}
+/**
+ * The guidance to hand a model when writing or fixing something in this file.
+ *
+ * Only the standards that apply, and only their prose: the checkable rules are enforced afterwards by
+ * `check`, so repeating them in a prompt would be asking politely for something that is about to be
+ * verified anyway.
+ */
+export function guidanceFor(standards, file) {
+    const relevant = standards.filter((s) => s.guidance.trim() && covers(s.appliesTo, file));
+    if (relevant.length === 0)
+        return '';
+    return relevant.map((s) => `## ${s.name}${s.description ? ` - ${s.description}` : ''}${String.fromCharCode(10)}${s.guidance.trim()}`).join(String.fromCharCode(10) + String.fromCharCode(10)).slice(0, 6000);
+}
+const covers = (where, file) => where.length === 0 || where.some((p) => file.split('\\').join('/').includes(p.replace(/^\*\*?\//, '').replace(/\*/g, '')));
+/** Violations in the files a change touched. */
+export function checkChanged(root, standards, files) {
+    const out = [];
+    for (const file of files) {
+        const full = resolve(root, file);
+        if (!existsSync(full))
+            continue;
+        try {
+            out.push(...check(standards, file.split('\\').join('/'), readFileSync(full, 'utf8')));
+        }
+        catch {
+            // Unreadable: nothing can be said about it.
+        }
+    }
+    return out;
+}
+export function renderStandards(standards, violations, checkedFiles) {
+    if (standards.length === 0) {
+        return [
+            '# This project has taught Tewip nothing yet',
+            '',
+            `Put a markdown file in \`${STANDARDS_DIR.split('\\').join('/')}/\` and Tewip will read it. For example, \`no-fixed-waits.md\`:`,
+            '',
+            '```markdown',
+            '---',
+            'description: A fixed wait hides a race instead of fixing it.',
+            'applies-to: tests/, e2e/',
+            'forbid: /waitForTimeout|sleep\\(/ because a fixed wait passes by luck and fails in CI',
+            '---',
+            '',
+            'Wait for the thing you are actually waiting for - an element, a response, a state -',
+            'never for a number of milliseconds.',
+            '```',
+            '',
+            'The `forbid` and `require` lines are checked and enforced. The prose below them is guidance: Tewip',
+            'passes it on when it writes or fixes something, and never claims to have verified it.',
+        ].join(String.fromCharCode(10));
+    }
+    const checkable = standards.filter((s) => s.rules.length > 0);
+    const guidanceOnly = standards.filter((s) => s.rules.length === 0 && s.guidance.trim());
+    const lines = [
+        '# What this project has taught Tewip',
+        '',
+        `${standards.length} standard(s) loaded: ${checkable.length} with rules Tewip can check, ${guidanceOnly.length} guidance only.`,
+        ...(checkedFiles > 0 ? ['', `${checkedFiles} changed file(s) checked. **${violations.length}** broke a rule.`] : []),
+        '',
+        '## Checked and enforced',
+        '',
+    ];
+    if (checkable.length === 0)
+        lines.push('None. No standard here carries a `forbid:` or `require:` rule, so nothing is enforced.', '');
+    for (const standard of checkable) {
+        lines.push(`- **${standard.name}**${standard.description ? ` — ${standard.description}` : ''}`);
+        for (const rule of standard.rules) {
+            lines.push(`  - ${rule.kind} \`${rule.pattern}\`${rule.where.length > 0 ? ` in ${rule.where.join(', ')}` : ''}${rule.because ? ` — ${rule.because}` : ''}`);
+        }
+    }
+    lines.push('');
+    if (guidanceOnly.length > 0) {
+        lines.push('## Carried, but not checked', '', 'Tewip passes these to the model when it writes or fixes something, and quotes them in reports. It', 'cannot verify them, and it will never report them as kept.', '', ...guidanceOnly.map((s) => `- **${s.name}**${s.description ? ` — ${s.description}` : ''}`), '');
+    }
+    const unusable = standards.filter((s) => s.unusable);
+    if (unusable.length > 0) {
+        lines.push(`## Could not be used (${unusable.length})`, '', ...unusable.map((s) => `- **${s.name}**: ${s.unusable}`), '');
+    }
+    lines.push(...renderViolations(violations, standards));
+    lines.push('---', '', 'A rule is enforced only if it appears above under "checked and enforced". Everything else is prose', 'Tewip carries for you - useful, and not the same thing as a check.');
+    return lines.join(String.fromCharCode(10));
+}
+export function runStandards(cmd) {
+    const standards = loadStandards(cmd.root);
+    const files = cmd.files && cmd.files.length > 0 ? cmd.files : cmd.diff ? (changeSummary(cmd.root, cmd.diff)?.files ?? []) : [];
+    const violations = files.length > 0 ? checkChanged(cmd.root, standards, files.map((f) => f.split('\\').join('/'))) : [];
+    const report = renderStandards(standards, violations, files.length);
+    console.log(report);
+    if (cmd.out) {
+        mkdirSync(dirname(resolve(cmd.out)), { recursive: true });
+        writeFileSync(resolve(cmd.out), report + String.fromCharCode(10), 'utf8');
+    }
+    if (cmd.strict && violations.length > 0) {
+        console.error(String.fromCharCode(10) + `${violations.length} violation(s) of this project's own standards.`);
+        process.exitCode = 1;
+    }
+    return { violations: violations.length };
+}

package/dist/engine/standards/standards.js

@@ -0,0 +1,140 @@
+/**
+ * Reads one standard.
+ *
+ * The format is deliberately plain: a markdown file with a small front matter block. A team should be
+ * able to write one without reading a manual, and anything Tewip cannot understand is reported as
+ * unusable rather than silently ignored - a rule nobody is enforcing is worse than no rule, because
+ * somebody believes in it.
+ */
+export function readStandard(file, text) {
+    const name = file.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? file;
+    const front = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+    const body = front ? text.slice(front[0].length).trim() : text.trim();
+    const standard = { name, description: '', appliesTo: [], rules: [], guidance: body, unusable: '' };
+    if (!front) {
+        // Prose only. That is allowed, and it is guidance - but say so, so nobody thinks it is enforced.
+        standard.description = firstLine(body);
+        return standard;
+    }
+    for (const line of front[1].split(String.fromCharCode(10))) {
+        const entry = /^\s*([a-z-]+)\s*:\s*(.*)$/i.exec(line);
+        if (!entry)
+            continue;
+        const [, key, rawValue] = entry;
+        const value = rawValue.trim();
+        if (key === 'name' && value)
+            standard.name = value;
+        else if (key === 'description')
+            standard.description = value;
+        else if (key === 'applies-to')
+            standard.appliesTo = list(value);
+        else if (key === 'forbid' || key === 'require') {
+            const rule = parseRule(key, value, standard.appliesTo);
+            if (rule)
+                standard.rules.push(rule);
+            else
+                standard.unusable = `the ${key} on this line could not be read: ${line.trim().slice(0, 120)}`;
+        }
+    }
+    if (!standard.description)
+        standard.description = firstLine(body);
+    return standard;
+}
+/** `forbid: /waitForTimeout/ in tests because a fixed wait hides a race` */
+function parseRule(kind, value, scope) {
+    const shape = /^\/(.+?)\/([a-z]*)\s*(?:\bin\s+([^]*?))?\s*(?:\bbecause\s+([^]*))?$/i.exec(value.trim());
+    if (!shape)
+        return null;
+    try {
+        new RegExp(shape[1], shape[2] || undefined); // it has to be a pattern before it is a rule
+    }
+    catch {
+        return null;
+    }
+    return {
+        kind,
+        pattern: shape[2] ? `/${shape[1]}/${shape[2]}` : shape[1],
+        where: shape[3] ? list(shape[3]) : scope,
+        because: (shape[4] ?? '').trim(),
+    };
+}
+const list = (value) => value
+    .replace(/^\[|\]$/g, '')
+    .split(/[,\s]+/)
+    .map((v) => v.trim().replace(/^["']|["']$/g, ''))
+    .filter(Boolean);
+const firstLine = (text) => text.split(String.fromCharCode(10)).map((l) => l.replace(/^#+\s*/, '').trim()).find(Boolean)?.slice(0, 160) ?? '';
+/** Does this file fall under that scope? A suffix, an extension, or a path fragment. */
+export function covers(where, file) {
+    if (where.length === 0)
+        return true;
+    const path = file.split('\\').join('/');
+    return where.some((pattern) => {
+        const clean = pattern.replace(/^\*\*?\//, '').replace(/\*/g, '');
+        return clean !== '' && path.includes(clean);
+    });
+}
+const regexOf = (rule) => {
+    const slashed = /^\/(.+)\/([a-z]*)$/.exec(rule.pattern);
+    return slashed ? new RegExp(slashed[1], slashed[2]) : new RegExp(rule.pattern);
+};
+/**
+ * The rules this file breaks.
+ *
+ * `forbid` is checked line by line, so the violation can be quoted. `require` is checked over the whole
+ * file, because "this file must mention X" is a statement about the file and pointing at a line would be
+ * inventing a location.
+ */
+export function check(standards, file, text) {
+    const out = [];
+    const lines = text.split(String.fromCharCode(10));
+    for (const standard of standards) {
+        if (!covers(standard.appliesTo, file))
+            continue;
+        for (const rule of standard.rules) {
+            if (!covers(rule.where, file))
+                continue;
+            let pattern;
+            try {
+                pattern = regexOf(rule);
+            }
+            catch {
+                continue;
+            }
+            if (rule.kind === 'forbid') {
+                lines.forEach((line, index) => {
+                    if (pattern.test(line))
+                        out.push({ standard: standard.name, file, line: index + 1, text: line.trim().slice(0, 160), rule });
+                });
+            }
+            else if (!pattern.test(text)) {
+                out.push({ standard: standard.name, file, line: 0, text: '', rule });
+            }
+        }
+    }
+    return out;
+}
+/** The section for a review, a pull request comment or a verdict. Empty when nothing is broken. */
+export function renderViolations(violations, loaded) {
+    if (violations.length === 0)
+        return [];
+    const lines = [`## Your own standards (${violations.length})`, ''];
+    for (const v of violations.slice(0, 20)) {
+        const where = v.line > 0 ? `${v.file}:${v.line}` : v.file;
+        lines.push(v.rule.kind === 'forbid'
+            ? `- **${v.standard}** — \`${where}\` has \`${v.rule.pattern}\`, which this project forbids`
+            : `- **${v.standard}** — \`${where}\` does not have \`${v.rule.pattern}\`, which this project requires`);
+        if (v.text)
+            lines.push(`  - \`${v.text.replace(/`/g, "'")}\``);
+        if (v.rule.because)
+            lines.push(`  - ${v.rule.because}`);
+    }
+    if (violations.length > 20)
+        lines.push(`- …and ${violations.length - 20} more`);
+    const guidance = loaded.filter((s) => s.guidance.trim().length > 0);
+    if (guidance.length > 0) {
+        lines.push('', `${guidance.length} standard(s) also carry guidance Tewip cannot check: ${guidance.map((s) => s.name).join(', ')}. It is passed on when Tewip writes or fixes something, and it is not counted here as either kept or broken.`);
+    }
+    lines.push('');
+    return lines;
+}

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

@@ -13,6 +13,7 @@ import { coverageFor, testFiles } from '../review/coverage.js';
 import { importingTests } from '../prove/prove.js';
 import { testsReaching } from '../prove/reaches.js';
 import { vouchChanged } from '../vouch/changed.js';
+import { checkChanged, loadStandards } from '../standards/standards-command.js';
 import { datasetFiles, readJsonl, readTriageRecords } from '../../reporters/store.js';
 import { decide, renderDecision } from './verdict.js';
 const SOURCE = /\.(js|jsx|mjs|cjs|ts|tsx|mts|cts|py|java|kt|go|cs|rb|php)$/i;
@@ -97,6 +98,8 @@ export function gather(cmd) {
         return touched.has(where) || [...touched].some((t) => r.testId.includes(t.replace(/\.[a-z]+$/, '')));
     })
         .map((r) => ({ testId: r.testId, category: String(r.diagnosis?.category ?? 'UNKNOWN') }));
+    const standards = loadStandards(cmd.root);
+    const brokenRules = standards.length === 0 ? null : checkChanged(cmd.root, standards, changed).map((v) => ({ standard: v.standard, file: v.file, line: v.line, why: v.rule.because }));
     const proved = cmd.prove ? proveChanged(cmd.root, changedSource, { budgetSeconds: cmd.proveBudgetSeconds ?? 300, onStep: (m) => console.error(`  ${m}`) }) : null;
     return {
         changed,
@@ -110,6 +113,7 @@ export function gather(cmd) {
             failingNow,
             noHistory: runs.length === 0,
             uncovered: uncoveredFor(cmd.root, changed, Object.keys(newest?.attempts ?? {})),
+            brokenRules,
         },
     };
 }

package/dist/engine/verdict/verdict.js

@@ -76,7 +76,23 @@ export function decide(evidence) {
     else {
         checks.push({ question: 'Would the tests catch a bug in this code?', standing: 'met', answer: 'every deliberate change made to this code was caught by a covering test', decidedBy: 'tewip prove' });
     }
-    // 5. Is what was asked for covered? Only where the project keeps plans to compare against.
+    // 5. Does it keep the rules this team wrote down? Only a project that has written some can break them.
+    if (evidence.brokenRules === null) {
+        checks.push({ question: "Does it keep this project's own standards?", standing: 'not-checked', answer: 'this project has written none for Tewip to read, so there is nothing to keep or break', decidedBy: 'tewip standards' });
+    }
+    else if (evidence.brokenRules.length > 0) {
+        const first = evidence.brokenRules[0];
+        checks.push({
+            question: "Does it keep this project's own standards?",
+            standing: 'not-met',
+            answer: `${evidence.brokenRules.length} rule(s) this team wrote are broken, starting with ${first.standard} at ${first.file}${first.line > 0 ? `:${first.line}` : ''}${first.why ? ` - ${first.why}` : ''}`,
+            decidedBy: 'tewip standards, which enforces only the rules a pattern can check',
+        });
+    }
+    else {
+        checks.push({ question: "Does it keep this project's own standards?", standing: 'met', answer: 'every rule this team wrote and Tewip can check is kept', decidedBy: 'tewip standards' });
+    }
+    // 6. Is what was asked for covered? Only where the project keeps plans to compare against.
     if (evidence.uncovered === null) {
         checks.push({ question: 'Is what was asked for covered?', standing: 'not-checked', answer: 'this project keeps no test plan Tewip can read, so there is nothing to compare the change against', decidedBy: 'tewip trace' });
     }

package/dist/mcp/server.js

@@ -216,4 +216,22 @@ server.registerTool('what_will_this_migration_do', {
         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);
+}));
 await server.connect(new StdioServerTransport());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tewip-ai",
-  "version": "0.31.0",
+  "version": "0.32.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",