agentram 0.1.21 → 0.1.29

package/README.md

@@ -1,4 +1,4 @@
-# AgentRAM
+# AgentRAM
 
 Async, model-agnostic Working RAM for coding agents such as Codex, Claude Code, Cursor, and custom MCP clients.
 
@@ -358,20 +358,20 @@ Minimum usage pattern:
 
 AgentRAM can bind multiple coding model endpoints and let Claude Code or MCP clients orchestrate them in parallel. This keeps the `free-code` style command registry, but adds project RAM, Goal Stack, and multi-agent model routing.
 
-Bind models:
-
-```bash
-agentram bind-model claude-subagent agentram-reviewer --role reviewer
-agentram bind-model claude claude-3-5-sonnet-latest --role reviewer --api-key-env ANTHROPIC_API_KEY
-agentram bind-model openai-compatible qwen2.5-coder --role coder --base-url http://localhost:8000/v1 --api-key-env OPENAI_API_KEY
-```
-
-Claude Code subagent endpoint uses your local Claude CLI entrypoint. `model` is the subagent name from `.claude/agents`, for example `agentram-reviewer` or `agentram-planner`. Default command is `claude -p`. Override command when needed:
-
-```bash
-set AGENTRAM_CLAUDE_COMMAND=claude
-agentram bind-model claude-subagent agentram-reviewer --role reviewer
-```
+Bind models:
+
+```bash
+agentram bind-model claude-subagent agentram-reviewer --role reviewer
+agentram bind-model claude claude-3-5-sonnet-latest --role reviewer --api-key-env ANTHROPIC_API_KEY
+agentram bind-model openai-compatible qwen2.5-coder --role coder --base-url http://localhost:8000/v1 --api-key-env OPENAI_API_KEY
+```
+
+Claude Code subagent endpoint uses your local Claude CLI entrypoint. `model` is the subagent name from `.claude/agents`, for example `agentram-reviewer` or `agentram-planner`. Default command is `claude -p`. Override command when needed:
+
+```bash
+set AGENTRAM_CLAUDE_COMMAND=claude
+agentram bind-model claude-subagent agentram-reviewer --role reviewer
+```
 
 Build a dry-run orchestration plan:
 
@@ -396,12 +396,12 @@ agentram_run_coding_orchestration
 
 TUI slash commands. Plain text only records/retrieves RAM; use `/ask` to call bound models:
 
-```text
-/bind-model claude-subagent agentram-reviewer role=reviewer
-/bind-model claude claude-3-5-sonnet-latest role=reviewer api_key_env=ANTHROPIC_API_KEY
-/models
-/orchestrate review CLI orchestration
-/ask xin chào
+```text
+/bind-model claude-subagent agentram-reviewer role=reviewer
+/bind-model claude claude-3-5-sonnet-latest role=reviewer api_key_env=ANTHROPIC_API_KEY
+/models
+/orchestrate review CLI orchestration
+/ask xin chào
 ```
 
 Storage:
@@ -876,7 +876,7 @@ Inside TUI:
 
 ```text
 /bind-model openai-compatible Agentic --role coder --base-url http://localhost:8000/v1 --api-key-env OPENAI_API_KEY
-/ask xin chào
+/ask xin chào
 ```
 
 Do not paste raw API keys into `/bind-model`. `api_key_env` means environment variable name, e.g. `OPENAI_API_KEY`.
@@ -908,133 +908,146 @@ If `/ask` shows connection refused, the configured OpenAI-compatible server is n
 
 ```text
 /bind-model openai-compatible Agentic --role coder --base-url http://localhost:8000/v1 --api-key-env OPENAI_API_KEY
-/ask xin chào
+/ask xin chào
 ```
 
 Start your local server first, or change `--base-url` to the provider URL.
-
-## Prompt Router Model
-
-AgentRAM can use a separate small router model before normal prompts. The router classifies each prompt, then sends it to the right path.
-
-```text
-coding   -> bound coding endpoints / Claude subagents
-planning -> Goal Stack and drift check
-memory   -> AgentRAM note ingest
-chat     -> RAM retrieve only
-```
-
-Bind a router model:
-
-```text
-/bind-router openai-compatible qwen2.5:1.5b base_url=http://localhost:8000/v1 api_key_env=OPENAI_API_KEY
-/route on
-```
-
-Then prompt without slash:
-
-```text
-fix adapter.py
-c?p nh?t goal stack
-ghi nh? d�ng Claude subagent
-```
-
-Disable auto routing:
-
-```text
-/route off
-```
-
-## Supervisor + Small Agent Workflow
-
-AgentRAM can run as a two-flow coding agent system, not only as a flat multi-model router.
-
-```text
-agentram
-  |
-  v
-Parse User Request
-  |
-  v
-Supervisor Memory
-  |
-  v
-Task Classifier / Supervisor Plan
-  |----------------------|
-  v                      v
-Main Agent               Small Agent
-(GPT-5.5 Codex)          (Qwen Codex)
-planning/coding/fix      notes/RAM/coding facts
-  |                      |
-  |----------|-----------|
-             v
-Merge + Update Memory
-             |
-             v
-Return Result
-```
-
-Bind workflow agents:
-
-```text
-/bind-agent supervisor claude-subagent agentram-planner
-/bind-agent main openai-compatible gpt-5.5-codex base_url=https://api.example.com/v1 api_key_env=MAIN_AGENT_KEY
-/bind-agent small openai-compatible qwen-codex base_url=http://localhost:8001/v1 api_key_env=SMALL_AGENT_KEY
-/workflow
-```
-
-Then use normal prompts without slash:
-
-```text
-refactor orchestration workflow
-fix bug in adapter.py
-plan next milestone
-```
-
-Runtime behavior:
-
-```text
-Supervisor creates plan -> Main agent executes -> Small agent records RAM notes -> AgentRAM merges result
-```
-
+
+## Prompt Router Model
+
+AgentRAM can use a separate small router model before normal prompts. The router classifies each prompt, then sends it to the right path.
+
+```text
+coding   -> bound coding endpoints / Claude subagents
+planning -> Goal Stack and drift check
+memory   -> AgentRAM note ingest
+chat     -> RAM retrieve only
+```
+
+Bind a router model:
+
+```text
+/bind-router openai-compatible qwen2.5:1.5b base_url=http://localhost:8000/v1 api_key_env=OPENAI_API_KEY
+/route on
+```
+
+Then prompt without slash:
+
+```text
+fix adapter.py
+cap nhat goal stack
+ghi nho dung Claude subagent
+```
+
+Disable auto routing:
+
+```text
+/route off
+```
+
+## Supervisor + Small Agent Workflow
+
+AgentRAM can run as a two-flow coding agent system, not only as a flat multi-model router.
+
+```text
+agentram
+  |
+  v
+Parse User Request
+  |
+  v
+Supervisor Memory
+  |
+  v
+Task Classifier / Supervisor Plan
+  |----------------------|
+  v                      v
+Main Agent
+(Codex CLI / Claude Code / OpenAI-compatible)
+planning/coding/fix, may edit files when bound to CLI provider
+  |
+  v
+Small Agent
+(Qwen/OpenAI-compatible/Anthropic)
+notes/RAM/coding facts only
+  |
+  v
+Merge + Update Memory
+  |
+  v
+Return Result
+```
+
+Bind workflow agents:
+
+```text
+/bind-agent supervisor openai-compatible supervisor-model base_url=https://api.example.com/v1 api_key_env=SUPERVISOR_AGENT_KEY
+/bind-agent main codex-cli current base_url="codex exec"
+/bind-agent small openai-compatible qwen-codex base_url=http://localhost:8001/v1 api_key_env=SMALL_AGENT_KEY
+/workflow
+```
+
+Then use normal prompts without slash:
+
+```text
+refactor orchestration workflow
+fix bug in adapter.py
+plan next milestone
+```
+
+Runtime behavior:
+
+```text
+Supervisor creates plan -> Main CLI coding agent edits/returns result -> Small agent reads plan + main result and records RAM notes -> AgentRAM merges result
+```
+
 Small agent should not own big direction. It records plans, decisions, files, risks, next tasks, and coding facts into RAM.
-
-## Textual TUI
-
-Install rich terminal UI with native scrollable chat pane:
-
-```bash
-pip install agentram[tui]
-agentram tui
-```
-
+
+CLI coding providers for file edits:
+
+```text
+/bind-agent main codex-cli current base_url="codex exec"
+/bind-agent main claude-code claude base_url="claude"
+```
+
+Use `codex-cli` or `claude-code` only for the main agent when you want a coding agent subprocess that can inspect and edit files. Keep the small agent on an LLM-only provider so it records notes but does not edit code.
+
+## Textual TUI
+
+Install rich terminal UI with native scrollable chat pane:
+
+```bash
+pip install agentram[tui]
+agentram tui
+```
+
 When `textual` is installed, AgentRAM uses a real full-screen TUI with mouse wheel scrolling inside the chat frame. If `textual` is missing, it falls back to the basic print-based terminal UI.
-
-## npm Python Dependencies
-
-When installed through npm, AgentRAM runs a `postinstall` step that tries to install Python TUI dependencies for the Python interpreter used by `agentram`:
-
-```text
-textual>=0.80
-prompt_toolkit>=3.0
-```
-
-Set target Python before install when needed:
-
-```powershell
-$env:PYTHON="C:\Users\admin\anaconda3\python.exe"
-npm install -g agentram@latest
-```
-
-Skip automatic Python dependency install:
-
-```powershell
-$env:AGENTRAM_SKIP_PY_DEPS="1"
-npm install -g agentram@latest
-```
-
-If auto install fails, install manually:
-
-```powershell
-python -m pip install textual prompt_toolkit
+
+## npm Python Dependencies
+
+When installed through npm, AgentRAM runs a `postinstall` step that tries to install Python TUI dependencies for the Python interpreter used by `agentram`:
+
+```text
+textual>=0.80
+prompt_toolkit>=3.0
+```
+
+Set target Python before install when needed:
+
+```powershell
+$env:PYTHON="C:\Users\admin\anaconda3\python.exe"
+npm install -g agentram@latest
+```
+
+Skip automatic Python dependency install:
+
+```powershell
+$env:AGENTRAM_SKIP_PY_DEPS="1"
+npm install -g agentram@latest
+```
+
+If auto install fails, install manually:
+
+```powershell
+python -m pip install textual prompt_toolkit
 ```

package/agentram/cli.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations
 
 import argparse
 import asyncio
@@ -101,6 +101,135 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
 ]
 
 
+
+CLAUDE_COMPAT_COMMANDS: list[tuple[str, str]] = [
+    ("/add-dir <path>", "Claude: add a working directory for file access"),
+    ("/advisor [model|off]", "Claude: enable or disable advisor model"),
+    ("/autofix-pr [prompt]", "Claude: cloud session fixes PR CI/review comments"),
+    ("/background [prompt]", "Claude: detach session as background agent"),
+    ("/bg [prompt]", "Claude alias: /background"),
+    ("/batch <instruction>", "Claude workflow: parallel codebase change"),
+    ("/branch [name]", "Claude: fork conversation branch"),
+    ("/btw <question>", "Claude: side question without history"),
+    ("/cd <path>", "Claude: move session to another directory"),
+    ("/chrome", "Claude: configure Claude in Chrome"),
+    ("/claude-api [migrate|managed-agents-onboard]", "Claude skill: API reference and migration"),
+    ("/reset [name]", "Claude alias: /clear"),
+    ("/new [name]", "Claude alias: /clear"),
+    ("/code-review [level] [--fix] [--comment] [target]", "Claude skill: review current diff"),
+    ("/color [color|default]", "Claude: prompt bar color"),
+    ("/compact [instructions]", "Claude: summarize context to free space"),
+    ("/config [key=value ...]", "Claude: settings interface"),
+    ("/settings [key=value ...]", "Claude alias: /config"),
+    ("/context [all]", "Claude: visualize context usage"),
+    ("/copy [N]", "Claude: copy assistant response"),
+    ("/cost", "Claude alias: /usage"),
+    ("/dataviz [request]", "Claude skill: chart/dashboard design guidance"),
+    ("/debug [description]", "Claude skill: enable and inspect debug logs"),
+    ("/deep-research <question>", "Claude workflow: web research report"),
+    ("/design-login", "Claude: authorize design-system access"),
+    ("/design-sync [hint]", "Claude skill: sync React design system"),
+    ("/desktop", "Claude: continue in desktop app"),
+    ("/app", "Claude alias: /desktop"),
+    ("/diff", "Claude: interactive diff viewer"),
+    ("/doctor", "Claude: diagnose install/runtime"),
+    ("/effort [level|auto]", "Claude: set reasoning effort"),
+    ("/export [filename]", "Claude: export conversation"),
+    ("/fast [on|off]", "Claude: toggle fast mode"),
+    ("/feedback [report]", "Claude: send feedback"),
+    ("/bug [report]", "Claude alias: /feedback"),
+    ("/share [report]", "Claude alias: /feedback"),
+    ("/fewer-permission-prompts", "Claude skill: reduce permission prompts"),
+    ("/focus", "Claude: toggle focus view"),
+    ("/fork <directive>", "Claude: forked background subagent"),
+    ("/heapdump", "Claude: write heap snapshot"),
+    ("/hooks", "Claude: view hook config"),
+    ("/ide", "Claude: manage IDE integration"),
+    ("/insights", "Claude: analyze Claude Code sessions"),
+    ("/install-github-app", "Claude: install GitHub app"),
+    ("/install-slack-app", "Claude: install Slack app"),
+    ("/keybindings", "Claude: open keyboard shortcut file"),
+    ("/login", "Claude: sign in"),
+    ("/logout", "Claude: sign out"),
+    ("/loop [interval] [prompt]", "Claude skill: repeated prompt loop"),
+    ("/proactive [interval] [prompt]", "Claude alias: /loop"),
+    ("/mcp [reconnect|enable|disable]", "Claude: manage MCP servers"),
+    ("/memory", "Claude: edit CLAUDE.md memory"),
+    ("/mobile", "Claude: show mobile app QR"),
+    ("/ios", "Claude alias: /mobile"),
+    ("/android", "Claude alias: /mobile"),
+    ("/model [model]", "Claude: switch model"),
+    ("/passes", "Claude: share Claude Code pass"),
+    ("/permissions", "Claude: manage tool permissions"),
+    ("/allowed-tools", "Claude alias: /permissions"),
+    ("/plan [description]", "Claude: enter plan mode"),
+    ("/plugin [subcommand]", "Claude: manage plugins"),
+    ("/powerup", "Claude: feature lessons"),
+    ("/pr-comments [PR]", "Claude legacy: PR comments"),
+    ("/privacy-settings", "Claude: privacy settings"),
+    ("/radio", "Claude: Claude FM radio"),
+    ("/recap", "Claude: one-line session summary"),
+    ("/release-notes", "Claude: changelog picker"),
+    ("/reload-plugins [--force]", "Claude: reload plugins"),
+    ("/reload-skills", "Claude: reload skills and commands"),
+    ("/remote-control", "Claude: remote control from claude.ai"),
+    ("/rc", "Claude alias: /remote-control"),
+    ("/remote-env", "Claude: cloud agent environment"),
+    ("/rename [name]", "Claude: rename session"),
+    ("/resume [session]", "Claude: resume conversation"),
+    ("/continue [session]", "Claude alias: /resume"),
+    ("/review [PR]", "Claude: review GitHub PR"),
+    ("/rewind", "Claude: rewind conversation/code"),
+    ("/checkpoint", "Claude alias: /rewind"),
+    ("/undo", "Claude alias: /rewind"),
+    ("/run", "Claude skill: run app and verify change"),
+    ("/run-skill-generator", "Claude skill: generate run/verify skill"),
+    ("/sandbox", "Claude: toggle sandbox mode"),
+    ("/schedule [description]", "Claude: cloud routine"),
+    ("/routines [description]", "Claude alias: /schedule"),
+    ("/scroll-speed", "Claude: adjust mouse wheel speed"),
+    ("/security-review", "Claude: security review current diff"),
+    ("/setup-bedrock", "Claude: Bedrock setup wizard"),
+    ("/setup-vertex", "Claude: Vertex setup wizard"),
+    ("/simplify [target]", "Claude skill: cleanup review and fixes"),
+    ("/skills", "Claude: list skills"),
+    ("/stats", "Claude alias: /usage"),
+    ("/statusline", "Claude: configure status line"),
+    ("/stickers", "Claude: order stickers"),
+    ("/stop", "Claude: stop background session"),
+    ("/tasks", "Claude: view background work"),
+    ("/bashes", "Claude alias: /tasks"),
+    ("/team-onboarding", "Claude: generate team onboarding"),
+    ("/teleport", "Claude: pull web session into terminal"),
+    ("/tp", "Claude alias: /teleport"),
+    ("/terminal-setup", "Claude: terminal keybindings setup"),
+    ("/theme", "Claude: change color theme"),
+    ("/tui [default|fullscreen]", "Claude: switch renderer"),
+    ("/ultraplan <prompt>", "Claude: draft cloud plan"),
+    ("/ultrareview [PR]", "Claude: deep cloud review"),
+    ("/upgrade", "Claude: open upgrade page"),
+    ("/usage", "Claude: show usage and cost"),
+    ("/usage-credits", "Claude: configure usage credits"),
+    ("/verify", "Claude skill: verify app behavior"),
+    ("/vim", "Claude legacy: use /config for editor mode"),
+    ("/voice [hold|tap|off]", "Claude: voice dictation"),
+    ("/web-setup", "Claude: connect GitHub for web"),
+    ("/workflows", "Claude: workflow progress view"),
+]
+
+CLAUDE_COMPAT_NAMES = {command.split()[0] for command, _ in CLAUDE_COMPAT_COMMANDS}
+
+def slash_entries() -> list[tuple[str, str]]:
+    seen: set[str] = set()
+    entries: list[tuple[str, str]] = []
+    for command, description in [*SLASH_COMMANDS, *CLAUDE_COMPAT_COMMANDS]:
+        name = command.split()[0]
+        if name in seen:
+            continue
+        seen.add(name)
+        entries.append((command, description))
+    return entries
+
 SLASH_HELP = """Slash commands:
 /help                         Show commands
 /init                         Create .agentram files
@@ -353,6 +482,8 @@ def run_textual_tui(context: McpContext) -> bool:
             self.prompt_history: list[str] = []
             self.history_index: int | None = None
             self.last_ctrl_c_at = 0.0
+            self.setup_slots = ("supervisor", "main", "small")
+            self.setup_index = 0
 
         def compose(self) -> ComposeResult:
             yield Header(show_clock=True)
@@ -360,18 +491,20 @@ def run_textual_tui(context: McpContext) -> bool:
                 yield Static(id="sidebar")
                 with Vertical(id="main"):
                     with Vertical(id="setup"):
-                        yield Static("Model setup - configure each agent separately", id="setup-title")
+                        yield Static("Model setup - 1/3 Supervisor", id="setup-title")
                         for slot, label, default_model in [
-                            ("supervisor", "Supervisor", ""),
-                            ("main", "Main coding", ""),
-                            ("small", "Small memory", ""),
+                            ("supervisor", "1. Supervisor", ""),
+                            ("main", "2. Main coding", ""),
+                            ("small", "3. Small memory", ""),
                         ]:
-                            with Vertical(classes="agent-setup"):
+                            with Vertical(id=f"setup-{slot}-panel", classes="agent-setup"):
                                 yield Static(f"{label} agent")
                                 yield Select(
                                     [
                                         ("OpenAI Compatible", "openai-compatible"),
                                         ("Anthropic Compatible", "anthropic"),
+                                        ("Claude Code CLI", "claude-code"),
+                                        ("Codex CLI", "codex-cli"),
                                         ("Custom", "custom"),
                                     ],
                                     value="openai-compatible",
@@ -380,14 +513,16 @@ def run_textual_tui(context: McpContext) -> bool:
                                 )
                                 yield Input(placeholder="Custom provider if preset=Custom", id=f"setup-{slot}-custom-provider", classes="setup-input")
                                 yield Input(value=default_model, placeholder="Model name", id=f"setup-{slot}-model", classes="setup-input")
-                                yield Input(placeholder="Base URL, e.g. http://localhost:20128/v1", id=f"setup-{slot}-base-url", classes="setup-input")
+                                yield Input(placeholder="Base URL or CLI command, e.g. http://localhost:20128/v1 / claude / codex exec", id=f"setup-{slot}-base-url", classes="setup-input")
                                 yield Input(value="OPENAI_API_KEY", placeholder="API key or env name", id=f"setup-{slot}-api-key-env", classes="setup-input")
                         with Horizontal(id="setup-actions"):
-                            yield Button("Save setup", id="setup-save", variant="primary")
+                            yield Button("Back", id="setup-prev")
+                            yield Button("Next", id="setup-next", variant="primary")
+                            yield Button("Save setup", id="setup-save", variant="success")
                             yield Button("Skip", id="setup-skip")
                     yield RichLog(id="chat", wrap=True, highlight=True, markup=False, auto_scroll=True)
                     yield Static(id="palette")
-                    yield Input(placeholder="Prompt ho?c /command. Mouse wheel scroll trong khung chat.", id="input")
+                    yield Input(placeholder="Prompt or /command. Mouse wheel scroll in chat.", id="input")
             yield Footer()
 
         def on_mount(self) -> None:
@@ -395,10 +530,11 @@ def run_textual_tui(context: McpContext) -> bool:
             self.chat.write("system > AgentRAM Textual TUI ready")
             self.chat.write(f"system > RAM root: {self.context.ram_root}")
             self.prefill_setup_from_profile()
+            self.refresh_setup_step()
             self.refresh_sidebar()
             self.set_interval(1.0, self.refresh_sidebar)
             try:
-                self.query_one("#setup-supervisor-model", Input).focus()
+                self.focus_current_setup_model()
             except Exception:  # noqa: BLE001 - fallback if setup is hidden/unmounted
                 self.query_one("#input", Input).focus()
 
@@ -418,7 +554,7 @@ def run_textual_tui(context: McpContext) -> bool:
                 if not endpoint:
                     continue
                 provider = endpoint.provider
-                preset = provider if provider in {"openai-compatible", "anthropic"} else "custom"
+                preset = provider if provider in {"openai-compatible", "anthropic", "claude-code", "codex-cli"} else "custom"
                 self.query_one(f"#setup-{slot}-provider", Select).value = preset
                 self.query_one(f"#setup-{slot}-custom-provider", Input).value = "" if preset != "custom" else provider
                 self.query_one(f"#setup-{slot}-model", Input).value = endpoint.model
@@ -426,6 +562,37 @@ def run_textual_tui(context: McpContext) -> bool:
                 self.query_one(f"#setup-{slot}-api-key-env", Input).value = endpoint.api_key_env
             self.chat.write("system > Existing workflow models loaded. Save to update, or Skip to keep.")
 
+        def current_setup_slot(self) -> str:
+            return self.setup_slots[self.setup_index]
+
+        def current_setup_label(self) -> str:
+            labels = {"supervisor": "Supervisor", "main": "Main coding", "small": "Small memory"}
+            return labels[self.current_setup_slot()]
+
+        def refresh_setup_step(self) -> None:
+            total = len(self.setup_slots)
+            slot = self.current_setup_slot()
+            self.query_one("#setup-title", Static).update(f"Model setup - {self.setup_index + 1}/{total} {self.current_setup_label()}")
+            for item in self.setup_slots:
+                self.query_one(f"#setup-{item}-panel", Vertical).styles.display = "block" if item == slot else "none"
+
+        def focus_current_setup_model(self) -> None:
+            self.query_one(f"#setup-{self.current_setup_slot()}-model", Input).focus()
+
+        def action_next_setup(self) -> None:
+            if self.setup_index < len(self.setup_slots) - 1:
+                self.setup_index += 1
+                self.refresh_setup_step()
+                self.focus_current_setup_model()
+            else:
+                self.action_save_setup()
+
+        def action_prev_setup(self) -> None:
+            if self.setup_index > 0:
+                self.setup_index -= 1
+                self.refresh_setup_step()
+                self.focus_current_setup_model()
+
         def setup_value(self, widget_id: str) -> str:
             return self.query_one(f"#{widget_id}", Input).value.strip()
 
@@ -473,8 +640,10 @@ def run_textual_tui(context: McpContext) -> bool:
 
         def show_setup(self) -> None:
             self.setup_done = False
+            self.setup_index = 0
             self.query_one("#setup", Vertical).styles.display = "block"
-            self.query_one("#setup-supervisor-model", Input).focus()
+            self.refresh_setup_step()
+            self.focus_current_setup_model()
 
         def action_history_prev(self) -> None:
             input_widget = self.query_one("#input", Input)
@@ -515,6 +684,10 @@ def run_textual_tui(context: McpContext) -> bool:
         def on_button_pressed(self, event: Button.Pressed) -> None:
             if event.button.id == "setup-save":
                 self.action_save_setup()
+            elif event.button.id == "setup-next":
+                self.action_next_setup()
+            elif event.button.id == "setup-prev":
+                self.action_prev_setup()
             elif event.button.id == "setup-skip":
                 self.chat.write("system > Model setup skipped. Use /bind-agent later.")
                 self.hide_setup()
@@ -535,7 +708,7 @@ def run_textual_tui(context: McpContext) -> bool:
                 return
             query = value.strip().lower().lstrip("/")
             matches = []
-            for command, description in SLASH_COMMANDS:
+            for command, description in slash_entries():
                 if not command.startswith("/"):
                     continue
                 command_name = command.split()[0]
@@ -547,7 +720,7 @@ def run_textual_tui(context: McpContext) -> bool:
             if not matches:
                 palette.update("No matching slash command")
             else:
-                lines = ["Slash commands  ?  Tab completes first match"]
+                lines = ["Slash commands - Tab completes first match"]
                 lines.extend(f"  {command.ljust(18)} {description}" for command, description in matches[:8])
                 palette.update("\n".join(lines))
             palette.styles.display = "block"
@@ -571,7 +744,7 @@ def run_textual_tui(context: McpContext) -> bool:
 
         async def on_input_submitted(self, event: Input.Submitted) -> None:
             if event.input.id and str(event.input.id).startswith("setup-"):
-                self.action_save_setup()
+                self.action_next_setup()
                 return
             text = event.value.strip()
             event.input.value = ""
@@ -631,11 +804,11 @@ def run_with_activity(context: McpContext, messages: list[str], user_input: str)
 
 
 def slash_command_names() -> list[str]:
-    return [command.split()[0] for command, _ in SLASH_COMMANDS if command.startswith("/")]
+    return [command.split()[0] for command, _ in slash_entries() if command.startswith("/")]
 
 
 def slash_command_meta() -> dict[str, str]:
-    return {command.split()[0]: description for command, description in SLASH_COMMANDS if command.startswith("/")}
+    return {command.split()[0]: description for command, description in slash_entries() if command.startswith("/")}
 
 
 def create_prompt_session() -> Any | None:
@@ -655,7 +828,7 @@ def create_prompt_session() -> Any | None:
         completer=completer,
         complete_while_typing=True,
         reserve_space_for_menu=12,
-        bottom_toolbar="Type / for slash commands · /agents for subagents · /ask to call bound models",
+        bottom_toolbar="Type / for slash commands | /agents for subagents | /ask to call bound models",
     )
 
 
@@ -755,9 +928,25 @@ def handle_slash_command(context: McpContext, text: str, messages: list[str] | N
         return note_text(context, raw_rest)
     if command == "/clear":
         return "__clear__"
+    if command in CLAUDE_COMPAT_NAMES:
+        return claude_compat_command_text(command, raw_rest)
     return f"Unknown slash command: {command}\n\n{SLASH_HELP}"
 
 
+def claude_compat_command_text(command: str, arguments: str) -> str:
+    descriptions = slash_command_meta()
+    description = descriptions.get(command, "Claude Code command")
+    return "\n".join(
+        [
+            f"Claude-compatible command: {command}",
+            f"Purpose: {description}",
+            f"Args: {arguments or '-'}",
+            "Status: listed for Claude parity in AgentRAM TUI.",
+            "Native execution is not implemented here unless AgentRAM has its own handler for this command.",
+            "Run the same command inside Claude Code for Claude-native behavior.",
+        ]
+    )
+
 def init_text(context: McpContext) -> str:
     data = payload(call_tool(context, "agentram_init", {}))
     created = data.get("created", [])
@@ -852,7 +1041,7 @@ def agents_text() -> str:
 def slash_palette_text(filter_text: str = "") -> str:
     normalized = filter_text.strip().lower().lstrip("/")
     rows = []
-    for command, description in SLASH_COMMANDS:
+    for command, description in slash_entries():
         command_key = command.lower().lstrip("/")
         if normalized and normalized not in command_key:
             continue
@@ -993,45 +1182,154 @@ def workflow_text(context: McpContext) -> str:
             lines.append(f"- {slot}: not bound")
     return "\n".join(lines)
 
-def supervisor_workflow_text(context: McpContext, prompt: str) -> str:
-    agents = context.profile_store.list_agents()
-    supervisor = agents.get("supervisor")
-    main_agent = agents.get("main")
-    small_agent = agents.get("small")
-    memory_context = retrieve_text(context, prompt, task_id="codex", limit=8)
-    plan = supervisor_plan(supervisor, prompt, memory_context)
-    outputs: dict[str, str] = {}
-    with ThreadPoolExecutor(max_workers=2) as executor:
-        futures = {}
-        if main_agent:
-            futures[executor.submit(call_agent_endpoint, main_agent, build_main_agent_prompt(prompt, plan, memory_context))] = "main"
-        if small_agent:
-            futures[executor.submit(call_agent_endpoint, small_agent, build_small_agent_prompt(prompt, plan, memory_context))] = "small"
-        for future, slot in list(futures.items()):
-            try:
-                outputs[slot] = future.result()
-            except Exception as error:  # noqa: BLE001 - agent boundary
-                outputs[slot] = f"error: {model_error_hint(str(error))}"
-    if not main_agent:
-        outputs["main"] = "No main agent bound. Use /bind-agent main <provider> <model>."
-    persist_workflow_memory(context, prompt, plan, outputs)
-    return "\n".join(
-        [
-            "Workflow: supervisor -> main + small -> merge",
-            "Supervisor plan:",
-            plan,
-            "",
-            "Main agent result:",
-            outputs.get("main", "-"),
-            "",
-            "Small memory agent notes:",
-            outputs.get("small", "No small agent bound."),
-        ]
-    )
-
-def persist_workflow_memory(context: McpContext, prompt: str, plan: str, outputs: dict[str, str]) -> None:
-    small_notes = outputs.get("small", "").strip()
-    main_result = outputs.get("main", "").strip()
+def supervisor_workflow_text(context: McpContext, prompt: str) -> str:
+    agents = context.profile_store.list_agents()
+    supervisor = agents.get("supervisor")
+    main_agent = agents.get("main")
+    small_agent = agents.get("small")
+    memory_context = retrieve_text(context, prompt, task_id="codex", limit=8)
+    route = classify_agent_runtime_route(context, prompt)
+    intent = str(route.get("intent", "chat"))
+    outputs: dict[str, str] = {}
+
+    if intent == "planning":
+        plan = supervisor_plan(supervisor, prompt, memory_context)
+        outputs["supervisor"] = plan
+        outputs["small"] = small_agent_observe(context, small_agent, prompt, "supervisor_plan", plan, plan, memory_context)
+        sync_goal_state_from_small_agent(context, prompt, plan, outputs.get("small", ""))
+        persist_workflow_memory(context, prompt, plan, outputs)
+        return "\n".join(
+            [
+                f"Workflow: route=planning confidence={float(route.get('confidence', 0.0)):.2f} -> supervisor -> small memory note -> merge",
+                "Supervisor plan:",
+                plan,
+                "",
+                "Small memory agent notes:",
+                outputs.get("small", "No small agent bound."),
+            ]
+        )
+
+    if intent == "memory":
+        plan = "Memory-only event. Small agent writes RAM note directly."
+        outputs["small"] = small_agent_observe(context, small_agent, prompt, "memory_event", prompt, plan, memory_context)
+        sync_goal_state_from_small_agent(context, prompt, plan, outputs.get("small", ""))
+        persist_workflow_memory(context, prompt, plan, outputs)
+        return "\n".join(
+            [
+                f"Workflow: route=memory confidence={float(route.get('confidence', 0.0)):.2f} -> small memory note -> merge",
+                "Small memory agent notes:",
+                outputs.get("small", "No small agent bound."),
+            ]
+        )
+
+    plan = runtime_execution_plan(context, supervisor, prompt, memory_context, route)
+    outputs["supervisor"] = plan
+    outputs["small_after_plan"] = small_agent_observe(context, small_agent, prompt, "supervisor_plan", plan, plan, memory_context)
+    if main_agent:
+        try:
+            outputs["main"] = call_agent_endpoint(main_agent, build_main_agent_prompt(prompt, plan, memory_context))
+        except Exception as error:  # noqa: BLE001 - agent boundary
+            outputs["main"] = f"error: {model_error_hint(str(error))}"
+    else:
+        outputs["main"] = "No main agent bound. Use /bind-agent main <provider> <model>."
+    outputs["small"] = small_agent_observe(context, small_agent, prompt, "main_result", outputs.get("main", ""), plan, memory_context)
+    sync_goal_state_from_small_agent(context, prompt, plan, outputs.get("small", ""))
+    persist_workflow_memory(context, prompt, plan, outputs)
+    return "\n".join(
+        [
+            f"Workflow: route={intent} confidence={float(route.get('confidence', 0.0)):.2f} -> main -> small memory note -> merge",
+            "Supervisor plan:",
+            plan,
+            "",
+            "Main agent result:",
+            outputs.get("main", "-"),
+            "",
+            "Small memory agent after plan:",
+            outputs.get("small_after_plan", "No small agent bound."),
+            "",
+            "Small memory agent notes:",
+            outputs.get("small", "No small agent bound."),
+        ]
+    )
+
+def classify_agent_runtime_route(context: McpContext, prompt: str) -> dict[str, object]:
+    lower = prompt.lower()
+    execute_words = [
+        "bắt đầu làm", "bat dau lam", "làm đi", "lam di", "tiến hành", "tien hanh", "thực hiện", "thuc hien",
+        "chốt kế hoạch", "chot ke hoach", "bắt tay", "start", "execute", "implement", "do it", "go ahead",
+    ]
+    plan_words = ["lên kế hoạch", "len ke hoach", "kế hoạch", "ke hoach", "plan", "roadmap", "milestone", "thiết kế", "thiet ke"]
+    if any(word in lower for word in execute_words):
+        return {"intent": "execution", "confidence": 0.9, "source": "heuristic"}
+    if any(word in lower for word in plan_words):
+        return {"intent": "planning", "confidence": 0.85, "source": "heuristic"}
+    decision = classify_prompt_intent(context, prompt)
+    intent = str(decision.get("intent", "chat"))
+    if intent == "coding":
+        decision["intent"] = "execution"
+    return decision
+
+def runtime_execution_plan(context: McpContext, supervisor: AgentModelEndpoint | None, prompt: str, memory_context: str, route: dict[str, object]) -> str:
+    state = context.goal_store.load().context_block()
+    if state:
+        return "\n".join(["Use current accepted Goal Stack as execution plan.", state])
+    if str(route.get("intent")) == "execution" and any(word in prompt.lower() for word in ["bắt đầu", "bat dau", "làm đi", "lam di", "execute", "do it"]):
+        return "User approved previous plan. Use AgentRAM memory context and current prompt to execute next concrete task."
+    return supervisor_plan(supervisor, prompt, memory_context)
+
+def small_agent_observe(context: McpContext, small_agent: AgentModelEndpoint | None, prompt: str, event_type: str, event_content: str, plan: str, memory_context: str) -> str:
+    if not small_agent:
+        return "No small agent bound."
+    try:
+        return call_agent_endpoint(
+            small_agent,
+            build_small_agent_prompt(prompt, plan, memory_context, event_content, event_type=event_type),
+        )
+    except Exception as error:  # noqa: BLE001 - agent boundary
+        return f"error: {model_error_hint(str(error))}"
+
+def sync_goal_state_from_small_agent(context: McpContext, prompt: str, plan: str, small_notes: str) -> None:
+    if not small_notes.strip() or small_notes.strip().startswith("error:"):
+        return
+    state = context.goal_store.load()
+    goal = extract_labeled_value(small_notes, ("current_goal", "goal", "mục tiêu", "muc tieu")) or first_nonempty_line(plan)
+    task = extract_labeled_value(small_notes, ("current_task", "task", "nhiệm vụ", "nhiem vu")) or first_nonempty_line(small_notes) or prompt
+    patch: dict[str, object] = {
+        "current_task": trim(task.strip(), 180),
+        "goal_history": [trim(goal.strip() or prompt.strip(), 180)],
+    }
+    if not state.mission:
+        patch["mission"] = "Xây dựng và vận hành AgentRAM cho coding agents."
+    if not state.project_goal:
+        patch["project_goal"] = "AgentRAM workflow: supervisor lập kế hoạch, main coding agent thực thi, small memory agent ghi RAM."
+    if goal:
+        patch["current_goal"] = trim(goal.strip(), 180)
+    context.goal_store.update(patch)
+
+def extract_labeled_value(text: str, labels: tuple[str, ...]) -> str:
+    for line in text.splitlines():
+        cleaned = line.strip().lstrip("-*").strip()
+        for label in labels:
+            pattern = rf"^{re.escape(label)}\s*[:=]\s*(.+)$"
+            match = re.match(pattern, cleaned, flags=re.IGNORECASE)
+            if match:
+                return match.group(1).strip().strip("`*_-")
+    return ""
+
+def first_nonempty_line(value: str) -> str:
+    for line in value.splitlines():
+        cleaned = line.strip().lstrip("-0123456789. )")
+        if cleaned and not cleaned.lower().startswith(("supervisor error", "fallback plan")):
+            return cleaned
+    return ""
+
+def persist_workflow_memory(context: McpContext, prompt: str, plan: str, outputs: dict[str, str]) -> None:
+    small_notes = "\n".join(
+        value.strip()
+        for key, value in outputs.items()
+        if key.startswith("small") and value.strip() and not value.strip().startswith("error:")
+    )
+    main_result = outputs.get("main", "").strip()
     note_parts = [
         f"User request: {prompt}",
         f"Supervisor plan: {trim(plan.strip(), 1200)}" if plan.strip() else "Supervisor plan: -",
@@ -1062,14 +1360,14 @@ def supervisor_plan(supervisor: AgentModelEndpoint | None, prompt: str, memory_c
 def call_agent_endpoint(endpoint: AgentModelEndpoint, prompt: str) -> str:
     return MultiModelCodingOrchestrator([endpoint])._call_endpoint(endpoint, prompt)
 
-def build_supervisor_prompt(prompt: str, memory_context: str) -> str:
-    return "\n".join(["You are AgentRAM supervisor. Act like a senior coding-agent boss.", "Create concise plan for main coding agent and small memory agent.", "Return only actionable plan. No markdown table.", "User request:", prompt, "AgentRAM context:", memory_context])
-
-def build_main_agent_prompt(prompt: str, plan: str, memory_context: str) -> str:
-    return "\n".join(["You are AgentRAM main coding agent.", "Follow supervisor plan. Focus on planning, orchestration, coding, refactor, bug fix, and final result.", "Do not invent repo facts. Mention files to inspect/change.", "User request:", prompt, "Supervisor plan:", plan, "AgentRAM context:", memory_context])
-
-def build_small_agent_prompt(prompt: str, plan: str, memory_context: str) -> str:
-    return "\n".join(["You are AgentRAM small memory agent.", "Do not edit code. Note plans, decisions, risks, files, next tasks, and coding facts for RAM.", "Return concise memory notes only.", "User request:", prompt, "Supervisor plan:", plan, "AgentRAM context:", memory_context])
+def build_supervisor_prompt(prompt: str, memory_context: str) -> str:
+    return "\n".join(["You are AgentRAM supervisor. Act like a senior coding-agent boss.", "Nếu user prompt bằng tiếng Việt, trả lời bằng tiếng Việt. Giữ code, command, path, errors nguyên văn.", "Create a concise plan only. Do not code. Main agent runs later only after user approves/starts execution.", "Small memory agent observes this plan and writes RAM notes.", "Return only actionable plan. No markdown table.", "User request:", prompt, "AgentRAM context:", memory_context])
+
+def build_main_agent_prompt(prompt: str, plan: str, memory_context: str) -> str:
+    return "\n".join(["You are AgentRAM main coding agent.", "Nếu user prompt bằng tiếng Việt, trả lời bằng tiếng Việt. Giữ code, command, path, errors nguyên văn.", "Follow supervisor plan. Focus on planning, orchestration, coding, refactor, bug fix, and final result.", "Do not invent repo facts. Mention files to inspect/change.", "User request:", prompt, "Supervisor plan:", plan, "AgentRAM context:", memory_context])
+
+def build_small_agent_prompt(prompt: str, plan: str, memory_context: str, event_content: str = "", event_type: str = "main_result") -> str:
+    return "\n".join(["You are AgentRAM small memory agent.", "Nếu user prompt bằng tiếng Việt, ghi note RAM bằng tiếng Việt. Giữ code, command, path, errors nguyên văn.", "You participate in every AgentRAM event directly: user request, supervisor plan, main result, compact/merge.", "Do not edit code. Observe event content, then note decisions, risks, files, next tasks, and coding facts for RAM.", "You are responsible for setting the visible RAM goal/task from the latest event.", "Return concise memory notes only. Không dùng tiếng Anh nếu user đang dùng tiếng Việt.", "Bắt buộc gồm 2 dòng đầu theo format: current_goal: ... và current_task: ...", "User request:", prompt, "Supervisor plan:", plan, "Observed event type:", event_type, "Observed event content:", event_content or "-", "AgentRAM context:", memory_context])
 
 def bind_router_text(context: McpContext, options: dict[str, object]) -> str:
     api_key_env = str(options.get("api_key_env", ""))
@@ -1154,9 +1452,9 @@ def extract_json_object(text: str) -> str:
 
 def heuristic_intent(prompt: str) -> dict[str, object]:
     lower = prompt.lower()
-    memory_words = ["ghi nhớ", "remember", "note", "decision", "lưu lại", "save this"]
-    planning_words = ["goal", "kế hoạch", "ke hoach", "milestone", "mission", "drift", "next task", "roadmap", "mục tiêu", "muc tieu"]
-    coding_words = ["sửa", "sua", "fix", "bug", "code", "test", "refactor", "review", "file", ".py", ".js", "endpoint", "class", "function"]
+    memory_words = ["ghi nhớ", "remember", "note", "decision", "lưu lại", "save this"]
+    planning_words = ["goal", "kế hoạch", "ke hoach", "milestone", "mission", "drift", "next task", "roadmap", "mục tiêu", "muc tieu"]
+    coding_words = ["sá»­a", "sua", "fix", "bug", "code", "test", "refactor", "review", "file", ".py", ".js", "endpoint", "class", "function"]
     if any(word in lower for word in memory_words):
         return {"intent": "memory", "confidence": 0.75}
     if any(word in lower for word in planning_words):
@@ -1191,12 +1489,16 @@ def model_error_hint(message: str) -> str:
         return message + " | Fix: /remove-model <id> or re-bind with --base-url http://localhost:8000/v1"
     if "actively refused" in lower or "connection refused" in lower or "winerror 10061" in lower:
         return message + " | Fix: start your OpenAI-compatible server at base_url, or change --base-url."
+    if "http 403" in lower or "403" in lower and "groq" in lower:
+        return message + " | Fix: Groq rejected auth/model. Rotate/check API key, ensure provider=openai-compatible, base_url=https://api.groq.com/openai/v1, and use a Groq-supported model name."
     if "http 404" in lower or "404: not found" in lower:
         return message + " | Fix: verify base_url includes /v1, provider supports /chat/completions, and model name exists."
     if "http 400" in lower and "not supported" in lower:
         return message + " | Fix: this account/provider rejects that model. Bind a supported model name from your local endpoint."
     if "returned non-json" in lower or "expecting value" in lower:
         return message + " | Fix: endpoint returned empty/HTML/non-JSON. Check base_url, auth key, proxy, and server logs."
+    if "command not found" in lower or "winerror 2" in lower or "the system cannot find the file" in lower:
+        return message + r" | Fix: install the CLI or set Main base_url to full command path. For Codex use base_url='C:\Users\admin\AppData\Roaming\npm\codex.cmd exec' or paste codex.cmd path; AgentRAM auto-adds exec when missing."
     if "missing api key env" in lower:
         return message + " | Fix: set environment variable, then bind using --api-key-env ENV_NAME, not raw key."
     return message
@@ -1273,7 +1575,7 @@ def draw_screen(context: McpContext, messages: list[str], activity: str | None =
     left_width = 30
     right_width = width - left_width - 3
     print("+" + "-" * (width - 2) + "+")
-    print(box_text("◆ AgentRAM Code  |  RAM + Claude subagents + slash commands", width))
+    print(box_text("AgentRAM Code  |  RAM + Claude subagents + slash commands", width))
     print("+" + "-" * (width - 2) + "+")
 
     sidebar = sidebar_lines(context)
@@ -1328,7 +1630,7 @@ def sidebar_lines(context: McpContext) -> list[str]:
 
 
 def trim(text: str, limit: int) -> str:
-    return text if len(text) <= limit else text[: limit - 1] + "…"
+    return text if len(text) <= limit else text[: limit - 3] + "..."
 
 
 def menu_lines() -> list[str]:

package/agentram/orchestration.py

@@ -1,12 +1,14 @@
-from __future__ import annotations
+from __future__ import annotations
 
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass, field
 import json
-import os
-import re
-import shlex
-import subprocess
+import os
+from pathlib import Path
+import re
+import shlex
+import subprocess
+import tempfile
 import urllib.error
 import urllib.request
 from typing import Any, Callable
@@ -30,6 +32,12 @@ PROVIDER_ALIASES = {
     "claudesubagent": "claude-subagent",
     "claude_subagent": "claude-subagent",
     "claude-subagent": "claude-subagent",
+    "codex": "codex-cli",
+    "codexcli": "codex-cli",
+    "codex_cli": "codex-cli",
+    "codex-code": "codex-cli",
+    "codex_cli_agent": "codex-cli",
+    "codex-cli": "codex-cli",
 }
 
 
@@ -38,6 +46,38 @@ def normalize_provider_name(provider: str) -> str:
     return PROVIDER_ALIASES.get(normalized, normalized)
 
 
+def split_cli_command(command: str) -> list[str]:
+    cleaned = command.strip().strip('"')
+    if not cleaned:
+        return []
+    if os.name == "nt":
+        lowered = cleaned.lower()
+        for marker in (".cmd", ".exe", ".bat", ".ps1"):
+            index = lowered.find(marker)
+            if index != -1:
+                end = index + len(marker)
+                program = cleaned[:end]
+                rest = cleaned[end:].strip()
+                return [program, *shlex.split(rest)] if rest else [program]
+    return shlex.split(cleaned)
+
+def env_value(name: str) -> str:
+    value = os.getenv(name, "")
+    if value:
+        return value
+    env_path = Path(".env")
+    if not env_path.exists():
+        return ""
+    for line in env_path.read_text(encoding="utf-8", errors="ignore").splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or "=" not in stripped:
+            continue
+        key, raw_value = stripped.split("=", 1)
+        if key.strip() == name:
+            return raw_value.strip().strip('"').strip("'")
+    return ""
+
+
 @dataclass(frozen=True)
 class AgentModelEndpoint:
     provider: str
@@ -137,10 +177,12 @@ class MultiModelCodingOrchestrator:
             return self._call_anthropic(endpoint, prompt)
         if provider in {"claude-code", "claude-cli", "claude-subagent", "claude-code-subagent"}:
             return self._call_claude_code_subagent(endpoint, prompt)
+        if provider in {"codex-cli"}:
+            return self._call_codex_cli_agent(endpoint, prompt)
         raise ValueError(f"Unsupported provider for execution: {endpoint.provider}")
 
     def _call_openai_compatible(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
-        api_key = os.getenv(endpoint.api_key_env) if endpoint.api_key_env else ""
+        api_key = env_value(endpoint.api_key_env) if endpoint.api_key_env else ""
         if not endpoint.base_url:
             raise ValueError("base_url is required")
         if endpoint.api_key_env and not api_key:
@@ -162,17 +204,20 @@ class MultiModelCodingOrchestrator:
             if error.code == 404:
                 hint += " | base_url should include /v1 but not /chat/completions; verify provider URL and model name"
             raise RuntimeError(f"{hint} | response={body[:500]}") from error
-        try:
-            data = json.loads(raw)
-        except json.JSONDecodeError as error:
-            streamed = parse_openai_sse(raw)
-            if streamed:
-                return streamed
-            raise RuntimeError(f"OpenAI-compatible returned non-JSON at {url} | response={raw[:500]}") from error
-        return str(data.get("choices", [{}])[0].get("message", {}).get("content", ""))
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError as error:
+            mixed_json = parse_openai_mixed_json(raw)
+            if mixed_json:
+                return extract_openai_message(mixed_json)
+            streamed = parse_openai_sse(raw)
+            if streamed:
+                return streamed
+            raise RuntimeError(f"OpenAI-compatible returned non-JSON at {url} | response={raw[:500]}") from error
+        return extract_openai_message(data)
 
     def _call_anthropic(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
-        api_key = os.getenv(endpoint.api_key_env) if endpoint.api_key_env else ""
+        api_key = env_value(endpoint.api_key_env) if endpoint.api_key_env else ""
         if endpoint.api_key_env and not api_key:
             raise ValueError(f"missing API key env: {endpoint.api_key_env}")
         base_url = endpoint.base_url.rstrip("/") if endpoint.base_url else "https://api.anthropic.com/v1"
@@ -192,7 +237,7 @@ class MultiModelCodingOrchestrator:
 
     def _call_claude_code_subagent(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
         command = endpoint.base_url.strip() or os.getenv("AGENTRAM_CLAUDE_COMMAND", "claude")
-        args = shlex.split(command)
+        args = split_cli_command(command)
         if not args:
             raise ValueError("claude command is required")
         subagent_prompt = "\n".join(
@@ -200,25 +245,81 @@ class MultiModelCodingOrchestrator:
                 f"Use Claude Code subagent entrypoint: {endpoint.model}",
                 f"Subagent role: {endpoint.role}",
                 "If that subagent exists in .claude/agents, follow it. If not, act as this role.",
-                "Return concise coding-agent output only.",
+                "If role is coder/main, you may inspect and edit files using Claude Code tools. If role is memory/small, do not edit files; write notes only.",
+                "Return concise coding-agent output, changed files, and verification status.",
                 "",
                 prompt,
             ]
         )
-        process = subprocess.run(
-            [*args, "-p", subagent_prompt],
-            check=False,
-            capture_output=True,
-            encoding="utf-8",
-            timeout=300,
-        )
+        try:
+            process = subprocess.run(
+                [*args, "-p", subagent_prompt],
+                check=False,
+                capture_output=True,
+                encoding="utf-8",
+                timeout=300,
+            )
+        except FileNotFoundError as error:
+            raise RuntimeError(f"Claude Code command not found: {args[0]}. Install Claude Code CLI or set base_url to the full command path.") from error
         output = (process.stdout or "").strip()
         error = (process.stderr or "").strip()
         if process.returncode != 0:
             raise RuntimeError(error or f"claude command failed with exit code {process.returncode}")
         return output or error
 
-def parse_openai_sse(raw: str) -> str:
+    def _call_codex_cli_agent(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
+        command = endpoint.base_url.strip() or os.getenv("AGENTRAM_CODEX_COMMAND", "codex exec")
+        args = split_cli_command(command)
+        if not args:
+            raise ValueError("codex command is required")
+        if len(args) == 1:
+            args.append("exec")
+        codex_prompt = "\n".join(
+            [
+                f"You are AgentRAM {endpoint.role} agent running through Codex CLI.",
+                f"Model hint: {endpoint.model}",
+                "If role is coder/main, inspect and edit files as needed in the current repo. If role is memory/small, do not edit files; write notes only.",
+                "Return concise result, changed files, tests/verification, and blockers.",
+                "",
+                prompt,
+            ]
+        )
+        prompt_path = ""
+        try:
+            with tempfile.NamedTemporaryFile(
+                "w",
+                encoding="utf-8",
+                delete=False,
+                dir=os.getcwd(),
+                prefix=".agentram_codex_prompt_",
+                suffix=".txt",
+            ) as prompt_file:
+                prompt_file.write(codex_prompt)
+                prompt_path = prompt_file.name
+            short_prompt = f"Read AgentRAM task from file and execute it: {prompt_path}"
+            process = subprocess.run(
+                [*args, short_prompt],
+                check=False,
+                capture_output=True,
+                encoding="utf-8",
+                timeout=int(os.getenv("AGENTRAM_CLI_TIMEOUT", "900")),
+            )
+        except FileNotFoundError as error:
+            raise RuntimeError(f"Codex CLI command not found: {args[0]}. Install Codex CLI or set base_url to the full command path.") from error
+        finally:
+            if prompt_path:
+                try:
+                    os.remove(prompt_path)
+                except OSError:
+                    pass
+        output = (process.stdout or "").strip()
+        error = (process.stderr or "").strip()
+        if process.returncode != 0:
+            raise RuntimeError(error or f"codex command failed with exit code {process.returncode}")
+        return output or error
+
+
+def parse_openai_sse(raw: str) -> str:
     parts: list[str] = []
     for line in raw.splitlines():
         stripped = line.strip()
@@ -245,9 +346,39 @@ def parse_openai_sse(raw: str) -> str:
         message = choice.get("message", {})
         if isinstance(message, dict) and message.get("content"):
             parts.append(str(message.get("content")))
-    return strip_thinking_blocks("".join(parts)).strip()
-
-def strip_thinking_blocks(text: str) -> str:
+    return strip_thinking_blocks("".join(parts)).strip()
+
+def parse_openai_mixed_json(raw: str) -> dict[str, Any]:
+    stripped = raw.strip()
+    if not stripped.startswith("{"):
+        return {}
+    for marker in ("\ndata:", "\r\ndata:"):
+        if marker not in stripped:
+            continue
+        candidate = stripped.split(marker, 1)[0].strip()
+        try:
+            value = json.loads(candidate)
+        except json.JSONDecodeError:
+            return {}
+        return value if isinstance(value, dict) else {}
+    return {}
+
+def extract_openai_message(data: dict[str, Any]) -> str:
+    choices = data.get("choices", [])
+    if not choices or not isinstance(choices, list):
+        return ""
+    first = choices[0]
+    if not isinstance(first, dict):
+        return ""
+    message = first.get("message", {})
+    if isinstance(message, dict):
+        return strip_thinking_blocks(str(message.get("content", ""))).strip()
+    delta = first.get("delta", {})
+    if isinstance(delta, dict):
+        return strip_thinking_blocks(str(delta.get("content", ""))).strip()
+    return ""
+
+def strip_thinking_blocks(text: str) -> str:
     text = re.sub(r"<thinking>.*?</thinking>", "", text, flags=re.DOTALL | re.IGNORECASE)
     text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL | re.IGNORECASE)
     text = re.sub(r"^\s*</?(thinking|think)>\s*", "", text, flags=re.IGNORECASE)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentram",
-  "version": "0.1.21",
+  "version": "0.1.29",
   "description": "Async, model-agnostic Working RAM for coding agents.",
   "license": "MIT",
   "homepage": "https://github.com/trancongnghia/AGENT_RAM#readme",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentram"
-version = "0.1.21"
+version = "0.1.29"
 description = "Async, model-agnostic RAM layer for agentic coding tools."
 readme = "README.md"
 license = "MIT"