@sparkleideas/integration 3.0.2 → 3.0.4

package/src/agentic-flow-bridge.ts

@@ -1,10 +1,10 @@
 /**
  * Agentic Flow Integration Bridge
  *
- * Core integration bridge for @sparkleideas/agentic-flow@alpha deep integration.
- * Implements ADR-001: Adopt @sparkleideas/agentic-flow as Core Foundation
+ * Core integration bridge for agentic-flow@alpha deep integration.
+ * Implements ADR-001: Adopt agentic-flow as Core Foundation
  *
- * Eliminates 10,000+ lines of duplicate code by building on @sparkleideas/agentic-flow
+ * Eliminates 10,000+ lines of duplicate code by building on agentic-flow
  * rather than implementing parallel systems.
  *
  * @module v3/integration/agentic-flow-bridge
@@ -28,8 +28,8 @@ import { AttentionCoordinator } from './attention-coordinator.js';
 import { SDKBridge } from './sdk-bridge.js';
 
 /**
- * Interface for @sparkleideas/agentic-flow core module (dynamically loaded)
- * This represents the external @sparkleideas/agentic-flow@alpha package API
+ * Interface for agentic-flow core module (dynamically loaded)
+ * This represents the external agentic-flow@alpha package API
  */
 interface AgenticFlowSONAInterface {
   setMode(mode: string): Promise<void>;
@@ -51,26 +51,26 @@ interface AgenticFlowAgentDBInterface {
 }
 
 /**
- * Core interface for @sparkleideas/agentic-flow@alpha package
+ * Core interface for agentic-flow@alpha package
  * Used for deep integration and code deduplication per ADR-001
  */
 export interface AgenticFlowCore {
   sona: AgenticFlowSONAInterface;
   attention: AgenticFlowAttentionInterface;
-  @sparkleideas/agentdb: AgenticFlowAgentDBInterface;
+  agentdb: AgenticFlowAgentDBInterface;
   version: string;
   isConnected: boolean;
 }
 
 /**
- * Factory function type for creating @sparkleideas/agentic-flow instance
+ * Factory function type for creating agentic-flow instance
  */
 type AgenticFlowFactory = (config: unknown) => Promise<AgenticFlowCore>;
 
 /**
- * AgenticFlowBridge - Core integration class for @sparkleideas/agentic-flow@alpha
+ * AgenticFlowBridge - Core integration class for agentic-flow@alpha
  *
- * This class serves as the main entry point for all @sparkleideas/agentic-flow integration,
+ * This class serves as the main entry point for all agentic-flow integration,
  * providing unified access to SONA learning, Flash Attention, and AgentDB.
  *
  * Performance Targets:
@@ -90,14 +90,14 @@ export class AgenticFlowBridge extends EventEmitter {
   private initializationPromise: Promise<void> | null = null;
 
   /**
-   * Reference to the @sparkleideas/agentic-flow@alpha core instance
+   * Reference to the agentic-flow@alpha core instance
    * When available, components delegate to this instead of local implementations
-   * This follows ADR-001: Adopt @sparkleideas/agentic-flow as Core Foundation
+   * This follows ADR-001: Adopt agentic-flow as Core Foundation
    */
   private agenticFlowCore: AgenticFlowCore | null = null;
 
   /**
-   * Indicates whether @sparkleideas/agentic-flow is available for delegation
+   * Indicates whether agentic-flow is available for delegation
    */
   private agenticFlowAvailable: boolean = false;
 
@@ -149,7 +149,7 @@ export class AgenticFlowBridge extends EventEmitter {
       this.runtimeInfo = await this.detectRuntime();
       this.logDebug('Runtime detected', this.runtimeInfo);
 
-      // ADR-001: Attempt to load @sparkleideas/agentic-flow@alpha dynamically
+      // ADR-001: Attempt to load agentic-flow@alpha dynamically
       // This enables deep integration and code deduplication
       await this.connectToAgenticFlow();
 
@@ -165,11 +165,11 @@ export class AgenticFlowBridge extends EventEmitter {
       this.updateComponentHealth('sdk', 'healthy');
 
       // Initialize SONA adapter if enabled
-      // Pass @sparkleideas/agentic-flow reference for delegation when available
+      // Pass agentic-flow reference for delegation when available
       if (this.config.features.enableSONA) {
         this.sona = new SONAAdapter(this.config.sona);
         if (this.agenticFlowCore) {
-          // Type cast: @sparkleideas/agentic-flow runtime API is compatible but typed as `unknown`
+          // Type cast: agentic-flow runtime API is compatible but typed as `unknown`
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           this.sona.setAgenticFlowReference(this.agenticFlowCore.sona as any);
         }
@@ -178,11 +178,11 @@ export class AgenticFlowBridge extends EventEmitter {
       }
 
       // Initialize Attention coordinator if enabled
-      // Pass @sparkleideas/agentic-flow reference for delegation when available
+      // Pass agentic-flow reference for delegation when available
       if (this.config.features.enableFlashAttention) {
         this.attention = new AttentionCoordinator(this.config.attention);
         if (this.agenticFlowCore) {
-          // Type cast: @sparkleideas/agentic-flow runtime API is compatible but typed as `unknown`
+          // Type cast: agentic-flow runtime API is compatible but typed as `unknown`
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           this.attention.setAgenticFlowReference(this.agenticFlowCore.attention as any);
         }
@@ -207,22 +207,22 @@ export class AgenticFlowBridge extends EventEmitter {
   }
 
   /**
-   * Connect to @sparkleideas/agentic-flow@alpha package dynamically
+   * Connect to agentic-flow@alpha package dynamically
    *
-   * This implements ADR-001: Adopt @sparkleideas/agentic-flow as Core Foundation
-   * When @sparkleideas/agentic-flow is available, components delegate to it for:
+   * This implements ADR-001: Adopt agentic-flow as Core Foundation
+   * When agentic-flow is available, components delegate to it for:
    * - SONA learning (eliminating duplicate pattern storage)
    * - Flash Attention (using native optimized implementations)
    * - AgentDB (leveraging 150x-12,500x faster HNSW search)
    *
-   * If @sparkleideas/agentic-flow is not installed, falls back to local implementations
+   * If agentic-flow is not installed, falls back to local implementations
    * to maintain backward compatibility.
    */
   private async connectToAgenticFlow(): Promise<void> {
     try {
       // Dynamic import to handle optional dependency
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const agenticFlowModule: any = await import('@sparkleideas/agentic-flow').catch(() => null);
+      const agenticFlowModule: any = await import('agentic-flow').catch(() => null);
 
       if (agenticFlowModule && typeof agenticFlowModule.createAgenticFlow === 'function') {
         const factory: AgenticFlowFactory = agenticFlowModule.createAgenticFlow;
@@ -230,40 +230,40 @@ export class AgenticFlowBridge extends EventEmitter {
         this.agenticFlowCore = await factory({
           sona: this.config.sona,
           attention: this.config.attention,
-          @sparkleideas/agentdb: this.config.@sparkleideas/agentdb,
+          agentdb: this.config.agentdb,
         });
 
         this.agenticFlowAvailable = true;
-        this.updateComponentHealth('@sparkleideas/agentic-flow', 'healthy');
+        this.updateComponentHealth('agentic-flow', 'healthy');
 
-        this.emit('@sparkleideas/agentic-flow:connected', {
+        this.emit('agentic-flow:connected', {
           version: this.agenticFlowCore.version,
           features: {
             sona: true,
             attention: true,
-            @sparkleideas/agentdb: true,
+            agentdb: true,
           },
         });
 
-        this.logDebug('Connected to @sparkleideas/agentic-flow', {
+        this.logDebug('Connected to agentic-flow', {
           version: this.agenticFlowCore.version,
         });
       } else {
         // Package not found or doesn't export expected factory
         this.agenticFlowAvailable = false;
-        this.emit('@sparkleideas/agentic-flow:fallback', {
+        this.emit('agentic-flow:fallback', {
           reason: 'package not found or incompatible',
         });
-        this.logDebug('@sparkleideas/agentic-flow not available, using local implementations');
+        this.logDebug('agentic-flow not available, using local implementations');
       }
     } catch (error) {
-      // Fallback to local implementation if @sparkleideas/agentic-flow fails to load
+      // Fallback to local implementation if agentic-flow fails to load
       this.agenticFlowAvailable = false;
-      this.emit('@sparkleideas/agentic-flow:fallback', {
+      this.emit('agentic-flow:fallback', {
         reason: 'initialization error',
         error: (error as Error).message,
       });
-      this.logDebug('@sparkleideas/agentic-flow initialization failed, using fallback', error);
+      this.logDebug('agentic-flow initialization failed, using fallback', error);
     }
   }
 
@@ -558,9 +558,9 @@ export class AgenticFlowBridge extends EventEmitter {
   }
 
   /**
-   * Check if @sparkleideas/agentic-flow@alpha is connected and available for delegation
+   * Check if agentic-flow@alpha is connected and available for delegation
    *
-   * When true, components can delegate to @sparkleideas/agentic-flow for optimized
+   * When true, components can delegate to agentic-flow for optimized
    * implementations (per ADR-001).
    */
   isAgenticFlowConnected(): boolean {
@@ -568,9 +568,9 @@ export class AgenticFlowBridge extends EventEmitter {
   }
 
   /**
-   * Get the @sparkleideas/agentic-flow core instance for direct access
+   * Get the agentic-flow core instance for direct access
    *
-   * Returns null if @sparkleideas/agentic-flow is not available.
+   * Returns null if agentic-flow is not available.
    * Prefer using getSONAAdapter() or getAttentionCoordinator() which
    * handle delegation automatically.
    */
@@ -601,7 +601,7 @@ export class AgenticFlowBridge extends EventEmitter {
         flashOptLevel: 2,
         memoryOptimization: 'moderate',
       },
-      @sparkleideas/agentdb: {
+      agentdb: {
         dimension: 1536,
         indexType: 'hnsw',
         hnswM: 16,
@@ -633,7 +633,7 @@ export class AgenticFlowBridge extends EventEmitter {
       ...config,
       sona: { ...defaultConfig.sona, ...config.sona },
       attention: { ...defaultConfig.attention, ...config.attention },
-      @sparkleideas/agentdb: { ...defaultConfig.@sparkleideas/agentdb, ...config.@sparkleideas/agentdb },
+      agentdb: { ...defaultConfig.agentdb, ...config.agentdb },
       features: { ...defaultConfig.features, ...config.features },
     };
   }

package/src/attention-coordinator.ts

@@ -1,7 +1,7 @@
 /**
  * Attention Coordinator for Flash Attention Integration
  *
- * Provides integration with @sparkleideas/agentic-flow's attention mechanisms,
+ * Provides integration with agentic-flow's attention mechanisms,
  * including Flash Attention for 2.49x-7.47x speedup with
  * 50-75% memory reduction.
  *
@@ -28,8 +28,8 @@ import type {
 } from './types.js';
 
 /**
- * Interface for @sparkleideas/agentic-flow Attention reference (for delegation)
- * This allows the coordinator to delegate to @sparkleideas/agentic-flow when available
+ * Interface for agentic-flow Attention reference (for delegation)
+ * This allows the coordinator to delegate to agentic-flow when available
  */
 interface AgenticFlowAttentionReference {
   compute(params: {
@@ -136,13 +136,13 @@ export class AttentionCoordinator extends EventEmitter {
   private maxCacheSize: number = 1000;
 
   /**
-   * Reference to @sparkleideas/agentic-flow Attention for delegation (ADR-001)
+   * Reference to agentic-flow Attention for delegation (ADR-001)
    * When set, performAttention delegates to native Flash Attention
    */
   private agenticFlowAttention: AgenticFlowAttentionReference | null = null;
 
   /**
-   * Indicates if delegation to @sparkleideas/agentic-flow is active
+   * Indicates if delegation to agentic-flow is active
    */
   private delegationEnabled: boolean = false;
 
@@ -153,23 +153,23 @@ export class AttentionCoordinator extends EventEmitter {
   }
 
   /**
-   * Set reference to @sparkleideas/agentic-flow Attention for delegation
+   * Set reference to agentic-flow Attention for delegation
    *
-   * This implements ADR-001: Adopt @sparkleideas/agentic-flow as Core Foundation
+   * This implements ADR-001: Adopt agentic-flow as Core Foundation
    * When a reference is provided, attention computation for sequences
-   * longer than 512 tokens delegates to @sparkleideas/agentic-flow's optimized
+   * longer than 512 tokens delegates to agentic-flow's optimized
    * Flash Attention implementation for 2.49x-7.47x speedup.
    *
-   * @param attentionRef - The @sparkleideas/agentic-flow Attention interface reference
+   * @param attentionRef - The agentic-flow Attention interface reference
    */
   setAgenticFlowReference(attentionRef: AgenticFlowAttentionReference): void {
     this.agenticFlowAttention = attentionRef;
     this.delegationEnabled = true;
-    this.emit('delegation-enabled', { target: '@sparkleideas/agentic-flow' });
+    this.emit('delegation-enabled', { target: 'agentic-flow' });
   }
 
   /**
-   * Check if delegation to @sparkleideas/agentic-flow is enabled
+   * Check if delegation to agentic-flow is enabled
    */
   isDelegationEnabled(): boolean {
     return this.delegationEnabled && this.agenticFlowAttention !== null;
@@ -496,7 +496,7 @@ export class AttentionCoordinator extends EventEmitter {
    * Perform attention computation
    *
    * ADR-001: For sequences longer than 512 tokens, delegates to
-   * @sparkleideas/agentic-flow's native Flash Attention for 2.49x-7.47x speedup
+   * agentic-flow's native Flash Attention for 2.49x-7.47x speedup
    * and 50-75% memory reduction.
    */
   private async performAttention(params: {
@@ -514,7 +514,7 @@ export class AttentionCoordinator extends EventEmitter {
     // Calculate sequence length for delegation decision
     const sequenceLength = qArray.length;
 
-    // ADR-001: Delegate to @sparkleideas/agentic-flow for long sequences
+    // ADR-001: Delegate to agentic-flow for long sequences
     // Flash Attention provides 2.49x-7.47x speedup for sequences > 512 tokens
     if (
       this.isDelegationEnabled() &&
@@ -534,7 +534,7 @@ export class AttentionCoordinator extends EventEmitter {
           sequenceLength,
           mechanism: result.mechanism,
           latencyMs: result.latencyMs,
-          target: '@sparkleideas/agentic-flow',
+          target: 'agentic-flow',
         });
 
         return result.output;

package/src/index.ts

@@ -1,11 +1,11 @@
 /**
  * @sparkleideas/integration - V3 Integration Module
  *
- * Main entry point for the @sparkleideas/agentic-flow@alpha integration module.
+ * Main entry point for the agentic-flow@alpha integration module.
  * Provides deep integration with SONA learning, Flash Attention,
  * and AgentDB for maximum performance and capability.
  *
- * This module implements ADR-001: Adopt @sparkleideas/agentic-flow as Core Foundation
+ * This module implements ADR-001: Adopt agentic-flow as Core Foundation
  *
  * Key Features:
  * - SONA Learning: Real-time adaptation with <0.05ms response
@@ -145,7 +145,7 @@ export type {
   AgentConversionResult,
 } from './agent-adapter.js';
 
-// ===== Swarm Adapter (@sparkleideas/agentic-flow pattern alignment) =====
+// ===== Swarm Adapter (agentic-flow pattern alignment) =====
 export {
   SwarmAdapter,
   createSwarmAdapter,
@@ -154,7 +154,7 @@ export {
 } from './swarm-adapter.js';
 
 export type {
-  // @sparkleideas/agentic-flow pattern types
+  // agentic-flow pattern types
   AgenticFlowTopology,
   AgenticFlowAttentionMechanism,
   AgenticFlowAgentOutput,
@@ -433,7 +433,7 @@ export const VERSION = '3.0.0-alpha.1';
 export const METADATA = {
   name: '@sparkleideas/integration',
   version: VERSION,
-  description: 'Deep @sparkleideas/agentic-flow@alpha integration for @sparkleideas/claude-flow v3',
+  description: 'Deep agentic-flow@alpha integration for claude-flow v3',
   implements: ['ADR-001'],
   features: [
     'SONA Learning (5 modes)',
@@ -443,7 +443,7 @@ export const METADATA = {
     'Trajectory Tracking',
     'Feature Flags',
     'SDK Compatibility Layer',
-    'Worker Patterns (@sparkleideas/agentic-flow aligned)',
+    'Worker Patterns (agentic-flow aligned)',
     'Specialized Workers (16 domains)',
     'Long-Running Workers (checkpoint support)',
     'Worker Pool (intelligent routing)',

package/src/long-running-worker.ts

@@ -11,7 +11,7 @@
  * - Timeout management with graceful handling
  * - Resource cleanup on completion or failure
  *
- * Compatible with @sparkleideas/agentic-flow's long-running agent patterns.
+ * Compatible with agentic-flow's long-running agent patterns.
  *
  * @module v3/integration/long-running-worker
  * @version 3.0.0-alpha.1

package/src/multi-model-router.ts

@@ -1,7 +1,7 @@
 /**
  * Multi-Model Router
  *
- * Cost-optimized routing across multiple LLM providers from @sparkleideas/agentic-flow@alpha:
+ * Cost-optimized routing across multiple LLM providers from agentic-flow@alpha:
  * - anthropic: Claude models
  * - openai: GPT models
  * - openrouter: 100+ models, 85-99% cost savings

package/src/provider-adapter.ts

@@ -13,7 +13,7 @@
  * - Cost tracking and optimization
  * - Provider health monitoring
  *
- * Compatible with @sparkleideas/agentic-flow's provider manager patterns.
+ * Compatible with agentic-flow's provider manager patterns.
  *
  * @module v3/integration/provider-adapter
  * @version 3.0.0-alpha.1

package/src/sdk-bridge.ts

@@ -1,8 +1,8 @@
 /**
- * SDK Bridge for @sparkleideas/agentic-flow API Compatibility
+ * SDK Bridge for agentic-flow API Compatibility
  *
- * Provides API compatibility layer between @sparkleideas/claude-flow v3 and
- * @sparkleideas/agentic-flow@alpha, handling version negotiation, feature
+ * Provides API compatibility layer between claude-flow v3 and
+ * agentic-flow@alpha, handling version negotiation, feature
  * detection, and fallback behavior.
  *
  * Key Responsibilities:
@@ -65,7 +65,7 @@ const DEPRECATED_API_MAP: Record<string, {
  * SDKBridge - API Compatibility Layer
  *
  * This bridge handles version compatibility, feature detection,
- * and API translation between @sparkleideas/claude-flow and @sparkleideas/agentic-flow.
+ * and API translation between claude-flow and agentic-flow.
  */
 export class SDKBridge extends EventEmitter {
   private config: SDKBridgeConfig;
@@ -334,14 +334,14 @@ export class SDKBridge extends EventEmitter {
   }
 
   private async detectVersion(): Promise<SDKVersion> {
-    // Detect @sparkleideas/agentic-flow version dynamically
+    // Detect agentic-flow version dynamically
     try {
-      const af = await import('@sparkleideas/agentic-flow');
+      const af = await import('agentic-flow');
       if (af.VERSION) {
         return this.parseVersion(af.VERSION);
       }
     } catch {
-      // @sparkleideas/agentic-flow not available, use fallback version
+      // agentic-flow not available, use fallback version
     }
     return this.parseVersion('2.0.1-alpha.50');
   }

package/src/sona-adapter.ts

@@ -1,7 +1,7 @@
 /**
  * SONA (Self-Optimizing Neural Architecture) Adapter
  *
- * Provides integration with @sparkleideas/agentic-flow's SONA learning system,
+ * Provides integration with agentic-flow's SONA learning system,
  * enabling real-time adaptation, pattern recognition, and
  * continuous learning capabilities.
  *
@@ -26,8 +26,8 @@ import type {
 } from './types.js';
 
 /**
- * Interface for @sparkleideas/agentic-flow SONA reference (for delegation)
- * This allows the adapter to delegate to @sparkleideas/agentic-flow when available
+ * Interface for agentic-flow SONA reference (for delegation)
+ * This allows the adapter to delegate to agentic-flow when available
  */
 interface AgenticFlowSONAReference {
   setMode(mode: string): Promise<void>;
@@ -98,7 +98,7 @@ const MODE_CONFIGS: Record<SONALearningMode, Partial<SONAConfiguration>> = {
 /**
  * SONAAdapter - SONA Learning System Integration
  *
- * This adapter provides a clean interface to @sparkleideas/agentic-flow's SONA
+ * This adapter provides a clean interface to agentic-flow's SONA
  * learning capabilities, including:
  * - Learning mode selection and auto-switching
  * - Trajectory tracking for experience replay
@@ -115,13 +115,13 @@ export class SONAAdapter extends EventEmitter {
   private learningCycleCount: number = 0;
 
   /**
-   * Reference to @sparkleideas/agentic-flow SONA for delegation (ADR-001)
-   * When set, methods delegate to @sparkleideas/agentic-flow instead of local implementation
+   * Reference to agentic-flow SONA for delegation (ADR-001)
+   * When set, methods delegate to agentic-flow instead of local implementation
    */
   private agenticFlowSona: AgenticFlowSONAReference | null = null;
 
   /**
-   * Indicates if delegation to @sparkleideas/agentic-flow is active
+   * Indicates if delegation to agentic-flow is active
    */
   private delegationEnabled: boolean = false;
 
@@ -132,22 +132,22 @@ export class SONAAdapter extends EventEmitter {
   }
 
   /**
-   * Set reference to @sparkleideas/agentic-flow SONA for delegation
+   * Set reference to agentic-flow SONA for delegation
    *
-   * This implements ADR-001: Adopt @sparkleideas/agentic-flow as Core Foundation
+   * This implements ADR-001: Adopt agentic-flow as Core Foundation
    * When a reference is provided, pattern storage and retrieval
-   * delegate to @sparkleideas/agentic-flow's optimized implementations.
+   * delegate to agentic-flow's optimized implementations.
    *
-   * @param sonaRef - The @sparkleideas/agentic-flow SONA interface reference
+   * @param sonaRef - The agentic-flow SONA interface reference
    */
   setAgenticFlowReference(sonaRef: AgenticFlowSONAReference): void {
     this.agenticFlowSona = sonaRef;
     this.delegationEnabled = true;
-    this.emit('delegation-enabled', { target: '@sparkleideas/agentic-flow' });
+    this.emit('delegation-enabled', { target: 'agentic-flow' });
   }
 
   /**
-   * Check if delegation to @sparkleideas/agentic-flow is enabled
+   * Check if delegation to agentic-flow is enabled
    */
   isDelegationEnabled(): boolean {
     return this.delegationEnabled && this.agenticFlowSona !== null;
@@ -336,7 +336,7 @@ export class SONAAdapter extends EventEmitter {
   /**
    * Store a learned pattern
    *
-   * ADR-001: When @sparkleideas/agentic-flow is available, delegates to its optimized
+   * ADR-001: When agentic-flow is available, delegates to its optimized
    * pattern storage which uses AgentDB with HNSW indexing for
    * 150x-12,500x faster similarity search.
    */
@@ -349,7 +349,7 @@ export class SONAAdapter extends EventEmitter {
   }): Promise<string> {
     this.ensureInitialized();
 
-    // ADR-001: Delegate to @sparkleideas/agentic-flow when available
+    // ADR-001: Delegate to agentic-flow when available
     if (this.isDelegationEnabled() && this.agenticFlowSona) {
       try {
         const patternId = await this.agenticFlowSona.storePattern({
@@ -364,7 +364,7 @@ export class SONAAdapter extends EventEmitter {
         this.emit('pattern-stored', {
           patternId,
           delegated: true,
-          target: '@sparkleideas/agentic-flow',
+          target: 'agentic-flow',
         });
 
         return patternId;
@@ -379,7 +379,7 @@ export class SONAAdapter extends EventEmitter {
       }
     }
 
-    // Local implementation (fallback or when @sparkleideas/agentic-flow not available)
+    // Local implementation (fallback or when agentic-flow not available)
     const patternId = this.generateId('pat');
     const storedPattern: SONAPattern = {
       id: patternId,
@@ -409,7 +409,7 @@ export class SONAAdapter extends EventEmitter {
   /**
    * Find similar patterns to a query
    *
-   * ADR-001: When @sparkleideas/agentic-flow is available, delegates to its optimized
+   * ADR-001: When agentic-flow is available, delegates to its optimized
    * HNSW-indexed search for 150x-12,500x faster retrieval.
    */
   async findSimilarPatterns(params: {
@@ -423,7 +423,7 @@ export class SONAAdapter extends EventEmitter {
     const topK = params.topK || 5;
     const threshold = params.threshold ?? this.config.similarityThreshold;
 
-    // ADR-001: Delegate to @sparkleideas/agentic-flow when available for optimized search
+    // ADR-001: Delegate to agentic-flow when available for optimized search
     if (this.isDelegationEnabled() && this.agenticFlowSona) {
       try {
         const results = await this.agenticFlowSona.findPatterns(params.query, {
@@ -449,7 +449,7 @@ export class SONAAdapter extends EventEmitter {
           query: params.query,
           count: patterns.length,
           delegated: true,
-          target: '@sparkleideas/agentic-flow',
+          target: 'agentic-flow',
         });
 
         return patterns;
@@ -464,7 +464,7 @@ export class SONAAdapter extends EventEmitter {
       }
     }
 
-    // Local implementation (fallback or when @sparkleideas/agentic-flow not available)
+    // Local implementation (fallback or when agentic-flow not available)
     const results: Array<{ pattern: SONAPattern; score: number }> = [];
 
     for (const pattern of this.patterns.values()) {

package/src/specialized-worker.ts

@@ -10,7 +10,7 @@
  * - Capability verification and scoring
  * - Domain-specific execution strategies
  *
- * Compatible with @sparkleideas/agentic-flow's SpecializedAgent pattern.
+ * Compatible with agentic-flow's SpecializedAgent pattern.
  *
  * @module v3/integration/specialized-worker
  * @version 3.0.0-alpha.1