/**
 * Memory claim verdicts (change: add-memory-claim-verdicts).
 *
 * A memory's anchor can stay byte-identical while a fact it asserts stops being true ("`helper`
 * is dead" — until someone calls it). A memory can therefore carry structural claims in
 * `verify_claim`'s grammar. `remember` refuses a claim that is not confirmed when recorded, and
 * `recall` checks each claim again against the current graph:
 *
 *   confirmed    → `evidence-holds`
 *   refuted      → `evidence-refuted`     (the memory leaves the authoritative set)
 *   unverifiable → `evidence-unverifiable` (the memory leaves the authoritative set)
 *
 * Each check is `handleVerifyClaim` itself — the same verdict and receipt a human would get — so
 * there is no second claim evaluator to drift from the first. No LLM. The verifier is loaded lazily:
 * the shape check below runs on light paths (the prompt hook) that never check a claim.
 */
import type { MemoryClaim } from '../../../types/index.js';
/** Most claims one memory may carry: every recall re-checks each one. */
export declare const MAX_MEMORY_CLAIMS = 10;
export type ClaimEvidence = 'evidence-holds' | 'evidence-refuted' | 'evidence-unverifiable';
export interface ClaimCheck {
    kind: MemoryClaim['kind'];
    subject: string;
    object?: string;
    verdict: ClaimEvidence;
    reason: string;
    /** The `verify_claim` receipt: for `evidence-refuted`, the counter-evidence. */
    receipt?: unknown;
}
/**
 * A stored claim OpenLore could have written. `notes.json` is committed repo content, so the read
 * path checks the shape as well as the write path.
 */
export declare function isWellFormedClaim(c: unknown): c is MemoryClaim;
/** Parse caller-supplied claims, or say what is wrong with them. Verdicts are not checked here. */
export declare function parseClaims(claims: unknown): {
    claims: MemoryClaim[];
} | {
    error: string;
};
/**
 * Check claims against the current graph. `memo` shares a check between memories that carry the
 * same claim within one call; it never outlives the call, so a re-analyzed graph is always seen.
 */
export declare function checkClaims(directory: string, claims: readonly MemoryClaim[], memo?: Map<string, Promise<ClaimCheck>>): Promise<ClaimCheck[]>;
/** The receipt's index commit, when the check produced one. */
export declare function receiptIndexCommit(check: ClaimCheck): string | undefined;
//# sourceMappingURL=memory-claims.d.ts.map