tewip-ai 0.10.0 → 0.11.0

package/README.md

@@ -166,6 +166,36 @@ that lost its markup) and **5 of 5 harmless changes ignored** (capitals, extra s
 implemented as a link, reordered sections). No designer has judged the output yet, so the roadmap's
 own metric is still open.
 
+## More runners: Robot Framework, JMeter, k6 (new)
+
+Tewip now reads **Robot Framework's output.xml**, **JMeter's .jtl** and a **k6 summary** as well as
+JUnit XML, TRX, NUnit and Playwright's own reports. A load test does not fail test by test, so a
+JMeter report becomes one line per request ("4 of 5 requests failed, an assertion failed") and a k6
+run becomes one record per crossed threshold, with the number that crossed it.
+
+Appium and Selenium need no importer: those suites report through Mocha, pytest or JUnit, which
+Tewip already reads, and their own error messages ("Could not find a connected device", "stale
+element reference") are already understood.
+
+Each reader was checked against real reports published in public repositories, which is how three
+defects were found before release - a Robot timestamp that is not a date, k6's numbers living under
+`values`, and a JMeter line that read "mostly 200" when an assertion had failed.
+
+## Before anyone reads the diff (new)
+
+```bash
+tewip review --diff main...HEAD
+```
+
+Which tests cover this change and **how** (they import the file, they import the package that
+exports it, or their words merely match); which of them have flaked before, so a red run is not
+blamed on your change; what has gone wrong in these areas before; what nothing tests at all; and the
+command to run the telling tests first. From your project's own history, so it costs nothing.
+
+Measured on **16 real commits** from two public projects, where the developers changed source *and*
+its test: given only the source files, Tewip **named the right test in 16 of 16, ranked it first in
+12**.
+
 ## Which flaky tests to quarantine, and what they cost (new)
 
 ```bash

package/TEAM-GUIDE.md

@@ -127,6 +127,7 @@ collects environment failures in one issue, and (optionally) opens a fix pull re
 | `tewip spec "<feature>"` | An epic, its user stories and acceptance criteria, grounded in your code; files them in Jira with `--project PROJ --create` | Before the work is broken down |
 | `tewip report report.xml --gate` | The CI command for GitLab, Jenkins, CircleCI, Azure, Bitbucket and the rest: diagnoses the run, comments on the GitLab merge request, and fails the build only on failures that need a person | Your CI is not GitHub Actions |
 | `tewip watch --cmd "npm test"` | Runs your tests when you save a file and explains each failure straight away | While you are writing code |
+| `tewip review --diff main...HEAD` | Which tests cover your change, which have flaked before, what nothing tests, and what to run first | Before you open a pull request |
 | `tewip flaky --days 30` | Which tests to quarantine, which to fix, what they cost in CI minutes - and when a quarantined one can come back | Monday morning |
 | `tewip note --days 7` | The weekly quality note for a lead, from runs already diagnosed (no model calls, free) | Monday morning |
 | `tewip fix --code report.xml` | Opt-in: proposes the smallest change to application code for a real bug, and keeps it only if the failing test passes and the whole suite still passes | "It is a real bug and I want a starting patch" |
@@ -140,7 +141,7 @@ Notes that save you time:
 - `write` never touches your application code. It only adds new test files, and you review and
   commit them yourself.
 - Everything it writes locally goes to the `.tewip` folder in your project.
-- Work items go to **Jira, Rally or GitHub Issues** - set `TEWIP_TRACKER`, or just the credentials
+- Work items go to **Jira, Rally, GitHub Issues, Azure Boards or Linear** - set `TEWIP_TRACKER`, or just the credentials
   of the one you use. GitHub Issues uses your existing `gh` login, so it needs no new secret.
 - Jira works with **Cloud, Server and Data Center**. To read tickets from a tracker anyone can read
   (many open-source ones), `TEWIP_JIRA_URL` alone is enough - no account. Writing needs a token.

package/dist/cli/tewip.js

@@ -67,6 +67,12 @@ Usage:
                                     the GitLab merge request, tells Slack or Teams only when a
                                     failure needs a person, and with --gate fails the build only on
                                     those failures.
+  tewip review [--diff main...HEAD] [--out review.md]
+                                    Before anyone reads the diff: which tests cover this change,
+                                    which of them have flaked before, what has gone wrong in these
+                                    areas, what nothing tests at all, and the command that runs the
+                                    telling tests first. From this project's own history, so it
+                                    costs nothing.
   tewip watch [--cmd "npm test"] [--report <path>] [--paths src,tests]
                                     Beside your editor: runs your tests when a file changes (or
                                     watches for new reports) and explains each failure as it
@@ -92,7 +98,9 @@ Usage:
   tewip --version                   Print the version.
 
 Reports it reads: Playwright, pytest/unittest, Jest, Vitest, Mocha, node:test, JUnit/TestNG
-(Maven, Gradle), Go (gotestsum), .NET (TRX or JUnit), RSpec, PHPUnit, Rust (nextest).
+(Maven, Gradle), Go (gotestsum), .NET (TRX or JUnit), NUnit 3, RSpec, PHPUnit, Rust (nextest),
+Robot Framework (output.xml), JMeter (.jtl) and k6 (--summary-export). Appium, Selenium and
+WebdriverIO suites report through one of the above, and their own error messages are understood.
 Set OPENAI_API_KEY to let the AI layer decide what the rules leave open.`;
 const flag = (args, name) => {
     const i = args.indexOf(`--${name}`);
@@ -248,6 +256,16 @@ async function main() {
                 process.exitCode = 1;
             return;
         }
+        case 'review': {
+            const { runReview } = await import('../engine/review/review-command.js');
+            await runReview({
+                root: process.cwd(),
+                diff: flag(args, 'diff') ?? 'main...HEAD',
+                out: flag(args, 'out'),
+                name: flag(args, 'name'),
+            });
+            return;
+        }
         case 'watch': {
             const { runWatch } = await import('../engine/watch/watch-command.js');
             await runWatch({

package/dist/engine/autofix/fix-selector.js

@@ -0,0 +1,93 @@
+// ACT + VERIFY for a drifted selector in a Cypress, Selenium or WebdriverIO test.
+//
+// The same loop as every other fix Tewip makes: change one thing in the test file, run that test,
+// keep the change only if it passes, and otherwise put the file back exactly as it was. What is new
+// is where the replacement comes from - the repository, not a page snapshot - which is why these
+// tools can be fixed at all without a trace.
+//
+// It will not touch application code, will not change what the test asserts, and will not offer a
+// replacement it cannot point at in the source or in a commit.
+import { relative, resolve, sep } from 'node:path';
+import { driverLocator } from '../driver-errors.js';
+import { likeItInSource, renamedInGit, tokenOf, writeSelector } from './selector-source.js';
+/**
+ * Where a selector is written in a test: the whole line, so the replacement reads in context.
+ * Cypress and Selenium put the selector in a plain string, so this is simpler than Playwright's
+ * chained calls - and looking for the quoted form keeps it from matching a comment about it.
+ */
+export function findSelectorSites(source, selector) {
+    const quoted = [`'${selector}'`, `"${selector}"`, `\`${selector}\``];
+    const sites = [];
+    source.split('\n').forEach((text, index) => {
+        if (quoted.some((q) => text.includes(q)))
+            sites.push({ line: index + 1, text });
+    });
+    return sites;
+}
+/**
+ * One drifted selector, fixed from what the repository knows. `keep` false checks a suggestion
+ * without leaving it in the file, exactly as the locator fix does.
+ */
+export async function attemptSelectorFix({ record, diagnosis, action, specFile }, deps, { keep = true } = {}) {
+    const title = record.testId.split(' > ').at(-1) ?? record.testId;
+    const result = { testId: record.testId, specFile, status: 'not-eligible', applied: false, log: [] };
+    const stop = (status, why) => ({ ...result, status, log: [...result.log, why] });
+    if (diagnosis.category !== 'LOCATOR_DRIFT' || action.kind !== 'fix-locator') {
+        return stop('not-eligible', `only a renamed element is fixed this way; this one is ${diagnosis.category} (${action.kind})`);
+    }
+    const rel = relative(resolve(deps.allowedRoot), resolve(specFile));
+    if (rel.startsWith('..') || rel.startsWith(sep) || /^[a-zA-Z]:/.test(rel))
+        return stop('outside-sandbox', `refused: ${specFile} is outside ${deps.allowedRoot}`);
+    // What the tool said it was looking for.
+    const selector = driverLocator(record.errorMessage) ?? '';
+    if (!selector)
+        return stop('no-selector', 'the error does not say which selector was not found');
+    result.log.push(`the test looked for ${selector}`);
+    // What the line in the test really holds: Selenium prints "css selector=#x" but writes "#x".
+    const written = /^[a-z ]+=\s*/i.test(selector) ? selector.replace(/^[a-z ]+=\s*/i, '') : selector;
+    const token = tokenOf(selector);
+    if (!token) {
+        return stop('not-identifiable', `${selector} is not an id, class or data attribute, so there is nothing in the source to compare it against. A person should look at the page.`);
+    }
+    // Git first: somebody renamed it, and the commit says to what. The source is the weaker answer.
+    const found = renamedInGit(deps.projectRoot, token) ?? likeItInSource(deps.projectRoot, token, deps.sources);
+    if (!found) {
+        return stop('no-replacement', `nothing in the source or in the history looks like "${token.value}" renamed. Tewip will not invent a selector.`);
+    }
+    const evidence = found.how === 'renamed in git'
+        ? `commit ${found.commit} changed "${token.value}" to "${found.value}" in ${found.file}`
+        : `"${token.value}" is nowhere in the source any more, and ${found.file} now has "${found.value}"`;
+    result.evidence = evidence;
+    result.log.push(evidence);
+    const replacement = writeSelector(token, found.value);
+    const source = deps.readFile(specFile);
+    const sites = findSelectorSites(source, written);
+    const site = sites[0];
+    if (!site)
+        return stop('selector-not-in-test', `${selector} is not written in ${rel}: it comes from a helper or a page object, which a person should change`);
+    result.line = site.line;
+    result.original = site.text;
+    result.replacement = site.text.replace(written, replacement);
+    deps.writeFile(specFile, source.replace(site.text, result.replacement));
+    try {
+        const run = await deps.verify(specFile, title);
+        if (!run.passed) {
+            deps.writeFile(specFile, source);
+            return stop('still-failing', `with ${replacement} the test still failed, so the file was put back: ${run.detail.slice(-200)}`);
+        }
+        result.log.push(`with ${replacement} the test passes`);
+        if (!keep)
+            deps.writeFile(specFile, source);
+        return { ...result, status: 'fixed', applied: keep };
+    }
+    catch (error) {
+        deps.writeFile(specFile, source);
+        throw error;
+    }
+}
+/** The one-line diff a reviewer reads. */
+export function selectorFixDiff(result) {
+    if (!result.original || !result.replacement)
+        return '';
+    return [`--- a/${result.specFile}`, `+++ b/${result.specFile}`, `@@ line ${result.line} @@`, `-${result.original.trim()}`, `+${result.replacement.trim()}`].join('\n');
+}

package/dist/engine/autofix/selector-source.js

@@ -0,0 +1,162 @@
+// Phase 5, for the tools that do not have a page snapshot: Cypress, Selenium and WebdriverIO.
+//
+// Playwright's traces tell Tewip what was on the page, so a drifted locator can be matched against
+// the real elements. A Cypress or Selenium failure in a JUnit report carries none of that - only
+// "Expected to find element: '#submit-btn', but never found it". Inventing a replacement from that
+// would be exactly the kind of guess this project exists not to make.
+//
+// So the answer comes from the repository instead. If a test looks for `#submit-btn` and the app
+// now renders `id="submit-button"`, the new name is in the application source, and git knows which
+// commit renamed it. That is evidence, not a guess - and the fix is still only kept if the test
+// passes afterwards.
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+/** What a CSS or XPath selector is really identifying, when it is something identifiable. */
+export function tokenOf(selector) {
+    // Selenium and WebdriverIO name the strategy first: "css selector=#submit-btn", "id=submit-btn".
+    const strategy = /^(css selector|css|xpath|id|name|class name|link text|partial link text|tag name)\s*=\s*(.+)$/i.exec(selector.trim());
+    const s = (strategy ? strategy[2] : selector).trim();
+    if (strategy) {
+        const method = strategy[1].toLowerCase();
+        if (method === 'id')
+            return { kind: 'id', value: s };
+        if (method === 'class name')
+            return { kind: 'class', value: s.split(/\s+/)[0] };
+        if (method === 'link text' || method === 'partial link text')
+            return { kind: 'text', value: s };
+    }
+    const data = /\[\s*([\w-]*data[\w-]*)\s*[~|^$*]?=\s*["']?([^"'\]]+)["']?\s*\]/i.exec(s);
+    if (data)
+        return { kind: 'data', attribute: data[1], value: data[2] };
+    const id = /^#([\w-]+)$|\[\s*id\s*=\s*["']([^"']+)["']\s*\]|@id\s*=\s*["']([^"']+)["']/i.exec(s);
+    if (id)
+        return { kind: 'id', value: id[1] ?? id[2] ?? id[3] };
+    const cls = /^\.([\w-]+)$|\[\s*class\s*=\s*["']([^"']+)["']\s*\]/i.exec(s);
+    if (cls)
+        return { kind: 'class', value: (cls[1] ?? cls[2]).split(/\s+/)[0] };
+    const text = /text\(\)\s*=\s*["']([^"']+)["']|contains\(\s*(?:text\(\)|\.)\s*,\s*["']([^"']+)["']/i.exec(s);
+    if (text)
+        return { kind: 'text', value: text[1] ?? text[2] };
+    return null;
+}
+/** How close two names are, 0 to 1, by the words in them - "submit-btn" and "submit-button". */
+export function closeness(a, b) {
+    const words = (s) => new Set(s.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean));
+    const left = words(a);
+    const right = words(b);
+    if (left.size === 0 || right.size === 0)
+        return 0;
+    let shared = 0;
+    for (const w of left)
+        if (right.has(w))
+            shared++;
+    // A shared prefix counts too: "submitBtn" and "submitButton" have no word in common.
+    const prefix = commonPrefix(a.toLowerCase(), b.toLowerCase()) / Math.max(a.length, b.length);
+    return Math.max(shared / Math.max(left.size, right.size), prefix);
+}
+function commonPrefix(a, b) {
+    let i = 0;
+    while (i < a.length && i < b.length && a[i] === b[i])
+        i++;
+    return i;
+}
+const git = (root, args) => {
+    try {
+        return execFileSync('git', args, { cwd: root, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024, timeout: 60_000 });
+    }
+    catch {
+        return '';
+    }
+};
+/**
+ * The commit that removed this value, and what took its place on the same line. This is the
+ * strongest evidence there is: somebody renamed it, and the diff says to what.
+ */
+export function renamedInGit(root, token, maxCommits = 5) {
+    const shas = git(root, ['log', '-S', token.value, '--format=%H', `-n${maxCommits}`, '--', '.'])
+        .split('\n')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    for (const sha of shas) {
+        const diff = git(root, ['show', '--unified=0', '--format=', sha]);
+        if (!diff)
+            continue;
+        let file = '';
+        const removed = [];
+        const added = [];
+        for (const line of diff.split('\n')) {
+            if (line.startsWith('+++ b/'))
+                file = line.slice(6);
+            else if (line.startsWith('-') && line.includes(token.value))
+                removed.push(line);
+            else if (line.startsWith('+'))
+                added.push(line);
+        }
+        if (removed.length === 0 || added.length === 0)
+            continue;
+        // The best replacement is the attribute value on an added line that most resembles the old one.
+        let best = null;
+        for (const line of added) {
+            for (const value of attributeValues(line, token)) {
+                const score = closeness(token.value, value);
+                if (value !== token.value && score >= 0.5 && (!best || score > best.score)) {
+                    best = { value, file, how: 'renamed in git', commit: sha.slice(0, 8), score };
+                }
+            }
+        }
+        if (best)
+            return best;
+    }
+    return null;
+}
+/** Values of the same kind of attribute written on a line of source. */
+function attributeValues(line, token) {
+    const out = [];
+    const attribute = token.kind === 'data' ? token.attribute ?? 'data-[\\w-]+' : token.kind === 'id' ? 'id' : token.kind === 'class' ? 'class(?:Name)?' : '';
+    if (!attribute)
+        return out;
+    const pattern = new RegExp(`${attribute}\\s*=\\s*["'\`{]?\\s*["']?([\\w\\s-]+)["']?`, 'gi');
+    for (const m of line.matchAll(pattern)) {
+        for (const value of m[1].trim().split(/\s+/))
+            if (value)
+                out.push(value);
+    }
+    return out;
+}
+/**
+ * The closest value of the same kind anywhere in the application source now. Weaker than git,
+ * because nobody wrote down that it is a rename - so it is offered only when it is clearly close.
+ */
+export function likeItInSource(root, token, sources, min = 0.6) {
+    let best = null;
+    for (const file of sources) {
+        let text;
+        try {
+            text = readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (text.includes(token.value))
+            return null; // it is still there; this is not a rename
+        for (const line of text.split('\n')) {
+            for (const value of attributeValues(line, token)) {
+                const score = closeness(token.value, value);
+                if (value !== token.value && score >= min && (!best || score > best.score)) {
+                    best = { value, file, how: 'found in the source', score };
+                }
+            }
+        }
+    }
+    return best;
+}
+/** The selector written the way each tool writes it, so the fix reads like the rest of the test. */
+export function writeSelector(token, value) {
+    if (token.kind === 'id')
+        return `#${value}`;
+    if (token.kind === 'class')
+        return `.${value}`;
+    if (token.kind === 'data')
+        return `[${token.attribute}="${value}"]`;
+    return value;
+}

package/dist/engine/import/junit.js

@@ -1,6 +1,8 @@
 // Imports test reports from any language or framework into the agent's records: JUnit XML, which
 // pytest, Jest, Vitest, Mocha, node:test, Maven Surefire, Gradle, gotestsum, PHPUnit, RSpec,
-// cargo-nextest and Cypress write, and .NET's own TRX. Playwright keeps its own importer
+// cargo-nextest and Cypress write; .NET's own TRX; NUnit 3's result file; Robot Framework's
+// output.xml; JMeter's .jtl; and a k6 summary, where a run fails by crossing a threshold rather
+// than test by test. Playwright keeps its own importer
 // (blob.ts), which also reads traces.
 //
 // What these reports can and cannot say: each test's name, outcome, failure message and stack,
@@ -11,6 +13,7 @@ import { readdirSync, readFileSync, statSync } from 'node:fs';
 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: '' };
 const FAILURE = new Set(['failure', 'error']);
 /** Maven Surefire's records of earlier attempts: flaky* when a later one passed, rerun* when not. */
@@ -138,7 +141,8 @@ function nunitCases(root) {
         };
     });
 }
-const REPORT_FILE = /\.(xml|trx)$/i;
+// .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) {
     if (!statSync(path).isDirectory())
@@ -162,7 +166,26 @@ export function importJunit(path, meta) {
     const unread = [];
     let parsedFiles = 0;
     for (const file of junitFiles(path)) {
-        const root = parseXml(readFileSync(file, 'utf8'));
+        const raw = readFileSync(file, 'utf8');
+        // k6 writes JSON, not XML: a performance run fails by crossing a threshold, not test by test.
+        if (/\.json$/i.test(file)) {
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                unread.push(`${file} (not JSON)`);
+                continue;
+            }
+            if (!looksLikeK6(parsed)) {
+                unread.push(`${file} (JSON, but not a k6 summary)`);
+                continue;
+            }
+            parsedFiles++;
+            addCases(k6Cases(parsed));
+            continue;
+        }
+        const root = parseXml(raw);
         let cases;
         if (root.name === 'TestRun') {
             cases = trxCases(root);
@@ -182,6 +205,15 @@ export function importJunit(path, meta) {
             if (start && (!startedAt || start < startedAt))
                 startedAt = start;
         }
+        else if (root.name === 'robot') {
+            cases = robotCases(root);
+            const start = robotTime(root.attrs.generated ?? '');
+            if (start && !startedAt)
+                startedAt = start;
+        }
+        else if (root.name === 'testResults') {
+            cases = jmeterCases(root);
+        }
         else {
             // Not a report Tewip knows. Staying silent here would report a failing run as clean, so the
             // file is remembered and, if nothing at all could be read, the caller is told.
@@ -189,6 +221,9 @@ export function importJunit(path, meta) {
             continue;
         }
         parsedFiles++;
+        addCases(cases);
+    }
+    function addCases(cases) {
         for (const c of cases) {
             attempts[c.testId] = (attempts[c.testId] ?? 0) + c.attempts.length;
             c.attempts.forEach((attempt, retry) => {
@@ -226,7 +261,8 @@ export function importJunit(path, meta) {
     if (unread.length > 0) {
         const list = unread.slice(0, 5).join(', ');
         if (parsedFiles === 0) {
-            throw new Error(`no test report Tewip can read in ${path}: ${list}. It reads JUnit XML (<testsuites>/<testsuite>), NUnit 3 (<test-run>) and .NET TRX (<TestRun>). ` +
+            throw new Error(`no test report Tewip can read in ${path}: ${list}. It reads JUnit XML (<testsuites>/<testsuite>), NUnit 3 (<test-run>), .NET TRX (<TestRun>), ` +
+                'Robot Framework output.xml (<robot>), JMeter .jtl (<testResults>) and a k6 summary (--summary-export). ' +
                 'Most runners can write JUnit XML; for TestNG use the Surefire report, and for NUnit use --result=x.xml.');
         }
         console.error(`[tewip] ignored ${unread.length} file(s) that are not a test report: ${list}`);

package/dist/engine/import/other-formats.js

@@ -0,0 +1,127 @@
+import { descendants } from './xml.js';
+const text = (element) => (element ? element.text.trim() : '');
+/**
+ * Robot Framework writes output.xml by default, and only writes JUnit if asked. A suite holds
+ * tests, a test holds a status with the failure message inside it, and suites nest - so the test's
+ * name is its whole path, the way Robot itself prints it.
+ */
+export function robotCases(root) {
+    const cases = [];
+    const walk = (element, path, source) => {
+        for (const child of element.children) {
+            if (child.name === 'suite') {
+                walk(child, [...path, child.attrs.name ?? ''], child.attrs.source ?? source);
+                continue;
+            }
+            if (child.name !== 'test')
+                continue;
+            const status = child.children.find((c) => c.name === 'status');
+            const failed = (status?.attrs.status ?? '').toUpperCase() === 'FAIL';
+            const start = status?.attrs.starttime ?? status?.attrs.start ?? '';
+            const end = status?.attrs.endtime ?? status?.attrs.end ?? '';
+            // The last keyword that failed says where it went wrong, which the message alone does not.
+            const failedKeyword = descendants(child, 'kw').find((kw) => (kw.children.find((c) => c.name === 'status')?.attrs.status ?? '').toUpperCase() === 'FAIL');
+            const where = failedKeyword?.attrs.name ? `Keyword: ${failedKeyword.attrs.name}` : '';
+            cases.push({
+                testId: [...path, child.attrs.name ?? ''].filter(Boolean).join(' > '),
+                file: source,
+                duration: robotDuration(start, end),
+                attempts: [{ failed, message: failed ? text(status) || 'the test failed' : '', stack: failed ? where : '' }],
+            });
+        }
+    };
+    walk(root, [], root.attrs.source ?? '');
+    return cases;
+}
+/** Robot's timestamp as an ISO one, or '' when it is not the shape Robot writes. */
+export function robotTime(stamp) {
+    const at = robotStamp(stamp);
+    return at > 0 ? new Date(at).toISOString() : '';
+}
+/** Robot's own timestamp shape: 20260923 14:05:01.123 */
+function robotStamp(s) {
+    const m = /^(\d{4})(\d{2})(\d{2}) (\d{2}):(\d{2}):(\d{2})\.(\d{1,3})$/.exec(s.trim());
+    return m ? Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3]), Number(m[4]), Number(m[5]), Number(m[6]), Number(m[7])) : 0;
+}
+function robotDuration(start, end) {
+    const from = robotStamp(start);
+    const to = robotStamp(end);
+    return from > 0 && to >= from ? to - from : 0;
+}
+/**
+ * JMeter's .jtl in XML form: one sample per request, s="false" when it failed. A load test has
+ * thousands of samples, so they are grouped by label - nobody wants ten thousand records, they want
+ * "the checkout request failed 412 times, mostly 503".
+ */
+export function jmeterCases(root) {
+    const samples = [...descendants(root, 'httpSample'), ...descendants(root, 'sample')];
+    const byLabel = new Map();
+    for (const sample of samples) {
+        const label = sample.attrs.lb ?? 'sample';
+        const found = byLabel.get(label) ?? { failed: 0, total: 0, time: 0, codes: new Map(), messages: new Set() };
+        found.total++;
+        found.time += Number(sample.attrs.t ?? 0);
+        if ((sample.attrs.s ?? 'true').toLowerCase() === 'false') {
+            found.failed++;
+            const code = `${sample.attrs.rc ?? ''} ${sample.attrs.rm ?? ''}`.trim();
+            if (code)
+                found.codes.set(code, (found.codes.get(code) ?? 0) + 1);
+            const assertion = descendants(sample, 'failureMessage')[0];
+            if (assertion)
+                found.messages.add(text(assertion).slice(0, 200));
+        }
+        byLabel.set(label, found);
+    }
+    return [...byLabel].map(([label, s]) => {
+        const worst = [...s.codes].sort((a, b) => b[1] - a[1])[0];
+        // A 2xx that still counts as failed is an assertion failing, not the server: "mostly 200" would
+        // read as nonsense to whoever opens the report.
+        const why = worst ? (/^2\d\d/.test(worst[0]) ? `, an assertion failed (${worst[1]} times, response ${worst[0]})` : `, mostly ${worst[0]} (${worst[1]} times)`) : '';
+        const message = s.failed === 0 ? '' : `${s.failed} of ${s.total} requests failed${why}${s.messages.size > 0 ? `: ${[...s.messages][0]}` : ''}`;
+        return { testId: `JMeter > ${label}`, file: '', duration: s.time, attempts: [{ failed: s.failed > 0, message, stack: [...s.messages].join('\n').slice(0, 2000) }] };
+    });
+}
+/**
+ * k6 writes a summary as JSON (`k6 run --summary-export=summary.json`). A performance run does not
+ * fail test by test: it fails when a threshold is crossed, and that is what is imported - one
+ * record per crossed threshold, saying by how much.
+ */
+export function k6Cases(json) {
+    const report = json;
+    if (!report?.metrics)
+        return [];
+    const cases = [];
+    for (const [metric, body] of Object.entries(report.metrics)) {
+        const thresholds = body.thresholds;
+        if (!thresholds)
+            continue;
+        for (const [expression, result] of Object.entries(thresholds)) {
+            // k6 writes either a boolean "ok" or an object with it; a crossed threshold is ok === false.
+            const ok = typeof result === 'boolean' ? result : Boolean(result?.ok);
+            const measured = describeMetric((body.values ?? body));
+            cases.push({
+                testId: `k6 > ${metric} > ${expression}`,
+                file: '',
+                duration: 0,
+                attempts: [{ failed: !ok, message: ok ? '' : `the threshold "${expression}" on ${metric} was crossed${measured ? `: ${measured}` : ''}`, stack: measured }],
+            });
+        }
+    }
+    return cases;
+}
+/** The numbers k6 reports for a metric, in one readable line. */
+function describeMetric(body) {
+    const wanted = ['avg', 'min', 'med', 'max', 'p(90)', 'p(95)', 'p(99)', 'rate', 'count', 'value'];
+    return wanted
+        .filter((key) => typeof body[key] === 'number')
+        .map((key) => `${key}=${round(body[key])}`)
+        .join(' ');
+}
+const round = (n) => (Number.isInteger(n) ? String(n) : n.toFixed(2));
+/** Whether a parsed JSON file looks like a k6 summary, so nothing else is read as one. */
+export function looksLikeK6(json) {
+    const report = json;
+    if (!report?.metrics || typeof report.metrics !== 'object')
+        return false;
+    return ['http_req_duration', 'iterations', 'vus', 'checks', 'http_reqs'].some((m) => m in report.metrics);
+}

package/dist/engine/review/coverage.js

@@ -0,0 +1,188 @@
+// Which tests actually reach the code a change touched.
+//
+// Two ways of knowing, in this order: a test that imports the changed file (directly, or through
+// the package's front door) really does exercise it; a test whose name and path share the change's
+// words probably does. The first is a fact, the second a guess, and the report says which is which -
+// because "these 6 tests cover your change" is only useful if it is true.
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { basename, dirname, extname, join, relative, resolve, sep } from 'node:path';
+const TEST_FILE = /(?:\.|_)(?:spec|test)\.[cm]?[jt]sx?$|(?:^|[\\/])test_[^\\/]+\.py$|_test\.py$|_test\.go$|Test(?:s)?\.(?:java|kt|cs)$|\.cy\.[jt]sx?$|\.feature$|\.robot$/i;
+const SKIP_DIR = new Set(['node_modules', '.git', 'dist', 'build', 'out', 'coverage', 'target', 'vendor', '__pycache__', '.venv', 'venv', '.tewip', '.next']);
+/** Every test file in the project. */
+export function testFiles(root, limit = 4000) {
+    const out = [];
+    const walk = (dir) => {
+        if (out.length >= limit)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const path = join(dir, entry);
+            let info;
+            try {
+                info = statSync(path);
+            }
+            catch {
+                continue;
+            }
+            if (info.isDirectory()) {
+                if (!SKIP_DIR.has(entry))
+                    walk(path);
+            }
+            else if (TEST_FILE.test(entry))
+                out.push(path);
+        }
+    };
+    walk(root);
+    return out;
+}
+/**
+ * Files a test could plausibly cover. Documentation, lockfiles and images change in almost every
+ * pull request; saying "nothing tests ROADMAP.md" is noise, and noise is how a review gets skipped.
+ */
+export const isCode = (file) => /\.(?:[cm]?[jt]sx?|py|rb|go|java|kt|cs|php|rs|vue|svelte|scala|swift|sql)$/i.test(file) && !/(?:^|[\/])(?:package-lock\.json|yarn\.lock)$/i.test(file);
+/** The module names a file can be imported by: its path, its name, and its folder's front door. */
+function importNames(root, changed) {
+    const full = resolve(root, changed);
+    const noExt = full.slice(0, full.length - extname(full).length);
+    const names = new Set([basename(noExt), relative(root, noExt).split(sep).join('/')]);
+    // Python: a.b.c for src/a/b/c.py, and the package it sits in.
+    const parts = relative(root, noExt).split(sep).filter((p) => p !== 'src');
+    names.add(parts.join('.'));
+    names.add(parts.slice(0, -1).join('.'));
+    if (basename(noExt) === 'index' || basename(noExt) === '__init__')
+        names.add(basename(dirname(noExt)));
+    return [...names].filter((n) => n.length > 1);
+}
+/**
+ * The package a changed file is re-exported from. In a project with one front door - which is most
+ * libraries - every test imports "../src" and nothing imports "../src/utils.ts", so without this a
+ * review finds no tests at all for a real change. Measured: 8 of 16 real commits were missed this
+ * way before.
+ */
+function packageNames(root, changed) {
+    const full = resolve(root, changed);
+    const out = [];
+    let dir = dirname(full);
+    for (let up = 0; up < 3; up++) {
+        for (const entry of ['index.ts', 'index.js', 'index.mjs', 'index.tsx', '__init__.py']) {
+            const front = join(dir, entry);
+            if (!existsSync(front))
+                continue;
+            let source = '';
+            try {
+                source = readFileSync(front, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const stem = basename(full).replace(/\.[^.]+$/, '');
+            // Either it names this file, or it re-exports everything beside it.
+            if (front !== full && (source.includes(stem) || /export\s+\*/.test(source))) {
+                out.push(relative(root, dir).split(sep).join('/'), basename(dir));
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return [...new Set(out)].filter(Boolean);
+}
+/** Does this test's source import that changed file? */
+function importsIt(source, names) {
+    for (const name of names) {
+        const quoted = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const patterns = [
+            new RegExp(`(?:from|import|require\\()\\s*['"][^'"]*${quoted}(?:\\.[cm]?[jt]sx?)?['"]`),
+            new RegExp(`(?:^|\\n)\\s*(?:from\\s+${quoted}\\s+import|import\\s+${quoted})\\b`),
+        ];
+        if (patterns.some((p) => p.test(source)))
+            return true;
+    }
+    return false;
+}
+const words = (text) => (text.toLowerCase().match(/[a-z][a-z0-9]{2,}/g) ?? []).filter((w) => !STOP.has(w));
+const STOP = new Set(['src', 'lib', 'app', 'test', 'tests', 'spec', 'index', 'main', 'the', 'and', 'for', 'com', 'org', 'utils', 'util', 'js', 'ts', 'py']);
+/**
+ * The tests that reach a set of changed files. Imports first; then, for changed files nothing
+ * imports, the tests whose words overlap - marked as a guess.
+ */
+export function coverageFor(root, changedAll, tests = testFiles(root)) {
+    const changed = changedAll.filter(isCode);
+    const sources = new Map();
+    const read = (file) => {
+        if (!sources.has(file)) {
+            try {
+                sources.set(file, readFileSync(file, 'utf8'));
+            }
+            catch {
+                sources.set(file, '');
+            }
+        }
+        return sources.get(file);
+    };
+    const byTest = new Map();
+    const coveredByImport = new Set();
+    const add = (test, file, how) => {
+        const rel = relative(root, test).split(sep).join('/');
+        const found = byTest.get(rel) ?? { testFile: rel, covers: [], how };
+        // A test that imports the file itself is never downgraded to the weaker kinds of knowing.
+        if (RANK[how] < RANK[found.how])
+            found.how = how;
+        if (!found.covers.includes(file))
+            found.covers.push(file);
+        byTest.set(rel, found);
+    };
+    for (const file of changed) {
+        if (!existsSync(resolve(root, file)))
+            continue;
+        const direct = importNames(root, file);
+        const viaPackage = packageNames(root, file);
+        for (const test of tests) {
+            const source = read(test);
+            if (importsIt(source, direct)) {
+                coveredByImport.add(file);
+                add(test, file, 'imports');
+            }
+            else if (viaPackage.length > 0 && importsIt(source, viaPackage)) {
+                coveredByImport.add(file);
+                add(test, file, 'package');
+            }
+        }
+    }
+    // Only for the changed files nothing imports: the words, which is a weaker kind of knowing.
+    const orphans = changed.filter((f) => !coveredByImport.has(f));
+    for (const file of orphans) {
+        const wanted = new Set(words(file));
+        if (wanted.size === 0)
+            continue;
+        for (const test of tests) {
+            const rel = relative(root, test).split(sep).join('/');
+            if (byTest.has(rel))
+                continue;
+            const shared = words(`${rel} ${read(test).slice(0, 4000)}`).filter((w) => wanted.has(w));
+            if (new Set(shared).size < 2)
+                continue;
+            add(test, file, 'name');
+        }
+    }
+    // Direct imports first, then the package ones - and inside each group the test whose words match
+    // the change, because "every test in the library covers this" is true and useless.
+    const overlap = (test) => {
+        const wanted = new Set(test.covers.flatMap((f) => words(f)));
+        return words(test.testFile).filter((w) => wanted.has(w)).length;
+    };
+    return [...byTest.values()].sort((a, b) => RANK[a.how] - RANK[b.how] || overlap(b) - overlap(a) || b.covers.length - a.covers.length);
+}
+const RANK = { imports: 0, package: 1, name: 2 };
+/** Changed files that no test reaches at all: the part of a change nobody will notice breaking. */
+export function uncovered(changed, coverage) {
+    const reached = new Set(coverage.flatMap((c) => c.covers));
+    return changed.filter((f) => isCode(f) && !reached.has(f) && !TEST_FILE.test(f));
+}

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

@@ -0,0 +1,44 @@
+// `tewip review --diff main...HEAD`: what a developer wants to know before anyone reads the diff.
+import { existsSync, readdirSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { changeSummary } from '../quality/grounding.js';
+import { chooseFramework, detectFrameworks } from '../quality/frameworks.js';
+import { readTriageRecords, datasetFiles } from '../../reporters/store.js';
+import { coverageFor, uncovered } from './coverage.js';
+import { renderReview, reviewChange } from './review.js';
+/** Every failure Tewip has diagnosed in this project, from the history it keeps. */
+function history(root, only) {
+    const dir = join(root, '.tewip', 'history');
+    if (!existsSync(dir))
+        return [];
+    const names = only ? [only] : readdirSync(dir);
+    return names.flatMap((name) => readTriageRecords(datasetFiles(join(dir, name)).triage));
+}
+export async function runReview(cmd) {
+    const change = changeSummary(cmd.root, cmd.diff);
+    if (!change)
+        throw new Error(`could not read the change "${cmd.diff}". Is this a git checkout, and does that range exist? (try --diff main...HEAD)`);
+    if (change.files.length === 0) {
+        console.log(`Nothing changed in ${cmd.diff}.`);
+        return null;
+    }
+    const files = change.files.map((f) => f.split('\\').join('/'));
+    const coverage = coverageFor(cmd.root, files);
+    const past = history(cmd.root, cmd.name);
+    const review = reviewChange(cmd.diff, files, coverage, past, uncovered(files, coverage));
+    // The command that runs just those tests - but only when the project's runner really owns them.
+    // Printing a Playwright command for a file Playwright never runs is worse than printing nothing.
+    const framework = chooseFramework(detectFrameworks(cmd.root), undefined, false) ?? detectFrameworks(cmd.root)[0] ?? null;
+    const ownsThem = framework ? review.runFirst.some((f) => resolve(cmd.root, f).startsWith(resolve(framework.testDir))) : false;
+    const runCommand = framework && ownsThem ? (chosen) => chosen.map((f) => framework.command(resolve(cmd.root, f))).join(' && ') : undefined;
+    const report = renderReview(review, runCommand);
+    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.');
+    }
+    if (cmd.out) {
+        writeFileSync(resolve(cmd.out), `${report}\n`, 'utf8');
+        console.log(`\nWritten to ${cmd.out}`);
+    }
+    return review;
+}

package/dist/engine/review/review.js

@@ -0,0 +1,127 @@
+// The risk review of a change, from what Tewip already knows about this project.
+//
+// A general coding agent can read a diff. What it cannot do is tell you that the two tests covering
+// your change have flaked eleven times this month, that this area has had three real bugs since
+// August, and that nothing at all covers the file you edited. That comes from Tewip's own history,
+// which is why this costs nothing and why nothing else can produce it.
+import { componentOf } from '../../outlets/items.js';
+const fileOf = (record) => record.file ?? '';
+const countBy = (xs, key) => {
+    const out = new Map();
+    for (const x of xs)
+        out.set(key(x), (out.get(key(x)) ?? 0) + 1);
+    return out;
+};
+/** The review, assembled from the change, what covers it, and what has gone wrong here before. */
+export function reviewChange(range, changed, coverage, history, notCovered) {
+    const byFile = new Map();
+    for (const record of history) {
+        const file = fileOf(record).split('\\').join('/');
+        if (!file)
+            continue;
+        byFile.set(file, [...(byFile.get(file) ?? []), record]);
+    }
+    const tests = coverage.map((c) => {
+        const past = byFile.get(c.testFile) ?? [];
+        const kinds = countBy(past, (r) => r.diagnosis?.category ?? 'UNKNOWN');
+        return {
+            testFile: c.testFile,
+            how: c.how,
+            covers: c.covers,
+            flakedTimes: kinds.get('TIMING') ?? 0,
+            bugTimes: kinds.get('REAL_BUG') ?? 0,
+            lastFailed: past.map((r) => r.timestamp).sort().at(-1) ?? '',
+        };
+    });
+    // The areas a change touches, and what has broken in them before.
+    const areaOf = (file) => componentOf(file);
+    const areas = new Map();
+    for (const file of changed) {
+        const area = areaOf(file);
+        const found = areas.get(area) ?? { area, failures: 0, realBugs: 0, flaky: 0, files: [] };
+        found.files.push(file);
+        areas.set(area, found);
+    }
+    for (const record of history) {
+        const area = areaOf(fileOf(record));
+        const found = areas.get(area);
+        if (!found)
+            continue;
+        found.failures++;
+        if (record.diagnosis?.category === 'REAL_BUG')
+            found.realBugs++;
+        if (record.diagnosis?.category === 'TIMING')
+            found.flaky++;
+    }
+    // What to run first: what really imports the change, worst history first - a test that has caught
+    // a real bug here before is the one most worth running now.
+    const runFirst = [...tests]
+        .filter((t) => t.how !== 'name')
+        .sort((a, b) => b.bugTimes - a.bugTimes || a.flakedTimes - b.flakedTimes)
+        .slice(0, 10)
+        .map((t) => t.testFile);
+    const notes = [];
+    const flaky = tests.filter((t) => t.flakedTimes >= 3);
+    if (flaky.length > 0) {
+        notes.push(`${flaky.length} of the tests covering this change have flaked before (${flaky.map((t) => `${t.testFile.split('/').at(-1)} ×${t.flakedTimes}`).join(', ')}). If one of them goes red, check Tewip's diagnosis before blaming the change.`);
+    }
+    if (notCovered.length > 0) {
+        notes.push(`${notCovered.length} changed file(s) have no test that imports them: ${notCovered.slice(0, 5).join(', ')}${notCovered.length > 5 ? ', ...' : ''}. A mistake there would reach production unnoticed.`);
+    }
+    const risky = [...areas.values()].filter((a) => a.realBugs >= 2).sort((a, b) => b.realBugs - a.realBugs);
+    if (risky.length > 0) {
+        notes.push(`${risky[0].area} has had ${risky[0].realBugs} real bug(s) in the history Tewip has kept. It is the part of this change worth a second pair of eyes.`);
+    }
+    if (tests.length === 0 && changed.length > 0) {
+        notes.push('No test in this project reaches any of the changed files. Tewip can write one: `tewip plan "<what the change should do>"` then `tewip write`.');
+    }
+    return { range, files: changed, tests, uncovered: notCovered, areas: [...areas.values()].sort((a, b) => b.realBugs - a.realBugs || b.failures - a.failures), runFirst, notes };
+}
+const when = (at) => {
+    if (!at)
+        return 'never';
+    const days = Math.round((Date.now() - Date.parse(at)) / 86_400_000);
+    if (!Number.isFinite(days))
+        return 'once';
+    return days <= 1 ? 'yesterday' : days < 14 ? `${days} days ago` : days < 60 ? `${Math.round(days / 7)} weeks ago` : `${Math.round(days / 30)} months ago`;
+};
+/** The review as a person reads it, before they read the diff. */
+export function renderReview(review, runCommand) {
+    const lines = [`# Risk review: ${review.range}`, '', `${review.files.length} changed file(s).`, ''];
+    if (review.notes.length > 0) {
+        lines.push('## Before you read the diff', '');
+        for (const note of review.notes)
+            lines.push(`- ${note}`);
+        lines.push('');
+    }
+    lines.push('## Tests that cover this change', '');
+    if (review.tests.length === 0)
+        lines.push('None found.', '');
+    for (const test of review.tests.slice(0, 15)) {
+        const past = test.flakedTimes + test.bugTimes > 0 ? ` — failed before: ${test.bugTimes} real bug(s), ${test.flakedTimes} flaky, last ${when(test.lastFailed)}` : ' — never failed in the history Tewip has kept';
+        const how = test.how === 'imports' ? 'imports the changed code' : test.how === 'package' ? 'imports the package that exports it' : 'shares its words, so this one is a guess';
+        lines.push(`- **${test.testFile}** (${how})${past}`);
+        lines.push(`  - covers: ${test.covers.slice(0, 4).join(', ')}${test.covers.length > 4 ? `, +${test.covers.length - 4}` : ''}`);
+    }
+    lines.push('');
+    if (review.uncovered.length > 0) {
+        lines.push('## Changed, but nothing tests it', '');
+        for (const file of review.uncovered.slice(0, 15))
+            lines.push(`- ${file}`);
+        lines.push('');
+    }
+    if (review.areas.some((a) => a.failures > 0)) {
+        lines.push('## What has gone wrong here before', '');
+        for (const area of review.areas.filter((a) => a.failures > 0).slice(0, 6)) {
+            lines.push(`- **${area.area}**: ${area.failures} failure(s) — ${area.realBugs} real bug(s), ${area.flaky} flaky`);
+        }
+        lines.push('');
+    }
+    if (review.runFirst.length > 0) {
+        lines.push('## Run these first', '');
+        lines.push(runCommand ? '```' : '', runCommand ? runCommand(review.runFirst) : review.runFirst.map((f) => `- ${f}`).join('\n'), runCommand ? '```' : '');
+        lines.push('');
+    }
+    lines.push('---', '', 'Read from this project\'s own failure history. No model was called, so this cost nothing.');
+    return lines.join('\n');
+}

package/dist/engine/work/azure-linear.js

@@ -0,0 +1,116 @@
+export function azureFromEnv(env = process.env) {
+    const org = env.TEWIP_AZURE_ORG?.trim();
+    const project = env.TEWIP_AZURE_PROJECT?.trim();
+    if (!org || !project)
+        return null;
+    return { org, project, token: (env.TEWIP_AZURE_TOKEN ?? env.SYSTEM_ACCESSTOKEN ?? '').trim() };
+}
+/** Azure's own names for the kinds of work. A project template may not have all of them. */
+const AZURE_TYPE = {
+    'test-case': ['Test Case', 'Task'],
+    bug: ['Bug', 'Issue'],
+    story: ['User Story', 'Product Backlog Item', 'Issue'],
+    epic: ['Epic', 'Feature'],
+};
+export class AzureBoards {
+    name = 'Azure Boards';
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    canWrite() {
+        return Boolean(this.config.token);
+    }
+    headers(contentType = 'application/json') {
+        // Azure takes the token as the password of a basic login with an empty user.
+        return { Authorization: `Basic ${Buffer.from(`:${this.config.token}`).toString('base64')}`, Accept: 'application/json', 'Content-Type': contentType };
+    }
+    base() {
+        return `https://dev.azure.com/${encodeURIComponent(this.config.org)}/${encodeURIComponent(this.config.project)}/_apis`;
+    }
+    async request(method, url, body, contentType) {
+        const res = await fetch(url, { method, headers: this.headers(contentType), body: body ? JSON.stringify(body) : undefined });
+        if (!res.ok)
+            throw new Error(`Azure Boards ${method} ${url.replace(/\?.*/, '')} -> ${res.status}: ${(await res.text()).slice(0, 300)}`);
+        return (res.status === 204 ? undefined : await res.json());
+    }
+    /** Work items carrying Tewip's tag. Azure answers a query with ids, which are then read. */
+    async mine(_project, label) {
+        const wiql = { query: `SELECT [System.Id] FROM WorkItems WHERE [System.Tags] CONTAINS '${label.replace(/'/g, "''")}'` };
+        const found = await this.request('POST', `${this.base()}/wit/wiql?api-version=7.0`, wiql);
+        const ids = (found.workItems ?? []).slice(0, 200).map((w) => w.id);
+        if (ids.length === 0)
+            return [];
+        const items = await this.request('GET', `${this.base()}/wit/workitems?ids=${ids.join(',')}&fields=System.Title&api-version=7.0`);
+        return (items.value ?? []).map((i) => ({ key: String(i.id), title: i.fields['System.Title'] ?? '' }));
+    }
+    async create(_project, item) {
+        // Azure creates a work item from a list of patch operations, not from an object.
+        const type = AZURE_TYPE[item.kind][0];
+        const patch = [
+            { op: 'add', path: '/fields/System.Title', value: item.title.slice(0, 250) },
+            { op: 'add', path: '/fields/System.Description', value: item.body.slice(0, 60_000).replace(/\n/g, '<br>') },
+        ];
+        if (item.labels?.length)
+            patch.push({ op: 'add', path: '/fields/System.Tags', value: item.labels.join('; ') });
+        const created = await this.request('POST', `${this.base()}/wit/workitems/$${encodeURIComponent(type)}?api-version=7.0`, patch, 'application/json-patch+json');
+        return String(created.id);
+    }
+    async comment(key, text) {
+        await this.request('POST', `${this.base()}/wit/workItems/${encodeURIComponent(key)}/comments?api-version=7.0-preview.3`, { text: text.slice(0, 60_000) });
+    }
+}
+export function linearFromEnv(env = process.env) {
+    const apiKey = env.TEWIP_LINEAR_KEY?.trim();
+    return apiKey ? { apiKey, team: (env.TEWIP_LINEAR_TEAM ?? '').trim() } : null;
+}
+export class Linear {
+    name = 'Linear';
+    config;
+    teamId = null;
+    constructor(config) {
+        this.config = config;
+    }
+    canWrite() {
+        return Boolean(this.config.apiKey && this.config.team);
+    }
+    /** Linear speaks GraphQL, and answers 200 with the errors inside the body. */
+    async graphql(query, variables = {}) {
+        const res = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: { Authorization: this.config.apiKey, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ query, variables }),
+        });
+        if (!res.ok)
+            throw new Error(`Linear -> ${res.status}: ${(await res.text()).slice(0, 300)}`);
+        const body = (await res.json());
+        if (body.errors?.length)
+            throw new Error(`Linear: ${body.errors.map((e) => e.message).join('; ').slice(0, 300)}`);
+        return body.data;
+    }
+    async team() {
+        if (this.teamId)
+            return this.teamId;
+        const data = await this.graphql('query { teams(first: 50) { nodes { id key } } }');
+        const found = data.teams.nodes.find((t) => t.key.toLowerCase() === this.config.team.toLowerCase());
+        if (!found)
+            throw new Error(`Linear has no team with the key "${this.config.team}". It has: ${data.teams.nodes.map((t) => t.key).join(', ')}`);
+        this.teamId = found.id;
+        return found.id;
+    }
+    async mine(_project, label) {
+        const data = await this.graphql('query($label: String!) { issues(first: 100, filter: { labels: { name: { eq: $label } } }) { nodes { identifier title url } } }', { label });
+        return data.issues.nodes.map((i) => ({ key: i.identifier, title: i.title, url: i.url }));
+    }
+    async create(_project, item) {
+        const teamId = await this.team();
+        const data = await this.graphql('mutation($input: IssueCreateInput!) { issueCreate(input: $input) { issue { identifier } } }', { input: { teamId, title: item.title.slice(0, 250), description: item.body.slice(0, 60_000) } });
+        return data.issueCreate.issue.identifier;
+    }
+    async comment(key, text) {
+        const found = await this.graphql('query($id: String!) { issue(id: $id) { id } }', { id: key });
+        if (!found.issue)
+            throw new Error(`Linear has no issue ${key}`);
+        await this.graphql('mutation($input: CommentCreateInput!) { commentCreate(input: $input) { success } }', { input: { issueId: found.issue.id, body: text.slice(0, 60_000) } });
+    }
+}

package/dist/engine/work/tracker.js

@@ -4,17 +4,22 @@ export const PRIORITY_WORDS = {
     jira: { P0: 'Highest', P1: 'High', P2: 'Medium' },
     rally: { P0: 'Resolve Immediately', P1: 'High Attention', P2: 'Normal' },
     github: { P0: 'priority:high', P1: 'priority:medium', P2: 'priority:low' },
+    azure: { P0: '1', P1: '2', P2: '3' },
+    linear: { P0: 'Urgent', P1: 'High', P2: 'Medium' },
 };
 export function priorityWord(tracker, priority) {
     return PRIORITY_WORDS[tracker]?.[priority] ?? priority;
 }
-/** Which tracker the settings point at. Jira stays the default, because most teams are there. */
 export function trackerNameFromEnv(env = process.env) {
     const named = (env.TEWIP_TRACKER ?? '').trim().toLowerCase();
-    if (named === 'rally' || named === 'github' || named === 'jira')
+    if (['jira', 'rally', 'github', 'azure', 'linear'].includes(named))
         return named;
     if (env.TEWIP_RALLY_KEY)
         return 'rally';
+    if (env.TEWIP_LINEAR_KEY)
+        return 'linear';
+    if (env.TEWIP_AZURE_ORG && env.TEWIP_AZURE_PROJECT)
+        return 'azure';
     if (env.TEWIP_GITHUB_REPO && !env.TEWIP_JIRA_URL)
         return 'github';
     return 'jira';
@@ -32,6 +37,12 @@ export function trackerHelp() {
         '  GitHub Issues',
         '    TEWIP_GITHUB_REPO=owner/name   TEWIP_GITHUB_TOKEN=ghp_...  (or be logged in with the gh CLI)',
         '',
-        'Set TEWIP_TRACKER=jira|rally|github when more than one is configured.',
+        '  Azure DevOps Boards',
+        '    TEWIP_AZURE_ORG=your-org   TEWIP_AZURE_PROJECT=your-project   TEWIP_AZURE_TOKEN=...',
+        '',
+        '  Linear',
+        '    TEWIP_LINEAR_KEY=lin_api_...   TEWIP_LINEAR_TEAM=ENG',
+        '',
+        'Set TEWIP_TRACKER=jira|rally|github|azure|linear when more than one is configured.',
     ].join('\n');
 }

package/dist/engine/work/trackers.js

@@ -6,6 +6,7 @@
 import { Jira, jiraFromEnv } from './jira.js';
 import { Rally, rallyFromEnv } from './rally.js';
 import { GitHubIssues, githubIssuesFromEnv } from './github-issues.js';
+import { AzureBoards, azureFromEnv, Linear, linearFromEnv } from './azure-linear.js';
 import { priorityWord, trackerHelp, trackerNameFromEnv } from './tracker.js';
 /** Jira, wearing the same interface as the rest. */
 export class JiraTracker {
@@ -66,6 +67,14 @@ export function trackerFromEnv(projectKey = '', env = process.env) {
         const config = githubIssuesFromEnv(env);
         return config ? { tracker: new GitHubIssues(config), project: projectKey || config.repo, id } : null;
     }
+    if (id === 'azure') {
+        const config = azureFromEnv(env);
+        return config ? { tracker: new AzureBoards(config), project: projectKey || config.project, id } : null;
+    }
+    if (id === 'linear') {
+        const config = linearFromEnv(env);
+        return config ? { tracker: new Linear(config), project: projectKey || config.team, id } : null;
+    }
     const config = jiraFromEnv();
     return config ? { tracker: new JiraTracker(new Jira(config), Boolean(config.token)), project: projectKey, id } : null;
 }

package/package.json

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