monomind 1.18.15 → 2.0.0

package/packages/@monomind/guidance/dist/hooks.js

@@ -1,347 +0,0 @@
-/**
- * Guidance Hook Integration Layer
- *
- * Wires the EnforcementGates and ShardRetriever into the Monomind
- * 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 @monomind/guidance/hooks
- */
-import { HookEvent, HookPriority, } from '@monomind/hooks';
-// ============================================================================
-// Gate-Result -> Hook-Result Mapping
-// ============================================================================
-/**
- * Convert an array of GateResults into a single HookResult.
- *
- * Severity ordering: block > require-confirmation > warn > allow.
- * The most restrictive decision drives the hook outcome.
- */
-function gateResultsToHookResult(gateResults) {
-    if (gateResults.length === 0) {
-        return { success: true };
-    }
-    const severityOrder = {
-        block: 3,
-        'require-confirmation': 2,
-        warn: 1,
-        allow: 0,
-    };
-    // Sort by severity descending to find the most restrictive
-    const sorted = [...gateResults].sort((a, b) => severityOrder[b.decision] - severityOrder[a.decision]);
-    const worst = sorted[0];
-    // Collect all warnings and reasons
-    const allWarnings = [];
-    const allReasons = [];
-    for (const result of gateResults) {
-        allReasons.push(`[${result.gateName}] ${result.reason}`);
-        if (result.remediation) {
-            allWarnings.push(`[${result.gateName}] ${result.remediation}`);
-        }
-    }
-    switch (worst.decision) {
-        case 'block':
-            return {
-                success: false,
-                abort: true,
-                error: allReasons.join(' | '),
-                message: allReasons.join('\n'),
-                warnings: allWarnings.length > 0 ? allWarnings : undefined,
-                data: {
-                    gateDecision: 'block',
-                    gateResults: gateResults.map(r => ({
-                        gate: r.gateName,
-                        decision: r.decision,
-                        reason: r.reason,
-                    })),
-                },
-            };
-        case 'require-confirmation':
-            return {
-                success: false,
-                abort: true,
-                message: allReasons.join('\n'),
-                warnings: allWarnings.length > 0 ? allWarnings : undefined,
-                data: {
-                    gateDecision: 'require-confirmation',
-                    gateResults: gateResults.map(r => ({
-                        gate: r.gateName,
-                        decision: r.decision,
-                        reason: r.reason,
-                    })),
-                },
-            };
-        case 'warn':
-            return {
-                success: true,
-                message: allReasons.join('\n'),
-                warnings: allWarnings.length > 0 ? allWarnings : allReasons,
-                data: {
-                    gateDecision: 'warn',
-                    gateResults: gateResults.map(r => ({
-                        gate: r.gateName,
-                        decision: r.decision,
-                        reason: r.reason,
-                    })),
-                },
-            };
-        default:
-            return { success: true };
-    }
-}
-// ============================================================================
-// Guidance Hook Provider
-// ============================================================================
-/**
- * Provides guidance enforcement hooks for the V1 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 class GuidanceHookProvider {
-    gates;
-    retriever;
-    ledger;
-    /** IDs of hooks registered by this provider, for cleanup */
-    hookIds = [];
-    /** Active run events keyed by task ID, for PostTask finalization */
-    activeRuns = new Map();
-    constructor(gates, retriever, ledger) {
-        this.gates = gates;
-        this.retriever = retriever;
-        this.ledger = ledger;
-    }
-    /**
-     * Register all guidance hooks on the given registry.
-     *
-     * Returns the array of generated hook IDs for tracking.
-     */
-    registerAll(registry) {
-        this.hookIds = [];
-        // 1. PreCommand -> gate enforcement (Critical priority)
-        this.hookIds.push(registry.register(HookEvent.PreCommand, (ctx) => this.handlePreCommand(ctx), HookPriority.Critical, {
-            name: 'guidance-gate-pre-command',
-            description: 'Evaluates commands for destructive ops and secrets',
-        }));
-        // 2. PreToolUse -> gate enforcement (Critical priority)
-        this.hookIds.push(registry.register(HookEvent.PreToolUse, (ctx) => this.handlePreToolUse(ctx), HookPriority.Critical, {
-            name: 'guidance-gate-pre-tool-use',
-            description: 'Evaluates tool usage against allowlist and checks for secrets',
-        }));
-        // 3. PreEdit -> gate enforcement (High priority)
-        this.hookIds.push(registry.register(HookEvent.PreEdit, (ctx) => this.handlePreEdit(ctx), HookPriority.High, {
-            name: 'guidance-gate-pre-edit',
-            description: 'Evaluates file edits for diff size and secrets',
-        }));
-        // 4. PreTask -> shard retrieval (Normal priority)
-        this.hookIds.push(registry.register(HookEvent.PreTask, (ctx) => this.handlePreTask(ctx), HookPriority.Normal, {
-            name: 'guidance-retriever-pre-task',
-            description: 'Retrieves relevant guidance shards at task start',
-        }));
-        // 5. PostTask -> ledger finalization (Normal priority)
-        this.hookIds.push(registry.register(HookEvent.PostTask, (ctx) => this.handlePostTask(ctx), HookPriority.Normal, {
-            name: 'guidance-ledger-post-task',
-            description: 'Finalizes the run event in the ledger on task completion',
-        }));
-        return [...this.hookIds];
-    }
-    /**
-     * Unregister all hooks previously registered by this provider.
-     */
-    unregisterAll(registry) {
-        for (const id of this.hookIds) {
-            registry.unregister(id);
-        }
-        this.hookIds = [];
-    }
-    /**
-     * Get the IDs of all registered hooks.
-     */
-    getHookIds() {
-        return [...this.hookIds];
-    }
-    /**
-     * Get the active run event for a given task ID (if any).
-     */
-    getActiveRun(taskId) {
-        return this.activeRuns.get(taskId);
-    }
-    // ==========================================================================
-    // Hook Handlers
-    // ==========================================================================
-    /**
-     * PreCommand handler: evaluate command through destructive ops and secrets gates.
-     */
-    handlePreCommand(ctx) {
-        const command = ctx.command?.raw;
-        if (!command) {
-            return { success: true };
-        }
-        const gateResults = this.gates.evaluateCommand(command);
-        return gateResultsToHookResult(gateResults);
-    }
-    /**
-     * PreToolUse handler: evaluate tool usage against allowlist and check params for secrets.
-     */
-    handlePreToolUse(ctx) {
-        const toolName = ctx.tool?.name;
-        if (!toolName) {
-            return { success: true };
-        }
-        const params = ctx.tool?.parameters ?? {};
-        const gateResults = this.gates.evaluateToolUse(toolName, params);
-        return gateResultsToHookResult(gateResults);
-    }
-    /**
-     * 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.
-     */
-    handlePreEdit(ctx) {
-        const filePath = ctx.file?.path;
-        if (!filePath) {
-            return { success: true };
-        }
-        const content = ctx.metadata?.content ?? '';
-        const diffLines = ctx.metadata?.diffLines ?? 0;
-        const gateResults = this.gates.evaluateEdit(filePath, content, diffLines);
-        return gateResultsToHookResult(gateResults);
-    }
-    /**
-     * 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.
-     */
-    async handlePreTask(ctx) {
-        const taskId = ctx.task?.id;
-        const taskDescription = ctx.task?.description;
-        if (!taskId || !taskDescription) {
-            return { success: true };
-        }
-        try {
-            // Classify intent
-            const { intent, confidence } = this.retriever.classifyIntent(taskDescription);
-            // Retrieve relevant shards
-            let retrievalResult = null;
-            try {
-                retrievalResult = await this.retriever.retrieve({
-                    taskDescription,
-                    intent,
-                });
-            }
-            catch {
-                // Retriever may not have a loaded bundle -- degrade gracefully
-            }
-            // Create a run event for ledger tracking
-            const guidanceHash = retrievalResult?.constitution?.hash ?? 'unknown';
-            const runEvent = this.ledger.createEvent(taskId, intent, guidanceHash);
-            if (retrievalResult) {
-                runEvent.retrievedRuleIds = retrievalResult.shards.map(s => s.shard.rule.id);
-            }
-            this.activeRuns.set(taskId, runEvent);
-            return {
-                success: true,
-                message: retrievalResult
-                    ? `Retrieved ${retrievalResult.shards.length} guidance shard(s) for intent "${intent}" (confidence: ${(confidence * 100).toFixed(0)}%)`
-                    : `Classified intent as "${intent}" (confidence: ${(confidence * 100).toFixed(0)}%). No policy bundle loaded.`,
-                data: {
-                    intent,
-                    confidence,
-                    policyText: retrievalResult?.policyText ?? null,
-                    shardCount: retrievalResult?.shards.length ?? 0,
-                    contradictionsResolved: retrievalResult?.contradictionsResolved ?? 0,
-                    retrievalLatencyMs: retrievalResult?.latencyMs ?? 0,
-                },
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                message: 'Failed to retrieve guidance shards for task',
-            };
-        }
-    }
-    /**
-     * PostTask handler: finalize the run event in the ledger.
-     *
-     * Looks up the active run by task ID, populates completion metadata,
-     * and calls ledger.finalizeEvent().
-     */
-    handlePostTask(ctx) {
-        const taskId = ctx.task?.id;
-        if (!taskId) {
-            return { success: true };
-        }
-        const runEvent = this.activeRuns.get(taskId);
-        if (!runEvent) {
-            return {
-                success: true,
-                message: `No active run event found for task "${taskId}". Skipping finalization.`,
-            };
-        }
-        try {
-            // Populate additional metadata from context if available
-            if (ctx.task?.status) {
-                runEvent.outcomeAccepted = ctx.task.status === 'completed';
-            }
-            if (ctx.metadata?.toolsUsed && Array.isArray(ctx.metadata.toolsUsed)) {
-                runEvent.toolsUsed = ctx.metadata.toolsUsed;
-            }
-            if (ctx.metadata?.filesTouched && Array.isArray(ctx.metadata.filesTouched)) {
-                runEvent.filesTouched = ctx.metadata.filesTouched;
-            }
-            // Finalize the event in the ledger
-            this.ledger.finalizeEvent(runEvent);
-            this.activeRuns.delete(taskId);
-            return {
-                success: true,
-                message: `Run event finalized for task "${taskId}" (duration: ${runEvent.durationMs}ms)`,
-                data: {
-                    eventId: runEvent.eventId,
-                    taskId: runEvent.taskId,
-                    intent: runEvent.intent,
-                    durationMs: runEvent.durationMs,
-                    violationCount: runEvent.violations.length,
-                },
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                message: `Failed to finalize run event for task "${taskId}"`,
-            };
-        }
-    }
-}
-// ============================================================================
-// Factory
-// ============================================================================
-/**
- * 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 function createGuidanceHooks(gates, retriever, ledger, registry) {
-    const provider = new GuidanceHookProvider(gates, retriever, ledger);
-    const hookIds = registry ? provider.registerAll(registry) : [];
-    return { provider, hookIds };
-}
-export { gateResultsToHookResult };
-//# sourceMappingURL=hooks.js.map

package/packages/@monomind/guidance/dist/index.d.ts

@@ -1,203 +0,0 @@
-/**
- * @monomind/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
- * - MonoVector/HNSW for semantic shard retrieval
- *
- * @module @monomind/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 { 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, createTrustLedger, 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