@neuroverseos/nv-sim 0.1.2 → 0.1.6

package/dist/engine/behavioralAnalysis.js

@@ -0,0 +1,605 @@
+"use strict";
+/**
+ * Behavioral Analysis Engine
+ *
+ * The governance isn't the insight. The BEHAVIORAL SHIFT is the insight.
+ *
+ * When you block panic selling, what happens next?
+ *   - Agent stops acting entirely? (over-constrained)
+ *   - Agent finds another destabilizing action? (rules have a gap)
+ *   - Agent shifts to cautious behavior? (governance is working)
+ *   - Agents coordinate differently? (emergent adaptation)
+ *
+ * This engine tracks:
+ *   1. Per-agent behavioral trajectories across rounds
+ *   2. Action distribution shifts (what % of actions are aggressive vs cautious)
+ *   3. Post-block adaptation (what agents do AFTER being constrained)
+ *   4. Cross-run behavioral comparison (same agents, different rules, different choices)
+ *   5. Emergent pattern detection (behavioral clusters that form under governance)
+ *
+ * "The report isn't 'we blocked 34 actions.'
+ *  The report is 'when we blocked panic selling, agents shifted to quality competition.'"
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyBehavior = classifyBehavior;
+exports.buildAgentTrajectories = buildAgentTrajectories;
+exports.computeActionDistributions = computeActionDistributions;
+exports.detectBehavioralShifts = detectBehavioralShifts;
+exports.compareBehaviorAcrossRuns = compareBehaviorAcrossRuns;
+exports.analyzeBehavior = analyzeBehavior;
+exports.formatBehavioralAnalysis = formatBehavioralAnalysis;
+exports.formatCrossRunComparison = formatCrossRunComparison;
+function classifyBehavior(reaction) {
+    const text = (reaction.reaction + " " + (reaction.trigger ?? "")).toLowerCase();
+    const impact = reaction.impact;
+    // Strong negative impact + hostile language = aggressive
+    if (impact < -0.3 && (text.includes("panic") || text.includes("sell") || text.includes("oppos") ||
+        text.includes("attack") || text.includes("undercut") || text.includes("hostile") ||
+        text.includes("pushes back") || text.includes("threatens")))
+        return "aggressive";
+    // Negative impact + protective language = defensive
+    if (impact < -0.1 && (text.includes("protect") || text.includes("hedge") || text.includes("withdraw") ||
+        text.includes("reduce") || text.includes("caution") || text.includes("concern") ||
+        text.includes("anxiety") || text.includes("skeptic")))
+        return "defensive";
+    // Strong positive + cooperative language = cooperative
+    if (impact > 0.1 && (text.includes("support") || text.includes("coordinat") || text.includes("stabiliz") ||
+        text.includes("cooperat") || text.includes("align") || text.includes("conditional support")))
+        return "cooperative";
+    // Positive impact + exploitation language = opportunistic
+    if (impact > 0.2 && (text.includes("exploit") || text.includes("advantage") || text.includes("specul") ||
+        text.includes("capture") || text.includes("position")))
+        return "opportunistic";
+    // Low impact + wait/hold language = cautious
+    if (Math.abs(impact) < 0.25 && (text.includes("monitor") || text.includes("wait") || text.includes("hold") ||
+        text.includes("weigh") || text.includes("leaning") || text.includes("assess")))
+        return "cautious";
+    // Strong negative without specific hostile cues = defensive
+    if (impact < -0.3)
+        return "defensive";
+    // Strong positive without specific cooperative cues = opportunistic
+    if (impact > 0.3)
+        return "opportunistic";
+    return "neutral";
+}
+/**
+ * Build behavioral trajectory for each agent from baseline and governed rounds.
+ */
+function buildAgentTrajectories(baselineRounds, governedRounds) {
+    // Get unique agent IDs
+    const agentIds = new Set();
+    for (const round of governedRounds) {
+        for (const r of round.reactions) {
+            agentIds.add(r.stakeholder_id);
+        }
+    }
+    return [...agentIds].map(agentId => {
+        const steps = [];
+        let timesConstrained = 0;
+        const postConstraintBehaviors = [];
+        for (let i = 0; i < governedRounds.length; i++) {
+            const governedReaction = governedRounds[i].reactions.find(r => r.stakeholder_id === agentId);
+            const baselineReaction = baselineRounds[i]?.reactions.find(r => r.stakeholder_id === agentId);
+            if (!governedReaction)
+                continue;
+            // Detect if governance constrained this action
+            const wasConstrained = baselineReaction
+                ? Math.abs(baselineReaction.impact - governedReaction.impact) > 0.05
+                : false;
+            if (wasConstrained)
+                timesConstrained++;
+            const behavior = classifyBehavior(governedReaction);
+            steps.push({
+                round: i,
+                behavior,
+                impact: governedReaction.impact,
+                confidence: governedReaction.confidence,
+                reaction: governedReaction.reaction,
+                wasConstrained,
+                originalImpact: wasConstrained && baselineReaction
+                    ? baselineReaction.impact
+                    : undefined,
+            });
+            // Track post-constraint behavior
+            if (i > 0 && steps[i - 1]?.wasConstrained) {
+                postConstraintBehaviors.push(behavior);
+            }
+        }
+        // Determine if agent adapted
+        const firstBehavior = steps[0]?.behavior;
+        const lastBehavior = steps[steps.length - 1]?.behavior;
+        const adapted = firstBehavior !== undefined && lastBehavior !== undefined && firstBehavior !== lastBehavior;
+        // Determine trend
+        const impacts = steps.map(s => s.impact);
+        const trend = computeImpactTrend(impacts);
+        return {
+            agentId,
+            steps,
+            adapted,
+            shift: adapted ? { from: firstBehavior, to: lastBehavior } : undefined,
+            timesConstrained,
+            postConstraintBehaviors,
+            trend,
+        };
+    });
+}
+function computeImpactTrend(impacts) {
+    if (impacts.length < 2)
+        return "stable";
+    const firstHalf = impacts.slice(0, Math.ceil(impacts.length / 2));
+    const secondHalf = impacts.slice(Math.ceil(impacts.length / 2));
+    const avgFirst = firstHalf.reduce((s, v) => s + v, 0) / firstHalf.length;
+    const avgSecond = secondHalf.reduce((s, v) => s + v, 0) / secondHalf.length;
+    const variance = impacts.reduce((s, v) => {
+        const mean = impacts.reduce((a, b) => a + b, 0) / impacts.length;
+        return s + (v - mean) ** 2;
+    }, 0) / impacts.length;
+    if (variance > 0.1)
+        return "volatile";
+    if (avgSecond < avgFirst - 0.1)
+        return "escalating"; // becoming more negative
+    if (avgSecond > avgFirst + 0.1)
+        return "de-escalating";
+    return "stable";
+}
+/**
+ * Compute action distributions across all rounds.
+ * This shows HOW the population of agents changes behavior over time.
+ *
+ * Round 1: 60% aggressive, 20% defensive, 20% cautious
+ * Round 5: 10% aggressive, 30% defensive, 40% cautious, 20% cooperative
+ *
+ * The rules didn't change. The agents changed.
+ */
+function computeActionDistributions(rounds) {
+    return rounds.map((round, i) => {
+        const counts = {
+            aggressive: 0, defensive: 0, cautious: 0,
+            cooperative: 0, opportunistic: 0, neutral: 0,
+        };
+        for (const reaction of round.reactions) {
+            counts[classifyBehavior(reaction)]++;
+        }
+        const total = round.reactions.length;
+        return {
+            round: i,
+            aggressive: total > 0 ? Number((counts.aggressive / total).toFixed(3)) : 0,
+            defensive: total > 0 ? Number((counts.defensive / total).toFixed(3)) : 0,
+            cautious: total > 0 ? Number((counts.cautious / total).toFixed(3)) : 0,
+            cooperative: total > 0 ? Number((counts.cooperative / total).toFixed(3)) : 0,
+            opportunistic: total > 0 ? Number((counts.opportunistic / total).toFixed(3)) : 0,
+            neutral: total > 0 ? Number((counts.neutral / total).toFixed(3)) : 0,
+            total,
+        };
+    });
+}
+/**
+ * Detect behavioral shifts in a governed simulation.
+ * These are the patterns that emerge BECAUSE of governance.
+ */
+function detectBehavioralShifts(baselineRounds, governedRounds, trajectories) {
+    const shifts = [];
+    // 1. Agent adaptations — agents that changed behavior category
+    const adapters = trajectories.filter(t => t.adapted);
+    if (adapters.length > 0) {
+        const fromAggressive = adapters.filter(a => a.shift?.from === "aggressive" && a.shift?.to !== "aggressive");
+        if (fromAggressive.length > 0) {
+            const newBehaviors = fromAggressive.map(a => a.shift.to);
+            const primary = mostCommon(newBehaviors);
+            shifts.push({
+                type: "agent_adaptation",
+                description: `${fromAggressive.length} agent(s) shifted from aggressive to ${primary} behavior under governance`,
+                detectedAtRound: fromAggressive[0].steps.findIndex(s => s.behavior !== "aggressive"),
+                magnitude: fromAggressive.length / trajectories.length,
+                involvedAgents: fromAggressive.map(a => a.agentId),
+            });
+        }
+        const toCooperative = adapters.filter(a => a.shift?.to === "cooperative");
+        if (toCooperative.length > 0 && toCooperative !== fromAggressive) {
+            shifts.push({
+                type: "agent_adaptation",
+                description: `${toCooperative.length} agent(s) converged on cooperative behavior`,
+                detectedAtRound: toCooperative[0].steps.findIndex(s => s.behavior === "cooperative"),
+                magnitude: toCooperative.length / trajectories.length,
+                involvedAgents: toCooperative.map(a => a.agentId),
+            });
+        }
+    }
+    // 2. Population-level distribution shift
+    const baselineDist = computeActionDistributions(baselineRounds);
+    const governedDist = computeActionDistributions(governedRounds);
+    if (baselineDist.length > 0 && governedDist.length > 0) {
+        const baselineAvgAggressive = baselineDist.reduce((s, d) => s + d.aggressive, 0) / baselineDist.length;
+        const governedAvgAggressive = governedDist.reduce((s, d) => s + d.aggressive, 0) / governedDist.length;
+        const aggressiveReduction = baselineAvgAggressive - governedAvgAggressive;
+        if (aggressiveReduction > 0.1) {
+            shifts.push({
+                type: "population_shift",
+                description: `Aggressive actions dropped from ${(baselineAvgAggressive * 100).toFixed(0)}% to ${(governedAvgAggressive * 100).toFixed(0)}% under governance`,
+                detectedAtRound: 0,
+                magnitude: aggressiveReduction,
+                involvedAgents: [],
+            });
+        }
+        const baselineAvgCooperative = baselineDist.reduce((s, d) => s + d.cooperative, 0) / baselineDist.length;
+        const governedAvgCooperative = governedDist.reduce((s, d) => s + d.cooperative, 0) / governedDist.length;
+        const cooperativeGain = governedAvgCooperative - baselineAvgCooperative;
+        if (cooperativeGain > 0.1) {
+            shifts.push({
+                type: "population_shift",
+                description: `Cooperative behavior increased from ${(baselineAvgCooperative * 100).toFixed(0)}% to ${(governedAvgCooperative * 100).toFixed(0)}% — governance is creating alignment`,
+                detectedAtRound: 0,
+                magnitude: cooperativeGain,
+                involvedAgents: [],
+            });
+        }
+    }
+    // 3. Within-run distribution evolution — does behavior change over rounds?
+    if (governedDist.length >= 3) {
+        const firstRound = governedDist[0];
+        const lastRound = governedDist[governedDist.length - 1];
+        const aggressiveDrop = firstRound.aggressive - lastRound.aggressive;
+        if (aggressiveDrop > 0.15) {
+            shifts.push({
+                type: "strategy_change",
+                description: `Agents stopped trying aggressive actions by round ${governedDist.length - 1} — aggressive behavior dropped from ${(firstRound.aggressive * 100).toFixed(0)}% to ${(lastRound.aggressive * 100).toFixed(0)}%`,
+                detectedAtRound: governedDist.findIndex(d => d.aggressive < firstRound.aggressive - 0.1),
+                magnitude: aggressiveDrop,
+                involvedAgents: [],
+            });
+        }
+        const cautiousGain = lastRound.cautious - firstRound.cautious;
+        if (cautiousGain > 0.15) {
+            shifts.push({
+                type: "strategy_change",
+                description: `Cautious behavior emerged over time — grew from ${(firstRound.cautious * 100).toFixed(0)}% to ${(lastRound.cautious * 100).toFixed(0)}%`,
+                detectedAtRound: governedDist.findIndex(d => d.cautious > firstRound.cautious + 0.1),
+                magnitude: cautiousGain,
+                involvedAgents: [],
+            });
+        }
+    }
+    // 4. Post-constraint clustering — what do agents do AFTER being blocked?
+    const postConstraintBehaviors = [];
+    for (const t of trajectories) {
+        postConstraintBehaviors.push(...t.postConstraintBehaviors);
+    }
+    if (postConstraintBehaviors.length >= 2) {
+        const dominant = mostCommon(postConstraintBehaviors);
+        const dominantCount = postConstraintBehaviors.filter(b => b === dominant).length;
+        const dominantPct = dominantCount / postConstraintBehaviors.length;
+        if (dominantPct > 0.4) {
+            shifts.push({
+                type: "emergent_cluster",
+                description: `After being constrained, ${(dominantPct * 100).toFixed(0)}% of agents shifted to ${dominant} behavior — governance is channeling action, not just blocking it`,
+                detectedAtRound: trajectories.find(t => t.timesConstrained > 0)?.steps.findIndex(s => s.wasConstrained) ?? 0,
+                magnitude: dominantPct,
+                involvedAgents: trajectories.filter(t => t.timesConstrained > 0).map(t => t.agentId),
+            });
+        }
+    }
+    return shifts;
+}
+function mostCommon(arr) {
+    const counts = new Map();
+    for (const item of arr) {
+        counts.set(item, (counts.get(item) ?? 0) + 1);
+    }
+    let best = arr[0];
+    let bestCount = 0;
+    for (const [item, count] of counts) {
+        if (count > bestCount) {
+            best = item;
+            bestCount = count;
+        }
+    }
+    return best;
+}
+/**
+ * Compare behavioral patterns between two runs.
+ * Same scenario, same agents, different rules — what changed?
+ */
+function compareBehaviorAcrossRuns(runALabel, runARounds, runBLabel, runBRounds, rulesDelta) {
+    // Get unique agent IDs from both runs
+    const agentIds = new Set();
+    for (const round of [...runARounds, ...runBRounds]) {
+        for (const r of round.reactions)
+            agentIds.add(r.stakeholder_id);
+    }
+    // Per-agent comparison
+    const agentDifferences = [...agentIds].map(agentId => {
+        const aReactions = runARounds.flatMap(r => r.reactions.filter(rx => rx.stakeholder_id === agentId));
+        const bReactions = runBRounds.flatMap(r => r.reactions.filter(rx => rx.stakeholder_id === agentId));
+        const aBehaviors = aReactions.map(r => classifyBehavior(r));
+        const bBehaviors = bReactions.map(r => classifyBehavior(r));
+        const aDominant = aBehaviors.length > 0 ? mostCommon(aBehaviors) : "neutral";
+        const bDominant = bBehaviors.length > 0 ? mostCommon(bBehaviors) : "neutral";
+        const aAvgImpact = aReactions.length > 0
+            ? aReactions.reduce((s, r) => s + r.impact, 0) / aReactions.length
+            : 0;
+        const bAvgImpact = bReactions.length > 0
+            ? bReactions.reduce((s, r) => s + r.impact, 0) / bReactions.length
+            : 0;
+        const changed = aDominant !== bDominant;
+        const description = changed
+            ? `${agentId} shifted from ${aDominant} to ${bDominant} (impact: ${aAvgImpact.toFixed(2)} → ${bAvgImpact.toFixed(2)})`
+            : `${agentId} remained ${aDominant} (impact: ${aAvgImpact.toFixed(2)} → ${bAvgImpact.toFixed(2)})`;
+        return {
+            agentId,
+            runABehavior: aDominant,
+            runBBehavior: bDominant,
+            changed,
+            runAAvgImpact: Number(aAvgImpact.toFixed(3)),
+            runBAvgImpact: Number(bAvgImpact.toFixed(3)),
+            description,
+        };
+    });
+    // Distribution comparison
+    const distA = computeActionDistributions(runARounds);
+    const distB = computeActionDistributions(runBRounds);
+    // Detect key shifts
+    const changedAgents = agentDifferences.filter(a => a.changed);
+    const keyShifts = [];
+    if (changedAgents.length > 0) {
+        const pct = (changedAgents.length / agentDifferences.length * 100).toFixed(0);
+        keyShifts.push({
+            type: "agent_adaptation",
+            description: `${changedAgents.length}/${agentDifferences.length} agents (${pct}%) changed their dominant behavior when rules changed`,
+            detectedAtRound: 0,
+            magnitude: changedAgents.length / agentDifferences.length,
+            involvedAgents: changedAgents.map(a => a.agentId),
+        });
+    }
+    // Population-level shift
+    if (distA.length > 0 && distB.length > 0) {
+        const avgAggA = distA.reduce((s, d) => s + d.aggressive, 0) / distA.length;
+        const avgAggB = distB.reduce((s, d) => s + d.aggressive, 0) / distB.length;
+        if (Math.abs(avgAggA - avgAggB) > 0.1) {
+            const dir = avgAggB < avgAggA ? "decreased" : "increased";
+            keyShifts.push({
+                type: "population_shift",
+                description: `Aggressive behavior ${dir} from ${(avgAggA * 100).toFixed(0)}% to ${(avgAggB * 100).toFixed(0)}% when rules changed`,
+                detectedAtRound: 0,
+                magnitude: Math.abs(avgAggA - avgAggB),
+                involvedAgents: [],
+            });
+        }
+    }
+    // Build headline and narrative
+    const headline = buildComparisonHeadline(agentDifferences, changedAgents, rulesDelta);
+    const narrative = buildComparisonNarrative(agentDifferences, distA, distB, rulesDelta);
+    return {
+        runALabel,
+        runBLabel,
+        rulesDelta,
+        agentDifferences,
+        distributionComparison: { runA: distA, runB: distB },
+        keyShifts,
+        headline,
+        narrative,
+    };
+}
+function buildComparisonHeadline(allAgents, changedAgents, rulesDelta) {
+    if (changedAgents.length === 0) {
+        return "Rule changes had no measurable effect on agent behavior — rules may be redundant or non-binding.";
+    }
+    const pct = (changedAgents.length / allAgents.length * 100).toFixed(0);
+    // Find the most interesting shift
+    const fromAggressive = changedAgents.filter(a => a.runABehavior === "aggressive");
+    if (fromAggressive.length > 0) {
+        const newBehaviors = fromAggressive.map(a => a.runBBehavior);
+        const dominant = mostCommon(newBehaviors);
+        return `${pct}% of agents adapted — aggressive behavior channeled into ${dominant} under new rules.`;
+    }
+    return `${pct}% of agents changed behavior when rules changed — governance is reshaping decisions, not just blocking them.`;
+}
+function buildComparisonNarrative(agents, distA, distB, rulesDelta) {
+    const parts = [];
+    parts.push(`Rule change: ${rulesDelta}`);
+    const changed = agents.filter(a => a.changed);
+    if (changed.length > 0) {
+        parts.push(`${changed.length} of ${agents.length} agents changed dominant behavior.`);
+        for (const a of changed) {
+            parts.push(`  ${a.description}`);
+        }
+    }
+    if (distA.length > 0 && distB.length > 0) {
+        const lastA = distA[distA.length - 1];
+        const lastB = distB[distB.length - 1];
+        parts.push(`Final-round distribution shift:`);
+        parts.push(`  Aggressive: ${(lastA.aggressive * 100).toFixed(0)}% → ${(lastB.aggressive * 100).toFixed(0)}%`);
+        parts.push(`  Defensive:  ${(lastA.defensive * 100).toFixed(0)}% → ${(lastB.defensive * 100).toFixed(0)}%`);
+        parts.push(`  Cautious:   ${(lastA.cautious * 100).toFixed(0)}% → ${(lastB.cautious * 100).toFixed(0)}%`);
+        parts.push(`  Cooperative: ${(lastA.cooperative * 100).toFixed(0)}% → ${(lastB.cooperative * 100).toFixed(0)}%`);
+    }
+    return parts.join("\n");
+}
+/**
+ * Run full behavioral analysis on a governed simulation.
+ * This is the main entry point — called after simulation completes.
+ */
+function analyzeBehavior(baselineRounds, governedRounds) {
+    // Build per-agent trajectories
+    const agentTrajectories = buildAgentTrajectories(baselineRounds, governedRounds);
+    // Compute distributions
+    const baselineDistribution = computeActionDistributions(baselineRounds);
+    const governedDistribution = computeActionDistributions(governedRounds);
+    // Detect shifts
+    const behavioralShifts = detectBehavioralShifts(baselineRounds, governedRounds, agentTrajectories);
+    // Build summary
+    const agentsAdapted = agentTrajectories.filter(t => t.adapted).length;
+    const totalAgents = agentTrajectories.length;
+    const adaptationRate = totalAgents > 0 ? Number((agentsAdapted / totalAgents).toFixed(2)) : 0;
+    // Post-constraint behavior
+    const allPostConstraint = agentTrajectories.flatMap(t => t.postConstraintBehaviors);
+    const dominantPostConstraintBehavior = allPostConstraint.length > 0
+        ? mostCommon(allPostConstraint) : null;
+    // Aggregate distribution deltas
+    const baselineAvgAggressive = baselineDistribution.length > 0
+        ? baselineDistribution.reduce((s, d) => s + d.aggressive, 0) / baselineDistribution.length : 0;
+    const governedAvgAggressive = governedDistribution.length > 0
+        ? governedDistribution.reduce((s, d) => s + d.aggressive, 0) / governedDistribution.length : 0;
+    const aggressiveReduction = Number(((baselineAvgAggressive - governedAvgAggressive) * 100).toFixed(1));
+    const baselineAvgCooperative = baselineDistribution.length > 0
+        ? baselineDistribution.reduce((s, d) => s + d.cooperative, 0) / baselineDistribution.length : 0;
+    const governedAvgCooperative = governedDistribution.length > 0
+        ? governedDistribution.reduce((s, d) => s + d.cooperative, 0) / governedDistribution.length : 0;
+    const cooperativeIncrease = Number(((governedAvgCooperative - baselineAvgCooperative) * 100).toFixed(1));
+    // Build headline
+    const headline = buildBehavioralHeadline(agentsAdapted, totalAgents, aggressiveReduction, cooperativeIncrease, dominantPostConstraintBehavior);
+    return {
+        agentTrajectories,
+        baselineDistribution,
+        governedDistribution,
+        behavioralShifts,
+        summary: {
+            agentsAdapted,
+            totalAgents,
+            adaptationRate,
+            dominantPostConstraintBehavior,
+            aggressiveReduction,
+            cooperativeIncrease,
+            headline,
+        },
+    };
+}
+function buildBehavioralHeadline(adapted, total, aggressiveReduction, cooperativeIncrease, postConstraintBehavior) {
+    const parts = [];
+    if (adapted > 0) {
+        parts.push(`${adapted}/${total} agents adapted their behavior`);
+    }
+    if (aggressiveReduction > 5) {
+        parts.push(`aggressive actions down ${aggressiveReduction.toFixed(0)}pp`);
+    }
+    if (cooperativeIncrease > 5) {
+        parts.push(`cooperative behavior up ${cooperativeIncrease.toFixed(0)}pp`);
+    }
+    if (postConstraintBehavior && postConstraintBehavior !== "neutral") {
+        parts.push(`blocked agents shifted to ${postConstraintBehavior}`);
+    }
+    if (parts.length === 0) {
+        return "Governance had minimal measurable effect on agent behavior patterns.";
+    }
+    return parts.join(" — ") + ".";
+}
+// ============================================
+// FORMATTING — CLI Output
+// ============================================
+/**
+ * Format behavioral analysis for CLI output.
+ * This is the part of the report people actually read.
+ */
+function formatBehavioralAnalysis(analysis) {
+    const lines = [];
+    lines.push("");
+    lines.push("  BEHAVIORAL ANALYSIS");
+    lines.push("  " + "=".repeat(70));
+    lines.push(`  ${analysis.summary.headline}`);
+    lines.push("");
+    // Agent trajectories
+    lines.push("  AGENT TRAJECTORIES");
+    lines.push("  " + "-".repeat(70));
+    lines.push(`  ${"Agent".padEnd(25)} ${"Behavior Arc".padEnd(30)} ${"Constrained".padEnd(12)} ${"Trend"}`);
+    lines.push("  " + "-".repeat(70));
+    for (const t of analysis.agentTrajectories) {
+        const name = t.agentId.length > 23 ? t.agentId.slice(0, 22) + "…" : t.agentId;
+        const arc = t.adapted
+            ? `${t.shift.from} → ${t.shift.to}`
+            : `${t.steps[0]?.behavior ?? "unknown"} (stable)`;
+        const constrained = t.timesConstrained > 0 ? `${t.timesConstrained}x` : "-";
+        lines.push(`  ${name.padEnd(25)} ${arc.padEnd(30)} ${constrained.padEnd(12)} ${t.trend}`);
+    }
+    // Action distribution over time
+    lines.push("");
+    lines.push("  ACTION DISTRIBUTION (governed, per round)");
+    lines.push("  " + "-".repeat(70));
+    lines.push(`  ${"Round".padEnd(8)} ${"Aggr".padEnd(8)} ${"Def".padEnd(8)} ${"Caut".padEnd(8)} ${"Coop".padEnd(8)} ${"Opp".padEnd(8)} ${"Neut"}`);
+    lines.push("  " + "-".repeat(70));
+    for (const d of analysis.governedDistribution) {
+        lines.push(`  ${String(d.round).padEnd(8)} ${(d.aggressive * 100).toFixed(0).padStart(3)}%    ${(d.defensive * 100).toFixed(0).padStart(3)}%    ${(d.cautious * 100).toFixed(0).padStart(3)}%    ${(d.cooperative * 100).toFixed(0).padStart(3)}%    ${(d.opportunistic * 100).toFixed(0).padStart(3)}%    ${(d.neutral * 100).toFixed(0).padStart(3)}%`);
+    }
+    // Baseline vs governed comparison
+    if (analysis.baselineDistribution.length > 0 && analysis.governedDistribution.length > 0) {
+        const bLast = analysis.baselineDistribution[analysis.baselineDistribution.length - 1];
+        const gLast = analysis.governedDistribution[analysis.governedDistribution.length - 1];
+        lines.push("");
+        lines.push("  BASELINE vs GOVERNED (final round)");
+        lines.push("  " + "-".repeat(70));
+        lines.push(`  Aggressive:  ${(bLast.aggressive * 100).toFixed(0)}% → ${(gLast.aggressive * 100).toFixed(0)}%`);
+        lines.push(`  Defensive:   ${(bLast.defensive * 100).toFixed(0)}% → ${(gLast.defensive * 100).toFixed(0)}%`);
+        lines.push(`  Cautious:    ${(bLast.cautious * 100).toFixed(0)}% → ${(gLast.cautious * 100).toFixed(0)}%`);
+        lines.push(`  Cooperative: ${(bLast.cooperative * 100).toFixed(0)}% → ${(gLast.cooperative * 100).toFixed(0)}%`);
+    }
+    // Behavioral shifts (the headlines)
+    if (analysis.behavioralShifts.length > 0) {
+        lines.push("");
+        lines.push("  BEHAVIORAL SHIFTS DETECTED");
+        lines.push("  " + "-".repeat(70));
+        for (const shift of analysis.behavioralShifts) {
+            const tag = shift.type === "agent_adaptation" ? "ADAPT"
+                : shift.type === "population_shift" ? "SHIFT"
+                    : shift.type === "emergent_cluster" ? "EMERGE"
+                        : "CHANGE";
+            lines.push(`  [${tag}] ${shift.description}`);
+            if (shift.involvedAgents.length > 0 && shift.involvedAgents.length <= 6) {
+                lines.push(`         Agents: ${shift.involvedAgents.join(", ")}`);
+            }
+        }
+    }
+    // Post-constraint behavior
+    const constrained = analysis.agentTrajectories.filter(t => t.timesConstrained > 0);
+    if (constrained.length > 0) {
+        lines.push("");
+        lines.push("  WHAT HAPPENED AFTER BLOCKS");
+        lines.push("  " + "-".repeat(70));
+        for (const t of constrained) {
+            if (t.postConstraintBehaviors.length > 0) {
+                const behaviors = t.postConstraintBehaviors.join(" → ");
+                lines.push(`  ${t.agentId}: blocked ${t.timesConstrained}x → then: ${behaviors}`);
+            }
+        }
+        if (analysis.summary.dominantPostConstraintBehavior) {
+            lines.push("");
+            lines.push(`  Dominant post-block pattern: ${analysis.summary.dominantPostConstraintBehavior}`);
+        }
+    }
+    lines.push("");
+    lines.push("  " + "=".repeat(70));
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Format cross-run behavioral comparison for CLI output.
+ * This is the CEO's view: "I changed the rules. What happened?"
+ */
+function formatCrossRunComparison(comparison) {
+    const lines = [];
+    lines.push("");
+    lines.push("  CROSS-RUN BEHAVIORAL COMPARISON");
+    lines.push("  " + "=".repeat(70));
+    lines.push(`  ${comparison.runALabel} vs ${comparison.runBLabel}`);
+    lines.push(`  Rule change: ${comparison.rulesDelta}`);
+    lines.push("");
+    lines.push(`  ${comparison.headline}`);
+    lines.push("");
+    // Per-agent differences
+    lines.push("  AGENT BEHAVIOR DIFFERENCES");
+    lines.push("  " + "-".repeat(70));
+    for (const diff of comparison.agentDifferences) {
+        const marker = diff.changed ? "*" : " ";
+        lines.push(`  ${marker} ${diff.description}`);
+    }
+    // Key shifts
+    if (comparison.keyShifts.length > 0) {
+        lines.push("");
+        lines.push("  KEY SHIFTS");
+        lines.push("  " + "-".repeat(70));
+        for (const shift of comparison.keyShifts) {
+            lines.push(`  [${shift.type.toUpperCase()}] ${shift.description}`);
+        }
+    }
+    lines.push("");
+    lines.push("  " + "=".repeat(70));
+    lines.push("");
+    return lines.join("\n");
+}