tewip-ai 0.5.0 → 0.6.0

package/README.md

@@ -164,6 +164,38 @@ from them): 38 checks, **0 differences reported on pages that match their design
 injected drifts caught** - a renamed button, a dropped sentence, a region that stopped being marked
 up. No designer has judged the output yet, so the roadmap's own metric is still open.
 
+## Epics, stories and acceptance criteria (Phase 14, new)
+
+```bash
+tewip spec "Readers can search the library and open a result"
+tewip spec "..." --project PROJ            # shows what it would file in Jira
+tewip spec "..." --project PROJ --create   # files the epic and its stories
+```
+
+An epic, user stories and Given / When / Then acceptance criteria, written from your code, your
+tests and your failure history. Anything it says the system **already** does carries a quote from a
+file it read, and Tewip checks that quote word by word; what it cannot quote becomes an open
+question instead of a confident sentence. It writes no estimates, dates or business cases, because
+it cannot check them.
+
+Measured on three real projects: 15 stories, 49 acceptance criteria, and of 46 claims about existing
+behaviour, **22 were kept with a checkable quote and 24 were turned into open questions**.
+
+## Any CI, your chat, and your own machine (Phase 13, new)
+
+```bash
+tewip report report.xml --gate      # GitLab CI, Jenkins, CircleCI, Azure, Bitbucket, Travis, Drone
+tewip watch --cmd "npm test"        # beside your editor: explains each failure as it happens
+tewip note --days 7                 # the weekly quality note for a lead - free, no model calls
+```
+
+`tewip report` reads which CI it is in from that platform's own variables, prints the triage board,
+writes it to a file, appends it to the job summary, and with `--gate` fails the build **only** on
+failures that are not known flaky or environment noise. On GitLab it posts the diagnosis as one
+merge-request note and edits that same note next run instead of piling up. With
+`TEWIP_SLACK_WEBHOOK` or `TEWIP_TEAMS_WEBHOOK` it tells the team's chat - and says nothing at all
+when no failure needs a person, so nobody mutes it.
+
 ## Fix the code, but only when the tests prove it (Phase 12, new, opt-in)
 
 ```bash
@@ -179,11 +211,17 @@ configuration, CI files, lockfiles, migrations or anything with secrets in it, b
 green after changing those proves nothing. If it cannot prove a change, it explains the bug instead
 and puts your file back byte for byte. It never commits and never merges.
 
-Measured by replaying **8 real bug fixes** from a public repository (unjs/ufo): the commit before
-each fix, with only that fix's tests, so the real bug reproduces. **4 of 8 got a change proved by
-the tests, 4 of 4 in the same file the developers changed, each a one-liner doing what the
-developers' own fix does. 0 wrong fixes were offered** - the other four were refused (three times
-the model wanted a 50-line rewrite, which the size rule threw away).
+Measured by replaying **16 real bug fixes** from two public repositories, in two languages: the
+commit before each fix, with only that fix's tests, so the real bug really reproduces.
+
+| Project | Language | Bugs | Proved by the tests | Right file |
+|---|---|---|---|---|
+| unjs/ufo | TypeScript, Vitest | 8 | **8** | 8 of 8 |
+| python-humanize/humanize | Python, pytest | 8 | **8** | 8 of 8 |
+
+Every change is small (1 to 16 lines, median 4) and most are what the developers themselves wrote.
+**No wrong fix was offered**: anything that could not be proved was thrown away and the file put
+back byte for byte.
 
 ## Where it has been tried
 

package/TEAM-GUIDE.md

@@ -121,6 +121,10 @@ collects environment failures in one issue, and (optionally) opens a fix pull re
 | `tewip write` | Turns the plan's scenarios into real tests in your own framework, and keeps only the ones that pass repeatedly **and** fail when their check is broken on purpose | When you know what to test but not how to write it |
 | `tewip plan --issue PROJ-123` | Plans from the Jira ticket itself: its description and acceptance criteria | "Here's the story, what should we test?" |
 | `tewip jira plan.json --project PROJ` | Files the plan's scenarios as test-case tickets, linked to the story | Handing work to the team |
+| `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 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" |
 | `tewip design <figma link> --url <page>` | Compares a Figma frame against the running page: the words the design specifies and the controls its layer names imply | "Did we build what was designed?" |
 | `tewip mcp` | Serves all of the above to your editor's AI assistant | Set up once |
@@ -134,6 +138,8 @@ Notes that save you time:
 - Everything it writes locally goes to the `.tewip` folder in your project.
 - `tewip jira` shows what it *would* file and creates nothing until you add `--create`. It never
   files the same scenario twice, and never moves, assigns or closes a ticket.
+- `tewip report` posts to Slack or Teams only when a failure needs a person (`TEWIP_SLACK_WEBHOOK`,
+  `TEWIP_TEAMS_WEBHOOK`). A run of known flaky tests pings nobody, on purpose.
 - `tewip design` needs a Figma read token (`TEWIP_FIGMA_TOKEN`), or a frame saved as JSON if you
   would rather not create one. It compares words, controls and page regions - never pixels, colours
   or spacing, because a design tool and a browser do not measure those the same way.
@@ -170,6 +176,11 @@ Notes that save you time:
   dependencies.
 - The quality view: flakiness hotspots and test-design debt, ranked by the CI time they waste.
 
+**Business analyst / product owner**
+- `tewip spec "<feature>"` writes the epic, the stories and the acceptance criteria from what the
+  code and tests actually do. Every "the system already does X" carries a quote you can check, and
+  anything it could not quote is listed as an open question for you to answer.
+
 **Designer, and the developer building from a design**
 - `tewip design <figma link> --url http://localhost:3000` after building a screen: it lists what the
   design says and what the page says, side by side, so a renamed button or a dropped sentence is

package/dist/ci/gate.js

@@ -0,0 +1,37 @@
+// The smart merge gate: fail the build on failures that need someone, let known noise through.
+// Flaky-test products quarantine tests they have flagged so they stop blocking merges; this does
+// the same per failure, from the diagnosis. It is conservative on purpose: only a deterministic
+// rule's or a person's TIMING/ENV verdict counts as noise. An AI-only verdict, a low confidence,
+// or anything undecided still blocks, because letting a real bug through costs far more than
+// asking a person to look at a flaky test.
+import { appendFileSync } from 'node:fs';
+/** Below this, even a rule's TIMING/ENV verdict is not trusted to let a failure through. */
+export const GATE_MIN_CONFIDENCE = 0.7;
+/** True when this failure is noise the gate may let through. */
+export function isNoise(item) {
+    const d = item.diagnosis;
+    const trusted = d.source === 'human' || (d.source === 'rules' && d.confidence >= GATE_MIN_CONFIDENCE);
+    return trusted && (d.category === 'TIMING' || d.category === 'ENV');
+}
+export function gate(items) {
+    return {
+        blocking: items.filter((i) => !isNoise(i)),
+        flaky: items.filter((i) => isNoise(i) && i.diagnosis.category === 'TIMING'),
+        environment: items.filter((i) => isNoise(i) && i.diagnosis.category === 'ENV'),
+    };
+}
+/** Writes the counts as step outputs, so later steps and workflows can act on them. */
+export function writeGateOutputs(file, result) {
+    if (!file)
+        return;
+    appendFileSync(file, `blocking=${result.blocking.length}\nflaky=${result.flaky.length}\nenvironment=${result.environment.length}\n`, 'utf8');
+}
+/** One line for the log saying what the gate decided and why. */
+export function gateSummary(result) {
+    const noise = result.flaky.length + result.environment.length;
+    if (result.blocking.length === 0) {
+        return noise === 0 ? 'gate: no failures' : `gate: passing - all ${noise} failure(s) are flaky (${result.flaky.length}) or environment (${result.environment.length}), classified by a rule or a person`;
+    }
+    const names = result.blocking.slice(0, 5).map((i) => `${i.title} (${i.diagnosis.category}${i.diagnosis.source === 'llm' ? ', AI only' : ''})`);
+    return `gate: failing - ${result.blocking.length} failure(s) need someone: ${names.join('; ')}${result.blocking.length > 5 ? '; ...' : ''}${noise ? `. ${noise} other failure(s) are flaky or environment and do not block` : ''}`;
+}

package/dist/cli/tewip.js

@@ -38,6 +38,25 @@ Usage:
                                     File the plan's scenarios as test-case issues, linked to the
                                     story. Shows what it would create; --create actually files
                                     them, and the same scenario is never filed twice.
+  tewip spec "<feature>" [--diff main...HEAD] [--url <page> ...] [--project PROJ] [--create]
+                                    An epic, its user stories and their acceptance criteria, from
+                                    this project's code, tests and failure history. Anything it
+                                    says the system already does is quoted from a file it read;
+                                    what it cannot quote becomes an open question. With --project it
+                                    shows what it would file in Jira; --create files it.
+  tewip report <report> [--gate] [--out report.md] [--name <project>] [--no-post]
+                                    The CI command for any platform: GitLab CI, Jenkins, CircleCI,
+                                    Azure, Bitbucket, Travis, Drone. Diagnoses the run, comments on
+                                    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 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
+                                    happens, without CI.
+  tewip note [--days 7] [--name <project>] [--out note.md] [--post]
+                                    The weekly quality note for a lead, written from the runs Tewip
+                                    already diagnosed. No model calls, so it costs nothing.
   tewip fix --code <report> [--only "<test title>"] [--max 3] [--apply] [--suite "<command>"]
                                     Opt-in: for failures diagnosed as a real bug, propose the
                                     smallest change to application code, and keep it only if the
@@ -132,6 +151,63 @@ async function main() {
             });
             return;
         }
+        case 'spec': {
+            const feature = args.filter((a, i) => !a.startsWith('--') && !['--diff', '--url', '--out', '--project'].includes(args[i - 1] ?? '')).join(' ').trim();
+            if (!feature)
+                throw new Error('usage: tewip spec "<what the feature should do>" [--diff main...HEAD] [--url http://localhost:3000/page] [--project PROJ] [--create]');
+            const { runSpec } = await import('../engine/spec/spec-command.js');
+            await runSpec({
+                feature,
+                root: process.cwd(),
+                diffRange: flag(args, 'diff'),
+                urls: args.flatMap((a, i) => (args[i - 1] === '--url' ? [a] : [])),
+                out: flag(args, 'out'),
+                projectKey: flag(args, 'project'),
+                create: args.includes('--create'),
+            });
+            return;
+        }
+        case 'report': {
+            const report = args.find((a, i) => !a.startsWith('--') && !['--out', '--name'].includes(args[i - 1] ?? ''));
+            if (!report)
+                throw new Error('usage: tewip report <report.xml | reports-dir | blob-report-dir> [--gate] [--out report.md] [--name project] [--no-post]');
+            process.env.TEWIP_LLM_CACHE ??= join(process.cwd(), '.tewip', 'llm-cache.jsonl');
+            const { runReport } = await import('../engine/ci/report-command.js');
+            const result = await runReport({
+                root: process.cwd(),
+                report,
+                name: flag(args, 'name'),
+                out: flag(args, 'out'),
+                gate: args.includes('--gate'),
+                post: !args.includes('--no-post'),
+            });
+            // The gate fails the build only for failures that are not known flaky or environment noise.
+            if (args.includes('--gate') && result.blocking > 0)
+                process.exitCode = 1;
+            return;
+        }
+        case 'watch': {
+            const { runWatch } = await import('../engine/watch/watch-command.js');
+            await runWatch({
+                root: process.cwd(),
+                cmd: flag(args, 'cmd'),
+                report: flag(args, 'report'),
+                paths: (flag(args, 'paths') ?? '').split(',').map((s) => s.trim()).filter(Boolean),
+                once: args.includes('--once'),
+            });
+            return;
+        }
+        case 'note': {
+            const { runNote } = await import('../engine/notify/note-command.js');
+            await runNote({
+                root: process.cwd(),
+                name: flag(args, 'name'),
+                days: Math.max(1, Number(flag(args, 'days')) || 7),
+                out: flag(args, 'out'),
+                post: args.includes('--post'),
+            });
+            return;
+        }
         case 'fix': {
             // Changing application code is the one thing Tewip has always refused, so it happens only
             // when a person asks for it by name. Without --code, this says so rather than guessing.

package/dist/engine/autofix/code-command.js

@@ -13,6 +13,7 @@ import { HistoryIndex } from '../history.js';
 import { importJunit } from '../import/junit.js';
 import { importBlobReportDir } from '../import/blob.js';
 import { llmFromEnv } from '../llm/client.js';
+import { writerFromEnv } from '../quality/model.js';
 import { usageLine } from '../llm/usage.js';
 import { buildItems } from '../../outlets/items.js';
 import { chooseFramework, detectFrameworks } from '../quality/frameworks.js';
@@ -30,7 +31,8 @@ function testFileOf(file, root) {
     return existsSync(direct) ? direct : null;
 }
 export async function runCodeFix(cmd) {
-    const model = llmFromEnv();
+    // Fixing code is writing code, so it uses the writing model, not the small triage one.
+    const model = writerFromEnv(cmd.root);
     if (!model)
         throw new Error('fixing code needs a model. Set TEWIP_API_KEY (and TEWIP_PROVIDER), or OPENAI_API_KEY.');
     const path = resolve(cmd.report);

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

@@ -14,6 +14,7 @@
 import { relative, resolve, sep } from 'node:path';
 import { codeTarget, mayChange } from './code-target.js';
 import { excerpt, proposeCodeFix } from './code-propose.js';
+import { countChanged, lineDiff, renderDiff } from './line-diff.js';
 /**
  * The runner never ran the test: a missing module, a reporter or config it could not load, a
  * browser that never started. The test did not fail - it never happened - so a change afterwards
@@ -21,51 +22,42 @@ import { excerpt, proposeCodeFix } from './code-propose.js';
  * running the fixer against real bug fixes with a mistyped runner flag: every case looked like a
  * failing test, and every fix looked like it did not work.)
  */
-const NEVER_RAN = /No test files found|Failed to load url|Cannot find module|ERR_MODULE_NOT_FOUND|has not captured in \d+ ?ms|No captured browser|EADDRINUSE|webServer.{0,60}(?:exited|timed out)|command not found|is not recognized as an internal/i;
+const NEVER_RAN = /No test files found|Failed to load url|Cannot find module|ModuleNotFoundError|ImportError while importing test module|ERR_MODULE_NOT_FOUND|has not captured in \d+ ?ms|No captured browser|EADDRINUSE|webServer.{0,60}(?:exited|timed out)|command not found|is not recognized as an internal/i;
 /** More changed lines than this is a rewrite, not a bug fix, whatever the model calls it. */
 export const MAX_CHANGED_LINES = 20;
 /** How many times the model may try before Tewip gives up and explains instead. */
-export const MAX_ATTEMPTS = 2;
-/** A unified diff of one replacement, for a person to read. */
+export const MAX_ATTEMPTS = 3;
+const CR = String.fromCharCode(13);
+const NL = String.fromCharCode(10);
+/**
+ * Which other tests a change broke, by name. A tail of runner output is mostly noise; the names of
+ * the tests that used to pass say what behaviour the fix must keep, and that is what the next
+ * attempt needs to hear.
+ */
+export function failingTests(output) {
+    const names = [
+        ...output.matchAll(/^(?:FAILED|ERROR)\s+(\S+)/gm), // pytest
+        ...output.matchAll(/^\s*(?:FAIL|×)\s+(.+?)(?:\s+\d+\s*ms)?$/gm), // vitest, jest
+        ...output.matchAll(/^\s*\d+\)\s+(.+)$/gm), // mocha
+        ...output.matchAll(/^\s*\[FAIL\]\s+(.+)$/gm), // .NET
+    ]
+        .map((m) => m[1].trim())
+        .filter((name) => name.length > 0 && !/^\d+$/.test(name));
+    return [...new Set(names)];
+}
+/** Those names, said in one line for the model to read. */
+export function brokeWhat(names, fallback, max = 8) {
+    if (names.length === 0)
+        return fallback.slice(-400);
+    return `${names.slice(0, max).join(', ')}${names.length > max ? `, and ${names.length - max} more` : ''}`;
+}
+/** The patch a reviewer reads: real hunks, not the whole span between the first and last change. */
 export function changeDiff(file, original, changed) {
-    const a = original.split('\n');
-    const b = changed.split('\n');
-    let start = 0;
-    while (start < a.length && start < b.length && a[start] === b[start])
-        start++;
-    let endA = a.length - 1;
-    let endB = b.length - 1;
-    while (endA > start && endB > start && a[endA] === b[endB]) {
-        endA--;
-        endB--;
-    }
-    const context = 3;
-    const from = Math.max(0, start - context);
-    const lines = [`--- a/${file}`, `+++ b/${file}`, `@@ -${from + 1},${endA - from + 1 + context} +${from + 1},${endB - from + 1 + context} @@`];
-    for (let i = from; i < start; i++)
-        lines.push(` ${a[i]}`);
-    for (let i = start; i <= endA; i++)
-        lines.push(`-${a[i]}`);
-    for (let i = start; i <= endB; i++)
-        lines.push(`+${b[i]}`);
-    for (let i = endA + 1; i <= Math.min(a.length - 1, endA + context); i++)
-        lines.push(` ${a[i]}`);
-    return lines.join('\n');
+    return renderDiff(file, lineDiff(original, changed));
 }
-/** How many lines the change touches, counted on both sides. */
+/** How many lines a change really adds or removes, counted from that same diff. */
 export function changedLines(original, changed) {
-    const a = original.split('\n');
-    const b = changed.split('\n');
-    let start = 0;
-    while (start < a.length && start < b.length && a[start] === b[start])
-        start++;
-    let endA = a.length - 1;
-    let endB = b.length - 1;
-    while (endA >= start && endB >= start && a[endA] === b[endB]) {
-        endA--;
-        endB--;
-    }
-    return Math.max(0, endA - start + 1) + Math.max(0, endB - start + 1);
+    return countChanged(lineDiff(original, changed));
 }
 export async function attemptCodeFix(input, deps, { keep = false } = {}) {
     const { record, diagnosis, action } = input;
@@ -100,14 +92,30 @@ export async function attemptCodeFix(input, deps, { keep = false } = {}) {
         return stop('test-never-ran', `the test never ran, so nothing can be proved here: ${said?.trim().slice(0, 200)}`);
     }
     result.log.push('the test fails before any change, as expected');
+    // What is already broken here, before Tewip touches anything. Real projects have failing and
+    // skipped tests of their own, and a repository checked out at an older commit has more; blaming a
+    // fix for those would reject every correct change, which is exactly what happened in a measurement
+    // before this existed. The suite is read once, lazily, and only to know what NOT to blame.
+    let baseline = null;
+    const alreadyFailing = async () => {
+        if (!baseline) {
+            const run = await deps.runSuite();
+            baseline = new Set(run.passed ? [] : failingTests(run.output));
+            if (baseline.size > 0)
+                result.log.push(`${baseline.size} test(s) in this project were already failing before any change, and are not counted against the fix`);
+        }
+        return baseline;
+    };
     // The bug is not always in the first file that looked right. When the model says the cause is not
     // in the file it was given, the next candidate is tried rather than the whole attempt abandoned.
     let last = stop('no-target', why || 'nothing to change');
+    const trail = [];
     for (const candidate of [target, ...more]) {
-        const outcome = await tryFile(candidate, input, deps, { keep, result: { ...result, file: relative(resolve(deps.root), candidate.file) } });
+        const outcome = await tryFile(candidate, input, deps, { keep, alreadyFailing, result: { ...result, file: relative(resolve(deps.root), candidate.file) } });
         if (outcome.status === 'fixed')
-            return outcome;
-        last = outcome;
+            return { ...outcome, log: [...trail, ...outcome.log] };
+        trail.push(`${relative(resolve(deps.root), candidate.file)}: ${outcome.status}`);
+        last = { ...outcome, log: [...trail, ...outcome.log] };
         if (outcome.status !== 'model-declined' && outcome.status !== 'change-not-found')
             break;
         if (more.length > 0)
@@ -116,11 +124,17 @@ export async function attemptCodeFix(input, deps, { keep = false } = {}) {
     return last;
 }
 /** One file: ask, check the change is small and exact, apply, run the test, run the suite. */
-async function tryFile(target, input, deps, { keep, result }) {
+async function tryFile(target, input, deps, { keep, result, alreadyFailing }) {
     const { record } = input;
     const rel = relative(resolve(deps.root), target.file);
     const stop = (status, why) => ({ ...result, status, why, log: [...result.log, why] });
-    const original = deps.readFile(target.file);
+    // A checkout on Windows has CRLF line endings; a model answers in LF. Comparing them directly
+    // threw away four correct fixes in a real measurement, so both sides are read in LF here and the
+    // file is written back in whatever it used.
+    const raw = deps.readFile(target.file);
+    const crlf = raw.includes(CR + NL);
+    const asFile = (text) => (crlf ? text.split(NL).join(CR + NL) : text);
+    const original = crlf ? raw.split(CR + NL).join(NL) : raw;
     const piece = excerpt(original, target.line);
     const earlier = [];
     for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
@@ -142,7 +156,9 @@ async function tryFile(target, input, deps, { keep, result }) {
         if (change.fault === 'test' || !change.before.trim()) {
             return stop('model-declined', `no code change offered: ${change.why || 'the cause is not visible in this file'}`);
         }
-        const occurrences = original.split(change.before).length - 1;
+        const before = change.before.split(CR + NL).join(NL);
+        const after = change.after.split(CR + NL).join(NL);
+        const occurrences = original.split(before).length - 1;
         if (occurrences !== 1) {
             earlier.push(`attempt ${attempt}: the text to replace ${occurrences === 0 ? 'was not in the file' : `appeared ${occurrences} times`}`);
             result.attempts.push({ file: rel, changedLines: 0, detail: earlier.at(-1) });
@@ -150,7 +166,7 @@ async function tryFile(target, input, deps, { keep, result }) {
                 return stop('change-not-found', `the proposed change does not match the file exactly (${earlier.at(-1)})`);
             continue;
         }
-        const changed = original.replace(change.before, change.after);
+        const changed = original.replace(before, after);
         const touched = changedLines(original, changed);
         if (touched > MAX_CHANGED_LINES) {
             earlier.push(`attempt ${attempt}: the change touched ${touched} lines, which is a rewrite rather than a fix`);
@@ -160,22 +176,26 @@ async function tryFile(target, input, deps, { keep, result }) {
             continue;
         }
         // 5 and 6. The test, then everything else. The file goes back unless both hold.
-        deps.writeFile(target.file, changed);
+        deps.writeFile(target.file, asFile(changed));
         try {
             const after = await deps.runTest();
             if (!after.passed) {
                 earlier.push(`attempt ${attempt}: the test still failed after the change: ${after.output.slice(-400)}`);
                 result.attempts.push({ file: rel, changedLines: touched, detail: 'the test still failed' });
-                deps.writeFile(target.file, original);
+                deps.writeFile(target.file, raw);
                 if (attempt === MAX_ATTEMPTS)
                     return stop('still-failing', 'the test still failed after every change tried, so the file was put back');
                 continue;
             }
             const suite = await deps.runSuite();
-            if (!suite.passed) {
-                earlier.push(`attempt ${attempt}: the test passed but other tests broke: ${suite.output.slice(-400)}`);
+            // A change is rejected for what it broke, not for what was broken before it.
+            const failingNow = failingTests(suite.output);
+            const wasFailing = suite.passed ? new Set() : await alreadyFailing();
+            const brokeNow = failingNow.filter((name) => !wasFailing.has(name));
+            if (!suite.passed && (brokeNow.length > 0 || failingNow.length === 0)) {
+                earlier.push(`attempt ${attempt}: the failing test passed, but this change broke tests that were passing: ${brokeWhat(brokeNow, suite.output)}. Those describe behaviour the code must keep. Fix the reported bug without changing what they rely on.`);
                 result.attempts.push({ file: rel, changedLines: touched, detail: 'other tests broke' });
-                deps.writeFile(target.file, original);
+                deps.writeFile(target.file, raw);
                 if (attempt === MAX_ATTEMPTS)
                     return stop('broke-others', 'the change made this test pass by breaking others, so the file was put back');
                 continue;
@@ -184,11 +204,11 @@ async function tryFile(target, input, deps, { keep, result }) {
             result.log.push(`the test passes with the change, and the rest of the suite still passes (${touched} line(s) changed in ${rel})`);
             const diff = changeDiff(rel, original, changed);
             if (!keep)
-                deps.writeFile(target.file, original);
+                deps.writeFile(target.file, raw);
             return { ...result, status: 'fixed', applied: keep, before: change.before, after: change.after, why: change.why, diff };
         }
         catch (error) {
-            deps.writeFile(target.file, original);
+            deps.writeFile(target.file, raw);
             throw error;
         }
     }

package/dist/engine/autofix/code-propose.js

@@ -30,7 +30,7 @@ export async function proposeCodeFix(model, ctx) {
  * against real bug fixes the model copied text that still carried those numbers: the change matched
  * nothing in the file and was thrown away for a reason that was Tewip's fault, not the model's.
  */
-export function excerpt(source, around = 1, maxLines = 500) {
+export function excerpt(source, around = 1, maxLines = 900) {
     const lines = source.split('\n');
     if (lines.length <= maxLines)
         return { text: source, from: 1 };

package/dist/engine/autofix/code-target.js

@@ -19,6 +19,7 @@ const FRAME_PATTERNS = [
     /([\w.\-/\\]+\.(?:rb|php)):(\d+)/g, // Ruby, PHP
     / in ([A-Za-z]:[^():\s]+|\/[^():\s]+):line (\d+)/g, // .NET
     /[❯>]\s+(?:[\w$.]+ )?([\w.\-/\\]+\.[cm]?[jt]sx?):(\d+):\d+/g, // Vitest and Jest: "❯ src/utils.ts:35:11"
+    /^\s*([\w.\-/\\]+\.(?:py|rb|php|java|kt|cs|go)):(\d+):/gm, // pytest and friends: "src/humanize/number.py:164: OverflowError"
 ];
 /** Files that are tests, not the code under test. */
 export const isTestFile = (path) => /(?:^|[\\/])(?:tests?|spec|specs|__tests__|e2e|cypress|testing)[\\/]/i.test(path) ||
@@ -90,18 +91,22 @@ export function codeTarget(stack, root, test, hint = '') {
         refused.push(`${rel} (${verdict.why})`);
     }
     if (test) {
-        const imported = sourceUnderTest(test.file, test.source, root);
+        const imported = sourceUnderTest(test.file, test.source, root) ?? pythonModule(test.source, root);
         // A project with one module per feature exports them all through one file, so the file the test
         // imports is often not the file with the bug. The name of the failing test says which function
         // it is about, so the file that defines that function comes first.
         const byName = definers(imported ? dirname(imported) : dirname(test.file), hint, test.source.slice(0, 2000));
-        const ordered = [...byName, ...(imported && !byName.includes(imported) ? [imported] : [])].filter((f) => mayChange(f).allowed);
+        const ordered = [...byName, ...(imported && !byName.some((d) => d.file === imported) ? [{ file: imported, line: 1 }] : [])]
+            .filter((d) => mayChange(d.file).allowed)
+            // A file that only re-exports other files holds no bug, and offering it wastes an attempt:
+            // in a real run the model rightly answered "this only imports and re-exports that function".
+            .filter((d) => !isReExportOnly(d.file));
         if (ordered.length > 0) {
-            const say = (f) => `nothing threw inside the code, so the file that defines what the test is about was read: ${relative(resolve(root), f)}`;
+            const say = (d) => `nothing threw inside the code, so the file that defines what the test is about was read: ${relative(resolve(root), d.file)}${d.line > 1 ? `, around line ${d.line}` : ''}`;
             return {
-                target: { file: ordered[0], line: 1, why: say(ordered[0]) },
+                target: { ...ordered[0], why: say(ordered[0]) },
                 why: '',
-                more: ordered.slice(1, 3).map((f) => ({ file: f, line: 1, why: say(f) })),
+                more: ordered.slice(1, 3).map((d) => ({ ...d, why: say(d) })),
             };
         }
     }
@@ -109,6 +114,49 @@ export function codeTarget(stack, root, test, hint = '') {
         return { target: null, why: 'the failure has no stack trace pointing inside this project, and the test imports no file from it', more: [] };
     return { target: null, why: `every file the failure names is one Tewip may not change: ${refused.slice(0, 3).join('; ')}`, more: [] };
 }
+/**
+ * A file that defines no function and no class: a package's front door, which re-exports what other
+ * files implement. There is no bug to fix in one, and offering it wastes an attempt - in a real run
+ * the model answered, correctly, "this only imports and re-exports that function".
+ */
+export function isReExportOnly(file) {
+    try {
+        const source = readFileSync(file, 'utf8');
+        const defines = /^\s*(?:async\s+)?def\s+\w|^\s*class\s+\w|(?:export\s+)?(?:function|class)\s+\w|=>\s*[{(]/m;
+        return !defines.test(source);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The project's own module a Python test imports. Python has no relative paths in an import, so the
+ * dotted name is turned back into a file under the layouts real projects use: `src/` beside the
+ * root, a package folder, or a single module.
+ */
+function pythonModule(testSource, root) {
+    if (!/^\s*(?:from|import)\s+[\w.]+/m.test(testSource))
+        return null;
+    const modules = [...testSource.matchAll(/^\s*(?:from|import)\s+([\w.]+)/gm)]
+        .map((m) => m[1])
+        .filter((name) => !name.startsWith('.') && !STANDARD.has(name.split('.')[0]));
+    for (const dotted of modules) {
+        const parts = dotted.split('.');
+        // A submodule ("humanize.number") is a better answer than the package itself.
+        for (const depth of [parts.length, 1]) {
+            const head = parts.slice(0, depth);
+            for (const base of [join(root, 'src'), root]) {
+                for (const candidate of [join(base, ...head) + '.py', join(base, ...head, '__init__.py')]) {
+                    if (existsSync(candidate) && statSync(candidate).isFile() && !isTestFile(candidate))
+                        return candidate;
+                }
+            }
+        }
+    }
+    return null;
+}
+/** Modules that are never the code under test, so an import of them says nothing. */
+const STANDARD = new Set(['pytest', 'unittest', 'os', 'sys', 're', 'json', 'math', 'time', 'datetime', 'typing', 'pathlib', 'collections', 'decimal', 'itertools', 'functools', 'random', 'string', 'subprocess', 'freezegun', 'mock', 'hypothesis', '__future__']);
 /**
  * The source files in a folder that define the functions named in the failure, best match first.
  * This is what tells `parseQuery` in src/query.ts apart from everything else exported by src/.
@@ -123,16 +171,23 @@ function definers(dir, named, mentioned = '') {
     const weak = words(mentioned).filter((n) => !strong.includes(n));
     if (strong.length === 0 && weak.length === 0)
         return [];
-    const defines = (source, name) => new RegExp(String.raw `(?:export\s+(?:async\s+)?(?:function|const|class)\s+|^def\s+)${name}\b`, 'm').test(source);
+    // Where a name is defined, not merely whether it is: a 600-line module keeps the function under
+    // test well past the point where a long file has to be cut, and the model must be sent that part.
+    const definition = (source, name) => {
+        const at = new RegExp(String.raw `(?:export\s+(?:async\s+)?(?:function|const|class)\s+|^\s*def\s+)${name}\b`, 'm').exec(source);
+        return at ? source.slice(0, at.index).split('\n').length : 0;
+    };
     const scored = [];
     for (const entry of readdirSync(dir)) {
         const file = join(dir, entry);
         if (!/\.[cm]?[jt]sx?$|\.py$/.test(entry) || isTestFile(file) || !statSync(file).isFile())
             continue;
         const source = readFileSync(file, 'utf8');
-        const score = strong.filter((n) => defines(source, n)).length * 5 + weak.filter((n) => defines(source, n)).length;
+        const strongAt = strong.map((n) => definition(source, n)).filter((line) => line > 0);
+        const weakAt = weak.map((n) => definition(source, n)).filter((line) => line > 0);
+        const score = strongAt.length * 5 + weakAt.length;
         if (score > 0)
-            scored.push({ file, score });
+            scored.push({ file, line: strongAt[0] ?? weakAt[0] ?? 1, score });
     }
-    return scored.sort((a, b) => b.score - a.score).map((s) => s.file);
+    return scored.sort((a, b) => b.score - a.score).map(({ file, line }) => ({ file, line }));
 }