nexus-prime 3.0.3 → 3.2.0

package/README.md

@@ -2,7 +2,7 @@
   <h1>🧬 Nexus Prime</h1>
   <p><strong>The Cognitive Operating System for Multi-Agent Swarms</strong></p>
 
-  [![Version](https://img.shields.io/badge/version-3.0.0-00ff88?style=for-the-badge&logoRepository=nexus-prime)](https://github.com/sir-ad/nexus-prime/releases)
+  [![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)
   [![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)
@@ -29,7 +29,7 @@ npx nexus-prime mcp
 
 ---
 
-**Nexus Prime** is an autonomous, hyper-optimized, distributed, Byzantine-fault-tolerant cognitive operating system. Exposed as an MCP (Model Context Protocol) server or integrated programmatically, it provides single and multi-agent systems with **permanent memory, mathematically optimized context limits, safety guardrails, and massively parallel Git-worktree execution.**
+**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.**
 
 ---
 
@@ -166,10 +166,21 @@ Formulates file-reading as a **Greedy Knapsack Problem**, solving for maximum in
 ### 3. Phantom Worker Swarms
 <details>
 <summary><b>View Details</b></summary>
-Parallelize complex tasks using isolated Git Worktrees. Ghost Pass performs read-only risk analysis, while the Merge Oracle evaluates AST diffs using **Byzantine Fault Tolerance consensus**.
+Parallelize complex tasks using isolated Git Worktrees. Ghost Pass performs read-only risk analysis, coder workers execute real file mutations in detached worktrees, verifier workers run build/test commands independently, and the Merge Oracle selects the final patch with an auditable artifact trail.
 </details>
 
-### 4. Quantum-Inspired Entanglement (Phase 9A)
+### 4. Live Skills, Workflows, and Derivation
+<details>
+<summary><b>View Details</b></summary>
+Nexus Prime now ships bundled domain skill packs and workflow packs for **marketing, product, backend, frontend, sales, finance, workflows, and orchestration**. Runs can generate new skills and workflows, deploy them at runtime checkpoints, and promote them only after verifier evidence plus multi-tier consensus.
+</details>
+
+### 5. Runtime Console
+<details>
+<summary><b>View Details</b></summary>
+The built-in dashboard exposes active and recent runs, worker states, verifier results, backend catalogs, skills, workflows, live events, and docs/release health from the same runtime ledger that powers CLI and MCP execution.
+</details>
+### 6. Quantum-Inspired Entanglement (Phase 9A)
 <details>
 <summary><b>View Details</b></summary>
 Agents share mathematical state in a high-dimensional Hilbert space. When an agent acts, the shared probabilistic state collapses, causing entangled agents to automatically make correlated decisions across the swarm without explicit communication overhead.
@@ -177,7 +188,7 @@ Agents share mathematical state in a high-dimensional Hilbert space. When an age
 
 ---
 
-## 🛠️ MCP Tooling Checklist (v1.5)
+## 🛠️ MCP Tooling Checklist
 
 Nexus Prime exposes 20 native MCP tools that any agent can invoke. Below are key examples:
 
@@ -186,11 +197,31 @@ Nexus Prime exposes 20 native MCP tools that any agent can invoke. Below are key
 | `nexus_store_memory` | Store finding/insight | Core |
 | `nexus_recall_memory` | Semantically recall context | Core |
 | `nexus_optimize_tokens` | Mathematical context reduction | Optimization |
-| `nexus_spawn_workers` | Dispatch parallel swarm | Autonomy |
+| `nexus_spawn_workers` | Execute parallel worktree swarm with verification and artifacts | Autonomy |
 | `nexus_mindkit_check` | Guardrail validation | Safety |
 | `nexus_ghost_pass` | Pre-flight risk analysis | Analysis |
+| `nexus_run_status` | Inspect run ledger state | Runtime |
+| `nexus_skill_generate` | Generate deployable runtime skills | Runtime |
+| `nexus_workflow_run` | Execute workflow artifacts | Runtime |
 | `nexus_entangle` | Measure entangled agent state | Quantum |
 
+### Real Runtime Execution
+```bash
+# Execute a real runtime task with explicit actions
+nexus-prime execute <agent-id> "apply runtime patch" \
+  --files README.md package.json \
+  --verify "npm run build" \
+  --skills backend-playbook orchestration-playbook \
+  --workflows backend-execution-loop \
+  --compression-backend meta-compression \
+  --actions-file ./actions.json
+
+# Execute an NXL graph directly
+nexus-prime execute <agent-id> "ship release workflow" --nxl-file ./plan.nxl.yaml
+```
+
+Each run returns a real execution state plus an artifact directory containing manifests, worker diffs, verifier output, and the final merge decision.
+
 ---
 
 ## 🚀 Get Started

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

@@ -9,9 +9,11 @@ export declare class MCPAdapter implements Adapter {
     private nexusRef?;
     private telemetry;
     private sessionDNA;
+    private runtime?;
     private box;
     constructor();
     setNexusRef(nexus: NexusPrime): void;
+    private getRuntime;
     private setupToolHandlers;
     private handleToolCall;
     scanSourceFiles(cwd: string): string[];

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":"AAWA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAsK5C,qBAAa,UAAW,YAAW,OAAO;IACtC,IAAI,SAAS;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;IAEtC,OAAO,CAAC,GAAG;;IAkBX,WAAW,CAAC,KAAK,EAAE,UAAU;IAI7B,OAAO,CAAC,iBAAiB;YAiWX,cAAc;IAq0B5B,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":"AAWA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AA0K5C,qBAAa,UAAW,YAAW,OAAO;IACtC,IAAI,SAAS;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;;IAkBX,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"}

package/dist/agents/adapters/mcp.js

@@ -1,12 +1,11 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
-import { statSync, readdirSync, readFileSync } from 'fs';
+import { statSync, readdirSync } from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { TokenSupremacyEngine, formatReadingPlan } from '../../engines/token-supremacy.js';
-import { GhostPass, PhantomWorker } from '../../phantom/index.js';
-import { MergeOracle } from '../../phantom/merge-oracle.js';
+import { GhostPass, createSubAgentRuntime, summarizeExecution, } from '../../phantom/index.js';
 import { GuardrailEngine } from '../../engines/guardrails-bridge.js';
 import { SessionDNAManager } from '../../engines/session-dna.js';
 import { ContextAssembler } from '../../engines/context-assembler.js';
@@ -28,6 +27,7 @@ const casEngine = new ContinuousAttentionStream();
 const kvBridge = createKVBridge({ agents: 3 });
 const orchestrator = new OrchestratorEngine();
 const federation = new FederationEngine();
+const fallbackRuntime = createSubAgentRuntime({ repoRoot: process.cwd() });
 // Lazy-initialized Graph Engine (separate DB from core memory)
 let _graphEngine = null;
 let _traversalEngine = null;
@@ -156,6 +156,7 @@ export class MCPAdapter {
     nexusRef;
     telemetry = new SessionTelemetry();
     sessionDNA;
+    runtime;
     box(title, content, color = '34') {
         const width = 68;
         console.error(`\n\x1b[${color}m┌─ ${title} ${'─'.repeat(Math.max(0, width - title.length - 4))}┐\x1b[0m`);
@@ -172,6 +173,15 @@ export class MCPAdapter {
     setNexusRef(nexus) {
         this.nexusRef = nexus;
     }
+    getRuntime() {
+        if (this.nexusRef && typeof this.nexusRef.getRuntime === 'function') {
+            return this.nexusRef.getRuntime();
+        }
+        if (!this.runtime) {
+            this.runtime = fallbackRuntime;
+        }
+        return this.runtime;
+    }
     setupToolHandlers() {
         this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
             tools: [
@@ -262,13 +272,22 @@ export class MCPAdapter {
                 },
                 {
                     name: 'nexus_spawn_workers',
-                    description: 'Spawn parallel Phantom Workers when modifying 3+ interrelated files OR when Ghost Pass recommends parallel exploration. Each worker gets an isolated git worktree to independently analyze the goal. Workers sync via POD Network. Returns a synthesized merge decision with confidence score and recommended approach.',
+                    description: 'Spawn parallel Phantom Workers when modifying 3+ interrelated files OR when Ghost Pass recommends parallel exploration. Each worker gets an isolated git worktree to execute actions, run verification, and return artifacts. The runtime applies merge consensus and reports the final decision truthfully.',
                     inputSchema: {
                         type: 'object',
                         properties: {
                             goal: { type: 'string', description: 'The overall goal for the swarm' },
                             files: { type: 'array', items: { type: 'string' }, description: 'Files relevant to the task' },
-                            workers: { type: 'number', description: 'Number of phantom workers to spawn (max 7)', default: 3 }
+                            workers: { type: 'number', description: 'Number of phantom workers to spawn (max 7)', default: 3 },
+                            verify: { type: 'array', items: { type: 'string' }, description: 'Verification commands to run in verifier worktrees' },
+                            strategies: { type: 'array', items: { type: 'string' }, description: 'Optional worker strategies such as minimal, standard, thorough' },
+                            actions: { type: 'array', items: { type: 'object' }, description: 'Optional runtime actions or skill bindings to execute in worker worktrees' },
+                            skills: { type: 'array', items: { type: 'string' }, description: 'Runtime skill selectors' },
+                            workflows: { type: 'array', items: { type: 'string' }, description: 'Workflow selectors' },
+                            memoryBackend: { type: 'string', description: 'Memory backend selector' },
+                            compressionBackend: { type: 'string', description: 'Compression backend selector' },
+                            dslCompiler: { type: 'string', description: 'DSL compiler selector' },
+                            backendMode: { type: 'string', enum: ['default', 'shadow', 'experimental'], description: 'Backend execution mode' }
                         },
                         required: ['goal', 'files'],
                     },
@@ -338,6 +357,92 @@ export class MCPAdapter {
                         required: ['card'],
                     },
                 },
+                {
+                    name: 'nexus_skill_generate',
+                    description: 'Generate a live runtime skill artifact that can be deployed to future runs or promoted after evidence-backed execution.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Skill name' },
+                            instructions: { type: 'string', description: 'Instructions for the generated skill' },
+                            riskClass: { type: 'string', enum: ['read', 'orchestrate', 'mutate'], description: 'Risk class for the skill' },
+                            scope: { type: 'string', enum: ['session', 'worker', 'global'], description: 'Initial scope for the skill' }
+                        },
+                        required: ['name', 'instructions'],
+                    },
+                },
+                {
+                    name: 'nexus_skill_deploy',
+                    description: 'Promote or deploy a live runtime skill artifact so future runs can activate it.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            skillId: { type: 'string', description: 'Skill artifact ID or exact name' },
+                            scope: { type: 'string', enum: ['session', 'worker', 'global'], description: 'Deployment scope' }
+                        },
+                        required: ['skillId'],
+                    },
+                },
+                {
+                    name: 'nexus_skill_revoke',
+                    description: 'Revoke a live runtime skill artifact.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            skillId: { type: 'string', description: 'Skill artifact ID or exact name' }
+                        },
+                        required: ['skillId'],
+                    },
+                },
+                {
+                    name: 'nexus_workflow_generate',
+                    description: 'Generate a workflow artifact that can be deployed to runs or promoted through runtime evidence.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Workflow name' },
+                            description: { type: 'string', description: 'Workflow description' },
+                            domain: { type: 'string', description: 'Optional workflow domain' },
+                            scope: { type: 'string', enum: ['session', 'worker', 'global'], description: 'Initial workflow scope' }
+                        },
+                        required: ['name', 'description'],
+                    },
+                },
+                {
+                    name: 'nexus_workflow_deploy',
+                    description: 'Deploy or promote a workflow artifact for future runs.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            workflowId: { type: 'string', description: 'Workflow artifact ID or exact name' },
+                            scope: { type: 'string', enum: ['session', 'worker', 'global'], description: 'Deployment scope' }
+                        },
+                        required: ['workflowId'],
+                    },
+                },
+                {
+                    name: 'nexus_workflow_run',
+                    description: 'Run a workflow artifact through the real execution runtime.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            workflowId: { type: 'string', description: 'Workflow artifact ID or exact name' },
+                            goal: { type: 'string', description: 'Optional override goal' }
+                        },
+                        required: ['workflowId'],
+                    },
+                },
+                {
+                    name: 'nexus_run_status',
+                    description: 'Return the current recorded state of a runtime execution run.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            runId: { type: 'string', description: 'Execution run ID' }
+                        },
+                        required: ['runId'],
+                    },
+                },
                 // ── Darwin Loop ──────────────────────────────────────────────────
                 {
                     name: 'nexus_darwin_propose',
@@ -474,7 +579,7 @@ export class MCPAdapter {
                 // ── Nexus Layer (v1.5) ──────────────────────────────────────────
                 {
                     name: 'nexus_execute_nxl',
-                    description: 'Execute a declarative Nexus Language (NXL) script or induce an army of specialized agents for a goal.',
+                    description: 'Execute a declarative Nexus Language (NXL) script as a real runtime graph across worktree-backed sub-agents, verification workers, and merge consensus.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -736,75 +841,92 @@ export class MCPAdapter {
                 const rawFiles = Array.isArray(request.params.arguments?.files)
                     ? request.params.arguments.files.map(String)
                     : [];
-                const files = rawFiles.map(p => {
-                    try {
-                        const stat = statSync(p);
-                        return { path: p, sizeBytes: stat.size, lastModified: stat.mtimeMs };
-                    }
-                    catch {
-                        return { path: p, sizeBytes: 0 };
+                const verifyCommands = Array.isArray(request.params.arguments?.verify)
+                    ? request.params.arguments.verify.map(String)
+                    : undefined;
+                const strategies = Array.isArray(request.params.arguments?.strategies)
+                    ? request.params.arguments.strategies.map(String)
+                    : undefined;
+                const actions = Array.isArray(request.params.arguments?.actions)
+                    ? request.params.arguments.actions
+                    : [];
+                const skills = Array.isArray(request.params.arguments?.skills)
+                    ? request.params.arguments.skills.map(String)
+                    : undefined;
+                const workflows = Array.isArray(request.params.arguments?.workflows)
+                    ? request.params.arguments.workflows.map(String)
+                    : undefined;
+                const memoryBackend = request.params.arguments?.memoryBackend
+                    ? String(request.params.arguments.memoryBackend)
+                    : undefined;
+                const compressionBackend = request.params.arguments?.compressionBackend
+                    ? String(request.params.arguments.compressionBackend)
+                    : undefined;
+                const dslCompiler = request.params.arguments?.dslCompiler
+                    ? String(request.params.arguments.dslCompiler)
+                    : undefined;
+                const backendMode = request.params.arguments?.backendMode
+                    ? String(request.params.arguments.backendMode)
+                    : undefined;
+                const execution = await this.getRuntime().run({
+                    goal,
+                    files: rawFiles,
+                    workers: workersCount,
+                    roles: ['planner', 'coder', 'verifier', 'skill-maker', 'research-shadow'],
+                    verifyCommands,
+                    strategies,
+                    actions,
+                    skillNames: skills,
+                    workflowSelectors: workflows,
+                    backendSelectors: { memoryBackend, compressionBackend, dslCompiler },
+                    backendMode,
+                });
+                const verifiedWorkers = execution.workerResults.filter(result => result.verified).length;
+                const modifiedFiles = execution.workerResults.reduce((sum, result) => sum + result.modifiedFiles.length, 0);
+                execution.activeSkills.forEach(skill => {
+                    this.sessionDNA.recordSkill(skill.name);
+                    if (skill.scope === 'global' || skill.rolloutStatus === 'promoted') {
+                        this.sessionDNA.recordSkillLearned(skill.name);
                     }
                 });
-                const ghost = new GhostPass(process.cwd());
-                const report = await ghost.analyze(goal, files, workersCount);
-                // Multi-process dispatch with worktree-isolated execution
-                const workerPromises = report.workerAssignments.map(async (assign) => {
-                    const worker = new PhantomWorker(process.cwd());
-                    return worker.spawn(assign, async (worktreeDir, task, w) => {
-                        const learnings = [];
-                        // Read relevant files in the worktree to build context
-                        for (const file of task.files.slice(0, 5)) {
-                            try {
-                                const fullPath = path.join(worktreeDir, file.path);
-                                const content = readFileSync(fullPath, 'utf-8').slice(0, 500);
-                                learnings.push(`[${task.approach}] Read ${file.path}: ${content.length} chars`);
-                            }
-                            catch {
-                                learnings.push(`[${task.approach}] Could not read ${file.path}`);
-                            }
-                        }
-                        // Broadcast discovery to POD network for cross-worker learning
-                        w.broadcast(`Worker ${w.id} (${task.approach}): analyzed ${task.files.length} files`, 0.7, ['#phantom-swarm', `#approach-${task.approach}`]);
-                        nexusEventBus.emit('phantom.worker.start', { workerId: `W-${w.id}`, approach: task.approach, goal });
-                        // Check what other workers found
-                        const peerFindings = w.receive(['#phantom-swarm']);
-                        if (peerFindings.length > 0) {
-                            learnings.push(`Received ${peerFindings.length} findings from peer workers`);
-                        }
-                        const confidence = learnings.length > 0 ? 0.75 : 0.5;
-                        nexusEventBus.emit('phantom.worker.complete', { workerId: `W-${w.id}`, confidence });
-                        return {
-                            learnings,
-                            confidence,
-                        };
-                    });
+                execution.workerResults.forEach(result => {
+                    result.modifiedFiles.forEach(file => this.sessionDNA.recordFileModified(file));
                 });
-                const results = await Promise.all(workerPromises);
-                // Synthesis
-                const oracle = new MergeOracle(this.nexusRef.memory);
-                const decision = await oracle.merge(results);
-                this.nexusRef.storeMemory(`Phantom Swarm executed: ${results.length} workers, action=${decision.action}, confidence=${decision.confidence.toFixed(2)}`, 0.8, ['#phantom-swarm', '#decision']);
-                nexusEventBus.emit('phantom.merge', { action: decision.action, winner: decision.recommendedStrategy });
-                // NEW: Agent Learning Loop
-                await this.nexusRef.analyzeLearning(goal, decision);
-                // Console ASCII UI
-                this.box('🐝 PHANTOM SWARM MERGED', [
-                    `Workers: ${results.length.toString().padEnd(5, ' ')} Confidence: ${decision.confidence.toFixed(2).padEnd(36)}`,
-                    `Action: ${decision.action.padEnd(57, ' ')}`
-                ], '32');
+                this.sessionDNA.recordDecision('Runtime swarm execution completed', execution.result || summarizeExecution(execution), execution.state === 'merged' ? 0.94 : execution.state === 'rolled_back' ? 0.45 : 0.3);
+                this.nexusRef.storeMemory(`Runtime swarm: state=${execution.state}, workers=${execution.workerResults.length}, verified=${verifiedWorkers}, decision=${execution.finalDecision?.action ?? 'none'}`, execution.state === 'merged' ? 0.92 : 0.72, ['#phantom', '#decision', execution.state]);
+                if (execution.finalDecision) {
+                    nexusEventBus.emit('phantom.merge', {
+                        action: execution.finalDecision.action,
+                        winner: execution.finalDecision.recommendedStrategy,
+                    });
+                    await this.nexusRef.analyzeLearning(goal, execution.finalDecision);
+                }
+                this.box('🐝 PHANTOM RUNTIME', [
+                    `Run: ${execution.runId.padEnd(28, ' ')} State: ${execution.state.padEnd(18, ' ')}`,
+                    `Workers: ${execution.workerResults.length.toString().padEnd(5, ' ')} Verified: ${verifiedWorkers.toString().padEnd(10, ' ')} Files: ${String(modifiedFiles).padEnd(12, ' ')}`,
+                    `Decision: ${(execution.finalDecision?.action ?? 'none').padEnd(52, ' ')}`
+                ], execution.state === 'merged' ? '32' : execution.state === 'rolled_back' ? '33' : '31');
                 return {
                     content: [{
                             type: 'text',
                             text: [
-                                `🐝 Phantom Swarm Complete — ${results.length} workers synchronized.`,
-                                '',
-                                `🎯 Goal: ${goal}`,
+                                `🐝 Phantom Runtime — ${summarizeExecution(execution)}`,
                                 '',
-                                `🧩 Synthesized Decision:`,
-                                decision.synthesized || 'No changes made.',
+                                `Run ID: ${execution.runId}`,
+                                `State: ${execution.state}`,
+                                `Artifacts: ${execution.artifactsPath}`,
+                                `Workers: ${execution.workerResults.length}`,
+                                `Verified Workers: ${verifiedWorkers}`,
+                                `Modified Files: ${modifiedFiles}`,
+                                `Decision: ${execution.finalDecision?.action ?? 'none'}`,
+                                `Recommended Strategy: ${execution.finalDecision?.recommendedStrategy ?? 'n/a'}`,
+                                `Planner: ${execution.plannerResult?.summary ?? 'n/a'}`,
+                                `Backends: memory=${execution.selectedBackends.memoryBackend}, compression=${execution.selectedBackends.compressionBackend}, consensus=${execution.selectedBackends.consensusPolicy}, dsl=${execution.selectedBackends.dslCompiler}`,
+                                `Active Skills: ${execution.activeSkills.length > 0 ? execution.activeSkills.map(skill => `${skill.name}(${skill.riskClass})`).join(', ') : 'none'}`,
+                                `Active Workflows: ${execution.activeWorkflows.length > 0 ? execution.activeWorkflows.map(workflow => workflow.name).join(', ') : 'none'}`,
+                                `Promotions: ${execution.promotionDecisions.length > 0 ? execution.promotionDecisions.map(decision => `${decision.kind}:${decision.target}:${decision.approved ? 'approved' : 'held'}`).join(', ') : 'none'}`,
                                 '',
-                                `📝 Conflicts: ${decision.conflicts.length > 0 ? decision.conflicts.join(', ') : 'None'}`,
-                                `📈 Strategy: ${decision.recommendedStrategy}`
+                                `Result: ${execution.result}`
                             ].join('\n')
                         }]
                 };
@@ -972,6 +1094,127 @@ export class MCPAdapter {
                         }]
                 };
             }
+            case 'nexus_skill_generate': {
+                const name = String(request.params.arguments?.name ?? '');
+                const instructions = String(request.params.arguments?.instructions ?? '');
+                const riskClass = String(request.params.arguments?.riskClass ?? 'orchestrate');
+                const scope = String(request.params.arguments?.scope ?? 'session');
+                const artifact = this.getRuntime().generateSkill({ name, instructions, riskClass, scope, provenance: 'mcp:generate' });
+                this.sessionDNA.recordSkillLearned(artifact.name);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `🧠 Runtime skill generated\nID: ${artifact.skillId}\nName: ${artifact.name}\nRisk: ${artifact.riskClass}\nScope: ${artifact.scope}\nProvenance: ${artifact.provenance}`,
+                        }],
+                };
+            }
+            case 'nexus_skill_deploy': {
+                const skillId = String(request.params.arguments?.skillId ?? '');
+                const scope = String(request.params.arguments?.scope ?? 'session');
+                const runtime = this.getRuntime();
+                const known = runtime.listSkills().find((skill) => skill.skillId === skillId || skill.name === skillId);
+                const artifact = known ? runtime.deploySkill(known.skillId, scope) : undefined;
+                if (!artifact) {
+                    return { content: [{ type: 'text', text: `❌ Skill not found: ${skillId}` }] };
+                }
+                this.sessionDNA.recordSkill(artifact.name);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `🚚 Runtime skill deployed\nID: ${artifact.skillId}\nName: ${artifact.name}\nScope: ${artifact.scope}\nRollout: ${artifact.rolloutStatus}`,
+                        }],
+                };
+            }
+            case 'nexus_skill_revoke': {
+                const skillId = String(request.params.arguments?.skillId ?? '');
+                const runtime = this.getRuntime();
+                const known = runtime.listSkills().find((skill) => skill.skillId === skillId || skill.name === skillId);
+                const artifact = known ? runtime.revokeSkill(known.skillId) : undefined;
+                if (!artifact) {
+                    return { content: [{ type: 'text', text: `❌ Skill not found: ${skillId}` }] };
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `🧯 Runtime skill revoked\nID: ${artifact.skillId}\nName: ${artifact.name}\nRollout: ${artifact.rolloutStatus}`,
+                        }],
+                };
+            }
+            case 'nexus_workflow_generate': {
+                const name = String(request.params.arguments?.name ?? '');
+                const description = String(request.params.arguments?.description ?? '');
+                const domain = request.params.arguments?.domain ? String(request.params.arguments?.domain) : undefined;
+                const scope = String(request.params.arguments?.scope ?? 'session');
+                const artifact = this.getRuntime().generateWorkflow({ name, description, domain, scope });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `🧭 Workflow generated\nID: ${artifact.workflowId}\nName: ${artifact.name}\nDomain: ${artifact.domain}\nScope: ${artifact.scope}`,
+                        }],
+                };
+            }
+            case 'nexus_workflow_deploy': {
+                const workflowId = String(request.params.arguments?.workflowId ?? '');
+                const scope = String(request.params.arguments?.scope ?? 'session');
+                const runtime = this.getRuntime();
+                const known = runtime.listWorkflows().find((workflow) => workflow.workflowId === workflowId || workflow.name === workflowId);
+                const artifact = known ? runtime.deployWorkflow(known.workflowId, scope) : undefined;
+                if (!artifact) {
+                    return { content: [{ type: 'text', text: `❌ Workflow not found: ${workflowId}` }] };
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `🚚 Workflow deployed\nID: ${artifact.workflowId}\nName: ${artifact.name}\nScope: ${artifact.scope}\nRollout: ${artifact.rolloutStatus}`,
+                        }],
+                };
+            }
+            case 'nexus_workflow_run': {
+                const workflowId = String(request.params.arguments?.workflowId ?? '');
+                const goalOverride = request.params.arguments?.goal ? String(request.params.arguments.goal) : undefined;
+                try {
+                    const execution = await this.getRuntime().runWorkflow(workflowId, goalOverride);
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: [
+                                    `🧭 Workflow Runtime — ${summarizeExecution(execution)}`,
+                                    `Run ID: ${execution.runId}`,
+                                    `Artifacts: ${execution.artifactsPath}`,
+                                    `Decision: ${execution.finalDecision?.action ?? 'none'}`,
+                                    `Workflows: ${execution.activeWorkflows.map((workflow) => workflow.name).join(', ') || 'none'}`,
+                                    `Result: ${execution.result}`,
+                                ].join('\n'),
+                            }],
+                    };
+                }
+                catch (error) {
+                    return { content: [{ type: 'text', text: `❌ Workflow runtime error: ${error.message}` }] };
+                }
+            }
+            case 'nexus_run_status': {
+                const runId = String(request.params.arguments?.runId ?? '');
+                const run = this.getRuntime().getRun(runId);
+                if (!run) {
+                    return { content: [{ type: 'text', text: `❌ Run not found: ${runId}` }] };
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                runId: run.runId,
+                                state: run.state,
+                                result: run.result,
+                                artifactsPath: run.artifactsPath,
+                                workers: run.workerResults.length,
+                                verifiedWorkers: run.workerResults.filter((worker) => worker.verified).length,
+                                workflows: run.activeWorkflows.map((workflow) => workflow.name),
+                                promotions: run.promotionDecisions,
+                                backends: run.selectedBackends,
+                            }, null, 2),
+                        }],
+                };
+            }
             case 'nexus_darwin_propose': {
                 const hypothesis = String(request.params.arguments?.hypothesis ?? '');
                 const targetFile = String(request.params.arguments?.targetFile ?? '');
@@ -1204,22 +1447,49 @@ export class MCPAdapter {
                         return { content: [{ type: 'text', text: `❌ NXL Parse Error: ${e.message}` }] };
                     }
                 }
-                const swarm = await orchestrator.executeSwarm(goal);
-                const lines = [
-                    `Goal: ${goal.substring(0, 60)}...`,
-                    '─'.repeat(66)
-                ];
-                swarm.agents.forEach((agent, idx) => {
-                    const prefix = idx === swarm.agents.length - 1 ? '└──' : '├──';
-                    lines.push(`${prefix} [${agent.archetype?.name}] as ${agent.type.substring(0, 42)}`);
-                });
-                this.box('🚀 NEXUS SWARM INDUCTED', lines, '34');
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `🚀 Nexus Swarm Activated: ${swarm.agents.length} specialized sub-agents induced for: ${goal}\nCheck CLI for worker mapping.`
-                        }]
-                };
+                try {
+                    const execution = await this.getRuntime().runNXL(goal, nxlScript || undefined, useCase);
+                    const verifiedWorkers = execution.workerResults.filter(result => result.verified).length;
+                    execution.activeSkills.forEach(skill => this.sessionDNA.recordSkill(skill.name));
+                    execution.workerResults.forEach(result => {
+                        result.modifiedFiles.forEach(file => this.sessionDNA.recordFileModified(file));
+                    });
+                    this.sessionDNA.recordDecision('NXL execution graph completed', execution.result || summarizeExecution(execution), execution.state === 'merged' ? 0.95 : execution.state === 'rolled_back' ? 0.5 : 0.28);
+                    this.nexusRef.storeMemory(`NXL runtime: state=${execution.state}, workers=${execution.workerResults.length}, verified=${verifiedWorkers}, useCase=${useCase}`, execution.state === 'merged' ? 0.94 : 0.74, ['#nxl', '#decision', execution.state]);
+                    if (execution.finalDecision) {
+                        await this.nexusRef.analyzeLearning(goal, execution.finalDecision);
+                    }
+                    this.box('🚀 NXL RUNTIME GRAPH', [
+                        `Goal: ${goal.substring(0, 60).padEnd(60, ' ')}`,
+                        `Run: ${execution.runId.padEnd(28, ' ')} State: ${execution.state.padEnd(18, ' ')}`,
+                        `Workers: ${execution.workerResults.length.toString().padEnd(5, ' ')} Verified: ${verifiedWorkers.toString().padEnd(10, ' ')}`
+                    ], execution.state === 'merged' ? '32' : execution.state === 'rolled_back' ? '33' : '31');
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: [
+                                    `🚀 NXL Runtime — ${summarizeExecution(execution)}`,
+                                    '',
+                                    `Run ID: ${execution.runId}`,
+                                    `Use Case: ${useCase}`,
+                                    `Artifacts: ${execution.artifactsPath}`,
+                                    `Workers: ${execution.workerResults.length}`,
+                                    `Verified Workers: ${verifiedWorkers}`,
+                                    `Decision: ${execution.finalDecision?.action ?? 'none'}`,
+                                    `Planner: ${execution.plannerResult?.summary ?? 'n/a'}`,
+                                    `Backends: memory=${execution.selectedBackends.memoryBackend}, compression=${execution.selectedBackends.compressionBackend}, consensus=${execution.selectedBackends.consensusPolicy}, dsl=${execution.selectedBackends.dslCompiler}`,
+                                    `Active Skills: ${execution.activeSkills.length > 0 ? execution.activeSkills.map(skill => skill.name).join(', ') : 'none'}`,
+                                    `Active Workflows: ${execution.activeWorkflows.length > 0 ? execution.activeWorkflows.map(workflow => workflow.name).join(', ') : 'none'}`,
+                                    `Promotions: ${execution.promotionDecisions.length > 0 ? execution.promotionDecisions.map(decision => `${decision.kind}:${decision.target}:${decision.approved ? 'approved' : 'held'}`).join(', ') : 'none'}`,
+                                    '',
+                                    `Result: ${execution.result}`
+                                ].join('\n')
+                            }]
+                    };
+                }
+                catch (e) {
+                    return { content: [{ type: 'text', text: `❌ NXL Runtime Error: ${e.message}` }] };
+                }
             }
             case 'nexus_publish_trace': {
                 const taskId = String(request.params.arguments?.taskId ?? '');
@@ -1266,7 +1536,7 @@ export class MCPAdapter {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
         this.connected = true;
-        console.error('[MCP Adapter] Connected — 16 tools active');
+        console.error('[MCP Adapter] Connected — runtime tools active');
     }
     async disconnect() {
         // Auto-flush Session DNA on disconnect