@agentikos/omega-os 0.19.17 → 0.19.19

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

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.17"
+__version__ = "0.19.19"
 
 __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,149 @@ 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:
+        return _attach_or_spawn_chat(
+            "AISB-chat",
+            spawn_fn=tmux.spawn_aisb_chat,
+            label="AISB master (Claude Code on Max OAuth)",
+        )
+    if chosen_key == NEW_HERMES:
+        return _attach_or_spawn_chat(
+            "Hermes-chat",
+            spawn_fn=tmux.spawn_hermes_chat,
+            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

@@ -231,42 +231,99 @@ def spawn_worker(project: str, task: str, *,
     return name
 
 
+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.
+    """
+    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.
+    gi = ctx_dir / ".gitignore"
+    if not gi.exists():
+        gi.write_text("*\n!.gitignore\n!CLAUDE.md\n")
+    return ctx_dir
+
+
 def spawn_aisb_chat(omega_home: str | Path | None = None) -> str:
-    """Spawn the AISB master chat tmux session.
+    """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.
 
-    Runs ``omega aisb chat-loop`` inside — REPL conversation with the
-    AISB master agent on Claude Max OAuth. This is what bare `omega`
-    attaches to (v0.19.15+).
+    Auth: Claude Max OAuth (inherited from the user's shell env, no env
+    override needed — `claude` reads `~/.claude/.credentials.json`).
 
-    v0.19.17 — explicitly cwd=$HOME. Without this the session inherited
-    the parent process's cwd, which could be the npm/_npx cache dir; if
-    that dir got cleaned (or `rm -rf ~/Omega` happened later), every
-    subprocess (including `claude -p`) crashed with
-    "The current working directory was deleted".
+    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.
     """
     name = "AISB-chat"
     home = Path(omega_home or os.environ.get("OMEGA_HOME")
                 or Path.home() / "Omega")
-    omega_bin = home / "Agentik_Tools" / "bin" / "omega"
-    spawn(name, command=f"{omega_bin} aisb chat-loop",
+    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
 
 
 def spawn_hermes_chat(omega_home: str | Path | None = None) -> str:
-    """Spawn the Hermès meta-companion chat tmux session.
-
-    Runs ``omega hermes chat-loop`` — REPL conversation with Hermès on
-    Anthropic API (separate budget from AISB's Max OAuth). This is what
-    `omega hermes` attaches to (v0.19.15+). Spawned with cwd=$HOME for
-    the same reason as ``spawn_aisb_chat`` (avoid deleted-cwd crash).
+    """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.
     """
     name = "Hermes-chat"
     home = Path(omega_home or os.environ.get("OMEGA_HOME")
                 or Path.home() / "Omega")
-    omega_bin = home / "Agentik_Tools" / "bin" / "omega"
-    spawn(name, command=f"{omega_bin} hermes chat-loop",
-          cwd=str(Path.home()))
+    persona = home / "Agentik_SSOT" / "docs" / "LAYERS.md"   # Hermès reads architecture as persona
+    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()
+    except Exception:  # noqa: BLE001
+        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"
+            "Set `ANTHROPIC_API_KEY_HERMES` in the vault to use Hermès's\n"
+            "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"
+    else:
+        cmd = (f"cd {ctx_dir} && "
+               f"ANTHROPIC_API_KEY={api_key} exec claude")
+    spawn(name, command=cmd, cwd=str(Path.home()))
     return name
 
 

package/omega/Agentik_Engine/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "omega-engine"
-version = "0.19.17"
+version = "0.19.19"
 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.17
+0.19.19

package/package.json

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