moflo 4.8.31 → 4.8.32

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

@@ -1,282 +0,0 @@
-/**
- * Evolution Pipeline
- *
- * Every change to prompts, policies, tools, and code becomes a signed change
- * proposal that goes through simulation, replay comparison, and staged rollout.
- *
- * Pipeline stages:
- * 1. Propose - Create a signed ChangeProposal
- * 2. Simulate - Replay golden traces with baseline vs candidate config
- * 3. Compare  - Approve or reject based on divergence threshold
- * 4. Stage    - Create a staged rollout plan (canary -> partial -> full)
- * 5. Advance  - Progress through stages with metric gates
- * 6. Promote / Rollback - Apply permanently or revert
- *
- * @module @claude-flow/guidance/evolution
- */
-/**
- * The kind of change being proposed.
- */
-export type ChangeProposalKind = 'rule-modify' | 'rule-add' | 'rule-remove' | 'rule-promote' | 'policy-update' | 'tool-config' | 'budget-adjust';
-/**
- * Lifecycle status of a change proposal.
- */
-export type ProposalStatus = 'draft' | 'signed' | 'simulating' | 'compared' | 'staged' | 'promoted' | 'rolled-back' | 'rejected';
-/**
- * Risk assessment attached to a proposal.
- */
-export interface RiskAssessment {
-    level: 'low' | 'medium' | 'high';
-    factors: string[];
-}
-/**
- * A signed change proposal describing a modification to the guidance system.
- */
-export interface ChangeProposal {
-    /** Unique identifier (UUID) */
-    proposalId: string;
-    /** What kind of change this is */
-    kind: ChangeProposalKind;
-    /** Short human-readable title */
-    title: string;
-    /** Longer description of the change */
-    description: string;
-    /** Agent or human ID that authored the proposal */
-    author: string;
-    /** Dot-path or identifier of what is being changed */
-    targetPath: string;
-    /** Before/after snapshot of the change */
-    diff: {
-        before: unknown;
-        after: unknown;
-    };
-    /** Why this change is being proposed */
-    rationale: string;
-    /** Risk assessment for the change */
-    riskAssessment: RiskAssessment;
-    /** HMAC-SHA256 signature of the proposal content */
-    signature: string;
-    /** Epoch ms when the proposal was created */
-    createdAt: number;
-    /** Current lifecycle status */
-    status: ProposalStatus;
-}
-/**
- * A single decision point where baseline and candidate diverged.
- */
-export interface DecisionDiff {
-    /** Sequence number in the trace */
-    seq: number;
-    /** What the baseline decided */
-    baseline: unknown;
-    /** What the candidate decided */
-    candidate: unknown;
-    /** How severe the divergence is */
-    severity: 'low' | 'medium' | 'high';
-}
-/**
- * Result of simulating a proposal against golden traces.
- */
-export interface SimulationResult {
-    /** Proposal that was simulated */
-    proposalId: string;
-    /** Hash of the trace produced by baseline config */
-    baselineTraceHash: string;
-    /** Hash of the trace produced by candidate config */
-    candidateTraceHash: string;
-    /** 0-1 score: 0 = identical, 1 = completely different */
-    divergenceScore: number;
-    /** Individual decision points where behaviour diverged */
-    decisionDiffs: DecisionDiff[];
-    /** Side-by-side metric comparison */
-    metricsComparison: {
-        baseline: Record<string, number>;
-        candidate: Record<string, number>;
-    };
-    /** Whether the simulation passed acceptance criteria */
-    passed: boolean;
-    /** Human-readable reason for the verdict */
-    reason: string;
-}
-/**
- * A single stage in a staged rollout.
- */
-export interface RolloutStage {
-    /** Stage name (e.g. 'canary', 'partial', 'full') */
-    name: string;
-    /** Percentage of traffic/agents this stage covers (0-100) */
-    percentage: number;
-    /** How long this stage should run before advancing (ms) */
-    durationMs: number;
-    /** Observed metrics during this stage */
-    metrics: Record<string, number>;
-    /** Maximum acceptable divergence before auto-rollback */
-    divergenceThreshold: number;
-    /** null = not evaluated yet, true = passed, false = failed */
-    passed: boolean | null;
-    /** Epoch ms when the stage started (null if not started) */
-    startedAt: number | null;
-    /** Epoch ms when the stage completed (null if not completed) */
-    completedAt: number | null;
-}
-/**
- * A staged rollout plan for a change proposal.
- */
-export interface StagedRollout {
-    /** Unique rollout identifier */
-    rolloutId: string;
-    /** The proposal being rolled out */
-    proposalId: string;
-    /** Ordered stages (canary -> partial -> full) */
-    stages: RolloutStage[];
-    /** Index of the current stage (0-based) */
-    currentStage: number;
-    /** Overall rollout status */
-    status: 'in-progress' | 'completed' | 'rolled-back';
-    /** Epoch ms when the rollout started */
-    startedAt: number;
-    /** Epoch ms when the rollout completed (null if still running) */
-    completedAt: number | null;
-}
-/**
- * History entry combining proposal, optional simulation, optional rollout,
- * and final outcome.
- */
-export interface EvolutionHistoryEntry {
-    proposal: ChangeProposal;
-    simulation?: SimulationResult;
-    rollout?: StagedRollout;
-    outcome: ProposalStatus;
-}
-/**
- * Evaluator function for simulation: given a golden trace and a config variant,
- * produce a trace hash and metrics.
- */
-export type TraceEvaluator = (trace: unknown, config: 'baseline' | 'candidate') => {
-    traceHash: string;
-    metrics: Record<string, number>;
-    decisions: unknown[];
-};
-export interface EvolutionPipelineConfig {
-    /** HMAC signing key for proposals */
-    signingKey?: string;
-    /** Maximum divergence score (0-1) to approve a change */
-    maxDivergence?: number;
-    /** Default rollout stages */
-    stages?: RolloutStage[];
-}
-/**
- * The Evolution Pipeline manages the lifecycle of change proposals through
- * signing, simulation, comparison, staged rollout, and promotion or rollback.
- */
-export declare class EvolutionPipeline {
-    private readonly signingKey;
-    private readonly maxDivergence;
-    private readonly defaultStages;
-    private proposals;
-    private simulations;
-    private rollouts;
-    constructor(config?: EvolutionPipelineConfig);
-    /**
-     * Create and sign a new change proposal.
-     */
-    propose(params: {
-        kind: ChangeProposalKind;
-        title: string;
-        description: string;
-        author: string;
-        targetPath: string;
-        diff: {
-            before: unknown;
-            after: unknown;
-        };
-        rationale: string;
-        riskAssessment: RiskAssessment;
-    }): ChangeProposal;
-    /**
-     * Run golden traces through both baseline and candidate configs to measure
-     * divergence. The evaluator is called once per golden trace per config.
-     */
-    simulate(proposalId: string, goldenTraces: unknown[], evaluator: TraceEvaluator): SimulationResult;
-    /**
-     * Compare a simulation result against acceptance criteria.
-     *
-     * Checks:
-     * 1. Divergence is below threshold
-     * 2. No regression in key metrics (candidate >= baseline)
-     */
-    compare(proposalId: string, simulationResult: SimulationResult): {
-        approved: boolean;
-        reason: string;
-    };
-    /**
-     * Create a staged rollout plan for a proposal.
-     */
-    stage(proposalId: string): StagedRollout;
-    /**
-     * Advance to the next rollout stage or auto-rollback.
-     *
-     * If `stageMetrics.divergence` exceeds the current stage's threshold,
-     * the rollout is automatically rolled back.
-     */
-    advanceStage(rolloutId: string, stageMetrics: Record<string, number>): {
-        advanced: boolean;
-        rolledBack: boolean;
-        reason: string;
-    };
-    /**
-     * Roll back a staged rollout.
-     */
-    rollback(rolloutId: string, reason: string): void;
-    /**
-     * Promote a rollout, permanently applying the change.
-     */
-    promote(rolloutId: string): void;
-    /**
-     * Get a proposal by ID.
-     */
-    getProposal(id: string): ChangeProposal | undefined;
-    /**
-     * Get all proposals, optionally filtered by status.
-     */
-    getProposals(status?: ProposalStatus): ChangeProposal[];
-    /**
-     * Get a rollout by ID.
-     */
-    getRollout(id: string): StagedRollout | undefined;
-    /**
-     * Get the full evolution history across all proposals.
-     */
-    getHistory(): EvolutionHistoryEntry[];
-    /**
-     * Produce an HMAC-SHA256 signature for a proposal.
-     *
-     * The signature covers every field except `signature` and `status`.
-     */
-    private signProposal;
-    /**
-     * Compute a composite hash from an array of trace hashes.
-     */
-    private hashTraceResults;
-    /**
-     * Classify how severe a single decision diff is.
-     */
-    private classifyDiffSeverity;
-    /**
-     * Compute an overall divergence score (0-1).
-     */
-    private computeDivergenceScore;
-    /**
-     * Aggregate an array of metric records into averages.
-     */
-    private aggregateMetrics;
-    /**
-     * Find the rollout associated with a proposal.
-     */
-    private findRolloutByProposal;
-}
-/**
- * Create an EvolutionPipeline instance.
- */
-export declare function createEvolutionPipeline(config?: EvolutionPipelineConfig): EvolutionPipeline;
-//# sourceMappingURL=evolution.d.ts.map

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

@@ -1,79 +0,0 @@
-/**
- * Hook-based Enforcement Gates
- *
- * Uses Claude Flow hooks to enforce non-negotiable rules.
- * The model can forget. The hook does not.
- *
- * Gates:
- * 1. Destructive ops gate - requires confirmation + rollback plan
- * 2. Tool allowlist gate - blocks non-allowlisted tools
- * 3. Diff size gate - requires plan + staged commits for large diffs
- * 4. Secrets gate - redacts and warns on secret patterns
- *
- * @module @claude-flow/guidance/gates
- */
-import type { GateConfig, GateResult, GateDecision, GuidanceRule } from './types.js';
-export declare class EnforcementGates {
-    private config;
-    private activeRules;
-    constructor(config?: Partial<GateConfig>);
-    /**
-     * Update active rules from retrieval
-     */
-    setActiveRules(rules: GuidanceRule[]): void;
-    /**
-     * Update configuration
-     */
-    updateConfig(config: Partial<GateConfig>): void;
-    /**
-     * Evaluate all gates for a command
-     */
-    evaluateCommand(command: string): GateResult[];
-    /**
-     * Evaluate all gates for a tool use
-     */
-    evaluateToolUse(toolName: string, params: Record<string, unknown>): GateResult[];
-    /**
-     * Evaluate all gates for a file edit
-     */
-    evaluateEdit(filePath: string, content: string, diffLines: number): GateResult[];
-    /**
-     * Gate 1: Destructive Operations
-     *
-     * If command includes delete, drop, rm, force, migration,
-     * require explicit confirmation and a rollback plan.
-     */
-    evaluateDestructiveOps(command: string): GateResult | null;
-    /**
-     * Gate 2: Tool Allowlist
-     *
-     * If tool not in allowlist, block and ask for permission.
-     */
-    evaluateToolAllowlist(toolName: string): GateResult | null;
-    /**
-     * Gate 3: Diff Size
-     *
-     * If patch exceeds threshold, require a plan and staged commits.
-     */
-    evaluateDiffSize(filePath: string, diffLines: number): GateResult | null;
-    /**
-     * Gate 4: Secrets Detection
-     *
-     * If output matches secret patterns, redact and warn.
-     */
-    evaluateSecrets(content: string): GateResult | null;
-    /**
-     * Get the most restrictive decision from multiple gate results
-     */
-    aggregateDecision(results: GateResult[]): GateDecision;
-    /**
-     * Get gate statistics
-     */
-    getActiveGateCount(): number;
-    private findTriggeredRules;
-}
-/**
- * Create enforcement gates
- */
-export declare function createGates(config?: Partial<GateConfig>): EnforcementGates;
-//# sourceMappingURL=gates.d.ts.map

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

@@ -1,206 +0,0 @@
-/**
- * Deterministic Tool Gateway
- *
- * Extends EnforcementGates with idempotency, schema validation,
- * and budget metering. Every tool call passes through a deterministic
- * pipeline: idempotency check -> schema validation -> budget check ->
- * enforcement gates -> allow/deny.
- *
- * @module @claude-flow/guidance/gateway
- */
-import { EnforcementGates } from './gates.js';
-import type { GateConfig } from './types.js';
-/**
- * Schema definition for a tool's parameters
- */
-export interface ToolSchema {
-    /** Tool name this schema applies to */
-    toolName: string;
-    /** Parameters that must be present */
-    requiredParams: string[];
-    /** Parameters that may be present */
-    optionalParams: string[];
-    /** Expected type for each parameter */
-    paramTypes: Record<string, 'string' | 'number' | 'boolean' | 'object' | 'array'>;
-    /** Maximum total serialized size of all parameters in bytes */
-    maxParamSize: number;
-    /** Optional whitelist of allowed values per parameter */
-    allowedValues?: Record<string, unknown[]>;
-}
-/**
- * Multi-dimensional budget tracking
- */
-export interface Budget {
-    tokenBudget: {
-        used: number;
-        limit: number;
-    };
-    toolCallBudget: {
-        used: number;
-        limit: number;
-    };
-    storageBudget: {
-        usedBytes: number;
-        limitBytes: number;
-    };
-    timeBudget: {
-        usedMs: number;
-        limitMs: number;
-    };
-    costBudget: {
-        usedUsd: number;
-        limitUsd: number;
-    };
-}
-/**
- * Record of a previous tool call for idempotency
- */
-export interface IdempotencyRecord {
-    /** SHA-256 of tool name + sorted params */
-    key: string;
-    /** Tool that was called */
-    toolName: string;
-    /** Hash of the parameters */
-    paramsHash: string;
-    /** Cached result from the call */
-    result: unknown;
-    /** When the call was recorded */
-    timestamp: number;
-    /** Time-to-live in milliseconds */
-    ttlMs: number;
-}
-/**
- * Decision returned by the gateway for each tool call evaluation
- */
-export interface GatewayDecision {
-    /** Whether the call is allowed */
-    allowed: boolean;
-    /** Human-readable reason for the decision */
-    reason: string;
-    /** Which gate produced the decision (or 'none' if allowed) */
-    gate: string;
-    /** Evidence of what was checked */
-    evidence: Record<string, unknown>;
-    /** Whether an idempotency cache hit occurred */
-    idempotencyHit: boolean;
-    /** Cached result if idempotency hit */
-    cachedResult?: unknown;
-    /** Remaining budget after this decision */
-    budgetRemaining?: Budget;
-}
-export interface ToolGatewayConfig {
-    /** Tool schemas for validation */
-    schemas?: ToolSchema[];
-    /** Budget limits (partial; defaults to Infinity for unset dimensions) */
-    budget?: Partial<Budget>;
-    /** Default TTL for idempotency records in milliseconds */
-    idempotencyTtlMs?: number;
-    /** Maximum idempotency cache entries (default 10000) */
-    maxCacheSize?: number;
-    /** If true, evidence must be non-empty for allow decisions */
-    requireEvidence?: boolean;
-    /** Gate configuration passed through to EnforcementGates */
-    gateConfig?: Partial<GateConfig>;
-}
-export declare class DeterministicToolGateway {
-    private readonly gates;
-    private readonly schemas;
-    private budget;
-    private readonly idempotencyTtlMs;
-    private readonly maxCacheSize;
-    private readonly requireEvidence;
-    private readonly idempotencyCache;
-    private lastCleanupTime;
-    private static readonly CLEANUP_INTERVAL_MS;
-    constructor(config?: ToolGatewayConfig);
-    /**
-     * Evaluate whether a tool call should be allowed.
-     *
-     * Pipeline:
-     * 1. Check idempotency cache
-     * 2. Validate params against schema
-     * 3. Check budget
-     * 4. Run EnforcementGates checks
-     * 5. Return decision with remaining budget
-     */
-    evaluate(toolName: string, params: Record<string, unknown>, context?: Record<string, unknown>): GatewayDecision;
-    /**
-     * Record a completed tool call.
-     * Updates budgets and stores the result in the idempotency cache.
-     */
-    recordCall(toolName: string, params: Record<string, unknown>, result: unknown, durationMs: number, tokenCount?: number): void;
-    /**
-     * Validate tool parameters against the registered schema.
-     * Returns valid:true if no schema is registered for the tool.
-     */
-    validateSchema(toolName: string, params: Record<string, unknown>): {
-        valid: boolean;
-        errors: string[];
-    };
-    /**
-     * Check whether all budget dimensions are within limits.
-     */
-    checkBudget(): {
-        withinBudget: boolean;
-        budgetStatus: Budget;
-    };
-    /**
-     * Compute a deterministic idempotency key from tool name and params.
-     * Uses SHA-256 of `toolName:sortedParamsJSON`.
-     */
-    getIdempotencyKey(toolName: string, params: Record<string, unknown>): string;
-    /**
-     * Reset all budget counters to zero.
-     */
-    resetBudget(): void;
-    /**
-     * Get a snapshot of the current budget.
-     */
-    getBudget(): Budget;
-    /**
-     * Get all idempotency records (including expired ones not yet cleaned).
-     */
-    getCallHistory(): IdempotencyRecord[];
-    /**
-     * Access the underlying EnforcementGates instance.
-     */
-    getGates(): EnforcementGates;
-    /**
-     * Remove expired idempotency records (batched on interval to avoid per-call overhead).
-     */
-    private maybeCleanExpiredIdempotency;
-    /**
-     * Compute a deterministic SHA-256 key from tool name and sorted params.
-     */
-    private computeIdempotencyKey;
-    /**
-     * Compute a SHA-256 hash of params only (for the IdempotencyRecord).
-     */
-    private computeParamsHash;
-    /**
-     * Recursively sort object keys for deterministic serialization.
-     */
-    private sortObject;
-    /**
-     * Determine the type string for a parameter value.
-     */
-    private getParamType;
-    /**
-     * Create a deep clone of the current budget.
-     */
-    private cloneBudget;
-    /**
-     * Merge a partial budget config with defaults.
-     */
-    private mergeBudget;
-    private cloneDefaultBudget;
-    /**
-     * Find which budget dimensions have been exceeded.
-     */
-    private findExceededBudgets;
-}
-/**
- * Create a DeterministicToolGateway instance
- */
-export declare function createToolGateway(config?: ToolGatewayConfig): DeterministicToolGateway;
-//# sourceMappingURL=gateway.d.ts.map