/**
 * fleet_status + the drift-aware verification memory (change: add-fleet-coordination-arc).
 *
 * Completes the coordination arc — plan_parallel_work (dispatch) → map_in_flight_conflicts (in
 * flight) → certify_merge (landing) — with the piece the arc was missing: continuity across a
 * moving base. When parallel agents each work off a base that advances under them, every verified
 * fact they hold ("this blast radius is clean", "this merge was certified compatible") silently
 * becomes suspect. This records each coordination verdict as a typed, anchored record carrying the
 * base commit it was proven against, and re-classifies it when the base moves — reusing the SAME
 * freshness lease `recheckCertificate` uses, so a verdict is never served fresh once its base moved
 * without the check.
 *
 * Deterministic, local, read-only against the graph. `fleet_status` composes the recorded verdicts
 * with the arc's conclusions, attributing each line to the tool that produced it; it references
 * those tools, it does not re-derive them. Live PR/branch harvesting, the expire-on-land lifecycle,
 * and the CLI are follow-ups.
 */
import { memoryFreshness } from '../../decisions/anchor.js';
import type { StructuralAnchor } from '../../../types/index.js';
/** The coordination verdicts whose currency the fleet tracks. */
export type CoordinationVerdict = 'blast-radius-clean' | 'surface-stable' | 'merge-compatible';
/** A verified coordination fact, anchored to the symbols it was proven over. */
export interface VerificationRecord {
    id: string;
    verdict: CoordinationVerdict;
    /** The branch/task this verdict belongs to (for lifecycle + attribution). */
    branch: string;
    /** The base commit the verdict was proven against. */
    baseCommit: string;
    /** The tool that produced the verdict. */
    producedBy: string;
    anchors: StructuralAnchor[];
}
export type RecordState = 'still-valid' | 'carried' | 'invalidated' | 'needs-reverification';
export interface ClassifiedRecord {
    id: string;
    branch: string;
    verdict: CoordinationVerdict;
    producedBy: string;
    baseCommit: string;
    state: RecordState;
    reason: string;
}
/**
 * Map a memory-freshness aggregate to a record state. Pure. The anchor system carries a
 * moved-but-unchanged symbol at analyze, so a carried anchor already reads `fresh` here; a genuine
 * content drift is `drifted` → invalidated; a lost anchor is `orphaned` → needs-reverification.
 * Anything else is conservatively needs-reverification — a verdict is never served fresh by default.
 */
export declare function stateForFreshness(freshness: string, anchored: boolean): RecordState;
/** Classify each record's currency against a freshness view. Pure over (records, view). */
export declare function classifyRecords(records: readonly VerificationRecord[], view: Parameters<typeof memoryFreshness>[1] | null): ClassifiedRecord[];
/** Record a verification verdict (coordination-scoped). Advisory, best-effort. */
export declare function recordVerification(absDir: string, record: VerificationRecord): Promise<void>;
export interface FleetStatusInput {
    directory: string;
    /** In-flight branches to compose the arc for (attribution + the tools to run per branch). */
    branches?: string[];
}
/**
 * Compose the coordination arc into one readiness view: the recorded verdicts classified against
 * the current graph, plus the arc's tool references per in-flight branch. Each line is attributed
 * to its producing tool; the arc tools are referenced, not re-derived.
 */
export declare function handleFleetStatus(input: FleetStatusInput): Promise<Record<string, unknown>>;
//# sourceMappingURL=fleet-coordination.d.ts.map