Session recap

kcap recap is the fastest way to find out what a session did when you already know which session you want. By default it prints an AI-generated summary — why the work was done, key decisions, and anything left unfinished. Use --full for the complete transcript with every prompt, response, and tool call.

Don’t know the session ID?

For “didn’t we work on something like this last month?” questions, use Session recall instead — the agent-facing search side of the same data.

Recap skill

Most of the time you’re already talking to a coding agent — and the Capacitor plugin gives that agent a skill it can invoke without you switching to a terminal. On Claude Code it’s /kcap:recap, installed automatically by kcap setup. On Codex the same kcap setup flow installs kcap-recap to ~/.agents/skills/. On Cursor (or any other agent that reads ~/.agents/skills/ without Codex on PATH), run kcap plugin install --skills once to get kcap-recap set up. On any other agent — including Gemini CLI, Pi, OpenCode, Antigravity, Kiro, and GitHub Copilot CLI — kcap recap from the terminal does exactly the same thing; the skill is just a convenience for agents that read ~/.agents/skills/. The skill invocations shell out to kcap recap under the hood and inline the output into the chat.

You almost never need to type the slash command yourself — the skill is description-matched, so a natural question is enough. The three phrasings that map cleanly to what the skill can do:

Recent activity in the current repo. The skill runs kcap recap --repo and lists the most recent ended sessions with their summaries. Start here when you don’t know the session ID.

What have we been working on in this repo recently?

Catch me up on the last few sessions here, then suggest where to pick up.

A specific past session by slug or ID. The dashboard URL gives you both forms — a 32-character session ID (c4de7fbecff54e2cbf809858d02f58be) or a slug (acme-billing-rate-limit). Either works.

Recap session acme-billing-rate-limit and propose next steps.

Walk me through session c4de7fbecff54e2cbf809858d02f58be — what changed and why?

The current session. The Capacitor SessionStart hook exports KCAP_SESSION_ID, so kcap recap with no argument resolves to this session. Mostly useful for “summarise what we just did before we continue” mid-conversation.

Summarise what we've done in this session so far, then we'll continue.

For continuation chains (a session context-compacted and continued in a new one), the skill threads --chain through. The phrasing the agent picks up on is something like “…across the whole chain” or “…across the continuations” — explicit enough that it knows to follow the link rather than recap just one segment.

The recap renders into the chat as a single message, then your conversation continues with that context loaded. That’s what makes “pick up where this left off” a one-line ask rather than a copy-paste exercise — the agent reads the recap, internalises decisions and unfinished items, and proceeds.

Use in the terminal

When you’d rather just print the recap to stdout — for scripting, code review, or because you don’t have an agent open — call the CLI directly:

kcap recap <sessionId>                    # summary (default)
kcap recap --full <sessionId>             # complete transcript
kcap recap --chain <sessionId>            # summary across the continuation chain
kcap recap --chain --full <sessionId>     # full transcript across the chain

The identifier can be:

• A 32-character session ID — open the session in the dashboard and click the copy icon next to the session title (it flips to a green check on success); also available from hook payloads.
• A meta-session slug — the slug-shaped URL in the dashboard, e.g. acme-billing-rate-limit.

When you run kcap recap from inside any agent session that has Capacitor hooks installed, the session ID is picked up automatically from the environment — you don’t need to pass an argument.

Reading one turn at a time

Long sessions are easier to navigate a turn at a time:

kcap recap --per-turn <sessionId>       # a compact index — one block per turn
kcap recap --get-turn 7 <sessionId>     # the full transcript for turn 7

--per-turn lists each turn with its prompt excerpt, the tools it used, files changed, tokens, and a time range; pass a turn number from that index to --get-turn to read that turn in full — the user message, assistant text, and every tool call with its result. A turn is one user message plus the assistant’s full response up to the next user message. Agents can drill in the same way through the get_turn MCP tool.

Continuation chains

When a session hits context-window limits, Claude may compact it and continue in a new session. The two sessions are linked. --chain tells recap to follow the link forwards or backwards and summarise the entire arc, not just one segment.

When summaries are generated

Summaries are written when a session ends. If a session is still running, kcap recap returns whatever it can synthesize from the events seen so far — typically less useful than waiting for the session to end.

For an ended session, the summary is cached server-side, so repeated kcap recap <id> calls don’t re-run the LLM.

Related

• Errors & plan validation — kcap errors and kcap validate-plan, two adjacent post-session tools.
• Evaluations — for a structured quality score, not just a narrative summary.
• Session recall — the same summaries (and full transcripts) exposed to your coding agent so it can pull prior work into the current conversation.