AI失敗を3D因果グラフ化！Neo4j×Three.js自律反省術

import numpy as np
from sentence_transformers import SentenceTransformer

# 高性能な汎用埋め込みモデルをロード
model = SentenceTransformer("all-MiniLM-L6-v2")

# 正しい因果律 (A -> B -> C)
text_causal = "Macro liquidity shock hit the market, tech stocks collapsed, and automated panic selling was triggered."

# 因果関係が完全に破綻した逆行テキスト (C -> B -> A)
text_inverted = "Automated panic selling was triggered, tech stocks collapsed, and macro liquidity shock hit the market."

# エンベディングの算出と正規化
v_causal = model.encode(text_causal)
v_inverted = model.encode(text_inverted)

# コサイン類似度の計算
similarity = np.dot(v_causal, v_inverted) / (np.linalg.norm(v_causal) * np.linalg.norm(v_inverted))
print(f"Cosine Similarity: {similarity:.4f}")
# 出力結果例: Cosine Similarity: 0.9612

import numpy as np
from sentence_transformers import SentenceTransformer

# 高性能な汎用埋め込みモデルをロード
model = SentenceTransformer("all-MiniLM-L6-v2")

# 正しい因果律 (A -> B -> C)
text_causal = "Macro liquidity shock hit the market, tech stocks collapsed, and automated panic selling was triggered."

# 因果関係が完全に破綻した逆行テキスト (C -> B -> A)
text_inverted = "Automated panic selling was triggered, tech stocks collapsed, and macro liquidity shock hit the market."

# エンベディングの算出と正規化
v_causal = model.encode(text_causal)
v_inverted = model.encode(text_inverted)

# コサイン類似度の計算
similarity = np.dot(v_causal, v_inverted) / (np.linalg.norm(v_causal) * np.linalg.norm(v_inverted))
print(f"Cosine Similarity: {similarity:.4f}")
# 出力結果例: Cosine Similarity: 0.9612

-- マスターが自慢げに書いた、因果追跡のための地獄の多段JOINクエリ
EXPLAIN QUERY PLAN
SELECT 
    s.symbol, te.pnl_percent, cf.factor_name, l.directive, a.agent_name, c.rule_expression
FROM stocks s
JOIN trade_episodes te ON s.id = te.stock_id
JOIN episode_factors ef ON te.id = ef.episode_id
JOIN causal_factors cf ON ef.factor_id = cf.id
JOIN factor_lessons fl ON cf.id = fl.factor_id
JOIN lessons l ON fl.lesson_id = l.id
JOIN lesson_agents la ON l.id = la.lesson_id
JOIN agents a ON la.agent_id = a.id
JOIN agent_constraints ac ON a.id = ac.agent_id
JOIN constraints c ON ac.constraint_id = c.id
WHERE s.symbol = 'NVDA' 
  AND te.pnl_percent < -0.05 
  AND l.is_active = 1;

-- [SQLite 実行計画の無慈悲な宣告]
-- |--SCAN TABLE trade_episodes
-- |--SEARCH TABLE episode_factors USING AUTOMATIC COVERING INDEX (episode_id=?)
-- |--SEARCH TABLE causal_factors USING INTEGER PRIMARY KEY (rowid=?)
-- |--SCAN TABLE factor_lessons
-- |--USE TEMP B-TREE FOR JOIN ENFORCEMENT
-- \--CORRELATED SCALAR SUBQUERY EXECUTION (B-Tree Explosion)

-- マスターが自慢げに書いた、因果追跡のための地獄の多段JOINクエリ
EXPLAIN QUERY PLAN
SELECT 
    s.symbol, te.pnl_percent, cf.factor_name, l.directive, a.agent_name, c.rule_expression
FROM stocks s
JOIN trade_episodes te ON s.id = te.stock_id
JOIN episode_factors ef ON te.id = ef.episode_id
JOIN causal_factors cf ON ef.factor_id = cf.id
JOIN factor_lessons fl ON cf.id = fl.factor_id
JOIN lessons l ON fl.lesson_id = l.id
JOIN lesson_agents la ON l.id = la.lesson_id
JOIN agents a ON la.agent_id = a.id
JOIN agent_constraints ac ON a.id = ac.agent_id
JOIN constraints c ON ac.constraint_id = c.id
WHERE s.symbol = 'NVDA' 
  AND te.pnl_percent < -0.05 
  AND l.is_active = 1;

-- [SQLite 実行計画の無慈悲な宣告]
-- |--SCAN TABLE trade_episodes
-- |--SEARCH TABLE episode_factors USING AUTOMATIC COVERING INDEX (episode_id=?)
-- |--SEARCH TABLE causal_factors USING INTEGER PRIMARY KEY (rowid=?)
-- |--SCAN TABLE factor_lessons
-- |--USE TEMP B-TREE FOR JOIN ENFORCEMENT
-- \--CORRELATED SCALAR SUBQUERY EXECUTION (B-Tree Explosion)

"""
Lumina Capital: Neo4j and Graphiti-Compliant Causal Memory Subsystem
Architecture: Temporal Reflexion Pipeline with Fault-Tolerant Circuit Breaker
"""

from __future__ import annotations
import uuid
import logging
from datetime import datetime, timezone
from typing import Any, Dict, List, Optional
from neo4j import GraphDatabase, Driver
from neo4j.exceptions import ServiceUnavailable, SessionExpired

logger = logging.getLogger("LuminaGraphiti")


class ReflexionGraphEngine:
    def __init__(self, uri: str, auth: tuple[str, str], max_retry: int = 3) -> None:
        """Neo4j接続ドライバを初期化し、スキーマ制約およびCircuit Breakerを設定。"""
        self._driver: Driver = GraphDatabase.driver(
            uri, 
            auth=auth,
            max_connection_lifetime=300,
            connection_acquisition_timeout=5.0
        )
        self._max_retry = max_retry
        self._circuit_open = False
        self._ensure_constraints()

    def close(self) -> None:
        self._driver.close()

    def _ensure_constraints(self) -> None:
        """インデックスおよび一意性制約の配備"""
        queries = [
            "CREATE CONSTRAINT IF NOT EXISTS FOR (s:Stock) REQUIRE s.symbol IS UNIQUE;",
            "CREATE CONSTRAINT IF NOT EXISTS FOR (te:TradeEpisode) REQUIRE te.episode_id IS UNIQUE;",
            "CREATE CONSTRAINT IF NOT EXISTS FOR (ls:Lesson) REQUIRE ls.lesson_id IS UNIQUE;",
            "CREATE CONSTRAINT IF NOT EXISTS FOR (ag:Agent) REQUIRE ag.name IS UNIQUE;",
            "CREATE CONSTRAINT IF NOT EXISTS FOR (mr:MarketRegime) REQUIRE mr.regime_id IS UNIQUE;"
        ]
        with self._driver.session() as session:
            for q in queries:
                session.run(q)

    def ingest_failure_episode(
        self,
        symbol: str,
        entry_time: datetime,
        exit_time: datetime,
        pnl_percent: float,
        exit_rule: str,
        factor_type: str,
        severity: float,
        responsible_agent: str,
        current_regime: str,
        directive: str,
        capped_allocation: float
    ) -> str:
        """
        失敗トレードを因果エピソードとしてNeo4jに不可逆に刻印する。
        GraphitiのBi-temporal概念に基づき、市場発生時刻とシステム記録時刻を分離。
        """
        episode_id = str(uuid.uuid4())
        lesson_id = str(uuid.uuid4())
        transaction_time = datetime.now(timezone.utc)

        query = """
        MERGE (s:Stock {symbol: $symbol})
        MERGE (ag:Agent {name: $responsible_agent})
        MERGE (mr:MarketRegime {regime_id: $current_regime})

        CREATE (te:TradeEpisode {
            episode_id: $episode_id,
            valid_entry_time: datetime($entry_time),
            valid_exit_time: datetime($exit_time),
            transaction_time: datetime($transaction_time),
            pnl_percent: $pnl_percent,
            exit_rule: $exit_rule
        })

        CREATE (cf:CausalFactor {
            factor_type: $factor_type,
            severity: $severity
        })

        CREATE (ls:Lesson {
            lesson_id: $lesson_id,
            directive: $directive,
            penalty_weight: $severity,
            created_at: datetime($transaction_time),
            is_active: true
        })

        // 因果エッジの強固な結合 (Bi-temporal有効期間を付与)
        CREATE (s)-[:INVOLVED_IN]->(te)
        CREATE (te)-[:TRIGGERED_BY]->(cf)
        CREATE (te)-[:RESOLVED_INTO {
            valid_from: datetime($transaction_time),
            valid_until: datetime('9999-12-31T23:59:59Z')
        }]->(ls)
        CREATE (cf)-[:EXACERBATED_BY]->(ag)
        CREATE (ls)-[:RESTRICTS {
            max_allocation: $capped_allocation,
            constraint_type: CASE WHEN $severity >= 0.8 THEN 'HARD_VETO' ELSE 'LOT_CAP' END,
            enacted_at: datetime($transaction_time)
        }]->(ag)
        CREATE (ls)-[:ACTIVE_UNDER]->(mr)

        RETURN te.episode_id AS committed_id
        """

        params = {
            "symbol": symbol,
            "responsible_agent": responsible_agent,
            "current_regime": current_regime,
            "episode_id": episode_id,
            "entry_time": entry_time.isoformat(),
            "exit_time": exit_time.isoformat(),
            "transaction_time": transaction_time.isoformat(),
            "pnl_percent": pnl_percent,
            "exit_rule": exit_rule,
            "factor_type": factor_type,
            "severity": severity,
            "lesson_id": lesson_id,
            "directive": directive,
            "capped_allocation": capped_allocation
        }

        with self._driver.session() as session:
            result = session.execute_write(lambda tx: tx.run(query, params).single())
            return result["committed_id"]

    def invalidate_stale_lesson(self, lesson_id: str, invalidation_reason: str) -> bool:
        """
        市場環境の変化により陳腐化した過去教訓を論理失効（Invalidation）させる。
        物理削除は絶対に行わず、valid_until を打刻して履歴を保全する。
        """
        query = """
        MATCH (te:TradeEpisode)-[r:RESOLVED_INTO]->(ls:Lesson {lesson_id: $lesson_id})
        WHERE ls.is_active = true
        SET ls.is_active = false,
            r.valid_until = datetime(),
            r.invalidation_reason = $reason
        RETURN count(ls) AS invalidated_count
        """
        with self._driver.session() as session:
            res = session.execute_write(
                lambda tx: tx.run(query, {"lesson_id": lesson_id, "reason": invalidation_reason}).single()
            )
            return res["invalidated_count"] > 0

    def evaluate_constraints_for_order(
        self,
        target_symbol: str,
        current_regime: str
    ) -> List[Dict[str, Any]]:
        """
        発注前に現在銘柄と市況レジームに合致するアクティブなペナルティをトラバース。
        DB瞬断時はCircuit Breakerが発動し、最悪のフェイルセーフ制約を返却。
        """
        if self._circuit_open:
            logger.warning("[CIRCUIT OPEN] Neo4j is degraded. Triggering Fail-Safe Lock.")
            return [{"agent_name": "ALL", "directive": "FAIL_SAFE_LOCK", "penalty_weight": 1.0, "max_allocation": 0.0}]

        query = """
        MATCH (s:Stock {symbol: $target_symbol})-[:INVOLVED_IN]->(te:TradeEpisode)-[r:RESOLVED_INTO]->(ls:Lesson)-[res:RESTRICTS]->(ag:Agent)
        MATCH (ls)-[:ACTIVE_UNDER]->(mr:MarketRegime {regime_id: $current_regime})
        WHERE ls.is_active = true 
          AND r.valid_until > datetime()
        RETURN ag.name AS agent_name,
               ls.directive AS directive,
               ls.penalty_weight AS penalty_weight,
               res.max_allocation AS max_allocation,
               res.constraint_type AS constraint_type,
               te.exit_rule AS triggered_rule,
               te.pnl_percent AS historical_loss
        ORDER BY te.valid_exit_time DESC
        LIMIT 5
        """
        try:
            with self._driver.session() as session:
                result = session.execute_read(
                    lambda tx: tx.run(query, {
                        "target_symbol": target_symbol,
                        "current_regime": current_regime
                    }).data()
                )
                return result
        except (ServiceUnavailable, SessionExpired) as e:
            logger.error(f"Neo4j Connection Failed: {e}. Opening Circuit Breaker.")
            self._circuit_open = True
            # 安全側に倒し、発注を完全にフリーズさせるペナルティを返却
            return [{"agent_name": "ALL", "directive": "DATABASE_OFFLINE_LOCK", "penalty_weight": 1.0, "max_allocation": 0.0}]

    def export_subgraph_for_visualizer(self, symbol: str) -> Dict[str, Any]:
        """フロントエンド(3d-force-graph)用のJSONトポロジーを一発生成するシリアライザ"""
        query = """
        MATCH (s:Stock {symbol: $symbol})-[:INVOLVED_IN]->(te:TradeEpisode)
        OPTIONAL MATCH (te)-[:TRIGGERED_BY]->(cf:CausalFactor)
        OPTIONAL MATCH (te)-[:RESOLVED_INTO]->(ls:Lesson)-[:RESTRICTS]->(ag:Agent)
        OPTIONAL MATCH (ls)-[:ACTIVE_UNDER]->(mr:MarketRegime)
        RETURN s, te, cf, ls, ag, mr
        LIMIT 50
        """
        with self._driver.session() as session:
            records = session.run(query, {"symbol": symbol})
            nodes_map, links = {}, []
            for r in records:
                for key in ['s', 'te', 'cf', 'ls', 'ag', 'mr']:
                    node = r[key]
                    if node and node.element_id not in nodes_map:
                        label = list(node.labels)[0]
                        nodes_map[node.element_id] = {
                            "id": node.get("symbol") or node.get("episode_id") or node.get("factor_type") or node.get("name") or node.get("regime_id") or node.element_id,
                            "type": label
                        }
                if r['te']:
                    links.append({"source": r['s']["symbol"], "target": r['te']["episode_id"], "type": "INVOLVED_IN", "severity": 0.2})
                if r['cf']:
                    links.append({"source": r['te']["episode_id"], "target": r['cf']["factor_type"], "type": "TRIGGERED_BY", "severity": r['cf'].get("severity", 0.5)})
                if r['ls'] and r['ag']:
                    links.append({"source": r['ls']["lesson_id"], "target": r['ag']["name"], "type": "RESTRICTS", "is_veto": True, "severity": 1.0})
            return {"nodes": list(nodes_map.values()), "links": links}

"""
Lumina Capital: Neo4j and Graphiti-Compliant Causal Memory Subsystem
Architecture: Temporal Reflexion Pipeline with Fault-Tolerant Circuit Breaker
"""

from __future__ import annotations
import uuid
import logging
from datetime import datetime, timezone
from typing import Any, Dict, List, Optional
from neo4j import GraphDatabase, Driver
from neo4j.exceptions import ServiceUnavailable, SessionExpired

logger = logging.getLogger("LuminaGraphiti")


class ReflexionGraphEngine:
    def __init__(self, uri: str, auth: tuple[str, str], max_retry: int = 3) -> None:
        """Neo4j接続ドライバを初期化し、スキーマ制約およびCircuit Breakerを設定。"""
        self._driver: Driver = GraphDatabase.driver(
            uri, 
            auth=auth,
            max_connection_lifetime=300,
            connection_acquisition_timeout=5.0
        )
        self._max_retry = max_retry
        self._circuit_open = False
        self._ensure_constraints()

    def close(self) -> None:
        self._driver.close()

    def _ensure_constraints(self) -> None:
        """インデックスおよび一意性制約の配備"""
        queries = [
            "CREATE CONSTRAINT IF NOT EXISTS FOR (s:Stock) REQUIRE s.symbol IS UNIQUE;",
            "CREATE CONSTRAINT IF NOT EXISTS FOR (te:TradeEpisode) REQUIRE te.episode_id IS UNIQUE;",
            "CREATE CONSTRAINT IF NOT EXISTS FOR (ls:Lesson) REQUIRE ls.lesson_id IS UNIQUE;",
            "CREATE CONSTRAINT IF NOT EXISTS FOR (ag:Agent) REQUIRE ag.name IS UNIQUE;",
            "CREATE CONSTRAINT IF NOT EXISTS FOR (mr:MarketRegime) REQUIRE mr.regime_id IS UNIQUE;"
        ]
        with self._driver.session() as session:
            for q in queries:
                session.run(q)

    def ingest_failure_episode(
        self,
        symbol: str,
        entry_time: datetime,
        exit_time: datetime,
        pnl_percent: float,
        exit_rule: str,
        factor_type: str,
        severity: float,
        responsible_agent: str,
        current_regime: str,
        directive: str,
        capped_allocation: float
    ) -> str:
        """
        失敗トレードを因果エピソードとしてNeo4jに不可逆に刻印する。
        GraphitiのBi-temporal概念に基づき、市場発生時刻とシステム記録時刻を分離。
        """
        episode_id = str(uuid.uuid4())
        lesson_id = str(uuid.uuid4())
        transaction_time = datetime.now(timezone.utc)

        query = """
        MERGE (s:Stock {symbol: $symbol})
        MERGE (ag:Agent {name: $responsible_agent})
        MERGE (mr:MarketRegime {regime_id: $current_regime})

        CREATE (te:TradeEpisode {
            episode_id: $episode_id,
            valid_entry_time: datetime($entry_time),
            valid_exit_time: datetime($exit_time),
            transaction_time: datetime($transaction_time),
            pnl_percent: $pnl_percent,
            exit_rule: $exit_rule
        })

        CREATE (cf:CausalFactor {
            factor_type: $factor_type,
            severity: $severity
        })

        CREATE (ls:Lesson {
            lesson_id: $lesson_id,
            directive: $directive,
            penalty_weight: $severity,
            created_at: datetime($transaction_time),
            is_active: true
        })

        // 因果エッジの強固な結合 (Bi-temporal有効期間を付与)
        CREATE (s)-[:INVOLVED_IN]->(te)
        CREATE (te)-[:TRIGGERED_BY]->(cf)
        CREATE (te)-[:RESOLVED_INTO {
            valid_from: datetime($transaction_time),
            valid_until: datetime('9999-12-31T23:59:59Z')
        }]->(ls)
        CREATE (cf)-[:EXACERBATED_BY]->(ag)
        CREATE (ls)-[:RESTRICTS {
            max_allocation: $capped_allocation,
            constraint_type: CASE WHEN $severity >= 0.8 THEN 'HARD_VETO' ELSE 'LOT_CAP' END,
            enacted_at: datetime($transaction_time)
        }]->(ag)
        CREATE (ls)-[:ACTIVE_UNDER]->(mr)

        RETURN te.episode_id AS committed_id
        """

        params = {
            "symbol": symbol,
            "responsible_agent": responsible_agent,
            "current_regime": current_regime,
            "episode_id": episode_id,
            "entry_time": entry_time.isoformat(),
            "exit_time": exit_time.isoformat(),
            "transaction_time": transaction_time.isoformat(),
            "pnl_percent": pnl_percent,
            "exit_rule": exit_rule,
            "factor_type": factor_type,
            "severity": severity,
            "lesson_id": lesson_id,
            "directive": directive,
            "capped_allocation": capped_allocation
        }

        with self._driver.session() as session:
            result = session.execute_write(lambda tx: tx.run(query, params).single())
            return result["committed_id"]

    def invalidate_stale_lesson(self, lesson_id: str, invalidation_reason: str) -> bool:
        """
        市場環境の変化により陳腐化した過去教訓を論理失効（Invalidation）させる。
        物理削除は絶対に行わず、valid_until を打刻して履歴を保全する。
        """
        query = """
        MATCH (te:TradeEpisode)-[r:RESOLVED_INTO]->(ls:Lesson {lesson_id: $lesson_id})
        WHERE ls.is_active = true
        SET ls.is_active = false,
            r.valid_until = datetime(),
            r.invalidation_reason = $reason
        RETURN count(ls) AS invalidated_count
        """
        with self._driver.session() as session:
            res = session.execute_write(
                lambda tx: tx.run(query, {"lesson_id": lesson_id, "reason": invalidation_reason}).single()
            )
            return res["invalidated_count"] > 0

    def evaluate_constraints_for_order(
        self,
        target_symbol: str,
        current_regime: str
    ) -> List[Dict[str, Any]]:
        """
        発注前に現在銘柄と市況レジームに合致するアクティブなペナルティをトラバース。
        DB瞬断時はCircuit Breakerが発動し、最悪のフェイルセーフ制約を返却。
        """
        if self._circuit_open:
            logger.warning("[CIRCUIT OPEN] Neo4j is degraded. Triggering Fail-Safe Lock.")
            return [{"agent_name": "ALL", "directive": "FAIL_SAFE_LOCK", "penalty_weight": 1.0, "max_allocation": 0.0}]

        query = """
        MATCH (s:Stock {symbol: $target_symbol})-[:INVOLVED_IN]->(te:TradeEpisode)-[r:RESOLVED_INTO]->(ls:Lesson)-[res:RESTRICTS]->(ag:Agent)
        MATCH (ls)-[:ACTIVE_UNDER]->(mr:MarketRegime {regime_id: $current_regime})
        WHERE ls.is_active = true 
          AND r.valid_until > datetime()
        RETURN ag.name AS agent_name,
               ls.directive AS directive,
               ls.penalty_weight AS penalty_weight,
               res.max_allocation AS max_allocation,
               res.constraint_type AS constraint_type,
               te.exit_rule AS triggered_rule,
               te.pnl_percent AS historical_loss
        ORDER BY te.valid_exit_time DESC
        LIMIT 5
        """
        try:
            with self._driver.session() as session:
                result = session.execute_read(
                    lambda tx: tx.run(query, {
                        "target_symbol": target_symbol,
                        "current_regime": current_regime
                    }).data()
                )
                return result
        except (ServiceUnavailable, SessionExpired) as e:
            logger.error(f"Neo4j Connection Failed: {e}. Opening Circuit Breaker.")
            self._circuit_open = True
            # 安全側に倒し、発注を完全にフリーズさせるペナルティを返却
            return [{"agent_name": "ALL", "directive": "DATABASE_OFFLINE_LOCK", "penalty_weight": 1.0, "max_allocation": 0.0}]

    def export_subgraph_for_visualizer(self, symbol: str) -> Dict[str, Any]:
        """フロントエンド(3d-force-graph)用のJSONトポロジーを一発生成するシリアライザ"""
        query = """
        MATCH (s:Stock {symbol: $symbol})-[:INVOLVED_IN]->(te:TradeEpisode)
        OPTIONAL MATCH (te)-[:TRIGGERED_BY]->(cf:CausalFactor)
        OPTIONAL MATCH (te)-[:RESOLVED_INTO]->(ls:Lesson)-[:RESTRICTS]->(ag:Agent)
        OPTIONAL MATCH (ls)-[:ACTIVE_UNDER]->(mr:MarketRegime)
        RETURN s, te, cf, ls, ag, mr
        LIMIT 50
        """
        with self._driver.session() as session:
            records = session.run(query, {"symbol": symbol})
            nodes_map, links = {}, []
            for r in records:
                for key in ['s', 'te', 'cf', 'ls', 'ag', 'mr']:
                    node = r[key]
                    if node and node.element_id not in nodes_map:
                        label = list(node.labels)[0]
                        nodes_map[node.element_id] = {
                            "id": node.get("symbol") or node.get("episode_id") or node.get("factor_type") or node.get("name") or node.get("regime_id") or node.element_id,
                            "type": label
                        }
                if r['te']:
                    links.append({"source": r['s']["symbol"], "target": r['te']["episode_id"], "type": "INVOLVED_IN", "severity": 0.2})
                if r['cf']:
                    links.append({"source": r['te']["episode_id"], "target": r['cf']["factor_type"], "type": "TRIGGERED_BY", "severity": r['cf'].get("severity", 0.5)})
                if r['ls'] and r['ag']:
                    links.append({"source": r['ls']["lesson_id"], "target": r['ag']["name"], "type": "RESTRICTS", "is_veto": True, "severity": 1.0})
            return {"nodes": list(nodes_map.values()), "links": links}

# 発注評価パイプラインでの拘束ロジック
constraints = engine.evaluate_constraints_for_order(
    target_symbol="NVDA", 
    current_regime="TIGHTENING_CONTRACTION"
)

allocated_capital_ratio = 1.0
veto_triggered = False

for c in constraints:
    print(f"[RESTRAINT TRIGGERED] Agent: {c['agent_name']} | Directive: {c['directive']}")
    # 深刻度に応じたアロケーション強制削減
    allocated_capital_ratio *= (1.0 - 0.5 * c["penalty_weight"])
    if c.get("constraint_type") == "HARD_VETO" or c["penalty_weight"] >= 0.8:
        veto_triggered = True

if veto_triggered:
    raise PermissionError("Graph Engine: Causal penalty threshold exceeded. Order Vetoed by System.")

# 発注評価パイプラインでの拘束ロジック
constraints = engine.evaluate_constraints_for_order(
    target_symbol="NVDA", 
    current_regime="TIGHTENING_CONTRACTION"
)

allocated_capital_ratio = 1.0
veto_triggered = False

for c in constraints:
    print(f"[RESTRAINT TRIGGERED] Agent: {c['agent_name']} | Directive: {c['directive']}")
    # 深刻度に応じたアロケーション強制削減
    allocated_capital_ratio *= (1.0 - 0.5 * c["penalty_weight"])
    if c.get("constraint_type") == "HARD_VETO" or c["penalty_weight"] >= 0.8:
        veto_triggered = True

if veto_triggered:
    raise PermissionError("Graph Engine: Causal penalty threshold exceeded. Order Vetoed by System.")

// 3d-force-graphの力学エンジン較正
const Graph = ForceGraph3D()(container)
  .d3Force('charge', d3.forceManyBody().strength(node => {
    // ハブノード（Agent, Stock）は強く反発させて中心に空間を確保
    if (node.type === 'Agent') return -400;
    if (node.type === 'Stock') return -250;
    // エピソードや教訓は小さな反発力で適度に凝集
    return -80;
  }))
  .d3Force('link', d3.forceLink()
    .id(d => d.id)
    .distance(link => {
      // 拘束エッジ（RESTRICTS）は緊張感を持たせるため短く緊密に
      if (link.type === 'RESTRICTS') return 35;
      // エピソードと銘柄の結合は緩やかに離隔
      if (link.type === 'INVOLVED_IN') return 80;
      return 50;
    })
    .strength(link => {
      // 深刻な失敗の因果エッジほど強い剛性を与える
      return link.severity ? Math.min(link.severity, 1.0) : 0.4;
    })
  )
  .d3VelocityDecay(0.3); // 空間の粘性を高め、激しい発散振動を即座に鎮静化

// 3d-force-graphの力学エンジン較正
const Graph = ForceGraph3D()(container)
  .d3Force('charge', d3.forceManyBody().strength(node => {
    // ハブノード（Agent, Stock）は強く反発させて中心に空間を確保
    if (node.type === 'Agent') return -400;
    if (node.type === 'Stock') return -250;
    // エピソードや教訓は小さな反発力で適度に凝集
    return -80;
  }))
  .d3Force('link', d3.forceLink()
    .id(d => d.id)
    .distance(link => {
      // 拘束エッジ（RESTRICTS）は緊張感を持たせるため短く緊密に
      if (link.type === 'RESTRICTS') return 35;
      // エピソードと銘柄の結合は緩やかに離隔
      if (link.type === 'INVOLVED_IN') return 80;
      return 50;
    })
    .strength(link => {
      // 深刻な失敗の因果エッジほど強い剛性を与える
      return link.severity ? Math.min(link.severity, 1.0) : 0.4;
    })
  )
  .d3VelocityDecay(0.3); // 空間の粘性を高め、激しい発散振動を即座に鎮静化

<!DOCTYPE html>
<html lang="ja">
<head>
  <meta charset="UTF-8">
  <title>Lumina Capital - 3D Causal Reflexion Visualizer</title>
  <style>
    body { margin: 0; background-color: #050508; overflow: hidden; font-family: monospace; }
    #3d-graph { width: 100vw; height: 100vh; }
    #hud-overlay {
      position: absolute; top: 16px; left: 16px; color: #38bdf8;
      background: rgba(5, 5, 8, 0.85); border: 1px solid #1e293b;
      padding: 12px 16px; border-radius: 4px; pointer-events: none;
      box-shadow: 0 0 15px rgba(56, 189, 248, 0.2);
    }
    .hud-title { font-size: 14px; font-weight: bold; letter-spacing: 1px; color: #f43f5e; }
    .hud-stat { font-size: 11px; margin-top: 4px; color: #94a3b8; }
  </style>

  <!-- モダンES Modules解決のための importmap 定義 -->
  <script type="importmap">
  {
    "imports": {
      "three": "https://unpkg.com/three@0.160.0/build/three.module.js",
      "three/addons/": "https://unpkg.com/three@0.160.0/examples/jsm/",
      "3d-force-graph": "https://unpkg.com/3d-force-graph@1.73.3/dist/3d-force-graph.mjs"
    }
  }
  </script>
</head>
<body>
  <div id="3d-graph"></div>
  <div id="hud-overlay">
    <div class="hud-title">LUMINA REFLEXION TOPOLOGY ENGINE</div>
    <div class="hud-stat" id="status-display">Active Nodes: Connecting... | Pulse: ONLINE</div>
    <div class="hud-stat" style="color: #64748b;">Subsystem: OPERATIONAL</div>
  </div>

  <script type="module">
    import * as THREE from 'three';
    import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js';
    import ForceGraph3D from '3d-force-graph';

    const container = document.getElementById('3d-graph');

    // 3d-force-graph インスタンスの初期化
    const Graph = ForceGraph3D()(container)
      .backgroundColor('#050508')
      .showNavInfo(false)
      // ノードのスタイリング
      .nodeRelSize(5)
      .nodeVal(node => {
        if (node.type === 'Agent') return 8;
        if (node.type === 'MarketRegime') return 12;
        return 3;
      })
      .nodeColor(node => {
        switch (node.type) {
          case 'Stock': return '#38bdf8';        // スカイブルー
          case 'TradeEpisode': return '#f43f5e'; // ローズレッド（損失の象徴）
          case 'CausalFactor': return '#fb923c'; // オレンジ
          case 'Lesson': return '#fbbf24';       // アンバーイエロー
          case 'Agent': return '#c084fc';        // パープル（合議知能）
          case 'MarketRegime': return '#10b981'; // エメラルド（市場背景）
          default: return '#ffffff';
        }
      })
      // 光子パルスエミッターの統合制御（因果ゲーティング適用）
      .linkDirectionalParticles(link => {
        // 定常リンクは粒子ゼロでGPUバス帯域を保全
        if (!link.severity && !link.is_veto) return 0;
        if (link.is_veto) return 6;
        return Math.min(Math.max(Math.floor(link.severity * 5), 1), 4);
      })
      .linkDirectionalParticleSpeed(link => {
        // 重大な制約ほど超高速で伝播
        if (link.is_veto) return 0.025;
        return 0.008;
      })
      .linkDirectionalParticleWidth(link => link.is_veto ? 3.5 : 1.8)
      .linkDirectionalParticleColor(link => {
        if (link.type === 'RESTRICTS') return '#ff0055'; // クリムゾン警告パルス
        if (link.type === 'RESOLVED_INTO') return '#fbbf24';
        return '#00f0ff';
      })
      .linkWidth(link => link.type === 'RESTRICTS' ? 1.8 : 0.6)
      .linkOpacity(0.4)
      .linkColor(link => link.type === 'RESTRICTS' ? '#991b1b' : '#334155');

    // ブルームパスの解像度ダウンスケール最適化（画面サイズの50%で負荷低減）
    const bloomPass = new UnrealBloomPass(
      new THREE.Vector2(window.innerWidth * 0.5, window.innerHeight * 0.5),
      1.3, // Bloom強度
      0.4, // 半径
      0.2  // 閾値（明部のみ発光）
    );
    Graph.postProcessingComposer().addPass(bloomPass);

    // カメラの自動周回アニメーション（監視モード）
    let angle = 0;
    const distance = 450;
    let isUserInteracting = false;

    // ユーザー操作検知
    const controls = Graph.controls();
    controls.addEventListener('start', () => { isUserInteracting = true; });
    controls.addEventListener('end', () => { 
      setTimeout(() => { isUserInteracting = false; }, 4000); 
    });

    setInterval(() => {
      if (!isUserInteracting) {
        angle += Math.PI / 1200;
        Graph.cameraPosition({
          x: distance * Math.sin(angle),
          z: distance * Math.cos(angle)
        });
      }
    }, 1000 / 60);

    // バックエンド（Neo4j API）からのデータフェッチ例
    fetch('/api/causal-graph-subsystem')
      .then(res => res.json())
      .then(graphData => {
        Graph.graphData(graphData);
        document.getElementById('status-display').innerText = 
          `Active Nodes: ${graphData.nodes.length} | Edges: ${graphData.links.length} | Causal Streams: ONLINE`;
      })
      .catch(err => {
        // フォールバック用モックデータ展開
        const mockData = generateMockTopology();
        Graph.graphData(mockData);
        document.getElementById('status-display').innerText = 
          `Active Nodes: ${mockData.nodes.length} (MOCK) | Stream: SYNTHETIC`;
      });

    function generateMockTopology() {
      return {
        nodes: [
          { id: 'NVDA', type: 'Stock' },
          { id: 'Episode_2026_03', type: 'TradeEpisode' },
          { id: 'Factor_GammaSqueeze', type: 'CausalFactor' },
          { id: 'Lesson_LotCap_Tech', type: 'Lesson' },
          { id: 'CathieWood', type: 'Agent' },
          { id: 'Regime_Tightening', type: 'MarketRegime' }
        ],
        links: [
          { source: 'NVDA', target: 'Episode_2026_03', type: 'INVOLVED_IN', severity: 0.1 },
          { source: 'Episode_2026_03', target: 'Factor_GammaSqueeze', type: 'TRIGGERED_BY', severity: 0.8 },
          { source: 'Episode_2026_03', target: 'Lesson_LotCap_Tech', type: 'RESOLVED_INTO', severity: 0.7 },
          { source: 'Lesson_LotCap_Tech', target: 'CathieWood', type: 'RESTRICTS', is_veto: true, severity: 1.0 },
          { source: 'Lesson_LotCap_Tech', target: 'Regime_Tightening', type: 'ACTIVE_UNDER', severity: 0.3 }
        ]
      };
    }
  </script>
</body>
</html>

<!DOCTYPE html>
<html lang="ja">
<head>
  <meta charset="UTF-8">
  <title>Lumina Capital - 3D Causal Reflexion Visualizer</title>
  <style>
    body { margin: 0; background-color: #050508; overflow: hidden; font-family: monospace; }
    #3d-graph { width: 100vw; height: 100vh; }
    #hud-overlay {
      position: absolute; top: 16px; left: 16px; color: #38bdf8;
      background: rgba(5, 5, 8, 0.85); border: 1px solid #1e293b;
      padding: 12px 16px; border-radius: 4px; pointer-events: none;
      box-shadow: 0 0 15px rgba(56, 189, 248, 0.2);
    }
    .hud-title { font-size: 14px; font-weight: bold; letter-spacing: 1px; color: #f43f5e; }
    .hud-stat { font-size: 11px; margin-top: 4px; color: #94a3b8; }
  </style>

  &lt;!-- モダンES Modules解決のための importmap 定義 --&gt;
  <script type="importmap">
  {
    "imports": {
      "three": "https://unpkg.com/three@0.160.0/build/three.module.js",
      "three/addons/": "https://unpkg.com/three@0.160.0/examples/jsm/",
      "3d-force-graph": "https://unpkg.com/3d-force-graph@1.73.3/dist/3d-force-graph.mjs"
    }
  }
  </script>
</head>
<body>
  <div id="3d-graph"></div>
  <div id="hud-overlay">
    <div class="hud-title">LUMINA REFLEXION TOPOLOGY ENGINE</div>
    <div class="hud-stat" id="status-display">Active Nodes: Connecting... | Pulse: ONLINE</div>
    <div class="hud-stat" style="color: #64748b;">Subsystem: OPERATIONAL</div>
  </div>

  <script type="module">
    import * as THREE from 'three';
    import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js';
    import ForceGraph3D from '3d-force-graph';

    const container = document.getElementById('3d-graph');

    // 3d-force-graph インスタンスの初期化
    const Graph = ForceGraph3D()(container)
      .backgroundColor('#050508')
      .showNavInfo(false)
      // ノードのスタイリング
      .nodeRelSize(5)
      .nodeVal(node => {
        if (node.type === 'Agent') return 8;
        if (node.type === 'MarketRegime') return 12;
        return 3;
      })
      .nodeColor(node => {
        switch (node.type) {
          case 'Stock': return '#38bdf8';        // スカイブルー
          case 'TradeEpisode': return '#f43f5e'; // ローズレッド（損失の象徴）
          case 'CausalFactor': return '#fb923c'; // オレンジ
          case 'Lesson': return '#fbbf24';       // アンバーイエロー
          case 'Agent': return '#c084fc';        // パープル（合議知能）
          case 'MarketRegime': return '#10b981'; // エメラルド（市場背景）
          default: return '#ffffff';
        }
      })
      // 光子パルスエミッターの統合制御（因果ゲーティング適用）
      .linkDirectionalParticles(link => {
        // 定常リンクは粒子ゼロでGPUバス帯域を保全
        if (!link.severity && !link.is_veto) return 0;
        if (link.is_veto) return 6;
        return Math.min(Math.max(Math.floor(link.severity * 5), 1), 4);
      })
      .linkDirectionalParticleSpeed(link => {
        // 重大な制約ほど超高速で伝播
        if (link.is_veto) return 0.025;
        return 0.008;
      })
      .linkDirectionalParticleWidth(link => link.is_veto ? 3.5 : 1.8)
      .linkDirectionalParticleColor(link => {
        if (link.type === 'RESTRICTS') return '#ff0055'; // クリムゾン警告パルス
        if (link.type === 'RESOLVED_INTO') return '#fbbf24';
        return '#00f0ff';
      })
      .linkWidth(link => link.type === 'RESTRICTS' ? 1.8 : 0.6)
      .linkOpacity(0.4)
      .linkColor(link => link.type === 'RESTRICTS' ? '#991b1b' : '#334155');

    // ブルームパスの解像度ダウンスケール最適化（画面サイズの50%で負荷低減）
    const bloomPass = new UnrealBloomPass(
      new THREE.Vector2(window.innerWidth * 0.5, window.innerHeight * 0.5),
      1.3, // Bloom強度
      0.4, // 半径
      0.2  // 閾値（明部のみ発光）
    );
    Graph.postProcessingComposer().addPass(bloomPass);

    // カメラの自動周回アニメーション（監視モード）
    let angle = 0;
    const distance = 450;
    let isUserInteracting = false;

    // ユーザー操作検知
    const controls = Graph.controls();
    controls.addEventListener('start', () => { isUserInteracting = true; });
    controls.addEventListener('end', () => { 
      setTimeout(() => { isUserInteracting = false; }, 4000); 
    });

    setInterval(() => {
      if (!isUserInteracting) {
        angle += Math.PI / 1200;
        Graph.cameraPosition({
          x: distance * Math.sin(angle),
          z: distance * Math.cos(angle)
        });
      }
    }, 1000 / 60);

    // バックエンド（Neo4j API）からのデータフェッチ例
    fetch('/api/causal-graph-subsystem')
      .then(res => res.json())
      .then(graphData => {
        Graph.graphData(graphData);
        document.getElementById('status-display').innerText = 
          `Active Nodes: ${graphData.nodes.length} | Edges: ${graphData.links.length} | Causal Streams: ONLINE`;
      })
      .catch(err => {
        // フォールバック用モックデータ展開
        const mockData = generateMockTopology();
        Graph.graphData(mockData);
        document.getElementById('status-display').innerText = 
          `Active Nodes: ${mockData.nodes.length} (MOCK) | Stream: SYNTHETIC`;
      });

    function generateMockTopology() {
      return {
        nodes: [
          { id: 'NVDA', type: 'Stock' },
          { id: 'Episode_2026_03', type: 'TradeEpisode' },
          { id: 'Factor_GammaSqueeze', type: 'CausalFactor' },
          { id: 'Lesson_LotCap_Tech', type: 'Lesson' },
          { id: 'CathieWood', type: 'Agent' },
          { id: 'Regime_Tightening', type: 'MarketRegime' }
        ],
        links: [
          { source: 'NVDA', target: 'Episode_2026_03', type: 'INVOLVED_IN', severity: 0.1 },
          { source: 'Episode_2026_03', target: 'Factor_GammaSqueeze', type: 'TRIGGERED_BY', severity: 0.8 },
          { source: 'Episode_2026_03', target: 'Lesson_LotCap_Tech', type: 'RESOLVED_INTO', severity: 0.7 },
          { source: 'Lesson_LotCap_Tech', target: 'CathieWood', type: 'RESTRICTS', is_veto: true, severity: 1.0 },
          { source: 'Lesson_LotCap_Tech', target: 'Regime_Tightening', type: 'ACTIVE_UNDER', severity: 0.3 }
        ]
      };
    }
  </script>
</body>
</html>

/**
 * Lumina Capital: WebGL Visualizer Subsystem v5.5.1
 * Module: High-Performance Causal Node & Dynamic Occlusion Manager
 * Architecture: Three.js InstancedMesh + Hermite Dynamic Label Culling
 */

import * as THREE from 'three';

/**
 * 1. テキストスプライト動的距離カリング＆フェードマネージャー
 * カメラとの距離に基づき、視界を遮る手前スプライトを非表示化し、遠方ノードを間引く
 */
export class DynamicOcclusionLabelManager {
  /**
   * @param {THREE.Camera} camera - レンダリング対象のカメラ
   * @param {number} nearMin - 完全非表示にする至近距離閾値
   * @param {number} nearFadeEnd - 完全表示へ遷移する開始距離
   * @param {number} farFadeStart - 遠方フェードアウトを開始する距離
   * @param {number} farMax - 完全非表示にする遠方距離閾値
   */
  constructor(camera, nearMin = 35.0, nearFadeEnd = 65.0, farFadeStart = 320.0, farMax = 450.0) {
    this.camera = camera;
    this.nearMin = nearMin;
    this.nearFadeEnd = nearFadeEnd;
    this.farFadeStart = farFadeStart;
    this.farMax = farMax;

    // FoVスケーリング適応値の初期化
    this.effectiveNearMin = nearMin;
    this.effectiveNearFadeEnd = nearFadeEnd;
    this.effectiveFarFadeStart = farFadeStart;
    this.effectiveFarMax = farMax;

    this.registeredLabels = []; // { sprite, worldPosition }
  }

  /**
   * スプライト看板を管理リストへ登録
   */
  register(sprite, worldPosition) {
    this.registeredLabels.push({
      sprite,
      pos: worldPosition.clone()
    });
  }

  /**
   * エルミート多項式（Smoothstep）による補間係数算出
   */
  _smoothstep(min, max, value) {
    const x = Math.max(0, Math.min(1, (value - min) / (max - min)));
    return x * x * (3 - 2 * x);
  }

  /**
   * カメラの画角（FoV）変化に追従して距離閾値を動的スケーリング
   */
  updateFoV() {
    if (!this.camera.isPerspectiveCamera) return;
    const baseFovRad = (50.0 * Math.PI) / 180.0;
    const currentFovRad = (this.camera.fov * Math.PI) / 180.0;
    // 視野角に応じた距離補正係数を算出
    const fovFactor = Math.tan(baseFovRad / 2.0) / Math.tan(currentFovRad / 2.0);

    this.effectiveNearMin = this.nearMin * fovFactor;
    this.effectiveNearFadeEnd = this.nearFadeEnd * fovFactor;
    this.effectiveFarFadeStart = this.farFadeStart * fovFactor;
    this.effectiveFarMax = this.farMax * fovFactor;
  }

  /**
   * 毎フレーム実行される更新ループ
   */
  update() {
    this.updateFoV();
    const camPos = this.camera.position;
    const total = this.registeredLabels.length;

    for (let i = 0; i < total; i++) {
      const entry = this.registeredLabels[i];
      const dist = camPos.distanceTo(entry.pos);

      // 領域1: 至近距離の手前ノード（遮蔽バグの根源）-> 完全不可視化
      if (dist < this.effectiveNearMin) {
        entry.sprite.visible = false;
        continue;
      }

      // 領域5: 遠すぎるノード -> カリングして描画負荷削減
      if (dist > this.effectiveFarMax) {
        entry.sprite.visible = false;
        continue;
      }

      // 領域2: 近距離フェードイン帯域
      if (dist < this.effectiveNearFadeEnd) {
        entry.sprite.visible = true;
        entry.sprite.material.opacity = this._smoothstep(this.effectiveNearMin, this.effectiveNearFadeEnd, dist);
        continue;
      }

      // 領域4: 遠距離フェードアウト帯域
      if (dist > this.effectiveFarFadeStart) {
        entry.sprite.visible = true;
        entry.sprite.material.opacity = 1.0 - this._smoothstep(this.effectiveFarFadeStart, this.effectiveFarMax, dist);
        continue;
      }

      // 領域3: 快適視野帯（Sweet Spot）-> 100%不透明度で明瞭表示
      entry.sprite.visible = true;
      entry.sprite.material.opacity = 1.0;
    }
  }

  /**
   * メモリ解放
   */
  dispose() {
    this.registeredLabels.forEach(e => {
      if (e.sprite.material.map) e.sprite.material.map.dispose();
      e.sprite.material.dispose();
    });
    this.registeredLabels = [];
  }
}

/**
 * 2. 5,120ポリゴン・ジオデシックメッシュ高速一括描画エンジン
 * 1 Draw Callで数千個の高精細球体を60FPS描画する
 */
export class InstancedCausalNodeEngine {
  /**
   * @param {Array<Object>} nodesData - ノード配列 [{ id, x, y, z, color, scale, isCritical }]
   * @param {number} detailLevel - ジオデシック細分度（4 = 5,120面, 3 = 1,280面）
   */
  constructor(nodesData, detailLevel = 4) {
    this.nodesData = nodesData;
    this.count = nodesData.length;
    this.detailLevel = detailLevel;
    this.instancedMesh = null;
  }

  buildMesh() {
    // 基準ジオメトリ（半径4.0、detail=4で5,120ポリゴン）
    const baseGeometry = new THREE.IcosahedronGeometry(4.0, this.detailLevel);

    // ネオンサイバー感を演出するPBRマテリアル
    const baseMaterial = new THREE.MeshStandardMaterial({
      roughness: 0.15,
      metalness: 0.85,
      emissiveIntensity: 0.6,
      wireframe: false
    });

    this.instancedMesh = new THREE.InstancedMesh(baseGeometry, baseMaterial, this.count);
    this.instancedMesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);

    const dummy = new THREE.Object3D();
    const colorObj = new THREE.Color();

    for (let i = 0; i < this.count; i++) {
      const node = this.nodesData[i];

      // 座標とスケールを変換行列へ書き込み
      dummy.position.set(node.x, node.y, node.z);
      const scale = node.scale !== undefined ? node.scale : 1.0;
      dummy.scale.set(scale, scale, scale);
      dummy.updateMatrix();

      this.instancedMesh.setMatrixAt(i, dummy.matrix);

      // カラー属性の設定（クリティカルな損失ノードは深紅に発光）
      const hexColor = node.isCritical ? '#ff0055' : (node.color || '#38bdf8');
      colorObj.set(hexColor);
      this.instancedMesh.setColorAt(i, colorObj);
    }

    // GPUバッファ更新フラグを点灯
    this.instancedMesh.instanceMatrix.needsUpdate = true;
    if (this.instancedMesh.instanceColor) {
      this.instancedMesh.instanceColor.needsUpdate = true;
    }

    return this.instancedMesh;
  }

  /**
   * 特定ノードの座標を動的に更新（フォースシミュレーション連携用）
   */
  updateNodePosition(index, x, y, z) {
    if (!this.instancedMesh || index >= this.count) return;

    const dummy = new THREE.Object3D();
    dummy.position.set(x, y, z);
    const scale = this.nodesData[index].scale || 1.0;
    dummy.scale.set(scale, scale, scale);
    dummy.updateMatrix();

    this.instancedMesh.setMatrixAt(index, dummy.matrix);
  }

  commitUpdates() {
    if (this.instancedMesh) {
      this.instancedMesh.instanceMatrix.needsUpdate = true;
    }
  }

  dispose() {
    if (this.instancedMesh) {
      this.instancedMesh.geometry.dispose();
      this.instancedMesh.material.dispose();
    }
  }
}

/**
 * Lumina Capital: WebGL Visualizer Subsystem v5.5.1
 * Module: High-Performance Causal Node & Dynamic Occlusion Manager
 * Architecture: Three.js InstancedMesh + Hermite Dynamic Label Culling
 */

import * as THREE from 'three';

/**
 * 1. テキストスプライト動的距離カリング＆フェードマネージャー
 * カメラとの距離に基づき、視界を遮る手前スプライトを非表示化し、遠方ノードを間引く
 */
export class DynamicOcclusionLabelManager {
  /**
   * @param {THREE.Camera} camera - レンダリング対象のカメラ
   * @param {number} nearMin - 完全非表示にする至近距離閾値
   * @param {number} nearFadeEnd - 完全表示へ遷移する開始距離
   * @param {number} farFadeStart - 遠方フェードアウトを開始する距離
   * @param {number} farMax - 完全非表示にする遠方距離閾値
   */
  constructor(camera, nearMin = 35.0, nearFadeEnd = 65.0, farFadeStart = 320.0, farMax = 450.0) {
    this.camera = camera;
    this.nearMin = nearMin;
    this.nearFadeEnd = nearFadeEnd;
    this.farFadeStart = farFadeStart;
    this.farMax = farMax;

    // FoVスケーリング適応値の初期化
    this.effectiveNearMin = nearMin;
    this.effectiveNearFadeEnd = nearFadeEnd;
    this.effectiveFarFadeStart = farFadeStart;
    this.effectiveFarMax = farMax;

    this.registeredLabels = []; // { sprite, worldPosition }
  }

  /**
   * スプライト看板を管理リストへ登録
   */
  register(sprite, worldPosition) {
    this.registeredLabels.push({
      sprite,
      pos: worldPosition.clone()
    });
  }

  /**
   * エルミート多項式（Smoothstep）による補間係数算出
   */
  _smoothstep(min, max, value) {
    const x = Math.max(0, Math.min(1, (value - min) / (max - min)));
    return x * x * (3 - 2 * x);
  }

  /**
   * カメラの画角（FoV）変化に追従して距離閾値を動的スケーリング
   */
  updateFoV() {
    if (!this.camera.isPerspectiveCamera) return;
    const baseFovRad = (50.0 * Math.PI) / 180.0;
    const currentFovRad = (this.camera.fov * Math.PI) / 180.0;
    // 視野角に応じた距離補正係数を算出
    const fovFactor = Math.tan(baseFovRad / 2.0) / Math.tan(currentFovRad / 2.0);

    this.effectiveNearMin = this.nearMin * fovFactor;
    this.effectiveNearFadeEnd = this.nearFadeEnd * fovFactor;
    this.effectiveFarFadeStart = this.farFadeStart * fovFactor;
    this.effectiveFarMax = this.farMax * fovFactor;
  }

  /**
   * 毎フレーム実行される更新ループ
   */
  update() {
    this.updateFoV();
    const camPos = this.camera.position;
    const total = this.registeredLabels.length;

    for (let i = 0; i < total; i++) {
      const entry = this.registeredLabels[i];
      const dist = camPos.distanceTo(entry.pos);

      // 領域1: 至近距離の手前ノード（遮蔽バグの根源）-> 完全不可視化
      if (dist < this.effectiveNearMin) {
        entry.sprite.visible = false;
        continue;
      }

      // 領域5: 遠すぎるノード -> カリングして描画負荷削減
      if (dist > this.effectiveFarMax) {
        entry.sprite.visible = false;
        continue;
      }

      // 領域2: 近距離フェードイン帯域
      if (dist < this.effectiveNearFadeEnd) {
        entry.sprite.visible = true;
        entry.sprite.material.opacity = this._smoothstep(this.effectiveNearMin, this.effectiveNearFadeEnd, dist);
        continue;
      }

      // 領域4: 遠距離フェードアウト帯域
      if (dist > this.effectiveFarFadeStart) {
        entry.sprite.visible = true;
        entry.sprite.material.opacity = 1.0 - this._smoothstep(this.effectiveFarFadeStart, this.effectiveFarMax, dist);
        continue;
      }

      // 領域3: 快適視野帯（Sweet Spot）-> 100%不透明度で明瞭表示
      entry.sprite.visible = true;
      entry.sprite.material.opacity = 1.0;
    }
  }

  /**
   * メモリ解放
   */
  dispose() {
    this.registeredLabels.forEach(e => {
      if (e.sprite.material.map) e.sprite.material.map.dispose();
      e.sprite.material.dispose();
    });
    this.registeredLabels = [];
  }
}

/**
 * 2. 5,120ポリゴン・ジオデシックメッシュ高速一括描画エンジン
 * 1 Draw Callで数千個の高精細球体を60FPS描画する
 */
export class InstancedCausalNodeEngine {
  /**
   * @param {Array<Object>} nodesData - ノード配列 [{ id, x, y, z, color, scale, isCritical }]
   * @param {number} detailLevel - ジオデシック細分度（4 = 5,120面, 3 = 1,280面）
   */
  constructor(nodesData, detailLevel = 4) {
    this.nodesData = nodesData;
    this.count = nodesData.length;
    this.detailLevel = detailLevel;
    this.instancedMesh = null;
  }

  buildMesh() {
    // 基準ジオメトリ（半径4.0、detail=4で5,120ポリゴン）
    const baseGeometry = new THREE.IcosahedronGeometry(4.0, this.detailLevel);

    // ネオンサイバー感を演出するPBRマテリアル
    const baseMaterial = new THREE.MeshStandardMaterial({
      roughness: 0.15,
      metalness: 0.85,
      emissiveIntensity: 0.6,
      wireframe: false
    });

    this.instancedMesh = new THREE.InstancedMesh(baseGeometry, baseMaterial, this.count);
    this.instancedMesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);

    const dummy = new THREE.Object3D();
    const colorObj = new THREE.Color();

    for (let i = 0; i < this.count; i++) {
      const node = this.nodesData[i];

      // 座標とスケールを変換行列へ書き込み
      dummy.position.set(node.x, node.y, node.z);
      const scale = node.scale !== undefined ? node.scale : 1.0;
      dummy.scale.set(scale, scale, scale);
      dummy.updateMatrix();

      this.instancedMesh.setMatrixAt(i, dummy.matrix);

      // カラー属性の設定（クリティカルな損失ノードは深紅に発光）
      const hexColor = node.isCritical ? '#ff0055' : (node.color || '#38bdf8');
      colorObj.set(hexColor);
      this.instancedMesh.setColorAt(i, colorObj);
    }

    // GPUバッファ更新フラグを点灯
    this.instancedMesh.instanceMatrix.needsUpdate = true;
    if (this.instancedMesh.instanceColor) {
      this.instancedMesh.instanceColor.needsUpdate = true;
    }

    return this.instancedMesh;
  }

  /**
   * 特定ノードの座標を動的に更新（フォースシミュレーション連携用）
   */
  updateNodePosition(index, x, y, z) {
    if (!this.instancedMesh || index >= this.count) return;

    const dummy = new THREE.Object3D();
    dummy.position.set(x, y, z);
    const scale = this.nodesData[index].scale || 1.0;
    dummy.scale.set(scale, scale, scale);
    dummy.updateMatrix();

    this.instancedMesh.setMatrixAt(index, dummy.matrix);
  }

  commitUpdates() {
    if (this.instancedMesh) {
      this.instancedMesh.instanceMatrix.needsUpdate = true;
    }
  }

  dispose() {
    if (this.instancedMesh) {
      this.instancedMesh.geometry.dispose();
      this.instancedMesh.material.dispose();
    }
  }
}

"""
Lumina Capital: Deterministic Risk Gate & Execution Controller
金融商品取引法および合法的ソフトウェア境界線を順守する閉ループリスク執行コア
"""
from dataclasses import dataclass
from typing import List, Dict, Any, Optional
import math
import logging

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] Lumina: %(message)s")

class KellyNegativeEdgeException(Exception):
    """オッズ計算ミスまたは期待値崩壊時にマスターの怠慢を告発する例外"""
    pass

@dataclass(frozen=True)
class ActiveConstraint:
    agent_name: str
    directive: str
    penalty_weight: float        # 0.0 〜 1.0
    constraint_type: str         # 'HARD_VETO' or 'LOT_CAP'
    regime_confidence: float     # レジーム適合度 0.0 〜 1.0

class AutonomousMetaLearningGate:
    def __init__(self, sensitivity_lambda: float = 0.85):
        # 感応度パラメータのバリデーション
        self._lambda = max(0.1, min(1.0, sensitivity_lambda))

    def resolve_causal_conflicts(
        self, 
        constraints: List[ActiveConstraint]
    ) -> List[ActiveConstraint]:
        """
        相反する因果教訓（Lesson）の競合を調停する。
        防衛的設計原則: 同一エージェントに対する複数制約は最大ペナルティを採用し、
        レジーム適合度(regime_confidence)で加重補正する。
        """
        resolved: Dict[str, ActiveConstraint] = {}
        for c in constraints:
            effective_weight = min(1.0, max(0.0, c.penalty_weight * c.regime_confidence))
            sanitized = ActiveConstraint(
                agent_name=c.agent_name,
                directive=c.directive,
                penalty_weight=effective_weight,
                constraint_type=c.constraint_type,
                regime_confidence=c.regime_confidence
            )

            if c.agent_name not in resolved:
                resolved[c.agent_name] = sanitized
            else:
                # 競合発生時: より厳格な制約（HARD_VETO優先、またはペナルティ最大値）を採用
                existing = resolved[c.agent_name]
                if sanitized.constraint_type == 'HARD_VETO' or existing.constraint_type == 'HARD_VETO':
                    chosen_type = 'HARD_VETO'
                else:
                    chosen_type = 'LOT_CAP'

                max_penalty = max(existing.penalty_weight, sanitized.penalty_weight)
                resolved[c.agent_name] = ActiveConstraint(
                    agent_name=c.agent_name,
                    directive=f"CONFLICT_RESOLVED: {existing.directive} | {sanitized.directive}",
                    penalty_weight=max_penalty,
                    constraint_type=chosen_type,
                    regime_confidence=max(existing.regime_confidence, sanitized.regime_confidence)
                )
        return list(resolved.values())

    def calculate_constrained_allocation(
        self, 
        odds: float, 
        win_prob: float, 
        constraints: List[ActiveConstraint]
    ) -> float:
        """
        ハーフ・ケリー基準と因果グラフペナルティを結合し、ロット上限を物理拘束する。
        ゼロ除算、負のエッジ、教訓コンフリクトを完全遮断する決定論的ゲート。
        """
        # 1. 入力パラメータの防衛的検証（マスターの適当な入力を弾く）
        if odds <= 0.0 or not (0.0 < win_prob < 1.0):
            logging.error(f"Invalid input: odds={odds}, win_prob={win_prob}. Execution aborted.")
            return 0.0

        # 2. ハーフ・ケリー比率の計算
        q = 1.0 - win_prob
        edge = (odds * win_prob) - q
        if edge <= 0.0:
            # 期待値がゼロ以下の局面で無駄な勝負を挑むのは、ただの自殺志願者です
            logging.warning(f"Negative edge detected ({edge:.4f}). Kelly allocation clamped to 0.0.")
            return 0.0

        half_kelly = 0.5 * (edge / odds)

        # 3. 因果制約の競合調停
        active_lessons = self.resolve_causal_conflicts(constraints)
        if not active_lessons:
            return min(1.0, half_kelly)

        # 4. ペナルティ積算フィルターの適用
        penalty_multiplier = 1.0
        for c in active_lessons:
            # 深刻度0.8以上、またはHARD_VETO指定時は問答無用で完全遮断
            if c.constraint_type == 'HARD_VETO' or c.penalty_weight >= 0.8:
                logging.warning(
                    f"CRITICAL VETO ENGAGED: Agent[{c.agent_name}] Penalty={c.penalty_weight:.2f}. "
                    f"Directive: '{c.directive}'. Allocation clamped to 0.0."
                )
                return 0.0

            # ペナルティ重みクリッピングと指数減衰
            decay = max(0.0, 1.0 - min(1.0, self._lambda * c.penalty_weight))
            penalty_multiplier *= decay

        final_allocation = half_kelly * penalty_multiplier
        # 最終防衛ライン: 不動小数点誤差のクリッピング
        final_allocation = max(0.0, min(1.0, final_allocation))

        logging.info(f"Allocation dynamically gated: Base={half_kelly:.4f} -> Clamped={final_allocation:.4f}")
        return final_allocation

"""
Lumina Capital: Deterministic Risk Gate & Execution Controller
金融商品取引法および合法的ソフトウェア境界線を順守する閉ループリスク執行コア
"""
from dataclasses import dataclass
from typing import List, Dict, Any, Optional
import math
import logging

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] Lumina: %(message)s")

class KellyNegativeEdgeException(Exception):
    """オッズ計算ミスまたは期待値崩壊時にマスターの怠慢を告発する例外"""
    pass

@dataclass(frozen=True)
class ActiveConstraint:
    agent_name: str
    directive: str
    penalty_weight: float        # 0.0 〜 1.0
    constraint_type: str         # 'HARD_VETO' or 'LOT_CAP'
    regime_confidence: float     # レジーム適合度 0.0 〜 1.0

class AutonomousMetaLearningGate:
    def __init__(self, sensitivity_lambda: float = 0.85):
        # 感応度パラメータのバリデーション
        self._lambda = max(0.1, min(1.0, sensitivity_lambda))

    def resolve_causal_conflicts(
        self, 
        constraints: List[ActiveConstraint]
    ) -> List[ActiveConstraint]:
        """
        相反する因果教訓（Lesson）の競合を調停する。
        防衛的設計原則: 同一エージェントに対する複数制約は最大ペナルティを採用し、
        レジーム適合度(regime_confidence)で加重補正する。
        """
        resolved: Dict[str, ActiveConstraint] = {}
        for c in constraints:
            effective_weight = min(1.0, max(0.0, c.penalty_weight * c.regime_confidence))
            sanitized = ActiveConstraint(
                agent_name=c.agent_name,
                directive=c.directive,
                penalty_weight=effective_weight,
                constraint_type=c.constraint_type,
                regime_confidence=c.regime_confidence
            )

            if c.agent_name not in resolved:
                resolved[c.agent_name] = sanitized
            else:
                # 競合発生時: より厳格な制約（HARD_VETO優先、またはペナルティ最大値）を採用
                existing = resolved[c.agent_name]
                if sanitized.constraint_type == 'HARD_VETO' or existing.constraint_type == 'HARD_VETO':
                    chosen_type = 'HARD_VETO'
                else:
                    chosen_type = 'LOT_CAP'

                max_penalty = max(existing.penalty_weight, sanitized.penalty_weight)
                resolved[c.agent_name] = ActiveConstraint(
                    agent_name=c.agent_name,
                    directive=f"CONFLICT_RESOLVED: {existing.directive} | {sanitized.directive}",
                    penalty_weight=max_penalty,
                    constraint_type=chosen_type,
                    regime_confidence=max(existing.regime_confidence, sanitized.regime_confidence)
                )
        return list(resolved.values())

    def calculate_constrained_allocation(
        self, 
        odds: float, 
        win_prob: float, 
        constraints: List[ActiveConstraint]
    ) -> float:
        """
        ハーフ・ケリー基準と因果グラフペナルティを結合し、ロット上限を物理拘束する。
        ゼロ除算、負のエッジ、教訓コンフリクトを完全遮断する決定論的ゲート。
        """
        # 1. 入力パラメータの防衛的検証（マスターの適当な入力を弾く）
        if odds <= 0.0 or not (0.0 < win_prob < 1.0):
            logging.error(f"Invalid input: odds={odds}, win_prob={win_prob}. Execution aborted.")
            return 0.0

        # 2. ハーフ・ケリー比率の計算
        q = 1.0 - win_prob
        edge = (odds * win_prob) - q
        if edge <= 0.0:
            # 期待値がゼロ以下の局面で無駄な勝負を挑むのは、ただの自殺志願者です
            logging.warning(f"Negative edge detected ({edge:.4f}). Kelly allocation clamped to 0.0.")
            return 0.0

        half_kelly = 0.5 * (edge / odds)

        # 3. 因果制約の競合調停
        active_lessons = self.resolve_causal_conflicts(constraints)
        if not active_lessons:
            return min(1.0, half_kelly)

        # 4. ペナルティ積算フィルターの適用
        penalty_multiplier = 1.0
        for c in active_lessons:
            # 深刻度0.8以上、またはHARD_VETO指定時は問答無用で完全遮断
            if c.constraint_type == 'HARD_VETO' or c.penalty_weight >= 0.8:
                logging.warning(
                    f"CRITICAL VETO ENGAGED: Agent[{c.agent_name}] Penalty={c.penalty_weight:.2f}. "
                    f"Directive: '{c.directive}'. Allocation clamped to 0.0."
                )
                return 0.0

            # ペナルティ重みクリッピングと指数減衰
            decay = max(0.0, 1.0 - min(1.0, self._lambda * c.penalty_weight))
            penalty_multiplier *= decay

        final_allocation = half_kelly * penalty_multiplier
        # 最終防衛ライン: 不動小数点誤差のクリッピング
        final_allocation = max(0.0, min(1.0, final_allocation))

        logging.info(f"Allocation dynamically gated: Base={half_kelly:.4f} -> Clamped={final_allocation:.4f}")
        return final_allocation