tewip-ai 0.67.0 → 0.69.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/github-report.js

@@ -24,6 +24,33 @@ async function latestReports(repo, branch) {
     }
     return null;
 }
+/**
+ * Which of the artifact's reports to show, and in what order.
+ *
+ * This used to be two hard-coded names, `pr-comment.md` and `infra.md`, which are what the Action's
+ * *triage* mode writes. Its **check** mode writes a different set - `checks.md`, `done.md`,
+ * `schema.md`, `standards.md`, `vouch.md`, `access.md` - under the same artifact name, and both
+ * modes were read by the same two lines. Found by running `tewip ci hmamut39/tewip` against Tewip's
+ * own repository, whose self-check workflow runs in check mode: the artifact held 9KB of findings
+ * across six files and the command printed **167 characters** - a title, a run link, and nothing
+ * underneath. The answer to "why did CI fail on my PR?" was a URL.
+ *
+ * So the artifact decides what is shown, not this file. `pr-comment.md` leads when it exists because
+ * it is the one written to be read by a person on a pull request; `infra.md` stays behind its ENV
+ * count because it is about the machines rather than the change; everything else is named and shown.
+ */
+const LEADS = ['pr-comment.md', 'checks.md'];
+export function reportsIn(files, envCount) {
+    const text = (name) => (files.get(name)?.toString('utf8') ?? '').trim();
+    const names = [...files.keys()].filter((n) => n.endsWith('.md'));
+    const ordered = [...LEADS.filter((n) => names.includes(n)), ...names.filter((n) => !LEADS.includes(n)).sort()];
+    return ordered
+        .filter((name) => (name === 'infra.md' ? envCount > 0 : true))
+        .map((name) => ({ name, body: text(name) }))
+        .filter((r) => r.body.length > 0);
+}
+/** A report's own heading if it has one, else its filename turned into words. */
+const titleOf = (name) => name.replace(/\.md$/, '').replace(/[-_]/g, ' ');
 export async function githubCiReport(repo, pr, branch) {
     const head = pr ? (await ghApi(`repos/${repo}/pulls/${pr}`)).head.ref : branch;
     const target = pr ? `PR #${pr} (${head})` : head ? `branch ${head}` : 'any branch';
@@ -37,14 +64,17 @@ export async function githubCiReport(repo, pr, branch) {
         const bundle = JSON.parse(text('triage.json') || '{}');
         const envCount = (bundle.items ?? []).filter((i) => i.diagnosis.category === 'ENV').length;
         const suite = artifact.name.replace(/^(?:tewip|triage-agent)-report-?/, '');
+        const reports = reportsIn(files, envCount);
+        // A header with nothing under it is the worst of the three possible answers here, because it
+        // reads as "CI is fine" to anyone who does not know what the artifact was supposed to contain.
+        const body = reports.length > 0
+            ? reports.map((r, i) => (i === 0 && LEADS.includes(r.name) ? r.body : `## ${titleOf(r.name)}\n\n${r.body}`)).join('\n\n')
+            : `This run's \`${artifact.name}\` artifact has nothing Tewip can show. It holds ${files.size === 0 ? 'no files' : `${files.size} file(s): ${[...files.keys()].sort().join(', ')}`}, and none of them has any content. The run itself is at ${found.run.html_url}.`;
         sections.push([
             `# Tewip CI report: ${repo}, ${target}${suite ? ` - suite "${suite}"` : ''}`,
             `Run: ${bundle.runUrl ?? found.run.html_url} · commit \`${(bundle.sha ?? found.run.head_sha).slice(0, 8)}\` · generated ${bundle.generatedAt ?? artifact.created_at}${bundle.fixPr ? ` · verified fix PR: ${bundle.fixPr}` : ''}`,
-            text('pr-comment.md'),
-            envCount > 0 ? text('infra.md') : '',
-        ]
-            .filter(Boolean)
-            .join('\n\n'));
+            body,
+        ].join('\n\n'));
     }
     return cap(sections.join('\n\n---\n\n'));
 }

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.69.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": [