@markstanden/opencode-test-container 0.0.0-stage → 0.1.1

package/dist/evaluators/docs/analysis/screening/scan.js

@@ -0,0 +1,362 @@
+/**
+ * Static-screening orchestration for one recorded trial.
+ *
+ * Reads the resulting documents, before/after states, the final response, the
+ * task prompt and the recorded writes, applies the configured rules and
+ * returns findings with hashed, root-relative sources and trial provenance.
+ * Every input is a {@link Loaded} record: a rule runs only with sufficient
+ * evidence, so an unobserved change can never be published as a mechanical
+ * contradiction. The screen is advisory infrastructure: it never modifies
+ * judge inputs, eligibility, outcomes, scores or guardrails, and it is
+ * generated independently of any judge packet.
+ */
+import { docChanges, } from "../../campaign.js";
+import { claimMutationFindings, duplicationFindings, permissionFindings, sourceOf, structureFindings, transientWordingFindings, SCREENING_RULES_VERSION, } from "./rules.js";
+import { scanInventory } from "./inventory.js";
+/** Map one source kind to the evidence role it plays in a trial. */
+const ROLE_OF = {
+    "before-document": "before",
+    "after-document": "after",
+    "resulting-document": "after",
+    "final-response": "response",
+    "task-prompt": "prompt",
+    "recorded-write": "writes",
+};
+/**
+ * Rewrite one source's tree-relative reference to its root-relative identity.
+ * Identity is positional, never content-derived: two trials may hold identical
+ * final answers and still cite distinguishable sources.
+ * @param source The source with a tree-relative or label reference.
+ * @param paths The trial's root-relative references.
+ * @returns The source with a root-relative reference.
+ */
+function rooted(source, paths) {
+    switch (source.kind) {
+        case "before-document":
+            return {
+                ...source,
+                reference: `${paths.beforeRoot}/${source.reference}`,
+            };
+        case "after-document":
+        case "resulting-document":
+            return {
+                ...source,
+                reference: `${paths.afterRoot}/${source.reference}`,
+            };
+        case "final-response":
+            return { ...source, reference: paths.finalAnswer };
+        case "task-prompt":
+            return { ...source, reference: paths.prompt };
+        case "recorded-write":
+            return { ...source, reference: paths.writes };
+    }
+}
+/**
+ * Attach the trial identity, evidence role and root-relative source to one
+ * rule-produced finding.
+ * @param draft The rule finding.
+ * @param input The screen input.
+ * @returns The finding with provenance.
+ */
+function withProvenance(draft, input) {
+    return {
+        ...draft,
+        trial: input.trial,
+        role: ROLE_OF[draft.source.kind],
+        source: rooted(draft.source, input.paths),
+    };
+}
+/**
+ * Convert one inventory trigger into a finding.
+ * @param trigger The trigger with its spans.
+ * @param source The scanned document's source record.
+ * @param scenario The scenario id.
+ * @returns The finding.
+ */
+function triggerFinding(trigger, source, scenario) {
+    const base = {
+        ruleVersion: SCREENING_RULES_VERSION,
+        applicability: scenario,
+        authority: "mechanical",
+        source,
+        excerpt: trigger.mention.text,
+        span: { start: trigger.mention.start, end: trigger.mention.end },
+        factId: trigger.factId,
+    };
+    if (trigger.kind === "obsolete-current") {
+        return {
+            ...base,
+            ruleId: "fact-obsolete-current",
+            category: "fact-obsolete-current",
+            explanation: "the configured obsolete claim is presented as current; no local negation qualifies it",
+        };
+    }
+    if (trigger.kind === "conflict") {
+        return {
+            ...base,
+            ruleId: "fact-conflict",
+            category: "fact-conflict",
+            explanation: `the document asserts and locally negates the same fact; opposing assertion: ${JSON.stringify(trigger.other?.assertion ?? "")}`,
+        };
+    }
+    return {
+        ...base,
+        ruleId: "fact-negation",
+        category: "fact-negation",
+        explanation: `a local negation cue ${JSON.stringify(trigger.negation?.text ?? "")} applies to this mention; a local cue does not by itself prove semantic loss`,
+    };
+}
+/**
+ * Convert one unrecognised inventory fact into an advisory finding.
+ * @param factId The fact id.
+ * @param factLabel The configured label.
+ * @param source The scanned document's source record.
+ * @param scenario The scenario id.
+ * @returns The finding.
+ */
+function coverageFinding(factId, factLabel, source, scenario) {
+    return {
+        ruleId: "fact-coverage-unknown",
+        ruleVersion: SCREENING_RULES_VERSION,
+        category: "fact-coverage-unknown",
+        applicability: scenario,
+        authority: "advisory",
+        source,
+        excerpt: "",
+        span: { start: 0, end: 0 },
+        factId,
+        explanation: `no recognised mention of ${JSON.stringify(factLabel)}; a missing keyword does not prove loss, and an unrecognised paraphrase remains possible`,
+    };
+}
+/**
+ * Read every available source the screen consults, hashed, rooted and sorted.
+ * A missing input contributes no source, so no hash can imply it was read.
+ * @param input The screen input.
+ * @returns The source records.
+ */
+function sourcesOf(input) {
+    const sources = [];
+    const add = (source) => {
+        sources.push(rooted(source, input.paths));
+    };
+    if (input.finalAnswer.state === "available") {
+        add(sourceOf("final-response", "final.md", input.finalAnswer.value));
+    }
+    if (input.taskPrompt.state === "available") {
+        add(sourceOf("task-prompt", "prompt.md", input.taskPrompt.value));
+    }
+    if (input.writesText.state === "available") {
+        add(sourceOf("recorded-write", "writes.txt", input.writesText.value));
+    }
+    if (input.beforeDocs.state === "available") {
+        for (const doc of input.beforeDocs.value) {
+            add(sourceOf("before-document", doc.path, doc.contents));
+        }
+    }
+    if (input.afterDocs.state === "available") {
+        for (const doc of input.afterDocs.value) {
+            add(sourceOf("after-document", doc.path, doc.contents));
+        }
+    }
+    return sources.sort((left, right) => left.reference.localeCompare(right.reference) ||
+        left.kind.localeCompare(right.kind));
+}
+/** One recorded change line: verb, path and artefact kind. */
+const WRITE_LINE = /^(?:added|modified|removed|created|deleted): (.+?) \([a-z]+\)$/;
+/**
+ * Extract changed paths from a recorded writes report. Only the report's
+ * change lines count: summary headers and repetition sections describe the
+ * same changes again and must not become phantom paths.
+ * @param writesText The report text.
+ * @returns The distinct changed paths, in report order.
+ */
+function changedPathsOf(writesText) {
+    const paths = new Set();
+    for (const line of writesText.split("\n")) {
+        const match = WRITE_LINE.exec(line.trim());
+        if (match?.[1] !== undefined)
+            paths.add(match[1]);
+    }
+    return [...paths];
+}
+/**
+ * Transient-wording findings over the answer and every changed document. The
+ * answer check needs the answer; the document check needs the after state.
+ * @param input The screen input.
+ * @param changedDocs The new or modified documents.
+ * @returns Advisory findings.
+ */
+function wordingFindings(input, changedDocs) {
+    const patterns = input.transientPatterns ?? [];
+    if (patterns.length === 0)
+        return [];
+    const counterexamples = input.durableCounterexamples ?? [];
+    const findings = [];
+    if (input.finalAnswer.state === "available") {
+        findings.push(...transientWordingFindings({
+            text: input.finalAnswer.value,
+            reference: "final.md",
+            kind: "final-response",
+            scenario: input.trial.scenario,
+            patterns,
+            counterexamples,
+        }));
+    }
+    for (const doc of changedDocs) {
+        findings.push(...transientWordingFindings({
+            text: doc.contents,
+            reference: doc.path,
+            kind: "resulting-document",
+            scenario: input.trial.scenario,
+            patterns,
+            counterexamples,
+        }));
+    }
+    return findings;
+}
+/**
+ * Permission findings, when the campaign records a policy and the writes are
+ * observable. Without either, out-of-policy mutation is unknown, not clean.
+ * @param input The screen input.
+ * @returns Mechanical findings for out-of-policy paths.
+ */
+function permissionFindingList(input) {
+    const policy = input.mutationPolicy;
+    if (policy === undefined || policy.allowed.length === 0)
+        return [];
+    if (input.writesText.state !== "available")
+        return [];
+    return permissionFindings({
+        changedPaths: changedPathsOf(input.writesText.value),
+        allowedGlobs: policy.allowed,
+        taskPrompt: input.taskPrompt.state === "available"
+            ? input.taskPrompt.value
+            : null,
+        visibleConstraints: policy.visibleConstraints,
+        writesText: input.writesText.value,
+        reference: "writes.txt",
+        scenario: input.trial.scenario,
+    });
+}
+/**
+ * Inventory findings over every candidate document.
+ * @param input The screen input.
+ * @param candidates The documents to scan.
+ * @returns Trigger and coverage-unknown findings.
+ */
+function inventoryFindingList(input, candidates) {
+    const inventory = input.inventory;
+    if (inventory === undefined)
+        return [];
+    return candidates.flatMap((doc) => {
+        const source = sourceOf("resulting-document", doc.path, doc.contents);
+        const scan = scanInventory(doc.contents, inventory);
+        const triggerList = scan.triggers.map((trigger) => triggerFinding(trigger, source, input.trial.scenario));
+        const coverageList = scan.missing.map((factId) => {
+            const fact = inventory.facts.find((entry) => entry.id === factId);
+            return coverageFinding(factId, fact?.label ?? factId, source, input.trial.scenario);
+        });
+        return [...triggerList, ...coverageList];
+    });
+}
+/**
+ * The documents a resulting-document rule should describe. With the after
+ * state observable but the before state absent, change is unknown and every
+ * after document is a candidate; with both states, only new or modified ones.
+ * @param before The before state, or null when unavailable.
+ * @param after The after state, or null when unavailable.
+ * @returns The candidate documents, or null when the after state is missing.
+ */
+function candidatesOf(before, after) {
+    if (after === null)
+        return null;
+    if (before === null)
+        return [...after];
+    const beforeByPath = new Map(before.map((doc) => [doc.path, doc.contents]));
+    return after.filter((doc) => beforeByPath.get(doc.path) !== doc.contents);
+}
+/**
+ * Structural findings, only when the resulting documents are observable.
+ * @param input The screen input.
+ * @param candidates The candidate documents, or null.
+ * @returns Structural findings.
+ */
+function structureFor(input, candidates) {
+    if (candidates === null)
+        return [];
+    return candidates.flatMap((doc) => structureFindings(doc, input.trial.scenario));
+}
+/**
+ * Claimed-mutation contradictions, only when both states are observable.
+ * @param input The screen input.
+ * @param before The before state, or null.
+ * @param after The after state, or null.
+ * @param answer The final answer, or null.
+ * @returns Contradiction findings.
+ */
+function mutationFor(input, before, after, answer) {
+    if (before === null || after === null || answer === null)
+        return [];
+    return claimMutationFindings({
+        answer,
+        changes: docChanges([...before], [...after]),
+        reference: "final.md",
+        scenario: input.trial.scenario,
+    });
+}
+/**
+ * Duplication findings, only when both states are observable.
+ * @param input The screen input.
+ * @param before The before state, or null.
+ * @param after The after state, or null.
+ * @returns Duplication findings.
+ */
+function duplicationFor(input, before, after) {
+    if (before === null || after === null)
+        return [];
+    return duplicationFindings([...before], [...after], input.trial.scenario);
+}
+/**
+ * Inventory findings, only when the resulting documents are observable.
+ * @param input The screen input.
+ * @param candidates The candidate documents, or null.
+ * @returns Inventory findings.
+ */
+function inventoryFor(input, candidates) {
+    if (candidates === null)
+        return [];
+    return inventoryFindingList(input, candidates);
+}
+/**
+ * Screen one recorded trial. Each rule sees only the evidence it needs: the
+ * after state for resulting-document rules, both states for mutation and
+ * duplication, the answer for response wording, and the writes plus a
+ * recorded policy for permissions.
+ * @param input Everything the screen reads.
+ * @returns Findings with provenance, hashed sources and the change state.
+ */
+export function screenTrial(input) {
+    const before = input.beforeDocs.state === "available" ? input.beforeDocs.value : null;
+    const after = input.afterDocs.state === "available" ? input.afterDocs.value : null;
+    const answer = input.finalAnswer.state === "available"
+        ? input.finalAnswer.value
+        : null;
+    const changes = before !== null && after !== null
+        ? docChanges([...before], [...after])
+        : null;
+    const candidates = candidatesOf(before, after);
+    const drafts = [
+        ...structureFor(input, candidates),
+        ...mutationFor(input, before, after, answer),
+        ...duplicationFor(input, before, after),
+        ...wordingFindings(input, candidates ?? []),
+        ...permissionFindingList(input),
+        ...inventoryFor(input, candidates),
+    ];
+    const findings = drafts
+        .map((draft) => withProvenance(draft, input))
+        .sort((left, right) => left.source.reference.localeCompare(right.source.reference) ||
+        left.span.start - right.span.start ||
+        left.ruleId.localeCompare(right.ruleId));
+    return { findings, sources: sourcesOf(input), changes };
+}

package/dist/evaluators/docs/analysis/selector.d.ts

@@ -0,0 +1,68 @@
+/**
+ * One frozen attempt selection shared by every consumer.
+ *
+ * The campaign manifest is the single declared source of which judge attempt
+ * the trial, judge, resolver, continuation and analyser read. A command-line
+ * override may agree with it or be absent; it may never contradict it. That
+ * refusal happens before a spawn or a ledger write, so a conflicting flag
+ * cannot spend money or mutate evidence.
+ */
+/** Where a selection came from. */
+export type SelectionSource = "default" | "manifest" | "override";
+/** One resolved attempt selection. */
+export interface AttemptSelection {
+    /** The selected attempt directory name, e.g. `attempt-002`. */
+    attemptId: string;
+    /** Which declaration produced it. */
+    source: SelectionSource;
+}
+/** The declarations a caller supplies. */
+export interface SelectionInput {
+    /** The manifest's `assessment.attemptId`, when declared. */
+    manifestAttemptId?: string | null | undefined;
+    /** A command-line override, when supplied. */
+    overrideAttemptId?: string | null | undefined;
+}
+/** The selection outcome. */
+export type SelectionResolution = {
+    ok: true;
+    selection: AttemptSelection;
+} | {
+    ok: false;
+    problems: string[];
+};
+/**
+ * Whether an attempt id has the accepted shape.
+ * @param attemptId The candidate id.
+ * @returns True for `attempt-NNN`.
+ */
+export declare function isAttemptId(attemptId: string): boolean;
+/** The default attempt id when nothing is declared. */
+export declare const DEFAULT_ATTEMPT_ID = "attempt-001";
+/**
+ * Resolve the single attempt selection.
+ *
+ * Precedence is: a valid manifest declaration wins; an override may agree with
+ * it but never contradict it. With no manifest declaration the selection
+ * defaults to `attempt-001`, unless the caller supplies an override — the
+ * legacy-freeze recovery path, where the frozen record names no attempt and an
+ * operator selects one explicitly. An invalid id or a contradiction returns
+ * problems and no selection, so callers refuse rather than guess.
+ * @param input The manifest declaration and any override.
+ * @returns The selection, or every problem found.
+ */
+export declare function resolveAttemptSelection(input: SelectionInput): SelectionResolution;
+/**
+ * The selection a recovery run may use. Recovery is a separate authorised
+ * budget and a separately identified analysis selection; it must never reuse
+ * the normal selection's attempt directory, and it must not rewrite the
+ * original freeze.
+ * @param input The manifest declaration and any recovery override.
+ * @param input.manifestAttemptId The frozen manifest selection, or null.
+ * @param input.recoveryAttemptId The explicit recovery selection.
+ * @returns The selection, or the refusal.
+ */
+export declare function resolveRecoverySelection(input: {
+    manifestAttemptId?: string | null;
+    recoveryAttemptId?: string | null;
+}): SelectionResolution;

package/dist/evaluators/docs/analysis/selector.js

@@ -0,0 +1,123 @@
+/**
+ * One frozen attempt selection shared by every consumer.
+ *
+ * The campaign manifest is the single declared source of which judge attempt
+ * the trial, judge, resolver, continuation and analyser read. A command-line
+ * override may agree with it or be absent; it may never contradict it. That
+ * refusal happens before a spawn or a ledger write, so a conflicting flag
+ * cannot spend money or mutate evidence.
+ */
+/** The attempt id shape every consumer accepts. */
+const ATTEMPT_PATTERN = /^attempt-\d{3}$/;
+/**
+ * Whether an attempt id has the accepted shape.
+ * @param attemptId The candidate id.
+ * @returns True for `attempt-NNN`.
+ */
+export function isAttemptId(attemptId) {
+    return ATTEMPT_PATTERN.test(attemptId);
+}
+/** The default attempt id when nothing is declared. */
+export const DEFAULT_ATTEMPT_ID = "attempt-001";
+/**
+ * Resolve the single attempt selection.
+ *
+ * Precedence is: a valid manifest declaration wins; an override may agree with
+ * it but never contradict it. With no manifest declaration the selection
+ * defaults to `attempt-001`, unless the caller supplies an override — the
+ * legacy-freeze recovery path, where the frozen record names no attempt and an
+ * operator selects one explicitly. An invalid id or a contradiction returns
+ * problems and no selection, so callers refuse rather than guess.
+ * @param input The manifest declaration and any override.
+ * @returns The selection, or every problem found.
+ */
+export function resolveAttemptSelection(input) {
+    const manifest = input.manifestAttemptId ?? null;
+    const override = input.overrideAttemptId ?? null;
+    const problems = selectionProblems(manifest, override);
+    if (problems.length > 0)
+        return { ok: false, problems };
+    if (manifest !== null) {
+        return {
+            ok: true,
+            selection: { attemptId: manifest, source: "manifest" },
+        };
+    }
+    if (override !== null) {
+        return {
+            ok: true,
+            selection: { attemptId: override, source: "override" },
+        };
+    }
+    return {
+        ok: true,
+        selection: { attemptId: DEFAULT_ATTEMPT_ID, source: "default" },
+    };
+}
+/**
+ * Validate the declared ids and their agreement.
+ * @param manifest The manifest attempt id, or null.
+ * @param override The override attempt id, or null.
+ * @returns Problems; empty means the selection is unambiguous.
+ */
+function selectionProblems(manifest, override) {
+    const problems = [];
+    if (manifest !== null && !isAttemptId(manifest)) {
+        problems.push(`manifest attemptId ${JSON.stringify(manifest)} must match attempt-NNN`);
+    }
+    if (override !== null && !isAttemptId(override)) {
+        problems.push(`override attemptId ${JSON.stringify(override)} must match attempt-NNN`);
+    }
+    if (manifest !== null && override !== null && manifest !== override) {
+        problems.push(`conflicting attempt selections: manifest ${manifest} and override ${override}`);
+    }
+    return problems;
+}
+/**
+ * The selection a recovery run may use. Recovery is a separate authorised
+ * budget and a separately identified analysis selection; it must never reuse
+ * the normal selection's attempt directory, and it must not rewrite the
+ * original freeze.
+ * @param input The manifest declaration and any recovery override.
+ * @param input.manifestAttemptId The frozen manifest selection, or null.
+ * @param input.recoveryAttemptId The explicit recovery selection.
+ * @returns The selection, or the refusal.
+ */
+export function resolveRecoverySelection(input) {
+    const manifest = input.manifestAttemptId ?? null;
+    const recovery = input.recoveryAttemptId ?? null;
+    if (recovery === null) {
+        return {
+            ok: false,
+            problems: ["recovery requires an explicit attempt id"],
+        };
+    }
+    if (!isAttemptId(recovery)) {
+        return {
+            ok: false,
+            problems: [
+                `recovery attemptId ${JSON.stringify(recovery)} must match attempt-NNN`,
+            ],
+        };
+    }
+    if (manifest !== null && ordinal(recovery) <= ordinal(manifest)) {
+        return {
+            ok: false,
+            problems: [
+                `recovery selection ${recovery} must be a later attempt than the frozen manifest selection ${manifest}`,
+            ],
+        };
+    }
+    return {
+        ok: true,
+        selection: { attemptId: recovery, source: "override" },
+    };
+}
+/**
+ * The numeric ordinal of an attempt id.
+ * @param attemptId An id of the accepted shape.
+ * @returns The parsed number.
+ */
+function ordinal(attemptId) {
+    return Number(attemptId.slice("attempt-".length));
+}

package/dist/evaluators/docs/assess.d.ts

@@ -0,0 +1,129 @@
+import type { SuiteCase } from "../../contracts/types.ts";
+import { type Usage } from "../../adapters/opencode/events.ts";
+import { type JournalVerification } from "./journal.ts";
+import { type PrimaryCheckRecord } from "../../campaign/primary.ts";
+/** The one docs case shape. */
+type DocsCase = Extract<SuiteCase, {
+    kind: "docs-task";
+}>;
+/** The evidence states the deterministic docs evaluator can establish. */
+export type DocsValidity = "valid" | "invalid" | "unknown" | "unrun";
+/** The deterministic docs criterion verdict. */
+export type DocsOutcome = "pass" | "fail" | "unknown";
+/** The docs operation a journal record proves. */
+export type DocsVerb = "search" | "add" | "read" | "check" | "help" | "other";
+/** Exact counts, with attempted and verified writes kept distinct. */
+export interface DocsCounts {
+    /** The credited calls value. */
+    creditedCalls: number;
+    /** The credited writes value. */
+    creditedWrites: number;
+    /** The attempted writes value. */
+    attemptedWrites: number;
+    /** The rejected lines value. */
+    rejectedLines: number;
+    /** The search calls value. */
+    searchCalls: number;
+}
+/** The deterministic assessment of one docs-recording trial. */
+export interface DocsAssessment {
+    /** The schema version value. */
+    schemaVersion: 1;
+    /** The kind value. */
+    kind: "docs-recording";
+    /** The campaign id value. */
+    campaignId: string;
+    /** The slot id value. */
+    slotId: string;
+    /** The case id value. */
+    caseId: string;
+    /** The arm id value. */
+    armId: string;
+    /** The repetition id value. */
+    repetitionId: string;
+    /** The attempt id value. */
+    attemptId: string;
+    /** The expected value. */
+    expected: DocsCase["expectedDocs"]["kind"];
+    /** The validity value. */
+    validity: DocsValidity;
+    /** The outcome value. */
+    outcome: DocsOutcome;
+    /** The counts value. */
+    counts: DocsCounts;
+    /** The journal value. */
+    journal: {
+        state: JournalVerification["state"];
+        credited: number;
+        rejected: number;
+        problems: string[];
+    };
+    /** The target value. */
+    target: string | null;
+    /** The independent primary-check result, or null when none was declared. */
+    primary: {
+        id: string;
+        status: PrimaryCheckRecord["status"];
+        exit: number | null;
+    } | null;
+    /** The reasons value. */
+    reasons: string[];
+    /** The usage value. */
+    usage: Usage | null;
+    /** The answered value. */
+    answered: boolean;
+    /** The assessed at value. */
+    assessedAt: string;
+}
+/** Determine which docs verb one host input names. */
+export declare function docsVerbOf(input: unknown): DocsVerb;
+/** Whether a credited record proves a completed write and where. */
+export declare function creditedWriteOf(record: Record<string, unknown>): {
+    path: string | null;
+    mode: string | null;
+} | null;
+/**
+ * Assess one docs-recording trial from the signed journal and the uploaded
+ * workspace. The journal is the only route that credits a served operation;
+ * an attempted but refused write retains zero recording credit.
+ * @param options Trial identity, case definition, evidence and workspace.
+ * @returns The assessment.
+ * @param options.campaignId The campaignId value.
+ * @param options.slotId The slotId value.
+ * @param options.caseId The caseId value.
+ * @param options.armId The armId value.
+ * @param options.repetitionId The repetitionId value.
+ * @param options.testCase The testCase value.
+ * @param options.trialDir The trialDir value.
+ * @param options.workspace The workspace value.
+ * @param options.prepared The prepared value.
+ * @param options.attemptId The attemptId value.
+ * @param options.assessedAt The assessedAt value.
+ */
+export declare function assessDocsTrial(options: {
+    campaignId: string;
+    slotId: string;
+    caseId: string;
+    armId: string;
+    repetitionId: string;
+    testCase: DocsCase;
+    trialDir: string;
+    workspace: string;
+    prepared: ReadonlyMap<string, string>;
+    attemptId: string;
+    assessedAt: string;
+}): DocsAssessment;
+/** The compact journal summary a report carries. */
+export declare function journalSummary(verification: JournalVerification): DocsAssessment["journal"];
+/**
+ * The judge-visible docs operations for one trial: credited journal records
+ * only. An unattributable journal yields no lines and an explicit problem.
+ * @param trialDir The trial evidence directory.
+ * @returns The rendered operations and the verification state.
+ */
+export declare function creditedOperationLines(trialDir: string): {
+    state: JournalVerification["state"];
+    lines: string[];
+    problems: string[];
+};
+export {};