tewip-ai 0.67.0 → 0.68.0

package/dist/cli/tewip.js

@@ -199,7 +199,7 @@ async function main() {
             if (!question)
                 throw new Error('usage: tewip recall "<an error, or a question>" [--test "<test id>"] [--limit 5]');
             const { runRecall } = await import('../engine/recall/recall-command.js');
-            runRecall({ root: process.cwd(), question, testId: flag(args, 'test'), limit: Number(flag(args, 'limit')) || undefined, name: flag(args, 'name'), out: flag(args, 'out') });
+            await runRecall({ root: process.cwd(), question, testId: flag(args, 'test'), limit: Number(flag(args, 'limit')) || undefined, name: flag(args, 'name'), out: flag(args, 'out') });
             return;
         }
         case 'incident': {

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

@@ -24,7 +24,13 @@ function gather(root, only) {
 }
 export function runLearn(cmd) {
     const { corrections, records } = gather(cmd.root, cmd.name);
-    const learned = whatWeLearned(corrections, loadVerdicts(cmd.root), records);
+    // The denominator is diagnoses, not kept failures. A store can hold thousands of failures that
+    // nothing has diagnosed yet - the harvest writes exactly that - and counting those as decisions
+    // divides the corrections by a number far larger than the decisions Tewip actually made, making
+    // it look more accurate than it is. Found next to the same mistake in `recall`, which called 1,305
+    // undiagnosed failures "searched".
+    const diagnosed = records.filter((r) => r.diagnosis?.category).length;
+    const learned = whatWeLearned(corrections, loadVerdicts(cmd.root), records, diagnosed);
     const report = renderLearning(learned);
     console.log(report);
     if (cmd.labels) {

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

@@ -1,43 +1,82 @@
 // `tewip recall "<an error, or a question>"`: what this project already concluded.
 import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { datasetFiles, readTriageRecords } from '../../reporters/store.js';
+import { buildItems } from '../../outlets/items.js';
+import { datasetFiles, readRunSummaries, readTriageRecords } from '../../reporters/store.js';
 import { loadCorrections } from '../corrections.js';
+import { HistoryIndex } from '../history.js';
 import { memories, recall, renderRecall } from './recall.js';
 /** Everything kept for this project: its failures, and the times a person overruled Tewip. */
 function kept(root, only) {
     const dir = join(root, '.tewip', 'history');
     if (!existsSync(dir))
-        return { records: [], corrections: [] };
+        return { records: [], runs: [], corrections: [] };
     const records = [];
+    const runs = [];
     const corrections = [];
     for (const project of only ? [only] : readdirSync(dir)) {
         const where = join(dir, project);
         if (!existsSync(where))
             continue;
-        records.push(...readTriageRecords(datasetFiles(where).triage));
+        const files = datasetFiles(where);
+        records.push(...readTriageRecords(files.triage));
+        runs.push(...readRunSummaries(files.runs));
         corrections.push(...loadCorrections(where));
     }
-    return { records, corrections };
+    return { records, runs, corrections };
+}
+/**
+ * The kept failures with a category on each, diagnosing the ones that do not have one stored.
+ *
+ * This is the whole bug Phase 59 was looking for. `memories()` keeps only records that carry a
+ * `diagnosis`, and **nothing on the collection path writes one**: the reporter and the harvest both
+ * store the raw failure, and the category is worked out when a report is rendered. So on a real
+ * 1,305-failure history, `recall` had nothing to search - and said "Nothing in this project's
+ * history resembles it... this is new here", footed by "Searched 1305 kept failure(s)". Both halves
+ * false: nothing was searched, and 660 of those 1,305 failures were the timeout being asked about.
+ *
+ * `note`, `flaky` and the risk digest had all been diagnosing on read for months. Recall was the
+ * one retrieval layer that demanded a field nobody writes, which made it permanently empty on every
+ * project that had not been through `tewip explain` - and empty in a way that read like an answer.
+ *
+ * Rules only, never a model: `recall`'s promise is no model, no network, nothing to set up, and a
+ * question asked of local history must not start costing money because of how it is indexed.
+ */
+async function diagnosed(records, runs, corrections) {
+    if (records.length === 0)
+        return [];
+    const items = await buildItems(records, new HistoryIndex(records, runs), { dataset: 'recall', llm: null, reuseStoredDiagnoses: true, corrections });
+    const byCase = new Map(items.map((item) => [`${item.runId}::${item.testId}`, item.diagnosis]));
+    return records.map((record) => (record.diagnosis ? record : { ...record, diagnosis: byCase.get(`${record.runId}::${record.testId}`) }));
 }
 /**
  * The report, without printing it. An MCP server speaks JSON-RPC over stdout, so anything one of
  * its tools calls has to return its answer: a stray console.log corrupts every response the
  * assistant receives, and the corruption looks like the tool being broken rather than noisy.
  */
-export function recallReport(cmd) {
-    const { records, corrections } = kept(cmd.root, cmd.name);
+export async function recallReport(cmd) {
+    const { records, runs, corrections } = kept(cmd.root, cmd.name);
     if (records.length === 0) {
         return { report: 'Nothing has been kept here yet, so there is no history to search. Run `tewip explain <report>` first.', searched: 0, corrections: 0 };
     }
-    const found = recall(cmd.question, memories(records, corrections), { testId: cmd.testId, limit: cmd.limit ?? 5 });
-    return { report: renderRecall(cmd.question, found), searched: records.length, corrections: corrections.length };
+    // The count reported is the count searched. It used to be `records.length` whatever `memories`
+    // actually indexed, which is how an empty index came to be described as 1,305 failures searched.
+    const mem = memories(await diagnosed(records, runs, corrections), corrections);
+    if (mem.length === 0) {
+        return {
+            report: `${records.length} failure(s) are kept here, but none of them could be given a category, so there is nothing to compare this against. Recall searches what Tewip concluded about a failure, and a failure it cannot read is not a conclusion.`,
+            searched: 0,
+            corrections: corrections.length,
+        };
+    }
+    const found = recall(cmd.question, mem, { testId: cmd.testId, limit: cmd.limit ?? 5 });
+    return { report: renderRecall(cmd.question, found, mem.length), searched: mem.length, corrections: corrections.length };
 }
-export function runRecall(cmd) {
-    const { report, searched, corrections } = recallReport(cmd);
+export async function runRecall(cmd) {
+    const { report, searched, corrections } = await recallReport(cmd);
     console.log(report);
     if (searched > 0)
-        console.error(`\nSearched ${searched} kept failure(s) and ${corrections} correction(s). No model was called.`);
+        console.error(`\nSearched ${searched} diagnosed failure(s) and ${corrections} correction(s). No model was called.`);
     if (cmd.out) {
         mkdirSync(dirname(resolve(cmd.out)), { recursive: true });
         writeFileSync(resolve(cmd.out), `${report}\n`, 'utf8');

package/dist/engine/recall/recall.js

@@ -88,10 +88,20 @@ export function recall(question, all, { testId, limit = 5 } = {}) {
         .slice(0, limit);
 }
 /** What a person reads. Every line names the run it came from, so nothing has to be believed. */
-export function renderRecall(question, found) {
+/**
+ * What a person reads.
+ *
+ * `searched` is not decoration. "Nothing in this project's history resembles it" is only an answer
+ * if something was actually compared against, and on a real 1,305-failure history this said exactly
+ * that while the searchable set was **empty** - see `recallReport`. The number belongs in the report
+ * body rather than only on stderr, because an MCP client and a `> file` both keep the body and throw
+ * stderr away, which is precisely where a reader would have caught it.
+ */
+export function renderRecall(question, found, searched) {
     const lines = [`# What this project already knows`, '', `Asked: ${question.replace(/\s+/g, ' ').slice(0, 160)}`, ''];
     if (found.length === 0) {
-        lines.push('Nothing in this project\'s history resembles it. That is an answer, not a failure: it means', 'this is new here, and there is no earlier decision to follow.');
+        const against = searched === undefined ? 'this project\'s history' : `the ${searched} diagnosed failure(s) kept here`;
+        lines.push(`Nothing in ${against} resembles it. That is an answer, not a failure: it means`, 'this is new here, and there is no earlier decision to follow.');
         return lines.join('\n');
     }
     const corrected = found.filter((f) => f.correctedBy);

package/dist/mcp/server.js

@@ -111,7 +111,7 @@ server.registerTool('recall', {
     if (!isAbsolute(root) || !existsSync(root))
         throw new Error(`project must be an existing absolute path, got "${root}"`);
     const { recallReport } = await import('../engine/recall/recall-command.js');
-    return recallReport({ root, question, testId: test }).report;
+    return (await recallReport({ root, question, testId: test })).report;
 }));
 server.registerTool('trace_requirements', {
     title: 'Is this requirement covered, and is it passing?',

package/package.json

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