@mxf-dev/core 2.0.4 → 3.0.0

package/src/services/WebSearchService.ts

@@ -25,6 +25,10 @@
 
 import { BrowserManager, BrowserConfig } from './BrowserManager.js';
 import { ContentProcessor, OptimizationOptions } from './ContentProcessor.js';
+import {
+    installBrowserTargetGuard,
+    requireAllowedBrowserTarget
+} from '../protocols/mcp/security/BrowserTargetGuard.js';
 // Type-only: erased at compile time, so puppeteer stays an optional peer dependency.
 import type { Page } from 'puppeteer';
 
@@ -90,6 +94,7 @@ export class WebSearchService {
             try {
                 // Set user agent
                 await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36');
+                await installBrowserTargetGuard(page);
                 
                 // Perform search based on engine
                 let results: SearchResult[] = [];
@@ -131,6 +136,7 @@ export class WebSearchService {
 
     async navigate(args: WebNavigationArgs): Promise<any> {
         try {
+            await requireAllowedBrowserTarget(args.url);
             const browserInstance = await this.browserManager.getBrowser();
             const browser = browserInstance.browser;
             const page = await browser.newPage();
@@ -138,6 +144,7 @@ export class WebSearchService {
             try {
                 // Set viewport if needed
                 await page.setViewport({ width: 1280, height: 720 });
+                await installBrowserTargetGuard(page);
                 
                 // Navigate to URL
                 const response = await page.goto(args.url, {
@@ -223,6 +230,7 @@ export class WebSearchService {
 
     async screenshot(args: WebScreenshotArgs): Promise<Buffer> {
         try {
+            await requireAllowedBrowserTarget(args.url);
             const browserInstance = await this.browserManager.getBrowser();
             const browser = browserInstance.browser;
             const page = await browser.newPage();
@@ -233,6 +241,7 @@ export class WebSearchService {
                     width: args.width || 1280, 
                     height: args.height || 720 
                 });
+                await installBrowserTargetGuard(page);
                 
                 // Navigate to URL
                 await page.goto(args.url, {
@@ -261,7 +270,8 @@ export class WebSearchService {
 
     private async searchGoogle(page: Page, query: string, maxResults: number): Promise<SearchResult[]> {
         const searchUrl = `https://www.google.com/search?q=${encodeURIComponent(query)}&num=${maxResults}`;
-        
+
+        await requireAllowedBrowserTarget(searchUrl);
         await page.goto(searchUrl, { waitUntil: 'networkidle2' });
         
         // Extract search results
@@ -291,7 +301,8 @@ export class WebSearchService {
 
     private async searchBing(page: Page, query: string, maxResults: number): Promise<SearchResult[]> {
         const searchUrl = `https://www.bing.com/search?q=${encodeURIComponent(query)}&count=${maxResults}`;
-        
+
+        await requireAllowedBrowserTarget(searchUrl);
         await page.goto(searchUrl, { waitUntil: 'networkidle2' });
         
         // Extract search results
@@ -320,7 +331,8 @@ export class WebSearchService {
 
     private async searchDuckDuckGo(page: Page, query: string, maxResults: number): Promise<SearchResult[]> {
         const searchUrl = `https://duckduckgo.com/?q=${encodeURIComponent(query)}`;
-        
+
+        await requireAllowedBrowserTarget(searchUrl);
         await page.goto(searchUrl, { waitUntil: 'networkidle2' });
         
         // Extract search results
@@ -380,4 +392,4 @@ export class WebSearchService {
     async cleanup(): Promise<void> {
         await this.browserManager.cleanup();
     }
-}
+}

package/src/services/dag/TaskDagService.ts

@@ -107,7 +107,7 @@ interface DagCacheEntry {
  * TaskDagService manages Task DAGs for all channels
  */
 export class TaskDagService {
-    private static instance: TaskDagService;
+    private static instance: TaskDagService | undefined;
     private logger: Logger;
     private enabled: boolean = false;
 
@@ -119,6 +119,7 @@ export class TaskDagService {
 
     // Cache cleanup interval
     private cleanupInterval: NodeJS.Timeout | null = null;
+    private shutdownComplete = false;
 
     private constructor() {
         this.logger = new Logger('info', 'TaskDagService', 'server');
@@ -135,6 +136,16 @@ export class TaskDagService {
         return TaskDagService.instance;
     }
 
+    /** Stop the live singleton without constructing one solely for teardown. */
+    public static shutdownExisting(): boolean {
+        const instance = TaskDagService.instance;
+        if (!instance) {
+            return false;
+        }
+        instance.shutdown();
+        return true;
+    }
+
     /**
      * Initialize the service
      */
@@ -1048,12 +1059,20 @@ export class TaskDagService {
      * Shutdown the service
      */
     public shutdown(): void {
+        if (this.shutdownComplete) {
+            return;
+        }
+        this.shutdownComplete = true;
         if (this.cleanupInterval) {
             clearInterval(this.cleanupInterval);
             this.cleanupInterval = null;
         }
         this.channelLocks.clear();
         this.clearAllCaches();
+        this.enabled = false;
+        if (TaskDagService.instance === this) {
+            TaskDagService.instance = undefined;
+        }
         this.logger.info('TaskDagService shutdown complete');
     }
 }

package/src/services/kg/EntityQValueManager.ts

@@ -50,6 +50,8 @@ import { createBaseEventPayload } from '../../schemas/EventPayloadSchema.js';
  */
 export interface EntityRewardSignal {
     entityId: string;
+    /** Channel the entity belongs to; the update is bound to it. */
+    channelId: ChannelId;
     reward: number; // -1 to 1
     reason: string;
     taskId?: string;
@@ -122,7 +124,7 @@ export class EntityQValueManager {
             return null;
         }
 
-        const entity = await this.repository.getEntity(signal.entityId);
+        const entity = await this.repository.getEntity(signal.entityId, signal.channelId);
         if (!entity) {
             this.logger.warn(`Entity not found for Q-value update: ${signal.entityId}`);
             return null;
@@ -141,7 +143,12 @@ export class EntityQValueManager {
         const clampedQValue = Math.max(0, Math.min(1, newQValue));
 
         // Update in database
-        await this.repository.updateEntityQValue(signal.entityId, clampedQValue, signal.reason);
+        await this.repository.updateEntityQValue(
+            signal.entityId,
+            signal.channelId,
+            clampedQValue,
+            signal.reason
+        );
 
         const result: QValueUpdateResult = {
             entityId: signal.entityId,
@@ -184,7 +191,7 @@ export class EntityQValueManager {
         const updates: Array<{ entityId: string; qValue: number; reason: string }> = [];
 
         for (const entityId of entityIds) {
-            const entity = await this.repository.getEntity(entityId);
+            const entity = await this.repository.getEntity(entityId, channelId);
             if (!entity) continue;
 
             const alpha = getQValueLearningRate();
@@ -208,10 +215,10 @@ export class EntityQValueManager {
 
         // Batch update
         if (updates.length > 0) {
-            await this.repository.batchUpdateQValues(updates);
+            await this.repository.batchUpdateQValues(channelId, updates);
 
             // Record outcomes for statistics
-            await this.repository.recordOutcome(entityIds, taskOutcome.success);
+            await this.repository.recordOutcome(channelId, entityIds, taskOutcome.success);
 
             // Emit batch event
             this.emitBatchQValueUpdatedEvent(channelId, results, taskOutcome.taskId);
@@ -251,7 +258,7 @@ export class EntityQValueManager {
         }
 
         if (updates.length > 0) {
-            await this.repository.batchUpdateQValues(updates);
+            await this.repository.batchUpdateQValues(channelId, updates);
             this.logger.info(`Decayed Q-values for ${updates.length} unused entities in channel ${channelId}`);
         }
 
@@ -262,19 +269,23 @@ export class EntityQValueManager {
      * Boost Q-value for retrieved entities
      * Called when entities are used in context retrieval
      */
-    public async boostRetrievedEntities(entityIds: string[], boostAmount: number = 0.05): Promise<void> {
+    public async boostRetrievedEntities(
+        channelId: ChannelId,
+        entityIds: string[],
+        boostAmount: number = 0.05
+    ): Promise<void> {
         if (!this.enabled || entityIds.length === 0) {
             return;
         }
 
         // Increment retrieval counts
-        await this.repository.incrementRetrievalCount(entityIds);
+        await this.repository.incrementRetrievalCount(channelId, entityIds);
 
         // Small Q-value boost for being retrieved
         const updates: Array<{ entityId: string; qValue: number; reason: string }> = [];
 
         for (const entityId of entityIds) {
-            const entity = await this.repository.getEntity(entityId);
+            const entity = await this.repository.getEntity(entityId, channelId);
             if (entity) {
                 const newQValue = Math.min(1, entity.utility.qValue + boostAmount);
                 if (newQValue !== entity.utility.qValue) {
@@ -288,7 +299,7 @@ export class EntityQValueManager {
         }
 
         if (updates.length > 0) {
-            await this.repository.batchUpdateQValues(updates);
+            await this.repository.batchUpdateQValues(channelId, updates);
         }
     }
 

package/src/services/kg/GraphSurpriseCalculator.ts

@@ -309,20 +309,6 @@ export class GraphSurpriseCalculator {
         return analyses.sort((a, b) => b.surpriseScore - a.surpriseScore);
     }
 
-    /**
-     * Update surprise score for a relationship after analysis
-     */
-    public async updateRelationshipSurprise(
-        relationshipId: string,
-        surpriseScore: number
-    ): Promise<void> {
-        if (!this.enabled) {
-            return;
-        }
-
-        await this.repository.updateRelationship(relationshipId, { surpriseScore });
-    }
-
     /**
      * Emit high surprise relationship event
      */

package/src/services/kg/KnowledgeGraphService.ts

@@ -176,12 +176,12 @@ export class KnowledgeGraphService {
     /**
      * Get entity by ID
      */
-    public async getEntity(entityId: string): Promise<Entity | null> {
+    public async getEntity(entityId: string, channelId?: ChannelId): Promise<Entity | null> {
         if (!this.enabled) {
             return null;
         }
 
-        return this.repository.getEntity(entityId);
+        return this.repository.getEntity(entityId, channelId);
     }
 
     /**
@@ -219,6 +219,7 @@ export class KnowledgeGraphService {
      */
     public async updateEntity(
         entityId: string,
+        channelId: ChannelId,
         updates: Partial<Entity>,
         updatedBy?: AgentId
     ): Promise<Entity | null> {
@@ -226,12 +227,12 @@ export class KnowledgeGraphService {
             return null;
         }
 
-        const original = await this.repository.getEntity(entityId);
+        const original = await this.repository.getEntity(entityId, channelId);
         if (!original) {
             return null;
         }
 
-        const updated = await this.repository.updateEntity(entityId, updates);
+        const updated = await this.repository.updateEntity(entityId, channelId, updates);
 
         if (updated) {
             // Build changes object
@@ -261,6 +262,7 @@ export class KnowledgeGraphService {
      */
     public async deleteEntity(
         entityId: string,
+        channelId: ChannelId,
         deletedBy?: AgentId,
         reason?: string
     ): Promise<boolean> {
@@ -268,12 +270,12 @@ export class KnowledgeGraphService {
             return false;
         }
 
-        const entity = await this.repository.getEntity(entityId);
+        const entity = await this.repository.getEntity(entityId, channelId);
         if (!entity) {
             return false;
         }
 
-        const deleted = await this.repository.deleteEntity(entityId);
+        const deleted = await this.repository.deleteEntity(entityId, channelId);
 
         if (deleted) {
             this.emitEvent(KnowledgeGraphEvents.ENTITY_DELETED, entity.channelId, deletedBy || 'system', {
@@ -293,13 +295,18 @@ export class KnowledgeGraphService {
     public async mergeEntities(
         targetEntityId: string,
         sourceEntityIds: string[],
-        mergedBy?: AgentId
+        mergedBy?: AgentId,
+        channelId?: ChannelId
     ): Promise<EntityMergeResult> {
         if (!this.enabled) {
             return { success: false, sourceEntityIds, error: 'Knowledge Graph not enabled' };
         }
 
-        const result = await this.repository.mergeEntities(targetEntityId, sourceEntityIds);
+        const result = await this.repository.mergeEntities(
+            targetEntityId,
+            sourceEntityIds,
+            channelId
+        );
 
         if (result.success && result.mergedEntity) {
             this.emitEvent(
@@ -399,6 +406,7 @@ export class KnowledgeGraphService {
      */
     public async updateRelationship(
         relationshipId: string,
+        channelId: ChannelId,
         updates: Partial<Relationship>,
         updatedBy?: AgentId
     ): Promise<Relationship | null> {
@@ -407,11 +415,11 @@ export class KnowledgeGraphService {
         }
 
         const original = await this.repository.getRelationship(relationshipId);
-        if (!original) {
+        if (!original || original.channelId !== channelId) {
             return null;
         }
 
-        const updated = await this.repository.updateRelationship(relationshipId, updates);
+        const updated = await this.repository.updateRelationship(relationshipId, channelId, updates);
 
         if (updated) {
             const changes: Record<string, { old: any; new: any }> = {};
@@ -445,6 +453,7 @@ export class KnowledgeGraphService {
      */
     public async deleteRelationship(
         relationshipId: string,
+        channelId: ChannelId,
         deletedBy?: AgentId,
         reason?: string
     ): Promise<boolean> {
@@ -453,11 +462,11 @@ export class KnowledgeGraphService {
         }
 
         const relationship = await this.repository.getRelationship(relationshipId);
-        if (!relationship) {
+        if (!relationship || relationship.channelId !== channelId) {
             return false;
         }
 
-        const deleted = await this.repository.deleteRelationship(relationshipId);
+        const deleted = await this.repository.deleteRelationship(relationshipId, channelId);
 
         if (deleted) {
             this.emitEvent(
@@ -518,13 +527,14 @@ export class KnowledgeGraphService {
             entityType?: EntityType | EntityType[];
             maxDepth?: number;
             limit?: number;
-        }
+        },
+        channelId?: ChannelId
     ): Promise<{ entities: Entity[]; relationships: Relationship[] }> {
         if (!this.enabled) {
             return { entities: [], relationships: [] };
         }
 
-        return this.repository.getNeighbors(entityId, options);
+        return this.repository.getNeighbors(entityId, options, channelId);
     }
 
     /**
@@ -533,13 +543,14 @@ export class KnowledgeGraphService {
     public async findPath(
         fromEntityId: string,
         toEntityId: string,
-        maxHops?: number
+        maxHops?: number,
+        channelId?: ChannelId
     ): Promise<GraphPath | null> {
         if (!this.enabled) {
             return null;
         }
 
-        return this.repository.findPath(fromEntityId, toEntityId, maxHops);
+        return this.repository.findPath(fromEntityId, toEntityId, maxHops, channelId);
     }
 
     /**
@@ -547,13 +558,14 @@ export class KnowledgeGraphService {
      */
     public async getEntityContext(
         entityId: string,
-        depth?: number
+        depth?: number,
+        channelId?: ChannelId
     ): Promise<{ entities: Entity[]; relationships: Relationship[] }> {
         if (!this.enabled) {
             return { entities: [], relationships: [] };
         }
 
-        return this.repository.getSubgraph(entityId, depth);
+        return this.repository.getSubgraph(entityId, depth, undefined, channelId);
     }
 
     /**
@@ -599,6 +611,7 @@ export class KnowledgeGraphService {
      * Uses batch queries to avoid N+1 database calls.
      */
     public async findConnections(
+        channelId: ChannelId,
         entityIds: string[],
         maxHops?: number
     ): Promise<{ entities: Entity[]; relationships: Relationship[]; paths: GraphPath[] }> {
@@ -616,7 +629,8 @@ export class KnowledgeGraphService {
                     entityIds[i],
                     entityIds[j],
                     maxHops ?? 3,
-                    5
+                    5,
+                    channelId
                 );
                 allPaths.push(...paths);
 
@@ -630,10 +644,10 @@ export class KnowledgeGraphService {
         }
 
         // Batch fetch all entities in one query instead of N individual calls
-        const entities = await this.repository.getEntitiesByIds(Array.from(entitySet));
+        const entities = await this.repository.getEntitiesByIds(channelId, Array.from(entitySet));
 
         // Batch fetch all relationships involving these entities in one query
-        const allRels = await this.repository.getRelationshipsByEntityIds(Array.from(entitySet));
+        const allRels = await this.repository.getRelationshipsByEntityIds(channelId, Array.from(entitySet));
 
         // Filter to only relationships where both endpoints are in our entity set
         const seenRelIds = new Set<string>();
@@ -665,6 +679,7 @@ export class KnowledgeGraphService {
      */
     public async updateEntityQValue(
         entityId: string,
+        channelId: ChannelId,
         reward: number,
         reason: string
     ): Promise<Entity | null> {
@@ -672,7 +687,7 @@ export class KnowledgeGraphService {
             return null;
         }
 
-        const entity = await this.repository.getEntity(entityId);
+        const entity = await this.repository.getEntity(entityId, channelId);
         if (!entity) {
             return null;
         }
@@ -682,7 +697,7 @@ export class KnowledgeGraphService {
         const oldQValue = entity.utility.qValue;
         const newQValue = oldQValue + alpha * (reward - oldQValue);
 
-        const updated = await this.repository.updateEntityQValue(entityId, newQValue, reason);
+        const updated = await this.repository.updateEntityQValue(entityId, channelId, newQValue, reason);
 
         if (updated) {
             this.emitEvent(
@@ -706,6 +721,7 @@ export class KnowledgeGraphService {
      * Propagate reward to entities involved in a task
      */
     public async propagateReward(
+        channelId: ChannelId,
         entityIds: string[],
         reward: number,
         taskId?: string
@@ -716,13 +732,10 @@ export class KnowledgeGraphService {
 
         const updates: Array<{ entityId: string; qValue: number; reason: string }> = [];
         const alpha = getQValueLearningRate();
-        let channelId: ChannelId | null = null;
 
         for (const entityId of entityIds) {
-            const entity = await this.repository.getEntity(entityId);
+            const entity = await this.repository.getEntity(entityId, channelId);
             if (entity) {
-                if (!channelId) channelId = entity.channelId;
-
                 const newQValue = entity.utility.qValue + alpha * (reward - entity.utility.qValue);
                 updates.push({
                     entityId,
@@ -733,32 +746,27 @@ export class KnowledgeGraphService {
         }
 
         if (updates.length > 0) {
-            await this.repository.batchUpdateQValues(updates);
+            await this.repository.batchUpdateQValues(channelId, updates);
 
             // Record outcome
-            await this.repository.recordOutcome(entityIds, reward > 0.5);
+            await this.repository.recordOutcome(channelId, entityIds, reward > 0.5);
 
             // Emit batch update event
-            if (channelId) {
-                this.emitEvent(
-                    KnowledgeGraphEvents.ENTITY_QVALUE_BATCH_UPDATED,
+            this.emitEvent(
+                KnowledgeGraphEvents.ENTITY_QVALUE_BATCH_UPDATED,
+                channelId,
+                'system',
+                {
                     channelId,
-                    'system',
-                    {
-                        channelId,
-                        updates: updates.map((u) => {
-                            const entity = entityIds.find((id) => id === u.entityId);
-                            return {
-                                entityId: u.entityId,
-                                oldQValue: 0, // We don't track old values in batch
-                                newQValue: u.qValue,
-                            };
-                        }),
-                        reason: taskId ? `Task ${taskId} outcome` : 'Reward propagation',
-                        taskId,
-                    }
-                );
-            }
+                    updates: updates.map((u) => ({
+                        entityId: u.entityId,
+                        oldQValue: 0, // We don't track old values in batch
+                        newQValue: u.qValue,
+                    })),
+                    reason: taskId ? `Task ${taskId} outcome` : 'Reward propagation',
+                    taskId,
+                }
+            );
         }
     }
 

package/src/services/kg/OrparGraphIntegration.ts

@@ -236,7 +236,11 @@ export class OrparGraphIntegration {
         // Get relationships between matching entities
         const relationships: Relationship[] = [];
         for (const entity of matchingEntities) {
-            const neighbors = await this.kgService.getNeighbors(entity.id, { limit: 5 });
+            const neighbors = await this.kgService.getNeighbors(
+                entity.id,
+                { limit: 5 },
+                channelId
+            );
             for (const rel of neighbors.relationships) {
                 if (!relationships.find((r) => r.id === rel.id)) {
                     relationships.push(rel);
@@ -300,7 +304,7 @@ export class OrparGraphIntegration {
         }
 
         for (const entityId of centralEntityIds) {
-            const subgraph = await this.kgService.getEntityContext(entityId, 2);
+            const subgraph = await this.kgService.getEntityContext(entityId, 2, channelId);
             for (const entity of subgraph.entities) {
                 if (!allEntities.find((e) => e.id === entity.id)) {
                     allEntities.push(entity);
@@ -320,7 +324,8 @@ export class OrparGraphIntegration {
                 const path = await this.kgService.findPath(
                     centralEntityIds[i],
                     centralEntityIds[i + 1],
-                    3
+                    3,
+                    channelId
                 );
                 if (path) {
                     const fromEntity = allEntities.find((e) => e.id === centralEntityIds[i]);
@@ -400,7 +405,7 @@ export class OrparGraphIntegration {
 
         // Get entities and their dependencies
         for (const entityId of taskEntityIds) {
-            const entity = await this.kgService.getEntity(entityId);
+            const entity = await this.kgService.getEntity(entityId, channelId);
             if (entity) {
                 entities.push(entity);
 
@@ -408,7 +413,7 @@ export class OrparGraphIntegration {
                 const neighbors = await this.kgService.getNeighbors(entityId, {
                     direction: 'both',
                     limit: 20,
-                });
+                }, channelId);
 
                 for (const rel of neighbors.relationships) {
                     if (!relationships.find((r) => r.id === rel.id)) {
@@ -544,6 +549,7 @@ export class OrparGraphIntegration {
         for (const qUpdate of update.qValueUpdates) {
             const result = await this.qValueManager.updateEntityQValue({
                 entityId: qUpdate.entityId,
+                channelId,
                 reward: qUpdate.reward,
                 reason: qUpdate.reason,
             });

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

@@ -37,6 +37,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 { Events, ControlLoopEvents } from '../../events/EventNames.js';
@@ -88,6 +89,7 @@ export class CycleConsolidationTrigger {
     private qValueManager: QValueManager;
     private enabled: boolean = false;
     private rules: ConsolidationRule[];
+    private cycleCompletedSubscription?: Subscription;
 
     // Track success/failure counts per memory
     private memorySuccessCounts: Map<string, number> = new Map();
@@ -132,8 +134,13 @@ export class CycleConsolidationTrigger {
      * Setup event listeners for ORPAR cycle completion
      */
     private setupEventListeners(): void {
+        if (this.cycleCompletedSubscription && !this.cycleCompletedSubscription.closed) {
+            return;
+        }
+        this.cycleCompletedSubscription = undefined;
+
         // Listen to cycle completed events
-        EventBus.server.on(OrparMemoryEvents.CYCLE_COMPLETED, async (payload: any) => {
+        this.cycleCompletedSubscription = EventBus.server.on(OrparMemoryEvents.CYCLE_COMPLETED, async payload => {
             if (this.enabled) {
                 await this.onCycleCompleted(payload);
             }
@@ -686,6 +693,8 @@ export class CycleConsolidationTrigger {
      */
     public reset(): void {
         this.enabled = false;
+        this.cycleCompletedSubscription?.unsubscribe();
+        this.cycleCompletedSubscription = undefined;
         this.rules = DEFAULT_CONSOLIDATION_RULES;
         this.memorySuccessCounts.clear();
         this.memoryFailureCounts.clear();