agentram 0.1.0 → 0.1.2

package/agentram/cli.py

@@ -1,242 +1,549 @@
-from __future__ import annotations
-
-import argparse
-import os
-import shutil
-import textwrap
-from pathlib import Path
-from typing import Any
-
-from .config import default_ram_root
-from .mcp_server import McpContext, call_tool
-
-
-def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(description="AgentRAM terminal UI and CLI.")
-    parser.add_argument("--ram-root", default=None, help="AgentRAM storage root. Defaults to .agentram in the current project directory.")
-    subparsers = parser.add_subparsers(dest="command")
-
-    subparsers.add_parser("tui", help="Open terminal chat UI.")
-    subparsers.add_parser("init", help="Create AgentRAM files.")
-    subparsers.add_parser("status", help="Show RAM file and item counts.")
-    subparsers.add_parser("goal", help="Show goal stack.")
-
-    retrieve = subparsers.add_parser("retrieve", help="Retrieve memory context.")
-    retrieve.add_argument("query", nargs="?", default="", help="Search query.")
-    retrieve.add_argument("--task-id", default="codex", help="Task id.")
-    retrieve.add_argument("--limit", type=int, default=8, help="Max items.")
-
-    drift = subparsers.add_parser("drift", help="Check goal drift for a task.")
-    drift.add_argument("task", nargs="?", default="", help="Task to check.")
-
-    replay = subparsers.add_parser("replay", help="Replay events into memory.")
-    replay.add_argument("--task-id", default=None, help="Optional task id filter.")
-
-    return parser
-
-
-def context_from_args(args: argparse.Namespace) -> McpContext:
-    ram_root = Path(args.ram_root) if args.ram_root else default_ram_root()
-    return McpContext(ram_root=ram_root)
-
-
-def payload(result: dict[str, Any]) -> dict[str, Any]:
-    return dict(result.get("structuredContent", {}))
-
-
-def print_status(context: McpContext) -> None:
-    context.init_storage()
-    memory_items = context.memory_store.list_items()
-    events = context.event_log.read_all()
-    goal_state = context.goal_store.load()
-    print(f"AgentRAM root: {context.ram_root}")
-    print(f"Events: {len(events)}")
-    print(f"Memory items: {len(memory_items)}")
-    print(f"Mission: {goal_state.mission or '-'}")
-    print(f"Current goal: {goal_state.current_goal or '-'}")
-    print(f"Current task: {goal_state.current_task or '-'}")
-
-
-def run_command(args: argparse.Namespace) -> int:
-    context = context_from_args(args)
-    command = args.command or "tui"
-
-    if command == "tui":
-        run_tui(context)
-        return 0
-    if command == "init":
-        data = payload(call_tool(context, "agentram_init", {}))
-        print(f"AgentRAM root: {data['ram_root']}")
-        created = data.get("created", [])
-        print("Created: " + (", ".join(created) if created else "none"))
-        return 0
-    if command == "status":
-        print_status(context)
-        return 0
-    if command == "retrieve":
-        query = args.query or input("Query > ").strip()
-        data = payload(call_tool(context, "agentram_retrieve", {"query": query, "task_id": args.task_id, "limit": args.limit}))
-        print(data.get("context") or "No matching memory.")
-        return 0
-    if command == "goal":
-        data = payload(call_tool(context, "agentram_read_goal_state", {}))
-        print(data.get("context") or "No goal stack yet.")
-        return 0
-    if command == "drift":
-        task = args.task or input("Task > ").strip()
-        data = payload(call_tool(context, "agentram_check_goal_drift", {"task": task}))
-        print(f"Status: {data.get('status')}")
-        print(f"Aligned: {data.get('aligned')}")
-        print(f"Reason: {data.get('reason')}")
-        if data.get("warning"):
-            print(f"Warning: {data['warning']}")
-        return 0
-    if command == "replay":
-        arguments = {"task_id": args.task_id} if args.task_id else {}
-        data = payload(call_tool(context, "agentram_replay_events", arguments))
-        print(f"Events: {data.get('event_count', 0)}")
-        print(f"Patches: {data.get('patch_count', 0)}")
-        print(f"Memory items: {data.get('memory_count', 0)}")
-        return 0
-
+from __future__ import annotations
+
+import argparse
+import os
+import shlex
+import shutil
+import textwrap
+from pathlib import Path
+from typing import Any
+
+from .config import default_ram_root
+from .mcp_server import McpContext, call_tool
+
+SUBAGENTS: dict[str, str] = {
+    "memory": "Summarize important facts, decisions, files, risks, and next tasks into AgentRAM events. Do not edit code.",
+    "planner": "Break the coding request into small ordered steps. Check AgentRAM goal drift before scope changes.",
+    "reviewer": "Review code changes for correctness, missing tests, regressions, and risky assumptions.",
+    "documenter": "Update README or usage notes from current implementation. Keep docs concise and runnable.",
+}
+
+SLASH_HELP = """Slash commands:
+/help                         Show commands
+/init                         Create .agentram files
+/status                       Show RAM status
+/retrieve <query>             Print relevant RAM context
+/goal                         Show Goal Stack
+/set-goal key=value ...       Update mission/current_goal/current_task/etc
+/drift <task>                 Check goal drift
+/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
+/bind-model provider model    Bind model endpoint
+/orchestrate <task>           Build multi-model agent plan
+/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
+""".strip()
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="AgentRAM terminal UI and CLI.")
+    parser.add_argument("--ram-root", default=None, help="AgentRAM storage root. Defaults to .agentram in the current project directory.")
+    subparsers = parser.add_subparsers(dest="command")
+
+    subparsers.add_parser("tui", help="Open terminal chat UI.")
+    subparsers.add_parser("init", help="Create AgentRAM files.")
+    subparsers.add_parser("status", help="Show RAM file and item counts.")
+    subparsers.add_parser("goal", help="Show goal stack.")
+    subparsers.add_parser("agents", help="List subagent presets.")
+    subparsers.add_parser("models", help="List bound coding model endpoints.")
+
+    bind_model = subparsers.add_parser("bind-model", help="Bind a coding model endpoint.")
+    bind_model.add_argument("provider", help="Provider name, e.g. claude, openai-compatible, groq.")
+    bind_model.add_argument("model", help="Model name.")
+    bind_model.add_argument("--role", default="coder", help="Agent role.")
+    bind_model.add_argument("--base-url", default="", help="Provider base URL.")
+    bind_model.add_argument("--api-key-env", default="", help="Environment variable containing API key.")
+    bind_model.add_argument("--modalities", default="text", help="Comma-separated modalities.")
+
+    orchestrate = subparsers.add_parser("orchestrate", help="Build or run multi-model coding orchestration.")
+    orchestrate.add_argument("task", nargs="?", default="", help="Coding task.")
+    orchestrate.add_argument("--file", action="append", default=[], help="File path to include.")
+    orchestrate.add_argument("--execute", action="store_true", help="Call model endpoints concurrently.")
+
+    retrieve = subparsers.add_parser("retrieve", help="Retrieve memory context.")
+    retrieve.add_argument("query", nargs="?", default="", help="Search query.")
+    retrieve.add_argument("--task-id", default="codex", help="Task id.")
+    retrieve.add_argument("--limit", type=int, default=8, help="Max items.")
+
+    drift = subparsers.add_parser("drift", help="Check goal drift for a task.")
+    drift.add_argument("task", nargs="?", default="", help="Task to check.")
+
+    replay = subparsers.add_parser("replay", help="Replay events into memory.")
+    replay.add_argument("--task-id", default=None, help="Optional task id filter.")
+
+    claude_install = subparsers.add_parser("claude-install", help="Install Claude Code slash commands and subagents into a project.")
+    claude_install.add_argument("--target", default=".", help="Target project root.")
+    claude_install.add_argument("--force", action="store_true", help="Overwrite existing templates.")
+
+    agent = subparsers.add_parser("agent", help="Build subagent prompt.")
+    agent.add_argument("name", choices=sorted(SUBAGENTS), help="Subagent preset.")
+    agent.add_argument("task", nargs="*", help="Task for subagent.")
+
+    return parser
+
+
+def context_from_args(args: argparse.Namespace) -> McpContext:
+    ram_root = Path(args.ram_root) if args.ram_root else default_ram_root()
+    return McpContext(ram_root=ram_root)
+
+
+def payload(result: dict[str, Any]) -> dict[str, Any]:
+    return dict(result.get("structuredContent", {}))
+
+
+def run_command(args: argparse.Namespace) -> int:
+    context = context_from_args(args)
+    command = args.command or "tui"
+
+    if command == "tui":
+        run_tui(context)
+        return 0
+    if command == "init":
+        print(init_text(context))
+        return 0
+    if command == "status":
+        print(status_text(context))
+        return 0
+    if command == "retrieve":
+        query = args.query or input("Query > ").strip()
+        print(retrieve_text(context, query, task_id=args.task_id, limit=args.limit))
+        return 0
+    if command == "goal":
+        print(goal_text(context))
+        return 0
+    if command == "drift":
+        task = args.task or input("Task > ").strip()
+        print(drift_text(context, task))
+        return 0
+    if command == "replay":
+        arguments = {"task_id": args.task_id} if args.task_id else {}
+        print(replay_text(context, arguments))
+        return 0
+    if command == "agents":
+        print(agents_text())
+        return 0
+    if command == "models":
+        print(models_text(context))
+        return 0
+    if command == "bind-model":
+        print(bind_model_text(context, vars(args)))
+        return 0
+    if command == "orchestrate":
+        task = args.task or input("Task > ").strip()
+        print(orchestrate_text(context, task, files=args.file, execute=args.execute))
+        return 0
+    if command == "claude-install":
+        print(install_claude_templates_text(Path(args.target), force=args.force))
+        return 0
+    if command == "agent":
+        print(agent_prompt_text(context, args.name, " ".join(args.task)))
+        return 0
+
     raise SystemExit(f"unknown command: {command}")
-
-
-def run_tui(context: McpContext) -> None:
-    context.init_storage()
-    messages = ["AgentRAM terminal UI ready.", f"RAM root: {context.ram_root}"]
-    while True:
-        draw_screen(context, messages)
-        choice = input("You > ").strip()
-        if choice in {"0", "q", "quit", "exit"}:
-            return
-        handle_tui_choice(context, choice, messages)
-
-
-def handle_tui_choice(context: McpContext, choice: str, messages: list[str]) -> None:
-    try:
-        if choice == "1":
-            data = payload(call_tool(context, "agentram_init", {}))
-            created = data.get("created", [])
-            messages.append("Init: " + (", ".join(created) if created else "already ready"))
-        elif choice == "2":
-            messages.append(status_text(context))
-        elif choice == "3":
-            query = input("Query > ").strip()
-            data = payload(call_tool(context, "agentram_retrieve", {"query": query, "task_id": "codex", "limit": 8}))
-            messages.append(data.get("context") or "No matching memory.")
-        elif choice == "4":
-            data = payload(call_tool(context, "agentram_read_goal_state", {}))
-            messages.append(data.get("context") or "No goal stack yet.")
-        elif choice == "5":
-            update_goal_from_prompt(context, messages)
-        elif choice == "6":
-            task = input("Task > ").strip()
-            data = payload(call_tool(context, "agentram_check_goal_drift", {"task": task}))
-            messages.append(f"Drift: {data.get('status')} | aligned={data.get('aligned')} | {data.get('reason')}")
-        elif choice == "7":
-            events = context.event_log.read_all()
-            latest = events[-5:]
-            lines = [f"Events: {len(events)}"]
-            lines.extend(f"- {event.type.value} {event.payload}" for event in latest)
-            messages.append("\n".join(lines))
-        elif choice == "8":
-            data = payload(call_tool(context, "agentram_replay_events", {}))
-            messages.append(f"Replay: events={data.get('event_count', 0)} patches={data.get('patch_count', 0)} memory={data.get('memory_count', 0)}")
-        elif choice == "9" or not choice:
-            messages.append("Choose button number. Use retrieve before injecting context into agent prompt.")
-        else:
-            messages.append(f"Unknown button: {choice}")
-    except Exception as error:  # noqa: BLE001 - terminal boundary
-        messages.append(f"Error: {error}")
-    del messages[:-8]
-
-
-def update_goal_from_prompt(context: McpContext, messages: list[str]) -> None:
-    patch: dict[str, object] = {}
-    fields = ["mission", "project_goal", "current_milestone", "current_goal", "current_task"]
-    for field in fields:
-        value = input(f"{field} (blank skip) > ").strip()
-        if value:
-            patch[field] = value
-    next_tasks = input("next_tasks comma list (blank skip) > ").strip()
-    if next_tasks:
-        patch["next_tasks"] = [item.strip() for item in next_tasks.split(",") if item.strip()]
-    if not patch:
-        messages.append("Goal update skipped.")
-        return
-    data = payload(call_tool(context, "agentram_update_goal_state", patch))
-    messages.append(data.get("context") or "Goal updated.")
-
-
-def status_text(context: McpContext) -> str:
-    context.init_storage()
-    events = context.event_log.read_all()
-    items = context.memory_store.list_items()
-    goal_state = context.goal_store.load()
-    return "\n".join(
-        [
-            f"RAM root: {context.ram_root}",
-            f"Events: {len(events)}",
-            f"Memory items: {len(items)}",
-            f"Current goal: {goal_state.current_goal or '-'}",
-            f"Current task: {goal_state.current_task or '-'}",
-        ]
-    )
-
-
-def draw_screen(context: McpContext, messages: list[str]) -> None:
-    clear_terminal()
-    width = min(max(shutil.get_terminal_size((100, 30)).columns, 72), 120)
-    print(box_line("┌", "─", "┐", width))
-    print(box_text("AgentRAM CLI", width))
-    print(box_text(f"root: {context.ram_root}", width))
-    print(box_line("├", "─", "┤", width))
-    for line in menu_lines():
-        print(box_text(line, width))
-    print(box_line("├", "─", "┤", width))
-    chat_lines = wrap_messages(messages, width - 4)
-    visible = chat_lines[-14:]
-    for line in visible:
-        print(box_text(line, width))
-    for _ in range(max(0, 14 - len(visible))):
-        print(box_text("", width))
-    print(box_line("└", "─", "┘", width))
-
-
-def menu_lines() -> list[str]:
-    return [
-        "[1] Init RAM        [2] Status          [3] Retrieve",
-        "[4] Goal Show       [5] Goal Set        [6] Drift Check",
-        "[7] Events          [8] Replay          [9] Help       [0] Exit",
-    ]
-
-
-def wrap_messages(messages: list[str], width: int) -> list[str]:
-    lines: list[str] = []
-    for message in messages:
-        for raw_line in str(message).splitlines() or [""]:
-            wrapped = textwrap.wrap(raw_line, width=width, replace_whitespace=False) or [""]
-            lines.extend(wrapped)
-    return lines
-
-
-def box_line(left: str, fill: str, right: str, width: int) -> str:
-    return left + fill * (width - 2) + right
-
-
-def box_text(text: str, width: int) -> str:
-    return "│ " + text[: width - 4].ljust(width - 4) + " │"
-
-
-def clear_terminal() -> None:
-    os.system("cls" if os.name == "nt" else "clear")
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = build_parser().parse_args(argv)
-    return run_command(args)
-
-
-if __name__ == "__main__":
+
+
+def run_tui(context: McpContext) -> None:
+    context.init_storage()
+    messages = ["system > AgentRAM coding-agent CLI ready", f"system > RAM root: {context.ram_root}", "system > Type /help, /agent reviewer <task>, or plain coding request."]
+    while True:
+        draw_screen(context, messages)
+        user_input = input("You > ").strip()
+        if user_input in {"0", "q", "quit", "exit", "/exit", "/quit"}:
+            return
+        if user_input in BUTTONS:
+            user_input = BUTTONS[user_input]
+        if user_input:
+            messages.append(f"user > {user_input}")
+        response = handle_chat_input(context, user_input, messages)
+        if response == "__clear__":
+            messages.clear()
+            messages.append("system > Chat cleared.")
+        elif response:
+            messages.append("agentram > " + response)
+        del messages[:-10]
+
+
+def handle_chat_input(context: McpContext, text: str, messages: list[str] | None = None) -> str:
+    if not text:
+        return SLASH_HELP
+    if text.startswith("/"):
+        return handle_slash_command(context, text, messages)
+    call_tool(
+        context,
+        "agentram_emit_event",
+        {"type": "USER_MESSAGE", "payload": {"content": text}, "task_id": "codex", "ingest": False},
+    )
+    context_block = retrieve_text(context, text, task_id="codex", limit=6)
+    return "Coding chat captured. Relevant context:\n" + context_block
+
+
+def handle_slash_command(context: McpContext, text: str, messages: list[str] | None = None) -> str:
+    parts = shlex.split(text, posix=os.name != 'nt')
+    command = parts[0].lower()
+    rest = parts[1:]
+    raw_rest = text[len(parts[0]) :].strip()
+
+    if command == "/help":
+        return SLASH_HELP
+    if command == "/init":
+        return init_text(context)
+    if command == "/status":
+        return status_text(context)
+    if command == "/retrieve":
+        return retrieve_text(context, raw_rest, task_id="codex", limit=8)
+    if command == "/goal":
+        return goal_text(context)
+    if command == "/set-goal":
+        return set_goal_text(context, rest)
+    if command == "/drift":
+        return drift_text(context, raw_rest)
+    if command == "/events":
+        return events_text(context)
+    if command == "/replay":
+        return replay_text(context, {})
+    if command == "/agents":
+        return agents_text()
+    if command == "/models":
+        return models_text(context)
+    if command == "/bind-model":
+        if len(rest) < 2:
+            return "Usage: /bind-model <provider> <model> [role=coder] [base_url=...] [api_key_env=...] [modalities=text,image]"
+        options = {"provider": rest[0], "model": rest[1]}
+        for item in rest[2:]:
+            if "=" in item:
+                key, value = item.split("=", 1)
+                options[key.replace("-", "_")] = value
+        return bind_model_text(context, options)
+    if command == "/orchestrate":
+        return orchestrate_text(context, raw_rest, execute=False)
+    if command == "/agent":
+        if not rest:
+            return "Usage: /agent <memory|planner|reviewer|documenter> <task>"
+        return agent_prompt_text(context, rest[0], " ".join(rest[1:]))
+    if command == "/claude-install":
+        force = "--force" in raw_rest
+        target_text = raw_rest.replace("--force", "").strip().strip('"')
+        target = Path(target_text) if target_text else Path.cwd()
+        return install_claude_templates_text(target, force=force)
+    if command == "/note":
+        return note_text(context, raw_rest)
+    if command == "/clear":
+        return "__clear__"
+    return f"Unknown slash command: {command}\n\n{SLASH_HELP}"
+
+
+def init_text(context: McpContext) -> str:
+    data = payload(call_tool(context, "agentram_init", {}))
+    created = data.get("created", [])
+    return f"AgentRAM root: {data['ram_root']}\nCreated: {', '.join(created) if created else 'none'}"
+
+
+def status_text(context: McpContext) -> str:
+    context.init_storage()
+    events = context.event_log.read_all()
+    items = context.memory_store.list_items()
+    goal_state = context.goal_store.load()
+    return "\n".join(
+        [
+            f"RAM root: {context.ram_root}",
+            f"Events: {len(events)}",
+            f"Memory items: {len(items)}",
+            f"Mission: {goal_state.mission or '-'}",
+            f"Current goal: {goal_state.current_goal or '-'}",
+            f"Current task: {goal_state.current_task or '-'}",
+        ]
+    )
+
+
+def retrieve_text(context: McpContext, query: str, task_id: str = "codex", limit: int = 8) -> str:
+    if not query.strip():
+        return "Usage: /retrieve <query>"
+    data = payload(call_tool(context, "agentram_retrieve", {"query": query, "task_id": task_id, "limit": limit}))
+    return data.get("context") or "No matching memory."
+
+
+def goal_text(context: McpContext) -> str:
+    data = payload(call_tool(context, "agentram_read_goal_state", {}))
+    return data.get("context") or "No goal stack yet."
+
+
+def set_goal_text(context: McpContext, assignments: list[str]) -> str:
+    if not assignments:
+        return "Usage: /set-goal current_goal='Ship CLI' current_task='Add slash commands'"
+    patch: dict[str, object] = {}
+    for item in assignments:
+        if "=" not in item:
+            return f"Invalid assignment: {item}"
+        key, value = item.split("=", 1)
+        if key == "next_tasks":
+            patch[key] = [part.strip() for part in value.split(",") if part.strip()]
+        else:
+            patch[key] = value
+    data = payload(call_tool(context, "agentram_update_goal_state", patch))
+    return data.get("context") or "Goal updated."
+
+
+def drift_text(context: McpContext, task: str) -> str:
+    if not task.strip():
+        return "Usage: /drift <task>"
+    data = payload(call_tool(context, "agentram_check_goal_drift", {"task": task}))
+    lines = [f"Status: {data.get('status')}", f"Aligned: {data.get('aligned')}", f"Reason: {data.get('reason')}"]
+    if data.get("warning"):
+        lines.append(f"Warning: {data['warning']}")
+    return "\n".join(lines)
+
+
+def events_text(context: McpContext) -> str:
+    events = context.event_log.read_all()
+    latest = events[-8:]
+    lines = [f"Events: {len(events)}"]
+    lines.extend(f"- {event.type.value} {event.payload}" for event in latest)
+    return "\n".join(lines)
+
+
+def replay_text(context: McpContext, arguments: dict[str, object]) -> str:
+    data = payload(call_tool(context, "agentram_replay_events", arguments))
+    return f"Events: {data.get('event_count', 0)}\nPatches: {data.get('patch_count', 0)}\nMemory items: {data.get('memory_count', 0)}"
+
+
+def agents_text() -> str:
+    lines = ["Subagent presets:"]
+    lines.extend(f"- {name}: {description}" for name, description in SUBAGENTS.items())
+    return "\n".join(lines)
+
+
+def agent_prompt_text(context: McpContext, name: str, task: str) -> str:
+    if name not in SUBAGENTS:
+        return f"Unknown subagent: {name}\n\n{agents_text()}"
+    memory = retrieve_text(context, task or name, task_id="codex", limit=6) if task else goal_text(context)
+    return "\n".join(
+        [
+            f"Subagent: {name}",
+            f"Role: {SUBAGENTS[name]}",
+            f"Task: {task or '-'}",
+            "Context:",
+            memory,
+            "Output contract:",
+            "- Return concise findings.",
+            "- Mention files touched or inspected.",
+            "- Do not invent facts outside repo/RAM.",
+        ]
+    )
+
+
+
+
+def models_text(context: McpContext) -> str:
+    data = payload(call_tool(context, "agentram_read_coding_models", {}))
+    endpoints = data.get("endpoints", [])
+    if not endpoints:
+        return "No coding models bound. Use /bind-model claude claude-3-5-sonnet-latest role=reviewer api_key_env=ANTHROPIC_API_KEY"
+    lines = ["Bound coding models:"]
+    for endpoint in endpoints:
+        lines.append(f"- {endpoint.get('id')} provider={endpoint.get('provider')} model={endpoint.get('model')} role={endpoint.get('role')} modalities={','.join(endpoint.get('modalities', []))}")
+    return "\n".join(lines)
+
+
+def bind_model_text(context: McpContext, options: dict[str, object]) -> str:
+    modalities_value = str(options.get("modalities", "text"))
+    arguments = {
+        "id": str(options.get("id", "")) or None,
+        "provider": str(options.get("provider", "openai-compatible")),
+        "model": str(options.get("model", "")),
+        "role": str(options.get("role", "coder")),
+        "base_url": str(options.get("base_url", "")),
+        "api_key_env": str(options.get("api_key_env", "")),
+        "modalities": [item.strip() for item in modalities_value.split(",") if item.strip()],
+        "enabled": bool(options.get("enabled", True)),
+    }
+    arguments = {key: value for key, value in arguments.items() if value is not None}
+    data = payload(call_tool(context, "agentram_bind_coding_model", arguments))
+    endpoint = data.get("endpoint", {})
+    return f"Bound model: {endpoint.get('id')} provider={endpoint.get('provider')} model={endpoint.get('model')} role={endpoint.get('role')}"
+
+
+def orchestrate_text(context: McpContext, task: str, files: list[str] | None = None, execute: bool = False) -> str:
+    if not task.strip():
+        return "Usage: /orchestrate <coding task>"
+    tool = "agentram_run_coding_orchestration" if execute else "agentram_build_coding_orchestration"
+    data = payload(call_tool(context, tool, {"task": task, "files": files or [], "execute": execute}))
+    if not execute:
+        lines = [f"Orchestration plan: agents={data.get('agent_count', 0)}"]
+        for agent in data.get("agents", []):
+            endpoint = agent.get("endpoint", {})
+            lines.append(f"- {endpoint.get('id')} {endpoint.get('provider')}:{endpoint.get('model')} role={endpoint.get('role')}")
+        return "\n".join(lines)
+    lines = [f"Orchestration run: agents={data.get('agent_count', 0)}"]
+    for result in data.get("results", []):
+        endpoint = result.get("endpoint", {})
+        status = "ok" if result.get("ok") else "error"
+        output = result.get("output") or result.get("error", "")
+        lines.append(f"- {endpoint.get('id')} {status}: {str(output)[:300]}")
+    return "\n".join(lines)
+
+def claude_template_root() -> Path:
+    return Path(__file__).resolve().parent.parent / ".claude"
+
+
+def install_claude_templates_text(target: Path, force: bool = False) -> str:
+    source_root = claude_template_root()
+    if not source_root.exists():
+        return f"Claude templates not found: {source_root}"
+    target_root = target.resolve() / ".claude"
+    copied: list[str] = []
+    skipped: list[str] = []
+    for source in source_root.rglob("*.md"):
+        relative = source.relative_to(source_root)
+        destination = target_root / relative
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        if destination.exists() and not force:
+            skipped.append(str(destination))
+            continue
+        destination.write_text(source.read_text(encoding="utf-8"), encoding="utf-8")
+        copied.append(str(destination))
+    lines = [f"Claude templates target: {target_root}", f"Copied: {len(copied)}", f"Skipped: {len(skipped)}"]
+    if copied:
+        lines.append("Installed:")
+        lines.extend(f"- {item}" for item in copied)
+    if skipped:
+        lines.append("Skipped existing files. Use --force to overwrite.")
+    return "\n".join(lines)
+
+def note_text(context: McpContext, content: str) -> str:
+    if not content.strip():
+        return "Usage: /note <decision or fact>"
+    data = payload(call_tool(context, "agentram_emit_event", {"type": "DECISION", "payload": {"content": content}, "task_id": "codex", "ingest": True}))
+    ingest = data.get("ingest") or {}
+    return f"Note saved. Patches: {ingest.get('patch_count', 0)}"
+
+
+def update_goal_from_prompt(context: McpContext, messages: list[str]) -> None:
+    patch: dict[str, object] = {}
+    fields = ["mission", "project_goal", "current_milestone", "current_goal", "current_task"]
+    for field in fields:
+        value = input(f"{field} (blank skip) > ").strip()
+        if value:
+            patch[field] = value
+    next_tasks = input("next_tasks comma list (blank skip) > ").strip()
+    if next_tasks:
+        patch["next_tasks"] = [item.strip() for item in next_tasks.split(",") if item.strip()]
+    if not patch:
+        messages.append("Goal update skipped.")
+        return
+    data = payload(call_tool(context, "agentram_update_goal_state", patch))
+    messages.append(data.get("context") or "Goal updated.")
+
+
+BUTTONS = {
+    "1": "/init",
+    "2": "/status",
+    "3": "/retrieve",
+    "4": "/goal",
+    "5": "/set-goal",
+    "6": "/drift",
+    "7": "/events",
+    "8": "/replay",
+    "9": "/help",
+}
+
+
+def draw_screen(context: McpContext, messages: list[str]) -> None:
+    clear_terminal()
+    width = min(max(shutil.get_terminal_size((110, 34)).columns, 86), 132)
+    left_width = 30
+    right_width = width - left_width - 3
+    print("+" + "-" * (width - 2) + "+")
+    print(box_text("AgentRAM Code Agent CLI  |  RAM + Claude subagents + slash commands", width))
+    print("+" + "-" * (width - 2) + "+")
+
+    sidebar = sidebar_lines(context)
+    chat = wrap_messages(messages, right_width - 4)[-22:]
+    rows = max(len(sidebar), len(chat), 22)
+    for index in range(rows):
+        left = sidebar[index] if index < len(sidebar) else ""
+        right = chat[index] if index < len(chat) else ""
+        print("| " + left[: left_width - 2].ljust(left_width - 2) + "| " + right[: right_width - 2].ljust(right_width - 2) + "|")
+    print("+" + "-" * (left_width - 1) + "+" + "-" * (right_width) + "+")
+    print(box_text("Input: plain coding request, /help, /agent reviewer <task>, /claude-install .", width))
+    print("+" + "-" * (width - 2) + "+")
+
+
+def sidebar_lines(context: McpContext) -> list[str]:
+    context.init_storage()
+    events = context.event_log.read_all()
+    items = context.memory_store.list_items()
+    goal = context.goal_store.load()
+    return [
+        "MODE",
+        "  coding-agent TUI",
+        "",
+        "RAM",
+        f"  events: {len(events)}",
+        f"  notes:  {len(items)}",
+        "",
+        "GOAL",
+        f"  {trim(goal.current_goal or '-', 24)}",
+        "",
+        "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",
+        "  /claude-install .",
+        "  /models",
+        "  /bind-model claude <model>",
+        "  /orchestrate <task>",
+    ]
+
+
+def trim(text: str, limit: int) -> str:
+    return text if len(text) <= limit else text[: limit - 1] + "…"
+
+
+def menu_lines() -> list[str]:
+    return [
+        "1=/init 2=/status 3=/retrieve 4=/goal 5=/set-goal 6=/drift 7=/events 8=/replay 9=/help",
+        "Plain text captures coding request. Claude: /claude-install ., /agents, /agent reviewer <task>",
+    ]
+
+
+def wrap_messages(messages: list[str], width: int) -> list[str]:
+    lines: list[str] = []
+    for message in messages:
+        for raw_line in str(message).splitlines() or [""]:
+            wrapped = textwrap.wrap(raw_line, width=width, replace_whitespace=False) or [""]
+            lines.extend(wrapped)
+    return lines
+
+
+def box_line(left: str, fill: str, right: str, width: int) -> str:
+    return left + fill * (width - 2) + right
+
+
+def box_text(text: str, width: int) -> str:
+    return "| " + text[: width - 4].ljust(width - 4) + " |"
+
+
+def clear_terminal() -> None:
+    os.system("cls" if os.name == "nt" else "clear")
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    return run_command(args)
+
+
+if __name__ == "__main__":
     raise SystemExit(main())