/**
 * Info/Action Separation Bridge — W1.6 of F-NEW-PRODUCT-AGENT-VISIBILITY-CLUSTER-2026-05-12.
 *
 * Surfaces the already-shipped AutonomousActionIsolator as a customer-facing
 * primitive driven by a company pack's `requiresActionIsolation` declaration.
 * No re-implementation of the enforcer — this slice is the missing wiring + the
 * customer-facing shape.
 *
 * Customer flow:
 *   1. Company pack authored with `isolation: 'strict'` (or 'sourced-only').
 *   2. buildCompanyPack sets `requiresActionIsolation` on the pack.
 *   3. InfoActionSeparationBridge.applyPackPolicy() reads that field across all
 *      active packs and configures the AutonomousActionIsolator for the agent.
 *   4. recordInfoGathering / recordConsequential / gateConsequential bridge to
 *      the underlying isolator. gateConsequential returns a verdict shape that
 *      composes cleanly with PackEvaluatorVerdict (ALLOW / DENY / PENDING).
 *
 * Spec authority: /root/.claude/rules/web-interaction-security.md Rule 2
 *   ("Isolation Between Fetch and Action") — wires that policy as a runtime
 *   enforceable check class.
 *
 * @connexum/ai-governance  F-NEW-PRODUCT-INFO-ACTION-SEPARATION
 */
import { AutonomousActionIsolator, type IsolationMode, type ConsequentialGuardAction, type IsolationAuditSink } from './action-isolation.js';
import type { CompliancePack } from '../packs/index.js';
/** Composite verdict shape so callers can interleave with PackEvaluatorVerdict. */
export interface InfoActionVerdict {
    verdict: 'ALLOW' | 'DENY' | 'PENDING';
    /** Effective isolation mode applied. */
    mode: IsolationMode;
    /** Pack IDs whose declarations contributed to the mode. */
    contributingPackIds: string[];
    /** Human-readable reason. */
    reason: string;
}
/**
 * Derive the strictest isolation mode declared across a pack list.
 * Treats `true` as 'sourced-only' (the documented default for strict regulated packs).
 * Returns 'none' when no pack declares isolation.
 */
export declare function deriveIsolationMode(packs: ReadonlyArray<CompliancePack>): {
    mode: IsolationMode;
    contributingPackIds: string[];
};
export interface BridgeOptions {
    /**
     * Audit sink forwarded to AutonomousActionIsolator. Same shape as the
     * underlying isolator expects (`IsolationAuditEvent` callback).
     */
    auditSink?: IsolationAuditSink;
    /**
     * Test-only operator-identity-to-role map. Forwarded to AutonomousActionIsolator
     * so its RBAC gate can be bypassed during unit tests without needing a full
     * OperatorRoles instance.
     */
    testOperatorMap?: Map<string, string>;
    /**
     * Default outcome when an isolation violation is detected. 'DENY' (default)
     * blocks the action; 'PENDING' routes through the approval pipeline.
     */
    violationOutcome?: 'DENY' | 'PENDING';
}
/**
 * InfoActionSeparationBridge — single entry point that combines pack policy
 * with the AutonomousActionIsolator enforcer.
 */
export declare class InfoActionSeparationBridge {
    private readonly isolator;
    private readonly violationOutcome;
    /** Per-agent record of whether applyPackPolicy has configured the isolator. */
    private readonly configuredAgents;
    constructor(options?: BridgeOptions);
    /** Direct accessor for tests + admin tooling that need the underlying isolator. */
    get underlying(): AutonomousActionIsolator;
    /**
     * Configure the underlying isolator for an agent based on a list of packs.
     * Auto-resolves the strictest isolation mode and the resulting packBinding.
     * No-op (mode = 'none') if no pack declares isolation.
     */
    applyPackPolicy(orgId: string, agentId: string, packs: ReadonlyArray<CompliancePack>, approverIdentity: string): {
        mode: IsolationMode;
        contributingPackIds: string[];
    };
    /** Record an info-gathering action in the cycle log. */
    recordInfoGathering(orgId: string, agentId: string, cycleId: string, sourceIds: string[], packBinding: string[]): Promise<void>;
    /**
     * Gate a consequential action. Returns a structured verdict:
     *   - ALLOW    : action may proceed
     *   - DENY     : isolation violated; default outcome
     *   - PENDING  : isolation violated; configured to route through approval
     */
    gateConsequential(orgId: string, agentId: string, cycleId: string, action: ConsequentialGuardAction, packBinding: string[]): Promise<InfoActionVerdict>;
    /** Clear the per-cycle action log (cycle teardown). */
    clearCycle(orgId: string, agentId: string, cycleId: string): void;
    private resolveEffectiveMode;
    private agentKey;
}
//# sourceMappingURL=info-action-separation.d.ts.map