@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/project-run/controls/validation.ts

@@ -1,14 +1,34 @@
-import { snapshotClosedArray } from "../../data-boundary/closed-values.ts";
+import { isOutputDirectory } from "../../project-definition/output-validation.ts";
 import { isNonArrayRecord, isUnknownArray } from "../../data-boundary/value-shapes.ts";
 import { parseOutputsOverride } from "./outputs-override-validation.ts";
+import { CHANGE_FLAG_PREFIX } from "../changes/git.ts";
 import type { RunControlDiagnostic, RunControlValidationResult } from "./validation-result.ts";
-import type { CheckAggregation, RunControls } from "./contract.ts";
+import type { CheckAggregation, DiagnosticLogFileNaming, RunControls } from "./contract.ts";
+
+const RUN_CONTROL_KEYS = [
+  "checkArtifactBaseDirectory",
+  "checkAggregation",
+  "diagnosticLogFileNaming",
+  "progressLogFile",
+  "outputs",
+  "flags",
+  "projectRoot",
+  "signal"
+] as const;
+
+interface ParsedInvocationOutputTargets {
+  readonly diagnosticLogFileNaming: DiagnosticLogFileNaming | undefined;
+  readonly checkArtifactBaseDirectory: string | undefined;
+  readonly progressLogFile: string | undefined;
+}
 
-const RUN_CONTROL_KEYS = ["checkAggregation", "outputs", "flags", "projectRoot", "signal"] as const;
-const CHECK_AGGREGATION_MODES = ["all", "any"] as const;
-const UNAVAILABLE_HANDLING = ["propagate", "fail", "exclude"] as const;
-const NOT_APPLICABLE_HANDLING = ["exclude", "pass", "fail"] as const;
-const EMPTY_AGGREGATION_RESULTS = ["passed", "failed", "not-applicable"] as const;
+interface ParsedRunControlFields extends ParsedInvocationOutputTargets {
+  readonly checkAggregation: CheckAggregation | undefined;
+  readonly flags: readonly string[];
+  readonly outputs: RunControls["outputs"] | undefined;
+  readonly projectRoot: string | undefined;
+  readonly signal: AbortSignal | undefined;
+}
 
 export function validateRunControls(value: unknown = {}): RunControlValidationResult<RunControls> {
   try {
@@ -21,28 +41,88 @@ export function validateRunControls(value: unknown = {}): RunControlValidationRe
 function validateRunControlsValue(value: unknown): RunControlValidationResult<RunControls> {
   const data = exactControlRecord(value);
   if (!data.ok) return data;
-  const flags = parseFlags(data.value.flags);
+  const fields = parseRunControlFields(data.value);
+  if (!fields.ok) return fields;
+  return Object.freeze({ ok: true, value: runControlsFromFields(fields.value) });
+}
+
+function parseRunControlFields(
+  data: Readonly<Record<string, unknown>>
+): RunControlValidationResult<ParsedRunControlFields> {
+  const outputTargets = parseInvocationOutputTargets(data);
+  if (!outputTargets.ok) return outputTargets;
+  const flags = parseFlags(data.flags);
   if (!flags.ok) return flags;
-  const checkAggregation = parseOptionalCheckAggregation(data.value.checkAggregation);
+  const checkAggregation = parseOptionalCheckAggregation(data.checkAggregation);
   if (!checkAggregation.ok) return checkAggregation;
-  const outputs = optionalControl(data.value.outputs, parseOutputsOverride, "controls.outputs");
+  const outputs = parseOutputsOverride(data.outputs);
   if (!outputs.ok) return outputs;
-  const projectRoot = optionalControl(data.value.projectRoot, parseString, "controls.projectRoot");
+  const projectRoot = optionalControl(data.projectRoot, parseString, "controls.projectRoot");
   if (!projectRoot.ok) return projectRoot;
-  const signal = optionalControl(data.value.signal, parseAbortSignal, "controls.signal");
+  const signal = optionalControl(data.signal, parseAbortSignal, "controls.signal");
   if (!signal.ok) return signal;
   return Object.freeze({
     ok: true,
     value: Object.freeze({
-      ...(checkAggregation.value === undefined ? {} : { checkAggregation: checkAggregation.value }),
-      ...(outputs.value === undefined ? {} : { outputs: outputs.value }),
+      ...outputTargets.value,
+      checkAggregation: checkAggregation.value,
       flags: flags.value,
-      ...(projectRoot.value === undefined ? {} : { projectRoot: projectRoot.value }),
-      ...(signal.value === undefined ? {} : { signal: signal.value })
+      outputs: outputs.value,
+      projectRoot: projectRoot.value,
+      signal: signal.value
+    })
+  });
+}
+
+/** Parse caller-owned invocation output targets separately from Run execution controls. */
+function parseInvocationOutputTargets(
+  data: Readonly<Record<string, unknown>>
+): RunControlValidationResult<ParsedInvocationOutputTargets> {
+  const diagnosticLogFileNaming = optionalControl(
+    data.diagnosticLogFileNaming,
+    parseDiagnosticLogFileNaming,
+    "controls.diagnosticLogFileNaming"
+  );
+  if (!diagnosticLogFileNaming.ok) return diagnosticLogFileNaming;
+  const checkArtifactBaseDirectory = optionalControl(
+    data.checkArtifactBaseDirectory,
+    parseOutputDirectory,
+    "controls.checkArtifactBaseDirectory"
+  );
+  if (!checkArtifactBaseDirectory.ok) return checkArtifactBaseDirectory;
+  const progressLogFile = optionalControl(
+    data.progressLogFile,
+    parseOutputDirectory,
+    "controls.progressLogFile"
+  );
+  if (!progressLogFile.ok) return progressLogFile;
+  return Object.freeze({
+    ok: true,
+    value: Object.freeze({
+      diagnosticLogFileNaming: diagnosticLogFileNaming.value,
+      checkArtifactBaseDirectory: checkArtifactBaseDirectory.value,
+      progressLogFile: progressLogFile.value
     })
   });
 }
 
+function runControlsFromFields(fields: ParsedRunControlFields): RunControls {
+  return Object.freeze({
+    ...(fields.diagnosticLogFileNaming === undefined
+      ? {}
+      : { diagnosticLogFileNaming: fields.diagnosticLogFileNaming }),
+    ...(fields.checkArtifactBaseDirectory === undefined
+      ? {}
+      : { checkArtifactBaseDirectory: fields.checkArtifactBaseDirectory }),
+    ...(fields.checkAggregation === undefined ? {} : { checkAggregation: fields.checkAggregation }),
+    ...(fields.outputs === undefined ? {} : { outputs: fields.outputs }),
+    ...(fields.progressLogFile === undefined ? {} : { progressLogFile: fields.progressLogFile }),
+    flags: fields.flags,
+    ...(fields.projectRoot === undefined ? {} : { projectRoot: fields.projectRoot }),
+    ...(fields.signal === undefined ? {} : { signal: fields.signal })
+  });
+}
+
 function exactControlRecord(
   value: unknown
 ): RunControlValidationResult<Readonly<Record<string, unknown>>> {
@@ -53,6 +133,10 @@ function exactControlRecord(
     : invalidRunControl(`controls.${unknownKey}`, "unknown-key");
 }
 
+function parseDiagnosticLogFileNaming(value: unknown): DiagnosticLogFileNaming | undefined {
+  return value === "unique" || value === "channel" ? value : undefined;
+}
+
 function optionalControl<T>(
   value: unknown,
   parse: (candidate: unknown) => T | undefined,
@@ -71,7 +155,7 @@ function parseFlags(value: unknown): RunControlValidationResult<readonly string[
   for (let index = 0; index < length; index += 1) {
     if (!Object.hasOwn(value, index)) return invalidControls("controls.flags");
     const flag = value[index];
-    if (typeof flag !== "string" || flag.length === 0) {
+    if (typeof flag !== "string" || flag.length === 0 || flag.startsWith(CHANGE_FLAG_PREFIX)) {
       return invalidControls("controls.flags");
     }
     flags.push(flag);
@@ -86,65 +170,19 @@ function parseOptionalCheckAggregation(
   value: unknown
 ): RunControlValidationResult<CheckAggregation | undefined> {
   if (value === undefined) return Object.freeze({ ok: true, value: undefined });
-  const data = exactKeys(value, ["checks", "mode", "unavailable", "notApplicable", "empty"]);
-  if (data === undefined) return invalidControls("controls.checkAggregation");
-  const checks = data.checks === "all" ? "all" : parseClosedCheckIds(data.checks);
-  if (checks === undefined) return invalidControls("controls.checkAggregation.checks");
-  const mode = parseLiteral(data.mode, CHECK_AGGREGATION_MODES);
-  const unavailable = parseLiteral(data.unavailable, UNAVAILABLE_HANDLING);
-  const notApplicable = parseLiteral(data.notApplicable, NOT_APPLICABLE_HANDLING);
-  const empty = parseLiteral(data.empty, EMPTY_AGGREGATION_RESULTS);
-  if (
-    mode === undefined ||
-    unavailable === undefined ||
-    notApplicable === undefined ||
-    empty === undefined
-  )
-    return invalidControls("controls.checkAggregation");
-  return Object.freeze({
-    ok: true,
-    value: Object.freeze({
-      checks,
-      mode,
-      unavailable,
-      notApplicable,
-      empty
-    })
-  });
-}
-
-function parseClosedCheckIds(value: unknown): readonly string[] | undefined {
-  const values = snapshotClosedArray(value);
-  if (values === undefined) return undefined;
-  const checkIds: string[] = [];
-  for (const checkId of values) {
-    if (typeof checkId !== "string" || checkId.length === 0) return undefined;
-    checkIds.push(checkId);
-  }
-  return Object.freeze(checkIds);
+  return isCheckAggregation(value)
+    ? Object.freeze({ ok: true, value })
+    : invalidControls("controls.checkAggregation");
 }
 
-function parseLiteral<Value extends string>(
-  value: unknown,
-  allowed: readonly Value[]
-): Value | undefined {
-  return typeof value === "string" ? allowed.find((option) => option === value) : undefined;
+function isCheckAggregation(value: unknown): value is CheckAggregation {
+  return typeof value === "function";
 }
 
 function isRunControlKey(value: string): boolean {
   return RUN_CONTROL_KEYS.some((key) => key === value);
 }
 
-function exactKeys(
-  value: unknown,
-  keys: readonly string[]
-): Readonly<Record<string, unknown>> | undefined {
-  if (!isNonArrayRecord(value)) return undefined;
-  return Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key))
-    ? value
-    : undefined;
-}
-
 function isAbortSignal(value: unknown): value is AbortSignal {
   return (
     isNonArrayRecord(value) &&
@@ -161,6 +199,10 @@ function parseString(value: unknown): string | undefined {
   return typeof value === "string" ? value : undefined;
 }
 
+function parseOutputDirectory(value: unknown): string | undefined {
+  return typeof value === "string" && isOutputDirectory(value) ? value : undefined;
+}
+
 function invalidControls(path: string): RunControlValidationResult<never> {
   return invalidRunControl(path, "invalid-value");
 }

package/src/project-run/diagnostic-logging/diagnostic-detail-rendering.ts

@@ -199,9 +199,8 @@ function renderDetailRecord(
 function isEnumerableDataDescriptor(
   descriptor: PropertyDescriptor | undefined
 ): descriptor is PropertyDescriptor & Readonly<{ readonly value: unknown }> {
+  if (descriptor?.enumerable !== true) return false;
   return (
-    descriptor !== undefined &&
-    descriptor.enumerable === true &&
     descriptor.get === undefined &&
     descriptor.set === undefined &&
     Object.hasOwn(descriptor, "value")

package/src/project-run/diagnostic-logging/logger.ts

@@ -2,22 +2,39 @@ import { closeSync, mkdirSync, openSync, writeSync } from "node:fs";
 import { dirname } from "node:path";
 
 import type { CheckExecutionClock } from "../check-execution/resolved-checks.ts";
-import { renderSafeDiagnosticDetail } from "./diagnostic-detail-rendering.ts";
+import { renderDiagnosticObservation } from "./observation-rendering.ts";
 export { summarizeDiagnosticValue } from "./diagnostic-detail-rendering.ts";
 
-/** Product-private observation written synchronously at the fact owner. */
+export const DIAGNOSTIC_CHANNELS = ["core", "scheduler"] as const;
+export type DiagnosticChannel = (typeof DIAGNOSTIC_CHANNELS)[number];
+export type DiagnosticChannelStatus = "disabled" | "failed" | "succeeded";
+
+/** Product-private observation written synchronously at its output owner. */
 export interface DiagnosticObservation {
+  /** Router-owned correlation, added before any channel write and never authored by Check code. */
+  readonly correlation?: Readonly<{
+    readonly elapsedMs: number;
+    readonly invocationId: string;
+    readonly sequence: number;
+  }>;
   readonly details?: unknown;
   readonly event: string;
   readonly tags: readonly string[];
 }
 
-/** Product-private invocation logger; its failures never escape lifecycle owners. */
+/** One channel writer. Its failures never escape the lifecycle owner that emits an observation. */
 export interface DiagnosticLogger {
-  close(): "disabled" | "failed" | "succeeded";
+  close(): DiagnosticChannelStatus;
   observe(observation: DiagnosticObservation): void;
 }
 
+/** The invocation-local router is the sole Product correlation and channel-routing owner. */
+export interface DiagnosticLoggingRouter {
+  readonly core: DiagnosticLogger;
+  readonly scheduler: DiagnosticLogger;
+  close(): Readonly<Record<DiagnosticChannel, DiagnosticChannelStatus>>;
+}
+
 /** A bounded, descriptor-safe description for normal diagnostic payloads. */
 export type DiagnosticValueSummary =
   | Readonly<{
@@ -29,7 +46,7 @@ export type DiagnosticValueSummary =
     }>
   | Readonly<{ readonly availability: "unavailable"; readonly reason: string }>;
 
-/** Test-only construction seam; Product invocation owns its lifecycle and output mapping. */
+/** Test-only construction seam; invocation construction owns all three channel lifecycles. */
 export type DiagnosticLoggerFactory = (
   input: Readonly<{
     readonly clock: CheckExecutionClock;
@@ -38,16 +55,107 @@ export type DiagnosticLoggerFactory = (
   }>
 ) => DiagnosticLogger;
 
+/**
+ * Creates one direct channel writer. The invocation router normally supplies correlation; retaining this
+ * construction function keeps focused writer tests independent of multi-channel invocation wiring.
+ */
 export const createDiagnosticLogger: DiagnosticLoggerFactory = (input) => {
   if (!input.enabled || input.file === null) return disabledLogger();
   return createEnabledLogger({ clock: input.clock, file: input.file });
 };
 
+/**
+ * Builds the minimal owner-neutral router. It has no subscriber registry: the Product owners are
+ * explicit fields, each writer is isolated, and one shared sequence/clock is assigned before delegation.
+ */
+export function createDiagnosticLoggingRouter(
+  input: Readonly<{
+    readonly clock: CheckExecutionClock;
+    readonly coreFile: string | null;
+    readonly factory: DiagnosticLoggerFactory;
+    readonly invocationId: string;
+    readonly schedulerFile: string | null;
+  }>
+): DiagnosticLoggingRouter {
+  if (input.coreFile === null && input.schedulerFile === null)
+    return disabledDiagnosticLoggingRouter();
+  const startedAt = safeNow(input.clock);
+  let sequence = 0;
+  const route = (file: string | null): DiagnosticLogger => {
+    if (file === null) return disabledLogger();
+    return createRoutedLogger({
+      clock: input.clock,
+      factory: input.factory,
+      file,
+      nextCorrelation: () =>
+        Object.freeze({
+          elapsedMs: elapsedSince(startedAt, input.clock),
+          invocationId: input.invocationId,
+          sequence: ++sequence
+        })
+    });
+  };
+  const core = route(input.coreFile);
+  const scheduler = route(input.schedulerFile);
+  return Object.freeze({
+    core,
+    scheduler,
+    close: () =>
+      Object.freeze({
+        core: core.close(),
+        scheduler: scheduler.close()
+      })
+  });
+}
+
 /** Builds one immutable set of human-filterable diagnostic labels. */
 export function diagnosticTags(...tags: readonly string[]): readonly string[] {
   return Object.freeze([...tags]);
 }
 
+/** Correlates one channel while containing its factory, write, and close lifecycle. */
+function createRoutedLogger(
+  input: Readonly<{
+    readonly clock: CheckExecutionClock;
+    readonly factory: DiagnosticLoggerFactory;
+    readonly file: string;
+    readonly nextCorrelation: () => NonNullable<DiagnosticObservation["correlation"]>;
+  }>
+): DiagnosticLogger {
+  let delegate: DiagnosticLogger | undefined;
+  let closed = false;
+  let failed = false;
+  try {
+    delegate = input.factory({ clock: input.clock, enabled: true, file: input.file });
+  } catch {
+    failed = true;
+  }
+  return Object.freeze({
+    close: (): DiagnosticChannelStatus => {
+      if (closed) return failed ? "failed" : "succeeded";
+      closed = true;
+      if (delegate === undefined) return "failed";
+      try {
+        const status = delegate.close();
+        failed ||= status === "failed";
+      } catch {
+        failed = true;
+      }
+      return failed ? "failed" : "succeeded";
+    },
+    observe: (observation: DiagnosticObservation): void => {
+      if (closed) return;
+      const correlation = input.nextCorrelation();
+      if (failed || delegate === undefined) return;
+      try {
+        delegate.observe(Object.freeze({ ...observation, correlation }));
+      } catch {
+        failed = true;
+      }
+    }
+  });
+}
+
 function disabledLogger(): DiagnosticLogger {
   return Object.freeze({
     close: () => "disabled" as const,
@@ -55,6 +163,19 @@ function disabledLogger(): DiagnosticLogger {
   });
 }
 
+function disabledDiagnosticLoggingRouter(): DiagnosticLoggingRouter {
+  const disabled = disabledLogger();
+  return Object.freeze({
+    core: disabled,
+    scheduler: disabled,
+    close: () =>
+      Object.freeze({
+        core: "disabled" as const,
+        scheduler: "disabled" as const
+      })
+  });
+}
+
 function createEnabledLogger(
   input: Readonly<{
     readonly clock: CheckExecutionClock;
@@ -88,12 +209,14 @@ function createEnabledLogger(
     observe: (observation: DiagnosticObservation) => {
       if (failed || descriptor === undefined) return;
       try {
-        const buffer = renderObservation({
-          elapsedMs: elapsedSince(startedAt, input.clock),
+        const correlation = observation.correlation;
+        const buffer = renderDiagnosticObservation({
+          elapsedMs: correlation?.elapsedMs ?? elapsedSince(startedAt, input.clock),
+          invocationId: correlation?.invocationId,
           observation,
-          sequence: sequence + 1
+          sequence: correlation?.sequence ?? sequence + 1
         });
-        sequence += 1;
+        if (correlation === undefined) sequence += 1;
         writeBuffer(descriptor, buffer);
       } catch {
         failed = true;
@@ -112,204 +235,6 @@ function writeBuffer(descriptor: number, buffer: string): void {
   }
 }
 
-function renderObservation(
-  input: Readonly<{
-    readonly elapsedMs: number;
-    readonly observation: DiagnosticObservation;
-    readonly sequence: number;
-  }>
-): string {
-  const tags = input.observation.tags.map((tag) => `[${escapeLogHeaderField(tag)}]`).join(" ");
-  const header = `#${String(input.sequence).padStart(6, "0")} +${formatElapsed(input.elapsedMs)} ${tags} ${escapeLogHeaderField(input.observation.event)}`;
-  return renderFactLines(header, diagnosticFacts(input.observation));
-}
-
-/** Keeps author-controlled header fields on one physical header line. */
-function escapeLogHeaderField(text: string): string {
-  let escaped = "";
-  for (const character of text) {
-    if (character === "\\") {
-      escaped += "\\\\";
-      continue;
-    }
-    const codeUnit = character.charCodeAt(0);
-    escaped +=
-      codeUnit <= 0x1f ||
-      (codeUnit >= 0x7f && codeUnit <= 0x9f) ||
-      codeUnit === 0x5b ||
-      codeUnit === 0x5d ||
-      codeUnit === 0x2028 ||
-      codeUnit === 0x2029
-        ? `\\u${codeUnit.toString(16).padStart(4, "0")}`
-        : character;
-  }
-  return escaped;
-}
-
-function diagnosticFacts(observation: DiagnosticObservation): readonly string[] {
-  if (observation.details === undefined) return Object.freeze([]);
-  const rendered = renderSafeDiagnosticDetail(observation.details);
-  if (!rendered.ok)
-    return Object.freeze([`details=unavailable:${escapeLogHeaderField(rendered.reason)}`]);
-
-  const value: unknown = JSON.parse(rendered.text);
-  const facts: string[] = [];
-  flattenDiagnosticFacts(value, [], facts, observation);
-  return Object.freeze(facts);
-}
-
-function flattenDiagnosticFacts(
-  value: unknown,
-  path: readonly string[],
-  facts: string[],
-  observation: DiagnosticObservation
-): void {
-  if (Array.isArray(value)) {
-    flattenDiagnosticArrayFacts(value, path, facts, observation);
-    return;
-  }
-
-  if (value !== null && typeof value === "object") {
-    flattenDiagnosticRecordFacts(value, path, facts, observation);
-    return;
-  }
-
-  facts.push(`${factKey(path)}=${factValue(path, value)}`);
-}
-
-function flattenDiagnosticArrayFacts(
-  value: readonly unknown[],
-  path: readonly string[],
-  facts: string[],
-  observation: DiagnosticObservation
-): void {
-  const inline = JSON.stringify(value);
-  if (inline.length <= MAX_INLINE_DIAGNOSTIC_VALUE_CHARACTERS) {
-    facts.push(`${factKey(path)}=${inline}`);
-    return;
-  }
-  const arrayPath = path.length === 0 ? ["details"] : path;
-  for (let index = 0; index < value.length; index += 1) {
-    flattenDiagnosticFacts(value[index], [...arrayPath, String(index)], facts, observation);
-  }
-}
-
-function flattenDiagnosticRecordFacts(
-  value: object,
-  path: readonly string[],
-  facts: string[],
-  observation: DiagnosticObservation
-): void {
-  const entries = Object.entries(value);
-  if (entries.length === 0) {
-    facts.push(`${factKey(path)}={}`);
-    return;
-  }
-  for (const [key, nested] of entries) {
-    if (path.length === 0 && isTopLevelFactRepresentedByTag(observation, key, nested)) continue;
-    flattenDiagnosticFacts(nested, [...path, key], facts, observation);
-  }
-}
-
-/** Omits only exact producer facts already visible in the observation's filter tags. */
-function isTopLevelFactRepresentedByTag(
-  observation: DiagnosticObservation,
-  key: string,
-  value: unknown
-): boolean {
-  if (typeof value !== "string") return false;
-  if (observation.event === "scheduler.decision") {
-    if (key === "kind") return observation.tags.includes(value.toUpperCase());
-    return key === "taskId" && observation.tags.includes(`TASK:${value}`);
-  }
-  return (
-    observation.event === "record.reported" &&
-    key === "result" &&
-    observation.tags.includes(value.toUpperCase())
-  );
-}
-
-const MAX_INLINE_DIAGNOSTIC_VALUE_CHARACTERS = 120;
-
-function factKey(path: readonly string[]): string {
-  if (path.length === 0) return "details";
-  const joined = path.join(".");
-  return /^[A-Za-z_][A-Za-z0-9_.-]*$/u.test(joined) ? joined : JSON.stringify(joined);
-}
-
-function factValue(path: readonly string[], value: unknown): string {
-  const key = path.at(-1);
-  if (typeof value === "number" && key?.endsWith("Ms")) {
-    return String(Math.round(value * 1_000) / 1_000);
-  }
-  return JSON.stringify(value);
-}
-
-const MAX_DIAGNOSTIC_LINE_CHARACTERS = 200;
-
-function renderFactLines(header: string, facts: readonly string[]): string {
-  if (facts.length === 0) return `${header}\n`;
-
-  const lines: string[] = [];
-  let current = header;
-  for (const fact of facts) {
-    if (current.length + 1 + fact.length <= MAX_DIAGNOSTIC_LINE_CHARACTERS) {
-      current += ` ${fact}`;
-      continue;
-    }
-
-    lines.push(current);
-    const firstCapacity = MAX_DIAGNOSTIC_LINE_CHARACTERS - "│ ".length;
-    const continuationCapacity = MAX_DIAGNOSTIC_LINE_CHARACTERS - "│   ".length;
-    let offset = 0;
-    let prefix = "│ ";
-    while (fact.length - offset > (prefix === "│ " ? firstCapacity : continuationCapacity)) {
-      const capacity = prefix === "│ " ? firstCapacity : continuationCapacity;
-      const end = diagnosticChunkEnd(fact, offset, capacity);
-      lines.push(`${prefix}${fact.slice(offset, end)}`);
-      offset = end;
-      prefix = "│   ";
-    }
-    current = `${prefix}${fact.slice(offset)}`;
-  }
-  lines.push(current);
-  return `${lines.join("\n")}\n`;
-}
-
-function diagnosticChunkEnd(text: string, offset: number, capacity: number): number {
-  let end = offset + capacity;
-  const preferredMinimum = offset + Math.floor(capacity * 0.6);
-  for (let index = end - 1; index >= preferredMinimum; index -= 1) {
-    if (text[index] === " ") {
-      end = index;
-      break;
-    }
-    if (text[index] === ",") {
-      end = index + 1;
-      break;
-    }
-  }
-  if (
-    end < text.length &&
-    text.charCodeAt(end - 1) >= 0xd800 &&
-    text.charCodeAt(end - 1) <= 0xdbff &&
-    text.charCodeAt(end) >= 0xdc00 &&
-    text.charCodeAt(end) <= 0xdfff
-  ) {
-    end -= 1;
-  }
-  return end;
-}
-
-function formatElapsed(elapsedMs: number): string {
-  const totalMilliseconds = Math.round(elapsedMs);
-  const hours = Math.floor(totalMilliseconds / 3_600_000);
-  const minutes = Math.floor((totalMilliseconds % 3_600_000) / 60_000);
-  const seconds = Math.floor((totalMilliseconds % 60_000) / 1_000);
-  const milliseconds = totalMilliseconds % 1_000;
-  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${String(milliseconds).padStart(3, "0")}`;
-}
-
 function safeNow(clock: CheckExecutionClock): number {
   try {
     const now = clock.now();