/**
 * Hooks adapter — barrel.
 *
 * In-process host surface over `kernel.run.*` and selected engine services.
 * Consumers should import from this module:
 *
 *   import { Hooks, createHooks } from '../../adapters/hooks/index.js';
 *
 *   const hooks = createHooks({ repoRoot, memory, runtimeHealth });
 *   await hooks.context.init();
 *   const pack = await hooks.context.compile({ runId, host: 'cli', ... });
 *
 * The statically-exported `Hooks` namespace is a convenience for hosts that
 * don't need multi-repo isolation — it uses kernel singletons rooted at
 * process.cwd(). `createHooks()` returns a composed surface bound to the
 * supplied `ctx.repoRoot` so hosts that manage multiple repos can isolate
 * reads and mutations to the right working tree.
 */
import { ContextHooks } from './context.js';
import { ExecutionHooks } from './execution.js';
import { type HealthHooks } from './health.js';
import { type MemoryHooks } from './memory.js';
import type { HooksContext } from './types.js';
import { type RunMergeRequest, type RunMergeResult, type RunStepRequest, type RunStepResult, type RunVerifyRequest, type RunVerifyResult } from '../../kernel/execution/index.js';
import type { ExecutedStep, RuntimeExecuteInput } from '../../kernel/runtime/index.js';
import type { CompiledContextRequest, FileRef } from '../../kernel/context/index.js';
export type { HooksContext, HookResult } from './types.js';
/**
 * Stateless hooks that don't need a HooksContext.
 * - Context + Execution delegate directly to kernel singletons rooted at
 *   process.cwd(). Use `createHooks()` for multi-repo hosts.
 */
export declare const Hooks: {
    readonly context: {
        readonly init: () => Promise<void>;
        readonly compile: (request: CompiledContextRequest) => Promise<import("../../kernel/index.js").CompiledContextPack>;
        readonly hypertuneMax: (task: string, files: FileRef[], graphConnectivity?: (chunk: {
            source: string;
            label: string;
        }) => number) => Promise<{
            plan: import("../../engines/token-supremacy.js").ReadingPlan;
            assembly: import("../../engines/context-assembler.js").AssemblyResult;
            budgetConfig: import("../../engines/context-assembler.js").BudgetConfig;
        }>;
        readonly differential: (prev: import("../../engines/token-supremacy.js").SessionSummary, curr: FileRef[]) => import("../../engines/token-supremacy.js").ContextDelta;
        readonly loadLatestSessionSummary: () => Promise<import("../../engines/token-supremacy.js").SessionSummary | null>;
        readonly allocateBudget: (workers: Array<{
            id: string;
            estimatedValue: number;
            estimatedCost: number;
        }>, totalBudget?: number) => import("../../engines/token-supremacy.js").TokenBudget;
    };
    readonly execution: {
        readonly step: (request: RunStepRequest) => Promise<RunStepResult>;
        readonly verify: (request: RunVerifyRequest) => Promise<RunVerifyResult>;
        readonly merge: (request: RunMergeRequest) => Promise<RunMergeResult>;
        readonly execute: (request: RuntimeExecuteInput) => Promise<ExecutedStep>;
    };
};
export type BoundContextHooks = typeof ContextHooks;
export type BoundExecutionHooks = typeof ExecutionHooks;
export interface ComposedHooks {
    context: BoundContextHooks;
    execution: BoundExecutionHooks;
    health: HealthHooks;
    memory: MemoryHooks;
}
/**
 * Compose a fully-wired hooks namespace for a host that has memory + runtime
 * providers. Throws at construction time if required providers are missing —
 * fail-fast contract so hosts catch wiring errors early.
 *
 * Context + execution are bound to `ctx.repoRoot`:
 * - context.compile / hypertuneMax / differential pre-resolve relative paths
 *   against repoRoot before calling the kernel.
 * - execution uses a dedicated KernelExecutionServiceImpl rooted at repoRoot;
 *   the process-wide kernel singleton is left untouched.
 */
export declare function createHooks(ctx: HooksContext): ComposedHooks;
export { ContextHooks } from './context.js';
export { ExecutionHooks } from './execution.js';
export type { HealthHooks } from './health.js';
export type { MemoryHooks } from './memory.js';
