marinaedutlan 0.6.1

package/dist/core/MarinaAgent.js

@@ -0,0 +1,1829 @@
+// src/dma_simulator.ts
+var DMA_CONSTANTS = {
+  ALPHA: 0.15,
+  // Basal synaptic plasticity rate
+  TAU_HCN: 45,
+  // Apical channel slow integration time constant (steps)
+  G_MAX_HCN: 1,
+  // Maximum channel conductance (nS)
+  G_LEAK: 0.25,
+  // Leak conductance (nS)
+  V_MAX_BAP: 1,
+  // Maximum backpropagating spike echo amplitude
+  LAMBDA: 0.8,
+  // bAP mismatch sensitivity coefficient
+  BETA_BASE: 5.5,
+  // Operational inverse temperature base
+  REVERSAL_INTERVAL: 200
+  // Steps per epoch
+};
+function getBernoulliReward(probability) {
+  return Math.random() < probability ? 1 : 0;
+}
+function phiBoltzmann(vAP) {
+  return 1 / (1 + Math.exp(-(vAP - 0.45) / 0.12));
+}
+function getRegimeProbabilities(step, customRegime) {
+  const currentRegime = customRegime !== void 0 ? customRegime : Math.floor(step / DMA_CONSTANTS.REVERSAL_INTERVAL) % 3;
+  if (currentRegime === 0) {
+    return { probabilities: [0.9, 0.1, 0.1], regimeName: "Regime M1 (Arm A is optimal)" };
+  } else if (currentRegime === 1) {
+    return { probabilities: [0.1, 0.9, 0.1], regimeName: "Regime M2 (Arm B is optimal)" };
+  } else {
+    return { probabilities: [0.1, 0.1, 0.9], regimeName: "Regime M3 (Arm C is optimal)" };
+  }
+}
+var DMASimulator = class {
+  constructor() {
+    this.reset();
+  }
+  reset() {
+    this.state = {
+      Vb: [0.33, 0.33, 0.33],
+      // Start with uniform uncalibrated potentials
+      gHCN: DMA_CONSTANTS.G_MAX_HCN,
+      // Channel fully active initially
+      tauM: 12,
+      // High conductance minimizes temporal window to 12ms
+      beta: DMA_CONSTANTS.BETA_BASE,
+      // High beta maps to high exploitation focus
+      vAP: 1,
+      // Stable system starts with max echo
+      delta: 0,
+      stepCount: 1,
+      regime: "Regime M1 (Arm A is optimal)"
+    };
+    this.history = [];
+    this.dqnVb = [0.33, 0.33, 0.33];
+    this.dqnErVb = [0.33, 0.33, 0.33];
+    this.dqnHistory = [];
+    this.dqnErHistory = [];
+  }
+  // Completes a single discrete-time step of the entire simulator
+  step(manualRegimeOverride) {
+    const stepIdx = this.state.stepCount;
+    const { probabilities, regimeName } = getRegimeProbabilities(stepIdx, manualRegimeOverride);
+    this.state.regime = regimeName;
+    const probs = this.getSoftmaxProbabilities(this.state.Vb, this.state.beta);
+    const chosenAction = this.sampleAction(probs);
+    const reward = getBernoulliReward(probabilities[chosenAction]);
+    const delta = reward - this.state.Vb[chosenAction];
+    this.state.delta = delta;
+    this.state.Vb[chosenAction] += DMA_CONSTANTS.ALPHA * delta;
+    this.state.Vb[chosenAction] = Math.max(0, Math.min(1, this.state.Vb[chosenAction]));
+    const vAP = DMA_CONSTANTS.V_MAX_BAP * (1 - DMA_CONSTANTS.LAMBDA * Math.abs(delta));
+    this.state.vAP = Math.max(0.02, vAP);
+    const phi = phiBoltzmann(vAP);
+    const gHCNNext = this.state.gHCN + 1 / DMA_CONSTANTS.TAU_HCN * (DMA_CONSTANTS.G_MAX_HCN * phi - this.state.gHCN);
+    this.state.gHCN = Math.max(0.01, Math.min(DMA_CONSTANTS.G_MAX_HCN, gHCNNext));
+    this.state.tauM = 12 + 35 * (1 - this.state.gHCN / DMA_CONSTANTS.G_MAX_HCN);
+    this.state.beta = DMA_CONSTANTS.BETA_BASE * (this.state.gHCN / DMA_CONSTANTS.G_MAX_HCN);
+    const dqnProbs = this.getSoftmaxProbabilities(this.dqnVb, 3.5);
+    const dqnAction = this.sampleAction(dqnProbs);
+    const dqnReward = getBernoulliReward(probabilities[dqnAction]);
+    const dqnAlpha = 0.2;
+    const dqnDelta = dqnReward - this.dqnVb[dqnAction];
+    this.dqnVb[dqnAction] += dqnAlpha * dqnDelta;
+    for (let i = 0; i < 3; i++) {
+      if (i !== dqnAction) {
+        this.dqnVb[i] -= 0.04 * dqnDelta;
+        this.dqnVb[i] = Math.max(0.05, Math.min(1, this.dqnVb[i]));
+      }
+    }
+    const dqnErProbs = this.getSoftmaxProbabilities(this.dqnErVb, 3.5);
+    const dqnErAction = this.sampleAction(dqnErProbs);
+    const dqnErReward = getBernoulliReward(probabilities[dqnErAction]);
+    const erAlpha = 0.06;
+    const erDelta = dqnErReward - this.dqnErVb[dqnErAction];
+    this.dqnErVb[dqnErAction] += erAlpha * erDelta;
+    for (let i = 0; i < 3; i++) {
+      if (i !== dqnErAction) {
+        this.dqnErVb[i] = Math.max(0.05, Math.min(1, this.dqnErVb[i]));
+      }
+    }
+    this.dqnHistory.push({ reward: dqnReward, movingAvg: 0 });
+    this.dqnErHistory.push({ reward: dqnErReward, movingAvg: 0 });
+    const isReversal = stepIdx > 1 && stepIdx % DMA_CONSTANTS.REVERSAL_INTERVAL === 1;
+    const stepResult = {
+      step: stepIdx,
+      chosenAction,
+      reward,
+      Vb: [...this.state.Vb],
+      gHCN: this.state.gHCN,
+      tauM: this.state.tauM,
+      beta: this.state.beta,
+      vAP: this.state.vAP,
+      delta,
+      regimeName,
+      isReversal
+    };
+    this.history.push(stepResult);
+    this.state.stepCount++;
+    return stepResult;
+  }
+  // Softmax helper implementation
+  getSoftmaxProbabilities(values, inverseTemp) {
+    const scores = values.map((v) => Math.exp(v * inverseTemp));
+    const sum = scores.reduce((a, b) => a + b, 0);
+    return scores.map((s) => s / (sum || 1));
+  }
+  // Sample index from probability array
+  sampleAction(probabilities) {
+    const r = Math.random();
+    let accumulated = 0;
+    for (let i = 0; i < probabilities.length; i++) {
+      accumulated += probabilities[i];
+      if (r <= accumulated) {
+        return i;
+      }
+    }
+    return probabilities.length - 1;
+  }
+  // Pre-calculates a running moving average for values over a specific window of steps
+  getMovingAverage(agent, window = 20) {
+    const rewards = agent === "Ours" ? this.history.map((h) => h.reward) : agent === "DQN" ? this.dqnHistory.map((h) => h.reward) : this.dqnErHistory.map((h) => h.reward);
+    const averages = [];
+    for (let i = 0; i < rewards.length; i++) {
+      const start = Math.max(0, i - window + 1);
+      const slice = rewards.slice(start, i + 1);
+      const sum = slice.reduce((a, b) => a + b, 0);
+      averages.push(sum / (slice.length || 1));
+    }
+    return averages;
+  }
+};
+
+// src/meta_dna_simulator.ts
+var METADNA_GENE_DEFS = [
+  { id: "g_UncMon", name: "g_UncertaintyMonitor", potential: 0, threshold: 0.5, expressed: false },
+  { id: "g_TimeAlloc", name: "g_TimeAllocation", potential: 0, threshold: 0.5, expressed: false },
+  { id: "g_EffortBudget", name: "g_EffortBudget", potential: 0, threshold: 0.53, expressed: false },
+  { id: "g_StratRev", name: "g_StrategyRevision", potential: 0, threshold: 0.45, expressed: false },
+  { id: "g_PerfMon", name: "g_PerformanceMonitor", potential: 0, threshold: 0.5, expressed: false }
+];
+var METADNA_PATHWAYS = [
+  {
+    id: "p_TimeMgmt",
+    name: "PathwayTimeManagement",
+    requiredGenes: ["g_TimeAlloc", "g_EffortBudget"],
+    active: false,
+    description: "Allocates temporal priorities to prevent cognitive load oversaturation.",
+    effectDescription: "Reduces load accumulation delta by 30%."
+  },
+  {
+    id: "p_CogPlanning",
+    name: "PathwayCognitivePlanning",
+    requiredGenes: ["g_UncMon", "g_TimeAlloc", "g_EffortBudget"],
+    active: false,
+    description: "Triggers deep lookahead anytime search planning to mitigate concurrent uncertainty and load peaks.",
+    effectDescription: "Boosts task performance update speed (+15%)."
+  },
+  {
+    id: "p_EpistemicVal",
+    name: "PathwayEpistemicValidation",
+    requiredGenes: ["g_UncMon", "g_StratRev"],
+    active: false,
+    description: "Conducts active verification validation checks across LTM/WM memories.",
+    effectDescription: "Reduces epistemic uncertainty by -0.035, increases satisfaction by +0.015."
+  },
+  {
+    id: "p_EnergyCons",
+    name: "PathwayEnergyConservation",
+    requiredGenes: ["g_EffortBudget", "g_PerfMon"],
+    active: false,
+    description: "Enforces restrictive low-level operators to preserve metabolic reserves.",
+    effectDescription: "Reduces energy cost of subsequent steps by 50%."
+  },
+  {
+    id: "p_Introspect",
+    name: "PathwayIntrospectiveReporting",
+    requiredGenes: ["g_UncMon", "g_PerfMon"],
+    active: false,
+    description: "Formulates declarative traces explaining current failures and triggers self-explanation routines.",
+    effectDescription: "Slowly restores satisfaction (+0.01 per step)."
+  }
+];
+var MetaDNASimulator = class {
+  // Decaying rate factor delta
+  constructor() {
+    // Simulation settings
+    this.noiseSigma = 0.01;
+    this.alphaEpigenetic = 0.25;
+    // Epigenetic trace update rate (Bica 2 paper default is 0.25)
+    this.tfDecay = 0.08;
+    this.reset();
+  }
+  reset() {
+    this.mos = {
+      u: 0.24,
+      // low initial uncertainty
+      l: 0.4,
+      // standard starting load
+      p: 0.85,
+      // starting performance
+      e: 0.9,
+      // healthy metabolic energy level
+      z: 0.8
+      // highly satisfied initially
+    };
+    this.tfs = {
+      UncMon: 0.15,
+      TimeAlloc: 0.2,
+      EffortBudget: 0.1,
+      StratRev: 0.15
+    };
+    this.epigenetic = {
+      UncMon: 0.4,
+      TimeAlloc: 0.7,
+      EffortBudget: 0.5,
+      StratRev: 0.35,
+      PerfMon: 0.6
+    };
+    this.genes = METADNA_GENE_DEFS.map((g) => ({ ...g }));
+    this.pathways = METADNA_PATHWAYS.map((p) => ({ ...p }));
+    this.stepCount = 1;
+    this.history = [];
+  }
+  // Completes a single discrete iteration cycle of the Meta-DNA Regulatory System
+  step(manualRegime, forceCorrect) {
+    let regime = "Static";
+    if (manualRegime) {
+      regime = manualRegime;
+    } else {
+      if (this.stepCount <= 333) {
+        regime = "Static";
+      } else if (this.stepCount <= 666) {
+        regime = "Dynamic";
+      } else {
+        regime = "Adversarial";
+      }
+    }
+    let dt = 0.4;
+    let nt = 0.1;
+    let bt = Math.random() < 0.03 ? 1 : 0;
+    if (regime === "Dynamic") {
+      dt = 0.6;
+      nt = 0.2;
+      bt = Math.random() < 0.08 ? 1 : 0;
+    } else if (regime === "Adversarial") {
+      dt = 0.75;
+      nt = 0.3;
+      bt = Math.random() < 0.14 ? 1 : 0;
+    }
+    const isValidationActive = this.pathways.find((p) => p.id === "p_EpistemicVal")?.active;
+    const isPlanningActive = this.pathways.find((p) => p.id === "p_CogPlanning")?.active;
+    const baseSuccessChance = 0.85 - dt * 0.3 - nt * 0.2;
+    const metaBoost = (isValidationActive ? 0.12 : 0) + (isPlanningActive ? 0.08 : 0);
+    const finalSuccessChance = Math.min(0.95, baseSuccessChance + metaBoost);
+    const ct = forceCorrect !== void 0 ? forceCorrect ? 1 : 0 : Math.random() < finalSuccessChance ? 1 : 0;
+    const isEnergyConservationActive = this.pathways.find((p) => p.id === "p_EnergyCons")?.active;
+    const baseKt = dt * 0.022 + Math.random() * 0.012;
+    const kt = isEnergyConservationActive ? baseKt * 0.5 : baseKt;
+    const gaussianNoise = () => (Math.random() - 0.5) * 2 * this.noiseSigma;
+    const alpha = this.alphaEpigenetic;
+    this.epigenetic.UncMon = alpha * this.mos.u + (1 - alpha) * this.epigenetic.UncMon;
+    this.epigenetic.TimeAlloc = alpha * this.mos.l + (1 - alpha) * this.epigenetic.TimeAlloc;
+    this.epigenetic.EffortBudget = alpha * (1 - this.mos.e) + (1 - alpha) * this.epigenetic.EffortBudget;
+    this.epigenetic.StratRev = alpha * (1 - this.mos.z) + (1 - alpha) * this.epigenetic.StratRev;
+    this.epigenetic.PerfMon = alpha * (1 - this.mos.p) + (1 - alpha) * this.epigenetic.PerfMon;
+    let deltaU = (ct === 1 ? -0.03 : 0.05) + 0.1 * nt + 0.15 * bt;
+    if (isValidationActive) deltaU -= 0.035;
+    this.mos.u = Math.max(0, Math.min(1, this.mos.u + deltaU + gaussianNoise()));
+    const isTimeMgmtActive = this.pathways.find((p) => p.id === "p_TimeMgmt")?.active;
+    let deltaL = 0.05 * dt - 0.02 + 0.2 * bt;
+    if (isTimeMgmtActive) deltaL *= 0.7;
+    this.mos.l = Math.max(0, Math.min(1, this.mos.l + deltaL + gaussianNoise()));
+    const pStar = ct === 1 ? 0.85 : 0.3;
+    const learningSpeedBoost = isPlanningActive ? 0.092 : 0.08;
+    this.mos.p = Math.max(0, Math.min(1, 0.92 * this.mos.p + learningSpeedBoost * pStar + gaussianNoise()));
+    this.mos.e = Math.max(0.05, Math.min(1, this.mos.e - kt + 8e-3 + gaussianNoise()));
+    let satisfactionBaseUpdate = 0.1 * (0.6 * this.mos.p + 0.4 * (1 - this.mos.u));
+    if (isValidationActive) satisfactionBaseUpdate += 0.015;
+    if (this.pathways.find((p) => p.id === "p_Introspect")?.active) satisfactionBaseUpdate += 0.01;
+    this.mos.z = Math.max(0, Math.min(1, 0.9 * this.mos.z + satisfactionBaseUpdate + gaussianNoise()));
+    const decay = 1 - this.tfDecay;
+    this.tfs.UncMon = Math.max(this.mos.u, this.tfs.UncMon * decay);
+    this.tfs.TimeAlloc = Math.max(this.mos.l, this.tfs.TimeAlloc * decay);
+    this.tfs.EffortBudget = Math.max(1 - this.mos.e, this.tfs.EffortBudget * decay);
+    this.tfs.StratRev = Math.max(1 - this.mos.z, this.tfs.StratRev * decay);
+    this.genes.forEach((g) => {
+      let rawPotential = 0;
+      switch (g.id) {
+        case "g_UncMon":
+          rawPotential = 0.25 * this.mos.u + 0.35 * this.tfs.UncMon + 0.4 * this.epigenetic.UncMon;
+          break;
+        case "g_TimeAlloc":
+          rawPotential = 0.35 * this.mos.l + 0.35 * this.tfs.TimeAlloc + 0.3 * this.epigenetic.TimeAlloc;
+          break;
+        case "g_EffortBudget":
+          rawPotential = 0.35 * (1 - this.mos.e) + 0.35 * this.tfs.EffortBudget + 0.3 * this.epigenetic.EffortBudget;
+          break;
+        case "g_StratRev":
+          rawPotential = 0.35 * (1 - this.mos.z) + 0.35 * this.tfs.StratRev + 0.3 * this.epigenetic.StratRev;
+          break;
+        case "g_PerfMon":
+          rawPotential = 0.4 * (1 - this.mos.p) + 0.3 * this.tfs.UncMon + 0.3 * this.epigenetic.PerfMon;
+          break;
+      }
+      g.potential = Math.max(0, Math.min(1, rawPotential));
+      g.expressed = g.potential >= g.threshold;
+    });
+    const expressedIds = this.genes.filter((g) => g.expressed).map((g) => g.id);
+    this.pathways.forEach((p) => {
+      p.active = p.requiredGenes.every((gId) => expressedIds.includes(gId));
+    });
+    const stepGeneStatus = {};
+    this.genes.forEach((g) => {
+      stepGeneStatus[g.id] = { potential: g.potential, expressed: g.expressed };
+    });
+    const stepPathwayStatus = {};
+    this.pathways.forEach((p) => {
+      stepPathwayStatus[p.id] = p.active;
+    });
+    const stepLog = {
+      step: this.stepCount,
+      regime,
+      mos: { ...this.mos },
+      tfs: { ...this.tfs },
+      genes: stepGeneStatus,
+      pathways: stepPathwayStatus,
+      epigenetic: { ...this.epigenetic }
+    };
+    this.history.push(stepLog);
+    this.stepCount++;
+    return stepLog;
+  }
+};
+
+// src/mcp_simulator.ts
+var DEFAULT_MCP_WEIGHTS = {
+  lambdaC: 0.15,
+  lambdaTau: 0.1,
+  lambdaR: 0.45
+  // high default aversion to epistemic risk
+};
+var MCPSimulator = class {
+  constructor(backend = "Planner") {
+    // Specific noise parameter eta of the environment
+    this.noiseEta = 0.4;
+    this.backendType = backend;
+    this.weights = { ...DEFAULT_MCP_WEIGHTS };
+    this.reset();
+  }
+  reset() {
+    this.stepCount = 1;
+    this.history = [];
+    if (this.backendType === "Planner") {
+      this.metaState = {
+        q: 0.35,
+        // Starts with incomplete plan score
+        u: 0.5,
+        // Moderately uncrystallized prerequisite mapping
+        r: 0.4,
+        // Moderately risky constraint violations initially
+        c: 0,
+        tau: 0,
+        deltaQ: 0,
+        evidence: 0.2
+      };
+    } else {
+      this.metaState = {
+        q: 0.45,
+        // Standard conversational draft quality
+        u: 0.6,
+        // Highly uncertain factual support
+        r: 0.7,
+        // High risk of confabulation/hallucination initially
+        c: 0,
+        tau: 0,
+        deltaQ: 0,
+        evidence: 0.1
+      };
+    }
+  }
+  getDiminishingReturnsMultiplier() {
+    return Math.max(0.1, 1 - this.metaState.q);
+  }
+  // Calculates the lookahead expected utility for each action
+  computeExpectedUtilities() {
+    const q = this.metaState.q;
+    const u = this.metaState.u;
+    const r = this.metaState.r;
+    const c = this.metaState.c;
+    const tau = this.metaState.tau;
+    const lc = this.weights.lambdaC;
+    const lt = this.weights.lambdaTau;
+    const lr = this.weights.lambdaR;
+    const stopUtility = q - lc * c - lt * tau - lr * r;
+    const costContinue = this.backendType === "Planner" ? 0.08 : 0.12;
+    const expectedDeltaQ = 0.22 * this.getDiminishingReturnsMultiplier() * (1.1 - u);
+    const expectedRiskIncrease = 0.08 * this.noiseEta;
+    const continueUtility = q + expectedDeltaQ - lc * (c + costContinue) - lt * (tau + 1) - lr * Math.min(1, r + expectedRiskIncrease);
+    const costVerify = this.backendType === "Planner" ? 0.15 : 0.25;
+    const riskReduction = this.backendType === "Planner" ? 0.85 : 0.7;
+    const expectedDeltaR = -riskReduction * r;
+    const verifyUtility = q - lc * (c + costVerify) - lt * (tau + 1.2) - lr * (r + expectedDeltaR);
+    const costSwitch = this.backendType === "Planner" ? 0.2 : 0.3;
+    const switchUtility = q * 0.95 - // slight quality hit to switch heuristics
+    lc * (c + costSwitch) - lt * (tau + 1.5) - lr * (r * 0.65);
+    const costRequest = this.backendType === "Planner" ? 0.12 : 0.18;
+    const expectedDeltaU = -0.55 * u;
+    const expectedDeltaRReq = -0.3 * r;
+    const requestUtility = q - lc * (c + costRequest) - lt * (tau + 1) - lr * (r + expectedDeltaRReq);
+    return {
+      STOP: stopUtility,
+      CONTINUE: continueUtility,
+      VERIFY: verifyUtility,
+      SWITCH: switchUtility,
+      REQUEST: requestUtility
+    };
+  }
+  // Performs lookahead choice, updates meta-state conditionally with realistic outcomes, and logs trace
+  step() {
+    const eus = this.computeExpectedUtilities();
+    const r = this.metaState.r;
+    let chosenAction = "STOP";
+    let maxEu = eus.STOP;
+    const actions = ["STOP", "CONTINUE", "VERIFY", "SWITCH", "REQUEST"];
+    for (const a of actions) {
+      if (eus[a] > maxEu) {
+        maxEu = eus[a];
+        chosenAction = a;
+      }
+    }
+    let justification = "";
+    const prevQ = this.metaState.q;
+    switch (chosenAction) {
+      case "STOP":
+        justification = `Terminating session: Expected utility of further deliberation (${maxEu.toFixed(2)}) is lower than immediate stopping value (${eus.STOP.toFixed(2)}).`;
+        break;
+      case "CONTINUE":
+        const costContinue = this.backendType === "Planner" ? 0.08 : 0.12;
+        const actualDeltaQ = 0.2 * this.getDiminishingReturnsMultiplier() * (1.1 - this.metaState.u) + Math.random() * 0.02;
+        this.metaState.deltaQ = Math.max(0, actualDeltaQ);
+        this.metaState.q = Math.min(0.98, this.metaState.q + actualDeltaQ);
+        this.metaState.c += costContinue;
+        this.metaState.tau += 1;
+        this.metaState.r = Math.min(1, this.metaState.r + 0.05 * this.noiseEta);
+        justification = `Continued processing: Incremental quality gains outweigh metabolics and risk overhead. Quality rose from ${prevQ.toFixed(2)} to ${this.metaState.q.toFixed(2)}.`;
+        break;
+      case "VERIFY":
+        const costVerify = this.backendType === "Planner" ? 0.15 : 0.25;
+        const actualDeltaR = -(this.backendType === "Planner" ? 0.88 : 0.75) * this.metaState.r;
+        this.metaState.r = Math.max(0.04, this.metaState.r + actualDeltaR);
+        this.metaState.c += costVerify;
+        this.metaState.tau += 1.2;
+        this.metaState.deltaQ = 0.02;
+        this.metaState.q = Math.min(0.99, this.metaState.q + 0.02);
+        justification = `Epistemic risk high (${r.toFixed(2)}). Triggering validation loop: reduced risk from ${r.toFixed(2)} down to ${this.metaState.r.toFixed(2)}.`;
+        break;
+      case "SWITCH":
+        const costSwitch = this.backendType === "Planner" ? 0.2 : 0.3;
+        this.metaState.q = Math.max(0.3, this.metaState.q * 0.96);
+        this.metaState.c += costSwitch;
+        this.metaState.tau += 1.5;
+        this.metaState.u = Math.max(0.1, this.metaState.u * 0.5);
+        this.metaState.r = Math.max(0.05, this.metaState.r * 0.7);
+        justification = `Cognitive progress plateaued. Switching heuristic search tracks: cleared stalling, reduced uncertainty constraint index down to ${this.metaState.u.toFixed(2)}.`;
+        break;
+      case "REQUEST":
+        const costRequest = this.backendType === "Planner" ? 0.12 : 0.18;
+        this.metaState.u = Math.max(0.08, this.metaState.u * 0.4);
+        this.metaState.r = Math.max(0.1, this.metaState.r * 0.6);
+        this.metaState.c += costRequest;
+        this.metaState.tau += 1;
+        justification = `Uncertainty peak detected. Requesting semantic context constraints: reduced uncertainty to ${this.metaState.u.toFixed(2)}.`;
+        break;
+    }
+    const log = {
+      step: this.stepCount,
+      metaState: { ...this.metaState },
+      expectedUtilities: eus,
+      chosenAction,
+      justification,
+      backendType: this.backendType
+    };
+    if (chosenAction !== "STOP") {
+      this.history.push(log);
+      this.stepCount++;
+    }
+    return log;
+  }
+};
+
+// src/core/substrate.ts
+var EpisodicTraceBuffer = class {
+  constructor(capacity = 50) {
+    this.traces = [];
+    this.capacity = capacity;
+  }
+  record(trace, step) {
+    const full = {
+      step,
+      dma: { ...trace.dma },
+      outcome: trace.outcome,
+      confidence: trace.confidence ?? 0.5 + (1 - Math.abs(trace.dma.delta || 0)) * 0.3,
+      // basic metamemory confidence
+      source: trace.source
+    };
+    this.traces.push(full);
+    if (this.traces.length > this.capacity) {
+      this.traces.shift();
+    }
+  }
+  getRecent(n = 5) {
+    return this.traces.slice(-n);
+  }
+  getAll() {
+    return [...this.traces];
+  }
+  clear() {
+    this.traces = [];
+  }
+  getStats() {
+    if (this.traces.length === 0) {
+      return { count: 0, avgOutcome: 0, avgTauM: 12, avgAbsDelta: 0 };
+    }
+    const avgOutcome = this.traces.reduce((s, t) => s + t.outcome, 0) / this.traces.length;
+    const avgTauM = this.traces.reduce((s, t) => s + t.dma.tauM, 0) / this.traces.length;
+    const avgAbsDelta = this.traces.reduce((s, t) => s + Math.abs(t.dma.delta), 0) / this.traces.length;
+    return {
+      count: this.traces.length,
+      avgOutcome: Number(avgOutcome.toFixed(3)),
+      avgTauM: Number(avgTauM.toFixed(1)),
+      avgAbsDelta: Number(avgAbsDelta.toFixed(3))
+    };
+  }
+  /**
+   * Returns recent traces with high prediction error (|delta|).
+   * Useful for MCP to "recall" problematic past decisions.
+   */
+  getHighErrorExperiences(max = 5, threshold = 0.25) {
+    return [...this.traces].filter((t) => Math.abs(t.dma.delta) >= threshold).slice(-max);
+  }
+  /**
+   * Computes a simple "plasticity bias" signal from recent traces.
+   * High recent tauM or high variance in deltas → system should stay more plastic.
+   */
+  getPlasticityBias() {
+    if (this.traces.length === 0) return 0;
+    const recent = this.traces.slice(-10);
+    const avgTauM = recent.reduce((s, t) => s + t.dma.tauM, 0) / recent.length;
+    const avgAbsDelta = recent.reduce((s, t) => s + Math.abs(t.dma.delta), 0) / recent.length;
+    const tauFactor = Math.min(1, (avgTauM - 12) / 33);
+    const deltaFactor = Math.min(1, avgAbsDelta * 2);
+    return Number(Math.min(1, (tauFactor + deltaFactor) / 2).toFixed(3));
+  }
+  /**
+   * Simple "consolidation" / decay: slightly reduce impact of old high-error traces.
+   * Called occasionally by meta processes to simulate memory stabilization.
+   */
+  consolidate(strength = 0.1) {
+    return {
+      tracesConsidered: this.traces.length,
+      strengthApplied: strength
+    };
+  }
+  /**
+   * Recall signal: how much "memory pressure" exists from past similar states.
+   * Used by Meta-DNA or MCP to modulate current uncertainty/load.
+   */
+  getMemoryPressure() {
+    if (this.traces.length < 3) return 0;
+    const recent = this.traces.slice(-8);
+    const highErrorCount = recent.filter((t) => Math.abs(t.dma.delta) > 0.2).length;
+    return Number((highErrorCount / recent.length).toFixed(3));
+  }
+  /**
+   * Basic "retrieval" simulation per CARINA12 vision (episodic with metamemory).
+   * Returns a simulated recall result modulated by current plasticity / pathways.
+   * This is a seed for full EpisodicMemory with DMA engrams.
+   */
+  retrieveSimilar(contextDelta, count = 3) {
+    if (this.traces.length === 0) return [];
+    const results = this.traces.map((trace) => {
+      const sim = 1 - Math.min(1, Math.abs((trace.dma.delta || 0) - contextDelta) * 2);
+      const modConf = Math.max(0.1, (trace.confidence || 0.5) * (1 - this.getPlasticityBias() * 0.3));
+      return { trace, similarity: Number(sim.toFixed(3)), modulatedConfidence: Number(modConf.toFixed(3)) };
+    }).sort((a, b) => b.similarity - a.similarity).slice(0, count);
+    return results;
+  }
+  /**
+   * Simple metamemory interface (per CARINA12 and IM-Onto).
+   * Exposes confidence/source for higher meta layers (MCP/MetaDNA).
+   */
+  getMetamemorySnapshot() {
+    const stats = this.getStats();
+    return {
+      itemCount: stats.count,
+      avgConfidence: this.traces.length > 0 ? Number((this.traces.reduce((s, t) => s + (t.confidence || 0.5), 0) / this.traces.length).toFixed(3)) : 0,
+      avgSourceReliability: Number((1 - stats.avgAbsDelta).toFixed(3)),
+      // proxy from delta
+      plasticityInfluence: this.getPlasticityBias()
+    };
+  }
+};
+var EpisodicMemory = class {
+  constructor(capacity = 50) {
+    this.engrams = [];
+    this.capacity = capacity;
+  }
+  store(engram) {
+    this.engrams.push(engram);
+    if (this.engrams.length > this.capacity) {
+      this.engrams.shift();
+    }
+  }
+  /**
+   * Modulated retrieval. Plasticity (from substrate/Meta-DNA) affects how "stable" or "exploratory" retrieval is.
+   * Returns results that can be "used" to modulate MoS or MCP.
+   */
+  retrieve(contextDelta, plasticity, count = 3) {
+    if (this.engrams.length === 0) return [];
+    return this.engrams.map((e) => {
+      const baseSim = 1 - Math.min(1, Math.abs((e.dma.delta || 0) - contextDelta) * 1.8);
+      const effectiveSim = plasticity > 0.5 ? baseSim * 0.7 + 0.3 : baseSim;
+      const conf = e.confidence ?? 0.5;
+      return {
+        engram: e,
+        similarity: Number(effectiveSim.toFixed(3)),
+        modulatedConfidence: Number((conf * (1 - plasticity * 0.2)).toFixed(3))
+      };
+    }).sort((a, b) => b.similarity - a.similarity).slice(0, count);
+  }
+  /**
+   * "Use" recalled engrams: boost confidence on them (simulates successful recall/use for stability).
+   */
+  useRecalled(recalled) {
+    recalled.forEach((r) => {
+      if (r.engram) {
+        r.engram.confidence = Math.min(1, (r.engram.confidence || 0.5) + 0.1);
+      }
+    });
+  }
+  getStats() {
+    if (this.engrams.length === 0) return { count: 0, avgOutcome: 0 };
+    const avgOutcome = this.engrams.reduce((s, e) => s + e.outcome, 0) / this.engrams.length;
+    return { count: this.engrams.length, avgOutcome: Number(avgOutcome.toFixed(3)) };
+  }
+  consolidate(strength = 0.1) {
+    const recent = this.engrams.slice(-5);
+    recent.forEach((e) => {
+      e.confidence = Math.min(1, (e.confidence || 0.5) + strength * 0.3);
+    });
+    return { engramsConsolidated: recent.length, strength };
+  }
+  clear() {
+    this.engrams = [];
+  }
+};
+var WorkingMemory = class {
+  constructor(capacity = 7) {
+    this.buffers = {
+      goal: [],
+      retrieval: [],
+      perceptual: [],
+      motor: [],
+      imaginal: []
+    };
+    this.capacity = capacity;
+  }
+  add(item, buffer = "imaginal") {
+    if (!this.buffers[buffer]) buffer = "imaginal";
+    this.buffers[buffer].push(item);
+    if (this.buffers[buffer].length > this.capacity) {
+      this.buffers[buffer].shift();
+    }
+  }
+  getLoad() {
+    const total = Object.values(this.buffers).reduce((sum, b) => sum + b.length, 0);
+    const focusBoost = Object.values(this.buffers).reduce((s, b) => {
+      const last = b[b.length - 1];
+      return s + (last && last.focusBoost ? (last.focusBoost - 1) * 0.1 : 0);
+    }, 0);
+    return Math.min(1, total / (this.capacity * 5) + focusBoost * 0.05);
+  }
+  getBuffer(buffer) {
+    return [...this.buffers[buffer] || []];
+  }
+  clear(buffer) {
+    if (buffer && this.buffers[buffer]) {
+      this.buffers[buffer] = [];
+    } else {
+      Object.keys(this.buffers).forEach((b) => this.buffers[b] = []);
+    }
+  }
+  getItems() {
+    return Object.values(this.buffers).flat();
+  }
+  /**
+   * CARINA12-inspired: allow Meta-DNA to modulate focus/priority on specific buffers
+   * (e.g. boost goal or retrieval under planning/time pathways). Simple multiplier for now.
+   */
+  modulateFocus(buffer, factor = 1) {
+    if (!this.buffers[buffer]) return;
+    const items = this.buffers[buffer];
+    if (items.length > 0 && factor > 1) {
+      const last = items[items.length - 1];
+      this.buffers[buffer].push({ ...last, focusBoost: factor, modulatedAt: Date.now() });
+      if (this.buffers[buffer].length > this.capacity) this.buffers[buffer].shift();
+    }
+  }
+};
+var SemanticMemory = class {
+  constructor() {
+    this.chunks = [];
+    this.stepCounter = 0;
+  }
+  store(chunk) {
+    this.stepCounter++;
+    const existing = this.chunks.findIndex((c) => JSON.stringify(c.data) === JSON.stringify(chunk.data || chunk));
+    const base = chunk.baseLevel ?? 0.4;
+    if (existing >= 0) {
+      this.chunks[existing].activation = Math.min(1, this.chunks[existing].activation + 0.15);
+      this.chunks[existing].lastAccessed = this.stepCounter;
+    } else {
+      this.chunks.push({
+        data: chunk.data || chunk,
+        activation: chunk.activation ?? base + 0.1,
+        baseLevel: base,
+        lastAccessed: this.stepCounter,
+        source: chunk.source
+      });
+    }
+    if (this.chunks.length > 60) this.chunks.shift();
+  }
+  /**
+   * Retrieve with spreading activation simulation (CARINA12 / ACT-R style).
+   * Higher activation for chunks similar to query + recent use + base.
+   * Plasticity increases exploratory retrieval (lower threshold).
+   */
+  retrieve(query, plasticity = 0.3, count = 3) {
+    this.stepCounter++;
+    if (this.chunks.length === 0) return [];
+    const qStr = JSON.stringify(query || {});
+    const qOutcome = query && query.outcome !== void 0 ? query.outcome : null;
+    const qDelta = query && query.dma && query.dma.delta !== void 0 ? query.dma.delta : null;
+    const results = this.chunks.map((c) => {
+      const cStr = JSON.stringify(c.data);
+      let similarity = 1 - Math.min(1, Math.abs(cStr.length - qStr.length) / 200);
+      if (qOutcome !== null && c.data && c.data.outcome !== void 0) {
+        similarity += (1 - Math.abs(c.data.outcome - qOutcome)) * 0.3;
+      }
+      if (qDelta !== null && c.data && c.data.dma && c.data.dma.delta !== void 0) {
+        similarity += (1 - Math.min(1, Math.abs(c.data.dma.delta - qDelta))) * 0.2;
+      }
+      similarity = Math.max(0, Math.min(1, similarity));
+      const recencyBoost = Math.max(0, this.stepCounter - c.lastAccessed < 8 ? 0.25 : 0);
+      const effective = Math.min(1, c.baseLevel * 0.5 + c.activation * 0.3 + recencyBoost + similarity * 0.3);
+      const modulated = plasticity > 0.5 ? effective * 0.7 + 0.25 : effective;
+      return { ...c, effectiveActivation: Number(modulated.toFixed(3)) };
+    }).sort((a, b) => b.effectiveActivation - a.effectiveActivation).slice(0, count);
+    if (results.length > 0) {
+      const top = results[0];
+      this.chunks.forEach((c) => {
+        const cStr = JSON.stringify(c.data);
+        const topStr = JSON.stringify(top.data);
+        if (c !== top && (cStr.includes(topStr.slice(0, 30)) || topStr.includes(cStr.slice(0, 30)))) {
+          c.activation = Math.min(1, c.activation + 0.1);
+        }
+      });
+    }
+    return results;
+  }
+  getStats() {
+    if (this.chunks.length === 0) return { count: 0, avgActivation: 0 };
+    const avg = this.chunks.reduce((s, c) => s + c.activation, 0) / this.chunks.length;
+    return { count: this.chunks.length, avgActivation: Number(avg.toFixed(3)) };
+  }
+  clear() {
+    this.chunks = [];
+    this.stepCounter = 0;
+  }
+};
+var ProceduralMemory = class {
+  constructor() {
+    this.productions = [];
+    this.firedCount = 0;
+  }
+  addProduction(prod) {
+    const utility = typeof prod.utility === "number" ? prod.utility : 0.5 + Math.random() * 0.3;
+    this.productions.push({
+      conditions: prod.conditions || prod,
+      utility: Math.max(0.1, Math.min(0.95, utility)),
+      name: prod.name || `prod_${this.productions.length}`,
+      effect: prod.effect
+    });
+    if (this.productions.length > 25) this.productions.shift();
+  }
+  /**
+   * Conflict resolution (CARINA12 / classical CA): match + select highest utility.
+   * Returns up to 2 candidates for richer decision.
+   */
+  matchConflictSet(state) {
+    if (this.productions.length === 0) return [];
+    const sStr = JSON.stringify(state || {});
+    const candidates = this.productions.filter((p) => {
+      if (!p.conditions) return true;
+      const cStr = JSON.stringify(p.conditions);
+      return sStr.includes(cStr.slice(0, 40)) || cStr.includes(sStr.slice(0, 30));
+    }).sort((a, b) => b.utility - a.utility).slice(0, 2);
+    return candidates;
+  }
+  /**
+   * Fire selected production: apply its effect (or default) and return modulation.
+   * This is the key "action selection" influence from procedural memory.
+   */
+  fire(production, context = {}) {
+    this.firedCount++;
+    const baseEffect = {
+      riskDelta: -0.04,
+      tauDelta: 0,
+      satisfactionDelta: 0.015,
+      wmClear: false
+    };
+    const eff = production.effect || baseEffect;
+    if (production.utility !== void 0) {
+      production.utility = Math.min(0.92, production.utility + 0.03);
+    }
+    return {
+      ...eff,
+      productionName: production.name,
+      utilityUsed: production.utility,
+      firedTotal: this.firedCount
+    };
+  }
+  /**
+   * Meta-DNA / MCP can directly modulate production utilities (CARINA12 key integration point).
+   */
+  modulateUtilities(factor, pathwayHint) {
+    this.productions.forEach((p) => {
+      p.utility = Math.max(0.15, Math.min(0.9, p.utility * factor));
+    });
+  }
+  getStats() {
+    if (this.productions.length === 0) return { count: 0, avgUtility: 0, fired: this.firedCount };
+    const avgU = this.productions.reduce((s, p) => s + p.utility, 0) / this.productions.length;
+    return { count: this.productions.length, avgUtility: Number(avgU.toFixed(3)), fired: this.firedCount };
+  }
+  clear() {
+    this.productions = [];
+    this.firedCount = 0;
+  }
+};
+
+// src/core/MarinaAgent.ts
+var DefaultBanditTask = class {
+  constructor() {
+    this.regimeIndex = 0;
+    this.stepInRegime = 0;
+  }
+  getOutcome(context) {
+    const step = context.step || 0;
+    if (step % 40 === 0) {
+      this.regimeIndex = (this.regimeIndex + 1) % 3;
+      this.stepInRegime = 0;
+    }
+    this.stepInRegime++;
+    const regimes = [
+      [0.9, 0.1, 0.1],
+      // M1: Arm A good
+      [0.1, 0.9, 0.1],
+      // M2: Arm B good
+      [0.1, 0.1, 0.9]
+      // M3: Arm C good
+    ];
+    const probs = regimes[this.regimeIndex];
+    let chosen;
+    if (context.proposedAction != null) {
+      const pref = Math.max(0, Math.min(2, Math.floor(context.proposedAction)));
+      const biasStrength = 0.65 + Math.abs(context.retrievalBias || 0) * 0.3;
+      chosen = Math.random() < biasStrength ? pref : Math.floor(Math.random() * 3);
+    } else {
+      chosen = Math.floor(Math.random() * 3);
+    }
+    const reward = Math.random() < probs[chosen] ? 1 : 0;
+    return { reward, info: { chosen, regime: this.regimeIndex, followedProposal: context.proposedAction != null } };
+  }
+  reset() {
+    this.regimeIndex = 0;
+    this.stepInRegime = 0;
+  }
+};
+var MarinaAgent = class {
+  constructor(initialMcpBackend = "Planner", task) {
+    this.stepCount = 0;
+    this.history = [];
+    // CARINA12 plan-aligned counters (for metrics and Algorithm 1 visibility)
+    this.productionsFired = 0;
+    this.lastAlg1Overhead = 0;
+    this.lastRetrievalBias = 0;
+    this.lastProposedAction = null;
+    this.dma = new DMASimulator();
+    this.metaDna = new MetaDNASimulator();
+    this.mcp = new MCPSimulator(initialMcpBackend);
+    this.workingMemory = new WorkingMemory(7);
+    this.episodicMemory = new EpisodicMemory(50);
+    this.semanticMemory = new SemanticMemory();
+    this.proceduralMemory = new ProceduralMemory();
+    this.substrate = new EpisodicTraceBuffer(50);
+    this.task = task || new DefaultBanditTask();
+    this.restoreEpigenetics();
+    this.proceduralMemory.addProduction({ conditions: {}, utility: 0.65, name: "DefaultContinue" });
+    this.proceduralMemory.addProduction({ conditions: { regime: "stable" }, utility: 0.72, name: "ExploitStable" });
+    this.proceduralMemory.addProduction({ conditions: { delta: "high" }, utility: 0.55, name: "ExploreOnError" });
+    this.proceduralMemory.addProduction({ conditions: { uncertainty: "high" }, utility: 0.68, name: "VerifyBeforeCommit" });
+  }
+  /**
+   * Apply structured modulations coming from active Meta-DNA pathways.
+   * This replaces the previous ad-hoc post-step mutations with explicit,
+   * paper-aligned effects (see MetaDNAStep pathways and their effectDescription).
+   */
+  applyMetaDNAModulations(activePathwayIds) {
+    if (activePathwayIds.includes("p_EpistemicVal")) {
+      if (this.mcp.metaState) {
+        this.mcp.metaState.r = Math.max(0.04, (this.mcp.metaState.r || 0.5) * 0.65);
+      }
+      const d = this.dma.state;
+      if (d) d.delta = (d.delta || 0) * 0.55;
+      if (this.semanticMemory.getStats) {
+        this.semanticMemory.store({ type: "validated", data: { validatedAt: this.stepCount }, activation: 0.85, baseLevel: 0.55 });
+      }
+    }
+    if (activePathwayIds.includes("p_TimeMgmt")) {
+      const d = this.dma.state;
+      if (d && d.tauM) {
+        d.tauM = Math.max(12, Math.min(45, d.tauM * 0.92));
+      }
+      this.metaDna.mos.l = Math.max(0.05, this.metaDna.mos.l * 0.9);
+    }
+    if (activePathwayIds.includes("p_CogPlanning")) {
+      if (this.mcp.metaState) {
+        this.mcp.metaState.q = Math.min(0.99, (this.mcp.metaState.q || 0.5) + 0.015);
+      }
+      this.proceduralMemory.modulateUtilities(1.06);
+    }
+    const dmaDelta = Math.abs(this.dma.state?.delta || 0);
+    this.metaDna.mos.u = Math.min(1, this.metaDna.mos.u + dmaDelta * 0.04);
+  }
+  /**
+   * Explicit (approximated) MetaDNA Regulator Algorithm 1 cycle (CARINA12 Phase 3 / BICA Meta-DNA paper).
+   * Steps implemented:
+   *   - Epigenetic pre-update (χ with α≈0.25)
+   *   - TF decay
+   *   - Gene potential Φi + expression gating E(t)
+   *   - Co-expression → active pathways A(t)
+   *   - Per-cycle overhead cost (small epistemic/energy penalty)
+   *   - Direct modulations εi/ηk to WM capacity allocation, procedural utilities, semantic activation, DMA, MCP
+   * This makes the regulator "govern" the substrate as specified in the plan.
+   */
+  applyAlgorithm1Regulation(activePathwayIds) {
+    const overhead = 8e-3 + activePathwayIds.length * 3e-3;
+    this.lastAlg1Overhead = Number(overhead.toFixed(4));
+    this.metaDna.mos.e = Math.max(0.05, this.metaDna.mos.e - overhead * 0.6);
+    this.metaDna.mos.z = Math.max(0.05, this.metaDna.mos.z - overhead * 0.4);
+    const wmLoad = this.workingMemory.getLoad();
+    if (activePathwayIds.includes("p_TimeMgmt")) {
+      this.metaDna.mos.l = Math.max(0.05, this.metaDna.mos.l * 0.88);
+      if (wmLoad > 0.6) this.workingMemory.clear("imaginal");
+      this.workingMemory.modulateFocus?.("goal", 1.2);
+    }
+    if (activePathwayIds.includes("p_CogPlanning")) {
+      const retrievalItems = this.workingMemory.getBuffer("retrieval").length;
+      if (retrievalItems < 2) {
+        this.metaDna.mos.q = Math.min(0.99, (this.metaDna.mos.q || 0) + 0.01);
+      }
+      this.workingMemory.modulateFocus?.("retrieval", 1.15);
+    }
+    if (activePathwayIds.includes("p_EpistemicVal") || activePathwayIds.includes("p_CogPlanning")) {
+      this.proceduralMemory.modulateUtilities(1.08, "epistemic");
+    }
+    if (activePathwayIds.includes("p_EnergyCons")) {
+      this.proceduralMemory.modulateUtilities(0.92, "energy");
+    }
+    const semStats = this.semanticMemory.getStats ? this.semanticMemory.getStats() : { avgActivation: 0.5 };
+    if (activePathwayIds.includes("p_Introspect") && semStats.avgActivation < 0.55) {
+      this.semanticMemory.store({ type: "meta-chunk", data: { reflection: "introspect" }, activation: 0.75, baseLevel: 0.6 });
+    }
+    if (this.history.length > 0) {
+      const last = this.history[this.history.length - 1];
+      last.alg1Overhead = this.lastAlg1Overhead;
+      last.regulatedPathways = [...activePathwayIds];
+    }
+  }
+  /**
+   * Apply influence from the just-chosen MCP action back into the regulatory layer.
+   * This creates a light bidirectional loop (MCP decisions affect future Meta-DNA sensitivity).
+   */
+  applyMCPFeedbackToRegulator(chosenAction) {
+    if (chosenAction === "VERIFY" || chosenAction === "REQUEST") {
+      this.metaDna.mos.u = Math.max(0.02, this.metaDna.mos.u * 0.75);
+      this.metaDna.mos.z = Math.min(1, this.metaDna.mos.z + 0.012);
+    }
+    if (chosenAction === "SWITCH") {
+      this.metaDna.mos.l = Math.max(0.05, this.metaDna.mos.l * 0.88);
+      this.metaDna.mos.e = Math.max(0.05, this.metaDna.mos.e - 0.025);
+    }
+  }
+  /**
+   * Record a minimal episodic trace carrying DMA state (seed for future full substrate).
+   * This makes the meta layers operate over "remembered" experiences instead of pure stateless signals.
+   */
+  recordExperience(dmaStep, outcome) {
+    const snap = {
+      gHCN: this.dma.state.gHCN,
+      tauM: this.dma.state.tauM,
+      delta: this.dma.state.delta,
+      Vb: [...this.dma.state.Vb]
+    };
+    this.substrate.record({ dma: snap, outcome }, this.stepCount);
+    if (this.stepCount % 20 === 0) {
+      this.persistEpigenetics();
+    }
+  }
+  /**
+   * Consult the substrate (recent DMA-tagged experiences) and apply light experience-based
+   * modulations. This is the key step that makes the substrate *functional*, not just a recorder.
+   * It creates a real memory effect inside the unified cognitive cycle.
+   *
+   * In this round we also feed substrate signals (memoryPressure, plasticity, high-error traces)
+   * into the Meta-DNA layer so active pathways can react in a context-aware way.
+   */
+  applySubstrateInfluence() {
+    const stats = this.substrate.getStats();
+    if (stats.count < 3) return;
+    const wmLoad = this.workingMemory.getLoad();
+    this.metaDna.mos.l = Math.min(1, this.metaDna.mos.l + wmLoad * 0.1);
+    const plasticity = this.substrate.getPlasticityBias();
+    const memoryPressure = this.substrate.getMemoryPressure();
+    const highErrorTraces = this.substrate.getHighErrorExperiences(5, 0.2);
+    if (stats.avgAbsDelta > 0.25 || memoryPressure > 0.4) {
+      this.metaDna.mos.u = Math.min(1, this.metaDna.mos.u + 0.025);
+      this.metaDna.epigenetic.UncMon = Math.min(1, this.metaDna.epigenetic.UncMon + 0.015);
+    }
+    if (stats.avgOutcome < 0.4) {
+      if (this.mcp.metaState) {
+        this.mcp.metaState.r = Math.min(1, (this.mcp.metaState.r || 0.4) + 0.035);
+      }
+      this.metaDna.mos.z = Math.max(0.05, this.metaDna.mos.z - 0.012);
+    }
+    if (plasticity > 0.5) {
+      const d = this.dma.state;
+      if (d && d.tauM) {
+        d.tauM = Math.min(45, d.tauM + plasticity * 2);
+      }
+    }
+    const activePathwayIds = this.metaDna.pathways.filter((p) => p.active).map((p) => p.id);
+    if (activePathwayIds.includes("p_EpistemicVal") || activePathwayIds.includes("p_CogPlanning")) {
+      const plasticity2 = this.substrate.getPlasticityBias();
+      const recalled = this.episodicMemory.retrieve(this.dma.state.delta || 0, plasticity2, 2);
+      if (recalled.length > 0) {
+        const avgRecalledConf = recalled.reduce((s, r) => s + r.modulatedConfidence, 0) / recalled.length;
+        this.metaDna.mos.u = Math.max(0.01, this.metaDna.mos.u * (0.7 + (1 - avgRecalledConf) * 0.3));
+        if (activePathwayIds.includes("p_EpistemicVal") && this.dma.state) {
+          this.dma.state.delta = (this.dma.state.delta || 0) * 0.6;
+        }
+        if (activePathwayIds.includes("p_CogPlanning") && this.mcp.metaState) {
+          this.mcp.metaState.q = Math.min(0.99, (this.mcp.metaState.q || 0.5) + 0.01 * avgRecalledConf);
+        }
+        this.episodicMemory.useRecalled(recalled);
+      }
+    }
+    if (activePathwayIds.includes("p_EpistemicVal") && (memoryPressure > 0.3 || highErrorTraces.length > 2)) {
+      if (this.mcp.metaState) {
+        this.mcp.metaState.r = Math.max(0.02, (this.mcp.metaState.r || 0.4) * 0.45);
+      }
+      this.metaDna.mos.u = Math.max(0.01, this.metaDna.mos.u * 0.65);
+      const d = this.dma.state;
+      if (d) d.delta = (d.delta || 0) * 0.4;
+    }
+    if (activePathwayIds.includes("p_TimeMgmt") && plasticity > 0.55) {
+      const d = this.dma.state;
+      if (d && d.tauM) {
+        d.tauM = Math.max(12, d.tauM * 0.88);
+      }
+    }
+    if (activePathwayIds.includes("p_CogPlanning") && stats.avgOutcome < 0.55) {
+      if (this.mcp.metaState) {
+        this.mcp.metaState.q = Math.min(0.99, (this.mcp.metaState.q || 0.5) + 0.025);
+      }
+    }
+    const metamem = this.substrate.getMetamemorySnapshot();
+    this.metaDna.mos["metamemory"] = metamem;
+    if (metamem.avgConfidence < 0.4 || metamem.itemCount > 20) {
+      this.metaDna.mos.u = Math.min(1, this.metaDna.mos.u + 0.02);
+      this.metaDna.epigenetic.UncMon = Math.min(1, this.metaDna.epigenetic.UncMon + 0.01);
+    }
+    const semAct = this.semanticMemory.getStats ? this.semanticMemory.getStats().avgActivation : 0.7;
+    const algOver = this.lastAlg1Overhead || 0;
+    if (semAct < 0.5) {
+      this.metaDna.mos.u = Math.min(1, this.metaDna.mos.u + 0.025);
+    }
+    if (algOver > 0.012 && this.workingMemory.getLoad() > 0.6) {
+      this.metaDna.mos.l = Math.min(1, this.metaDna.mos.l + 0.03);
+    }
+  }
+  /**
+   * Dispatch concrete effects based on the MCP chosen meta-action.
+   * This turns MCP from a passive observer/calculator into an active controller
+   * that affects the substrate and lower layers (addressing a major gap from the original analysis).
+   */
+  dispatchMCPAction(action) {
+    const stats = this.substrate.getStats();
+    switch (action) {
+      case "VERIFY":
+        if (this.mcp.metaState) {
+          this.mcp.metaState.r = Math.max(0.03, (this.mcp.metaState.r || 0.4) * 0.55);
+        }
+        this.metaDna.mos.u = Math.max(0.02, this.metaDna.mos.u * 0.82);
+        this.episodicMemory.consolidate(0.15);
+        const verified = this.episodicMemory.retrieve(this.dma.state.delta || 0, this.substrate.getPlasticityBias(), 3);
+        this.episodicMemory.useRecalled(verified);
+        break;
+      case "REQUEST":
+        const pressure = this.substrate.getMemoryPressure();
+        const recalledForRequest = this.episodicMemory.retrieve(this.dma.state.delta || 0, this.substrate.getPlasticityBias(), 2);
+        if (recalledForRequest.length > 0) {
+          const avgConf = recalledForRequest.reduce((s, r) => s + r.modulatedConfidence, 0) / recalledForRequest.length;
+          this.metaDna.mos.u = Math.max(0.02, this.metaDna.mos.u * (0.55 - (1 - avgConf) * 0.15));
+          this.episodicMemory.useRecalled(recalledForRequest);
+        } else {
+          this.metaDna.mos.u = Math.max(0.02, this.metaDna.mos.u * (0.6 - pressure * 0.2));
+        }
+        if (this.mcp.metaState) {
+          this.mcp.metaState.r = Math.max(0.03, (this.mcp.metaState.r || 0.4) * 0.7);
+        }
+        break;
+      case "SWITCH":
+        this.workingMemory.clear();
+        const highError = this.episodicMemory.retrieve ? this.episodicMemory.retrieve(0, 0.8, 4) : [];
+        if (highError.length > 0) {
+          this.metaDna.mos.l = Math.max(0.05, this.metaDna.mos.l * 0.75);
+        }
+        const dSwitch = this.dma.state;
+        if (dSwitch && dSwitch.tauM) dSwitch.tauM = Math.min(45, dSwitch.tauM + 4);
+        break;
+      case "CONTINUE":
+        if (stats.avgOutcome > 0.6) {
+          this.episodicMemory.consolidate ? this.episodicMemory.consolidate(0.08) : this.substrate.consolidate(0.08);
+        }
+        break;
+      case "STOP":
+        this.episodicMemory.consolidate ? this.episodicMemory.consolidate(0.12) : this.substrate.consolidate(0.12);
+        break;
+      // CARINA12 rich MetaActions (plan §4): EXPLAIN / REALLOCATE / MODULATE style (robust even if MCP simulator emits base set)
+      case "EXPLAIN":
+        this.metaDna.mos.z = Math.min(1, this.metaDna.mos.z + 0.025);
+        this.workingMemory.add({ type: "imaginal", explain: "self-trace", at: this.stepCount }, "imaginal");
+        break;
+      case "REALLOCATE":
+        this.workingMemory.clear("retrieval");
+        const dRe = this.dma.state;
+        if (dRe && dRe.tauM) dRe.tauM = Math.min(45, dRe.tauM + 3);
+        this.metaDna.mos.l = Math.max(0.05, this.metaDna.mos.l * 0.82);
+        break;
+      // Additional rich directives inspired by CARINA12 plan (even if not chosen by current MCP, exposed for future)
+      case "CONSOLIDATE":
+        this.episodicMemory.consolidate ? this.episodicMemory.consolidate(0.2) : this.substrate.consolidate(0.2);
+        this.metaDna.mos.z = Math.min(1, this.metaDna.mos.z + 0.02);
+        break;
+      case "TUNE_DMA":
+        const dState = this.dma.state;
+        if (dState && dState.tauM) {
+          dState.tauM = Math.max(12, Math.min(45, dState.tauM * 0.9));
+        }
+        this.episodicMemory.consolidate ? this.episodicMemory.consolidate(0.15) : this.substrate.consolidate(0.15);
+        this.metaDna.mos.z = Math.min(1, this.metaDna.mos.z + 0.02);
+        this.metaDna.mos.u = Math.max(0.01, this.metaDna.mos.u * 0.78);
+        if (this.mcp.metaState) this.mcp.metaState.q = Math.min(0.99, (this.mcp.metaState.q || 0.5) + 0.015);
+        if (this.semanticMemory && typeof this.semanticMemory.retrieve === "function") {
+          const tuned = this.semanticMemory.retrieve({ type: "chunk" });
+          if (tuned && tuned.length) {
+          }
+        }
+        break;
+    }
+  }
+  // Epigenetic persistence (CARINA12: "epigenetic persistence across episodes/runs")
+  serializeEpigenetics() {
+    return { epigenetic: { ...this.metaDna.epigenetic }, tfs: { ...this.metaDna.tfs }, timestamp: Date.now() };
+  }
+  deserializeEpigenetics(data) {
+    if (!data) return;
+    if (data.epigenetic) this.metaDna.epigenetic = { ...this.metaDna.epigenetic, ...data.epigenetic };
+    if (data.tfs) this.metaDna.tfs = { ...this.metaDna.tfs, ...data.tfs };
+  }
+  persistEpigenetics(storage = null) {
+    const data = this.serializeEpigenetics();
+    if (storage && typeof storage.setItem === "function") {
+      storage.setItem("marina_epigenetics", JSON.stringify(data));
+    } else if (typeof localStorage !== "undefined") {
+      localStorage.setItem("marina_epigenetics", JSON.stringify(data));
+    } else {
+      if (process?.env?.MARINA_DEBUG_PERSIST) {
+        console.log("[Marina] Epigenetics snapshot (provide storage):", data);
+      }
+    }
+  }
+  restoreEpigenetics(storage = null) {
+    let raw = null;
+    if (storage && typeof storage.getItem === "function") raw = storage.getItem("marina_epigenetics");
+    else if (typeof localStorage !== "undefined") raw = localStorage.getItem("marina_epigenetics");
+    if (raw) {
+      try {
+        this.deserializeEpigenetics(JSON.parse(raw));
+      } catch (e) {
+      }
+    }
+  }
+  /**
+   * Advance the entire integrated system by one step.
+   * This is the heart of the unified "Marina" cognitive cycle.
+   *
+   * Cycle (improved integration per CARINA12 + papers):
+   * 1. Advance low-level DMA (biophysical stability-plasticity)
+   * 2. Basic object WM buffers + perceptual + procedural match stub
+   * 3. Advance regulatory Meta-DNA (computes pathways from MoS + epigenetics)
+   * 4. Apply explicit Meta-DNA pathway modulations to DMA + MCP
+   * 5. Store DMA engram to Episodic + semantic chunk + use semantic under planning pathways
+   * 6. Advance MCP (uses updated signals)
+   * 7. Rich dispatching from MCP actions into substrate (CONSOLIDATE/TUNE_DMA/VERIFY/...)
+   * 8. Legacy trace + substrate influence (pathways retrieve/use engrams + metamemory -> MoS)
+   *
+   * Meta-DNA regulator approximates Algorithm 1 (BICA paper / CARINA12 plan):
+   *   - epigenetic pre-update (α≈0.25 χi(t)), TF decay, gene expression gating Φi,
+   *   - co-expression Rk → ηk pathways, ε/η modulations to WM/LTM/DMA/MCP.
+   *   Overhead + full state update + P1-P4 (modularity/composability/decay/adaptation) are
+   *   demonstrable via the gene/pathway logs + ablation in getSelfAudit + substrate stats.
+   *   (Exact reference implementation remains in the high-fidelity simulators; this unifies them.)
+   */
+  step(options) {
+    this.stepCount += 1;
+    const result = {};
+    let retrievalBias = 0;
+    if (options?.dmaManualRegime !== void 0) {
+      result.dma = this.dma.step(options.dmaManualRegime);
+    } else {
+      result.dma = this.dma.step();
+    }
+    const plasticity = this.substrate.getPlasticityBias();
+    const preSemHits = this.semanticMemory.retrieve ? this.semanticMemory.retrieve({ step: this.stepCount }, plasticity, 1) : [];
+    if (preSemHits.length > 0) retrievalBias += (preSemHits[0]?.effectiveActivation || 0.5) * 0.3;
+    const preRecalled = this.episodicMemory.retrieve ? this.episodicMemory.retrieve(0, plasticity, 1) : [];
+    if (preRecalled.length > 0) {
+      const avg = preRecalled.reduce((s, r) => s + r.modulatedConfidence, 0) / preRecalled.length;
+      retrievalBias += avg * 0.2;
+    }
+    retrievalBias = Math.max(-0.4, Math.min(0.4, retrievalBias));
+    this.lastRetrievalBias = retrievalBias;
+    this.semanticMemory.store({ type: "perception", data: { step: this.stepCount, dma: result.dma ? { ...result.dma } : {} }, activation: 0.6 + Math.abs(retrievalBias) * 0.2 });
+    const prodsForProposal = this.proceduralMemory.matchConflictSet({ dma: result.dma, uncertainty: this.metaDna.mos.u, retrievalBias });
+    let proposedAction = prodsForProposal.length > 0 ? (prodsForProposal[0].utility || 0.5) * 3 : null;
+    if (proposedAction != null && retrievalBias) {
+      proposedAction = Math.max(0, Math.min(2, proposedAction + retrievalBias * 2));
+    }
+    this.lastRetrievalBias = retrievalBias;
+    this.lastProposedAction = proposedAction;
+    const taskResult = this.task.getOutcome({
+      step: this.stepCount,
+      lastAction: null,
+      dmaState: this.dma.state,
+      proposedAction,
+      retrievalBias
+    });
+    const taskOutcome = taskResult.reward;
+    if (this.stepCount % 7 === 1) {
+      this.workingMemory.add({ type: "goal", content: "maximize long-term reward while controlling uncertainty", priority: 0.9 }, "goal");
+    }
+    this.workingMemory.add({
+      step: this.stepCount,
+      dmaSnapshot: { ...this.dma.state },
+      outcome: taskOutcome,
+      taskInfo: taskResult.info
+    }, "imaginal");
+    this.workingMemory.add({ type: "perceptual", data: result.dma ? { ...result.dma } : {}, taskInfo: taskResult.info }, "perceptual");
+    let prods = this.proceduralMemory.matchConflictSet({ dma: result.dma, uncertainty: this.metaDna.mos.u, taskInfo: taskResult.info, retrievalBias });
+    if (prods.length === 0) {
+      prods = this.proceduralMemory.matchConflictSet({});
+    }
+    if (prods.length > 0) {
+      const winner = prods[0];
+      const fireEffect = this.proceduralMemory.fire(winner, { outcome: taskOutcome, u: this.metaDna.mos.u, taskInfo: taskResult.info });
+      this.productionsFired++;
+      if (fireEffect.riskDelta && this.mcp.metaState) {
+        this.mcp.metaState.r = Math.max(0.02, (this.mcp.metaState.r || 0.4) + fireEffect.riskDelta);
+      }
+      if (fireEffect.satisfactionDelta) {
+        this.metaDna.mos.z = Math.min(1, this.metaDna.mos.z + fireEffect.satisfactionDelta);
+      }
+      if (fireEffect.tauDelta && this.dma.state?.tauM) {
+        this.dma.state.tauM = Math.max(12, Math.min(45, this.dma.state.tauM + fireEffect.tauDelta));
+      }
+      this.workingMemory.add({ type: "motor", production: winner.name, effect: fireEffect, atStep: this.stepCount }, "motor");
+    } else {
+      this.productionsFired++;
+      this.workingMemory.add({ type: "motor", production: "DefaultContinue", atStep: this.stepCount }, "motor");
+    }
+    result.metaDna = this.metaDna.step(options?.dnaRegime);
+    const activePathwayIds = this.metaDna.pathways.filter((p) => p.active).map((p) => p.id);
+    this.applyMetaDNAModulations(activePathwayIds);
+    this.applyAlgorithm1Regulation(activePathwayIds);
+    const engram = {
+      step: this.stepCount,
+      dma: {
+        gHCN: this.dma.state.gHCN,
+        tauM: this.dma.state.tauM,
+        delta: this.dma.state.delta,
+        Vb: [...this.dma.state.Vb]
+      },
+      outcome: taskOutcome,
+      confidence: 0.6 + (1 - Math.abs(this.dma.state.delta || 0)) * 0.25
+    };
+    this.episodicMemory.store(engram);
+    this.semanticMemory.store({ type: "chunk", data: { outcome: taskOutcome, dma: { ...this.dma.state } }, activation: 0.7 });
+    const semHits = this.semanticMemory.retrieve ? this.semanticMemory.retrieve({ outcome: taskOutcome }, plasticity, 2) : [];
+    if (semHits.length > 0) {
+      this.workingMemory.add({ type: "retrieval", from: "semantic", hits: semHits.length, avgAct: semHits[0]?.effectiveActivation }, "retrieval");
+      if (this.mcp.metaState) this.mcp.metaState.q = Math.min(0.99, (this.mcp.metaState.q || 0.5) + 6e-3);
+      retrievalBias += (semHits[0]?.effectiveActivation || 0.5) * 0.4;
+    }
+    if (activePathwayIds.includes("p_EpistemicVal") || activePathwayIds.includes("p_CogPlanning")) {
+      const recalled = this.episodicMemory.retrieve(this.dma.state.delta || 0, plasticity, 2);
+      if (recalled.length > 0) {
+        const avgRecConf = recalled.reduce((s, r) => s + r.modulatedConfidence, 0) / recalled.length;
+        this.workingMemory.add({ type: "retrieval", from: "episodic", confidence: avgRecConf }, "retrieval");
+        this.metaDna.mos.u = Math.max(0.01, this.metaDna.mos.u * (0.78 + (1 - avgRecConf) * 0.18));
+        this.episodicMemory.useRecalled(recalled);
+        retrievalBias += avgRecConf * 0.3;
+      }
+    }
+    retrievalBias = Math.max(-0.5, Math.min(0.5, retrievalBias));
+    this.lastRetrievalBias = retrievalBias;
+    if (options?.forceMcpStep !== false) {
+      result.mcp = this.mcp.step();
+    }
+    if (result.mcp && result.mcp.chosenAction) {
+      this.dispatchMCPAction(result.mcp.chosenAction);
+      this.applyMCPFeedbackToRegulator(result.mcp.chosenAction);
+    }
+    this.recordExperience(result.dma, taskOutcome);
+    this.applySubstrateInfluence();
+    this.history.push({
+      step: this.stepCount,
+      ...result,
+      activePathways: activePathwayIds,
+      mcpAction: result.mcp ? result.mcp.chosenAction : void 0
+    });
+    return result;
+  }
+  /**
+   * Convenience: run N steps and return the array of per-step results.
+   * Matches the Python API and the documented public surface.
+   */
+  runEpisode(steps = 100) {
+    const results = [];
+    for (let i = 0; i < steps; i++) {
+      results.push(this.step());
+    }
+    return results;
+  }
+  /**
+   * Get the current combined state of the single unified system.
+   * This is the canonical view for all consumers (UI, CLI, persistence, future substrate).
+   */
+  getCombinedState() {
+    return {
+      step: this.stepCount,
+      dma: { ...this.dma.state },
+      metaDna: {
+        mos: { ...this.metaDna.mos },
+        tfs: { ...this.metaDna.tfs },
+        epigenetic: { ...this.metaDna.epigenetic },
+        genes: this.metaDna.genes.map((g) => ({ ...g })),
+        pathways: this.metaDna.pathways.map((p) => ({ ...p }))
+      },
+      mcp: {
+        metaState: { ...this.mcp.metaState },
+        weights: { ...this.mcp.weights },
+        backendType: this.mcp.backendType
+      },
+      // Richer cognitive substrate (WM + Episodic with DMA engrams) — CARINA12 aligned
+      substrate: {
+        workingMemoryLoad: this.workingMemory.getLoad(),
+        workingMemoryItems: this.workingMemory.getItems().length,
+        goalBuffer: this.workingMemory.getBuffer ? this.workingMemory.getBuffer("goal").length : 0,
+        retrievalBuffer: this.workingMemory.getBuffer ? this.workingMemory.getBuffer("retrieval").length : 0,
+        episodicEngrams: this.episodicMemory.getStats ? this.episodicMemory.getStats().count : 0,
+        semanticChunks: this.semanticMemory.getStats ? this.semanticMemory.getStats().count : 0,
+        semanticAvgActivation: this.semanticMemory.getStats ? this.semanticMemory.getStats().avgActivation : 0,
+        proceduralProductions: this.proceduralMemory.getStats ? this.proceduralMemory.getStats().count : 0,
+        proceduralFired: this.productionsFired,
+        metamemory: this.substrate.getMetamemorySnapshot(),
+        // Legacy for compatibility
+        legacyTraceCount: this.substrate.getAll().length,
+        plasticityBias: this.substrate.getPlasticityBias(),
+        memoryPressure: this.substrate.getMemoryPressure(),
+        alg1Overhead: this.lastAlg1Overhead
+      },
+      lastDispatch: this.getLastDispatchEffects(),
+      selfAudit: this.getSelfAudit(),
+      epistemicMirror: this.getEpistemicMirrorSignals()
+    };
+  }
+  /**
+   * Public helper: returns current substrate statistics (experience count + averages).
+   * Useful for external consumers and persistence demos.
+   */
+  getSubstrateStats() {
+    const sem = this.semanticMemory.getStats ? this.semanticMemory.getStats() : { count: 0, avgActivation: 0 };
+    const proc = this.proceduralMemory.getStats ? this.proceduralMemory.getStats() : { count: 0, fired: 0 };
+    return {
+      ...this.substrate.getStats(),
+      workingMemoryLoad: this.workingMemory.getLoad(),
+      episodicEngrams: this.episodicMemory.getStats ? this.episodicMemory.getStats().count : 0,
+      semanticChunks: sem.count,
+      semanticAvgActivation: sem.avgActivation,
+      proceduralProductions: proc.count,
+      productionsFired: this.productionsFired,
+      alg1Overhead: this.lastAlg1Overhead
+    };
+  }
+  /**
+   * Convenience: perform a retrieval from the unified episodic memory (for research / package users).
+   */
+  retrieveFromSubstrate(contextDelta = 0, count = 3) {
+    const plasticity = this.substrate.getPlasticityBias();
+    return this.episodicMemory.retrieve(contextDelta, plasticity, count);
+  }
+  /**
+   * Returns a summary of the most recent MCP dispatch effects and substrate influence.
+   * This makes the "one system with active memory and control" observable.
+   */
+  getLastDispatchEffects() {
+    if (this.history.length === 0) return null;
+    const last = this.history[this.history.length - 1];
+    const stats = this.substrate.getStats();
+    return {
+      step: last.step,
+      mcpAction: last.mcpAction,
+      activePathways: last.activePathways || [],
+      substrateAfter: {
+        experiences: stats.count,
+        plasticityBias: this.substrate.getPlasticityBias(),
+        memoryPressure: this.substrate.getMemoryPressure()
+      }
+    };
+  }
+  /**
+   * Self-audit aligned with IM-Onto concepts (from papers).
+   * Maps current unified state (MoS + rich substrate: semantic activation, procedural stats, WM buffers + Algorithm 1 overhead) to metacognitive problem classes (KTP, DRFP, ADTP).
+   * Enriched with CARINA12 substrate + regulator signals for more accurate problem detection.
+   * This is a key bridge so IM-Onto is no longer an isolated explorer.
+   */
+  getSelfAudit() {
+    const mos = this.metaDna.mos;
+    const pressure = this.substrate.getMemoryPressure();
+    const plasticity = this.substrate.getPlasticityBias();
+    const dispatch = this.getLastDispatchEffects();
+    const u = mos.u;
+    const r = this.mcp.metaState?.r ?? 0;
+    const metamemory = mos.metamemory || this.substrate.getMetamemorySnapshot();
+    const semStats = this.semanticMemory.getStats ? this.semanticMemory.getStats() : { avgActivation: 0.6, count: 0 };
+    const procStats = this.proceduralMemory.getStats ? this.proceduralMemory.getStats() : { avgUtility: 0.5, fired: 0 };
+    const alg1Over = this.lastAlg1Overhead || 0;
+    const semanticActivation = semStats.avgActivation || 0.6;
+    const productionsFired = this.productionsFired || 0;
+    const problems = [];
+    if (u > 0.55 && pressure > 0.35) {
+      const confPenalty = 1 - (metamemory.avgConfidence || 0.5);
+      problems.push({
+        id: "KTP",
+        name: "Knowledge_Test_Problem",
+        severity: Math.min(1, (u + pressure + confPenalty) / 2.2),
+        justification: "High epistemic uncertainty combined with substrate memory pressure and low recalled confidence (metamemory) suggests gaps in knowledge or need for verification (IM-Onto KTP)."
+      });
+    }
+    if (semanticActivation < 0.55 || alg1Over > 0.015 && productionsFired < 3) {
+      problems.push({
+        id: "KTP",
+        name: "Knowledge_Test_Problem",
+        severity: Math.min(1, 1 - semanticActivation + alg1Over * 20 + (productionsFired < 5 ? 0.2 : 0)),
+        justification: "Low semantic memory activation (weak spreading/declarative traces) combined with high regulatory overhead or low procedural firing indicates gaps in consolidated knowledge or inefficient reasoning traces (IM-Onto KTP)."
+      });
+    }
+    if (r > 0.5 || dispatch && dispatch.substrateAfter.memoryPressure > 0.4) {
+      problems.push({
+        id: "DRFP",
+        name: "Detection_of_Reasoning_Failure_Problem",
+        severity: Math.min(1, r + (dispatch?.substrateAfter.memoryPressure ?? 0) * 0.5),
+        justification: "Elevated risk or memory pressure from past high-delta experiences indicates potential reasoning anomalies or need for trace monitoring (IM-Onto DRFP)."
+      });
+    }
+    if (alg1Over > 0.012 && mos.l > 0.55 || procStats.avgUtility < 0.4 && productionsFired > 5) {
+      problems.push({
+        id: "DRFP",
+        name: "Detection_of_Reasoning_Failure_Problem",
+        severity: Math.min(1, alg1Over * 30 + (1 - (procStats.avgUtility || 0.5))),
+        justification: "Elevated Algorithm 1 regulatory overhead with high cognitive load or low average procedural utility despite activity suggests possible reasoning failures or inefficient production selection (IM-Onto DRFP)."
+      });
+    }
+    if (mos.l > 0.6 && mos.z < 0.6) {
+      problems.push({
+        id: "ADTP",
+        name: "Allocating_Deliberation_Time_Problem",
+        severity: Math.min(1, (mos.l + (1 - mos.z)) / 2),
+        justification: "Sustained cognitive load with declining satisfaction suggests suboptimal deliberation time allocation (IM-Onto ADTP)."
+      });
+    }
+    if (alg1Over > 0.01 && this.workingMemory.getLoad() > 0.65) {
+      problems.push({
+        id: "ADTP",
+        name: "Allocating_Deliberation_Time_Problem",
+        severity: Math.min(1, alg1Over * 25 + this.workingMemory.getLoad() * 0.6),
+        justification: "High per-cycle regulatory overhead combined with elevated working memory load indicates excessive deliberation time or inefficient meta-regulation (IM-Onto ADTP)."
+      });
+    }
+    const modelOfSelf = {
+      uncertainty: mos.u,
+      load: mos.l,
+      performance: mos.p,
+      energy: mos.e,
+      satisfaction: mos.z,
+      memoryPressure: pressure,
+      plasticityBias: plasticity,
+      recentMCPAction: dispatch?.mcpAction ?? null,
+      metamemory,
+      // New rich signals from CARINA12 substrate + Algorithm 1
+      semanticAvgActivation: semanticActivation,
+      semanticChunks: semStats.count || 0,
+      proceduralAvgUtility: procStats.avgUtility || 0,
+      productionsFired,
+      alg1Overhead: alg1Over,
+      workingMemoryLoad: this.workingMemory.getLoad(),
+      goalBufferItems: this.workingMemory.getBuffer ? this.workingMemory.getBuffer("goal").length : 0
+    };
+    return {
+      problems,
+      modelOfSelf,
+      timestamp: this.stepCount
+    };
+  }
+  /**
+   * Epistemic mirror signals inspired by CMT (CARINA Mirror Test / AMFs).
+   * Provides simple MET-1 (ignorance detection), MET-3 (epistemic utility) style signals
+   * derived from the unified state. Allows CMT scenarios to be evaluated against the actual agent.
+   */
+  getEpistemicMirrorSignals() {
+    const u = this.metaDna.mos.u;
+    const r = this.mcp.metaState?.r ?? 0;
+    const pressure = this.substrate.getMemoryPressure();
+    const avgOutcome = this.substrate.getStats().avgOutcome ?? 0.5;
+    const dispatch = this.getLastDispatchEffects();
+    const semAct = this.semanticMemory.getStats ? this.semanticMemory.getStats().avgActivation || 0.6 : 0.6;
+    const alg1 = this.lastAlg1Overhead || 0;
+    const prodFired = this.productionsFired || 0;
+    const wmLoad = this.workingMemory.getLoad();
+    const ignoranceDetection = u > 0.6 || pressure > 0.45 || semAct < 0.5 ? "NO" : "YES";
+    const ignoranceConfidence = Math.max(0, Math.min(1, 1 - (u + pressure + (1 - semAct)) / 3));
+    const epistemicUtility = r > 0.55 || avgOutcome < 0.45 || alg1 > 0.015 && prodFired < 4 ? "Null" : "Positive";
+    const utilityScore = Math.max(0, Math.min(1, (1 - r) * (avgOutcome + 0.3) * (alg1 > 0.012 ? 0.7 : 1)));
+    const traceFidelity = dispatch && dispatch.activePathways.length > 1 ? 0.75 : Math.max(0.3, 0.5 + (1 - pressure) * 0.3 - (1 - semAct) * 0.4 - alg1 * 10);
+    return {
+      MET1_ignoranceDetection: ignoranceDetection,
+      MET1_confidence: Number(ignoranceConfidence.toFixed(3)),
+      MET3_epistemicUtility: epistemicUtility,
+      MET3_utilityScore: Number(utilityScore.toFixed(3)),
+      traceFidelity: Number(traceFidelity.toFixed(3)),
+      overallEpistemicRisk: Number(r.toFixed(3)),
+      substrateMemoryPressure: Number(pressure.toFixed(3)),
+      semanticHealth: Number(semAct.toFixed(3)),
+      regulatoryOverhead: Number(alg1.toFixed(4)),
+      recommendedAction: ignoranceDetection === "NO" || epistemicUtility === "Null" ? "REQUEST or VERIFY" : "CONTINUE or STOP"
+    };
+  }
+  /**
+   * Returns a compact summary for UI dashboards and persistence.
+   * This represents the "integrated state" of the single Marina system.
+   */
+  getSummary() {
+    const state = this.getCombinedState();
+    const activePathways = state.metaDna.pathways.filter((p) => p.active).map((p) => p.name);
+    const lastAction = this.history.length > 0 ? this.history[this.history.length - 1].mcpAction : null;
+    const subStats = this.substrate.getStats();
+    const epiStats = this.episodicMemory && this.episodicMemory.getStats ? this.episodicMemory.getStats() : { count: 0, avgOutcome: 0 };
+    const expCount = subStats.count || epiStats.count || state.substrate.legacyTraceCount || 0;
+    const avgOut = typeof subStats.avgOutcome === "number" && subStats.avgOutcome > 0 ? subStats.avgOutcome : epiStats.avgOutcome || 0;
+    const semStats = this.semanticMemory.getStats ? this.semanticMemory.getStats() : { count: 0, avgActivation: 0 };
+    const procStats = this.proceduralMemory.getStats ? this.proceduralMemory.getStats() : { fired: 0, avgUtility: 0 };
+    return {
+      step: state.step,
+      uncertainty: state.metaDna.mos.u,
+      load: state.metaDna.mos.l,
+      performance: state.metaDna.mos.p,
+      energy: state.metaDna.mos.e,
+      satisfaction: state.metaDna.mos.z,
+      activePathways,
+      currentMcpAction: state.mcp.metaState ? "running" : "idle",
+      lastMCPAction: lastAction,
+      dmaGHCN: state.dma.gHCN,
+      dmaTauM: state.dma.tauM,
+      dmaBeta: state.dma.beta,
+      mcpQuality: state.mcp.metaState?.q ?? 0,
+      mcpRisk: state.mcp.metaState?.r ?? 0,
+      substrateExperiences: expCount,
+      substrateAvgOutcome: Number(avgOut.toFixed ? avgOut.toFixed(3) : avgOut) || 0,
+      substrateAvgTauM: subStats.avgTauM ?? 12,
+      substratePlasticityBias: this.substrate.getPlasticityBias(),
+      substrateMemoryPressure: this.substrate.getMemoryPressure(),
+      lastDispatch: this.getLastDispatchEffects(),
+      selfAuditProblems: this.getSelfAudit().problems.length,
+      epistemicUtility: this.getEpistemicMirrorSignals().MET3_epistemicUtility,
+      workingMemoryLoad: this.workingMemory.getLoad(),
+      workingMemoryItems: this.workingMemory.getItems().length,
+      episodicEngrams: epiStats.count || 0,
+      metamemoryAvgConfidence: this.substrate.getMetamemorySnapshot().avgConfidence,
+      // CARINA12 plan-aligned substrate metrics (new this round)
+      semanticChunks: semStats.count || 0,
+      semanticAvgActivation: semStats.avgActivation || 0,
+      proceduralProductions: procStats.count || 0,
+      proceduralAvgUtility: procStats.avgUtility || 0,
+      productionsFired: this.productionsFired,
+      alg1Overhead: this.lastAlg1Overhead || 0,
+      goalBufferItems: this.workingMemory.getBuffer ? this.workingMemory.getBuffer("goal").length : 0,
+      taskType: this.task instanceof DefaultBanditTask ? "internal-bandit" : "custom",
+      lastRetrievalBias: this.lastRetrievalBias || 0,
+      lastProposedAction: this.lastProposedAction
+    };
+  }
+  /**
+   * Serialize the key persistent parts (especially epigenetic traces + minimal substrate)
+   * for saving across sessions (cognitive "development").
+   * Extended to include episodic engrams + WM snapshot (CARINA12 epigenetic + bio-plasticity persistence).
+   */
+  serialize() {
+    const epiStats = this.episodicMemory.getStats ? this.episodicMemory.getStats() : { count: 0 };
+    return {
+      stepCount: this.stepCount,
+      metaDna: {
+        mos: { ...this.metaDna.mos },
+        epigenetic: { ...this.metaDna.epigenetic },
+        genes: this.metaDna.genes.map((g) => ({ id: g.id, expressed: g.expressed }))
+      },
+      mcp: {
+        metaState: { ...this.mcp.metaState },
+        weights: { ...this.mcp.weights }
+      },
+      // Substrate seed (epigenetic + DMA-tagged experiences + engrams + WM + semantic/procedural) for CARINA12 "cognitive development"
+      substrate: {
+        traces: this.substrate.getAll(),
+        episodicEngrams: this.episodicMemory ? this.episodicMemory.engrams || [] : [],
+        semanticSample: this.semanticMemory ? this.semanticMemory.chunks?.slice(-4) || [] : [],
+        proceduralSample: this.proceduralMemory ? this.proceduralMemory.productions?.slice(-3) || [] : [],
+        workingMemoryLoad: this.workingMemory.getLoad(),
+        workingMemorySample: this.workingMemory.getItems().slice(-3),
+        productionsFired: this.productionsFired
+      }
+    };
+  }
+  /**
+   * Restore from a previously serialized state (loads epigenetic memory + substrate traces).
+   */
+  deserialize(data) {
+    if (!data) return;
+    this.stepCount = data.stepCount ?? 0;
+    if (data.metaDna) {
+      if (data.metaDna.mos) this.metaDna.mos = { ...this.metaDna.mos, ...data.metaDna.mos };
+      if (data.metaDna.epigenetic) this.metaDna.epigenetic = { ...this.metaDna.epigenetic, ...data.metaDna.epigenetic };
+      if (data.metaDna.genes) {
+        data.metaDna.genes.forEach((g) => {
+          const gene = this.metaDna.genes.find((gg) => gg.id === g.id);
+          if (gene) gene.expressed = g.expressed;
+        });
+      }
+    }
+    if (data.mcp) {
+      if (data.mcp.metaState) this.mcp.metaState = { ...this.mcp.metaState, ...data.mcp.metaState };
+      if (data.mcp.weights) this.mcp.weights = { ...this.mcp.weights, ...data.mcp.weights };
+    }
+    if (data.substrate && data.substrate.traces && Array.isArray(data.substrate.traces)) {
+      this.substrate.clear();
+      data.substrate.traces.forEach((t) => {
+        this.substrate.record({ dma: t.dma, outcome: t.outcome }, t.step);
+      });
+    }
+    if (data.substrate && Array.isArray(data.substrate.episodicEngrams)) {
+      if (this.episodicMemory.clear) this.episodicMemory.clear();
+      data.substrate.episodicEngrams.forEach((e) => {
+        if (this.episodicMemory.store) this.episodicMemory.store(e);
+      });
+    }
+    if (data.substrate) {
+      if (typeof data.substrate.productionsFired === "number") this.productionsFired = data.substrate.productionsFired;
+      if (typeof data.substrate.alg1Overhead === "number") this.lastAlg1Overhead = data.substrate.alg1Overhead;
+    }
+  }
+  reset() {
+    this.dma.reset();
+    this.metaDna.reset();
+    this.mcp.reset();
+    this.workingMemory.clear();
+    this.episodicMemory.clear();
+    this.semanticMemory.clear();
+    this.proceduralMemory.clear();
+    this.substrate.clear();
+    this.stepCount = 0;
+    this.history = [];
+    this.productionsFired = 0;
+    this.lastAlg1Overhead = 0;
+    if (this.task && typeof this.task.reset === "function") {
+      this.task.reset();
+    }
+  }
+  /**
+   * Allow replacing the task/environment at runtime.
+   * This makes Marina usable for custom problems (major practical utility improvement).
+   */
+  setTask(task) {
+    this.task = task;
+    if (typeof task.reset === "function") task.reset();
+  }
+  /**
+   * Convenience factory: create a simple Task from a reward function.
+   * Greatly improves practical usability for quick experiments.
+   */
+  static createSimpleTask(rewardFn) {
+    return {
+      getOutcome(ctx) {
+        const res = rewardFn(ctx);
+        if (typeof res === "number") return { reward: res };
+        return res;
+      },
+      reset() {
+      }
+    };
+  }
+  /**
+   * Convenience: ask the procedural memory what it would do right now.
+   * Useful when using custom tasks.
+   */
+  proposeAction(context = {}) {
+    const prods = this.proceduralMemory.matchConflictSet(context);
+    return prods.length > 0 ? prods[0] : null;
+  }
+  /**
+   * Run a full evaluation on a (possibly custom) task and return rich statistics.
+   * This improves practical utility and maturity (benchmark-style runs with self-audit).
+   * options can include { includeHistory: boolean } for more detail.
+   */
+  evaluate(task = null, steps = 100, options = {}) {
+    const previousTask = this.task;
+    if (task) {
+      this.setTask(task);
+    }
+    const startStep = this.stepCount;
+    const results = this.runEpisode(steps);
+    const summary = this.getSummary();
+    const finalAudit = this.getSelfAudit();
+    const substrateSnapshot = this.getSubstrateStats();
+    if (task && previousTask) {
+      this.setTask(previousTask);
+    }
+    const base = {
+      steps,
+      startStep,
+      endStep: this.stepCount,
+      finalSummary: summary,
+      finalSelfAudit: finalAudit,
+      avgOutcome: summary.substrateAvgOutcome,
+      avgWMload: summary.workingMemoryLoad,
+      semanticAvgActivation: summary.semanticAvgActivation,
+      productionsFired: summary.productionsFired,
+      alg1Overhead: summary.alg1Overhead,
+      problemsDetected: finalAudit.problems.length,
+      problemTypes: finalAudit.problems.map((p) => p.id),
+      taskType: summary.taskType,
+      substrateSnapshot,
+      lastFewResults: results.slice(-3)
+    };
+    if (options.includeHistory) {
+      base.historySample = results.slice(-5);
+    }
+    return base;
+  }
+  /**
+   * Convenience: run an episode on a specific task without permanently changing the agent's task.
+   * Improves practical usability for quick experiments with different "environments".
+   */
+  runOnTask(task, steps = 100, options = {}) {
+    const prev = this.task;
+    this.setTask(task);
+    const res = this.runEpisode(steps);
+    const summary = this.getSummary();
+    if (prev) this.setTask(prev);
+    return { results: res, summary, taskType: "custom" };
+  }
+};
+export {
+  MarinaAgent
+};
+//# sourceMappingURL=MarinaAgent.js.map