quantum-spherifier 1.0.0

package/src/modules/SafetyGuardrails.js

@@ -0,0 +1,139 @@
+/**
+ * SafetyGuardrails.js — quantum-spherifier (v1.0)
+ * Pre-execution safety filter tuned for quantum-computing research.
+ *
+ * Levels:
+ *   permissive – minimal checks; useful for fast batch research
+ *   standard   – default; blocks destructive file ops, requires resource anchor
+ *   strict     – all checks + patent-novelty pre-check + rollback plan
+ *
+ * quantum-spherifier-specific checks:
+ *   - Reject any faster-than-light / no-decoherence "infinite coherence" claim
+ *   - Reject any proposal exceeding 10M physical qubits without a credible roadmap
+ *   - Reject any claim of breaking RSA-2048 on current hardware
+ *   - Reject any proposal claiming quantum advantage without a defined problem
+ *   - Require at least one RESOURCE_ANCHOR reference per claim (strict mode)
+ *   - Require at least one KG cross-link per hypothesis (nothing isolated)
+ */
+
+import { EventEmitter } from 'eventemitter3';
+import { RESOURCE_ANCHORS } from './ResourceFeasibilityChecker.js';
+
+const FORBIDDEN_PATTERNS = [
+  /faster[\s_-]?than[\s_-]?light/i,
+  /instantaneous[\s_-]?communication/i,
+  /infinite[\s_-]?coherence/i,
+  /no[\s_-]?decoherence/i,
+  /perpetual[\s_-]?quantum/i,
+  /free[\s_-]?energy/i,
+  /macroscopic[\s_-]?schrodinger[\s_-]?cat[\s_-]?indefinitely/i,
+  /break[\s_-]?rsa[\s_-]?2048[\s_-]?(today|now|current)/i,
+  /quantum[\s_-]?advantage[\s_-]?(for|on)[\s_-]?(everything|all|any)/i,
+];
+
+const PROTECTED_PATHS = new Set([
+  '/etc', '/root', '/var', '/usr', '/boot', '/sys', '/proc',
+  '/dev', '/lib', '/bin', '/sbin',
+]);
+
+export class SafetyGuardrails extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.safetyLevel = opts.safetyLevel ?? 'standard';
+    this.protectedPaths = new Set([...PROTECTED_PATHS, ...(opts.protectedPaths ?? [])]);
+    this.rateLimits = opts.rateLimits ?? { perMinute: 60, perHour: 600 };
+    this._calls = [];
+  }
+
+  /**
+   * Check a research action before execution.
+   * @param {object} action  – { type, payload, target }
+   * @returns {{ allowed: boolean, reason?: string, severity?: string }}
+   */
+  check(action) {
+    if (this.safetyLevel === 'permissive') return { allowed: true };
+
+    // 1. Forbidden physics patterns
+    const text = JSON.stringify(action ?? {});
+    for (const pat of FORBIDDEN_PATTERNS) {
+      if (pat.test(text)) {
+        this.emit('blocked', { reason: 'forbidden_physics', pattern: pat.source });
+        return {
+          allowed: false,
+          reason: `Forbidden physics pattern detected: ${pat.source}`,
+          severity: 'critical',
+        };
+      }
+    }
+
+    // 2. Physical qubit cap (no proposal may exceed 10M without roadmap anchor)
+    const qubits = action?.parameters?.physicalQubits ?? action?.payload?.parameters?.physicalQubits;
+    if (typeof qubits === 'number' && qubits > 10_000_000) {
+      this.emit('blocked', { reason: 'qubit_overrun', value: qubits });
+      return {
+        allowed: false,
+        reason: `Physical qubit count ${qubits} exceeds 10M cap without credible roadmap`,
+        severity: 'critical',
+      };
+    }
+
+    // 3. File path protection
+    const target = action?.target ?? action?.payload?.path;
+    if (typeof target === 'string') {
+      for (const p of this.protectedPaths) {
+        if (target.startsWith(p)) {
+          this.emit('blocked', { reason: 'protected_path', path: target });
+          return {
+            allowed: false,
+            reason: `Target path is protected: ${target}`,
+            severity: 'critical',
+          };
+        }
+      }
+    }
+
+    // 4. Resource anchor requirement (strict level)
+    if (this.safetyLevel === 'strict') {
+      const claim = action?.payload?.hypothesis ?? action?.payload?.claim ?? action?.payload;
+      const anchorText = JSON.stringify(claim ?? {}).toLowerCase();
+      const hasAnchor = Object.keys(RESOURCE_ANCHORS).some(id => {
+        const a = RESOURCE_ANCHORS[id];
+        const label = (a.label ?? id).toLowerCase();
+        return anchorText.includes(label)
+            || anchorText.includes(id.toLowerCase().replace(/_/g, ' '))
+            || (a.modality && anchorText.includes(a.modality.toLowerCase().replace(/_/g, ' ')));
+      });
+      if (!hasAnchor && action?.type !== 'noop') {
+        this.emit('warning', { reason: 'no_resource_anchor' });
+        return {
+          allowed: false,
+          reason: 'Strict mode requires at least one RESOURCE_ANCHOR reference',
+          severity: 'warning',
+        };
+      }
+    }
+
+    // 5. Rate limit
+    const now = Date.now();
+    this._calls = this._calls.filter(t => now - t < 60 * 60 * 1000);
+    const lastMinute = this._calls.filter(t => now - t < 60_000).length;
+    if (lastMinute >= this.rateLimits.perMinute) {
+      return {
+        allowed: false,
+        reason: 'Per-minute rate limit exceeded',
+        severity: 'warning',
+      };
+    }
+    this._calls.push(now);
+
+    return { allowed: true };
+  }
+
+  setLevel(level) {
+    if (!['permissive', 'standard', 'strict'].includes(level)) {
+      throw new Error(`Invalid safety level: ${level}`);
+    }
+    this.safetyLevel = level;
+    this.emit('levelChanged', level);
+  }
+}

package/src/modules/TokenEnergyArbitrator.js

@@ -0,0 +1,129 @@
+/**
+ * TokenEnergyArbitrator.js + PraxicStreamExecutor.js — FUSIONARY (v1.0)
+ * PID-controlled emission rate for praxes, with parallel execution,
+ * retry logic, and structured audit log.
+ */
+
+import { EventEmitter } from 'eventemitter3';
+
+// ── Token-Energy Arbitrator ──────────────────────────────────────────────────
+export class TokenEnergyArbitrator extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.budgetTokens = opts.budgetTokens ?? 100_000;
+    this.budgetEnergy = opts.budgetEnergy ?? 1.0;     // Normalised 0-1
+    this.tokensUsed = 0;
+    this.energyUsed = 0;
+    this.kp = opts.kp ?? 0.6;
+    this.ki = opts.ki ?? 0.1;
+    this.kd = opts.kd ?? 0.05;
+    this._integral = 0;
+    this._prevError = 0;
+    this.emissionRate = 1.0;
+  }
+
+  setBudget(tokens, energy) {
+    if (typeof tokens === 'number') this.budgetTokens = tokens;
+    if (typeof energy === 'number') this.budgetEnergy = energy;
+  }
+
+  /** Decide whether to allow a praxis emission of `tokens` tokens and `energy` energy. */
+  arbitrate(tokens = 0, energy = 0) {
+    const tokenError = 1 - (this.tokensUsed / this.budgetTokens);
+    const energyError = 1 - (this.energyUsed / this.budgetEnergy);
+    const error = Math.min(tokenError, energyError);
+
+    this._integral += error;
+    const derivative = error - this._prevError;
+    this._prevError = error;
+
+    const output = this.kp * error + this.ki * this._integral + this.kd * derivative;
+    this.emissionRate = Math.max(0, Math.min(1, output));
+
+    const allowed = this.emissionRate > 0.1 && this.tokensUsed + tokens <= this.budgetTokens;
+    if (allowed) {
+      this.tokensUsed += tokens;
+      this.energyUsed += energy;
+    }
+    this.emit('decision', { allowed, emissionRate: this.emissionRate, tokens, energy });
+    return allowed;
+  }
+
+  status() {
+    return {
+      tokensUsed: this.tokensUsed,
+      tokensRemaining: Math.max(0, this.budgetTokens - this.tokensUsed),
+      energyUsed: this.energyUsed,
+      energyRemaining: Math.max(0, this.budgetEnergy - this.energyUsed),
+      emissionRate: this.emissionRate,
+    };
+  }
+
+  reset() {
+    this.tokensUsed = 0;
+    this.energyUsed = 0;
+    this._integral = 0;
+    this._prevError = 0;
+    this.emissionRate = 1.0;
+  }
+}
+
+// ── Praxic Stream Executor ──────────────────────────────────────────────────
+export class PraxicStreamExecutor extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.registry = opts.registry ?? null;
+    this.maxRetries = opts.maxRetries ?? 3;
+    this.timeoutMs = opts.timeoutMs ?? 30_000;
+    this.auditLog = [];
+  }
+
+  /**
+   * Execute a praxis (action) by looking up its handler in the registry.
+   * @param {object} praxis  – { toolId, args }
+   */
+  async execute(praxis) {
+    if (!this.registry) throw new Error('No tool registry attached');
+    const { toolId, args } = praxis;
+    const handler = this.registry.get(toolId);
+    if (!handler) {
+      this._log(praxis, 'error', { error: `Unknown tool: ${toolId}` });
+      return { ok: false, error: `Unknown tool: ${toolId}` };
+    }
+
+    let attempt = 0;
+    let lastError = null;
+    while (attempt < this.maxRetries) {
+      attempt++;
+      try {
+        const result = await this._withTimeout(handler(args), this.timeoutMs);
+        this._log(praxis, 'success', { attempt, result });
+        return { ok: true, result, attempts: attempt };
+      } catch (err) {
+        lastError = err;
+        this._log(praxis, 'retry', { attempt, error: err.message });
+        await new Promise(r => setTimeout(r, 100 * 2 ** attempt));
+      }
+    }
+    this._log(praxis, 'failure', { error: lastError?.message ?? 'unknown' });
+    return { ok: false, error: lastError?.message ?? 'unknown', attempts: attempt };
+  }
+
+  async _withTimeout(promise, ms) {
+    return Promise.race([
+      promise,
+      new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), ms)),
+    ]);
+  }
+
+  _log(praxis, status, extra) {
+    this.auditLog.push({
+      timestamp: Date.now(),
+      toolId: praxis.toolId,
+      status,
+      ...extra,
+    });
+    if (this.auditLog.length > 1000) this.auditLog.shift();
+    this.emit('audit', { praxis, status, ...extra });
+  }
+}

package/src/tools/BibliographyTool.js

@@ -0,0 +1,74 @@
+/**
+ * BibliographyTool.js — FUSIONARY (v1.0)
+ * Builds BibTeX files for archived documents.
+ */
+
+import { Tool } from './Tool.js';
+import { v4 as uuidv4 } from 'uuid';
+
+const ENTRY_TYPES = ['article', 'inproceedings', 'techreport', 'misc', 'online', 'patent'];
+
+function escapeLatex(s) {
+  return String(s ?? '')
+    .replace(/\\/g, '\\textbackslash{}')
+    .replace(/&/g, '\\&')
+    .replace(/%/g, '\\%')
+    .replace(/_/g, '\\_')
+    .replace(/\{/g, '\\{')
+    .replace(/\}/g, '\\}');
+}
+
+export class BibliographyTool extends Tool {
+  constructor(opts = {}) {
+    super(opts);
+    this.id = 'bibliography';
+    this.name = 'Bibliography Builder';
+    this.description = 'Generates BibTeX entries from citation metadata.';
+    this.schema = {
+      type: 'object',
+      properties: {
+        operation: { type: 'string', enum: ['add', 'compile'] },
+        entries: { type: 'array' },
+      },
+    };
+    this.entries = new Map();
+  }
+
+  async execute(args) {
+    const op = args?.operation ?? 'add';
+    if (op === 'add') {
+      const list = Array.isArray(args?.entries) ? args.entries : [];
+      const added = [];
+      for (const e of list) {
+        const id = e.key ?? uuidv4().slice(0, 8);
+        this.entries.set(id, e);
+        added.push(id);
+      }
+      return { ok: true, added, total: this.entries.size };
+    }
+    if (op === 'compile') {
+      return { ok: true, bibtex: this.compile() };
+    }
+    return { ok: false, error: `Unknown operation: ${op}` };
+  }
+
+  compile() {
+    const lines = [];
+    for (const [key, e] of this.entries) {
+      const type = ENTRY_TYPES.includes(e.type) ? e.type : 'misc';
+      lines.push(`@${type}{${key},`);
+      if (e.title)   lines.push(`  title   = {${escapeLatex(e.title)}},`);
+      if (e.author)  lines.push(`  author  = {${escapeLatex(e.author)}},`);
+      if (e.year)    lines.push(`  year    = {${e.year}},`);
+      if (e.journal) lines.push(`  journal = {${escapeLatex(e.journal)}},`);
+      if (e.volume)  lines.push(`  volume  = {${e.volume}},`);
+      if (e.pages)   lines.push(`  pages   = {${e.pages}},`);
+      if (e.doi)     lines.push(`  doi     = {${e.doi}},`);
+      if (e.url)     lines.push(`  url     = {${e.url}},`);
+      if (e.note)    lines.push(`  note    = {${escapeLatex(e.note)}},`);
+      lines.push('}');
+      lines.push('');
+    }
+    return lines.join('\n');
+  }
+}

package/src/tools/FileSystemTool.js

@@ -0,0 +1,91 @@
+/**
+ * FileSystemTool.js — FUSIONARY (v1.0)
+ * Real file I/O tool with sandbox directory enforcement.
+ */
+
+import { Tool } from './Tool.js';
+import {
+  existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync,
+  unlinkSync, readdirSync, statSync, copyFileSync, renameSync,
+} from 'node:fs';
+import { join, resolve, dirname, relative, isAbsolute } from 'node:path';
+
+const SANDBOX_DEFAULT = join(process.cwd(), 'research');
+
+export class FileSystemTool extends Tool {
+  constructor(opts = {}) {
+    super(opts);
+    this.id = 'filesystem';
+    this.name = 'File System Tool';
+    this.description = 'Sandboxed file I/O: read, write, append, delete, list, mkdir, copy, move.';
+    this.sandbox = opts.sandbox ?? SANDBOX_DEFAULT;
+    this.schema = {
+      type: 'object',
+      required: ['operation', 'path'],
+      properties: {
+        operation: { type: 'string', enum: ['read', 'write', 'append', 'delete', 'list', 'stat', 'mkdir', 'copy', 'move'] },
+        path: { type: 'string' },
+        content: { type: 'string' },
+        dest: { type: 'string' },
+      },
+    };
+  }
+
+  _resolve(path) {
+    const abs = isAbsolute(path) ? path : join(this.sandbox, path);
+    const rel = relative(this.sandbox, abs);
+    if (rel.startsWith('..')) {
+      throw new Error(`Path escapes sandbox: ${path}`);
+    }
+    return abs;
+  }
+
+  async execute(args) {
+    try {
+      const op = args?.operation;
+      const p = this._resolve(args?.path ?? '');
+      switch (op) {
+        case 'read':
+          if (!existsSync(p)) return { ok: false, error: 'Not found' };
+          return { ok: true, content: readFileSync(p, 'utf8') };
+        case 'write':
+          mkdirSync(dirname(p), { recursive: true });
+          writeFileSync(p, args?.content ?? '');
+          return { ok: true, path: p };
+        case 'append':
+          mkdirSync(dirname(p), { recursive: true });
+          appendFileSync(p, args?.content ?? '');
+          return { ok: true, path: p };
+        case 'delete':
+          if (existsSync(p)) { unlinkSync(p); return { ok: true }; }
+          return { ok: false, error: 'Not found' };
+        case 'list':
+          if (!existsSync(p)) return { ok: false, error: 'Not found' };
+          return { ok: true, entries: readdirSync(p) };
+        case 'stat':
+          if (!existsSync(p)) return { ok: false, error: 'Not found' };
+          const s = statSync(p);
+          return { ok: true, stat: { size: s.size, mtime: s.mtime, isDir: s.isDirectory() } };
+        case 'mkdir':
+          mkdirSync(p, { recursive: true });
+          return { ok: true, path: p };
+        case 'copy':
+          if (!existsSync(p)) return { ok: false, error: 'Source not found' };
+          const dst = this._resolve(args?.dest ?? '');
+          mkdirSync(dirname(dst), { recursive: true });
+          copyFileSync(p, dst);
+          return { ok: true, from: p, to: dst };
+        case 'move':
+          if (!existsSync(p)) return { ok: false, error: 'Source not found' };
+          const d = this._resolve(args?.dest ?? '');
+          mkdirSync(dirname(d), { recursive: true });
+          renameSync(p, d);
+          return { ok: true, from: p, to: d };
+        default:
+          return { ok: false, error: `Unknown operation: ${op}` };
+      }
+    } catch (err) {
+      return { ok: false, error: err.message };
+    }
+  }
+}

package/src/tools/LaTeXDocumentTool.js

@@ -0,0 +1,94 @@
+/**
+ * LaTeXDocumentTool.js — FUSIONARY (v1.0)
+ * Compiles a TeX source string into a PDF using the local `pdflatex`
+ * toolchain if available; otherwise writes only the .tex file and
+ * emits a warning. Always returns the absolute paths of the produced
+ * artifacts.
+ *
+ * Inputs:
+ *   { source: <tex string>, outputPath: <dir>, filename: <stem> }
+ * Outputs:
+ *   { texPath, pdfPath?, log?, ok, error? }
+ */
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync, spawnSync } from 'node:child_process';
+import { Tool } from './Tool.js';
+
+export class LaTeXDocumentTool extends Tool {
+  constructor(opts = {}) {
+    super(opts);
+    this.id = 'latex_document';
+    this.name = 'LaTeX Document Compiler';
+    this.description = 'Compiles a TeX source string into a PDF artifact.';
+    this.schema = {
+      type: 'object',
+      required: ['source', 'outputPath'],
+      properties: {
+        source: { type: 'string' },
+        outputPath: { type: 'string' },
+        filename: { type: 'string' },
+        attempts: { type: 'number' },
+      },
+    };
+    this.pdflatexPath = opts.pdflatexPath ?? 'pdflatex';
+    this._available = null;
+  }
+
+  isAvailable() {
+    if (this._available !== null) return this._available;
+    try {
+      const r = spawnSync(this.pdflatexPath, ['--version'], { encoding: 'utf8' });
+      this._available = r.status === 0;
+    } catch {
+      this._available = false;
+    }
+    return this._available;
+  }
+
+  async execute(args) {
+    const { source, outputPath, filename = 'main', attempts = 2 } = args;
+    if (!source) return { ok: false, error: 'Missing "source"' };
+    if (!outputPath) return { ok: false, error: 'Missing "outputPath"' };
+
+    if (!existsSync(outputPath)) mkdirSync(outputPath, { recursive: true });
+    const texPath = join(outputPath, `${filename}.tex`);
+    writeFileSync(texPath, source);
+
+    if (!this.isAvailable()) {
+      return {
+        ok: true,
+        texPath,
+        pdfPath: null,
+        warning: 'pdflatex not available; only .tex was written.',
+      };
+    }
+
+    let lastLog = '';
+    for (let i = 0; i < attempts; i++) {
+      try {
+        const result = spawnSync(
+          this.pdflatexPath,
+          ['-interaction=nonstopmode', '-halt-on-error', '-output-directory', outputPath, texPath],
+          { encoding: 'utf8', timeout: 60_000 }
+        );
+        lastLog = result.stdout ?? '';
+        if (result.status === 0) {
+          const pdfPath = join(outputPath, `${filename}.pdf`);
+          if (existsSync(pdfPath)) {
+            return { ok: true, texPath, pdfPath, log: lastLog };
+          }
+        }
+      } catch (err) {
+        return { ok: false, texPath, error: err.message, log: lastLog };
+      }
+    }
+    return {
+      ok: false,
+      texPath,
+      error: 'pdflatex failed after multiple attempts',
+      log: lastLog,
+    };
+  }
+}