nexus-prime 3.3.0 → 3.5.0

package/README.md

@@ -2,11 +2,16 @@
   <h1>🧬 Nexus Prime</h1>
   <p><strong>The Cognitive Operating System for Multi-Agent Swarms</strong></p>
 
-  [![Version](https://img.shields.io/badge/version-3.2.0-00ff88?style=for-the-badge&logoRepository=nexus-prime)](https://github.com/sir-ad/nexus-prime/releases)
+  [![npm version](https://img.shields.io/npm/v/nexus-prime?style=for-the-badge&color=00ff88)](https://www.npmjs.com/package/nexus-prime)
+  [![npm downloads](https://img.shields.io/npm/d18m/nexus-prime?style=for-the-badge&color=00d4ff)](https://www.npmjs.com/package/nexus-prime)
   [![License: MIT](https://img.shields.io/badge/License-MIT-00d4ff?style=for-the-badge)](LICENSE)
   [![Agentic OS](https://img.shields.io/badge/Ecosystem-Agentic_OS-8b5cf6?style=for-the-badge)](https://github.com/topics/agentic-os)
   [![Build Status](https://img.shields.io/badge/build-passing-success?style=for-the-badge)](https://github.com/sir-ad/nexus-prime/actions)
   [![Node.js](https://img.shields.io/badge/node-%3E%3D20.0.0-339933?style=for-the-badge&logo=node.js)](https://nodejs.org)
+  <!-- traffic-badges:start -->
+  [![Views](https://img.shields.io/endpoint?style=for-the-badge&logo=github&url=https%3A%2F%2Fgist.githubusercontent.com%2Fsir-ad%2Fbbf9ebc77ccb2097ccf760bec3825ab7%2Fraw%2Fviews.json)](https://github.com/sir-ad/nexus-prime)
+  [![Clones](https://img.shields.io/endpoint?style=for-the-badge&logo=github&url=https%3A%2F%2Fgist.githubusercontent.com%2Fsir-ad%2Fbbf9ebc77ccb2097ccf760bec3825ab7%2Fraw%2Fclones.json)](https://github.com/sir-ad/nexus-prime)
+  <!-- traffic-badges:end -->
   
   <!-- AI / Agentic Widgets -->
   [![AI Framework](https://img.shields.io/badge/AI-Framework-FF9900?style=for-the-badge)](https://github.com/topics/ai)
@@ -31,6 +36,9 @@ npx nexus-prime mcp
 
 **Nexus Prime** is a local-first coding-agent operating system. Exposed as an MCP (Model Context Protocol) server or integrated programmatically, it provides single and multi-agent systems with **persistent memory, selectable runtime backends, guarded live skills, workflow artifacts, a live dashboard, and parallel Git-worktree execution with verification.**
 
+**Website:** [sir-ad.github.io/nexus-prime](https://sir-ad.github.io/nexus-prime/)
+**Documentation:** [Knowledge Base](https://sir-ad.github.io/nexus-prime/knowledge-base.html) · [Integrations](https://sir-ad.github.io/nexus-prime/integrations.html) · [Architecture Diagrams](https://sir-ad.github.io/nexus-prime/architecture-diagrams.html)
+
 ---
 
 <details>
@@ -106,7 +114,7 @@ Nexus Prime significantly reduces cognitive load and token expenditure compared
 
 ---
 
-## 🏛️ Swarm Topology & Orchestration
+## 🏛️ Architecture & Swarm Topology
 
 Nexus Prime enables true parallelization by isolating agents into dynamically generated Git worktrees. Inter-worker communication happens over the local **POD Network**, and merges are mediated by the **Merge Oracle**.
 
@@ -132,12 +140,68 @@ sequenceDiagram
     M-->>U: JSON-RPC Response
 ```
 
+### 🐝 Phantom Swarm Execution Topology
+
+The original Phantom concept remains central to Nexus Prime: `GhostPass()` evaluates risk, workers execute in isolated worktrees, the entanglement layer shares runtime state, and the Merge Oracle decides what lands back on the main branch.
+
+```text
+┌─────────────────────────────────────────────────────────────────────┐
+│ SWARM EXECUTION TOPOLOGY                                            │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  [Main Branch] ──▶ GhostPass() (Risk Analysis)                      │
+│                          │                                          │
+│           ┌──────────────┼──────────────┐                           │
+│           │              │              │                           │
+│     [Worktree A]   [Worktree B]   [Worktree C]                      │
+│     (UX Agent)     (API Agent)    (DB Agent)                        │
+│           │              │              │                           │
+│           └────┬─────────┴─────────┬────┘                           │
+│                │                   │                                │
+│                ▼                   ▼                                │
+│        Entanglement Engine (Quantum-Inspired Hilbert Space)         │
+│                │                                                    │
+│                ▼                   ▼                                │
+│      Merge Oracle (Byzantine Consensus + Hierarchical Synthesis)    │
+│                │                                                    │
+│                ▼                                                    │
+│  [Main Branch] ◀── Commit & State Collapse                          │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
 <div align="center">
   <img src="./docs/assets/screenshots/swarm_trace.png" alt="Swarm Induction Trace" width="80%">
   <br>
   <i>Mandatory Induction: A 7-worker swarm coordinating via POD Network.</i>
 </div>
 
+### Execution Protocol (Agent Orchestrator)
+
+When invoking `nexus_spawn_workers`, workflow execution, or a runtime swarm task, Nexus Prime follows explicit routing patterns rather than improvised worker fan-out:
+
+| Request Intent | Sub-Agents Spawned | Execution Order |
+| :--- | :--- | :--- |
+| Full stack feature | UX Designer + Backend Engineer | Parallel, cross-communicating via POD |
+| Database migration | DB Architect + Backend Engineer | Sequential, schema first |
+| Bug hunt | 3x QA / verifier workers | Parallel competitive |
+| Refactor module | Senior Coder + Security / verifier pass | Sequential pipeline |
+
+```typescript
+import { PhantomSwarm } from 'nexus-prime/orchestrator';
+
+const swarm = new PhantomSwarm();
+
+const results = await swarm.dispatch({
+  goal: 'Migrate user settings to Postgres',
+  agents: ['db-migrator', 'api-refactor'],
+  topology: 'parallel-mesh',
+});
+
+swarm.on('consensus.reach', (state) => {
+  console.log(`Merged ${state.filesResolved} files with ${state.confidence}% certainty.`);
+});
+```
+
 ---
 
 ## 🧠 Core Capabilities
@@ -249,6 +313,27 @@ nexus-prime setup status
 
 ## 📜 Changelog
 
+### v3.4.0 "Dashboard Overhaul"
+- **Heartbeat Throttling**: Eliminated refresh storm from client heartbeats — graph stays stable.
+- **Smart Empty States**: Token dial, event filters, and graph all show context-aware placeholder UI.
+- **14 Default Skills**: session-start-research, prompt-architect, architecture-scout, debug-forensics, refactor-guardian, documentation-writer, dependency-auditor, performance-profiler + original 6.
+- **3 Default Workflows**: full-audit-loop, research-and-implement, release-pipeline — auto-seeded on first load.
+- **Graph Caching**: Memory topology preserves last-known-good state during refreshes.
+- **Version & User Display**: Header now shows package version and git username correctly.
+- **README Audit**: Updated changelog, fixed maintainer reference, verified all screenshot paths.
+
+### v3.3.0 "Dashboard Polish"
+- **Tool Spend Tracker**: Estimated cost visualization for token usage across sessions.
+- **Skill UI**: In-dashboard skill creation form and seed button for default skills.
+- **Tool Detection**: Improved client heuristic detection via environment variables and process scanning.
+- **Dashboard Stability**: Fixed flickering, memory graph load order, and token dial responsiveness.
+
+### v3.2.0 "Runtime Closure"
+- **Topology Console**: Rebuilt dashboard with memory graph, run graph, and POD network visualization.
+- **SSE Live Stream**: Server-Sent Events for real-time event broadcasting with exponential backoff.
+- **Backend Registry**: Selectable memory, compression, and DSL compiler backends.
+- **Security Hardening**: Content Security Policy headers and input sanitization.
+
 ### v3.0.0 "The Pulse Update"
 - **POD Telemetry**: Real-time heartbeat visualization of worker sync.
 - **Improved Tokens**: Optimized HyperTune for large monorepo traversal.
@@ -285,5 +370,5 @@ nexus-prime setup status
 
 <div align="center">
   <strong>License:</strong> MIT <br>
-  <strong>Maintainers:</strong> The Nexus Prime Protocol Consortium
+  <strong>Maintainer:</strong> <a href="https://github.com/sir-ad">Adarsh Agrahari (sir-ad)</a>
 </div>

package/dist/agents/adapters/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/agents/adapters/mcp.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AA0K5C,qBAAa,UAAW,YAAW,OAAO;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAG,KAAK,CAAU;IACtB,SAAS,UAAS;IAClB,MAAM,EAAE,MAAM,EAAE,CAAM;IAEtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,CAAa;IAC9B,OAAO,CAAC,SAAS,CAA4C;IAC7D,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,OAAO,CAAC,CAAkB;IAElC,OAAO,CAAC,GAAG;;IAmBX,OAAO,CAAC,gBAAgB;IAkCxB,WAAW,CAAC,KAAK,EAAE,UAAU;IAI7B,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,iBAAiB;YAgcX,cAAc;IAk/B5B,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAItC,OAAO,CAAC,IAAI;IAmBN,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAOxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B,IAAI,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IACnD,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;CAC1C"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/agents/adapters/mcp.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AA2K5C,qBAAa,UAAW,YAAW,OAAO;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAG,KAAK,CAAU;IACtB,SAAS,UAAS;IAClB,MAAM,EAAE,MAAM,EAAE,CAAM;IAEtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,CAAa;IAC9B,OAAO,CAAC,SAAS,CAA4C;IAC7D,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,OAAO,CAAC,CAAkB;IAElC,OAAO,CAAC,GAAG;;IAmBX,OAAO,CAAC,gBAAgB;IAkCxB,WAAW,CAAC,KAAK,EAAE,UAAU;IAI7B,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,iBAAiB;YA0iBX,cAAc;IAuoC5B,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAItC,OAAO,CAAC,IAAI;IAmBN,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAOxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B,IAAI,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IACnD,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;CAC1C"}

package/dist/agents/adapters/mcp.js

@@ -474,6 +474,112 @@ export class MCPAdapter {
                         required: ['workflowId'],
                     },
                 },
+                {
+                    name: 'nexus_hook_generate',
+                    description: 'Generate a runtime hook artifact for checkpoint and system-event execution.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Hook name' },
+                            description: { type: 'string', description: 'Hook description' },
+                            trigger: { type: 'string', enum: ['run.created', 'before-read', 'before-mutate', 'before-verify', 'retry', 'run.failed', 'run.verified', 'promotion.approved', 'memory.stored', 'shield.blocked'], description: 'Hook trigger' },
+                            riskClass: { type: 'string', enum: ['read', 'orchestrate', 'mutate'], description: 'Risk class for the hook' },
+                            scope: { type: 'string', enum: ['session', 'worker', 'global'], description: 'Initial hook scope' }
+                        },
+                        required: ['name', 'description', 'trigger'],
+                    },
+                },
+                {
+                    name: 'nexus_hook_deploy',
+                    description: 'Deploy or promote a hook artifact for future runs.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            hookId: { type: 'string', description: 'Hook artifact ID or exact name' },
+                            scope: { type: 'string', enum: ['session', 'worker', 'global'], description: 'Deployment scope' }
+                        },
+                        required: ['hookId'],
+                    },
+                },
+                {
+                    name: 'nexus_hook_revoke',
+                    description: 'Revoke a runtime hook artifact.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            hookId: { type: 'string', description: 'Hook artifact ID or exact name' }
+                        },
+                        required: ['hookId'],
+                    },
+                },
+                {
+                    name: 'nexus_automation_generate',
+                    description: 'Generate a runtime automation artifact for event, schedule, or connector triggers.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Automation name' },
+                            description: { type: 'string', description: 'Automation description' },
+                            triggerMode: { type: 'string', enum: ['event', 'schedule', 'connector'], description: 'Trigger mode' },
+                            eventTrigger: { type: 'string', enum: ['run.created', 'before-read', 'before-mutate', 'before-verify', 'retry', 'run.failed', 'run.verified', 'promotion.approved', 'memory.stored', 'shield.blocked'], description: 'Event trigger when triggerMode=event' },
+                            scope: { type: 'string', enum: ['session', 'worker', 'global'], description: 'Initial automation scope' }
+                        },
+                        required: ['name', 'description'],
+                    },
+                },
+                {
+                    name: 'nexus_automation_deploy',
+                    description: 'Deploy or promote an automation artifact.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            automationId: { type: 'string', description: 'Automation artifact ID or exact name' },
+                            scope: { type: 'string', enum: ['session', 'worker', 'global'], description: 'Deployment scope' }
+                        },
+                        required: ['automationId'],
+                    },
+                },
+                {
+                    name: 'nexus_automation_run',
+                    description: 'Run an automation artifact through the real execution runtime.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            automationId: { type: 'string', description: 'Automation artifact ID or exact name' },
+                            goal: { type: 'string', description: 'Optional override goal' }
+                        },
+                        required: ['automationId'],
+                    },
+                },
+                {
+                    name: 'nexus_automation_revoke',
+                    description: 'Revoke a runtime automation artifact.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            automationId: { type: 'string', description: 'Automation artifact ID or exact name' }
+                        },
+                        required: ['automationId'],
+                    },
+                },
+                {
+                    name: 'nexus_memory_audit',
+                    description: 'Audit stored memories for duplicates, contradictions, quarantine candidates, and promotion safety.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            limit: { type: 'number', description: 'Maximum memories to scan' }
+                        },
+                    },
+                },
+                {
+                    name: 'nexus_federation_status',
+                    description: 'Return local federation status, peer inventory, relay learnings, and active peer links.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
                 {
                     name: 'nexus_run_status',
                     description: 'Return the current recorded state of a runtime execution run.',
@@ -1234,6 +1340,142 @@ export class MCPAdapter {
                     return { content: [{ type: 'text', text: `❌ Workflow runtime error: ${error.message}` }] };
                 }
             }
+            case 'nexus_hook_generate': {
+                const name = String(request.params.arguments?.name ?? '');
+                const description = String(request.params.arguments?.description ?? '');
+                const trigger = String(request.params.arguments?.trigger ?? 'run.created');
+                const riskClass = String(request.params.arguments?.riskClass ?? 'orchestrate');
+                const scope = String(request.params.arguments?.scope ?? 'session');
+                const artifact = this.getRuntime().generateHook({ name, description, trigger, riskClass, scope });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `🪝 Hook generated\nID: ${artifact.hookId}\nName: ${artifact.name}\nTrigger: ${artifact.trigger}\nScope: ${artifact.scope}`,
+                        }],
+                };
+            }
+            case 'nexus_hook_deploy': {
+                const hookId = String(request.params.arguments?.hookId ?? '');
+                const scope = String(request.params.arguments?.scope ?? 'session');
+                const runtime = this.getRuntime();
+                const known = runtime.listHooks().find((hook) => hook.hookId === hookId || hook.name === hookId);
+                const artifact = known ? runtime.deployHook(known.hookId, scope) : undefined;
+                if (!artifact) {
+                    return { content: [{ type: 'text', text: `❌ Hook not found: ${hookId}` }] };
+                }
+                nexusEventBus.emit('hook.deploy', { hookId: artifact.hookId, scope: artifact.scope, status: artifact.rolloutStatus });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `🪝 Hook deployed\nID: ${artifact.hookId}\nName: ${artifact.name}\nScope: ${artifact.scope}\nRollout: ${artifact.rolloutStatus}`,
+                        }],
+                };
+            }
+            case 'nexus_hook_revoke': {
+                const hookId = String(request.params.arguments?.hookId ?? '');
+                const runtime = this.getRuntime();
+                const known = runtime.listHooks().find((hook) => hook.hookId === hookId || hook.name === hookId);
+                const artifact = known ? runtime.revokeHook(known.hookId) : undefined;
+                if (!artifact) {
+                    return { content: [{ type: 'text', text: `❌ Hook not found: ${hookId}` }] };
+                }
+                nexusEventBus.emit('hook.revoke', { hookId: artifact.hookId, status: artifact.rolloutStatus });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `🧯 Hook revoked\nID: ${artifact.hookId}\nName: ${artifact.name}\nRollout: ${artifact.rolloutStatus}`,
+                        }],
+                };
+            }
+            case 'nexus_automation_generate': {
+                const name = String(request.params.arguments?.name ?? '');
+                const description = String(request.params.arguments?.description ?? '');
+                const triggerMode = String(request.params.arguments?.triggerMode ?? 'event');
+                const eventTrigger = request.params.arguments?.eventTrigger ? String(request.params.arguments?.eventTrigger) : undefined;
+                const scope = String(request.params.arguments?.scope ?? 'session');
+                const artifact = this.getRuntime().generateAutomation({ name, description, triggerMode, eventTrigger, scope });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `🤖 Automation generated\nID: ${artifact.automationId}\nName: ${artifact.name}\nTrigger Mode: ${artifact.triggerMode}\nScope: ${artifact.scope}`,
+                        }],
+                };
+            }
+            case 'nexus_automation_deploy': {
+                const automationId = String(request.params.arguments?.automationId ?? '');
+                const scope = String(request.params.arguments?.scope ?? 'session');
+                const runtime = this.getRuntime();
+                const known = runtime.listAutomations().find((automation) => automation.automationId === automationId || automation.name === automationId);
+                const artifact = known ? runtime.deployAutomation(known.automationId, scope) : undefined;
+                if (!artifact) {
+                    return { content: [{ type: 'text', text: `❌ Automation not found: ${automationId}` }] };
+                }
+                nexusEventBus.emit('automation.deploy', { automationId: artifact.automationId, scope: artifact.scope, status: artifact.rolloutStatus });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `🤖 Automation deployed\nID: ${artifact.automationId}\nName: ${artifact.name}\nScope: ${artifact.scope}\nRollout: ${artifact.rolloutStatus}`,
+                        }],
+                };
+            }
+            case 'nexus_automation_run': {
+                const automationId = String(request.params.arguments?.automationId ?? '');
+                const goalOverride = request.params.arguments?.goal ? String(request.params.arguments.goal) : undefined;
+                try {
+                    const execution = await this.getRuntime().runAutomation(automationId, goalOverride);
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: [
+                                    `🤖 Automation Runtime — ${summarizeExecution(execution)}`,
+                                    `Run ID: ${execution.runId}`,
+                                    `Artifacts: ${execution.artifactsPath}`,
+                                    `Automations: ${execution.activeAutomations.map((automation) => automation.name).join(', ') || 'none'}`,
+                                    `Result: ${execution.result}`,
+                                ].join('\n'),
+                            }],
+                    };
+                }
+                catch (error) {
+                    return { content: [{ type: 'text', text: `❌ Automation runtime error: ${error.message}` }] };
+                }
+            }
+            case 'nexus_automation_revoke': {
+                const automationId = String(request.params.arguments?.automationId ?? '');
+                const runtime = this.getRuntime();
+                const known = runtime.listAutomations().find((automation) => automation.automationId === automationId || automation.name === automationId);
+                const artifact = known ? runtime.revokeAutomation(known.automationId) : undefined;
+                if (!artifact) {
+                    return { content: [{ type: 'text', text: `❌ Automation not found: ${automationId}` }] };
+                }
+                nexusEventBus.emit('automation.revoke', { automationId: artifact.automationId, status: artifact.rolloutStatus });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `🧯 Automation revoked\nID: ${artifact.automationId}\nName: ${artifact.name}\nRollout: ${artifact.rolloutStatus}`,
+                        }],
+                };
+            }
+            case 'nexus_memory_audit': {
+                const limit = Number(request.params.arguments?.limit ?? 80);
+                const audit = this.getRuntime().auditMemory(limit) ?? { scanned: 0, quarantined: [], findings: [] };
+                nexusEventBus.emit('memory.audit', { scanned: audit.scanned, quarantined: audit.quarantined.length });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(audit, null, 2),
+                        }],
+                };
+            }
+            case 'nexus_federation_status': {
+                const snapshot = this.getRuntime().getNetworkStatus();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(snapshot, null, 2),
+                        }],
+                };
+            }
             case 'nexus_run_status': {
                 const runId = String(request.params.arguments?.runId ?? '');
                 const run = this.getRuntime().getRun(runId);
@@ -1251,7 +1493,12 @@ export class MCPAdapter {
                                 workers: run.workerResults.length,
                                 verifiedWorkers: run.workerResults.filter((worker) => worker.verified).length,
                                 workflows: run.activeWorkflows.map((workflow) => workflow.name),
+                                hooks: run.activeHooks.map((hook) => hook.name),
+                                automations: run.activeAutomations.map((automation) => automation.name),
                                 promotions: run.promotionDecisions,
+                                shield: run.shieldDecisions,
+                                memoryChecks: run.memoryChecks,
+                                federation: run.federationState,
                                 backends: run.selectedBackends,
                             }, null, 2),
                         }],