@mxf-dev/core 2.0.4 → 3.0.0

package/src/services/orpar-memory/OrparMemoryCoordinator.ts

@@ -52,6 +52,7 @@
  */
 
 import { v4 as uuidv4 } from 'uuid';
+import type { Subscription } from 'rxjs';
 import { Logger } from '../../utils/Logger.js';
 import { EventBus } from '../../events/EventBus.js';
 import { Events, ControlLoopEvents } from '../../events/EventNames.js';
@@ -94,6 +95,8 @@ export class OrparMemoryCoordinator {
     private static instance: OrparMemoryCoordinator;
     private logger: Logger;
     private enabled: boolean = false;
+    private initialized: boolean = false;
+    private eventSubscriptions: Subscription[] = [];
 
     // Component services
     private phaseStrataRouter: PhaseStrataRouter;
@@ -112,6 +115,7 @@ export class OrparMemoryCoordinator {
         outcome: CycleOutcome;
         completedAt: number;
     }> = new Map();
+    private recentlyCompletedExpiryTimers: Map<string, NodeJS.Timeout> = new Map();
     private static readonly RECENTLY_COMPLETED_TTL_MS = 60_000;
 
     // Fix #2: Per-cycle locking to prevent race conditions
@@ -147,25 +151,36 @@ export class OrparMemoryCoordinator {
      * Initialize the coordinator and all component services
      */
     public initialize(): void {
+        if (this.initialized) {
+            return;
+        }
+
         this.enabled = isOrparMemoryIntegrationEnabled();
 
         if (this.enabled) {
-            // Initialize all component services
-            this.phaseStrataRouter.initialize();
-            this.surpriseAdapter.initialize();
-            this.phaseRewarder.initialize();
-            this.consolidationTrigger.initialize();
-            this.memoryOperations.initialize();
-
-            // Setup event listeners
-            this.setupEventListeners();
-
-            // Fix #3: Start stale cycle cleanup
-            this.startStaleCycleCleanup();
-
-            this.logger.info('[OrparMemoryCoordinator] Initialized with ORPAR-Memory integration ENABLED');
-            this.logger.info('[OrparMemoryCoordinator] All component services initialized');
+            try {
+                // Initialize all component services
+                this.phaseStrataRouter.initialize();
+                this.surpriseAdapter.initialize();
+                this.phaseRewarder.initialize();
+                this.consolidationTrigger.initialize();
+                this.memoryOperations.initialize();
+
+                // Setup event listeners
+                this.setupEventListeners();
+
+                // Fix #3: Start stale cycle cleanup
+                this.startStaleCycleCleanup();
+                this.initialized = true;
+
+                this.logger.info('[OrparMemoryCoordinator] Initialized with ORPAR-Memory integration ENABLED');
+                this.logger.info('[OrparMemoryCoordinator] All component services initialized');
+            } catch (error) {
+                this.shutdown();
+                throw error;
+            }
         } else {
+            this.initialized = true;
             this.logger.info(
                 '[OrparMemoryCoordinator] ORPAR-Memory integration is DISABLED. ' +
                 'Enable with ORPAR_MEMORY_INTEGRATION_ENABLED=true'
@@ -284,46 +299,58 @@ export class OrparMemoryCoordinator {
      */
     private setupEventListeners(): void {
         // Listen to control loop events to track cycle phases (server-side ControlLoop)
-        EventBus.server.on(ControlLoopEvents.OBSERVATION, (payload: any) => {
-            this.onPhaseEvent('observation', payload, 'controlLoop');
-        });
-
-        EventBus.server.on(ControlLoopEvents.REASONING, (payload: any) => {
-            this.onPhaseEvent('reasoning', payload, 'controlLoop');
-        });
-
-        EventBus.server.on(ControlLoopEvents.PLAN, (payload: any) => {
-            this.onPhaseEvent('planning', payload, 'controlLoop');
-        });
-
-        EventBus.server.on(ControlLoopEvents.EXECUTION, (payload: any) => {
-            this.onPhaseEvent('action', payload, 'controlLoop');
-        });
-
-        EventBus.server.on(ControlLoopEvents.REFLECTION, (payload: any) => {
-            this.onPhaseEvent('reflection', payload, 'controlLoop');
-        });
+        this.eventSubscriptions.push(
+            EventBus.server.on(ControlLoopEvents.OBSERVATION, payload => {
+                this.onPhaseEvent('observation', payload, 'controlLoop');
+            })
+        );
+        this.eventSubscriptions.push(
+            EventBus.server.on(ControlLoopEvents.REASONING, payload => {
+                this.onPhaseEvent('reasoning', payload, 'controlLoop');
+            })
+        );
+        this.eventSubscriptions.push(
+            EventBus.server.on(ControlLoopEvents.PLAN, payload => {
+                this.onPhaseEvent('planning', payload, 'controlLoop');
+            })
+        );
+        this.eventSubscriptions.push(
+            EventBus.server.on(ControlLoopEvents.EXECUTION, payload => {
+                this.onPhaseEvent('action', payload, 'controlLoop');
+            })
+        );
+        this.eventSubscriptions.push(
+            EventBus.server.on(ControlLoopEvents.REFLECTION, payload => {
+                this.onPhaseEvent('reflection', payload, 'controlLoop');
+            })
+        );
 
         // Listen to ORPAR tool events (agent-driven ORPAR tools)
-        EventBus.server.on(OrparEvents.OBSERVE, (payload: any) => {
-            this.onOrparToolEvent('observation', payload);
-        });
-
-        EventBus.server.on(OrparEvents.REASON, (payload: any) => {
-            this.onOrparToolEvent('reasoning', payload);
-        });
-
-        EventBus.server.on(OrparEvents.PLAN, (payload: any) => {
-            this.onOrparToolEvent('planning', payload);
-        });
-
-        EventBus.server.on(OrparEvents.ACT, (payload: any) => {
-            this.onOrparToolEvent('action', payload);
-        });
-
-        EventBus.server.on(OrparEvents.REFLECT, (payload: any) => {
-            this.onOrparToolEvent('reflection', payload);
-        });
+        this.eventSubscriptions.push(
+            EventBus.server.on(OrparEvents.OBSERVE, payload => {
+                this.onOrparToolEvent('observation', payload);
+            })
+        );
+        this.eventSubscriptions.push(
+            EventBus.server.on(OrparEvents.REASON, payload => {
+                this.onOrparToolEvent('reasoning', payload);
+            })
+        );
+        this.eventSubscriptions.push(
+            EventBus.server.on(OrparEvents.PLAN, payload => {
+                this.onOrparToolEvent('planning', payload);
+            })
+        );
+        this.eventSubscriptions.push(
+            EventBus.server.on(OrparEvents.ACT, payload => {
+                this.onOrparToolEvent('action', payload);
+            })
+        );
+        this.eventSubscriptions.push(
+            EventBus.server.on(OrparEvents.REFLECT, payload => {
+                this.onOrparToolEvent('reflection', payload);
+            })
+        );
 
         // Fill phase memory usage from actual retrievals.
         //
@@ -333,19 +360,26 @@ export class OrparMemoryCoordinator {
         // therefore always empty, so PhaseWeightedRewarder returned no rewards and cycle
         // consolidation iterated zero memories. Subscribing here is what makes
         // phase-weighted rewards real.
-        EventBus.server.on(OrparMemoryEvents.PHASE_MEMORY_RETRIEVED, (payload: any) => {
-            if (this.enabled) {
-                this.onPhaseMemoryRetrieved(payload);
-            }
-        });
+        this.eventSubscriptions.push(
+            EventBus.server.on(OrparMemoryEvents.PHASE_MEMORY_RETRIEVED, payload => {
+                if (this.enabled) {
+                    this.onPhaseMemoryRetrieved(payload);
+                }
+            })
+        );
 
         // Listen for task completion to retroactively update rewards when
         // the ORPAR cycle completed before task_complete was called
-        EventBus.server.on(Events.Task.COMPLETED, (payload: any) => {
-            if (this.enabled) {
-                this.onTaskCompleted(payload);
-            }
-        });
+        this.eventSubscriptions.push(
+            EventBus.server.on(Events.Task.COMPLETED, (payload): Promise<void> | undefined => {
+                if (this.enabled) {
+                    // Return the persistence chain so EventBus.drain() keeps the
+                    // database open until retroactive Q-value updates finish.
+                    return this.onTaskCompleted(payload);
+                }
+                return undefined;
+            })
+        );
 
         this.logger.debug('[OrparMemoryCoordinator] Event listeners registered for ControlLoop, OrparTools, PhaseMemory, and TaskEvents');
     }
@@ -688,9 +722,7 @@ export class OrparMemoryCoordinator {
                 outcome,
                 completedAt: Date.now(),
             });
-            setTimeout(() => {
-                this.recentlyCompletedCycles.delete(cacheKey);
-            }, OrparMemoryCoordinator.RECENTLY_COMPLETED_TTL_MS);
+            this.scheduleRecentlyCompletedExpiry(cacheKey);
         }
 
         // Remove from active cycles
@@ -718,7 +750,7 @@ export class OrparMemoryCoordinator {
 
         // Already successful — no recalculation needed
         if (cached.outcome.success) {
-            this.recentlyCompletedCycles.delete(cacheKey);
+            this.clearRecentlyCompletedCycle(cacheKey);
             return;
         }
 
@@ -749,7 +781,30 @@ export class OrparMemoryCoordinator {
             );
         }
 
+        this.clearRecentlyCompletedCycle(cacheKey);
+    }
+
+    private scheduleRecentlyCompletedExpiry(cacheKey: string): void {
+        const existingTimer = this.recentlyCompletedExpiryTimers.get(cacheKey);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+        }
+
+        const expiryTimer = setTimeout(() => {
+            this.recentlyCompletedCycles.delete(cacheKey);
+            this.recentlyCompletedExpiryTimers.delete(cacheKey);
+        }, OrparMemoryCoordinator.RECENTLY_COMPLETED_TTL_MS);
+        expiryTimer.unref();
+        this.recentlyCompletedExpiryTimers.set(cacheKey, expiryTimer);
+    }
+
+    private clearRecentlyCompletedCycle(cacheKey: string): void {
         this.recentlyCompletedCycles.delete(cacheKey);
+        const expiryTimer = this.recentlyCompletedExpiryTimers.get(cacheKey);
+        if (expiryTimer) {
+            clearTimeout(expiryTimer);
+            this.recentlyCompletedExpiryTimers.delete(cacheKey);
+        }
     }
 
     // =========================================================================
@@ -1050,11 +1105,21 @@ export class OrparMemoryCoordinator {
         ].join('\n');
     }
 
-    /**
-     * Reset the coordinator (useful for testing)
-     */
-    public reset(): void {
+    /** Release all coordinator-owned process resources and runtime state. */
+    public shutdown(): void {
         this.enabled = false;
+        this.initialized = false;
+
+        for (const subscription of this.eventSubscriptions) {
+            subscription.unsubscribe();
+        }
+        this.eventSubscriptions = [];
+
+        for (const expiryTimer of this.recentlyCompletedExpiryTimers.values()) {
+            clearTimeout(expiryTimer);
+        }
+        this.recentlyCompletedExpiryTimers.clear();
+
         this.activeCycles.clear();
         this.recentlyCompletedCycles.clear();
 
@@ -1070,7 +1135,13 @@ export class OrparMemoryCoordinator {
         this.phaseRewarder.reset();
         this.consolidationTrigger.reset();
         this.memoryOperations.reset();
+    }
 
+    /**
+     * Reset the coordinator and its cached configuration (useful for testing).
+     */
+    public reset(): void {
+        this.shutdown();
         // Reset config
         resetOrparMemoryConfig();
     }

package/src/services/orpar-memory/SurpriseOrparAdapter.ts

@@ -35,6 +35,7 @@
  */
 
 import { createBaseEventPayload } from '../../schemas/EventPayloadSchema.js';
+import type { Subscription } from 'rxjs';
 import { Logger } from '../../utils/Logger.js';
 import { EventBus } from '../../events/EventBus.js';
 import {
@@ -87,6 +88,7 @@ export class SurpriseOrparAdapter {
     private logger: Logger;
     private enabled: boolean = false;
     private thresholds: SurpriseThresholds;
+    private graphSurpriseSubscription?: Subscription;
 
     // Track surprise momentum per agent/cycle
     private surpriseMomentum: Map<string, number[]> = new Map();
@@ -137,13 +139,18 @@ export class SurpriseOrparAdapter {
      * observation cycles.
      */
     private setupGraphSurpriseListener(): void {
+        if (this.graphSurpriseSubscription && !this.graphSurpriseSubscription.closed) {
+            return;
+        }
+        this.graphSurpriseSubscription = undefined;
+
         // Only set up listener if Knowledge Graph surprise detection is enabled
         if (!isKnowledgeGraphEnabled() || !isSurpriseDetectionEnabled()) {
             this.logger.debug('[SurpriseOrparAdapter] Knowledge Graph surprise integration disabled');
             return;
         }
 
-        EventBus.server.on(
+        this.graphSurpriseSubscription = EventBus.server.on(
             KnowledgeGraphEvents.HIGH_SURPRISE_RELATIONSHIP,
             (payload: { data: HighSurpriseRelationshipEventData; agentId?: AgentId; channelId?: ChannelId }) => {
                 this.handleGraphSurpriseEvent(payload);
@@ -567,6 +574,8 @@ export class SurpriseOrparAdapter {
      */
     public reset(): void {
         this.enabled = false;
+        this.graphSurpriseSubscription?.unsubscribe();
+        this.graphSurpriseSubscription = undefined;
         this.surpriseMomentum.clear();
     }
 }

package/src/types/ChannelContext.ts

@@ -272,12 +272,14 @@ export interface IChannelContextService {
      * @param channelId - Channel ID
      * @param context - Channel context to save
      * @param historyEntry - Optional history entry to record with this update
+     * @param expectedContextUpdatedAt - Persisted revision required for an update
      * @returns Observable of the saved context
      */
     saveContextToMemory(
         channelId: ChannelId,
         context: ChannelContextType,
-        historyEntry?: ChannelContextHistoryEntry
+        historyEntry?: ChannelContextHistoryEntry,
+        expectedContextUpdatedAt?: number
     ): Observable<ChannelContextType>;
     
     /**

package/src/types/EffectivenessTypes.ts

@@ -125,6 +125,9 @@ export interface TaskEffectivenessMetrics {
 export interface TaskDefinition {
     /** Unique task identifier */
     taskId: string;
+
+    /** Agent that owns this effectiveness record */
+    agentId: AgentId;
     
     /** Channel where task is executed */
     channelId: ChannelId;
@@ -267,9 +270,10 @@ export interface EffectivenessAnalytics {
 export interface TaskExecutionEvent {
     eventId: string;
     taskId: string;
+    agentId: AgentId;
+    channelId: ChannelId;
     timestamp: number;
     type: 'start' | 'step' | 'tool_use' | 'agent_join' | 'human_input' | 'error' | 'complete';
-    agentId?: AgentId;
     details: Record<string, any>;
 }
 
@@ -300,4 +304,4 @@ export interface EffectivenessConfig {
         enabled: boolean;
         defaultBaselineType?: 'human' | 'previous_run' | 'traditional_method';
     };
-}
+}

package/src/types/TaskCompletionTypes.ts

@@ -46,6 +46,7 @@ export interface SystemLLMEvalCompletion {
     objectives: string[];              // What needs to be achieved
     evaluationInterval: number;        // How often to check (ms)
     confidenceThreshold: number;       // 0-1, required confidence
+    maxEvaluations: number;             // Hard provider-call budget
 }
 
 export interface OutputBasedCompletion {
@@ -67,7 +68,7 @@ export interface TimeBasedCompletion {
 export interface EventBasedCompletion {
     type: 'event-based';
     eventName: string;                 // Event that triggers completion
-    eventData?: Record<string, any>;   // Optional data to match
+    eventData?: Record<string, unknown>;   // Optional data to match
 }
 
 export interface ConsensusCompletion {
@@ -79,7 +80,7 @@ export interface ConsensusCompletion {
 export interface CustomCompletion {
     type: 'custom';
     evaluatorFunction: string;         // Name of custom evaluator
-    parameters?: Record<string, any>;
+    parameters?: Record<string, unknown>;
 }
 
 export type TaskCompletionCriteria = 
@@ -98,12 +99,9 @@ export interface TaskCompletionConfig {
     // Primary completion strategy
     primary: TaskCompletionCriteria;
     
-    // Fallback strategies if primary doesn't complete
-    fallbacks?: TaskCompletionCriteria[];
-    
-    // Global timeout (applies to all strategies)
+    // Optional hard deadline. A deadline may fail a task; it can never manufacture completion.
     absoluteTimeout?: number;
-    timeoutBehavior?: 'complete' | 'fail' | 'alert';
+    timeoutBehavior?: 'fail';
     
     // Whether agents can still manually complete
     allowManualCompletion?: boolean;
@@ -111,6 +109,8 @@ export interface TaskCompletionConfig {
 
 export interface TaskMonitoringState {
     taskId: string;
+    channelId: string;
+    assignedAgentIds: string[];
     startTime: number;
     lastActivityTime: number;
     activityCount: number;
@@ -125,7 +125,7 @@ export interface TaskMonitoringState {
         toolCalls: Array<{
             agentId: string;
             toolName: string;
-            result: any;
+            result: unknown;
             timestamp: number;
         }>;
         planProgress?: {
@@ -160,4 +160,4 @@ export interface TaskCompletionEvent {
     confidence: number;
     reason: string;
     duration: number;
-}
+}

package/src/types/TaskTypes.ts

@@ -77,6 +77,7 @@ export interface ChannelTask {
     // Task coordination
     coordinationMode?: 'independent' | 'collaborative' | 'sequential' | 'hierarchical';
     leadAgentId?: AgentId;             // Primary coordinator for collaborative tasks
+    completionAgentId?: AgentId;       // Agent authorized to report the terminal outcome
     
     // Agent selection criteria
     agentSelectionCriteria?: {
@@ -147,6 +148,7 @@ export interface CreateTaskRequest {
     // Task coordination
     coordinationMode?: 'independent' | 'collaborative' | 'sequential' | 'hierarchical';
     leadAgentId?: AgentId;             // Primary coordinator for collaborative tasks
+    completionAgentId?: AgentId;       // Agent authorized to report the terminal outcome
     
     // Agent selection criteria
     agentSelectionCriteria?: {
@@ -176,6 +178,16 @@ export interface UpdateTaskRequest {
     tags?: string[];
 }
 
+/**
+ * Fields that may be changed without performing a task lifecycle transition.
+ * Status and assignment changes go through dedicated operations so actor
+ * authorization and legal-state predicates remain on the database write.
+ */
+export type NonLifecycleTaskUpdateRequest = Omit<
+    UpdateTaskRequest,
+    'status' | 'assignedAgentId'
+>;
+
 /**
  * Agent assignment analysis from SystemLLM
  */
@@ -275,7 +287,6 @@ export interface TaskOrchestrationConfig {
     // SystemLLM integration
     enableLlmAssignment: boolean;
     llmConfidenceThreshold: number;     // Minimum confidence for LLM assignments
-    fallbackStrategy: AssignmentStrategy;
     
     // Coordination behavior
     enableTaskDependencies: boolean;

package/src/utils/GlobMatcher.ts

@@ -0,0 +1,157 @@
+/**
+ * Glob matching for relative file paths without regular expressions.
+ *
+ * Supported syntax:
+ * - `*`  any run of characters inside one path segment (never crosses `/`)
+ * - `?`  exactly one character inside a path segment
+ * - `**` as a whole segment: zero or more whole directories. A `**` that
+ *        is part of a larger segment behaves like `*`.
+ * Every other character is literal, including regex metacharacters.
+ *
+ * The matcher walks the pattern and the candidate with a single backtrack
+ * point per wildcard, so cost is bounded by pattern length × candidate
+ * length. A compiled regular expression is not used because patterns such
+ * as `*a*a*a*b` made the engine backtrack for seconds per file name, and
+ * the filesystem walk runs the matcher once per directory entry on the
+ * server's event loop.
+ */
+
+/** Upper bound on `*` runs plus `?` characters in one pattern. */
+export const MAX_GLOB_WILDCARDS = 32;
+
+export interface GlobMatcher {
+    /**
+     * True when the pattern contains a path separator. Such a pattern must
+     * be tested against a relative path; a pattern without one addresses a
+     * bare file name.
+     */
+    readonly matchesPath: boolean;
+    /** Return true when `candidate` (segments separated by `/`) matches the whole pattern. */
+    test(candidate: string): boolean;
+}
+
+type PatternSegment =
+    | { readonly kind: 'globstar' }
+    | { readonly kind: 'segment'; readonly text: string };
+
+const countWildcards = (pattern: string): number => {
+    let wildcards = 0;
+    for (let index = 0; index < pattern.length; index += 1) {
+        const character = pattern[index];
+        if (character === '?') {
+            wildcards += 1;
+        } else if (character === '*' && pattern[index - 1] !== '*') {
+            wildcards += 1;
+        }
+    }
+    return wildcards;
+};
+
+/**
+ * Match one path segment against a segment pattern containing `*` and `?`.
+ * Classic greedy wildcard matching with one backtrack point: O(p × t).
+ */
+const matchSegment = (pattern: string, text: string): boolean => {
+    let patternIndex = 0;
+    let textIndex = 0;
+    let starIndex = -1;
+    let starTextIndex = -1;
+
+    while (textIndex < text.length) {
+        const patternCharacter = pattern[patternIndex];
+        if (patternIndex < pattern.length &&
+            (patternCharacter === '?' || patternCharacter === text[textIndex])) {
+            patternIndex += 1;
+            textIndex += 1;
+        } else if (patternIndex < pattern.length && patternCharacter === '*') {
+            starIndex = patternIndex;
+            starTextIndex = textIndex;
+            patternIndex += 1;
+        } else if (starIndex !== -1) {
+            patternIndex = starIndex + 1;
+            starTextIndex += 1;
+            textIndex = starTextIndex;
+        } else {
+            return false;
+        }
+    }
+
+    while (patternIndex < pattern.length && pattern[patternIndex] === '*') {
+        patternIndex += 1;
+    }
+    return patternIndex === pattern.length;
+};
+
+/**
+ * Match path segments against pattern segments. A `globstar` pattern
+ * segment plays the role `*` plays inside a segment: it absorbs zero or
+ * more whole path segments, with one backtrack point.
+ */
+const matchSegments = (
+    patternSegments: readonly PatternSegment[],
+    pathSegments: readonly string[]
+): boolean => {
+    let patternIndex = 0;
+    let pathIndex = 0;
+    let globstarIndex = -1;
+    let globstarPathIndex = -1;
+
+    while (pathIndex < pathSegments.length) {
+        const patternSegment = patternSegments[patternIndex];
+        if (patternIndex < patternSegments.length && patternSegment.kind === 'globstar') {
+            globstarIndex = patternIndex;
+            globstarPathIndex = pathIndex;
+            patternIndex += 1;
+        } else if (patternIndex < patternSegments.length &&
+            patternSegment.kind === 'segment' &&
+            matchSegment(patternSegment.text, pathSegments[pathIndex])) {
+            patternIndex += 1;
+            pathIndex += 1;
+        } else if (globstarIndex !== -1) {
+            patternIndex = globstarIndex + 1;
+            globstarPathIndex += 1;
+            pathIndex = globstarPathIndex;
+        } else {
+            return false;
+        }
+    }
+
+    while (patternIndex < patternSegments.length &&
+        patternSegments[patternIndex].kind === 'globstar') {
+        patternIndex += 1;
+    }
+    return patternIndex === patternSegments.length;
+};
+
+/**
+ * Compile a glob pattern into a matcher.
+ *
+ * @throws Error when the pattern is empty or uses more than
+ *         {@link MAX_GLOB_WILDCARDS} wildcards.
+ */
+export function createGlobMatcher(pattern: string, caseSensitive: boolean): GlobMatcher {
+    if (typeof pattern !== 'string' || pattern.length === 0) {
+        throw new Error('Glob pattern must be a non-empty string');
+    }
+
+    const wildcards = countWildcards(pattern);
+    if (wildcards > MAX_GLOB_WILDCARDS) {
+        throw new Error(
+            `Glob pattern uses ${wildcards} wildcards; at most ${MAX_GLOB_WILDCARDS} are supported`
+        );
+    }
+
+    const normalizedPattern = caseSensitive ? pattern : pattern.toLowerCase();
+    const patternSegments: PatternSegment[] = normalizedPattern.split('/').map(segment => (
+        segment === '**' ? { kind: 'globstar' } : { kind: 'segment', text: segment }
+    ));
+    const matchesPath = pattern.includes('/');
+
+    return {
+        matchesPath,
+        test(candidate: string): boolean {
+            const normalizedCandidate = caseSensitive ? candidate : candidate.toLowerCase();
+            return matchSegments(patternSegments, normalizedCandidate.split('/'));
+        }
+    };
+}