@gotza02/seq-thinking 1.1.5 → 1.1.6

package/src/__tests__/sequential-thinking.test.ts

@@ -1,687 +0,0 @@
-/**
- * Sequential Thinking Engine Test Suite
- * Tests for ConfidenceCalibrator, ThoughtGraph, MetaReasoningEngine,
- * SelfCorrectionEngine, AdaptiveGranularityEngine, and SessionManager
- */
-import { test, describe, beforeEach } from 'node:test';
-import assert from 'node:assert';
-import {
-  ConfidenceCalibrator,
-  ThoughtGraph,
-  MetaReasoningEngine,
-  SelfCorrectionEngine,
-  AdaptiveGranularityEngine,
-  SessionManager,
-} from '../sequential-thinking.js';
-import { ThoughtType, SessionStatus, TaskStatus, type SessionContext, type SessionSettings } from '../types/index.js';
-
-describe('ConfidenceCalibrator', () => {
-  let calibrator: ConfidenceCalibrator;
-
-  beforeEach(() => {
-    calibrator = new ConfidenceCalibrator();
-  });
-
-  test('should create initial confidence with valid structure', () => {
-    const confidence = calibrator.createInitialConfidence();
-    
-    assert.ok(typeof confidence.overall === 'number');
-    assert.ok(confidence.overall >= 0 && confidence.overall <= 1);
-    
-    assert.ok(typeof confidence.components.logicalConsistency === 'number');
-    assert.ok(typeof confidence.components.factualAccuracy === 'number');
-    assert.ok(typeof confidence.components.reasoningQuality === 'number');
-    assert.ok(typeof confidence.components.evidenceStrength === 'number');
-    
-    assert.ok(Array.isArray(confidence.uncertaintyBounds));
-    assert.strictEqual(confidence.uncertaintyBounds.length, 2);
-    assert.ok(confidence.uncertaintyBounds[0] <= confidence.uncertaintyBounds[1]);
-    
-    assert.ok(Array.isArray(confidence.calibrationHistory));
-  });
-
-  test('should calculate overall confidence from components', () => {
-    const components = {
-      logicalConsistency: 0.9,
-      factualAccuracy: 0.8,
-      reasoningQuality: 0.85,
-      evidenceStrength: 0.75,
-    };
-    
-    const overall = calibrator.calculateOverall(components);
-    assert.ok(overall >= 0 && overall <= 1);
-    assert.ok(overall > 0.7 && overall < 0.9);
-  });
-
-  test('should handle all zero components', () => {
-    const components = {
-      logicalConsistency: 0,
-      factualAccuracy: 0,
-      reasoningQuality: 0,
-      evidenceStrength: 0,
-    };
-    
-    const overall = calibrator.calculateOverall(components);
-    assert.strictEqual(overall, 0);
-  });
-
-  test('should handle all perfect components', () => {
-    const components = {
-      logicalConsistency: 1,
-      factualAccuracy: 1,
-      reasoningQuality: 1,
-      evidenceStrength: 1,
-    };
-    
-    const overall = calibrator.calculateOverall(components);
-    assert.strictEqual(overall, 1);
-  });
-
-  test('should handle mixed component values', () => {
-    const components = {
-      logicalConsistency: 0.5,
-      factualAccuracy: 0.5,
-      reasoningQuality: 0.5,
-      evidenceStrength: 0.5,
-    };
-    
-    const overall = calibrator.calculateOverall(components);
-    assert.strictEqual(overall, 0.5);
-  });
-});
-
-describe('ThoughtGraph', () => {
-  let graph: ThoughtGraph;
-  const sessionId = 'test-session-001';
-
-  beforeEach(() => {
-    graph = new ThoughtGraph();
-  });
-
-  test('should create a thought with default options', () => {
-    const thought = graph.createThought(sessionId, 'Test thought content');
-    
-    assert.ok(thought.id);
-    assert.strictEqual(thought.sessionId, sessionId);
-    assert.strictEqual(thought.content, 'Test thought content');
-    assert.strictEqual(thought.thoughtType, ThoughtType.ANALYSIS);
-    assert.strictEqual(thought.stepNumber, 1);
-    assert.ok(thought.confidence);
-    assert.ok(thought.branchId);
-    assert.ok(thought.metadata.createdAt);
-  });
-
-  test('should create a thought with custom options', () => {
-    const thought = graph.createThought(sessionId, 'Custom thought', {
-      thoughtType: ThoughtType.ANALYSIS,
-      confidence: 0.9,
-      tags: ['test', 'analysis'],
-      assumptions: ['assumption-1'],
-      dependencies: ['dep-1'],
-      agentId: 'agent-001',
-    });
-    
-    assert.strictEqual(thought.thoughtType, ThoughtType.ANALYSIS);
-    assert.deepStrictEqual(thought.tags, ['test', 'analysis']);
-    assert.deepStrictEqual(thought.assumptions, ['assumption-1']);
-    assert.deepStrictEqual(thought.dependencies, ['dep-1']);
-    assert.strictEqual(thought.metadata.agentId, 'agent-001');
-  });
-
-  test('should create child thoughts with correct step numbers', () => {
-    const parent = graph.createThought(sessionId, 'Parent thought');
-    const child = graph.createThought(sessionId, 'Child thought', {
-      parentThoughtId: parent.id,
-    });
-    
-    assert.strictEqual(child.stepNumber, 2);
-    assert.strictEqual(child.parentThoughtId, parent.id);
-    assert.ok(parent.childThoughtIds.includes(child.id));
-  });
-
-  test('should create multiple levels of thoughts', () => {
-    const level1 = graph.createThought(sessionId, 'Level 1');
-    const level2 = graph.createThought(sessionId, 'Level 2', {
-      parentThoughtId: level1.id,
-    });
-    const level3 = graph.createThought(sessionId, 'Level 3', {
-      parentThoughtId: level2.id,
-    });
-    
-    assert.strictEqual(level1.stepNumber, 1);
-    assert.strictEqual(level2.stepNumber, 2);
-    assert.strictEqual(level3.stepNumber, 3);
-  });
-
-  test('should revise a thought', () => {
-    const original = graph.createThought(sessionId, 'Original content');
-    const revised = graph.reviseThought(original.id, 'Revised content', 'Improved clarity');
-    
-    assert.notStrictEqual(revised.id, original.id);
-    assert.strictEqual(revised.revisionOf, original.id);
-    assert.strictEqual(revised.content, 'Revised content');
-    assert.strictEqual(revised.revisionHistory.length, 1);
-    assert.strictEqual(revised.revisionHistory[0].previousContent, 'Original content');
-    assert.strictEqual(revised.revisionHistory[0].revisionReason, 'Improved clarity');
-  });
-
-  test('should create a branch', () => {
-    const root = graph.createThought(sessionId, 'Root thought');
-    const { branch, thought } = graph.createBranch(
-      sessionId,
-      root.id,
-      'Alternative Path',
-      'Exploring alternative reasoning',
-      'Branch thought'
-    );
-    
-    assert.ok(branch.id);
-    assert.strictEqual(branch.name, 'Alternative Path');
-    assert.strictEqual(branch.parentBranchId, root.branchId);
-    assert.ok(branch.thoughtIds.includes(thought.id));
-    assert.strictEqual(thought.branchId, branch.id);
-  });
-
-  test('should merge branches', () => {
-    const root = graph.createThought(sessionId, 'Root thought');
-    const { branch: branch1 } = graph.createBranch(sessionId, root.id, 'Branch 1', 'First branch', 'B1 thought');
-    const { branch: branch2 } = graph.createBranch(sessionId, root.id, 'Branch 2', 'Second branch', 'B2 thought');
-    
-    const mergeThought = graph.mergeBranches(branch1.id, branch2.id, 'Merged conclusion');
-    
-    assert.ok(mergeThought);
-    assert.strictEqual(mergeThought.thoughtType, ThoughtType.MERGE_POINT);
-  });
-
-  test('should prune a branch', () => {
-    const root = graph.createThought(sessionId, 'Root thought');
-    const { branch } = graph.createBranch(sessionId, root.id, 'To Prune', 'Will be pruned', 'Prune me');
-    
-    graph.pruneBranch(branch.id, 'Low confidence');
-    
-    const branches = graph.getBranches();
-    const prunedBranch = branches.get(branch.id);
-    assert.ok(prunedBranch);
-    assert.strictEqual(prunedBranch.status, 'pruned');
-  });
-
-  test('should get thinking path', () => {
-    const thought1 = graph.createThought(sessionId, 'Thought 1');
-    const thought2 = graph.createThought(sessionId, 'Thought 2', {
-      parentThoughtId: thought1.id,
-    });
-    const thought3 = graph.createThought(sessionId, 'Thought 3', {
-      parentThoughtId: thought2.id,
-    });
-    
-    const path = graph.getThinkingPath(thought3.id);
-    
-    assert.strictEqual(path.length, 3);
-    assert.strictEqual(path[0].id, thought1.id);
-    assert.strictEqual(path[1].id, thought2.id);
-    assert.strictEqual(path[2].id, thought3.id);
-  });
-
-  test('should get branch comparison', () => {
-    const root = graph.createThought(sessionId, 'Root thought');
-    const { branch: branch1 } = graph.createBranch(sessionId, root.id, 'Branch 1', 'First', 'B1');
-    const { branch: branch2 } = graph.createBranch(sessionId, root.id, 'Branch 2', 'Second', 'B2');
-    
-    graph.createThought(sessionId, 'B1 child', { branchId: branch1.id });
-    graph.createThought(sessionId, 'B2 child', { branchId: branch2.id });
-    
-    const comparison = graph.getBranchComparison([branch1.id, branch2.id]);
-    
-    assert.strictEqual(comparison.length, 2);
-    comparison.forEach(item => {
-      assert.ok(item.branchId);
-      assert.ok(typeof item.thoughtCount === 'number');
-      assert.ok(typeof item.averageConfidence === 'number');
-    });
-  });
-
-  test('should store thoughts and branches correctly', () => {
-    const root = graph.createThought(sessionId, 'Test thought');
-    graph.createBranch(sessionId, root.id, 'Branch 1', 'Test Branch', 'Branch content');
-    
-    const thoughts = graph.getThoughts();
-    const branches = graph.getBranches();
-    
-    assert.ok(thoughts instanceof Map);
-    assert.ok(branches instanceof Map);
-    assert.ok(thoughts.size > 0);
-    assert.ok(branches.size > 0);
-  });
-
-  test('should handle multiple thoughts in same branch', () => {
-    const thought1 = graph.createThought(sessionId, 'Thought 1');
-    const thought2 = graph.createThought(sessionId, 'Thought 2', {
-      branchId: thought1.branchId,
-    });
-    const thought3 = graph.createThought(sessionId, 'Thought 3', {
-      branchId: thought1.branchId,
-      parentThoughtId: thought2.id,
-    });
-    
-    assert.strictEqual(thought1.branchId, thought2.branchId);
-    assert.strictEqual(thought2.branchId, thought3.branchId);
-  });
-
-  test('should handle thought with null parent', () => {
-    const thought = graph.createThought(sessionId, 'Root thought', {
-      parentThoughtId: null,
-    });
-    
-    assert.strictEqual(thought.parentThoughtId, null);
-    assert.strictEqual(thought.stepNumber, 1);
-  });
-
-  test('should handle revision of non-existent thought gracefully', () => {
-    assert.throws(() => {
-      graph.reviseThought('non-existent-id', 'Content', 'Reason');
-    });
-  });
-});
-
-describe('MetaReasoningEngine', () => {
-  let engine: MetaReasoningEngine;
-  let graph: ThoughtGraph;
-
-  beforeEach(() => {
-    engine = new MetaReasoningEngine();
-    graph = new ThoughtGraph();
-  });
-
-  test('should reflect on session', async () => {
-    const session = createMockSession();
-    const reflection = await engine.reflect(session);
-    
-    assert.ok(reflection.reflectionType);
-    assert.ok(reflection.content);
-    assert.ok(Array.isArray(reflection.insights));
-    assert.ok(Array.isArray(reflection.recommendations));
-  });
-
-  test('should generate meta observation for thought', () => {
-    const sessionId = 'test-session';
-    const thought = graph.createThought(sessionId, 'Test thought');
-    
-    const metaNote = engine.generateMetaObservation(thought.id, graph);
-    
-    if (metaNote) {
-      assert.ok(metaNote.id);
-      assert.strictEqual(metaNote.thoughtId, thought.id);
-      assert.ok(metaNote.content);
-      assert.ok(['pattern', 'concern', 'strategy', 'bias', 'confidence', 'process'].includes(metaNote.observationType));
-      assert.ok(metaNote.timestamp);
-      assert.ok(Array.isArray(metaNote.triggeredActions));
-    }
-  });
-
-  test('should handle empty session reflection', async () => {
-    const emptySession = createMockSession({ totalThoughts: 0, totalBranches: 0 });
-    const reflection = await engine.reflect(emptySession);
-    
-    assert.ok(reflection);
-    assert.ok(Array.isArray(reflection.insights));
-    assert.ok(Array.isArray(reflection.recommendations));
-  });
-
-  test('should handle session with multiple branches', async () => {
-    const session = createMockSession({ totalThoughts: 10, totalBranches: 3 });
-    const reflection = await engine.reflect(session);
-    
-    assert.ok(reflection.insights.length > 0 || reflection.recommendations.length > 0);
-  });
-});
-
-describe('SelfCorrectionEngine', () => {
-  let engine: SelfCorrectionEngine;
-  let graph: ThoughtGraph;
-
-  beforeEach(() => {
-    engine = new SelfCorrectionEngine();
-    graph = new ThoughtGraph();
-  });
-
-  test('should detect issues in thought', async () => {
-    const sessionId = 'test-session';
-    const thought = graph.createThought(sessionId, 'Test thought with potential issues');
-    
-    const issues = await engine.detectIssues(thought, graph);
-    
-    assert.ok(Array.isArray(issues));
-    issues.forEach(issue => {
-      assert.ok(['logical', 'factual', 'assumption', 'calibration'].includes(issue.type));
-      assert.ok(['low', 'medium', 'high'].includes(issue.severity));
-      assert.ok(issue.description);
-      assert.ok(issue.suggestion);
-    });
-  });
-
-  test('should detect no issues in well-formed thought', async () => {
-    const sessionId = 'test-session';
-    const thought = graph.createThought(sessionId, 'Well-formed thought with clear reasoning', {
-      confidence: 0.95,
-      assumptions: ['valid-assumption'],
-    });
-    
-    const issues = await engine.detectIssues(thought, graph);
-    
-    // Should either return empty array or only low severity issues
-    issues.forEach(issue => {
-      assert.ok(issue.severity === 'low');
-    });
-  });
-
-  test('should check session health', () => {
-    const session = createMockSession({ totalThoughts: 5, totalBranches: 2 });
-    
-    const health = engine.checkSessionHealth(session);
-    
-    assert.ok(typeof health.isHealthy === 'boolean');
-    assert.ok(Array.isArray(health.issues));
-    assert.ok(Array.isArray(health.suggestions));
-    assert.ok(typeof health.confidence === 'number');
-    assert.ok(health.confidence >= 0 && health.confidence <= 1);
-  });
-
-  test('should identify unhealthy session', () => {
-    const unhealthySession = createMockSession({ 
-      totalThoughts: 100, 
-      totalBranches: 50,
-      status: SessionStatus.COMPLETED
-    });
-    
-    const health = engine.checkSessionHealth(unhealthySession);
-    
-    // High branch count might indicate issues
-    if (health.issues.length > 0) {
-      assert.ok(health.issues.some(issue => issue.includes('branch') || issue.includes('complexity')));
-    }
-  });
-
-  test('should handle empty session health check', () => {
-    const emptySession = createMockSession({ totalThoughts: 0, totalBranches: 0 });
-    
-    const health = engine.checkSessionHealth(emptySession);
-    
-    assert.ok(typeof health.isHealthy === 'boolean');
-    assert.ok(health.issues.length >= 0);
-  });
-});
-
-describe('AdaptiveGranularityEngine', () => {
-  let engine: AdaptiveGranularityEngine;
-
-  beforeEach(() => {
-    engine = new AdaptiveGranularityEngine();
-  });
-
-  test('should calculate granularity for simple topic', async () => {
-    const context = createMockContext();
-    const result = await engine.calculateGranularity('Simple topic', context, 1);
-    
-    assert.ok(typeof result.detail === 'number');
-    assert.ok(result.detail > 0 && result.detail <= 1);
-    assert.ok(result.reasoning);
-  });
-
-  test('should calculate granularity for complex topic', async () => {
-    const context = createMockContext();
-    const complexTopic = 'Analyze the implications of quantum computing on cryptographic systems';
-    const result = await engine.calculateGranularity(complexTopic, context, 1);
-    
-    assert.ok(result.detail > 0);
-    assert.ok(result.reasoning.length > 0);
-  });
-
-  test('should adjust granularity based on depth', async () => {
-    const context = createMockContext();
-    const topic = 'Test topic';
-    
-    const shallow = await engine.calculateGranularity(topic, context, 1);
-    const deep = await engine.calculateGranularity(topic, context, 10);
-    
-    // Deeper depth might suggest different granularity
-    assert.ok(typeof shallow.detail === 'number');
-    assert.ok(typeof deep.detail === 'number');
-  });
-
-  test('should get recommendation for session', () => {
-    const session = createMockSession();
-    
-    const recommendation = engine.getRecommendation(session);
-    
-    assert.ok(recommendation.suggestedAction);
-    assert.ok(typeof recommendation.detail === 'number');
-    assert.ok(recommendation.reasoning);
-  });
-
-  test('should handle empty context', async () => {
-    const emptyContext: SessionContext = {
-      originalProblem: '',
-      constraints: [],
-      relevantInformation: [],
-      workingMemory: new Map(),
-      longTermReferences: [],
-    };
-    
-    const result = await engine.calculateGranularity('Topic', emptyContext, 1);
-    
-    assert.ok(typeof result.detail === 'number');
-    assert.ok(result.reasoning);
-  });
-
-  test('should handle very complex context', async () => {
-    const complexContext: SessionContext = {
-      originalProblem: 'Complex multi-faceted problem',
-      constraints: Array(20).fill('constraint'),
-      relevantInformation: Array(50).fill('info'),
-      workingMemory: new Map(Array(30).fill(0).map((_, i) => [`key${i}`, `value${i}`])),
-      longTermReferences: Array(10).fill('ref'),
-    };
-    
-    const result = await engine.calculateGranularity('Complex topic', complexContext, 5);
-    
-    assert.ok(typeof result.detail === 'number');
-    assert.ok(result.detail > 0 && result.detail <= 1);
-  });
-});
-
-describe('SessionManager', () => {
-  let manager: SessionManager;
-
-  beforeEach(() => {
-    manager = new SessionManager();
-  });
-
-  test('should create a session', async () => {
-    const session = await manager.createSession('Test topic');
-    
-    assert.ok(session.id);
-    assert.strictEqual(session.topic, 'Test topic');
-    assert.strictEqual(session.status, SessionStatus.INITIALIZING);
-    assert.ok(session.branches instanceof Map);
-    assert.ok(session.thoughts instanceof Map);
-    assert.ok(session.settings);
-    assert.ok(session.metadata.createdAt);
-  });
-
-  test('should create session with custom settings', async () => {
-    const customSettings: Partial<SessionSettings> = {
-      maxBranches: 10,
-      confidenceThreshold: 0.8,
-      enableSelfCorrection: false,
-    };
-    
-    const session = await manager.createSession('Test topic', customSettings);
-    
-    assert.strictEqual(session.settings.maxBranches, 10);
-    assert.strictEqual(session.settings.confidenceThreshold, 0.8);
-    assert.strictEqual(session.settings.enableSelfCorrection, false);
-  });
-
-  test('should add thought to session', async () => {
-    const session = await manager.createSession('Test topic');
-    const result = await manager.addThought(session.id, 'Test thought content');
-    
-    assert.ok(result.thought);
-    assert.strictEqual(result.thought.content, 'Test thought content');
-    assert.ok(result.thought.confidence);
-  });
-
-  test('should add thought with options', async () => {
-    const session = await manager.createSession('Test topic');
-    const result = await manager.addThought(session.id, 'Test thought', {
-      thoughtType: ThoughtType.ANALYSIS,
-      confidence: 0.9,
-      tags: ['test'],
-    });
-    
-    assert.strictEqual(result.thought.thoughtType, ThoughtType.ANALYSIS);
-    assert.deepStrictEqual(result.thought.tags, ['test']);
-  });
-
-  test('should get session by id', async () => {
-    const session = await manager.createSession('Test topic');
-    const retrieved = manager.getSession(session.id);
-    
-    assert.ok(retrieved);
-    assert.strictEqual(retrieved!.id, session.id);
-    assert.strictEqual(retrieved!.topic, 'Test topic');
-  });
-
-  test('should return undefined for non-existent session', () => {
-    const retrieved = manager.getSession('non-existent-id');
-    assert.strictEqual(retrieved, undefined);
-  });
-
-  test('should get thought graph', () => {
-    const graph = manager.getThoughtGraph();
-    assert.ok(graph);
-    assert.ok(typeof graph.createThought === 'function');
-  });
-
-  test('should get meta engine', () => {
-    const engine = manager.getMetaEngine();
-    assert.ok(engine);
-    assert.ok(typeof engine.reflect === 'function');
-  });
-
-  test('should complete session', async () => {
-    const session = await manager.createSession('Test topic');
-    await manager.addThought(session.id, 'Thought 1');
-    
-    await manager.completeSession(session.id);
-    
-    const completed = manager.getSession(session.id);
-    assert.strictEqual(completed!.status, 'completed');
-    assert.ok(completed!.metadata.completedAt);
-  });
-
-  test('should get session status', async () => {
-    const session = await manager.createSession('Test topic');
-    await manager.addThought(session.id, 'Thought 1');
-    
-    const status = manager.getSessionStatus(session.id);
-    
-    assert.ok(status);
-    assert.strictEqual(status.id, session.id);
-    assert.ok(status.status);
-    assert.ok(typeof status.totalThoughts === 'number');
-    assert.ok(Array.isArray(status.branches));
-    assert.ok(typeof status.averageConfidence === 'number');
-    assert.ok(status.lastActivity);
-  });
-
-  test('should track multiple thoughts', async () => {
-    const session = await manager.createSession('Test topic');
-    
-    await manager.addThought(session.id, 'Thought 1');
-    await manager.addThought(session.id, 'Thought 2');
-    await manager.addThought(session.id, 'Thought 3');
-    
-    const status = manager.getSessionStatus(session.id);
-    assert.strictEqual(status.totalThoughts, 3);
-  });
-
-  test('should handle adding thought to non-existent session', async () => {
-    await assert.rejects(async () => {
-      await manager.addThought('non-existent-id', 'Test thought');
-    });
-  });
-
-  test('should handle completing non-existent session', async () => {
-    await assert.rejects(async () => {
-      await manager.completeSession('non-existent-id');
-    });
-  });
-
-  test('should create multiple independent sessions', async () => {
-    const session1 = await manager.createSession('Topic 1');
-    const session2 = await manager.createSession('Topic 2');
-    
-    assert.notStrictEqual(session1.id, session2.id);
-    
-    await manager.addThought(session1.id, 'Thought for session 1');
-    await manager.addThought(session2.id, 'Thought for session 2');
-    
-    const status1 = manager.getSessionStatus(session1.id);
-    const status2 = manager.getSessionStatus(session2.id);
-    
-    assert.strictEqual(status1.totalThoughts, 1);
-    assert.strictEqual(status2.totalThoughts, 1);
-  });
-});
-
-// Helper functions
-function createMockSession(overrides: { totalThoughts?: number; totalBranches?: number; status?: SessionStatus } = {}) {
-  const now = new Date();
-  return {
-    id: 'mock-session',
-    topic: 'Mock Topic',
-    status: overrides.status || SessionStatus.ACTIVE,
-    currentBranchId: 'branch-001',
-    branches: new Map(),
-    thoughts: new Map(),
-    metaNotes: new Map(),
-    context: {
-      originalProblem: 'Mock problem',
-      constraints: [],
-      relevantInformation: [],
-      workingMemory: new Map(),
-      longTermReferences: [],
-    },
-    settings: {
-      maxBranches: 5,
-      maxDepth: 10,
-      confidenceThreshold: 0.7,
-      enableSelfCorrection: true,
-      enableMetaReasoning: true,
-      enableParallelHypotheses: false,
-      adaptiveGranularity: true,
-      granularitySettings: {
-        minStepDetail: 1,
-        maxStepDetail: 10,
-        complexityThreshold: 0.5,
-      },
-    },
-    metadata: {
-      createdAt: now,
-      lastActivityAt: now,
-      totalThoughts: overrides.totalThoughts ?? 5,
-      totalBranches: overrides.totalBranches ?? 1,
-    },
-  };
-}
-
-function createMockContext(): SessionContext {
-  return {
-    originalProblem: 'Test problem',
-    constraints: ['constraint-1', 'constraint-2'],
-    relevantInformation: ['info-1', 'info-2'],
-    workingMemory: new Map([['key', 'value']]),
-    longTermReferences: ['ref-1'],
-  };
-}