@agentikos/omega-os 0.19.20 → 0.19.22

package/bootstrap/lib/llm-clis.py

@@ -99,6 +99,38 @@ _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",
+    ),
 ]
 
 

package/bootstrap/lib/steps.sh

@@ -463,6 +463,154 @@ PY
 
 # --- 40 -----------------------------------------------------------------------
 #
+# step_clis — install system CLIs + Printing Press CLI library.
+#
+# Replaces step_mcp as the default integration story (v0.19.21+). The
+# rationale per the operator: MCP servers are token-expensive (each
+# call pays protocol round-trip + server system prompt overhead). System
+# CLIs that Claude Code shells out to via `Bash` are predictable, cheap,
+# and survive without a long-lived server process. Printing Press
+# (https://printingpress.dev) extends that model with agent-native CLIs
+# that ship local SQLite mirrors — even cheaper than remote API calls.
+#
+# Three phases:
+#   1. AUDIT — detect what's already installed; render a status table.
+#   2. NATIVE — install missing recommended native binaries via the
+#               OS package manager (or npm-global / curl fallback).
+#   3. PRINTING PRESS — install the PP factory + the recommended CLIs
+#                       from the library catalog.
+#
+# Idempotent — re-running only acts on what's still missing.
+step_clis() {
+  local catalog="$OMEGA_HOME/Agentik_SSOT/clis/clis-catalog.yaml"
+  [ -f "$catalog" ] || { err "CLI catalog missing: $catalog"; return 1; }
+  PYTHONPATH="$OMEGA_HOME/Agentik_Engine" python3 - "$catalog" "$OMEGA_PKG" <<'PY' 2>>"$LOG_FILE"
+import os
+import shutil
+import subprocess
+import sys
+import yaml
+
+catalog_path = sys.argv[1]
+pkg = sys.argv[2]  # apt | dnf | brew | unknown
+
+with open(catalog_path) as f:
+    catalog = yaml.safe_load(f) or {}
+
+# ─── Phase 1: audit ───────────────────────────────────────────
+print("\n  ──── CLI audit ────")
+ok_count = 0
+missing = []
+for entry in catalog.get("native", []):
+    cli_id = entry["id"]
+    binary = entry.get("binary", cli_id)
+    if shutil.which(binary):
+        print(f"  ok   {cli_id:<14} ({binary} present)")
+        ok_count += 1
+    else:
+        rec = entry.get("recommended", False)
+        tag = "MISSING (recommended)" if rec else "missing (optional)"
+        print(f"  --   {cli_id:<14} {tag}")
+        missing.append(entry)
+print(f"  → {ok_count}/{len(catalog.get('native', []))} native CLIs present\n")
+
+# ─── Phase 2: install missing recommended native CLIs ─────────
+def _run(cmd, env=None, timeout=600):
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True,
+                              timeout=timeout, env=env)
+        return proc.returncode, proc.stdout + proc.stderr
+    except (subprocess.SubprocessError, FileNotFoundError) as e:
+        return 1, str(e)
+
+installed_now = []
+failed_now = []
+for entry in missing:
+    if not entry.get("recommended", False):
+        continue
+    cli_id = entry["id"]
+    install = entry.get("install", {})
+    rc, out, attempt = 1, "", ""
+
+    if pkg in install:  # platform-specific package name
+        if pkg == "brew":
+            rc, out = _run(["brew", "install", install[pkg]])
+            attempt = f"brew install {install[pkg]}"
+        elif pkg == "apt":
+            rc, out = _run(["sudo", "apt-get", "install", "-y", "-qq", install[pkg]])
+            attempt = f"apt-get install {install[pkg]}"
+        elif pkg == "dnf":
+            rc, out = _run(["sudo", "dnf", "install", "-y", "-q", install[pkg]])
+            attempt = f"dnf install {install[pkg]}"
+    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 "curl" in install:
+        # curl|bash installer — last resort
+        rc, out = _run(["bash", "-c", f"curl -fsSL {install['curl']} | bash"])
+        attempt = f"curl {install['curl']} | bash"
+    else:
+        print(f"  skip {cli_id}: no install method for pkg={pkg}")
+        continue
+
+    binary = entry.get("binary", cli_id)
+    if shutil.which(binary):
+        print(f"  ok   {cli_id:<14} (installed via {attempt})")
+        installed_now.append(cli_id)
+    else:
+        print(f"  fail {cli_id}: {attempt} returned rc={rc}")
+        failed_now.append(cli_id)
+
+# ─── Phase 3: Printing Press ──────────────────────────────────
+pp_core = catalog.get("printing_press_core", {})
+pp_clis = catalog.get("printing_press_clis", [])
+
+print(f"\n  ──── Printing Press ({len(pp_clis)} library CLIs available) ────")
+
+# Install PP core (printer + library client) if not present
+if not shutil.which("ppi-update") and not shutil.which("npx"):
+    print("  skip: neither ppi-update nor npx on PATH — install Node first")
+elif not shutil.which("ppi-update"):
+    install_cmd = pp_core.get("install_method", "")
+    if install_cmd:
+        print(f"  installing Printing Press core: {install_cmd}")
+        rc, out = _run(["bash", "-c", install_cmd], timeout=300)
+        if rc == 0:
+            print("  ok   Printing Press core installed")
+        else:
+            print(f"  warn Printing Press core install rc={rc} — library CLIs may still work via npx")
+else:
+    print("  ok   Printing Press core already installed")
+
+# Install recommended PP library CLIs (one npx call per recommended entry)
+pp_lib_cmd = ["npx", "-y", "@mvanhorn/printing-press-library"]
+pp_ok = 0
+pp_failed = []
+for entry in pp_clis:
+    if not entry.get("recommended", False):
+        continue
+    cli_id = entry["id"]
+    print(f"  installing pp-cli: {cli_id}…")
+    rc, out = _run([*pp_lib_cmd, "install", cli_id], timeout=300)
+    if rc == 0:
+        print(f"  ok   {cli_id}")
+        pp_ok += 1
+    else:
+        print(f"  fail {cli_id}: rc={rc}")
+        pp_failed.append(cli_id)
+
+print(f"\n  ──── Summary ────")
+print(f"  Native CLIs installed this run:    {installed_now or '(none missing)'}")
+print(f"  Native CLIs that failed:           {failed_now or '(none)'}")
+print(f"  Printing Press CLIs installed:     {pp_ok} (of {sum(1 for e in pp_clis if e.get('recommended'))} recommended)")
+print(f"  Printing Press CLIs that failed:   {pp_failed or '(none)'}")
+print(f"  Non-recommended CLIs available via:  omega cli install <id>")
+PY
+  return 0
+}
+
+# --- 40-legacy ----------------------------------------------------------------
+#
 # step_mcp — present the MCP/plugin catalog as a checklist (interactive) or
 # apply the manifest's `mcp:` list (headless). For each selected entry:
 #   1. install the server binary into Agentik_Tools/<id>/

package/install.sh

@@ -147,7 +147,13 @@ STEPS=(
   "35-providers:step_providers"
   "36-tmux-config:step_tmux_config"
   "37-hermes-brief:step_hermes_brief"
-  "40-mcp:step_mcp"
+  # v0.19.21 — MCP install dropped from the default sequence. MCPs are
+  # token-expensive (each call pays the protocol round-trip + the
+  # server's system prompt overhead). We replace with system CLIs +
+  # Printing Press (https://printingpress.dev) — agent-native CLIs
+  # with local SQLite mirrors. Re-enable opt-in via:
+  #   omega tool install <id>   (still wired for one-offs)
+  "40-clis:step_clis"
   "45-claude-plugins:step_claude_plugins"
 )
 if [ "$PROFILE" != "minimal" ]; then

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.20"
+__version__ = "0.19.22"
 
 __all__ = [
     "__version__",

package/omega/Agentik_Engine/omega_engine/cli.py

@@ -2941,6 +2941,80 @@ 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_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 +4098,17 @@ 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)
     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.20"
+version = "0.19.22"
 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.20
+0.19.22

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

@@ -0,0 +1,151 @@
+# Omega OS — system CLI catalog (v0.19.21+)
+#
+# Replaces the v0.19.20 MCP catalog. Rationale: MCP servers are
+# token-expensive (each call pays the protocol round-trip + the server's
+# system prompt overhead). System CLIs that Claude Code calls via `Bash`
+# are cheap, predictable, and survive without a running server.
+#
+# Printing Press (https://printingpress.dev) ships ~50 agent-native CLIs
+# with local SQLite mirrors for offline queries — even cheaper than
+# remote API calls. We pull a curated subset by default.
+#
+# Maintained by the connection-educator (Agentik_Orchestration/educators/).
+# Secrets are referenced by name only — operator wires them at install
+# time or later via `omega vault write <REF> <value>`.
+
+version: 1
+
+# --- 1. Native binaries — install via system package manager -----------
+# These are the bedrock — `omega audit` and most workflows assume
+# they're on PATH.
+native:
+  - id: gh
+    name: GitHub CLI
+    install: { brew: "gh", apt: "gh", dnf: "gh" }
+    recommended: true
+  - id: vercel
+    name: Vercel CLI
+    install: { npm_global: "vercel" }
+    recommended: true
+  - id: wrangler
+    name: Cloudflare Wrangler
+    install: { npm_global: "wrangler" }
+    recommended: false
+  - id: pnpm
+    name: pnpm package manager
+    install: { brew: "pnpm", npm_global: "pnpm" }
+    recommended: true
+  - id: bun
+    name: Bun runtime + package manager
+    install: { brew: "oven-sh/bun/bun", curl: "https://bun.sh/install" }
+    recommended: true
+  - id: ripgrep
+    name: ripgrep (rg) — fast code search
+    install: { brew: "ripgrep", apt: "ripgrep", dnf: "ripgrep" }
+    binary: rg
+    recommended: true
+  - id: bat
+    name: bat — better cat with syntax highlight
+    install: { brew: "bat", apt: "bat", dnf: "bat" }
+    recommended: false
+  - id: jq
+    name: jq — JSON processor
+    install: { brew: "jq", apt: "jq", dnf: "jq" }
+    recommended: true
+  - id: stripe-cli
+    name: Stripe CLI
+    install: { brew: "stripe/stripe-cli/stripe" }
+    binary: stripe
+    secrets: [STRIPE_API_KEY]
+    recommended: false
+  - id: playwright
+    name: Playwright (browser automation for E2E + audits)
+    install: { npm_global: "@playwright/test" }
+    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.
+#
+# Catalog source: github.com/mvanhorn/printing-press-library/library
+printing_press_core:
+  install_method: "curl -fsSL https://raw.githubusercontent.com/mvanhorn/cli-printing-press/main/scripts/install.sh | bash"
+  description: "Printing Press generator + library client (ppi-* CLIs)"
+
+printing_press_clis:
+  - id: stripe
+    category: payments
+    description: "Every Stripe entity + local SQLite mirror, cross-entity SQL"
+    secrets: [STRIPE_API_KEY]
+    recommended: true
+  - id: linear
+    category: project-management
+    description: "Linear issues + projects, local SQLite mirror, compound queries"
+    secrets: [LINEAR_API_KEY]
+    recommended: true
+  - id: jira
+    category: project-management
+    description: "Jira issues + sprints"
+    secrets: [JIRA_API_TOKEN, JIRA_HOST]
+    recommended: false
+  - id: clickup
+    category: project-management
+    description: "ClickUp tasks + spaces"
+    secrets: [CLICKUP_API_KEY]
+    recommended: false
+  - id: cal-com
+    category: productivity
+    description: "Cal.com bookings + availability"
+    secrets: [CAL_COM_API_KEY]
+    recommended: false
+  - id: figma
+    category: productivity
+    description: "Figma files + comments (read-only)"
+    secrets: [FIGMA_TOKEN]
+    recommended: false
+  - id: fireflies
+    category: productivity
+    description: "Fireflies meeting transcripts + summaries"
+    secrets: [FIREFLIES_API_KEY]
+    recommended: false
+  - id: granola
+    category: productivity
+    description: "Granola notes export"
+    secrets: [GRANOLA_API_KEY]
+    recommended: false
+  - id: apify
+    category: developer-tools
+    description: "Apify scraping actors + dataset access"
+    secrets: [APIFY_TOKEN]
+    recommended: false
+  - id: firecrawl
+    category: developer-tools
+    description: "Firecrawl web scraping with local mirror"
+    secrets: [FIRECRAWL_API_KEY]
+    recommended: false
+  - id: docker-hub
+    category: developer-tools
+    description: "Docker Hub repos + tags inspection"
+    secrets: []
+    recommended: false
+  - id: twilio
+    category: social-and-messaging
+    description: "Twilio SMS + voice + WhatsApp"
+    secrets: [TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN]
+    recommended: false
+  - id: ahrefs
+    category: marketing
+    description: "Ahrefs SEO data with local SQLite mirror"
+    secrets: [AHREFS_API_KEY]
+    recommended: false
+  - id: google-search-console
+    category: marketing
+    description: "GSC properties + queries + pages"
+    secrets: [GSC_CREDENTIALS_JSON]
+    recommended: false
+  - id: google-ads
+    category: marketing
+    description: "Google Ads campaigns + spend"
+    secrets: [GOOGLE_ADS_DEVELOPER_TOKEN, GOOGLE_ADS_CLIENT_ID, GOOGLE_ADS_CLIENT_SECRET]
+    recommended: false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentikos/omega-os",
-  "version": "0.19.20",
+  "version": "0.19.22",
   "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"