pi-jev-wiki 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,10 +1,31 @@
 # Changelog
 
+## 0.3.0 — 2026-09-20
+
+### Added
+
+- `wiki_triage`: rejected-claim triage. Lists recent rejections with Jev scores, whether the
+  problem is evidence or policy, a concrete remedy per claim, and the accepted-vs-rejected
+  derivability ranges so miscalibrated thresholds are visible.
+
+### Changed
+
+- The `llm-wiki` skill now teaches the judgment criteria comprehensively: every score, the decision
+  gates in order, the framing exception, which evidence kinds pass, phrasing rules, a pre-submission
+  checklist, and threshold calibration.
+- High-importance architecture, invariant, and decision framing that Jev rates derivable is queued
+  for confirmation instead of rejected (`thresholds.framingImportance`, default 0.6).
+- Rejection guidance treats a correctly rejected claim as a working system rather than a failure;
+  `wiki_insights` guidelines point at the criteria and at `wiki_triage`.
+
 ## 0.2.0 — 2026-09-19
 
 First public release. A pi package that builds and maintains a project mental-model wiki,
 with [Jev](https://typesafe.ai) (TypeSafe System One) as the calibrated decision layer.
 
+Published to npm as `pi-jev-wiki@0.2.0` on 2026-09-20 via an interactive publish, so this version
+has no provenance attestation; the next CI-published release will carry provenance.
+
 ### Intake
 
 - Research ingest (`wiki_ingest`): immutable raw sources, claim extraction with verbatim quote

package/README.md

@@ -146,7 +146,17 @@ under `docs/` and `research/` stays in the repository.
 
 ## Status
 
-P0 (walking skeleton) implemented: both intake channels (research ingest + agent insights),
-architecture-first pages, TOC/log, decision ledger, Jev client with retries and usage accounting,
-guided writing. See `docs/plans/PLAN.md` §9 for P1–P3 (change-driven invalidation, paged routing beyond 250
-pages, agent-managed review queue, lint, decision-quality evaluation).
+**Published:** [`pi-jev-wiki@0.2.0`](https://www.npmjs.com/package/pi-jev-wiki) — first release was
+an interactive publish, so it has no provenance attestation; CI publishing is wired and the next
+version bump will be the first release with provenance. Listed on the
+[pi package gallery](https://pi.dev/packages/pi-jev-wiki).
+
+Implemented through P3: both intake channels (research ingest + agent insights), architecture-first
+pages, TOC/log, decision ledger, change-driven invalidation (`wiki_sync`), agent-managed review,
+draft/auto writers with adaptive risk, pluggable search (index/BM25/qmd), hierarchical TOC,
+lint/consolidation checks, redaction, cross-process locking, `wiki_doctor`/`wiki_setup`, and
+offline unit + scale tests.
+
+Not yet done: trusted publishing (OIDC) migration, the decision-quality evaluation harness, and the
+remaining hardening items tracked in [`docs/HARDENING.md`](docs/HARDENING.md). See
+[`docs/RELEASING.md`](docs/RELEASING.md) for the release process.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-jev-wiki",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Project mental-model wiki for pi, maintained by agent insights and Jev decisions",
   "type": "module",
   "license": "MIT",

package/skills/llm-wiki/SKILL.md

@@ -10,6 +10,9 @@ the system: how it is structured, why, and what a change touches. It is not a co
 Jev (a calibrated decision model) judges whether claims are grounded, derivable, durable, and
 where they belong; you do the writing.
 
+**Read [How claims are judged](#how-claims-are-judged) before composing insights.** Most
+rejections are phrasing or evidence problems that are easy to avoid once you know the gates.
+
 ## Setup (when no key is configured)
 
 If Jev calls fail with an authentication error, or the user asks how to connect a provider:
@@ -23,17 +26,94 @@ If Jev calls fail with an authentication error, or the user asks how to connect
 Never print the key value. TypeSafe uses `TYPESAFE_API_KEY` (`JEV_TOKEN` also works); OpenRouter
 uses `OPENROUTER_API_KEY` with provider `openrouter`, or pi's own `/login openrouter` credential.
 
-## The quality bar
+## How claims are judged
+
+You are the writer; Jev decides. These are the criteria, in the order they are applied.
+
+### The quality bar
 
 File only what the repository cannot answer cheaply:
 
-- **Delete test** — if deleting the page would just send a future agent back to reading code, it
-  does not belong.
+- **Delete test** — if deleting the page would send a future agent straight back to reading code,
+  it does not belong. The one exception is high-importance framing (see the framing gate).
 - **Decision test** — does it help decide *where a change belongs* or *what a change breaks*?
 
 Good: module responsibilities and boundaries, dependency direction, data flow, invariants,
 decisions with rationale, change-impact knowledge, historical attempts, external constraints,
-domain glossary. Bad: function bodies, obvious implementation, transient task state, code excerpts.
+domain glossary, gotchas that cost real debugging time.
+
+Bad: function bodies, obvious implementation, transient task state, code excerpts, restated docs.
+
+### What Jev scores
+
+Every claim is judged against the evidence you attach, and returns calibrated scores:
+
+| Score | Question |
+|---|---|
+| `grounded` | Does the evidence state or directly imply the claim? |
+| `derivable` | Could a developer re-derive this from the repository in under a minute? |
+| `durable` | Will it still be true and useful in a month? |
+| `importance` | How load-bearing is it? (ephemeral → contextual → durable → canonical) |
+| `criticality` | How costly is acting on it incorrectly? |
+| `already_known` | Does the wiki already hold it? |
+| `trustTier` | Basis of the claim: `source_document`, `verified_in_repo`, `user_stated`, `inference`, `speculation` |
+
+### The decision gates, in order
+
+| # | Condition | Outcome |
+|---|---|---|
+| 1 | `sensitive` ≥ 0.9 | **rejected** — secrets and PII are never filed |
+| 2 | `derivable` ≥ 0.5 | **rejected** as implementation detail, *except* high-importance framing (below) |
+| 3 | `already_known` ≥ 0.9 | **rejected** as duplicate — reinforce or extend the existing claim |
+| 4 | `grounded` ≥ 0.8 and `importance` ≥ 1 | **filed**, or **reinforced** when it extends or agrees with existing claims |
+| 5 | `grounded` ≥ 0.7 | **queued for review** (below auto-accept) |
+| 6 | `grounded` < 0.7 | filed only with trust tier `user_stated` (stored with lower status) or `verified_in_repo`; `inference` and `speculation` never file |
+| 7 | otherwise | **rejected** as unsupported |
+
+**Framing gate (the exception to #2):** architecture, invariant, and decision claims with
+`importance` ≥ 0.6 are **queued for confirmation** when Jev rates them derivable, instead of being
+dropped. The reason: a future agent needs the frame even when the code technically contains the
+pieces. Lower-importance derivable claims still fail the delete test.
+
+### Evidence that passes
+
+Attach evidence that *states* what you claim — Jev reads it.
+
+| Kind | Use it for | Notes |
+|---|---|---|
+| `commit` | decisions and rationale | The strongest artifact for *why*. Use the hash of the commit that introduced the change; its message is read. |
+| `source` | external knowledge, docs | Include a verbatim quote. Paraphrases fail grounding. |
+| `user` | policies the user stated | Filed with `status: user-stated` (lower trust), not verified. |
+| `file` | code-visible structure | The extension reads and excerpts the file for Jev. A bare path does not ground *intent* or *rationale* — pair it with a commit or a quote for "why" claims. |
+| `command` / `test` | reproducible behavior | Include the command and the observed output. |
+
+### Phrasing rules
+
+- **Atomic**: one claim, one idea. Split mechanism, rationale, and consequence into separate claims.
+- **Scope to the evidence**: if the quote supports X, do not claim X and Y.
+- **Separate *what* from *why***: "the client retries on 429" is derivable → rejected; "retries
+  live in the client because provider gateways implement Retry-After inconsistently" is rationale → durable.
+- **Prefer framing over detail**: decisions, invariants, boundaries, and gotchas over implementation facts.
+- **Name the kind**: `decision`, `invariant`, `architecture`, `gotcha`, `pattern`, `procedure`,
+  `fact`, `preference` — it decides which gate applies.
+
+### Pre-submission checklist
+
+1. Can another agent re-derive it in a minute from the repo? → don't submit, or submit it as
+   high-importance framing.
+2. Can I point to a quote, commit, or user sentence that states it? → if not, it will be rejected
+   as unsupported.
+3. Is it transient task state? → don't submit.
+4. Does the wiki already say it? → reinforce or extend the existing page instead.
+5. Is it code-visible but load-bearing framing? → submit as architecture/invariant/decision; it
+   will be queued rather than dropped.
+
+### Thresholds and calibration
+
+Defaults: `autoAccept` 0.8, `minSupport` 0.7, `minDerivable` 0.5, `framingImportance` 0.6,
+`minImportance` 1. They are configurable in `.pi/jev-wiki.json` (project) or
+`~/.pi/agent/jev-wiki.json` (global). If rejections look wrong for this project, run
+`wiki_triage`: it reports the accepted vs rejected score ranges and flags overlapping thresholds.
 
 ## Layout
 
@@ -69,6 +149,23 @@ Rejected claims are **not** written to the wiki — even when the user explicitl
 content. Report what was rejected and why, so the user can supply better evidence or a stronger
 artifact. Never hand-write a rejected claim into a page.
 
+### When a claim is rejected
+
+Rejections are diagnosable — run `wiki_triage` to see the scores, the reason, and the fix for each:
+
+- **derivable from code**: add what the code cannot show — a commit message (evidence `kind: commit`),
+  a source quote, or the rationale behind the decision. High-importance architecture, invariant, and
+  decision framing is queued for confirmation instead of dropped.
+- **unsupported**: attach evidence that *states* the claim: a verbatim quote, the commit that
+  introduced it, or the user's own words (`kind: user`). A file reference without a supporting
+  passage is not enough.
+- **duplicate**: find the page that covers it and reinforce or extend it instead of filing a new claim.
+- **sensitive**: never file it; redact secrets and PII first.
+
+If a rejected claim still matters after applying the remedy, re-submit it with the better evidence
+rather than writing it by hand. If it does not survive re-submission, tell the user why — a
+correctly rejected claim is a working system, not a failure.
+
 ### Ingest a document (research channel)
 
 1. `wiki_ingest` with `path` (or `text`) — it stores the raw source, extracts claims, and returns
@@ -78,12 +175,12 @@ artifact. Never hand-write a rejected claim into a page.
 
 ### Capture session insights (work channel)
 
-1. Compose atomic insights with evidence pointers (files, commits, tests, user statements).
-   No transient state, no code snippets, nothing derivable from the repo.
-2. `wiki_insights` with the list — Jev filters (derivable/durable/sensitive), relates them to
-   existing knowledge, and chooses placement. Include file/commit evidence: file evidence is read
-   and excerpted for Jev, which grounds the decision.
-3. Write or merge the **accepted** pages, then `wiki_finalize`.
+1. Compose atomic insights against the [criteria](#how-claims-are-judged). For decisions, attach
+   the introducing commit; for policy, the user's words; for documents, a verbatim quote.
+2. `wiki_insights` with the list — Jev filters, relates them to existing knowledge, and chooses
+   placement. File evidence is read and excerpted for Jev, which grounds the decision.
+3. Write or merge the **accepted** pages, then `wiki_finalize`. If a claim is queued under the
+   framing gate, it is worth filing: confirm it via `wiki_review` and write the page.
 
 ## Page format
 

package/src/config.ts

@@ -40,6 +40,7 @@ export interface JevWikiConfig {
 		autoAccept: number;
 		minSupport: number;
 		minDerivable: number;
+		framingImportance: number;
 		minNovelty: number;
 		minImportance: number;
 	};
@@ -65,7 +66,7 @@ export const DEFAULT_CONFIG: JevWikiConfig = {
 	routing: { shardSize: 250, minFit: 0.6, newPageConfidence: 0.7 },
 	review: { mode: "agent", escalateCriticality: 0.85, maxPerSession: 10 },
 	sync: { onSessionStart: "check", onCommit: false, backstopLintDays: 14 },
-	thresholds: { autoAccept: 0.8, minSupport: 0.7, minDerivable: 0.5, minNovelty: 0.6, minImportance: 1 },
+	thresholds: { autoAccept: 0.8, minSupport: 0.7, minDerivable: 0.5, framingImportance: 0.6, minNovelty: 0.6, minImportance: 1 },
 	weights: { grounded: 0.45, importance: 0.25, nonDerivable: 0.2, authority: 0.1 },
 	toc: { maxTokens: 3000 },
 	lint: { orphanMinAgeDays: 7, duplicateSimilarity: 0.72 },

package/src/extension.ts

@@ -23,6 +23,7 @@ import { applyReinforcement, applySupersession, bestCandidatePage } from "./prov
 import { redact } from "./redact.ts";
 import { appendSessionLog, promoteRecurring } from "./sessionlog.ts";
 import { renderStructure, scanStructure } from "./structure.ts";
+import { buildTriageReport, renderTriage } from "./triage.ts";
 import { extractInsights, sessionTextFromEntries } from "./pipeline/capture.ts";
 import {
 	applyReviewResolution,
@@ -966,8 +967,9 @@ export default function (pi: ExtensionAPI) {
 		promptSnippet: "Capture durable project insights from this session into the wiki",
 		promptGuidelines: [
 			"Use wiki_insights at the end of substantive work to capture durable, non-derivable knowledge (decisions, invariants, architecture, gotchas) with evidence pointers.",
+			"Before submitting, apply the pre-submission checklist in the llm-wiki skill (How claims are judged): the evidence must state the claim; attach the introducing commit for decisions and the user's own words for policy.",
 			"Do not capture transient task state, code snippets, or anything derivable by reading the repo.",
-			"After wiki_insights, write or merge the recommended pages, then call wiki_finalize.",
+			"After wiki_insights, write or merge only the accepted pages, then call wiki_finalize. Use wiki_triage to diagnose rejected claims instead of writing them by hand.",
 		],
 		parameters: Type.Object({
 			insights: Type.Array(
@@ -1446,6 +1448,28 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	pi.registerTool({
+		name: "wiki_triage",
+		label: "Triage Rejected Insights",
+		description:
+			"Explain rejected wiki claims: why each was rejected, its Jev scores, whether the problem is evidence or policy, how to fix it, and whether the derivability threshold is calibrated for this project. No model calls.",
+		promptSnippet: "Triage rejected insights and how to fix them",
+		promptGuidelines: [
+			"Use wiki_triage when an agent or user disagrees with rejected insights, and before re-submitting a rejection.",
+			"After wiki_triage, re-submit fixable claims with wiki_insights using commit messages or quotes as evidence.",
+		],
+		parameters: Type.Object({
+			limit: Type.Optional(Type.Number({ description: "Max rejections to list (default 20)" })),
+			sinceDays: Type.Optional(Type.Number({ description: "Only consider rejections from the last N days" })),
+		}),
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const { layout } = runtimeFor(ctx);
+			const ledger = await readLedger(layout);
+			const report = buildTriageReport(ledger, { limit: params.limit ?? 20, sinceDays: params.sinceDays });
+			return { content: [{ type: "text", text: renderTriage(report) }], details: report };
+		},
+	});
+
 	// Commands -----------------------------------------------------------------
 
 	pi.registerCommand("wiki:status", {

package/src/pipeline/adjudicate.ts

@@ -371,6 +371,20 @@ export function decideClaim(verdicts: ClaimVerdicts, config: ResolvedConfig): Cl
 		return { action: "reject_sensitive", score: 0, reasons: ["contains sensitive content"] };
 	}
 	if (verdicts.derivable >= thresholds.minDerivable) {
+		const framingKinds = ["architecture", "invariant", "decision"];
+		const framing =
+			framingKinds.includes(verdicts.kind) &&
+			verdicts.importanceNorm >= thresholds.framingImportance &&
+			verdicts.grounded >= 0.5;
+		if (framing) {
+			return {
+				action: "review",
+				score: 0,
+				reasons: [
+					`derivable from code (${verdicts.derivable.toFixed(2)} ≥ ${thresholds.minDerivable}) but high-importance ${verdicts.kind} framing — queued for confirmation instead of dropped`,
+				],
+			};
+		}
 		return {
 			action: "reject_derivable",
 			score: 0,

package/src/triage.ts

@@ -0,0 +1,190 @@
+/**
+ * Triage for rejected claims.
+ *
+ * The decision ledger already holds every verdict. This module turns it into an
+ * actionable report: what was rejected, why, whether the rejection is fixable
+ * (re-submit with better evidence) or a policy call (high-importance framing),
+ * and whether the derivability threshold is calibrated for this project.
+ */
+import type { LedgerEntry } from "./ledger.ts";
+
+export interface RejectionEntry {
+	ts: string;
+	claim: string;
+	action: string;
+	reason: string;
+	derivable?: number;
+	grounded?: number;
+	importance?: number;
+	kind?: string;
+	trustTier?: string;
+}
+
+export interface ScoreStats {
+	count: number;
+	min: number;
+	median: number;
+	max: number;
+}
+
+export interface TriageReport {
+	rejections: RejectionEntry[];
+	counts: Record<string, number>;
+	separated: {
+		acceptedDerivable: ScoreStats | null;
+		rejectedDerivable: ScoreStats | null;
+		rejectedGrounded: ScoreStats | null;
+	};
+}
+
+const ADJUDICATE_OPS = new Set(["insight.adjudicate", "ingest.adjudicate"]);
+const ACCEPTED = new Set(["file", "reinforce", "file_user_stated"]);
+
+function asRecord(value: unknown): Record<string, unknown> {
+	return value && typeof value === "object" ? (value as Record<string, unknown>) : {};
+}
+
+function asNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function stats(values: number[]): ScoreStats | null {
+	if (values.length === 0) return null;
+	const sorted = [...values].sort((a, b) => a - b);
+	return {
+		count: sorted.length,
+		min: Number(sorted[0].toFixed(2)),
+		median: Number(sorted[Math.floor(sorted.length / 2)].toFixed(2)),
+		max: Number(sorted[sorted.length - 1].toFixed(2)),
+	};
+}
+
+export function buildTriageReport(entries: LedgerEntry[], options?: { limit?: number; sinceDays?: number }): TriageReport {
+	const cutoff = options?.sinceDays ? Date.now() - options.sinceDays * 86_400_000 : undefined;
+	const rows = entries.filter((entry) => {
+		if (!ADJUDICATE_OPS.has(String(entry.op))) return false;
+		if (cutoff !== undefined) {
+			const ts = Date.parse(String(entry.ts ?? ""));
+			if (!Number.isFinite(ts) || ts < cutoff) return false;
+		}
+		return true;
+	});
+
+	const counts: Record<string, number> = {};
+	const rejections: RejectionEntry[] = [];
+	const acceptedDerivable: number[] = [];
+	const rejectedDerivable: number[] = [];
+	const rejectedGrounded: number[] = [];
+
+	for (const row of rows) {
+		const action = String(row.action ?? "unknown");
+		counts[action] = (counts[action] ?? 0) + 1;
+		const verdict = asRecord(row.verdict);
+		const derivable = asNumber(verdict.derivable);
+		const grounded = asNumber(verdict.grounded);
+		if (ACCEPTED.has(action) && derivable !== undefined) acceptedDerivable.push(derivable);
+		if (action === "reject_derivable" && derivable !== undefined) rejectedDerivable.push(derivable);
+		if (action === "reject_unsupported" && grounded !== undefined) rejectedGrounded.push(grounded);
+		if (!action.startsWith("reject")) continue;
+		rejections.push({
+			ts: String(row.ts ?? ""),
+			claim: String(row.subject ?? "(unknown claim)"),
+			action,
+			reason: String(row.reason ?? verdict.reason ?? ""),
+			derivable,
+			grounded,
+			importance: asNumber(verdict.importanceNorm),
+			kind: typeof verdict.kind === "string" ? verdict.kind : undefined,
+			trustTier: typeof verdict.trustTier === "string" ? verdict.trustTier : undefined,
+		});
+	}
+
+	rejections.sort((a, b) => b.ts.localeCompare(a.ts));
+	const limited = options?.limit ? rejections.slice(0, options.limit) : rejections;
+
+	return {
+		rejections: limited,
+		counts,
+		separated: {
+			acceptedDerivable: stats(acceptedDerivable),
+			rejectedDerivable: stats(rejectedDerivable),
+			rejectedGrounded: stats(rejectedGrounded),
+		},
+	};
+}
+
+/** Concrete next step for a rejected claim. */
+export function remedyFor(entry: RejectionEntry): string {
+	switch (entry.action) {
+		case "reject_derivable": {
+			const framing = ["architecture", "invariant", "decision"].includes(entry.kind ?? "") && (entry.importance ?? 0) >= 0.6;
+			if (framing) {
+				return "High-importance framing: re-submit as-is (kind architecture/invariant/decision) and it will be queued for confirmation instead of dropped.";
+			}
+			return "Add rationale the code cannot show: a commit message (evidence kind=commit), a source quote, or state the reasoning behind it as kind=decision.";
+		}
+		case "reject_unsupported":
+			return "Ground it: attach a verbatim quote (kind=source), the commit message that introduced it (kind=commit), a file excerpt that states it, or the user's own words (kind=user). Referencing a file without a supporting passage is not enough.";
+		case "reject_duplicate":
+			return "Already covered: find the page, then reinforce it (wiki_insights with the page's claim) or extend it rather than filing a new claim.";
+		case "reject_sensitive":
+			return "Contains secrets or PII; redact before re-submitting. Sensitive claims are never written to the wiki.";
+		default:
+			return "Review the reason above and re-submit with stronger evidence if the claim matters.";
+	}
+}
+
+export function renderTriage(report: TriageReport): string {
+	const lines: string[] = ["# Rejected-claim triage", ""];
+	const total = Object.values(report.counts).reduce((sum, count) => sum + count, 0);
+	lines.push(
+		`Adjudicated: ${total} · accepted ${["file", "reinforce", "file_user_stated"].reduce((sum, action) => sum + (report.counts[action] ?? 0), 0)} · rejected ${Object.entries(report.counts)
+			.filter(([action]) => action.startsWith("reject"))
+			.reduce((sum, [, count]) => sum + count, 0)} · queued ${report.counts.review ?? 0}`,
+		"",
+		`Breakdown: ${Object.entries(report.counts)
+			.map(([action, count]) => `${action} ${count}`)
+			.join(" · ")}`,
+		"",
+	);
+
+	const { acceptedDerivable, rejectedDerivable, rejectedGrounded } = report.separated;
+	if (acceptedDerivable && rejectedDerivable) {
+		const overlap = acceptedDerivable.max >= rejectedDerivable.min;
+		lines.push(
+			`## Threshold separation (project data)`,
+			`- accepted claims derivable: ${acceptedDerivable.min}–${acceptedDerivable.max} (median ${acceptedDerivable.median}, n=${acceptedDerivable.count})`,
+			`- reject_derivable derivable: ${rejectedDerivable.min}–${rejectedDerivable.max} (median ${rejectedDerivable.median}, n=${rejectedDerivable.count})`,
+			overlap
+				? `- ⚠️ ranges overlap: the ${"minDerivable"} threshold may be miscalibrated for this project — consider raising thresholds.minDerivable or filing the borderline claims as framing.`
+				: `- clean separation: no accepted claim scored at or above the rejected range.`,
+			"",
+		);
+	}
+	if (rejectedGrounded) {
+		lines.push(
+			`- reject_unsupported grounded: ${rejectedGrounded.min}–${rejectedGrounded.max} (median ${rejectedGrounded.median}, n=${rejectedGrounded.count}) — these are evidence problems, not policy problems.`,
+			"",
+		);
+	}
+
+	if (report.rejections.length === 0) {
+		lines.push("No rejected claims in the selected window.");
+		return lines.join("\n");
+	}
+
+	lines.push("## Rejections (newest first)", "", "| When | Action | Claim | Scores | Fix |", "|------|--------|-------|--------|-----|");
+	for (const entry of report.rejections) {
+		const when = entry.ts.slice(0, 16).replace("T", " ");
+		const scores = [
+			entry.grounded !== undefined ? `g ${entry.grounded.toFixed(2)}` : "",
+			entry.derivable !== undefined ? `d ${entry.derivable.toFixed(2)}` : "",
+			entry.importance !== undefined ? `i ${entry.importance.toFixed(2)}` : "",
+		]
+			.filter(Boolean)
+			.join(" · ");
+		const claim = entry.claim.replace(/\|/g, "\\|").slice(0, 90);
+		lines.push(`| ${when} | ${entry.action} | ${claim} | ${scores || "—"} | ${remedyFor(entry)} |`);
+	}
+	return lines.join("\n");
+}