import { verifyReceiptDag, type ReceiptCapabilityLevel, type ReceiptDagEnvelope, type ReceiptDagNode } from '../receipts/dag';
import { type SpendGuardConfig } from '../spend-guard';
import type { Provider, SignedDecisionLogEntry, SpendDecision, SpendPolicy, SpendScope } from '../types';
export type HermesKanbanProfile = 'researcher' | 'writer' | 'reviewer' | 'director' | 'orchestrator' | string;
export type HermesKanbanTaskState = 'triage' | 'blocked' | 'scheduled' | 'running' | 'complete' | 'revoked';
export type HermesKanbanGovernanceMode = 'lightweight' | 'full';
export interface HermesKanbanProfilePolicy {
    capability: ReceiptCapabilityLevel;
    toolAllowlist?: string[];
    capCents?: number;
}
export interface HermesKanbanAdapterOptions {
    policy: SpendPolicy;
    scope: SpendScope;
    config?: Omit<SpendGuardConfig, 'policy'>;
    licenseKey?: string;
    defaultModel?: string;
    defaultCapCents?: number;
    runtimeBudgetCentsPerMinute?: number;
    lightweightThresholdCents?: number;
    lightweightCapabilityCeiling?: ReceiptCapabilityLevel;
    profileMap?: Record<string, HermesKanbanProfilePolicy>;
    reviewerCascade?: {
        enabled?: boolean;
        highRiskThreshold?: number;
        drafterModel?: string;
        reviewerModel?: string;
        drafterMaxCostCents?: number;
        reviewerMaxCostCents?: number;
    };
}
export interface HermesKanbanTaskInput {
    taskId: string;
    boardSlug: string;
    profile: HermesKanbanProfile;
    parentTaskIds?: string[];
    workspacePath?: string;
    maxRuntimeMinutes?: number;
    maxRuntimeMs?: number;
    metadata?: Record<string, unknown>;
    builderCode?: string;
}
export interface HermesKanbanEnvelope {
    taskId: string;
    taskHash: string;
    boardHash: string;
    profile: string;
    state: HermesKanbanTaskState;
    capabilityCeiling: ReceiptCapabilityLevel;
    toolAllowlist: string[];
    capCents: number;
    parentTaskIds: string[];
    parentEntryHashes: string[];
    workspacePath?: string;
    governanceMode: HermesKanbanGovernanceMode;
    scope: SpendScope;
    builderCode?: string;
    createdAt: string;
    revokedAt?: string;
    completedAt?: string;
}
export interface HermesKanbanDispatchInput {
    taskId: string;
    model?: string;
    provider?: Provider;
    inputTokens: number;
    outputTokens: number;
    metadata?: Record<string, unknown>;
}
export interface HermesKanbanDispatchResult {
    allow: boolean;
    decision: SpendDecision;
    signed: SignedDecisionLogEntry | null;
}
export interface HermesKanbanCapabilityInput {
    taskId: string;
    requestedCapability: ReceiptCapabilityLevel;
    toolName?: string;
    toolArgs?: Record<string, unknown>;
}
export interface HermesKanbanCapabilityResult {
    approved: boolean;
    reason?: string;
    signed?: SignedDecisionLogEntry | null;
    decision?: SpendDecision;
    editedArgs?: Record<string, unknown>;
}
export interface HermesKanbanReceiptInput {
    taskId: string;
    parentTaskIds?: string[];
    capability?: ReceiptCapabilityLevel;
    modelIds?: string[];
    tokenCounts?: {
        inputTokens?: number;
        outputTokens?: number;
    };
    totalCostCents?: number;
    metadata?: Record<string, unknown>;
    workspacePath?: string;
    highRiskClassifierScore?: number;
    keywordRisk?: boolean;
    reviewerVerdict?: 'drafter_only' | 'review_required' | 'approved' | 'rejected';
}
export interface HermesKanbanReceiptResult {
    node: ReceiptDagNode;
    envelope: HermesKanbanEnvelope;
    dag: ReceiptDagEnvelope;
    verification?: Awaited<ReturnType<typeof verifyReceiptDag>>;
}
export declare function createHermesKanbanAdapter(opts: HermesKanbanAdapterOptions): HermesKanbanAdapter;
export declare class HermesKanbanAdapter {
    private readonly opts;
    private readonly taskGuards;
    private readonly envelopes;
    private readonly nodesByTaskId;
    private readonly nodes;
    private readonly profileMap;
    private readonly config;
    constructor(opts: HermesKanbanAdapterOptions);
    governTask(input: HermesKanbanTaskInput): HermesKanbanEnvelope;
    enforceProviderCall(input: HermesKanbanDispatchInput): Promise<HermesKanbanDispatchResult>;
    guardCapability(input: HermesKanbanCapabilityInput): Promise<HermesKanbanCapabilityResult>;
    revokeTask(taskId: string, reason?: string): Promise<HermesKanbanReceiptResult>;
    emitTaskReceipt(input: HermesKanbanReceiptInput): Promise<HermesKanbanReceiptResult>;
    getEnvelope(taskId: string): HermesKanbanEnvelope | null;
    getReceiptDag(rootTaskId?: string): ReceiptDagEnvelope;
    outboundPayloads(): Record<string, unknown>[];
    verifyDag(publicKeyHex?: string): Promise<Awaited<ReturnType<typeof verifyReceiptDag>>>;
    private signTaskNode;
    private receiptResult;
    private spendCentsSoFar;
    private requireEnvelope;
    private requireGuard;
    private requireNode;
    private profilePolicy;
    private publicKeyHex;
}
export declare function hermesKanbanSignerFingerprint(opts: HermesKanbanAdapterOptions): string | null;
//# sourceMappingURL=hermes-kanban.d.ts.map