How to Use KeepGoing from the Terminal

Not everyone lives in VS Code. If you work primarily in Neovim, Vim, Helix, or a JetBrains IDE, the VS Code extension is not going to help you. The KeepGoing CLI fills that gap. It is a full first-class tool that gives you session checkpoints, momentum checks, briefings, and decision history from any terminal, in any project, alongside any editor.

Installing the CLI

npm install -g @keepgoingdev/cli

That is it. Once installed, the keepgoing command is available globally.

The commands

keepgoing status

Check what is going on in the current project. Run this when you sit down and want to know where you left off.

$ keepgoing status

Project:    my-app
Branch:     feature/auth
Last saved: 2 hours ago

Intent:     Build out the authentication flow end-to-end
Next step:  Add refresh token handling to the API middleware

If you have not saved a checkpoint yet, status will tell you that too. It reads from the .keepgoing/ directory in your git root, so it works the same way whether you are in the project root or a subdirectory.

keepgoing save

Save a checkpoint. Use this before stepping away, switching tasks, or wrapping up a session.

keepgoing save

You will be prompted for a summary of what you just did and what to do next. Keep it short. A sentence or two is enough. The goal is to give your future self enough context to resume without having to re-read everything.

$ keepgoing save
Summary: Implemented JWT verification middleware, all routes now protected
Next step: Add refresh token rotation and test the edge cases
Checkpoint saved.

keepgoing momentum

Get a quick read on how the project is moving. This is useful when you return to a project after a few days and want a sense of recent activity before diving in.

$ keepgoing momentum

Last 7 days: 4 sessions, 12 checkpoints
Recent focus: auth middleware, user model refactor
Decision: Switched from sessions to JWTs for stateless auth (2026-03-25)

keepgoing briefing

Get a full re-entry briefing. This is the detailed version of status, written for when you have been away for a while and need the full picture.

$ keepgoing briefing

Re-entry briefing for my-app
Last session: 3 days ago

Intent: Build out the authentication flow end-to-end

What you did last:
- Implemented JWT verification middleware
- Protected all API routes
- Wrote unit tests for token expiry

Next step: Add refresh token rotation and test the edge cases

Recent decisions:
- Switched from session-based auth to JWTs for stateless scaling
- Using HS256 for now, plan to rotate to RS256 before launch

keepgoing log

See your full session history. Useful for tracking how a project evolved over time, or for understanding why something is the way it is.

keepgoing log

keepgoing decisions

List the architectural decisions captured in the project. These are the high-signal commits and notes that explain why things are the way they are, not just what changed.

keepgoing decisions

If you have the Decision Detection add-on, this list is built automatically from your commits. Without it, decisions come from checkpoints where you flagged something as a decision.

Shell hook: momentum on every new terminal

This is the feature that makes the CLI feel native to a terminal workflow. Run this once:

keepgoing hook install

It adds a prompt hook to your shell config (.zshrc, .bashrc, or .config/fish/config.fish). After that, every time you open a new terminal session inside a project with a .keepgoing/ directory, you get a brief status line automatically.

$ cd ~/projects/my-app

KeepGoing: Last session 3 days ago. Next: add refresh token rotation.

No command to remember. No manual step. It is just there when you need it.

To remove it later:

keepgoing hook uninstall

Works with the MCP server

If you also use AI coding tools, the CLI and MCP server write to the same .keepgoing/ directory. Checkpoints you save from the terminal show up in Claude Code, GitHub Copilot, or any other MCP-compatible tool. Briefings generated from AI sessions are readable via keepgoing briefing.

The workflow here is simple: you do some work in your editor with an AI assistant, it saves a checkpoint automatically when the session ends, and the next morning you run keepgoing status in your terminal to remember where things are. No duplication, no sync issues. One data directory, multiple tools reading from it.

Why it is editor-agnostic by design

KeepGoing’s data layer is a set of JSON files in your project directory at .keepgoing/. The VS Code extension, JetBrains plugin, Desktop Tray, MCP server, and CLI all read and write to the same place. There is no cloud sync, no account, and no proprietary format.

This means the CLI works alongside any editor. Neovim users can save checkpoints from the terminal and read them back in the JetBrains plugin when they open the project there. Emacs users can use the MCP server for AI context and the CLI for everything else. The data is yours, stored locally, and every tool that understands the format can use it.

A quick workflow example

Here is what a typical day might look like using the CLI as your primary KeepGoing interface:

# Sit down in the morning, check where you left off
cd ~/projects/my-app
keepgoing status

# Work for a few hours...

# Before lunch, save your progress
keepgoing save
# > Summary: Finished refresh token rotation, added integration tests
# > Next step: Review the token expiry edge cases, then move to the email verification flow

# Come back after lunch
keepgoing status

# End of day, final checkpoint
keepgoing save

If you have the shell hook installed, the first keepgoing status after cd is optional. The hook shows you the summary automatically.

For detailed installation options and shell-specific setup, see the CLI setup guide.

---

Your context should follow you, not your editor.