moflo 4.8.31 → 4.8.32

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

@@ -1,225 +0,0 @@
-/**
- * Agent Cell Conformance Kit
- *
- * Canonical acceptance test proving the entire guidance control plane works
- * end-to-end. Implements the "Memory Clerk" agent cell pattern:
- *
- * 1. Read 20 memory entries (knowledge retrieval)
- * 2. Run 1 model inference (reasoning)
- * 3. Propose 5 memory writes based on inference
- * 4. Inject a coherence drop at write #3
- * 5. Verify the system switches to read-only and blocks remaining writes
- * 6. Emit a signed proof envelope
- * 7. Return a complete, replayable trace
- *
- * @module @claude-flow/guidance/conformance-kit
- */
-import { MemoryWriteGate } from './memory-gate.js';
-import type { MemoryAuthority } from './memory-gate.js';
-import { ProofChain } from './proof.js';
-import type { MemoryOperation } from './proof.js';
-import { RunLedger } from './ledger.js';
-import { CoherenceScheduler, EconomicGovernor } from './coherence.js';
-import { DeterministicToolGateway } from './gateway.js';
-/**
- * A single event in the agent cell execution trace.
- */
-export interface TraceEvent {
-    /** Monotonically increasing sequence number starting at 0 */
-    seq: number;
-    /** Epoch-ms timestamp when the event was recorded */
-    ts: number;
-    /** Event classification */
-    type: 'memory_read' | 'memory_write_proposed' | 'memory_write_committed' | 'memory_write_blocked' | 'model_infer' | 'tool_invoke' | 'coherence_check' | 'privilege_change' | 'run_start' | 'run_end';
-    /** Arbitrary structured data describing the event */
-    payload: Record<string, unknown>;
-    /** Human-readable decision string for replay verification */
-    decision: string;
-    /** Snapshot of budget counters at event time */
-    budgetSnapshot: Record<string, number>;
-}
-/**
- * Complete result of an agent cell run including the full trace,
- * memory operation counts, proof hash, and budget usage.
- */
-export interface CellRunResult {
-    cellId: string;
-    runId: string;
-    traceEvents: TraceEvent[];
-    memoryReads: number;
-    memoryWritesAttempted: number;
-    memoryWritesCommitted: number;
-    memoryWritesBlocked: number;
-    proofEnvelopeHash: string;
-    coherenceHistory: number[];
-    budgetUsage: Record<string, number>;
-    outcome: 'completed' | 'restricted' | 'suspended';
-}
-/**
- * Runtime services provided to an agent cell.
- */
-export interface CellRuntime {
-    readMemory(key: string, namespace: string): unknown;
-    writeMemory(key: string, namespace: string, value: unknown, evidence?: Record<string, unknown>): {
-        allowed: boolean;
-        reason: string;
-    };
-    invokeModel(prompt: string): string;
-    invokeTool(name: string, params: Record<string, unknown>): {
-        result: unknown;
-        allowed: boolean;
-    };
-    getCoherenceScore(): number;
-    setCoherenceScore(score: number): void;
-    getProofChain(): ProofChain;
-    getLedger(): RunLedger;
-}
-/**
- * An agent cell is a self-contained unit of work that executes against
- * a CellRuntime, producing a fully traced CellRunResult.
- */
-export interface AgentCell {
-    cellId: string;
-    name: string;
-    run(runtime: CellRuntime): CellRunResult;
-}
-export interface SimulatedRuntimeConfig {
-    memoryGate: MemoryWriteGate;
-    proofChain: ProofChain;
-    ledger: RunLedger;
-    coherenceScheduler: CoherenceScheduler;
-    economicGovernor: EconomicGovernor;
-    toolGateway?: DeterministicToolGateway;
-    authority: MemoryAuthority;
-    initialCoherenceScore?: number;
-    initialMemory?: Map<string, {
-        namespace: string;
-        value: unknown;
-    }>;
-}
-/**
- * A test runtime that wires together all guidance control plane components
- * and records every operation as a TraceEvent.
- */
-export declare class SimulatedRuntime implements CellRuntime {
-    private readonly memoryGate;
-    private readonly proofChain;
-    private readonly ledger;
-    private readonly coherenceScheduler;
-    private readonly economicGovernor;
-    private readonly toolGateway;
-    private readonly authority;
-    private coherenceScore;
-    private readonly memoryStore;
-    private readonly memoryEntries;
-    private readonly traceEvents;
-    private readonly coherenceHistory;
-    private seq;
-    private memoryReadCount;
-    private memoryWritesAttemptedCount;
-    private memoryWritesCommittedCount;
-    private memoryWritesBlockedCount;
-    private readonly memoryOps;
-    constructor(config: SimulatedRuntimeConfig);
-    readMemory(key: string, namespace: string): unknown;
-    writeMemory(key: string, namespace: string, value: unknown, evidence?: Record<string, unknown>): {
-        allowed: boolean;
-        reason: string;
-    };
-    invokeModel(prompt: string): string;
-    invokeTool(name: string, params: Record<string, unknown>): {
-        result: unknown;
-        allowed: boolean;
-    };
-    getCoherenceScore(): number;
-    setCoherenceScore(score: number): void;
-    getProofChain(): ProofChain;
-    getLedger(): RunLedger;
-    /**
-     * Emit a custom trace event. Exposed so agent cells can record
-     * lifecycle events (run_start, run_end) through the same trace stream.
-     */
-    emitCustomTrace(type: TraceEvent['type'], payload: Record<string, unknown>, decision: string): void;
-    getTraceEvents(): TraceEvent[];
-    getCoherenceHistory(): number[];
-    getMemoryReads(): number;
-    getMemoryWritesAttempted(): number;
-    getMemoryWritesCommitted(): number;
-    getMemoryWritesBlocked(): number;
-    getMemoryOps(): MemoryOperation[];
-    getBudgetUsage(): Record<string, number>;
-    private resolvePrivilegeLevel;
-    private emitTrace;
-}
-/**
- * The canonical test agent cell. Exercises every layer of the guidance
- * control plane by performing reads, inference, and gated writes with
- * a deliberate coherence drop mid-run.
- */
-export declare class MemoryClerkCell implements AgentCell {
-    readonly cellId: string;
-    readonly name = "MemoryClerk";
-    private readonly readCount;
-    private readonly inferenceCount;
-    private readonly writeCount;
-    private readonly coherenceDropAtWrite;
-    private readonly droppedCoherenceScore;
-    constructor(cellId?: string, options?: {
-        readCount?: number;
-        inferenceCount?: number;
-        writeCount?: number;
-        coherenceDropAtWrite?: number;
-        droppedCoherenceScore?: number;
-    });
-    run(runtime: CellRuntime): CellRunResult;
-}
-export interface ConformanceTestResult {
-    passed: boolean;
-    checks: Array<{
-        name: string;
-        passed: boolean;
-        expected: unknown;
-        actual: unknown;
-        details: string;
-    }>;
-    trace: TraceEvent[];
-    proofHash: string;
-    duration: number;
-}
-export interface ReplayTestResult {
-    identical: boolean;
-    totalEvents: number;
-    divergences: Array<{
-        seq: number;
-        originalDecision: string;
-        replayDecision: string;
-    }>;
-}
-/**
- * Orchestrates conformance tests by creating all control plane components,
- * running the MemoryClerkCell, and verifying every invariant.
- */
-export declare class ConformanceRunner {
-    private readonly authority;
-    private readonly signingKey;
-    constructor(authority?: MemoryAuthority, signingKey?: string);
-    /**
-     * Run the full conformance test suite and return a structured result
-     * with individual pass/fail checks.
-     */
-    runConformanceTest(): ConformanceTestResult;
-    /**
-     * Replay a previously captured trace and verify that every decision
-     * is reproduced identically by the control plane logic.
-     */
-    runReplayTest(originalTrace: TraceEvent[]): ReplayTestResult;
-}
-/**
- * Create a MemoryClerkCell with an optional cellId override.
- */
-export declare function createMemoryClerkCell(cellId?: string): MemoryClerkCell;
-/**
- * Create a ConformanceRunner with optional authority override.
- */
-export declare function createConformanceRunner(authority?: MemoryAuthority, signingKey?: string): ConformanceRunner;
-//# sourceMappingURL=conformance-kit.d.ts.map

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

@@ -1,214 +0,0 @@
-/**
- * Continue Gate - Long-Running Agent Control
- *
- * Evaluates whether a long-running agent should continue its next step.
- * Prevents runaway loops, budget exhaustion, and coherence degradation.
- *
- * Problem:
- * Current gates are tool-centric (PreToolUse, PreCommand, PreEdit).
- * Long-run loops are often internally generated — the agent keeps going
- * without a single obviously bad tool call. There is no gate for "should
- * this agent continue at all?"
- *
- * ContinueGate provides step-level evaluation with:
- * - Hard limits on consecutive steps without checkpoints
- * - Budget acceleration detection via linear regression
- * - Coherence threshold enforcement
- * - Uncertainty threshold enforcement
- * - Rework ratio tracking
- * - Automatic checkpoint intervals
- * - Cooldown between evaluations
- *
- * Decision types:
- * - continue: Agent may proceed to next step
- * - checkpoint: Agent must save state before continuing
- * - throttle: Agent should slow down or wait
- * - pause: Agent should stop and await human review
- * - stop: Agent must halt immediately
- *
- * @module @claude-flow/guidance/continue-gate
- */
-/**
- * Configuration for the ContinueGate
- */
-export interface ContinueGateConfig {
-    /** Hard limit on consecutive steps without checkpoint (default 100) */
-    maxConsecutiveSteps: number;
-    /** Maximum budget slope per step (cost acceleration threshold, default 0.02) */
-    maxBudgetSlopePerStep: number;
-    /** Minimum coherence score to continue (default 0.4) */
-    minCoherenceForContinue: number;
-    /** Maximum uncertainty score to continue (default 0.8) */
-    maxUncertaintyForContinue: number;
-    /** Maximum rework/total steps ratio (default 0.3) */
-    maxReworkRatio: number;
-    /** Force checkpoint every N steps (default 25) */
-    checkpointIntervalSteps: number;
-    /** Minimum time between evaluations in milliseconds (default 5000) */
-    cooldownMs: number;
-}
-/**
- * Context for a single step evaluation
- */
-export interface StepContext {
-    /** Current step number in the run */
-    stepNumber: number;
-    /** Total tokens consumed so far */
-    totalTokensUsed: number;
-    /** Total tool calls made so far */
-    totalToolCalls: number;
-    /** Number of steps that redid previous work */
-    reworkCount: number;
-    /** Coherence score from CoherenceScheduler (0-1) */
-    coherenceScore: number;
-    /** Uncertainty score from UncertaintyAggregator (0-1) */
-    uncertaintyScore: number;
-    /** Elapsed time in milliseconds since run start */
-    elapsedMs: number;
-    /** Step number of the last checkpoint */
-    lastCheckpointStep: number;
-    /** Remaining budget across all dimensions */
-    budgetRemaining: {
-        tokens: number;
-        toolCalls: number;
-        timeMs: number;
-    };
-    /** Recent evaluation decisions (last 10) */
-    recentDecisions: Array<{
-        step: number;
-        decision: 'allow' | 'deny' | 'warn';
-    }>;
-}
-/**
- * Decision outcome from the continue gate
- */
-export interface ContinueDecision {
-    /** The decision type */
-    decision: 'continue' | 'checkpoint' | 'throttle' | 'pause' | 'stop';
-    /** Human-readable reasons for the decision */
-    reasons: string[];
-    /** Computed metrics for this evaluation */
-    metrics: {
-        /** Budget acceleration rate (tokens per step slope) */
-        budgetSlope: number;
-        /** Ratio of rework steps to total steps */
-        reworkRatio: number;
-        /** Steps until next required checkpoint */
-        stepsUntilCheckpoint: number;
-        /** Coherence health level */
-        coherenceLevel: 'healthy' | 'degraded' | 'critical';
-        /** Uncertainty level */
-        uncertaintyLevel: 'low' | 'moderate' | 'high' | 'extreme';
-    };
-    /** Recommended action for the agent */
-    recommendedAction?: string;
-}
-/**
- * Gate that evaluates whether a long-running agent should continue.
- *
- * Prevents runaway execution by checking:
- * - Step limits
- * - Budget exhaustion and acceleration
- * - Coherence degradation
- * - Uncertainty thresholds
- * - Rework ratios
- * - Checkpoint intervals
- *
- * Maintains history of evaluations and provides aggregate statistics.
- */
-export declare class ContinueGate {
-    private readonly config;
-    private readonly history;
-    private lastEvaluationTime;
-    private readonly tokenHistory;
-    constructor(config?: Partial<ContinueGateConfig>);
-    /**
-     * Evaluate whether the agent should continue.
-     *
-     * Applies decision logic in priority order:
-     * 1. Coherence below threshold → stop
-     * 2. Step limit exceeded → stop
-     * 3. Budget exhausted → stop
-     * 4. High rework ratio → pause
-     * 5. High uncertainty → pause
-     * 6. Budget acceleration → throttle
-     * 7. Checkpoint interval reached → checkpoint
-     * 8. Otherwise → continue
-     *
-     * @param context - Current step context
-     * @returns Decision with reasons and metrics
-     */
-    evaluate(context: StepContext): ContinueDecision;
-    /**
-     * Evaluate and record the decision in history.
-     *
-     * This method also checks the cooldown period — if called too soon
-     * after the last evaluation, it returns a 'continue' decision without
-     * full evaluation to prevent excessive overhead.
-     *
-     * @param context - Current step context
-     * @returns Decision with reasons and metrics
-     */
-    evaluateWithHistory(context: StepContext): ContinueDecision;
-    /**
-     * Get the full evaluation history.
-     *
-     * Returns up to MAX_HISTORY_SIZE most recent evaluations.
-     *
-     * @returns Array of evaluation records ordered oldest to newest
-     */
-    getHistory(): Array<{
-        step: number;
-        decision: ContinueDecision;
-        timestamp: number;
-    }>;
-    /**
-     * Get aggregate statistics across all evaluations.
-     *
-     * @returns Statistics including total evaluations, decision counts, and average budget slope
-     */
-    getStats(): {
-        totalEvaluations: number;
-        decisions: Record<string, number>;
-        averageBudgetSlope: number;
-    };
-    /**
-     * Reset all internal state.
-     *
-     * Clears history, token tracking, and last evaluation time.
-     */
-    reset(): void;
-    /**
-     * Get the current configuration.
-     */
-    getConfig(): ContinueGateConfig;
-    /**
-     * Compute the budget slope (rate of token consumption per step)
-     * using linear regression on the last N steps.
-     *
-     * Returns the slope coefficient (tokens per step). A positive slope
-     * indicates increasing token usage. A slope above the configured
-     * threshold indicates budget acceleration.
-     */
-    private computeBudgetSlope;
-    /**
-     * Map coherence score to a health level.
-     */
-    private getCoherenceLevel;
-    /**
-     * Map uncertainty score to a level.
-     */
-    private getUncertaintyLevel;
-    /**
-     * Create a standardized decision object.
-     */
-    private createDecision;
-}
-/**
- * Create a ContinueGate instance with optional configuration.
- *
- * @param config - Partial configuration; unspecified values use defaults
- * @returns A fresh ContinueGate instance
- */
-export declare function createContinueGate(config?: Partial<ContinueGateConfig>): ContinueGate;
-//# sourceMappingURL=continue-gate.d.ts.map

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

@@ -1,17 +0,0 @@
-/**
- * Shared Cryptographic Utilities
- *
- * Centralises timing-safe comparison so every module that verifies
- * HMAC signatures uses the same constant-time implementation.
- *
- * @module @claude-flow/guidance/crypto-utils
- */
-/**
- * Constant-time string comparison to prevent timing attacks on HMAC signatures.
- *
- * Delegates to Node.js `crypto.timingSafeEqual` via `Buffer.from` for
- * encoding-safe comparison. Falls back to a manual XOR loop when the
- * buffers have different byte lengths (which the native function rejects).
- */
-export declare function timingSafeEqual(a: string, b: string): boolean;
-//# sourceMappingURL=crypto-utils.d.ts.map