@interf/compiler 0.9.4 → 0.13.0

package/dist/packages/local-service/runtime-resource-builders.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Pure shaping helpers used by the runtime to assemble resource payloads
+ * (preparations, methods, proofs, log paths, readiness summaries) from
+ * raw state/run records. No I/O, no `this` — every input is passed in.
+ *
+ * Splitting these out keeps the runtime coordinator focused on
+ * orchestration rather than payload formatting.
+ */
+import { type ArtifactRef, type ProofRecord } from "../execution/lib/schema.js";
+import { type CompiledState } from "../compiler/state.js";
+import { type RuntimeRun } from "../compiler/lib/schema.js";
+import { type ReadinessState, type ReadinessTargetResult } from "../contracts/lib/schema.js";
+import { type TestRunTargetSummary } from "../testing/lib/schema.js";
+import { type SourcePreparationConfig } from "../project-model/lib/schema.js";
+import { type MethodResource, type PreparationResource } from "./lib/schema.js";
+export declare function createRunId(prefix: "compile" | "test" | "job"): string;
+export declare function stageArtifactRefs(stageId: string, artifacts: string[] | undefined): ArtifactRef[];
+export declare function proofForStage(options: {
+    runId: string;
+    stageId: string;
+    summary?: string | null;
+    stageState: NonNullable<CompiledState["stages"]>[string];
+    artifacts: ArtifactRef[];
+}): ProofRecord;
+export declare function logsForStageRun(stageState: NonNullable<CompiledState["stages"]>[string] | undefined): {
+    prompt_path: string;
+    event_stream_path: string;
+    status_path: string;
+    contract_path: string;
+} | undefined;
+export declare function logsForRuntimeRun(run: RuntimeRun | undefined): {
+    contract_path: string;
+    status_path?: string | undefined;
+    event_stream_path?: string | undefined;
+    prompt_path?: string | undefined;
+} | undefined;
+export declare function passRate(passed: number, total: number): number | null;
+export declare function readinessTargetResult(summary: TestRunTargetSummary | null | undefined, currentFingerprint: string | null, readinessRunFingerprint: string | null | undefined): ReadinessTargetResult | null;
+export declare function readinessSummaryForStatus(status: ReadinessState["status"]): string;
+export declare function readinessStateToPreparationReadiness(readiness: ReadinessState): ReadinessState;
+export declare function buildPreparationResource(rootPath: string, preparation: SourcePreparationConfig, readiness: ReadinessState, latestCompileRunId: string | null, latestTestRunId: string | null): PreparationResource;
+export declare function buildMethodResource(resource: {
+    id: string;
+    path: string;
+    label?: string;
+    hint?: string;
+    source_kind: "builtin" | "local";
+    built_in: boolean;
+    active_for_preparations: string[];
+    output_paths: string[];
+    stages: MethodResource["stages"];
+}): MethodResource;

package/dist/packages/local-service/runtime-resource-builders.js

@@ -0,0 +1,149 @@
+import { ReadinessStateSchema, } from "../contracts/lib/schema.js";
+import { methodIdForSourcePreparationConfig, resolveSourcePreparationPath, } from "../project-model/source-config.js";
+import { MethodResourceSchema, PreparationResourceSchema, } from "./lib/schema.js";
+export function createRunId(prefix) {
+    return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+export function stageArtifactRefs(stageId, artifacts) {
+    return (artifacts ?? []).map((path) => ({
+        path,
+        role: "output",
+        stage_id: stageId,
+        label: path,
+    }));
+}
+export function proofForStage(options) {
+    return {
+        id: `${options.runId}-${options.stageId}-proof`,
+        run_id: options.runId,
+        stage_id: options.stageId,
+        generated_at: options.stageState.finished_at ?? new Date().toISOString(),
+        summary: options.summary ?? `${options.stageId} produced stage evidence.`,
+        files_processed: options.stageState.counts?.source_total,
+        artifacts: options.artifacts,
+        checks: [
+            {
+                id: `${options.stageId}-status`,
+                label: "stage completed",
+                ok: options.stageState.status === "succeeded",
+                ...(options.stageState.status === "succeeded"
+                    ? {}
+                    : { detail: options.stageState.summary ?? "Stage did not complete successfully." }),
+            },
+            {
+                id: `${options.stageId}-artifacts`,
+                label: "artifacts recorded",
+                ok: options.artifacts.length > 0,
+                ...(options.artifacts.length > 0
+                    ? {}
+                    : { detail: "No stage artifacts were recorded." }),
+            },
+        ],
+    };
+}
+export function logsForStageRun(stageState) {
+    const runId = stageState?.run_id;
+    if (!runId)
+        return undefined;
+    return {
+        prompt_path: `.interf/runtime/logs/${runId}.prompt.txt`,
+        event_stream_path: `.interf/runtime/logs/${runId}.events.ndjson`,
+        status_path: `.interf/runtime/logs/${runId}.status.log`,
+        contract_path: `.interf/runtime/logs/${runId}.stage-contract.json`,
+    };
+}
+export function logsForRuntimeRun(run) {
+    if (!run)
+        return undefined;
+    return {
+        ...(run.logs?.prompt_path ? { prompt_path: run.logs.prompt_path } : {}),
+        ...(run.logs?.event_stream_path ? { event_stream_path: run.logs.event_stream_path } : {}),
+        ...(run.logs?.status_path ? { status_path: run.logs.status_path } : {}),
+        contract_path: run.contract_path,
+    };
+}
+export function passRate(passed, total) {
+    if (total <= 0)
+        return null;
+    return Math.round((passed / total) * 100);
+}
+export function readinessTargetResult(summary, currentFingerprint, readinessRunFingerprint) {
+    if (!summary)
+        return null;
+    const resultFingerprint = readinessRunFingerprint ?? null;
+    return {
+        passed: summary.passed_cases,
+        total: summary.total_cases,
+        pass_rate: passRate(summary.passed_cases, summary.total_cases),
+        checks_fingerprint: resultFingerprint,
+        stale: Boolean(currentFingerprint && resultFingerprint && currentFingerprint !== resultFingerprint),
+        run_id: null,
+        run_path: summary.run_path,
+    };
+}
+export function readinessSummaryForStatus(status) {
+    if (status === "ready")
+        return "Ready for agent work.";
+    if (status === "not-ready")
+        return "Readiness checks did not pass.";
+    if (status === "stale")
+        return "Readiness checks are stale for the current saved checks.";
+    if (status === "checking")
+        return "Readiness checks are running.";
+    if (status === "building")
+        return "Portable context is building.";
+    if (status === "built")
+        return "Portable context is built; readiness has not been proven yet.";
+    if (status === "not-built")
+        return "Portable context has not been built yet.";
+    if (status === "not-configured")
+        return "No readiness checks are configured.";
+    return "Latest preparation failed.";
+}
+export function readinessStateToPreparationReadiness(readiness) {
+    return ReadinessStateSchema.parse({
+        ...readiness,
+        checks: readiness.checks.map((check) => ({ ...check })),
+    });
+}
+export function buildPreparationResource(rootPath, preparation, readiness, latestCompileRunId, latestTestRunId) {
+    const methodId = methodIdForSourcePreparationConfig(preparation);
+    return PreparationResourceSchema.parse({
+        id: preparation.name,
+        name: preparation.name,
+        preparation,
+        source_path: resolveSourcePreparationPath(rootPath, preparation),
+        method_id: methodId,
+        checks: preparation.checks,
+        portable_context: {
+            preparation: preparation.name,
+            path: readiness.portable_context_path,
+            exists: readiness.portable_context_path !== null,
+            method_id: methodId,
+            latest_compile_run_id: latestCompileRunId,
+            latest_test_run_id: latestTestRunId,
+        },
+        portable_context_path: readiness.portable_context_path,
+        readiness: readinessStateToPreparationReadiness(readiness),
+        runs: {
+            latest_compile_run_id: latestCompileRunId,
+            latest_test_run_id: latestTestRunId,
+        },
+        latest_compile_run_id: latestCompileRunId,
+        latest_test_run_id: latestTestRunId,
+    });
+}
+export function buildMethodResource(resource) {
+    return MethodResourceSchema.parse({
+        id: resource.id,
+        method_id: resource.id,
+        path: resource.path,
+        ...(resource.label ? { label: resource.label } : {}),
+        ...(resource.hint ? { hint: resource.hint } : {}),
+        source_kind: resource.source_kind,
+        built_in: resource.built_in,
+        active_for_preparations: resource.active_for_preparations,
+        output_paths: resource.output_paths,
+        stages: resource.stages,
+    });
+}

package/dist/packages/local-service/runtime.d.ts

@@ -2,7 +2,7 @@ import { type ArtifactRef, type CompileRun, type InterfRunEvent, type ProofRecor
 import { type RunEventSink } from "../execution/events.js";
 import { type ReadinessState } from "../contracts/lib/schema.js";
 import type { SourcePreparationConfig } from "../project-model/lib/schema.js";
-import { type ActionProposalCreateRequest, type ActionProposalPlan, type ActionProposalResource, type CompileRunCreateRequest, type CompileRunResource, type MethodResource, type LocalServiceHealth, type LocalJobEvent, type LocalJobEventAppendRequest, type LocalExecutorStatus, type LocalJobRunResource, type LocalRunHandlerResult, type PortableContextResource, type PreparationReadinessState, type PreparationResource, type ReadinessCheckDraftCreateRequest, type ReadinessCheckDraftResult, type RunObservabilityResource, type SourceFileResource, type WorkspaceFileResource, type TestRunCreateRequest, type TestRunResource, type MethodAuthoringCreateRequest, type MethodAuthoringResult } from "./lib/schema.js";
+import { type ActionProposalCreateRequest, type ActionProposalPlan, type ActionProposalResource, type CompileRunCreateRequest, type CompileRunResource, type MethodResource, type LocalServiceHealth, type LocalJobEvent, type LocalJobEventAppendRequest, type LocalExecutorStatus, type LocalJobRunResource, type LocalRunHandlerResult, type PortableContextResource, type PreparationResource, type ReadinessCheckDraftCreateRequest, type ReadinessCheckDraftResult, type RunObservabilityResource, type ServiceRegistryWorkspace, type SourceFileResource, type WorkspaceFileResource, type TestRunCreateRequest, type TestRunResource, type MethodAuthoringCreateRequest, type MethodAuthoringResult, type MethodChangeResult, type PreparationChangeResult, type PreparationSetupResult, type WorkspaceBootstrapResult, type ResetResult } from "./lib/schema.js";
 export interface LocalServiceCompileRunContext {
     runId: string;
     sourcePath: string;
@@ -52,64 +52,221 @@ export interface LocalServiceRuntimeOptions {
     packageVersion?: string;
     startedAt?: string;
     handlers?: Partial<LocalServiceRunHandlers>;
+    /**
+     * Per-instance bearer token. The server requires it on mutating
+     * requests. Optional only so test code that does not exercise auth can
+     * skip generating one; production startup always provides a token.
+     */
+    authToken?: string;
+}
+/**
+ * Per-workspace context tracked by the runtime. Multiple workspaces can be
+ * registered against one running service; each one owns its rootPath and
+ * activity timestamps. Routes pass the workspace explicitly to every
+ * runtime method that needs one, so there is no swap-state to manage.
+ */
+export interface PreparationContext {
+    rootPath: string;
+    startedAt: string;
+    lastActivity: string;
 }
 export declare class LocalServiceRuntime {
-    readonly rootPath: string;
     readonly host: string;
-    readonly port: number;
+    port: number;
     readonly startedAt: string;
     readonly packageVersion?: string;
     readonly handlers: Partial<LocalServiceRunHandlers>;
+    /**
+     * The seed root path the runtime was constructed with. Used as a
+     * non-preparation fallback when a preparation-independent route
+     * (methods, action proposals, runs listings) needs an anchor to load
+     * shared state (user-library methods, bundled methods, etc).
+     */
+    readonly rootPath: string;
+    /**
+     * Per-instance bearer token. Mutating routes require this on the
+     * Authorization header. `null` means token-less mode (test harness).
+     */
+    readonly authToken: string | null;
+    /** Map of prepDataDir -> PreparationContext. */
+    private workspaces;
+    /** Hook called whenever a workspace is registered or deregistered. */
+    private onRegistryChanged;
+    /** In-flight runs across all workspaces. Used for `idle_for_seconds`. */
+    private activeRunCount;
+    /**
+     * Active compile-run cancellation handles, keyed by run id. Populated
+     * when a compile run is launched and cleared once the run reaches a
+     * terminal state. Each entry remembers where the persisted record lives
+     * so cancel can mark it without re-resolving the Preparation.
+     */
+    private activeCompileRuns;
+    /**
+     * Idempotency-key cache for `POST /v1/compile-runs`. Outer key is the
+     * resolved workspace root; inner key is the client-supplied idempotency
+     * value. Namespacing per workspace prevents key collisions across
+     * tenants on the same engine (CSO finding: a malicious workspace could
+     * otherwise hijack another workspace's run id by reusing its key).
+     * Entries expire after `IDEMPOTENCY_TTL_MS`.
+     */
+    private idempotencyKeyCache;
+    /**
+     * Read-side caches. Polling clients (Compiler UI, CLI status loops)
+     * hit list/get endpoints multiple times per second; without these,
+     * every request re-walks the filesystem and re-parses every JSON
+     * record through Zod. The runtime invalidates each cache on the
+     * matching write path. See {@link runtime-caches} for design notes.
+     */
+    private readonly compileRunCache;
+    private readonly testRunCache;
+    private readonly readinessCache;
+    private readonly sourceFilesCache;
+    private readonly methodListingCache;
     constructor(options: LocalServiceRuntimeOptions);
-    health(): LocalServiceHealth;
-    listPreparations(): PreparationResource[];
-    getPreparation(preparationName: string): PreparationResource | null;
-    listPreparationReadiness(): PreparationReadinessState[];
-    getPreparationReadiness(preparationName: string): PreparationReadinessState | null;
-    listReadiness(): ReadinessState[];
-    getReadiness(preparationName: string): ReadinessState | null;
-    computePreparationReadiness(preparation: SourcePreparationConfig): ReadinessState;
-    listSourceFiles(preparationName?: string | null): SourceFileResource[];
-    listWorkspaceFiles(): WorkspaceFileResource[];
-    listMethods(): MethodResource[];
-    getMethod(methodId: string): MethodResource | null;
-    listJobs(): LocalJobRunResource[];
-    getJob(runId: string): LocalJobRunResource | null;
-    getJobEvents(runId: string): LocalJobEvent[] | null;
+    setBoundPort(port: number): void;
+    /** Set a hook that fires whenever the registered workspaces change. */
+    setOnRegistryChanged(handler: (() => void) | null): void;
+    /**
+     * Register a workspace with this runtime. Returns the PreparationContext.
+     * Idempotent: re-registering an existing workspace updates `lastActivity`.
+     */
+    registerPreparation(prepDataDir: string): PreparationContext;
+    /**
+     * Remove a workspace from the runtime. Returns true if a workspace was
+     * removed.
+     */
+    deregisterPreparation(prepDataDir: string): boolean;
+    /**
+     * Most recently active workspace, or the first registered if none has
+     * activity yet. Server code uses this as the fallback when a request
+     * omits the workspace header. Throws if no workspace is registered.
+     */
+    defaultPreparationDataDir(): string;
+    /** Look up a workspace context by rootPath. */
+    getPreparationContext(prepDataDir: string): PreparationContext | null;
+    /** All registered workspaces, ordered by registration time. */
+    listRegisteredPreparations(): PreparationContext[];
+    /** True when no workspaces are registered. */
+    hasNoWorkspaces(): boolean;
+    /** Number of registered workspaces. */
+    registeredPreparationCount(): number;
+    /** Increment in-flight run counter. Call when a long-running run starts. */
+    beginActiveRun(): void;
+    /** Decrement in-flight run counter. Pair with `beginActiveRun`. */
+    endActiveRun(): void;
+    /** Sum of in-flight runs across all workspaces. */
+    activeRuns(): number;
+    /**
+     * Mark the workspace as recently active. Routes call this on entry so
+     * `idleForSeconds` and the registry snapshots stay in sync with the
+     * actual request cadence.
+     */
+    touchPreparation(prepDataDir: string): void;
+    /** Snapshot of registered workspaces for the registry / status output. */
+    registeredPreparationSnapshots(): ServiceRegistryWorkspace[];
+    /** Seconds since the most recent workspace activity (0 if active). */
+    idleForSeconds(): number;
+    health(prepDataDir?: string): LocalServiceHealth;
+    listPreparations(prepDataDir: string): PreparationResource[];
+    getPreparation(prepDataDir: string, preparationName: string): PreparationResource | null;
+    listPreparationReadiness(prepDataDir: string): ReadinessState[];
+    getPreparationReadiness(prepDataDir: string, preparationName: string): ReadinessState | null;
+    listReadiness(prepDataDir: string): ReadinessState[];
+    getReadiness(prepDataDir: string, preparationName: string): ReadinessState | null;
+    computePreparationReadiness(prepDataDir: string, preparation: SourcePreparationConfig): ReadinessState;
+    private computePreparationReadinessUncached;
+    listSourceFiles(prepDataDir: string, preparationName?: string | null): SourceFileResource[];
+    listWorkspaceFiles(prepDataDir: string): WorkspaceFileResource[];
+    listMethods(prepDataDir: string): MethodResource[];
+    getMethod(prepDataDir: string, methodId: string): MethodResource | null;
+    listJobs(prepDataDir: string): LocalJobRunResource[];
+    getJob(prepDataDir: string, runId: string): LocalJobRunResource | null;
+    getJobEvents(prepDataDir: string, runId: string): LocalJobEvent[] | null;
     getExecutorStatus(): LocalExecutorStatus;
     selectExecutor(requestValue: unknown): LocalExecutorStatus;
-    listActionProposals(): ActionProposalResource[];
-    getActionProposal(proposalId: string): ActionProposalResource | null;
-    createActionProposal(requestValue: unknown): Promise<ActionProposalResource>;
-    decideActionProposal(proposalId: string, requestValue: unknown): Promise<ActionProposalResource | null>;
-    listRunObservability(): RunObservabilityResource[];
-    getRunObservability(runId: string): RunObservabilityResource | null;
-    createJobRun(requestValue: unknown): LocalJobRunResource;
-    appendJobRunEvent(runId: string, requestValue: unknown): LocalJobRunResource | null;
-    createReadinessCheckDraftRun(requestValue: unknown): Promise<LocalJobRunResource>;
-    createPreparationSetupRun(requestValue: unknown): Promise<LocalJobRunResource>;
-    createMethodAuthoringRun(requestValue: unknown): Promise<LocalJobRunResource>;
-    listPortableContexts(): PortableContextResource[];
-    getPortableContext(preparationName: string): PortableContextResource | null;
-    listCompileRuns(): CompileRunResource[];
-    listCompileRunsForPreparation(preparationName: string): CompileRun[];
-    getCompileRun(runId: string): CompileRunResource | null;
-    getCompileRunEvents(runId: string): InterfRunEvent[] | null;
-    getCompileRunProof(runId: string): ProofRecord[] | null;
-    getCompileRunArtifacts(runId: string): ArtifactRef[] | null;
-    createCompileRun(requestValue: unknown): Promise<CompileRunResource>;
-    listTestRuns(): TestRunResource[];
-    listTestRunsForPreparation(preparationName: string): TestRunResource[];
-    getTestRun(runId: string): TestRunResource | null;
-    createTestRun(requestValue: unknown): Promise<TestRunResource>;
+    listActionProposals(prepDataDir: string): ActionProposalResource[];
+    getActionProposal(prepDataDir: string, proposalId: string): ActionProposalResource | null;
+    createActionProposal(prepDataDir: string, requestValue: unknown): Promise<ActionProposalResource>;
+    decideActionProposal(prepDataDir: string, proposalId: string, requestValue: unknown): Promise<ActionProposalResource | null>;
+    listRunObservability(prepDataDir: string): RunObservabilityResource[];
+    getRunObservability(prepDataDir: string, runId: string): RunObservabilityResource | null;
+    private createJobRun;
+    private appendJobRunEvent;
+    createReadinessCheckDraftRun(prepDataDir: string, requestValue: unknown): Promise<LocalJobRunResource>;
+    applyMethodChange(prepDataDir: string, requestValue: unknown): MethodChangeResult;
+    /**
+     * Bootstrap the workspace's source-folder binding and seed the default
+     * Method. Idempotent: re-running with the same source folder preserves
+     * existing preparations and reports `changed: false`.
+     *
+     * The CLI calls this in place of writing `interf.json` directly, so the
+     * operation is recorded by the service (and visible to other clients).
+     */
+    bootstrapWorkspace(prepDataDir: string, requestValue: unknown): WorkspaceBootstrapResult;
+    applyPreparationSetup(prepDataDir: string, requestValue: unknown): PreparationSetupResult;
+    applyPreparationChange(prepDataDir: string, requestValue: unknown): PreparationChangeResult;
+    applyReset(prepDataDir: string, requestValue: unknown): ResetResult;
+    createMethodAuthoringRun(prepDataDir: string, requestValue: unknown, jobType?: "method-authoring" | "method-improvement"): Promise<LocalJobRunResource>;
+    listPortableContexts(prepDataDir: string): PortableContextResource[];
+    getPortableContext(prepDataDir: string, preparationName: string): PortableContextResource | null;
+    listCompileRuns(prepDataDir: string): CompileRunResource[];
+    listCompileRunsForPreparation(prepDataDir: string, preparationName: string): CompileRun[];
+    getCompileRun(prepDataDir: string, runId: string): CompileRunResource | null;
+    getCompileRunEvents(prepDataDir: string, runId: string): InterfRunEvent[] | null;
+    getCompileRunProof(prepDataDir: string, runId: string): ProofRecord[] | null;
+    getCompileRunArtifacts(prepDataDir: string, runId: string): ArtifactRef[] | null;
+    createCompileRun(prepDataDir: string, requestValue: unknown): Promise<CompileRunResource>;
+    /**
+     * Cancel an in-flight compile run. Marks the persisted record as
+     * `cancelled`, emits a `run.failed` event to capture the cancellation in
+     * the run timeline, and clears the active handle so retries may start a
+     * fresh run. If the run already finished, returns
+     * `{ cancelled: false, reason: "already finished" }` and persists nothing.
+     */
+    cancelCompileRun(runId: string): {
+        cancelled: boolean;
+        reason?: string;
+    };
+    /**
+     * Look up the run id previously associated with this idempotency key in
+     * `prepDataDir`. Returns null when the key is unknown or its TTL has
+     * elapsed. The workspace argument is required so that the same key in
+     * two different workspaces always returns two different runs.
+     */
+    findIdempotentCompileRun(prepDataDir: string, key: string): string | null;
+    /**
+     * Cache the run id created (or returned) for this idempotency key in
+     * `prepDataDir`. Entries expire after `IDEMPOTENCY_TTL_MS`. Pruning
+     * is opportunistic: the previous implementation walked every entry on
+     * every read AND write, which was O(N) per request. Now we only sweep
+     * when the cache grows past {@link IDEMPOTENCY_PRUNE_THRESHOLD}.
+     */
+    recordIdempotentCompileRun(prepDataDir: string, key: string, runId: string): void;
+    /** Total cached idempotency entries across all workspaces. */
+    private totalIdempotencyEntries;
+    private pruneIdempotencyKeyCache;
+    /**
+     * Test seam: force the cached entry for `key` in `prepDataDir` to be
+     * expired so the next lookup returns null. Returns true when an entry was
+     * found and expired. Tests use this in place of fake timers because the
+     * idempotency TTL is one hour and faking `Date.now()` would destabilize
+     * unrelated runtime state.
+     */
+    expireIdempotencyKeyForTesting(prepDataDir: string, key: string): boolean;
+    listTestRuns(prepDataDir: string): TestRunResource[];
+    listTestRunsForPreparation(prepDataDir: string, preparationName: string): TestRunResource[];
+    getTestRun(prepDataDir: string, runId: string): TestRunResource | null;
+    createTestRun(prepDataDir: string, requestValue: unknown): Promise<TestRunResource>;
     private runCompileInBackground;
     private runTestInBackground;
     private runReadinessCheckDraftInBackground;
+    private runReadinessCheckDraftInBackgroundInner;
     private runMethodAuthoringInBackground;
+    private runMethodAuthoringInBackgroundInner;
     private jobRunContext;
     private defaultPreparationName;
     private planActionProposal;
-    private buildPreparationSetupRequest;
+    private directServiceActionClarification;
     private buildActionProposal;
     private submitActionProposal;
     private resolvePreparationConfig;
@@ -122,7 +279,7 @@ export declare class LocalServiceRuntime {
     private recordCompileRunEvent;
     private refreshCompileRunFromRuntime;
     private emitRuntimeDerivedEvents;
-    private readLatestComparison;
+    private readLatestReadinessRun;
     private checksEvaluatedEvent;
     private readinessUpdatedEvent;
     private writeTestRun;