Callimachus v0.12.0

Minor Changes

• e93ab7c: The app around the Project page: fewer tabs, one home per repo, search that scopes to it, and a daily reason to open the app.

  • A Today tab opens the app: what happened since you last opened it, grouped by repo, with each session's duration and the commits it produced (click a commit to copy its sha), new TODOs, errors seen again and snapshots captured, a 24 hours or 7 days switch, and Copy as standup. It is built from the index alone and never calls an LLM. The tabs are now Today, Search, Chat and Projects; Stats and Settings stay icons, and the activity heatmap moved from Coach to Stats, where a day opens Search for that day.
  • Ask is a mode of Chat: pick Ask in the Chat header to answer from your history with [thread N] citations that open the thread, then keep going as a normal chat. Ask answers are saved with your chats. The Coach, Knowledge and Ask tabs are gone.
  • Each repo has a Project page: recent sessions with Resume and Open in CLI, memory (decisions, gotchas and TODOs with every edit action), snapshots (read one, resume it in an agent CLI, or delete it), the commits sessions produced, recurring errors, spend for the last 30 days and all time, and "What agents see": the exact SessionStart hook text and AGENTS.md block a new session in that repo gets, with their sizes against the 10,000-character cap. All projects lists every repo and the open TODOs across them. The page opens on the repo you last looked at, and threads gain "Open project".
  • Search scopes: a repo chip (it starts on your last project, one click clears it), 24h, 7d and 30d presets, semantic search on by default once 90 percent of messages are embedded (the switch still turns it off), and a "Decisions and gotchas" group above the results that opens a fact's thread at the message it came from. An empty scoped search offers "Search all repos" and "Search all time".
  • Settings > AI engine replaces Providers and Knowledge: the memory switch and engine, auto-distill, Chat's provider and model, and the API keys and server URLs in one place. The Chat header now shows only the provider and model, with a link there when no key is saved.
  • The toolbar Reindex button is gone: the watcher indexes new sessions as they land, so a full reindex is now Reindex history in the command palette, Settings > Sources still reindexes one source, and the empty index screen keeps its Index my history button.
  • callimachus.app: the copy now matches the app (the Today, Search, Chat and Projects tabs, search filters, the setup checklist, memory that starts with the recent-sessions digest, the plugin as the first way to connect Claude Code) and has no em-dashes left.

• dd18928: Every agent, one memory: the memory Callimachus fills now reaches Codex and Gemini CLI through their own hooks, Callimachus installs into Claude Code in one step, the first run walks you to a connected and remembering setup, and Stats shows what it did for your agents.

  • Codex and Gemini CLI get each repo's memory too: Settings > Agents > Other agents has a Memory hooks switch per detected agent that installs cal hook --for codex|gemini on session start (with imported Claude Code memories, marked as such), queues an ended session for auto-distillation, and snapshots a Codex session before compaction. The /recall skill is also copied to the shared ~/.agents/skills/ folder.
  • Install Callimachus in Claude Code in one step: a plugin brings the /recall skill, the MCP server and the memory hooks (claude plugin marketplace add BetaBots-LLC/callimachus, then /plugin install callimachus@callimachus). While the plugin is enabled, Settings > Agents installs only the cal CLI its hooks run and removes the app's own skill, MCP entry and hooks, so memory is never injected twice and only one MCP server starts; Settings says the integration is managed by the plugin. The marketplace serves the plugin from the release tag, with its MCP server pinned to the same release, so it matches the app you installed (0.11.4 or later). On Windows, keep using Settings > Agents: the plugin's hooks need Git Bash there, and the app keeps its own install.
  • The MCP server no longer upgrades the index itself. When its version and the index disagree, every tool says what to do, naming the version: update the Callimachus app and open it once (the index needs an upgrade), or update callimachus-mcp and restart your agent (the index is newer than the server). These notices never count in Stats. It picks up again as soon as the app has upgraded the index.
  • A first-run setup checklist replaces the one-button welcome screen: index your history, connect your agents, turn on memory with the one-click engine choice, and build semantic search in the background. Each step says what it unlocks, every step after indexing can be skipped, and the checklist reopens from the command palette ("Setup checklist") or Settings > General. The anonymous-usage question moves into the checklist's footer instead of covering it.
  • Stats shows what Callimachus did for your agents this week (sessions started with injected memory or a recent-sessions digest, recall hits, MCP tool calls), counted in a local ledger.jsonl (the dev build's index gets its own) that never leaves the machine and is folded into the index once each day is over, safely across a crash; cal stats prints the same line. Stats also counts the indexed Claude Code sessions whose transcripts Claude Code has deleted (cleanupPeriodDays, 30 days by default) and offers a reversible "Keep transcripts for a year".
  • callimachus.app: the MCP and desktop pages mention the plugin, the FAQ mentions the checklist.

• 4430037: cal can now build and refresh the index without the desktop app. Four new cal commands run the app's background jobs from a terminal: cal index builds or refreshes the index from every agent's history (exit code 1 when a session could not be indexed), cal watch keeps it fresh as agents write (one line per batch), cal embed builds the semantic index (it downloads the embedding model once; cal embed --no-download uses only a model already there), and cal distill --auto distills recent sessions under the daily cap. cal distill --auto, like the drain cal watch runs, uses the memory engine turned on in the app's Settings > AI engine: once memory is on it runs with the app closed (a logged-in claude or codex CLI and local Ollama need nothing else, and an API key comes from the OS keychain where the app saved it), and on a machine that never ran the app it says memory is off. Only one process watches or distills an index: cal watch refuses to start while the app is open, and the app leaves live indexing to a running cal watch (Settings > Index says so) and takes over within a minute after it stops, and it starts no auto-distill round while cal watch or cal distill --auto runs. A second app open on the same index now waits the same way instead of running a second watcher. cal distill --auto refuses while the app or cal watch runs, since both distill on their own. The standalone cal and callimachus-mcp binaries and the Docker image now build without GTK or WebKit (the released binaries never loaded them at run time).

• 84536fb: Memory that fills itself: every memory surface now says something useful on day one, and the knowledge layer fills from what your agents already write.

  • The Claude Code SessionStart hook helps on day one: a repo with no distilled memory gets a short digest of its recent sessions (agent, branch, age, the latest summary or prompt, touched files, open TODOs and the latest snapshot), with no LLM. cal hook --explain shows what a new session would get, cal hook --mute turns the digest off for one repo, and Settings > Agents turns it off everywhere. The hook no longer injects memory twice when Claude Code already reads the managed block from AGENTS.md (only when no CLAUDE.md exists) or CLAUDE.local.md.
  • The MCP server stays useful before memory is distilled: recall and check_decision point to the closest past sessions with a coverage count, project_memory adds the recent-sessions digest, and a zero-hit search says what the index covers and what it cannot see (cloud sessions, Cursor project paths). It also offers recall, check_decision and prior_work prompts (slash commands in Claude Code) and project memory as the callimachus://memory resource. Facts carry their origin (extractor, originRef).
  • Turning on memory is one consent click that names the engine and where transcripts go: the card preselects the saved engine, else a detected Claude Code or Codex CLI (no API key), then local Ollama (with a model the server has pulled), then a saved key, and shows how many sessions qualify and the daily cap. Existing settings are never switched. Heuristic TODOs and Remember no longer need the Knowledge switch, which now means only "LLM distillation"; the Projects tab and the Knowledge tab's TODOs work without it.
  • Project memory fills from what your agents already write: Claude Code's auto memory joins each repo's memory without an LLM (feedback as gotchas, project notes as decisions, shown with a badge; turn it off in Settings to remove them), the PreCompact hook keeps Claude Code's compaction summary as the session's summary, and a new SessionEnd hook moves a finished session to the front of the auto-distill queue.
  • The hooks that write (PreCompact and SessionEnd) no longer upgrade the index themselves: after an update they stay quiet until the app or a cal command you run has applied the upgrade, so a newer hook can never lock an older app out of its index.

• 2a5ca18: Memory that travels: facts keep their identity, a project's memory can live in its repo, and the index answers "why is this line like this", "what did that cost" and "how did I fix this last time".

  • Facts keep their identity. Every remembered fact has a stable id that survives a reindex and keeps its link to the message it came from. The index records which files each session read, edited or wrote, from the agents' own tool calls (Claude Code, Codex, Gemini CLI, Qwen Code, Cline, Cursor, Copilot CLI); sessions from before the update are filled in once, in the background, with no reindex needed. Commits are linked to the sessions that produced them as those sessions are indexed, and recurring errors are kept in a table refreshed in the background (by the app, or by cal index) after new sessions land. cal issues, and the recurring_issues MCP tool when asked about every project, answer from that table while it is current (refreshed in the last 10 minutes, or up to a day when nothing new was indexed since) instead of re-mining your history; a call scoped to one project, as the MCP tool is by default, still reads that project's sessions directly.
  • Repo memory. Publish to repo (a project's Memory section, under More) and cal memory publish write the repo's pinned facts and the ones you or an agent recorded to .callimachus/memory/decisions.jsonl and gotchas.jsonl, one fact per line sorted by id so branches merge cleanly; --all (or the switch in the preview) adds the distilled ones. In the app, a preview shows every fact added, updated or removed before anything is written; cal memory publish writes the files and then lists the same changes. Text is redacted, Claude Code's auto memory is never included, lines a teammate added are kept, and nothing is committed or pushed for you. Everyone with Callimachus who works in the repo gets those facts when a session there is indexed (by the app or cal index), or right away with cal memory import (--review lists the changes without writing them). Imported facts are marked "From the repo", are never pinned, and appear in the session-start hook and the AGENTS.md block as (repo) under a line naming the files. Your edit of an imported fact wins over the file, hiding one is local to you (publish never removes a teammate's line), a fact removed from the files is hidden on the next import (once no other clone of the repo on this machine still has it), and facts you published show as "Shared".
  • Why this line. cal why <file>:<line> runs git blame on the line, finds the sessions linked to the commit behind it, puts the ones that edited the file first and prints their decisions and gotchas. Leave off the line to see the commits behind the whole file (up to 10, preferring the ones a session produced). When no session is linked to the commit yet, it says so and points to cal commits. The MCP tool threads_for_file takes an optional line and then also carries the commit, its sessions and their decisions, so an agent can check the reasoning before changing the code. VS Code and Cursor get Callimachus: Why This Line (also in the editor's right-click menu); it needs a Callimachus app that has cal why.
  • Cost to outcome. Spend now covers Codex, Gemini CLI, Qwen Code and OpenCode as well as Claude Code and Copilot: their token usage is read at index time, and sessions indexed before the update get theirs filled in on their own, once, in the background (by the app, or by cal index), with no reindex. cal cost --by thread|commit|project|day [--since DAYS] breaks the estimate down per session (a Claude Code session's subagents folded in, with short notes on where the spend went: cache reads, turns past 50, subagents, one tool failing several times in a row), per commit those sessions produced, per project or per local day. The Stats spend card adds the last 30 days and the priciest commits, and a Project page shows its priciest commits once commits are linked. Prices come from a table shipped with the app, with OpenAI and Gemini models next to Anthropic's; figures are labeled as list-price equivalents (a subscription bills differently), and models without a published flat list price (Qwen's, open-weight ones, a release the providers have not priced yet) are listed as unpriced with the reason instead of being guessed. Gemini CLI sessions indexed or changed after the update no longer show a reply twice when its token count arrived after the text.
  • Failure playbooks. When a session that hit a recurring error then edited the file the error named, and a commit linked to that session changed that file, that commit is recorded as the fix in that repo. The Project page shows "Last fixed in <sha>" under the error with a link to the session, cal issues prints the fix under each error, and the fix becomes a playbook gotcha in the repo's memory ("<error>: seen N times; fixed in <sha>"), refreshed in place as the count or the fix changes and never pinned; edit or delete it like any other fact. Generic errors (a bare error:, a Python traceback header, a path that was not there) get none. New opt-in Claude Code hook, Settings, Agents, Error playbooks (off by default): when a shell command Claude runs fails with an error a commit in the same repo fixed before, Claude is told that fix, once per error per session; output without an error line costs a few milliseconds. The hook ships for Claude Code first; Codex and Gemini CLI do not get it yet. Its per-session note of what it already said is deleted when the session ends.
  • Versioned JSON. cal why, cal cost and cal issues print their versioned shapes under --json-version 1 (schemas at callimachus.app/schemas/cal/why.v1.json, cost.v1.json and issues.v1.json); plain --json keeps its old shape, and the recurring_issues MCP tool returns the sessions behind each error, the fix and the playbook.
  • Site: the privacy policy names repo memory and the error-playbook hook, and SECURITY.md says the repo memory files are written only by your own publish action and leave your machine only if you commit and push them.

• 730cd97: The platform layer, second half: contracts other tools can depend on, a complete archive as vendors change formats, and the Claude Code plugin without the desktop app.

  • cal has a versioned JSON contract, --json-version 1. Nothing existing breaks: plain --json prints the same bare arrays and objects as before.
    • With --json-version 1 (or CAL_JSON_VERSION=1 in the environment beside --json), the outputs of search, recent, related, cat, stats, memory, decisions, gotchas, commits and audit-pr open with schema_version (1). Lists come as {"schema_version": 1, "results": [...]}; stats, memory and audit-pr keep their fields next to the version.
    • Each versioned output has a published JSON Schema at callimachus.app/schemas/cal/ (for example search.v1.json), generated from the code so the two cannot drift.
    • Plain --json output stays unversioned and may change in a future major release, so scripts that need a stable shape should pass --json-version 1.
    • cal cat takes --json (the thread's id, source, title, project path and the packed transcript).
    • When the embedding model isn't on the machine, cal decisions / cal gotchas --json-version 1 print an empty list with a notice saying why, so a script can tell that from no match.
  • Every MCP tool declares an output schema and returns structured content that matches it, which is what Claude Code and Codex pass to the model.
    • Lists sit under a key (threads, facts, todos and so on), transcripts and memory under markdown, and setup guidance (no index yet, a version mismatch, a busy index, no embedding model) as notice.
    • The schemas are published at callimachus.app/schemas/mcp/ (for example recall_decisions.json) and checked in, so a changed key shows up in review.
    • The text block is unchanged for every client; clients older than MCP 2025-06-18 get no structured content. get_thread and load_snapshot carry the transcript in both, so their responses are about twice budget.
  • The VS Code extension asks cal for the versioned output. Nothing breaks in either direction: an older cal keeps answering with the bare output the extension still reads, and an extension already installed keeps working with the new cal. When cal is newer than the extension can read, it says to update the extension instead of failing on a missing field.
  • More of your agent history gets indexed.
    • Cursor: the agent transcripts under ~/.cursor/projects/ are now read (with their subagents), along with the Cursor CLI's chat stores under ~/.cursor/chats/, so Cursor CLI sessions are searchable and Cursor threads finally carry their project (it comes from the transcript's folder, so Project pages and project-scoped search and memory now include Cursor). Editor chats already indexed from Cursor's state database stay as they are and gain the project without being re-indexed.
    • Codex: the thread database is found where Codex keeps it, honoring sqlite_home in config.toml and CODEX_SQLITE_HOME, and the newest state_<N>.sqlite is read instead of only state_5, so a Codex update that bumps the schema no longer drops titles and branches.
    • New source, the GitHub Copilot CLI (copilot_cli): sessions under ~/.copilot/session-state/ (or $COPILOT_HOME) are indexed with their prompts, answers, tool calls and capped tool output, plus each session's token usage per model for the spend view. It has a source filter under More and a reindex button, and shows in cal stats; cal search -s copilot_cli filters to it.
    • Only interactive Copilot CLI conversations are indexed: sessions run by Copilot SDK clients (GitHub Desktop's commit messages) are skipped.
    • The site, the README and the VS Code extension now count thirteen agents.
  • The Claude Code plugin works without the desktop app on macOS and Linux.
    • npx callimachus-mcp --install-cal downloads the release's cal CLI (checked against the same SHA256SUMS as the MCP server) and links it at ~/.local/bin/cal. It never replaces another program's cal and leaves the app's own link alone. Each time the MCP server starts, a cal linked this way moves to the server's release (never back to an older one), and the cache never prunes the version it runs from.
    • The plugin's new SessionStart hook, cal index --if-stale, starts a background cal index when no full pass finished in the last hour and neither the app nor cal watch is running. It does nothing with a cal that has no cal index, and it upgrades the index schema only with the launcher's cal while no app runs. A start it declines because of the schema adds a line to index.db.index.log, and typed in a terminal it says in one line what it did.
    • cal index now refuses to start while another cal index runs on the same index (index.db.index.lock).
    • Shrink index and Reclaim space wait while a background cal index runs.
    • The npm launcher finishes or cleans up a cal download when it exits, removes partial downloads older than an hour, and recognizes its own cal link through relative and symlinked paths.
    • When the index needs a schema upgrade, the MCP server and cal say to open Callimachus, or on a machine without the app run cal index.
    • The source-build instructions in the npm launcher no longer ask for WebKit packages or an empty dist folder: the standalone binaries build from the Tauri-free crate.
    • The plugin README, the main README and the CLI and MCP pages on callimachus.app describe the app-free path and what it gives up (the Projects page, Chat, Settings and the harvest controls).

---

Install: macOS .dmg (Apple Silicon), Windows .msi or -setup.exe, Linux .AppImage, .deb or .rpm (glibc 2.38+). Installed apps update themselves. The standalone cal-<target> and callimachus-mcp-<target> binaries are for CLI/MCP-only use; their SHA-256 sums are in SHA256SUMS.