SINGULARITY-MBP-APEX-COGNITION v1.0

The graph that thinks, learns, verifies, and evolves — autonomously.

TIER-7/APEX sits above all other MBP tiers. It orchestrates Tiers 0–6 as cognitive subsystems, applies evolutionary pressure to agent strategies, validates every output through critic sub-agents, and persists learned intelligence across sessions so THEMANBEARPIG never forgets a lesson.

Layer 1: EvoAgent Architecture — Population-Based Strategy Evolution

1.1 Core AORP Loop Controller

/**
 * EvoAgentController — Act-Observe-Reflect-Plan loop with evolutionary strategy selection.
 *
 * Each agent maintains a "strategy genome" — a configuration of search patterns,
 * query expansions, lane priorities, and scoring weights. A population of 8 strategy
 * variants competes via tournament selection. Winners reproduce with mutation;
 * losers are replaced. Over sessions the population converges on strategies that
 * produce the highest-value evidence discoveries.
 *
 * Architecture:
 *   Population(8 genomes) → Tournament(k=3) → Crossover → Mutation → Evaluate → Select
 */
class EvoAgentController {
  constructor(opts = {}) {
    this.populationSize = opts.populationSize || 8;
    this.tournamentK    = opts.tournamentK || 3;
    this.mutationRate   = opts.mutationRate || 0.15;
    this.crossoverRate  = opts.crossoverRate || 0.7;
    this.eliteCount     = opts.eliteCount || 2;
    this.generationCap  = opts.generationCap || 50;
    this.generation     = 0;

    this.population = this._loadOrSeed();
    this.fitnessHistory = JSON.parse(
      localStorage.getItem('evo_fitness_history') || '[]'
    );
    this.activeAgent = null;
    this.observationBuffer = [];
  }

  // ── Genome Schema ───────────────────────────────────────────────
  _defaultGenome() {
    return {
      id: crypto.randomUUID(),
      generation: this.generation,
      // Search strategy genes
      queryExpansionDepth: 2,          // how many synonym expansions
      lanePriorities: {A:1, B:0.3, C:0.5, D:0.8, E:0.9, F:0.7, CRIMINAL:0.1},
      fts5BoostFactors: {exact:3.0, phrase:2.0, prefix:1.0, fuzzy:0.5},
      minConfidenceThreshold: 0.6,
      maxResultsPerQuery: 25,
      // Scoring weights
      scoringWeights: {
        impeachmentValue: 0.25,
        contradictionSeverity: 0.20,
        timelineProximity: 0.15,
        authorityChainDepth: 0.15,
        evidenceNovelty: 0.15,
        crossLaneRelevance: 0.10
      },
      // Behavioral genes
      explorationVsExploitation: 0.3,  // 0 = pure exploit, 1 = pure explore
      retryMutationStrength: 0.2,
      parallelQueryCount: 2,
      // Fitness tracking
      fitness: 0,
      evaluationCount: 0,
      highValueFinds: 0,
      totalFinds: 0,
      avgResponseMs: 0
    };
  }

  _loadOrSeed() {
    const saved = localStorage.getItem('evo_population');
    if (saved) {
      const pop = JSON.parse(saved);
      if (pop.length === this.populationSize) return pop;
    }
    return Array.from({length: this.populationSize}, () => this._randomGenome());
  }

  _randomGenome() {
    const g = this._defaultGenome();
    g.queryExpansionDepth = this._randInt(1, 4);
    g.minConfidenceThreshold = 0.3 + Math.random() * 0.5;
    g.maxResultsPerQuery = this._randInt(10, 50);
    g.explorationVsExploitation = Math.random();
    g.retryMutationStrength = 0.05 + Math.random() * 0.4;
    g.parallelQueryCount = this._randInt(1, 3);
    // Randomize scoring weights (normalized to 1.0)
    const keys = Object.keys(g.scoringWeights);
    const raw = keys.map(() => Math.random());
    const sum = raw.reduce((a, b) => a + b, 0);
    keys.forEach((k, i) => { g.scoringWeights[k] = raw[i] / sum; });
    // Randomize lane priorities
    Object.keys(g.lanePriorities).forEach(k => {
      g.lanePriorities[k] = Math.round(Math.random() * 10) / 10;
    });
    return g;
  }

  // ── AORP Loop ───────────────────────────────────────────────────

  /** ACT — execute the active genome's strategy against the database. */
  act(queryContext) {
    this.activeAgent = this._selectActiveGenome();
    const genome = this.activeAgent;
    const query = this._buildQuery(queryContext, genome);
    const startMs = performance.now();
    return {
      genome: genome.id,
      query,
      lanePriorities: genome.lanePriorities,
      maxResults: genome.maxResultsPerQuery,
      expansionDepth: genome.queryExpansionDepth,
      startMs
    };
  }

  /** OBSERVE — collect results from the action and buffer observations. */
  observe(actionResult, dbResults) {
    const elapsedMs = performance.now() - actionResult.startMs;
    const observation = {
      genomeId: actionResult.genome,
      query: actionResult.query,
      resultCount: dbResults.length,
      highValueCount: dbResults.filter(r => r.score >= 0.7).length,
      novelCount: dbResults.filter(r => r.isNovel).length,
      elapsedMs,
      timestamp: Date.now()
    };
    this.observationBuffer.push(observation);
    return observation;
  }

  /** REFLECT — evaluate the genome's performance from observations. */
  reflect() {
    if (this.observationBuffer.length === 0) return null;
    const obs = this.observationBuffer;
    const genome = this.population.find(g => g.id === obs[0].genomeId);
    if (!genome) return null;

    const totalHigh = obs.reduce((s, o) => s + o.highValueCount, 0);
    const totalNovel = obs.reduce((s, o) => s + o.novelCount, 0);
    const avgMs = obs.reduce((s, o) => s + o.elapsedMs, 0) / obs.length;
    const totalResults = obs.reduce((s, o) => s + o.resultCount, 0);

    // Fitness = weighted combination of quality and efficiency
    const rawFitness =
      (totalHigh * 3.0) +          // high-value evidence is paramount
      (totalNovel * 2.0) +          // novelty prevents re-discovery
      (totalResults * 0.1) -        // volume has diminishing returns
      (avgMs > 200 ? (avgMs - 200) * 0.01 : 0);  // speed penalty above budget

    genome.fitness = (genome.fitness * genome.evaluationCount + rawFitness) /
                     (genome.evaluationCount + 1);
    genome.evaluationCount += 1;
    genome.highValueFinds += totalHigh;
    genome.totalFinds += totalResults;
    genome.avgResponseMs = (genome.avgResponseMs + avgMs) / 2;

    this.observationBuffer = [];
    return { genomeId: genome.id, fitness: genome.fitness, totalHigh, totalNovel, avgMs };
  }

  /** PLAN — evolve the population based on accumulated fitness. */
  plan() {
    this.generation++;
    const sorted = [...this.population].sort((a, b) => b.fitness - a.fitness);

    // Elite preservation — top genomes survive unchanged
    const nextGen = sorted.slice(0, this.eliteCount).map(g => ({...g}));

    // Fill remaining slots with tournament-selected offspring
    while (nextGen.length < this.populationSize) {
      const parent1 = this._tournamentSelect();
      const parent2 = this._tournamentSelect();
      let child;
      if (Math.random() < this.crossoverRate) {
        child = this._crossover(parent1, parent2);
      } else {
        child = {...parent1, id: crypto.randomUUID(), fitness: 0, evaluationCount: 0};
      }
      if (Math.random() < this.mutationRate) {
        this._mutate(child);
      }
      child.generation = this.generation;
      nextGen.push(child);
    }

    this.population = nextGen;
    this._persist();
    this.fitnessHistory.push({
      generation: this.generation,
      bestFitness: sorted[0].fitness,
      avgFitness: sorted.reduce((s, g) => s + g.fitness, 0) / sorted.length,
      timestamp: Date.now()
    });
    localStorage.setItem('evo_fitness_history', JSON.stringify(this.fitnessHistory));
    return {
      generation: this.generation,
      best: sorted[0],
      populationAvg: sorted.reduce((s, g) => s + g.fitness, 0) / sorted.length
    };
  }

  // ── Genetic Operators ───────────────────────────────────────────

  _tournamentSelect() {
    const contestants = [];
    for (let i = 0; i < this.tournamentK; i++) {
      contestants.push(this.population[this._randInt(0, this.population.length - 1)]);
    }
    return contestants.sort((a, b) => b.fitness - a.fitness)[0];
  }

  _crossover(p1, p2) {
    const child = this._defaultGenome();
    child.id = crypto.randomUUID();
    // Uniform crossover on numeric genes
    child.queryExpansionDepth = Math.random() < 0.5 ? p1.queryExpansionDepth : p2.queryExpansionDepth;
    child.minConfidenceThreshold = Math.random() < 0.5 ? p1.minConfidenceThreshold : p2.minConfidenceThreshold;
    child.maxResultsPerQuery = Math.random() < 0.5 ? p1.maxResultsPerQuery : p2.maxResultsPerQuery;
    child.explorationVsExploitation = (p1.explorationVsExploitation + p2.explorationVsExploitation) / 2;
    child.parallelQueryCount = Math.random() < 0.5 ? p1.parallelQueryCount : p2.parallelQueryCount;
    // Blend scoring weights
    const keys = Object.keys(child.scoringWeights);
    keys.forEach(k => {
      child.scoringWeights[k] = (p1.scoringWeights[k] + p2.scoringWeights[k]) / 2;
    });
    // Blend lane priorities
    Object.keys(child.lanePriorities).forEach(k => {
      child.lanePriorities[k] = Math.round(
        ((p1.lanePriorities[k] || 0.5) + (p2.lanePriorities[k] || 0.5)) / 2 * 10
      ) / 10;
    });
    return child;
  }

  _mutate(genome) {
    const strength = genome.retryMutationStrength;
    // Mutate one random numeric gene
    const genes = ['queryExpansionDepth', 'minConfidenceThreshold', 'maxResultsPerQuery',
                   'explorationVsExploitation', 'parallelQueryCount'];
    const gene = genes[this._randInt(0, genes.length - 1)];
    const delta = (Math.random() - 0.5) * 2 * strength;
    if (gene === 'queryExpansionDepth') {
      genome[gene] = Math.max(1, Math.min(5, Math.round(genome[gene] + delta * 3)));
    } else if (gene === 'maxResultsPerQuery') {
      genome[gene] = Math.max(5, Math.min(100, Math.round(genome[gene] + delta * 30)));
    } else if (gene === 'parallelQueryCount') {
      genome[gene] = Math.max(1, Math.min(3, Math.round(genome[gene] + delta * 2)));
    } else {
      genome[gene] = Math.max(0, Math.min(1, genome[gene] + delta));
    }
    // Mutate one random scoring weight and renormalize
    const wKeys = Object.keys(genome.scoringWeights);
    const wk = wKeys[this._randInt(0, wKeys.length - 1)];
    genome.scoringWeights[wk] = Math.max(0.01, genome.scoringWeights[wk] + (Math.random() - 0.5) * 0.1);
    const wSum = Object.values(genome.scoringWeights).reduce((a, b) => a + b, 0);
    wKeys.forEach(k => { genome.scoringWeights[k] /= wSum; });
  }

  // ── Query Building ──────────────────────────────────────────────

  _buildQuery(context, genome) {
    const base = context.topic || context.query || '';
    const expansions = [];
    if (genome.queryExpansionDepth >= 2 && context.synonyms) {
      expansions.push(...context.synonyms.slice(0, genome.queryExpansionDepth));
    }
    const terms = [base, ...expansions].filter(Boolean);
    const fts5 = terms.map(t => `"${t}"`).join(' OR ');
    return {
      fts5Query: fts5,
      lanes: Object.entries(genome.lanePriorities)
        .filter(([, v]) => v >= genome.minConfidenceThreshold)
        .map(([k]) => k),
      limit: genome.maxResultsPerQuery
    };
  }

  _selectActiveGenome() {
    // ε-greedy: exploit best genome most of the time, explore randomly sometimes
    const epsilon = this.population[0]?.explorationVsExploitation ?? 0.3;
    if (Math.random() < epsilon) {
      return this.population[this._randInt(0, this.population.length - 1)];
    }
    return [...this.population].sort((a, b) => b.fitness - a.fitness)[0];
  }

  _persist() {
    localStorage.setItem('evo_population', JSON.stringify(this.population));
  }

  _randInt(min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; }

  // ── Public API ──────────────────────────────────────────────────

  getBestGenome() {
    return [...this.population].sort((a, b) => b.fitness - a.fitness)[0];
  }

  getGenerationStats() {
    const sorted = [...this.population].sort((a, b) => b.fitness - a.fitness);
    return {
      generation: this.generation,
      best: sorted[0].fitness,
      worst: sorted[sorted.length - 1].fitness,
      avg: sorted.reduce((s, g) => s + g.fitness, 0) / sorted.length,
      diversity: this._populationDiversity()
    };
  }

  _populationDiversity() {
    // Coefficient of variation of fitness values
    const fits = this.population.map(g => g.fitness);
    const mean = fits.reduce((a, b) => a + b, 0) / fits.length;
    if (mean === 0) return 1.0;
    const variance = fits.reduce((s, f) => s + (f - mean) ** 2, 0) / fits.length;
    return Math.sqrt(variance) / mean;
  }

  resetPopulation() {
    this.population = Array.from({length: this.populationSize}, () => this._randomGenome());
    this.generation = 0;
    this.fitnessHistory = [];
    this._persist();
    localStorage.setItem('evo_fitness_history', '[]');
  }
}

SINGULARITY-MBP-APEX-COGNITION v1.0

The graph that thinks, learns, verifies, and evolves — autonomously.

Layer 1: EvoAgent Architecture — Population-Based Strategy Evolution

1.1 Core AORP Loop Controller

/**
 * EvoAgentController — Act-Observe-Reflect-Plan loop with evolutionary strategy selection.
 *
 * Each agent maintains a "strategy genome" — a configuration of search patterns,
 * query expansions, lane priorities, and scoring weights. A population of 8 strategy
 * variants competes via tournament selection. Winners reproduce with mutation;
 * losers are replaced. Over sessions the population converges on strategies that
 * produce the highest-value evidence discoveries.
 *
 * Architecture:
 *   Population(8 genomes) → Tournament(k=3) → Crossover → Mutation → Evaluate → Select
 */
class EvoAgentController {
  constructor(opts = {}) {
    this.populationSize = opts.populationSize || 8;
    this.tournamentK    = opts.tournamentK || 3;
    this.mutationRate   = opts.mutationRate || 0.15;
    this.crossoverRate  = opts.crossoverRate || 0.7;
    this.eliteCount     = opts.eliteCount || 2;
    this.generationCap  = opts.generationCap || 50;
    this.generation     = 0;

    this.population = this._loadOrSeed();
    this.fitnessHistory = JSON.parse(
      localStorage.getItem('evo_fitness_history') || '[]'
    );
    this.activeAgent = null;
    this.observationBuffer = [];
  }

  // ── Genome Schema ───────────────────────────────────────────────
  _defaultGenome() {
    return {
      id: crypto.randomUUID(),
      generation: this.generation,
      // Search strategy genes
      queryExpansionDepth: 2,          // how many synonym expansions
      lanePriorities: {A:1, B:0.3, C:0.5, D:0.8, E:0.9, F:0.7, CRIMINAL:0.1},
      fts5BoostFactors: {exact:3.0, phrase:2.0, prefix:1.0, fuzzy:0.5},
      minConfidenceThreshold: 0.6,
      maxResultsPerQuery: 25,
      // Scoring weights
      scoringWeights: {
        impeachmentValue: 0.25,
        contradictionSeverity: 0.20,
        timelineProximity: 0.15,
        authorityChainDepth: 0.15,
        evidenceNovelty: 0.15,
        crossLaneRelevance: 0.10
      },
      // Behavioral genes
      explorationVsExploitation: 0.3,  // 0 = pure exploit, 1 = pure explore
      retryMutationStrength: 0.2,
      parallelQueryCount: 2,
      // Fitness tracking
      fitness: 0,
      evaluationCount: 0,
      highValueFinds: 0,
      totalFinds: 0,
      avgResponseMs: 0
    };
  }

  _loadOrSeed() {
    const saved = localStorage.getItem('evo_population');
    if (saved) {
      const pop = JSON.parse(saved);
      if (pop.length === this.populationSize) return pop;
    }
    return Array.from({length: this.populationSize}, () => this._randomGenome());
  }

  _randomGenome() {
    const g = this._defaultGenome();
    g.queryExpansionDepth = this._randInt(1, 4);
    g.minConfidenceThreshold = 0.3 + Math.random() * 0.5;
    g.maxResultsPerQuery = this._randInt(10, 50);
    g.explorationVsExploitation = Math.random();
    g.retryMutationStrength = 0.05 + Math.random() * 0.4;
    g.parallelQueryCount = this._randInt(1, 3);
    // Randomize scoring weights (normalized to 1.0)
    const keys = Object.keys(g.scoringWeights);
    const raw = keys.map(() => Math.random());
    const sum = raw.reduce((a, b) => a + b, 0);
    keys.forEach((k, i) => { g.scoringWeights[k] = raw[i] / sum; });
    // Randomize lane priorities
    Object.keys(g.lanePriorities).forEach(k => {
      g.lanePriorities[k] = Math.round(Math.random() * 10) / 10;
    });
    return g;
  }

  // ── AORP Loop ───────────────────────────────────────────────────

  /** ACT — execute the active genome's strategy against the database. */
  act(queryContext) {
    this.activeAgent = this._selectActiveGenome();
    const genome = this.activeAgent;
    const query = this._buildQuery(queryContext, genome);
    const startMs = performance.now();
    return {
      genome: genome.id,
      query,
      lanePriorities: genome.lanePriorities,
      maxResults: genome.maxResultsPerQuery,
      expansionDepth: genome.queryExpansionDepth,
      startMs
    };
  }

  /** OBSERVE — collect results from the action and buffer observations. */
  observe(actionResult, dbResults) {
    const elapsedMs = performance.now() - actionResult.startMs;
    const observation = {
      genomeId: actionResult.genome,
      query: actionResult.query,
      resultCount: dbResults.length,
      highValueCount: dbResults.filter(r => r.score >= 0.7).length,
      novelCount: dbResults.filter(r => r.isNovel).length,
      elapsedMs,
      timestamp: Date.now()
    };
    this.observationBuffer.push(observation);
    return observation;
  }

  /** REFLECT — evaluate the genome's performance from observations. */
  reflect() {
    if (this.observationBuffer.length === 0) return null;
    const obs = this.observationBuffer;
    const genome = this.population.find(g => g.id === obs[0].genomeId);
    if (!genome) return null;

    const totalHigh = obs.reduce((s, o) => s + o.highValueCount, 0);
    const totalNovel = obs.reduce((s, o) => s + o.novelCount, 0);
    const avgMs = obs.reduce((s, o) => s + o.elapsedMs, 0) / obs.length;
    const totalResults = obs.reduce((s, o) => s + o.resultCount, 0);

    // Fitness = weighted combination of quality and efficiency
    const rawFitness =
      (totalHigh * 3.0) +          // high-value evidence is paramount
      (totalNovel * 2.0) +          // novelty prevents re-discovery
      (totalResults * 0.1) -        // volume has diminishing returns
      (avgMs > 200 ? (avgMs - 200) * 0.01 : 0);  // speed penalty above budget

    genome.fitness = (genome.fitness * genome.evaluationCount + rawFitness) /
                     (genome.evaluationCount + 1);
    genome.evaluationCount += 1;
    genome.highValueFinds += totalHigh;
    genome.totalFinds += totalResults;
    genome.avgResponseMs = (genome.avgResponseMs + avgMs) / 2;

    this.observationBuffer = [];
    return { genomeId: genome.id, fitness: genome.fitness, totalHigh, totalNovel, avgMs };
  }

  /** PLAN — evolve the population based on accumulated fitness. */
  plan() {
    this.generation++;
    const sorted = [...this.population].sort((a, b) => b.fitness - a.fitness);

    // Elite preservation — top genomes survive unchanged
    const nextGen = sorted.slice(0, this.eliteCount).map(g => ({...g}));

    // Fill remaining slots with tournament-selected offspring
    while (nextGen.length < this.populationSize) {
      const parent1 = this._tournamentSelect();
      const parent2 = this._tournamentSelect();
      let child;
      if (Math.random() < this.crossoverRate) {
        child = this._crossover(parent1, parent2);
      } else {
        child = {...parent1, id: crypto.randomUUID(), fitness: 0, evaluationCount: 0};
      }
      if (Math.random() < this.mutationRate) {
        this._mutate(child);
      }
      child.generation = this.generation;
      nextGen.push(child);
    }

    this.population = nextGen;
    this._persist();
    this.fitnessHistory.push({
      generation: this.generation,
      bestFitness: sorted[0].fitness,
      avgFitness: sorted.reduce((s, g) => s + g.fitness, 0) / sorted.length,
      timestamp: Date.now()
    });
    localStorage.setItem('evo_fitness_history', JSON.stringify(this.fitnessHistory));
    return {
      generation: this.generation,
      best: sorted[0],
      populationAvg: sorted.reduce((s, g) => s + g.fitness, 0) / sorted.length
    };
  }

  // ── Genetic Operators ───────────────────────────────────────────

  _tournamentSelect() {
    const contestants = [];
    for (let i = 0; i < this.tournamentK; i++) {
      contestants.push(this.population[this._randInt(0, this.population.length - 1)]);
    }
    return contestants.sort((a, b) => b.fitness - a.fitness)[0];
  }

  _crossover(p1, p2) {
    const child = this._defaultGenome();
    child.id = crypto.randomUUID();
    // Uniform crossover on numeric genes
    child.queryExpansionDepth = Math.random() < 0.5 ? p1.queryExpansionDepth : p2.queryExpansionDepth;
    child.minConfidenceThreshold = Math.random() < 0.5 ? p1.minConfidenceThreshold : p2.minConfidenceThreshold;
    child.maxResultsPerQuery = Math.random() < 0.5 ? p1.maxResultsPerQuery : p2.maxResultsPerQuery;
    child.explorationVsExploitation = (p1.explorationVsExploitation + p2.explorationVsExploitation) / 2;
    child.parallelQueryCount = Math.random() < 0.5 ? p1.parallelQueryCount : p2.parallelQueryCount;
    // Blend scoring weights
    const keys = Object.keys(child.scoringWeights);
    keys.forEach(k => {
      child.scoringWeights[k] = (p1.scoringWeights[k] + p2.scoringWeights[k]) / 2;
    });
    // Blend lane priorities
    Object.keys(child.lanePriorities).forEach(k => {
      child.lanePriorities[k] = Math.round(
        ((p1.lanePriorities[k] || 0.5) + (p2.lanePriorities[k] || 0.5)) / 2 * 10
      ) / 10;
    });
    return child;
  }

  _mutate(genome) {
    const strength = genome.retryMutationStrength;
    // Mutate one random numeric gene
    const genes = ['queryExpansionDepth', 'minConfidenceThreshold', 'maxResultsPerQuery',
                   'explorationVsExploitation', 'parallelQueryCount'];
    const gene = genes[this._randInt(0, genes.length - 1)];
    const delta = (Math.random() - 0.5) * 2 * strength;
    if (gene === 'queryExpansionDepth') {
      genome[gene] = Math.max(1, Math.min(5, Math.round(genome[gene] + delta * 3)));
    } else if (gene === 'maxResultsPerQuery') {
      genome[gene] = Math.max(5, Math.min(100, Math.round(genome[gene] + delta * 30)));
    } else if (gene === 'parallelQueryCount') {
      genome[gene] = Math.max(1, Math.min(3, Math.round(genome[gene] + delta * 2)));
    } else {
      genome[gene] = Math.max(0, Math.min(1, genome[gene] + delta));
    }
    // Mutate one random scoring weight and renormalize
    const wKeys = Object.keys(genome.scoringWeights);
    const wk = wKeys[this._randInt(0, wKeys.length - 1)];
    genome.scoringWeights[wk] = Math.max(0.01, genome.scoringWeights[wk] + (Math.random() - 0.5) * 0.1);
    const wSum = Object.values(genome.scoringWeights).reduce((a, b) => a + b, 0);
    wKeys.forEach(k => { genome.scoringWeights[k] /= wSum; });
  }

  // ── Query Building ──────────────────────────────────────────────

  _buildQuery(context, genome) {
    const base = context.topic || context.query || '';
    const expansions = [];
    if (genome.queryExpansionDepth >= 2 && context.synonyms) {
      expansions.push(...context.synonyms.slice(0, genome.queryExpansionDepth));
    }
    const terms = [base, ...expansions].filter(Boolean);
    const fts5 = terms.map(t => `"${t}"`).join(' OR ');
    return {
      fts5Query: fts5,
      lanes: Object.entries(genome.lanePriorities)
        .filter(([, v]) => v >= genome.minConfidenceThreshold)
        .map(([k]) => k),
      limit: genome.maxResultsPerQuery
    };
  }

  _selectActiveGenome() {
    // ε-greedy: exploit best genome most of the time, explore randomly sometimes
    const epsilon = this.population[0]?.explorationVsExploitation ?? 0.3;
    if (Math.random() < epsilon) {
      return this.population[this._randInt(0, this.population.length - 1)];
    }
    return [...this.population].sort((a, b) => b.fitness - a.fitness)[0];
  }

  _persist() {
    localStorage.setItem('evo_population', JSON.stringify(this.population));
  }

  _randInt(min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; }

  // ── Public API ──────────────────────────────────────────────────

  getBestGenome() {
    return [...this.population].sort((a, b) => b.fitness - a.fitness)[0];
  }

  getGenerationStats() {
    const sorted = [...this.population].sort((a, b) => b.fitness - a.fitness);
    return {
      generation: this.generation,
      best: sorted[0].fitness,
      worst: sorted[sorted.length - 1].fitness,
      avg: sorted.reduce((s, g) => s + g.fitness, 0) / sorted.length,
      diversity: this._populationDiversity()
    };
  }

  _populationDiversity() {
    // Coefficient of variation of fitness values
    const fits = this.population.map(g => g.fitness);
    const mean = fits.reduce((a, b) => a + b, 0) / fits.length;
    if (mean === 0) return 1.0;
    const variance = fits.reduce((s, f) => s + (f - mean) ** 2, 0) / fits.length;
    return Math.sqrt(variance) / mean;
  }

  resetPopulation() {
    this.population = Array.from({length: this.populationSize}, () => this._randomGenome());
    this.generation = 0;
    this.fitnessHistory = [];
    this._persist();
    localStorage.setItem('evo_fitness_history', '[]');
  }
}

#	Anti-Pattern	Why It's Fatal	Correct Pattern
1	Agent writes to evidence tables	Corrupts sworn evidence — data integrity violation	Read-only DB access; writes via separate verified pipeline
2	Neural output accepted without symbolic check	Hallucinated citations enter the graph	Every neural result → symbolic predicate gate → CriticAgent verify
3	Evolution past checkpoint without fitness validation	Bad strategies propagate, fitness regression	Fitness must improve or hold ≥ 2 consecutive gens before checkpoint
4	More than 2 concurrent background agents	429 rate limits stall entire fleet	`maxParallelAgents = 2`, batch remaining tasks
5	Confidence score used raw without calibration	Overconfident claims damage credibility in court	Every confidence → `ConfidenceCalibrator.adjust()` before display
6	Hardcoded separation day count	Stale counts in filings = automatic FAIL	`(today - date(2025,7,29)).days` computed at render time
7	Citation fabricated to fill an argument gap	Rule 9 violation — unverifiable citation destroys filing	`CriticAgent.validateCitations()` before any citation enters output
8	Single-stage contradiction detection (cosine only)	Contradictory statements are often semantically similar	Two-stage: bi-encoder retrieval → cross-encoder rerank
9	Strategy genome never mutated	Premature convergence — population loses diversity	Mutation rate ≥ 0.10 on every non-elite genome
10	Population diversity drops below 0.05	Monoculture — all agents use same strategy	Monitor `_populationDiversity()`; inject random genomes if CV < 0.05
11	Calibration curve built from < 20 data points	Noisy curve leads to wrong adjustments	Minimum 20 resolved predictions per bucket before using curve
12	Agent retries same failed strategy	Definition of insanity — same input same error	Mutate strategy genome before each retry
13	Learning persisted only to localStorage	Browser cache wipe deletes all intelligence	Three-tier: localStorage + IndexedDB + DB write-back
14	Child's full name in any agent output	MCR 8.119(H) violation	Hallucination guard regex catches `Lincoln David`
15	Agent generates aggregate statistics for filings	Rule 20 — AI-generated counts destroy credibility	Only hand-countable or specific-query-backed stats in filings
16	Fleet orchestrator decomposes into 5+ parallel tasks	Exceeds agent concurrency limit, triggers cascading failures	Max 2 parallel, batch remainder sequentially
17	Cross-session learning replays stale genome on new data	Old strategies may be suboptimal for changed evidence landscape	Re-evaluate imported genomes for 3 gens before trusting fitness
18	Syllogism built without checking required elements	Incomplete IRAC — court rejects for insufficient argument	`requiredElements` check in `buildSyllogism()`, gaps reported
19	EvoAgent exploits only — zero exploration	Misses novel evidence in unexplored lanes	ε-greedy with ε ≥ 0.15 ensures exploration
20	CriticAgent bypassed for "trusted" sources	Even court orders can be misquoted or mis-cited	Every intelligence item goes through full 5-axis verification
21	Fitness function rewards volume over quality	Agent floods graph with low-value noise	`highValue * 3.0 + novel * 2.0 + total * 0.1` — quality weighted 30:1
22	Symbolic rules hardcoded without template ID	Can't trace which rule produced which conclusion	Every rule has a unique template ID (e.g., `MCL_722_23_j`)
23	DB query in AORP loop without parameterized bind	SQL injection or FTS5 syntax crash	All queries use `?` placeholders with `params` array
24	Genetic crossover without normalization	Scoring weights sum to > 1.0 or < 1.0 after blend	Renormalize weights after every crossover and mutation
25	Agent fleet starts without EvoAgent initialization	No strategy genome loaded — random behavior	`FleetOrchestrator` constructor requires `EvoAgentController` instance

Operation	Budget	Technique	Measurement
AORP loop iteration	< 200ms	Cached DB queries, compiled predicates	`performance.now()` delta
Citation verification (per cite)	< 100ms	FTS5 on `authority_chains_v2` + `michigan_rules_extracted`	Async batch with `Promise.all`
Contradiction detection (per pair)	< 500ms	Stage 1 bi-encoder (fast), Stage 2 cross-encoder (precise)	Two-stage timing
Strategy evolution (per generation)	< 2s	Tournament selection (k=3, pop=8), no DB writes	`plan()` method timing
Confidence recalibration	< 100ms	Windowed Brier score over last 500 predictions	`adjust()` method timing
Fleet task decomposition	< 50ms	Rule-based regex matching, no DB access	`decompose()` method timing
Hallucination scan (full document)	< 150ms	15 compiled regex patterns, single-pass	`detectHallucinations()` timing
Syllogism construction	< 300ms	Predicate filter + top-3 evidence selection	`buildSyllogism()` timing
Cross-session recall (IndexedDB)	< 200ms	Cursor scan with query filter, capped at 100 results	`recall()` method timing
Knowledge distillation	< 1s	Statistical analysis over genome population	`distill()` method timing
Full verification (5 axes)	< 800ms	Sequential axes with early termination on HALLUCINATION	`verify()` method timing
Population diversity check	< 10ms	Coefficient of variation on fitness array	`_populationDiversity()` timing

Tier	Skill	Relationship	Data Flow
0	MBP-GENESIS	Schema consumer	Reads node/link taxonomy for evidence classification
0	MBP-DATAWEAVE	Data source	All DB queries route through DATAWEAVE transforms
1	MBP-FORGE-RENDERER	Display target	Verified intelligence → node attributes → visual rendering
1	MBP-FORGE-PHYSICS	Layout influence	Agent fitness → force parameters via SELFEVOLVE bridge
2	MBP-COMBAT-ADVERSARY	Intelligence consumer	EvoAgent discoveries feed adversary network PageRank
2	MBP-COMBAT-EVIDENCE	Evidence pipeline	Verified evidence atoms → density heatmap updates
2	MBP-COMBAT-AUTHORITY	Authority validator	CriticAgent citation checks use AUTHORITY hierarchy
2	MBP-COMBAT-IMPEACHMENT	Impeachment source	Contradiction detection feeds impeachment scoring
2	MBP-COMBAT-JUDICIAL	Judicial intelligence	Judicial violation patterns inform bias detection
2	MBP-COMBAT-WEAPONS	Weapon chain builder	Syllogism engine provides doctrine → remedy → filing chains
3	MBP-INTERFACE-HUD	Dashboard display	Calibration health, fitness, fleet status → HUD gauges
3	MBP-INTERFACE-NARRATIVE	Narrative generation	Fused reasoning chains → story-mode walkthrough
4	MBP-INTEGRATION-ENGINES	Engine bridge	14-engine fleet receives orchestrated queries
4	MBP-INTEGRATION-FILING	Filing readiness	Syllogism strength → filing confidence scores
5	MBP-EMERGENCE-SELFEVOLVE	Base evolution	APEX extends with population genetics + fitness tracking
5	MBP-EMERGENCE-PREDICTION	Forecast consumer	Escalation predictions inform agent priority queues
5	MBP-EMERGENCE-CONVERGENCE	Gap detection	Cross-layer gaps → acquisition task generation

NEXUS Tool	APEX-COGNITION Usage
`query_litigation_db`	EvoAgent ACT phase — parameterized evidence queries
`search_evidence`	FleetOrchestrator EVIDENCE_SEARCH task type
`search_impeachment`	FleetOrchestrator IMPEACHMENT_BUILD task type
`search_contradictions`	CriticAgent contradiction detection fallback
`search_authority_chains`	CriticAgent citation validation
`nexus_fuse`	FleetOrchestrator result fusion cross-reference
`nexus_argue`	HybridReasoningEngine syllogism verification
`nexus_readiness`	FleetOrchestrator FILING_READINESS assessment
`judicial_intel`	FleetOrchestrator JUDICIAL_INTEL task type
`timeline_search`	FleetOrchestrator TIMELINE_CONSTRUCT task type
`vector_search`	Neural layer semantic similarity (LanceDB 75K vectors)
`red_team`	CriticAgent red-team validation of argument strength

Singularity Mbp Apex Cognition

SINGULARITY-MBP-APEX-COGNITION v1.0

Layer 1: EvoAgent Architecture — Population-Based Strategy Evolution

1.1 Core AORP Loop Controller

Singularity Mbp Apex Cognition

SINGULARITY-MBP-APEX-COGNITION v1.0

Layer 1: EvoAgent Architecture — Population-Based Strategy Evolution

1.1 Core AORP Loop Controller

Layer 2: Critic / Verifier Sub-Agent System

2.1 CriticAgent — Multi-Faceted Output Verification

2.2 Batch Verification Pipeline (Python Backend)

Layer 3: Hybrid Neural + Symbolic Reasoning

3.1 HybridReasoningEngine — Symbolic Rules Constrain Neural Search

Layer 4: Cross-Session Learning Persistence

4.1 CrossSessionLearner — Strategy DNA Serialization

Layer 5: Self-Calibrating Confidence System

5.1 ConfidenceCalibrator — Brier Scores + Per-Domain Tracking

Layer 6: Agent Fleet Orchestration

6.1 FleetOrchestrator — Task Decomposition + Agent Selection + Result Fusion

Anti-Patterns — 25 INVIOLABLE Rules

Performance Budgets

Integration Matrix

Tier Dependencies (APEX-COGNITION orchestrates all lower tiers)

LitigationOS Tool Integration

Research Citations

Appendix A: Quick-Start Wiring

Appendix B: Strategy Genome Visualization (D3.js)

Llm Trading Agent Security

Energy Procurement

Council

Carrier Relationship Management

Market Research

Market Research