/**
 * Structural claim verification (change: add-structural-claim-verification).
 *
 * The reverse of context retrieval: instead of OpenLore handing the agent facts,
 * the AGENT submits a structured claim about code structure and OpenLore returns a
 * deterministic verdict plus a citation it can show a human. This converts the
 * agent's confident-wrong failure mode ("this function is dead", "Y calls Z") into
 * checked-or-flagged, and makes the agent's output auditable.
 *
 *   claim   = { kind: 'calls'|'reaches'|'dead'|'impacts'|'safe-to-change'|'decision-current', subject, object? }
 *   verdict = { verdict: 'confirmed'|'refuted'|'unverifiable', reason, receipt?, confidenceBoundary }
 *
 * Every verdict is a deterministic computation, never an LLM judgement and never a
 * confidence number (north star c6d1ad07). The structural kinds compute over the
 * call graph:
 *   - `calls`          → a direct caller→callee edge exists.
 *   - `reaches`        → forward reachability subject ⇒ object.
 *   - `impacts`        → backward reachability: object transitively calls subject,
 *                        so changing subject can require changes in object.
 *   - `dead`           → mark-and-sweep reachability (reuses {@link deadCodeIds}),
 *                        run twice (synthesized-inclusive vs directly-resolved) to
 *                        separate truly-unreached from reached-only-via-heuristic.
 *   - `safe-to-change` → no internal caller depends on subject (blast radius is
 *                        empty by directly-resolved edges).
 * The decision kind computes over the recorded decision store instead (change:
 * add-decision-reference-claim-verification):
 *   - `decision-current` → the subject decision id is recorded and neither
 *                        superseded (reusing the `stale-decision-reference`
 *                        retirement graph) nor rejected, so citing it is sound.
 *
 * The receipt reuses the grounding-certificate shape (`{ symbol, filePath,
 * lineSpan, contentHash }`) — the same span hash the freshness check compares — so
 * a human can audit the claim against the index at a named commit. `unverifiable`
 * is first-class: when a verdict rests on a dispatch blind spot it is named via
 * `add-confidence-boundary-disclosure`, rather than fabricating a decisive answer.
 */
export type ClaimKind = 'calls' | 'reaches' | 'dead' | 'impacts' | 'safe-to-change' | 'decision-current';
export type Verdict = 'confirmed' | 'refuted' | 'unverifiable';
export interface VerifyClaimInput {
    directory: string;
    kind: ClaimKind;
    /**
     * What the claim is about: a function/method name for structural kinds, or an
     * 8-character decision id for the `decision-current` kind.
     */
    subject: string;
    /** The second symbol, for relational kinds (`calls`, `reaches`, `impacts`). */
    object?: string;
}
/**
 * Verify a structured structural claim against the deterministic call graph.
 * Read-only, offline, no LLM. Returns `unknown` (additive-by-cast like the
 * sibling handlers).
 */
export declare function handleVerifyClaim(input: VerifyClaimInput): Promise<unknown>;
//# sourceMappingURL=claim-verification.d.ts.map