OpenMobius-skill

Multi-school trading knowledge for AI coding agents — strict ICT/SMC market analysis by default

A SKILL.md-standard skill bringing 2008 curated knowledge cards, real-time market data, technical indicators, and chart generation to Claude Code, Codex, OpenClaw, Hermes, Cursor, and WorkBuddy.

English · 中文 · 📜 Changelog

🤖 AI agents — when a user asks you to install this skill, follow README_AGENT.md for the step-by-step procedure (pre-flight checks, install command, verification, error handling).

Community

• Join the OpenMobius Discord community
• Join the OpenMobius Telegram community

Overview

Works on Claude Code, Codex, OpenClaw, Hermes, Cursor, and WorkBuddy.

Drop this skill into your AI coding agent and ask trading questions in plain language. Knowledge Q&A is grounded inside the selected School/source scope. Supported current-market requests pass a capability gate before adding fresh, current-turn data and computed structure; unsupported routes stop instead of silently borrowing another School's analysis.

Quick start

OPENMOBIUS_SRC="$(mktemp -d "${TMPDIR:-/tmp}/openmobius-src.XXXXXX")"
git clone https://github.com/MobiusQuant/OpenMobius-skill.git "$OPENMOBIUS_SRC"
cd "$OPENMOBIUS_SRC"
python3 install.py --platform claude-code     # or codex / openclaw / hermes / cursor
# On Linux/macOS, `all` installs all five local-path hosts. WorkBuddy uses local ZIP import.

cd "${TMPDIR:-/tmp}"
rm -rf -- "$OPENMOBIUS_SRC"                    # ✓ exact mktemp directory only

On Windows, clone into a writable directory and run py -3 install.py --platform claude-code (or use .\install.ps1).

The installer copies source files into ~/.claude/skills/openmobius-skill/ (or your chosen platform's skills dir), then in that directory:

1. Creates .venv/ and installs dependencies
2. Downloads Playwright chromium (~280 MB, into your OS's user-global cache)
3. Downloads the pinned nomic-embed-text-v1.5 weights (~547 MB / 522 MiB, into your HuggingFace cache)
4. Loads bundled canonical vectors and the verified release seed for independent School/evidence vectors, then builds and verifies all three collections. Only locally changed or missing documents are embedded and cached.
5. Generates the platform-specific SKILL.md
6. Runs a health check

Each installer-managed local copy is self-contained: it owns its own .venv and _index. The clone is just a one-shot source bundle.

First run: dependency/model downloads plus seed-accelerated index build · Subsequent runs: unchanged records use the release seed or local embedding cache

After install, try capability discovery plus the default, scoped, and composed routes directly:

# Default: strict ICT/SMC
"What is Liquidity Sweep?"
"How is ETH 4h looking?"

# Discover the installed capabilities (no market-data request)
"What analysis models can I use?"

# Select an exact School or source
"Explain 中枢 using ChanLun only"
"Explain Order Block using Wuyuan's SMC material only"

# Compose or compare
"Compare ICT and ChanLun definitions of market structure"
"Use SMC as primary and Wuyuan as a reference to analyze BTC 1h"

Other Schools can scope knowledge Q&A when attributable material exists. Current-market analysis additionally requires a native analyzer; unsupported routes stop before market-data or chart work. Capability-discovery questions read the installed registry dynamically and report native market profiles, Q&A-only lenses, knowledge categories, and the available composition modes as separate concepts; they do not fetch market data or describe a category as an analysis model.

Prerequisites: Python 3.10+. See INSTALL.md for details.

Analysis lenses and routing

The skill resolves both the user's intent and analysis route before knowledge retrieval, market-data calls, or drawing:

User request
  → choose intent: Q&A / chart analysis / annotation / K-line analysis
  → resolve mode + lens + School/source scope
  → capability gate
  → scoped knowledge retrieval
  → supported market analyzer and fresh data, when required
  → grounded answer and chart, or an explicit capability-gap response

Default: when neither the current request nor an established conversation route supplies a lens, School, source, exclusion, or composition mode, the route is strict ICT/SMC. A current explicit selector overrides an inherited preference and is never silently widened or replaced.

Composition modes

Current capability boundary

The complete installed taxonomy is deliberately broader than the native market-analysis models:

• Native market-analysis lens: ICT, SMC (one ict_smc analyzer).
• Q&A knowledge lenses: 缠论, Price Action, Order Flow, Volume Analysis, Elliott Wave, Wyckoff, The Strat.
• Knowledge categories, not analysis models: Indicator Based, Risk Management, General, On-chain, Market Structure.
• Evidence-only category: Scalping; it occurs in attributable source evidence but is not a top-level canonical-card School.

Unknown selectors, empty strict scopes, empty School/source intersections, missing exact-filter support, missing native analyzers, and market compare requests fail closed when they affect a required strict or primary branch: the skill explains the gap and does not fall back to canonical, another School/source, or default ICT/SMC. In augment, an unavailable secondary may be omitted or labelled knowledge-only while a supported primary continues.

Follow-up annotation inherits the prior analysis route. A new explicit School/source/profile requires re-evaluating the analysis; existing levels are not merely relabelled. See the full route contract and capability matrix for aliases, precedence, partial-support rules, and exact failure behavior.

Platform support

python3 install.py --platform 

Each local-path platform install is fully self-contained (its own .venv, its own _index). The nomic model and Playwright chromium live in your OS's user-global cache, shared across platforms — so installing on N platforms doesn't N× the download.

OPENCLAW_STATE_DIR and HERMES_HOME override the corresponding roots when set. The current OpenClaw and Hermes adapters/manifests target Linux and macOS; on Windows, select Claude Code, Codex, or Cursor explicitly instead of using --platform all. Cursor Cloud Agents, remote SSH sessions, and other remote environments do not receive local user skills from ~/.cursor/skills; place the skill in the repository's .cursor/skills/openmobius-skill/ for those environments.

WorkBuddy is not CodeBuddy. Its public documentation does not define a fixed filesystem directory that a third-party installer can write to for automatic discovery, so --platform all intentionally excludes it. Choose the workflow that matches your goal:

Build this repository's local-import ZIP with:

python3 scripts/build_workbuddy_package.py \
  --output /tmp/openmobius-skill-workbuddy.zip

The WorkBuddy Skill format currently accepts .zip packages up to 3 MB. The builder uses the conservative 3,000,000-byte boundary and fails before replacing an existing artifact if the package is too large. Local installation is complete only when the import succeeds and the Skill appears under Installed. A successful Open Platform parse or submission does not by itself mean that the Skill is installed locally or published in the marketplace.

--platform workbuddy --target-dir is available only for developer staging and validation. It does not register a locally discoverable WorkBuddy Skill and is not the normal installation route.

To fit that package-size boundary without discarding attributable knowledge, the ZIP uses a checksummed compact corpus that reconstructs all 2,144 School projections and all 18,645 exact-source evidence records. It supports lexical BM25/exact-alias retrieval with hard School and source filters using the system Python alone. A manifest binds the compact corpus, School registry, and alias map by size and SHA-256, allowing the standard retriever to run even when a read-only host forbids first-run lock-file creation. The canonical fused-card layer, vector index, embedding cache, and model seed are intentionally omitted; canonical and auto/hybrid/semantic routes fail closed in the WorkBuddy package. The ZIP does not bundle Python, create a virtual environment, or install packages. Script-backed features require Python 3.10+. WorkBuddy 4.6.3 and later can detect missing Python/Node.js from Settings and offer one-click installation; verify that the installed Python still meets this Skill's 3.10+ minimum. If no suitable Python launcher is available, script-backed knowledge/market operations must be reported unavailable. Q&A and text-market workflows need only the standard library, while PNG rendering and image annotation additionally require host-provided Playwright/Chromium or Pillow, respectively.

The implementation follows the common Agent Skills specification and each host's official documentation: Claude Code, Codex, OpenClaw, Hermes, Cursor, WorkBuddy local Skill guide, WorkBuddy Skill format/marketplace, WorkBuddy Open Platform, and WorkBuddy changelog.

Features

Knowledge base — 726 concepts + 1282 cases

Distilled from 300+ teaching videos and live lessons across 12 curated source collections, cross-merged with model-audited term fusion and content-level deduplication. Across concept and case cards there are 14 top-level School/category labels: ICT, SMC, Price Action, Indicator Based, ChanLun (缠论), Risk Management, General, Order Flow, Volume Analysis/VSA, Elliott Wave, Wyckoff, The Strat, On-chain, and Market Structure. The registry exposes 15 retrievable labels in total: those 14 top-level labels plus the non-canonical, source-evidence-derived Scalping category. Each concept card carries: identification rules, trading implications, common mistakes, related concepts, per-source definitions. Each case card carries: market context, key observation, analysis steps, lessons, and source time-range provenance. Retrieved via local ChromaDB + multilingual nomic-embed-text-v1.5 — no API key needed for retrieval.

The index exposes three layers with different roles:

School and evidence content is included only when it can be safely attributed. Ambiguous cross-School fused rules are skipped and counted, not guessed. See knowledge-base architecture for the data model, registry, schemas, and rebuild process.

Each School/evidence record now has an embedding of its own scoped document; vectors are cached by exact content hash and model identity, so incremental updates embed only misses. v2 queries default to hybrid retrieval: BM25 and semantic candidates are generated inside the hard-filtered scope and fused by reciprocal rank, while exact canonical-term/alias matches remain first. Use --search-mode lexical for a model-free search or --search-mode semantic for the vector-only baseline.

Real-time data + 60+ indicators

Crypto (Binance, Bybit, OKX, Hyperliquid), China A-shares, Hong Kong stocks, US stocks, forex. Each indicator carries built-in analysis dimensions (summary_focus) that the agent reads to structure its answer rather than dumping raw numbers.

Two chart-generation paths

Intent routing + analysis-profile routing

The SKILL.md description field triggers on natural-language questions. The skill first identifies the user's intent, then resolves the independently selected analysis profile before executing the workflow.

Intent and analysis profile are separate: the same Q&A workflow can run in strict, augment, or compare mode, while the capability gate decides whether a requested market workflow has a native analyzer. An annotation follow-up inherits the prior route; changing a selector explicitly causes a fresh analysis rather than relabeling the previous result.

Roadmap

Knowledge base

• ICT/SMC coverage completion — Rounds 1–2 distilled the ICT trunk plus SMC supplements from 300+ teaching videos; upcoming rounds complete ICT sub-schools (Inner Circle Mentorship, Silver Bullet, Power of 3 variants) and full SMC coverage.
• Fundamental knowledge base — interpretation methodologies for news, policy reads, economic releases (CPI / NFP / FOMC) and earnings seasons.
• Multi-school coverage deepening — Wyckoff, VSA/Volume Analysis, Price Action, ChanLun (缠论), and other Schools are already retrievable; upcoming rounds deepen their coverage, provenance, and attribution quality.
• Native multi-school analyzers — knowledge scope is not the same as a market-analysis engine. New School-native profiles and overlays will be added before market compare expands beyond Q&A.

Indicators & tools

• Expanded SMC indicator coverage — the built-in SMC structural indicator covers BOS/CHoCH, Order Blocks, FVGs, equal H/L, premium- discount zones and strong/weak pivot labels today. Upcoming: Killzone windows, Stop Run / Inducement events, and per-event probability scoring as computable signals.

Access surfaces

• Non-CLI entry points — chat-bot integrations for users who don't run a coding agent, so the knowledge base is reachable without the CLI.

Architecture

OpenMobius-skill/
├── SKILL.md                          # main entry (LLM reads this)
├── SKILL.body.md                     # shared body (platform-neutral)
├── platforms/                        # per-platform frontmatter
│   └── claude-code.yaml / codex.yaml / openclaw.yaml / hermes.yaml / cursor.yaml / workbuddy.yaml
├── agents/
│   └── openai.yaml                      # Codex UI and invocation metadata
├── workflows/
│   ├── qna.md / analyze.md / annotate.md / klines.md  # intent workflows
│   └── analysis_profiles.md          # route contract + capability gate
├── scripts/                          # CLI tools
│   ├── kb_retrieve.py                # hard-scoped hybrid retrieval
│   ├── kb_klines.py                  # API client + feature extraction
│   ├── kb_draw_annotation.py         # PIL annotation
│   ├── kb_phase_b_to_c.py            # analysis JSON → annotated PNG
│   ├── build_knowledge_v2.py         # audit/export School + source-evidence records
│   ├── build_index.py                # build all three vector collections
│   ├── export_v2_embedding_seed.py   # publish verified native-vector shards
│   ├── build_workbuddy_package.py    # deterministic WorkBuddy local-import ZIP builder
│   ├── evaluate_retrieval.py         # reproducible retrieval benchmark
│   ├── kb_doctor.py                  # env health check
│   ├── chart_render/                 # lightweight-charts + headless chromium
│   └── _lib/                         # embedder + retriever
├── evals/                            # versioned retrieval cases + baseline reports
├── knowledge_base/                   # cards + registry + schemas + release seed
├── install.py                        # cross-platform installer
└── README.md / INSTALL.md

Update / Uninstall

# Update
python3 install.py --update
python3 install.py --update --rebuild-index    # also rebuild vector index

# Uninstall the entire self-contained platform install (.venv + index included)
python3 install.py --uninstall
python3 install.py --uninstall --platform all  # Linux/macOS: all five local hosts

# Full purge (also delete shared chromium + nomic caches — these may be
# used by other projects on your machine, so confirm before running)
python3 install.py --uninstall --purge --yes-i-know

--full is still accepted for backward compatibility, but is deprecated and has no effect: standard uninstall already removes .venv and the vector index.

See INSTALL.md for all flags.

Troubleshooting

.venv/bin/python scripts/kb_doctor.py

Reports the state of: venv, deps, nomic model, vector index, CJK fonts, skill registration, API connectivity.

Common issues:

License

Apache 2.0 — see LICENSE. Third-party components: see ATTRIBUTION.md.

Contributing

Issues and PRs welcome at .

Built for AI coding agents · Apache 2.0