moflo 4.8.30 → 4.8.32

package/.claude/skills/worker-benchmarks/skill.md

@@ -1,135 +0,0 @@
----
-name: worker-benchmarks
-description: Run comprehensive worker system benchmarks and performance analysis
-version: 1.0.0
-invocable: true
-author: agentic-flow
-capabilities:
-  - performance_testing
-  - metrics_collection
-  - optimization_recommendations
----
-
-# Worker Benchmarks Skill
-
-Run comprehensive performance benchmarks for the agentic-flow worker system.
-
-## Quick Start
-
-```bash
-# Run full benchmark suite
-npx agentic-flow workers benchmark
-
-# Run specific benchmark
-npx agentic-flow workers benchmark --type trigger-detection
-npx agentic-flow workers benchmark --type registry
-npx agentic-flow workers benchmark --type agent-selection
-npx agentic-flow workers benchmark --type concurrent
-```
-
-## Benchmark Types
-
-### 1. Trigger Detection (`trigger-detection`)
-Tests keyword detection speed across 12 worker triggers.
-- **Target**: p95 < 5ms
-- **Iterations**: 1000
-- **Metrics**: latency, throughput, histogram
-
-### 2. Worker Registry (`registry`)
-Tests CRUD operations on worker entries.
-- **Target**: p95 < 10ms
-- **Iterations**: 500 creates, gets, updates
-- **Metrics**: per-operation latency breakdown
-
-### 3. Agent Selection (`agent-selection`)
-Tests performance-based agent selection.
-- **Target**: p95 < 1ms
-- **Iterations**: 1000
-- **Metrics**: selection confidence, agent scores
-
-### 4. Model Cache (`cache`)
-Tests model caching performance.
-- **Target**: p95 < 0.5ms
-- **Metrics**: hit rate, cache size, eviction stats
-
-### 5. Concurrent Workers (`concurrent`)
-Tests parallel worker creation and updates.
-- **Target**: < 1000ms for 10 workers
-- **Metrics**: per-worker latency, memory usage
-
-### 6. Memory Key Generation (`memory-keys`)
-Tests memory pattern key generation.
-- **Target**: p95 < 0.1ms
-- **Iterations**: 5000
-- **Metrics**: unique patterns, throughput
-
-## Output Format
-
-```
-═══════════════════════════════════════════════════════════
-📈 BENCHMARK RESULTS
-═══════════════════════════════════════════════════════════
-
-✅ Trigger Detection
-   Operation: detect
-   Count: 1,000
-   Avg: 0.045ms | p95: 0.120ms (target: 5ms)
-   Throughput: 22,222 ops/s
-   Memory Δ: 0.12MB
-
-✅ Worker Registry
-   Operation: crud
-   Count: 1,500
-   Avg: 1.234ms | p95: 3.456ms (target: 10ms)
-   Throughput: 810 ops/s
-   Memory Δ: 2.34MB
-
-───────────────────────────────────────────────────────────
-📊 SUMMARY
-───────────────────────────────────────────────────────────
-Total Tests: 6
-Passed: 6 | Failed: 0
-Avg Latency: 0.567ms
-Total Duration: 2345ms
-Peak Memory: 8.90MB
-═══════════════════════════════════════════════════════════
-```
-
-## Integration with Settings
-
-Benchmark thresholds are configured in `.claude/settings.json`:
-
-```json
-{
-  "performance": {
-    "benchmarkThresholds": {
-      "triggerDetection": { "p95Ms": 5 },
-      "workerRegistry": { "p95Ms": 10 },
-      "agentSelection": { "p95Ms": 1 },
-      "memoryKeyGeneration": { "p95Ms": 0.1 },
-      "concurrentWorkers": { "totalMs": 1000 }
-    }
-  }
-}
-```
-
-## Programmatic Usage
-
-```typescript
-import { workerBenchmarks, runBenchmarks } from 'agentic-flow/workers/worker-benchmarks';
-
-// Run full suite
-const suite = await runBenchmarks();
-console.log(suite.summary);
-
-// Run individual benchmarks
-const triggerResult = await workerBenchmarks.benchmarkTriggerDetection(1000);
-const registryResult = await workerBenchmarks.benchmarkRegistryOperations(500);
-```
-
-## Performance Optimization Tips
-
-1. **Model Cache**: Enable with `CLAUDE_FLOW_MODEL_CACHE_MB=512`
-2. **Parallel Workers**: Enable with `CLAUDE_FLOW_WORKER_PARALLEL=true`
-3. **Warning Suppression**: Enable with `CLAUDE_FLOW_SUPPRESS_WARNINGS=true`
-4. **SQLite WAL Mode**: Automatic for better concurrent performance

package/.claude/skills/worker-integration/skill.md

@@ -1,154 +0,0 @@
----
-name: worker-integration
-description: Worker-Agent integration for intelligent task dispatch and performance tracking
-version: 1.0.0
-invocable: true
-author: agentic-flow
-capabilities:
-  - agent_selection
-  - performance_tracking
-  - memory_coordination
-  - self_learning
----
-
-# Worker-Agent Integration Skill
-
-Intelligent coordination between background workers and specialized agents.
-
-## Quick Start
-
-```bash
-# View agent recommendations for a trigger
-npx agentic-flow workers agents ultralearn
-npx agentic-flow workers agents optimize
-
-# View performance metrics
-npx agentic-flow workers metrics
-
-# View integration stats
-npx agentic-flow workers stats --integration
-```
-
-## Agent Mappings
-
-Workers automatically dispatch to optimal agents based on trigger type:
-
-| Trigger | Primary Agents | Fallback | Pipeline Phases |
-|---------|---------------|----------|-----------------|
-| `ultralearn` | researcher, coder | planner | discovery → patterns → vectorization → summary |
-| `optimize` | performance-analyzer, coder | researcher | static-analysis → performance → patterns |
-| `audit` | security-analyst, tester | reviewer | security → secrets → vulnerability-scan |
-| `benchmark` | performance-analyzer | coder, tester | performance → metrics → report |
-| `testgaps` | tester | coder | discovery → coverage → gaps |
-| `document` | documenter, researcher | coder | api-discovery → patterns → indexing |
-| `deepdive` | researcher, security-analyst | coder | call-graph → deps → trace |
-| `refactor` | coder, reviewer | researcher | complexity → smells → patterns |
-
-## Performance-Based Selection
-
-The system learns from execution history to improve agent selection:
-
-```typescript
-// Agent selection considers:
-// 1. Quality score (0-1)
-// 2. Success rate
-// 3. Average latency
-// 4. Execution count
-
-const { agent, confidence, reasoning } = selectBestAgent('optimize');
-// agent: "performance-analyzer"
-// confidence: 0.87
-// reasoning: "Selected based on 45 executions with 94.2% success"
-```
-
-## Memory Key Patterns
-
-Workers store results using consistent patterns:
-
-```
-{trigger}/{topic}/{phase}
-
-Examples:
-- ultralearn/auth-module/analysis
-- optimize/database/performance
-- audit/payment/vulnerabilities
-- benchmark/api/metrics
-```
-
-## Benchmark Thresholds
-
-Agents are monitored against performance thresholds:
-
-```json
-{
-  "researcher": {
-    "p95_latency": "<500ms",
-    "memory_mb": "<256MB"
-  },
-  "coder": {
-    "p95_latency": "<300ms",
-    "quality_score": ">0.85"
-  },
-  "security-analyst": {
-    "scan_coverage": ">95%",
-    "p95_latency": "<1000ms"
-  }
-}
-```
-
-## Feedback Loop
-
-Workers provide feedback for continuous improvement:
-
-```typescript
-import { workerAgentIntegration } from 'agentic-flow/workers/worker-agent-integration';
-
-// Record execution feedback
-workerAgentIntegration.recordFeedback(
-  'optimize',           // trigger
-  'coder',              // agent
-  true,                 // success
-  245,                  // latency ms
-  0.92                  // quality score
-);
-
-// Check compliance
-const { compliant, violations } = workerAgentIntegration.checkBenchmarkCompliance('coder');
-```
-
-## Integration Statistics
-
-```bash
-$ npx agentic-flow workers stats --integration
-
-Worker-Agent Integration Stats
-══════════════════════════════
-Total Agents:       6
-Tracked Agents:     4
-Total Feedback:     156
-Avg Quality Score:  0.89
-
-Model Cache Stats
-─────────────────
-Hits:     1,234
-Misses:   45
-Hit Rate: 96.5%
-```
-
-## Configuration
-
-Enable integration features in `.claude/settings.json`:
-
-```json
-{
-  "workers": {
-    "enabled": true,
-    "parallel": true,
-    "memoryDepositEnabled": true,
-    "agentMappings": {
-      "ultralearn": ["researcher", "coder"],
-      "optimize": ["performance-analyzer", "coder"]
-    }
-  }
-}
-```

package/.claude/workflow-state.json

@@ -1,9 +0,0 @@
-{
-  "tasksCreated": true,
-  "taskCount": 6,
-  "memorySearched": false,
-  "sessionStart": "2026-03-23T02:45:57.764Z",
-  "memoryRequired": true,
-  "interactionCount": 59,
-  "lastBlockedAt": "2026-03-24T02:39:25.674Z"
-}

package/src/@claude-flow/cli/dist/src/appliance/gguf-engine.d.ts

@@ -1,91 +0,0 @@
-/**
- * ruvLLM GGUF Inference Engine -- Pure Node.js GGUF Model Interface
- *
- * Provides:
- *   1. GGUF binary header parsing (metadata without loading weights)
- *   2. Model loading abstraction (node-llama-cpp when available, metadata-only fallback)
- *   3. Token generation interface with async iterator streaming
- *   4. KV-cache persistence to RVF-compatible binary format
- *
- * Zero external dependencies. node-llama-cpp is an optional peer.
- *
- * @module @claude-flow/cli/appliance/gguf-engine
- */
-export interface GgufMetadata {
-    magic: string;
-    version: number;
-    tensorCount: number;
-    kvCount: number;
-    architecture?: string;
-    name?: string;
-    contextLength?: number;
-    embeddingLength?: number;
-    blockCount?: number;
-    vocabSize?: number;
-    quantization?: string;
-    fileSize: number;
-    metadata: Record<string, unknown>;
-}
-export interface GgufEngineConfig {
-    contextSize?: number;
-    maxTokens?: number;
-    temperature?: number;
-    kvCachePath?: string;
-    verbose?: boolean;
-}
-export interface GenerateRequest {
-    prompt: string;
-    model?: string;
-    maxTokens?: number;
-    temperature?: number;
-    stream?: boolean;
-    stopSequences?: string[];
-}
-export interface GenerateResponse {
-    text: string;
-    model: string;
-    tokensUsed: number;
-    latencyMs: number;
-    metadataOnly: boolean;
-}
-/**
- * Parse the header and metadata from a GGUF file without loading tensors.
- * Reads only the first 256 KB of the file.
- */
-export declare function parseGgufHeader(path: string): Promise<GgufMetadata>;
-export declare class GgufEngine {
-    private config;
-    private llamaCpp;
-    private llamaModel;
-    private llamaContext;
-    private loadedModels;
-    private activeModelPath;
-    private kvCache;
-    constructor(config: GgufEngineConfig);
-    /** Probe for node-llama-cpp availability. */
-    initialize(): Promise<void>;
-    /** Parse GGUF header and optionally load the model for inference. */
-    loadModel(path: string): Promise<GgufMetadata>;
-    /** Generate text. Delegates to node-llama-cpp or returns a metadata-only stub. */
-    generate(request: GenerateRequest): Promise<GenerateResponse>;
-    /** Stream tokens via async iterator. Falls back to yielding full response. */
-    stream(request: GenerateRequest): AsyncGenerator<string>;
-    /**
-     * Persist the KV cache to an RVF-compatible binary file.
-     * Format: RVKV magic | version u32 | model SHA-256 (32B) | entry count u32
-     *         entries: [key_len u32, key, val_len u32, val] | footer SHA-256 (32B)
-     */
-    persistKvCache(outputPath: string): Promise<void>;
-    /** Restore KV cache from an RVF-compatible binary file. */
-    loadKvCache(inputPath: string): Promise<void>;
-    /** Return metadata for all loaded models. */
-    getLoadedModels(): GgufMetadata[];
-    /** Store a key-value pair in the in-memory KV cache. */
-    setKvEntry(key: string, value: Buffer): void;
-    /** Retrieve a key-value pair from the in-memory KV cache. */
-    getKvEntry(key: string): Buffer | undefined;
-    /** Release resources, unload models, and optionally persist the KV cache. */
-    shutdown(): Promise<void>;
-    private tryLoadLlamaCpp;
-}
-//# sourceMappingURL=gguf-engine.d.ts.map

package/src/@claude-flow/cli/dist/src/appliance/ruvllm-bridge.d.ts

@@ -1,102 +0,0 @@
-/**
- * ruvLLM Bridge -- Local Language Model Inference from RuVector
- *
- * Extends @ruvector/core with on-device GGUF model inference.
- * Provides 3-tier routing:
- *   Tier 1: Agent Booster (WASM, <1ms) -- simple transforms
- *   Tier 2: Local model via ruvLLM (~200ms) -- routing, classification
- *   Tier 3: Cloud API (2-5s) -- complex reasoning
- *
- * All @ruvector/* packages are optional peer dependencies.
- * The bridge degrades gracefully when they are absent.
- *
- * @module @claude-flow/cli/appliance/ruvllm-bridge
- */
-export interface RuvllmConfig {
-    modelsDir: string;
-    defaultModel?: string;
-    maxTokens?: number;
-    temperature?: number;
-    contextSize?: number;
-    kvCachePath?: string;
-    verbose?: boolean;
-}
-export interface GenerateRequest {
-    prompt: string;
-    model?: string;
-    maxTokens?: number;
-    temperature?: number;
-    stream?: boolean;
-    stopSequences?: string[];
-}
-export interface GenerateResponse {
-    text: string;
-    model: string;
-    tokensUsed: number;
-    latencyMs: number;
-    tier: 1 | 2 | 3;
-    cached: boolean;
-}
-export interface ModelInfo {
-    name: string;
-    path: string;
-    format: string;
-    quantization: string;
-    size: number;
-    parameters: string;
-    loaded: boolean;
-}
-export interface TierRouting {
-    tier: 1 | 2 | 3;
-    model: string;
-    confidence: number;
-}
-export interface BridgeStatus {
-    available: boolean;
-    ruvectorCore: boolean;
-    ruvectorRouter: boolean;
-    ruvectorSona: boolean;
-    modelsLoaded: string[];
-    kvCacheSize: number;
-}
-export declare class RuvllmBridge {
-    private config;
-    private models;
-    private activeModel;
-    private kvCacheEntries;
-    private ruvectorCore;
-    private ruvectorRouter;
-    private ruvectorSona;
-    private ggufEngine;
-    constructor(config: RuvllmConfig);
-    /** Probe optional @ruvector packages, initialize GGUF engine, and scan modelsDir. */
-    initialize(): Promise<void>;
-    /** Return all discovered GGUF models. */
-    listModels(): Promise<ModelInfo[]>;
-    /** Load a model into memory (delegates to GGUF engine or @ruvector/core). */
-    loadModel(name: string): Promise<void>;
-    /**
-     * Generate text from a prompt. Routes through tiers:
-     * 1. Agent Booster (trivial transforms, no LLM).
-     * 2. Local GGUF model via @ruvector/core.
-     * 3. Cloud fallback (empty response -- caller handles upstream).
-     */
-    generate(request: GenerateRequest): Promise<GenerateResponse>;
-    /** Route a task description to the optimal tier. Uses @ruvector/router when available. */
-    routeTask(description: string): Promise<TierRouting>;
-    /** Return current bridge status. */
-    getStatus(): Promise<BridgeStatus>;
-    /** Persist KV-cache, unload models, and clean up. */
-    shutdown(): Promise<void>;
-    private scanModelsDir;
-    private tryImport;
-    /** Tier-1 Agent Booster: handle trivial transforms without any LLM. */
-    private tryAgentBooster;
-}
-/** Get or create the singleton RuvllmBridge. Config required on first call. */
-export declare function getRuvllmBridge(config?: RuvllmConfig): RuvllmBridge;
-/** Reset the singleton (useful for tests). */
-export declare function resetRuvllmBridge(): void;
-/** Check whether @ruvector/core is importable without loading the bridge. */
-export declare function isRuvllmAvailable(): Promise<boolean>;
-//# sourceMappingURL=ruvllm-bridge.d.ts.map

package/src/@claude-flow/cli/dist/src/appliance/rvfa-builder.d.ts

@@ -1,44 +0,0 @@
-/**
- * RVFA Appliance Builder -- Constructs self-contained .rvf appliance files.
- *
- * Creates a single binary containing kernel, runtime, Ruflo CLI, models/keys,
- * AgentDB data, and the verification suite. See ADR-058.
- */
-export interface BuildOptions {
-    profile: 'cloud' | 'hybrid' | 'offline';
-    arch: string;
-    output: string;
-    rufloVersion?: string;
-    models?: string[];
-    apiKeys?: string;
-    verbose?: boolean;
-}
-export interface BuildResult {
-    outputPath: string;
-    size: number;
-    sections: {
-        id: string;
-        size: number;
-        originalSize: number;
-    }[];
-    duration: number;
-    profile: string;
-}
-/** Encrypt API keys from a .env file. Output: salt(32)+iv(16)+tag(16)+ciphertext */
-export declare function encryptApiKeys(envPath: string, passphrase: string): Buffer;
-/** Decrypt API keys previously encrypted with encryptApiKeys. */
-export declare function decryptApiKeys(buf: Buffer, passphrase: string): Record<string, string>;
-export declare class RvfaBuilder {
-    private opts;
-    constructor(options: BuildOptions);
-    build(): Promise<BuildResult>;
-    private buildKernelSection;
-    private buildRuntimeSection;
-    private buildRufloSection;
-    private buildModelsSection;
-    private buildDataSection;
-    private buildVerifySection;
-    private buildHeaderPartial;
-    private log;
-}
-//# sourceMappingURL=rvfa-builder.d.ts.map

package/src/@claude-flow/cli/dist/src/appliance/rvfa-distribution.d.ts

@@ -1,97 +0,0 @@
-/**
- * RVFA Distribution & Hot-Patch Module
- *
- * IPFS publishing of RVFA appliances via Pinata and RVFP binary patches
- * for section-level hot updates with atomic rollback.
- *
- * RVFP layout: [4B "RVFP"] [4B version u32LE] [4B header_len u32LE]
- *              [header JSON] [new section data] [32B SHA256 footer]
- */
-export interface RvfpHeader {
-    magic: 'RVFP';
-    version: number;
-    targetApplianceName: string;
-    targetApplianceVersion: string;
-    targetSection: string;
-    patchVersion: string;
-    created: string;
-    newSectionSize: number;
-    newSectionSha256: string;
-    compression: 'none' | 'gzip';
-    signature?: string;
-    signedBy?: string;
-}
-export interface CreatePatchOptions {
-    targetName: string;
-    targetVersion: string;
-    sectionId: string;
-    sectionData: Buffer;
-    patchVersion: string;
-    compression?: 'none' | 'gzip';
-    privateKey?: Buffer;
-    signedBy?: string;
-}
-export interface ApplyOptions {
-    backup?: boolean;
-    verify?: boolean;
-    publicKey?: Buffer;
-}
-export interface ApplyResult {
-    success: boolean;
-    backupPath?: string;
-    newSize: number;
-    patchedSection: string;
-    errors: string[];
-}
-export interface PatchVerifyResult {
-    valid: boolean;
-    header: RvfpHeader;
-    errors: string[];
-}
-export interface PublishConfig {
-    pinataJwt?: string;
-    gatewayUrl?: string;
-    apiUrl?: string;
-}
-export interface PublishMetadata {
-    name?: string;
-    description?: string;
-    version?: string;
-    profile?: string;
-}
-export interface PublishResult {
-    cid: string;
-    size: number;
-    gatewayUrl: string;
-    pinataUrl: string;
-}
-export interface PublishedItem {
-    cid: string;
-    name: string;
-    size: number;
-    date: string;
-}
-export declare class RvfaPatcher {
-    static createPatch(opts: CreatePatchOptions): Promise<Buffer>;
-    static parsePatchHeader(buf: Buffer): RvfpHeader;
-    static verifyPatch(buf: Buffer): Promise<PatchVerifyResult>;
-    static applyPatch(rvfaPath: string, patchBuf: Buffer, opts?: ApplyOptions): Promise<ApplyResult>;
-}
-export declare class RvfaPublisher {
-    private jwt;
-    private gw;
-    private api;
-    constructor(config: PublishConfig);
-    private upload;
-    publish(rvfaPath: string, meta?: PublishMetadata): Promise<PublishResult>;
-    publishPatch(patchBuf: Buffer, meta?: PublishMetadata): Promise<PublishResult>;
-    fetch(cid: string, outputPath: string): Promise<void>;
-    list(): Promise<PublishedItem[]>;
-    pin(cid: string, name?: string): Promise<void>;
-}
-export declare function createPublisher(config?: Partial<PublishConfig>): RvfaPublisher;
-export declare function createAndVerifyPatch(options: CreatePatchOptions): Promise<{
-    patch: Buffer;
-    verification: PatchVerifyResult;
-}>;
-//# sourceMappingURL=rvfa-distribution.d.ts.map