Reading the log

Stats glossary.

Every term shown by captain-memo stats and the live captain-memo top dashboard, plus the vocabulary behind Virtual Skills, Virtual Capabilities, the work board and homework. Each definition describes what the product actually stores or computes — not a paraphrase.

observations your sessions, distilled◆ recall how they get used◆ Tide how they earn permanence

The hold

Corpus

The size of the searchable index, in chunks — embedding-sized pieces of text.

memory: Chunks from the memory channel — things you explicitly remembered, plus promoted facts.
observation: Chunks from observations — the summarizer-distilled summaries of past sessions (Claude Code + captured cross-AI tools).
skill: Chunks from synchronized Virtual Skills — complete reusable instructions discovered from the AI tools installed on this machine. The original skill file remains canonical.
capability: Chunks from Virtual Capabilities — sanitized descriptions of plugins and extensions, including which AI runtime owns them and can execute their operations.
Total: Total chunks in the vector index, across all channels.

Cross-AI observation capture

Native lifecycle capture

How supported AI CLIs write observations as they work, without giving up compatibility with older sessions.

native lifecycle capture: Prompt recall, tool-result observation capture and turn-end flushing delivered through an AI CLI's own hook events. Captain Memo currently capability-gates this path for supported Codex, Gemini CLI and Kimi releases.
native session: A session whose native tool event has been successfully accepted by the worker. Merely installing or detecting hooks does not make a session native.
fallback capture: The existing transcript, rollout or conversation reader. It remains active until native delivery is proven for that exact session, so old, disabled, untrusted or failed hook setups keep producing observations.
PostToolUse / AfterTool: The vendor lifecycle event emitted after an AI tool completes. Captain Memo turns useful file changes and command evidence from this event into observations with explicit origin provenance.
capture.native: The stats object counting proven native sessions by source: codex, gemini and kimi. It is evidence of successful delivery, not just configuration.
host-agent capture: Capture through the agent that owns the conversation and tool loop. Ollama supplies models and tool calling rather than the outer lifecycle, so Captain Memo observes the connected host agent instead.

Read the complete compatibility model on How native lifecycle capture works.

The crew's library and route map

Virtual Skills & Capabilities

Skills answer “how do we do this?” Capabilities answer “which AI can actually run it?” Both catalogs live in Captain Memo's local SQLite corpus and synchronize automatically from their native sources.

Virtual Skill: A complete, reusable instruction document imported from an installed AI tool's skill directory. Any connected AI can discover, recommend and load the instructions even when the native skill belongs to another CLI.
skill source / canonical file: The original SKILL.md (or equivalent supported skill document) owned by Claude Code, Codex, Gemini, Cursor, opencode, Vibe, Kimi or another discovered tool. Captain Memo mirrors it; edits and deletions at the source update the catalog.
list_skills / recommend_skills / load_skill: The MCP flow for enumerating the repository, finding instructions relevant to a task, and opening the selected skill in full. Humans can inspect the same catalog with captain-memo skill list.
Virtual Capability: A non-executable descriptor saying that a named plugin or extension exists on a particular AI runtime, what operations it advertises, and where work using it should be routed.
owning runtime: The concrete AI CLI that installed and can execute the capability — for example Gemini/Agy for an image-generation extension. Discovery does not make that plugin executable inside every other CLI.
sanitized descriptor: The safe catalog record Captain Memo stores: name, description, version, operation and interface names, provider, and owning runtime. Command bodies, executable configuration, arguments, environment values, and credentials are never imported.
list_capabilities / recommend_capabilities / get_capability: The MCP flow for enumerating available runtime tools, finding the best execution route for a task, and inspecting one descriptor. Humans can use captain-memo capability list and captain-memo capability recommend.
fleet route: In Captain Fleet, a capability recommendation also identifies the captain that owns it. Another AI can delegate the task to that runtime and machine while the plugin, its configuration, and its secrets stay at the source.

For the complete lifecycle, privacy boundary and examples, read How Virtual Skills & Capabilities work.

Sharing the deck

Work board & homework

Two ways the sessions on one machine keep out of each other's way. The work board says what a session is doing now; homework holds what is for later.

work board: The live list of work claims on this machine. Before an edit, a Claude Code, Codex or Gemini session claims the files it touches; any assistant can post a claim with work_set. A session is warned when another overlaps it by path, git checkout, topic or meaning. A live claim blocks another session's edit, file-writing shell command or upload of the same file until it goes quiet for 10 minutes or you type override: <file>. Only Claude Code, Codex and Gemini sessions are guarded, and Codex and Gemini claims block on Linux; a claim posted by any other assistant only warns.
work claim: What one session is doing right now, held on a lease that expires by itself (30 minutes unless work_set asks for between 1 minute and 8 hours). A crashed session cannot hold a file for long: its claim stops blocking once its process has exited, goes stale after 10 minutes without an edit, and expires at the end of its lease.
override: <file>: Typed by you as the first line of your own message, it lifts the work-board block on that file for the session you typed it in, for 30 minutes. Only a typed message counts, and the override shows on the work board. CAPTAIN_MEMO_WORKBOARD_ENFORCE=0 in the host's settings env turns blocking off altogether.
topics: One to five short kebab-case tags for what the work is about. Two sessions holding the same topic are flagged whatever files they touch. Since 0.44.3, the topics and description a session declared with work_set survive its later edits until that declaration's lease ends.
whole-repo claim: A claim on <repo>/**, which older versions left when a shell edit's file could not be named. Since 0.51.0 such an edit records only that the session works in the repository, and a whole-repo claim no longer raises an overlap warning.
work_set / work_active / work_clear: Post or renew a claim; list the live claims and topic_contention (every topic two or more sessions hold, with who); drop your claim when done.
homework item: An idea or task parked for later on this machine, numbered #N. Numbers come from a counter on this machine and are never reused. Not a memory (a fact) and not a work claim (now).
filing prefix: idea:, todo:, homework:, later:, идея: or за после: at the start of a prompt, with a colon, hyphen or em dash as the separator and any case. Where a prompt hook is wired, it files the rest of the prompt as the item and skips recall for that prompt.
filed line: The one line the hook puts in front of the model: 📝 Filed as homework #N on this captain (not for now): … with the open count. The prompt still reaches the model, which usually answers “noted”.
due / ⏰: An optional time on an item (todo_add's due: an ISO date or date-time, read in this machine's local time unless it carries its own zone; a bare date means its midnight). From then on it leads the open list shown at session start in Claude Code (the banner) and in Codex and Gemini CLI (model context), marked ⏰ and DUE since …; every assistant can read the time through todo_list, which shows it in UTC. A reminder, not a job: nothing starts on its own. Needs Captain Memo 0.56.0 or later; the Codex and Gemini start list needs 0.57.11 or later.
open / claimed / done: The lifecycle. A claimed item is still open, shown as claimed by a session; the claim is advisory, never expires, and a second claim replaces it. The holder can hand it back with todo_unclaim; another session's claim is refused. Done items stay listable for 7 days.
todo_add / todo_list / todo_claim / todo_unclaim / todo_done: File an item (text, optional topics, project and due time); list the open, done or all items; mark one taken; hand your own claim back without closing the item; close it with a note. Claude Code also shows the open count and up to three items in its session banner, and Codex and Gemini CLI sessions get up to six open items added to their context at session start. todo_unclaim needs Captain Memo 0.57.0 or later; the Codex and Gemini start list needs 0.57.11 or later.

For who files it on each assistant, what the session sees and the honest limits, read How homework works.

Ship's economy

Efficiency

How economical the pipeline is — how much raw material is compressed, and how much re-work is avoided.

Compression: raw session tokens ÷ stored observation tokens. 7.7× means the stored memory is 7.7× smaller than the material it was distilled from.
distilled A → B tok: The raw work tokens (A) the summarizer read, versus the tokens (B) it actually stored. The saved % is 1 − B/A.
Embedder: Embedding-API activity since the worker started: number of calls, average latency, throughput (tokens/sec).
Embed tokens: Tokens sent to the embedder since the worker started (the indexer and every search reader added up) and how many of them went to requests that never got an answer; 0 wasted when none did. Needs Captain Memo 0.57.4 or later; the search readers are counted from 0.57.5.
embedding paused: embedding paused until HH:MM in at least one engine: embedding stopped for 30 minutes because more than 500,000 tokens in an hour went to requests that never got an answer. The indexer and each search reader pause on their own, captain-memo doctor names it, and CAPTAIN_MEMO_EMBEDDER_WASTE_LIMIT_TOKENS changes the limit (0 turns the pause off).
Dedup (re-index): Share of documents skipped on re-index because their content hash was unchanged — work avoided. 42% 8 / 19 unchanged = 8 of 19 re-seen docs needed no re-embed. Not the consolidation pass of the same name, which is under Housekeeping.
Last Nm: Fresh input plus output tokens the Claude Code sessions on this machine spent in the last N minutes, with the per-minute rate, read from the session transcripts Claude Code writes. Cache reads are stated apart and not counted: they bill at about a tenth of the price.
All time: The same figure across every session and agent since the oldest transcript, with that date. It reads computing… until the first full scan lands; from 0.57.11 the worker rebuilds it in the background without pinning a core.

The fleet's hand

AI sources

One bar per originating tool, showing which AI authored each observation.

Who wrote it

claude-code, codex, agy, gemini, kimi, opencode — every tool whose finished sessions Captain Memo captured into the shared corpus.

Legacy rows

Observations from before cross-AI capture existed carry no recorded origin, so they are attributed to claude-code — the only tool that fed the pipeline back then.

The payoff

Recall — how memory actually gets used

Of everything stored, how much is actually being pulled back into sessions, and how strongly.

Surfaced: An observation was shown to the model by any path (see auto / search / drill). Counted per observation.
Recalled: Its full text was opened (a drill) — the strongest "this was actually useful" signal: a surfaced snippet that earned a full read.
Drill-in rate: Recalled ÷ Surfaced — of what got shown, how often it was worth opening in full.
Last surfaced: The single most-recently-surfaced observation (the live pulse), with the path that surfaced it.
Top surfaced · Top recalled: The observations with the highest surface / recall counts.
Recently surfaced: The most recent surfacing events, newest first.
auto: Surfaced automatically by the prompt hook (injected context).
search: Surfaced by an explicit /search.
drill: Opened in full via get_full (or Enter in top).
(+N): N near-duplicate observations were collapsed into this one row.
[REDACTED]: A token, key or password blanked out of a snippet before the model sees it, in auto recall and search alike. The snippet ends with how many values were redacted and the get_full call that opens the document as written. Your notes are never changed.

Many ships, many logs

Fleet memory: shared, never merged

In Captain Fleet, every captain keeps its own observations and notes: what it saw, on its project, its machine, at its time. Captains ask each other, like colleagues do. Nobody copies anyone's whole memory, and nothing is pooled into one "truth".

Shared, never merged: A captain can read what another captain knows, but that knowledge stays the other captain's statement. It never overrides or replaces this captain's own notes. A newer note elsewhere only says when it was written, not that it is true, and it may be about something else entirely: ALPHA's apples may be different apples.
Remote hit (⚓ captain, time): A recall or search result that came from another captain. It is tagged with that captain's name and the time it was written, so it reads as "per ALPHA, 10:05" and the source is never lost.
Guaranteed places: In automatic recall and search_all, up to 2 results from each other captain are guaranteed a place, only when they are actually on topic. These places never push out more than half of this captain's own results. Any other result from another captain gets in on its own score, which counts for less than a local one.
As per <captain>: How the AI is instructed to answer from another captain's memory: "As per ALPHA, the apples are 11", not "the apples are 11". It names the source and never presents ALPHA's answer as the answer for a different context, such as BRAVO's apples.

Rising and falling

Tide — memory lifecycle

Tide re-ranks retrieval by recency × stability, so memories that prove durable outrank one-off noise, and idle ones fade.

Status: Whether Tide re-ranking is on.
floor: Relevance floor — the minimum relevance a hit must clear to survive the re-rank (the one bounded knob).
tiering: Auto-tiering: whether idle memories are automatically demoted down tiers over time.
Strengthened: Observations whose stability has grown because a recall reinforced them — a memory earning permanence.
max stability: The highest stability any single observation has reached, in days.
Tiers: Lifecycle buckets: active (in play) · dormant (idle, deprioritised) · archived (aged out of normal retrieval) are Tide's own states. folded counts rows folded into a survivor or a theme, which are kept out of active (from Captain Memo 0.57.7), and anchored counts rows pinned so they never ebb. Both appear only when non-zero.

What the ship dreams

Dream

A corpus that only ever grows eventually crowds out the memories you wanted. Dreaming is the offline pass that fixes that: it reads what has piled up while you were working, groups the observations that belong together, folds each group into one higher-level theme, and archives the originals rather than deleting them. Nothing is lost — the detail moves out of the way of the summary.

What makes it more than clustering is how it decides two observations belong together. It goes by what you actually recall in the same breath — the pairs that keep surfacing together in real retrievals — not by what shares vocabulary. Group on vocabulary and you get memories that use the same words; group on co-retrieval and you get memories about the same thing. It runs on your machine, on your schedule, with the summarizer you chose.

Shipping (latest release). Consolidation runs automatically, two passes hourly and two while the machine is idle, and every change it makes is reversible — captain-memo theme undo restores a theme's members, captain-memo dedup --undo reverses a fold. Clusters form only where semantic similarity and co-retrieval evidence agree. The separate captain-memo dream --dry-run command remains a read-only explorer over the same signal: it never writes, never calls the summarizer, and is safe to run at any time.

Why it's called dreaming

The name is Anthropic's. In May 2026 they shipped Dreams in Claude Managed Agents — a pass that reads an agent's memory store alongside its past session transcripts and produces a new, reorganised store: duplicates merged, stale or contradicted entries replaced with the latest value, fresh insights surfaced. Their framing is the clean one: memory captures what an agent learns as it works; dreaming refines that memory between sessions.

Captain Memo takes the idea and moves it to your machine. Anthropic's dream runs in their cloud and has a model re-read your transcripts; Captain Memo's runs locally against your own SQLite files and infers structure from co-retrieval — which memories you pull up together — instead of re-reading the text. Both leave the input intact: theirs writes a separate store you can discard, ours archives the originals. Same intent, different mechanics: less corpus, more signal.

The Dream block in stats shows the inputs that pass would read — not its output.

Audit log

The recall-audit.jsonl write log — records each surfacing event. It feeds co-retrieval. On by default and bounded — past 32 MB it rotates once — and CAPTAIN_MEMO_RECALL_AUDIT=0 in worker.env switches it off. It never leaves the machine: nothing indexes it, nothing relays it.

Co-retrieval

Count of observation pairs that co-occur in the same retrievals, plus how many observations that covers — the raw signal the Dreams pipeline mines for connections.

Below decks

Housekeeping

The block in stats that shows the four consolidation passes: all reversible, none deleting. A pass reads off when its own switch or the master switch is off.

Dedup: Folds near-duplicate observations where title similarity and an embedding confirm both hold. Shows on or off, the cosine threshold, and the last run: how many it folded, how many rows it scanned and how long ago, or skipped when ingest was busy.
Supersede: Demotes an older version-fact when a newer one exists: a reversible 0.5x on its score, not an archive. Shows on or off, the cosine threshold and how many links it has made.
Semantic: Folds same-session restatements: one event the summarizer described twice. Shows on or off, the cosine threshold and the last run.
Themes: Turns a cross-session group into one durable fact, with the originals archived beneath it. Shows on or off, the cosine threshold, the live count and the last run: how many groups it considered and how many it declined. captain-memo theme list reads them.
Next pass: When the idle-time passes may run: a countdown (in 12m), waiting on what blocks them, eligible now, or forcing while a consolidate --for window is open. Any recall resets the idle clock, so the passes only run while you are away.

The bridge

Worker header

The status strip along the top of stats.

Worker: The background service state + uptime.
Indexing: Index build progress (done / total).
Embedder: The embedding model + endpoint in use.
Disk: On-disk footprint of the data directory.
Summarizer: The resolved summarizer provider + model. If this isn't running, no observations are created and cross-AI capture is disabled — captain-memo doctor flags it in red, and the Claude Code session banner says Summarizer DOWN — no observations are being captured with the reason. The worker checks the provider list again every 10 minutes and recovers on its own once one works. Needs Captain Memo 0.57.6 or later.

Cast off

See it live.

Open the live dashboard and press ? for this glossary in-app.

Open the dashboard. Run captain-memo top — an htop-style live view of how memory is being used.
Press a for the AI-sources chart, h for the Homework panel, s/r/n for the tables, ? for help + this glossary.
Back to the docs. The full README and everything else lives on GitHub.

live dashboard

captain-memo top

captain-memo stats