@agentikos/omega-os 0.19.18 → 0.19.20

package/bootstrap/lib/steps.sh

@@ -21,16 +21,18 @@ step_preflight() {
 
 # --- 10 -----------------------------------------------------------------------
 step_system_deps() {
-  # `whiptail` powers `omega` (the interactive menu — the post-install entry
-  # point). On Debian/Ubuntu it lives in the `whiptail` package, on RHEL/Fedora
-  # in `newt`, on macOS in `newt` via Homebrew. We add it to the base set so a
-  # fresh Mac doesn't end up with a silent `omega` command.
+  # System deps:
+  #   - whiptail/newt — back-up menu (`omega menu`)
+  #   - fzf           — primary picker for the new session manager (`omega`)
+  #                     and required by the tmux-claude install script too
+  # whiptail lives in `whiptail` (Debian/Ubuntu), `newt` (RHEL/Fedora),
+  # `newt` (Homebrew). fzf is `fzf` on every platform.
   local pkgs="python3 git tmux sqlite3 jq curl"
   case "$OMEGA_PKG" in
-    apt)  sudo apt-get update -qq && sudo apt-get install -y -qq $pkgs whiptail python3-venv python3-yaml ;;
-    dnf)  sudo dnf install -y -q $pkgs newt python3-pyyaml ;;
-    brew) brew install $pkgs newt 2>/dev/null || true ;;
-    *)    err "install manually: $pkgs (and whiptail/newt for the menu)"; return 1 ;;
+    apt)  sudo apt-get update -qq && sudo apt-get install -y -qq $pkgs whiptail fzf python3-venv python3-yaml ;;
+    dnf)  sudo dnf install -y -q $pkgs newt fzf python3-pyyaml ;;
+    brew) brew install $pkgs newt fzf 2>/dev/null || true ;;
+    *)    err "install manually: $pkgs (and whiptail/newt + fzf for the menu)"; return 1 ;;
   esac
 
   # PyYAML — required by every install-side helper that reads the manifest
@@ -732,27 +734,36 @@ step_claude_plugins() {
 
   # Register every marketplace referenced by the selected plugins (excluding
   # those marked `builtin: true`).
+  #
+  # Source format MUST be `<owner>/<repo>` for the Claude CLI. We strip
+  # any legacy `github:` prefix the catalog may still carry (pre-v0.19.20
+  # catalogs used `github:owner/repo` which fails with "Invalid
+  # marketplace source format").
   while IFS= read -r src; do
     [ -z "$src" ] && continue
+    src="${src#github:}"
     info "registering marketplace: $src"
     if claude plugin marketplace add "$src" >>"$LOG_FILE" 2>&1; then
       ok "marketplace ok: $src"
     else
-      # Already registered or other non-fatal; log only.
+      # Likely already registered — non-fatal, log only.
       info "marketplace add returned non-zero (may already be registered): $src"
     fi
   done < <(_claude_plugins_marketplaces_for "$catalog" "$selected")
 
+  # `claude plugin install` does NOT accept `-s <scope>` (verified against
+  # Claude Code 2.1.150 — the plugin help only documents --config). The
+  # scope is per-install determined by where the plugin manifest declares
+  # it; we keep `scope:` in the catalog only as documentation.
   local failed=""
   local id
   while IFS= read -r id; do
     [ -z "$id" ] && continue
-    local spec scope
+    local spec
     spec="$(_claude_plugins_install_spec "$catalog" "$id")"
-    scope="$(_claude_plugins_scope_for "$catalog" "$id")"
     [ -z "$spec" ] && { info "no install spec for $id — skipping"; continue; }
-    info "installing claude plugin: $spec (scope=$scope)"
-    if claude plugin install "$spec" -s "$scope" >>"$LOG_FILE" 2>&1; then
+    info "installing claude plugin: $spec"
+    if claude plugin install "$spec" >>"$LOG_FILE" 2>&1; then
       ok "claude plugin installed: $id"
     else
       err "claude plugin $id failed to install — see $LOG_FILE; continuing"

package/install.sh

@@ -207,3 +207,24 @@ record_state_version
 
 # Final boxed celebration + verdict from `omega doctor --json`.
 post_install_card
+
+# v0.19.20 — drop the user into a fresh login shell so $PATH (now
+# containing $OMEGA_HOME/Agentik_Tools/bin) and OMEGA_HOME are loaded
+# immediately. Without this, the user had to remember to
+# `source ~/.zshrc` or open a new terminal — bad UX.
+#
+# Only re-exec when:
+#   * stdin is a tty (interactive install, not piped/CI)
+#   * we're not running under --non-interactive
+#   * the user isn't already in a non-default shell we don't understand
+#   * an `omega` binary exists at the canonical path
+#
+# Otherwise we just print the instruction so the user knows what to do.
+if [ -t 0 ] && [ "${NONINTERACTIVE:-0}" != "1" ] \
+   && [ -x "$OMEGA_HOME/Agentik_Tools/bin/omega" ]; then
+  log ""
+  log "${C_DIM}::${C_RST} reloading your shell so \`omega\` is on PATH…"
+  log "${C_DIM}::${C_RST} type ${C_BOLD}omega${C_RST} to open the session manager"
+  log ""
+  exec "${SHELL:-/bin/bash}" -l
+fi

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

package/omega/Agentik_Engine/omega_engine/cli.py

@@ -2716,24 +2716,25 @@ def cmd_tmux(args: argparse.Namespace) -> int:
 
 
 def cmd_aisb(args: argparse.Namespace) -> int:
-    """`omega aisb` — talk to the AISB master agent without Telegram.
+    """`omega aisb` — straight to the AISB master Claude Code session.
 
-    Two sub-commands:
-      chat       — spawn (or attach to) the AISB-chat tmux session
-      chat-loop  — the REPL loop itself (run inside the tmux session)
+    v0.19.19 — `omega aisb` (no subcommand) now does spawn+attach in one
+    shot, identical to selecting "+ New AISB" from the `omega` session
+    manager. Same Claude Code TUI, same persona via CLAUDE.md.
+
+    Sub-commands:
+      chat       — explicit alias for the default (back-compat)
+      chat-loop  — the legacy Python REPL (used by dispatched workers
+                   that want a programmatic single-turn API)
     """
     from omega_engine import tmux
-    sub = args.aisb_cmd or "chat"
-    home = _omega_home()
-    if sub == "chat":
-        name = "AISB-chat"
-        if tmux.is_alive(name):
-            print(f"  session already exists: {name}")
-        else:
-            tmux.spawn_aisb_chat(home)
-            print(f"  spawned: {name}")
-        print(f"  attach:  {tmux.attach_command(name)}")
-        return 0
+    sub = getattr(args, "aisb_cmd", None) or "chat"
+    if sub in ("chat", None):
+        return _attach_or_spawn_chat(
+            "AISB-chat",
+            spawn_fn=tmux.spawn_aisb_chat,
+            label="AISB master (Claude Code on Max OAuth)",
+        )
     if sub == "chat-loop":
         from omega_engine.aisb_chat import run_chat_loop
         return run_chat_loop()
@@ -2783,21 +2784,152 @@ def _attach_or_spawn_chat(session_name: str, *,
     return 0  # unreachable (execvp replaced the process)
 
 
-def cmd_menu(_args: argparse.Namespace) -> int:
-    """`omega` (no args) — open the AISB master chat session in tmux.
+def _session_age(unix_ts: int) -> str:
+    """Pretty-print 'now' / '5m ago' / '2h ago' / '3d ago'."""
+    import time as _t
+    delta = max(0, int(_t.time()) - int(unix_ts))
+    if delta < 60:
+        return "now"
+    if delta < 3600:
+        return f"{delta // 60}m ago"
+    if delta < 86400:
+        return f"{delta // 3600}h ago"
+    return f"{delta // 86400}d ago"
+
 
-    v0.19.15 changed the default: typing `omega` used to open the whiptail
-    menu, which Gareth correctly called bad UX ("type `omega`, talk to my
-    master agent"). Now bare `omega` attaches to the always-on `AISB-chat`
-    tmux session, spawning it on demand. The whiptail menu lives at
-    `omega menu`.
+def cmd_menu(_args: argparse.Namespace) -> int:
+    """`omega` (no args) — open the OmegaOS session manager.
+
+    v0.19.19 redesign per the user's spec: bare `omega` no longer
+    auto-attaches to AISB-chat. Instead it shows a fzf-driven menu:
+
+      ┌─ Omega — Session Manager ──────────────────┐
+      │ > AISB-chat               now              │
+      │   Hermes-chat             5m ago           │
+      │   Causio-oracle           2h ago           │
+      │ ─────────────────────────────────────────  │
+      │ + New Claude Code session (AISB master)    │
+      │ + New Hermès session                       │
+      └────────────────────────────────────────────┘
+
+    Pick a session → attach. Pick "+ New …" → spawn + attach. Esc / q
+    → exit cleanly.
+
+    Direct shortcuts kept:
+      * `omega aisb`   → straight to AISB-chat (no menu)
+      * `omega hermes` → straight to Hermes-chat (no menu)
+      * `omega menu`   → legacy whiptail picker (advanced ops)
     """
+    import os
+    import shutil
+    import subprocess
     from omega_engine import tmux
-    return _attach_or_spawn_chat(
-        "AISB-chat",
-        spawn_fn=tmux.spawn_aisb_chat,
-        label="AISB master chat",
-    )
+
+    # If we're already inside a tmux session, instruct the user — we can't
+    # take over the current pane from a subprocess, but `omega aisb` /
+    # `omega hermes` from inside tmux still print switch-client instructions.
+    if os.environ.get("TMUX"):
+        print("  You're already inside tmux. Use Ctrl+b z (tmux-claude")
+        print("  session manager) or one of:")
+        print("    tmux switch-client -t AISB-chat")
+        print("    tmux switch-client -t Hermes-chat")
+        return 0
+
+    if not shutil.which("tmux"):
+        print("  tmux not installed — `brew install tmux` (macOS) or "
+              "`apt-get install tmux` (Linux)")
+        return 2
+
+    sessions = tmux.list_sessions(_omega_home())
+    sessions.sort(key=lambda s: -int(s.created))
+
+    NEW_AISB   = "__new_aisb__"
+    NEW_HERMES = "__new_hermes__"
+
+    lines: list[tuple[str, str]] = []  # (display, action_key)
+    if sessions:
+        for s in sessions:
+            attach_mark = " *" if s.attached else "  "
+            line = f"{attach_mark} {s.name:<32} {_session_age(s.created):<10} {s.category}"
+            lines.append((line, s.name))
+        lines.append(("──────────────────────────────────────────────",
+                      "__separator__"))
+    lines.append(("   + New Claude Code session (AISB master)", NEW_AISB))
+    lines.append(("   + New Hermès session", NEW_HERMES))
+
+    chosen_key: str | None = None
+    if shutil.which("fzf"):
+        # fzf path — prettiest UX. Header shows the title, separator line
+        # is non-selectable (we filter it after).
+        fzf_input = "\n".join(disp for disp, _ in lines)
+        try:
+            proc = subprocess.run(
+                ["fzf",
+                 "--prompt=omega › ",
+                 "--header=Omega Session Manager — Enter to attach, Esc to quit",
+                 "--layout=reverse",
+                 "--height=70%",
+                 "--border",
+                 "--no-multi"],
+                input=fzf_input, capture_output=True, text=True,
+            )
+            if proc.returncode == 0:
+                pick = proc.stdout.strip()
+                for disp, key in lines:
+                    if disp == pick and key != "__separator__":
+                        chosen_key = key
+                        break
+        except Exception as exc:  # noqa: BLE001
+            print(f"  fzf failed: {exc}")
+            return 2
+    else:
+        # Plain stdin fallback — numbered list.
+        print()
+        print("  Omega Session Manager")
+        for i, (disp, _) in enumerate(lines, 1):
+            print(f"  {i:2})  {disp}")
+        print()
+        try:
+            raw = input("  pick a number (Enter to quit): ").strip()
+        except (EOFError, KeyboardInterrupt):
+            return 0
+        if not raw:
+            return 0
+        try:
+            n = int(raw)
+        except ValueError:
+            print(f"  not a number: {raw!r}")
+            return 0
+        if 1 <= n <= len(lines):
+            chosen_key = lines[n - 1][1]
+            if chosen_key == "__separator__":
+                chosen_key = None
+
+    if chosen_key is None:
+        return 0
+    if chosen_key == NEW_AISB:
+        # "+ New AISB" means the user wants a FRESH session — kill
+        # the existing AISB-chat first so we don't attach to a dead
+        # one (claude died, OAuth missing, etc.).
+        return _attach_or_spawn_chat(
+            "AISB-chat",
+            spawn_fn=lambda h: tmux.spawn_aisb_chat(h, force_replace=True),
+            label="AISB master (Claude Code on Max OAuth)",
+        )
+    if chosen_key == NEW_HERMES:
+        return _attach_or_spawn_chat(
+            "Hermes-chat",
+            spawn_fn=lambda h: tmux.spawn_hermes_chat(h, force_replace=True),
+            label="Hermès (Claude Code on Anthropic API)",
+        )
+    # Otherwise it's an existing session name — just attach.
+    print(f"  attaching to {chosen_key}…")
+    try:
+        os.execvp("tmux", ["tmux", "attach", "-t", chosen_key])
+    except FileNotFoundError:
+        print("  tmux not on PATH")
+        return 2
+    return 0
 
 
 def cmd_menu_whiptail(_args: argparse.Namespace) -> int:

package/omega/Agentik_Engine/omega_engine/tmux.py

@@ -259,49 +259,85 @@ def _ensure_chat_context_dir(home: Path, label: str,
     return ctx_dir
 
 
-def spawn_aisb_chat(omega_home: str | Path | None = None) -> str:
+def _spawn_with_shell_then_run(
+    name: str,
+    *,
+    cwd: str | Path,
+    run_command: str,
+    force_replace: bool = False,
+) -> str:
+    """Spawn a tmux session that starts the user's interactive shell at
+    ``cwd``, then types ``run_command`` + Enter into it. This way:
+
+      * The shell stays alive even if ``run_command`` exits (claude
+        with no auth, claude exited cleanly, etc.) — user still sees
+        the shell and can debug.
+      * The shell sources the user's rc files normally (PATH, env, etc.)
+        so ``claude`` resolves to the operator's binary.
+
+    Used by spawn_aisb_chat / spawn_hermes_chat. ``force_replace=True``
+    kills any existing session of the same name first — the menu's
+    "+ New" actions pass this so the user always gets a fresh session
+    instead of attaching to a dead one.
+    """
+    if force_replace and is_alive(name):
+        kill(name)
+    if is_alive(name):
+        return name
+    # 1. Create a detached session running the user's login shell at cwd.
+    rc, _ = _tmux("new-session", "-d", "-s", name, "-c", str(cwd))
+    if rc != 0:
+        return name
+    # 2. Send the launch command + Enter into the shell. We use
+    # `send-keys` (not the new-session command arg) so the shell stays
+    # alive even if the launched binary exits.
+    _tmux("send-keys", "-t", name, run_command, "Enter")
+    return name
+
+
+def spawn_aisb_chat(omega_home: str | Path | None = None,
+                     force_replace: bool = False) -> str:
     """Spawn the AISB master chat tmux session — REAL Claude Code TUI.
 
-    v0.19.18 — instead of running our Python REPL (`omega aisb chat-loop`),
-    we now run the canonical `claude` CLI inside a dedicated project dir
-    seeded with the AISB master persona (``Agentik_SSOT/agents/aisb/CLAUDE.md``).
-    User sees the SAME interactive Claude Code TUI they get with bare
-    `claude`, but pre-loaded with AISB's identity, the L3 orchestrator
-    role, and full OmegaOS context.
+    v0.19.20 — moved from ``exec claude`` (which kills the session when
+    claude exits) to ``spawn shell + send-keys claude``. The shell stays
+    alive even if claude can't start (no Max OAuth wired, etc.), so the
+    user lands inside the session and sees the actual failure instead of
+    "ça fait rien du tout" silent attach-to-dead.
 
     Auth: Claude Max OAuth (inherited from the user's shell env, no env
     override needed — `claude` reads `~/.claude/.credentials.json`).
 
-    cwd=$HOME is the legacy crash fix (spawn() default would inherit
-    the npm/_npx cache dir which can disappear); the `claude` process
-    itself runs with cwd = the context dir we just created.
+    ``force_replace=True`` kills any existing AISB-chat first — used by
+    the `omega` session manager's "+ New" action so the user gets a
+    fresh session each time.
     """
     name = "AISB-chat"
     home = Path(omega_home or os.environ.get("OMEGA_HOME")
                 or Path.home() / "Omega")
     persona = home / "Agentik_SSOT" / "agents" / "aisb" / "CLAUDE.md"
     ctx_dir = _ensure_chat_context_dir(home, "aisb-master", persona)
-    spawn(name, command=f"cd {ctx_dir} && exec claude",
-          cwd=str(Path.home()))
-    return name
+    return _spawn_with_shell_then_run(
+        name, cwd=ctx_dir, run_command="claude",
+        force_replace=force_replace,
+    )
 
 
-def spawn_hermes_chat(omega_home: str | Path | None = None) -> str:
+def spawn_hermes_chat(omega_home: str | Path | None = None,
+                       force_replace: bool = False) -> str:
     """Spawn the Hermès chat tmux session — REAL Claude Code TUI, but on
     Anthropic API (Hermès's own paid key, budget-isolated from Max OAuth).
 
     Mirrors ``spawn_aisb_chat`` for the L2 companion: drops a Hermès
-    persona ``CLAUDE.md`` into a dedicated context dir, then runs
-    `claude` there with ``ANTHROPIC_API_KEY`` exported from the vault.
-    Setting the env var makes Claude Code use the API key instead of
-    the Max OAuth — same TUI, different billing surface.
+    persona ``CLAUDE.md`` into a dedicated context dir, exports
+    ``ANTHROPIC_API_KEY`` (from vault) before launching `claude`. Same
+    shell-stays-alive pattern.
     """
     name = "Hermes-chat"
     home = Path(omega_home or os.environ.get("OMEGA_HOME")
                 or Path.home() / "Omega")
-    persona = home / "Agentik_SSOT" / "docs" / "LAYERS.md"   # Hermès reads architecture as persona
+    persona = home / "Agentik_SSOT" / "docs" / "LAYERS.md"
     ctx_dir = _ensure_chat_context_dir(home, "hermes", persona)
-    # Resolve Anthropic key from vault → fallback to existing env.
     try:
         from omega_engine.vault import vault_read
         api_key = (vault_read(home, "ANTHROPIC_API_KEY_HERMES") or "").strip()
@@ -309,9 +345,6 @@ def spawn_hermes_chat(omega_home: str | Path | None = None) -> str:
         api_key = ""
     if not api_key:
         api_key = (os.environ.get("ANTHROPIC_API_KEY") or "").strip()
-    # If no key, fall back to Max OAuth (Hermès will share AISB's
-    # billing — not ideal but better than failing). Surface a marker
-    # file in the context dir so the user sees the warning on first launch.
     if not api_key:
         (ctx_dir / "NO_ANTHROPIC_KEY.md").write_text(
             "# Hermès — no Anthropic API key wired\n\n"
@@ -319,12 +352,14 @@ def spawn_hermes_chat(omega_home: str | Path | None = None) -> str:
             "own paid Anthropic budget instead of the AISB Max OAuth.\n\n"
             "    omega vault write ANTHROPIC_API_KEY_HERMES sk-ant-...\n"
         )
-        cmd = f"cd {ctx_dir} && exec claude"
+        run_cmd = "claude"
     else:
-        cmd = (f"cd {ctx_dir} && "
-               f"ANTHROPIC_API_KEY={api_key} exec claude")
-    spawn(name, command=cmd, cwd=str(Path.home()))
-    return name
+        # Single-line shell statement; send-keys passes it as-is.
+        run_cmd = f"ANTHROPIC_API_KEY={api_key} claude"
+    return _spawn_with_shell_then_run(
+        name, cwd=ctx_dir, run_command=run_cmd,
+        force_replace=force_replace,
+    )
 
 
 # ---------------------------------------------------------------------------

package/omega/Agentik_Engine/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "omega-engine"
-version = "0.19.18"
+version = "0.19.20"
 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.18
+0.19.20

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

@@ -4,44 +4,53 @@
 # (interactive) or apply the manifest's `claude_plugins:` list (headless). For
 # each selected plugin, the installer:
 #
-#   1. ensures the marketplace is registered: `claude plugin marketplace add <source>`
+#   1. ensures the marketplace is registered: `claude plugin marketplace add <owner>/<repo>`
 #      (skipped if `source: builtin` — already present after a fresh install)
-#   2. installs it:                          `claude plugin install <name>@<marketplace> -s <scope>`
+#   2. installs it:                          `claude plugin install <name>@<marketplace>`
 #
 # Maintained by the claudecode-educator (Agentik_Orchestration/educators/).
 # Secrets are referenced by name only — never stored here.
 #
 # Marketplaces are listed once; plugins reference them by `marketplace:` id.
+#
+# IMPORTANT — marketplace id != github source.
+# When `claude plugin marketplace add anthropics/skills` runs, the
+# Claude CLI derives an id from the marketplace.json `name` field in the
+# repo, which can be different from the repo name. We tracked these by
+# hand (verified on the VPS as of 2026-05-25).
+#
+# Source format: `<owner>/<repo>` — NO `github:` prefix (the prefix
+# previously bundled here caused `marketplace add` to fail with
+# "Invalid marketplace source format").
 
 version: 1
 
 marketplaces:
   - id: claude-plugins-official
-    source: "github:anthropics/claude-plugins-official"
+    source: "anthropics/claude-plugins-official"
     description: "Anthropic's official plugin marketplace"
-    builtin: true
-  - id: anthropic-skills
-    source: "github:anthropics/skills"
-    description: "Anthropic's official skill collection (find-skills, document skills, etc.)"
-    builtin: false
-    trust: high
-  - id: vercel-labs-skills
-    source: "github:vercel-labs/skills"
-    description: "Vercel Labs skills (skill discovery CLI + find-skills)"
+    builtin: true                       # auto-registered by claude CLI
+  - id: anthropic-agent-skills
+    source: "anthropics/skills"
+    description: "Anthropic's official Agent Skills repo (document-skills, claude-api, example-skills)"
     builtin: false
     trust: high
-  - id: davila7-templates
-    source: "github:davila7/claude-code-templates"
-    description: "Community-maintained Claude Code templates and skills"
-    builtin: false
-    trust: medium
   - id: thedotmack
-    source: "github:thedotmack/claude-mem"
+    source: "thedotmack/claude-mem"
     description: "claude-mem memory + observation system"
     builtin: false
     trust: medium
+  - id: daymade-skills
+    source: "daymade/claude-code-skills"
+    description: "Community skill creator marketplace (daymade) — includes skill-creator-style tooling"
+    builtin: false
+    trust: medium
 
 catalog:
+  # All entries below were verified to exist + install cleanly on a real
+  # Claude Code 2.1.150+ install before being committed here. See the
+  # commit message of v0.19.20 for the audit trail.
+
   - id: claude-mem
     name: claude-mem
     description: "Long-term memory + observation system across sessions"
@@ -75,26 +84,50 @@ catalog:
     secrets: [STRIPE_SECRET_KEY]
     recommended: false
 
-  - id: skill-creator
-    name: skill-creator
-    description: "Generate new SKILL.md files with Claude's help (Anthropic official)"
-    category: meta
-    marketplace: anthropic-skills
-    scope: user
-    recommended: true
-
-  - id: find-skills
-    name: find-skills
-    description: "Discover skills across marketplaces (vercel-labs); pairs with skill-auditor"
-    category: meta
-    marketplace: vercel-labs-skills
-    scope: user
-    recommended: true
-
   - id: document-skills
     name: document-skills
     description: "Anthropic official suite — docx, pdf, pptx, xlsx (creation + editing)"
     category: documents
-    marketplace: anthropic-skills
+    marketplace: anthropic-agent-skills
     scope: user
     recommended: true
+
+  - id: pr-review-toolkit
+    name: pr-review-toolkit
+    description: "Pull request review tooling — analyse diffs, suggest fixes"
+    category: dev
+    marketplace: claude-plugins-official
+    scope: user
+    recommended: false
+
+  - id: code-review
+    name: code-review
+    description: "Static code review with style + quality heuristics"
+    category: dev
+    marketplace: claude-plugins-official
+    scope: user
+    recommended: false
+
+  - id: feature-dev
+    name: feature-dev
+    description: "Feature development workflow — spec → impl → review"
+    category: dev
+    marketplace: claude-plugins-official
+    scope: user
+    recommended: false
+
+  - id: mcp-server-dev
+    name: mcp-server-dev
+    description: "Scaffold + iterate on new MCP servers"
+    category: dev
+    marketplace: claude-plugins-official
+    scope: user
+    recommended: false
+
+  - id: plugin-dev
+    name: plugin-dev
+    description: "Build + test new Claude Code plugins"
+    category: meta
+    marketplace: claude-plugins-official
+    scope: user
+    recommended: false

package/package.json

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