agentram 0.1.30 → 0.1.32

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.
 
@@ -407,7 +407,7 @@ TUI slash commands. Plain text only records/retrieves RAM; use `/ask` to call bo
 Storage:
 
 ```text
-.agentram/agent_profile.json
+.agentram/agent_profile.jsonl
 ```
 
 ## MCP Tools
@@ -1051,3 +1051,4 @@ 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
@@ -71,33 +71,19 @@ SUBAGENTS: dict[str, str] = {
 
 SLASH_COMMANDS: list[tuple[str, str]] = [
     ("/help", "Show commands"),
-    ("/init", "Create .agentram files"),
+    ("/setup", "Open model setup"),
     ("/status", "Show RAM status"),
-    ("/retrieve <query>", "Print relevant RAM context"),
+    ("/workflow", "Show supervisor/main/small agents"),
+    ("/models", "List bound workflow models"),
     ("/goal", "Show Goal Stack"),
-    ("/set-goal key=value ...", "Update mission/current_goal/current_task/etc"),
-    ("/drift <task>", "Check goal drift"),
+    ("/set-goal key=value ...", "Update goal/task"),
+    ("/retrieve <query>", "Print relevant RAM context"),
     ("/events", "Show latest events"),
     ("/replay", "Replay events into memory"),
-    ("/agents", "List Claude-style subagent presets"),
-    ("/agent <name> <task>", "Build Claude Code subagent prompt"),
-    ("/models", "List bound coding models"),
-    ("/remove-model <id>", "Remove bound coding model"),
-    ("/disable-model <id>", "Disable bound coding model"),
-    ("/clear-models", "Remove all bound coding models"),
-    ("/bind-model provider model", "Bind model endpoint"),
-    ("/bind-router provider model", "Bind intent router model"),
-    ("/bind-agent slot provider model", "Bind supervisor/main/small agent"),
-    ("/workflow", "Show supervisor workflow agents"),
-    ("/setup", "Show model setup panel"),
-    ("/route on|off|status", "Toggle auto prompt routing"),
-    ("/orchestrate <task>", "Build multi-model agent plan"),
-    ("/ask <prompt>", "Execute bound models and return outputs"),
-    ("/claude-install [path]", "Install .claude commands and agents"),
     ("/note <text>", "Save decision note"),
     ("/clear", "Clear chat"),
     ("/exit", "Quit"),
-    ("Plain text", "Capture coding chat message and retrieve context"),
+    ("Plain text", "Route prompt through AgentRAM runtime"),
 ]
 
 
@@ -222,7 +208,7 @@ CLAUDE_COMPAT_NAMES = {command.split()[0] for command, _ in CLAUDE_COMPAT_COMMAN
 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]:
+    for command, description in SLASH_COMMANDS:
         name = command.split()[0]
         if name in seen:
             continue
@@ -232,33 +218,19 @@ def slash_entries() -> list[tuple[str, str]]:
 
 SLASH_HELP = """Slash commands:
 /help                         Show commands
-/init                         Create .agentram files
+/setup                        Open model setup
 /status                       Show RAM status
-/retrieve <query>             Print relevant RAM context
+/workflow                     Show supervisor/main/small agents
+/models                       List bound workflow models
 /goal                         Show Goal Stack
-/set-goal key=value ...       Update mission/current_goal/current_task/etc
-/drift <task>                 Check goal drift
+/set-goal key=value ...       Update goal/task
+/retrieve <query>             Print relevant RAM context
 /events                       Show latest events
 /replay                       Replay events into memory
-/agents                       List subagent presets
-/agent <name> <task>          Build Claude Code subagent prompt
-/models                       List bound coding models
-/remove-model <id>            Remove bound coding model
-/disable-model <id>           Disable bound coding model
-/clear-models                 Remove all bound coding models
-/bind-model provider model    Bind model endpoint
-/bind-router provider model   Bind intent router model
-/bind-agent slot provider model Bind supervisor/main/small agent
-/workflow                     Show supervisor workflow agents
-/setup                        Show model setup panel
-/route on|off|status          Toggle auto prompt routing
-/orchestrate <task>           Build multi-model agent plan
-/ask <prompt>                 Execute bound models and return outputs
-/claude-install [path]        Install .claude commands and agents
 /note <text>                  Save decision note
 /clear                        Clear chat
 /exit                         Quit
-Plain text                    Capture coding chat message and retrieve context
+Plain text                    Route prompt through AgentRAM runtime
 """.strip()
 
 
@@ -470,16 +442,18 @@ def run_textual_tui(context: McpContext) -> bool:
         #input { dock: bottom; border: solid #3b82f6; }
         .muted { color: #8b9bb0; }
         """
-        BINDINGS = [("ctrl+c", "interrupt_or_quit", "Cancel/Quit"), ("tab", "accept_suggestion", "Complete slash"), ("ctrl+s", "save_setup", "Save setup"), ("up", "history_prev", "Previous prompt"), ("down", "history_next", "Next prompt")]
+        BINDINGS = [("ctrl+c", "interrupt_or_quit", "Cancel/Quit"), ("tab", "accept_suggestion", "Complete slash"), ("up", "history_prev", "Previous prompt"), ("down", "history_next", "Next prompt")]
 
         def __init__(self, mcp_context: McpContext) -> None:
             super().__init__()
             self.context = mcp_context
-            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.messages: list[str] = []
+            self.busy = False
+            self.prompt_queue: list[str] = []
+            self.processing_task: asyncio.Task[None] | None = None
+            self.pending_approval_prompt: str | None = None
+            self.project_main_agent_approved = False
+            self.suggestions: list[str] = []
             self.setup_done = False
             self.prompt_history: list[str] = []
             self.history_index: int | None = None
@@ -520,7 +494,6 @@ def run_textual_tui(context: McpContext) -> bool:
                         with Horizontal(id="setup-actions"):
                             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")
@@ -562,7 +535,7 @@ def run_textual_tui(context: McpContext) -> bool:
                 self.query_one(f"#setup-{slot}-model", Input).value = endpoint.model
                 self.query_one(f"#setup-{slot}-base-url", Input).value = endpoint.base_url
                 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.")
+            self.chat.write("system > Existing workflow models loaded. Next auto-saves each step, or Skip to keep.")
 
         def current_setup_slot(self) -> str:
             return self.setup_slots[self.setup_index]
@@ -582,12 +555,18 @@ def run_textual_tui(context: McpContext) -> bool:
             self.query_one(f"#setup-{self.current_setup_slot()}-model", Input).focus()
 
         def action_next_setup(self) -> None:
+            saved = self.save_setup_slot(self.current_setup_slot())
+            if saved:
+                self.chat.write(f"agentram > setup saved: {saved}")
             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()
+                self.chat.write("agentram > setup complete")
+                self.hide_setup()
+                self.refresh_sidebar()
+                self.query_one("#input", Input).focus()
 
         def action_prev_setup(self) -> None:
             if self.setup_index > 0:
@@ -604,34 +583,32 @@ def run_textual_tui(context: McpContext) -> bool:
                 return self.setup_value(f"setup-{slot}-custom-provider") or "custom"
             return preset
 
-        def action_save_setup(self) -> None:
+        def save_setup_slot(self, slot: str) -> str:
             role_by_slot = {"supervisor": "supervisor", "main": "coder", "small": "memory"}
-            bound: list[str] = []
-            for slot, role in role_by_slot.items():
-                provider = self.setup_provider(slot)
-                model = self.setup_value(f"setup-{slot}-model")
-                base_url = self.setup_value(f"setup-{slot}-base-url")
-                api_key_input = self.setup_value(f"setup-{slot}-api-key-env")
-                api_key_env, saved_env_name = resolve_api_key_env(slot, api_key_input)
-                if not model:
-                    continue
-                endpoint = AgentModelEndpoint(
-                    provider=provider,
-                    model=model,
-                    role=role,
-                    base_url=base_url,
-                    api_key_env=api_key_env,
-                    modalities=["text"],
-                )
-                self.context.profile_store.set_agent(slot, endpoint)
-                if saved_env_name:
-                    bound.append(f"{slot}={provider}:{model} key=.env:{saved_env_name}")
-                else:
-                    bound.append(f"{slot}={provider}:{model}")
-            if not bound:
-                self.chat.write("agentram > setup skipped: no model entered")
-            else:
-                self.chat.write("agentram > setup saved: " + ", ".join(bound))
+            role = role_by_slot[slot]
+            provider = self.setup_provider(slot)
+            model = self.setup_value(f"setup-{slot}-model")
+            base_url = self.setup_value(f"setup-{slot}-base-url")
+            api_key_input = self.setup_value(f"setup-{slot}-api-key-env")
+            api_key_env, saved_env_name = resolve_api_key_env(slot, api_key_input)
+            if not model:
+                return f"{slot}=skipped"
+            endpoint = AgentModelEndpoint(
+                provider=provider,
+                model=model,
+                role=role,
+                base_url=base_url,
+                api_key_env=api_key_env,
+                modalities=["text"],
+            )
+            self.context.profile_store.set_agent(slot, endpoint)
+            if saved_env_name:
+                return f"{slot}={provider}:{model} key=.env:{saved_env_name}"
+            return f"{slot}={provider}:{model}"
+
+        def action_save_setup(self) -> None:
+            bound = [self.save_setup_slot(slot) for slot in self.setup_slots]
+            self.chat.write("agentram > setup saved: " + ", ".join(bound))
             self.hide_setup()
             self.refresh_sidebar()
             self.query_one("#input", Input).focus()
@@ -684,9 +661,7 @@ def run_textual_tui(context: McpContext) -> bool:
                 self.last_ctrl_c_at = now
 
         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":
+            if event.button.id == "setup-next":
                 self.action_next_setup()
             elif event.button.id == "setup-prev":
                 self.action_prev_setup()
@@ -763,6 +738,27 @@ def run_textual_tui(context: McpContext) -> bool:
                 return
             if text in BUTTONS:
                 text = BUTTONS[text]
+            if self.pending_approval_prompt is not None:
+                decision = normalize_approval_decision(text)
+                if decision == "yes_once":
+                    approved = self.pending_approval_prompt
+                    self.pending_approval_prompt = None
+                    self.chat.write("agentram > approved once")
+                    self.enqueue_prompt(approved)
+                    return
+                if decision == "yes_project":
+                    approved = self.pending_approval_prompt
+                    self.pending_approval_prompt = None
+                    self.project_main_agent_approved = True
+                    self.chat.write("agentram > approved for this project")
+                    self.enqueue_prompt(approved)
+                    return
+                if decision == "no":
+                    self.chat.write("agentram > denied; prompt dropped")
+                    self.pending_approval_prompt = None
+                    return
+                self.chat.write("agentram > approval required: type yes, yes do this project, or no")
+                return
             if text and (not self.prompt_history or self.prompt_history[-1] != text):
                 self.prompt_history.append(text)
                 del self.prompt_history[:-100]
@@ -771,37 +767,49 @@ def run_textual_tui(context: McpContext) -> bool:
                 self.chat.clear()
                 self.chat.write("system > Chat cleared.")
                 return
-            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()
+            if requires_main_agent_approval(self.context, text) and not self.project_main_agent_approved:
+                self.pending_approval_prompt = text
+                self.chat.write(
+                    "agentram > main agent wants terminal/file access. Allow?\n"
+                    "  yes = allow once\n"
+                    "  yes do this project = allow for this project\n"
+                    "  no = deny"
+                )
+                return
+            self.enqueue_prompt(text)
+
+        def enqueue_prompt(self, text: str) -> None:
+            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
@@ -844,7 +852,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 AgentRAM commands | plain text routes through supervisor/main/small",
     )
 
 
@@ -853,6 +861,35 @@ def read_tui_input(prompt_session: Any | None) -> str:
         return input("You > ")
     return prompt_session.prompt("You > ")
 
+def normalize_approval_decision(text: str) -> str:
+    normalized = text.strip().lower()
+    if normalized in {"yes", "y", "ok", "allow", "approve", "đồng ý", "dong y"}:
+        return "yes_once"
+    if normalized in {"yes do this project", "yes project", "always", "a", "p", "allow project", "approve project", "đồng ý project", "dong y project"}:
+        return "yes_project"
+    if normalized in {"no", "n", "deny", "reject", "không", "khong"}:
+        return "no"
+    return ""
+
+def requires_main_agent_approval(context: McpContext, prompt: str) -> bool:
+    main_agent = context.profile_store.list_agents().get("main")
+    if not main_agent:
+        return False
+    provider = main_agent.provider.lower()
+    if provider not in {"codex-cli", "claude-code", "claude-cli", "claude-subagent", "claude-code-subagent"}:
+        return False
+    route = heuristic_agent_runtime_route(prompt)
+    if str(route.get("intent")) == "planning":
+        return False
+    if str(route.get("intent")) == "execution":
+        return True
+    lower = prompt.lower()
+    risky_words = [
+        "terminal", "command", "shell", "powershell", "cmd", "npm", "pip", "git", "pytest", "run", "build",
+        "sửa", "sua", "fix", "refactor", "edit", "write", "delete", "xóa", "xoa", "tạo file", "tao file",
+    ]
+    return any(word in lower for word in risky_words)
+
 def handle_chat_input(context: McpContext, text: str, messages: list[str] | None = None) -> str:
     if not text:
         return SLASH_HELP
@@ -1198,192 +1235,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)
-    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()
+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: -",
@@ -1414,14 +1451,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.", "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 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", ""))
@@ -1552,7 +1589,7 @@ def model_error_hint(message: str) -> str:
     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."
+        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
@@ -1665,20 +1702,14 @@ def sidebar_lines(context: McpContext) -> list[str]:
         "TASK",
         f"  {trim(goal.current_task or '-', 24)}",
         "",
-        "BUTTONS",
-        "  1 init     2 status",
-        "  3 retrieve 4 goal",
-        "  5 set-goal 6 drift",
-        "  7 events   8 replay",
-        "  9 help     0 exit",
-        "",
-        "CLAUDE",
+        "COMMANDS",
         "  / = command palette",
-        "  /agents",
-        "  /claude-install .",
-        "  /models",
-        "  /clear-models",
-        "  /ask <prompt>",
+        "  /setup",
+        "  /status",
+        "  /goal",
+        "  /workflow",
+        "  /note <text>",
+        "  /clear",
     ]
 
 

package/agentram/mcp_server.py

@@ -46,7 +46,7 @@ class McpContext:
 
     @property
     def profile_store(self) -> JsonAgentProfileStore:
-        return JsonAgentProfileStore(self.ram_root / "agent_profile.json")
+        return JsonAgentProfileStore(self.ram_root / "agent_profile.jsonl")
 
     @property
     def merger(self) -> MemoryMerger:

package/agentram/orchestration.py

@@ -252,12 +252,13 @@ class MultiModelCodingOrchestrator:
             ]
         )
         try:
-            process = subprocess.run(
-                [*args, "-p", subagent_prompt],
-                check=False,
-                capture_output=True,
-                encoding="utf-8",
-                timeout=300,
+            process = subprocess.run(
+                [*args, "-p", subagent_prompt],
+                check=False,
+                stdin=subprocess.DEVNULL,
+                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
@@ -300,6 +301,7 @@ class MultiModelCodingOrchestrator:
             process = subprocess.run(
                 [*args, short_prompt],
                 check=False,
+                stdin=subprocess.DEVNULL,
                 capture_output=True,
                 encoding="utf-8",
                 timeout=int(os.getenv("AGENTRAM_CLI_TIMEOUT", "900")),

package/agentram/storage.py

@@ -80,27 +80,48 @@ class JsonAgentProfileStore:
         self.path = Path(path)
         self.path.parent.mkdir(parents=True, exist_ok=True)
 
-    def load(self) -> dict[str, object]:
-        if not self.path.exists():
-            return {"updated_at": utc_now(), "endpoints": [], "router": None, "auto_route": True, "agents": {}}
-        data = json.loads(self.path.read_text(encoding="utf-8"))
-        data.setdefault("endpoints", [])
-        data.setdefault("router", None)
-        data.setdefault("auto_route", True)
-        data.setdefault("agents", {})
-        return data
-
-    def save(self, endpoints: list[AgentModelEndpoint]) -> dict[str, object]:
-        current = self.load()
-        payload = {
-            "updated_at": utc_now(),
-            "endpoints": [endpoint.to_dict() for endpoint in endpoints],
-            "router": current.get("router"),
-            "auto_route": bool(current.get("auto_route", True)),
-            "agents": current.get("agents", {}),
-        }
-        self.path.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")
-        return payload
+    def default_payload(self) -> dict[str, object]:
+        return {"updated_at": utc_now(), "endpoints": [], "router": None, "auto_route": True, "agents": {}}
+
+    def legacy_json_path(self) -> Path:
+        return self.path.with_suffix(".json") if self.path.suffix == ".jsonl" else self.path
+
+    def normalize_payload(self, data: dict[str, object]) -> dict[str, object]:
+        data.setdefault("endpoints", [])
+        data.setdefault("router", None)
+        data.setdefault("auto_route", True)
+        data.setdefault("agents", {})
+        return data
+
+    def load(self) -> dict[str, object]:
+        if self.path.exists():
+            lines = [line.strip() for line in self.path.read_text(encoding="utf-8").splitlines() if line.strip()]
+            if not lines:
+                return self.default_payload()
+            return self.normalize_payload(json.loads(lines[-1]))
+        legacy = self.legacy_json_path()
+        if legacy.exists() and legacy != self.path:
+            data = self.normalize_payload(json.loads(legacy.read_text(encoding="utf-8")))
+            self.write_snapshot(data)
+            return data
+        return self.default_payload()
+
+    def write_snapshot(self, payload: dict[str, object]) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with self.path.open("a", encoding="utf-8") as file:
+            file.write(json.dumps(payload, ensure_ascii=False) + "\n")
+
+    def save(self, endpoints: list[AgentModelEndpoint]) -> dict[str, object]:
+        current = self.load()
+        payload = {
+            "updated_at": utc_now(),
+            "endpoints": [endpoint.to_dict() for endpoint in endpoints],
+            "router": current.get("router"),
+            "auto_route": bool(current.get("auto_route", True)),
+            "agents": current.get("agents", {}),
+        }
+        self.write_snapshot(payload)
+        return payload
 
     def list_endpoints(self) -> list[AgentModelEndpoint]:
         data = self.load()
@@ -143,62 +164,62 @@ class JsonAgentProfileStore:
         payload["changed"] = changed
         return payload
 
-    def clear(self) -> dict[str, object]:
-        payload = self.save([])
-        payload["cleared"] = True
-        return payload
-
-    def get_router(self) -> AgentModelEndpoint | None:
-        router = self.load().get("router")
-        if not isinstance(router, dict):
-            return None
-        return AgentModelEndpoint.from_dict(router)
-
-    def set_router(self, endpoint: AgentModelEndpoint | None) -> dict[str, object]:
-        current = self.load()
-        current["updated_at"] = utc_now()
-        current["router"] = endpoint.to_dict() if endpoint else None
-        self.path.write_text(json.dumps(current, indent=2, ensure_ascii=False), encoding="utf-8")
-        return current
-
-    def auto_route_enabled(self) -> bool:
-        return bool(self.load().get("auto_route", True))
-
-    def set_auto_route(self, enabled: bool) -> dict[str, object]:
-        current = self.load()
-        current["updated_at"] = utc_now()
-        current["auto_route"] = enabled
-        self.path.write_text(json.dumps(current, indent=2, ensure_ascii=False), encoding="utf-8")
-        return current
-
-    def get_agent(self, slot: str) -> AgentModelEndpoint | None:
-        agents = self.load().get("agents", {})
-        if not isinstance(agents, dict):
-            return None
-        item = agents.get(slot)
-        if not isinstance(item, dict):
-            return None
-        return AgentModelEndpoint.from_dict(item)
-
-    def set_agent(self, slot: str, endpoint: AgentModelEndpoint | None) -> dict[str, object]:
-        current = self.load()
-        agents = current.get("agents", {})
-        if not isinstance(agents, dict):
-            agents = {}
-        if endpoint is None:
-            agents.pop(slot, None)
-        else:
-            agents[slot] = endpoint.to_dict()
-        current["agents"] = agents
-        current["updated_at"] = utc_now()
-        self.path.write_text(json.dumps(current, indent=2, ensure_ascii=False), encoding="utf-8")
-        return current
-
-    def list_agents(self) -> dict[str, AgentModelEndpoint]:
-        agents = self.load().get("agents", {})
-        if not isinstance(agents, dict):
-            return {}
-        return {slot: AgentModelEndpoint.from_dict(item) for slot, item in agents.items() if isinstance(item, dict)}
+    def clear(self) -> dict[str, object]:
+        payload = self.save([])
+        payload["cleared"] = True
+        return payload
+
+    def get_router(self) -> AgentModelEndpoint | None:
+        router = self.load().get("router")
+        if not isinstance(router, dict):
+            return None
+        return AgentModelEndpoint.from_dict(router)
+
+    def set_router(self, endpoint: AgentModelEndpoint | None) -> dict[str, object]:
+        current = self.load()
+        current["updated_at"] = utc_now()
+        current["router"] = endpoint.to_dict() if endpoint else None
+        self.write_snapshot(current)
+        return current
+
+    def auto_route_enabled(self) -> bool:
+        return bool(self.load().get("auto_route", True))
+
+    def set_auto_route(self, enabled: bool) -> dict[str, object]:
+        current = self.load()
+        current["updated_at"] = utc_now()
+        current["auto_route"] = enabled
+        self.write_snapshot(current)
+        return current
+
+    def get_agent(self, slot: str) -> AgentModelEndpoint | None:
+        agents = self.load().get("agents", {})
+        if not isinstance(agents, dict):
+            return None
+        item = agents.get(slot)
+        if not isinstance(item, dict):
+            return None
+        return AgentModelEndpoint.from_dict(item)
+
+    def set_agent(self, slot: str, endpoint: AgentModelEndpoint | None) -> dict[str, object]:
+        current = self.load()
+        agents = current.get("agents", {})
+        if not isinstance(agents, dict):
+            agents = {}
+        if endpoint is None:
+            agents.pop(slot, None)
+        else:
+            agents[slot] = endpoint.to_dict()
+        current["agents"] = agents
+        current["updated_at"] = utc_now()
+        self.write_snapshot(current)
+        return current
+
+    def list_agents(self) -> dict[str, AgentModelEndpoint]:
+        agents = self.load().get("agents", {})
+        if not isinstance(agents, dict):
+            return {}
+        return {slot: AgentModelEndpoint.from_dict(item) for slot, item in agents.items() if isinstance(item, dict)}
 
 
 def ensure_ram_storage(root: str | Path) -> dict[str, object]:
@@ -208,7 +229,7 @@ def ensure_ram_storage(root: str | Path) -> dict[str, object]:
     events_path = ram_root / "events.jsonl"
     memory_path = ram_root / "memory.json"
     goal_path = ram_root / "goal_state.json"
-    profile_path = ram_root / "agent_profile.json"
+    profile_path = ram_root / "agent_profile.jsonl"
 
     created: list[str] = []
     if not events_path.exists():
@@ -222,7 +243,7 @@ def ensure_ram_storage(root: str | Path) -> dict[str, object]:
         created.append("goal_state.json")
     if not profile_path.exists():
         JsonAgentProfileStore(profile_path).save([])
-        created.append("agent_profile.json")
+        created.append("agent_profile.jsonl")
 
     return {
         "ram_root": str(ram_root),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentram",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "description": "Async, model-agnostic Working RAM for coding agents.",
   "license": "MIT",
   "homepage": "https://github.com/trancongnghia/AGENT_RAM#readme",
@@ -50,3 +50,4 @@
     "access": "public"
   }
 }
+

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentram"
-version = "0.1.29"
+version = "0.1.32"
 description = "Async, model-agnostic RAM layer for agentic coding tools."
 readme = "README.md"
 license = "MIT"
@@ -39,3 +39,4 @@ agentram-daemon = "agentram.daemon:main"
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 pythonpath = ["."]
+