@tech-leads-club/harness-toolkit 0.2.1

package/src/core/capability/capability.service.ts

@@ -0,0 +1,62 @@
+import { type CapabilityCatalog, type CatalogCapability, ENABLE_HINT } from "./capability.types.ts";
+
+export function resolveConfigPath(policy: Record<string, unknown>, configPath: string): unknown {
+  let current: unknown = policy;
+  for (const part of configPath.split(".").filter(Boolean)) {
+    if (!current || typeof current !== "object") {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current;
+}
+
+export function isAvailableNotEnabled(policy: Record<string, unknown>, cap: CatalogCapability): boolean {
+  const value = resolveConfigPath(policy, cap.configPath);
+  return cap.defaultOn ? value === false : value !== true;
+}
+
+export function listAvailableNotEnabled(
+  policy: Record<string, unknown>,
+  catalog: CapabilityCatalog,
+): CatalogCapability[] {
+  return catalog.capabilities.filter((cap) => isAvailableNotEnabled(policy, cap));
+}
+
+export function listNewlyAnnounceable(
+  policy: Record<string, unknown>,
+  catalog: CapabilityCatalog,
+  seenCatalogVersion: number,
+): CatalogCapability[] {
+  return listAvailableNotEnabled(policy, catalog).filter(
+    (cap) => cap.sinceCatalogVersion > seenCatalogVersion,
+  );
+}
+
+export function formatCapabilityDigest(caps: CatalogCapability[]): string {
+  const lines = ["Available for this project (not enabled yet):", ""];
+  for (const cap of caps) {
+    lines.push(`• ${cap.title}`);
+    lines.push(`  Benefit:  ${cap.benefit}`);
+    lines.push(`  Trade-off: ${cap.tradeOff}`);
+    lines.push("");
+  }
+  lines.push(ENABLE_HINT);
+  return lines.join("\n").trimEnd();
+}
+
+// hazard: this prefixed "WARN:" while the row it lands in already carries its level, so an operator read the word
+// twice. Seen in a real doctor run ([/decisions/ad-034.md](/decisions/ad-034.md)).
+export function formatDoctorWarn(cap: CatalogCapability): string {
+  return `${cap.title} off — ${cap.tradeOff} — ${ENABLE_HINT}`;
+}
+
+/**
+ * hazard: every capability that was merely *not enabled* produced a warning, so a healthy install printed nine of
+ * them and the two rows that needed attention were buried in the middle. An optional capability nobody switched on is
+ * inventory, not a fault, and a warning that fires on a healthy install teaches the reader to skip warnings — which
+ * is how the row that mattered got missed ([/decisions/ad-034.md](/decisions/ad-034.md)).
+ */
+export function formatAvailableInventory(caps: readonly CatalogCapability[]): string {
+  return `${caps.length} available and not enabled: ${caps.map((cap) => cap.id).join(", ")}. ${ENABLE_HINT}`;
+}

package/src/core/capability/capability.store.ts

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeJsonAtomic } from "../../platform/fs-atomic.ts";
+import { projectConfigPath, projectStateDir, runtimeHome } from "../../platform/paths.ts";
+import type { CapabilityCatalog, RuntimeSeen } from "./capability.types.ts";
+
+function readJson<T>(path: string): T | null {
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf8")) as T;
+  } catch {
+    return null;
+  }
+}
+
+export function catalogPath(home = runtimeHome()): string {
+  return join(home, "capabilities", "catalog.json");
+}
+
+export function loadCatalog(home = runtimeHome()): CapabilityCatalog | null {
+  const raw = readJson<CapabilityCatalog>(catalogPath(home));
+  if (!raw || typeof raw.catalogVersion !== "number" || !Array.isArray(raw.capabilities)) {
+    return null;
+  }
+  return raw;
+}
+
+export function readProjectPolicyRaw(projectDir: string): Record<string, unknown> | null {
+  return readJson<Record<string, unknown>>(projectConfigPath(projectDir));
+}
+
+function runtimeSeenPath(projectDir: string): string {
+  return join(projectStateDir(projectDir), "runtime-seen.json");
+}
+
+export function readRuntimeSeen(projectDir: string): RuntimeSeen {
+  const raw = readJson<RuntimeSeen>(runtimeSeenPath(projectDir));
+  if (!raw || typeof raw.catalogVersion !== "number" || raw.catalogVersion < 0) {
+    return { catalogVersion: 0 };
+  }
+  return raw;
+}
+
+export async function writeRuntimeSeen(projectDir: string, catalogVersion: number): Promise<void> {
+  await writeJsonAtomic(runtimeSeenPath(projectDir), {
+    catalogVersion,
+    updatedAt: new Date().toISOString(),
+  } satisfies RuntimeSeen);
+}

package/src/core/capability/capability.types.ts

@@ -0,0 +1,56 @@
+import type { HarnessEventKind } from "../../contracts/harness-event.ts";
+
+/**
+ * What a capability does at the moment it triggers, in the operator's terms rather than the code's. `deny` and
+ * `ask` answer the tool call; `block-stop` and `follow-up` both send the turn back to work and differ in whether
+ * the turn may end; `context` and `record` change no decision at all.
+ */
+export type CapabilityVerdict = "deny" | "ask" | "block-stop" | "follow-up" | "context" | "record";
+
+export const SUMMARY_MAX_CHARS = 120;
+
+export type CatalogCapability = {
+  id: string;
+  configPath: string;
+  title: string;
+  /**
+   * One line stating what this rail checks, short enough to sit in a table cell next to twenty others. Capped at
+   * `SUMMARY_MAX_CHARS`: a rail that cannot be stated in a line is one the reader cannot scan past, and the
+   * unbounded `benefit` field is where the full case belongs.
+   */
+  summary: string;
+  benefit: string;
+  tradeOff: string;
+  defaultOn: boolean;
+  sinceCatalogVersion: number;
+  /**
+   * The events whose handler evaluates this capability. Required, and checked against `HARNESS_EVENT_KINDS`
+   * — the question "when does this fire?" was the one the README could not answer, and a free-text answer is
+   * one refactor away from naming an event that no longer exists.
+   */
+  fires: HarnessEventKind[];
+  /** What happens when it triggers. */
+  verdict: CapabilityVerdict;
+  /**
+   * The command or file that shows this capability's own record. Required, because a rail nobody can observe
+   * cannot be explained, and one with no producer would have nothing to name here.
+   */
+  inspect: string;
+  /** Follow-up values the wizard collects when the operator accepts. Presentation only. */
+  asks?: string[];
+  /** A stated recommendation, where there is one worth stating. */
+  recommend?: "on" | "off";
+};
+
+export type CapabilityCatalog = {
+  catalogVersion: number;
+  capabilities: CatalogCapability[];
+};
+
+export type RuntimeSeen = {
+  catalogVersion: number;
+  updatedAt?: string;
+};
+
+export const ENABLE_HINT =
+  'Enable: ask the agent "setup harness" (harness-init skill) or edit .tlc/harness/config.json';

package/src/core/comment-policy/comment-policy.service.ts

@@ -0,0 +1,307 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { AddedLine } from "../../platform/git.ts";
+import { listAddedLines } from "../../platform/git.ts";
+import type { CommentMode } from "../policy/policy.types.ts";
+import type { CommentFinding } from "./comment-policy.types.ts";
+import { firstLeak, leakReason } from "./comment-resolvability.ts";
+import { syntaxFor } from "./comment-syntax.store.ts";
+import type { CommentSyntax } from "./comment-syntax.types.ts";
+
+/**
+ * hazard: this was three hand-written regexes and a ten-extension list. `#` starts a comment in shell and Python
+ * but not in TypeScript, where it starts a private field — and markdown inside a template literal made
+ * `## Heading` read as seven added comments. Both cases are now decided by the catalog, which says which
+ * delimiters a given extension actually has, and a Python docstring is covered because the catalog carries it
+ * ([/decisions/ad-058.md](/decisions/ad-058.md)).
+ *
+ * invariant: a file the catalog does not know produces no findings and is counted as unknown. Guessing a
+ * delimiter for an unrecognised language is how `#` came to mean "comment" in TypeScript.
+ */
+export function matchesSyntax(text: string, syntax: CommentSyntax): boolean {
+  const trimmed = text.trimStart();
+  if (trimmed === "") {
+    return false;
+  }
+  if (syntax.line.some((prefix) => prefix !== "" && trimmed.startsWith(prefix))) {
+    return true;
+  }
+  for (const [open, close] of syntax.block) {
+    if (trimmed.startsWith(open)) {
+      return true;
+    }
+    // hazard: a lone closer ends a block and is not itself a comment line, so counting it would extend every
+    // block by one. A symmetric fence — a Python docstring — is exempt, because its closer is also its opener.
+    if (open !== close && trimmed.startsWith(close)) {
+      return false;
+    }
+  }
+  // hazard: `*` continues a C-family block and `**` is markdown bold. The regex this replaced spelled that
+  // `\*(?![*/])`, and dropping the guard made `**Provider:** \`x\`` in a template literal read as narration —
+  // caught by the test written for that exact regression.
+  return syntax.middle.some((middle) => trimmed.startsWith(middle) && !trimmed.startsWith(middle + middle));
+}
+
+const TOOL_DIRECTIVE =
+  /^\s*(?:\/\/|\/\*|\*|#)\s*(?:biome-ignore|eslint|@ts-|prettier-ignore|noqa|type:|shellcheck|!)/;
+const DECLARED_REASON = /^\s*(?:\/\/|\/\*|\*|#)\s*(?:why|hazard|invariant):\s*\S/i;
+const CLOSER_OR_CONTINUATION = /^\s*(?:\*\/|\*|\/\/)/;
+
+export const COMMENT_MARKERS = ["why:", "hazard:", "invariant:"] as const;
+
+/**
+ * why: `file` decides everything now, so an empty one resolves to no syntax rather than to a permissive union of
+ * every delimiter the harness has heard of. The facade keeps this signature; the scanner always has a real path.
+ */
+export function isCommentLine(text: string, file = ""): boolean {
+  const syntax = file === "" ? null : syntaxFor(file);
+  if (syntax === null) {
+    return false;
+  }
+  return matchesSyntax(text, syntax) && !TOOL_DIRECTIVE.test(text);
+}
+
+export function declaresReason(text: string): boolean {
+  return DECLARED_REASON.test(text);
+}
+
+const DECLARATION =
+  /^\s*(?:(?:export|declare|public|private|protected|readonly|static|async|abstract)\s+)*(?:class|function|const|let|var|type|interface|enum|namespace)\s+([A-Za-z_$][\w$]*)|^\s*(?:readonly\s+)?([A-Za-z_$][\w$]*)\??\s*[:(<]/;
+
+// invariant: attachment is decided by position, the same way every JSDoc tool decides it. A `/** */`
+// floating inside a function body documents nothing, so it is judged as an inline comment instead.
+export function attachedIdentifier(codeLine: string | undefined): string | null {
+  const match = codeLine === undefined ? null : DECLARATION.exec(codeLine);
+  return match ? (match[1] ?? match[2] ?? null) : null;
+}
+
+const STOPWORDS = new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "get",
+  "gets",
+  "has",
+  "in",
+  "into",
+  "is",
+  "it",
+  "its",
+  "of",
+  "on",
+  "or",
+  "return",
+  "returns",
+  "set",
+  "sets",
+  "that",
+  "the",
+  "then",
+  "this",
+  "to",
+  "true",
+  "when",
+  "which",
+  "with",
+]);
+
+function words(text: string): string[] {
+  return text
+    .replace(/[_-]+/g, " ")
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter((word) => word.length > 1);
+}
+
+export const MIN_INFORMATIVE_WORDS = 3;
+
+// invariant: a doc comment addresses the caller, so the question is whether it carries information the
+// identifier does not. Exempting the form outright would make `/** */` an escape hatch.
+export function isInformativeDoc(commentText: string, identifier: string): boolean {
+  const named = new Set(words(identifier));
+  const remaining = words(commentText.replace(/^[\s/*]+|[\s*/]+$/g, "")).filter(
+    (word) => !named.has(word) && !STOPWORDS.has(word),
+  );
+  return new Set(remaining).size >= MIN_INFORMATIVE_WORDS;
+}
+
+// invariant: a marker sits on the first line of a comment, so continuation lines are part of the same
+// block and are not judged on their own.
+export function groupCommentBlocks(added: AddedLine[]): AddedLine[][] {
+  const blocks: AddedLine[][] = [];
+  let block: AddedLine[] = [];
+
+  for (const line of added) {
+    if (!isCommentLine(line.text, line.file)) {
+      block = [];
+      continue;
+    }
+    const previous = block.at(-1);
+    if (previous && previous.file === line.file && previous.line === line.line - 1) {
+      block.push(line);
+      continue;
+    }
+    block = [line];
+    blocks.push(block);
+  }
+
+  return blocks;
+}
+
+// hazard: judging by the head alone lets one marker cover any length of text below it.
+export const MAX_DECLARED_LINES = 4;
+
+export type NextCodeLine = (file: string, line: number) => string | undefined;
+
+type Verdict = { violates: boolean; reason: string };
+
+// hazard: `*/` is not a comment line, so a block ends one line before its closer. The lookup skips the
+// closer and any continuation line to reach the declaration, here rather than in each resolver.
+function declarationAfter(file: string, tailLine: number, nextCodeLine: NextCodeLine): string | undefined {
+  for (let line = tailLine + 1; line <= tailLine + 4; line += 1) {
+    const text = nextCodeLine(file, line);
+    if (text === undefined) {
+      continue;
+    }
+    if (text.trim() === "" || CLOSER_OR_CONTINUATION.test(text)) {
+      continue;
+    }
+    return text;
+  }
+  return undefined;
+}
+
+function judge(block: AddedLine[], mode: CommentMode, nextCodeLine?: NextCodeLine): Verdict {
+  const head = block[0] as AddedLine;
+  const tail = block.at(-1) as AddedLine;
+
+  if (head.text.trimStart().startsWith("/**") && nextCodeLine) {
+    const identifier = attachedIdentifier(declarationAfter(head.file, tail.line, nextCodeLine));
+    if (identifier !== null) {
+      const body = block.map((line) => line.text).join(" ");
+      if (mode === "strict") {
+        return { violates: true, reason: "comment added this turn" };
+      }
+      if (!isInformativeDoc(body, identifier)) {
+        return { violates: true, reason: `doc comment only restates ${identifier}` };
+      }
+      // why: a doc comment is prose a reader meets first, so it is the surface where a dead citation costs most.
+      const docLeak = mode === "resolvable" ? firstLeak(body) : null;
+      return docLeak === null
+        ? { violates: false, reason: "" }
+        : { violates: true, reason: leakReason(docLeak) };
+    }
+  }
+
+  if (mode === "strict") {
+    return { violates: true, reason: "comment added this turn" };
+  }
+  if (!declaresReason(head.text)) {
+    return { violates: true, reason: "undeclared comment added this turn" };
+  }
+  if (block.length > MAX_DECLARED_LINES) {
+    return { violates: true, reason: `declared comment runs past ${MAX_DECLARED_LINES} lines` };
+  }
+  // invariant: resolvability is asked last, and only of a comment that already earned its place. A comment with
+  // no declared reason is refused for that, and adding a second refusal to the same block would report one
+  // problem as two ([/decisions/ad-070.md](/decisions/ad-070.md)).
+  if (mode === "resolvable") {
+    const leak = firstLeak(block.map((line) => line.text).join(" "));
+    if (leak !== null) {
+      return { violates: true, reason: leakReason(leak) };
+    }
+  }
+  return { violates: false, reason: "" };
+}
+
+export function findAddedComments(
+  added: AddedLine[],
+  mode: CommentMode = "declared",
+  nextCodeLine?: NextCodeLine,
+): CommentFinding[] {
+  const findings: CommentFinding[] = [];
+  for (const block of groupCommentBlocks(added)) {
+    if (block[0] === undefined) {
+      continue;
+    }
+    const verdict = judge(block, mode, nextCodeLine);
+    if (verdict.violates) {
+      const head = block[0];
+      findings.push({
+        file: head.file,
+        line: head.line,
+        reason: verdict.reason,
+        text: head.text.trim().slice(0, 120),
+      });
+    }
+  }
+  return findings;
+}
+
+// hazard: documenting an existing export touches only the comment, so the declaration it attaches to is
+// absent from the diff and has to be read from disk.
+function diskLineReader(projectDir: string): NextCodeLine {
+  const cache = new Map<string, string[]>();
+  return (file, line) => {
+    let lines = cache.get(file);
+    if (lines === undefined) {
+      try {
+        lines = readFileSync(join(projectDir, file), "utf8").split("\n");
+      } catch {
+        lines = [];
+      }
+      cache.set(file, lines);
+    }
+    return lines[line - 1];
+  };
+}
+
+export async function scanAddedComments(
+  projectDir: string,
+  relativePaths: string[],
+  mode: CommentMode = "declared",
+  base = "HEAD",
+): Promise<CommentFinding[]> {
+  const added = await listAddedLines(projectDir, relativePaths, base);
+  return findAddedComments(added, mode, diskLineReader(projectDir));
+}
+
+export function commentViolationMessage(hits: CommentFinding[], mode: CommentMode = "declared"): string {
+  const need =
+    mode === "resolvable"
+      ? [
+          // why: the fix for an unresolvable comment is not deletion. The passage usually carries a true fact
+          // wrapped in the session's vantage — restating it at HEAD keeps the fact and drops the transcript.
+          "NEED: restate each line below so a reader at HEAD can check it without the transcript of",
+          "this session — state the present behaviour, or state the counterfactual (`without X, Y`).",
+          "Delete it when nothing survives that restatement.",
+        ]
+      : mode === "strict"
+        ? [
+            "NEED: delete every line below. This project does not accept agent-added comments.",
+            "If one is genuinely warranted, say so in your reply and let the operator write it.",
+          ]
+        : [
+            `NEED: delete each line below, or restate it as ${COMMENT_MARKERS.join(" / ")} when it`,
+            "records a non-obvious why, a hazard, or an external constraint. Narrating what the code",
+            "does is not a reason.",
+          ];
+  return [
+    `BLOCKED: this turn added ${hits.length} comment(s).`,
+    "TRIED: compared the lines this turn added against the commit it started from; pre-existing",
+    "comments are never counted.",
+    "Each entry is one comment, reported at its first line.",
+    ...need,
+    "Tool directives (biome-ignore, @ts-, noqa, shellcheck, shebang) are exempt.",
+    "",
+    ...hits.slice(0, 20).map((h) => `${h.file}:${h.line}  ${h.text}`),
+  ].join("\n");
+}

package/src/core/comment-policy/comment-policy.types.ts

@@ -0,0 +1,6 @@
+export type CommentFinding = {
+  file: string;
+  line: number;
+  reason: string;
+  text: string;
+};

package/src/core/comment-policy/comment-resolvability.ts

@@ -0,0 +1,134 @@
+/**
+ * A comment is resolvable when a reader at HEAD — with no transcript of the session that wrote it, no pull
+ * request thread and no draft — can resolve every reference in it and check every claim.
+ *
+ * why: the existing modes ask whether a comment *declares* a reason. They cannot ask whether the reason means
+ * anything to somebody who was not there, and that is the comment a model actually writes: it narrates the
+ * change it just made, cites a numbered item only the session could see, or argues with a reviewer who has since
+ * left. Each one reads as a reason and resolves to nothing
+ * ([/decisions/ad-070.md](/decisions/ad-070.md)).
+ *
+ * invariant: prose, never syntax. Nothing here parses a language, so a new language costs nothing and the rule
+ * behaves identically in Go, Python and TypeScript — the constraint that produced the syntax catalog
+ * ([/decisions/ad-058.md](/decisions/ad-058.md)).
+ */
+export type LeakKind =
+  | "change-narration"
+  | "dead-citation"
+  | "review-vantage"
+  | "reviewer-addressed"
+  | "flow-narration";
+
+export type LeakRule = {
+  kind: LeakKind;
+  pattern: RegExp;
+  /** What the reader at HEAD cannot do, phrased so the fix is obvious from the message. */
+  says: string;
+};
+
+/**
+ * hazard: precision over recall, deliberately. A rail that flags a good comment teaches the operator to switch it
+ * off, and the next real finding goes with it ([/decisions/ad-034.md](/decisions/ad-034.md)). Every pattern here
+ * is one that cannot be true of a comment describing present behaviour: a past-tense claim about the code is
+ * never a statement about what it does now, and a parenthesised decision number never resolves from the
+ * repository.
+ */
+export const LEAK_RULES: readonly LeakRule[] = [
+  /**
+   * hazard: `no longer` was here and was dropped on the evidence. Every occurrence in this repository described
+   * *runtime* state — a lock owner that no longer exists, a lesson ref that no longer resolves, a path a future
+   * refactor would leave behind — and not one described the repository's own history. A phrase that is four
+   * times wrong and zero times right is a phrase that trains the operator to switch the rail off.
+   */
+  {
+    kind: "change-narration",
+    pattern: /\b(?:used to|previously)\b/i,
+    says: "narrates the change instead of the state",
+  },
+  {
+    kind: "change-narration",
+    pattern: /\bthis (?:was|used to)\b/i,
+    says: "narrates the change instead of the state",
+  },
+  {
+    kind: "change-narration",
+    pattern: /\bthe old (?:code|version|implementation|approach|way|behaviou?r)\b/i,
+    says: "refers to code that is no longer here",
+  },
+  {
+    kind: "change-narration",
+    pattern: /\bbefore (?:this|the) (?:change|commit|fix|patch|refactor)\b/i,
+    says: "refers to a state the repository no longer holds",
+  },
+  {
+    kind: "dead-citation",
+    pattern: /\((?:decision|item|step|phase|task|audit|option)\s*#?\d+\)/i,
+    says: "cites something only the authoring session could see",
+  },
+  {
+    kind: "dead-citation",
+    pattern: /§\s*\d/,
+    says: "cites a section of a document that is not in the repository",
+  },
+  {
+    kind: "dead-citation",
+    pattern: /\bas (?:decided|agreed|discussed|mentioned|described) (?:above|earlier|previously|before)\b/i,
+    says: "points at a conversation the reader cannot see",
+  },
+  {
+    kind: "dead-citation",
+    pattern: /\b(?:per|from|in) the plan\b|\bthe plan above\b/i,
+    says: "points at a plan that is not in the repository",
+  },
+  {
+    kind: "review-vantage",
+    pattern: /\bthis (?:PR|MR|commit|patch|diff|changeset)\b/i,
+    says: "speaks from the change rather than from the repository",
+  },
+  {
+    kind: "review-vantage",
+    pattern: /\ba (?:later|follow-?up|subsequent) (?:PR|MR|commit)\b/i,
+    says: "speaks from the change rather than from the repository",
+  },
+  {
+    kind: "reviewer-addressed",
+    pattern: /\bthis is (?:safe|correct|fine|ok|okay)\b/i,
+    says: "argues its own correctness to a reviewer instead of stating the invariant",
+  },
+  {
+    kind: "reviewer-addressed",
+    pattern: /\brejected in review\b|\bthe reviewer\b/i,
+    says: "records who said what, which the repository cannot confirm",
+  },
+  {
+    kind: "flow-narration",
+    pattern: /\bfirst (?:we|it|this)\b[\s\S]{0,80}\bthen (?:we|it|this)\b/i,
+    says: "restates the control flow the code already shows",
+  },
+];
+
+export type Leak = { kind: LeakKind; says: string; match: string };
+
+/**
+ * why: the whole block is judged as one string. A sentence split across two comment lines is still one sentence,
+ * and a pattern spanning a clause only matches once the lines are joined.
+ */
+export function findLeaks(blockText: string): Leak[] {
+  const leaks: Leak[] = [];
+  for (const rule of LEAK_RULES) {
+    const found = rule.pattern.exec(blockText);
+    if (found !== null) {
+      leaks.push({ kind: rule.kind, says: rule.says, match: found[0] });
+    }
+  }
+  return leaks;
+}
+
+/** why: one comment yields one finding, so a block matching three rules does not read as three problems. */
+export function firstLeak(blockText: string): Leak | null {
+  return findLeaks(blockText)[0] ?? null;
+}
+
+export function leakReason(leak: Leak): string {
+  return `unresolvable comment — ${leak.says} (\`${leak.match}\`)`;
+}