Retrieve a specific coding session by ID (a memory_search record's session_id, a list_recent_conversations code row's id): its user-spine turns (what the human asked/decided/corrected), files touched, and per-session summary. To read the turns around a record, pass its session_id as id and its turn_idx as turn: you get only turns turn-window..turn+window (window default 8, max 40; max_chars default 12000 here) with focus {turn, window, first_idx, last_idx, total_turns}; prev_start/next_start, passed as start (without turn), read the turns before/after; start reads forward from there with the default 60000 chars. Whole-session paging below is the fallback. Long sessions come in parts: each call returns the session metadata and summary plus whole turns from start up to about max_chars of turn text (default 60000), with total_turns, total_chars, returned {start, end (exclusive)} and next_start. files_touched is on the first part only (up to 200 paths; files_touched_total and files_touched_omitted give the rest's count). When next_start is not null, call get_code_session again with the same id and start=next_start until next_start is null to read every turn. The first part also lists sub_agents: the sub-agent sessions this session spawned (id, agent_type, description, started_at, ended_at, turn_count, brief = first 160 chars of the task it was given; at most 200, sub_agents_total gives the full count); open one with get_code_session id=. When this session is itself a sub-agent, parent_session_id is the id of the session that spawned it. Use it to read what was actually said; use session_summary for a short threaded overview of the same session. Results are dated records of what sessions did, not the current state of a PR or issue; check that live.

Retrieve a specific conversation by ID with its messages. Long conversations come in parts: each call returns whole messages from start up to about max_chars of content (default 60000), plus total_messages, total_chars, returned {start, end (exclusive)} and next_start. When next_start is not null, call get_conversation again with the same id and start=next_start until next_start is null to read the whole conversation. Tool calls/results are replaced by short stubs by default (see include_tool_io) so tool-heavy chats don't overflow the part budget.

List the user's coding-agent projects (repos worked on via Claude Code etc.) with a rollup summary, session count, and last-active time

List the user's recent sessions — chats AND coding sessions (Claude Code, opencode, Copilot CLI, Codex; main sessions, not sub-agents) — from the last few days by default, newest first, metadata only. Chat rows (type "chat"): id, title, source, created_at, updated_at, message_count. Code rows (type "code"): id, project_name, git_branch, source, started_at, ended_at, turn_count, summary (up to 200 chars). Defaults to the last 7 days and both kinds. Use it to find something by when it happened (e.g. yesterday's chat → since = yesterday's date, kind = chat), then open a chat with get_conversation id= or a coding session with get_code_session id=; both return long results in parts. Results are dated records of what sessions did, not the current state of a PR or issue; check that live.

Recall memory records BY REPO OR PATH (not by topic -- use memory_search for that). 'outcome' alone answers 'what shipped here lately'. Ordered kind-priority then recency. Read the turns around a record with get_code_session id=<session_id> turn=<turn_idx>. Records carry links to their sources when known: sha (the commit the session was on), paths (files it names, up to 5), ref_url (the ref's forge page). Open them directly; they locate sources, they do not report current state. Replaced records are hidden and paraphrases of one fact are served once with seen_in; every record carries as_of.

Mark a blocker as fixed. Call this right after you fix a blocker that Membral showed you (in the preamble, memory_search or memory_recall); quote your own or the user's message text that states the fix (not tool output, which is not stored). The blocker and its repeats are closed for every later session; the owner can restore it. The quote is checked against this session's transcript when it uploads and kept as the receipt. Only your own open blockers can be resolved.

Search past sessions' learnings, decisions, blockers and other memory records by TOPIC (Postgres full-text search fused with semantic similarity) -- the tool for 'what did we decide/learn about X'. Filter by kind, scope, project, path, or since/days. A date phrase in the query ("last week", "yesterday", "Sept 20") is read as a time hint: it is taken out of the search text and records from that window rank higher, but older matches still come back (date_hint shows the reading); since/days are hard filters. Newer records win near-ties. since/days filter on the session's start time; each record's when is its session's end time (else start). Covers extracted, quote-verified records (extraction runs on sessions within about 30 days of upload; older extracted records stay searchable); a fact that was said but never extracted is only in the raw turns (search_conversations). When nothing is relevant enough, reason says why -- that is the answer, not an error. Records a newer record replaced are hidden unless include_superseded is true or the query names a past date; paraphrases of one fact are served as one record with seen_in (the number of sessions that said it); every record carries as_of, the day its session recorded it (true when recorded, not current state). Local installs return served: lines (records as JSON, raw session excerpts marked "raw excerpt") packed whole to max_tokens (default 3000). Else (hosted; raw_reason says why) ranked records cut at max_tokens (dropped_for_budget). A record's session_id is a code session: read the turns around it with get_code_session id=<session_id> turn=<turn_idx>, or session_summary session_id=<session_id>. Records carry links to their sources when known: sha (the commit the session was on), paths (files it names, up to 5), ref_url (the ref's forge page). Open them directly; they locate sources, they do not report current state. Results are dated records of what sessions did, not the current state of a PR or issue; check that live.

Search the user's synced conversations AND coding-agent sessions by keyword and semantic similarity — results are tagged source_type (chat/code) and, when a matching chunk exists, resolve to the specific message span inside the conversation rather than just its title. To find a chat or session from a specific time, pass since (or days): e.g. yesterday's chat about X → query = X, since = yesterday's date. To browse recent activity with no query, use list_recent_conversations. Hits are raw text as said, not extracted, checked or versioned: true when said, not current truth; for decisions, learnings and outcomes use memory_search. Results are dated records of what sessions did, not the current state of a PR or issue; check that live.

Get one coding session's header (repo, branch, turns, models, files touched) and its JOURNEY: threads in order from the first prompt, each with its records (outcomes first) and files touched in that range. Use it for the short story of a session (what it set out to do and what it found); use get_code_session when you need the actual turns, e.g. the exact words around a memory_search record. Results are dated records of what sessions did, not the current state of a PR or issue; check that live.