tewip-ai 0.40.0 → 0.42.0

package/README.md

@@ -576,6 +576,40 @@ With `--json` the verdict is **sealed**: editing `not-ready` to `ready` in the f
 fail, so a verdict that travels into a ticket or a release note can be checked rather than trusted. It is
 also an MCP tool, so an agent can ask whether its own work is done before saying that it is.
 
+## Tewip as a peer other agents must satisfy (Phase 34, new)
+
+```bash
+tewip a2a                 # serves on 127.0.0.1:41241
+```
+
+MCP lets an assistant call Tewip as a tool. **A2A is the other direction**: Tewip as an agent in its
+own right, which another agent has to get past before its work counts as finished. That is the right
+shape for a tool whose whole claim is proving work *written by a person or by an agent* — when most
+code is written by agents, the thing that checks it has to be reachable by agents.
+
+It serves the card at `/.well-known/agent-card.json` and answers JSON-RPC `SendMessage`, with eight
+skills: triage, vouch, pick, schema, access, perf, standards and done.
+
+**It asks rather than guesses.** Send "check my code" and you get back a question naming the eight
+things Tewip answers — A2A has a state for exactly that, `TASK_STATE_INPUT_REQUIRED`:
+
+```
+TASK_STATE_INPUT_REQUIRED
+Tewip will not guess which question you are asking: that could be "Does this keep the
+team's own rules?" or "Is this work actually finished?", and Tewip will not pick for you.
+```
+
+**The guardrails are the design.** This is an HTTP port that runs commands against your repository:
+
+- **Only read-only skills are reachable.** `fix`, `write`, `build`, `pursue` and `prove` are not on
+  the list — they change files or run your suite. A test asserts they never can be.
+- **It listens on this machine alone** unless you pass `--host`, and says plainly what that means.
+- **Every request is recorded** in `.tewip/a2a.jsonl`.
+
+Its card declares `streaming: false` and `pushNotifications: false`, and those operations return an
+error naming the field that says why. Declaring a capability you have not implemented is the one
+thing an agent card must not do.
+
 ## Is this change slower? (Phase 30, new)
 
 ```bash
@@ -836,7 +870,7 @@ That last section is the part no SQL linter does: it searches your own code for
 away. "This drops `users.nickname`, and four files still read it" is a different sentence from "dropping a
 column is risky", and it is the one that stops the outage.
 
-It reads **SQL, Django, Rails, Alembic and TypeORM** migrations — which covers Prisma, Drizzle, Flyway
+It reads **SQL, Django, Rails, Alembic, TypeORM, Sequelize, Knex, EF Core and Liquibase** migrations — which covers Prisma, Drizzle, Flyway
 and golang-migrate too, since those all emit plain `.sql`. It judges **only the forward path** (a rollback step
 contains the mirror image of the change, so reading it says a migration that creates a table destroys
 one), and stays quiet when the team already did the safe thing — `atomic = False`, `algorithm:

package/dist/cli/help.js

@@ -157,9 +157,11 @@ Usage:
                                     What will this migration do to a live database? Names the changes
                                     that break the version still running during a deploy, destroy data,
                                     block writes while they run, or cannot be undone - and searches your
-                                    code for what still uses the column it takes away. Reads SQL, Django,
-                                    Rails and Alembic migrations, and says so when it cannot read one.
-                                    No model, no cost.
+                                    code for what still uses the column it takes away. Reads SQL,
+                                    Django, Rails, Alembic, TypeORM, Sequelize, Knex, EF Core and
+                                    Liquibase - so Prisma, Drizzle, Flyway and golang-migrate too,
+                                    since those emit plain SQL - and says so when it cannot read one.
+                                    It judges only the forward path, never the rollback. No cost.
   tewip pick [--diff main...HEAD] [--list] [--out picked.md]
                                     Which tests could notice this change? Narrows a test run using
                                     facts rather than a prediction: a test runs when it imports a
@@ -212,6 +214,14 @@ Usage:
                                     it too. --verify says what it checked and what that does not
                                     establish - a digest means undamaged, not unedited. No cost.
   tewip mcp                         Serve Tewip over MCP (stdio) for an editor or AI assistant.
+  tewip a2a [--port 41241] [--host 127.0.0.1]
+                                    Answer other agents over A2A, so an agent that writes a diff has
+                                    a peer it must satisfy. Serves the agent card at
+                                    /.well-known/agent-card.json and takes JSON-RPC "SendMessage".
+                                    Only the read-only skills are reachable - nothing it exposes
+                                    writes a file - it listens on this machine alone unless you pass
+                                    --host, and every request is recorded in .tewip/a2a.jsonl. A
+                                    message it cannot place comes back as a question, not a guess.
   tewip --version                   Print the version.
 
 Reports it reads: Playwright, pytest/unittest, Jest, Vitest, Mocha, node:test, JUnit/TestNG

package/dist/cli/verbs-prove.js

@@ -20,6 +20,19 @@ export async function proveVerb(verb, args) {
             });
             return true;
         }
+        case 'a2a': {
+            const { serveA2A } = await import('../engine/a2a/serve.js');
+            const { dirname, join } = await import('node:path');
+            serveA2A({
+                root: process.cwd(),
+                port: Number(flag(args, 'port') ?? '41241'),
+                // Loopback unless somebody asks for otherwise in so many words. The server runs commands
+                // against a repository and has no authentication, so the default must be the safe one.
+                host: flag(args, 'host') ?? '127.0.0.1',
+                tewipRoot: join(dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1')), '..'),
+            });
+            return true;
+        }
         case 'perf': {
             const { runPerf } = await import('../engine/perf/perf-command.js');
             const paths = args.filter((a, i) => !a.startsWith('--') && !['--out', '--label'].includes(args[i - 1] ?? ''));

package/dist/engine/a2a/answer.js

@@ -0,0 +1,125 @@
+// Phase 34: turning another agent's message into one of Tewip's verdicts.
+//
+// The interesting decision here is what to do when the message is vague, and the answer is the same
+// one the rest of this project gives: ask rather than guess. A2A has a state for exactly that -
+// TASK_STATE_INPUT_REQUIRED - so a caller who says "check my code" gets back a question naming the
+// skills Tewip has, not a guess at which of eight things they meant. Guessing would make Tewip
+// occasionally run a twenty-minute job nobody asked for, and occasionally answer the wrong question
+// confidently, which is the failure this whole product exists to avoid.
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { ANSWERABLE, skillById } from './card.js';
+const str = (v) => (typeof v === 'string' ? v : '');
+/** The words in a message, from its text parts. A2A puts the text directly on the part. */
+export function textOf(message) {
+    if (!Array.isArray(message.parts))
+        return '';
+    return message.parts
+        .map((p) => (p && typeof p === 'object' ? str(p.text) : ''))
+        .filter((t) => t !== '')
+        .join(' ')
+        .trim();
+}
+/** A skill named outright, either in the message metadata or in a data part. */
+function namedSkill(message) {
+    const meta = (message.metadata ?? {});
+    const fromMeta = str(meta.skillId ?? meta.skill);
+    if (fromMeta !== '')
+        return fromMeta;
+    if (!Array.isArray(message.parts))
+        return '';
+    for (const part of message.parts) {
+        if (!part || typeof part !== 'object')
+            continue;
+        const data = part.data;
+        if (data && typeof data === 'object') {
+            const named = str(data.skillId ?? data.skill);
+            if (named !== '')
+                return named;
+        }
+    }
+    return '';
+}
+/** How well a skill matches some words: its own tags and name, scored by how specific the word is. */
+function scoreOf(skill, words) {
+    const haystack = `${skill.id} ${skill.verb} ${skill.name} ${skill.tags.join(' ')}`.toLowerCase();
+    let score = 0;
+    for (const word of words) {
+        if (word.length < 4)
+            continue;
+        if (haystack.includes(word))
+            score += word.length >= 7 ? 2 : 1;
+    }
+    return score;
+}
+/**
+ * Which skill a message is asking for.
+ *
+ * An id given outright always wins, because a calling agent that read the card should be taken at
+ * its word. Otherwise the words are matched, and a tie or a blank is a question rather than a coin
+ * toss: two skills scoring the same means Tewip genuinely does not know which was meant.
+ */
+export function chooseSkill(message) {
+    const asked = textOf(message);
+    const named = namedSkill(message);
+    if (named !== '') {
+        const skill = skillById(named);
+        if (skill)
+            return { kind: 'skill', skill, text: asked };
+        return { kind: 'unknown', asked: named };
+    }
+    const words = asked.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+    const scored = ANSWERABLE.map((skill) => ({ skill, score: scoreOf(skill, words) })).sort((a, b) => b.score - a.score);
+    const [best, next] = scored;
+    if (!best || best.score === 0) {
+        return { kind: 'ask', why: 'nothing in that message names one of the things Tewip answers' };
+    }
+    if (next && next.score === best.score) {
+        return { kind: 'ask', why: `that could be "${best.skill.name}" or "${next.skill.name}", and Tewip will not pick for you` };
+    }
+    return { kind: 'skill', skill: best.skill, text: asked };
+}
+/** The question Tewip asks back when it will not guess, listing what it can actually answer. */
+export function askWhich(why) {
+    const list = ANSWERABLE.map((s) => `- \`${s.id}\` — ${s.name}`).join('\n');
+    return [
+        `Tewip will not guess which question you are asking: ${why}.`,
+        '',
+        'Send the skill id in the message metadata as `skillId`, or say which of these you want:',
+        '',
+        list,
+    ].join('\n');
+}
+export function cliEntry() {
+    const here = import.meta.dirname;
+    for (const candidate of [join(here, '..', '..', 'cli', 'tewip.ts'), join(here, '..', '..', 'cli', 'tewip.js')]) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+/**
+ * Runs the verb and returns what it printed.
+ *
+ * The command line is the gate every one of these verdicts already goes through, so A2A reuses it
+ * rather than reaching into the engine: one code path means a verdict delivered to an agent cannot
+ * quietly differ from the same verdict delivered to a person.
+ */
+export function runSkill(root, skill, args, timeoutMs = 10 * 60_000) {
+    const entry = cliEntry();
+    if (entry === null)
+        return { text: 'Tewip could not find its own command line, so it cannot answer.', failed: true };
+    const ran = spawnSync(process.execPath, [entry, skill.verb, ...args], {
+        cwd: root,
+        encoding: 'utf8',
+        timeout: timeoutMs,
+        maxBuffer: 32 * 1024 * 1024,
+    });
+    if (ran.error)
+        return { text: `Tewip could not run \`${skill.verb}\`: ${ran.error.message}`, failed: true };
+    const out = `${ran.stdout ?? ''}${ran.stderr ? `\n${ran.stderr}` : ''}`.trim();
+    // A non-zero exit is how the gating verbs report a real problem, so it is an answer rather than a
+    // failure. Only an empty answer means something actually went wrong.
+    return { text: out === '' ? `\`${skill.verb}\` produced no output.` : out, failed: out === '' };
+}

package/dist/engine/a2a/card.js

@@ -0,0 +1,126 @@
+// Phase 34: the agent card, so other agents can find out what Tewip will answer.
+//
+// A2A is the one capability on the standard list that matches this product's thesis exactly. Tewip
+// exists to prove work "written by a person or by an agent", and MCP already lets an assistant call
+// it as a tool. A2A is the other direction: Tewip as a peer that another agent has to satisfy
+// before its diff counts as finished. When most code is written by agents, the thing that checks
+// the work has to be reachable by agents.
+//
+// Every field here was taken from the v1.0 specification rather than from memory, because four
+// details would have been wrong: discovery is `/.well-known/agent-card.json` and not `agent.json`;
+// the JSON-RPC method is `SendMessage` in PascalCase, not `message/send`; a role is `ROLE_USER`,
+// not `user`; and a task state is `TASK_STATE_COMPLETED`, not `completed`. Each of those is the
+// kind of mistake that produces a server nothing can talk to.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * The verbs a caller down a socket is allowed to reach, and the single rule behind the list:
+ * **everything here reads and nothing here writes.**
+ *
+ * `fix`, `write`, `build` and `pursue` change files; `prove` deliberately breaks a file and runs the
+ * suite before putting it back. None of those belongs behind an HTTP port that another program can
+ * reach. The whole guardrail story in this project is an allowlist of what may be done rather than
+ * a blocklist of what may not, and this is the same allowlist applied to a new door.
+ */
+export const ANSWERABLE = [
+    {
+        id: 'explain-failures',
+        verb: 'explain',
+        name: 'Why did these tests fail?',
+        description: 'Reads a test report and gives each failure a cause with the evidence for it: a real bug, a flaky test, the environment, the test data, or a changed selector. Answers "cannot say" rather than guessing.',
+        tags: ['testing', 'triage', 'ci', 'debugging'],
+        examples: ['Why did the checkout tests fail in this report?', 'Is this failure flaky or a real bug?'],
+    },
+    {
+        id: 'could-these-tests-fail',
+        verb: 'vouch',
+        name: 'Could these tests ever fail?',
+        description: 'Reads a test file and names the tests that check nothing: an assertion that compares a value with itself, an expectation left unfinished, a test with no assertion at all. A suite that cannot fail is not evidence.',
+        tags: ['testing', 'quality', 'review'],
+        examples: ['Can the tests in this file actually fail?'],
+    },
+    {
+        id: 'which-tests-notice',
+        verb: 'pick',
+        name: 'Which tests could notice this change?',
+        description: 'Narrows a test run from facts in the source, and refuses to narrow when it cannot show the rest are unaffected. Returns the files to run, or says it cannot be done safely.',
+        tags: ['testing', 'ci', 'performance'],
+        examples: ['Which tests do I need to run for this diff?'],
+    },
+    {
+        id: 'migration-safety',
+        verb: 'schema',
+        name: 'What will this migration do to a live database?',
+        description: 'Names what breaks the version still running during a rolling deploy, destroys data, blocks writes, or cannot be undone - and searches the repository for code that still uses a column being dropped. Reads SQL, Django, Rails, Alembic, TypeORM, Sequelize, Knex, EF Core and Liquibase, which covers Prisma, Drizzle and Flyway too.',
+        tags: ['database', 'migrations', 'deployment', 'risk'],
+        examples: ['Is this migration safe to deploy?', 'Will this drop break the running version?'],
+    },
+    {
+        id: 'accessibility',
+        verb: 'access',
+        name: 'Can everybody use this interface?',
+        description: 'Names the accessibility barriers that reading the markup proves, each against its WCAG 2.2 criterion and EN 301 549 clause, and keeps apart the ones only a person can settle. Always reports which criteria it could not check.',
+        tags: ['accessibility', 'wcag', 'compliance', 'frontend'],
+        examples: ['Is this component accessible?', 'What WCAG failures are in this page?'],
+    },
+    {
+        id: 'is-it-slower',
+        verb: 'perf',
+        name: 'Is this change slower?',
+        description: 'Judges a k6 or Lighthouse run against recorded baselines, and refuses to call a regression without at least three of them, because one run against one run cannot tell a change from a busy machine.',
+        tags: ['performance', 'benchmarking', 'regression'],
+        examples: ['Did this change make the checkout slower?'],
+    },
+    {
+        id: 'house-standards',
+        verb: 'standards',
+        name: "Does this keep the team's own rules?",
+        description: "Checks a change against the rules this team wrote down in .tewip/standards/, quoting the offending line and the team's own reason. Rules it enforces are kept apart from guidance it can only carry.",
+        tags: ['code-review', 'standards', 'conventions'],
+        examples: ['Does this change follow our conventions?'],
+    },
+    {
+        id: 'is-this-done',
+        verb: 'done',
+        name: 'Is this work actually finished?',
+        description: 'One verdict over a change, from layers that each have a measured accuracy: is anything failing, is the changed code tested by something that really reaches it, can those tests fail at all, and is what was asked for covered. Answers ready, not ready, or cannot say - and never rounds cannot say up to ready.',
+        tags: ['code-review', 'quality', 'verification'],
+        examples: ['Is this pull request ready to merge?', 'Is my change done?'],
+    },
+];
+/** The version Tewip is running, so the card does not claim a version it is not. */
+function versionOf(root) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+        return typeof pkg.version === 'string' ? pkg.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/**
+ * The card, built from the same list the server answers from, so the two cannot drift. A card that
+ * advertises a skill the server will not perform is worse than no card.
+ */
+export function agentCard(url, tewipRoot) {
+    return {
+        name: 'Tewip',
+        description: 'Proves software work, written by a person or by an agent. Triages a failing test to a cause with evidence, says whether a test could ever fail, reads what a migration will do to a live database, names who cannot use an interface, and gives one verdict on whether a change is done. It answers "cannot say" rather than guessing, and every answer carries what it did not check.',
+        supportedInterfaces: [{ url, transport: 'JSONRPC' }],
+        provider: { organization: 'Mamuti Aishan (Hasan)', url: 'https://github.com/hmamut39/tewip' },
+        version: versionOf(tewipRoot),
+        documentationUrl: 'https://github.com/hmamut39/tewip#readme',
+        // Both false, and the specification is explicit that an operation whose flag is false must
+        // return an error. Declaring a capability that is not implemented is the one thing a card must
+        // not do, and streaming a verdict that is computed in one step would buy nothing anyway.
+        capabilities: { streaming: false, pushNotifications: false, extendedAgentCard: false },
+        defaultInputModes: ['text/plain'],
+        defaultOutputModes: ['text/plain', 'text/markdown'],
+        skills: ANSWERABLE.map(({ verb: _verb, ...skill }) => skill),
+        iconUrl: 'https://raw.githubusercontent.com/hmamut39/tewip/main/assets/logo.svg',
+    };
+}
+/** The skill a caller asked for by id, if it is one Tewip answers. */
+export function skillById(id) {
+    return ANSWERABLE.find((s) => s.id === id);
+}

package/dist/engine/a2a/serve.js

@@ -0,0 +1,171 @@
+// Phase 34: serving Tewip to other agents over A2A.
+//
+// This is an HTTP port that runs commands against somebody's repository, so the guardrails are the
+// design rather than a footnote:
+//
+//   - **It listens on 127.0.0.1 and nowhere else** unless a person passes --host deliberately, and
+//     it says so loudly when they do. A quality tool that quietly opened a port on 0.0.0.0 would be
+//     a worse problem than any bug it found.
+//   - **Only the read-only skills are reachable.** The allowlist lives in card.ts; `fix`, `write`,
+//     `build`, `pursue` and `prove` are not on it, because they change files or run the suite.
+//   - **Every request is written to `.tewip/a2a.jsonl`**, the same way `pursue` records what it did,
+//     so there is a record of what another agent asked for and what it was told.
+//
+// The shapes below are v1.0's: method `SendMessage` in PascalCase, roles `ROLE_USER`/`ROLE_AGENT`,
+// states like `TASK_STATE_COMPLETED`, and a Part carrying exactly one of text/raw/url/data.
+import { createServer } from 'node:http';
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { agentCard } from './card.js';
+import { askWhich, chooseSkill, runSkill } from './answer.js';
+const JSONRPC_PATH = '/a2a/v1';
+const CARD_PATH = '/.well-known/agent-card.json';
+/** A2A's own error numbers sit outside the JSON-RPC reserved range; -32601 is "no such method". */
+const METHOD_NOT_FOUND = -32601;
+const INVALID_PARAMS = -32602;
+const UNSUPPORTED = -32004;
+function send(res, status, body) {
+    const text = JSON.stringify(body);
+    res.writeHead(status, { 'content-type': 'application/json', 'content-length': Buffer.byteLength(text) });
+    res.end(text);
+}
+const rpcError = (id, code, message) => ({ jsonrpc: '2.0', id: id ?? null, error: { code, message } });
+/** A completed task carrying the verdict as one artifact, which is what A2A expects back. */
+function completedTask(text, failed) {
+    return {
+        task: {
+            id: randomUUID(),
+            contextId: randomUUID(),
+            status: { state: failed ? 'TASK_STATE_FAILED' : 'TASK_STATE_COMPLETED', timestamp: new Date().toISOString() },
+            artifacts: [
+                {
+                    artifactId: randomUUID(),
+                    name: 'verdict',
+                    description: "Tewip's answer, in the same words it would print for a person",
+                    parts: [{ text, mediaType: 'text/markdown' }],
+                },
+            ],
+        },
+    };
+}
+/** A task that stops and asks, which is how Tewip declines to guess what was meant. */
+function needsInput(text) {
+    return {
+        task: {
+            id: randomUUID(),
+            contextId: randomUUID(),
+            status: {
+                state: 'TASK_STATE_INPUT_REQUIRED',
+                timestamp: new Date().toISOString(),
+                message: { messageId: randomUUID(), role: 'ROLE_AGENT', parts: [{ text }] },
+            },
+        },
+    };
+}
+function record(root, entry) {
+    try {
+        const path = join(root, '.tewip', 'a2a.jsonl');
+        mkdirSync(dirname(path), { recursive: true });
+        appendFileSync(path, `${JSON.stringify({ at: new Date().toISOString(), ...entry })}\n`, 'utf8');
+    }
+    catch {
+        // A log that cannot be written must not stop an answer being given.
+    }
+}
+function readBody(req, limit = 4 * 1024 * 1024) {
+    return new Promise((done, fail) => {
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk.toString('utf8');
+            if (body.length > limit) {
+                fail(new Error('request too large'));
+                req.destroy();
+            }
+        });
+        req.on('end', () => done(body));
+        req.on('error', fail);
+    });
+}
+/** Everything the server does with one JSON-RPC call, kept apart from the socket for testing. */
+export function handleRpc(cmd, body) {
+    if (typeof body !== 'object' || body === null)
+        return { status: 400, payload: rpcError(null, INVALID_PARAMS, 'the body is not a JSON-RPC object') };
+    const call = body;
+    const id = call.id ?? null;
+    const method = typeof call.method === 'string' ? call.method : '';
+    // The card says streaming and push notifications are false, and the specification requires an
+    // operation whose flag is false to fail rather than silently behave differently.
+    if (method === 'SendStreamingMessage' || method === 'SubscribeToTask') {
+        return { status: 200, payload: rpcError(id, UNSUPPORTED, 'this agent does not stream; its card declares capabilities.streaming false. Use SendMessage.') };
+    }
+    if (method.includes('PushNotificationConfig')) {
+        return { status: 200, payload: rpcError(id, UNSUPPORTED, 'this agent does not push; its card declares capabilities.pushNotifications false.') };
+    }
+    if (method !== 'SendMessage') {
+        return { status: 200, payload: rpcError(id, METHOD_NOT_FOUND, `this agent answers SendMessage only, and was asked for "${method}"`) };
+    }
+    const params = (call.params ?? {});
+    const message = (params.message ?? null);
+    if (message === null || typeof message !== 'object') {
+        return { status: 200, payload: rpcError(id, INVALID_PARAMS, 'params.message is required') };
+    }
+    const choice = chooseSkill(message);
+    if (choice.kind === 'ask') {
+        record(cmd.root, { method, outcome: 'asked-back', why: choice.why });
+        return { status: 200, payload: { jsonrpc: '2.0', id, result: needsInput(askWhich(choice.why)) } };
+    }
+    if (choice.kind === 'unknown') {
+        record(cmd.root, { method, outcome: 'unknown-skill', asked: choice.asked });
+        return { status: 200, payload: { jsonrpc: '2.0', id, result: needsInput(askWhich(`"${choice.asked}" is not a skill Tewip has`)) } };
+    }
+    const answered = runSkill(cmd.root, choice.skill, []);
+    record(cmd.root, { method, outcome: 'answered', skill: choice.skill.id, verb: choice.skill.verb, failed: answered.failed });
+    return { status: 200, payload: { jsonrpc: '2.0', id, result: completedTask(answered.text, answered.failed) } };
+}
+/** True of an address that only this machine can reach. */
+export const isLoopback = (host) => host === '127.0.0.1' || host === 'localhost' || host === '::1';
+export function serveA2A(cmd) {
+    const root = resolve(cmd.root);
+    const url = `http://${cmd.host}:${cmd.port}${JSONRPC_PATH}`;
+    const server = createServer((req, res) => {
+        const path = (req.url ?? '').split('?')[0];
+        if (req.method === 'GET' && path === CARD_PATH) {
+            send(res, 200, agentCard(url, cmd.tewipRoot));
+            return;
+        }
+        if (req.method !== 'POST' || path !== JSONRPC_PATH) {
+            send(res, 404, { error: `nothing here. The card is at ${CARD_PATH} and calls go to ${JSONRPC_PATH}` });
+            return;
+        }
+        readBody(req)
+            .then((raw) => {
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                send(res, 400, rpcError(null, INVALID_PARAMS, 'the body is not JSON'));
+                return;
+            }
+            const { status, payload } = handleRpc({ ...cmd, root }, parsed);
+            send(res, status, payload);
+        })
+            .catch((error) => send(res, 413, rpcError(null, INVALID_PARAMS, error.message)));
+    });
+    server.listen(cmd.port, cmd.host, () => {
+        console.log(`Tewip is answering other agents about ${root}`);
+        console.log(`  card:  http://${cmd.host}:${cmd.port}${CARD_PATH}`);
+        console.log(`  calls: POST ${url}  (JSON-RPC, method "SendMessage")`);
+        if (!isLoopback(cmd.host)) {
+            console.log('');
+            console.log(`  WARNING: ${cmd.host} is reachable from outside this machine, and this server has no`);
+            console.log('  authentication. Anything that can reach it can ask Tewip to read this repository.');
+            console.log('  Only the read-only skills are exposed - nothing here writes a file - but a port');
+            console.log('  that reads your source to strangers is still a port that reads your source.');
+        }
+        console.log('');
+        console.log('Every request is recorded in .tewip/a2a.jsonl. Stop with Ctrl+C.');
+    });
+    return server;
+}

package/dist/engine/schema/dialect-rules-node.js

@@ -0,0 +1,190 @@
+const STR = String.raw `['"]([\w.]+)['"]`;
+/** Alembic. */
+/**
+ * Sequelize. `queryInterface.removeColumn('Users', 'passwordHash')` names the table and the column
+ * in one call, which makes it the simplest of these to read.
+ *
+ * Written against opencollective-api's real migrations, which also show why the forward path
+ * matters more here than anywhere else: a Sequelize migration almost always *adds* in `up` and
+ * *removes* in `down`, so a reader that took the whole file would report every harmless migration
+ * in the ecosystem as dropping a column.
+ */
+const SEQUELIZE = [
+    {
+        find: new RegExp(String.raw `removeColumn\s*\(\s*${STR}\s*,\s*${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `removes ${m[1]}.${m[2]}`,
+        instead: 'deploy code that no longer selects or writes the column, then remove it in a later migration',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `renameColumn\s*\(\s*${STR}\s*,\s*${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `renames ${m[1]}.${m[2]}`,
+        instead: 'add the new column, write to both, move the readers, then remove the old one',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `dropTable\s*\(\s*${STR}`, 'i'),
+        risk: 'destroys-data',
+        what: (m) => `drops the table ${m[1]}`,
+        instead: 'stop reading the table, deploy that, then drop it once nothing refers to it',
+        table: (m) => m[1],
+    },
+    {
+        // Sequelize has no CONCURRENTLY option, so an index on a populated table takes the lock.
+        find: new RegExp(String.raw `addIndex\s*\(\s*${STR}`, 'i'),
+        unless: /concurrently\s*:\s*true/i,
+        risk: 'locks-writes',
+        what: (m) => `builds an index on ${m[1]} while holding a lock that blocks writes to it`,
+        instead: 'build it concurrently with a raw query, or accept the lock if the table is small',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `changeColumn\s*\(\s*${STR}\s*,\s*${STR}`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `changes the type of ${m[1]}.${m[2]}, which can rewrite the whole table`,
+        instead: 'add a new column, backfill it in batches, and switch the readers over',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+];
+/**
+ * Knex. The awkward one: the table is named by `knex.schema.table('articles', ...)` and the
+ * operation happens inside the callback, so the two are matched together across the lines between
+ * them. Matterwiki's real migrations are exactly this shape.
+ */
+const KNEX = [
+    {
+        find: new RegExp(String.raw `\.(?:table|alterTable)\s*\(\s*${STR}[\s\S]{0,400}?\.dropColumn\s*\(\s*${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `drops ${m[1]}.${m[2]}`,
+        instead: 'deploy code that no longer selects or writes the column, then drop it in a later migration',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `\.(?:table|alterTable)\s*\(\s*${STR}[\s\S]{0,400}?\.renameColumn\s*\(\s*${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `renames ${m[1]}.${m[2]}`,
+        instead: 'add the new column, write to both, move the readers, then remove the old one',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `\.dropTable(?:IfExists)?\s*\(\s*${STR}`, 'i'),
+        risk: 'destroys-data',
+        what: (m) => `drops the table ${m[1]}`,
+        instead: 'stop reading the table, deploy that, then drop it once nothing refers to it',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `\.(?:table|alterTable)\s*\(\s*${STR}[\s\S]{0,400}?\.notNullable\s*\(`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `makes a column on ${m[1]} NOT NULL, which scans every row under a lock`,
+        instead: 'add a CHECK ... NOT VALID, validate it, then set NOT NULL - or accept the scan if the table is small',
+        table: (m) => m[1],
+    },
+];
+/**
+ * EF Core. Its MigrationBuilder calls use named arguments over several lines and in either order,
+ * so each operation is matched twice - once for `name` before `table`, once for the reverse -
+ * rather than assuming the order Coflnet's real migrations happen to use.
+ */
+const NAMED = (first, second) => String.raw `(?:${first}:\s*${STR}[\s\S]{0,200}?${second}:\s*${STR}|${second}:\s*${STR}[\s\S]{0,200}?${first}:\s*${STR})`;
+/** Whichever order the arguments came in, the two names are in 1,2 or in 4,3. */
+const pair = (m) => (m[1] !== undefined ? [m[1], m[2]] : [m[4], m[3]]);
+const EFCORE = [
+    {
+        find: new RegExp(String.raw `migrationBuilder\.DropColumn\s*\(\s*${NAMED('name', 'table')}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `drops ${pair(m)[1]}.${pair(m)[0]}`,
+        instead: 'deploy code that no longer selects or writes the column, then drop it in a later migration',
+        table: (m) => pair(m)[1],
+        column: (m) => pair(m)[0],
+    },
+    {
+        find: new RegExp(String.raw `migrationBuilder\.DropTable\s*\(\s*name:\s*${STR}`, 'i'),
+        risk: 'destroys-data',
+        what: (m) => `drops the table ${m[1]}`,
+        instead: 'stop reading the table, deploy that, then drop it once nothing refers to it',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `migrationBuilder\.RenameColumn\s*\(\s*${NAMED('name', 'table')}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `renames ${pair(m)[1]}.${pair(m)[0]}`,
+        instead: 'add the new column, write to both, move the readers, then remove the old one',
+        table: (m) => pair(m)[1],
+        column: (m) => pair(m)[0],
+    },
+    {
+        find: new RegExp(String.raw `migrationBuilder\.CreateIndex\s*\(\s*${NAMED('name', 'table')}`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `builds an index on ${pair(m)[1]} while holding a lock that blocks writes to it`,
+        instead: 'build it concurrently with migrationBuilder.Sql, or accept the lock if the table is small',
+        table: (m) => pair(m)[1],
+    },
+    {
+        find: new RegExp(String.raw `migrationBuilder\.AlterColumn<[^>]*>\s*\(\s*${NAMED('name', 'table')}`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `alters ${pair(m)[1]}.${pair(m)[0]}, which can rewrite the whole table`,
+        instead: 'add a new column, backfill it in batches, and switch the readers over',
+        table: (m) => pair(m)[1],
+        column: (m) => pair(m)[0],
+    },
+];
+/**
+ * Liquibase. A changelog is XML or YAML rather than code, and the operation is the element name
+ * with the table on `tableName`. DEFRA's real changelogs are the shape this was written against.
+ */
+const XML_TABLE = String.raw `tableName\s*=\s*["']([\w.]+)["']`;
+const LIQUIBASE = [
+    {
+        find: new RegExp(String.raw `<dropColumn[^>]*${XML_TABLE}[\s\S]{0,300}?<column[^>]*name\s*=\s*["']([\w.]+)["']`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `drops ${m[1]}.${m[2]}`,
+        instead: 'deploy code that no longer selects or writes the column, then drop it in a later changeSet',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `<dropColumn[^>]*columnName\s*=\s*["']([\w.]+)["'][^>]*${XML_TABLE}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `drops ${m[2]}.${m[1]}`,
+        instead: 'deploy code that no longer selects or writes the column, then drop it in a later changeSet',
+        table: (m) => m[2],
+        column: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `<dropTable[^>]*${XML_TABLE}`, 'i'),
+        risk: 'destroys-data',
+        what: (m) => `drops the table ${m[1]}`,
+        instead: 'stop reading the table, deploy that, then drop it once nothing refers to it',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `<renameColumn[^>]*${XML_TABLE}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `renames a column on ${m[1]}`,
+        instead: 'add the new column, write to both, move the readers, then remove the old one',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `<addNotNullConstraint[^>]*${XML_TABLE}`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `makes a column on ${m[1]} NOT NULL, which scans every row under a lock`,
+        instead: 'add a CHECK ... NOT VALID, validate it, then set NOT NULL - or accept the scan if the table is small',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `<createIndex[^>]*${XML_TABLE}`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `builds an index on ${m[1]} while holding a lock that blocks writes to it`,
+        instead: 'build it concurrently with a <sql> changeSet, or accept the lock if the table is small',
+        table: (m) => m[1],
+    },
+];
+export { SEQUELIZE, KNEX, EFCORE, LIQUIBASE };

package/dist/engine/schema/dialect-rules.js

@@ -0,0 +1,147 @@
+const STR = String.raw `['"]([\w.]+)['"]`;
+/** Django's operations. `model_name` and `name` are the table and the column. */
+const DJANGO = [
+    {
+        find: new RegExp(String.raw `migrations\.RemoveField\([\s\S]{0,200}?model_name=${STR}[\s\S]{0,200}?name=${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `removes the field ${m[2]} from ${m[1]}`,
+        instead: 'stop reading and writing the field, deploy that, then remove it in a later migration. The version still running during a rolling deploy will select a column that no longer exists',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `migrations\.RenameField\([\s\S]{0,200}?model_name=${STR}[\s\S]{0,200}?old_name=${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `renames ${m[1]}.${m[2]}`,
+        instead: 'add the new field, write to both, move the readers, then remove the old one',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `migrations\.DeleteModel\([\s\S]{0,120}?${STR}`, 'i'),
+        risk: 'destroys-data',
+        what: (m) => `deletes the model ${m[1]} and its table`,
+        instead: 'stop using it, ship that, confirm nothing reads it, and delete it later',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `migrations\.AddField\([\s\S]{0,400}?null=False(?![\s\S]{0,400}?default=)`, 'i'),
+        risk: 'breaks-old-code',
+        what: () => 'adds a field that cannot be null and has no default',
+        instead: 'add it with null=True or a default. Without one, Django rewrites the table and every insert from the running version fails',
+    },
+    {
+        find: new RegExp(String.raw `migrations\.AlterField\([\s\S]{0,400}?null=False`, 'i'),
+        risk: 'locks-writes',
+        what: () => 'makes an existing field NOT NULL, which reads every row under a lock',
+        instead: 'backfill first, add a validated constraint, then alter - or use SeparateDatabaseAndState with the safe SQL',
+    },
+    {
+        // A data migration. Django wraps a migration in one transaction, so this holds it open for as long as
+        // the work takes - fine for a hundred rows, an outage for a hundred million.
+        find: /migrations\.RunPython\(/,
+        unless: /atomic\s*=\s*False/,
+        risk: 'slow',
+        what: () => 'runs application code against the data inside the migration transaction',
+        instead: 'for a large table, work in batches with atomic = False on the migration and make it resumable. For a small one this is fine - Tewip cannot see how many rows there are',
+    },
+    {
+        find: /AddIndex\(|AddConstraint\(/i,
+        unless: /AddIndexConcurrently|AddConstraintNotValid|atomic\s*=\s*False/,
+        risk: 'locks-writes',
+        what: () => 'adds an index or constraint, which Django builds with a lock unless told otherwise',
+        instead: 'AddIndexConcurrently / AddConstraintNotValid from django.contrib.postgres.operations, with atomic = False on the migration',
+    },
+];
+/** Rails migrations. */
+const RAILS = [
+    {
+        find: new RegExp(String.raw `remove_column\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `removes ${m[1]}.${m[2]}`,
+        instead: "ignore the column in the model (self.ignored_columns), deploy that, then remove it. Rails caches the column list, so the running version keeps selecting it",
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `rename_column\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `renames ${m[1]}.${m[2]}`,
+        instead: 'add the new column, write to both, move the readers, then remove the old one',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `drop_table\s*[\s(]\s*:?(\w+)`, 'i'),
+        risk: 'destroys-data',
+        what: (m) => `drops the table ${m[1]}`,
+        instead: 'stop using it, ship that, then drop it later',
+        table: (m) => m[1],
+    },
+    {
+        find: /add_index\s*[\s(]/i,
+        unless: /algorithm:\s*:concurrently/,
+        risk: 'locks-writes',
+        what: () => 'adds an index without algorithm: :concurrently, so writes to the table block while it builds',
+        instead: 'add_index ..., algorithm: :concurrently, with disable_ddl_transaction! on the migration',
+    },
+    {
+        find: new RegExp(String.raw `change_column\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `changes the type of ${m[1]}.${m[2]}, which usually rewrites the table`,
+        instead: 'add a new column, backfill in batches, switch the readers, then drop the old one',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `change_column_null\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)\s*,\s*false`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `makes ${m[1]}.${m[2]} NOT NULL, which reads every row under a lock`,
+        instead: 'add a validated check constraint first, then set the column NOT NULL',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+];
+const ALEMBIC = [
+    {
+        find: new RegExp(String.raw `op\.drop_column\(\s*${STR}\s*,\s*${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `drops ${m[1]}.${m[2]}`,
+        instead: 'stop reading and writing it, deploy that, then drop it in a later revision',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `op\.drop_table\(\s*${STR}`, 'i'),
+        risk: 'destroys-data',
+        what: (m) => `drops the table ${m[1]}`,
+        instead: 'stop using it, ship that, then drop it later',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `op\.alter_column\([\s\S]{0,300}?nullable=False`, 'i'),
+        risk: 'locks-writes',
+        what: () => 'makes a column NOT NULL, which reads every row under a lock',
+        instead: 'backfill, add a validated constraint, then alter the column',
+    },
+    {
+        find: /op\.create_index\(/i,
+        unless: /postgresql_concurrently\s*=\s*True/,
+        risk: 'locks-writes',
+        what: () => 'builds an index without postgresql_concurrently, so writes block while it builds',
+        instead: 'op.create_index(..., postgresql_concurrently=True) with a non-transactional revision',
+    },
+    {
+        find: new RegExp(String.raw `op\.rename_table\(\s*${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `renames the table ${m[1]}`,
+        instead: 'move the readers first, or keep a view with the old name',
+        table: (m) => m[1],
+    },
+];
+// TypeORM has no operations of its own: unlike Django's `RemoveField` or Rails's `remove_column`,
+// a TypeORM migration contains SQL and nothing else, handed to queryRunner.query(). So its list is
+// empty on purpose and every finding comes from reading that SQL, which is the same reader the
+// `.sql` dialect uses. The exhaustive Record is what made this a compile error rather than a
+// TypeORM migration silently producing no findings at all.
+export { DJANGO, RAILS, ALEMBIC };

package/dist/engine/schema/frameworks.js

@@ -1,3 +1,5 @@
+import { ALEMBIC, DJANGO, RAILS } from './dialect-rules.js';
+import { EFCORE, KNEX, LIQUIBASE, SEQUELIZE } from './dialect-rules-node.js';
 export function dialectOf(file, text) {
     const path = file.split('\\').join('/').toLowerCase();
     if (path.endsWith('.sql'))
@@ -17,158 +19,28 @@ export function dialectOf(file, text) {
     // at all - and on a Node backend that is most of them.
     if (/\bMigrationInterface\b|\bqueryRunner\.query\s*\(/.test(text))
         return 'typeorm';
+    if (/\bqueryInterface\.\w+\s*\(/.test(text))
+        return 'sequelize';
+    if (/\bknex\.schema\b|\bexports\.(?:up|down)\s*=\s*(?:async\s*)?function\s*\(\s*knex\b/.test(text))
+        return 'knex';
+    if (/\bmigrationBuilder\.\w+|\b:\s*Migration\b[\s\S]*\bMigrationBuilder\b/.test(text))
+        return 'efcore';
+    if (/<databaseChangeLog\b|\bdatabaseChangeLog\s*:/.test(text))
+        return 'liquibase';
     if (/(^|\/)(migrations?|db\/migrate)\//.test(path))
         return 'unknown';
     return 'unknown';
 }
-const STR = String.raw `['"]([\w.]+)['"]`;
-/** Django's operations. `model_name` and `name` are the table and the column. */
-const DJANGO = [
-    {
-        find: new RegExp(String.raw `migrations\.RemoveField\([\s\S]{0,200}?model_name=${STR}[\s\S]{0,200}?name=${STR}`, 'i'),
-        risk: 'breaks-old-code',
-        what: (m) => `removes the field ${m[2]} from ${m[1]}`,
-        instead: 'stop reading and writing the field, deploy that, then remove it in a later migration. The version still running during a rolling deploy will select a column that no longer exists',
-        table: (m) => m[1],
-        column: (m) => m[2],
-    },
-    {
-        find: new RegExp(String.raw `migrations\.RenameField\([\s\S]{0,200}?model_name=${STR}[\s\S]{0,200}?old_name=${STR}`, 'i'),
-        risk: 'breaks-old-code',
-        what: (m) => `renames ${m[1]}.${m[2]}`,
-        instead: 'add the new field, write to both, move the readers, then remove the old one',
-        table: (m) => m[1],
-        column: (m) => m[2],
-    },
-    {
-        find: new RegExp(String.raw `migrations\.DeleteModel\([\s\S]{0,120}?${STR}`, 'i'),
-        risk: 'destroys-data',
-        what: (m) => `deletes the model ${m[1]} and its table`,
-        instead: 'stop using it, ship that, confirm nothing reads it, and delete it later',
-        table: (m) => m[1],
-    },
-    {
-        find: new RegExp(String.raw `migrations\.AddField\([\s\S]{0,400}?null=False(?![\s\S]{0,400}?default=)`, 'i'),
-        risk: 'breaks-old-code',
-        what: () => 'adds a field that cannot be null and has no default',
-        instead: 'add it with null=True or a default. Without one, Django rewrites the table and every insert from the running version fails',
-    },
-    {
-        find: new RegExp(String.raw `migrations\.AlterField\([\s\S]{0,400}?null=False`, 'i'),
-        risk: 'locks-writes',
-        what: () => 'makes an existing field NOT NULL, which reads every row under a lock',
-        instead: 'backfill first, add a validated constraint, then alter - or use SeparateDatabaseAndState with the safe SQL',
-    },
-    {
-        // A data migration. Django wraps a migration in one transaction, so this holds it open for as long as
-        // the work takes - fine for a hundred rows, an outage for a hundred million.
-        find: /migrations\.RunPython\(/,
-        unless: /atomic\s*=\s*False/,
-        risk: 'slow',
-        what: () => 'runs application code against the data inside the migration transaction',
-        instead: 'for a large table, work in batches with atomic = False on the migration and make it resumable. For a small one this is fine - Tewip cannot see how many rows there are',
-    },
-    {
-        find: /AddIndex\(|AddConstraint\(/i,
-        unless: /AddIndexConcurrently|AddConstraintNotValid|atomic\s*=\s*False/,
-        risk: 'locks-writes',
-        what: () => 'adds an index or constraint, which Django builds with a lock unless told otherwise',
-        instead: 'AddIndexConcurrently / AddConstraintNotValid from django.contrib.postgres.operations, with atomic = False on the migration',
-    },
-];
-/** Rails migrations. */
-const RAILS = [
-    {
-        find: new RegExp(String.raw `remove_column\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)`, 'i'),
-        risk: 'breaks-old-code',
-        what: (m) => `removes ${m[1]}.${m[2]}`,
-        instead: "ignore the column in the model (self.ignored_columns), deploy that, then remove it. Rails caches the column list, so the running version keeps selecting it",
-        table: (m) => m[1],
-        column: (m) => m[2],
-    },
-    {
-        find: new RegExp(String.raw `rename_column\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)`, 'i'),
-        risk: 'breaks-old-code',
-        what: (m) => `renames ${m[1]}.${m[2]}`,
-        instead: 'add the new column, write to both, move the readers, then remove the old one',
-        table: (m) => m[1],
-        column: (m) => m[2],
-    },
-    {
-        find: new RegExp(String.raw `drop_table\s*[\s(]\s*:?(\w+)`, 'i'),
-        risk: 'destroys-data',
-        what: (m) => `drops the table ${m[1]}`,
-        instead: 'stop using it, ship that, then drop it later',
-        table: (m) => m[1],
-    },
-    {
-        find: /add_index\s*[\s(]/i,
-        unless: /algorithm:\s*:concurrently/,
-        risk: 'locks-writes',
-        what: () => 'adds an index without algorithm: :concurrently, so writes to the table block while it builds',
-        instead: 'add_index ..., algorithm: :concurrently, with disable_ddl_transaction! on the migration',
-    },
-    {
-        find: new RegExp(String.raw `change_column\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)`, 'i'),
-        risk: 'locks-writes',
-        what: (m) => `changes the type of ${m[1]}.${m[2]}, which usually rewrites the table`,
-        instead: 'add a new column, backfill in batches, switch the readers, then drop the old one',
-        table: (m) => m[1],
-        column: (m) => m[2],
-    },
-    {
-        find: new RegExp(String.raw `change_column_null\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)\s*,\s*false`, 'i'),
-        risk: 'locks-writes',
-        what: (m) => `makes ${m[1]}.${m[2]} NOT NULL, which reads every row under a lock`,
-        instead: 'add a validated check constraint first, then set the column NOT NULL',
-        table: (m) => m[1],
-        column: (m) => m[2],
-    },
-];
-/** Alembic. */
-const ALEMBIC = [
-    {
-        find: new RegExp(String.raw `op\.drop_column\(\s*${STR}\s*,\s*${STR}`, 'i'),
-        risk: 'breaks-old-code',
-        what: (m) => `drops ${m[1]}.${m[2]}`,
-        instead: 'stop reading and writing it, deploy that, then drop it in a later revision',
-        table: (m) => m[1],
-        column: (m) => m[2],
-    },
-    {
-        find: new RegExp(String.raw `op\.drop_table\(\s*${STR}`, 'i'),
-        risk: 'destroys-data',
-        what: (m) => `drops the table ${m[1]}`,
-        instead: 'stop using it, ship that, then drop it later',
-        table: (m) => m[1],
-    },
-    {
-        find: new RegExp(String.raw `op\.alter_column\([\s\S]{0,300}?nullable=False`, 'i'),
-        risk: 'locks-writes',
-        what: () => 'makes a column NOT NULL, which reads every row under a lock',
-        instead: 'backfill, add a validated constraint, then alter the column',
-    },
-    {
-        find: /op\.create_index\(/i,
-        unless: /postgresql_concurrently\s*=\s*True/,
-        risk: 'locks-writes',
-        what: () => 'builds an index without postgresql_concurrently, so writes block while it builds',
-        instead: 'op.create_index(..., postgresql_concurrently=True) with a non-transactional revision',
-    },
-    {
-        find: new RegExp(String.raw `op\.rename_table\(\s*${STR}`, 'i'),
-        risk: 'breaks-old-code',
-        what: (m) => `renames the table ${m[1]}`,
-        instead: 'move the readers first, or keep a view with the old name',
-        table: (m) => m[1],
-    },
-];
-// TypeORM has no operations of its own: unlike Django's `RemoveField` or Rails's `remove_column`,
-// a TypeORM migration contains SQL and nothing else, handed to queryRunner.query(). So its list is
-// empty on purpose and every finding comes from reading that SQL, which is the same reader the
-// `.sql` dialect uses. The exhaustive Record is what made this a compile error rather than a
-// TypeORM migration silently producing no findings at all.
-const BY_DIALECT = { django: DJANGO, rails: RAILS, alembic: ALEMBIC, typeorm: [] };
+const BY_DIALECT = {
+    django: DJANGO,
+    rails: RAILS,
+    alembic: ALEMBIC,
+    typeorm: [],
+    sequelize: SEQUELIZE,
+    knex: KNEX,
+    efcore: EFCORE,
+    liquibase: LIQUIBASE,
+};
 /** Findings from a framework migration, with the line each one sits on. */
 export function readFramework(dialect, text) {
     const lines = text.split(String.fromCharCode(10));
@@ -230,10 +102,24 @@ export function forwardOnly(dialect, text) {
             (dialect === 'sql' && /^\s*--\s*(?:\+migrate\s+Down|\+goose\s+Down|\/\/@UNDO|Down\b)/i.test(line)) ||
             // TypeORM's rollback is `public async down(queryRunner: QueryRunner)`. Reading it as part of
             // the change would report a migration that adds a column as one that drops it.
-            (dialect === 'typeorm' && /^\s*(?:public\s+)?async\s+down\s*\(/.test(line));
+            (dialect === 'typeorm' && /^\s*(?:public\s+)?async\s+down\s*\(/.test(line)) ||
+            // These three matter more than the rest. A Sequelize or Knex migration almost always *adds*
+            // in up and *removes* in down, and an EF Core Down() is the mirror image of its Up(), so a
+            // reader that took the whole file would report nearly every harmless migration in those
+            // ecosystems as dropping a column. Verified on real migrations from opencollective-api,
+            // Matterwiki and Coflnet, all three of which have their only destructive call in down.
+            (dialect === 'sequelize' && /^\s*down\s*:/.test(line)) ||
+            (dialect === 'knex' && /^\s*(?:exports\.down|module\.exports\.down)\s*=/.test(line)) ||
+            (dialect === 'efcore' && /^\s*protected\s+override\s+void\s+Down\s*\(/.test(line)) ||
+            // Liquibase puts the reverse inside the change itself rather than in a second method.
+            (dialect === 'liquibase' && /^\s*<rollback\b/.test(line));
         if (down) {
             // To the end of the block: the next line at the same indentation or less that starts something new.
-            blankFrom(i, (l, indent) => l.trim() !== '' && indentOf(l) <= indent && !/^\s*(end|\})\s*$/.test(l), indentOf(line));
+            // A lone brace is punctuation, not the start of something new. C# puts the opening `{` of a
+            // method on its own line at the same indent as the signature, so without `{` here the block
+            // ended one line after it began and the whole of EF Core's Down() was read as part of the
+            // change - which reported Coflnet's real migration as dropping three columns it adds.
+            blankFrom(i, (l, indent) => l.trim() !== '' && indentOf(l) <= indent && !/^\s*(end|\}|\{)\s*$/.test(l), indentOf(line));
             continue;
         }
         // Rails's `direction.down { ... }` is usually one line.

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

@@ -70,7 +70,7 @@ export function readMigration(root, file) {
             file,
             dialect,
             findings: [],
-            unread: 'Tewip does not recognise how this migration is written, so it says nothing about it rather than passing it. It reads SQL, Django, Rails, Alembic and TypeORM migrations',
+            unread: 'Tewip does not recognise how this migration is written, so it says nothing about it rather than passing it. It reads SQL, Django, Rails, Alembic, TypeORM, Sequelize, Knex, EF Core and Liquibase migrations',
             irreversible: false,
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tewip-ai",
-  "version": "0.40.0",
+  "version": "0.42.0",
   "mcpName": "io.github.hmamut39/tewip",
   "description": "Tewip finds why each failing test failed - real bug, flaky test, environment, test data or changed selector - for any stack, from the command line, CI, or your editor.",
   "keywords": [