explore

# Memory Exploration (RLM-style)

Instead of injecting top-k memories, explore the memory graph dynamically.

## How It Works

1. Start with a query
2. Get initial hints via `explore_recall`
3. Iteratively decide: peek, expand, follow neighbors, or answer
4. Accumulate relevant findings
5. Answer when sufficient context gathered

## Exploration Protocol

You have these primitives (via chitta RPC):

| Tool | Purpose | Token Cost |
|------|---------|------------|
| `explore_recall` | Semantic search, returns hints (id, title, score) | ~100 |
| `explore_peek` | Get 200-char summary of a memory | ~50 |
| `explore_expand` | Get full memory content | ~200-500 |
| `explore_neighbors` | Get triplet connections from a node | ~100 |

## Agent Loop

```
query = user's question
context = []
trace = []
max_iterations = 10

# Initial hints
hints = explore_recall(query, limit=5)
trace.append(("recall", query, hints))

for i in range(max_iterations):
    # Decide next action based on query + current context
    action = decide_action(query, context, hints)

    if action == "ANSWER":
        break
    elif action.startswith("PEEK"):
        id = extract_id(action)
        summary = explore_peek(id)
        context.append(summary)
        trace.append(("peek", id, summary))
    elif action.startswith("EXPAND"):
        id = extract_id(action)
        full = explore_expand(id)
        context.append(full)
        trace.append(("expand", id, len(full)))
    elif action.startswith("NEIGHBORS"):
        node = extract_node(action)
        neighbors = explore_neighbors(node)
        hints.extend(relevant_neighbors(neighbors))
        trace.append(("neighbors", node, len(neighbors)))
    elif action.startswith("RECALL"):
        new_query = extract_query(action)
        new_hints = explore_recall(new_query, limit=5)
        hints.extend(new_hints)
        trace.append(("recall", new_query, new_hints))

# Generate answer from accumulated context
answer = synthesize(query, context)
return a