claude-flow-novice 1.6.1 → 1.6.3

package/examples/phase-5-multi-level-control.ts

@@ -0,0 +1,282 @@
+/**
+ * Phase 5 - Sprint 5.2: Multi-Level Agent Control Example
+ *
+ * Demonstrates pause/inject/resume from Level 0 to any child level
+ *
+ * @module examples/phase-5-multi-level-control
+ */
+
+import { QueryController } from '../src/coordination/v2/sdk/query-controller.js';
+import { HierarchicalCoordinator } from '../src/agents/hierarchical-coordinator.js';
+import {
+  MultiLevelController,
+  InjectedCommandType,
+  createMultiLevelControllerWithHierarchy,
+} from '../src/coordination/v2/sdk/multi-level-control.js';
+
+/**
+ * Example: Multi-Level Agent Control
+ *
+ * Scenario:
+ * - Level 0: Supervisor (top-level coordinator)
+ * - Level 1: Team Leads (2 agents)
+ * - Level 2: Workers (3 agents under Team Lead A)
+ *
+ * Demonstrates:
+ * - Level 0 pauses any agent at any level
+ * - Level 0 injects commands to modify agent state/tasks
+ * - Level 0 resumes agents with commands applied
+ * - <100ms latency for all control operations
+ */
+async function multiLevelControlExample() {
+  console.log('=== Phase 5 - Sprint 5.2: Multi-Level Agent Control Example ===\n');
+
+  // Step 1: Initialize QueryController (Phase 0)
+  console.log('Step 1: Initialize QueryController for pause/resume...');
+  const queryController = new QueryController({
+    maxConcurrentAgents: 20,
+    defaultTokenBudget: 10000,
+    enableDynamicAllocation: true,
+  });
+  await queryController.initialize();
+  console.log('✓ QueryController initialized\n');
+
+  // Step 2: Initialize HierarchicalCoordinator (Phase 5)
+  console.log('Step 2: Initialize HierarchicalCoordinator for hierarchy management...');
+  const hierarchicalCoordinator = new HierarchicalCoordinator({
+    maxDepth: 10,
+    maxChildrenPerNode: 10,
+    enableDependencyTracking: true,
+  });
+  await hierarchicalCoordinator.initialize();
+  console.log('✓ HierarchicalCoordinator initialized\n');
+
+  // Step 3: Create Multi-Level Controller (Sprint 5.2)
+  console.log('Step 3: Create MultiLevelController integration layer...');
+  const multiLevelController = createMultiLevelControllerWithHierarchy(
+    queryController,
+    hierarchicalCoordinator,
+    {
+      maxControlLatencyMs: 100, // <100ms target
+      enableCommandQueue: true,
+      maxQueuedCommands: 50,
+    }
+  );
+  console.log('✓ MultiLevelController created\n');
+
+  // Step 4: Build 3-Level Agent Hierarchy
+  console.log('Step 4: Build 3-level agent hierarchy...');
+
+  // Level 0: Supervisor
+  const supervisor = await queryController.spawnAgent({
+    agentId: 'supervisor',
+    type: 'coordinator',
+    priority: 10,
+    metadata: { role: 'Level 0 Supervisor' },
+  });
+  await hierarchicalCoordinator.registerAgent(
+    'supervisor',
+    {
+      name: 'Supervisor',
+      type: 'coordinator',
+      level: 0,
+      status: 'ready',
+      capabilities: ['coordination', 'hierarchy-control'],
+    },
+    undefined // No parent (root)
+  );
+
+  // Level 1: Team Leads
+  const teamLeadA = await queryController.spawnAgent({
+    agentId: 'team-lead-a',
+    type: 'coordinator',
+    priority: 8,
+    metadata: { role: 'Team Lead A' },
+  });
+  await hierarchicalCoordinator.registerAgent(
+    'team-lead-a',
+    {
+      name: 'Team Lead A',
+      type: 'coordinator',
+      level: 1,
+      status: 'ready',
+      capabilities: ['coordination', 'task-delegation'],
+    },
+    'supervisor' // Parent: supervisor
+  );
+
+  const teamLeadB = await queryController.spawnAgent({
+    agentId: 'team-lead-b',
+    type: 'coordinator',
+    priority: 8,
+    metadata: { role: 'Team Lead B' },
+  });
+  await hierarchicalCoordinator.registerAgent(
+    'team-lead-b',
+    {
+      name: 'Team Lead B',
+      type: 'coordinator',
+      level: 1,
+      status: 'ready',
+      capabilities: ['coordination', 'task-delegation'],
+    },
+    'supervisor'
+  );
+
+  // Level 2: Workers (under Team Lead A)
+  const workerA1 = await queryController.spawnAgent({
+    agentId: 'worker-a1',
+    type: 'worker',
+    priority: 5,
+    metadata: { role: 'Worker A1' },
+  });
+  await hierarchicalCoordinator.registerAgent(
+    'worker-a1',
+    {
+      name: 'Worker A1',
+      type: 'worker',
+      level: 2,
+      status: 'ready',
+      capabilities: ['code-generation', 'testing'],
+    },
+    'team-lead-a'
+  );
+
+  const workerA2 = await queryController.spawnAgent({
+    agentId: 'worker-a2',
+    type: 'worker',
+    priority: 5,
+    metadata: { role: 'Worker A2' },
+  });
+  await hierarchicalCoordinator.registerAgent(
+    'worker-a2',
+    {
+      name: 'Worker A2',
+      type: 'worker',
+      level: 2,
+      status: 'ready',
+      capabilities: ['documentation', 'review'],
+    },
+    'team-lead-a'
+  );
+
+  console.log('✓ Hierarchy built:');
+  console.log('  - Level 0: Supervisor');
+  console.log('  - Level 1: Team Lead A, Team Lead B');
+  console.log('  - Level 2: Worker A1, Worker A2\n');
+
+  // Step 5: Demonstrate Multi-Level Control Operations
+  console.log('Step 5: Multi-Level Control Operations\n');
+
+  // Operation 1: Level 0 pauses Level 2 agent
+  console.log('Operation 1: Supervisor (L0) pauses Worker A1 (L2)...');
+  const pauseResult = await multiLevelController.pauseChildAgent(
+    'supervisor',
+    'worker-a1',
+    'Supervisor directive: pause for configuration update'
+  );
+  console.log(`✓ Paused: ${pauseResult.success}`);
+  console.log(`  - Agent: ${pauseResult.agentId} (Level ${pauseResult.level})`);
+  console.log(`  - Latency: ${pauseResult.latencyMs.toFixed(2)}ms (<100ms target)\n`);
+
+  // Operation 2: Level 0 injects commands to paused agent
+  console.log('Operation 2: Supervisor (L0) injects commands to Worker A1 (L2)...');
+
+  const stateInjection = await multiLevelController.injectCommand(
+    'supervisor',
+    'worker-a1',
+    InjectedCommandType.STATE_UPDATE,
+    { state: 'working' },
+    false
+  );
+  console.log(`✓ Injected STATE_UPDATE: ${stateInjection.success} (${stateInjection.latencyMs.toFixed(2)}ms)`);
+
+  const taskInjection = await multiLevelController.injectCommand(
+    'supervisor',
+    'worker-a1',
+    InjectedCommandType.TASK_UPDATE,
+    {
+      task: 'Implement authentication module',
+      taskId: 'task-auth-001',
+      deadline: '2025-10-15',
+    },
+    false
+  );
+  console.log(`✓ Injected TASK_UPDATE: ${taskInjection.success} (${taskInjection.latencyMs.toFixed(2)}ms)`);
+
+  const priorityInjection = await multiLevelController.injectCommand(
+    'supervisor',
+    'worker-a1',
+    InjectedCommandType.PRIORITY_UPDATE,
+    { priority: 9 },
+    false
+  );
+  console.log(`✓ Injected PRIORITY_UPDATE: ${priorityInjection.success} (${priorityInjection.latencyMs.toFixed(2)}ms)`);
+
+  const queuedCount = multiLevelController.getQueuedCommandsCount('worker-a1');
+  console.log(`  - Queued commands: ${queuedCount}\n`);
+
+  // Operation 3: Level 0 resumes agent with commands applied
+  console.log('Operation 3: Supervisor (L0) resumes Worker A1 (L2)...');
+  const resumeResult = await multiLevelController.resumeChildAgent('supervisor', 'worker-a1');
+  console.log(`✓ Resumed: ${resumeResult.success}`);
+  console.log(`  - Commands applied: ${resumeResult.data?.appliedCommands}`);
+  console.log(`  - Latency: ${resumeResult.latencyMs.toFixed(2)}ms\n`);
+
+  // Verify commands were applied
+  const workerSession = await queryController.getAgentSession('worker-a1');
+  console.log('✓ Verification:');
+  console.log(`  - Worker A1 state: ${workerSession.state}`);
+  console.log(`  - Worker A1 priority: ${workerSession.priority}`);
+  console.log(`  - Injected commands: ${workerSession.metadata.injectedCommands?.length ?? 0}\n`);
+
+  // Operation 4: Cascade pause to all Team Lead A's children
+  console.log('Operation 4: Supervisor (L0) cascades pause to all Team Lead A children...');
+  const cascadeResults = await multiLevelController.cascadeControlOperation('team-lead-a', 'pause');
+  console.log(`✓ Cascade pause completed: ${cascadeResults.length} agents affected`);
+  for (const result of cascadeResults) {
+    console.log(
+      `  - ${result.agentId} (L${result.level}): ${result.success ? 'Paused' : 'Failed'} (${result.latencyMs.toFixed(2)}ms)`
+    );
+  }
+  console.log('');
+
+  // Operation 5: Cascade resume
+  console.log('Operation 5: Supervisor (L0) cascades resume to all Team Lead A children...');
+  const resumeCascade = await multiLevelController.cascadeControlOperation('team-lead-a', 'resume');
+  console.log(`✓ Cascade resume completed: ${resumeCascade.length} agents resumed\n`);
+
+  // Step 6: Show Final Metrics
+  console.log('Step 6: Control Operation Metrics');
+  const metrics = multiLevelController.getMetrics();
+  console.log(`  - Total pauses: ${metrics.totalPauses}`);
+  console.log(`  - Total injections: ${metrics.totalInjections}`);
+  console.log(`  - Total resumes: ${metrics.totalResumes}`);
+  console.log(`  - Average latency: ${metrics.averageControlLatencyMs.toFixed(2)}ms`);
+  console.log(`  - Max latency: ${metrics.maxControlLatencyMs.toFixed(2)}ms`);
+  console.log(`  - Within <100ms target: ${metrics.withinTarget ? 'YES ✓' : 'NO ✗'}\n`);
+
+  // Cleanup
+  console.log('Cleanup...');
+  await multiLevelController.cleanup();
+  await hierarchicalCoordinator.shutdown();
+  await queryController.cleanup();
+  console.log('✓ All components cleaned up\n');
+
+  console.log('=== Multi-Level Control Example Complete ===');
+}
+
+// Run example
+if (import.meta.url === `file://${process.argv[1]}`) {
+  multiLevelControlExample()
+    .then(() => {
+      console.log('\n✓ Example completed successfully');
+      process.exit(0);
+    })
+    .catch((error) => {
+      console.error('\n✗ Example failed:', error);
+      process.exit(1);
+    });
+}
+
+export { multiLevelControlExample };

package/examples/session-pool-optimizer-example.ts

@@ -0,0 +1,311 @@
+/**
+ * Session Pool Optimizer - Usage Examples
+ *
+ * Demonstrates how to use the SessionPoolOptimizer for managing
+ * 50+ concurrent agent sessions with efficient resource management.
+ */
+
+import { SessionPoolOptimizer } from '../src/coordination/v2/sdk/session-pool-optimizer.js';
+import type { SessionRequest, PoolMetrics } from '../src/coordination/v2/sdk/session-pool-optimizer.js';
+
+/**
+ * Example 1: Basic Session Pool Setup
+ */
+async function basicPoolSetup() {
+  console.log('=== Example 1: Basic Session Pool Setup ===\n');
+
+  // Initialize pool with default configuration
+  const pool = new SessionPoolOptimizer({
+    maxPoolSize: 60,
+    minPoolSize: 10,
+    autoScaleThreshold: 80,
+  });
+
+  await pool.initialize();
+
+  // Acquire session for an agent
+  const session = await pool.acquireSession({
+    agentId: 'agent-1',
+    priority: 8,
+    metadata: { task: 'feature-development' },
+  });
+
+  console.log(`Session acquired: ${session.sessionId}`);
+  console.log(`Agent ID: ${session.agentId}`);
+  console.log(`Priority: ${session.metadata.priority}`);
+
+  // Release session
+  await pool.releaseSession(session.sessionId);
+  console.log('Session released back to pool\n');
+
+  await pool.shutdown();
+}
+
+/**
+ * Example 2: Handling 50+ Concurrent Agents
+ */
+async function handleConcurrentAgents() {
+  console.log('=== Example 2: Handling 50+ Concurrent Agents ===\n');
+
+  const pool = new SessionPoolOptimizer({
+    maxPoolSize: 70,
+    minPoolSize: 15,
+    throttleLimit: 10,
+  });
+
+  await pool.initialize();
+
+  // Simulate 55 concurrent agents
+  const agentRequests: SessionRequest[] = [];
+  for (let i = 0; i < 55; i++) {
+    agentRequests.push({
+      agentId: `concurrent-agent-${i}`,
+      priority: Math.floor(Math.random() * 10),
+      metadata: { index: i },
+    });
+  }
+
+  // Acquire sessions concurrently
+  console.log('Acquiring 55 sessions concurrently...');
+  const sessions = await Promise.all(
+    agentRequests.map((req) => pool.acquireSession(req))
+  );
+
+  const metrics = pool.getMetrics();
+  console.log(`\nPool Metrics:`);
+  console.log(`- Current pool size: ${metrics.currentPoolSize}`);
+  console.log(`- Active sessions: ${metrics.activeSessions}`);
+  console.log(`- Utilization: ${metrics.utilizationPercent.toFixed(1)}%`);
+  console.log(`- Auto-scale events: ${metrics.autoScaleEvents}`);
+
+  // Release all sessions
+  await Promise.all(sessions.map((s) => pool.releaseSession(s.sessionId)));
+  console.log('\nAll sessions released\n');
+
+  await pool.shutdown();
+}
+
+/**
+ * Example 3: Session Reuse and Efficiency
+ */
+async function sessionReuseExample() {
+  console.log('=== Example 3: Session Reuse and Efficiency ===\n');
+
+  const pool = new SessionPoolOptimizer({
+    maxPoolSize: 30,
+    minPoolSize: 5,
+    enableReuse: true,
+  });
+
+  await pool.initialize();
+
+  // Create and release sessions
+  const session1 = await pool.acquireSession({
+    agentId: 'agent-reuse-1',
+    priority: 5,
+  });
+  console.log(`Session 1 created: ${session1.sessionId}`);
+  await pool.releaseSession(session1.sessionId);
+
+  // Acquire new session (should reuse idle session)
+  const session2 = await pool.acquireSession({
+    agentId: 'agent-reuse-2',
+    priority: 6,
+  });
+
+  const metrics = pool.getMetrics();
+  console.log(`\nReuse Statistics:`);
+  console.log(`- Total sessions created: ${metrics.totalCreated}`);
+  console.log(`- Total reuses: ${metrics.totalReuses}`);
+  console.log(`- Idle sessions: ${metrics.idleSessions}`);
+
+  await pool.releaseSession(session2.sessionId);
+  await pool.shutdown();
+}
+
+/**
+ * Example 4: Health Checks and Auto-Recovery
+ */
+async function healthCheckExample() {
+  console.log('\n=== Example 4: Health Checks and Auto-Recovery ===\n');
+
+  const pool = new SessionPoolOptimizer({
+    maxPoolSize: 25,
+    minPoolSize: 5,
+    healthCheckIntervalMs: 5000, // 5 seconds
+    enableAutoRecovery: true,
+  });
+
+  await pool.initialize();
+
+  // Listen for health check events
+  pool.on('health:checked', (event) => {
+    console.log(`Health Check: ${event.healthyCount}/${event.totalChecked} healthy (${event.passRate.toFixed(1)}%)`);
+  });
+
+  // Create some sessions
+  await pool.acquireSession({ agentId: 'health-agent-1', priority: 5 });
+  await pool.acquireSession({ agentId: 'health-agent-2', priority: 6 });
+
+  console.log('Waiting for health checks...');
+  await new Promise((resolve) => setTimeout(resolve, 6000));
+
+  const metrics = pool.getMetrics();
+  console.log(`\nHealth Metrics:`);
+  console.log(`- Health check pass rate: ${metrics.healthCheckPassRate.toFixed(1)}%`);
+  console.log(`- Unhealthy sessions: ${metrics.unhealthySessions}`);
+
+  await pool.shutdown();
+}
+
+/**
+ * Example 5: Session Pinning for Critical Sessions
+ */
+async function sessionPinningExample() {
+  console.log('\n=== Example 5: Session Pinning for Critical Sessions ===\n');
+
+  const pool = new SessionPoolOptimizer({
+    maxPoolSize: 20,
+    minPoolSize: 5,
+  });
+
+  await pool.initialize();
+
+  // Acquire critical session
+  const criticalSession = await pool.acquireSession({
+    agentId: 'critical-agent',
+    priority: 10,
+    metadata: { critical: true },
+  });
+
+  // Pin session to prevent eviction
+  pool.pinSession(criticalSession.sessionId);
+  console.log(`Critical session pinned: ${criticalSession.sessionId}`);
+
+  const session = pool.getSession(criticalSession.sessionId);
+  console.log(`Is pinned: ${session?.metadata.isPinned}`);
+
+  // Later, unpin when no longer critical
+  pool.unpinSession(criticalSession.sessionId);
+  console.log('Session unpinned\n');
+
+  await pool.releaseSession(criticalSession.sessionId);
+  await pool.shutdown();
+}
+
+/**
+ * Example 6: Metrics Monitoring
+ */
+async function metricsMonitoringExample() {
+  console.log('=== Example 6: Metrics Monitoring ===\n');
+
+  const pool = new SessionPoolOptimizer({
+    maxPoolSize: 40,
+    minPoolSize: 10,
+  });
+
+  await pool.initialize();
+
+  // Create workload
+  for (let i = 0; i < 15; i++) {
+    await pool.acquireSession({
+      agentId: `metrics-agent-${i}`,
+      priority: Math.floor(Math.random() * 10),
+    });
+  }
+
+  const metrics = pool.getMetrics();
+
+  console.log('Pool Metrics Dashboard:');
+  console.log('========================');
+  console.log(`Pool Size: ${metrics.currentPoolSize} (max: 40)`);
+  console.log(`Active Sessions: ${metrics.activeSessions}`);
+  console.log(`Idle Sessions: ${metrics.idleSessions}`);
+  console.log(`Utilization: ${metrics.utilizationPercent.toFixed(1)}%`);
+  console.log(`\nLifetime Statistics:`);
+  console.log(`Total Created: ${metrics.totalCreated}`);
+  console.log(`Total Evicted: ${metrics.totalEvicted}`);
+  console.log(`Total Reuses: ${metrics.totalReuses}`);
+  console.log(`Avg Lifetime: ${(metrics.averageLifetimeMs / 1000).toFixed(2)}s`);
+  console.log(`\nPerformance:`);
+  console.log(`Request Rate: ${metrics.requestRate} req/s`);
+  console.log(`Health Pass Rate: ${metrics.healthCheckPassRate.toFixed(1)}%`);
+  console.log(`Auto-scale Events: ${metrics.autoScaleEvents}\n`);
+
+  await pool.shutdown();
+}
+
+/**
+ * Example 7: Event-Driven Architecture
+ */
+async function eventDrivenExample() {
+  console.log('=== Example 7: Event-Driven Architecture ===\n');
+
+  const pool = new SessionPoolOptimizer({
+    maxPoolSize: 30,
+    minPoolSize: 8,
+  });
+
+  // Set up event listeners
+  pool.on('session:created', (event) => {
+    console.log(`✓ Session created: ${event.sessionId} for ${event.agentId}`);
+  });
+
+  pool.on('session:reused', (event) => {
+    console.log(`♻️  Session reused: ${event.sessionId} for ${event.agentId}`);
+  });
+
+  pool.on('session:released', (event) => {
+    console.log(`↓ Session released: ${event.sessionId}`);
+  });
+
+  pool.on('pool:autoscaled', (event) => {
+    console.log(`📈 Pool auto-scaled: ${event.previousSize} → ${event.newSize}`);
+  });
+
+  await pool.initialize();
+
+  // Trigger events
+  const session1 = await pool.acquireSession({ agentId: 'event-agent-1', priority: 7 });
+  await pool.releaseSession(session1.sessionId);
+
+  const session2 = await pool.acquireSession({ agentId: 'event-agent-2', priority: 8 });
+  await pool.releaseSession(session2.sessionId);
+
+  console.log('');
+  await pool.shutdown();
+}
+
+/**
+ * Run all examples
+ */
+async function runAllExamples() {
+  try {
+    await basicPoolSetup();
+    await handleConcurrentAgents();
+    await sessionReuseExample();
+    await healthCheckExample();
+    await sessionPinningExample();
+    await metricsMonitoringExample();
+    await eventDrivenExample();
+
+    console.log('✅ All examples completed successfully!');
+  } catch (error) {
+    console.error('❌ Example failed:', error);
+  }
+}
+
+// Run examples if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runAllExamples();
+}
+
+export {
+  basicPoolSetup,
+  handleConcurrentAgents,
+  sessionReuseExample,
+  healthCheckExample,
+  sessionPinningExample,
+  metricsMonitoringExample,
+  eventDrivenExample,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow-novice",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "description": "Standalone Claude Flow for beginners - AI agent orchestration made easy with enhanced TDD testing pipeline. Enhanced init command creates complete agent system, MCP configuration with 30 essential tools, and automated hooks with single-file testing, real-time coverage analysis, and advanced validation. Fully standalone with zero external dependencies, complete project setup in one command.",
   "mcpName": "io.github.ruvnet/claude-flow",
   "main": ".claude-flow-novice/dist/index.js",
@@ -205,13 +205,16 @@
     "src/npx/",
     "src/language/",
     "src/hooks/",
+    "src/observability/",
     "examples/",
     "wiki/",
     "CLAUDE.md",
     "README.md",
     "README-NPM.md",
     "LICENSE",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "AGENT_PERFORMANCE_GUIDELINES.md",
+    "MEMORY_LEAK_ROOT_CAUSE.md"
   ],
   "exports": {
     ".": "./.claude-flow-novice/dist/index.js",
@@ -229,6 +232,9 @@
     "./slash-commands/parse-epic": "./.claude-flow-novice/dist/src/slash-commands/parse-epic.js",
     "./slash-commands/custom-routing-activate": "./.claude-flow-novice/dist/src/slash-commands/custom-routing-activate.js",
     "./slash-commands/custom-routing-deactivate": "./.claude-flow-novice/dist/src/slash-commands/custom-routing-deactivate.js",
+    "./slash-commands/metrics-summary": "./.claude-flow-novice/dist/src/slash-commands/metrics-summary.js",
+    "./observability/metrics-counter": "./.claude-flow-novice/dist/src/observability/metrics-counter.js",
+    "./observability/metrics-storage": "./.claude-flow-novice/dist/src/observability/metrics-storage.js",
     "./providers": "./.claude-flow-novice/dist/src/providers/index.js",
     "./providers/zai": "./.claude-flow-novice/dist/src/providers/zai-provider.js",
     "./providers/tiered-router": "./.claude-flow-novice/dist/src/providers/tiered-router.js",
@@ -241,11 +247,15 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.1.1",
     "@modelcontextprotocol/sdk": "^1.18.2",
+    "@types/bcrypt": "^6.0.0",
+    "@types/express-rate-limit": "^5.1.3",
     "@types/msgpack-lite": "^0.1.11",
     "@types/msgpack5": "^3.4.6",
+    "@types/winston": "^2.4.4",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "async-mutex": "^0.5.0",
+    "bcrypt": "^6.0.0",
     "better-sqlite3": "^12.4.1",
     "boxen": "^8.0.1",
     "chalk": "^4.1.2",
@@ -253,11 +263,14 @@
     "commander": "^13.1.0",
     "compression": "^1.7.4",
     "cors": "^2.8.5",
+    "express-rate-limit": "^8.1.0",
     "fs-extra": "^11.2.0",
     "glob": "^11.0.0",
-    "helmet": "^7.0.0",
+    "helmet": "^7.2.0",
     "inquirer": "^12.9.6",
     "isomorphic-dompurify": "^2.28.0",
+    "jsonwebtoken": "^9.0.2",
+    "limiter": "^3.0.0",
     "lru-cache": "^11.2.2",
     "msgpack-lite": "^0.1.26",
     "msgpack5": "^6.0.2",
@@ -266,6 +279,7 @@
     "socket.io": "^4.8.1",
     "table": "^6.8.0",
     "uuid": "^13.0.0",
+    "winston": "^3.18.3",
     "ws": "^8.14.0",
     "yaml": "^2.8.1",
     "zod": "^3.25.76"
@@ -281,7 +295,7 @@
     "@swc/core": "^1.13.19",
     "@types/blessed": "^0.1.25",
     "@types/commander": "^2.12.0",
-    "@types/cors": "^2.8.17",
+    "@types/cors": "^2.8.19",
     "@types/express": "^4.17.21",
     "@types/figlet": "^1.7.0",
     "@types/fs-extra": "^11.0.4",