@agentikos/omega-os 0.19.21 → 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/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.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.21"
+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.21
+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/package.json

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