testguard-cli 0.5.0 → 0.6.0

package/src/scaffold/producers.mjs

@@ -1,10 +1,25 @@
 /**
  * Mechanical fault producers. Deterministic, line-oriented, no AST, no LLM.
  *
- * Two independent field reports found that ~80% of hand-written faults are
- * one of these shapes. Each producer looks at one line (plus a little
- * context) and proposes a fault whose `find` is the exact line, so the anchor
- * hits by construction. A human keeps or drops every proposal.
+ * Field reports found that most hand-written faults are one of a few shapes.
+ * Each producer looks at one line (plus a little context) and proposes a
+ * fault whose `find` is the exact line, so the anchor hits by construction.
+ * A human keeps or drops every proposal.
+ *
+ * Shapes:
+ *   condition-forced   `if (<guard>) {` → `if (false) {`
+ *   statement-deleted  a single-line guard or a state change removed
+ *   return-altered     `return <check>;` → `return true;`
+ *   literal-changed    a security flag / window / cost literal weakened
+ *   call-removed       a bare verify/validate/check call removed
+ *   field-dropped      a field removed from a persisted or transmitted object,
+ *                      an allow-list, a schema, or a spread merge (issue #14)
+ *   argument-swapped   a call kept, its parameter-derived argument swapped for
+ *                      a trivial value (issue #22)
+ *   element-removed    a one-line JSX element (self-closing or paired) removed
+ *                      (issue #15)
+ *   handler-dropped    an on<Event>={…} prop removed from a JSX element
+ *                      (issue #15)
  */
 
 const COMMENT = /^\s*(\/\/|\*|\/\*)/;
@@ -26,6 +41,36 @@ const FUNCTION_HEAD = [
 ];
 const NOT_A_FUNCTION = new Set(['if', 'for', 'while', 'switch', 'catch', 'else', 'return', 'function', 'constructor']);
 
+// ── field-dropped ──
+// An object literal counts as a payload when its opening line says so: it is
+// returned, built by an arrow, assigned to a payload-ish name, passed to a
+// persistence/transport call, or is a validation schema. Type-level braces
+// (`interface`, `type X = {`) are never payloads: dropping a key there is a
+// compile error, not a behaviour.
+const PAYLOAD_OPENER = /(\breturn\s*\{\s*$|=>\s*\(?\s*\{\s*$|\b(?:body|payload|input|item|params|data|record|row|attrs|attributes|values|fields|patch|update|updates|changes|doc|document|entity|dto|request|response|options|args|props|config|settings|message|event|entry|audit)\w*\s*[:=]\s*\{\s*$|\.(?:save|update|put|patch|post|send|write|insert|upsert|create|set|publish|emit|dispatch|persist|store|log|fetch|request|audit|record|track|notify)\w*\s*\(\s*(?:[^,{]*,\s*)*\{\s*$|\b(?:z|yup|joi|v|t)\.(?:object|shape|strictObject|looseObject)\s*\(\s*\{\s*$|\.(?:object|shape|extend|merge|pick|omit)\s*\(\s*\{\s*$|\bobject\s*\(\s*\{\s*$)/i;
+const TYPE_OPENER = /\b(?:interface|type|enum|declare)\b/;
+const ALLOWLIST_OPENER = /\b\w*(?:fields|keys|allowed|writable|columns|attributes|props|whitelist|allowlist|editable|mutable|updatable|permitted|selectable|sortable|filterable|required)\w*\b[^[]*\[\s*$/i;
+const PROP_LINE = /^\s*(?:[\w$]+|'[^']*'|"[^"]*"|\[[^\]]+\])\s*:\s*(?!\s*(?:async\s+)?(?:function\b|\([^)]*\)\s*=>|[\w$]+\s*=>))(.+?)(,?)\s*$/;
+const SHORTHAND_LINE = /^\s*[\w$]+\s*,\s*$/;
+const METHOD_LINE = /^\s*(?:async\s+)?(?:get\s+|set\s+)?[\w$]+\s*\([^)]*\)\s*\{\s*$/;
+const SPREAD_LINE = /^\s*\.\.\.[\w$.()]+\s*,?\s*$/;
+const STRING_ENTRY = /^\s*(['"])[^'"]+\1\s*,?\s*$/;
+const INLINE_SPREAD_MERGE = /\{\s*\.\.\.([\w$.()]+)\s*,\s*(?=[^}]*\S)/;
+
+// ── element-removed / handler-dropped (JSX) ──
+// One-line elements only, so the removal is syntactically safe by construction.
+const JSX_SELF_CLOSING = /^\s*<[A-Za-z][\w.-]*\b[^<>]*\/>\s*$/;
+const JSX_PAIRED_LINE = /^\s*<([A-Za-z][\w.-]*)\b[^<>]*>[^<>]*<\/\1>\s*$/;
+const JSX_HANDLER_PROP_LINE = /^\s*on[A-Z]\w*=\{(?:[^{}]|\{[^{}]*\})*\}\s*$/;
+const JSX_INLINE_HANDLER = /\s+on[A-Z]\w*=\{(?:[^{}]|\{[^{}]*\})*\}/;
+
+// ── argument-swapped ──
+// A call whose first argument is derived from a parameter or a request-like
+// value. `callee(` must not be a keyword, a constructor, an import, or a test
+// helper; the argument must not be a literal.
+const CALL_WITH_ARG = /(?<![\w$.])(?<!\bnew\s+)(?!(?:if|for|while|switch|catch|return|function|typeof|await|new|require|import|expect|describe|it|test|vi|jest|console|logger)\b)([\w$]+(?:\.[\w$]+)*)\(\s*((?:[\w$]+(?:\?\.|\.)[\w$?.]+)|(?:[\w$]+\([^()]*\))|(?:[\w$]+))\s*(?=,|\))/g;
+const REQUEST_LIKE = /^(?:req|request|res|ctx|context|event|input|args|params|options|opts|props|state|session|user|payload|body|query|headers|msg|message|job|task)$/;
+
 /** Name of the function whose head is on this line, or null. */
 export function functionHead(line) {
   for (const re of FUNCTION_HEAD) {
@@ -35,17 +80,177 @@ export function functionHead(line) {
   return null;
 }
 
+/**
+ * Parameter names declared on a function-head line: plain, defaulted,
+ * typed, rest, and the leaves of one level of destructuring. Best effort.
+ */
+export function functionParams(line) {
+  const open = line.indexOf('(');
+  const arrow = line.indexOf('=>');
+  if (open === -1 || (arrow !== -1 && arrow < open)) {
+    // `const f = x => …` style: a bare identifier before `=>`
+    const bare = /=\s*(?:async\s+)?([\w$]+)\s*=>/.exec(line);
+    return bare ? [bare[1]] : [];
+  }
+  let depth = 0;
+  let close = -1;
+  for (let i = open; i < line.length; i++) {
+    if (line[i] === '(') depth++;
+    else if (line[i] === ')' && --depth === 0) { close = i; break; }
+  }
+  if (close === -1) return [];
+  const inner = line.slice(open + 1, close);
+  const names = [];
+  for (const raw of inner.split(/,(?![^{[]*[}\]])/)) {
+    let p = raw.trim();
+    if (!p) continue;
+    p = p.replace(/^\.\.\./, '').replace(/\s*=[\s\S]*$/, '').replace(/\s*:[^,{}]*$/, '').replace(/\?$/, '');
+    const destructured = /^[{[]([\s\S]*)[}\]]$/.exec(p);
+    if (destructured) {
+      for (const part of destructured[1].split(',')) {
+        const leaf = part.trim().replace(/^\.\.\./, '').split(/\s*[:=]\s*/).pop().trim();
+        if (/^[\w$]+$/.test(leaf)) names.push(leaf);
+      }
+    } else if (/^[\w$]+$/.test(p)) {
+      names.push(p);
+    }
+  }
+  return names;
+}
+
 function isGuard(cond, lines, i) {
   if (/^\s*!/.test(cond)) return true;
   const tail = lines.slice(i, i + 4).join('\n');
   return GUARD_BODY.test(tail);
 }
 
-/** Proposals for one line. Each: { faultClass, description, replace } where find is the line itself. */
-export function proposalsForLine(lines, i) {
+const openerCache = new WeakMap();
+
+/**
+ * For every line, the innermost bracket left open before that line starts:
+ * `{ line, char }` or null. One forward pass with a stack; strings and
+ * comments are not parsed (deterministic heuristic, like everything here).
+ */
+export function openerIndex(lines) {
+  if (openerCache.has(lines)) return openerCache.get(lines);
+  const out = new Array(lines.length);
+  const stack = [];
+  for (let i = 0; i < lines.length; i++) {
+    out[i] = stack.length ? stack[stack.length - 1] : null;
+    const line = lines[i];
+    if (COMMENT.test(line)) continue;
+    for (const ch of line) {
+      if (ch === '{' || ch === '[' || ch === '(') stack.push({ line: i, char: ch });
+      else if (ch === '}' || ch === ']' || ch === ')') stack.pop();
+    }
+  }
+  openerCache.set(lines, out);
+  return out;
+}
+
+const balanced = (line) => {
+  const n = (re) => (line.match(re) ?? []).length;
+  return n(/\{/g) === n(/\}/g) && n(/\[/g) === n(/\]/g) && n(/\(/g) === n(/\)/g);
+};
+
+/** A line that can be removed on its own: balanced, and either comma-terminated or followed by the closer. */
+function removableAlone(lines, i) {
+  const line = lines[i];
+  if (!balanced(line)) return false;
+  if (/,\s*$/.test(line)) return true;
+  for (let j = i + 1; j < lines.length; j++) {
+    if (!lines[j].trim()) continue;
+    return /^\s*[}\])]/.test(lines[j]);
+  }
+  return false;
+}
+
+function fieldDropProposals(lines, i) {
+  const line = lines[i];
+  const out = [];
+  const opener = openerIndex(lines)[i];
+  const openerLine = opener ? lines[opener.line] : '';
+  const inPayload = opener?.char === '{' && PAYLOAD_OPENER.test(openerLine) && !TYPE_OPENER.test(openerLine);
+  const inAllowList = opener?.char === '[' && ALLOWLIST_OPENER.test(openerLine);
+
+  if (inPayload && !METHOD_LINE.test(line) && removableAlone(lines, i)) {
+    const schema = /\b(?:z|yup|joi|v|t)\.|\.(?:object|shape|extend|merge|pick|omit)\s*\(|\bobject\s*\(/i.test(openerLine);
+    if (SPREAD_LINE.test(line)) {
+      out.push({ faultClass: 'field-dropped', description: `Base object dropped from the merge: \`${line.trim()}\` no longer contributes its fields.`, replace: '' });
+    } else if (PROP_LINE.test(line) || SHORTHAND_LINE.test(line)) {
+      const name = line.trim().replace(/[,:].*$/, '').replace(/^['"[]|['"\]]$/g, '');
+      out.push({ faultClass: 'field-dropped', description: schema ? `Field dropped from the schema: \`${name}\` is no longer validated or serialised.` : `Field dropped: \`${name}\` is no longer written.`, replace: '' });
+    }
+  } else if (inAllowList && STRING_ENTRY.test(line) && removableAlone(lines, i)) {
+    out.push({ faultClass: 'field-dropped', description: `Field dropped from the allow-list: ${line.trim().replace(/,\s*$/, '')} is no longer permitted.`, replace: '' });
+  }
+
+  const merge = INLINE_SPREAD_MERGE.exec(line);
+  if (merge) {
+    out.push({ faultClass: 'field-dropped', description: `Base object dropped from the inline merge: \`...${merge[1]}\` no longer contributes its fields.`, replace: line.replace(merge[0], '{ ') });
+  }
+  return out;
+}
+
+function jsxProposals(lines, i) {
+  const line = lines[i];
+  const out = [];
+  if (JSX_SELF_CLOSING.test(line) || JSX_PAIRED_LINE.test(line)) {
+    const tag = /<([A-Za-z][\w.-]*)/.exec(line)[1];
+    out.push({ faultClass: 'element-removed', description: `Element removed: \`<${tag}>\` is no longer rendered.`, replace: '' });
+  }
+  if (JSX_HANDLER_PROP_LINE.test(line)) {
+    const name = /on[A-Z]\w*/.exec(line)[0];
+    out.push({ faultClass: 'handler-dropped', description: `Handler dropped: \`${name}\` is no longer wired.`, replace: '' });
+  } else {
+    const m = JSX_INLINE_HANDLER.exec(line);
+    if (m && /<[A-Za-z]/.test(line)) {
+      const name = /on[A-Z]\w*/.exec(m[0])[0];
+      out.push({ faultClass: 'handler-dropped', description: `Handler dropped: \`${name}\` is no longer wired.`, replace: line.replace(m[0], '') });
+    }
+  }
+  return out;
+}
+
+function isDerived(arg, params) {
+  const idents = arg.match(/[\w$]+/g) ?? [];
+  if (idents.some((id) => params.has(id))) return true;
+  const head = /^([\w$]+)/.exec(arg)?.[1] ?? '';
+  return REQUEST_LIKE.test(head) || arg === 'this' || /^this[.?]/.test(arg);
+}
+
+function argumentSwapProposals(lines, i, params) {
+  const line = lines[i];
+  const out = [];
+  const head = functionHead(line);
+  const seen = new Set();
+  for (const m of line.matchAll(CALL_WITH_ARG)) {
+    const [whole, callee, arg] = m;
+    if (head && callee.split('.').pop() === head) continue; // the head of a declaration, not a call
+    if (/^(?:'|"|`|\d|true$|false$|null$|undefined$)/.test(arg)) continue;
+    if (!isDerived(arg, params)) continue;
+    if (seen.has(whole)) continue;
+    seen.add(whole);
+    const swap = (value) => line.replace(whole, `${callee}(${value}`);
+    out.push({ faultClass: 'argument-swapped', description: `Argument swapped: \`${callee}(${arg}, …)\` is called with \`undefined\` instead of the derived value.`, replace: swap('undefined') });
+    if (/\(/.test(arg)) out.push({ faultClass: 'argument-swapped', description: `Argument swapped: \`${callee}(${arg}, …)\` is called with an empty object instead of the derived value.`, replace: swap('{}') });
+  }
+  return out;
+}
+
+/**
+ * Proposals for one line. Each: { faultClass, description, replace } where
+ * find is the line itself. `ctx.params` is the enclosing function's parameter
+ * set (for argument-swapped); `ctx.fieldDrops = false` disables the
+ * data/UI shapes — field-dropped, element-removed, handler-dropped — for
+ * test files, fixtures and migrations, where an object or element is data,
+ * not the product's output.
+ */
+export function proposalsForLine(lines, i, ctx = {}) {
   const line = lines[i];
   const out = [];
   if (!line.trim() || COMMENT.test(line)) return out;
+  const params = ctx.params ?? new Set();
 
   const ifm = IF_LINE.exec(line);
   if (ifm && isGuard(ifm[2], lines, i)) {
@@ -81,5 +286,11 @@ export function proposalsForLine(lines, i) {
   } else if ((m = WINDOW_NUM.exec(line))) {
     out.push({ faultClass: 'literal-changed', description: `Window widened ×1000: \`${m[1]}\` ${m[3]} becomes ${Number(m[3]) * 1000}.`, replace: line.replace(m[0], `${m[1]}${m[2] === ':' ? ': ' : ' = '}${Number(m[3]) * 1000}`) });
   }
+
+  if (ctx.fieldDrops !== false) {
+    out.push(...fieldDropProposals(lines, i));
+    out.push(...jsxProposals(lines, i));
+  }
+  out.push(...argumentSwapProposals(lines, i, params));
   return out;
 }

package/src/scaffold/scaffold.mjs

@@ -1,11 +1,14 @@
 import { readFileSync } from 'node:fs';
 import { basename, extname, join } from 'node:path';
-import { proposalsForLine, functionHead } from './producers.mjs';
+import { proposalsForLine, functionHead, functionParams } from './producers.mjs';
 import { locate } from '../probe/inject.mjs';
 import { discoverDefenders } from '../probe/discover.mjs';
 import { validate } from '../../spec/lib/validate.mjs';
 
 const ANNOTATION = /@claim\s+([A-Za-z0-9]+(?:[._]?[A-Za-z0-9]+)*-[A-Za-z0-9._-]*[A-Za-z0-9])\b/;
+// field-dropped is never proposed inside tests, fixtures or migrations: an
+// object literal there is data, not a payload the product writes.
+const NO_FIELD_DROPS = /\.(test|spec)\.[cm]?[jt]sx?$|(^|\/)(__tests__|__fixtures__|__mocks__|fixtures|migrations)\//;
 
 const idPart = (s) => s.replace(/[^A-Za-z0-9]+/g, '-').replace(/^-+|-+$/g, '').toUpperCase();
 
@@ -43,6 +46,8 @@ export function scaffoldFile({ projectDir, file, claimId, existingClaims, toolVe
   let offset = 0;
   let fn = null;
   let fnDepth = 0;
+  let params = new Set();
+  const fieldDrops = !NO_FIELD_DROPS.test(file);
   let depth = 0;
   let pendingAnnotation = null;
   const proposals = [];
@@ -54,9 +59,10 @@ export function scaffoldFile({ projectDir, file, claimId, existingClaims, toolVe
     if (head) {
       fn = head;
       fnDepth = depth;
+      params = new Set(functionParams(line));
     }
 
-    for (const p of proposalsForLine(lines, i)) {
+    for (const p of proposalsForLine(lines, i, { params, fieldDrops })) {
       const find = line;
       const { hits, occurrence } = anchorFor(source, find, offset);
       const fault = { ...p, find, replace: p.replace, expectHits: hits, occurrence, line: i + 1, fn, annotation: pendingAnnotation };
@@ -65,7 +71,7 @@ export function scaffoldFile({ projectDir, file, claimId, existingClaims, toolVe
     }
 
     depth += (line.match(/\{/g) ?? []).length - (line.match(/\}/g) ?? []).length;
-    if (fn && depth <= fnDepth && !head) fn = null;
+    if (fn && depth <= fnDepth && !head) { fn = null; params = new Set(); }
     if (pendingAnnotation && !ann && !head && line.trim() && !/^\s*(\/\/|\*|\/\*)/.test(line)) pendingAnnotation = null;
     offset += line.length + 1;
   });

package/src/status/status.mjs

@@ -8,6 +8,7 @@ import { resolveDefenders } from '../probe/runners/shared.mjs';
 import { discoverDefenders } from '../probe/discover.mjs';
 import { sortForReport } from '../render.mjs';
 import { computeChangedGate, defaultIgnorePath } from '../gate/changed.mjs';
+import { headSha, isAncestor } from '../git.mjs';
 
 export const faultContentHash = (fault) => sha256(`${fault.find}\n${fault.replace}`);
 
@@ -23,7 +24,13 @@ const P = (projectDir) => ({
  * Reads the claims file, evidence, baseline and the working tree; never
  * trusts a cached verdict whose inputs have changed.
  */
-export function computeStatus({ projectDir, toolVersion = '0.0.0', generatedAt = new Date().toISOString(), paths = P(projectDir), max = 20, changedRef, includeDirty = false }) {
+/**
+ * `evidence` overrides the project's own evidence file: a document taken on
+ * ANOTHER commit (CI's, fetched as an artifact) is legitimate input. Staleness
+ * is computed from the recorded input hashes exactly as for a local run, so a
+ * foreign document is trusted only for the faults whose inputs still match.
+ */
+export function computeStatus({ projectDir, toolVersion = '0.0.0', generatedAt = new Date().toISOString(), paths = P(projectDir), max = 20, changedRef, includeDirty = false, evidence: evidenceOverride }) {
   const rel = (p) => relative(projectDir, p) || '.';
   const doc = {
     schemaVersion: 1,
@@ -36,6 +43,7 @@ export function computeStatus({ projectDir, toolVersion = '0.0.0', generatedAt =
     stale: [],
     changedFaults: [],
     findings: [],
+    notes: [],
     paths: {},
   };
   // ── Claim coverage of the change, when a reference is known ──
@@ -79,7 +87,8 @@ export function computeStatus({ projectDir, toolVersion = '0.0.0', generatedAt =
     return doc;
   }
 
-  const hasEvidence = existsSync(paths.evidence);
+  const evidenceFile = evidenceOverride ?? paths.evidence;
+  const hasEvidence = existsSync(evidenceFile);
   const hasProvisional = existsSync(paths.provisional);
   if (hasProvisional) doc.paths.provisionalEvidence = rel(paths.provisional);
   if (!hasEvidence) {
@@ -93,11 +102,29 @@ export function computeStatus({ projectDir, toolVersion = '0.0.0', generatedAt =
     }
     return doc;
   }
-  doc.paths.evidence = rel(paths.evidence);
-  const evidence = readSpecDoc('evidence', paths.evidence);
+  doc.paths.evidence = rel(evidenceFile);
+  doc.evidenceSource = evidenceOverride ? 'provided' : 'local';
+  const evidence = readSpecDoc('evidence', evidenceFile);
+  // A verdict is about a commit. When the evidence describes a different one,
+  // say both: "looks right and is not" is the failure mode this prevents.
+  doc.evidenceHead = evidence.run.repo.snapshot ?? evidence.run.repo.head;
+  const localHead = (() => { try { return headSha(projectDir); } catch { return null; } })();
+  if (localHead) doc.head = localHead;
+
   const baseline = existsSync(paths.baseline) ? readSpecDoc('baseline', paths.baseline) : undefined;
   if (baseline) doc.paths.baseline = rel(paths.baseline);
 
+  // ── Baseline provenance: informational, never a state. A baseline frozen
+  // from a snapshot or a dirty tree names the PARENT of the commit that carries
+  // its tests; once HEAD moved on, say so and name the way to re-stamp. ──
+  if (baseline?.head) {
+    const head = headSha(projectDir);
+    if (head && head !== baseline.head) {
+      if (baseline.snapshot || baseline.dirty) doc.notes.push(`baseline was frozen from a ${baseline.snapshot ? 'working-tree snapshot' : 'dirty tree'} at ${baseline.head.slice(0, 7)}; HEAD is ${head.slice(0, 7)} — it predates the commit that carries its tests. After a clean probe of HEAD reproduces the same fingerprints: testguard baseline --restamp`);
+      else if (!isAncestor(projectDir, baseline.head, head)) doc.notes.push(`baseline head ${baseline.head.slice(0, 7)} is not an ancestor of HEAD ${head.slice(0, 7)} (rewritten or foreign history); re-probe and re-baseline if the fingerprints changed`);
+    }
+  }
+
   // ── Staleness: does the evidence still describe this claims file and this tree? ──
   const probed = new Map(evidence.records.map((r) => [`${r.claim.id}/${r.subject.id}`, r]));
   for (const key of faultIndex.keys()) if (!probed.has(key)) doc.stale.push(`fault ${key} has never been probed`);
@@ -124,6 +151,14 @@ export function computeStatus({ projectDir, toolVersion = '0.0.0', generatedAt =
   const counts = {};
   for (const r of evidence.records) counts[r.verdict] = (counts[r.verdict] ?? 0) + 1;
   doc.counts.byVerdict = counts;
+  // L3 independence and observed flakiness, as numbers rather than adjectives.
+  const kills = evidence.records.filter((r) => r.verdict === 'killed');
+  if (kills.length) doc.counts.killedCoAuthored = kills.filter((r) => r.detail.independence?.class === 'co-authored').length;
+  const flaky = evidence.records.filter((r) => r.detail.flakeRate?.failures > 0);
+  if (flaky.length) {
+    doc.counts.flakyDefenderSets = new Set(flaky.map((r) => r.defenders.resolved.join('\n'))).size;
+    doc.counts.worstFlakeRate = Math.max(...flaky.map((r) => r.detail.flakeRate.failures / r.detail.flakeRate.runs));
+  }
   doc.counts.new = g.new.length + g.belowFloor.length;
   doc.counts.baselined = g.baselined.length;
   const ranked = sortForReport([...g.new, ...g.belowFloor, ...g.baselined]);
@@ -170,7 +205,7 @@ export function computeStatus({ projectDir, toolVersion = '0.0.0', generatedAt =
       action: fixClaim ? 'probe' : 'write-test',
       command: fixClaim
         ? `edit ${top.claimId}/${top.subjectId} in testguard.claims.json, then: testguard probe --claim ${top.claimId} --include-dirty`
-        : `write a test in ${where} that fails on ${top.claimId}/${top.subjectId} and passes on HEAD, then: testguard probe --claim ${top.claimId} --include-dirty`,
+        : `write a test in ${where} that fails on ${top.claimId}/${top.subjectId} and passes on HEAD, then: testguard admit ${defenders[0] ?? '<that test file>'} --claim ${top.claimId}`,
       why: whyByVerdict[top.verdict] ?? `${top.claimId}/${top.subjectId} is ${top.verdict}.`,
       target: { claimId: top.claimId, subjectId: top.subjectId, ...(top.file ? { file: top.file } : {}), verdict: top.verdict },
     };
@@ -187,7 +222,12 @@ export function computeStatus({ projectDir, toolVersion = '0.0.0', generatedAt =
 }
 
 export function renderStatus(doc) {
-  const lines = [`state: ${doc.state}${doc.provisional ? ' (provisional)' : ''} — ${doc.counts.claims} claims / ${doc.counts.faults} faults` + (doc.counts.byVerdict ? `; ${Object.entries(doc.counts.byVerdict).map(([k, v]) => `${v} ${k}`).join(', ')}; ${doc.counts.new ?? 0} new, ${doc.counts.baselined ?? 0} baselined` : '')];
+  const lines = [];
+  if (doc.evidenceSource === 'provided') {
+    lines.push(`evidence: ${doc.paths.evidence} (provided)` + (doc.evidenceHead ? ` describes ${doc.evidenceHead.slice(0, 7)}` : '') + (doc.head && doc.evidenceHead && doc.head !== doc.evidenceHead ? `; this tree is ${doc.head.slice(0, 7)}` : ''));
+  }
+  lines.push(`state: ${doc.state}${doc.provisional ? ' (provisional)' : ''} — ${doc.counts.claims} claims / ${doc.counts.faults} faults` + (doc.counts.byVerdict ? `; ${Object.entries(doc.counts.byVerdict).map(([k, v]) => `${v} ${k}`).join(', ')}; ${doc.counts.new ?? 0} new, ${doc.counts.baselined ?? 0} baselined` : '')
+  );
   if (doc.changes) {
     const c = doc.changes;
     lines.push(`changes:  ${c.changed} file${c.changed === 1 ? '' : 's'} since ${c.ref}; ${c.evaluated} evaluated, ${c.excluded} excluded, ${c.uncovered.length} unclaimed`);
@@ -197,6 +237,7 @@ export function renderStatus(doc) {
   }
   for (const c of doc.changedFaults) lines.push(`CHANGED   ${c.claimId}/${c.subjectId} edited since it ${c.previousVerdict} (${c.file})`);
   for (const s of doc.stale.slice(0, 8)) lines.push(`stale     ${s}`);
+  for (const n of doc.notes ?? []) lines.push(`note      ${n}`);
   lines.push(`next:     [${doc.next.action}] ${doc.next.command}`);
   lines.push(`why:      ${doc.next.why}`);
   return lines.join('\n');