agentram 0.1.0 → 0.1.1

package/.claude/agents/agentram-docs.md

@@ -0,0 +1,18 @@
+---
+name: agentram-docs
+description: Updates or reviews docs from AgentRAM memory and current repo state.
+tools: Read, Grep, Glob, Edit, mcp__agentram__agentram_retrieve
+---
+
+You are AgentRAM Docs Subagent.
+
+Scope:
+- Read current README/docs.
+- Pull relevant AgentRAM notes.
+- Update usage docs for commands, MCP, npm, and integrations.
+
+Rules:
+- Keep docs runnable.
+- Prefer short examples.
+- Do not expose secrets.
+- Mention Python 3.10+ requirement for npm wrapper.

package/.claude/agents/agentram-memory.md

@@ -0,0 +1,20 @@
+---
+name: agentram-memory
+description: Records decisions, files, task state, and risks into AgentRAM. Use after major coding actions or before context compaction.
+tools: Read, Grep, Glob, mcp__agentram__agentram_emit_event, mcp__agentram__agentram_retrieve
+---
+
+You are AgentRAM Memory Subagent.
+
+Scope:
+- Observe coding work.
+- Extract durable notes: decisions, file changes, task state, open questions, risks.
+- Write notes through `agentram_emit_event`.
+- Do not edit code.
+
+Rules:
+- Use only facts visible in repo, tool results, or conversation.
+- Keep notes short.
+- Include file paths when known.
+- Prefer `ingest: true` for important decisions.
+- Prefer `ingest: false` for noisy chat/tool events.

package/.claude/agents/agentram-planner.md

@@ -0,0 +1,18 @@
+---
+name: agentram-planner
+description: Builds task plans using AgentRAM Goal Stack and checks drift before scope changes.
+tools: Read, Grep, Glob, mcp__agentram__agentram_retrieve, mcp__agentram__agentram_check_goal_drift, mcp__agentram__agentram_update_goal_state
+---
+
+You are AgentRAM Planner Subagent.
+
+Scope:
+- Read Goal Stack first.
+- Check whether requested task aligns with mission/current goal/current task.
+- Produce small ordered implementation plan.
+- Update Goal Stack only when user intent is clear.
+
+Rules:
+- No code edits.
+- No broad refactors unless current goal requires them.
+- If drift risk appears, ask for confirmation.

package/.claude/agents/agentram-reviewer.md

@@ -0,0 +1,18 @@
+---
+name: agentram-reviewer
+description: Reviews changed code against AgentRAM context, tests, and goal drift.
+tools: Read, Grep, Glob, mcp__agentram__agentram_retrieve, mcp__agentram__agentram_check_goal_drift
+---
+
+You are AgentRAM Reviewer Subagent.
+
+Scope:
+- Review current changes.
+- Compare implementation to Goal Stack and RAM notes.
+- Find correctness gaps, missing tests, risky assumptions, and docs drift.
+
+Rules:
+- Return concise findings.
+- Cite file paths.
+- Separate blockers from non-blockers.
+- Do not edit code.

package/.claude/commands/ram-drift.md

@@ -0,0 +1,11 @@
+---
+description: Check whether current task drifts from AgentRAM Goal Stack.
+argument-hint: [task]
+---
+
+Check AgentRAM goal drift.
+
+1. Call MCP tool `agentram_check_goal_drift` with `task`: `$ARGUMENTS`.
+2. If `status` is `ok`, continue.
+3. If `status` is `drift_risk`, ask user to confirm scope change or update Goal Stack.
+4. Do not suggest extra next actions when AgentRAM returns `next_actions: []`.

package/.claude/commands/ram-note.md

@@ -0,0 +1,17 @@
+---
+description: Save a decision or important fact into AgentRAM.
+argument-hint: [note]
+---
+
+Save this note to AgentRAM.
+
+Call MCP tool `agentram_emit_event` with:
+
+```json
+{
+  "type": "DECISION",
+  "payload": {"content": "$ARGUMENTS"},
+  "task_id": "codex",
+  "ingest": true
+}
+```

package/.claude/commands/ram-status.md

@@ -0,0 +1,10 @@
+---
+description: Show AgentRAM status and Goal Stack.
+---
+
+Show AgentRAM project memory status.
+
+1. Call `agentram_init` if files do not exist.
+2. Call `agentram_read_goal_state`.
+3. Call `agentram_read_task_state` with `task_id`: `codex`.
+4. Summarize current goal, current task, and recent memory notes.

package/.claude/commands/ram.md

@@ -0,0 +1,14 @@
+---
+description: Retrieve AgentRAM context before coding.
+argument-hint: [query]
+---
+
+Use AgentRAM before coding.
+
+1. Call MCP tool `agentram_retrieve` with:
+   - `query`: `$ARGUMENTS`
+   - `task_id`: `codex`
+   - `limit`: `8`
+2. Read Goal Stack first.
+3. Use returned RAM notes as extra context.
+4. If no notes exist, continue normally and emit new events after important actions.

package/README.md

@@ -65,6 +65,12 @@ Equivalent explicit command:
 agentram tui
 ```
 
+Install Claude Code commands and subagents into the current project:
+
+```bash
+agentram claude-install --target .
+```
+
 Buttons inside the UI:
 
 ```text
@@ -153,6 +159,66 @@ If `python` is not the right binary, set `PYTHON`:
 ```bash
 PYTHON=python3 npx agentram status
 ```
+
+## Coding TUI, Slash Commands, And Subagents
+
+AgentRAM TUI now behaves like a coding-agent CLI inspired by `freecodexyz/free-code`: left status panel, chat transcript, slash command registry, RAM tool calls, and Claude subagent prompt templates.
+
+Run TUI:
+
+```bash
+agentram tui
+```
+
+Supported TUI slash commands:
+
+```text
+/help
+/init
+/status
+/retrieve <query>
+/goal
+/set-goal current_goal="Ship CLI" current_task="Add slash commands"
+/drift <task>
+/events
+/replay
+/agents
+/agent reviewer <task>
+/claude-install .
+/note <decision>
+/clear
+/exit
+```
+
+Claude Code repo templates are included:
+
+```text
+.claude/commands/ram.md
+.claude/commands/ram-drift.md
+.claude/commands/ram-note.md
+.claude/commands/ram-status.md
+.claude/agents/agentram-memory.md
+.claude/agents/agentram-planner.md
+.claude/agents/agentram-reviewer.md
+.claude/agents/agentram-docs.md
+```
+
+Usage inside Claude Code:
+
+```text
+/ram adapter memory writer
+/ram-drift refactor MCP server
+/ram-note Use npm wrapper only as Python launcher.
+/ram-status
+```
+
+Subagent intent:
+
+- `agentram-memory`: records durable notes, no code edits.
+- `agentram-planner`: checks Goal Stack and plans work.
+- `agentram-reviewer`: reviews changes against RAM and goal drift.
+- `agentram-docs`: updates docs from repo state and RAM notes.
+
 ## Install In Coding Agents
 
 ### Codex MCP

package/agentram/cli.py

@@ -1,242 +1,459 @@
-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
+/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.")
+
+    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 == "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 == "/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 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 .",
+        "  /agents",
+        "  /agent reviewer <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())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentram",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Async, model-agnostic Working RAM for coding agents.",
   "license": "MIT",
   "homepage": "https://github.com/trancongnghia/AGENT_RAM#readme",
@@ -33,6 +33,8 @@
   "files": [
     "agentram/*.py",
     "bin/*.js",
+    ".claude/agents/*.md",
+    ".claude/commands/*.md",
     "agentram_mcp_server.py",
     "agentram_daemon.py",
     "codex_ram.py",

package/pyproject.toml

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