원클릭으로
explore
RLM-style recursive memory exploration - dynamically navigate the memory graph
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
메뉴
RLM-style recursive memory exploration - dynamically navigate the memory graph
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
Trigger autonomous curiosity-driven exploration. The soul picks a topic from memory gaps or curiosity seeds, searches the web, and stores what it finds as dream-tagged memories.
Fine-tune the Qwen3-0.6B hint model — corpus gen, LoRA/unsloth, GGUF export, Ollama
Review soul discoveries (fixes, improvements, corrections) one by one, accept or discard each, implement accepted ones, build chitta, and optionally release.
First-principles review — question requirements, delete unnecessary parts, simplify, optimize with evidence, automate last. Use for code review, refactor, performance, or architecture.
Token-savvy session continuation. Rebuilds working context from transcript + soul memories in ~1500 tokens instead of replaying full history. Use when starting a new session to continue previous work.
Resume a thread by loading its ~800-token context capsule
SOC 직업 분류 기준
| name | explore |
| description | RLM-style recursive memory exploration - dynamically navigate the memory graph |
| execution | inline |
| model | inherit |
| aliases | ["deep-recall","rlm"] |
Instead of injecting top-k memories, explore the memory graph dynamically.
explore_recallYou 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 |
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 answer, trace
At each iteration, decide:
Query: {query}
Current context ({len(context)} items):
{format_context(context)}
Available hints:
{format_hints(hints)}
Recent trace:
{format_trace(trace[-3:])}
What should I explore next?
- PEEK(id) - get summary of a promising hint
- EXPAND(id) - get full content (use sparingly)
- NEIGHBORS(node) - explore triplet connections
- RECALL("query") - search for more hints
- ANSWER - I have enough context
Respond with just the action, e.g.: PEEK(00000000-0000-0000-0000-0000000001bd)
Use /explore instead of regular recall when:
When user invokes /explore <query>:
explore_recall with the queryPEEK(id) if a hint looks promising but need more infoEXPAND(id) if confident this memory is highly relevantNEIGHBORS(node) if you want to follow relationshipsRECALL("new query") if you need different search termsANSWER if you have enough contextShow at the end:
User: /explore How does the daemon handle authentication?
Claude: Starting exploration for "How does the daemon handle authentication?"
[Step 1] explore_recall("daemon authentication")
Found 5 hints:
[45%] id:123 - [mcp] cc-soul socket connection
[38%] id:456 - [wisdom] JSON-RPC protocol
[32%] id:789 - Unix socket permissions
...
[Step 2] PEEK(123) - socket connection looks relevant
Summary: "cc-soul daemon uses Unix socket at /tmp/chitta-*.sock..."
[Step 3] NEIGHBORS("daemon")
Found: daemon → uses → json_rpc
daemon → listens_on → unix_socket
[Step 4] EXPAND(456) - JSON-RPC protocol details needed
Full content loaded (342 chars)
[Step 5] ANSWER - have enough context
=== Answer ===
The daemon uses Unix socket authentication via file permissions.
No explicit auth - relies on filesystem access control to /tmp/chitta-*.sock.
=== Exploration Trace ===
1. recall("daemon authentication") → 5 hints
2. peek(123) → 200 chars
3. neighbors("daemon") → 5 connections
4. expand(456) → 342 chars
Tokens: ~692 exploration vs ~1500 full_resonate (54% savings)
Use these chitta commands during exploration:
# Lightweight recall
chitta explore_recall --query "your search" --limit 5
# Peek at summary
chitta explore_peek --id "00000000-0000-0000-0000-000000000123"
# Full content
chitta explore_expand --id "00000000-0000-0000-0000-000000000123"
# Graph neighbors
chitta explore_neighbors --node "Mind" --direction both