@agentikos/omega-os 0.19.21 → 0.19.23

package/bootstrap/lib/llm-clis.py

@@ -99,6 +99,57 @@ _CATALOG: list[CliSpec] = [
         install_cmd=[],     # filled at runtime
         description="Community aider-chat (`aider`)",
     ),
+    # v0.19.22 — extended provider matrix per the user's "install them all,
+    # let me hot-swap" spec.
+    CliSpec(
+        id="opencode", label="OpenCode (community multi-LLM)",
+        bin_name="opencode",
+        install_cmd=["npm", "install", "-g", "opencode-ai"],
+        description="OpenCode — terminal AI coding with provider switching",
+    ),
+    CliSpec(
+        id="openrouter_cli", label="OpenRouter via OpenCode",
+        bin_name="opencode",   # opencode supports openrouter as a provider
+        install_cmd=[],        # piggy-backs on opencode install
+        description="OpenRouter (300+ models) via OpenCode provider",
+    ),
+    CliSpec(
+        id="deepseek", label="DeepSeek (via OpenCode)",
+        bin_name="opencode",
+        install_cmd=[],
+        description="DeepSeek V3 / R1 via OpenCode provider",
+    ),
+    CliSpec(
+        id="qwen_code", label="Qwen Code (Alibaba CLI)",
+        bin_name="qwen",
+        install_cmd=["npm", "install", "-g", "@qwen-code/qwen-code"],
+        description="Alibaba's Qwen Coder CLI (`qwen`)",
+    ),
+    CliSpec(
+        id="continue_dev", label="Continue.dev (terminal)",
+        bin_name="cn",
+        install_cmd=["npm", "install", "-g", "@continuedev/cli"],
+        description="Continue.dev CLI — multi-provider with config.json",
+    ),
+    # v0.19.23 — local LLM runtimes (no API key needed, free local inference).
+    CliSpec(
+        id="ollama", label="Ollama (local model runtime)",
+        bin_name="ollama",
+        install_cmd=[],   # filled at runtime — curl|sh installer
+        description="Local LLM runtime — pull + run Llama/Mistral/Qwen/etc.",
+    ),
+    CliSpec(
+        id="lm_studio", label="LM Studio CLI (local)",
+        bin_name="lms",
+        install_cmd=["npx", "-y", "@lmstudio/cli", "install"],
+        description="LM Studio command-line manager (`lms`) for local models",
+    ),
+    CliSpec(
+        id="gh_copilot", label="GitHub Copilot Chat (via gh extension)",
+        bin_name="gh",   # we extend an existing binary
+        install_cmd=["gh", "extension", "install", "github/gh-copilot"],
+        description="GitHub Copilot Chat as a `gh copilot` subcommand",
+    ),
 ]
 
 

package/bootstrap/lib/steps.sh

@@ -545,6 +545,13 @@ for entry in missing:
     elif "npm_global" in install and shutil.which("npm"):
         rc, out = _run(["npm", "install", "-g", "--silent", install["npm_global"]])
         attempt = f"npm install -g {install['npm_global']}"
+    elif "uv_tool" in install and (shutil.which("uv") or os.path.isfile(
+            os.path.expanduser("~/.local/bin/uv"))):
+        # uv-managed Python tools — installs to ~/.local/share/uv/tools
+        # and links to ~/.local/bin (which step_system_deps put on PATH)
+        uv_bin = shutil.which("uv") or os.path.expanduser("~/.local/bin/uv")
+        rc, out = _run([uv_bin, "tool", "install", "--quiet", install["uv_tool"]])
+        attempt = f"uv tool install {install['uv_tool']}"
     elif "curl" in install:
         # curl|bash installer — last resort
         rc, out = _run(["bash", "-c", f"curl -fsSL {install['curl']} | bash"])

package/omega/Agentik_Engine/omega_engine/__init__.py

@@ -188,7 +188,7 @@ from omega_engine.genesis import (
 )
 from omega_engine import plan as plan_v7
 
-__version__ = "0.19.21"
+__version__ = "0.19.23"
 
 __all__ = [
     "__version__",

package/omega/Agentik_Engine/omega_engine/cli.py

@@ -2941,6 +2941,160 @@ def cmd_menu_whiptail(_args: argparse.Namespace) -> int:
     return run_menu()
 
 
+# Default LLM provider for chat sessions — recorded in a tiny state file
+# so spawn_*_chat picks the right one. Hot-swap via `omega switch <id>`.
+_PROVIDER_MARKER = "active-llm-provider"
+
+
+def _provider_state_path() -> "Path":
+    from pathlib import Path
+    home = _omega_home()
+    return home / "Agentik_Extra" / "var" / _PROVIDER_MARKER
+
+
+def _active_provider() -> str:
+    p = _provider_state_path()
+    if p.exists():
+        return p.read_text().strip() or "claude_code"
+    return "claude_code"
+
+
+def _set_active_provider(provider_id: str) -> None:
+    p = _provider_state_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(provider_id.strip() + "\n")
+
+
+def cmd_scrape(args: argparse.Namespace) -> int:
+    """`omega scrape <url> [--out file] [--humanize]` — stealth scraper.
+
+    Thin wrapper over CloakBrowser (https://github.com/CloakHQ/CloakBrowser).
+    Bypasses Cloudflare/Turnstile/FingerprintJS by patching the browser at
+    the C++ level. Default output = markdown to stdout so any LLM CLI can
+    pipe it directly into a context. The wrapper is what makes
+    CloakBrowser usable as a SHELL CLI for Claude/Gemini/Codex/etc.
+
+    Usage:
+      omega scrape https://example.com                    # → markdown to stdout
+      omega scrape https://example.com --out page.md      # → file
+      omega scrape https://example.com --humanize         # mouse curves + scroll
+      omega scrape https://example.com --proxy <url>      # SOCKS5/HTTP
+
+    Inside any Claude Code chat session: ``omega scrape <url>`` returns the
+    cleaned page content. No MCP server, no Playwright dance.
+    """
+    import shutil
+    import subprocess
+    if not args.url:
+        print("usage: omega scrape <url> [--out FILE] [--humanize] [--proxy URL]")
+        return 2
+    # CloakBrowser is installed as a uv tool (`cloakbrowser`) but we need
+    # to drive it from Python — the canonical path is `python -m
+    # cloakbrowser` after `pip install cloakbrowser`, OR we invoke the
+    # uv-tool-installed Python directly. Try shutil.which("cloakbrowser")
+    # first; if absent, fall back to running through the installer venv.
+    runner = None
+    if shutil.which("cloakbrowser"):
+        # Direct CLI is mostly for binary management (install/info/update).
+        # For SCRAPING we still need our Python wrapper.
+        pass
+    # Inline Python wrapper — no separate script file, no version drift.
+    py_code = (
+        "import sys, asyncio\n"
+        "try:\n"
+        "    from cloakbrowser import launch_async\n"
+        "except ImportError:\n"
+        "    sys.stderr.write('cloakbrowser not importable — install with: "
+        "uv tool install cloakbrowser\\n'); sys.exit(2)\n"
+        "URL = sys.argv[1]\n"
+        "HUMANIZE = '--humanize' in sys.argv\n"
+        "PROXY = None\n"
+        "if '--proxy' in sys.argv:\n"
+        "    PROXY = sys.argv[sys.argv.index('--proxy') + 1]\n"
+        "async def main():\n"
+        "    kwargs = {'humanize': HUMANIZE}\n"
+        "    if PROXY:\n"
+        "        kwargs['proxy'] = PROXY\n"
+        "    browser = await launch_async(**kwargs)\n"
+        "    page = await browser.new_page()\n"
+        "    await page.goto(URL, wait_until='networkidle')\n"
+        "    text = await page.evaluate(\"document.body.innerText\")\n"
+        "    await browser.close()\n"
+        "    print(text)\n"
+        "asyncio.run(main())\n"
+    )
+    cmd = ["python3", "-c", py_code, args.url]
+    if getattr(args, "humanize", False):
+        cmd.append("--humanize")
+    if getattr(args, "proxy", None):
+        cmd += ["--proxy", args.proxy]
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+    except subprocess.TimeoutExpired:
+        print("  cloakbrowser timed out after 120s")
+        return 2
+    out_target = getattr(args, "out", None)
+    if out_target:
+        from pathlib import Path
+        Path(out_target).write_text(proc.stdout)
+        print(f"  wrote {len(proc.stdout)} bytes → {out_target}")
+    else:
+        print(proc.stdout)
+    if proc.returncode != 0:
+        print(f"  cloakbrowser stderr: {proc.stderr[:400]}", file=__import__('sys').stderr)
+    return proc.returncode
+
+
+def cmd_switch(args: argparse.Namespace) -> int:
+    """`omega switch <provider>` — hot-swap the LLM provider for new chats.
+
+    Existing tmux sessions keep their current provider; only the NEXT
+    chat session spawned (via `omega`, `omega aisb`, `omega hermes`) uses
+    the new one. Per-LLM persona files are already in place in every
+    context dir (write_all_personas runs at install + on every spawn),
+    so switching is just changing which `cli` the tmux session launches.
+
+    Supported provider ids (must match the LLM CLI catalog in
+    `bootstrap/lib/llm-clis.py` + `omega_engine.personas`):
+
+      claude_code, gemini_cli, codex, opencode, openrouter_cli,
+      deepseek, qwen_code, continue_dev, aider
+    """
+    import shutil
+    valid = {
+        "claude_code":  "claude",
+        "gemini_cli":   "gemini",
+        "codex":        "codex",
+        "opencode":     "opencode",
+        "openrouter_cli": "opencode",
+        "deepseek":     "opencode",
+        "qwen_code":    "qwen",
+        "continue_dev": "cn",
+        "aider":        "aider",
+    }
+    if not getattr(args, "provider", None):
+        print(f"  active provider: {_active_provider()}")
+        print(f"  available:")
+        for pid, bin_name in valid.items():
+            mark = "✓" if shutil.which(bin_name) else "—"
+            active = "  (active)" if pid == _active_provider() else ""
+            print(f"    {mark}  {pid:<16} ({bin_name}){active}")
+        return 0
+    target = args.provider
+    if target not in valid:
+        print(f"  unknown provider: {target!r}")
+        print(f"  valid: {', '.join(valid)}")
+        return 2
+    if not shutil.which(valid[target]):
+        print(f"  provider {target!r} not installed — `omega upgrade` "
+              f"or re-run install.sh with the llm_clis: block")
+        return 2
+    _set_active_provider(target)
+    print(f"  active provider set to: {target}")
+    print(f"  next `omega` / `omega aisb` / `omega hermes` will launch with `{valid[target]}`")
+    return 0
+
+
 def cmd_hermes_desktop(args: argparse.Namespace) -> int:
     """`omega hermes-desktop {install,serve,profile,status}` — expose this
     VPS as a remote backend for the Hermes Desktop Electron app."""
@@ -4024,6 +4178,33 @@ def _build_parser() -> argparse.ArgumentParser:
         help="open the interactive whiptail menu (the old `omega` behaviour)"
     ).set_defaults(fn=cmd_menu_whiptail)
     sub.add_parser("version", help="print the engine version").set_defaults(fn=cmd_version)
+
+    # `omega switch <provider>` — hot-swap the LLM CLI used for new chats.
+    p_sw = sub.add_parser(
+        "switch",
+        help="switch the default LLM provider for new chat sessions "
+        "(claude_code / gemini_cli / codex / opencode / qwen_code / "
+        "continue_dev / aider)",
+    )
+    p_sw.add_argument("provider", nargs="?", default=None,
+                      help="provider id (omit to print current + available)")
+    p_sw.set_defaults(fn=cmd_switch)
+
+    # `omega scrape <url>` — official OmegaOS web scraper (CloakBrowser).
+    p_sc = sub.add_parser(
+        "scrape",
+        help="stealth scrape a URL via CloakBrowser — bypasses Cloudflare, "
+        "Turnstile, FingerprintJS. Output: markdown to stdout (or --out FILE)",
+    )
+    p_sc.add_argument("url", nargs="?", default=None,
+                      help="URL to fetch")
+    p_sc.add_argument("--out", default=None,
+                      help="write result to file instead of stdout")
+    p_sc.add_argument("--humanize", action="store_true",
+                      help="mouse curves + keyboard timing + scroll patterns")
+    p_sc.add_argument("--proxy", default=None,
+                      help="HTTP or SOCKS5 proxy (with inline creds)")
+    p_sc.set_defaults(fn=cmd_scrape)
     p_doc = sub.add_parser("doctor", help="validate the deployment")
     p_doc.add_argument("--json", action="store_true",
                        help="emit a single JSON object instead of pretty text")

package/omega/Agentik_Engine/omega_engine/genesis/stack.py

@@ -176,6 +176,61 @@ def _backend_supabase_stack() -> Stack:
     )
 
 
+def _convex_selfhosted_stack() -> Stack:
+    """Self-hosted Convex backend running on the operator's VPS.
+
+    Convex went open-source in 2024 — you can run the full backend
+    locally or on a VPS instead of paying the Convex Cloud. This stack
+    pre-wires that path: Next.js + Vercel frontend, Convex self-hosted
+    on the operator's VPS, Stripe payments, Clerk auth, shadcn UI.
+    """
+    return Stack(
+        id="convex-selfhosted",
+        title="Convex self-hosted (VPS) + Next.js + Vercel + Stripe + Clerk",
+        config=StackConfig(
+            type="web",
+            frontend="nextjs",
+            backend="convex",   # but with extras=["selfhosted"]
+            deploy="vercel",
+            payments="stripe",
+            ui_kit="shadcn",
+            auth="clerk",
+            extras=["convex-selfhosted", "vps-backend"],
+        ),
+        why="When the operator wants Convex's real-time + typed model "
+            "without Convex Cloud lock-in. Backend runs on their VPS via "
+            "the open-source Convex docker image. Same DX, zero per-call "
+            "cost, full data sovereignty.",
+    )
+
+
+def _sqlite_local_stack() -> Stack:
+    """Local SQLite-only stack — the simplest possible.
+
+    For tools, internal apps, single-user dashboards. No backend
+    process needed, no auth surface, no per-call cost. Drizzle ORM
+    over better-sqlite3 gives a typed query layer.
+    """
+    return Stack(
+        id="sqlite-local",
+        title="Local SQLite (Next.js + Drizzle + Vercel — single-user)",
+        config=StackConfig(
+            type="web",
+            frontend="nextjs",
+            backend="postgres+drizzle",   # drizzle works with sqlite too
+            deploy="vercel",
+            payments="none",
+            ui_kit="shadcn",
+            auth="none",
+            extras=["sqlite-local", "drizzle-sqlite"],
+        ),
+        why="Single-user / internal-tool stack. SQLite file in the project "
+            "dir, Drizzle for typed queries, no auth, no payments. Ship "
+            "in 20 minutes. Upgrade to a real backend later when the "
+            "scale calls for it.",
+    )
+
+
 def _claude_dashboard_stack() -> Stack:
     """The Claude Code-grade premium dashboard stack.
 
@@ -213,6 +268,8 @@ CANONICAL_STACKS: dict[str, Stack] = {
         _desktop_tauri_stack(),
         _backend_supabase_stack(),
         _claude_dashboard_stack(),
+        _convex_selfhosted_stack(),
+        _sqlite_local_stack(),
     )
 }
 

package/omega/Agentik_Engine/omega_engine/personas.py

@@ -0,0 +1,197 @@
+"""Multi-LLM persona writer — one canonical OmegaOS context, N output files.
+
+Every LLM CLI we install (Claude Code, Gemini CLI, OpenAI Codex, OpenCode,
+Continue.dev, Qwen, Aider…) reads a different filename for its project
+context (CLAUDE.md, GEMINI.md, AGENTS.md, .opencode/CONTEXT.md, etc.).
+Without a canonical source, the operator has to copy the same content
+into N files manually and they drift.
+
+This module:
+
+1. Defines the canonical OmegaOS context at one path
+   (``$OMEGA_HOME/Agentik_SSOT/personas/OMEGAOS-CONTEXT.md``).
+2. Exports ``write_all_personas(home, chat_context_dir)`` which mirrors
+   that one canonical file into every LLM's expected filename inside the
+   project dir, so when the user runs `claude`, `gemini`, `codex`,
+   etc. in that dir they ALL load the same OmegaOS persona.
+3. Idempotent — re-running diff-checks before write.
+
+Used by:
+  * step_clis post-install pass — seeds the canonical context.
+  * tmux.spawn_*_chat — ensures the chat context dir has every persona
+    file before launching whichever CLI the user picked.
+  * `omega switch <provider>` — re-renders the active context's
+    persona pointer.
+"""
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+
+# The single source of truth. Every per-LLM persona file is a symlink or
+# mirror of this.
+CANONICAL_FILENAME = "OMEGAOS-CONTEXT.md"
+
+
+# Map: LLM id → list of persona filenames it reads (relative to a project dir).
+# Sources:
+#   - Anthropic Claude Code → CLAUDE.md          (project root or ~/.claude/CLAUDE.md)
+#   - Google Gemini CLI    → GEMINI.md          (project root or ~/.gemini/GEMINI.md)
+#   - OpenAI Codex CLI     → AGENTS.md          (project root)
+#   - OpenCode             → .opencode/CONTEXT.md
+#   - Continue.dev         → .continue/CONTEXT.md
+#   - Qwen Code            → QWEN.md
+#   - Aider                → .aider.conf.yml    (config, not full context)
+#                            + CONVENTIONS.md   (Aider's persona convention)
+_LLM_PERSONA_PATHS: dict[str, list[str]] = {
+    "claude_code":  ["CLAUDE.md"],
+    "gemini_cli":   ["GEMINI.md"],
+    "codex":        ["AGENTS.md"],
+    "opencode":     [".opencode/CONTEXT.md"],
+    "openrouter_cli": [".opencode/CONTEXT.md"],
+    "deepseek":     [".opencode/CONTEXT.md"],
+    "qwen_code":    ["QWEN.md"],
+    "continue_dev": [".continue/CONTEXT.md"],
+    "aider":        ["CONVENTIONS.md"],
+    "hermes":       ["HERMES.md"],
+}
+
+
+_DEFAULT_CONTEXT_TEMPLATE = """\
+# OmegaOS — Working Context
+
+> *You are running inside an OmegaOS-managed Claude/Gemini/Codex/OpenCode
+> session. This file is auto-generated by `omega_engine.personas` and
+> mirrored from `$OMEGA_HOME/Agentik_SSOT/personas/OMEGAOS-CONTEXT.md`.
+> Edits to per-LLM files (CLAUDE.md, GEMINI.md, …) are lost on next sync —
+> edit the canonical file instead.*
+
+## What OmegaOS is
+
+OmegaOS is a 5-layer agentic operating system:
+
+```
+Layer 1  Human (Telegram, CLI, web)
+Layer 2  Hermès        — meta-companion (Anthropic API, separate budget)
+Layer 3  AISB          — OmegaOS intake / orchestrator (Claude Max OAuth)
+Layer 4  Oracle        — planner / dispatcher (per-project tmux session)
+Layer 5  Workers       — executors (one per subtask, .done.json verified)
+```
+
+You sit at L4 or L5 depending on context.
+
+## The Three Laws (override everything)
+
+1. **Code lies. Comments lie. Only runtime tells the truth.**
+   Observe before concluding. Before the 3rd code change on the same
+   bug, live runtime evidence is MANDATORY.
+2. **Researcher, not sycophant.** Challenge flawed premises. Think
+   before coding. Iterate with evidence. Root causes over symptoms.
+3. **Autonomous execution.** When dispatched, never wait. Decide →
+   execute → report. The only legal stop is `.done.json` with status
+   `done_clean | pending | failed`.
+
+## OmegaOS structure (where things live)
+
+```
+$OMEGA_HOME = ~/Omega
+├── Agentik_Engine/                  ← Python engine (omega CLI)
+├── Agentik_SSOT/                    ← source of truth
+│   ├── skills/                      ← 17 audits + orchestrators + /newcmd
+│   ├── agents/aisb/                 ← 13 AISB persona files
+│   ├── personas/OMEGAOS-CONTEXT.md  ← THIS FILE
+│   ├── docs/LAYERS.md               ← formal L1-L5 architecture
+│   └── clis/clis-catalog.yaml       ← CLI catalog
+├── Agentik_Orchestration/           ← topology YAMLs
+├── Agentik_Coding/projects/<slug>/  ← per-project root (strict isolation)
+├── Agentik_Runtime/                 ← event log, RAG, locks, sessions
+├── Agentik_Tools/bin/omega          ← the CLI you can shell out to
+└── Agentik_Extra/etc/secrets/       ← age-encrypted vault
+```
+
+## What you can do (shell out via Bash)
+
+| Action | Command |
+|---|---|
+| Mission with verified completion | `omega run "<intent>"` |
+| New project (Genesis pipeline) | `omega genesis new <slug>` |
+| Audit code/UI/flow/security/… | `omega audit <id>` (or the `/codeaudit` skill) |
+| Switch LLM provider for this session | `omega switch <provider>` |
+| Vault secrets | `omega vault read/write <REF>` |
+| Status / health | `omega doctor` / `omega status` |
+| Session manager (tmux) | `omega` (no args) |
+
+## Quality Arsenal (17 forensic audits)
+
+`/codeaudit /flowaudit /uiuxaudit /debugaudit /featureaudit /perfaudit
+/secaudit /a11yaudit /seoaudit /dataaudit /apiaudit /copyaudit /dxaudit
+/motionaudit /automationaudit /logicaudit /retentionaudit`
+
+Each: Gestalt clarity gate, Popper falsification, hinge point 10x
+scrutiny, auto-fix, auto-re-audit, scored /100.
+
+## When something doesn't fit OmegaOS
+
+Push back. Don't quietly invent. State the premise, decide, execute.
+If the user's request would violate one of the Three Laws or the
+verified-completion contract, call it out — they want a researcher,
+not a yes-engine.
+"""
+
+
+def canonical_path(omega_home: Path) -> Path:
+    """Where the single source of truth lives."""
+    return omega_home / "Agentik_SSOT" / "personas" / CANONICAL_FILENAME
+
+
+def ensure_canonical(omega_home: Path) -> Path:
+    """Create the canonical OmegaOS context file if absent. Returns its
+    path. Operators are free to edit this file — it's the SSOT."""
+    path = canonical_path(omega_home)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if not path.exists():
+        path.write_text(_DEFAULT_CONTEXT_TEMPLATE)
+    return path
+
+
+def write_all_personas(
+    omega_home: Path | str,
+    chat_context_dir: Path | str,
+    *,
+    llm_ids: list[str] | None = None,
+) -> dict[str, str]:
+    """Mirror the canonical context into every LLM's expected filename
+    inside ``chat_context_dir``.
+
+    Returns ``{llm_id: relative_path}`` for what was written. Files
+    that already match (content equality) are skipped silently —
+    idempotent.
+
+    When ``llm_ids`` is None we write for every LLM in
+    ``_LLM_PERSONA_PATHS`` (cheap insurance against the user later
+    swapping providers).
+    """
+    home = Path(omega_home)
+    ctx_dir = Path(chat_context_dir)
+    ctx_dir.mkdir(parents=True, exist_ok=True)
+
+    src = ensure_canonical(home)
+    content = src.read_text()
+
+    targets = list(llm_ids) if llm_ids else list(_LLM_PERSONA_PATHS)
+    written: dict[str, str] = {}
+    for llm in targets:
+        for rel in _LLM_PERSONA_PATHS.get(llm, []):
+            dest = ctx_dir / rel
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            if dest.exists() and dest.read_text() == content:
+                continue
+            dest.write_text(content)
+            written[llm] = rel
+    return written
+
+
+def supported_llm_ids() -> list[str]:
+    """The LLM ids personas can be written for."""
+    return list(_LLM_PERSONA_PATHS)

package/omega/Agentik_Engine/omega_engine/tmux.py

@@ -233,29 +233,59 @@ def spawn_worker(project: str, task: str, *,
 
 def _ensure_chat_context_dir(home: Path, label: str,
                               persona_md_path: Path) -> Path:
-    """Create (idempotent) a dedicated Claude Code project dir for an
-    OmegaOS chat session.
-
-    Drops ``CLAUDE.md`` (the persona) so Claude Code auto-loads it as
-    project context when the user runs `claude` in this dir. Returns
-    the path.
+    """Create (idempotent) a multi-LLM project dir for an OmegaOS chat
+    session.
+
+    v0.19.22 — drops persona files for EVERY supported LLM (CLAUDE.md,
+    GEMINI.md, AGENTS.md, QWEN.md, .opencode/CONTEXT.md, etc.) sourced
+    from the canonical ``Agentik_SSOT/personas/OMEGAOS-CONTEXT.md``.
+    User can `claude` here, OR `gemini`, OR `codex`, OR `opencode`, OR
+    `qwen`, OR `aider` — they all see the SAME OmegaOS context. Hot-swap
+    works because every CLI's file is already in place.
+
+    The ``persona_md_path`` argument is now used only as a hint: if a
+    role-specific persona file exists at that path (e.g. the AISB v7.0
+    master prompt), we PREPEND it to the canonical context so AISB-chat
+    gets both the role identity AND the OmegaOS background, while
+    Hermes-chat gets just the canonical context.
     """
     ctx_dir = home / "Agentik_Coding" / "chat-contexts" / label
     ctx_dir.mkdir(parents=True, exist_ok=True)
-    target = ctx_dir / "CLAUDE.md"
-    if persona_md_path.is_file():
-        # Mirror the upstream persona file so refreshes propagate.
-        target.write_text(persona_md_path.read_text())
-    elif not target.exists():
-        target.write_text(
-            f"# {label} chat context\n\n"
-            f"(no persona file found — using default Claude Code behaviour)\n"
-        )
-    # Also drop a .gitignore so this transient dir never gets committed
-    # by accident if the user `git init`s it.
+
+    # Build the merged context: role-specific persona (if any) + canonical.
+    from omega_engine.personas import (
+        canonical_path, ensure_canonical, write_all_personas,
+    )
+    ensure_canonical(home)
+    canonical_text = canonical_path(home).read_text()
+    if persona_md_path.is_file() and persona_md_path.name not in (
+        "OMEGAOS-CONTEXT.md",
+    ):
+        role_text = persona_md_path.read_text()
+        merged = f"{role_text}\n\n---\n\n{canonical_text}"
+        # Write merged to the canonical filename in ctx_dir, then mirror
+        # to every LLM's expected filename via personas.write_all.
+        merged_file = ctx_dir / "OMEGAOS-CONTEXT.md"
+        merged_file.write_text(merged)
+        # personas.write_all reads from the canonical — temporarily point
+        # to the merged version by writing per-LLM files directly.
+        for llm_id in [
+            "claude_code", "gemini_cli", "codex", "opencode",
+            "qwen_code", "continue_dev", "aider", "hermes",
+        ]:
+            from omega_engine.personas import _LLM_PERSONA_PATHS  # noqa: WPS437
+            for rel in _LLM_PERSONA_PATHS.get(llm_id, []):
+                dest = ctx_dir / rel
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                if not dest.exists() or dest.read_text() != merged:
+                    dest.write_text(merged)
+    else:
+        write_all_personas(home, ctx_dir)
+
+    # `.gitignore` so the transient dir doesn't get committed.
     gi = ctx_dir / ".gitignore"
     if not gi.exists():
-        gi.write_text("*\n!.gitignore\n!CLAUDE.md\n")
+        gi.write_text("*\n!.gitignore\n!*.md\n!.opencode/\n!.continue/\n")
     return ctx_dir
 
 

package/omega/Agentik_Engine/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "omega-engine"
-version = "0.19.21"
+version = "0.19.23"
 description = "The Omega OS orchestration engine — event-sourced, verified-completion agent graphs."
 readme = "README.md"
 requires-python = ">=3.11"

package/omega/Agentik_SSOT/VERSION

@@ -1 +1 @@
-0.19.21
+0.19.23

package/omega/Agentik_SSOT/claude-plugins/claude-plugins.yaml

@@ -131,3 +131,11 @@ catalog:
     marketplace: claude-plugins-official
     scope: user
     recommended: false
+
+  - id: superpowers
+    name: superpowers
+    description: "obra/superpowers — agentic framework with subagent-driven dev, TDD, planning, brainstorm, code review enforced"
+    category: workflow
+    marketplace: claude-plugins-official
+    scope: user
+    recommended: true

package/omega/Agentik_SSOT/clis/clis-catalog.yaml

@@ -64,6 +64,16 @@ native:
     secrets: []
     recommended: true
 
+  - id: cloakbrowser
+    name: CloakBrowser (official OmegaOS scraper — bypasses bot detection)
+    # PyPI package — installed into a uv tool so it's globally available
+    # as `cloakbrowser` + `python -m cloakbrowser`. ~200MB binary
+    # downloaded on first run (cached).
+    install: { uv_tool: "cloakbrowser" }
+    binary: cloakbrowser
+    secrets: []
+    recommended: true
+
 # --- 2. Printing Press CLIs --------------------------------------------
 # Installed via `npx -y @mvanhorn/printing-press-library install <name>`.
 # Each ships with a local SQLite mirror + Claude Code skill.

package/omega/Agentik_SSOT/llm-providers/providers-catalog.yaml

@@ -0,0 +1,169 @@
+# Omega OS — LLM provider catalog (v0.19.23+)
+#
+# Maps the operator's intent ("I want to talk to GLM") to a concrete
+# (cli + provider_config) pair. Most providers don't ship their own CLI —
+# they're configurable backends inside OpenCode / Continue.dev / Aider.
+#
+# Used by:
+#   * `omega switch <provider>` — looks up the cli + writes the
+#     provider-active marker.
+#   * step_provider_configs — drops templated config files for every
+#     supported provider with secret refs from the vault.
+#   * `omega account login --provider <id>` — guides the auth flow per
+#     provider.
+#
+# Secrets are vault refs, never literal. Templated config files end up at
+# the LLM CLI's expected path on first launch.
+
+version: 1
+
+providers:
+  # -- Anthropic family --
+  - id: anthropic
+    label: "Anthropic Claude (API key)"
+    cli: claude_code
+    auth_kind: api_key
+    secret_refs: [ANTHROPIC_API_KEY]
+    notes: |
+      Direct Anthropic API access. Pay-per-token. For OmegaOS's own
+      L3-L5 stack we prefer Claude Max OAuth (no cost) — this entry is
+      for L2 / Hermès style "use my paid Anthropic budget" scenarios.
+
+  - id: chatgpt_subscription
+    label: "ChatGPT Subscription (OpenAI Codex)"
+    cli: codex
+    auth_kind: oauth
+    secret_refs: []
+    notes: |
+      Codex CLI uses the same OAuth as your ChatGPT Plus/Team sub —
+      no separate API key needed. `codex login` opens the browser.
+
+  # -- OpenAI family --
+  - id: openai
+    label: "OpenAI (API key — gpt-4o, gpt-5, o3-pro)"
+    cli: codex          # codex IS OpenAI's official agentic CLI
+    auth_kind: api_key
+    secret_refs: [OPENAI_API_KEY]
+    notes: |
+      Pay-per-token OpenAI API. Use this when you want gpt-5/o3-pro
+      without the ChatGPT subscription cap.
+
+  - id: openai_compatible
+    label: "OpenAI API-Compatible endpoint (custom)"
+    cli: opencode       # OpenCode's `provider: openai_compatible`
+    auth_kind: api_key
+    secret_refs: [OPENAI_API_BASE, OPENAI_API_KEY]
+    notes: |
+      For LM Studio, vLLM, llama.cpp's `/v1` server, Together.ai's
+      OpenAI-shape endpoint, etc.
+
+  # -- Google --
+  - id: google_ai
+    label: "Google AI Studio (Gemini)"
+    cli: gemini_cli
+    auth_kind: api_key
+    secret_refs: [GOOGLE_API_KEY]
+    notes: |
+      Direct Gemini API via the official `gemini` CLI. Free tier
+      generous; paid tier for higher RPM.
+
+  # -- China --
+  - id: glm
+    label: "Zhipu GLM-4.5 / GLM-4.6 (via OpenCode)"
+    cli: opencode
+    auth_kind: api_key
+    secret_refs: [GLM_API_KEY]
+    notes: |
+      Zhipu AI's GLM models — open weights for the smaller variants,
+      hosted API for GLM-4.6. OpenCode provider `zhipu`.
+
+  - id: deepseek
+    label: "DeepSeek V3 / R1 (via OpenCode)"
+    cli: opencode
+    auth_kind: api_key
+    secret_refs: [DEEPSEEK_API_KEY]
+    notes: |
+      DeepSeek's V3 + R1 reasoning. Excellent price/perf. OpenCode
+      provider `deepseek`.
+
+  - id: qwen
+    label: "Qwen (Alibaba) — dedicated CLI"
+    cli: qwen_code
+    auth_kind: api_key
+    secret_refs: [DASHSCOPE_API_KEY]
+    notes: |
+      Qwen3-Coder via Alibaba's DashScope. Standalone `qwen` CLI.
+
+  # -- Local --
+  - id: ollama
+    label: "Ollama (local — Llama/Mistral/Qwen/DeepSeek-Coder)"
+    cli: ollama
+    auth_kind: none
+    secret_refs: []
+    notes: |
+      Local model runtime. Free, private, runs offline. Pull a model
+      with `ollama pull llama3.3:70b` then `ollama run`.
+
+  - id: lm_studio
+    label: "LM Studio (local — GUI + CLI)"
+    cli: lm_studio
+    auth_kind: none
+    secret_refs: []
+    notes: |
+      LM Studio for desktop. Run any GGUF model locally. Exposes an
+      OpenAI-compatible `/v1` endpoint OpenCode can consume.
+
+  # -- Aggregators / Gateways --
+  - id: openrouter
+    label: "OpenRouter (300+ models, one API key)"
+    cli: opencode
+    auth_kind: api_key
+    secret_refs: [OPENROUTER_API_KEY]
+    notes: |
+      Route to any of 300+ models with one API key. OpenCode provider
+      `openrouter`. Per-call routing in config.
+
+  - id: vercel_ai_gateway
+    label: "Vercel AI Gateway (multi-provider)"
+    cli: opencode
+    auth_kind: api_key
+    secret_refs: [AI_GATEWAY_API_KEY]
+    notes: |
+      Vercel's hosted gateway proxies your traffic across providers
+      with usage caps + observability. OpenCode `provider: ai_gateway`.
+
+  # -- Hyperscalers --
+  - id: amazon_bedrock
+    label: "Amazon Bedrock (AWS)"
+    cli: opencode
+    auth_kind: aws
+    secret_refs: [AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION]
+    notes: |
+      AWS Bedrock — Claude, Llama, Mistral, Cohere, Stability through
+      AWS auth. OpenCode `provider: bedrock`.
+
+  # -- Other --
+  - id: mistral
+    label: "Mistral AI (API key)"
+    cli: opencode
+    auth_kind: api_key
+    secret_refs: [MISTRAL_API_KEY]
+    notes: |
+      Mistral-Large, Codestral, Pixtral. OpenCode `provider: mistral`.
+
+  - id: xai
+    label: "xAI Grok (Grok-2, Grok-Beta)"
+    cli: opencode
+    auth_kind: api_key
+    secret_refs: [XAI_API_KEY]
+    notes: |
+      Grok-2 / Grok-Beta via xAI's API. OpenCode `provider: xai`.
+
+  - id: github_copilot
+    label: "GitHub Copilot Chat (via gh extension)"
+    cli: gh_copilot
+    auth_kind: oauth
+    secret_refs: []
+    notes: |
+      Talk to Copilot from the terminal — `gh copilot suggest "..."` and
+      `gh copilot explain "..."`. Uses your GitHub OAuth.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentikos/omega-os",
-  "version": "0.19.21",
+  "version": "0.19.23",
   "description": "Omega OS — installable agentic operating system with verified-completion orchestration. Event-sourced engine, 8-block rack, autonomous agents, MCP.",
   "bin": {
     "omega-os": "bin/omega-os.js"