@alisio/core 0.7.0 → 0.8.0

package/dist/proof/store.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Persistence of the Proof ledger (tables `proof_criteria` and `proof_evidence`, schema v11).
+ *
+ * Evidence is append-only: there is no update path here and a database trigger rejects UPDATE;
+ * rows disappear only with their session (`ON DELETE CASCADE`). The status is never stored (D4):
+ * `ledger()` derives it on every read.
+ */
+import type { ProofEvidence, ProofLedger, SqlDatabase } from "@alisio/sdk";
+import type { CriterionRecord, NewCriterion, NewEvidence } from "./types.ts";
+export declare class ProofStore {
+    private readonly db;
+    constructor(db: SqlDatabase);
+    addCriterion(input: NewCriterion): CriterionRecord;
+    criterion(criterionId: string): CriterionRecord | undefined;
+    /** The criteria of a session in creation order, without any derived field. */
+    criteria(sessionId: string): CriterionRecord[];
+    /** How many criteria a session has (one indexed count; the stream snapshot uses it). */
+    criteriaCount(sessionId: string): number;
+    /** Marks a criterion not applicable. Callers must be the user, never a tool result (O2). */
+    markNotApplicable(criterionId: string, reason: string): void;
+    /**
+     * The user edits a criterion. Only the wording and the required flag change: the verifier and
+     * the scope stay, so the evidence already captured keeps meaning what it meant (add a new
+     * criterion to check something else). Callers must be the user, never a tool result (O2).
+     */
+    updateCriterion(criterionId: string, change: {
+        text?: string;
+        required?: boolean;
+    }): CriterionRecord | undefined;
+    /**
+     * The unbacked claims the last COMPLETED run of the session warned about (`proof_divergence`
+     * events of the event journal). A later run that completes without a warning clears them.
+     * Display only (D8): nothing here changes a status.
+     */
+    divergences(sessionId: string): ProofLedger["divergences"];
+    /** Appends one immutable evidence (D2: it must name its run and its call). */
+    appendEvidence(input: NewEvidence): ProofEvidence;
+    /**
+     * Notes a successful edit of a workspace-relative path (D5). One row per path keeps the newest
+     * time, so the table is bounded by the files touched and an older time never rewinds it.
+     */
+    recordEdit(sessionId: string, path: string, editedAt: string): void;
+    /** The files edited in a session with the time of their latest edit, sorted by path. */
+    edits(sessionId: string): Array<{
+        path: string;
+        editedAt: string;
+    }>;
+    /** The ledger of a session with every status derived now (D4). */
+    ledger(sessionId: string, now?: string): ProofLedger;
+    /** The ledger every surface shows: `ledger()` plus the divergences of the last completed run. */
+    view(sessionId: string, now?: string): ProofLedger;
+}

package/dist/proof/store.js

@@ -0,0 +1,192 @@
+import { newId } from "../runtime/ids.js";
+import { buildLedger } from "./ledger.js";
+import { scopeMatches } from "./scope.js";
+const str = (value) => value === null || value === undefined ? undefined : String(value);
+function json(raw) {
+    if (typeof raw !== "string" || !raw)
+        return undefined;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function criterionFromRow(row) {
+    const goalId = str(row.goal_id);
+    const verifier = json(row.verifier_json);
+    const scope = json(row.scope_json);
+    const notApplicableReason = str(row.na_reason);
+    return {
+        criterionId: String(row.criterion_id),
+        sessionId: String(row.session_id),
+        ...(goalId ? { goalId } : {}),
+        text: String(row.text),
+        required: Number(row.required) === 1,
+        origin: String(row.origin),
+        ...(verifier ? { verifier } : {}),
+        ...(scope ? { scope } : {}),
+        ...(notApplicableReason ? { notApplicableReason } : {}),
+    };
+}
+function evidenceFromRow(row) {
+    const commandFingerprint = str(row.fingerprint);
+    const exitCode = row.exit_code === null || row.exit_code === undefined ? undefined : Number(row.exit_code);
+    const excerpt = str(row.excerpt);
+    return {
+        evidenceId: String(row.evidence_id),
+        criterionId: String(row.criterion_id),
+        verifierKind: String(row.verifier_kind),
+        runId: String(row.run_id),
+        callId: String(row.call_id),
+        ok: Number(row.ok) === 1,
+        ...(commandFingerprint ? { commandFingerprint } : {}),
+        ...(exitCode !== undefined ? { exitCode } : {}),
+        durationMs: Number(row.duration_ms),
+        outputHash: String(row.output_hash),
+        ...(excerpt !== undefined ? { excerpt } : {}),
+        treeFingerprint: String(row.tree_fingerprint),
+        filesTouched: json(row.files_json) ?? [],
+        capturedAt: String(row.captured_at),
+    };
+}
+export class ProofStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    addCriterion(input) {
+        const criterionId = newId("crit");
+        this.db
+            .prepare(`INSERT INTO proof_criteria(criterion_id,session_id,goal_id,text,required,origin,verifier_json,scope_json,created_at)
+         VALUES(?,?,?,?,?,?,?,?,?)`)
+            .run(criterionId, input.sessionId, input.goalId ?? null, input.text, input.required ? 1 : 0, input.origin, input.verifier ? JSON.stringify(input.verifier) : null, input.scope ? JSON.stringify(input.scope) : null, Date.now());
+        return this.criterion(criterionId);
+    }
+    criterion(criterionId) {
+        const row = this.db
+            .prepare("SELECT * FROM proof_criteria WHERE criterion_id=?")
+            .get(criterionId);
+        return row ? criterionFromRow(row) : undefined;
+    }
+    /** The criteria of a session in creation order, without any derived field. */
+    criteria(sessionId) {
+        return this.db
+            .prepare("SELECT * FROM proof_criteria WHERE session_id=? ORDER BY created_at, rowid")
+            .all(sessionId)
+            .map(criterionFromRow);
+    }
+    /** How many criteria a session has (one indexed count; the stream snapshot uses it). */
+    criteriaCount(sessionId) {
+        const row = this.db
+            .prepare("SELECT COUNT(*) AS n FROM proof_criteria WHERE session_id=?")
+            .get(sessionId);
+        return Number(row?.n ?? 0);
+    }
+    /** Marks a criterion not applicable. Callers must be the user, never a tool result (O2). */
+    markNotApplicable(criterionId, reason) {
+        const trimmed = reason.trim();
+        if (!trimmed)
+            throw new Error("not_applicable requires a reason");
+        const result = this.db
+            .prepare("UPDATE proof_criteria SET na_reason=? WHERE criterion_id=?")
+            .run(trimmed, criterionId);
+        if (Number(result.changes) === 0)
+            throw new Error(`unknown criterion: ${criterionId}`);
+    }
+    /**
+     * The user edits a criterion. Only the wording and the required flag change: the verifier and
+     * the scope stay, so the evidence already captured keeps meaning what it meant (add a new
+     * criterion to check something else). Callers must be the user, never a tool result (O2).
+     */
+    updateCriterion(criterionId, change) {
+        const text = change.text === undefined ? undefined : change.text.replace(/\s+/g, " ").trim();
+        if (text !== undefined && !text)
+            throw new Error("a criterion needs text");
+        if (!this.criterion(criterionId))
+            return undefined;
+        if (text !== undefined)
+            this.db
+                .prepare("UPDATE proof_criteria SET text=? WHERE criterion_id=?")
+                .run(text, criterionId);
+        if (change.required !== undefined)
+            this.db
+                .prepare("UPDATE proof_criteria SET required=? WHERE criterion_id=?")
+                .run(change.required ? 1 : 0, criterionId);
+        return this.criterion(criterionId);
+    }
+    /**
+     * The unbacked claims the last COMPLETED run of the session warned about (`proof_divergence`
+     * events of the event journal). A later run that completes without a warning clears them.
+     * Display only (D8): nothing here changes a status.
+     */
+    divergences(sessionId) {
+        const last = this.db
+            .prepare("SELECT run_id FROM events WHERE session=? AND type='run_completed' ORDER BY seq DESC LIMIT 1")
+            .get(sessionId);
+        if (!last)
+            return [];
+        return this.db
+            .prepare("SELECT body FROM events WHERE session=? AND run_id=? AND type='proof_divergence' ORDER BY seq")
+            .all(sessionId, String(last.run_id))
+            .flatMap((row) => {
+            const body = json(row.body);
+            return body ? [body] : [];
+        });
+    }
+    /** Appends one immutable evidence (D2: it must name its run and its call). */
+    appendEvidence(input) {
+        if (!input.runId || !input.callId)
+            throw new Error("evidence requires runId and callId");
+        const evidenceId = newId("ev");
+        this.db
+            .prepare(`INSERT INTO proof_evidence(evidence_id,criterion_id,run_id,call_id,ok,verifier_kind,fingerprint,exit_code,
+           duration_ms,output_hash,excerpt,tree_fingerprint,files_json,captured_at)
+         VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)
+            .run(evidenceId, input.criterionId, input.runId, input.callId, input.ok ? 1 : 0, input.verifierKind, input.commandFingerprint ?? null, input.exitCode ?? null, input.durationMs, input.outputHash, input.excerpt ?? null, input.treeFingerprint, JSON.stringify(input.filesTouched), input.capturedAt);
+        return { ...input, evidenceId };
+    }
+    /**
+     * Notes a successful edit of a workspace-relative path (D5). One row per path keeps the newest
+     * time, so the table is bounded by the files touched and an older time never rewinds it.
+     */
+    recordEdit(sessionId, path, editedAt) {
+        this.db
+            .prepare(`INSERT INTO proof_edits(session_id,path,edited_at) VALUES(?,?,?)
+         ON CONFLICT(session_id,path) DO UPDATE SET edited_at=excluded.edited_at
+         WHERE excluded.edited_at > proof_edits.edited_at`)
+            .run(sessionId, path, editedAt);
+    }
+    /** The files edited in a session with the time of their latest edit, sorted by path. */
+    edits(sessionId) {
+        return this.db
+            .prepare("SELECT path,edited_at FROM proof_edits WHERE session_id=? ORDER BY path")
+            .all(sessionId)
+            .map((row) => ({ path: String(row.path), editedAt: String(row.edited_at) }));
+    }
+    /** The ledger of a session with every status derived now (D4). */
+    ledger(sessionId, now = new Date().toISOString()) {
+        const criteria = this.criteria(sessionId);
+        const evidence = this.db
+            .prepare(`SELECT e.* FROM proof_evidence e JOIN proof_criteria c ON c.criterion_id=e.criterion_id
+         WHERE c.session_id=? ORDER BY e.rowid`)
+            .all(sessionId)
+            .map(evidenceFromRow);
+        const edits = this.edits(sessionId);
+        const lastEditAt = (criterion) => {
+            let latest;
+            for (const edit of edits) {
+                if (!scopeMatches(criterion.scope, edit.path))
+                    continue;
+                if (latest === undefined || Date.parse(edit.editedAt) > Date.parse(latest))
+                    latest = edit.editedAt;
+            }
+            return latest;
+        };
+        return buildLedger(sessionId, criteria, evidence, { now, lastEditAt });
+    }
+    /** The ledger every surface shows: `ledger()` plus the divergences of the last completed run. */
+    view(sessionId, now) {
+        return { ...this.ledger(sessionId, now), divergences: this.divergences(sessionId) };
+    }
+}

package/dist/proof/tree.d.ts

@@ -0,0 +1,6 @@
+/** Bytes of `git diff` that are read; the rest of a larger diff is not hashed. */
+export declare const MAX_DIFF_BYTES = 1048576;
+/** Touched files that enter the fingerprint (sorted, so the cut is deterministic). */
+export declare const MAX_FINGERPRINT_FILES = 200;
+/** The fingerprint of the tree at `workspace` given the files the session touched. */
+export declare function treeFingerprint(workspace: string, filesTouched: readonly string[]): string;

package/dist/proof/tree.js

@@ -0,0 +1,78 @@
+/**
+ * Tree fingerprint of a Proof evidence (specs/011 3.4, D5, section 7): a hash of a bounded
+ * `git diff` plus the sha256 of the files the session touched. It is an audit anchor stored with
+ * the evidence, not the expiry mechanism (expiry reads the recorded edit times). Deterministic for
+ * a given tree, bounded in cost, and safe outside git: no repository or no `git` binary just
+ * means the diff part is a constant.
+ */
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
+/** Bytes of `git diff` that are read; the rest of a larger diff is not hashed. */
+export const MAX_DIFF_BYTES = 1_048_576;
+/** Files larger than this are fingerprinted by size only. */
+const MAX_FILE_BYTES = 1_048_576;
+/** Touched files that enter the fingerprint (sorted, so the cut is deterministic). */
+export const MAX_FINGERPRINT_FILES = 200;
+const GIT_TIMEOUT_MS = 3_000;
+const HASH_CACHE_MAX = 512;
+const sha256 = (data) => createHash("sha256").update(data).digest("hex");
+/** File hashes by `path|size|mtime`: an unchanged file is never read twice. */
+const fileHashes = new Map();
+function fileDigest(workspace, path) {
+    const absolute = resolve(workspace, path);
+    const rel = relative(workspace, absolute);
+    if (rel.startsWith("..") || isAbsolute(rel))
+        return "outside";
+    try {
+        const info = statSync(absolute);
+        if (!info.isFile())
+            return "missing";
+        if (info.size > MAX_FILE_BYTES)
+            return `large:${info.size}`;
+        const key = `${absolute}\u0000${info.size}\u0000${info.mtimeMs}`;
+        const known = fileHashes.get(key);
+        if (known !== undefined)
+            return known;
+        const digest = sha256(readFileSync(absolute));
+        if (fileHashes.size >= HASH_CACHE_MAX)
+            fileHashes.clear();
+        fileHashes.set(key, digest);
+        return digest;
+    }
+    catch {
+        return "missing";
+    }
+}
+/** Digest of the working-tree diff against HEAD, or a constant when git cannot answer. */
+function diffDigest(workspace) {
+    const run = (args) => spawnSync("git", ["--no-pager", ...args], {
+        cwd: workspace,
+        maxBuffer: MAX_DIFF_BYTES,
+        timeout: GIT_TIMEOUT_MS,
+        env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0" },
+        windowsHide: true,
+    });
+    const flags = ["--no-ext-diff", "--no-textconv", "--no-color", "--no-renames"];
+    let result = run(["diff", ...flags, "HEAD", "--"]);
+    // A repository with no commit has no HEAD: fall back to the index.
+    if (result.status !== 0 &&
+        /bad revision|unknown revision|ambiguous argument/.test(String(result.stderr)))
+        result = run(["diff", ...flags, "--"]);
+    const out = result.stdout;
+    const overflow = result.error !== undefined && Buffer.isBuffer(out) && out.length > 0;
+    if (!overflow && (result.error || result.status !== 0 || !Buffer.isBuffer(out)))
+        return "nogit";
+    const bytes = out.subarray(0, MAX_DIFF_BYTES);
+    return `${overflow ? "truncated:" : "full:"}${sha256(bytes)}`;
+}
+/** The fingerprint of the tree at `workspace` given the files the session touched. */
+export function treeFingerprint(workspace, filesTouched) {
+    const files = [...new Set(filesTouched)].sort().slice(0, MAX_FINGERPRINT_FILES);
+    return sha256(JSON.stringify({
+        v: 1,
+        diff: diffDigest(workspace),
+        files: files.map((file) => [file, fileDigest(workspace, file)]),
+    }));
+}

package/dist/proof/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Core-side shapes of the Proof ledger (specs/011). The wire types (`ProofCriterion`,
+ * `ProofEvidence`, `ProofLedger`) live in `@alisio/sdk`; these are what the store keeps before the
+ * status is derived (D4: the status is never stored).
+ */
+import type { ProofCriterion, ProofEvidence } from "@alisio/sdk";
+/** A criterion as persisted: the wire shape without the derived fields. */
+export type CriterionRecord = Omit<ProofCriterion, "status" | "stale" | "evidenceIds">;
+/** What a caller supplies to create a criterion. */
+export interface NewCriterion {
+    sessionId: string;
+    text: string;
+    origin: ProofCriterion["origin"];
+    /** Defaults to false. */
+    required?: boolean;
+    goalId?: string;
+    verifier?: ProofCriterion["verifier"];
+    scope?: string[];
+}
+/** What a caller supplies to append evidence: the store assigns `evidenceId`. */
+export type NewEvidence = Omit<ProofEvidence, "evidenceId">;

package/dist/proof/types.js

@@ -0,0 +1 @@
+export {};

package/dist/proof/verifiers.d.ts

@@ -0,0 +1,46 @@
+import type { ProofVerifierSpec } from "@alisio/sdk";
+export type FileSpec = Extract<ProofVerifierSpec, {
+    kind: "file";
+}>;
+export type DataCheckSpec = Extract<ProofVerifierSpec, {
+    kind: "data-check";
+}>;
+/** A core tool call that makes a verifier's evidence appear when it runs. */
+export interface VerifierCall {
+    name: string;
+    input: Record<string, unknown>;
+}
+/** What a judge concluded: the verdict and a short, secret-free sentence about it. */
+export interface Judgement {
+    ok: boolean;
+    summary: string;
+}
+/** The single SQL statement whose result decides a `data-check` (no column: no verdict). */
+export declare function canonicalSql(spec: DataCheckSpec): string | undefined;
+/**
+ * Case, quoting, spacing and a trailing `;` do not change a canonical query. Identifiers with
+ * quotes or case differences collapse, which is what SQLite does with them anyway.
+ */
+export declare function normalizeSql(sql: string): string;
+/**
+ * The tool call an on-demand verification runs for this spec, or undefined when the spec cannot
+ * be checked by one (`manual`, `command`, `plugin`, or a data-check missing its column).
+ */
+export declare function verifierCall(spec: ProofVerifierSpec): VerifierCall | undefined;
+/** Workspace-relative POSIX path, or undefined when it leaves the workspace. */
+export declare function workspacePath(workspace: string, path: string): string | undefined;
+/** Does a `read_file` call (by its input) read the file this criterion names? */
+export declare function readsFile(spec: FileSpec, inputPath: unknown, workspace: string): boolean;
+/** Does a `data_query` call (by its input) run the canonical query of this criterion? */
+export declare function runsCanonicalQuery(spec: DataCheckSpec, input: Record<string, unknown>): boolean;
+/**
+ * Judges a successful `read_file` result against a `file` criterion: existence, sha256 and a
+ * regex over the content (line anchors work: the pattern runs with the `m` flag). A refutation
+ * needs the whole file in view; a window that starts after line 1 or stops early can only
+ * confirm a match.
+ */
+export declare function judgeFile(spec: FileSpec, body: Record<string, unknown>): Judgement | undefined;
+/** `read_file` failed because the file is not there: the criterion is refuted. */
+export declare function judgeMissingFile(errorText: string): Judgement | undefined;
+/** Judges the result text of the canonical query of a `data-check` criterion. */
+export declare function judgeDataCheck(spec: DataCheckSpec, text: string): Judgement | undefined;

package/dist/proof/verifiers.js

@@ -0,0 +1,176 @@
+/**
+ * Pure judgements of the `file` and `data-check` verifiers (specs/011 3.1, D3). They read the
+ * RAW result of a core tool call (`read_file`, `data_query`) and say whether the criterion holds;
+ * they never touch the filesystem or a dataset themselves, so the only inputs that count are the
+ * structured results of calls the runner really executed under its gate (D6).
+ *
+ * `undefined` from a judge means "this call cannot decide": a window of a file that does not
+ * start at line 1, a scalar that is not a number. No evidence is better than a guess.
+ */
+import { isAbsolute, relative, resolve, sep } from "node:path";
+const DEFAULT_TABLE = "data";
+/** Lines a pattern read asks for; `read_file` caps a window at 1000 lines. */
+const PATTERN_LINES = 1000;
+const NUMBER_TOLERANCE = 1e-9;
+const quote = (identifier) => `"${identifier.replaceAll('"', '""')}"`;
+/** The single SQL statement whose result decides a `data-check` (no column: no verdict). */
+export function canonicalSql(spec) {
+    const from = `FROM ${quote(spec.table ?? DEFAULT_TABLE)}`;
+    if (spec.check === "row_count")
+        return `SELECT COUNT(*) ${from}`;
+    if (!spec.column)
+        return undefined;
+    // TOTAL() is 0.0 over no rows where SUM() would be NULL.
+    if (spec.check === "sum")
+        return `SELECT TOTAL(${quote(spec.column)}) ${from}`;
+    if (spec.check === "equals")
+        return `SELECT DISTINCT ${quote(spec.column)} ${from} LIMIT 2`;
+    return undefined;
+}
+/**
+ * Case, quoting, spacing and a trailing `;` do not change a canonical query. Identifiers with
+ * quotes or case differences collapse, which is what SQLite does with them anyway.
+ */
+export function normalizeSql(sql) {
+    return sql
+        .replaceAll('"', "")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/\s*;+$/, "")
+        .toLowerCase();
+}
+/**
+ * The tool call an on-demand verification runs for this spec, or undefined when the spec cannot
+ * be checked by one (`manual`, `command`, `plugin`, or a data-check missing its column).
+ */
+export function verifierCall(spec) {
+    if (spec.kind === "file")
+        return {
+            name: "read_file",
+            input: { path: spec.path, limit: spec.pattern ? PATTERN_LINES : 1 },
+        };
+    // The configured coverage command, as the `shell` call whose raw result the recorder judges.
+    if (spec.kind === "coverage")
+        return { name: "shell", input: { command: spec.command } };
+    if (spec.kind === "data-check") {
+        const sql = canonicalSql(spec);
+        return sql ? { name: "data_query", input: { datasetId: spec.datasetId, sql } } : undefined;
+    }
+    return undefined;
+}
+/** Workspace-relative POSIX path, or undefined when it leaves the workspace. */
+export function workspacePath(workspace, path) {
+    const rel = relative(workspace, resolve(workspace, path));
+    if (!rel || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+        return undefined;
+    return rel.split(sep).join("/");
+}
+/** Does a `read_file` call (by its input) read the file this criterion names? */
+export function readsFile(spec, inputPath, workspace) {
+    if (typeof inputPath !== "string")
+        return false;
+    const wanted = workspacePath(workspace, spec.path);
+    return wanted !== undefined && wanted === workspacePath(workspace, inputPath);
+}
+/** Does a `data_query` call (by its input) run the canonical query of this criterion? */
+export function runsCanonicalQuery(spec, input) {
+    const canonical = canonicalSql(spec);
+    return (canonical !== undefined &&
+        input.datasetId === spec.datasetId &&
+        typeof input.sql === "string" &&
+        normalizeSql(input.sql) === normalizeSql(canonical));
+}
+const LINE_PREFIX = /^\d+: ?/;
+/** The text of a `read_file` window without its `N: ` line prefixes. */
+function plainContent(content) {
+    return content
+        .split("\n")
+        .map((line) => line.replace(LINE_PREFIX, ""))
+        .join("\n");
+}
+function patternMatches(pattern, text) {
+    try {
+        return new RegExp(pattern, "m").test(text);
+    }
+    catch {
+        return false; // an unusable pattern never verifies anything
+    }
+}
+/**
+ * Judges a successful `read_file` result against a `file` criterion: existence, sha256 and a
+ * regex over the content (line anchors work: the pattern runs with the `m` flag). A refutation
+ * needs the whole file in view; a window that starts after line 1 or stops early can only
+ * confirm a match.
+ */
+export function judgeFile(spec, body) {
+    const parts = ["exists"];
+    let undecided = false;
+    if (spec.sha256 !== undefined) {
+        if (typeof body.sha256 !== "string")
+            undecided = true; // too large to hash
+        else if (body.sha256.toLowerCase() !== spec.sha256.toLowerCase())
+            return { ok: false, summary: `sha256 differs (found ${body.sha256})` };
+        else
+            parts.push("sha256 matches");
+    }
+    if (spec.pattern !== undefined) {
+        const content = typeof body.content === "string" ? plainContent(body.content) : "";
+        if (patternMatches(spec.pattern, content))
+            parts.push("pattern matched");
+        else if (body.truncated === false && body.startLine === 1)
+            return { ok: false, summary: "pattern not found" };
+        else
+            undecided = true;
+    }
+    return undecided ? undefined : { ok: true, summary: parts.join("; ") };
+}
+/** `read_file` failed because the file is not there: the criterion is refuted. */
+export function judgeMissingFile(errorText) {
+    return /^File not found\b/.test(errorText) ? { ok: false, summary: "file not found" } : undefined;
+}
+/** A `data_query` text result: header, rows (tab separated) and the `[N rows…]` summary. */
+function parseQuery(text) {
+    const lines = text.split("\n");
+    const summary = lines.at(-1) ?? "";
+    if (lines.length < 2 || !/^\[[\d,]+ rows?/.test(summary))
+        return undefined;
+    return { rows: lines.slice(1, -1), cut: /truncated|shortened/.test(summary) };
+}
+const numeric = (cell) => {
+    if (cell === undefined || cell.trim() === "")
+        return undefined;
+    const value = Number(cell);
+    return Number.isFinite(value) ? value : undefined;
+};
+const sameNumber = (a, b) => Math.abs(a - b) <= NUMBER_TOLERANCE * Math.max(1, Math.abs(b));
+/** Judges the result text of the canonical query of a `data-check` criterion. */
+export function judgeDataCheck(spec, text) {
+    const parsed = parseQuery(text);
+    if (!parsed || parsed.cut)
+        return undefined;
+    const { rows } = parsed;
+    if (spec.check === "equals") {
+        if (rows.length === 0)
+            return { ok: false, summary: "equals: the column has no values" };
+        if (rows.length > 1)
+            return { ok: false, summary: "equals: the column has several values" };
+        const actual = rows[0] ?? "";
+        const expected = String(spec.expected);
+        const ok = actual === expected ||
+            (numeric(actual) !== undefined &&
+                numeric(expected) !== undefined &&
+                sameNumber(numeric(actual), numeric(expected)));
+        return { ok, summary: `equals ${spec.column}: actual ${actual}, expected ${expected}` };
+    }
+    if (rows.length !== 1)
+        return undefined;
+    const actual = numeric(rows[0]);
+    if (actual === undefined)
+        return undefined;
+    const expected = numeric(String(spec.expected));
+    const label = spec.check === "sum" ? `sum of ${spec.column}` : "row_count";
+    return {
+        ok: expected !== undefined && sameNumber(actual, expected),
+        summary: `${label}: actual ${actual}, expected ${spec.expected}`,
+    };
+}

package/dist/proof/verify.d.ts

@@ -0,0 +1,36 @@
+import type { ProofStatus, SqlDatabase, ToolResult } from "@alisio/sdk";
+import type { ProofVerifierRegistry } from "./plugin-verifiers.ts";
+import type { ProofStore } from "./store.ts";
+export interface VerifyDeps {
+    store: ProofStore;
+    registry: ProofVerifierRegistry;
+    db: SqlDatabase;
+    /** Runs one core tool call as a run of the session, through the same gate as a model call. */
+    callTool(sessionId: string, name: string, input: Record<string, unknown>, signal: AbortSignal): Promise<{
+        callId: string;
+        runId: string;
+        result: ToolResult;
+    }>;
+    /** `proof.coverage.enabled`: without it a `coverage` verifier never runs its command. */
+    coverage?: () => boolean;
+    /** Time a plugin verifier may take; 60 s by default. */
+    timeoutMs?: number;
+    now?: () => Date;
+}
+export interface VerifyRequest {
+    sessionId: string;
+    criterionId: string;
+    workspace: string;
+    signal?: AbortSignal;
+}
+export interface VerifyOutcome {
+    criterionId: string;
+    /** The criterion's derived status after the attempt. */
+    status: ProofStatus;
+    evidenceId?: string;
+    /** Why nothing (or only a degradation) was recorded; absent when evidence was captured. */
+    reason?: "unknown_criterion" | "not_applicable" | "no_verifier" | "unsupported_verifier" | "unverifiable_spec" | "coverage_disabled" | "no_evidence" | "verifier_unavailable" | "verifier_failed" | "no_referenceable_evidence";
+    /** Redacted, bounded detail of a failure. */
+    detail?: string;
+}
+export declare function verifyCriterion(deps: VerifyDeps, request: VerifyRequest): Promise<VerifyOutcome>;