@rmrdeveloper/sideroom-pi 8.11.0 → 8.13.0

package/extensions/explain/model.ts

@@ -13,7 +13,6 @@ export const EXPLAIN_OFFER =
 
 export const EXPLAIN_DECISION = {
   send: 'send',
-  defer: 'defer',
   none: 'none',
 } as const;
 
@@ -22,24 +21,18 @@ export type ExplainDecision =
 
 export interface ExplainState {
   mutatedFilesThisTurn: Set<string>;
-  mutatedSinceSettle: boolean;
-  pendingOffer: boolean;
   offeredThisTurn: boolean;
 }
 
 export function createExplainState(): ExplainState {
   return {
     mutatedFilesThisTurn: new Set(),
-    mutatedSinceSettle: false,
-    pendingOffer: false,
     offeredThisTurn: false,
   };
 }
 
 export function resetExplainTurn(state: ExplainState): void {
   state.mutatedFilesThisTurn.clear();
-  state.mutatedSinceSettle = false;
-  state.pendingOffer = false;
   state.offeredThisTurn = false;
 }
 
@@ -51,13 +44,9 @@ export function mutationPathKey(cwd: string, path: string): string | undefined {
 
 export function recordMutation(state: ExplainState, pathKey: string): void {
   state.mutatedFilesThisTurn.add(pathKey);
-  state.mutatedSinceSettle = true;
 }
 
-// The guidelines review steers at the first settle boundary after a mutation,
-// and both handlers run in an extension load order Sideroom does not control.
-// Explain holds its steer back one boundary so the review always runs first;
-// the review's continuation is what brings the next boundary.
+// The shared settle guard gives review and checks priority over the offer.
 export function decideOffer(
   state: ExplainState,
   mode: string,
@@ -66,15 +55,9 @@ export function decideOffer(
     mode === TUI_MODE &&
     !state.offeredThisTurn &&
     state.mutatedFilesThisTurn.size >= EXPLAIN_FILE_THRESHOLD;
-  if (state.pendingOffer && thresholdReached) {
+  if (thresholdReached) {
     return EXPLAIN_DECISION.send;
   }
-  if (
-    thresholdReached ||
-    (mode === TUI_MODE && state.mutatedSinceSettle && !state.offeredThisTurn)
-  ) {
-    return EXPLAIN_DECISION.defer;
-  }
   return EXPLAIN_DECISION.none;
 }
 
@@ -84,11 +67,5 @@ export function applyOfferDecision(
 ): void {
   if (decision === EXPLAIN_DECISION.send) {
     state.offeredThisTurn = true;
-    state.pendingOffer = false;
-  } else if (decision === EXPLAIN_DECISION.defer) {
-    state.pendingOffer = true;
-  } else {
-    state.pendingOffer = false;
   }
-  state.mutatedSinceSettle = false;
 }

package/extensions/guidelines/review.ts

@@ -5,7 +5,8 @@ import {
 } from '@earendil-works/pi-coding-agent';
 import { isReviewNote, REVIEW_NOTE_EVENT } from '../shared/review-note.ts';
 import {
-  acceptsSettleSteer,
+  registerSettleGuard,
+  SETTLE_PRIORITY,
   startsUserTurn,
   withHiddenSteer,
 } from '../shared/settle.ts';
@@ -13,10 +14,13 @@ import {
 export const REVIEW_STEER_TYPE = 'sideroom-guidelines-review';
 
 export const REVIEW_STEER =
-  'Review every file this run changed against the loaded Sideroom language guide: fix any mechanical, structural, or architectural rule violations in those files, then run the relevant formatter, linter, type checks, and tests. If the guide is no longer in context, re-read it in full first.';
+  'Finish any remaining requested implementation before reviewing. Review the changes this run introduced against the loaded Sideroom language guide: fix only demonstrated violations caused by those changes, preserving all requested requirements and existing behavior. KISS and YAGNI do not justify removing required error handling, compatibility, or tests. Do not refactor unrelated code. Then run the relevant formatter, linter, type checks, and tests. If the guide is no longer in context, re-read it in full first.';
+
+export const WORKFLOW_REVIEW_STEER =
+  'Verify the semantic notes below against the visible evidence and the questionnaire or task contract. Correct only demonstrated ambiguity or contradictions; respect user answers and ask again only when clarification is necessary. Missing evidence is not proof of unfinished work. Do not create unrelated implementation work. Run project checks only if code changes.';
 
 export const REVIEW_NOTES_STEER =
-  'Files changed during the review drew the semantic notes below. Verify each against the loaded Sideroom language guide, fix only real violations, then rerun the relevant checks.';
+  'Additional semantic notes arrived after the review. Verify each against the loaded Sideroom language guide, fix only demonstrated violations introduced by this run without removing required behavior or refactoring unrelated code, then rerun the relevant checks.';
 
 export interface ReviewState {
   mutated: boolean;
@@ -42,21 +46,27 @@ export function resetReviewTurn(state: ReviewState): void {
 }
 
 export function shouldReview(state: ReviewState): boolean {
-  return state.mutated && !state.steeredThisTurn;
+  return (state.mutated || state.notes.length > 0) && !state.steeredThisTurn;
 }
 
 // Notes that arrive after the review fired get one follow-up per turn, so a
 // fix that draws new notes cannot keep the run going.
 export function pendingReviewSteer(state: ReviewState): string | undefined {
   if (shouldReview(state)) {
-    return withNotes(REVIEW_STEER, state.notes);
+    return withNotes(
+      state.mutated ? REVIEW_STEER : WORKFLOW_REVIEW_STEER,
+      state.notes,
+    );
   }
   if (
     state.steeredThisTurn &&
     !state.notesSteeredThisTurn &&
     state.notes.length > 0
   ) {
-    return withNotes(REVIEW_NOTES_STEER, state.notes);
+    return withNotes(
+      state.mutated ? REVIEW_NOTES_STEER : WORKFLOW_REVIEW_STEER,
+      state.notes,
+    );
   }
   return undefined;
 }
@@ -104,12 +114,20 @@ export function registerReviewGuard(
   // continuation stays inside the same run. agent_settled is notification-only:
   // a steer sent there starts a second run after the user already saw the
   // agent stop, and it fires even when the user pressed Escape.
-  pi.on('agent_before_settle', (event) => {
-    const steer = pendingReviewSteer(state);
-    if (steer === undefined || !acceptsSettleSteer(event)) {
-      return;
-    }
-    markReviewSteered(state);
-    return withHiddenSteer(event, REVIEW_STEER_TYPE, steer);
+  registerSettleGuard(pi, {
+    priority: SETTLE_PRIORITY.review,
+    pending: () => pendingReviewSteer(state) !== undefined,
+    handle: (event) => {
+      const steer = pendingReviewSteer(state);
+      if (steer === undefined) {
+        return;
+      }
+      markReviewSteered(state);
+      return withHiddenSteer({
+        event,
+        customType: REVIEW_STEER_TYPE,
+        content: steer,
+      });
+    },
   });
 }

package/extensions/jev/client.ts

@@ -3,6 +3,7 @@ import {
   JEV_ENDPOINT,
   type JevFileState,
   type JevFinding,
+  type JevRequestBody,
   parseEnvelope,
   readFindings,
 } from './model.ts';
@@ -105,7 +106,27 @@ export async function askJev(
   file: JevFileState,
   signal: AbortSignal | undefined,
 ): Promise<JevAttempt> {
-  const requestBody = buildRequestBody(file);
+  return askJevRequest({
+    transport,
+    apiKey,
+    requestBody: buildRequestBody(file),
+    signal,
+  });
+}
+
+interface JevRequestInput {
+  readonly transport: JevTransport;
+  readonly apiKey: string;
+  readonly requestBody: JevRequestBody;
+  readonly signal: AbortSignal | undefined;
+}
+
+export async function askJevRequest({
+  transport,
+  apiKey,
+  requestBody,
+  signal,
+}: JevRequestInput): Promise<JevAttempt> {
   const body = JSON.stringify(requestBody);
   let response: JevHttpResponse;
   try {

package/extensions/jev/context.ts

@@ -4,6 +4,7 @@ import ignore from 'ignore';
 import { LANGUAGE, languageForPath } from '../rules/catalog.ts';
 import {
   buildFileState,
+  isTestPath,
   type JevFileState,
   type JevRelatedFile,
   stateFitsBudget,
@@ -52,19 +53,31 @@ export function buildContextualState(
         references(candidate.path, candidate.body),
         path,
       );
-      if (!importedByTarget && !consumesTarget) {
+      const companionTest = isCompanionTest(path, candidate.path);
+      const testedSource = isCompanionTest(candidate.path, path);
+      if (
+        !importedByTarget &&
+        !consumesTarget &&
+        !companionTest &&
+        !testedSource
+      ) {
         return [];
       }
       return [
         {
           ...candidate,
-          relation: importedByTarget ? 'imported' : 'consumer',
+          relation: isTestPath(candidate.path)
+            ? 'test'
+            : importedByTarget || testedSource
+              ? 'imported'
+              : 'consumer',
         } as const,
       ];
     })
     .sort((left, right) => {
       if (left.relation !== right.relation) {
-        return left.relation === 'imported' ? -1 : 1;
+        const priority = { test: 0, consumer: 1, imported: 2 };
+        return priority[left.relation] - priority[right.relation];
       }
       return compareText(left.path, right.path);
     });
@@ -325,3 +338,23 @@ function matchesReference(names: ReadonlySet<string>, path: string): boolean {
   }
   return false;
 }
+
+// Naming is evidence only for a sibling test, never for a repository-wide basename match.
+function isCompanionTest(source: string, candidate: string): boolean {
+  if (
+    isTestPath(source) ||
+    !isTestPath(candidate) ||
+    posix.dirname(source) !== posix.dirname(candidate)
+  ) {
+    return false;
+  }
+  const stem = posix.basename(source, extname(source));
+  const testStem = posix.basename(candidate, extname(candidate));
+  return (
+    testStem === `${stem}.test` ||
+    testStem === `${stem}.spec` ||
+    testStem === `${stem}_test` ||
+    testStem === `test_${stem}` ||
+    testStem === `${stem}Test`
+  );
+}

package/extensions/jev/guard.ts

@@ -6,6 +6,7 @@ import {
   isWriteToolResult,
   type ToolCallEvent,
 } from '@earendil-works/pi-coding-agent';
+import { commandMatches, detectCheckCommand } from '../done/detect.ts';
 import {
   projectRelativePath,
   resolveFileToolPath,
@@ -14,7 +15,7 @@ import { readFileIfExists } from '../shared/read-file.ts';
 import { REVIEW_NOTE_EVENT, type ReviewNote } from '../shared/review-note.ts';
 import { startsUserTurn } from '../shared/settle.ts';
 import {
-  askJev,
+  askJevRequest,
   JEV_FAILURE,
   type JevFailure,
   type JevTransport,
@@ -24,12 +25,25 @@ import {
   type AddedLine,
   addedLinesForEdit,
   addedLinesForWrite,
+  buildRequestBody,
   findingKey,
   formatFindings,
   isReviewablePath,
   type JevFinding,
+  type JevRequestBody,
 } from './model.ts';
 
+import {
+  buildAskReview,
+  buildBoardReview,
+  completedItems,
+  completionIds,
+  createWorkflowEvidence,
+  recordFileEvidence,
+  resetWorkflowEvidence,
+  type WorkflowEvidence,
+} from './workflow.ts';
+
 export const JEV_TRANSIENT_FAILURE_LIMIT = 3;
 
 const MUTATION_KIND = {
@@ -64,6 +78,7 @@ export interface JevGuardState {
   rateLimitedThisTurn: boolean;
   lastModel: string | undefined;
   calls: number;
+  readonly evidence: WorkflowEvidence;
   readonly pending: Map<string, PendingMutation>;
   readonly notedThisTurn: Set<string>;
 }
@@ -81,6 +96,7 @@ export function createJevGuardState(): JevGuardState {
     rateLimitedThisTurn: false,
     lastModel: undefined,
     calls: 0,
+    evidence: createWorkflowEvidence(),
     pending: new Map(),
     notedThisTurn: new Set(),
   };
@@ -88,6 +104,7 @@ export function createJevGuardState(): JevGuardState {
 
 // The F10 screen calls this after the user stores a key or asks to retry.
 export function resetJevGuard(state: JevGuardState): void {
+  resetWorkflowEvidence(state.evidence);
   state.halted = undefined;
   state.transientFailures = 0;
   state.rateLimitedThisTurn = false;
@@ -96,6 +113,7 @@ export function resetJevGuard(state: JevGuardState): void {
 // Usage and per-turn memory belong to the active session: a new session starts
 // counting from zero. The breaker stays, because it tracks the key.
 export function resetJevSession(state: JevGuardState): void {
+  resetWorkflowEvidence(state.evidence);
   state.calls = 0;
   state.rateLimitedThisTurn = false;
   state.pending.clear();
@@ -131,6 +149,7 @@ export function registerJevGuard(
     if (!startsUserTurn(event)) {
       return;
     }
+    resetWorkflowEvidence(state.evidence);
     state.notedThisTurn.clear();
     state.rateLimitedThisTurn = false;
   });
@@ -145,7 +164,7 @@ export function registerJevGuard(
   // the previous content is gone. The body is read after, from disk.
   pi.on('tool_call', (event, ctx) => {
     const mutation = extractMutation(event, ctx.cwd);
-    if (mutation === undefined || !isWorthAsking(mutation)) {
+    if (mutation === undefined || !isReviewablePath(mutation.relativePath)) {
       return undefined;
     }
     state.pending.set(event.toolCallId, mutation);
@@ -155,48 +174,108 @@ export function registerJevGuard(
   pi.on('tool_result', async (event, ctx) => {
     const pending = state.pending.get(event.toolCallId);
     state.pending.delete(event.toolCallId);
-    if (pending === undefined || event.isError) {
-      return undefined;
-    }
-    if (!isWriteToolResult(event) && !isEditToolResult(event)) {
-      return undefined;
-    }
-
     const apiKey = dependencies.apiKey();
-    if (apiKey === undefined) {
-      dependencies.report(JEV_STATUS.noKey, ctx);
+    if (
+      apiKey === undefined ||
+      !shouldCallJev(state) ||
+      ctx.signal?.aborted === true
+    ) {
+      if (!event.isError && pending !== undefined && isWorthAsking(pending)) {
+        dependencies.report(
+          apiKey === undefined ? JEV_STATUS.noKey : guardStatus(state),
+          ctx,
+        );
+      }
       return undefined;
     }
-    if (!shouldCallJev(state)) {
-      dependencies.report(guardStatus(state), ctx);
+    if (event.isError) {
+      if (
+        event.toolName === 'bash' &&
+        typeof event.input.command === 'string'
+      ) {
+        const check = detectCheckCommand(ctx.cwd);
+        if (check !== undefined && commandMatches(event.input.command, check)) {
+          state.evidence.checks = 'failed';
+        }
+      }
       return undefined;
     }
-
-    const body = readFileIfExists(pending.absolutePath);
-    if (body === undefined) {
+    if (event.toolName === 'bash' && typeof event.input.command === 'string') {
+      const check = detectCheckCommand(ctx.cwd);
+      if (check !== undefined && commandMatches(event.input.command, check)) {
+        state.evidence.checks = 'passed';
+      }
       return undefined;
     }
-    if (ctx.signal?.aborted === true) {
-      return undefined;
+    let requestBody: JevRequestBody | undefined;
+    let subject: string;
+    if (event.toolName === 'sideroom_ask') {
+      if (
+        typeof event.details !== 'object' ||
+        event.details === null ||
+        !('cancelled' in event.details) ||
+        event.details.cancelled !== false
+      ) {
+        return undefined;
+      }
+      requestBody = buildAskReview(event.input);
+      subject = 'sideroom_ask';
+    } else if (event.toolName === 'sideroom_todo') {
+      const items = completedItems(event.details);
+      if (items === undefined) {
+        return undefined;
+      }
+      requestBody = buildBoardReview({
+        items,
+        evidence: state.evidence,
+        changedIds: completionIds(event.input),
+      });
+      subject = 'sideroom_todo';
+    } else {
+      if (
+        pending === undefined ||
+        (!isWriteToolResult(event) && !isEditToolResult(event))
+      ) {
+        return undefined;
+      }
+      subject = pending.relativePath;
+      state.evidence.checks = 'stale';
+      // Replace cached evidence even when this version no longer fits the budget.
+      state.evidence.files.delete(subject);
+      if (!isWorthAsking(pending)) {
+        state.evidence.partial = true;
+        return undefined;
+      }
+      const body = readFileIfExists(pending.absolutePath);
+      if (body === undefined) {
+        state.evidence.partial = true;
+        return undefined;
+      }
+      const fileState = buildContextualState(
+        ctx.cwd,
+        subject,
+        body,
+        pending.kind,
+        pending.lines,
+      );
+      if (fileState === undefined) {
+        state.evidence.partial = true;
+        return undefined;
+      }
+      recordFileEvidence(state.evidence, fileState);
+      requestBody = buildRequestBody(fileState);
     }
-    const fileState = buildContextualState(
-      ctx.cwd,
-      pending.relativePath,
-      body,
-      pending.kind,
-      pending.lines,
-    );
-    if (fileState === undefined) {
+    if (requestBody === undefined) {
       return undefined;
     }
 
     state.calls += 1;
-    const attempt = await askJev(
-      dependencies.transport,
+    const attempt = await askJevRequest({
+      transport: dependencies.transport,
       apiKey,
-      fileState,
-      ctx.signal,
-    );
+      requestBody,
+      signal: ctx.signal,
+    });
     if (attempt.failure !== undefined) {
       registerFailure(state, attempt.failure);
       dependencies.report(guardStatus(state), ctx);
@@ -211,14 +290,14 @@ export function registerJevGuard(
 
     const findings = attempt.findings ?? [];
     const fresh = findings.filter((finding) =>
-      isUnnoted(state, pending.relativePath, finding),
+      isUnnoted(state, subject, finding),
     );
     if (fresh.length === 0) {
       return undefined;
     }
-    markNoted(state, pending.relativePath, fresh);
+    markNoted(state, subject, fresh);
     const note: ReviewNote = {
-      text: formatFindings(pending.relativePath, fresh),
+      text: formatFindings(subject, fresh),
     };
     pi.events.emit(REVIEW_NOTE_EVENT, note);
     return undefined;

package/extensions/jev/model.ts

@@ -147,12 +147,70 @@ export const JEV_RULES: readonly JevRule[] = [
       },
     },
   },
+  {
+    id: 'testability',
+    question: {
+      type: NOUL_TYPE,
+      instructions:
+        'Do the added lines hardcode clock, network or randomness inside business logic, making deterministic tests difficult? Do not flag infrastructure adapters or entry points merely for using their own APIs.',
+      criteria: {
+        true: 'Business behavior directly depends on an uncontrollable external dependency with no visible injection point',
+        false:
+          'Dependencies are supplied, or the code is the adapter/composition boundary itself',
+      },
+    },
+  },
+  {
+    id: 'contract-compatibility',
+    question: {
+      type: NOUL_TYPE,
+      instructions:
+        'Do added lines change a function signature, return shape or behavior in a way that demonstrably conflicts with a supplied non-test consumer? Require a concrete mismatch in visible code; do not speculate about unseen callers.',
+      criteria: {
+        true: 'A supplied consumer calls or interprets the changed contract incompatibly',
+        false:
+          'Visible consumers remain compatible, or there is insufficient evidence',
+      },
+    },
+  },
+  {
+    id: 'test-quality',
+    question: {
+      type: NOUL_TYPE,
+      instructions:
+        'For behavior touched by the added lines, do supplied related tests have a demonstrable blind spot: assertions that cannot detect that behavior failing, or an explicit changed error branch left untested? Use both production and test bodies. Never infer absent repository coverage from missing files or partial context. Do not request tests that mirror implementation or cover unrelated code.',
+      criteria: {
+        true: 'Visible relevant tests fail to assert the changed observable behavior or a visible changed error case, with concrete evidence',
+        false:
+          'Assertions cover the behavior, the change is low-impact, or evidence is incomplete',
+      },
+    },
+  },
+  {
+    id: 'unnecessary-abstraction',
+    question: {
+      type: NOUL_TYPE,
+      instructions:
+        'Do the added lines introduce a demonstrably redundant layer or combine visibly different domain concepts solely for similar syntax? Require evidence in supplied bodies. A single caller, delegation, injection, compatibility or a clear responsibility is not by itself a violation. Never infer requirements are absent or recommend removing required behavior.',
+      criteria: {
+        true: 'The added abstraction duplicates an existing role without adding a contract, responsibility or testability, or mixes visibly distinct concepts',
+        false:
+          'It serves a present responsibility or contract, or evidence is insufficient',
+      },
+    },
+  },
 ];
 
+export function isTestPath(path: string): boolean {
+  return /(?:^|\/)(?:__tests__|tests?|specs?)\/|(?:[._-](?:test|spec)|_test)\.[^/]+$|(?:^|\/)test_[^/]+$|Test\.java$/u.test(
+    path,
+  );
+}
+
 export interface JevRelatedFile {
   readonly path: string;
   readonly body: string;
-  readonly relation: 'imported' | 'consumer';
+  readonly relation: 'imported' | 'consumer' | 'test';
 }
 
 export interface JevFileState {
@@ -173,7 +231,7 @@ export interface JevFileState {
 
 export interface JevRequestBody {
   readonly model: string;
-  readonly state: JevFileState;
+  readonly state: unknown;
   readonly questions: Readonly<Record<string, JevNoulQuestion>>;
 }
 
@@ -225,14 +283,17 @@ export function isReviewablePath(path: string): boolean {
 }
 
 export function stateFitsBudget(state: JevFileState): boolean {
-  const request = buildRequestBody(state);
+  return requestFitsBudget(buildRequestBody(state));
+}
+
+export function requestFitsBudget(request: JevRequestBody): boolean {
   const longestQuestion = Object.values(request.questions).reduce(
     (longest, question) =>
       Math.max(longest, Buffer.byteLength(JSON.stringify(question))),
     0,
   );
   return (
-    Buffer.byteLength(JSON.stringify(state)) + longestQuestion <=
+    Buffer.byteLength(JSON.stringify(request.state)) + longestQuestion <=
       MAX_STATE_BYTES &&
     Buffer.byteLength(JSON.stringify(request)) <= MAX_REQUEST_BYTES
   );
@@ -243,6 +304,15 @@ export function buildRequestBody(file: JevFileState): JevRequestBody {
   const hasImportedFile = file.context.files.some(
     (related) => related.relation === 'imported',
   );
+  const hasConsumer = file.context.files.some(
+    (related) => related.relation === 'consumer' && !isTestPath(related.path),
+  );
+  const hasTest =
+    isTestPath(file.file.path) ||
+    file.context.files.some((related) => isTestPath(related.path));
+  const hasProduction =
+    !isTestPath(file.file.path) ||
+    file.context.files.some((related) => !isTestPath(related.path));
   const addedText = file.change.addedLines.join('\n');
   for (const rule of JEV_RULES) {
     if (rule.id === 'dependency-direction' && !hasImportedFile) {
@@ -251,6 +321,12 @@ export function buildRequestBody(file: JevFileState): JevRequestBody {
     if (rule.id === 'comments' && !/(?:\/\/|\/\*|#)/u.test(addedText)) {
       continue;
     }
+    if (rule.id === 'contract-compatibility' && !hasConsumer) {
+      continue;
+    }
+    if (rule.id === 'test-quality' && (!hasTest || !hasProduction)) {
+      continue;
+    }
     questions[rule.id] = rule.question;
   }
   return { model: JEV_MODEL, state: file, questions };
@@ -274,15 +350,17 @@ export function readFindings(
     return [];
   }
   const findings: JevFinding[] = [];
-  for (const rule of JEV_RULES) {
-    if (!askedRuleIds.has(rule.id)) {
-      continue;
-    }
-    const answer = answers[rule.id];
-    if (answer === undefined || answer.noul < VIOLATION_PROBABILITY) {
+  for (const ruleId of askedRuleIds) {
+    const answer = answers[ruleId];
+    if (
+      answer === undefined ||
+      !Number.isFinite(answer.noul) ||
+      answer.noul > 1 ||
+      answer.noul < VIOLATION_PROBABILITY
+    ) {
       continue;
     }
-    findings.push({ ruleId: rule.id, probability: answer.noul });
+    findings.push({ ruleId, probability: answer.noul });
   }
   return findings;
 }
@@ -299,7 +377,7 @@ export function formatFindings(
     `Sideroom Jev review flagged ${path}:`,
     ...findings.map(
       (finding) =>
-        `- [${finding.ruleId}] Jev scored ${finding.probability.toFixed(2)} probability that the added lines break this rule. Verify against the loaded guide before changing anything.`,
+        `- [${finding.ruleId}] Jev scored ${finding.probability.toFixed(2)} probability of a review concern. Verify the supplied evidence and applicable contract against the loaded guide before changing anything. Missing context is not proof of a violation.`,
     ),
   ].join('\n');
 }