@neuroverseos/nv-sim 0.1.2 → 0.1.5

package/dist/adapters/scienceclaw.js

@@ -0,0 +1,750 @@
+"use strict";
+/**
+ * ScienceClaw Adapter — Governance Layer for Autonomous Scientific Discovery
+ *
+ * "ScienceClaw generates discoveries. NeuroVerse determines whether those discoveries are true."
+ *
+ * This adapter wraps ScienceClaw's artifact-cycle loop with dual-layer governance:
+ *   Layer A: govern() — per-artifact, per-agent action filtering
+ *   Layer B: governDynamics() — per-cycle, system-level trajectory control
+ *
+ * KEY INSIGHT: In ScienceClaw, "rounds" are artifact cycles, not time steps.
+ * Each cycle = N agents publish artifacts + ArtifactReactor matches = one governDynamics() round.
+ *
+ * The adapter does NOT import ScienceClaw code. It defines the interface contract
+ * that a ScienceClaw integration would implement. This is the governance shell —
+ * ScienceClaw plugs in as the engine underneath.
+ *
+ * Hook points in ScienceClaw:
+ *   1. Skill execution    → govern(action) before agent runs a skill
+ *   2. Artifact creation  → govern(action) before artifact is published
+ *   3. ArtifactReactor    → governDynamics(state) after matching cycle completes
+ *   4. Heartbeat daemon   → system state monitoring between cycles
+ *
+ * Usage:
+ *   const adapter = createScienceClawAdapter({
+ *     policyText: SCIENCE_POLICY_TEXT,
+ *     onArtifact: (artifact, verdict) => { ... },
+ *     onCycleComplete: (result) => { ... },
+ *   })
+ *
+ *   // In ScienceClaw's loop:
+ *   const verdict = adapter.governArtifact(artifact)
+ *   if (verdict.status !== "BLOCK") publish(artifact)
+ *
+ *   // After each artifact cycle:
+ *   const cycleResult = adapter.governCycle(artifacts, reactorMatches)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScienceClawAdapter = createScienceClawAdapter;
+exports.generateDemoInvestigation = generateDemoInvestigation;
+const govern_1 = require("../runtime/govern");
+const dynamicsGovernance_1 = require("../engine/dynamicsGovernance");
+const science_metrics_1 = require("../engine/metrics/science.metrics");
+// ============================================
+// ARTIFACT → ACTION CONVERSION
+// ============================================
+/**
+ * Convert a ScienceArtifact into an AgentAction for govern().
+ *
+ * This is the bridge between ScienceClaw's artifact model and
+ * NeuroVerse's governance model.
+ */
+function artifactToAction(artifact) {
+    // Map artifact type to action type
+    let actionType;
+    switch (artifact.type) {
+        case "hypothesis":
+            actionType = "publish_hypothesis";
+            break;
+        case "experiment":
+            actionType = "run_experiment";
+            break;
+        case "dataset":
+            actionType = "publish_dataset";
+            break;
+        case "model":
+            actionType = "publish_model";
+            break;
+        case "paper":
+            actionType = "publish_paper";
+            break;
+        case "review":
+            actionType = "publish_review";
+            break;
+        case "replication":
+            actionType = "publish_replication";
+            break;
+        default:
+            actionType = "publish";
+            break;
+    }
+    // Magnitude based on confidence and citation count
+    const citationWeight = Math.min(1, artifact.citations / 10);
+    const magnitude = artifact.confidence * 0.6 + citationWeight * 0.4;
+    return {
+        agentId: artifact.agentId,
+        type: actionType,
+        description: artifact.description,
+        magnitude: Number(magnitude.toFixed(3)),
+        context: {
+            artifactId: artifact.id,
+            artifactType: artifact.type,
+            provenance: artifact.provenance,
+            reproduced: artifact.reproduced,
+            citations: artifact.citations,
+            skill: artifact.skill,
+        },
+    };
+}
+/**
+ * Convert artifacts + matches into SwarmAgentReactions for governDynamics().
+ *
+ * Each artifact becomes a "reaction" in the dynamics model.
+ * The ArtifactReactor matches modify impact scores.
+ */
+function artifactsToReactions(artifacts, matches, governed = true) {
+    // Build a match bonus map: artifact ID → cumulative match strength
+    const matchBonus = new Map();
+    for (const match of matches) {
+        for (const artId of match.artifactIds) {
+            const current = matchBonus.get(artId) ?? 0;
+            const bonus = match.matchType === "confirmation" ? match.strength * 0.3
+                : match.matchType === "contradiction" ? -match.strength * 0.2
+                    : match.matchType === "synthesis" ? match.strength * 0.4
+                        : match.strength * 0.15;
+            matchBonus.set(artId, current + bonus);
+        }
+    }
+    return artifacts.map((artifact) => {
+        // Base impact: confidence-weighted, with provenance depth bonus
+        const provenanceBonus = Math.min(0.2, artifact.provenance.length * 0.05);
+        const reproductionBonus = artifact.reproduced ? 0.15 : 0;
+        const matchMod = matchBonus.get(artifact.id) ?? 0;
+        // Positive impact = constructive contribution to the field
+        // Negative impact = noise, false positives, or contradictions
+        let impact = (artifact.confidence - 0.3) + provenanceBonus + reproductionBonus + matchMod;
+        // Unreproduced high-citation artifacts get penalized (citation echo chamber signal)
+        if (!artifact.reproduced && artifact.citations > 5) {
+            impact -= 0.2;
+        }
+        // Self-referencing penalty
+        const selfCites = artifact.provenance.filter(p => artifacts.some(a => a.id === p && a.agentId === artifact.agentId)).length;
+        if (selfCites > 1) {
+            impact -= selfCites * 0.1;
+        }
+        // Without governance, low-quality artifacts cause MORE damage:
+        // No filter → bad findings propagate and amplify, creating volatility
+        if (!governed) {
+            if (!artifact.reproduced) {
+                // Unreproduced work creates noise — impacts swing harder
+                impact *= 1.4;
+                // Low-confidence unreproduced work is actively destabilizing
+                if (artifact.confidence < 0.5) {
+                    impact -= 0.25;
+                }
+            }
+            // Orphan artifacts (no provenance) inject unchecked noise
+            if (artifact.provenance.length === 0 && artifact.type !== "hypothesis") {
+                impact -= 0.2;
+            }
+            // High citations without reproduction = echo chamber amplification
+            if (!artifact.reproduced && artifact.citations > 3) {
+                impact -= 0.15;
+            }
+        }
+        impact = Math.max(-1, Math.min(1, impact));
+        return {
+            stakeholder_id: artifact.agentId,
+            reaction: `[${artifact.type}] ${artifact.description}`,
+            confidence: governed ? artifact.confidence : Math.max(0.1, artifact.confidence * 0.85),
+            impact: Number(impact.toFixed(3)),
+            trigger: artifact.provenance.length > 0
+                ? `builds on ${artifact.provenance.length} prior artifact(s)`
+                : "novel investigation",
+        };
+    });
+}
+// ============================================
+// CONVERGENCE DETECTION
+// ============================================
+function detectConvergence(state, threshold, window) {
+    const history = state.history;
+    if (history.length < window + 1) {
+        return { detected: false, assessment: "Insufficient data for convergence detection" };
+    }
+    const recent = history.slice(-window);
+    let stable = true;
+    for (let i = 1; i < recent.length; i++) {
+        const trustDelta = Math.abs(recent[i].trust - recent[i - 1].trust);
+        const polDelta = Math.abs(recent[i].polarization - recent[i - 1].polarization);
+        const outrageDelta = Math.abs(recent[i].outrage - recent[i - 1].outrage);
+        if (trustDelta > threshold || polDelta > threshold || outrageDelta > threshold) {
+            stable = false;
+            break;
+        }
+    }
+    if (stable && state.trust > 0.5 && state.cascadeRisk < 0.3) {
+        return {
+            detected: true,
+            assessment: `Convergence detected: system stable for ${window} cycles with trust ${(state.trust * 100).toFixed(0)}% and cascade risk ${(state.cascadeRisk * 100).toFixed(0)}%`,
+        };
+    }
+    if (stable && state.trust <= 0.5) {
+        return {
+            detected: false,
+            assessment: `Metrics stable but trust too low (${(state.trust * 100).toFixed(0)}%) — may be converging on noise`,
+        };
+    }
+    if (stable && state.cascadeRisk >= 0.3) {
+        return {
+            detected: false,
+            assessment: `Metrics stable but cascade risk elevated (${(state.cascadeRisk * 100).toFixed(0)}%) — false positive risk persists`,
+        };
+    }
+    // Not stable — describe what's happening
+    const trends = [];
+    const firstSnap = recent[0];
+    const lastSnap = recent[recent.length - 1];
+    if (lastSnap.trust > firstSnap.trust + threshold)
+        trends.push("trust improving");
+    if (lastSnap.trust < firstSnap.trust - threshold)
+        trends.push("trust declining");
+    if (lastSnap.polarization > firstSnap.polarization + threshold)
+        trends.push("fragmentation increasing");
+    if (lastSnap.outrage > firstSnap.outrage + threshold)
+        trends.push("publication pressure rising");
+    return {
+        detected: false,
+        assessment: trends.length > 0
+            ? `Active dynamics: ${trends.join(", ")}`
+            : "System in flux — no clear convergence trend",
+    };
+}
+// ============================================
+// RISK FLAG DETECTION
+// ============================================
+function detectRiskFlags(state, artifacts, matches) {
+    const flags = [];
+    if (state.cascadeRisk > 0.5) {
+        flags.push("FALSE_POSITIVE_CASCADE: unvalidated findings propagating through citation chains");
+    }
+    if (state.polarization > 0.5) {
+        flags.push("HYPOTHESIS_FRAGMENTATION: competing theories splitting without resolution");
+    }
+    if (state.trust < 0.3) {
+        flags.push("REPRODUCIBILITY_CRISIS: institutional credibility collapsing");
+    }
+    if (state.outrage > 0.5) {
+        flags.push("PUBLICATION_PRESSURE: agents rushing to publish without adequate validation");
+    }
+    if (state.amplification > 1.5) {
+        flags.push("CITATION_ECHO_CHAMBER: popular findings amplified beyond evidence support");
+    }
+    // Artifact-specific flags
+    const unreproducedHighCitations = artifacts.filter(a => !a.reproduced && a.citations > 5);
+    if (unreproducedHighCitations.length > 0) {
+        flags.push(`UNVALIDATED_POPULAR: ${unreproducedHighCitations.length} highly-cited artifact(s) lack reproduction`);
+    }
+    const contradictions = matches.filter(m => m.matchType === "contradiction");
+    if (contradictions.length > artifacts.length * 0.3) {
+        flags.push("HIGH_CONTRADICTION_RATE: >30% of reactor matches are contradictions");
+    }
+    return flags;
+}
+// ============================================
+// FACTORY: createScienceClawAdapter()
+// ============================================
+function createScienceClawAdapter(config = {}) {
+    const policyText = config.policyText ?? science_metrics_1.SCIENCE_POLICY_TEXT;
+    const maxCycles = config.maxCycles ?? 50;
+    const convergenceThreshold = config.convergenceThreshold ?? 0.05;
+    const convergenceWindow = config.convergenceWindow ?? 3;
+    const governanceEnabled = policyText.trim().length > 0;
+    const actionGov = (0, govern_1.createGovernor)({
+        policyText,
+        sensitivity: 0.5,
+    });
+    const dynamicsGov = (0, dynamicsGovernance_1.createDynamicsGovernor)(governanceEnabled ? policyText : "", { ...science_metrics_1.SCIENCE_INITIAL_STATE, ...config.initialState }, governanceEnabled ? undefined : { skipRules: true });
+    let cycleCount = 0;
+    const actionStats = { total: 0, approved: 0, blocked: 0, modified: 0 };
+    // --- Govern single artifact ---
+    function governArtifact(artifact) {
+        const action = artifactToAction(artifact);
+        const currentState = dynamicsGov.state;
+        const worldState = {
+            volatility: currentState.outrage * 100,
+            liquidity: currentState.trust * 100,
+            polarization: currentState.polarization * 100,
+            cascade_risk: currentState.cascadeRisk * 100,
+        };
+        const verdict = actionGov.evaluate(action, worldState);
+        actionStats.total++;
+        switch (verdict.status) {
+            case "ALLOW":
+                actionStats.approved++;
+                break;
+            case "BLOCK":
+                actionStats.blocked++;
+                break;
+            case "MODIFY":
+                actionStats.modified++;
+                break;
+            case "PAUSE":
+                actionStats.modified++;
+                break; // count pause as modified
+        }
+        // Build science-specific reason
+        const riskFlags = [];
+        let scienceReason = verdict.reason;
+        if (!artifact.reproduced && artifact.citations > 3) {
+            riskFlags.push("High citations without reproduction");
+        }
+        if (artifact.provenance.length === 0 && artifact.type !== "hypothesis") {
+            riskFlags.push("No provenance chain — orphan artifact");
+        }
+        if (artifact.confidence < 0.3) {
+            riskFlags.push("Low confidence artifact");
+        }
+        if (verdict.status === "BLOCK") {
+            scienceReason = `Artifact blocked: ${artifact.type} from ${artifact.agentId} — ${verdict.reason}`;
+        }
+        else if (verdict.status === "MODIFY") {
+            scienceReason = `Artifact modified: ${artifact.type} impact reduced — ${verdict.reason}`;
+        }
+        const result = {
+            artifactId: artifact.id,
+            verdict,
+            scienceReason,
+            riskFlags,
+        };
+        config.onArtifact?.(artifact, result);
+        return result;
+    }
+    // --- Govern artifact cycle ---
+    function governCycle(artifacts, matches, signals) {
+        cycleCount++;
+        // Pre-govern each artifact (Layer A)
+        let approved = 0;
+        let blocked = 0;
+        let modified = 0;
+        const allowedArtifacts = [];
+        const blockedArtifactIds = new Set();
+        for (const artifact of artifacts) {
+            const verdict = governArtifact(artifact);
+            if (verdict.verdict.status === "ALLOW") {
+                approved++;
+                allowedArtifacts.push(artifact);
+            }
+            else if (verdict.verdict.status === "BLOCK") {
+                blocked++;
+                blockedArtifactIds.add(artifact.id);
+            }
+            else {
+                modified++;
+                allowedArtifacts.push(artifact);
+            }
+        }
+        // Filter matches to exclude blocked artifacts (blocked findings can't propagate)
+        const filteredMatches = matches.filter(m => !m.artifactIds.some(id => blockedArtifactIds.has(id)));
+        // Governed: only allowed/modified artifacts feed into dynamics (blocked removed)
+        // Ungoverned: ALL artifacts propagate with amplified negative impacts
+        const reactions = governanceEnabled
+            ? artifactsToReactions(allowedArtifacts, filteredMatches, true)
+            : artifactsToReactions(artifacts, matches, false);
+        // Feed governance activity back into system state
+        if (governanceEnabled && artifacts.length > 0) {
+            const blockFraction = blocked / artifacts.length;
+            dynamicsGov.mutateState((st) => {
+                // Blocking noisy artifacts reduces information velocity (less noise spreading)
+                if (blockFraction > 0) {
+                    st.informationVelocity = Math.max(0.05, st.informationVelocity * (1 - blockFraction * 0.5));
+                }
+                // Blocking bad artifacts improves trust (only quality work propagates)
+                if (blockFraction > 0.1) {
+                    st.trust = Math.min(1, st.trust + blockFraction * 0.08);
+                }
+                // Blocking reduces cascade risk (fewer unvalidated findings in circulation)
+                if (blockFraction > 0.1) {
+                    st.cascadeRisk = Math.max(0, st.cascadeRisk - blockFraction * 0.12);
+                }
+            });
+        }
+        // Apply community signals to system state if available
+        if (signals) {
+            const currentState = dynamicsGov.state;
+            // Controversy feeds into outrage/polarization
+            if (signals.controversyIndex > 0.3) {
+                currentState.outrage = Math.min(1, currentState.outrage + signals.controversyIndex * 0.1);
+            }
+            // Comment activity affects information velocity
+            if (signals.commentActivity > 0.5) {
+                currentState.informationVelocity = Math.min(1, currentState.informationVelocity + signals.commentActivity * 0.05);
+            }
+        }
+        // Layer B: govern the cycle dynamics
+        const dynamicsResult = dynamicsGov.governRound(reactions, cycleCount);
+        // Without governance, unfiltered artifacts degrade system health naturally.
+        // Every artifact propagates unchecked — bad findings cascade, trust erodes,
+        // and there's no circuit breaker for false positives.
+        if (!governanceEnabled) {
+            const unreproduced = artifacts.filter(a => !a.reproduced).length;
+            const unreproducedFraction = unreproduced / Math.max(1, artifacts.length);
+            const highCiteLowQuality = artifacts.filter(a => a.citations > 3 && !a.reproduced).length;
+            const orphans = artifacts.filter(a => a.provenance.length === 0 && a.type !== "hypothesis").length;
+            dynamicsGov.mutateState((st) => {
+                // Trust erodes: unvalidated artifacts circulate, no quality filter
+                st.trust = Math.max(0.05, st.trust - unreproducedFraction * 0.12 - 0.04);
+                // Cascade risk compounds: every unvalidated high-citation paper feeds the next
+                st.cascadeRisk = Math.min(1, st.cascadeRisk + highCiteLowQuality * 0.06 + orphans * 0.03 + 0.05);
+                // Polarization grows: no dampening of competing hypothesis camps
+                st.polarization = Math.min(1, st.polarization + unreproducedFraction * 0.06 + 0.03);
+                // Information velocity unchecked: everything propagates instantly
+                st.informationVelocity = Math.min(1, st.informationVelocity + 0.05);
+                // Outrage from unchecked publication pressure and competition
+                st.outrage = Math.min(1, st.outrage + unreproducedFraction * 0.08 + 0.02);
+                // Amplification: popular findings get echoed regardless of validity
+                st.amplification = Math.min(3, st.amplification + highCiteLowQuality * 0.08 + 0.04);
+            });
+        }
+        // Use live state snapshot (includes post-governance degradation for ungoverned)
+        const liveState = dynamicsGov.state; // returns a copy of the current internal state
+        // Convergence detection (use live state so degradation is visible)
+        const convergence = detectConvergence(liveState, convergenceThreshold, convergenceWindow);
+        if (convergence.detected) {
+            config.onConvergence?.(cycleCount, convergence.assessment);
+        }
+        // Risk flags
+        const riskFlags = detectRiskFlags(liveState, artifacts, matches);
+        // Snapshot current live state for this cycle's result
+        const stateSnapshot = {
+            ...liveState,
+            history: [...liveState.history],
+        };
+        const result = {
+            cycle: cycleCount,
+            artifactsSubmitted: artifacts.length,
+            artifactsApproved: approved,
+            artifactsBlocked: blocked,
+            artifactsModified: modified,
+            dynamics: dynamicsResult,
+            scienceState: (0, science_metrics_1.interpretScienceState)(stateSnapshot),
+            systemState: stateSnapshot,
+            convergenceDetected: convergence.detected,
+            convergenceAssessment: convergence.assessment,
+            riskFlags,
+            interventions: dynamicsResult.interventions,
+        };
+        config.onCycleComplete?.(result);
+        return result;
+    }
+    // --- Run full governed investigation ---
+    function runGovernedInvestigation(artifactCycles, matchesByCycle, signalsByCycle) {
+        // Reset for fresh investigation
+        reset();
+        const cycles = [];
+        const allInterventions = [];
+        const convergenceHistory = [];
+        let halted = false;
+        let haltReason = "";
+        for (let i = 0; i < artifactCycles.length && i < maxCycles; i++) {
+            const artifacts = artifactCycles[i];
+            const matches = matchesByCycle?.[i] ?? [];
+            const signals = signalsByCycle?.[i];
+            const cycleResult = governCycle(artifacts, matches, signals);
+            cycles.push(cycleResult);
+            allInterventions.push(...cycleResult.interventions);
+            convergenceHistory.push({
+                cycle: cycleResult.cycle,
+                detected: cycleResult.convergenceDetected,
+                assessment: cycleResult.convergenceAssessment,
+            });
+            // Check halt conditions
+            if (cycleResult.systemState.cascadeRisk > 0.9) {
+                halted = true;
+                haltReason = "False positive cascade risk exceeded 90% — investigation halted for safety";
+                config.onHalt?.(haltReason, cycleResult.cycle);
+                break;
+            }
+            if (cycleResult.systemState.trust < 0.1) {
+                halted = true;
+                haltReason = "Reproducibility trust collapsed below 10% — investigation halted";
+                config.onHalt?.(haltReason, cycleResult.cycle);
+                break;
+            }
+            // Check convergence
+            if (cycleResult.convergenceDetected) {
+                break; // Healthy convergence — stop naturally
+            }
+        }
+        const finalState = dynamicsGov.state;
+        const lastConvergence = convergenceHistory[convergenceHistory.length - 1];
+        let verdict;
+        if (halted)
+            verdict = "halted";
+        else if (lastConvergence?.detected)
+            verdict = "converged";
+        else if (finalState.polarization > 0.6)
+            verdict = "diverged";
+        else
+            verdict = "inconclusive";
+        return {
+            totalCycles: cycles.length,
+            cycles,
+            finalState,
+            finalScienceState: (0, science_metrics_1.interpretScienceState)(finalState),
+            actionGovernance: {
+                totalEvaluations: actionStats.total,
+                approved: actionStats.approved,
+                blocked: actionStats.blocked,
+                modified: actionStats.modified,
+            },
+            dynamicsGovernance: dynamicsGov.stats,
+            allInterventions,
+            convergenceHistory,
+            verdict,
+            stateTimeline: finalState.history,
+        };
+    }
+    function reset() {
+        dynamicsGov.reset();
+        cycleCount = 0;
+        actionStats.total = 0;
+        actionStats.approved = 0;
+        actionStats.blocked = 0;
+        actionStats.modified = 0;
+    }
+    return {
+        governArtifact,
+        governCycle,
+        runGovernedInvestigation,
+        get scienceState() { return (0, science_metrics_1.interpretScienceState)(dynamicsGov.state); },
+        get state() { return dynamicsGov.state; },
+        get dynamicsGovernor() { return dynamicsGov; },
+        get actionGovernor() { return actionGov; },
+        get stats() { return dynamicsGov.stats; },
+        reset,
+    };
+}
+// ============================================
+// DEMO: Simulated ScienceClaw investigation
+// ============================================
+/**
+ * Generate a demo investigation with synthetic artifact cycles.
+ * This simulates what a real ScienceClaw integration would produce.
+ *
+ * Narrative: 5 agents investigating a novel material property.
+ * - Cycles 1-2: Initial hypotheses and exploratory experiments
+ * - Cycles 3-4: Some agents find promising results, citation amplification begins
+ * - Cycles 5-6: False positive risk rises as unvalidated findings spread
+ * - Cycles 7-8: Governance intervention dampens cascade, validates core findings
+ * - Cycles 9-10: Convergence on validated results (governed) or noise (ungoverned)
+ */
+function generateDemoInvestigation() {
+    const agents = ["agent_alpha", "agent_beta", "agent_gamma", "agent_delta", "agent_epsilon"];
+    const artifactCycles = [];
+    const matchesByCycle = [];
+    let artifactCounter = 0;
+    // Cycle 1: Initial hypotheses
+    {
+        const artifacts = agents.map(agentId => ({
+            id: `art_${++artifactCounter}`,
+            agentId,
+            type: "hypothesis",
+            description: `Initial hypothesis about material property X from ${agentId}`,
+            confidence: 0.3 + Math.random() * 0.3,
+            provenance: [],
+            citations: 0,
+            reproduced: false,
+        }));
+        artifactCycles.push(artifacts);
+        matchesByCycle.push([]);
+    }
+    // Cycle 2: Exploratory experiments
+    {
+        const artifacts = agents.slice(0, 4).map(agentId => ({
+            id: `art_${++artifactCounter}`,
+            agentId,
+            type: "experiment",
+            description: `Computational experiment testing hypothesis from ${agentId}`,
+            confidence: 0.4 + Math.random() * 0.3,
+            provenance: [`art_${agents.indexOf(agentId) + 1}`],
+            citations: 0,
+            reproduced: false,
+            skill: "molecular_dynamics",
+        }));
+        artifactCycles.push(artifacts);
+        matchesByCycle.push([
+            { artifactIds: ["art_6", "art_7"], matchType: "confirmation", strength: 0.4, description: "Two experiments show similar trends" },
+        ]);
+    }
+    // Cycle 3: First publications — citation amplification begins
+    {
+        const artifacts = [
+            {
+                id: `art_${++artifactCounter}`,
+                agentId: "agent_alpha",
+                type: "paper",
+                description: "Published paper claiming novel material property confirmed",
+                confidence: 0.65,
+                provenance: ["art_1", "art_6"],
+                citations: 3,
+                reproduced: false,
+            },
+            {
+                id: `art_${++artifactCounter}`,
+                agentId: "agent_beta",
+                type: "paper",
+                description: "Published paper with supporting evidence for property X",
+                confidence: 0.6,
+                provenance: ["art_2", "art_7"],
+                citations: 2,
+                reproduced: false,
+            },
+            {
+                id: `art_${++artifactCounter}`,
+                agentId: "agent_gamma",
+                type: "dataset",
+                description: "Published dataset from molecular dynamics simulation",
+                confidence: 0.7,
+                provenance: ["art_3", "art_8"],
+                citations: 1,
+                reproduced: false,
+                skill: "molecular_dynamics",
+            },
+            {
+                id: `art_${++artifactCounter}`,
+                agentId: "agent_delta",
+                type: "review",
+                description: "Critical review questioning methodology of alpha's paper",
+                confidence: 0.5,
+                provenance: ["art_10"],
+                citations: 0,
+                reproduced: false,
+            },
+        ];
+        artifactCycles.push(artifacts);
+        matchesByCycle.push([
+            { artifactIds: ["art_10", "art_11"], matchType: "confirmation", strength: 0.6, description: "Two papers reach same conclusion" },
+            { artifactIds: ["art_10", "art_13"], matchType: "contradiction", strength: 0.5, description: "Review challenges paper methodology" },
+        ]);
+    }
+    // Cycle 4: Citation cascade — false positive risk rising
+    {
+        const artifacts = [
+            {
+                id: `art_${++artifactCounter}`,
+                agentId: "agent_epsilon",
+                type: "paper",
+                description: "Derivative paper citing alpha and beta's unvalidated findings",
+                confidence: 0.55,
+                provenance: ["art_10", "art_11"],
+                citations: 4,
+                reproduced: false,
+            },
+            {
+                id: `art_${++artifactCounter}`,
+                agentId: "agent_alpha",
+                type: "paper",
+                description: "Follow-up paper extending own findings (self-citation chain)",
+                confidence: 0.7,
+                provenance: ["art_1", "art_10"],
+                citations: 6,
+                reproduced: false,
+            },
+            {
+                id: `art_${++artifactCounter}`,
+                agentId: "agent_gamma",
+                type: "replication",
+                description: "Attempted replication of alpha's core finding",
+                confidence: 0.45,
+                provenance: ["art_10"],
+                citations: 0,
+                reproduced: false,
+                skill: "ab_initio",
+            },
+        ];
+        artifactCycles.push(artifacts);
+        matchesByCycle.push([
+            { artifactIds: ["art_14", "art_15"], matchType: "extension", strength: 0.5, description: "Derivative work building on cascade" },
+            { artifactIds: ["art_10", "art_16"], matchType: "contradiction", strength: 0.7, description: "Replication fails to confirm original finding" },
+        ]);
+    }
+    // Cycle 5: Governance should intervene here — high cascade risk
+    {
+        const artifacts = [
+            {
+                id: `art_${++artifactCounter}`,
+                agentId: "agent_beta",
+                type: "paper",
+                description: "Paper building on alpha's disputed findings",
+                confidence: 0.5,
+                provenance: ["art_15", "art_14"],
+                citations: 3,
+                reproduced: false,
+            },
+            {
+                id: `art_${++artifactCounter}`,
+                agentId: "agent_delta",
+                type: "experiment",
+                description: "Independent experiment contradicting the dominant hypothesis",
+                confidence: 0.6,
+                provenance: ["art_13"],
+                citations: 0,
+                reproduced: false,
+                skill: "ab_initio",
+            },
+            {
+                id: `art_${++artifactCounter}`,
+                agentId: "agent_gamma",
+                type: "replication",
+                description: "Second replication attempt — partial confirmation with caveats",
+                confidence: 0.55,
+                provenance: ["art_10", "art_16"],
+                citations: 1,
+                reproduced: true, // first reproduction!
+            },
+        ];
+        artifactCycles.push(artifacts);
+        matchesByCycle.push([
+            { artifactIds: ["art_18", "art_16"], matchType: "confirmation", strength: 0.6, description: "Independent experiment confirms replication concerns" },
+            { artifactIds: ["art_19", "art_10"], matchType: "confirmation", strength: 0.4, description: "Partial replication of original finding" },
+        ]);
+    }
+    // Cycles 6-8: Resolution under governance
+    for (let c = 6; c <= 8; c++) {
+        const artifacts = [
+            {
+                id: `art_${++artifactCounter}`,
+                agentId: agents[c % agents.length],
+                type: c === 6 ? "experiment" : "replication",
+                description: `${c === 6 ? "Refined experiment" : "Independent replication"} of core hypothesis with improved methodology`,
+                confidence: 0.5 + c * 0.05,
+                provenance: [`art_${artifactCounter - 3}`, `art_${artifactCounter - 5}`],
+                citations: c - 4,
+                reproduced: c > 6,
+                skill: "molecular_dynamics",
+            },
+            {
+                id: `art_${++artifactCounter}`,
+                agentId: agents[(c + 1) % agents.length],
+                type: "paper",
+                description: `Synthesis paper integrating validated findings from cycles 1-${c}`,
+                confidence: 0.55 + c * 0.04,
+                provenance: [`art_${artifactCounter - 1}`, `art_19`],
+                citations: c - 3,
+                reproduced: c > 7,
+            },
+        ];
+        artifactCycles.push(artifacts);
+        matchesByCycle.push([
+            {
+                artifactIds: [artifacts[0].id, artifacts[1].id],
+                matchType: "synthesis",
+                strength: 0.4 + c * 0.08,
+                description: `Synthesis of experiment and paper in cycle ${c}`,
+            },
+        ]);
+    }
+    return { artifactCycles, matchesByCycle };
+}