tewip-ai 0.70.3 → 0.70.5

package/dist/engine/a2a/serve.js

@@ -112,15 +112,15 @@ export function handleRpc(cmd, body) {
     }
     const choice = chooseSkill(message);
     if (choice.kind === 'ask') {
-        record(cmd.root, { method, outcome: 'asked-back', why: choice.why });
+        record(cmd.root, { http: 'POST', path: JSONRPC_PATH, 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 });
+        record(cmd.root, { http: 'POST', path: JSONRPC_PATH, 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 });
+    record(cmd.root, { http: 'POST', path: JSONRPC_PATH, 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. */
@@ -130,11 +130,26 @@ export function serveA2A(cmd) {
     const url = `http://${cmd.host}:${cmd.port}${JSONRPC_PATH}`;
     const server = createServer((req, res) => {
         const path = (req.url ?? '').split('?')[0];
+        // What reaches the port, not only what gets answered.
+        //
+        // `record` was called from the three places inside the answering path, so the log held
+        // successful answers and nothing else. Measured by sending four requests and finding one: a POST
+        // to the wrong path, a JSON-RPC call for a method this agent does not have, and a malformed body
+        // all left **no trace at all**. On a port with no authentication those are the entries worth
+        // keeping - a peer probing for methods is exactly what an operator needs to see - and the file's
+        // own comment promises "a record of what another agent asked for and what it was told". A
+        // rejected request is still something another agent asked for.
+        //
+        // The request's body is never recorded, only what it asked for and how it was answered, because
+        // a body from another agent can contain anything.
+        const seen = (outcome, extra = {}) => record(root, { http: req.method ?? '', path, outcome, ...extra });
         if (req.method === 'GET' && path === CARD_PATH) {
+            seen('card-read');
             send(res, 200, agentCard(url, cmd.tewipRoot));
             return;
         }
         if (req.method !== 'POST' || path !== JSONRPC_PATH) {
+            seen('no-such-endpoint');
             send(res, 404, { error: `nothing here. The card is at ${CARD_PATH} and calls go to ${JSONRPC_PATH}` });
             return;
         }
@@ -145,13 +160,23 @@ export function serveA2A(cmd) {
                 parsed = JSON.parse(raw);
             }
             catch {
+                seen('body-not-json');
                 send(res, 400, rpcError(null, INVALID_PARAMS, 'the body is not JSON'));
                 return;
             }
             const { status, payload } = handleRpc({ ...cmd, root }, parsed);
+            // A JSON-RPC error rides in a 200 response - the transport worked, the call did not - so the
+            // HTTP status cannot be the test. Checking it missed exactly the entry worth having: a peer
+            // asking for a method this agent does not implement.
+            const rpc = payload ?? {};
+            if (rpc.error)
+                seen('refused', { why: rpc.error.message ?? '' });
             send(res, status, payload);
         })
-            .catch((error) => send(res, 413, rpcError(null, INVALID_PARAMS, error.message)));
+            .catch((error) => {
+            seen('body-rejected', { why: error.message });
+            send(res, 413, rpcError(null, INVALID_PARAMS, error.message));
+        });
     });
     server.listen(cmd.port, cmd.host, () => {
         console.log(`Tewip is answering other agents about ${root}`);

package/dist/engine/notify/note-command.js

@@ -7,6 +7,7 @@
 import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { HistoryIndex } from '../history.js';
+import { loadCorrections } from '../corrections.js';
 import { buildItems } from '../../outlets/items.js';
 import { digestView } from '../../outlets/views/digest.js';
 import { qualityView } from '../../outlets/views/quality.js';
@@ -36,9 +37,13 @@ export async function runNote(cmd) {
             continue;
         totalRuns += runs.length;
         totalFailures += records.length;
-        // The diagnoses were made when each failure happened; nothing is judged again here.
+        // The diagnoses were made when each failure happened; nothing is judged again here - except
+        // where a person overruled one. This note is the report a lead reads, and it was printing
+        // "Diagnosis: LOCATOR_DRIFT, confidence 0.95, source: rules" about a test somebody had corrected
+        // to TIMING, because the corrections were never loaded here at all.
         const index = new HistoryIndex(records, runs);
-        const items = await buildItems(records, index, { dataset: `history: ${name}`, llm: null, reuseStoredDiagnoses: true });
+        const where = join(cmd.root, '.tewip', 'history', name);
+        const items = await buildItems(records, index, { dataset: `history: ${name}`, llm: null, reuseStoredDiagnoses: true, corrections: loadCorrections(where) });
         parts.push(`## ${name}`, '', `${runs.length} run(s), ${records.length} failure(s).`, '');
         if (items.length > 0) {
             parts.push(digestView(items, runs, `history: ${name}`).markdown, '', qualityView(items, `history: ${name}`).markdown, '');

package/dist/outlets/items.js

@@ -4,6 +4,7 @@ import { extractLocator } from '../engine/error-parse.js';
 import { decide } from '../engine/decide.js';
 import { lastFailedAttempts } from '../engine/dataset.js';
 import { failingCodeOf } from '../engine/llm/context.js';
+import { applyCorrection, correctionFor } from '../engine/corrections.js';
 import { diagnosePipeline } from '../engine/pipeline.js';
 import { truncate } from '../engine/signature.js';
 import { designDebt } from './design-debt.js';
@@ -47,7 +48,24 @@ export async function buildItems(records, index, { dataset, llm, reuseStoredDiag
     const stored = reuseStoredDiagnoses ? cases.map((c) => c.diagnosis) : cases.map(() => undefined);
     const missing = cases.filter((_, i) => !stored[i]);
     const fresh = await diagnosePipeline(missing, index, llm, { corrections });
-    const diagnoses = stored.map((d) => d ?? fresh.shift());
+    // A correction outranks a stored diagnosis, which it did not.
+    //
+    // `diagnosePipeline` applies corrections, but only to the failures in `missing` - the ones with no
+    // stored diagnosis. `explain` stores one for every failure it diagnoses, so on any history a team
+    // actually keeps, **every** failure has one and a correction reached none of them. Field-tested:
+    // three real corrections of real diagnoses, `learn` reported the pattern perfectly, and the weekly
+    // note still said "Diagnosis: LOCATOR_DRIFT, confidence 0.95, source: rules" about a test a person
+    // had overruled to TIMING - directly against what `correct` had just promised in print, "Tewip will
+    // answer with your decision the next time that test fails the same way, and say it was yours."
+    //
+    // This is the whole hierarchy of the product: what the team decided beats what the tool decided.
+    // Fixing it here fixes every caller at once, which matters because three of them reuse stored
+    // diagnoses and two of those did not even pass the corrections along.
+    const diagnoses = cases.map((record, i) => {
+        const own = stored[i] ?? fresh.shift();
+        const correction = corrections.length > 0 ? correctionFor(record, corrections) : null;
+        return correction ? applyCorrection(own, correction) : own;
+    });
     const failedAttempts = new Map();
     for (const r of records)
         failedAttempts.set(`${r.runId} ${r.testId}`, [...(failedAttempts.get(`${r.runId} ${r.testId}`) ?? []), r]);

package/package.json

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