moflo 4.8.30 → 4.8.32

package/src/@claude-flow/guidance/dist/generators.d.ts

@@ -1,153 +0,0 @@
-/**
- * CLAUDE.md Generator
- *
- * Generates a structured CLAUDE.md file optimized for the Guidance Control Plane.
- * The output is designed so that when compiled by GuidanceCompiler, it produces
- * a clean constitution (always-loaded invariants) and well-tagged shards
- * (task-scoped rules retrievable by intent).
- *
- * Structure conventions:
- * - Lines 1-60: Constitution (always loaded into every task)
- * - Remaining: Tagged shards (retrieved by intent classification)
- * - Headings map to shard boundaries
- * - Keywords in headings drive intent tagging: "test", "build", "security", etc.
- *
- * @module @claude-flow/guidance/generators
- */
-export interface ProjectProfile {
-    /** Project name */
-    name: string;
-    /** Short description */
-    description?: string;
-    /** Primary language(s) */
-    languages: string[];
-    /** Frameworks in use */
-    frameworks?: string[];
-    /** Package manager */
-    packageManager?: 'npm' | 'pnpm' | 'yarn' | 'bun';
-    /** Monorepo? */
-    monorepo?: boolean;
-    /** Build command */
-    buildCommand?: string;
-    /** Test command */
-    testCommand?: string;
-    /** Lint command */
-    lintCommand?: string;
-    /** Source directory */
-    srcDir?: string;
-    /** Test directory */
-    testDir?: string;
-    /** Domain-specific rules */
-    domainRules?: string[];
-    /** Architecture notes */
-    architecture?: string;
-    /** Team conventions */
-    conventions?: string[];
-    /** Forbidden patterns */
-    forbidden?: string[];
-    /** Required patterns */
-    required?: string[];
-    /** Import paths for personal instructions */
-    imports?: string[];
-    /** Enable guidance control plane integration */
-    guidanceControlPlane?: boolean;
-    /** Enable WASM kernel for hot paths */
-    wasmKernel?: boolean;
-    /** Agent swarm configuration */
-    swarm?: {
-        topology?: 'hierarchical' | 'mesh' | 'adaptive';
-        maxAgents?: number;
-        strategy?: 'specialized' | 'balanced';
-    };
-}
-export interface LocalProfile {
-    /** Developer name or identifier */
-    developer?: string;
-    /** Local API URLs */
-    localUrls?: Record<string, string>;
-    /** Local database connection strings */
-    databases?: Record<string, string>;
-    /** Personal preferences */
-    preferences?: string[];
-    /** Machine-specific notes */
-    machineNotes?: string[];
-    /** Editor / IDE */
-    editor?: string;
-    /** OS */
-    os?: string;
-    /** Custom environment variables */
-    envVars?: Record<string, string>;
-    /** Debug settings */
-    debug?: string[];
-}
-export interface SkillDefinition {
-    /** Skill name (kebab-case) */
-    name: string;
-    /** Version */
-    version?: string;
-    /** Description */
-    description: string;
-    /** Category */
-    category: 'core' | 'github' | 'testing' | 'security' | 'deployment' | 'analysis' | 'custom';
-    /** Tags */
-    tags?: string[];
-    /** Required tools */
-    requires?: string[];
-    /** Capabilities list */
-    capabilities?: string[];
-    /** Skill instructions (markdown body) */
-    instructions: string;
-}
-export interface AgentDefinition {
-    /** Agent name (kebab-case) */
-    name: string;
-    /** Agent type */
-    type: 'coordinator' | 'developer' | 'tester' | 'reviewer' | 'security-specialist' | 'researcher' | 'architect' | 'devops' | 'custom';
-    /** Description */
-    description: string;
-    /** Category subdirectory */
-    category?: string;
-    /** Color for UI */
-    color?: string;
-    /** Capabilities */
-    capabilities?: string[];
-    /** Focus areas */
-    focus?: string[];
-    /** Temperature (0.0-1.0) */
-    temperature?: number;
-    /** Priority */
-    priority?: 'high' | 'medium' | 'low';
-    /** System prompt */
-    systemPrompt?: string;
-    /** Pre-execution hook */
-    preHook?: string;
-    /** Post-execution hook */
-    postHook?: string;
-    /** Detailed instructions (markdown body) */
-    instructions?: string;
-}
-export declare function generateClaudeMd(profile: ProjectProfile): string;
-export declare function generateClaudeLocalMd(local: LocalProfile): string;
-export declare function generateSkillMd(skill: SkillDefinition): string;
-export declare function generateAgentMd(agent: AgentDefinition): string;
-export declare function generateAgentIndex(agents: AgentDefinition[]): string;
-export interface ScaffoldOptions {
-    /** Project profile for CLAUDE.md */
-    project: ProjectProfile;
-    /** Local profile for CLAUDE.local.md (optional) */
-    local?: LocalProfile;
-    /** Skills to generate */
-    skills?: SkillDefinition[];
-    /** Agents to generate */
-    agents?: AgentDefinition[];
-    /** Include default agents based on project profile */
-    includeDefaultAgents?: boolean;
-    /** Include default skills based on project profile */
-    includeDefaultSkills?: boolean;
-}
-export interface ScaffoldResult {
-    /** Map of relative file path → content */
-    files: Map<string, string>;
-}
-export declare function scaffold(options: ScaffoldOptions): ScaffoldResult;
-//# sourceMappingURL=generators.d.ts.map

package/src/@claude-flow/guidance/dist/headless.d.ts

@@ -1,177 +0,0 @@
-/**
- * Headless Test Harness
- *
- * Integrates with Claude Code headless mode (claude -p --output-format json)
- * to run automated evaluation suites against guidance rules.
- *
- * Usage:
- * 1. Define a task suite (list of tasks with expected behaviors)
- * 2. Run each task in headless mode
- * 3. Parse JSON output
- * 4. Evaluate against active rules
- * 5. Store results in the run ledger
- *
- * @module @claude-flow/guidance/headless
- */
-import type { RunEvent, TaskIntent, Violation, EvaluatorResult } from './types.js';
-import type { RunLedger } from './ledger.js';
-/**
- * A test task in the suite
- */
-export interface TestTask {
-    /** Unique task ID */
-    id: string;
-    /** Task description (the prompt to send) */
-    prompt: string;
-    /** Expected intent classification */
-    expectedIntent: TaskIntent;
-    /** Expected behavior assertions */
-    assertions: TaskAssertion[];
-    /** Maximum allowed violations */
-    maxViolations: number;
-    /** Timeout in ms */
-    timeoutMs: number;
-    /** Tags for filtering */
-    tags: string[];
-}
-/**
- * An assertion about expected behavior
- */
-export interface TaskAssertion {
-    /** Assertion type */
-    type: 'output-contains' | 'output-not-contains' | 'files-touched' | 'no-forbidden-commands' | 'tests-pass' | 'custom';
-    /** Expected value or pattern */
-    expected: string;
-    /** Assertion description */
-    description: string;
-}
-/**
- * Result of running a single test task
- */
-export interface TaskRunResult {
-    /** The task that was run */
-    task: TestTask;
-    /** Whether the run succeeded */
-    success: boolean;
-    /** Claude Code output (parsed JSON) */
-    output: HeadlessOutput | null;
-    /** Assertion results */
-    assertionResults: Array<{
-        assertion: TaskAssertion;
-        passed: boolean;
-        details: string;
-    }>;
-    /** Violations detected */
-    violations: Violation[];
-    /** Evaluator results */
-    evaluatorResults: EvaluatorResult[];
-    /** Run event logged to ledger */
-    runEvent: RunEvent | null;
-    /** Duration in ms */
-    durationMs: number;
-    /** Error if any */
-    error?: string;
-}
-/**
- * Parsed output from Claude Code headless mode
- */
-export interface HeadlessOutput {
-    /** The response text */
-    result: string;
-    /** Tools that were used */
-    toolsUsed: string[];
-    /** Files that were modified */
-    filesModified: string[];
-    /** Whether any errors occurred */
-    hasErrors: boolean;
-    /** Session metadata */
-    metadata: Record<string, unknown>;
-}
-/**
- * Suite run summary
- */
-export interface SuiteRunSummary {
-    /** Total tasks run */
-    totalTasks: number;
-    /** Tasks passed */
-    tasksPassed: number;
-    /** Tasks failed */
-    tasksFailed: number;
-    /** Total violations */
-    totalViolations: number;
-    /** Total assertions checked */
-    totalAssertions: number;
-    /** Assertions passed */
-    assertionsPassed: number;
-    /** Overall pass rate */
-    passRate: number;
-    /** Duration in ms */
-    durationMs: number;
-    /** Per-task results */
-    results: TaskRunResult[];
-}
-/**
- * Command executor interface (injectable for testing)
- */
-export interface ICommandExecutor {
-    execute(command: string, timeoutMs: number): Promise<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-    }>;
-}
-/**
- * Default command executor using child_process
- */
-export declare class ProcessExecutor implements ICommandExecutor {
-    execute(command: string, timeoutMs: number): Promise<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-    }>;
-    /** Parse a buildCommand() result into [executable, ...args] without shell. */
-    private parseCommand;
-}
-export declare class HeadlessRunner {
-    private executor;
-    private ledger;
-    private guidanceHash;
-    constructor(executor?: ICommandExecutor, ledger?: RunLedger, guidanceHash?: string);
-    /**
-     * Set the run ledger for logging
-     */
-    setLedger(ledger: RunLedger): void;
-    /**
-     * Run a single test task in headless mode
-     */
-    runTask(task: TestTask): Promise<TaskRunResult>;
-    /**
-     * Run an entire test suite
-     */
-    runSuite(tasks: TestTask[], tags?: string[]): Promise<SuiteRunSummary>;
-    /**
-     * Build the Claude Code headless command
-     */
-    private buildCommand;
-    /**
-     * Parse Claude Code JSON output
-     */
-    private parseOutput;
-    /**
-     * Check assertions against output
-     */
-    private checkAssertions;
-    /**
-     * Detect violations from task output
-     */
-    private detectViolations;
-}
-/**
- * Create a basic compliance test suite
- */
-export declare function createComplianceSuite(): TestTask[];
-/**
- * Create a headless runner instance
- */
-export declare function createHeadlessRunner(executor?: ICommandExecutor, ledger?: RunLedger, guidanceHash?: string): HeadlessRunner;
-//# sourceMappingURL=headless.d.ts.map

package/src/@claude-flow/guidance/dist/hooks.d.ts

@@ -1,109 +0,0 @@
-/**
- * Guidance Hook Integration Layer
- *
- * Wires the EnforcementGates and ShardRetriever into the Claude Flow V3
- * hook lifecycle. Each guidance concern is registered as a hook that
- * participates in the standard HookRegistry event flow.
- *
- * Hook mappings:
- *   PreCommand  -> EnforcementGates.evaluateCommand()  (destructive ops + secrets)
- *   PreToolUse  -> EnforcementGates.evaluateToolUse()   (tool allowlist + secrets)
- *   PreEdit     -> EnforcementGates.evaluateEdit()      (diff size + secrets)
- *   PreTask     -> ShardRetriever.retrieve()            (inject relevant shards)
- *   PostTask    -> RunLedger.finalizeEvent()             (record run completion)
- *
- * @module @claude-flow/guidance/hooks
- */
-import type { HookResult } from '@claude-flow/hooks';
-import type { HookRegistry } from '@claude-flow/hooks';
-import type { EnforcementGates } from './gates.js';
-import type { ShardRetriever } from './retriever.js';
-import type { RunLedger } from './ledger.js';
-import type { GateResult, RunEvent } from './types.js';
-/**
- * Convert an array of GateResults into a single HookResult.
- *
- * Severity ordering: block > require-confirmation > warn > allow.
- * The most restrictive decision drives the hook outcome.
- */
-declare function gateResultsToHookResult(gateResults: GateResult[]): HookResult;
-/**
- * Provides guidance enforcement hooks for the V3 hook system.
- *
- * Registers hooks on a HookRegistry that wire each lifecycle event
- * (PreCommand, PreToolUse, PreEdit, PreTask, PostTask) to the
- * appropriate guidance subsystem (gates, retriever, ledger).
- */
-export declare class GuidanceHookProvider {
-    private gates;
-    private retriever;
-    private ledger;
-    /** IDs of hooks registered by this provider, for cleanup */
-    private hookIds;
-    /** Active run events keyed by task ID, for PostTask finalization */
-    private activeRuns;
-    constructor(gates: EnforcementGates, retriever: ShardRetriever, ledger: RunLedger);
-    /**
-     * Register all guidance hooks on the given registry.
-     *
-     * Returns the array of generated hook IDs for tracking.
-     */
-    registerAll(registry: HookRegistry): string[];
-    /**
-     * Unregister all hooks previously registered by this provider.
-     */
-    unregisterAll(registry: HookRegistry): void;
-    /**
-     * Get the IDs of all registered hooks.
-     */
-    getHookIds(): string[];
-    /**
-     * Get the active run event for a given task ID (if any).
-     */
-    getActiveRun(taskId: string): RunEvent | undefined;
-    /**
-     * PreCommand handler: evaluate command through destructive ops and secrets gates.
-     */
-    private handlePreCommand;
-    /**
-     * PreToolUse handler: evaluate tool usage against allowlist and check params for secrets.
-     */
-    private handlePreToolUse;
-    /**
-     * PreEdit handler: evaluate file edit for diff size and secrets.
-     *
-     * Extracts the file path from context. The content to scan comes from
-     * metadata.content or is synthesized from available context. The diff
-     * line count defaults to metadata.diffLines or 0.
-     */
-    private handlePreEdit;
-    /**
-     * PreTask handler: classify intent and retrieve relevant guidance shards.
-     *
-     * Creates a new RunEvent in the active runs map for PostTask finalization.
-     * Returns the retrieved policy text and shards as hook data.
-     */
-    private handlePreTask;
-    /**
-     * PostTask handler: finalize the run event in the ledger.
-     *
-     * Looks up the active run by task ID, populates completion metadata,
-     * and calls ledger.finalizeEvent().
-     */
-    private handlePostTask;
-}
-/**
- * Create a GuidanceHookProvider and optionally register it on a registry.
- *
- * @param gates - The enforcement gates instance
- * @param retriever - The shard retriever instance
- * @param ledger - The run ledger instance
- * @param registry - Optional registry to auto-register on
- * @returns The provider and (if registry was given) the hook IDs
- */
-export declare function createGuidanceHooks(gates: EnforcementGates, retriever: ShardRetriever, ledger: RunLedger, registry?: HookRegistry): {
-    provider: GuidanceHookProvider;
-    hookIds: string[];
-};
-export { gateResultsToHookResult };
-//# sourceMappingURL=hooks.d.ts.map

package/src/@claude-flow/guidance/dist/index.d.ts

@@ -1,205 +0,0 @@
-/**
- * @claude-flow/guidance - Guidance Control Plane
- *
- * Sits beside Claude Code (not inside it) to:
- * 1. Compile CLAUDE.md into constitution + shards + manifest
- * 2. Retrieve task-relevant shards at runtime via intent classification
- * 3. Enforce non-negotiables through hook gates
- * 4. Log every run to a ledger with evaluators
- * 5. Evolve the rule set through an optimizer loop
- *
- * Architecture:
- * - Root CLAUDE.md → Repo constitution (rare changes)
- * - CLAUDE.local.md → Overlay / experiment sandbox (frequent changes)
- * - Optimizer → Promotes winning local rules to root
- *
- * Integration with Claude Code:
- * - Headless mode (claude -p --output-format json) for automated testing
- * - Hook system for enforcement gates
- * - RuVector/HNSW for semantic shard retrieval
- *
- * @module @claude-flow/guidance
- */
-import { RunLedger } from './ledger.js';
-import { OptimizerLoop } from './optimizer.js';
-import { HeadlessRunner } from './headless.js';
-export type { RiskClass, ToolClass, TaskIntent, GuidanceRule, RuleShard, Constitution, RuleManifest, PolicyBundle, RetrievalRequest, RetrievalResult, GateDecision, GateResult, GateConfig, RunEvent, Violation, EvaluatorResult, ViolationRanking, RuleChange, ABTestResult, OptimizationMetrics, RuleADR, GuidanceControlPlaneConfig, ControlPlaneStatus, } from './types.js';
-export { GuidanceCompiler, createCompiler } from './compiler.js';
-export type { CompilerConfig } from './compiler.js';
-export { ShardRetriever, createRetriever, HashEmbeddingProvider } from './retriever.js';
-export type { IEmbeddingProvider } from './retriever.js';
-export { EnforcementGates, createGates } from './gates.js';
-export { GuidanceHookProvider, createGuidanceHooks, gateResultsToHookResult, } from './hooks.js';
-export { RunLedger, createLedger, TestsPassEvaluator, ForbiddenCommandEvaluator, ForbiddenDependencyEvaluator, ViolationRateEvaluator, DiffQualityEvaluator, } from './ledger.js';
-export type { IEvaluator } from './ledger.js';
-export { OptimizerLoop, createOptimizer } from './optimizer.js';
-export type { OptimizerConfig } from './optimizer.js';
-export { PersistentLedger, EventStore, createPersistentLedger, createEventStore, } from './persistence.js';
-export type { PersistenceConfig, StorageStats } from './persistence.js';
-export { HeadlessRunner, createHeadlessRunner, ProcessExecutor, createComplianceSuite, } from './headless.js';
-export type { TestTask, TaskAssertion, TaskRunResult, HeadlessOutput, SuiteRunSummary, ICommandExecutor, } from './headless.js';
-export { DeterministicToolGateway, createToolGateway } from './gateway.js';
-export type { ToolSchema, Budget, IdempotencyRecord, GatewayDecision, ToolGatewayConfig, } from './gateway.js';
-export { ArtifactLedger, createArtifactLedger } from './artifacts.js';
-export type { ArtifactKind, Artifact, ArtifactLineage, ArtifactVerification, ArtifactSearchQuery, ArtifactStats, ArtifactLedgerConfig, RecordArtifactParams, SerializedArtifactLedger, } from './artifacts.js';
-export { EvolutionPipeline, createEvolutionPipeline } from './evolution.js';
-export type { ChangeProposalKind, ProposalStatus, RiskAssessment, ChangeProposal, DecisionDiff, SimulationResult, RolloutStage, StagedRollout, EvolutionHistoryEntry, TraceEvaluator, EvolutionPipelineConfig, } from './evolution.js';
-export { ManifestValidator, ConformanceSuite, createManifestValidator, createConformanceSuite, } from './manifest-validator.js';
-export type { AgentCellManifest, ValidationResult, ValidationError, ValidationWarning, GoldenTrace, GoldenTraceEvent, ConformanceResult, } from './manifest-validator.js';
-export { ProofChain, createProofChain } from './proof.js';
-export type { ToolCallRecord, MemoryOperation, MemoryLineageEntry, ProofEnvelopeMetadata, ProofEnvelope, SerializedProofChain, } from './proof.js';
-export { MemoryWriteGate, createMemoryWriteGate, createMemoryEntry, } from './memory-gate.js';
-export type { MemoryAuthority, MemoryEntry, WriteDecision, MemoryWriteGateConfig, } from './memory-gate.js';
-export { CoherenceScheduler, EconomicGovernor, createCoherenceScheduler, createEconomicGovernor, } from './coherence.js';
-export type { CoherenceScore, CoherenceThresholds, PrivilegeLevel, BudgetUsage, CoherenceSchedulerConfig, EconomicGovernorConfig, } from './coherence.js';
-export { CapabilityAlgebra, createCapabilityAlgebra } from './capabilities.js';
-export type { CapabilityScope, CapabilityConstraint, Attestation, Capability, CapabilityCheckResult, } from './capabilities.js';
-export { SimulatedRuntime, MemoryClerkCell, ConformanceRunner, createMemoryClerkCell, createConformanceRunner, } from './conformance-kit.js';
-export type { TraceEvent as CellTraceEvent, CellRunResult, CellRuntime, AgentCell, SimulatedRuntimeConfig, ConformanceTestResult, ReplayTestResult, } from './conformance-kit.js';
-export { RuvBotGuidanceBridge, AIDefenceGate, RuvBotMemoryAdapter, createRuvBotBridge, createAIDefenceGate, createRuvBotMemoryAdapter, } from './ruvbot-integration.js';
-export type { RuvBotInstance, RuvBotAIDefenceGuard, RuvBotMemory, AIDefenceThreat, AIDefenceResult, AIDefenceGateConfig, RuvBotBridgeConfig, RuvBotEvent, } from './ruvbot-integration.js';
-export { MetaGovernor, createMetaGovernor } from './meta-governance.js';
-export type { InvariantCheckResult, GovernanceState, ConstitutionalInvariant, AmendmentChange, Amendment, OptimizerConstraint, OptimizerAction, OptimizerValidation, InvariantReport, MetaGovernanceConfig, } from './meta-governance.js';
-export { ThreatDetector, CollusionDetector, MemoryQuorum, createThreatDetector, createCollusionDetector, createMemoryQuorum, } from './adversarial.js';
-export type { ThreatCategory, ThreatSignal, DetectionPattern, CollusionReport, MemoryProposal, QuorumResult, ThreatDetectorConfig, CollusionDetectorConfig, MemoryQuorumConfig, } from './adversarial.js';
-export { ContinueGate, createContinueGate } from './continue-gate.js';
-export type { ContinueGateConfig, StepContext, ContinueDecision, } from './continue-gate.js';
-export { getKernel, isWasmAvailable, resetKernel, } from './wasm-kernel.js';
-export type { WasmKernel, BatchOp, BatchResult, } from './wasm-kernel.js';
-export { generateClaudeMd, generateClaudeLocalMd, generateSkillMd, generateAgentMd, generateAgentIndex, scaffold, } from './generators.js';
-export type { ProjectProfile, LocalProfile, SkillDefinition, AgentDefinition, ScaffoldOptions, ScaffoldResult, } from './generators.js';
-export { analyze, benchmark, autoOptimize, optimizeForSize, headlessBenchmark, validateEffect, abBenchmark, getDefaultABTasks, formatReport, formatBenchmark, } from './analyzer.js';
-export type { AnalysisResult, AnalysisMetrics, DimensionScore, Suggestion, BenchmarkResult, ContextSize, OptimizeOptions, HeadlessBenchmarkResult, HeadlessTaskResult, IHeadlessExecutor, IContentAwareExecutor, ValidationAssertion, ValidationTask, ValidationTaskResult, ValidationRun, CorrelationResult, ValidationReport, ABTaskClass, ABTask, ABGatePattern, ABTaskResult, ABMetrics, ABReport, } from './analyzer.js';
-export { TrustAccumulator, TrustLedger as TrustScoreLedger, TrustSystem, getTrustBasedRateLimit, createTrustAccumulator, createTrustSystem, } from './trust.js';
-export type { TrustTier, GateOutcome, TrustConfig, TrustRecord, TrustSnapshot, } from './trust.js';
-export { TruthAnchorStore, TruthResolver, createTruthAnchorStore, createTruthResolver, } from './truth-anchors.js';
-export type { TruthSourceKind, TruthAnchor, TruthAnchorConfig, AnchorParams, TruthAnchorQuery, VerifyAllResult, ConflictResolution, } from './truth-anchors.js';
-export { UncertaintyLedger, UncertaintyAggregator, createUncertaintyLedger, createUncertaintyAggregator, } from './uncertainty.js';
-export type { BeliefStatus, ConfidenceInterval, Belief, UncertaintyConfig, } from './uncertainty.js';
-export { TemporalStore, TemporalReasoner, createTemporalStore, createTemporalReasoner, } from './temporal.js';
-export type { TemporalStatus, ValidityWindow, TemporalAssertion, TemporalTimeline, TemporalChange, TemporalConfig, } from './temporal.js';
-export { AuthorityGate, IrreversibilityClassifier, createAuthorityGate, createIrreversibilityClassifier, isHigherAuthority, getAuthorityHierarchy, } from './authority.js';
-export type { AuthorityLevel, IrreversibilityClass, ProofLevel, AuthorityScope, HumanIntervention, AuthorityCheckResult, IrreversibilityResult, AuthorityGateConfig, IrreversibilityClassifierConfig, } from './authority.js';
-import type { PolicyBundle, GuidanceControlPlaneConfig, ControlPlaneStatus, RetrievalRequest, RetrievalResult, GateResult, RunEvent, EvaluatorResult, TaskIntent, Violation } from './types.js';
-/**
- * The main Guidance Control Plane
- *
- * Orchestrates all components:
- * - Compiler: CLAUDE.md → PolicyBundle
- * - Retriever: PolicyBundle → task-relevant shards
- * - Gates: enforcement hooks
- * - Ledger: run logging + evaluation
- * - Optimizer: rule evolution
- * - Headless: automated testing
- */
-export declare class GuidanceControlPlane {
-    private config;
-    private compiler;
-    private retriever;
-    private gates;
-    private ledger;
-    private optimizer;
-    private headless;
-    private bundle;
-    private initialized;
-    constructor(config?: Partial<GuidanceControlPlaneConfig>);
-    /**
-     * Initialize the control plane
-     *
-     * 1. Read and compile guidance files
-     * 2. Load shards into retriever
-     * 3. Configure gates
-     * 4. Set up headless runner if enabled
-     */
-    initialize(): Promise<void>;
-    /**
-     * Compile guidance files (can be called independently)
-     */
-    compile(rootContent: string, localContent?: string): Promise<PolicyBundle>;
-    /**
-     * Retrieve relevant guidance for a task
-     *
-     * This is the main entry point called at task start.
-     * Returns the constitution + relevant shards.
-     */
-    retrieveForTask(request: RetrievalRequest): Promise<RetrievalResult>;
-    /**
-     * Evaluate a command through enforcement gates
-     */
-    evaluateCommand(command: string): GateResult[];
-    /**
-     * Evaluate a tool use through enforcement gates
-     */
-    evaluateToolUse(toolName: string, params: Record<string, unknown>): GateResult[];
-    /**
-     * Evaluate a file edit through enforcement gates
-     */
-    evaluateEdit(filePath: string, content: string, diffLines: number): GateResult[];
-    /**
-     * Start a run event for tracking
-     */
-    startRun(taskId: string, intent: TaskIntent): RunEvent;
-    /**
-     * Record a violation during a run
-     */
-    recordViolation(event: RunEvent, violation: Violation): void;
-    /**
-     * Finalize a run and evaluate it
-     */
-    finalizeRun(event: RunEvent): Promise<EvaluatorResult[]>;
-    /**
-     * Run the optimization cycle
-     */
-    optimize(): Promise<{
-        promoted: string[];
-        demoted: string[];
-        adrsCreated: number;
-    }>;
-    /**
-     * Get control plane status
-     */
-    getStatus(): ControlPlaneStatus;
-    /**
-     * Get the current policy bundle
-     */
-    getBundle(): PolicyBundle | null;
-    /**
-     * Get the run ledger
-     */
-    getLedger(): RunLedger;
-    /**
-     * Get the optimizer
-     */
-    getOptimizer(): OptimizerLoop;
-    /**
-     * Get the headless runner
-     */
-    getHeadlessRunner(): HeadlessRunner | null;
-    /**
-     * Get metrics for benefit tracking
-     */
-    getMetrics(): {
-        violationRatePer10Tasks: number;
-        selfCorrectionRate: number;
-        reworkLinesAvg: number;
-        clarifyingQuestionsAvg: number;
-        taskCount: number;
-        topViolations: Array<{
-            ruleId: string;
-            frequency: number;
-            cost: number;
-        }>;
-    };
-    private readGuidanceFile;
-    private ensureInitialized;
-}
-/**
- * Create a guidance control plane instance
- */
-export declare function createGuidanceControlPlane(config?: Partial<GuidanceControlPlaneConfig>): GuidanceControlPlane;
-/**
- * Quick setup: create and initialize the control plane
- */
-export declare function initializeGuidanceControlPlane(config?: Partial<GuidanceControlPlaneConfig>): Promise<GuidanceControlPlane>;
-export default GuidanceControlPlane;
-//# sourceMappingURL=index.d.ts.map