tewip-ai 0.39.0 → 0.41.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,8 @@ 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 and Alembic** migrations, judges **only the forward path** (a rollback step
+It reads **SQL, Django, Rails, Alembic and TypeORM** 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:
 :concurrently`, `NOT VALID`, `postgresql_concurrently=True`. When it cannot read a migration it says so

package/dist/cli/help.js

@@ -212,6 +212,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 and TypeORM, which covers Prisma, Drizzle and Flyway.',
+        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/frameworks.js

@@ -11,6 +11,12 @@ export function dialectOf(file, text) {
         return 'rails';
     if (/\bop\.(?:drop_column|add_column|create_index|alter_column|drop_table|rename_table|execute)\b/.test(text))
         return 'alembic';
+    // TypeORM writes a migration as a class with up() and down(), and puts the real DDL in template
+    // strings passed to queryRunner.query(). The SQL is right there and perfectly readable; only the
+    // wrapper was unfamiliar, so every TypeORM project was told Tewip could not read its migrations
+    // at all - and on a Node backend that is most of them.
+    if (/\bMigrationInterface\b|\bqueryRunner\.query\s*\(/.test(text))
+        return 'typeorm';
     if (/(^|\/)(migrations?|db\/migrate)\//.test(path))
         return 'unknown';
     return 'unknown';
@@ -157,7 +163,12 @@ const ALEMBIC = [
         table: (m) => m[1],
     },
 ];
-const BY_DIALECT = { django: DJANGO, rails: RAILS, alembic: ALEMBIC };
+// 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: [] };
 /** Findings from a framework migration, with the line each one sits on. */
 export function readFramework(dialect, text) {
     const lines = text.split(String.fromCharCode(10));
@@ -216,7 +227,10 @@ export function forwardOnly(dialect, text) {
         const line = lines[i];
         const down = (dialect === 'rails' && /^\s*def\s+down\b/.test(line)) ||
             (dialect === 'alembic' && /^\s*def\s+downgrade\s*\(/.test(line)) ||
-            (dialect === 'sql' && /^\s*--\s*(?:\+migrate\s+Down|\+goose\s+Down|\/\/@UNDO|Down\b)/i.test(line));
+            (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));
         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));

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

@@ -17,10 +17,39 @@ const MIGRATION = /(^|\/)(migrations?|db\/migrate|prisma\/migrations|alembic|fly
 const SCHEMA_FILE = /\.(sql)$|(^|\/)(migrations?|db\/migrate)\/.*\.(py|rb|js|ts)$/i;
 /** The schema files in this change. */
 export function schemaFiles(cmd) {
-    const given = cmd.files && cmd.files.length > 0 ? cmd.files : (changeSummary(cmd.root, cmd.diff)?.files ?? []);
+    const named = cmd.files !== undefined && cmd.files.length > 0;
+    const given = named ? cmd.files : (changeSummary(cmd.root, cmd.diff)?.files ?? []);
     return given
         .map((f) => f.split('\\').join('/'))
-        .filter((f) => (SCHEMA_FILE.test(f) || MIGRATION.test(f)) && existsSync(resolve(cmd.root, f)));
+        // Asking for a file by name overrides the path filter: the filter exists to find migrations in
+        // a diff of a hundred files, not to argue with somebody who pointed at one. A TypeORM migration
+        // sitting outside a migrations/ directory was being answered with "no migration in this change".
+        .filter((f) => (named || SCHEMA_FILE.test(f) || MIGRATION.test(f)) && existsSync(resolve(cmd.root, f)));
+}
+/**
+ * Tables this migration creates itself.
+ *
+ * A lock is only expensive because of the rows it holds up, and a table created three statements
+ * earlier has none. This matters enormously on the tools that generate their SQL: a Prisma project
+ * emits `CREATE TABLE` followed by an `ADD CONSTRAINT ... FOREIGN KEY` for every relation, so
+ * documenso's 165 real migrations produced 275 "blocks writes while it runs" findings - 1.7 per
+ * migration, nearly all of them about tables that did not exist a moment before. That is the volume
+ * at which a team stops reading the report, which costs more than the warnings are worth.
+ */
+function createdHere(text) {
+    const names = new Set();
+    for (const m of text.matchAll(/\bCREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?"?([\w$.]+)"?/gi)) {
+        names.add(m[1].toLowerCase().replace(/^.*\./, ''));
+    }
+    return names;
+}
+/** Risks that are only risks because rows already exist. */
+const ONLY_HURTS_EXISTING_ROWS = new Set(['locks-writes', 'slow']);
+export function droppingWhatIsNew(findings, text) {
+    const fresh = createdHere(text);
+    if (fresh.size === 0)
+        return findings;
+    return findings.filter((f) => !(ONLY_HURTS_EXISTING_ROWS.has(f.risk) && fresh.has(f.table.toLowerCase().replace(/^.*\./, ''))));
 }
 export function readMigration(root, file) {
     let text = '';
@@ -35,13 +64,13 @@ export function readMigration(root, file) {
     // part of the change says a migration that creates a table destroys one.
     const forward = forwardOnly(dialect, text);
     if (dialect === 'sql')
-        return { file, dialect, findings: readSql(forward), unread: '', irreversible: false };
+        return { file, dialect, findings: droppingWhatIsNew(readSql(forward), forward), unread: '', irreversible: false };
     if (dialect === 'unknown') {
         return {
             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 and Alembic 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 and TypeORM migrations',
             irreversible: false,
         };
     }
@@ -49,10 +78,12 @@ export function readMigration(root, file) {
     // A migration that only runs raw SQL through the framework is still readable: the SQL is the migration.
     // Raw SQL, however it reaches the database: through the framework, or through a cursor inside a data
     // migration, which is where most large projects put the dangerous parts.
-    const raw = [...forward.matchAll(/(?:RunSQL|op\.execute|execute|cursor\.execute)\(\s*(?:r?["'`]{1,3})([\s\S]*?)["'`]{1,3}\s*[,)]/g)].map((m) => m[1]).join(';');
+    // `queryRunner.query` is TypeORM's, and is the whole of a TypeORM migration rather than an
+    // escape hatch inside one: the class is a wrapper and every statement arrives this way.
+    const raw = [...forward.matchAll(/(?:RunSQL|op\.execute|queryRunner\.query|execute|cursor\.execute)\(\s*(?:r?["'`]{1,3})([\s\S]*?)["'`]{1,3}\s*[,)]/g)].map((m) => m[1]).join(';');
     if (raw.trim())
         findings.push(...readSql(raw));
-    return { file, dialect, findings, unread: '', irreversible: irreversible(dialect, text) };
+    return { file, dialect, findings: droppingWhatIsNew(findings, forward), unread: '', irreversible: irreversible(dialect, text) };
 }
 /**
  * Code outside the migrations that still names a table or column this change takes away.

package/dist/engine/schema/statements.js

@@ -20,7 +20,12 @@ const RULES = [
         table: (m) => bare(m[1]),
     },
     {
-        find: new RegExp(String.raw `\bALTER\s+TABLE\s+(${NAME})[\s\S]*?\bDROP\s+(?:COLUMN\s+)?(?:IF\s+EXISTS\s+)?(${NAME})`, 'i'),
+        // The word COLUMN is optional in SQL, so the name after DROP has to be checked against the
+        // other things an ALTER TABLE can drop. Without the lookahead, Prisma's own
+        // `ALTER TABLE "Share" DROP CONSTRAINT "Share_userId_fkey"` - which every Prisma project is full
+        // of - was read as dropping a column called CONSTRAINT, and reported as breaking the running
+        // version, which dropping a foreign key does not do. Found on documenso's real migrations.
+        find: new RegExp(String.raw `\bALTER\s+TABLE\s+(${NAME})[\s\S]*?\bDROP\s+(?:COLUMN\s+)?(?:IF\s+EXISTS\s+)?(?!CONSTRAINT\b|INDEX\b|DEFAULT\b|NOT\s+NULL\b|PRIMARY\b|FOREIGN\b|CHECK\b|UNIQUE\b|PARTITION\b)(${NAME})`, 'i'),
         risk: 'breaks-old-code',
         what: (m) => `drops the column ${bare(m[2])} from ${bare(m[1])}`,
         instead: 'deploy code that no longer selects or writes the column, then drop it in a later migration. During a rolling deploy the old version is still running and will fail on a column that is gone',

package/package.json

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