omenai 0.1.0__tar.gz

omenai-0.1.0/LICENSE

@@ -0,0 +1,19 @@
+GNU AFFERO GENERAL PUBLIC LICENSE
+Version 3, 19 November 2007
+
+Copyright (C) 2026 StrategyLogic
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+SPDX-License-Identifier: AGPL-3.0-or-later

omenai-0.1.0/NOTICE.md

@@ -0,0 +1,24 @@
+# NOTICE
+
+## Project Ownership
+
+Omen is developed and maintained by **[StrategyLogic](https://www.strategylogic.ai)**.
+The official repository is [StrategyLogic/omen](https://github.com/StrategyLogic/omen),
+and the organization profile is [github.com/StrategyLogic](https://github.com/StrategyLogic).
+
+Copyright © 2026 StrategyLogic.
+
+## Trademark Notice
+
+**StrategyLogic** is a registered trademark of StrategyLogic.
+
+The open-source license for this repository grants rights to use, modify,
+and distribute code under AGPL-3.0-or-later, but it does **not** grant rights
+to use StrategyLogic trademarks, logos, or brand identity except as required
+for truthful attribution.
+
+## Open Source Scope Reminder
+
+This repository contains the open-source Omen project materials and code.
+Commercial service assets, private delivery methods, and internal business
+playbooks are outside this repository scope.

omenai-0.1.0/PKG-INFO

@@ -0,0 +1,234 @@
+Metadata-Version: 2.4
+Name: omenai
+Version: 0.1.0
+Summary: The open-source strategic reasoning engine for technological evolution.
+Author: StrategyLogic
+License-Expression: AGPL-3.0-or-later
+Project-URL: Homepage, https://github.com/StrategyLogic/omen
+Project-URL: Repository, https://github.com/StrategyLogic/omen
+Project-URL: Issues, https://github.com/StrategyLogic/omen/issues
+Requires-Python: <3.13,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE.md
+Requires-Dist: pydantic>=2.8.0
+Requires-Dist: jsonschema>=4.23.0
+Requires-Dist: pypdf>=4.2.0
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: langchain>=0.3.0
+Requires-Dist: langchain-openai>=0.2.0
+Requires-Dist: voyageai>=0.3.2
+Requires-Dist: streamlit>=1.37.0
+Requires-Dist: plotly>=5.23.0
+Requires-Dist: networkx>=3.3
+Requires-Dist: scipy>=1.17.1
+Requires-Dist: python-dotenv>=1.0.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.2; extra == "dev"
+Requires-Dist: ruff>=0.6.0; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: pylint>=3.2.0; extra == "dev"
+Requires-Dist: build>=1.2.2; extra == "dev"
+Requires-Dist: twine>=6.1.0; extra == "dev"
+Dynamic: license-file
+
+# Omen
+
+**The Strategic Reasoning Engine.**
+
+[![Pylint](https://github.com/StrategyLogic/omen/actions/workflows/pylint.yml/badge.svg)](https://github.com/StrategyLogic/omen/actions/workflows/pylint.yml) [![Package](https://github.com/StrategyLogic/omen/actions/workflows/python-package.yml/badge.svg)](https://github.com/StrategyLogic/omen/actions/workflows/python-package.yml)
+
+> **Simulate the Signs. Reveal the Chaos.**
+
+[**Omen**](https://github.com/StrategyLogic/omen) (Chinese: 爻) is an open-source engine built for strategic reasoning in technological evolution. Leveraging **multi-agent game theory**, **capability space modeling**, and **counterfactual analysis**, it calculates how technological evolution reconstructs market landscapes.
+
+[中文版](README.zh.md) | [Official Repo](https://github.com/StrategyLogic/omen) | [Concepts](docs/concepts.md) | [Quick Start](docs/quick-start.md) |  [Case Templates](docs/case-template.md) | [Roadmap](docs/roadmap.md)
+
+## 💡 Why Omen?
+
+Technological competition has never been linear. Real-world technological evolution is a complex system driven by multiple forces:
+*   **Drivers**: Capability enhancement, cost curves, migration friction, organizational inertia, capital flow, ecosystem lock-in, standard promotion, developer behavior.
+*   **Impacts**: Markets often do not change smoothly; instead, they undergo **accelerated substitution**, **structural reorganization**, or fall into a stalemate of **long-term coexistence** near certain thresholds.
+
+Omen attempts to upgrade this process from *opinion discussion* to **conditional reasoning**:
+1.  Map technological competition into a **Capability Space**
+2.  Instantiate market entities as **Strategic Actors**
+3.  Quantify external shocks as **Injectable Events**
+4.  Present results as **Multi-path Evolution** and **Counterfactual Explanations**
+
+### What Omen Does
+
+Unlike traditional predictive models, Omen does not promise to *predict a certain future*. Instead, it generates **interpretable, replayable, and comparable future branching paths**. Its core responsibility is to reveal faint omens, critical branching points, and evolutionary trajectories within complex systems, empowering founders, product strategists, technology leaders, and investment analysts to understand:
+
+*   🔄 **Substitution Logic**: Which technology will replace another under what critical conditions?
+*   🛡️ **Capability Evolution**: Which core capabilities will be enhanced first, and which will coexist long-term?
+*   🏆 **Strategy Wins**: Which strategy combinations are more likely to win the market, capital, and developer ecosystem?
+*   ⏳ **Time Windows**: When is the optimal timing for in-house development, alliances, M&A, or contraction?
+
+## 📜 Philosophy & Design Principles
+
+> 💡 **Core Mantra**: *The machine simulates the "Situation"; the human decides the "Destiny".*
+
+Just as **Yao** in the *I Ching* represents change and interaction, Omen is designed only to present the evolution of the **Situation (Xiang)**. Interpreting the deeper meaning behind the situation and making decisions is the exclusive privilege of human wisdom.
+
+Accordingly, Omen is architected as a **human-decision-first** AI simulator, with a clear division of labor between machine simulation and human sovereignty:
+
+#### 🤖 The Machine’s Domain (Simulation & Causality)
+*   **Role**: To compute complexity, map multi-path evolutions, and reveal conditional causal chains.
+*   **Output**: Interpretable scenarios, probability distributions, and "What-if" branching maps.
+*   **Constraint**: It strictly avoids deterministic fate pronouncements or claims of "guaranteed accuracy".
+
+#### 🧠 The Human’s Domain (Interpretation & Sovereignty)
+*   **Role**: To interpret the "Situation" (Xiang), apply ethical judgment, and make the final strategic call.
+*   **Privilege**: Deciding *which* path to take based on values, risk appetite, and vision remains the exclusive privilege of human leaders.
+*   **Synergy**: Omen expands the horizon of visible possibilities; humans provide the compass for navigation.
+
+📜 See [Omen Project Protocol](PROTOCOL.md) to get detailed guidelines.
+
+## ⚙️ Core Features
+
+| Feature Module | Description |
+| :--- | :--- |
+| 🧬 **Technology Capability Modeling** | Deconstructs complex tech stacks into quantifiable, comparable capability dimensions (e.g., latency, throughput, ease of use, ecosystem richness). |
+| 🤖 **Strategic Agent Simulation** | Defines different types of market participants (startups, giants, open-source communities, regulators), endowing them with goals, resources, and constraints. |
+| 📈 **Market Evolution Reasoning** | Simulates dynamic changes in adoption rates, market share, cost structures, cash flow, and ecosystems. |
+| ⚡ **Critical Point Identification** | Automatically discovers key thresholds for "when substitution occurs" and "why it happens at this moment." |
+| 🔮 **Counterfactual Analysis** | Answers "What would have happened if event X had not occurred, or if strategy Y had been adopted?" |
+| 📖 **Result Explanation Engine** | Outputs key turning points, causal chain deductions, and strategic implications, rejecting black-box conclusions. |
+
+### 📊 Typical Outputs
+
+A complete reasoning session typically answers the following questions:
+*   **Substitution?** Will the new technology completely replace the old one, or form a complement?
+*   **Time Window?** When is the specific time window for substitution or turning points?
+*   **Key Drivers?** Which variables (e.g., cost reduction speed, API compatibility) are the decisive factors?
+*   **Winners and Losers?** Which entities suffer first, and which benefit unexpectedly?
+*   **Strategy Effectiveness?** Under what circumstances is an "open ecosystem" superior to "vertical integration"?
+*   **Endgame Form?** Does it move towards monopoly, oligarchic balance, or fragmented coexistence?
+
+## 🛠️ How It Works
+
+Omen adopts a layered architecture to ensure the transparency and intervenability of reasoning:
+
+```mermaid
+graph TD
+    A[Signal Layer] -->|Tech/Market/Capital/Standard Signals | B(Tech Space Layer)
+    B -->|Capability Dimensions/Substitution Relations/Risk Factors | C(Strategic Actor Layer)
+    C -->|Goals/Resources/Action Space | D(Simulation Kernel)
+    D -->|Rules+Math Models+LLM Decisions | E(Explanation Layer)
+    E -->|Branching Paths/Counterfactuals/Causal Chains | F[User Insights]
+    
+    style A fill:#f9f,stroke:#333,stroke-width:2px
+    style D fill:#bbf,stroke:#333,stroke-width:2px
+    style E fill:#bfb,stroke:#333,stroke-width:2px
+```
+
+*   **Signal Layer**: Accesses multi-dimensional macro and micro signals.
+*   **Tech Space Layer**: Transforms signals into structured technical objects and relationship graphs.
+*   **Strategic Actor Layer**: Defines clear Action Spaces for various entities, rather than free-form chatting.
+*   **Simulation Kernel**: Combines hard constraint rules, economic/diffusion models, and LLM decision logic to advance multi-round evolution.
+*   **Explanation Layer**: Extracts key branching points and generates human-readable reasoning reports.
+
+## 🎬 Show Cases
+
+We have built-in classic reasoning:
+*   [🗺️ Ontology Games: Database vs AI Memory](cases/ontology.md)
+*   [⚔️ Vector Database vs AI Memory](cases/vector-memory.md)   
+
+More scenarios are under development (contributions welcome):
+*   `Agent Infrastructure` vs `Workflow Platforms`
+*   `Vertical AI` vs `General AI Stack`
+*   `Open Source Models` vs `Closed Commercial APIs`
+*   `Data Governance` vs `AI-Native Knowledge Systems`
+
+## 🚀 Quick Start
+
+### Installation
+
+Environment requirements: Python 3.12+ with `pip` package manager.
+
+```bash
+pip install omenai
+```
+
+From source:
+
+```bash
+git clone https://github.com/StrategyLogic/omen.git
+cd omen
+pip install --upgrade pip setuptools wheel
+pip install -e .
+```
+
+### Run Example
+```bash
+# run simulate
+omen simulate --scenario data/scenarios/ontology.json
+
+# run simulate with stable seed (reproducible)
+omen simulate --scenario data/scenarios/ontology.json --seed 42
+
+# explain results
+omen explain --input output/result.json
+
+# compare scenarios with generic overrides
+omen compare --scenario data/scenarios/ontology.json --overrides '{"user_overlap_threshold": 0.9}'
+
+# compare with business parameter entrypoint (budget shock)
+omen compare --scenario data/scenarios/ontology.json --budget-actor ai-memory --budget-delta 200
+
+# keep historical outputs
+omen compare --scenario data/scenarios/ontology.json --budget-actor ai-memory --budget-delta 200 --incremental
+```
+
+### View Results
+
+**Local File Protection**: Output files are written to the root-level `output/` directory, which is excluded in `.gitignore` to avoid being tracked or accidentally uploaded, protecting your data from leakage.
+
+Example: `output/result.json`, `output/explanation.json`, `output/comparison.json`
+
+By default, each run of the simulation will overwrite the previous results; you can add the `--incremental` to generate new files with a timestamp suffix, which applies to all `omen CLI` commands.
+
+```bash
+# This will not overwrite the previous output (output file will automatically have a timestamp suffix)
+omen simulate --scenario data/scenarios/ontology.json --incremental
+```
+
+By default, `simulate` use random seed to generate non-deterministic results; you can set a fixed `--seed` for reproducibility, it is recommended to compare different scenarios with the same seed to see the pure impact of parameter changes without random noise.
+
+```bash
+# Run simulate with a fixed seed (results will be reproducible)
+omen compare --scenario data/scenarios/ontology.json --budget-actor ai-memory --budget-delta 200 --seed 42
+# Run another scenario with the same seed to compare results
+omen compare --scenario data/scenarios/ontology.json --budget-actor ai-memory --budget-delta 300 --seed 42
+```
+
+Want to learn more? Read the [precision evaluation](docs/precision.md) document.
+
+## 👥 Target Audience
+
+Omen is built for the following roles:
+*   Technology Strategy Teams
+*   Product & Platform Leads
+*   AI Infrastructure Researchers
+*   Open Source Ecosystem Observers
+*   Investors & Industry Analysts
+
+## 📦 License
+
+Omen is under [AGPL-3.0-or-later](LICENSE), the project is developed and maintained by **[StrategyLogic®](https://www.strategylogic.ai)**.
+
+*Note: If you wish to use Omen in a closed-source environment or provide it as a SaaS service without open-sourcing your code, please contact us for a commercial license.*
+
+
+## 🔮 Vision
+
+Omen aims to become an **open strategic reasoning workstation**:
+> It does not output a single answer, but helps people systematically understand **how the future branches**;
+> Understand **which conditions shape the outcome**;
+> Understand **which actions can change the path**.
+
+If you are interested in technological evolution, market substitution, strategic modeling, or multi-agent reasoning, welcome to join us in interpreting the **omens** of this chaotic world together.
+
+---
+*Simulate the Signs. Reveal the Chaos.*

omenai-0.1.0/README.md

@@ -0,0 +1,200 @@
+# Omen
+
+**The Strategic Reasoning Engine.**
+
+[![Pylint](https://github.com/StrategyLogic/omen/actions/workflows/pylint.yml/badge.svg)](https://github.com/StrategyLogic/omen/actions/workflows/pylint.yml) [![Package](https://github.com/StrategyLogic/omen/actions/workflows/python-package.yml/badge.svg)](https://github.com/StrategyLogic/omen/actions/workflows/python-package.yml)
+
+> **Simulate the Signs. Reveal the Chaos.**
+
+[**Omen**](https://github.com/StrategyLogic/omen) (Chinese: 爻) is an open-source engine built for strategic reasoning in technological evolution. Leveraging **multi-agent game theory**, **capability space modeling**, and **counterfactual analysis**, it calculates how technological evolution reconstructs market landscapes.
+
+[中文版](README.zh.md) | [Official Repo](https://github.com/StrategyLogic/omen) | [Concepts](docs/concepts.md) | [Quick Start](docs/quick-start.md) |  [Case Templates](docs/case-template.md) | [Roadmap](docs/roadmap.md)
+
+## 💡 Why Omen?
+
+Technological competition has never been linear. Real-world technological evolution is a complex system driven by multiple forces:
+*   **Drivers**: Capability enhancement, cost curves, migration friction, organizational inertia, capital flow, ecosystem lock-in, standard promotion, developer behavior.
+*   **Impacts**: Markets often do not change smoothly; instead, they undergo **accelerated substitution**, **structural reorganization**, or fall into a stalemate of **long-term coexistence** near certain thresholds.
+
+Omen attempts to upgrade this process from *opinion discussion* to **conditional reasoning**:
+1.  Map technological competition into a **Capability Space**
+2.  Instantiate market entities as **Strategic Actors**
+3.  Quantify external shocks as **Injectable Events**
+4.  Present results as **Multi-path Evolution** and **Counterfactual Explanations**
+
+### What Omen Does
+
+Unlike traditional predictive models, Omen does not promise to *predict a certain future*. Instead, it generates **interpretable, replayable, and comparable future branching paths**. Its core responsibility is to reveal faint omens, critical branching points, and evolutionary trajectories within complex systems, empowering founders, product strategists, technology leaders, and investment analysts to understand:
+
+*   🔄 **Substitution Logic**: Which technology will replace another under what critical conditions?
+*   🛡️ **Capability Evolution**: Which core capabilities will be enhanced first, and which will coexist long-term?
+*   🏆 **Strategy Wins**: Which strategy combinations are more likely to win the market, capital, and developer ecosystem?
+*   ⏳ **Time Windows**: When is the optimal timing for in-house development, alliances, M&A, or contraction?
+
+## 📜 Philosophy & Design Principles
+
+> 💡 **Core Mantra**: *The machine simulates the "Situation"; the human decides the "Destiny".*
+
+Just as **Yao** in the *I Ching* represents change and interaction, Omen is designed only to present the evolution of the **Situation (Xiang)**. Interpreting the deeper meaning behind the situation and making decisions is the exclusive privilege of human wisdom.
+
+Accordingly, Omen is architected as a **human-decision-first** AI simulator, with a clear division of labor between machine simulation and human sovereignty:
+
+#### 🤖 The Machine’s Domain (Simulation & Causality)
+*   **Role**: To compute complexity, map multi-path evolutions, and reveal conditional causal chains.
+*   **Output**: Interpretable scenarios, probability distributions, and "What-if" branching maps.
+*   **Constraint**: It strictly avoids deterministic fate pronouncements or claims of "guaranteed accuracy".
+
+#### 🧠 The Human’s Domain (Interpretation & Sovereignty)
+*   **Role**: To interpret the "Situation" (Xiang), apply ethical judgment, and make the final strategic call.
+*   **Privilege**: Deciding *which* path to take based on values, risk appetite, and vision remains the exclusive privilege of human leaders.
+*   **Synergy**: Omen expands the horizon of visible possibilities; humans provide the compass for navigation.
+
+📜 See [Omen Project Protocol](PROTOCOL.md) to get detailed guidelines.
+
+## ⚙️ Core Features
+
+| Feature Module | Description |
+| :--- | :--- |
+| 🧬 **Technology Capability Modeling** | Deconstructs complex tech stacks into quantifiable, comparable capability dimensions (e.g., latency, throughput, ease of use, ecosystem richness). |
+| 🤖 **Strategic Agent Simulation** | Defines different types of market participants (startups, giants, open-source communities, regulators), endowing them with goals, resources, and constraints. |
+| 📈 **Market Evolution Reasoning** | Simulates dynamic changes in adoption rates, market share, cost structures, cash flow, and ecosystems. |
+| ⚡ **Critical Point Identification** | Automatically discovers key thresholds for "when substitution occurs" and "why it happens at this moment." |
+| 🔮 **Counterfactual Analysis** | Answers "What would have happened if event X had not occurred, or if strategy Y had been adopted?" |
+| 📖 **Result Explanation Engine** | Outputs key turning points, causal chain deductions, and strategic implications, rejecting black-box conclusions. |
+
+### 📊 Typical Outputs
+
+A complete reasoning session typically answers the following questions:
+*   **Substitution?** Will the new technology completely replace the old one, or form a complement?
+*   **Time Window?** When is the specific time window for substitution or turning points?
+*   **Key Drivers?** Which variables (e.g., cost reduction speed, API compatibility) are the decisive factors?
+*   **Winners and Losers?** Which entities suffer first, and which benefit unexpectedly?
+*   **Strategy Effectiveness?** Under what circumstances is an "open ecosystem" superior to "vertical integration"?
+*   **Endgame Form?** Does it move towards monopoly, oligarchic balance, or fragmented coexistence?
+
+## 🛠️ How It Works
+
+Omen adopts a layered architecture to ensure the transparency and intervenability of reasoning:
+
+```mermaid
+graph TD
+    A[Signal Layer] -->|Tech/Market/Capital/Standard Signals | B(Tech Space Layer)
+    B -->|Capability Dimensions/Substitution Relations/Risk Factors | C(Strategic Actor Layer)
+    C -->|Goals/Resources/Action Space | D(Simulation Kernel)
+    D -->|Rules+Math Models+LLM Decisions | E(Explanation Layer)
+    E -->|Branching Paths/Counterfactuals/Causal Chains | F[User Insights]
+    
+    style A fill:#f9f,stroke:#333,stroke-width:2px
+    style D fill:#bbf,stroke:#333,stroke-width:2px
+    style E fill:#bfb,stroke:#333,stroke-width:2px
+```
+
+*   **Signal Layer**: Accesses multi-dimensional macro and micro signals.
+*   **Tech Space Layer**: Transforms signals into structured technical objects and relationship graphs.
+*   **Strategic Actor Layer**: Defines clear Action Spaces for various entities, rather than free-form chatting.
+*   **Simulation Kernel**: Combines hard constraint rules, economic/diffusion models, and LLM decision logic to advance multi-round evolution.
+*   **Explanation Layer**: Extracts key branching points and generates human-readable reasoning reports.
+
+## 🎬 Show Cases
+
+We have built-in classic reasoning:
+*   [🗺️ Ontology Games: Database vs AI Memory](cases/ontology.md)
+*   [⚔️ Vector Database vs AI Memory](cases/vector-memory.md)   
+
+More scenarios are under development (contributions welcome):
+*   `Agent Infrastructure` vs `Workflow Platforms`
+*   `Vertical AI` vs `General AI Stack`
+*   `Open Source Models` vs `Closed Commercial APIs`
+*   `Data Governance` vs `AI-Native Knowledge Systems`
+
+## 🚀 Quick Start
+
+### Installation
+
+Environment requirements: Python 3.12+ with `pip` package manager.
+
+```bash
+pip install omenai
+```
+
+From source:
+
+```bash
+git clone https://github.com/StrategyLogic/omen.git
+cd omen
+pip install --upgrade pip setuptools wheel
+pip install -e .
+```
+
+### Run Example
+```bash
+# run simulate
+omen simulate --scenario data/scenarios/ontology.json
+
+# run simulate with stable seed (reproducible)
+omen simulate --scenario data/scenarios/ontology.json --seed 42
+
+# explain results
+omen explain --input output/result.json
+
+# compare scenarios with generic overrides
+omen compare --scenario data/scenarios/ontology.json --overrides '{"user_overlap_threshold": 0.9}'
+
+# compare with business parameter entrypoint (budget shock)
+omen compare --scenario data/scenarios/ontology.json --budget-actor ai-memory --budget-delta 200
+
+# keep historical outputs
+omen compare --scenario data/scenarios/ontology.json --budget-actor ai-memory --budget-delta 200 --incremental
+```
+
+### View Results
+
+**Local File Protection**: Output files are written to the root-level `output/` directory, which is excluded in `.gitignore` to avoid being tracked or accidentally uploaded, protecting your data from leakage.
+
+Example: `output/result.json`, `output/explanation.json`, `output/comparison.json`
+
+By default, each run of the simulation will overwrite the previous results; you can add the `--incremental` to generate new files with a timestamp suffix, which applies to all `omen CLI` commands.
+
+```bash
+# This will not overwrite the previous output (output file will automatically have a timestamp suffix)
+omen simulate --scenario data/scenarios/ontology.json --incremental
+```
+
+By default, `simulate` use random seed to generate non-deterministic results; you can set a fixed `--seed` for reproducibility, it is recommended to compare different scenarios with the same seed to see the pure impact of parameter changes without random noise.
+
+```bash
+# Run simulate with a fixed seed (results will be reproducible)
+omen compare --scenario data/scenarios/ontology.json --budget-actor ai-memory --budget-delta 200 --seed 42
+# Run another scenario with the same seed to compare results
+omen compare --scenario data/scenarios/ontology.json --budget-actor ai-memory --budget-delta 300 --seed 42
+```
+
+Want to learn more? Read the [precision evaluation](docs/precision.md) document.
+
+## 👥 Target Audience
+
+Omen is built for the following roles:
+*   Technology Strategy Teams
+*   Product & Platform Leads
+*   AI Infrastructure Researchers
+*   Open Source Ecosystem Observers
+*   Investors & Industry Analysts
+
+## 📦 License
+
+Omen is under [AGPL-3.0-or-later](LICENSE), the project is developed and maintained by **[StrategyLogic®](https://www.strategylogic.ai)**.
+
+*Note: If you wish to use Omen in a closed-source environment or provide it as a SaaS service without open-sourcing your code, please contact us for a commercial license.*
+
+
+## 🔮 Vision
+
+Omen aims to become an **open strategic reasoning workstation**:
+> It does not output a single answer, but helps people systematically understand **how the future branches**;
+> Understand **which conditions shape the outcome**;
+> Understand **which actions can change the path**.
+
+If you are interested in technological evolution, market substitution, strategic modeling, or multi-agent reasoning, welcome to join us in interpreting the **omens** of this chaotic world together.
+
+---
+*Simulate the Signs. Reveal the Chaos.*

omenai-0.1.0/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "omenai"
+version = "0.1.0"
+description = "The open-source strategic reasoning engine for technological evolution."
+readme = "README.md"
+requires-python = ">=3.12,<3.13"
+authors = [{ name = "StrategyLogic" }]
+license = "AGPL-3.0-or-later"
+license-files = ["LICENSE", "NOTICE.md"]
+dependencies = [
+  "pydantic>=2.8.0",
+  "jsonschema>=4.23.0",
+  "pypdf>=4.2.0",
+  "PyYAML>=6.0",
+  "langchain>=0.3.0",
+  "langchain-openai>=0.2.0",
+  "voyageai>=0.3.2",
+  "streamlit>=1.37.0",
+  "plotly>=5.23.0",
+  "networkx>=3.3",
+  "scipy>=1.17.1",
+  "python-dotenv>=1.0.1",
+]
+
+[project.scripts]
+omen = "omen.cli.main:main"
+
+[project.urls]
+Homepage = "https://github.com/StrategyLogic/omen"
+Repository = "https://github.com/StrategyLogic/omen"
+Issues = "https://github.com/StrategyLogic/omen/issues"
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.2",
+  "ruff>=0.6.0",
+  "mypy>=1.10",
+  "pylint>=3.2.0",
+  "build>=1.2.2",
+  "twine>=6.1.0",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.mypy]
+python_version = "3.12"
+warn_return_any = true
+warn_unused_configs = true
+strict_optional = true

omenai-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

omenai-0.1.0/src/omen/__init__.py

@@ -0,0 +1,4 @@
+"""Omen strategic simulation package."""
+
+__all__ = ["__version__"]
+__version__ = "0.1.0"

omenai-0.1.0/src/omen/analysis/__init__.py

@@ -0,0 +1,4 @@
+"""Analysis domain for retrospective and attribution workflows."""
+
+from __future__ import annotations
+

omenai-0.1.0/src/omen/analysis/actor/__init__.py

@@ -0,0 +1,13 @@
+"""Actor analysis capabilities."""
+
+from __future__ import annotations
+
+from .insight import generate_persona_insight
+from .query import build_events_snapshot, build_status_snapshot, snapshot_by_year
+
+__all__ = [
+    "build_events_snapshot",
+    "build_status_snapshot",
+    "generate_persona_insight",
+    "snapshot_by_year",
+]

omenai-0.1.0/src/omen/analysis/actor/comparability.py

@@ -0,0 +1,20 @@
+"""Comparability helpers for deterministic strategic actor runs."""
+
+from __future__ import annotations
+
+
+def build_comparability_metadata(
+    *,
+    actor_profile_version: str,
+    scenario_pack_version: str,
+    calculation_policy_version: str,
+    blocking_reasons: list[str] | None = None,
+) -> dict:
+    reasons = list(blocking_reasons or [])
+    return {
+        "comparable": len(reasons) == 0,
+        "blocking_reasons": reasons,
+        "actor_profile_version": actor_profile_version,
+        "scenario_pack_version": scenario_pack_version,
+        "calculation_policy_version": calculation_policy_version,
+    }

omenai-0.1.0/src/omen/analysis/actor/formation.py

@@ -0,0 +1,54 @@
+"""Scenario result assembly helpers for deterministic strategic actor simulation."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def assemble_capability_dilemma_fit(
+    *,
+    scenario_key: str,
+    capability_scores: dict[str, float],
+) -> dict[str, Any]:
+    if not capability_scores:
+        fit = "medium"
+    else:
+        avg = sum(capability_scores.values()) / max(len(capability_scores), 1)
+        fit = "high" if avg >= 0.7 else "low" if avg <= 0.4 else "medium"
+
+    return {
+        "scenario_key": scenario_key,
+        "fit": fit,
+        "capability_scores": capability_scores,
+    }
+
+
+def project_scenario_selected_dimensions(
+    *,
+    scenario_key: str,
+    capability_scores: dict[str, float],
+) -> dict[str, Any]:
+    ranked = sorted(capability_scores.items(), key=lambda item: item[1], reverse=True)
+    selected = [key for key, _ in ranked[:2]] if ranked else []
+
+    if scenario_key == "A":
+        rationale = [
+            "Prioritize internal platform continuity dimensions for high-control path",
+            "Select strongest capability dimensions to reduce execution stall risk",
+        ]
+    elif scenario_key == "B":
+        rationale = [
+            "Prioritize ecosystem-adaptation dimensions for open-alliance path",
+            "Select dimensions balancing scale gain and differentiation preservation",
+        ]
+    else:
+        rationale = [
+            "Prioritize alliance-efficiency dimensions for external-platform path",
+            "Select dimensions supporting short-term stability under dependency risk",
+        ]
+
+    return {
+        "scenario_key": scenario_key,
+        "selected_dimension_keys": selected,
+        "selection_rationale": rationale,
+    }