agentram 0.1.21 → 0.1.30

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
@@ -346,13 +475,17 @@ def run_textual_tui(context: McpContext) -> bool:
         def __init__(self, mcp_context: McpContext) -> None:
             super().__init__()
             self.context = mcp_context
-            self.messages: list[str] = []
-            self.busy = False
-            self.suggestions: list[str] = []
+            self.messages: list[str] = []
+            self.busy = False
+            self.prompt_queue: list[str] = []
+            self.processing_task: asyncio.Task[None] | None = None
+            self.suggestions: list[str] = []
             self.setup_done = False
             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 +493,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 +515,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 +532,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 +556,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 +564,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 +642,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 +686,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 +710,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 +722,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 +746,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 = ""
@@ -596,23 +771,37 @@ def run_textual_tui(context: McpContext) -> bool:
                 self.chat.clear()
                 self.chat.write("system > Chat cleared.")
                 return
-            if self.busy:
-                self.chat.write("agentram > busy, wait current task")
-                return
-            self.busy = True
-            self.chat.write("agentram > thinking...")
-            try:
-                response = await asyncio.to_thread(handle_chat_input, self.context, text, self.messages)
-            except Exception as error:  # noqa: BLE001 - TUI boundary
-                response = f"error: {error}"
-            finally:
-                self.busy = False
-            if response == "__clear__":
-                self.chat.clear()
-                self.chat.write("system > Chat cleared.")
-            elif response:
-                self.chat.write("agentram > " + response)
-            self.refresh_sidebar()
+            if self.busy:
+                self.prompt_queue.append(text)
+                self.chat.write(f"agentram > queued #{len(self.prompt_queue)}")
+                return
+            self.prompt_queue.append(text)
+            self.processing_task = asyncio.create_task(self.process_prompt_queue())
+
+        async def process_prompt_queue(self) -> None:
+            if self.busy:
+                return
+            self.busy = True
+            try:
+                while self.prompt_queue:
+                    text = self.prompt_queue.pop(0)
+                    pending = len(self.prompt_queue)
+                    suffix = f" ({pending} queued)" if pending else ""
+                    self.chat.write(f"agentram > thinking...{suffix}")
+                    try:
+                        response = await asyncio.to_thread(handle_chat_input, self.context, text, self.messages)
+                    except Exception as error:  # noqa: BLE001 - TUI boundary
+                        response = f"error: {error}"
+                    if response == "__clear__":
+                        self.chat.clear()
+                        self.chat.write("system > Chat cleared.")
+                    elif response:
+                        self.chat.write("agentram > " + response)
+                    self.refresh_sidebar()
+            finally:
+                self.busy = False
+                self.processing_task = None
+                self.query_one("#input", Input).focus()
 
     AgentRAMTextualApp(context).run()
     return True
@@ -631,11 +820,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 +844,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 +944,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 +1057,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 +1198,192 @@ 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, main_agent)
+    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, main_agent: AgentModelEndpoint | None = None) -> dict[str, object]:
+    if main_agent:
+        try:
+            response = call_agent_endpoint(main_agent, build_agent_runtime_router_prompt(prompt))
+            data = json.loads(extract_json_object(response))
+            intent = str(data.get("intent", "")).strip().lower()
+            if intent in {"planning", "execution", "memory", "chat"}:
+                return {
+                    "intent": intent,
+                    "confidence": float(data.get("confidence", 0.75)),
+                    "reason": str(data.get("reason", "main-agent router")),
+                    "source": "main-agent",
+                }
+        except Exception as error:  # noqa: BLE001 - router boundary
+            fallback = heuristic_agent_runtime_route(prompt)
+            fallback["source"] = "heuristic"
+            fallback["router_error"] = str(error)
+            return fallback
+
+    return heuristic_agent_runtime_route(prompt)
+
+def heuristic_agent_runtime_route(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 = heuristic_intent(prompt)
+    intent = str(decision.get("intent", "chat"))
+    if intent == "coding":
+        decision["intent"] = "execution"
+    decision["source"] = "heuristic"
+    return decision
+
+def build_agent_runtime_router_prompt(prompt: str) -> str:
+    return "\n".join(
+        [
+            "You are AgentRAM orchestration router using the main agent model.",
+            "Classify which agent should handle the user prompt. Do not edit files. Do not run tools. Return only JSON.",
+            "Schema: {\"intent\":\"planning|execution|memory|chat\",\"confidence\":0.0,\"reason\":\"short\"}",
+            "planning = user asks to plan, design, set roadmap, discuss goal, no execution yet.",
+            "execution = user approves plan, says start/do it, or asks coding/refactor/fix/test/file work.",
+            "memory = user asks to remember/save/note a decision/fact.",
+            "chat = normal conversation.",
+            "Nếu user prompt bằng tiếng Việt, reason dùng tiếng Việt.",
+            "User prompt:",
+            prompt,
+        ]
+    )
+
+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 +1414,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 +1506,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 +1543,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 +1629,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 +1684,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]: