Spaces:

GaryLeckey
/

aureon-os

Running

aureon-os / scripts /traders /gammaSync.ts

Deploy Aureon OS (deploy/selfhost stack: nginx edge + fusion API x2 + console + HNC organ + redis + postgres; paper mode) (part 19)

da0ce7b verified 1 day ago

Raw History Blame Contribute Delete

14.6 kB

#!/usr/bin/env tsx
/**
 * Gamma API Integration for Aureon Trading System
 * 
 * Syncs trading reports, runbooks, and system status to Gamma presentations/sites.
 * 
 * Usage:
 *   npm run gamma:sync              # Generate ops dashboard
 *   npm run gamma:sync -- --runbook # Sync the live trading runbook
 *   npm run gamma:sync -- --report  # Generate trading performance report
 */

import 'dotenv/config';
import fs from 'fs';
import path from 'path';

const GAMMA_API_KEY = process.env.GAMMA_API_KEY;
const GAMMA_BASE_URL = 'https://public-api.gamma.app/v1.0';
const COMMAND_SERVER_URL = process.env.NEXUS_COMMAND_URL || 'http://localhost:8790';
const STATE_DIR = path.resolve(process.cwd(), process.env.AUREON_STATE_DIR || 'state');

function writeGammaLatest(payload: Record<string, unknown>, filename = 'gamma_latest.json'): void {
  fs.mkdirSync(STATE_DIR, { recursive: true });
  const targetPath = path.join(STATE_DIR, filename);
  const tmpPath = `${targetPath}.tmp`;
  fs.writeFileSync(tmpPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf-8');
  fs.renameSync(tmpPath, targetPath);
}

interface GammaGenerationRequest {
  inputText: string;
  textMode: 'generate' | 'condense' | 'preserve';
  format?: 'presentation' | 'document' | 'webpage' | 'social';
  numCards?: number;
  cardSplit?: 'auto' | 'inputTextBreaks';
  additionalInstructions?: string;
  textOptions?: {
    amount?: 'brief' | 'medium' | 'detailed' | 'extensive';
    tone?: string;
    audience?: string;
    language?: string;
  };
  imageOptions?: {
    source?: 'aiGenerated' | 'pictographic' | 'unsplash' | 'webAllImages' | 'placeholder' | 'noImages';
    model?: string;
    style?: string;
  };
  cardOptions?: {
    dimensions?: 'fluid' | '16x9' | '4x3' | '1x1' | '4x5' | '9x16' | 'letter' | 'a4' | 'pageless';
  };
  exportAs?: 'pdf' | 'pptx';
}

interface GammaGenerationResponse {
  generationId: string;
}

interface GammaStatusResponse {
  generationId: string;
  status: 'pending' | 'completed' | 'failed';
  gammaUrl?: string;
  exportUrl?: string;
  credits?: {
    deducted: number;
    remaining: number;
  };
  error?: {
    code: string;
    message: string;
  };
}

interface CommandCenterStatus {
  streaming: boolean;
  intervalMs: number | null;
  clients: number;
  activeCommand: {
    id: string;
    type: string;
    status: string;
  } | null;
  commandHistory: Array<{
    id: string;
    type: string;
    status: string;
    createdAt: number;
    finishedAt?: number;
  }>;
}

async function gammaRequest<T>(
  endpoint: string,
  method: 'GET' | 'POST' = 'GET',
  body?: unknown
): Promise<T> {
  if (!GAMMA_API_KEY) {
    throw new Error('GAMMA_API_KEY is required; embedded credentials are forbidden.');
  }
  const url = `${GAMMA_BASE_URL}${endpoint}`;
  const headers: Record<string, string> = {
    'X-API-KEY': GAMMA_API_KEY,
    'Accept': 'application/json',
  };

  if (method === 'POST') {
    headers['Content-Type'] = 'application/json';
  }

  const response = await fetch(url, {
    method,
    headers,
    body: body ? JSON.stringify(body) : undefined,
  });

  if (!response.ok) {
    const errorText = await response.text();
    throw new Error(`Gamma API error ${response.status}: ${errorText}`);
  }

  return response.json() as Promise<T>;
}

async function pollForCompletion(generationId: string, maxWaitMs = 120000): Promise<GammaStatusResponse> {
  const startTime = Date.now();
  const pollInterval = 3000;

  while (Date.now() - startTime < maxWaitMs) {
    const status = await gammaRequest<GammaStatusResponse>(`/generations/${generationId}`);
    
    console.log(`  ⏳ Status: ${status.status}`);
    
    if (status.status === 'completed') {
      return status;
    }
    
    if (status.status === 'failed') {
      throw new Error(`Generation failed: ${status.error?.message || 'Unknown error'}`);
    }

    await new Promise(resolve => setTimeout(resolve, pollInterval));
  }

  throw new Error('Generation timed out');
}

async function generateGamma(request: GammaGenerationRequest): Promise<GammaStatusResponse> {
  console.log('🚀 Starting Gamma generation...');
  
  const { generationId } = await gammaRequest<GammaGenerationResponse>(
    '/generations',
    'POST',
    request
  );

  console.log(`📋 Generation ID: ${generationId}`);
  
  const result = await pollForCompletion(generationId);
  
  console.log(`\n✅ Generation complete!`);
  console.log(`🔗 View: ${result.gammaUrl}`);
  if (result.exportUrl) {
    console.log(`📥 Export: ${result.exportUrl}`);
  }
  if (result.credits) {
    console.log(`💳 Credits used: ${result.credits.deducted} (${result.credits.remaining} remaining)`);
  }

  writeGammaLatest({
    generationId: result.generationId,
    status: result.status,
    gammaUrl: result.gammaUrl ?? null,
    exportUrl: result.exportUrl ?? null,
    format: request.format ?? null,
    textMode: request.textMode,
    updatedAt: new Date().toISOString(),
  });

  return result;
}

async function fetchCommandServerStatus(): Promise<CommandCenterStatus | null> {
  try {
    const response = await fetch(`${COMMAND_SERVER_URL}/api/command-center/status`);
    if (!response.ok) return null;
    return response.json();
  } catch {
    return null;
  }
}

function readRunbook(): string {
  const runbookPath = path.resolve(process.cwd(), 'LIVE_TRADING_RUNBOOK.md');
  if (!fs.existsSync(runbookPath)) {
    throw new Error('LIVE_TRADING_RUNBOOK.md not found');
  }
  return fs.readFileSync(runbookPath, 'utf-8');
}

async function syncRunbook(): Promise<void> {
  console.log('\n📖 Syncing Live Trading Runbook to Gamma...\n');
  
  const runbookContent = readRunbook();
  
  // Convert markdown sections to Gamma card breaks
  const formattedContent = runbookContent
    .replace(/^## /gm, '\n---\n## ')
    .replace(/^### /gm, '\n---\n### ')
    .slice(0, 50000); // Gamma has input limits

  await generateGamma({
    inputText: formattedContent,
    textMode: 'preserve',
    format: 'webpage',
    numCards: 20,
    cardSplit: 'inputTextBreaks',
    additionalInstructions: 'Create a professional ops runbook site. Keep code blocks formatted. Use clear section headers.',
    textOptions: {
      amount: 'detailed',
      tone: 'professional, technical',
      audience: 'trading system operators and developers',
      language: 'en',
    },
    imageOptions: {
      source: 'pictographic',
      style: 'minimal tech icons, financial dashboard aesthetic',
    },
    cardOptions: {
      dimensions: 'pageless',
    },
  });
}

async function generateOpsDashboard(): Promise<void> {
  console.log('\n🛰️ Generating Aureon Trading Portal for aureoninstitute.uk...\n');
  
  const serverStatus = await fetchCommandServerStatus();
  const timestamp = new Date().toISOString();
  
  let statusSection = '';
  if (serverStatus) {
    statusSection = `
## 🟢 Live System Status
- **Streaming:** ${serverStatus.streaming ? '🟢 Active' : '⚪ Idle'}
- **Connected Clients:** ${serverStatus.clients}
- **Stream Interval:** ${serverStatus.intervalMs ?? 'N/A'} ms
- **Active Command:** ${serverStatus.activeCommand?.type ?? 'None'}
`;
  } else {
    statusSection = `
## System Status
🔵 Portal Mode - Backend services available on demand
`;
  }

  const dashboardContent = `
# AUREON INSTITUTE
## Quantum Trading Intelligence

Welcome to the Aureon Institute — where consciousness meets capital markets.

---

# 🌌 The Vision

Aureon is a next-generation trading system that unifies:
- **Quantum field dynamics** with market microstructure
- **Neural hive intelligence** with risk management
- **Coherence-based signals** with execution precision

We don't predict markets. We resonate with them.

---

# 🧠 How It Works

## The Master Equation

At the heart of Aureon lies a unified field equation:

**Λ(t) = S(t) + O(t) + E(t)**

Where:
- **S(t)** = Substrate — 9 Auris nodes sensing market state
- **O(t)** = Observer — Self-referential awareness loop
- **E(t)** = Echo — Momentum memory from past cycles
- **Γ** = Coherence — Field alignment score (0-1)

**Entry Signal:** Γ > 0.938
**Exit Signal:** Γ < 0.934

---

# 🐝 Queen Hive Architecture

## Multi-Agent Trading Swarm

The system deploys autonomous trading agents organized in hives:

| Component | Role |
|-----------|------|
| **Queen** | Orchestrates hive strategy and spawning |
| **Agents** | Execute trades across BTC, ETH, BNB, ADA, DOGE |
| **Mycelium** | Neural network connecting all hives |
| **Nexus** | Central command and coherence processor |

### The 10-9-1 Model
- **90%** compounds within the hive
- **10%** harvested at 5x growth to spawn new hives
- **Exponential scaling** with controlled risk

---

# 🌈 The Nine Auris Nodes

Each node resonates at a specific frequency, sensing different market dimensions:

| Node | Frequency | Role | 
|------|-----------|------|
| 🐅 Tiger | 220 Hz | Volatility |
| 🦅 Falcon | 285 Hz | Momentum |
| 🐦 Hummingbird | 396 Hz | Stability |
| 🐬 Dolphin | 528 Hz | Emotion (Love Frequency) |
| 🦌 Deer | 639 Hz | Sensing |
| 🦉 Owl | 741 Hz | Memory |
| 🐼 Panda | 852 Hz | Love |
| 🚢 CargoShip | 936 Hz | Infrastructure |
| 🐠 Clownfish | 963 Hz | Symbiosis |

---

# 📊 Live Metrics

${statusSection}

### Key Performance Indicators

| Metric | Description |
|--------|-------------|
| **Coherence (Γ)** | Field alignment strength |
| **Lambda (Λ)** | Unified field state |
| **Prism Status** | Gold / Blue / Red signal state |
| **Unity Index** | System-wide harmony score |

---

# 🛡️ Risk Controls

Safety is built into every layer:

| Control | Value | Purpose |
|---------|-------|---------|
| Risk Fraction | 2% | Max risk per trade |
| Max Order Size | $25 USDT | Position cap |
| Dry Run Mode | Default ON | Paper trading first |
| Testnet First | Required | Validate before live |

---

# 🚀 Getting Started

## For Operators

1. **Stage 0:** Validate on testnet with dry-run
2. **Stage 1:** Execute real testnet orders
3. **Stage 2:** Go live with conservative sizing

## Quick Commands

| Action | Command |
|--------|---------|
| Start System | \`python aureon_nexus.py --cycles 10\` |
| Run Dashboard | \`npm run dev\` |
| Sync Portal | \`npm run gamma:sync\` |
| Generate Report | \`npm run gamma:report\` |

---

# 🔗 Connect With Us

**Aureon Institute** — Quantum Trading Intelligence

- 🌐 Website: aureoninstitute.uk
- 📧 Contact: hello@aureoninstitute.com
- 🐙 GitHub: github.com/RA-CONSULTING/aureon-trading

---

*"If you don't quit, you can't lose. You have the power, my friend."*

Generated: ${timestamp}
`;

  await generateGamma({
    inputText: dashboardContent,
    textMode: 'generate',
    format: 'webpage',
    numCards: 12,
    cardSplit: 'inputTextBreaks',
    additionalInstructions: 'Create a stunning, professional trading platform website. Use dark theme with glowing accents. Make it feel like a premium fintech product. Include visual hierarchy and clear sections. This will be published at aureoninstitute.uk.',
    textOptions: {
      amount: 'medium',
      tone: 'professional, visionary, confident',
      audience: 'traders, investors, and technology enthusiasts',
      language: 'en',
    },
    imageOptions: {
      source: 'aiGenerated',
      style: 'futuristic trading dashboard, neural network visualization, dark theme with blue and gold accents, quantum computing aesthetic, professional fintech',
    },
    cardOptions: {
      dimensions: 'pageless',
    },
  });
}

async function generateTradingReport(): Promise<void> {
  console.log('\n📊 Generating Trading Performance Report...\n');
  
  // Read trade audit log if available
  const auditLogPath = path.resolve(process.cwd(), 'trade_audit.log');
  let tradeData = 'No trade data available yet.';
  
  if (fs.existsSync(auditLogPath)) {
    const logContent = fs.readFileSync(auditLogPath, 'utf-8');
    const lines = logContent.split('\n').filter(Boolean).slice(-50);
    tradeData = lines.join('\n');
  }

  const reportContent = `
# AUREON Trading Report
## Performance Summary
Generated: ${new Date().toISOString()}

---

## Executive Summary

This report covers the latest trading activity from the Aureon Quantum Trading System.

Key Highlights:
- Multi-agent hive architecture
- Coherence-based entry/exit signals
- Risk-managed position sizing

---

## Recent Activity

\`\`\`
${tradeData}
\`\`\`

---

## System Health

- Nexus Engine: Operational
- Mycelium Network: Connected
- Queen Hive: Active
- Risk Controls: Enabled

---

## Recommendations

1. Continue monitoring coherence thresholds
2. Review position sizing based on volatility
3. Validate all signals against Master Equation

---

## Next Steps

- Scale to additional trading pairs
- Implement advanced portfolio optimization
- Expand hive spawning thresholds
`;

  await generateGamma({
    inputText: reportContent,
    textMode: 'generate',
    format: 'presentation',
    numCards: 10,
    cardSplit: 'inputTextBreaks',
    additionalInstructions: 'Create a professional trading performance report. Include data visualizations where appropriate.',
    textOptions: {
      amount: 'medium',
      tone: 'professional, analytical, data-driven',
      audience: 'portfolio managers and traders',
      language: 'en',
    },
    imageOptions: {
      source: 'aiGenerated',
      style: 'financial charts, trading graphs, professional business presentation',
    },
    cardOptions: {
      dimensions: '16x9',
    },
    exportAs: 'pdf',
  });
}

async function main(): Promise<void> {
  const args = process.argv.slice(2);
  
  console.log('🎨 Gamma Sync for Aureon Trading System');
  console.log('=========================================');

  try {
    if (args.includes('--runbook')) {
      await syncRunbook();
    } else if (args.includes('--report')) {
      await generateTradingReport();
    } else {
      await generateOpsDashboard();
    }
    
    console.log('\n🎉 Done!');
  } catch (error) {
    console.error('\n❌ Error:', error instanceof Error ? error.message : error);
    process.exit(1);
  }
}

main();

	#!/usr/bin/env tsx
	/**
	* Gamma API Integration for Aureon Trading System
	*
	* Syncs trading reports, runbooks, and system status to Gamma presentations/sites.
	*
	* Usage:
	* npm run gamma:sync # Generate ops dashboard
	* npm run gamma:sync -- --runbook # Sync the live trading runbook
	* npm run gamma:sync -- --report # Generate trading performance report
	*/

	import 'dotenv/config';
	import fs from 'fs';
	import path from 'path';

	const GAMMA_API_KEY = process.env.GAMMA_API_KEY;
	const GAMMA_BASE_URL = 'https://public-api.gamma.app/v1.0';
	const COMMAND_SERVER_URL = process.env.NEXUS_COMMAND_URL \|\| 'http://localhost:8790';
	const STATE_DIR = path.resolve(process.cwd(), process.env.AUREON_STATE_DIR \|\| 'state');

	function writeGammaLatest(payload: Record<string, unknown>, filename = 'gamma_latest.json'): void {
	fs.mkdirSync(STATE_DIR, { recursive: true });
	const targetPath = path.join(STATE_DIR, filename);
	const tmpPath = `${targetPath}.tmp`;
	fs.writeFileSync(tmpPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf-8');
	fs.renameSync(tmpPath, targetPath);
	}

	interface GammaGenerationRequest {
	inputText: string;
	textMode: 'generate' \| 'condense' \| 'preserve';
	format?: 'presentation' \| 'document' \| 'webpage' \| 'social';
	numCards?: number;
	cardSplit?: 'auto' \| 'inputTextBreaks';
	additionalInstructions?: string;
	textOptions?: {
	amount?: 'brief' \| 'medium' \| 'detailed' \| 'extensive';
	tone?: string;
	audience?: string;
	language?: string;
	};
	imageOptions?: {
	source?: 'aiGenerated' \| 'pictographic' \| 'unsplash' \| 'webAllImages' \| 'placeholder' \| 'noImages';
	model?: string;
	style?: string;
	};
	cardOptions?: {
	dimensions?: 'fluid' \| '16x9' \| '4x3' \| '1x1' \| '4x5' \| '9x16' \| 'letter' \| 'a4' \| 'pageless';
	};
	exportAs?: 'pdf' \| 'pptx';
	}

	interface GammaGenerationResponse {
	generationId: string;
	}

	interface GammaStatusResponse {
	generationId: string;
	status: 'pending' \| 'completed' \| 'failed';
	gammaUrl?: string;
	exportUrl?: string;
	credits?: {
	deducted: number;
	remaining: number;
	};
	error?: {
	code: string;
	message: string;
	};
	}

	interface CommandCenterStatus {
	streaming: boolean;
	intervalMs: number \| null;
	clients: number;
	activeCommand: {
	id: string;
	type: string;
	status: string;
	} \| null;
	commandHistory: Array<{
	id: string;
	type: string;
	status: string;
	createdAt: number;
	finishedAt?: number;
	}>;
	}

	async function gammaRequest<T>(
	endpoint: string,
	method: 'GET' \| 'POST' = 'GET',
	body?: unknown
	): Promise<T> {
	if (!GAMMA_API_KEY) {
	throw new Error('GAMMA_API_KEY is required; embedded credentials are forbidden.');
	}
	const url = `${GAMMA_BASE_URL}${endpoint}`;
	const headers: Record<string, string> = {
	'X-API-KEY': GAMMA_API_KEY,
	'Accept': 'application/json',
	};

	if (method === 'POST') {
	headers['Content-Type'] = 'application/json';
	}

	const response = await fetch(url, {
	method,
	headers,
	body: body ? JSON.stringify(body) : undefined,
	});

	if (!response.ok) {
	const errorText = await response.text();
	throw new Error(`Gamma API error ${response.status}: ${errorText}`);
	}

	return response.json() as Promise<T>;
	}

	async function pollForCompletion(generationId: string, maxWaitMs = 120000): Promise<GammaStatusResponse> {
	const startTime = Date.now();
	const pollInterval = 3000;

	while (Date.now() - startTime < maxWaitMs) {
	const status = await gammaRequest<GammaStatusResponse>(`/generations/${generationId}`);

	console.log(` ⏳ Status: ${status.status}`);

	if (status.status === 'completed') {
	return status;
	}

	if (status.status === 'failed') {
	throw new Error(`Generation failed: ${status.error?.message \|\| 'Unknown error'}`);
	}

	await new Promise(resolve => setTimeout(resolve, pollInterval));
	}

	throw new Error('Generation timed out');
	}

	async function generateGamma(request: GammaGenerationRequest): Promise<GammaStatusResponse> {
	console.log('🚀 Starting Gamma generation...');

	const { generationId } = await gammaRequest<GammaGenerationResponse>(
	'/generations',
	'POST',
	request
	);

	console.log(`📋 Generation ID: ${generationId}`);

	const result = await pollForCompletion(generationId);

	console.log(`\n✅ Generation complete!`);
	console.log(`🔗 View: ${result.gammaUrl}`);
	if (result.exportUrl) {
	console.log(`📥 Export: ${result.exportUrl}`);
	}
	if (result.credits) {
	console.log(`💳 Credits used: ${result.credits.deducted} (${result.credits.remaining} remaining)`);
	}

	writeGammaLatest({
	generationId: result.generationId,
	status: result.status,
	gammaUrl: result.gammaUrl ?? null,
	exportUrl: result.exportUrl ?? null,
	format: request.format ?? null,
	textMode: request.textMode,
	updatedAt: new Date().toISOString(),
	});

	return result;
	}

	async function fetchCommandServerStatus(): Promise<CommandCenterStatus \| null> {
	try {
	const response = await fetch(`${COMMAND_SERVER_URL}/api/command-center/status`);
	if (!response.ok) return null;
	return response.json();
	} catch {
	return null;
	}
	}

	function readRunbook(): string {
	const runbookPath = path.resolve(process.cwd(), 'LIVE_TRADING_RUNBOOK.md');
	if (!fs.existsSync(runbookPath)) {
	throw new Error('LIVE_TRADING_RUNBOOK.md not found');
	}
	return fs.readFileSync(runbookPath, 'utf-8');
	}

	async function syncRunbook(): Promise<void> {
	console.log('\n📖 Syncing Live Trading Runbook to Gamma...\n');

	const runbookContent = readRunbook();

	// Convert markdown sections to Gamma card breaks
	const formattedContent = runbookContent
	.replace(/^## /gm, '\n---\n## ')
	.replace(/^### /gm, '\n---\n### ')
	.slice(0, 50000); // Gamma has input limits

	await generateGamma({
	inputText: formattedContent,
	textMode: 'preserve',
	format: 'webpage',
	numCards: 20,
	cardSplit: 'inputTextBreaks',
	additionalInstructions: 'Create a professional ops runbook site. Keep code blocks formatted. Use clear section headers.',
	textOptions: {
	amount: 'detailed',
	tone: 'professional, technical',
	audience: 'trading system operators and developers',
	language: 'en',
	},
	imageOptions: {
	source: 'pictographic',
	style: 'minimal tech icons, financial dashboard aesthetic',
	},
	cardOptions: {
	dimensions: 'pageless',
	},
	});
	}

	async function generateOpsDashboard(): Promise<void> {
	console.log('\n🛰️ Generating Aureon Trading Portal for aureoninstitute.uk...\n');

	const serverStatus = await fetchCommandServerStatus();
	const timestamp = new Date().toISOString();

	let statusSection = '';
	if (serverStatus) {
	statusSection = `
	## 🟢 Live System Status
	- Streaming: ${serverStatus.streaming ? '🟢 Active' : '⚪ Idle'}
	- Connected Clients: ${serverStatus.clients}
	- Stream Interval: ${serverStatus.intervalMs ?? 'N/A'} ms
	- Active Command: ${serverStatus.activeCommand?.type ?? 'None'}
	`;
	} else {
	statusSection = `
	## System Status
	🔵 Portal Mode - Backend services available on demand
	`;
	}

	const dashboardContent = `
	# AUREON INSTITUTE
	## Quantum Trading Intelligence

	Welcome to the Aureon Institute — where consciousness meets capital markets.

	---

	# 🌌 The Vision

	Aureon is a next-generation trading system that unifies:
	- Quantum field dynamics with market microstructure
	- Neural hive intelligence with risk management
	- Coherence-based signals with execution precision

	We don't predict markets. We resonate with them.

	---

	# 🧠 How It Works

	## The Master Equation

	At the heart of Aureon lies a unified field equation:

	Λ(t) = S(t) + O(t) + E(t)

	Where:
	- S(t) = Substrate — 9 Auris nodes sensing market state
	- O(t) = Observer — Self-referential awareness loop
	- E(t) = Echo — Momentum memory from past cycles
	- Γ = Coherence — Field alignment score (0-1)

	Entry Signal: Γ > 0.938
	Exit Signal: Γ < 0.934

	---

	# 🐝 Queen Hive Architecture

	## Multi-Agent Trading Swarm

	The system deploys autonomous trading agents organized in hives:

	\| Component \| Role \|
	\|-----------\|------\|
	\| Queen \| Orchestrates hive strategy and spawning \|
	\| Agents \| Execute trades across BTC, ETH, BNB, ADA, DOGE \|
	\| Mycelium \| Neural network connecting all hives \|
	\| Nexus \| Central command and coherence processor \|

	### The 10-9-1 Model
	- 90% compounds within the hive
	- 10% harvested at 5x growth to spawn new hives
	- Exponential scaling with controlled risk

	---

	# 🌈 The Nine Auris Nodes

	Each node resonates at a specific frequency, sensing different market dimensions:

	\| Node \| Frequency \| Role \|
	\|------\|-----------\|------\|
	\| 🐅 Tiger \| 220 Hz \| Volatility \|
	\| 🦅 Falcon \| 285 Hz \| Momentum \|
	\| 🐦 Hummingbird \| 396 Hz \| Stability \|
	\| 🐬 Dolphin \| 528 Hz \| Emotion (Love Frequency) \|
	\| 🦌 Deer \| 639 Hz \| Sensing \|
	\| 🦉 Owl \| 741 Hz \| Memory \|
	\| 🐼 Panda \| 852 Hz \| Love \|
	\| 🚢 CargoShip \| 936 Hz \| Infrastructure \|
	\| 🐠 Clownfish \| 963 Hz \| Symbiosis \|

	---

	# 📊 Live Metrics

	${statusSection}

	### Key Performance Indicators

	\| Metric \| Description \|
	\|--------\|-------------\|
	\| Coherence (Γ) \| Field alignment strength \|
	\| Lambda (Λ) \| Unified field state \|
	\| Prism Status \| Gold / Blue / Red signal state \|
	\| Unity Index \| System-wide harmony score \|

	---

	# 🛡️ Risk Controls

	Safety is built into every layer:

	\| Control \| Value \| Purpose \|
	\|---------\|-------\|---------\|
	\| Risk Fraction \| 2% \| Max risk per trade \|
	\| Max Order Size \| $25 USDT \| Position cap \|
	\| Dry Run Mode \| Default ON \| Paper trading first \|
	\| Testnet First \| Required \| Validate before live \|

	---

	# 🚀 Getting Started

	## For Operators

	1. Stage 0: Validate on testnet with dry-run
	2. Stage 1: Execute real testnet orders
	3. Stage 2: Go live with conservative sizing

	## Quick Commands

	\| Action \| Command \|
	\|--------\|---------\|
	\| Start System \| \`python aureon_nexus.py --cycles 10\` \|
	\| Run Dashboard \| \`npm run dev\` \|
	\| Sync Portal \| \`npm run gamma:sync\` \|
	\| Generate Report \| \`npm run gamma:report\` \|

	---

	# 🔗 Connect With Us

	Aureon Institute — Quantum Trading Intelligence

	- 🌐 Website: aureoninstitute.uk
	- 📧 Contact: hello@aureoninstitute.com
	- 🐙 GitHub: github.com/RA-CONSULTING/aureon-trading

	---

	"If you don't quit, you can't lose. You have the power, my friend."

	Generated: ${timestamp}
	`;

	await generateGamma({
	inputText: dashboardContent,
	textMode: 'generate',
	format: 'webpage',
	numCards: 12,
	cardSplit: 'inputTextBreaks',
	additionalInstructions: 'Create a stunning, professional trading platform website. Use dark theme with glowing accents. Make it feel like a premium fintech product. Include visual hierarchy and clear sections. This will be published at aureoninstitute.uk.',
	textOptions: {
	amount: 'medium',
	tone: 'professional, visionary, confident',
	audience: 'traders, investors, and technology enthusiasts',
	language: 'en',
	},
	imageOptions: {
	source: 'aiGenerated',
	style: 'futuristic trading dashboard, neural network visualization, dark theme with blue and gold accents, quantum computing aesthetic, professional fintech',
	},
	cardOptions: {
	dimensions: 'pageless',
	},
	});
	}

	async function generateTradingReport(): Promise<void> {
	console.log('\n📊 Generating Trading Performance Report...\n');

	// Read trade audit log if available
	const auditLogPath = path.resolve(process.cwd(), 'trade_audit.log');
	let tradeData = 'No trade data available yet.';

	if (fs.existsSync(auditLogPath)) {
	const logContent = fs.readFileSync(auditLogPath, 'utf-8');
	const lines = logContent.split('\n').filter(Boolean).slice(-50);
	tradeData = lines.join('\n');
	}

	const reportContent = `
	# AUREON Trading Report
	## Performance Summary
	Generated: ${new Date().toISOString()}

	---

	## Executive Summary

	This report covers the latest trading activity from the Aureon Quantum Trading System.

	Key Highlights:
	- Multi-agent hive architecture
	- Coherence-based entry/exit signals
	- Risk-managed position sizing

	---

	## Recent Activity

	\`\`\`
	${tradeData}
	\`\`\`

	---

	## System Health

	- Nexus Engine: Operational
	- Mycelium Network: Connected
	- Queen Hive: Active
	- Risk Controls: Enabled

	---

	## Recommendations

	1. Continue monitoring coherence thresholds
	2. Review position sizing based on volatility
	3. Validate all signals against Master Equation

	---

	## Next Steps

	- Scale to additional trading pairs
	- Implement advanced portfolio optimization
	- Expand hive spawning thresholds
	`;

	await generateGamma({
	inputText: reportContent,
	textMode: 'generate',
	format: 'presentation',
	numCards: 10,
	cardSplit: 'inputTextBreaks',
	additionalInstructions: 'Create a professional trading performance report. Include data visualizations where appropriate.',
	textOptions: {
	amount: 'medium',
	tone: 'professional, analytical, data-driven',
	audience: 'portfolio managers and traders',
	language: 'en',
	},
	imageOptions: {
	source: 'aiGenerated',
	style: 'financial charts, trading graphs, professional business presentation',
	},
	cardOptions: {
	dimensions: '16x9',
	},
	exportAs: 'pdf',
	});
	}

	async function main(): Promise<void> {
	const args = process.argv.slice(2);

	console.log('🎨 Gamma Sync for Aureon Trading System');
	console.log('=========================================');

	try {
	if (args.includes('--runbook')) {
	await syncRunbook();
	} else if (args.includes('--report')) {
	await generateTradingReport();
	} else {
	await generateOpsDashboard();
	}

	console.log('\n🎉 Done!');
	} catch (error) {
	console.error('\n❌ Error:', error instanceof Error ? error.message : error);
	process.exit(1);
	}
	}

	main();