import type { OrgDaemon } from './daemon.js';
import { type DecisionGate, type DecisionKind } from './types.js';
export declare function gatesPath(root: string, org: string): string;
export declare function readGates(root: string, org: string): {
    gates: DecisionGate[];
};
/** A RUNNING org's gates live in memory (loaded when it starts, written
 *  through on every change, flushed when it stops) and are never re-read from
 *  disk during the run: gates.json sits in a directory the org's own roles can
 *  write, so a role that rewrote it — directly, or by swapping the directory —
 *  could otherwise approve its own gate. A stopped org's gates are the file,
 *  which is how an offline resolution reaches the next run. */
export declare function gatesFor(daemon: OrgDaemon, org: string): {
    gates: DecisionGate[];
};
export declare function writeGates(root: string, org: string, data: {
    gates: DecisionGate[];
}): void;
export declare function createGate(daemon: OrgDaemon, org: string, role: string, name: string, description: string): Promise<string>;
export declare function resolveGate(daemon: OrgDaemon, org: string, gateId: string, approved: boolean, resolution?: string, resolvedBy?: string): Promise<{
    ok: true;
} | {
    ok: false;
    error: string;
}>;
export declare function listGates(daemon: OrgDaemon, org: string, status?: 'pending' | 'approved' | 'rejected'): DecisionGate[];
/** Record a structured decision trace for Rifft-style debugging */
export declare function recordDecision(daemon: OrgDaemon, org: string, role: string, decision: {
    type: 'tool' | 'handoff' | 'approval' | 'routing';
    /** #290: structured cause — required so every emitter populates it and no
     *  consumer ever has to pattern-match the prose in context/reasoning. */
    kind: DecisionKind;
    context: string;
    reasoning: string;
    alternatives?: Array<{
        choice: string;
        score: number;
        reason: string;
    }>;
    outcome: string;
}): void;
//# sourceMappingURL=decision-gates.d.ts.map